find-dialog.c: Replace exp10 with our own integer version
[pspp] / src / ui / gui / psppire-keypad.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2007, 2010, 2011, 2015 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18 #include <gtk/gtk.h>
19 #include <gdk/gdkkeysyms.h>
20 #include "psppire-keypad.h"
21
22 enum {
23   INSERT_SYNTAX,
24   ERASE,
25   n_SIGNALS
26 };
27
28 static void psppire_keypad_class_init          (PsppireKeypadClass *klass);
29 static void psppire_keypad_init                (PsppireKeypad      *kp);
30
31 static guint keypad_signals [n_SIGNALS] = { 0 };
32
33 GType
34 psppire_keypad_get_type (void)
35 {
36   static GType kp_type = 0;
37
38   if (!kp_type)
39     {
40       static const GTypeInfo kp_info =
41       {
42         sizeof (PsppireKeypadClass),
43         NULL, /* base_init */
44         NULL, /* base_finalize */
45         (GClassInitFunc) psppire_keypad_class_init,
46         NULL, /* class_finalize */
47         NULL, /* class_data */
48         sizeof (PsppireKeypad),
49         0,
50         (GInstanceInitFunc) psppire_keypad_init,
51       };
52
53       kp_type = g_type_register_static (GTK_TYPE_EVENT_BOX, "PsppireKeypad",
54                                         &kp_info, 0);
55     }
56
57   return kp_type;
58 }
59
60 static GObjectClass * parent_class = NULL;
61
62 static void
63 psppire_keypad_dispose (GObject *obj)
64 {
65   PsppireKeypad *kp = (PsppireKeypad *)obj;
66
67   if (kp->dispose_has_run)
68     return;
69
70   /* Make sure dispose does not run twice. */
71   kp->dispose_has_run = TRUE;
72
73   g_hash_table_unref (kp->frag_table);
74
75   /* Chain up to the parent class */
76   G_OBJECT_CLASS (parent_class)->dispose (obj);
77 }
78
79 static void
80 psppire_keypad_finalize (GObject *obj)
81 {
82    /* Chain up to the parent class */
83    G_OBJECT_CLASS (parent_class)->finalize (obj);
84 }
85
86 static void
87 psppire_keypad_class_init (PsppireKeypadClass *klass)
88 {
89   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
90
91   parent_class = g_type_class_peek_parent (klass);
92
93   gobject_class->dispose = psppire_keypad_dispose;
94   gobject_class->finalize = psppire_keypad_finalize;
95
96   keypad_signals[INSERT_SYNTAX] = g_signal_new ("insert-syntax",
97                                          G_TYPE_FROM_CLASS (klass),
98                                          G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
99                                          G_STRUCT_OFFSET (PsppireKeypadClass,
100                                                           keypad),
101                                          NULL,
102                                          NULL,
103                                          g_cclosure_marshal_VOID__STRING,
104                                          G_TYPE_NONE, 1,
105                                          G_TYPE_STRING);
106
107   keypad_signals[ERASE] = g_signal_new ("erase",
108                                          G_TYPE_FROM_CLASS (klass),
109                                          G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
110                                          G_STRUCT_OFFSET (PsppireKeypadClass,
111                                                           keypad),
112                                          NULL,
113                                          NULL,
114                                          g_cclosure_marshal_VOID__VOID,
115                                          G_TYPE_NONE, 0);
116 }
117
118
119 /*
120    These are the strings that will be arguments to
121    the emitted signals.
122    The order of these must correspond
123    to the order of the button declarations
124 */
125 static const char * const keypad_insert_text[] = {
126   "0",  "1",  "2", "3", "4", "5", "6", "7", "8", "9",
127   ".", "+", "-", "*", "**", "/", "=", "<>", "<", "<=",
128   ">", ">=", "&", "|", "~", "()", NULL
129 };
130
131
132 /* Callback for any button click.
133    Emits the "insert-syntax" signal for the keypad,
134    with the string corresponding to the clicked button.
135 */
136 static void
137 button_click (GtkButton *b, PsppireKeypad *kp)
138 {
139   const gchar *s = g_hash_table_lookup (kp->frag_table, b);
140
141
142   if (s)
143     g_signal_emit (kp, keypad_signals [INSERT_SYNTAX], 0, s);
144   else
145     g_signal_emit (kp, keypad_signals [ERASE], 0);
146 }
147
148 static const gint cols = 6;
149 static const gint rows = 5;
150
151
152
153 /* Add BUTTON to KP.  The top-left corner at X1,Y1, the
154    botton-right corner at X2,Y2 */
155 static void
156 add_button (PsppireKeypad *kp, GtkWidget **button,
157             gint x1, gint x2,
158             gint y1, gint y2)
159 {
160   g_object_set (G_OBJECT (*button), "focus-on-click", FALSE, NULL);
161
162   gtk_grid_attach (GTK_GRID(kp->table), *button, x1, y1, x2 - x1, y2 - y1);
163
164   gtk_widget_set_size_request (*button,
165                                30 * rows / (float) cols,
166                                30 * cols / (float) rows);
167
168   g_hash_table_insert (kp->frag_table, *button,
169                        (void *) keypad_insert_text[(button - &kp->digit[0])]);
170
171   g_signal_connect (*button, "clicked",
172                     G_CALLBACK (button_click), kp);
173
174   gtk_widget_show (*button);
175 }
176
177
178 /* Return  a  new button with CODE as the unicode character for its label */
179 static inline GtkWidget *
180 button_new_from_unicode (gunichar code)
181 {
182   char s[6] = {0,0,0,0,0,0};
183
184   g_unichar_to_utf8 (code, s);
185
186   return gtk_button_new_with_label (s);
187 }
188
189
190 /* Callback which occurs when the mouse enters the widget.
191    It sets or unsets the focus.
192 */
193 static gboolean
194 enter_leave_notify (GtkWidget   *widget,
195       GdkEventCrossing *event,
196       gpointer     user_data)
197 {
198   /* Do nothing if we're just moving between the widget and
199      its children */
200  if (event->detail == GDK_NOTIFY_INFERIOR)
201    return FALSE;
202
203  if (event->type == GDK_ENTER_NOTIFY)
204    gtk_widget_grab_focus (widget);
205
206  return FALSE;
207 }
208
209 static gboolean
210 key_release_callback (GtkWidget   *widget,
211                       GdkEventKey *event,
212                       gpointer     user_data)
213 {
214   if (! gtk_widget_has_focus (widget))
215     return FALSE;
216
217   switch (event->keyval)
218     {
219     case '(':
220       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "(");
221       break;
222     case ')':
223       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, ")");
224       break;
225     case '>':
226       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, ">");
227       break;
228     case '<':
229       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "<");
230       break;
231     case GDK_KEY_KP_Equal :
232     case '=':
233       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "=");
234       break;
235     case GDK_KEY_KP_Multiply :
236     case '*':
237       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "*");
238       break;
239     case GDK_KEY_KP_Add :
240     case '+':
241       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "+");
242       break;
243     case GDK_KEY_KP_Subtract :
244     case '-':
245       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "-");
246       break;
247     case GDK_KEY_KP_Decimal :
248     case '.':
249       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, ".");
250       break;
251     case GDK_KEY_KP_Divide :
252     case '/':
253       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "/");
254       break;
255     case GDK_KEY_KP_0 :
256     case '0':
257       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "0");
258       break;
259     case GDK_KEY_KP_1 :
260     case '1':
261       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "1");
262       break;
263     case GDK_KEY_KP_2 :
264     case '2':
265       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "2");
266       break;
267     case GDK_KEY_KP_3 :
268     case '3':
269       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "3");
270       break;
271     case GDK_KEY_KP_4 :
272     case '4':
273       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "4");
274       break;
275     case GDK_KEY_KP_5 :
276     case '5':
277       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "5");
278       break;
279     case GDK_KEY_KP_6 :
280     case '6':
281       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "6");
282       break;
283     case GDK_KEY_KP_7 :
284     case '7':
285       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "7");
286       break;
287     case GDK_KEY_KP_8 :
288     case '8':
289       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "8");
290       break;
291     case GDK_KEY_KP_9 :
292     case '9':
293       g_signal_emit (widget, keypad_signals [INSERT_SYNTAX], 0, "9");
294       break;
295      default:
296        break;
297     };
298
299   return FALSE;
300 }
301
302
303 static void
304 psppire_keypad_init (PsppireKeypad *kp)
305 {
306   gint i;
307   const int digit_voffset = 0;
308   const int digit_hoffset = 3;
309
310   gtk_widget_set_can_focus (GTK_WIDGET (kp), TRUE);
311
312   kp->dispose_has_run = FALSE;
313
314   g_signal_connect (kp, "enter-notify-event", G_CALLBACK (enter_leave_notify),
315                     NULL);
316
317   g_signal_connect (kp, "leave-notify-event", G_CALLBACK (enter_leave_notify),
318                     NULL);
319
320   g_signal_connect (kp, "key-release-event", G_CALLBACK (key_release_callback),
321                     NULL);
322
323   kp->frag_table = g_hash_table_new (g_direct_hash, g_direct_equal);
324
325   kp->table = gtk_grid_new ();
326
327   /* Buttons for the digits */
328   for (i = 0; i < 10; i++)
329     {
330       int j = i - 1;
331       char buf[5];
332       g_snprintf (buf, 5, "%d", i);
333       kp->digit[i] = gtk_button_new_with_label (buf);
334
335       if (i == 0)
336         add_button (kp, &kp->digit[i],
337                     digit_hoffset + 0, digit_hoffset + 2,
338                     digit_voffset + 3, digit_voffset + 4);
339       else
340         add_button (kp, &kp->digit[i],
341                     digit_hoffset + j % 3, digit_hoffset + j % 3 + 1,
342                     digit_voffset + 2 - (j / 3),
343                     digit_voffset + 2 - (j / 3) + 1);
344     }
345
346   /* ... all the other buttons */
347
348   kp->dot = button_new_from_unicode (0xB7);     /* MIDDLE DOT */
349   add_button (kp, &kp->dot, digit_hoffset + 2,
350               digit_hoffset + 3,
351               digit_voffset + 3,
352               digit_voffset + 4);
353
354   kp->plus  = gtk_button_new_with_label ("+");
355   add_button (kp, &kp->plus, 0, 1,
356               0,1);
357
358   kp->minus = button_new_from_unicode (0x2212); /* MINUS SIGN */
359   add_button (kp, &kp->minus, 0, 1,
360               1,2);
361
362   kp->star  = button_new_from_unicode (0xD7);   /* MULTIPLICATION SIGN */
363   add_button (kp, &kp->star, 0, 1,
364               2,3);
365
366   kp->slash = button_new_from_unicode (0xF7);   /* DIVISION SIGN */
367   add_button (kp, &kp->slash, 0, 1,
368               3,4);
369
370   {
371     GtkWidget *label;
372     char *markup =
373       g_markup_printf_escaped ("<span style=\"italic\">x<sup>y</sup></span>");
374
375     label = gtk_label_new ("**");
376
377     gtk_label_set_markup (GTK_LABEL (label), markup);
378     g_free (markup);
379
380     kp->star_star = gtk_button_new ();
381     gtk_container_add (GTK_CONTAINER (kp->star_star), label);
382
383     gtk_widget_show (label);
384
385     add_button (kp, &kp->star_star,
386                 0, 1,
387                 4, 5);
388   }
389
390
391   kp->gt = button_new_from_unicode (0x3E); /* GREATER-THAN SIGN*/
392   add_button (kp, &kp->gt, 2, 3,
393               0,1);
394
395   kp->lt = button_new_from_unicode (0x3C); /* LESS-THAN SIGN*/
396   add_button (kp, &kp->lt, 1, 2,
397               0,1);
398
399   kp->ge = button_new_from_unicode (0x2265); /* GREATER-THAN OR EQUAL */
400   add_button (kp, &kp->ge, 2, 3,
401               1,2);
402
403   kp->le = button_new_from_unicode (0x2264); /* LESS-THAN OR EQUAL */
404   add_button (kp, &kp->le, 1, 2,
405               1,2);
406
407   kp->neq = button_new_from_unicode (0x2260); /* NOT EQUAL */
408   add_button (kp, &kp->neq, 2, 3,
409               2,3);
410
411   kp->eq = gtk_button_new_with_label ("=");
412   add_button (kp, &kp->eq, 1, 2,
413               2,3);
414
415   kp->parentheses = gtk_button_new_with_label ("()");
416   add_button (kp, &kp->parentheses, 2, 3,
417               4,5);
418
419
420   kp->delete = gtk_button_new_with_label ("Delete");
421   add_button (kp, &kp->delete, 3, 6,
422               4,5);
423
424
425
426   kp->and = button_new_from_unicode (0x2227); /* LOGICAL AND */
427   add_button (kp, &kp->and, 1, 2,
428               3,4);
429
430
431   kp->or = button_new_from_unicode (0x2228); /* LOGICAL OR */
432   add_button (kp, &kp->or, 2, 3,
433               3,4);
434
435
436   kp->not = button_new_from_unicode (0xAC); /* NOT SIGN */
437   add_button (kp, &kp->not, 1, 2,
438               4,5);
439
440
441
442   g_object_set (G_OBJECT (kp->table), "row-spacing", 5, NULL);
443   g_object_set (G_OBJECT (kp->table), "column-spacing", 5, NULL);
444
445   gtk_container_add (GTK_CONTAINER (kp), kp->table);
446   gtk_widget_show (kp->table);
447
448   gtk_widget_add_events (GTK_WIDGET (kp),
449         GDK_KEY_RELEASE_MASK  |
450         GDK_LEAVE_NOTIFY_MASK |
451         GDK_ENTER_NOTIFY_MASK |
452         GDK_FOCUS_CHANGE_MASK);
453
454 }
455
456
457 GtkWidget*
458 psppire_keypad_new (void)
459 {
460   return GTK_WIDGET (g_object_new (psppire_keypad_get_type (), NULL));
461 }