pintos-os.org Git - pspp/blob - 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 }