← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/gcalctool/intrepid

« back to all changes in this revision

Viewing changes to gcalctool/gtk.c

  • Committer: Bazaar Package Importer
  • Author(s): Christophe Sauthier
  • Date: 2008-08-08 16:55:27 UTC
  • mfrom: (1.1.39 upstream)
  • Revision ID: james.westby@ubuntu.com-20080808165527-4e4ape1y0dt7wyiy
Tags: 5.23.6-0ubuntu1
https://launchpad.net/bugs/256083
https://launchpad.net/bugs/238389
https://launchpad.net/bugs/235876
* New upstream version (LP: #256083)
  - Fixes letters digits in HEX not working if caps locked(LP: #238389)
  - Fixes calculator not on the screen (LP: #235876)

Show diffs side-by-side

added added

removed removed

Lines of Context:
gcalctool/gtk.c
36
36
#include "config.h"
37
37
#include "dsdefs.h"
38
38
#include "functions.h"
39
 
#include "lr_parser.h"
40
39
#include "ce_parser.h"
41
40
#include "mpmath.h"
42
41
#include "display.h"
475
474
static void
476
475
reset_display(void)
477
476
{
478
 
    struct exprm_state *e;
479
 
 
480
 
    switch (v->syntax) {
481
 
        case NPA:
482
 
            v->ltr.noparens = 0;
483
 
            MPstr_to_num("0", DEC, v->MPdisp_val);
484
 
            display_set_number(v->MPdisp_val);
485
 
            clear_undo_history();
486
 
            break;
487
 
 
488
 
        case EXPRS:
489
 
            e = get_state();
490
 
            MPstr_to_num("0", DEC, e->ans);
491
 
            display_clear(FALSE);
492
 
            display_set_number(e->ans);
493
 
            break;
494
 
        
495
 
        default:
496
 
            assert(0);
497
 
    }
498
 
}
499
 
 
500
 
void
501
 
ui_set_syntax_mode(enum syntax mode)
502
 
{
503
 
    GtkWidget *widget;
504
 
 
505
 
    v->syntax = mode;
506
 
    
507
 
    reset_display();
508
 
    
509
 
    if (mode == NPA) {
510
 
        ui_set_statusbar(_("Activated no operator precedence mode"), "");
511
 
    } else {
512
 
        ui_set_statusbar(
513
 
            _("Activated expression mode with operator precedence"), "");
514
 
    }
515
 
    
516
 
    /* Save the syntax mode */
517
 
    set_resource(R_SYNTAX, Rsstr[v->syntax]);
518
 
 
519
 
    /* ??? */
520
 
    ui_set_mode(v->modetype);
521
 
    
522
 
    /* Update menu */
523
 
    if (v->syntax == EXPRS) {
524
 
        widget = GET_WIDGET("arithmetic_precedence_menu");
525
 
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
526
 
    } else {
527
 
        widget = GET_WIDGET("ltr_precedence_menu");
528
 
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
529
 
    }
 
477
    int *ans;
 
478
 
 
479
    ans = display_get_answer(&v->display);
 
480
    MPstr_to_num("0", DEC, ans);
 
481
    display_clear(&v->display, FALSE);
 
482
    display_set_number(&v->display, ans);
530
483
}
531
484
 
532
485
 
571
524
    set_int_resource(R_ACCURACY, accuracy);
572
525
    
573
526
    ui_make_registers();
574
 
    display_refresh(-1);
 
527
    display_refresh(&v->display, -1);
575
528
    
576
529
    /* Hide the manual dialog */
577
530
    gtk_widget_hide(X->spframe);
883
836
static void
884
837
set_bit_panel(void)
885
838
{
886
 
    int bit_str_len, i, MP1[MP_SIZE], MP2[MP_SIZE];
 
839
    int bit_str_len, i;
887
840
    int MP[MP_SIZE];
888
841
    char bit_str[MAXLINE], label[MAXLINE];
889
842
 
890
 
    switch (v->syntax) {
891
 
        case NPA:
892
 
            MPstr_to_num(v->display, v->base, MP1);
893
 
            mpcmim(MP1, MP2);
894
 
            if (mp_is_equal(MP1, MP2)) {
895
 
                int toclear = (v->current == KEY_CLEAR_ENTRY)
896
 
                              ? TRUE : FALSE;
897
 
 
898
 
                make_fixed(bit_str, MAXLINE, MP1, BIN, MAXLINE, toclear);
899
 
                bit_str_len = strlen(bit_str);
900
 
                if (bit_str_len <= MAXBITS) {
901
 
                    gtk_widget_set_sensitive(X->bit_panel, TRUE);
902
 
 
903
 
                    for (i = 0; i < MAXBITS; i++) {
904
 
                        if (i < bit_str_len) {
905
 
                            SNPRINTF(label, MAXLINE, " %c", bit_str[bit_str_len-i-1]);
906
 
                        } else {
907
 
                            SNPRINTF(label, MAXLINE, " 0");
908
 
                        }
909
 
                        gtk_label_set_text(GTK_LABEL(X->bits[MAXBITS - i - 1]), label);
910
 
                    }
911
 
 
912
 
                    return;
913
 
                }
914
 
            }
915
 
            gtk_widget_set_sensitive(X->bit_panel, FALSE);
916
 
            break;
917
 
 
918
 
        case EXPRS: 
919
 
            if (display_is_usable_number(MP) || !is_integer(MP)) {
920
 
                gtk_widget_set_sensitive(X->bit_panel, FALSE);
921
 
                return;
922
 
            }
923
 
            make_fixed(bit_str, MAXLINE, MP, BIN, MAXLINE, FALSE);
924
 
            bit_str_len = strlen(bit_str);
925
 
            if (bit_str_len <= MAXBITS) {
926
 
                gtk_widget_set_sensitive(X->bit_panel, TRUE);
927
 
                
928
 
                for (i = 0; i < MAXBITS; i++) {
929
 
                    if (i < bit_str_len) {
930
 
                        SNPRINTF(label, MAXLINE, " %c", bit_str[bit_str_len-i-1]);
931
 
                    } else {
932
 
                        SNPRINTF(label, MAXLINE, " 0");
933
 
                    }
934
 
                    gtk_label_set_text(GTK_LABEL(X->bits[MAXBITS - i - 1]), label);
935
 
                }
 
843
    if (display_is_usable_number(&v->display, MP) || !is_integer(MP)) {
 
844
        gtk_widget_set_sensitive(X->bit_panel, FALSE);
 
845
        return;
 
846
    }
 
847
    make_fixed(bit_str, MAXLINE, MP, BIN, MAXLINE, FALSE);
 
848
    bit_str_len = strlen(bit_str);
 
849
    if (bit_str_len <= MAXBITS) {
 
850
        gtk_widget_set_sensitive(X->bit_panel, TRUE);
 
851
        
 
852
        for (i = 0; i < MAXBITS; i++) {
 
853
            if (i < bit_str_len) {
 
854
                SNPRINTF(label, MAXLINE, " %c", bit_str[bit_str_len-i-1]);
936
855
            } else {
937
 
                gtk_widget_set_sensitive(X->bit_panel, FALSE);
 
856
                SNPRINTF(label, MAXLINE, " 0");
938
857
            }
939
 
            break;
940
 
 
941
 
        default:
942
 
            assert(FALSE);
 
858
            gtk_label_set_text(GTK_LABEL(X->bits[MAXBITS - i - 1]), label);
 
859
        }
 
860
    } else {
 
861
        gtk_widget_set_sensitive(X->bit_panel, FALSE);
943
862
    }
944
863
}
945
864
 
975
894
    if (str == NULL || str[0] == '\0') {
976
895
        str = " ";
977
896
    } else {
978
 
        if (v->syntax == EXPRS || (v->syntax == NPA && v->ltr.noparens == 0)) {
979
 
            localize_expression(localized, str, MAX_LOCALIZED, &cursor);
980
 
            str = localized;
981
 
        }
 
897
        localize_expression(localized, str, MAX_LOCALIZED, &cursor);
 
898
        str = localized;
982
899
    }
983
900
 
984
901
    gtk_text_buffer_set_text(X->display_buffer, str, -1);
1055
972
                             !v->error); 
1056
973
    gtk_widget_set_sensitive(GET_WIDGET("show_bitcalculating_menu"), !v->error);
1057
974
    gtk_widget_set_sensitive(GET_WIDGET("show_registers_menu"), !v->error); 
1058
 
    gtk_widget_set_sensitive(GET_WIDGET("ltr_precedence_menu"), !v->error);
1059
 
 
1060
 
    gtk_widget_set_sensitive(GET_WIDGET("arithmetic_precedence_menu"),
1061
 
                             !v->error); 
1062
975
 
1063
976
    gtk_widget_set_sensitive(GET_WIDGET("about_menu"), !v->error);
1064
977
}
1183
1096
            "authors", authors,
1184
1097
            "documenters", documenters,
1185
1098
            "translator_credits", translator_credits,
1186
 
            "logo-icon-name", "gnome-calculator",
 
1099
            "logo-icon-name", "accessories-calculator",
1187
1100
            NULL);
1188
1101
}
1189
1102
 
1259
1172
    if (response_id == GTK_RESPONSE_OK) {
1260
1173
        ch = (char *) gtk_entry_get_text(GTK_ENTRY(X->aframe_ch));
1261
1174
        mp_set_from_integer(ch[0], v->MPdisp_val);
1262
 
        display_set_number(v->MPdisp_val);
 
1175
        display_set_number(&v->display, v->MPdisp_val);
1263
1176
    }
1264
1177
    
1265
1178
    gtk_widget_hide(dialog);
1323
1236
 
1324
1237
static void do_button(int function, int arg)
1325
1238
{
1326
 
    switch (v->syntax) {
1327
 
        case NPA:
1328
 
            v->current = buttons[function].id;
1329
 
 
1330
 
            if (v->error) {
1331
 
                /* Must press a valid key first. */
1332
 
                if (v->current != KEY_CLEAR) {
1333
 
                    return;
1334
 
                }
1335
 
                ui_set_error_state(FALSE);
1336
 
            }
1337
 
    
1338
 
            if (v->ltr.noparens > 0) {
1339
 
                do_paren();
1340
 
                return;
1341
 
            }
1342
 
 
1343
 
            buttons[function].func(arg);
1344
 
            set_bit_panel();
1345
 
            if (v->ltr.new_input && v->dtype == FIX) {
1346
 
                display_set_string(v->display);
1347
 
            }
1348
 
            break;
1349
 
 
1350
 
        case EXPRS:
1351
 
            do_expression(function, arg, get_cursor());
1352
 
            set_bit_panel();
1353
 
            break;
1354
 
 
1355
 
        default:
1356
 
            assert(0);
1357
 
    }
 
1239
    do_expression(function, arg, get_cursor());
 
1240
    set_bit_panel();
1358
1241
}
1359
1242
 
1360
1243
 
1740
1623
    double number;
1741
1624
    unsigned long long lval;
1742
1625
    int n, MP1[MP_SIZE], index;
1743
 
    struct exprm_state *e =  get_state();
1744
1626
 
1745
1627
    index = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(event_box),
1746
1628
                                              "bit_index"));
1747
1629
    n = MAXBITS - index - 1;
1748
1630
 
1749
 
    switch (v->syntax) {
1750
 
        case NPA:
1751
 
            MPstr_to_num(v->display, v->base, MP1);
1752
 
            break;
1753
 
        case EXPRS: {
1754
 
            int ret = display_is_usable_number(e->ans);
1755
 
            assert(!ret);
1756
 
            mp_set_from_mp(e->ans, MP1);
1757
 
        }
1758
 
        break;
1759
 
        default:
1760
 
            assert(FALSE);
1761
 
    }
 
1631
    int ret = display_is_usable_number(&v->display, display_get_answer(&v->display));
 
1632
    assert(!ret);
 
1633
    mp_set_from_mp(display_get_answer(&v->display), MP1);
1762
1634
 
1763
1635
    number = mp_cast_to_double(MP1);
1764
1636
    lval = (long long) number;
1772
1644
    }
1773
1645
    number = (double) lval;
1774
1646
 
1775
 
    switch (v->syntax) {
1776
 
        case NPA:
1777
 
            mp_set_from_double(number, v->MPdisp_val);
1778
 
            display_set_number(v->MPdisp_val);
1779
 
            break;
1780
 
        case EXPRS:
1781
 
            mp_set_from_double(number, e->ans);
1782
 
            display_set_string("Ans");
1783
 
            display_refresh(-1);
1784
 
            break;
1785
 
        default:
1786
 
            assert(FALSE);
1787
 
    }
 
1647
    mp_set_from_double(number, display_get_answer(&v->display));
 
1648
    display_set_string(&v->display, "Ans");
 
1649
    display_refresh(&v->display, -1);
1788
1650
 
1789
 
    v->ltr.toclear = 0;
1790
1651
    return (TRUE);
1791
1652
}
1792
1653
 
2135
1996
static void
2136
1997
get_proc(GtkClipboard *clipboard, const gchar *buffer, gpointer data)
2137
1998
{
2138
 
    int ret;
2139
1999
    gchar *dstp, *end_buffer, *srcp, *text, c;
2140
2000
 
2141
2001
    if (buffer == NULL) {
2203
2063
    }
2204
2064
    *dstp++ = '\0';
2205
2065
 
2206
 
    switch (v->syntax) {
2207
 
        case NPA:
2208
 
            ret = lr_parse((char *) text, v->MPdisp_val);
2209
 
            if (!ret) {
2210
 
                display_set_number(v->MPdisp_val);
2211
 
            } else {
2212
 
                ui_set_statusbar(_("Clipboard contained malformed calculation"),
2213
 
                                 "gtk-dialog-error");
2214
 
            }
2215
 
            break;
2216
 
    
2217
 
        case EXPRS:
2218
 
            display_insert((char *) text, get_cursor()); // FIXME: Move out of gtk.c
2219
 
            display_refresh(-1);
2220
 
            break;
2221
 
    
2222
 
        default:
2223
 
            assert(0);
2224
 
    }
 
2066
    display_insert(&v->display, (char *) text, get_cursor()); // FIXME: Move out of gtk.c
 
2067
    display_refresh(&v->display, -1);
2225
2068
    free(text);
2226
2069
}
2227
2070
 
2269
2112
redo_cb(GtkWidget *widget)
2270
2113
{
2271
2114
    perform_redo();
2272
 
    display_refresh(-1);
 
2115
    display_refresh(&v->display, -1);
2273
2116
}
2274
2117
 
2275
2118
 
2342
2185
}
2343
2186
 
2344
2187
 
2345
 
static void
2346
 
arithmetic_mode_cb(GtkWidget *widget)
2347
 
{
2348
 
    enum syntax mode;
2349
 
    mode = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)) ? EXPRS : NPA;
2350
 
    ui_set_syntax_mode(mode);
2351
 
}
2352
 
 
2353
 
 
2354
2188
/*ARGSUSED*/
2355
2189
static void
2356
2190
mode_radio_cb(GtkWidget *menu)
2376
2210
 *
2377
2211
 * (unless we are in Scientific mode with Decimal numeric base and Fixed).
2378
2212
 */
2379
 
    if (display_is_result() &&
 
2213
    if (display_is_result(&v->display) &&
2380
2214
        ((v->modetype != SCIENTIFIC) ||
2381
2215
         (v->dtype == FIX && v->base == DEC))) {
2382
2216
        v->modetype = mode;
2590
2424
    CONNECT_SIGNAL(store_menu_cb);
2591
2425
    CONNECT_SIGNAL(recall_menu_cb);
2592
2426
    CONNECT_SIGNAL(exchange_menu_cb);
2593
 
    CONNECT_SIGNAL(arithmetic_mode_cb);
2594
2427
    CONNECT_SIGNAL(mouse_button_cb);
2595
2428
    /* Detect when populating the right-click menu to enable pasting */
2596
2429
    CONNECT_SIGNAL(buffer_populate_popup_cb);
2743
2576
    set_menubar_tooltip("show_thousands_separator_menu");
2744
2577
    set_menubar_tooltip("show_bitcalculating_menu");
2745
2578
    set_menubar_tooltip("show_registers_menu");
2746
 
    set_menubar_tooltip("ltr_precedence_menu");
2747
 
    set_menubar_tooltip("arithmetic_precedence_menu");
2748
2579
    set_menubar_tooltip("help_menu");
2749
2580
    set_menubar_tooltip("about_menu");
2750
2581
 
2885
2716
    v->home = (char *) g_get_home_dir();
2886
2717
    gtk_rc_parse(g_build_path(v->home, RCNAME, NULL));
2887
2718
 
2888
 
    gtk_window_set_default_icon_name("gnome-calculator");
 
2719
    gtk_window_set_default_icon_name("accessories-calculator");
2889
2720
}
2890
2721
 
2891
2722
 
2910
2741
    ui_set_show_trailing_zeroes(v->show_zeroes);
2911
2742
    ui_set_show_bitcalculating(show_bit);
2912
2743
    
2913
 
    ui_set_syntax_mode(v->syntax);
2914
2744
    ui_set_mode(v->modetype);
2915
2745
    ui_set_numeric_mode(FIX);
2916
2746
    ui_set_base(v->base);