X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkdialog.c;h=b88ca5f5ba5d637f51e1ade6beafebf6d0a07540;hb=f9f6c4fa49cb630f169c2fa4ce6b4ed2b44be8f3;hp=3cc7f3e90f0879eae374e2756cf7da3b19179927;hpb=b699ac5853f69f617bb1d388c8bb8a8c0d5347e9;p=~andy%2Fgtk diff --git a/gtk/gtkdialog.c b/gtk/gtkdialog.c index 3cc7f3e90..b88ca5f5b 100644 --- a/gtk/gtkdialog.c +++ b/gtk/gtkdialog.c @@ -12,41 +12,165 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ /* * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with - * GTK+ at ftp://ftp.gtk.org/pub/gtk/. + * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ +#include "config.h" + #include #include -#include "config.h" + #include "gtkbutton.h" #include "gtkdialog.h" -#include "gtkhbbox.h" +#include "gtkbbox.h" #include "gtklabel.h" -#include "gtkhseparator.h" #include "gtkmarshalers.h" -#include "gtkvbox.h" -#include "gdkkeysyms.h" +#include "gtkbox.h" +#include "gtkboxprivate.h" #include "gtkmain.h" #include "gtkintl.h" #include "gtkbindings.h" #include "gtkprivate.h" #include "gtkbuildable.h" -#include "gtkalias.h" +#include "gtksettings.h" -#define GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_DIALOG, GtkDialogPrivate)) +/** + * SECTION:gtkdialog + * @Short_description: Create popup windows + * @Title: GtkDialog + * @See_also: #GtkVBox, #GtkWindow, #GtkButton + * + * Dialog boxes are a convenient way to prompt the user for a small amount + * of input, e.g. to display a message, ask a question, or anything else + * that does not require extensive effort on the user's part. + * + * GTK+ treats a dialog as a window split vertically. The top section is a + * #GtkVBox, and is where widgets such as a #GtkLabel or a #GtkEntry should + * be packed. The bottom area is known as the + * action_area. This is generally used for + * packing buttons into the dialog which may perform functions such as + * cancel, ok, or apply. + * + * #GtkDialog boxes are created with a call to gtk_dialog_new() or + * gtk_dialog_new_with_buttons(). gtk_dialog_new_with_buttons() is + * recommended; it allows you to set the dialog title, some convenient flags, + * and add simple buttons. + * + * If 'dialog' is a newly created dialog, the two primary areas of the + * window can be accessed through gtk_dialog_get_content_area() and + * gtk_dialog_get_action_area(), as can be seen from the example below. + * + * A 'modal' dialog (that is, one which freezes the rest of the application + * from user input), can be created by calling gtk_window_set_modal() on the + * dialog. Use the GTK_WINDOW() macro to cast the widget returned from + * gtk_dialog_new() into a #GtkWindow. When using gtk_dialog_new_with_buttons() + * you can also pass the #GTK_DIALOG_MODAL flag to make a dialog modal. + * + * If you add buttons to #GtkDialog using gtk_dialog_new_with_buttons(), + * gtk_dialog_add_button(), gtk_dialog_add_buttons(), or + * gtk_dialog_add_action_widget(), clicking the button will emit a signal + * called #GtkDialog::response with a response ID that you specified. GTK+ + * will never assign a meaning to positive response IDs; these are entirely + * user-defined. But for convenience, you can use the response IDs in the + * #GtkResponseType enumeration (these all have values less than zero). If + * a dialog receives a delete event, the #GtkDialog::response signal will + * be emitted with a response ID of #GTK_RESPONSE_DELETE_EVENT. + * + * If you want to block waiting for a dialog to return before returning + * control flow to your code, you can call gtk_dialog_run(). This function + * enters a recursive main loop and waits for the user to respond to the + * dialog, returning the response ID corresponding to the button the user + * clicked. + * + * For the simple dialog in the following example, in reality you'd probably + * use #GtkMessageDialog to save yourself some effort. But you'd need to + * create the dialog contents manually if you had more than a simple message + * in the dialog. + * + * Simple GtkDialog usage + * + * /* Function to open a dialog box displaying the message provided. */ + * void + * quick_message (gchar *message) + * { + * GtkWidget *dialog, *label, *content_area; + * + * /* Create the widgets */ + * dialog = gtk_dialog_new_with_buttons ("Message", + * main_application_window, + * GTK_DIALOG_DESTROY_WITH_PARENT, + * GTK_STOCK_OK, + * GTK_RESPONSE_NONE, + * NULL); + * content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); + * label = gtk_label_new (message); + * + * /* Ensure that the dialog box is destroyed when the user responds */ + * g_signal_connect_swapped (dialog, + * "response", + * G_CALLBACK (gtk_widget_destroy), + * dialog); + * + * /* Add the label, and show everything we've added to the dialog */ + * + * gtk_container_add (GTK_CONTAINER (content_area), label); + * gtk_widget_show_all (dialog); + * } + * + * + * + * GtkDialog as GtkBuildable + * + * The GtkDialog implementation of the #GtkBuildable interface exposes the + * @vbox and @action_area as internal children with the names "vbox" and + * "action_area". + * + * + * GtkDialog supports a custom <action-widgets> element, which + * can contain multiple <action-widget> elements. The "response" + * attribute specifies a numeric response, and the content of the element + * is the id of widget (which should be a child of the dialogs @action_area). + * + * + * A <structname>GtkDialog</structname> UI definition fragment. + * + * " + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * button_ok + * button_cancel + * + * + * ]]> + * + * + */ -typedef struct { - guint ignore_separator : 1; -} GtkDialogPrivate; +struct _GtkDialogPrivate +{ + GtkWidget *vbox; + GtkWidget *action_area; +}; typedef struct _ResponseData ResponseData; @@ -55,45 +179,36 @@ struct _ResponseData gint response_id; }; -static void gtk_dialog_add_buttons_valist (GtkDialog *dialog, - const gchar *first_button_text, - va_list args); - -static gint gtk_dialog_delete_event_handler (GtkWidget *widget, - GdkEventAny *event, - gpointer user_data); - -static void gtk_dialog_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec); -static void gtk_dialog_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec); -static void gtk_dialog_style_set (GtkWidget *widget, - GtkStyle *prev_style); -static void gtk_dialog_map (GtkWidget *widget); - -static void gtk_dialog_close (GtkDialog *dialog); - -static ResponseData* get_response_data (GtkWidget *widget, - gboolean create); -static void gtk_dialog_buildable_interface_init (GtkBuildableIface *iface); -static GObject * gtk_dialog_buildable_get_internal_child (GtkBuildable *buildable, - GtkBuilder *builder, - const gchar *childname); -static gboolean gtk_dialog_buildable_custom_tag_start (GtkBuildable *buildable, - GtkBuilder *builder, - GObject *child, - const gchar *tagname, - GMarkupParser *parser, - gpointer *data); -static void gtk_dialog_buildable_custom_finished (GtkBuildable *buildable, - GtkBuilder *builder, - GObject *child, - const gchar *tagname, - gpointer user_data); +static void gtk_dialog_add_buttons_valist (GtkDialog *dialog, + const gchar *first_button_text, + va_list args); + +static gboolean gtk_dialog_delete_event_handler (GtkWidget *widget, + GdkEventAny *event, + gpointer user_data); +static void gtk_dialog_style_updated (GtkWidget *widget); +static void gtk_dialog_map (GtkWidget *widget); + +static void gtk_dialog_close (GtkDialog *dialog); + +static ResponseData * get_response_data (GtkWidget *widget, + gboolean create); + +static void gtk_dialog_buildable_interface_init (GtkBuildableIface *iface); +static GObject * gtk_dialog_buildable_get_internal_child (GtkBuildable *buildable, + GtkBuilder *builder, + const gchar *childname); +static gboolean gtk_dialog_buildable_custom_tag_start (GtkBuildable *buildable, + GtkBuilder *builder, + GObject *child, + const gchar *tagname, + GMarkupParser *parser, + gpointer *data); +static void gtk_dialog_buildable_custom_finished (GtkBuildable *buildable, + GtkBuilder *builder, + GObject *child, + const gchar *tagname, + gpointer user_data); enum { @@ -119,41 +234,27 @@ gtk_dialog_class_init (GtkDialogClass *class) GObjectClass *gobject_class; GtkWidgetClass *widget_class; GtkBindingSet *binding_set; - + gobject_class = G_OBJECT_CLASS (class); widget_class = GTK_WIDGET_CLASS (class); - - gobject_class->set_property = gtk_dialog_set_property; - gobject_class->get_property = gtk_dialog_get_property; - + widget_class->map = gtk_dialog_map; - widget_class->style_set = gtk_dialog_style_set; + widget_class->style_updated = gtk_dialog_style_updated; + + gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_DIALOG); class->close = gtk_dialog_close; - - g_type_class_add_private (gobject_class, sizeof (GtkDialogPrivate)); - /** - * GtkDialog:has-separator: - * - * When %TRUE, the dialog has a separator bar above its buttons. - */ - g_object_class_install_property (gobject_class, - PROP_HAS_SEPARATOR, - g_param_spec_boolean ("has-separator", - P_("Has separator"), - P_("The dialog has a separator bar above its buttons"), - TRUE, - GTK_PARAM_READWRITE)); + g_type_class_add_private (gobject_class, sizeof (GtkDialogPrivate)); /** * GtkDialog::response: * @dialog: the object on which the signal is emitted * @response_id: the response ID - * - * Emitted when an action widget is clicked, the dialog receives a - * delete event, or the application programmer calls gtk_dialog_response(). - * On a delete event, the response ID is #GTK_RESPONSE_DELETE_EVENT. + * + * Emitted when an action widget is clicked, the dialog receives a + * delete event, or the application programmer calls gtk_dialog_response(). + * On a delete event, the response ID is #GTK_RESPONSE_DELETE_EVENT. * Otherwise, it depends on which action widget was clicked. */ dialog_signals[RESPONSE] = @@ -162,29 +263,29 @@ gtk_dialog_class_init (GtkDialogClass *class) G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GtkDialogClass, response), NULL, NULL, - _gtk_marshal_NONE__INT, + _gtk_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); /** * GtkDialog::close: * - * The ::close signal is a + * The ::close signal is a * keybinding signal - * which getrs emitted when the user uses a keybinding to close + * which gets emitted when the user uses a keybinding to close * the dialog. * * The default binding for this signal is the Escape key. - */ + */ dialog_signals[CLOSE] = g_signal_new (I_("close"), G_OBJECT_CLASS_TYPE (class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GtkDialogClass, close), NULL, NULL, - _gtk_marshal_NONE__NONE, + _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); - + gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("content-area-border", P_("Content area border"), @@ -193,6 +294,24 @@ gtk_dialog_class_init (GtkDialogClass *class) G_MAXINT, 2, GTK_PARAM_READABLE)); + /** + * GtkDialog:content-area-spacing: + * + * The default spacing used between elements of the + * content area of the dialog, as returned by + * gtk_dialog_get_content_area(), unless gtk_box_set_spacing() + * was called on that widget directly. + * + * Since: 2.16 + */ + gtk_widget_class_install_style_property (widget_class, + g_param_spec_int ("content-area-spacing", + P_("Content area spacing"), + P_("Spacing between elements of the main dialog area"), + 0, + G_MAXINT, + 0, + GTK_PARAM_READABLE)); gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("button-spacing", P_("Button spacing"), @@ -201,7 +320,7 @@ gtk_dialog_class_init (GtkDialogClass *class) G_MAXINT, 6, GTK_PARAM_READABLE)); - + gtk_widget_class_install_style_property (widget_class, g_param_spec_int ("action-area-border", P_("Action area border"), @@ -212,31 +331,37 @@ gtk_dialog_class_init (GtkDialogClass *class) GTK_PARAM_READABLE)); binding_set = gtk_binding_set_by_class (class); - - gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0, "close", 0); + + gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0, "close", 0); } static void update_spacings (GtkDialog *dialog) { - GtkWidget *widget; + GtkDialogPrivate *priv = dialog->priv; gint content_area_border; + gint content_area_spacing; gint button_spacing; gint action_area_border; - - widget = GTK_WIDGET (dialog); - gtk_widget_style_get (widget, + gtk_widget_style_get (GTK_WIDGET (dialog), "content-area-border", &content_area_border, + "content-area-spacing", &content_area_spacing, "button-spacing", &button_spacing, "action-area-border", &action_area_border, NULL); - gtk_container_set_border_width (GTK_CONTAINER (dialog->vbox), + + gtk_container_set_border_width (GTK_CONTAINER (priv->vbox), content_area_border); - gtk_box_set_spacing (GTK_BOX (dialog->action_area), + if (!_gtk_box_get_spacing_set (GTK_BOX (priv->vbox))) + { + gtk_box_set_spacing (GTK_BOX (priv->vbox), content_area_spacing); + _gtk_box_set_spacing_set (GTK_BOX (priv->vbox), FALSE); + } + gtk_box_set_spacing (GTK_BOX (priv->action_area), button_spacing); - gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), + gtk_container_set_border_width (GTK_CONTAINER (priv->action_area), action_area_border); } @@ -245,8 +370,10 @@ gtk_dialog_init (GtkDialog *dialog) { GtkDialogPrivate *priv; - priv = GET_PRIVATE (dialog); - priv->ignore_separator = FALSE; + dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog, + GTK_TYPE_DIALOG, + GtkDialogPrivate); + priv = dialog->priv; /* To avoid breaking old code that prevents destroy on delete event * by connecting a handler, we have to have the FIRST signal @@ -257,27 +384,24 @@ gtk_dialog_init (GtkDialog *dialog) G_CALLBACK (gtk_dialog_delete_event_handler), NULL); - dialog->vbox = gtk_vbox_new (FALSE, 0); - - gtk_container_add (GTK_CONTAINER (dialog), dialog->vbox); - gtk_widget_show (dialog->vbox); + priv->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_container_add (GTK_CONTAINER (dialog), priv->vbox); + gtk_widget_show (priv->vbox); - dialog->action_area = gtk_hbutton_box_new (); + priv->action_area = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); - gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog->action_area), + gtk_button_box_set_layout (GTK_BUTTON_BOX (priv->action_area), GTK_BUTTONBOX_END); - gtk_box_pack_end (GTK_BOX (dialog->vbox), dialog->action_area, + gtk_box_pack_end (GTK_BOX (priv->vbox), priv->action_area, FALSE, TRUE, 0); - gtk_widget_show (dialog->action_area); - - dialog->separator = gtk_hseparator_new (); - gtk_box_pack_end (GTK_BOX (dialog->vbox), dialog->separator, FALSE, TRUE, 0); - gtk_widget_show (dialog->separator); + gtk_widget_show (priv->action_area); gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER_ON_PARENT); + + update_spacings (dialog); } static GtkBuildableIface *parent_buildable_iface; @@ -296,61 +420,19 @@ gtk_dialog_buildable_get_internal_child (GtkBuildable *buildable, GtkBuilder *builder, const gchar *childname) { - if (strcmp (childname, "vbox") == 0) - return G_OBJECT (GTK_DIALOG (buildable)->vbox); - else if (strcmp (childname, "action_area") == 0) - return G_OBJECT (GTK_DIALOG (buildable)->action_area); - - return parent_buildable_iface->get_internal_child (buildable, - builder, - childname); -} + GtkDialogPrivate *priv = GTK_DIALOG (buildable)->priv; -static void -gtk_dialog_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - GtkDialog *dialog; - - dialog = GTK_DIALOG (object); - - switch (prop_id) - { - case PROP_HAS_SEPARATOR: - gtk_dialog_set_has_separator (dialog, g_value_get_boolean (value)); - break; - - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -gtk_dialog_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) -{ - GtkDialog *dialog; - - dialog = GTK_DIALOG (object); - - switch (prop_id) - { - case PROP_HAS_SEPARATOR: - g_value_set_boolean (value, dialog->separator != NULL); - break; + if (strcmp (childname, "vbox") == 0) + return G_OBJECT (priv->vbox); + else if (strcmp (childname, "action_area") == 0) + return G_OBJECT (priv->action_area); - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } + return parent_buildable_iface->get_internal_child (buildable, + builder, + childname); } -static gint +static gboolean gtk_dialog_delete_event_handler (GtkWidget *widget, GdkEventAny *event, gpointer user_data) @@ -374,58 +456,65 @@ gtk_dialog_delete_event_handler (GtkWidget *widget, static void gtk_dialog_map (GtkWidget *widget) { + GtkWidget *default_widget, *focus; GtkWindow *window = GTK_WINDOW (widget); GtkDialog *dialog = GTK_DIALOG (widget); - + GtkDialogPrivate *priv = dialog->priv; + GTK_WIDGET_CLASS (gtk_dialog_parent_class)->map (widget); - if (!window->focus_widget) + focus = gtk_window_get_focus (window); + if (!focus) { GList *children, *tmp_list; GtkWidget *first_focus = NULL; - - do - { - g_signal_emit_by_name (window, "move_focus", GTK_DIR_TAB_FORWARD); - if (first_focus == NULL) - first_focus = window->focus_widget; - else if (first_focus == window->focus_widget) - break; + do + { + g_signal_emit_by_name (window, "move_focus", GTK_DIR_TAB_FORWARD); - if (!GTK_IS_LABEL (window->focus_widget)) - break; - else - gtk_label_select_region (GTK_LABEL (window->focus_widget), 0, 0); - } + focus = gtk_window_get_focus (window); + if (GTK_IS_LABEL (focus) && + !gtk_label_get_current_uri (GTK_LABEL (focus))) + gtk_label_select_region (GTK_LABEL (focus), 0, 0); + + if (first_focus == NULL) + first_focus = focus; + else if (first_focus == focus) + break; + + if (!GTK_IS_LABEL (focus)) + break; + } while (TRUE); - tmp_list = children = gtk_container_get_children (GTK_CONTAINER (dialog->action_area)); - + tmp_list = children = gtk_container_get_children (GTK_CONTAINER (priv->action_area)); + while (tmp_list) { GtkWidget *child = tmp_list->data; - - if ((window->focus_widget == NULL || - child == window->focus_widget) && - child != window->default_widget && - window->default_widget) + + default_widget = gtk_window_get_default_widget (window); + if ((focus == NULL || child == focus) && + child != default_widget && + default_widget) { - gtk_widget_grab_focus (window->default_widget); + gtk_widget_grab_focus (default_widget); break; } - + tmp_list = tmp_list->next; } - + g_list_free (children); } } static void -gtk_dialog_style_set (GtkWidget *widget, - GtkStyle *prev_style) +gtk_dialog_style_updated (GtkWidget *widget) { + GTK_WIDGET_CLASS (gtk_dialog_parent_class)->style_updated (widget); + update_spacings (GTK_DIALOG (widget)); } @@ -433,15 +522,16 @@ static GtkWidget * dialog_find_button (GtkDialog *dialog, gint response_id) { - GList *children, *tmp_list; + GtkDialogPrivate *priv = dialog->priv; GtkWidget *child = NULL; - - children = gtk_container_get_children (GTK_CONTAINER (dialog->action_area)); + GList *children, *tmp_list; + + children = gtk_container_get_children (GTK_CONTAINER (priv->action_area)); for (tmp_list = children; tmp_list; tmp_list = tmp_list->next) { ResponseData *rd = get_response_data (tmp_list->data, FALSE); - + if (rd && rd->response_id == response_id) { child = tmp_list->data; @@ -458,19 +548,29 @@ static void gtk_dialog_close (GtkDialog *dialog) { /* Synthesize delete_event to close dialog. */ - + GtkWidget *widget = GTK_WIDGET (dialog); GdkEvent *event; event = gdk_event_new (GDK_DELETE); - - event->any.window = g_object_ref (widget->window); + + event->any.window = g_object_ref (gtk_widget_get_window (widget)); event->any.send_event = TRUE; - + gtk_main_do_event (event); gdk_event_free (event); } +/** + * gtk_dialog_new: + * + * Creates a new dialog box. + * + * Widgets should not be packed into this #GtkWindow + * directly, but into the @vbox and @action_area, as described above. + * + * Returns: the new dialog as a #GtkWidget + */ GtkWidget* gtk_dialog_new (void) { @@ -494,24 +594,21 @@ gtk_dialog_new_empty (const gchar *title, if (flags & GTK_DIALOG_MODAL) gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); - + if (flags & GTK_DIALOG_DESTROY_WITH_PARENT) gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE); - if (flags & GTK_DIALOG_NO_SEPARATOR) - gtk_dialog_set_has_separator (dialog, FALSE); - return GTK_WIDGET (dialog); } /** * gtk_dialog_new_with_buttons: - * @title: Title of the dialog, or %NULL - * @parent: Transient parent of the dialog, or %NULL + * @title: (allow-none): Title of the dialog, or %NULL + * @parent: (allow-none): Transient parent of the dialog, or %NULL * @flags: from #GtkDialogFlags - * @first_button_text: stock ID or text to go in first button, or %NULL - * @Varargs: response ID for first button, then additional buttons, ending with %NULL - * + * @first_button_text: (allow-none): stock ID or text to go in first button, or %NULL + * @...: response ID for first button, then additional buttons, ending with %NULL + * * Creates a new #GtkDialog with title @title (or %NULL for the default * title; see gtk_window_set_title()) and transient parent @parent (or * %NULL for none; see gtk_window_set_transient_for()). The @flags @@ -524,10 +621,10 @@ gtk_dialog_new_empty (const gchar *title, * any positive number, or one of the values in the #GtkResponseType * enumeration. If the user clicks one of these dialog buttons, * #GtkDialog will emit the #GtkDialog::response signal with the corresponding - * response ID. If a #GtkDialog receives the #GtkWidget::delete-event signal, + * response ID. If a #GtkDialog receives the #GtkWidget::delete-event signal, * it will emit ::response with a response ID of #GTK_RESPONSE_DELETE_EVENT. * However, destroying a dialog does not emit the ::response signal; - * so be careful relying on ::response when using the + * so be careful relying on ::response when using the * #GTK_DIALOG_DESTROY_WITH_PARENT flag. Buttons are from left to right, * so the first button in the list will be the leftmost button in the dialog. * @@ -542,9 +639,9 @@ gtk_dialog_new_empty (const gchar *title, * GTK_RESPONSE_REJECT, * NULL); * ]| - * + * * Return value: a new #GtkDialog - **/ + */ GtkWidget* gtk_dialog_new_with_buttons (const gchar *title, GtkWindow *parent, @@ -554,7 +651,7 @@ gtk_dialog_new_with_buttons (const gchar *title, { GtkDialog *dialog; va_list args; - + dialog = GTK_DIALOG (gtk_dialog_new_empty (title, parent, flags)); va_start (args, first_button_text); @@ -562,13 +659,13 @@ gtk_dialog_new_with_buttons (const gchar *title, gtk_dialog_add_buttons_valist (dialog, first_button_text, args); - + va_end (args); return GTK_WIDGET (dialog); } -static void +static void response_data_free (gpointer data) { g_slice_free (ResponseData, data); @@ -584,7 +681,7 @@ get_response_data (GtkWidget *widget, if (ad == NULL && create) { ad = g_slice_new (ResponseData); - + g_object_set_data_full (G_OBJECT (widget), I_("gtk-dialog-response-data"), ad, @@ -598,7 +695,7 @@ static void action_widget_activated (GtkWidget *widget, GtkDialog *dialog) { gint response_id; - + response_id = gtk_dialog_get_response_for_widget (dialog, widget); gtk_dialog_response (dialog, response_id); @@ -609,12 +706,12 @@ action_widget_activated (GtkWidget *widget, GtkDialog *dialog) * @dialog: a #GtkDialog * @child: an activatable widget * @response_id: response ID for @child - * + * * Adds an activatable widget to the action area of a #GtkDialog, - * connecting a signal handler that will emit the #GtkDialog::response - * signal on the dialog when the widget is activated. The widget is + * connecting a signal handler that will emit the #GtkDialog::response + * signal on the dialog when the widget is activated. The widget is * appended to the end of the dialog's action area. If you want to add a - * non-activatable widget, simply pack it into the @action_area field + * non-activatable widget, simply pack it into the @action_area field * of the #GtkDialog struct. **/ void @@ -622,12 +719,15 @@ gtk_dialog_add_action_widget (GtkDialog *dialog, GtkWidget *child, gint response_id) { + GtkDialogPrivate *priv; ResponseData *ad; guint signal_id; - + g_return_if_fail (GTK_IS_DIALOG (dialog)); g_return_if_fail (GTK_IS_WIDGET (child)); + priv = dialog->priv; + ad = get_response_data (child, TRUE); ad->response_id = response_id; @@ -652,12 +752,12 @@ gtk_dialog_add_action_widget (GtkDialog *dialog, else g_warning ("Only 'activatable' widgets can be packed into the action area of a GtkDialog"); - gtk_box_pack_end (GTK_BOX (dialog->action_area), + gtk_box_pack_end (GTK_BOX (priv->action_area), child, FALSE, TRUE, 0); - + if (response_id == GTK_RESPONSE_HELP) - gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (dialog->action_area), child, TRUE); + gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (priv->action_area), child, TRUE); } /** @@ -665,14 +765,14 @@ gtk_dialog_add_action_widget (GtkDialog *dialog, * @dialog: a #GtkDialog * @button_text: text of button, or stock ID * @response_id: response ID for the button - * + * * Adds a button with the given text (or a stock button, if @button_text is a * stock ID) and sets things up so that clicking the button will emit the - * #GtkDialog::response signal with the given @response_id. The button is - * appended to the end of the dialog's action area. The button widget is + * #GtkDialog::response signal with the given @response_id. The button is + * appended to the end of the dialog's action area. The button widget is * returned, but usually you don't need it. * - * Return value: the button widget that was added + * Return value: (transfer none): the #GtkButton widget that was added **/ GtkWidget* gtk_dialog_add_button (GtkDialog *dialog, @@ -680,16 +780,16 @@ gtk_dialog_add_button (GtkDialog *dialog, gint response_id) { GtkWidget *button; - + g_return_val_if_fail (GTK_IS_DIALOG (dialog), NULL); g_return_val_if_fail (button_text != NULL, NULL); button = gtk_button_new_from_stock (button_text); - GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); - + gtk_widget_set_can_default (button, TRUE); + gtk_widget_show (button); - + gtk_dialog_add_action_widget (dialog, button, response_id); @@ -706,10 +806,10 @@ gtk_dialog_add_buttons_valist (GtkDialog *dialog, gint response_id; g_return_if_fail (GTK_IS_DIALOG (dialog)); - + if (first_button_text == NULL) return; - + text = first_button_text; response_id = va_arg (args, gint); @@ -728,18 +828,18 @@ gtk_dialog_add_buttons_valist (GtkDialog *dialog, * gtk_dialog_add_buttons: * @dialog: a #GtkDialog * @first_button_text: button text or stock ID - * @Varargs: response ID for first button, then more text-response_id pairs - * + * @...: response ID for first button, then more text-response_id pairs + * * Adds more buttons, same as calling gtk_dialog_add_button() * repeatedly. The variable argument list should be %NULL-terminated * as with gtk_dialog_new_with_buttons(). Each button must have both * text and response ID. - **/ + */ void gtk_dialog_add_buttons (GtkDialog *dialog, const gchar *first_button_text, ...) -{ +{ va_list args; va_start (args, first_button_text); @@ -747,7 +847,7 @@ gtk_dialog_add_buttons (GtkDialog *dialog, gtk_dialog_add_buttons_valist (dialog, first_button_text, args); - + va_end (args); } @@ -757,7 +857,7 @@ gtk_dialog_add_buttons (GtkDialog *dialog, * @response_id: a response ID * @setting: %TRUE for sensitive * - * Calls gtk_widget_set_sensitive (widget, @setting) + * Calls gtk_widget_set_sensitive (widget, @setting) * for each widget in the dialog's action area with the given @response_id. * A convenient way to sensitize/desensitize dialog buttons. **/ @@ -766,12 +866,15 @@ gtk_dialog_set_response_sensitive (GtkDialog *dialog, gint response_id, gboolean setting) { + GtkDialogPrivate *priv; GList *children; GList *tmp_list; g_return_if_fail (GTK_IS_DIALOG (dialog)); - children = gtk_container_get_children (GTK_CONTAINER (dialog->action_area)); + priv = dialog->priv; + + children = gtk_container_get_children (GTK_CONTAINER (priv->action_area)); tmp_list = children; while (tmp_list != NULL) @@ -792,7 +895,7 @@ gtk_dialog_set_response_sensitive (GtkDialog *dialog, * gtk_dialog_set_default_response: * @dialog: a #GtkDialog * @response_id: a response ID - * + * * Sets the last widget in the dialog's action area with the given @response_id * as the default widget for the dialog. Pressing "Enter" normally activates * the default widget. @@ -801,12 +904,15 @@ void gtk_dialog_set_default_response (GtkDialog *dialog, gint response_id) { + GtkDialogPrivate *priv; GList *children; GList *tmp_list; g_return_if_fail (GTK_IS_DIALOG (dialog)); - children = gtk_container_get_children (GTK_CONTAINER (dialog->action_area)); + priv = dialog->priv; + + children = gtk_container_get_children (GTK_CONTAINER (priv->action_area)); tmp_list = children; while (tmp_list != NULL) @@ -816,82 +922,19 @@ gtk_dialog_set_default_response (GtkDialog *dialog, if (rd && rd->response_id == response_id) gtk_widget_grab_default (widget); - + tmp_list = g_list_next (tmp_list); } g_list_free (children); } -/** - * gtk_dialog_set_has_separator: - * @dialog: a #GtkDialog - * @setting: %TRUE to have a separator - * - * Sets whether the dialog has a separator above the buttons. - * %TRUE by default. - **/ -void -gtk_dialog_set_has_separator (GtkDialog *dialog, - gboolean setting) -{ - GtkDialogPrivate *priv; - - g_return_if_fail (GTK_IS_DIALOG (dialog)); - - priv = GET_PRIVATE (dialog); - - /* this might fail if we get called before _init() somehow */ - g_assert (dialog->vbox != NULL); - - if (priv->ignore_separator) - { - g_warning ("Ignoring the separator setting"); - return; - } - - if (setting && dialog->separator == NULL) - { - dialog->separator = gtk_hseparator_new (); - gtk_box_pack_end (GTK_BOX (dialog->vbox), dialog->separator, FALSE, TRUE, 0); - - /* The app programmer could screw this up, but, their own fault. - * Moves the separator just above the action area. - */ - gtk_box_reorder_child (GTK_BOX (dialog->vbox), dialog->separator, 1); - gtk_widget_show (dialog->separator); - } - else if (!setting && dialog->separator != NULL) - { - gtk_widget_destroy (dialog->separator); - dialog->separator = NULL; - } - - g_object_notify (G_OBJECT (dialog), "has-separator"); -} - -/** - * gtk_dialog_get_has_separator: - * @dialog: a #GtkDialog - * - * Accessor for whether the dialog has a separator. - * - * Return value: %TRUE if the dialog has a separator - **/ -gboolean -gtk_dialog_get_has_separator (GtkDialog *dialog) -{ - g_return_val_if_fail (GTK_IS_DIALOG (dialog), FALSE); - - return dialog->separator != NULL; -} - /** * gtk_dialog_response: * @dialog: a #GtkDialog - * @response_id: response ID - * - * Emits the #GtkDialog::response signal with the given response ID. + * @response_id: response ID + * + * Emits the #GtkDialog::response signal with the given response ID. * Used to indicate that the user has responded to the dialog in some way; * typically either you or gtk_dialog_run() will be monitoring the * ::response signal and take appropriate action. @@ -951,9 +994,9 @@ run_delete_handler (GtkDialog *dialog, gpointer data) { RunInfo *ri = data; - + shutdown_loop (ri); - + return TRUE; /* Do not destroy */ } @@ -963,31 +1006,31 @@ run_destroy_handler (GtkDialog *dialog, gpointer data) RunInfo *ri = data; /* shutdown_loop will be called by run_unmap_handler */ - + ri->destroyed = TRUE; } /** * gtk_dialog_run: * @dialog: a #GtkDialog - * + * * Blocks in a recursive main loop until the @dialog either emits the - * #GtkDialog::response signal, or is destroyed. If the dialog is - * destroyed during the call to gtk_dialog_run(), gtk_dialog_run() returns - * #GTK_RESPONSE_NONE. Otherwise, it returns the response ID from the + * #GtkDialog::response signal, or is destroyed. If the dialog is + * destroyed during the call to gtk_dialog_run(), gtk_dialog_run() returns + * #GTK_RESPONSE_NONE. Otherwise, it returns the response ID from the * ::response signal emission. * * Before entering the recursive main loop, gtk_dialog_run() calls * gtk_widget_show() on the dialog for you. Note that you still * need to show any children of the dialog yourself. * - * During gtk_dialog_run(), the default behavior of #GtkWidget::delete-event + * During gtk_dialog_run(), the default behavior of #GtkWidget::delete-event * is disabled; if the dialog receives ::delete_event, it will not be * destroyed as windows usually are, and gtk_dialog_run() will return - * #GTK_RESPONSE_DELETE_EVENT. Also, during gtk_dialog_run() the dialog + * #GTK_RESPONSE_DELETE_EVENT. Also, during gtk_dialog_run() the dialog * will be modal. You can force gtk_dialog_run() to return at any time by - * calling gtk_dialog_response() to emit the ::response signal. Destroying - * the dialog during gtk_dialog_run() is a very bad idea, because your + * calling gtk_dialog_response() to emit the ::response signal. Destroying + * the dialog during gtk_dialog_run() is a very bad idea, because your * post-run code won't know whether the dialog was destroyed or not. * * After gtk_dialog_run() returns, you are responsible for hiding or @@ -1007,13 +1050,13 @@ run_destroy_handler (GtkDialog *dialog, gpointer data) * } * gtk_widget_destroy (dialog); * ]| - * + * * Note that even though the recursive main loop gives the effect of a - * modal dialog (it prevents the user from interacting with other - * windows in the same window group while the dialog is run), callbacks - * such as timeouts, IO channel watches, DND drops, etc, will + * modal dialog (it prevents the user from interacting with other + * windows in the same window group while the dialog is run), callbacks + * such as timeouts, IO channel watches, DND drops, etc, will * be triggered during a gtk_dialog_run() call. - * + * * Return value: response ID **/ gint @@ -1025,57 +1068,57 @@ gtk_dialog_run (GtkDialog *dialog) gulong unmap_handler; gulong destroy_handler; gulong delete_handler; - + g_return_val_if_fail (GTK_IS_DIALOG (dialog), -1); g_object_ref (dialog); - was_modal = GTK_WINDOW (dialog)->modal; + was_modal = gtk_window_get_modal (GTK_WINDOW (dialog)); if (!was_modal) gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); - if (!GTK_WIDGET_VISIBLE (dialog)) + if (!gtk_widget_get_visible (GTK_WIDGET (dialog))) gtk_widget_show (GTK_WIDGET (dialog)); - + response_handler = g_signal_connect (dialog, "response", G_CALLBACK (run_response_handler), &ri); - + unmap_handler = g_signal_connect (dialog, "unmap", G_CALLBACK (run_unmap_handler), &ri); - + delete_handler = g_signal_connect (dialog, "delete-event", G_CALLBACK (run_delete_handler), &ri); - + destroy_handler = g_signal_connect (dialog, "destroy", G_CALLBACK (run_destroy_handler), &ri); - + ri.loop = g_main_loop_new (NULL, FALSE); - GDK_THREADS_LEAVE (); + gdk_threads_leave (); g_main_loop_run (ri.loop); - GDK_THREADS_ENTER (); + gdk_threads_enter (); g_main_loop_unref (ri.loop); ri.loop = NULL; - + if (!ri.destroyed) { if (!was_modal) gtk_window_set_modal (GTK_WINDOW(dialog), FALSE); - + g_signal_handler_disconnect (dialog, response_handler); g_signal_handler_disconnect (dialog, unmap_handler); g_signal_handler_disconnect (dialog, delete_handler); @@ -1087,14 +1130,51 @@ gtk_dialog_run (GtkDialog *dialog) return ri.response_id; } -void -_gtk_dialog_set_ignore_separator (GtkDialog *dialog, - gboolean ignore_separator) +/** + * gtk_dialog_get_widget_for_response: + * @dialog: a #GtkDialog + * @response_id: the response ID used by the @dialog widget + * + * Gets the widget button that uses the given response ID in the action area + * of a dialog. + * + * Returns: (transfer none): the @widget button that uses the given + * @response_id, or %NULL. + * + * Since: 2.20 + */ +GtkWidget* +gtk_dialog_get_widget_for_response (GtkDialog *dialog, + gint response_id) { GtkDialogPrivate *priv; + GList *children; + GList *tmp_list; + + g_return_val_if_fail (GTK_IS_DIALOG (dialog), NULL); + + priv = dialog->priv; + + children = gtk_container_get_children (GTK_CONTAINER (priv->action_area)); + + tmp_list = children; + while (tmp_list != NULL) + { + GtkWidget *widget = tmp_list->data; + ResponseData *rd = get_response_data (widget, FALSE); + + if (rd && rd->response_id == response_id) + { + g_list_free (children); + return widget; + } + + tmp_list = g_list_next (tmp_list); + } + + g_list_free (children); - priv = GET_PRIVATE (dialog); - priv->ignore_separator = ignore_separator; + return NULL; } /** @@ -1125,23 +1205,23 @@ gtk_dialog_get_response_for_widget (GtkDialog *dialog, /** * gtk_alternative_dialog_button_order: - * @screen: a #GdkScreen, or %NULL to use the default screen + * @screen: (allow-none): a #GdkScreen, or %NULL to use the default screen * * Returns %TRUE if dialogs are expected to use an alternative - * button order on the screen @screen. See + * button order on the screen @screen. See * gtk_dialog_set_alternative_button_order() for more details - * about alternative button order. + * about alternative button order. * * If you need to use this function, you should probably connect * to the ::notify:gtk-alternative-button-order signal on the - * #GtkSettings object associated to @screen, in order to be + * #GtkSettings object associated to @screen, in order to be * notified if the button order setting changes. * * Returns: Whether the alternative button order should be used * * Since: 2.6 */ -gboolean +gboolean gtk_alternative_dialog_button_order (GdkScreen *screen) { GtkSettings *settings; @@ -1151,7 +1231,7 @@ gtk_alternative_dialog_button_order (GdkScreen *screen) settings = gtk_settings_get_for_screen (screen); else settings = gtk_settings_get_default (); - + g_object_get (settings, "gtk-alternative-button-order", &result, NULL); @@ -1163,6 +1243,7 @@ gtk_dialog_set_alternative_button_order_valist (GtkDialog *dialog, gint first_response_id, va_list args) { + GtkDialogPrivate *priv = dialog->priv; GtkWidget *child; gint response_id; gint position; @@ -1173,7 +1254,7 @@ gtk_dialog_set_alternative_button_order_valist (GtkDialog *dialog, { /* reorder child with response_id to position */ child = dialog_find_button (dialog, response_id); - gtk_box_reorder_child (GTK_BOX (dialog->action_area), child, position); + gtk_box_reorder_child (GTK_BOX (priv->action_area), child, position); response_id = va_arg (args, gint); position++; @@ -1184,54 +1265,54 @@ gtk_dialog_set_alternative_button_order_valist (GtkDialog *dialog, * gtk_dialog_set_alternative_button_order: * @dialog: a #GtkDialog * @first_response_id: a response id used by one @dialog's buttons - * @Varargs: a list of more response ids of @dialog's buttons, terminated by -1 + * @...: a list of more response ids of @dialog's buttons, terminated by -1 * - * Sets an alternative button order. If the - * #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, - * the dialog buttons are reordered according to the order of the + * Sets an alternative button order. If the + * #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, + * the dialog buttons are reordered according to the order of the * response ids passed to this function. * - * By default, GTK+ dialogs use the button order advocated by the Gnome - * Human - * Interface Guidelines with the affirmative button at the far + * By default, GTK+ dialogs use the button order advocated by the Gnome + * Human + * Interface Guidelines with the affirmative button at the far * right, and the cancel button left of it. But the builtin GTK+ dialogs * and #GtkMessageDialogs do provide an alternative button order, * which is more suitable on some platforms, e.g. Windows. * - * Use this function after adding all the buttons to your dialog, as the + * Use this function after adding all the buttons to your dialog, as the * following example shows: * |[ * cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog), * GTK_STOCK_CANCEL, * GTK_RESPONSE_CANCEL); - * + * * ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog), * GTK_STOCK_OK, * GTK_RESPONSE_OK); - * + * * gtk_widget_grab_default (ok_button); - * + * * help_button = gtk_dialog_add_button (GTK_DIALOG (dialog), * GTK_STOCK_HELP, * GTK_RESPONSE_HELP); - * + * * gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), * GTK_RESPONSE_OK, * GTK_RESPONSE_CANCEL, * GTK_RESPONSE_HELP, * -1); * ]| - * + * * Since: 2.6 */ -void +void gtk_dialog_set_alternative_button_order (GtkDialog *dialog, gint first_response_id, ...) { GdkScreen *screen; va_list args; - + g_return_if_fail (GTK_IS_DIALOG (dialog)); screen = gtk_widget_get_screen (GTK_WIDGET (dialog)); @@ -1249,24 +1330,26 @@ gtk_dialog_set_alternative_button_order (GtkDialog *dialog, * gtk_dialog_set_alternative_button_order_from_array: * @dialog: a #GtkDialog * @n_params: the number of response ids in @new_order - * @new_order: an array of response ids of @dialog's buttons + * @new_order: (array length=n_params): an array of response ids of + * @dialog's buttons * - * Sets an alternative button order. If the - * #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, - * the dialog buttons are reordered according to the order of the + * Sets an alternative button order. If the + * #GtkSettings:gtk-alternative-button-order setting is set to %TRUE, + * the dialog buttons are reordered according to the order of the * response ids in @new_order. * * See gtk_dialog_set_alternative_button_order() for more information. * * This function is for use by language bindings. - * + * * Since: 2.6 */ -void +void gtk_dialog_set_alternative_button_order_from_array (GtkDialog *dialog, gint n_params, gint *new_order) { + GtkDialogPrivate *priv = dialog->priv; GdkScreen *screen; GtkWidget *child; gint position; @@ -1282,7 +1365,7 @@ gtk_dialog_set_alternative_button_order_from_array (GtkDialog *dialog, { /* reorder child with response_id to position */ child = dialog_find_button (dialog, new_order[position]); - gtk_box_reorder_child (GTK_BOX (dialog->action_area), child, position); + gtk_box_reorder_child (GTK_BOX (priv->action_area), child, position); } } @@ -1348,7 +1431,7 @@ static const GMarkupParser attributes_parser = attributes_text_element, }; -gboolean +static gboolean gtk_dialog_buildable_custom_tag_start (GtkBuildable *buildable, GtkBuilder *builder, GObject *child, @@ -1383,13 +1466,14 @@ gtk_dialog_buildable_custom_finished (GtkBuildable *buildable, const gchar *tagname, gpointer user_data) { + GtkDialog *dialog = GTK_DIALOG (buildable); + GtkDialogPrivate *priv = dialog->priv; GSList *l; ActionWidgetsSubParserData *parser_data; GObject *object; - GtkDialog *dialog; ResponseData *ad; guint signal_id; - + if (strcmp (tagname, "action-widgets")) { parent_buildable_iface->custom_finished (buildable, builder, child, @@ -1397,7 +1481,6 @@ gtk_dialog_buildable_custom_finished (GtkBuildable *buildable, return; } - dialog = GTK_DIALOG (buildable); parser_data = (ActionWidgetsSubParserData*)user_data; parser_data->items = g_slist_reverse (parser_data->items); @@ -1415,17 +1498,17 @@ gtk_dialog_buildable_custom_finished (GtkBuildable *buildable, } ad = get_response_data (GTK_WIDGET (object), TRUE); - ad->response_id = atoi (item->response_id); + ad->response_id = g_ascii_strtoll (item->response_id, NULL, 10); if (GTK_IS_BUTTON (object)) signal_id = g_signal_lookup ("clicked", GTK_TYPE_BUTTON); else signal_id = GTK_WIDGET_GET_CLASS (object)->activate_signal; - + if (signal_id) { GClosure *closure; - + closure = g_cclosure_new_object (G_CALLBACK (action_widget_activated), G_OBJECT (dialog)); g_signal_connect_closure_by_id (object, @@ -1436,7 +1519,7 @@ gtk_dialog_buildable_custom_finished (GtkBuildable *buildable, } if (ad->response_id == GTK_RESPONSE_HELP) - gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (dialog->action_area), + gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (priv->action_area), GTK_WIDGET (object), TRUE); g_free (item->widget_name); @@ -1453,7 +1536,7 @@ gtk_dialog_buildable_custom_finished (GtkBuildable *buildable, * * Returns the action area of @dialog. * - * Returns: the action area. + * Returns: (transfer none): the action area. * * Since: 2.14 **/ @@ -1462,7 +1545,7 @@ gtk_dialog_get_action_area (GtkDialog *dialog) { g_return_val_if_fail (GTK_IS_DIALOG (dialog), NULL); - return dialog->action_area; + return dialog->priv->action_area; } /** @@ -1471,7 +1554,7 @@ gtk_dialog_get_action_area (GtkDialog *dialog) * * Returns the content area of @dialog. * - * Returns: the content area #GtkVBox. + * Returns: (transfer none): the content area #GtkBox. * * Since: 2.14 **/ @@ -1480,8 +1563,5 @@ gtk_dialog_get_content_area (GtkDialog *dialog) { g_return_val_if_fail (GTK_IS_DIALOG (dialog), NULL); - return dialog->vbox; + return dialog->priv->vbox; } - -#define __GTK_DIALOG_C__ -#include "gtkaliasdef.c"