src/ui/gui/psppire-buttonbox.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007  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 <glib.h>
  21 #include <gtk/gtk.h>
  22 #include <gtk/gtksignal.h>
  23 #include "psppire-buttonbox.h"
  24 #include "psppire-dialog.h"
  25
  26 #include <gettext.h>
  27
  28 #define _(msgid) gettext (msgid)
  29 #define N_(msgid) msgid
  30
  31 GType psppire_button_flags_get_type (void);
  32
  33
  34 static void psppire_button_box_class_init          (PsppireButtonBoxClass *);
  35 static void psppire_button_box_init                (PsppireButtonBox      *);
  36
  37
  38 GType
  39 psppire_button_box_get_type (void)
  40 {
  41   static GType button_box_type = 0;
  42
  43   if (!button_box_type)
  44     {
  45       static const GTypeInfo button_box_info =
  46       {
  47         sizeof (PsppireButtonBoxClass),
  48         NULL, /* base_init */
  49         NULL, /* base_finalize */
  50         (GClassInitFunc) psppire_button_box_class_init,
  51         NULL, /* class_finalize */
  52         NULL, /* class_data */
  53         sizeof (PsppireButtonBox),
  54         0,
  55         (GInstanceInitFunc) psppire_button_box_init,
  56       };
  57
  58       button_box_type = g_type_register_static (GTK_TYPE_BUTTON_BOX,
  59                                             "PsppireButtonBox", &button_box_info, G_TYPE_FLAG_ABSTRACT);
  60     }
  61
  62   return button_box_type;
  63 }
  64
  65 enum {
  66   PROP_BUTTONS = 1
  67 };
  68
  69 static void
  70 psppire_buttonbox_set_property (GObject         *object,
  71                                guint            prop_id,
  72                                const GValue    *value,
  73                                GParamSpec      *pspec)
  74 {
  75   gint i;
  76   guint flags;
  77   PsppireButtonBox *bb = PSPPIRE_BUTTONBOX (object);
  78   if ( prop_id != PROP_BUTTONS)
  79     {
  80       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  81       return ;
  82     }
  83
  84   flags = g_value_get_flags (value);
  85
  86   for (i = 0 ; i < n_PsppireButtonBoxButtons ; ++i )
  87     g_object_set (bb->button[i], "visible", 0x01 & (flags >> i)  , NULL);
  88 }
  89
  90 static void
  91 psppire_buttonbox_get_property (GObject         *object,
  92                                guint            prop_id,
  93                                GValue          *value,
  94                                GParamSpec      *pspec)
  95 {
  96   guint flags = 0;
  97   gint i;
  98
  99   PsppireButtonBox *bb = PSPPIRE_BUTTONBOX (object);
 100
 101   if  (PROP_BUTTONS != prop_id)
 102     {
 103       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 104       return;
 105     }
 106
 107   for (i = 0 ; i < n_PsppireButtonBoxButtons ; ++i )
 108     {
 109       gboolean visibility;
 110       g_object_get (bb->button[i], "visible", &visibility, NULL);
 111
 112       if ( visibility )
 113         flags |= (0x01 << i);
 114     }
 115
 116   g_value_set_flags (value, flags);
 117 }
 118
 119
 120 typedef enum
 121   {
 122     PSPPIRE_BUTTON_OK_MASK     = (1 << PSPPIRE_BUTTON_OK),
 123     PSPPIRE_BUTTON_GOTO_MASK   = (1 << PSPPIRE_BUTTON_GOTO),
 124     PSPPIRE_BUTTON_CONTINUE_MASK = (1 << PSPPIRE_BUTTON_CONTINUE),
 125     PSPPIRE_BUTTON_CANCEL_MASK = (1 << PSPPIRE_BUTTON_CANCEL),
 126     PSPPIRE_BUTTON_HELP_MASK   = (1 << PSPPIRE_BUTTON_HELP),
 127     PSPPIRE_BUTTON_RESET_MASK  = (1 << PSPPIRE_BUTTON_RESET),
 128     PSPPIRE_BUTTON_PASTE_MASK  = (1 << PSPPIRE_BUTTON_PASTE)
 129   } PsppireButtonMask;
 130
 131 static GParamSpec *button_flags;
 132
 133 static void
 134 psppire_button_box_class_init (PsppireButtonBoxClass *class)
 135 {
 136   GObjectClass *object_class = G_OBJECT_CLASS (class);
 137
 138   object_class->set_property = psppire_buttonbox_set_property;
 139   object_class->get_property = psppire_buttonbox_get_property;
 140
 141   button_flags =
 142     g_param_spec_flags ("buttons",
 143                         "Buttons",
 144                         "The mask that decides what buttons appear in the button box",
 145                         PSPPIRE_TYPE_BUTTON_MASK,
 146                         PSPPIRE_BUTTON_OK_MASK |
 147                         PSPPIRE_BUTTON_CANCEL_MASK |
 148                         PSPPIRE_BUTTON_RESET_MASK |
 149                         PSPPIRE_BUTTON_HELP_MASK |
 150                         PSPPIRE_BUTTON_PASTE_MASK,
 151                         G_PARAM_READWRITE);
 152
 153
 154   g_object_class_install_property (object_class,
 155                                    PROP_BUTTONS,
 156                                    button_flags);
 157
 158 }
 159
 160 static void
 161 close_and_respond (GtkWidget *w, gint response)
 162 {
 163   PsppireDialog *dialog;
 164
 165   GtkWidget *toplevel = gtk_widget_get_toplevel (w);
 166
 167   /* If we're not in a psppire dialog (for example when in glade)
 168      then do nothing */
 169   if ( ! PSPPIRE_IS_DIALOG (toplevel))
 170     return;
 171
 172   dialog = PSPPIRE_DIALOG (toplevel);
 173
 174   dialog->response = response;
 175
 176   psppire_dialog_close (dialog);
 177 }
 178
 179
 180 static void
 181 close_dialog (GtkWidget *w, gpointer data)
 182 {
 183   close_and_respond (w, GTK_RESPONSE_CLOSE);
 184 }
 185
 186 static void
 187 continue_button_clicked (GtkWidget *w, gpointer data)
 188 {
 189   close_and_respond (w, PSPPIRE_RESPONSE_CONTINUE);
 190 }
 191
 192
 193 static void
 194 ok_button_clicked (GtkWidget *w, gpointer data)
 195 {
 196   close_and_respond (w, GTK_RESPONSE_OK);
 197 }
 198
 199
 200 static void
 201 paste_button_clicked (GtkWidget *w, gpointer data)
 202 {
 203   close_and_respond (w, PSPPIRE_RESPONSE_PASTE);
 204 }
 205
 206 static void
 207 goto_button_clicked (GtkWidget *w, gpointer data)
 208 {
 209   close_and_respond (w, PSPPIRE_RESPONSE_GOTO);
 210 }
 211
 212
 213 static void
 214 refresh_clicked (GtkWidget *w, gpointer data)
 215 {
 216   GtkWidget *toplevel = gtk_widget_get_toplevel (w);
 217   PsppireDialog *dialog;
 218
 219   if ( ! PSPPIRE_IS_DIALOG (toplevel))
 220     return;
 221
 222   dialog = PSPPIRE_DIALOG (toplevel);
 223
 224   psppire_dialog_reload (dialog);
 225 }
 226
 227
 228
 229 static void
 230 on_validity_change (GtkWidget *toplevel, gboolean valid, gpointer data)
 231 {
 232   PsppireButtonBox *bb = data;
 233
 234   /* Set the sensitivity of all the 'executive order' buttons */
 235   gtk_widget_set_sensitive (GTK_WIDGET (bb->button[PSPPIRE_BUTTON_OK]), valid);
 236   gtk_widget_set_sensitive (GTK_WIDGET (bb->button[PSPPIRE_BUTTON_PASTE]), valid);
 237   gtk_widget_set_sensitive (GTK_WIDGET (bb->button[PSPPIRE_BUTTON_GOTO]), valid);
 238   gtk_widget_set_sensitive (GTK_WIDGET (bb->button[PSPPIRE_BUTTON_CONTINUE]), valid);
 239 }
 240
 241 static void
 242 on_realize (GtkWidget *buttonbox, gpointer data)
 243 {
 244   GtkWidget *toplevel = gtk_widget_get_toplevel (buttonbox);
 245
 246   if ( PSPPIRE_IS_DIALOG (toplevel))
 247     {
 248       g_signal_connect (toplevel, "validity-changed",
 249                         G_CALLBACK (on_validity_change), buttonbox);
 250     }
 251 }
 252
 253 static void
 254 psppire_button_box_init (PsppireButtonBox *bb)
 255 {
 256
 257   bb->button[PSPPIRE_BUTTON_OK] = gtk_button_new_from_stock (GTK_STOCK_OK);
 258   gtk_box_pack_start_defaults (GTK_BOX (bb), bb->button[PSPPIRE_BUTTON_OK]);
 259   g_signal_connect (bb->button[PSPPIRE_BUTTON_OK], "clicked",
 260                     G_CALLBACK (ok_button_clicked), NULL);
 261   g_object_set (bb->button[PSPPIRE_BUTTON_OK], "no-show-all", TRUE, NULL);
 262
 263
 264   bb->button[PSPPIRE_BUTTON_GOTO] =
 265     gtk_button_new_from_stock (GTK_STOCK_JUMP_TO);
 266   gtk_box_pack_start_defaults (GTK_BOX (bb), bb->button[PSPPIRE_BUTTON_GOTO]);
 267   g_signal_connect (bb->button[PSPPIRE_BUTTON_GOTO], "clicked",
 268                     G_CALLBACK (goto_button_clicked), NULL);
 269   g_object_set (bb->button[PSPPIRE_BUTTON_GOTO], "no-show-all", TRUE, NULL);
 270
 271
 272   bb->button[PSPPIRE_BUTTON_CONTINUE] =
 273     gtk_button_new_with_mnemonic (_("Continue"));
 274
 275   GTK_WIDGET_SET_FLAGS (bb->button[PSPPIRE_BUTTON_CONTINUE],
 276                         GTK_CAN_DEFAULT);
 277
 278   g_signal_connect (bb->button[PSPPIRE_BUTTON_CONTINUE], "realize",
 279          G_CALLBACK (gtk_widget_grab_default), NULL);
 280
 281   gtk_box_pack_start_defaults (GTK_BOX (bb),
 282                                bb->button[PSPPIRE_BUTTON_CONTINUE]);
 283   g_signal_connect (bb->button[PSPPIRE_BUTTON_CONTINUE], "clicked",
 284                     G_CALLBACK (continue_button_clicked), NULL);
 285
 286   g_object_set (bb->button[PSPPIRE_BUTTON_CONTINUE],
 287                 "no-show-all", TRUE, NULL);
 288
 289
 290
 291   bb->button[PSPPIRE_BUTTON_PASTE] = gtk_button_new_from_stock (GTK_STOCK_PASTE);
 292   g_signal_connect (bb->button[PSPPIRE_BUTTON_PASTE], "clicked",
 293                     G_CALLBACK (paste_button_clicked), NULL);
 294   gtk_box_pack_start_defaults (GTK_BOX (bb), bb->button[PSPPIRE_BUTTON_PASTE]);
 295   g_object_set (bb->button[PSPPIRE_BUTTON_PASTE], "no-show-all", TRUE, NULL);
 296
 297   bb->button[PSPPIRE_BUTTON_CANCEL] = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
 298   g_signal_connect (bb->button[PSPPIRE_BUTTON_CANCEL], "clicked",
 299                     G_CALLBACK (close_dialog), NULL);
 300   gtk_box_pack_start_defaults (GTK_BOX (bb), bb->button[PSPPIRE_BUTTON_CANCEL]);
 301   g_object_set (bb->button[PSPPIRE_BUTTON_CANCEL], "no-show-all", TRUE, NULL);
 302
 303
 304   bb->button[PSPPIRE_BUTTON_RESET] = gtk_button_new_from_stock ("pspp-stock-reset");
 305   g_signal_connect (bb->button[PSPPIRE_BUTTON_RESET], "clicked",
 306                     G_CALLBACK (refresh_clicked), NULL);
 307   gtk_box_pack_start_defaults (GTK_BOX (bb), bb->button[PSPPIRE_BUTTON_RESET]);
 308   g_object_set (bb->button[PSPPIRE_BUTTON_RESET], "no-show-all", TRUE, NULL);
 309
 310
 311   bb->button[PSPPIRE_BUTTON_HELP] = gtk_button_new_from_stock (GTK_STOCK_HELP);
 312   gtk_box_pack_start_defaults (GTK_BOX (bb), bb->button[PSPPIRE_BUTTON_HELP]);
 313   g_object_set (bb->button[PSPPIRE_BUTTON_HELP], "no-show-all", TRUE, NULL);
 314
 315
 316   /* Set the default visibilities */
 317   {
 318     GValue value = { 0 };
 319     guint flags;
 320     gint i;
 321     g_value_init (&value, button_flags->value_type);
 322     g_param_value_set_default(button_flags, &value);
 323
 324
 325     flags = g_value_get_flags (&value);
 326
 327     for (i = 0 ; i < n_PsppireButtonBoxButtons ; ++i )
 328       g_object_set (bb->button[i], "visible", 0x01 & (flags >> i)  , NULL);
 329
 330     g_value_unset (&value);
 331   }
 332
 333
 334   g_signal_connect (bb, "realize", G_CALLBACK (on_realize), NULL);
 335 }
 336
 337
 338 /* This function is lifted verbatim from the Gtk2.10.6 library */
 339
 340 void
 341 _psppire_button_box_child_requisition (GtkWidget *widget,
 342                                        int       *nvis_children,
 343                                        int       *nvis_secondaries,
 344                                        int       *width,
 345                                        int       *height)
 346 {
 347   GtkButtonBox *bbox;
 348   GtkBoxChild *child;
 349   GList *children;
 350   gint nchildren;
 351   gint nsecondaries;
 352   gint needed_width;
 353   gint needed_height;
 354   GtkRequisition child_requisition;
 355   gint ipad_w;
 356   gint ipad_h;
 357   gint width_default;
 358   gint height_default;
 359   gint ipad_x_default;
 360   gint ipad_y_default;
 361
 362   gint child_min_width;
 363   gint child_min_height;
 364   gint ipad_x;
 365   gint ipad_y;
 366
 367   g_return_if_fail (GTK_IS_BUTTON_BOX (widget));
 368
 369   bbox = GTK_BUTTON_BOX (widget);
 370
 371   gtk_widget_style_get (widget,
 372                         "child-min-width", &width_default,
 373                         "child-min-height", &height_default,
 374                         "child-internal-pad-x", &ipad_x_default,
 375                         "child-internal-pad-y", &ipad_y_default,
 376                         NULL);
 377
 378   child_min_width = bbox->child_min_width   != GTK_BUTTONBOX_DEFAULT
 379     ? bbox->child_min_width : width_default;
 380   child_min_height = bbox->child_min_height !=GTK_BUTTONBOX_DEFAULT
 381     ? bbox->child_min_height : height_default;
 382   ipad_x = bbox->child_ipad_x != GTK_BUTTONBOX_DEFAULT
 383     ? bbox->child_ipad_x : ipad_x_default;
 384   ipad_y = bbox->child_ipad_y != GTK_BUTTONBOX_DEFAULT
 385     ? bbox->child_ipad_y : ipad_y_default;
 386
 387   nchildren = 0;
 388   nsecondaries = 0;
 389   children = GTK_BOX(bbox)->children;
 390   needed_width = child_min_width;
 391   needed_height = child_min_height;
 392   ipad_w = ipad_x * 2;
 393   ipad_h = ipad_y * 2;
 394
 395   while (children)
 396     {
 397       child = children->data;
 398       children = children->next;
 399
 400       if (GTK_WIDGET_VISIBLE (child->widget))
 401         {
 402           nchildren += 1;
 403           gtk_widget_size_request (child->widget, &child_requisition);
 404
 405           if (child_requisition.width + ipad_w > needed_width)
 406             needed_width = child_requisition.width + ipad_w;
 407           if (child_requisition.height + ipad_h > needed_height)
 408             needed_height = child_requisition.height + ipad_h;
 409           if (child->is_secondary)
 410             nsecondaries++;
 411         }
 412     }
 413
 414   if (nvis_children)
 415     *nvis_children = nchildren;
 416   if (nvis_secondaries)
 417     *nvis_secondaries = nsecondaries;
 418   if (width)
 419     *width = needed_width;
 420   if (height)
 421     *height = needed_height;
 422 }
 423
 424
 425 GType
 426 psppire_button_flags_get_type (void)
 427 {
 428   static GType ftype = 0;
 429   if (ftype == 0)
 430     {
 431       static const GFlagsValue values[] =
 432         {
 433           { PSPPIRE_BUTTON_OK_MASK,     "PSPPIRE_BUTTON_OK_MASK",     N_("OK") },
 434           { PSPPIRE_BUTTON_GOTO_MASK,   "PSPPIRE_BUTTON_GOTO_MASK", N_("Go To") },
 435           { PSPPIRE_BUTTON_CONTINUE_MASK,"PSPPIRE_BUTTON_CONTINUE_MASK", N_("Continue") },
 436           { PSPPIRE_BUTTON_CANCEL_MASK, "PSPPIRE_BUTTON_CANCEL_MASK", N_("Cancel") },
 437           { PSPPIRE_BUTTON_HELP_MASK,   "PSPPIRE_BUTTON_HELP_MASK",   N_("Help") },
 438           { PSPPIRE_BUTTON_RESET_MASK,  "PSPPIRE_BUTTON_RESET_MASK",  N_("Reset") },
 439           { PSPPIRE_BUTTON_PASTE_MASK,  "PSPPIRE_BUTTON_PASTE_MASK",  N_("Paste") },
 440           { 0, NULL, NULL }
 441         };
 442
 443       ftype = g_flags_register_static
 444         (g_intern_static_string ("PsppireButtonFlags"), values);
 445
 446     }
 447   return ftype;
 448 }
 449