?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove unused UI routines
[gcalctool.git] / gcalctool / gtk.c
blob9a33edf1ff86d4192f9809e0dd305a2f743481c3
1
2 /* $Header$
3 *
4 * Copyright (c) 1987-2007 Sun Microsystems, Inc. All Rights Reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 * 02111-1307, USA.
20 */
21
22 #include <stdio.h>
23 #include <string.h>
24 #include <ctype.h>
25 #include <limits.h>
26 #include <sys/param.h>
27 #include <sys/stat.h>
28 #include <netdb.h>
29 #include <gtk/gtk.h>
30 #include <gdk/gdkx.h>
31 #include <gdk/gdkkeysyms.h>
32 #include <glade/glade.h>
33
34 #include "ui.h"
35
36 #include "config.h"
37 #include "dsdefs.h"
38 #include "functions.h"
39 #include "lr_parser.h"
40 #include "ce_parser.h"
41 #include "mpmath.h"
42 #include "display.h"
43 #include "get.h"
44
45 /* Popup menu types. */
46 /* FIXME: This enum could be removed */
47 enum menu_type { M_ACC, M_CON, M_EXCH, M_FUN, M_LSHF,
48 M_RCL, M_RSHF, M_STO, M_NONE };
49 #define MAXMENUS 9 /* Maximum number of popup menus. */
50
51 #define MAX_ACCELERATORS 8
52 struct button_widget {
53 int key;
54 char *widget_name;
55 enum menu_type mtype;
56 guint accelerator_mods[MAX_ACCELERATORS];
57 guint accelerator_keys[MAX_ACCELERATORS];
58 };
59
60 /* Window titles dependant on mode */
61 static char *titles[] = {
62 N_("Calculator"), N_("Calculator - Advanced"), N_("Calculator - Financial"),
63 N_("Calculator - Scientific")
64 };
65
66 /* Window titles dependant on mode and hostname */
67 static char *hostname_titles[] = {
68 N_("Calculator [%s]"), N_("Calculator [%s] - Advanced"), N_("Calculator [%s] - Financial"),
69 N_("Calculator [%s] - Scientific")
70 };
71
72 /* This table shows the keyboard values that are currently being used:
73 *
74 * | a b c d e f g h i j k l m n o p q r s t u v w x y z
75 *-----------+-----------------------------------------------------
76 * Lower: | a b c d e f i l m n p r s t u v x
77 * Upper: | A C D E F G J K L M N P R S T X Y
78 * Numeric: | 0 1 2 3 4 5 6 7 8 9
79 * Other: | @ . + - * / = % ( ) # < > [ ] { } | & ~ ^ ? ! :
80 * | BackSpace Delete Return
81 *-----------+-----------------------------------------------------
82 */
83
84 static struct button_widget button_widgets[] = {
85 {KEY_0, "0", M_NONE,
86 { 0, GDK_SHIFT_MASK, 0, 0, 0 },
87 { GDK_0, GDK_0, GDK_KP_0, GDK_KP_Insert, 0 }},
88
89 {KEY_1, "1", M_NONE,
90 { 0, GDK_SHIFT_MASK, 0, 0, 0, 0 },
91 { GDK_1, GDK_1, GDK_KP_1, GDK_KP_End, GDK_R13, 0 }},
92
93 {KEY_2, "2", M_NONE,
94 { 0, GDK_SHIFT_MASK, 0, 0, 0 },
95 { GDK_2, GDK_2, GDK_KP_2, GDK_KP_Down, 0 }},
96
97 {KEY_3, "3", M_NONE,
98 { 0, GDK_SHIFT_MASK, 0, 0, 0, 0 },
99 { GDK_3, GDK_3, GDK_KP_3, GDK_KP_Page_Down, GDK_R15, 0 }},
100
101 {KEY_4, "4", M_NONE,
102 { 0, GDK_SHIFT_MASK, 0, 0, 0 },
103 { GDK_4, GDK_4, GDK_KP_4, GDK_KP_Left, 0 }},
104
105 {KEY_5, "5", M_NONE,
106 { 0, GDK_SHIFT_MASK, 0, 0, 0, 0 },
107 { GDK_5, GDK_5, GDK_KP_5, GDK_KP_Begin, GDK_R11, 0 }},
108
109 {KEY_6, "6", M_NONE,
110 { 0, GDK_SHIFT_MASK, 0, 0, 0 },
111 { GDK_6, GDK_6, GDK_KP_6, GDK_KP_Right, 0 }},
112
113 {KEY_7, "7", M_NONE,
114 { 0, GDK_SHIFT_MASK, 0, 0, 0, 0 },
115 { GDK_7, GDK_7, GDK_KP_7, GDK_KP_Home, GDK_R7, 0 }},
116
117 {KEY_8, "8", M_NONE,
118 { 0, GDK_SHIFT_MASK, 0, 0, 0 },
119 { GDK_8, GDK_8, GDK_KP_8, GDK_KP_Up, 0 }},
120
121 {KEY_9, "9", M_NONE,
122 { 0, GDK_SHIFT_MASK, 0, 0, 0, 0 },
123 { GDK_9, GDK_9, GDK_KP_9, GDK_KP_Page_Up, GDK_R9, 0 }},
124
125 {KEY_A, "a", M_NONE,
126 { 0, 0 },
127 { GDK_a, 0 }},
128
129 {KEY_B, "b", M_NONE,
130 { 0, 0 },
131 { GDK_b, 0 }},
132
133 {KEY_C, "c", M_NONE,
134 { 0, 0 },
135 { GDK_c, 0 }},
136
137 {KEY_D, "d", M_NONE,
138 { 0, 0 },
139 { GDK_d, 0 }},
140
141 {KEY_E, "e", M_NONE,
142 { 0, 0 },
143 { GDK_e, 0 }},
144
145 {KEY_F, "f", M_NONE,
146 { 0, 0 },
147 { GDK_f, 0 }},
148
149 {KEY_CLEAR, "clear_simple", M_NONE,
150 { 0, 0 },
151 { GDK_Delete, 0 }},
152
153 {KEY_CLEAR, "clear_advanced", M_NONE,
154 { 0, 0 },
155 { GDK_Delete, 0 }},
156
157 {KEY_SHIFT, "shift_left", M_LSHF,
158 { GDK_SHIFT_MASK, 0 },
159 { GDK_less, 0 }},
160
161 {KEY_SHIFT, "shift_right", M_RSHF,
162 { GDK_SHIFT_MASK, 0 },
163 { GDK_greater, 0 }},
164
165 {KEY_SET_ACCURACY, "accuracy", M_ACC,
166 { GDK_SHIFT_MASK, 0 },
167 { GDK_A, 0 }},
168
169 {KEY_CONSTANT, "constants", M_CON,
170 { GDK_SHIFT_MASK, 0, 0 },
171 { GDK_numbersign, GDK_numbersign, 0 }},
172
173 {KEY_FUNCTION, "functions", M_FUN,
174 { GDK_SHIFT_MASK, 0 },
175 { GDK_F, 0 }},
176
177 {KEY_STORE, "store", M_STO,
178 { GDK_SHIFT_MASK, 0 },
179 { GDK_S, 0 }},
180
181 {KEY_RECALL, "recall", M_RCL,
182 { GDK_SHIFT_MASK, 0 },
183 { GDK_R, 0 }},
184
185 {KEY_EXCHANGE, "exchange", M_EXCH,
186 { GDK_SHIFT_MASK, 0 },
187 { GDK_X, 0 }},
188
189 {KEY_CLEAR_ENTRY, "clear_entry_simple", M_NONE,
190 { GDK_CONTROL_MASK, 0, 0 },
191 { GDK_BackSpace, GDK_Escape, 0 }},
192
193 {KEY_CLEAR_ENTRY, "clear_entry_advanced", M_NONE,
194 { GDK_CONTROL_MASK, 0, 0 },
195 { GDK_BackSpace, GDK_Escape, 0 }},
196
197 {KEY_BACKSPACE, "backspace_simple", M_NONE,
198 { 0, 0 },
199 { GDK_BackSpace, 0 }},
200
201 {KEY_BACKSPACE, "backspace_advanced", M_NONE,
202 { 0, 0 },
203 { GDK_BackSpace, 0 }},
204
205 {KEY_NUMERIC_POINT, "numeric_point", M_NONE,
206 { 0, 0, 0, 0 },
207 { GDK_period, GDK_KP_Decimal, GDK_KP_Delete, GDK_KP_Separator, 0 }},
208
209 {KEY_CALCULATE, "result", M_NONE,
210 { 0, 0, 0, GDK_SHIFT_MASK, 0 },
211 { GDK_equal, GDK_KP_Enter, GDK_Return, GDK_equal, 0 }},
212
213 {KEY_START_BLOCK, "start_group", M_NONE,
214 { GDK_SHIFT_MASK, 0 },
215 { GDK_parenleft, 0 }},
216
217 {KEY_END_BLOCK, "end_group", M_NONE,
218 { GDK_SHIFT_MASK, 0 },
219 { GDK_parenright, 0 }},
220
221 {KEY_ADD, "add", M_NONE,
222 { GDK_SHIFT_MASK, 0, 0, 0 },
223 { GDK_plus, GDK_plus, GDK_KP_Add, 0 }},
224
225 {KEY_SUBTRACT, "subtract", M_NONE,
226 { 0, 0, 0, 0 },
227 { GDK_minus, GDK_KP_Subtract, GDK_R4, 0 }},
228
229 {KEY_MULTIPLY, "multiply", M_NONE,
230 { GDK_SHIFT_MASK, 0, 0, 0, 0 },
231 { GDK_asterisk, GDK_KP_Multiply, GDK_x, GDK_R6, 0 }},
232
233 {KEY_DIVIDE, "divide", M_NONE,
234 { 0, GDK_SHIFT_MASK, 0, 0, GDK_SHIFT_MASK, 0 },
235 { GDK_slash, GDK_slash, GDK_KP_Divide, GDK_R5, GDK_slash, 0 }},
236
237 {KEY_CHANGE_SIGN, "change_sign_simple", M_NONE,
238 { GDK_SHIFT_MASK, 0 },
239 { GDK_C, 0 }},
240
241 {KEY_CHANGE_SIGN, "change_sign_advanced", M_NONE,
242 { GDK_SHIFT_MASK, 0 },
243 { GDK_C, 0 }},
244
245 {KEY_INTEGER, "integer_portion", M_NONE,
246 { 0, 0 },
247 { GDK_i, 0 }},
248
249 {KEY_FRACTION, "fractional_portion", M_NONE,
250 { GDK_SHIFT_MASK, 0 },
251 { GDK_colon, 0 }},
252
253 {KEY_PERCENTAGE, "percentage", M_NONE,
254 { GDK_SHIFT_MASK, 0 },
255 { GDK_percent, 0 }},
256
257 {KEY_SQUARE, "square", M_NONE,
258 { GDK_SHIFT_MASK, 0 },
259 { GDK_at, 0 }},
260
261 {KEY_SQUARE_ROOT, "sqrt", M_NONE,
262 { 0, 0 },
263 { GDK_s, 0 }},
264
265 {KEY_RECIPROCAL, "reciprocal", M_NONE,
266 { 0, 0 },
267 { GDK_r, 0 }},
268
269 {KEY_ABSOLUTE_VALUE, "abs", M_NONE,
270 { 0, 0 },
271 { GDK_u, 0 }},
272
273 {KEY_MASK_16, "mask_16", M_NONE,
274 { 0, 0 },
275 { GDK_bracketright, 0 }},
276
277 {KEY_MASK_32, "mask_32", M_NONE,
278 { 0, 0 },
279 { GDK_bracketleft, 0 }},
280
281 {KEY_MODULUS_DIVIDE, "modulus_divide", M_NONE,
282 { GDK_SHIFT_MASK, 0 },
283 { GDK_M, 0 }},
284
285 {KEY_EXPONENTIAL, "exponential", M_NONE,
286 { GDK_SHIFT_MASK, 0 },
287 { GDK_E, 0 }},
288
289 {KEY_E_POW_X, "pow_e", M_NONE,
290 { GDK_SHIFT_MASK, 0 },
291 { GDK_braceleft, 0 }},
292
293 {KEY_10_POW_X, "pow_10", M_NONE,
294 { GDK_SHIFT_MASK, 0 },
295 { GDK_braceright, 0 }},
296
297 {KEY_X_POW_Y, "x_pow_y", M_NONE,
298 { GDK_SHIFT_MASK, GDK_SHIFT_MASK, 0 },
299 { GDK_caret, GDK_asciicircum, 0 }},
300
301 {KEY_NATURAL_LOGARITHM, "natural_logarithm", M_NONE,
302 { GDK_SHIFT_MASK, 0 },
303 { GDK_N, 0 }},
304
305 {KEY_LOGARITHM, "logarithm", M_NONE,
306 { GDK_SHIFT_MASK, 0 },
307 { GDK_G, 0 }},
308
309 {KEY_FACTORIAL, "factorial", M_NONE,
310 { GDK_SHIFT_MASK, 0 },
311 { GDK_exclam, 0 }},
312
313 {KEY_RANDOM, "random", M_NONE,
314 { GDK_SHIFT_MASK, 0 },
315 { GDK_question, 0 }},
316
317 {KEY_SIN, "sine", M_NONE,
318 { GDK_SHIFT_MASK, 0 },
319 { GDK_K, 0 }},
320
321 {KEY_COS, "cosine", M_NONE,
322 { GDK_SHIFT_MASK, 0 },
323 { GDK_J, 0 }},
324
325 {KEY_TAN, "tangent", M_NONE,
326 { GDK_SHIFT_MASK, 0 },
327 { GDK_L, 0 }},
328
329 {KEY_NOT, "not", M_NONE,
330 { GDK_SHIFT_MASK, 0 },
331 { GDK_asciitilde, 0 }},
332
333 {KEY_OR, "or", M_NONE,
334 { GDK_SHIFT_MASK, 0 },
335 { GDK_bar, 0 }},
336
337 {KEY_AND, "and", M_NONE,
338 { GDK_SHIFT_MASK, 0 },
339 { GDK_ampersand, 0 }},
340
341 {KEY_XOR, "xor", M_NONE,
342 { 0 },
343 { 0 }},
344
345 {KEY_XNOR, "xnor", M_NONE,
346 { 0, 0 },
347 { GDK_n, 0 }},
348
349 {KEY_FINC_CTRM, "finc_compounding_term", M_NONE,
350 { 0, 0 },
351 { GDK_m, 0 }},
352
353 {KEY_FINC_DDB, "finc_double_declining_depreciation", M_NONE,
354 { GDK_SHIFT_MASK, 0 },
355 { GDK_D, 0 }},
356
357 {KEY_FINC_FV, "finc_future_value", M_NONE,
358 { 0, 0 },
359 { GDK_v, 0 }},
360
361 {KEY_FINC_PMT, "finc_periodic_payment", M_NONE,
362 { GDK_SHIFT_MASK, 0 },
363 { GDK_P, 0 }},
364
365 {KEY_FINC_PV, "finc_present_value", M_NONE,
366 { 0, 0 },
367 { GDK_p, 0 }},
368
369 {KEY_FINC_RATE, "finc_periodic_interest_rate", M_NONE,
370 { GDK_SHIFT_MASK, 0 },
371 { GDK_T, 0 }},
372
373 {KEY_FINC_SLN, "finc_straight_line_depreciation", M_NONE,
374 { 0, 0 },
375 { GDK_l, 0 }},
376
377 {KEY_FINC_SYD, "finc_sum_of_the_years_digits_depreciation", M_NONE,
378 { 0, 0 },
379 { GDK_Y, 0 }},
380
381 {KEY_FINC_TERM, "finc_term", M_NONE,
382 { 0, 0 },
383 { GDK_T, 0 }},
384 };
385 #define NBUTTONS (sizeof(button_widgets) / sizeof(struct button_widget))
386
387 #define UI_FILE PACKAGE_GLADE_DIR "/gcalctool.glade"
388
389 #define MAXBITS 64 /* Bit panel: number of bit fields. */
390
391 #define GET_WIDGET(name) \
392 glade_xml_get_widget(X->ui, (name))
393
394 #define SET_MENUBAR_ITEM_STATE(name, state) \
395 g_object_set_data(G_OBJECT(GET_WIDGET(name)), "sensitive", \
396 GINT_TO_POINTER(state));
397
398 #define CONNECT_SIGNAL(name) glade_xml_signal_connect(X->ui, #name, \
399 G_CALLBACK(name))
400
401 struct Xobject { /* Gtk+/Xlib graphics object. */
402 GdkAtom clipboard_atom;
403 GdkAtom primary_atom;
404
405 GladeXML *ui;
406
407 GtkWidget *kframe; /* Main window. */
408
409 GtkWidget *cm_dialog; /* Change Mode dialog. */
410 GtkTreeModel *constants_model;
411 GtkWidget *con_dialog; /* Edit constants dialog. */
412
413 GtkTreeModel *functions_model;
414 GtkWidget *fun_dialog; /* Edit functions dialog. */
415 GtkWidget *menubar; // FIXME: Why is this needed?
416
417 GtkWidget *bit_panel;
418 GtkWidget *bits[MAXBITS]; /* The 0/1 labels in the bit panel. */
419
420 GtkWidget *status_image; /* Statusbar image */
421 GtkWidget *statusbar;
422
423 GtkWidget *undo; /* Undo menuitem */
424 GtkWidget *redo; /* Redo menuitem */
425 GtkWidget *copy; /* Copy menuitem */
426 GtkWidget *paste; /* Paste menuitem */
427
428 GtkWidget *aframe; /* ASCII window. */
429 GtkWidget *aframe_ch;
430
431 GtkWidget *display_item; /* Calculator display. */
432 GtkTextBuffer *display_buffer; /* Buffer used in display */
433 GtkWidget *scrolledwindow; /* Scrolled window for display_item. */
434
435 GtkWidget *rframe; /* Register window. */
436 GtkWidget *regs[MAXREGS]; /* Memory registers. */
437
438 GtkWidget *spframe; /* Set Precision window. */
439 GtkWidget *spframe_val;
440 GtkWidget *menus[MAXMENUS];
441
442 GtkWidget *buttons[NBUTTONS];
443 GtkWidget *digit_buttons[16];
444 GtkWidget *clear_buttons[2];
445
446 GtkWidget *bas_panel; /* Panel containing basic mode widgets. */
447 GtkWidget *adv_panel; /* Panel containing advanced mode widgets. */
448 GtkWidget *fin_panel; /* Panel containing financial mode widgets. */
449 GtkWidget *sci_panel; /* Panel containing scientific mode widgets. */
450 GtkWidget *mode_panel; /* Panel containing scientific mode widgets. */
451
452 /* Labels for popup menus */
453 GtkWidget *constant_menu_items[MAXCONFUN];
454 GtkWidget *function_menu_items[MAXCONFUN];
455 GtkWidget *memory_store_items[MAXREGS];
456 GtkWidget *memory_recall_items[MAXREGS];
457 GtkWidget *memory_exchange_items[MAXREGS];
458
459 /* Scientific mode widgets */
460 GtkWidget *hyp; /* Hyperbolic mode. */
461 GtkWidget *inv; /* Inverse mode. */
462 GtkWidget *base[MAXBASES]; /* Numeric base radio buttons. */
463 GtkWidget *disp[MAXDISPMODES]; /* Numeric display mode. */
464 GtkWidget *trig[MAXTRIGMODES]; /* Trigonometric mode. */
465
466 int mode; /* The new mode. */
467 int menuval; /* Index to button array at menu time. */
468 char *lnp; /* Localized numerical point (UTF8 format) */
469 struct button *mrec[MAXMENUS];
470 };
471
472 typedef struct Xobject *XVars;
473
474 enum {
475 COLUMN_NUMBER,
476 COLUMN_VALUE,
477 COLUMN_DESCRIPTION,
478 COLUMN_EDITABLE,
479 NUM_COLUMNS
480 };
481
482 static XVars X;
483
484
485 void
486 ui_set_accuracy(int accuracy)
487 {
488 GtkWidget *widget;
489 char text[MAXLINE];
490 char *desc, *current, *tooltip;
491
492 SNPRINTF(text, MAXLINE, _("Other (%d) ..."), accuracy);
493 widget = gtk_bin_get_child(GTK_BIN(GET_WIDGET("acc_item_other")));
494 gtk_label_set_text(GTK_LABEL(widget), text);
495
496 desc = g_strdup_printf(ngettext("Set accuracy from 0 to %d numeric places.",
497 "Set accuracy from 0 to %d numeric places.",
498 MAXACC),
499 MAXACC);
500
501 /* Translator: This refers to the current accuracy setting */
502 current = g_strdup_printf(ngettext("Currently set to %d places.",
503 "Currently set to %d places.",
504 accuracy),
505 accuracy);
506 tooltip = g_strdup_printf ("%s %s [A]", desc, current);
507 gtk_widget_set_tooltip_text (GET_WIDGET("calc_accuracy_button"), tooltip);
508 g_free(desc);
509 g_free(current);
510 g_free(tooltip);
511
512 if (accuracy >= 0 && accuracy <= 9) {
513 SNPRINTF(text, MAXLINE, "acc_item%d", accuracy);
514 widget = GET_WIDGET(text);
515 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
516 }
517 }
518
519
520 static void
521 ui_update_trig_mode()
522 {
523 static char *sine_labels[] = {N_("Sin"), N_("Sinh"),
524 N_("Sin<sup>-1</sup>"),
525 N_("Sinh<sup>-1</sup>")};
526 static int sine_functions[] = {KEY_SIN, KEY_SINH, KEY_ASIN, KEY_ASINH};
527 static char *cosine_labels[] = {N_("Cos"), N_("Cosh"),
528 N_("Cos<sup>-1</sup>"),
529 N_("Cosh<sup>-1</sup>")};
530 static int cosine_functions[] = {KEY_COS, KEY_COSH, KEY_ACOS, KEY_ACOSH};
531 static char *tangent_labels[] = {N_("Tan"), N_("Tanh"),
532 N_("Tan<sup>-1</sup>"),
533 N_("Tanh<sup>-1</sup>")};
534 static int tangent_functions[] = {KEY_TAN, KEY_TANH, KEY_ATAN, KEY_ATANH};
535 int index = 0;
536
537 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(X->hyp))) {
538 index |= 0x1;
539 }
540 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(X->inv))) {
541 index |= 0x2;
542 }
543
544 gtk_label_set_markup(GTK_LABEL(GET_WIDGET("sine_label")),
545 sine_labels[index]);
546 g_object_set_data(G_OBJECT(GET_WIDGET("calc_sine_button")), "button",
547 &buttons[sine_functions[index]]);
548
549 gtk_label_set_markup(GTK_LABEL(GET_WIDGET("cosine_label")),
550 cosine_labels[index]);
551 g_object_set_data(G_OBJECT(GET_WIDGET("calc_cosine_button")), "button",
552 &buttons[cosine_functions[index]]);
553
554 gtk_label_set_markup(GTK_LABEL(GET_WIDGET("tangent_label")),
555 tangent_labels[index]);
556 g_object_set_data(G_OBJECT(GET_WIDGET("calc_tangent_button")), "button",
557 &buttons[tangent_functions[index]]);
558 }
559
560
561 void
562 ui_set_hyperbolic_state(int state)
563 {
564 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(X->hyp), state);
565 ui_update_trig_mode();
566 }
567
568
569 void
570 ui_set_inverse_state(int state)
571 {
572 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(X->inv), state);
573 ui_update_trig_mode();
574 }
575
576
577 void
578 ui_set_trigonometric_mode(enum trig_type mode)
579 {
580 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(X->trig[mode]), 1);
581 }
582
583
584 void
585 ui_set_numeric_mode(enum base_type mode)
586 {
587 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(X->disp[mode]), 1);
588 }
589
590
591 void
592 ui_set_undo_enabled(int undo, int redo)
593 {
594 gtk_widget_set_sensitive(X->undo, undo);
595 gtk_widget_set_sensitive(X->redo, redo);
596 }
597
598
599 static char *
600 make_hostname()
601 {
602 Display *dpy = GDK_DISPLAY();
603 char client_hostname[MAXHOSTNAMELEN + 4];
604 char hostname[MAXHOSTNAMELEN];
605 char *display = DisplayString(dpy);
606 char *scanner = display;
607
608 GETHOSTNAME(hostname, MAXHOSTNAMELEN);
609
610 while (*scanner) {
611 scanner++;
612 }
613
614 while (*scanner != ':') {
615 scanner--;
616 }
617
618 *scanner = '\0';
619
620 if (strcmp(display, hostname) &&
621 strcmp(display, "localhost") &&
622 strcmp(display, "unix") &&
623 strcmp(display, "")) {
624 SPRINTF(client_hostname, " [%s] ", hostname);
625 } else {
626 STRCPY(client_hostname, "");
627 }
628
629 *scanner = ':';
630
631 if (client_hostname[0] == '\0')
632 return NULL;
633 else
634 return(strdup(client_hostname));
635 }
636
637
638 void
639 ui_set_mode(enum mode_type mode)
640 {
641 GtkRequisition *r;
642 gint w, h;
643 char *hostname, title[MAXLINE];
644 GtkWidget *menu;
645
646 switch (mode) {
647 case BASIC:
648 gtk_widget_show(X->bas_panel);
649 gtk_widget_hide(X->adv_panel);
650 gtk_widget_hide(X->fin_panel);
651 gtk_widget_hide(X->mode_panel);
652 gtk_widget_hide(X->bit_panel);
653 gtk_widget_hide(X->sci_panel);
654 menu = GET_WIDGET("view_basic_menu");
655 break;
656
657 case ADVANCED:
658 gtk_widget_hide(X->bas_panel);
659 gtk_widget_show(X->adv_panel);
660 gtk_widget_hide(X->fin_panel);
661 gtk_widget_hide(X->mode_panel);
662 gtk_widget_hide(X->bit_panel);
663 gtk_widget_hide(X->sci_panel);
664 menu = GET_WIDGET("view_advanced_menu");
665 break;
666
667 case FINANCIAL:
668 gtk_widget_hide(X->bas_panel);
669 gtk_widget_show(X->adv_panel);
670 gtk_widget_show(X->fin_panel);
671 gtk_widget_hide(X->mode_panel);
672 gtk_widget_hide(X->bit_panel);
673 gtk_widget_hide(X->sci_panel);
674 menu = GET_WIDGET("view_financial_menu");
675 break;
676
677 case SCIENTIFIC:
678 gtk_widget_hide(X->bas_panel);
679 gtk_widget_show(X->adv_panel);
680 gtk_widget_hide(X->fin_panel);
681 gtk_widget_show_all(X->mode_panel);
682 if (v->bitcalculating_mode) {
683 gtk_widget_show_all(X->bit_panel);
684 } else {
685 gtk_widget_hide(X->bit_panel);
686 }
687 gtk_widget_show(X->sci_panel);
688 menu = GET_WIDGET("view_scientific_menu");
689 break;
690
691 default:
692 assert(FALSE);
693 return;
694 }
695
696
697 r = g_new0(GtkRequisition, 1);
698 gtk_widget_size_request(X->menubar, r);
699 w = r->width;
700 h = r->height;
701 gtk_widget_size_request(X->display_item, r);
702 w = MAX(w, r->width);
703 h += r->height;
704
705 if (GTK_WIDGET_VISIBLE(X->fin_panel)) {
706 gtk_widget_size_request(X->fin_panel, r);
707 w = MAX(w, r->width);
708 h += r->height;
709 }
710
711 if (GTK_WIDGET_VISIBLE(X->mode_panel)) {
712 gtk_widget_size_request(X->mode_panel, r);
713 w = MAX(w, r->width);
714 h += r->height;
715 }
716
717 if (GTK_WIDGET_VISIBLE(X->sci_panel)) {
718 gtk_widget_size_request(X->sci_panel, r);
719 w = MAX(w, r->width);
720 h += r->height;
721 }
722
723 /* For initial display. */
724 gtk_window_set_default_size(GTK_WINDOW(X->kframe), w, h);
725 gtk_window_resize(GTK_WINDOW(X->kframe), w, h);
726
727 g_free(r);
728
729 if((hostname = make_hostname())) {
730 SNPRINTF(title, MAXLINE, hostname_titles[mode], hostname);
731 g_free(hostname);
732 } else {
733 SNPRINTF(title, MAXLINE, titles[mode]);
734 }
735 gtk_window_set_title(GTK_WINDOW(X->kframe), title);
736
737 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), TRUE);
738 }
739
740
741 void
742 ui_set_statusbar(gchar *text, const gchar *imagename)
743 {
744 GtkImage *image = GTK_IMAGE(X->status_image);
745
746 assert(text);
747 assert(imagename);
748 assert(image);
749
750 gtk_image_set_from_stock(image, imagename, GTK_ICON_SIZE_BUTTON);
751 gtk_statusbar_pop(GTK_STATUSBAR(X->statusbar), 0);
752 gtk_statusbar_push(GTK_STATUSBAR(X->statusbar), 0, text);
753 }
754
755
756 static void
757 bin_str(int MP_value[MP_SIZE], char *str, int maxbits)
758 {
759 int i, MP0[MP_SIZE], MP1[MP_SIZE], MP2[MP_SIZE], MP3[MP_SIZE];
760 int neg = 0;
761
762 MPstr_to_num("0", DEC, MP0);
763 MPstr_to_num("1", DEC, MP1);
764 MPstr_to_num("2", DEC, MP2);
765
766 if (mplt(MP_value, MP0)) {
767 mpcmim(MP_value, MP0);
768 mpadd(MP0, MP1, MP0);
769 neg = 1;
770 } else {
771 mpcmim(MP_value, MP0);
772 }
773
774 for (i = 0; i < maxbits; i++) {
775 double lsb; /* Least significant bit. */
776 calc_and(MP3, MP0, MP1);
777 mpcmd(MP3, &lsb);
778
779 if (lsb == 0) {
780 str[maxbits - i -1] = (neg) ? '1' : '0';
781 } else {
782 str[maxbits - i -1] = (neg) ? '0' : '1';
783 }
784
785 mpdiv(MP0, MP2, MP3);
786 mpcmim(MP3, MP0);
787 }
788
789 return;
790 }
791
792
793 static void
794 set_bit_panel()
795 {
796 int bit_str_len, i, MP1[MP_SIZE], MP2[MP_SIZE];
797 int MP[MP_SIZE];
798 char str[64], label[3];
799 int ret = usable_num(MP);
800
801 switch (v->syntax) {
802 case NPA:
803 MPstr_to_num(v->display, v->base, MP1);
804 mpcmim(MP1, MP2);
805 if (mpeq(MP1, MP2)) {
806 char *bit_str, label[3], tmp[MAXLINE];
807 int toclear = (v->current == KEY_CLEAR_ENTRY)
808 ? TRUE : FALSE;
809
810 bit_str = make_fixed(MP1, tmp, BIN, MAXLINE, toclear);
811 bit_str_len = strlen(bit_str);
812 if (bit_str_len <= MAXBITS) {
813 gtk_widget_set_sensitive(X->bit_panel, TRUE);
814
815 STRCPY(label, " 0");
816 for (i = 0; i < MAXBITS; i++) {
817 label[1] = (i < bit_str_len) ? bit_str[bit_str_len-i-1] : '0';
818 gtk_label_set_text(GTK_LABEL(X->bits[MAXBITS - i - 1]), label);
819 }
820
821 return;
822 }
823 }
824 gtk_widget_set_sensitive(X->bit_panel, FALSE);
825 break;
826
827 case EXPRS:
828 if (ret || !is_integer(MP)) {
829 gtk_widget_set_sensitive(X->bit_panel, FALSE);
830 return;
831 }
832 bin_str(MP, str, 64);
833 gtk_widget_set_sensitive(X->bit_panel, TRUE);
834
835 STRCPY(label, " 0");
836 for (i = 0; i < 64; i++) {
837 label[1] = str[64 - i - 1];
838 gtk_label_set_text(GTK_LABEL(X->bits[64 - i - 1]), label);
839 }
840 break;
841
842 default:
843 assert(FALSE);
844 }
845 }
846
847
848 static void
849 scroll_right()
850 {
851 if (!v->started) {
852 return;
853 }
854
855 if (GTK_WIDGET_VISIBLE(
856 GTK_SCROLLED_WINDOW(X->scrolledwindow)->hscrollbar)) {
857 GtkAdjustment *set;
858
859 set = gtk_scrolled_window_get_hadjustment(
860 GTK_SCROLLED_WINDOW(X->scrolledwindow));
861 gtk_adjustment_set_value(set, set->upper);
862 gtk_scrolled_window_set_hadjustment(
863 GTK_SCROLLED_WINDOW(X->scrolledwindow), set);
864 }
865 }
866
867
868 void
869 ui_set_display(char *str, int minimize_changes)
870 {
871 char localized[MAX_LOCALIZED];
872 GtkTextIter start, end;
873 gchar *text;
874 gint diff;
875 gint len1, len2;
876 gboolean done;
877
878 if (str == NULL || str[0] == '\0') {
879 str = " ";
880 } else {
881 if (v->noparens == 0) {
882 localize_number(localized, str);
883 str = localized;
884 }
885 }
886 gtk_text_buffer_get_bounds(X->display_buffer, &start, &end);
887 text = gtk_text_buffer_get_text(X->display_buffer, &start, &end, TRUE);
888 diff = strcmp (text, str);
889 if (diff != 0) {
890 len1 = strlen(text);
891 len2 = strlen(str);
892
893 done = FALSE;
894 if (minimize_changes) {
895 if (len1 < len2 && strncmp(text, str, len1) == 0) {
896 /* Text insertion */
897 gtk_text_buffer_insert(X->display_buffer, &end, str + len1, -1);
898 done = TRUE;
899 } else if (len1 > len2 && strncmp(text, str, len2) == 0) {
900 /* Text deletion */
901 gtk_text_buffer_get_iter_at_offset (X->display_buffer, &start, len2);
902 gtk_text_buffer_delete(X->display_buffer, &start, &end);
903 done = TRUE;
904 }
905 }
906
907 if (!done) {
908 gtk_text_buffer_delete(X->display_buffer, &start, &end);
909 gtk_text_buffer_insert(X->display_buffer, &end, str, -1);
910 }
911 }
912 scroll_right();
913 g_free(text);
914 }
915
916
917 /* When an error condition occurs:
918 *
919 * - make insensitive all buttons except Clr.
920 * - make all Scientific mode toggles and checkboxes insensitive.
921 * - make all menubar items insensitive except:
922 * Calculator->Quit
923 * Help->Contents
924 *
925 * When the error condition is cleared, resensitise everything, setting
926 * the numeric base buttons correctly.
927 */
928
929 void
930 ui_set_error_state(int error)
931 {
932 int i;
933
934 v->error = error;
935
936 for (i = 0; i < NBUTTONS; i++) {
937 gtk_widget_set_sensitive(X->buttons[i], !v->error);
938 }
939 /* Clr button always sensitive. */
940 gtk_widget_set_sensitive(X->clear_buttons[0], TRUE);
941 gtk_widget_set_sensitive(X->clear_buttons[1], TRUE);
942
943 if (!v->error) {
944 ui_set_base(v->base);
945 }
946
947 gtk_widget_set_sensitive(X->mode_panel, !v->error);
948
949 // FIXME: Isn't this missing a whole lot of widgets?
950 SET_MENUBAR_ITEM_STATE("copy_menu", !v->error);
951 SET_MENUBAR_ITEM_STATE("paste_menu", !v->error);
952 SET_MENUBAR_ITEM_STATE("insert_ascii_menu", !v->error);
953 SET_MENUBAR_ITEM_STATE("view_basic_menu", !v->error);
954 SET_MENUBAR_ITEM_STATE("view_advanced_menu", !v->error);
955 SET_MENUBAR_ITEM_STATE("view_financial_menu", !v->error);
956 SET_MENUBAR_ITEM_STATE("view_scientific_menu", !v->error);
957 SET_MENUBAR_ITEM_STATE("show_trailing_zeroes_menu",
958 !v->error && (v->modetype == SCIENTIFIC));
959 SET_MENUBAR_ITEM_STATE("show_thousands_separator_menu", !v->error);
960 SET_MENUBAR_ITEM_STATE("show_registers_menu", !v->error);
961 SET_MENUBAR_ITEM_STATE("arithmetic_precedence_menu", !v->error);
962 SET_MENUBAR_ITEM_STATE("about_menu", !v->error);
963 }
964
965
966 /*ARGSUSED*/
967 static void
968 about_cb(GtkWidget *widget)
969 {
970 const gchar *authors[] = {
971 "Rich Burridge <rich.burridge@sun.com>",
972 "Sami Pietila <sampie@ariana-dsl.utu.fi>",
973 "Robert Ancell <robert.ancell@gmail.com>",
974 NULL
975 };
976 const gchar *documenters[] = {
977 "Sun Microsystems",
978 NULL
979 };
980 const gchar *translator_credits = _("translator-credits");
981
982 const char *license[] = {
983 N_("Gcalctool is free software; you can redistribute it and/or modify\n"
984 "it under the terms of the GNU General Public License as published by\n"
985 "the Free Software Foundation; either version 2 of the License, or\n"
986 "(at your option) any later version.\n"),
987 N_("Gcalctool is distributed in the hope that it will be useful,\n"
988 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
989 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
990 "GNU General Public License for more details.\n"),
991 N_("You should have received a copy of the GNU General Public License\n"
992 "along with Gcalctool; if not, write to the Free Software Foundation, Inc.,\n"
993 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA\n")
994 };
995
996 char *license_trans = g_strconcat(_(license[0]), "\n",
997 _(license[1]), "\n",
998 _(license[2]), "\n",
999 NULL);
1000
1001 gtk_show_about_dialog(GTK_WINDOW(X->kframe),
1002 "name",_("Gcalctool"),
1003 "version", VERSION,
1004 "copyright", _("\xc2\xa9 1986-2007 The Gcalctool authors"),
1005 "license", license_trans,
1006 "comments", _("Calculator with financial and scientific modes."),
1007 "authors", authors,
1008 "documenters", documenters,
1009 "translator_credits", translator_credits,
1010 "logo-icon-name", "gnome-calculator",
1011 NULL);
1012 }
1013
1014
1015 static void
1016 cell_edited_cb(GtkCellRendererText *cell, const gchar *path_string,
1017 const gchar *new_text, gpointer data)
1018 {
1019 GtkTreeModel *model = (GtkTreeModel *) data;
1020 GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
1021 GtkTreeIter iter;
1022 gchar *old_text;
1023 gint *column;
1024
1025 column = g_object_get_data(G_OBJECT(cell), "column");
1026
1027 gtk_tree_model_get_iter(model, &iter, path);
1028
1029 switch (GPOINTER_TO_INT(column)) {
1030 case COLUMN_VALUE:
1031 gtk_tree_model_get(model, &iter, column, &old_text, -1);
1032 g_free(old_text);
1033 gtk_list_store_set(GTK_LIST_STORE(model), &iter, column,
1034 g_strdup(new_text), -1);
1035 break;
1036
1037 case COLUMN_DESCRIPTION:
1038 gtk_tree_model_get(model, &iter, column, &old_text, -1);
1039 g_free(old_text);
1040 gtk_list_store_set(GTK_LIST_STORE(model), &iter, column,
1041 g_strdup(new_text), -1);
1042 break;
1043 }
1044
1045 gtk_tree_path_free(path);
1046 }
1047
1048
1049 static void
1050 add_cf_column(GtkTreeView *treeview, gchar *name, gint colno, gboolean editable)
1051 {
1052 GtkCellRenderer *renderer;
1053 GtkTreeModel *model = gtk_tree_view_get_model(treeview);
1054
1055 renderer = gtk_cell_renderer_text_new();
1056 if (editable) {
1057 g_signal_connect(G_OBJECT(renderer), "edited",
1058 G_CALLBACK(cell_edited_cb), model);
1059 }
1060 g_object_set_data(G_OBJECT(renderer), "column", GINT_TO_POINTER(colno));
1061
1062 if (editable) {
1063 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview),
1064 -1, name, renderer,
1065 "text", colno,
1066 "editable", COLUMN_EDITABLE,
1067 NULL);
1068 } else {
1069 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview),
1070 -1, name, renderer,
1071 "text", colno,
1072 NULL);
1073 }
1074 }
1075
1076
1077 /*ARGSUSED*/
1078 static void
1079 aframe_cancel_cb(GtkButton *button, gpointer user_data)
1080 {
1081 gtk_widget_hide(X->aframe);
1082 }
1083
1084
1085 /*ARGSUSED*/
1086 static gboolean
1087 aframe_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1088 {
1089 g_return_val_if_fail(GTK_IS_WIDGET(widget), FALSE);
1090
1091 if (event->keyval == GDK_Escape) {
1092 gtk_widget_hide(X->aframe);
1093 }
1094
1095 return(FALSE);
1096 }
1097
1098
1099 /*ARGSUSED*/
1100 static void
1101 aframe_ok_cb(GtkButton *button, gpointer user_data)
1102 {
1103 char *ch;
1104 int val;
1105
1106 ch = (char *) gtk_entry_get_text(GTK_ENTRY(X->aframe_ch));
1107 val = ch[0];
1108 mpcim(&val, v->MPdisp_val);
1109 show_display(v->MPdisp_val);
1110 gtk_widget_hide(X->aframe);
1111 }
1112
1113
1114 /*ARGSUSED*/
1115 void
1116 base_cb(GtkWidget *widget)
1117 {
1118 enum base_type base;
1119
1120 base = (enum base_type) g_object_get_data(G_OBJECT(widget),
1121 "base_mode");
1122 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
1123 do_base(base);
1124 }
1125 }
1126
1127
1128 void
1129 ui_beep()
1130 {
1131 gdk_beep();
1132 }
1133
1134 static void do_button(struct button *n, int arg)
1135 {
1136 struct exprm_state *e;
1137
1138 switch (v->syntax) {
1139 case NPA:
1140 process_item(n, arg);
1141 set_bit_panel();
1142 if (v->new_input && v->dtype == FIX) {
1143 STRNCPY(v->fnum, v->display, MAX_DIGITS - 1);
1144 ui_set_display(v->fnum, TRUE);
1145 }
1146 break;
1147
1148 case EXPRS:
1149 e = get_state();
1150 e->value = arg;
1151 MEMCPY(&(e->button), n, sizeof(struct button));
1152 new_state();
1153 do_expression();
1154 set_bit_panel();
1155 break;
1156
1157 default:
1158 assert(0);
1159 }
1160 }
1161
1162
1163 static void
1164 help_display(void)
1165 {
1166 GError *error = NULL;
1167 char *command;
1168 const char *lang;
1169 char *uri = NULL;
1170 GdkScreen *gscreen;
1171
1172 int i;
1173
1174 const char * const * langs = g_get_language_names ();
1175
1176 for (i = 0; langs[i]; i++) {
1177 lang = langs[i];
1178 if (strchr (lang, '.')) {
1179 continue;
1180 }
1181
1182 uri = g_build_filename(PACKAGE_DATA_DIR,
1183 "/gnome/help/gcalctool/",
1184 lang,
1185 "/gcalctool.xml",
1186 NULL);
1187
1188 if (g_file_test (uri, G_FILE_TEST_EXISTS)) {
1189 break;
1190 }
1191 }
1192
1193 command = g_strconcat ("gnome-open ghelp://", uri, NULL);
1194 gscreen = gdk_screen_get_default();
1195 gdk_spawn_command_line_on_screen (gscreen, command, &error);
1196 if (error) {
1197 GtkWidget *d;
1198
1199 d = gtk_message_dialog_new(NULL,
1200 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1201 GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
1202 error->message);
1203 gtk_dialog_run(GTK_DIALOG(d));
1204 gtk_widget_destroy(d);
1205 g_error_free(error);
1206 error = NULL;
1207 }
1208
1209 g_free (command);
1210 g_free (uri);
1211 }
1212
1213
1214 static void
1215 put_constant(int n, char *con_value, char *con_name)
1216 {
1217 char key[MAXLINE];
1218 char *cstr = g_strdup(con_value);
1219
1220 /* Constants are written out with no thousands seaparator and with a radix
1221 * character of ".".
1222 */
1223
1224 SNPRINTF(key, MAXLINE, "constant%1dvalue", n);
1225 set_resource(key, cstr);
1226 g_free(cstr);
1227
1228 SNPRINTF(key, MAXLINE, "constant%1dname", n);
1229 set_resource(key, con_name);
1230 }
1231
1232
1233 static void
1234 put_function(int n, char *fun_value, char *fun_name)
1235 {
1236 char key[MAXLINE];
1237
1238 SNPRINTF(key, MAXLINE, "function%1dvalue", n);
1239 set_resource(key, fun_value);
1240
1241 SNPRINTF(key, MAXLINE, "function%1dname", n);
1242 set_resource(key, fun_name);
1243 }
1244
1245
1246 /*ARGSUSED*/
1247 static void
1248 menu_proc_cb(GtkMenuItem *mi, gpointer user_data)
1249 {
1250 struct button *n = (struct button *) g_object_get_data(G_OBJECT(mi), "button");
1251 do_button(n, GPOINTER_TO_INT(user_data));
1252 }
1253
1254
1255 /* Create popup window for editing constants/functions. */
1256
1257 static void
1258 update_popup_label(GtkWidget *menu_item, gchar *text)
1259 {
1260 GtkWidget *label;
1261 label = (GtkWidget *)gtk_container_get_children(GTK_CONTAINER(menu_item))->data;
1262 gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), text);
1263 }
1264
1265 static void
1266 update_constants_menu(void)
1267 {
1268 char mline[MAXLINE];
1269 int i;
1270
1271 for (i = 0; i < MAXCONFUN; i++) {
1272 SNPRINTF(mline, MAXLINE,
1273 "<span weight=\"bold\">%s_%1d:</span> %s [%s]", _("C"), i,
1274 make_number(v->MPcon_vals[i], DEC, TRUE),
1275 v->con_names[i]);
1276 update_popup_label(X->constant_menu_items[i], mline);
1277 }
1278 }
1279
1280
1281 static void
1282 update_functions_menu(void)
1283 {
1284 char mline[MAXLINE];
1285 int i;
1286
1287 for (i = 0; i < MAXCONFUN; i++) {
1288 if (strlen(v->fun_vals[i]) != 0) {
1289 SNPRINTF(mline, MAXLINE,
1290 "<span weight=\"bold\">%s_%1d:</span> %s [%s]",
1291 _("F"), i, v->fun_vals[i], v->fun_names[i]);
1292 gtk_widget_show(X->function_menu_items[i]);
1293 update_popup_label(X->function_menu_items[i], mline);
1294 }
1295 else
1296 gtk_widget_hide(X->function_menu_items[i]);
1297 }
1298 }
1299
1300
1301 static void
1302 edit_constants_response_cb(GtkDialog *dialog, gint id)
1303 {
1304 GtkTreeIter iter;
1305 gint number;
1306 gchar *value;
1307 gchar *description;
1308
1309 if (id == GTK_RESPONSE_HELP) {
1310 help_display();
1311 }
1312
1313 if (id == GTK_RESPONSE_ACCEPT) {
1314 if (gtk_tree_model_get_iter_first(X->constants_model, &iter)) {
1315 do {
1316 gtk_tree_model_get(X->constants_model, &iter,
1317 COLUMN_NUMBER, &number,
1318 COLUMN_VALUE, &value,
1319 COLUMN_DESCRIPTION, &description, -1);
1320 MPstr_to_num(value, DEC, v->MPcon_vals[number]);
1321 STRNCPY(v->con_names[number], description, MAXLINE - 1);
1322 put_constant(number, value, description);
1323 } while (gtk_tree_model_iter_next(X->constants_model, &iter));
1324 }
1325 }
1326
1327 gtk_widget_hide(GTK_WIDGET(dialog));
1328 }
1329
1330
1331 static void
1332 edit_functions_response_cb(GtkDialog *dialog, gint id)
1333 {
1334 GtkTreeIter iter;
1335 gint number;
1336 gchar *value;
1337 gchar *description;
1338
1339 if (id == GTK_RESPONSE_HELP) {
1340 help_display();
1341 }
1342
1343 if (id == GTK_RESPONSE_ACCEPT) {
1344 if (gtk_tree_model_get_iter_first(X->functions_model, &iter)) {
1345 do {
1346 gtk_tree_model_get(X->functions_model, &iter,
1347 COLUMN_NUMBER, &number,
1348 COLUMN_VALUE, &value,
1349 COLUMN_DESCRIPTION, &description, -1);
1350 STRNCPY(v->fun_vals[number], convert(value), MAXLINE - 1);
1351 STRNCPY(v->fun_names[number], description, MAXLINE - 1);
1352 put_function(number, value, description);
1353 } while (gtk_tree_model_iter_next(X->functions_model, &iter));
1354 }
1355 }
1356
1357 gtk_widget_hide(GTK_WIDGET(dialog));
1358 }
1359
1360
1361 /*ARGSUSED*/
1362 static GtkTreeModel *
1363 create_cf_model(enum menu_type mtype, GtkWidget *dialog)
1364 {
1365 gint i = 0;
1366 GtkListStore *model;
1367 GtkTreeIter iter;
1368 gchar *value, *description;
1369
1370 model = gtk_list_store_new(NUM_COLUMNS, G_TYPE_INT, G_TYPE_STRING,
1371 G_TYPE_STRING, G_TYPE_BOOLEAN);
1372 for (i = 0; i < MAXCONFUN; i++) {
1373 gtk_list_store_append(model, &iter);
1374
1375 if (mtype == M_CON) {
1376 value = g_strdup(make_number(v->MPcon_vals[i], DEC, TRUE));
1377 description = g_strdup(v->con_names[i]);
1378 } else {
1379 value = g_strdup(v->fun_vals[i]);
1380 description = g_strdup(v->fun_names[i]);
1381 }
1382 gtk_list_store_set(model, &iter,
1383 COLUMN_NUMBER, i,
1384 COLUMN_VALUE, value,
1385 COLUMN_DESCRIPTION, description,
1386 COLUMN_EDITABLE, TRUE,
1387 -1);
1388 }
1389
1390 return(GTK_TREE_MODEL(model));
1391 }
1392
1393
1394 static void
1395 set_show_tsep_toggle(int state)
1396 {
1397 GtkWidget *mi;
1398
1399 mi = GET_WIDGET("show_thousands_separator_menu");
1400 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), state);
1401 }
1402
1403
1404 static void
1405 set_show_bitcalculating_toggle(int state)
1406 {
1407 GtkWidget *mi;
1408
1409 mi = GET_WIDGET("show_bitcalculating_menu");
1410 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), state);
1411 }
1412
1413
1414 static void
1415 set_show_zeroes_toggle(int state)
1416 {
1417 GtkWidget *menu;
1418
1419 v->doing_mi = 1; /* Hack to get mstz_proc() to just return. */
1420 menu = GET_WIDGET("show_trailing_zeroes_menu");
1421 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), state);
1422 menu = GET_WIDGET("acc_trailing_zeroes_item");
1423 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), state);
1424 v->doing_mi = 0;
1425 }
1426
1427
1428 void
1429 ui_make_registers() /* Calculate memory register frame values. */
1430 {
1431 char *mval, key[MAXLINE];
1432 int n;
1433
1434 for (n = 0; n < MAXREGS; n++) {
1435 mval = make_number(v->MPmvals[n], v->base, TRUE);
1436 gtk_entry_set_width_chars(GTK_ENTRY(X->regs[n]), strlen(mval));
1437 gtk_entry_set_text(GTK_ENTRY(X->regs[n]), mval);
1438 SNPRINTF(key, MAXLINE, "register%d", n);
1439 set_resource(key, mval);
1440 }
1441 }
1442
1443
1444 static void
1445 reset_mode_display(void)
1446 {
1447 switch (v->syntax) {
1448 case NPA:
1449 show_display(v->MPdisp_val);
1450 break;
1451
1452 case EXPRS:
1453 refresh_display();
1454 break;
1455
1456 default:
1457 assert(FALSE);
1458 }
1459 ui_make_registers();
1460 }
1461
1462
1463 static void
1464 save_win_position()
1465 {
1466 int x, y;
1467
1468 (void) gdk_window_get_origin(X->kframe->window, &x, &y);
1469 set_int_resource(R_XPOS, x);
1470 set_int_resource(R_YPOS, y);
1471 }
1472
1473
1474 static void
1475 change_mode(int mode)
1476 {
1477 X->mode = mode;
1478 v->modetype = mode;
1479 v->base = DEC;
1480 ui_set_base(v->base);
1481 ui_set_numeric_mode(FIX);
1482 v->accuracy = 9;
1483 ui_set_accuracy(v->accuracy);
1484
1485 v->show_tsep = FALSE;
1486 set_show_tsep_toggle(v->show_tsep);
1487 set_boolean_resource(R_TSEP, v->show_tsep == TRUE);
1488
1489 v->show_zeroes = FALSE;
1490 set_show_zeroes_toggle(v->show_zeroes);
1491 set_boolean_resource(R_ZEROES, v->show_zeroes == TRUE);
1492
1493 reset_mode_display();
1494 do_mode(TRUE);
1495 }
1496
1497
1498 /*ARGSUSED*/
1499 static void
1500 cm_response_cb(GtkDialog *dialog, int response)
1501 {
1502 if (response == GTK_RESPONSE_ACCEPT) {
1503 change_mode(X->mode);
1504 } else {
1505 ui_set_mode(v->modetype);
1506 }
1507
1508 gtk_widget_destroy(X->cm_dialog);
1509 X->cm_dialog = NULL;
1510 }
1511
1512
1513 /*ARGSUSED*/
1514 static void
1515 cm_warning_cb(GtkWidget *button)
1516 {
1517 v->warn_change_mode = !gtk_toggle_button_get_active(
1518 GTK_TOGGLE_BUTTON(button));
1519 }
1520
1521
1522 static void
1523 create_change_mode_dialog()
1524 {
1525 GtkWidget *check, *button;
1526
1527 X->cm_dialog = gtk_message_dialog_new(GTK_WINDOW(X->kframe),
1528 GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
1529 GTK_MESSAGE_WARNING,
1530 GTK_BUTTONS_CANCEL,
1531 "%s",
1532 _("Changing Modes Clears Calculation"));
1533 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(X->cm_dialog),
1534 "%s",
1535 _("When you change modes, the current calculation "
1536 "will be cleared, and the base will be reset to "
1537 "decimal."));
1538
1539 check = gtk_check_button_new_with_mnemonic(_("_Do not warn me again"));
1540 gtk_box_pack_end(GTK_BOX(GTK_MESSAGE_DIALOG(X->cm_dialog)->label->parent),
1541 check, FALSE, FALSE, 0);
1542 gtk_widget_show(check);
1543
1544 button = gtk_dialog_add_button(GTK_DIALOG(X->cm_dialog),
1545 _("C_hange Mode"), GTK_RESPONSE_ACCEPT);
1546 gtk_button_set_image(GTK_BUTTON(button),
1547 gtk_image_new_from_stock(GTK_STOCK_REFRESH,
1548 GTK_ICON_SIZE_BUTTON));
1549 /* Set default focus on affirmative button */
1550 gtk_widget_grab_focus(button);
1551
1552 gtk_dialog_set_alternative_button_order(GTK_DIALOG(X->cm_dialog),
1553 GTK_RESPONSE_ACCEPT,
1554 GTK_RESPONSE_CANCEL,
1555 -1);
1556
1557 g_signal_connect((gpointer) check, "toggled",
1558 G_CALLBACK(cm_warning_cb), NULL);
1559 g_signal_connect(X->cm_dialog, "response",
1560 G_CALLBACK(cm_response_cb), NULL);
1561
1562 gtk_window_set_position(GTK_WINDOW(X->cm_dialog),
1563 GTK_WIN_POS_CENTER_ON_PARENT);
1564 }
1565
1566
1567 static void
1568 show_change_mode_dialog()
1569 {
1570 if (X->cm_dialog == NULL) {
1571 create_change_mode_dialog();
1572 }
1573
1574 gtk_window_present(GTK_WINDOW(X->cm_dialog));
1575 }
1576
1577
1578 /*ARGSUSED*/
1579 static gboolean
1580 bit_toggle_cb(GtkWidget *event_box, GdkEventButton *event)
1581 {
1582 double number;
1583 unsigned long long lval;
1584 int n, MP1[MP_SIZE], index;
1585
1586 index = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(event_box),
1587 "bit_index"));
1588 n = MAXBITS - index - 1;
1589 MPstr_to_num(v->display, v->base, MP1);
1590 mpcmd(MP1, &number);
1591 lval = (long long) number;
1592
1593 if (lval & (1LL << n)) {
1594 lval &= ~(1LL << n);
1595 gtk_label_set_text(GTK_LABEL(X->bits[index]), " 0");
1596 } else {
1597 lval |= (1LL << n);
1598 gtk_label_set_text(GTK_LABEL(X->bits[index]), " 1");
1599 }
1600
1601 number = (double) lval;
1602 mpcdm(&number, v->MPdisp_val);
1603 show_display(v->MPdisp_val);
1604 v->toclear = 0;
1605
1606 return(TRUE);
1607 }
1608
1609
1610 static void
1611 menu_item_select_cb(GtkWidget *widget)
1612 {
1613 GtkStatusbar *statusbar = GTK_STATUSBAR(X->statusbar);
1614 gchar *tooltip;
1615 guint context_id;
1616
1617 context_id = gtk_statusbar_get_context_id(statusbar, "menuhelp");
1618
1619 tooltip = (gchar *)g_object_get_data(G_OBJECT(widget), "tooltip");
1620 if (tooltip) {
1621 gtk_statusbar_push(statusbar, context_id, tooltip);
1622 }
1623 }
1624
1625
1626 /*ARGSUSED*/
1627 static void
1628 menu_item_deselect_cb(GtkWidget *widget)
1629 {
1630 GtkStatusbar *statusbar = GTK_STATUSBAR(X->statusbar);
1631 guint context_id;
1632
1633 context_id = gtk_statusbar_get_context_id(statusbar, "menuhelp");
1634 gtk_statusbar_pop(statusbar, context_id);
1635 }
1636
1637
1638 static void
1639 set_menubar_tooltip(gchar *menu_name)
1640 {
1641 GtkWidget *menu;
1642 gchar *tooltip;
1643
1644 menu = GET_WIDGET(menu_name);
1645 tooltip = gtk_widget_get_tooltip_text(menu);
1646 g_object_set_data(G_OBJECT(menu), "tooltip", tooltip);
1647 gtk_widget_set_tooltip_text(menu, NULL);
1648 }
1649
1650
1651 static void
1652 update_memory_menus()
1653 {
1654 char mstr[MAXLINE];
1655 int i;
1656
1657 for (i = 0; i < MAXREGS; i++) {
1658 SNPRINTF(mstr, MAXLINE, "<span weight=\"bold\">%s_%d:</span> %s",
1659 /* translators: R is the short form of register used inter alia
1660 in popup menus */
1661 _("R"), i, make_number(v->MPmvals[i], v->base, TRUE));
1662 update_popup_label(X->memory_store_items[i], mstr);
1663 update_popup_label(X->memory_recall_items[i], mstr);
1664 update_popup_label(X->memory_exchange_items[i], mstr);
1665 }
1666 }
1667
1668
1669 static void
1670 set_memory_toggle(int state)
1671 {
1672 GtkWidget *menu = GET_WIDGET("show_registers_menu");
1673
1674 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), state);
1675 }
1676
1677
1678 /*ARGSUSED*/
1679 static void
1680 rframe_response_cb(GtkDialog *dialog, int response)
1681 {
1682 set_memory_toggle(FALSE);
1683 set_boolean_resource(R_REGS, FALSE);
1684 gtk_widget_hide(X->rframe);
1685 }
1686
1687
1688 /*ARGSUSED*/
1689 static gboolean
1690 aframe_delete_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data)
1691 {
1692 gtk_widget_hide(widget);
1693
1694 return(TRUE);
1695 }
1696
1697
1698 /*ARGSUSED*/
1699 static gboolean
1700 rframe_delete_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data)
1701 {
1702 gtk_dialog_response(GTK_DIALOG(widget), GTK_RESPONSE_DELETE_EVENT);
1703
1704 return(TRUE);
1705 }
1706
1707
1708 /*ARGSUSED*/
1709 static gboolean
1710 spframe_delete_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data)
1711 {
1712 gtk_widget_hide(X->spframe);
1713
1714 return(TRUE);
1715 }
1716
1717
1718 /*ARGSUSED*/
1719 void
1720 disp_cb(GtkWidget *widget)
1721 {
1722 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
1723 do_numtype((enum num_type) g_object_get_data(G_OBJECT(widget), "numeric_mode"));
1724 }
1725
1726
1727 static void
1728 get_constant(int n)
1729 {
1730 char nkey[MAXLINE], *nline;
1731 char vkey[MAXLINE], *vline;
1732
1733 SNPRINTF(nkey, MAXLINE, "constant%1dname", n);
1734 if ((nline = get_resource(nkey)) == NULL) {
1735 return;
1736 }
1737
1738 SNPRINTF(vkey, MAXLINE, "constant%1dvalue", n);
1739 if ((vline = get_resource(vkey)) == NULL) {
1740 return;
1741 }
1742
1743 MPstr_to_num(vline, DEC, v->MPcon_vals[n]);
1744 STRNCPY(v->con_names[n], nline, MAXLINE - 1);
1745 }
1746
1747
1748 static void
1749 get_display() /* The Copy function key has been pressed. */
1750 {
1751 gchar *string = NULL;
1752 GtkTextIter start, end;
1753
1754 if (gtk_text_buffer_get_selection_bounds(X->display_buffer, &start, &end) == TRUE) {
1755 string = gtk_text_buffer_get_text(X->display_buffer, &start, &end, FALSE);
1756 } else {
1757 gtk_text_buffer_get_bounds(X->display_buffer, &start, &end);
1758 string = gtk_text_buffer_get_text(X->display_buffer, &start, &end, FALSE);
1759 }
1760
1761 if (v->shelf != NULL) {
1762 free(v->shelf);
1763 }
1764 v->shelf = g_locale_from_utf8(string, strlen(string), NULL, NULL, NULL);
1765 g_free(string);
1766
1767 gtk_clipboard_set_text(gtk_clipboard_get(X->clipboard_atom), v->shelf, -1);
1768 }
1769
1770
1771 static void
1772 get_function(int n)
1773 {
1774 char nkey[MAXLINE], *nline;
1775 char vkey[MAXLINE], *vline;
1776
1777 SNPRINTF(nkey, MAXLINE, "function%1dname", n);
1778 if ((nline = get_resource(nkey)) == NULL) {
1779 return;
1780 }
1781
1782 SNPRINTF(vkey, MAXLINE, "function%1dvalue", n);
1783 if ((vline = get_resource(vkey)) == NULL) {
1784 return;
1785 }
1786
1787 STRNCPY(v->fun_vals[n], convert(vline), MAXLINE - 1);
1788 STRNCPY(v->fun_names[n], nline, MAXLINE - 1);
1789 }
1790
1791
1792 char *
1793 ui_get_localized_numeric_point(void)
1794 {
1795 const char *decimal_point;
1796
1797 decimal_point = localeconv()->decimal_point;
1798
1799 return(g_locale_to_utf8(decimal_point, -1, NULL, NULL, NULL));
1800 }
1801
1802
1803 int
1804 get_menu_entry(enum menu_type mtype, int offset)
1805 {
1806 switch (mtype) {
1807 case M_ACC :
1808 return(offset + '0');
1809
1810 case M_LSHF :
1811 case M_RSHF :
1812 return((offset < 10) ? offset + '0' : offset + 'A' - 10);
1813
1814 default:
1815 FPRINTF(stderr, "need to handle menu type %d\n", mtype);
1816 }
1817
1818 return(0);
1819 }
1820
1821
1822 /*ARGSUSED*/
1823 static void
1824 get_proc(GtkClipboard *clipboard, const gchar *buffer, gpointer data)
1825 {
1826 int ret;
1827 gchar *dstp, *end_buffer, *srcp, *text;
1828
1829 if (buffer == NULL) {
1830 return;
1831 }
1832
1833 end_buffer = (gchar *) (buffer + strlen(buffer));
1834 text = malloc(strlen(buffer)+1);
1835
1836 srcp = (gchar *) buffer;
1837 dstp = text;
1838 while (srcp < end_buffer) {
1839
1840 /* If the clipboard buffer contains any occurances of the "thousands
1841 * separator", remove them.
1842 */
1843 if (*srcp == v->tsep[0]) {
1844 if (strstr(srcp, v->tsep) == srcp) {
1845 srcp += strlen(v->tsep);
1846 } else {
1847 *dstp++ = *srcp++;
1848 }
1849 } else {
1850
1851 /* If an "A", "B", "C", "D" or "F" character is encountered, it
1852 * will be converted to its lowercase equivalent. If an "E" is
1853 * found, and the next character is a "-" or a "+", then it
1854 * remains as an upper case "E" (it's assumed to be a possible
1855 * exponential number), otherwise its converted to a lower case
1856 * "e". See bugs #455889 and #469245 for more details.
1857 */
1858 switch (*srcp) {
1859 case 'A':
1860 case 'B':
1861 case 'C':
1862 case 'D':
1863 case 'F': *dstp++ = tolower(*srcp);
1864 srcp++;
1865 break;
1866
1867 case 'E': if (srcp < (end_buffer-1)) {
1868 if (*(srcp+1) != '-' &&
1869 *(srcp+1) != '+') {
1870 *dstp++ = tolower(*srcp);
1871 srcp++;
1872 break;
1873 }
1874 }
1875 /*FALLTHROUGH*/
1876
1877 default: *dstp++ = *srcp++;
1878 }
1879 }
1880 }
1881 *dstp++ = '\0';
1882
1883 switch (v->syntax) {
1884 case NPA:
1885 ret = lr_parse((char *) text, v->MPdisp_val);
1886 if (!ret) {
1887 show_display(v->MPdisp_val);
1888 } else {
1889 ui_set_statusbar(_("Clipboard contained malformed calculation"),
1890 "gtk-dialog-error");
1891 }
1892 break;
1893
1894 case EXPRS:
1895 exp_append((char *) text);
1896 refresh_display();
1897 break;
1898
1899 default:
1900 assert(0);
1901 }
1902 free(text);
1903 }
1904
1905
1906 void
1907 ui_set_base(enum base_type base)
1908 {
1909 int i, baseval = basevals[(int) base];
1910
1911 for (i = 0; i < 16; i++) {
1912 gtk_widget_set_sensitive(X->digit_buttons[i], i < baseval);
1913 }
1914 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(X->base[base]), 1);
1915 }
1916
1917
1918 void
1919 ui_set_registers_visible(int state)
1920 {
1921 ui_make_registers();
1922 v->rstate = state;
1923 gtk_widget_realize(X->rframe);
1924 if (state && gdk_window_is_visible(X->rframe->window)) {
1925 gdk_window_raise(X->rframe->window);
1926 return;
1927 }
1928
1929 if (state) {
1930 ds_position_popup(X->kframe, X->rframe, DS_POPUP_ABOVE);
1931 gtk_widget_show(X->rframe);
1932 } else {
1933 gtk_widget_hide(X->rframe);
1934 }
1935 }
1936
1937
1938 /*ARGSUSED*/
1939 static void
1940 help_cb(GtkWidget *widget)
1941 {
1942 if (v->started)
1943 help_display();
1944 }
1945
1946
1947 /*ARGSUSED*/
1948 void
1949 hyp_cb(GtkWidget *widget)
1950 {
1951 ui_update_trig_mode();
1952 }
1953
1954
1955 /*ARGSUSED*/
1956 void
1957 inv_cb(GtkWidget *widget)
1958 {
1959 ui_update_trig_mode();
1960 }
1961
1962
1963 static gboolean
1964 check_for_localized_numeric_point(int keyval)
1965 {
1966 gchar outbuf[10]; /* Minumum size 6. */
1967 gunichar ch;
1968
1969 ch = gdk_keyval_to_unicode(keyval);
1970 g_return_val_if_fail(g_unichar_validate(ch), FALSE);
1971
1972 outbuf[g_unichar_to_utf8(ch, outbuf)] = '\0';
1973
1974 return(strcmp(outbuf, X->lnp) == 0);
1975 }
1976
1977
1978 static void
1979 ui_parse_display()
1980 {
1981 char *text;
1982 GtkTextIter start, end;
1983
1984 gtk_text_buffer_get_bounds(X->display_buffer, &start, &end);
1985
1986 text = gtk_text_buffer_get_text(X->display_buffer,
1987 &start,
1988 &end,
1989 FALSE);
1990 exp_replace(text);
1991 }
1992
1993
1994 int
1995 ui_get_cursor(void)
1996 {
1997 gint pos;
1998 g_object_get(G_OBJECT(X->display_buffer), "cursor-position", &pos, NULL);
1999 return pos;
2000 }
2001
2002
2003 /*ARGSUSED*/
2004 static gboolean
2005 display_focus_out_cb(GtkWidget *widget, GdkEventKey *event)
2006 {
2007 if (v->syntax == EXPRS) {
2008 ui_parse_display();
2009 }
2010
2011 return(FALSE);
2012 }
2013
2014
2015 /*ARGSUSED*/
2016 static gboolean
2017 display_focus_in_cb(GtkWidget *widget, GdkEventKey *event)
2018 {
2019 v->ghost_zero = 0;
2020
2021 return(FALSE);
2022 }
2023
2024
2025 /*ARGSUSED*/
2026 static void
2027 menu_pos_func(GtkMenu *menu, gint *x, gint *y,
2028 gboolean *push_in, gpointer user_data)
2029 {
2030 GdkPoint *loc = (GdkPoint *) user_data;
2031
2032 *x = loc->x;
2033 *y = loc->y;
2034 }
2035
2036
2037 /*ARGSUSED*/
2038 static void
2039 button_cb(GtkWidget *widget, GdkEventButton *event)
2040 {
2041 struct button *n;
2042 enum menu_type mtype;
2043 GtkWidget *menu;
2044 GdkPoint loc;
2045
2046 n = (struct button *) g_object_get_data(G_OBJECT(widget), "button");
2047 mtype = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "mtype"));
2048
2049 if (mtype == M_NONE) {
2050 do_button(n, 0);
2051 } else {
2052 /* If gcalctool is being driven by gok, the on-screen keyboard
2053 * assistive technology, it's possible that the event returned by
2054 * gtk_get_current_event() is NULL. If this is the case, we need
2055 * to fudge the popping up on the menu associated with this menu
2056 * button.
2057 */
2058
2059 update_constants_menu();
2060 update_functions_menu();
2061 update_memory_menus();
2062
2063 menu = X->menus[mtype];
2064 if (event == NULL) {
2065 gdk_window_get_origin(widget->window, &loc.x, &loc.y);
2066 loc.x += widget->allocation.x;
2067 loc.y += widget->allocation.y;
2068 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, menu_pos_func,
2069 (gpointer) &loc, 0, gtk_get_current_event_time());
2070 } else if (event->button == 1) {
2071 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
2072 event->button, event->time);
2073 }
2074 }
2075 }
2076
2077
2078 /*ARGSUSED*/
2079 static void
2080 select_display_entry(int offset)
2081 {
2082 GtkTextIter iter;
2083
2084 gtk_text_buffer_get_iter_at_offset(X->display_buffer, &iter, offset);
2085 gtk_text_buffer_place_cursor(X->display_buffer, &iter);
2086 gtk_widget_grab_focus(X->display_item);
2087 }
2088
2089
2090 /*ARGSUSED*/
2091 static gboolean
2092 kframe_key_press_cb(GtkWidget *widget, GdkEventKey *event)
2093 {
2094 int i, j, state;
2095 GtkWidget *button;
2096
2097 if (check_for_localized_numeric_point(event->keyval) == TRUE) {
2098 event->state = 0;
2099 event->keyval = GDK_KP_Decimal;
2100 }
2101
2102 state = event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK);
2103
2104 /* Accuracy shortcuts */
2105 if (state == GDK_CONTROL_MASK && v->modetype == SCIENTIFIC)
2106 {
2107 switch (event->keyval) {
2108 case GDK_0:
2109 do_accuracy(0);
2110 return (TRUE);
2111 case GDK_1:
2112 do_accuracy(1);
2113 return (TRUE);
2114 case GDK_2:
2115 do_accuracy(2);
2116 return (TRUE);
2117 case GDK_3:
2118 do_accuracy(3);
2119 return (TRUE);
2120 case GDK_4:
2121 do_accuracy(4);
2122 return (TRUE);
2123 case GDK_5:
2124 do_accuracy(5);
2125 return (TRUE);
2126 case GDK_6:
2127 do_accuracy(6);
2128 return (TRUE);
2129 case GDK_7:
2130 do_accuracy(7);
2131 return (TRUE);
2132 case GDK_8:
2133 do_accuracy(8);
2134 return (TRUE);
2135 case GDK_9:
2136 do_accuracy(9);
2137 return (TRUE);
2138 }
2139 }
2140
2141 /* Connect home and end keys to move into the display entry */
2142 if (event->keyval == GDK_Home)
2143 {
2144 select_display_entry(0);
2145 return (TRUE);
2146 } else if (event->keyval == GDK_End)
2147 {
2148 select_display_entry(-1);
2149 return (TRUE);
2150 }
2151
2152 for (i = 0; i < NBUTTONS; i++) {
2153 button = X->buttons[i];
2154
2155 /* Check any parent widgets are visible */
2156 if (!GTK_WIDGET_VISIBLE(gtk_widget_get_parent(button)) ||
2157 !GTK_WIDGET_VISIBLE(button) || !GTK_WIDGET_IS_SENSITIVE(button)) {
2158 continue;
2159 }
2160
2161 j = 0;
2162 while (button_widgets[i].accelerator_keys[j] != 0) {
2163 if (button_widgets[i].accelerator_keys[j] == event->keyval &&
2164 (button_widgets[i].accelerator_mods[j] & ~GDK_SHIFT_MASK) == state) {
2165 button_cb(button, NULL);
2166 return(TRUE);
2167 }
2168 j++;
2169 }
2170 }
2171
2172 return(FALSE);
2173 }
2174
2175
2176 /*ARGSUSED*/
2177 static gboolean
2178 mouse_button_cb(GtkWidget *widget, GdkEventButton *event)
2179 {
2180 if (event->button == 2) {
2181 gtk_clipboard_request_text(gtk_clipboard_get(X->primary_atom),
2182 get_proc, NULL);
2183 }
2184
2185 return(FALSE);
2186 }
2187
2188
2189 static void
2190 set_win_position()
2191 {
2192 int intval, screen_height, screen_width;
2193 int x = 0, y = 0;
2194
2195 screen_width = gdk_screen_get_width(gdk_screen_get_default());
2196 screen_height = gdk_screen_get_height(gdk_screen_get_default());
2197
2198 if (get_int_resource(R_XPOS, &intval)) {
2199 x = intval;
2200 if (x < 0 || x > screen_width) {
2201 x = 0;
2202 }
2203 }
2204
2205 if (get_int_resource(R_YPOS, &intval)) {
2206 y = intval;
2207 if (y < 0 || y > screen_height) {
2208 y = 0;
2209 }
2210 }
2211
2212 gtk_window_move(GTK_WINDOW(X->kframe), x, y);
2213 }
2214
2215 static void
2216 show_ascii_frame() /* Display ASCII popup. */
2217 {
2218 if (!GTK_WIDGET_VISIBLE(X->aframe)) {
2219 ds_position_popup(X->kframe, X->aframe, DS_POPUP_LEFT);
2220 }
2221 gtk_window_set_focus(GTK_WINDOW(X->kframe), GTK_WIDGET(X->aframe_ch));
2222 gtk_widget_show(X->aframe);
2223 }
2224
2225
2226 static void
2227 show_precision_frame() /* Display Set Precision popup. */
2228 {
2229 if (!GTK_WIDGET_VISIBLE(X->spframe)) {
2230 ds_position_popup(X->kframe, X->spframe, DS_POPUP_LEFT);
2231 }
2232 gtk_window_set_focus(GTK_WINDOW(X->spframe), GTK_WIDGET(X->spframe_val));
2233 gtk_widget_show(X->spframe);
2234 }
2235
2236
2237 /* Handle menu bar menu selection. */
2238
2239 /*ARGSUSED*/
2240 static void
2241 edit_cb(GtkWidget *widget)
2242 {
2243 gboolean can_paste;
2244 gboolean can_copy;
2245
2246 if (!v->started) {
2247 return;
2248 }
2249
2250 can_copy = gtk_text_buffer_get_has_selection(X->display_buffer);
2251 can_paste = gtk_clipboard_wait_is_text_available(
2252 gtk_clipboard_get(X->clipboard_atom));
2253
2254 gtk_widget_set_sensitive(GTK_WIDGET(X->copy), can_copy);
2255 gtk_widget_set_sensitive(GTK_WIDGET(X->paste), can_paste);
2256 }
2257
2258
2259 static void
2260 handle_selection() /* Handle the GET function key being pressed. */
2261 {
2262 gtk_clipboard_request_text(gtk_clipboard_get(X->clipboard_atom),
2263 get_proc, NULL);
2264 }
2265
2266
2267 /*ARGSUSED*/
2268 static void
2269 popup_paste_cb(GtkMenuItem *menuitem)
2270 {
2271 handle_selection();
2272 }
2273
2274
2275 /*ARGSUSED*/
2276 static void
2277 copy_cb(GtkWidget *widget)
2278 {
2279 if (v->started) {
2280 get_display();
2281 }
2282 }
2283
2284
2285 /*ARGSUSED*/
2286 static void
2287 paste_cb(GtkWidget *widget)
2288 {
2289 if (v->started) {
2290 handle_selection();
2291 }
2292 }
2293
2294
2295 /*ARGSUSED*/
2296 static void
2297 undo_cb(GtkWidget *widget)
2298 {
2299 if (v->started) {
2300 perform_undo();
2301 refresh_display();
2302 }
2303 }
2304
2305
2306 /*ARGSUSED*/
2307 static void
2308 redo_cb(GtkWidget *widget)
2309 {
2310 if (v->started) {
2311 perform_redo();
2312 refresh_display();
2313 }
2314 }
2315
2316
2317 /*ARGSUSED*/
2318 static void
2319 for_each_menu(GtkWidget *widget, gpointer data)
2320 {
2321 /* Find the "Paste" entry and activate it (see bug #317786). */
2322 if (strcmp(G_OBJECT_TYPE_NAME(widget), "GtkImageMenuItem") == 0) {
2323 GtkWidget *label = gtk_bin_get_child(GTK_BIN(widget));
2324
2325 if (strcmp(gtk_label_get_text(GTK_LABEL(label)), _("Paste")) == 0) {
2326 if (gtk_clipboard_wait_is_text_available(
2327 gtk_clipboard_get(X->clipboard_atom))) {
2328 gtk_widget_set_sensitive(GTK_WIDGET(widget), TRUE);
2329 g_signal_connect(GTK_OBJECT(widget), "activate",
2330 G_CALLBACK(popup_paste_cb), NULL);
2331 }
2332 }
2333 }
2334 }
2335
2336
2337 /*ARGSUSED*/
2338 static void
2339 buffer_populate_popup_cb(GtkTextView *textview, GtkMenu *menu)
2340 {
2341 gtk_container_foreach(GTK_CONTAINER(menu), for_each_menu, NULL);
2342 }
2343
2344
2345 /*ARGSUSED*/
2346 static void
2347 insert_ascii_cb(GtkWidget *widget)
2348 {
2349 if (v->started) {
2350 show_ascii_frame();
2351 }
2352 }
2353
2354
2355 static void
2356 shift_left_cb(GtkWidget *widget)
2357 {
2358 int count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget),
2359 "shiftcount"));
2360
2361 if (v->started) {
2362 do_button(&buttons[KEY_SHIFT], count);
2363 }
2364 }
2365
2366
2367 static void
2368 shift_right_cb(GtkWidget *widget)
2369 {
2370 int count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget),
2371 "shiftcount"));
2372
2373 if (v->started) {
2374 do_button(&buttons[KEY_SHIFT], -count);
2375 }
2376 }
2377
2378 /*ARGSUSED*/
2379 static void
2380 show_bitcalculating_cb(GtkWidget *widget)
2381 {
2382 if (v->started) {
2383 v->bitcalculating_mode = v->bitcalculating_mode ^ 1;
2384 ui_set_mode(v->modetype);
2385 set_resource(R_BITCALC, Rcstr[v->bitcalculating_mode]);
2386 }
2387 }
2388
2389
2390 /*ARGSUSED*/
2391 static void
2392 show_registers_cb(GtkWidget *widget)
2393 {
2394 if (v->started) {
2395 v->rstate = !v->rstate;
2396 do_memory();
2397 }
2398 }
2399
2400
2401 /*ARGSUSED*/
2402 static void
2403 arithmetic_mode_cb(GtkWidget *widget)
2404 {
2405 struct exprm_state *e;
2406
2407 if (!v->started) {
2408 return;
2409 }
2410
2411 /* TODO: Always do clear things when mode is changed. */
2412
2413 v->syntax = v->syntax ^ 1;
2414 switch (v->syntax) {
2415 case NPA:
2416 v->noparens = 0;
2417 MPstr_to_num("0", DEC, v->MPdisp_val);
2418 show_display(v->MPdisp_val);
2419 ui_set_statusbar(_("Activated no operator precedence mode"), "");
2420 clear_undo_history();
2421 break;
2422
2423 case EXPRS:
2424 e = get_state();
2425 MPstr_to_num("0", DEC, e->ans);
2426 exp_del();
2427 show_display(e->ans);
2428 ui_set_statusbar(
2429 _("Activated expression mode with operator precedence"), "");
2430 break;
2431
2432 default:
2433 assert(0);
2434 }
2435 set_resource(R_SYNTAX, Rsstr[v->syntax]);
2436 ui_set_mode(v->modetype);
2437 // FIXME: We can't allow the display to be editable. See bug #326938
2438 gtk_text_view_set_editable(GTK_TEXT_VIEW(X->display_item),
2439 (v->syntax == EXPRS));
2440 }
2441
2442
2443 /*ARGSUSED*/
2444 static void
2445 mode_radio_cb(GtkWidget *radio)
2446 {
2447 struct exprm_state *e;
2448 int immediate = 0; /* Set if we can change mode without warning user. */
2449 int complete = 0; /* Set if the user has completed a calculation. */
2450
2451 if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(radio))) {
2452 return;
2453 }
2454
2455 if (!v->started) {
2456 return;
2457 }
2458
2459 X->mode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(radio), "calcmode"));
2460
2461 /* If the user has completed a calculation and we are going to a
2462 * new mode that is "compatible" with this one, then just change
2463 * modes. Otherwise display a dialog warning the user that the
2464 * current calculation will be cleared.
2465 *
2466 * Incompatible modes are:
2467 *
2468 * Scientific -> Basic
2469 * Scientific -> Advanced
2470 * Scientific -> Financial
2471 *
2472 * (unless we are in Scientific mode with Decimal numeric base and Fixed).
2473 */
2474
2475 switch (v->syntax) {
2476 case NPA:
2477 if (v->old_cal_value < 0 ||
2478 v->old_cal_value == KEY_CALCULATE) {
2479 complete = 1; /* Calculation is complete. */
2480 }
2481 break;
2482
2483 case EXPRS:
2484 e = get_state();
2485 if (!e->expression || !strcmp(e->expression, "Ans")) {
2486 complete = 1; /* Calculation is complete. */
2487 }
2488 break;
2489
2490 default:
2491 assert(FALSE);
2492 }
2493
2494 if (complete) {
2495 if ((v->modetype != SCIENTIFIC) ||
2496 (v->dtype == FIX && v->base == DEC)) {
2497 immediate = 1;
2498 }
2499 }
2500
2501 if (immediate) {
2502 v->modetype = X->mode;
2503 reset_mode_display();
2504 do_mode(FALSE);
2505 } else {
2506 if (v->warn_change_mode) {
2507 show_change_mode_dialog();
2508 } else {
2509 change_mode(X->mode);
2510 }
2511 }
2512 }
2513
2514
2515 /*ARGSUSED*/
2516 static void
2517 accuracy_radio_cb(GtkWidget *widget)
2518 {
2519 int count;
2520
2521 count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "accuracy"));
2522
2523 if (v->started &&
2524 gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
2525 do_accuracy(count);
2526 }
2527 }
2528
2529
2530 /*ARGSUSED*/
2531 static void
2532 accuracy_other_cb(GtkWidget *widget)
2533 {
2534 if (v->started) {
2535 show_precision_frame();
2536 }
2537 }
2538
2539
2540 /*ARGSUSED*/
2541 static void
2542 show_trailing_zeroes_cb(GtkWidget *widget)
2543 {
2544 if (!v->doing_mi) {
2545 v->show_zeroes = gtk_check_menu_item_get_active(
2546 GTK_CHECK_MENU_ITEM(widget));
2547
2548 syntaxdep_show_display();
2549 set_boolean_resource(R_ZEROES, v->show_zeroes == TRUE);
2550 ui_make_registers();
2551
2552 set_show_zeroes_toggle(v->show_zeroes);
2553 }
2554 }
2555
2556
2557 /*ARGSUSED*/
2558 static void
2559 quit_cb(GtkWidget *widget)
2560 {
2561 save_win_position();
2562 gtk_main_quit();
2563 }
2564
2565
2566 /*ARGSUSED*/
2567 static void
2568 spframe_cancel_cb(GtkButton *button)
2569 {
2570 gtk_widget_hide(X->spframe);
2571 }
2572
2573
2574 /*ARGSUSED*/
2575 static gboolean
2576 spframe_key_cb(GtkWidget *widget, GdkEventKey *event)
2577 {
2578 if (event->keyval == GDK_minus) {
2579 ui_set_statusbar(_("Accuracy value out of range"),
2580 "gtk-dialog-error");
2581 ui_beep();
2582 } else if (event->keyval == GDK_Escape) {
2583 gtk_widget_hide(X->spframe);
2584 }
2585
2586 return(FALSE);
2587 }
2588
2589
2590 /*ARGSUSED*/
2591 static void
2592 spframe_ok_cb(GtkButton *button)
2593 {
2594 int val = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(X->spframe_val));
2595
2596 v->accuracy = val;
2597
2598 set_int_resource(R_ACCURACY, v->accuracy);
2599
2600 ui_set_accuracy(v->accuracy);
2601
2602 ui_make_registers();
2603 refresh_display();
2604
2605 gtk_widget_hide(X->spframe);
2606 }
2607
2608
2609 /*ARGSUSED*/
2610 void
2611 trig_cb(GtkWidget *widget)
2612 {
2613 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
2614 do_trigtype((enum trig_type) g_object_get_data(G_OBJECT(widget),
2615 "trig_mode"));
2616 }
2617
2618
2619 void
2620 ui_start()
2621 {
2622 struct exprm_state *e;
2623
2624 v->started = 1;
2625 ui_set_base(v->base);
2626 ui_set_trigonometric_mode(v->ttype);
2627 ui_set_numeric_mode(v->dtype);
2628
2629 gtk_widget_show(X->kframe);
2630
2631 switch (v->syntax) {
2632 case NPA:
2633 break;
2634
2635 case EXPRS:
2636 /* Init expression mode.
2637 * This must be executed after do_base is called at init.
2638 * FIXME: The init code here is duplicated elsewhere.
2639 */
2640 e = get_state();
2641 MPstr_to_num("0", DEC, e->ans);
2642 exp_del();
2643 show_display(e->ans);
2644 break;
2645
2646 default:
2647 assert(0);
2648 }
2649
2650 gtk_main();
2651 }
2652
2653
2654 /*ARGSUSED*/
2655 static void
2656 show_thousands_separator_cb(GtkWidget *widget)
2657 {
2658 if (!v->started) {
2659 return;
2660 }
2661
2662 v->show_tsep = !v->show_tsep;
2663
2664 syntaxdep_show_display();
2665 set_boolean_resource(R_TSEP, v->show_tsep == TRUE);
2666 ui_make_registers();
2667 }
2668
2669
2670 /*ARGSUSED*/
2671 static void
2672 edit_constants_cb(GtkMenuItem *item)
2673 {
2674 gtk_widget_show(X->con_dialog);
2675 }
2676
2677
2678 /*ARGSUSED*/
2679 static void
2680 edit_functions_cb(GtkMenuItem *item)
2681 {
2682 gtk_widget_show(X->fun_dialog);
2683 }
2684
2685
2686 static void
2687 create_kframe()
2688 {
2689 int i;
2690 char name[MAXLINE];
2691 GtkWidget *widget;
2692 PangoFontDescription *font_desc;
2693 GtkSizeGroup *size_group;
2694 GtkAccelGroup *accel_group;
2695 GtkWidget *treeview;
2696
2697 X->ui = glade_xml_new(UI_FILE, NULL, NULL);
2698 if (X->ui == NULL) {
2699 GtkWidget *dialog;
2700
2701 dialog = gtk_message_dialog_new(NULL, 0,
2702 GTK_MESSAGE_ERROR,
2703 GTK_BUTTONS_NONE,
2704 N_("Error loading user interface"));
2705 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
2706 N_("The user interace file %s is missing or unable to be loaded. Please check your installation."), UI_FILE);
2707 gtk_dialog_add_buttons(GTK_DIALOG(dialog), GTK_STOCK_QUIT, GTK_RESPONSE_ACCEPT, NULL);
2708
2709 gtk_dialog_run(GTK_DIALOG(dialog));
2710 exit(0);
2711 }
2712
2713 /* When connecting up signals, would ideally use autoconnect but not
2714 * sure how to get the build process working.
2715 * See http://library.gnome.org/devel/libglade/unstable and
2716 * http://www.jamesh.id.au/software/libglade/
2717 * for some information on how to get this to work
2718 * glade_xml_signal_autoconnect(X->ui);
2719 */
2720 CONNECT_SIGNAL(kframe_key_press_cb);
2721 CONNECT_SIGNAL(button_cb);
2722 CONNECT_SIGNAL(menu_item_select_cb);
2723 CONNECT_SIGNAL(menu_item_deselect_cb);
2724 CONNECT_SIGNAL(mode_radio_cb);
2725 CONNECT_SIGNAL(inv_cb);
2726 CONNECT_SIGNAL(hyp_cb);
2727 CONNECT_SIGNAL(trig_cb);
2728 CONNECT_SIGNAL(base_cb);
2729 CONNECT_SIGNAL(disp_cb);
2730 CONNECT_SIGNAL(quit_cb);
2731 CONNECT_SIGNAL(edit_cb);
2732 CONNECT_SIGNAL(copy_cb);
2733 CONNECT_SIGNAL(paste_cb);
2734 CONNECT_SIGNAL(insert_ascii_cb);
2735 CONNECT_SIGNAL(undo_cb);
2736 CONNECT_SIGNAL(redo_cb);
2737 CONNECT_SIGNAL(help_cb);
2738 CONNECT_SIGNAL(about_cb);
2739 CONNECT_SIGNAL(show_trailing_zeroes_cb);
2740 CONNECT_SIGNAL(show_thousands_separator_cb);
2741 CONNECT_SIGNAL(show_bitcalculating_cb);
2742 CONNECT_SIGNAL(show_registers_cb);
2743 CONNECT_SIGNAL(accuracy_radio_cb);
2744 CONNECT_SIGNAL(accuracy_other_cb);
2745 CONNECT_SIGNAL(arithmetic_mode_cb);
2746 CONNECT_SIGNAL(mouse_button_cb);
2747 CONNECT_SIGNAL(display_focus_in_cb);
2748 CONNECT_SIGNAL(display_focus_out_cb);
2749 /* Detect when populating the right-click menu to enable pasting */
2750 CONNECT_SIGNAL(buffer_populate_popup_cb);
2751 CONNECT_SIGNAL(shift_left_cb);
2752 CONNECT_SIGNAL(shift_right_cb);
2753 CONNECT_SIGNAL(bit_toggle_cb);
2754 CONNECT_SIGNAL(aframe_delete_cb);
2755 CONNECT_SIGNAL(aframe_ok_cb);
2756 CONNECT_SIGNAL(aframe_cancel_cb);
2757 CONNECT_SIGNAL(aframe_key_cb);
2758 CONNECT_SIGNAL(spframe_delete_cb);
2759 CONNECT_SIGNAL(spframe_ok_cb);
2760 CONNECT_SIGNAL(spframe_cancel_cb);
2761 CONNECT_SIGNAL(spframe_key_cb);
2762 CONNECT_SIGNAL(rframe_delete_cb);
2763 CONNECT_SIGNAL(rframe_response_cb);
2764 CONNECT_SIGNAL(edit_constants_cb);
2765 CONNECT_SIGNAL(edit_functions_cb);
2766 CONNECT_SIGNAL(edit_constants_response_cb);
2767 CONNECT_SIGNAL(edit_functions_response_cb);
2768
2769 X->kframe = GET_WIDGET("calc_window");
2770 X->aframe = GET_WIDGET("ascii_window");
2771 X->aframe_ch = GET_WIDGET("ascii_entry");
2772 X->spframe = GET_WIDGET("precision_dialog");
2773 X->spframe_val = GET_WIDGET("spframe_spin");
2774 X->rframe = GET_WIDGET("register_dialog");
2775 X->con_dialog = GET_WIDGET("edit_constants_dialog");
2776 X->fun_dialog = GET_WIDGET("edit_functions_dialog");
2777 X->menubar = GET_WIDGET("menubar");
2778 X->scrolledwindow = GET_WIDGET("display_scroll"),
2779 X->display_item = GET_WIDGET("displayitem"),
2780 X->bas_panel = GET_WIDGET("basic_panel");
2781 X->sci_panel = GET_WIDGET("scientific_panel");
2782 X->adv_panel = GET_WIDGET("advanced_panel");
2783 X->fin_panel = GET_WIDGET("financial_panel");
2784 X->clear_buttons[0] = GET_WIDGET("calc_clear_simple_button");
2785 X->clear_buttons[1] = GET_WIDGET("calc_clear_advanced_button");
2786 X->mode_panel = GET_WIDGET("mode_panel");
2787 X->trig[0] = GET_WIDGET("degrees_radio");
2788 X->trig[1] = GET_WIDGET("gradians_radio");
2789 X->trig[2] = GET_WIDGET("radians_radio");
2790 X->base[0] = GET_WIDGET("binary_radio");
2791 X->base[1] = GET_WIDGET("octal_radio");
2792 X->base[2] = GET_WIDGET("decimal_radio");
2793 X->base[3] = GET_WIDGET("hexadecimal_radio");
2794 X->disp[0] = GET_WIDGET("engineering_radio");
2795 X->disp[1] = GET_WIDGET("fixed_point_radio");
2796 X->disp[2] = GET_WIDGET("scientific_radio");
2797 X->inv = GET_WIDGET("inverse_check");
2798 X->hyp = GET_WIDGET("hyperbolic_check");
2799 X->bit_panel = GET_WIDGET("bit_panel");
2800 X->statusbar = GET_WIDGET("statusbar");
2801 X->undo = GET_WIDGET("undo_menu");
2802 X->redo = GET_WIDGET("redo_menu");
2803 X->copy = GET_WIDGET("copy_menu");
2804 X->paste = GET_WIDGET("paste_menu");
2805 for (i = 0; i < 16; i++) {
2806 SNPRINTF(name, MAXLINE, "calc_%x_button", i);
2807 X->digit_buttons[i] = GET_WIDGET(name);
2808 }
2809 for (i = 0; i < MAXREGS; i++) {
2810 SNPRINTF(name, MAXLINE, "register_entry_%d", i);
2811 X->regs[i] = GET_WIDGET(name);
2812 }
2813
2814 /* Load buttons and set them all to be the same size */
2815 size_group = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
2816 for (i = 0; i < NBUTTONS; i++) {
2817 SNPRINTF(name, MAXLINE, "calc_%s_button",
2818 button_widgets[i].widget_name);
2819 X->buttons[i] = GET_WIDGET(name);
2820 assert(X->buttons[i] != NULL);
2821
2822 gtk_size_group_add_widget(size_group, X->buttons[i]);
2823
2824 g_object_set_data(G_OBJECT(X->buttons[i]), "button",
2825 &buttons[button_widgets[i].key]);
2826 g_object_set_data(G_OBJECT(X->buttons[i]), "mtype",
2827 GINT_TO_POINTER(button_widgets[i].mtype));
2828 }
2829
2830 /* Load bit panel */
2831 for (i = 0; i < MAXBITS; i++)
2832 {
2833 SNPRINTF(name, MAXLINE, "bit_label_%d", i);
2834 X->bits[i] = GET_WIDGET(name);
2835 SNPRINTF(name, MAXLINE, "bit_eventbox_%d", i);
2836 g_object_set_data(G_OBJECT(GET_WIDGET(name)),
2837 "bit_index", GINT_TO_POINTER(i));
2838 }
2839
2840 /* Make menu tooltips displayed in the status bar */
2841 set_menubar_tooltip("quit_menu");
2842 set_menubar_tooltip("copy_menu");
2843 set_menubar_tooltip("paste_menu");
2844 set_menubar_tooltip("insert_ascii_menu");
2845 set_menubar_tooltip("undo_menu");
2846 set_menubar_tooltip("redo_menu");
2847 set_menubar_tooltip("view_basic_menu");
2848 set_menubar_tooltip("view_advanced_menu");
2849 set_menubar_tooltip("view_financial_menu");
2850 set_menubar_tooltip("view_scientific_menu");
2851 set_menubar_tooltip("show_trailing_zeroes_menu");
2852 set_menubar_tooltip("show_thousands_separator_menu");
2853 set_menubar_tooltip("show_bitcalculating_menu");
2854 set_menubar_tooltip("show_registers_menu");
2855 set_menubar_tooltip("ltr_precedence_menu");
2856 set_menubar_tooltip("arithmetic_precedence_menu");
2857 set_menubar_tooltip("help_menu");
2858 set_menubar_tooltip("about_menu");
2859
2860 // ???
2861 widget = GET_WIDGET("kvbox");
2862 gtk_widget_set_direction(widget, GTK_TEXT_DIR_LTR);
2863 gtk_widget_set_direction(X->fin_panel, GTK_TEXT_DIR_LTR);
2864
2865 /* Make dialogs transient of the main window */
2866 gtk_window_set_transient_for(GTK_WINDOW(X->aframe), GTK_WINDOW(X->kframe));
2867 gtk_window_set_transient_for(GTK_WINDOW(X->spframe), GTK_WINDOW(X->kframe));
2868 gtk_window_set_transient_for(GTK_WINDOW(X->rframe), GTK_WINDOW(X->kframe));
2869 gtk_window_set_transient_for(GTK_WINDOW(X->con_dialog),
2870 GTK_WINDOW(X->kframe));
2871
2872 gtk_spin_button_set_value(GTK_SPIN_BUTTON(X->spframe_val),
2873 (double) v->accuracy); // FIXME
2874 gtk_entry_set_max_length(GTK_ENTRY(X->spframe_val), 2);
2875
2876 gtk_dialog_set_default_response(GTK_DIALOG(X->con_dialog),
2877 GTK_RESPONSE_ACCEPT);
2878
2879 /* Make constant tree model */
2880 X->constants_model = create_cf_model(M_CON, X->con_dialog);
2881 treeview = GET_WIDGET("edit_constants_treeview");
2882 gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), X->constants_model);
2883 gtk_tree_selection_set_mode(
2884 gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
2885 GTK_SELECTION_SINGLE);
2886 add_cf_column(GTK_TREE_VIEW(treeview), _("No."),
2887 COLUMN_NUMBER, FALSE);
2888 add_cf_column(GTK_TREE_VIEW(treeview), _("Value"),
2889 COLUMN_VALUE, TRUE);
2890 add_cf_column(GTK_TREE_VIEW(treeview), _("Description"),
2891 COLUMN_DESCRIPTION, TRUE);
2892
2893 /* Make function tree model */
2894 X->functions_model = create_cf_model(M_FUN, X->fun_dialog);
2895 treeview = GET_WIDGET("edit_functions_treeview");
2896 gtk_dialog_set_default_response(GTK_DIALOG(X->fun_dialog),
2897 GTK_RESPONSE_ACCEPT);
2898 gtk_window_set_transient_for(GTK_WINDOW(X->fun_dialog),
2899 GTK_WINDOW(X->kframe));
2900 gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), X->functions_model);
2901 gtk_tree_selection_set_mode(
2902 gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
2903 GTK_SELECTION_SINGLE);
2904 add_cf_column(GTK_TREE_VIEW(treeview), _("No."),
2905 COLUMN_NUMBER, FALSE);
2906 add_cf_column(GTK_TREE_VIEW(treeview), _("Value"),
2907 COLUMN_VALUE, TRUE);
2908 add_cf_column(GTK_TREE_VIEW(treeview), _("Description"),
2909 COLUMN_DESCRIPTION, TRUE);
2910
2911
2912 X->display_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(X->display_item));
2913 gtk_widget_ensure_style(X->display_item);
2914 font_desc = pango_font_description_copy(X->display_item->style->font_desc);
2915 pango_font_description_set_size(font_desc, 16 * PANGO_SCALE);
2916 gtk_widget_modify_font(X->display_item, font_desc);
2917 pango_font_description_free(font_desc);
2918 gtk_widget_set_name(X->display_item, "displayitem");
2919 // FIXME: We can't allow the display to be editable. See bug #326938
2920 gtk_text_view_set_editable(GTK_TEXT_VIEW(X->display_item),
2921 (v->syntax == EXPRS));
2922 atk_object_set_role(gtk_widget_get_accessible(X->display_item),
2923 ATK_ROLE_EDITBAR);
2924
2925 gtk_widget_realize(X->kframe);
2926 set_win_position();
2927
2928 for (i = 0; i < 3; i++)
2929 g_object_set_data(G_OBJECT(X->trig[i]),
2930 "trig_mode", GINT_TO_POINTER(i));
2931 for (i = 0; i < 4; i++)
2932 g_object_set_data(G_OBJECT(X->base[i]),
2933 "base_mode", GINT_TO_POINTER(i));
2934 for (i = 0; i < 3; i++)
2935 g_object_set_data(G_OBJECT(X->disp[i]),
2936 "numeric_mode", GINT_TO_POINTER(i));
2937
2938 /* Put status image into statusbar (glade doesn't support child widgets
2939 * in statusbars) */
2940 X->status_image = gtk_image_new_from_stock("", GTK_ICON_SIZE_BUTTON);
2941 gtk_widget_show(X->status_image);
2942 gtk_box_pack_start(GTK_BOX(X->statusbar), X->status_image, FALSE, TRUE, 0);
2943
2944 /* Set modes for menu items */
2945 for (i = 1; i < 16; i++) {
2946 SNPRINTF(name, MAXLINE, "shift_left%d_menu", i);
2947 g_object_set_data(G_OBJECT(GET_WIDGET(name)),
2948 "shiftcount", GINT_TO_POINTER(i));
2949 SNPRINTF(name, MAXLINE, "shift_right%d_menu", i);
2950 g_object_set_data(G_OBJECT(GET_WIDGET(name)),
2951 "shiftcount", GINT_TO_POINTER(i));
2952 }
2953 g_object_set_data(G_OBJECT(GET_WIDGET("view_basic_menu")),
2954 "calcmode", GINT_TO_POINTER(BASIC));
2955 g_object_set_data(G_OBJECT(GET_WIDGET("view_advanced_menu")),
2956 "calcmode", GINT_TO_POINTER(ADVANCED));
2957 g_object_set_data(G_OBJECT(GET_WIDGET("view_financial_menu")),
2958 "calcmode", GINT_TO_POINTER(FINANCIAL));
2959 g_object_set_data(G_OBJECT(GET_WIDGET("view_scientific_menu")),
2960 "calcmode", GINT_TO_POINTER(SCIENTIFIC));
2961
2962 /* Make shortcuts for accuracy menus */
2963 accel_group = gtk_accel_group_new();
2964 gtk_window_add_accel_group(GTK_WINDOW(X->kframe), accel_group);
2965 for (i = 0; i < 10; i++) {
2966 SNPRINTF(name, MAXLINE, "acc_item%d", i);
2967 widget = GET_WIDGET(name);
2968 g_object_set_data(G_OBJECT(widget), "accuracy", GINT_TO_POINTER(i));
2969 }
2970 }
2971
2972
2973 static GtkWidget *
2974 create_menu_item_with_markup(char *label, int menu_no, int index)
2975 {
2976 GtkWidget *accel_label;
2977 GtkWidget *menu_item;
2978
2979 accel_label = gtk_label_new(NULL);
2980 gtk_label_set_markup_with_mnemonic(GTK_LABEL(accel_label), label);
2981 gtk_misc_set_alignment(GTK_MISC(accel_label), 0.0, 0.5);
2982 menu_item = gtk_menu_item_new();
2983 gtk_container_add(GTK_CONTAINER(menu_item), accel_label);
2984 gtk_widget_show(accel_label);
2985 gtk_widget_show(menu_item);
2986
2987 g_object_set_data(G_OBJECT(menu_item), "button", X->mrec[menu_no]);
2988 gtk_menu_shell_append(GTK_MENU_SHELL(X->menus[menu_no]), menu_item);
2989
2990 g_signal_connect(G_OBJECT(menu_item), "activate",
2991 G_CALLBACK(menu_proc_cb), GINT_TO_POINTER(index));
2992
2993 return menu_item;
2994 }
2995
2996
2997 static void
2998 read_cfdefs() /* Read constant/function definitions. */
2999 {
3000 int n;
3001
3002 for (n = 0; n < MAXCONFUN; n++) {
3003 get_constant(n);
3004 STRCPY(v->fun_vals[n], ""); /* Initially empty function strings. */
3005 get_function(n);
3006 }
3007 }
3008
3009
3010 void
3011 ui_init(int *argc, char ***argv)
3012 {
3013 X = (XVars) LINT_CAST(calloc(1, sizeof(struct Xobject)));
3014
3015 gtk_init(argc, argv);
3016
3017 X->lnp = ui_get_localized_numeric_point();
3018
3019 gtk_rc_get_default_files();
3020
3021 v->home = (char *) g_get_home_dir();
3022 gtk_rc_parse(g_build_path(v->home, RCNAME, NULL));
3023
3024 gtk_window_set_default_icon_name("gnome-calculator");
3025 }
3026
3027 void
3028 ui_load()
3029 {
3030 int i;
3031 GtkWidget *widget;
3032
3033 read_cfdefs();
3034
3035 X->clipboard_atom = gdk_atom_intern("CLIPBOARD", FALSE);
3036 X->primary_atom = gdk_atom_intern("PRIMARY", FALSE);
3037 create_kframe(); /* Create main gcalctool window. */
3038
3039 X->menus[M_ACC] = GET_WIDGET("accuracy_popup");
3040 X->mrec[M_ACC] = &buttons[KEY_SET_ACCURACY];
3041 X->menus[M_LSHF] = GET_WIDGET("left_shift_popup");
3042 X->mrec[M_LSHF] = &buttons[KEY_SHIFT];
3043 X->menus[M_RSHF] = GET_WIDGET("right_shift_popup");
3044 X->mrec[M_RSHF] = &buttons[KEY_SHIFT];
3045
3046 X->menus[M_CON] = GET_WIDGET("constants_popup");
3047 X->mrec[M_CON] = &buttons[KEY_CONSTANT];
3048 X->menus[M_FUN] = GET_WIDGET("functions_popup");
3049 X->mrec[M_FUN] = &buttons[KEY_FUNCTION];
3050 for (i = 0; i < MAXCONFUN; i++) {
3051 X->constant_menu_items[i] = create_menu_item_with_markup("", M_CON, i);
3052 X->function_menu_items[i] = create_menu_item_with_markup("", M_FUN, i);
3053 }
3054
3055 X->menus[M_STO] = GET_WIDGET("memory_store_popup");
3056 X->mrec[M_STO] = &buttons[KEY_STORE];
3057 X->menus[M_RCL] = GET_WIDGET("memory_recall_popup");
3058 X->mrec[M_RCL] = &buttons[KEY_RECALL];
3059 X->menus[M_EXCH] = GET_WIDGET("memory_exchange_popup");
3060 X->mrec[M_EXCH] = &buttons[KEY_EXCHANGE];
3061 for (i = 0; i < MAXREGS; i++) {
3062 // FIXME: These labels should be replaced with GtkTreeModel labels
3063 X->memory_store_items[i] = create_menu_item_with_markup("", M_STO, i);
3064 X->memory_recall_items[i] = create_menu_item_with_markup("", M_RCL, i);
3065 X->memory_exchange_items[i] = create_menu_item_with_markup("", M_EXCH, i);
3066 }
3067
3068 // This matches existing behaviour we can't do in Glade. But is it needed?
3069 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_ACC]), 1);
3070 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_LSHF]), 1);
3071 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_RSHF]), 1);
3072 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_CON]), 1);
3073 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_FUN]), 1);
3074 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_STO]), 1);
3075 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_RCL]), 1);
3076 gtk_container_set_border_width(GTK_CONTAINER(X->menus[M_EXCH]), 1);
3077
3078 set_show_tsep_toggle(v->show_tsep);
3079 set_show_zeroes_toggle(v->show_zeroes);
3080 set_show_bitcalculating_toggle(v->bitcalculating_mode);
3081 set_memory_toggle(v->rstate);
3082
3083 /* Use loaded Arithmetic Precedence mode setting. */
3084 if (v->syntax == EXPRS) {
3085 widget = GET_WIDGET("arithmetic_precedence_menu");
3086 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
3087 } else {
3088 widget = GET_WIDGET("ltr_precedence_menu");
3089 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
3090 }
3091
3092 ui_set_display("0.00", FALSE);
3093 ui_set_mode(v->modetype);
3094 ui_set_numeric_mode(FIX);
3095 ui_set_base(v->base);
3096 ui_set_accuracy(v->accuracy);
3097 ui_set_undo_enabled(FALSE, FALSE);
3098 ui_update_trig_mode();
3099
3100 /* Show the memory register window? */
3101 ui_make_registers();
3102 if (v->rstate == TRUE) {
3103 ui_set_registers_visible(TRUE);
3104 }
3105
3106 /* Focus on the clear button */
3107 if (v->modetype == BASIC) {
3108 gtk_window_set_focus(GTK_WINDOW(X->kframe),
3109 GTK_WIDGET(X->clear_buttons[0]));
3110 } else {
3111 gtk_window_set_focus(GTK_WINDOW(X->kframe),
3112 GTK_WIDGET(X->clear_buttons[1]));
3113 }
3114 }
gcalctool mirror