CORRELATIONS: Fixed bug displaying non-sqaure correlation matrices
[pspp] / src / ui / gui / psppire-dialog.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2007, 2010, 2011, 2012  Free Software Foundation
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
18 #include <config.h>
19
20 #include <gtk/gtk.h>
21 #include "psppire-dialog.h"
22 #include "psppire-buttonbox.h"
23 #include "psppire-selector.h"
24 #include <string.h>
25 #include "builder-wrapper.h"
26 #include "help-menu.h"
27
28 #include "psppire-window-base.h"
29
30 static void psppire_dialog_class_init          (PsppireDialogClass *);
31 static void psppire_dialog_init                (PsppireDialog      *);
32
33
34 enum  {DIALOG_REFRESH,
35        RESPONSE,
36        VALIDITY_CHANGED,
37        DIALOG_HELP,
38        n_SIGNALS};
39
40 static guint signals [n_SIGNALS];
41
42
43 static void psppire_dialog_buildable_init (GtkBuildableIface *iface);
44
45
46 GType
47 psppire_dialog_get_type (void)
48 {
49   static GType dialog_type = 0;
50
51   if (!dialog_type)
52     {
53       static const GTypeInfo dialog_info =
54       {
55         sizeof (PsppireDialogClass),
56         NULL, /* base_init */
57         NULL, /* base_finalize */
58         (GClassInitFunc) psppire_dialog_class_init,
59         NULL, /* class_finalize */
60         NULL, /* class_data */
61         sizeof (PsppireDialog),
62         0,
63         (GInstanceInitFunc) psppire_dialog_init,
64       };
65
66       static const GInterfaceInfo buildable_info =
67       {
68         (GInterfaceInitFunc) psppire_dialog_buildable_init,
69         NULL,
70         NULL
71       };
72
73       dialog_type = g_type_register_static (PSPPIRE_TYPE_WINDOW_BASE,
74                                             "PsppireDialog", &dialog_info, 0);
75
76       g_type_add_interface_static (dialog_type,
77                                    GTK_TYPE_BUILDABLE,
78                                    &buildable_info);
79     }
80
81   return dialog_type;
82 }
83
84
85
86 static GObjectClass     *parent_class = NULL;
87
88
89 static void
90 psppire_dialog_finalize (GObject *object)
91 {
92   PsppireDialog *dialog ;
93
94   g_return_if_fail (object != NULL);
95   g_return_if_fail (PSPPIRE_IS_DIALOG (object));
96
97   dialog = PSPPIRE_DIALOG (object);
98
99   if (G_OBJECT_CLASS (parent_class)->finalize)
100     G_OBJECT_CLASS (parent_class)->finalize (object);
101 }
102
103
104
105 /* Properties */
106 enum
107 {
108   PROP_0,
109   PROP_ORIENTATION,
110   PROP_SLIDING
111 };
112
113
114 static void
115 psppire_dialog_get_property (GObject         *object,
116                              guint            prop_id,
117                              GValue          *value,
118                              GParamSpec      *pspec)
119 {
120   PsppireDialog *dialog = PSPPIRE_DIALOG (object);
121
122   switch (prop_id)
123     {
124     case PROP_ORIENTATION:
125       {
126         if ( GTK_IS_VBOX (dialog->box) || GTK_VPANED (dialog->box))
127           g_value_set_enum (value, PSPPIRE_VERTICAL);
128         else if ( GTK_IS_HBOX (dialog->box) || GTK_HPANED (dialog->box))
129           g_value_set_enum (value, PSPPIRE_HORIZONTAL);
130         else if ( GTK_IS_TABLE (dialog->box))
131           g_value_set_enum (value, PSPPIRE_TABULAR);
132       }
133       break;
134     case PROP_SLIDING:
135       g_value_set_boolean (value, dialog->slidable);
136       break;
137     default:
138       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
139       break;
140     };
141 }
142
143
144 static void
145 dialog_set_container (PsppireDialog *dialog)
146 {
147   if ( dialog->box != NULL)
148     {
149       gtk_container_remove (GTK_CONTAINER (dialog), dialog->box);
150     }
151
152   switch (dialog->orientation)
153     {
154     case PSPPIRE_HORIZONTAL:
155       if ( dialog->slidable)
156         dialog->box = gtk_hpaned_new();
157       else
158         dialog->box = gtk_hbox_new (FALSE, 5);
159       break;
160     case PSPPIRE_VERTICAL:
161       if ( dialog->slidable)
162         dialog->box = gtk_vpaned_new();
163       else
164         dialog->box = gtk_vbox_new (FALSE, 5);
165       break;
166     case PSPPIRE_TABULAR:
167       dialog->box = gtk_table_new (2, 3, FALSE);
168       g_object_set (dialog->box,
169                     "row-spacing", 5,
170                     "column-spacing", 5,
171                     NULL);
172       break;
173     }
174
175   gtk_widget_show_all (dialog->box);
176   gtk_container_add (GTK_CONTAINER (dialog), dialog->box);
177 }
178
179
180 static void
181 psppire_dialog_set_property (GObject         *object,
182                              guint            prop_id,
183                              const GValue    *value,
184                              GParamSpec      *pspec)
185
186 {
187   PsppireDialog *dialog = PSPPIRE_DIALOG (object);
188
189   switch (prop_id)
190     {
191     case PROP_SLIDING:
192       dialog->slidable = g_value_get_boolean (value);
193       break;
194     case PROP_ORIENTATION:
195       dialog->orientation = g_value_get_enum (value);
196       break;
197     default:
198       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
199       break;
200     };
201
202   dialog_set_container (dialog);
203 }
204
205
206 static GParamSpec *orientation_spec ;
207
208 static void
209 psppire_dialog_class_init (PsppireDialogClass *class)
210 {
211   GObjectClass *object_class = (GObjectClass *) class;
212
213   GParamSpec *sliding_spec ;
214
215   orientation_spec =
216     g_param_spec_enum ("orientation",
217                        "Orientation",
218                        "Which way widgets are packed",
219                        PSPPIRE_TYPE_ORIENTATION,
220                        PSPPIRE_HORIZONTAL /* default value */,
221                        G_PARAM_CONSTRUCT_ONLY |G_PARAM_READWRITE);
222
223   sliding_spec =
224     g_param_spec_boolean ("slidable",
225                           "Slidable",
226                           "Can the container be sized by the user",
227                           FALSE,
228                           G_PARAM_CONSTRUCT_ONLY |G_PARAM_READWRITE);
229
230   object_class->set_property = psppire_dialog_set_property;
231   object_class->get_property = psppire_dialog_get_property;
232
233   g_object_class_install_property (object_class,
234                                    PROP_ORIENTATION,
235                                    orientation_spec);
236
237
238   g_object_class_install_property (object_class,
239                                    PROP_SLIDING,
240                                    sliding_spec);
241
242   signals [DIALOG_REFRESH] =
243     g_signal_new ("refresh",
244                   G_TYPE_FROM_CLASS (class),
245                   G_SIGNAL_RUN_FIRST,
246                   0,
247                   NULL, NULL,
248                   g_cclosure_marshal_VOID__VOID,
249                   G_TYPE_NONE,
250                   0);
251
252
253   signals [RESPONSE] =
254     g_signal_new ("response",
255                   G_TYPE_FROM_CLASS (class),
256                   G_SIGNAL_RUN_FIRST,
257                   0,
258                   NULL, NULL,
259                   g_cclosure_marshal_VOID__INT,
260                   G_TYPE_NONE,
261                   1,
262                   G_TYPE_INT);
263
264
265   signals [VALIDITY_CHANGED] =
266     g_signal_new ("validity-changed",
267                   G_TYPE_FROM_CLASS (class),
268                   G_SIGNAL_RUN_FIRST,
269                   0,
270                   NULL, NULL,
271                   g_cclosure_marshal_VOID__BOOLEAN,
272                   G_TYPE_NONE,
273                   1,
274                   G_TYPE_BOOLEAN);
275
276
277   signals [DIALOG_HELP] =
278     g_signal_new ("help",
279                   G_TYPE_FROM_CLASS (class),
280                   G_SIGNAL_RUN_FIRST,
281                   0,
282                   NULL, NULL,
283                   g_cclosure_marshal_VOID__STRING,
284                   G_TYPE_NONE,
285                   1,
286                   G_TYPE_STRING);
287
288
289   object_class->finalize = psppire_dialog_finalize;
290
291   parent_class = g_type_class_peek_parent (class);
292 }
293
294
295
296
297 static void
298 close_dialog (GtkWidget *w, gpointer data)
299 {
300   PsppireDialog *dialog = data;
301
302   psppire_dialog_close (dialog);
303 }
304
305 void
306 psppire_dialog_close (PsppireDialog *dialog)
307 {
308   g_main_loop_quit (dialog->loop);
309   gtk_widget_hide (GTK_WIDGET (dialog));
310 }
311
312
313 static void
314 delete_event_callback (GtkWidget *w, GdkEvent *e, gpointer data)
315 {
316   close_dialog (w, data);
317 }
318
319
320 static void
321 psppire_dialog_init (PsppireDialog *dialog)
322 {
323   GValue value = {0};
324   dialog->box = NULL;
325   dialog->contents_are_valid = NULL;
326   dialog->validity_data = NULL;
327   dialog->slidable = FALSE;
328
329   g_value_init (&value, orientation_spec->value_type);
330   g_param_value_set_default (orientation_spec, &value);
331
332   gtk_window_set_type_hint (GTK_WINDOW (dialog),
333         GDK_WINDOW_TYPE_HINT_DIALOG);
334
335   g_value_unset (&value);
336
337   g_signal_connect (dialog, "delete-event",
338                     G_CALLBACK (delete_event_callback),
339                     dialog);
340
341   gtk_window_set_type_hint (GTK_WINDOW (dialog),
342         GDK_WINDOW_TYPE_HINT_DIALOG);
343
344   g_object_set (dialog, "icon-name", "pspp", NULL);
345 }
346
347
348 GtkWidget*
349 psppire_dialog_new (void)
350 {
351   PsppireDialog *dialog ;
352
353   dialog = g_object_new (psppire_dialog_get_type (),
354                          NULL);
355
356   return GTK_WIDGET (dialog) ;
357 }
358
359
360 void
361 psppire_dialog_notify_change (PsppireDialog *dialog)
362 {
363   if ( dialog->contents_are_valid )
364     {
365       gboolean valid = dialog->contents_are_valid (dialog->validity_data);
366
367       g_signal_emit (dialog, signals [VALIDITY_CHANGED], 0, valid);
368     }
369 }
370
371
372 /* Descend the widget tree, connecting appropriate signals to the
373    psppire_dialog_notify_change callback */
374 static void
375 connect_notify_signal (GtkWidget *w, gpointer data)
376 {
377   PsppireDialog *dialog = data;
378
379   if ( PSPPIRE_IS_BUTTONBOX (w))
380     return;
381
382   if ( GTK_IS_CONTAINER (w))
383     {
384       gtk_container_foreach (GTK_CONTAINER (w),
385                              connect_notify_signal,
386                              dialog);
387     }
388
389
390   /* It's unfortunate that GTK+ doesn't have a generic
391      "user-modified-state-changed" signal.  Instead, we have to try and
392      predict what widgets and signals are likely to exist in our dialogs. */
393
394   if ( GTK_IS_TOGGLE_BUTTON (w))
395     {
396       g_signal_connect_swapped (w, "toggled",
397                                 G_CALLBACK (psppire_dialog_notify_change),
398                                 dialog);
399     }
400
401   if ( PSPPIRE_IS_SELECTOR (w))
402     {
403       g_signal_connect_swapped (w, "selected",
404                                 G_CALLBACK (psppire_dialog_notify_change),
405                                 dialog);
406
407       g_signal_connect_swapped (w, "de-selected",
408                                 G_CALLBACK (psppire_dialog_notify_change),
409                                 dialog);
410     }
411
412   if ( GTK_IS_EDITABLE (w))
413     {
414       g_signal_connect_swapped (w, "changed",
415                                 G_CALLBACK (psppire_dialog_notify_change),
416                                 dialog);
417     }
418
419   if ( GTK_IS_CELL_EDITABLE (w))
420     {
421       g_signal_connect_swapped (w, "editing-done",
422                                 G_CALLBACK (psppire_dialog_notify_change),
423                                 dialog);
424     }
425
426   if ( GTK_IS_TEXT_VIEW (w))
427     {
428       GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (w));
429
430       g_signal_connect_swapped (buffer, "changed",
431                                 G_CALLBACK (psppire_dialog_notify_change),
432                                 dialog);
433     }
434
435   if ( GTK_IS_TREE_VIEW (w))
436     {
437       gint i = 0;
438       GtkTreeView *tv = GTK_TREE_VIEW (w);
439       GtkTreeSelection *selection =
440         gtk_tree_view_get_selection (tv);
441       GtkTreeViewColumn *col;
442       GtkTreeModel *model = gtk_tree_view_get_model (tv);
443
444       if ( model)
445         {
446       g_signal_connect_swapped (model, "row-changed",
447                                 G_CALLBACK (psppire_dialog_notify_change),
448                                 dialog);
449
450       g_signal_connect_swapped (model, "row-deleted",
451                                 G_CALLBACK (psppire_dialog_notify_change),
452                                 dialog);
453
454       g_signal_connect_swapped (model, "row-inserted",
455                                 G_CALLBACK (psppire_dialog_notify_change),
456                                 dialog);
457         }
458
459       g_signal_connect_swapped (selection, "changed",
460                                 G_CALLBACK (psppire_dialog_notify_change),
461                                 dialog);
462
463       while ((col = gtk_tree_view_get_column (tv, i++)))
464         {
465           GList *renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col));
466           GList *start = renderers;
467           while (renderers)
468             {
469               if ( GTK_IS_CELL_RENDERER_TOGGLE (renderers->data))
470                 g_signal_connect_swapped (renderers->data, "toggled",
471                                           G_CALLBACK (psppire_dialog_notify_change), dialog);
472               renderers = renderers->next;
473             }
474           g_list_free (start);
475         }
476     }
477 }
478
479
480 gint
481 psppire_dialog_run (PsppireDialog *dialog)
482 {
483   if ( dialog->contents_are_valid != NULL )
484     gtk_container_foreach (GTK_CONTAINER (dialog->box),
485                            connect_notify_signal,
486                            dialog);
487
488   dialog->loop = g_main_loop_new (NULL, FALSE);
489
490   gtk_widget_show (GTK_WIDGET (dialog));
491
492   if ( dialog->contents_are_valid != NULL)
493     g_signal_emit (dialog, signals [VALIDITY_CHANGED], 0, FALSE);
494
495   g_signal_emit (dialog, signals [DIALOG_REFRESH], 0);
496
497   gdk_threads_leave ();
498   g_main_loop_run (dialog->loop);
499   gdk_threads_enter ();
500
501   g_main_loop_unref (dialog->loop);
502
503   g_signal_emit (dialog, signals [RESPONSE], 0, dialog->response);
504
505   return dialog->response;
506 }
507
508
509 void
510 psppire_dialog_reload (PsppireDialog *dialog)
511 {
512   g_signal_emit (dialog, signals [DIALOG_REFRESH], 0);
513 }
514
515
516 void
517 psppire_dialog_help (PsppireDialog *dialog)
518 {
519   char *name = NULL;
520   g_object_get (dialog, "name", &name, NULL);
521
522   online_help (name);
523
524   g_signal_emit (dialog, signals [DIALOG_HELP], 0, name);
525 }
526
527
528 GType
529 psppire_orientation_get_type (void)
530 {
531   static GType etype = 0;
532   if (etype == 0)
533     {
534       static const GEnumValue values[] =
535         {
536           { PSPPIRE_HORIZONTAL, "PSPPIRE_HORIZONTAL", "Horizontal" },
537           { PSPPIRE_VERTICAL,   "PSPPIRE_VERTICAL",   "Vertical" },
538           { PSPPIRE_TABULAR,   "PSPPIRE_TABULAR",   "Tabular" },
539           { 0, NULL, NULL }
540         };
541
542       etype = g_enum_register_static
543         (g_intern_static_string ("PsppireOrientation"), values);
544
545     }
546   return etype;
547 }
548
549
550 void
551 psppire_dialog_set_valid_predicate (PsppireDialog *dialog,
552                                     ContentsAreValid contents_are_valid,
553                                     gpointer data)
554 {
555   dialog->contents_are_valid = contents_are_valid;
556   dialog->validity_data = data;
557 }
558
559
560
561
562
563 static GObject *
564 get_internal_child    (GtkBuildable *buildable,
565                        GtkBuilder *builder,
566                        const gchar *childname)
567 {
568   PsppireDialog *dialog = PSPPIRE_DIALOG (buildable);
569
570   if ( 0 == strcmp (childname, "hbox"))
571     return G_OBJECT (dialog->box);
572
573   return NULL;
574 }
575
576
577
578 static void
579 psppire_dialog_buildable_init (GtkBuildableIface *iface)
580 {
581   iface->get_internal_child = get_internal_child;
582 }