X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpsppire-dialog.c;h=d89b3b4ec288f8d9f00fd812a15f72f9d4b49202;hb=876da2249715aa8495343d8a9b1dd9b4a08fc91d;hp=b978880196448a9ba59d2b638fcd23ad6ca35c03;hpb=43b1296aafe7582e7dbe6c2b6a8b478d7d9b0fcf;p=pspp diff --git a/src/ui/gui/psppire-dialog.c b/src/ui/gui/psppire-dialog.c index b978880196..d89b3b4ec2 100644 --- a/src/ui/gui/psppire-dialog.c +++ b/src/ui/gui/psppire-dialog.c @@ -1,5 +1,5 @@ /* PSPPIRE - a graphical user interface for PSPP. - Copyright (C) 2007 Free Software Foundation + Copyright (C) 2007, 2010, 2011, 2012 Free Software Foundation This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -18,19 +18,31 @@ #include #include -#include #include "psppire-dialog.h" +#include "psppire-buttonbox.h" +#include "psppire-selector.h" +#include +#include "builder-wrapper.h" +#include "help-menu.h" + +#include "psppire-window-base.h" static void psppire_dialog_class_init (PsppireDialogClass *); static void psppire_dialog_init (PsppireDialog *); enum {DIALOG_REFRESH, + RESPONSE, + VALIDITY_CHANGED, + DIALOG_HELP, n_SIGNALS}; static guint signals [n_SIGNALS]; +static void psppire_dialog_buildable_init (GtkBuildableIface *iface); + + GType psppire_dialog_get_type (void) { @@ -51,8 +63,19 @@ psppire_dialog_get_type (void) (GInstanceInitFunc) psppire_dialog_init, }; - dialog_type = g_type_register_static (GTK_TYPE_WINDOW, + static const GInterfaceInfo buildable_info = + { + (GInterfaceInitFunc) psppire_dialog_buildable_init, + NULL, + NULL + }; + + dialog_type = g_type_register_static (PSPPIRE_TYPE_WINDOW_BASE, "PsppireDialog", &dialog_info, 0); + + g_type_add_interface_static (dialog_type, + GTK_TYPE_BUILDABLE, + &buildable_info); } return dialog_type; @@ -63,27 +86,12 @@ psppire_dialog_get_type (void) static GObjectClass *parent_class = NULL; -static void -psppire_dialog_finalize (GObject *object) -{ - PsppireDialog *dialog ; - - g_return_if_fail (object != NULL); - g_return_if_fail (PSPPIRE_IS_DIALOG (object)); - - dialog = PSPPIRE_DIALOG (object); - - if (G_OBJECT_CLASS (parent_class)->finalize) - G_OBJECT_CLASS (parent_class)->finalize (object); -} - - - /* Properties */ enum { PROP_0, - PROP_ORIENTATION + PROP_ORIENTATION, + PROP_SLIDING }; @@ -99,12 +107,17 @@ psppire_dialog_get_property (GObject *object, { case PROP_ORIENTATION: { - if ( GTK_IS_VBOX (dialog->box) ) + if ( GTK_IS_VBOX (dialog->box) || GTK_VPANED (dialog->box)) g_value_set_enum (value, PSPPIRE_VERTICAL); - else if ( GTK_IS_HBOX (dialog->box)) + else if ( GTK_IS_HBOX (dialog->box) || GTK_HPANED (dialog->box)) g_value_set_enum (value, PSPPIRE_HORIZONTAL); + else if ( GTK_IS_TABLE (dialog->box)) + g_value_set_enum (value, PSPPIRE_TABULAR); } break; + case PROP_SLIDING: + g_value_set_boolean (value, dialog->slidable); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -113,24 +126,37 @@ psppire_dialog_get_property (GObject *object, static void -dialog_set_orientation (PsppireDialog *dialog, const GValue *orval) +dialog_set_container (PsppireDialog *dialog) { - PsppireOrientation orientation = g_value_get_enum (orval); - if ( dialog->box != NULL) { gtk_container_remove (GTK_CONTAINER (dialog), dialog->box); } - if ( orientation == PSPPIRE_HORIZONTAL) + switch (dialog->orientation) { - dialog->box = gtk_hbox_new (FALSE, 5); - } - else - { - dialog->box = gtk_vbox_new (FALSE, 5); + case PSPPIRE_HORIZONTAL: + if ( dialog->slidable) + dialog->box = gtk_hpaned_new(); + else + dialog->box = gtk_hbox_new (FALSE, 5); + break; + case PSPPIRE_VERTICAL: + if ( dialog->slidable) + dialog->box = gtk_vpaned_new(); + else + dialog->box = gtk_vbox_new (FALSE, 5); + break; + case PSPPIRE_TABULAR: + dialog->box = gtk_table_new (2, 3, FALSE); + g_object_set (dialog->box, + "row-spacing", 5, + "column-spacing", 5, + NULL); + break; } + gtk_widget_show_all (dialog->box); gtk_container_add (GTK_CONTAINER (dialog), dialog->box); } @@ -146,13 +172,18 @@ psppire_dialog_set_property (GObject *object, switch (prop_id) { + case PROP_SLIDING: + dialog->slidable = g_value_get_boolean (value); + break; case PROP_ORIENTATION: - dialog_set_orientation (dialog, value); + dialog->orientation = g_value_get_enum (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; }; + + dialog_set_container (dialog); } @@ -163,15 +194,22 @@ psppire_dialog_class_init (PsppireDialogClass *class) { GObjectClass *object_class = (GObjectClass *) class; + GParamSpec *sliding_spec ; orientation_spec = g_param_spec_enum ("orientation", "Orientation", "Which way widgets are packed", - G_TYPE_PSPPIRE_ORIENTATION, + PSPPIRE_TYPE_ORIENTATION, PSPPIRE_HORIZONTAL /* default value */, G_PARAM_CONSTRUCT_ONLY |G_PARAM_READWRITE); + sliding_spec = + g_param_spec_boolean ("slidable", + "Slidable", + "Can the container be sized by the user", + FALSE, + G_PARAM_CONSTRUCT_ONLY |G_PARAM_READWRITE); object_class->set_property = psppire_dialog_set_property; object_class->get_property = psppire_dialog_get_property; @@ -181,6 +219,9 @@ psppire_dialog_class_init (PsppireDialogClass *class) orientation_spec); + g_object_class_install_property (object_class, + PROP_SLIDING, + sliding_spec); signals [DIALOG_REFRESH] = g_signal_new ("refresh", @@ -193,7 +234,43 @@ psppire_dialog_class_init (PsppireDialogClass *class) 0); - object_class->finalize = psppire_dialog_finalize; + signals [RESPONSE] = + g_signal_new ("response", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_FIRST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__INT, + G_TYPE_NONE, + 1, + G_TYPE_INT); + + + signals [VALIDITY_CHANGED] = + g_signal_new ("validity-changed", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_FIRST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__BOOLEAN, + G_TYPE_NONE, + 1, + G_TYPE_BOOLEAN); + + + signals [DIALOG_HELP] = + g_signal_new ("help", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_FIRST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__STRING, + G_TYPE_NONE, + 1, + G_TYPE_STRING); + + + parent_class = g_type_class_peek_parent (class); } @@ -227,19 +304,28 @@ psppire_dialog_init (PsppireDialog *dialog) { GValue value = {0}; dialog->box = NULL; + dialog->contents_are_valid = NULL; + dialog->validity_data = NULL; + dialog->contents_are_acceptable = NULL; + dialog->acceptable_data = NULL; + dialog->slidable = FALSE; g_value_init (&value, orientation_spec->value_type); g_param_value_set_default (orientation_spec, &value); - dialog_set_orientation (dialog, &value); + gtk_window_set_type_hint (GTK_WINDOW (dialog), + GDK_WINDOW_TYPE_HINT_DIALOG); g_value_unset (&value); - g_signal_connect (G_OBJECT (dialog), "delete-event", + g_signal_connect (dialog, "delete-event", G_CALLBACK (delete_event_callback), dialog); - gtk_widget_show_all (dialog->box); + gtk_window_set_type_hint (GTK_WINDOW (dialog), + GDK_WINDOW_TYPE_HINT_DIALOG); + + g_object_set (dialog, "icon-name", "pspp", NULL); } @@ -248,21 +334,173 @@ psppire_dialog_new (void) { PsppireDialog *dialog ; - dialog = g_object_new (psppire_dialog_get_type (), NULL); + dialog = g_object_new (psppire_dialog_get_type (), + NULL); return GTK_WIDGET (dialog) ; } + +void +psppire_dialog_notify_change (PsppireDialog *dialog) +{ + if ( dialog->contents_are_valid ) + { + gboolean valid = dialog->contents_are_valid (dialog->validity_data); + + g_signal_emit (dialog, signals [VALIDITY_CHANGED], 0, valid); + } +} + + +static void +remove_notify_handlers (PsppireDialog *dialog, GObject *sel) +{ + g_signal_handlers_disconnect_by_data (sel, dialog); +} + + +/* Descend the widget tree, connecting appropriate signals to the + psppire_dialog_notify_change callback */ +static void +connect_notify_signal (GtkWidget *w, gpointer data) +{ + PsppireDialog *dialog = data; + + if ( PSPPIRE_IS_BUTTONBOX (w)) + return; + + if ( GTK_IS_CONTAINER (w)) + { + gtk_container_foreach (GTK_CONTAINER (w), + connect_notify_signal, + dialog); + } + + + /* It's unfortunate that GTK+ doesn't have a generic + "user-modified-state-changed" signal. Instead, we have to try and + predict what widgets and signals are likely to exist in our dialogs. */ + + if ( GTK_IS_TOGGLE_BUTTON (w)) + { + g_signal_connect_swapped (w, "toggled", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + } + + if ( PSPPIRE_IS_SELECTOR (w)) + { + g_signal_connect_swapped (w, "selected", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + + g_signal_connect_swapped (w, "de-selected", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + } + + if ( GTK_IS_EDITABLE (w)) + { + g_signal_connect_swapped (w, "changed", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + } + + if ( GTK_IS_CELL_EDITABLE (w)) + { + g_signal_connect_swapped (w, "editing-done", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + } + + if ( GTK_IS_TEXT_VIEW (w)) + { + GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (w)); + + g_signal_connect_swapped (buffer, "changed", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + } + + if ( GTK_IS_TREE_VIEW (w)) + { + gint i = 0; + GtkTreeView *tv = GTK_TREE_VIEW (w); + GtkTreeSelection *selection = + gtk_tree_view_get_selection (tv); + GtkTreeViewColumn *col; + GtkTreeModel *model = gtk_tree_view_get_model (tv); + + if ( model) + { + g_signal_connect_swapped (model, "row-changed", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + + g_signal_connect_swapped (model, "row-deleted", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + + g_signal_connect_swapped (model, "row-inserted", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + + g_signal_connect (dialog, "destroy", G_CALLBACK (remove_notify_handlers), + model); + } + + g_signal_connect_swapped (selection, "changed", + G_CALLBACK (psppire_dialog_notify_change), + dialog); + + while ((col = gtk_tree_view_get_column (tv, i++))) + { + GList *renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); + GList *start = renderers; + while (renderers) + { + if ( GTK_IS_CELL_RENDERER_TOGGLE (renderers->data)) + g_signal_connect_swapped (renderers->data, "toggled", + G_CALLBACK (psppire_dialog_notify_change), dialog); + renderers = renderers->next; + } + g_list_free (start); + } + } +} + + gint psppire_dialog_run (PsppireDialog *dialog) { + gchar *title = NULL; + g_object_get (dialog, "title", &title, NULL); + + if (title == NULL) + g_warning ("PsppireDialog %s has no title", gtk_widget_get_name (GTK_WIDGET (dialog))); + + if ( dialog->contents_are_valid != NULL ) + gtk_container_foreach (GTK_CONTAINER (dialog->box), + connect_notify_signal, + dialog); + dialog->loop = g_main_loop_new (NULL, FALSE); gtk_widget_show (GTK_WIDGET (dialog)); + if ( dialog->contents_are_valid != NULL) + g_signal_emit (dialog, signals [VALIDITY_CHANGED], 0, FALSE); + g_signal_emit (dialog, signals [DIALOG_REFRESH], 0); + gdk_threads_leave (); g_main_loop_run (dialog->loop); + gdk_threads_enter (); + + g_main_loop_unref (dialog->loop); + + g_signal_emit (dialog, signals [RESPONSE], 0, dialog->response); return dialog->response; } @@ -275,6 +513,16 @@ psppire_dialog_reload (PsppireDialog *dialog) } +void +psppire_dialog_help (PsppireDialog *dialog) +{ + char *name = NULL; + g_object_get (dialog, "name", &name, NULL); + + online_help (name); + + g_signal_emit (dialog, signals [DIALOG_HELP], 0, name); +} GType @@ -287,6 +535,7 @@ psppire_orientation_get_type (void) { { PSPPIRE_HORIZONTAL, "PSPPIRE_HORIZONTAL", "Horizontal" }, { PSPPIRE_VERTICAL, "PSPPIRE_VERTICAL", "Vertical" }, + { PSPPIRE_TABULAR, "PSPPIRE_TABULAR", "Tabular" }, { 0, NULL, NULL } }; @@ -296,3 +545,66 @@ psppire_orientation_get_type (void) } return etype; } + + +/* Sets a predicate function that is checked after each change that the user + makes to the dialog's state. If the predicate function returns false, then + "OK" and other buttons that accept the dialog's settings will be + disabled. */ +void +psppire_dialog_set_valid_predicate (PsppireDialog *dialog, + ContentsAreValid contents_are_valid, + gpointer data) +{ + dialog->contents_are_valid = contents_are_valid; + dialog->validity_data = data; +} + +/* Sets a predicate function that is called after "OK" or another button that + accepts the dialog's settings is pushed. If the predicate function returns + false, then the button push is ignored. (If the predicate function returns + false, then it should take some action to notify the user why the contents + are unacceptable, e.g. pop up a dialog box.) + + An accept predicate is preferred over a validity predicate when the reason + why the dialog settings are unacceptable may not be obvious to the user, so + that the user needs a helpful message to explain. */ +void +psppire_dialog_set_accept_predicate (PsppireDialog *dialog, + ContentsAreValid contents_are_acceptable, + gpointer data) +{ + dialog->contents_are_acceptable = contents_are_acceptable; + dialog->acceptable_data = data; +} + +gboolean +psppire_dialog_is_acceptable (const PsppireDialog *dialog) +{ + return (dialog->contents_are_acceptable == NULL + || dialog->contents_are_acceptable (dialog->acceptable_data)); +} + + + + +static GObject * +get_internal_child (GtkBuildable *buildable, + GtkBuilder *builder, + const gchar *childname) +{ + PsppireDialog *dialog = PSPPIRE_DIALOG (buildable); + + if ( 0 == strcmp (childname, "hbox")) + return G_OBJECT (dialog->box); + + return NULL; +} + + + +static void +psppire_dialog_buildable_init (GtkBuildableIface *iface) +{ + iface->get_internal_child = get_internal_child; +}