diff options
29 files changed, 1986 insertions, 118 deletions
@@ -1,3 +1,57 @@ +2000-10-04 Havoc Pennington <hp@redhat.com> + + * gtk/testgtk.c (create_buttons): create some stock buttons + with the default accel group + (create_image): test some new GtkImage features + (make_message_dialog): test GtkMessageDialog + (create_modal_window): fix someone's bizzarro indentation + + * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement + GTK_WIN_POS_CENTER_ON_PARENT. + Add "destroy with parent" setting, which means the window goes + away with its transient parent. + (gtk_window_get_default_accel_group): get the default accel group + for the window. + (gtk_window_set_destroy_with_parent): set/unset destroy with + parent flag + (gtk_window_read_rcfiles): invalidate icon set caches + after reloading rcfiles + + * gtk/gtkenums.h (GtkWindowPosition): add + GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog + on its parent window when the dialog is mapped for the first time. + + * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add + a simple message dialog class + + * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event + handler to emit response signal, and maybe later it would + honor a hide_on_delete flag - though that isn't there yet. + Set border width on the vbox to 2, so we get some padding. + Use a button box for the action area. + (gtk_dialog_key_press): synthesize a delete event if Esc + is pressed and the GtkWidget key press handler didn't + handle the escape key. + (gtk_dialog_new_with_buttons): new function creates a dialog + with some default buttons in it. + (gtk_dialog_add_action_widget): add an activatable widget + as a button in the dialog - you can also add a non-activatable + widget by accessing the action area directly. + (gtk_dialog_add_button): add a simple button - stock ID or + label - to the action area + (gtk_dialog_response): emit response signal + (gtk_dialog_run): block waiting for the dialog, return + the response. Override normal delete_event behavior, so that + delete_event does nothing inside gtk_dialog_run(). + + * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal + emitted when an action widget is clicked or the dialog gets + delete_event + + * gtk/gtk.h: add gtkmessagedialog.h + + * gtk/Makefile.am: add gtkmessagedialog.[hc] + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0 index 1a2399d2df..7193b0aae5 100644 --- a/ChangeLog.pre-2-0 +++ b/ChangeLog.pre-2-0 @@ -1,3 +1,57 @@ +2000-10-04 Havoc Pennington <hp@redhat.com> + + * gtk/testgtk.c (create_buttons): create some stock buttons + with the default accel group + (create_image): test some new GtkImage features + (make_message_dialog): test GtkMessageDialog + (create_modal_window): fix someone's bizzarro indentation + + * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement + GTK_WIN_POS_CENTER_ON_PARENT. + Add "destroy with parent" setting, which means the window goes + away with its transient parent. + (gtk_window_get_default_accel_group): get the default accel group + for the window. + (gtk_window_set_destroy_with_parent): set/unset destroy with + parent flag + (gtk_window_read_rcfiles): invalidate icon set caches + after reloading rcfiles + + * gtk/gtkenums.h (GtkWindowPosition): add + GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog + on its parent window when the dialog is mapped for the first time. + + * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add + a simple message dialog class + + * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event + handler to emit response signal, and maybe later it would + honor a hide_on_delete flag - though that isn't there yet. + Set border width on the vbox to 2, so we get some padding. + Use a button box for the action area. + (gtk_dialog_key_press): synthesize a delete event if Esc + is pressed and the GtkWidget key press handler didn't + handle the escape key. + (gtk_dialog_new_with_buttons): new function creates a dialog + with some default buttons in it. + (gtk_dialog_add_action_widget): add an activatable widget + as a button in the dialog - you can also add a non-activatable + widget by accessing the action area directly. + (gtk_dialog_add_button): add a simple button - stock ID or + label - to the action area + (gtk_dialog_response): emit response signal + (gtk_dialog_run): block waiting for the dialog, return + the response. Override normal delete_event behavior, so that + delete_event does nothing inside gtk_dialog_run(). + + * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal + emitted when an action widget is clicked or the dialog gets + delete_event + + * gtk/gtk.h: add gtkmessagedialog.h + + * gtk/Makefile.am: add gtkmessagedialog.[hc] + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index 1a2399d2df..7193b0aae5 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,57 @@ +2000-10-04 Havoc Pennington <hp@redhat.com> + + * gtk/testgtk.c (create_buttons): create some stock buttons + with the default accel group + (create_image): test some new GtkImage features + (make_message_dialog): test GtkMessageDialog + (create_modal_window): fix someone's bizzarro indentation + + * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement + GTK_WIN_POS_CENTER_ON_PARENT. + Add "destroy with parent" setting, which means the window goes + away with its transient parent. + (gtk_window_get_default_accel_group): get the default accel group + for the window. + (gtk_window_set_destroy_with_parent): set/unset destroy with + parent flag + (gtk_window_read_rcfiles): invalidate icon set caches + after reloading rcfiles + + * gtk/gtkenums.h (GtkWindowPosition): add + GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog + on its parent window when the dialog is mapped for the first time. + + * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add + a simple message dialog class + + * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event + handler to emit response signal, and maybe later it would + honor a hide_on_delete flag - though that isn't there yet. + Set border width on the vbox to 2, so we get some padding. + Use a button box for the action area. + (gtk_dialog_key_press): synthesize a delete event if Esc + is pressed and the GtkWidget key press handler didn't + handle the escape key. + (gtk_dialog_new_with_buttons): new function creates a dialog + with some default buttons in it. + (gtk_dialog_add_action_widget): add an activatable widget + as a button in the dialog - you can also add a non-activatable + widget by accessing the action area directly. + (gtk_dialog_add_button): add a simple button - stock ID or + label - to the action area + (gtk_dialog_response): emit response signal + (gtk_dialog_run): block waiting for the dialog, return + the response. Override normal delete_event behavior, so that + delete_event does nothing inside gtk_dialog_run(). + + * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal + emitted when an action widget is clicked or the dialog gets + delete_event + + * gtk/gtk.h: add gtkmessagedialog.h + + * gtk/Makefile.am: add gtkmessagedialog.[hc] + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index 1a2399d2df..7193b0aae5 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,57 @@ +2000-10-04 Havoc Pennington <hp@redhat.com> + + * gtk/testgtk.c (create_buttons): create some stock buttons + with the default accel group + (create_image): test some new GtkImage features + (make_message_dialog): test GtkMessageDialog + (create_modal_window): fix someone's bizzarro indentation + + * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement + GTK_WIN_POS_CENTER_ON_PARENT. + Add "destroy with parent" setting, which means the window goes + away with its transient parent. + (gtk_window_get_default_accel_group): get the default accel group + for the window. + (gtk_window_set_destroy_with_parent): set/unset destroy with + parent flag + (gtk_window_read_rcfiles): invalidate icon set caches + after reloading rcfiles + + * gtk/gtkenums.h (GtkWindowPosition): add + GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog + on its parent window when the dialog is mapped for the first time. + + * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add + a simple message dialog class + + * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event + handler to emit response signal, and maybe later it would + honor a hide_on_delete flag - though that isn't there yet. + Set border width on the vbox to 2, so we get some padding. + Use a button box for the action area. + (gtk_dialog_key_press): synthesize a delete event if Esc + is pressed and the GtkWidget key press handler didn't + handle the escape key. + (gtk_dialog_new_with_buttons): new function creates a dialog + with some default buttons in it. + (gtk_dialog_add_action_widget): add an activatable widget + as a button in the dialog - you can also add a non-activatable + widget by accessing the action area directly. + (gtk_dialog_add_button): add a simple button - stock ID or + label - to the action area + (gtk_dialog_response): emit response signal + (gtk_dialog_run): block waiting for the dialog, return + the response. Override normal delete_event behavior, so that + delete_event does nothing inside gtk_dialog_run(). + + * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal + emitted when an action widget is clicked or the dialog gets + delete_event + + * gtk/gtk.h: add gtkmessagedialog.h + + * gtk/Makefile.am: add gtkmessagedialog.[hc] + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index 1a2399d2df..7193b0aae5 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,57 @@ +2000-10-04 Havoc Pennington <hp@redhat.com> + + * gtk/testgtk.c (create_buttons): create some stock buttons + with the default accel group + (create_image): test some new GtkImage features + (make_message_dialog): test GtkMessageDialog + (create_modal_window): fix someone's bizzarro indentation + + * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement + GTK_WIN_POS_CENTER_ON_PARENT. + Add "destroy with parent" setting, which means the window goes + away with its transient parent. + (gtk_window_get_default_accel_group): get the default accel group + for the window. + (gtk_window_set_destroy_with_parent): set/unset destroy with + parent flag + (gtk_window_read_rcfiles): invalidate icon set caches + after reloading rcfiles + + * gtk/gtkenums.h (GtkWindowPosition): add + GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog + on its parent window when the dialog is mapped for the first time. + + * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add + a simple message dialog class + + * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event + handler to emit response signal, and maybe later it would + honor a hide_on_delete flag - though that isn't there yet. + Set border width on the vbox to 2, so we get some padding. + Use a button box for the action area. + (gtk_dialog_key_press): synthesize a delete event if Esc + is pressed and the GtkWidget key press handler didn't + handle the escape key. + (gtk_dialog_new_with_buttons): new function creates a dialog + with some default buttons in it. + (gtk_dialog_add_action_widget): add an activatable widget + as a button in the dialog - you can also add a non-activatable + widget by accessing the action area directly. + (gtk_dialog_add_button): add a simple button - stock ID or + label - to the action area + (gtk_dialog_response): emit response signal + (gtk_dialog_run): block waiting for the dialog, return + the response. Override normal delete_event behavior, so that + delete_event does nothing inside gtk_dialog_run(). + + * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal + emitted when an action widget is clicked or the dialog gets + delete_event + + * gtk/gtk.h: add gtkmessagedialog.h + + * gtk/Makefile.am: add gtkmessagedialog.[hc] + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index 1a2399d2df..7193b0aae5 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,57 @@ +2000-10-04 Havoc Pennington <hp@redhat.com> + + * gtk/testgtk.c (create_buttons): create some stock buttons + with the default accel group + (create_image): test some new GtkImage features + (make_message_dialog): test GtkMessageDialog + (create_modal_window): fix someone's bizzarro indentation + + * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement + GTK_WIN_POS_CENTER_ON_PARENT. + Add "destroy with parent" setting, which means the window goes + away with its transient parent. + (gtk_window_get_default_accel_group): get the default accel group + for the window. + (gtk_window_set_destroy_with_parent): set/unset destroy with + parent flag + (gtk_window_read_rcfiles): invalidate icon set caches + after reloading rcfiles + + * gtk/gtkenums.h (GtkWindowPosition): add + GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog + on its parent window when the dialog is mapped for the first time. + + * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add + a simple message dialog class + + * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event + handler to emit response signal, and maybe later it would + honor a hide_on_delete flag - though that isn't there yet. + Set border width on the vbox to 2, so we get some padding. + Use a button box for the action area. + (gtk_dialog_key_press): synthesize a delete event if Esc + is pressed and the GtkWidget key press handler didn't + handle the escape key. + (gtk_dialog_new_with_buttons): new function creates a dialog + with some default buttons in it. + (gtk_dialog_add_action_widget): add an activatable widget + as a button in the dialog - you can also add a non-activatable + widget by accessing the action area directly. + (gtk_dialog_add_button): add a simple button - stock ID or + label - to the action area + (gtk_dialog_response): emit response signal + (gtk_dialog_run): block waiting for the dialog, return + the response. Override normal delete_event behavior, so that + delete_event does nothing inside gtk_dialog_run(). + + * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal + emitted when an action widget is clicked or the dialog gets + delete_event + + * gtk/gtk.h: add gtkmessagedialog.h + + * gtk/Makefile.am: add gtkmessagedialog.[hc] + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index 1a2399d2df..7193b0aae5 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,57 @@ +2000-10-04 Havoc Pennington <hp@redhat.com> + + * gtk/testgtk.c (create_buttons): create some stock buttons + with the default accel group + (create_image): test some new GtkImage features + (make_message_dialog): test GtkMessageDialog + (create_modal_window): fix someone's bizzarro indentation + + * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement + GTK_WIN_POS_CENTER_ON_PARENT. + Add "destroy with parent" setting, which means the window goes + away with its transient parent. + (gtk_window_get_default_accel_group): get the default accel group + for the window. + (gtk_window_set_destroy_with_parent): set/unset destroy with + parent flag + (gtk_window_read_rcfiles): invalidate icon set caches + after reloading rcfiles + + * gtk/gtkenums.h (GtkWindowPosition): add + GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog + on its parent window when the dialog is mapped for the first time. + + * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add + a simple message dialog class + + * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event + handler to emit response signal, and maybe later it would + honor a hide_on_delete flag - though that isn't there yet. + Set border width on the vbox to 2, so we get some padding. + Use a button box for the action area. + (gtk_dialog_key_press): synthesize a delete event if Esc + is pressed and the GtkWidget key press handler didn't + handle the escape key. + (gtk_dialog_new_with_buttons): new function creates a dialog + with some default buttons in it. + (gtk_dialog_add_action_widget): add an activatable widget + as a button in the dialog - you can also add a non-activatable + widget by accessing the action area directly. + (gtk_dialog_add_button): add a simple button - stock ID or + label - to the action area + (gtk_dialog_response): emit response signal + (gtk_dialog_run): block waiting for the dialog, return + the response. Override normal delete_event behavior, so that + delete_event does nothing inside gtk_dialog_run(). + + * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal + emitted when an action widget is clicked or the dialog gets + delete_event + + * gtk/gtk.h: add gtkmessagedialog.h + + * gtk/Makefile.am: add gtkmessagedialog.[hc] + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug diff --git a/docs/reference/ChangeLog b/docs/reference/ChangeLog index 5180f2406c..f1dd72d640 100644 --- a/docs/reference/ChangeLog +++ b/docs/reference/ChangeLog @@ -1,3 +1,7 @@ +2000-10-20 Havoc Pennington <hp@redhat.com> + + * gtk/gtk-sections.txt: Add dialog docs + 2000-10-18 Havoc Pennington <hp@redhat.com> * gtk/gtk-sections.txt: Some updates diff --git a/docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-unused.sgml b/docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-unused.sgml index 456531628e..85e68a93fe 100644 --- a/docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-unused.sgml +++ b/docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-unused.sgml @@ -1,3 +1,7 @@ +<!-- ##### SECTION ./tmpl/from-drawables.sgml:Title ##### --> +Drawables to Pixbufs + + <!-- ##### USER_FUNCTION GdkPixbufLastUnref ##### --> <para> A function of this type can be used to override the default @@ -15,10 +19,6 @@ @pixbuf: The pixbuf that is losing its last reference. @data: User closure data. -<!-- ##### SECTION ./tmpl/from-drawables.sgml:Title ##### --> -Drawables to Pixbufs - - <!-- ##### ARG GnomeCanvasPixbuf:height_pixels ##### --> <para> @@ -415,18 +415,18 @@ XlibRGB </para> -<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:See_Also ##### --> -<para> - -</para> - - <!-- ##### SECTION ./tmpl/from-drawables.sgml:See_Also ##### --> <para> gdk_image_get(). </para> +<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:See_Also ##### --> +<para> + +</para> + + <!-- ##### STRUCT GdkPixbufAnimationClass ##### --> <para> @@ -515,6 +515,12 @@ Getting parts of a drawable's image data into a pixbuf. </para> +<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:Long_Description ##### --> +<para> + +</para> + + <!-- ##### SECTION ./tmpl/gnome-canvas-pixbuf.sgml:Long_Description ##### --> <para> This canvas item displays #GdkPixbuf images. It handles full @@ -684,12 +690,6 @@ Getting parts of a drawable's image data into a pixbuf. </refsect2> -<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:Long_Description ##### --> -<para> - -</para> - - <!-- ##### SECTION ./tmpl/xlib-rendering.sgml:Title ##### --> Xlib Rendering diff --git a/docs/reference/gtk/gtk-sections.txt b/docs/reference/gtk/gtk-sections.txt index 2b2412ce5c..44d27b38d3 100644 --- a/docs/reference/gtk/gtk-sections.txt +++ b/docs/reference/gtk/gtk-sections.txt @@ -605,8 +605,14 @@ GTK_DATA_GET_CLASS <FILE>gtkdialog</FILE> GtkDialog <TITLE>GtkDialog</TITLE> -GtkDialogButton +GtkDialogFlags gtk_dialog_new +gtk_dialog_new_with_buttons +gtk_dialog_run +gtk_dialog_response +gtk_dialog_add_button +gtk_dialog_add_buttons +gtk_dialog_add_action_widget <SUBSECTION Standard> GTK_DIALOG GTK_IS_DIALOG @@ -1296,6 +1302,23 @@ GTK_MENU_SHELL_GET_CLASS </SECTION> <SECTION> +<FILE>gtkmessagedialog</FILE> +GtkMessageDialog +<TITLE>GtkMessageDialog</TITLE> +GtkMessageType +GtkButtonsType +gtk_message_dialog_new +<SUBSECTION Standard> +GTK_MESSAGE_DIALOG +GTK_IS_MESSAGE_DIALOG +GTK_TYPE_MESSAGE_DIALOG +gtk_message_dialog_get_type +GTK_MESSAGE_DIALOG_CLASS +GTK_IS_MESSAGE_DIALOG_CLASS +GTK_MESSAGE_DIALOG_GET_CLASS +</SECTION> + +<SECTION> <FILE>gtkmisc</FILE> <TITLE>GtkMisc</TITLE> GtkMisc @@ -2590,6 +2613,7 @@ gtk_window_set_default_size gtk_window_set_geometry_hints gtk_window_set_position gtk_window_set_transient_for +gtk_window_set_destroy_with_parent gtk_window_list_toplevels <SUBSECTION Standard> GTK_WINDOW diff --git a/docs/reference/gtk/tmpl/gtk-unused.sgml b/docs/reference/gtk/tmpl/gtk-unused.sgml index a359c75d41..ba5cfcbd5f 100644 --- a/docs/reference/gtk/tmpl/gtk-unused.sgml +++ b/docs/reference/gtk/tmpl/gtk-unused.sgml @@ -149,20 +149,20 @@ A structure used to return values from @gtk_type_query. @object_size: @class_size: -<!-- ##### MACRO gtk_widget_pop_visual ##### --> +<!-- ##### FUNCTION gtk_text_buffer_get_clipboard_contents ##### --> <para> </para> -@v: +@buffer: +@Returns: -<!-- ##### FUNCTION gtk_text_buffer_get_clipboard_contents ##### --> +<!-- ##### MACRO gtk_widget_pop_visual ##### --> <para> </para> -@buffer: -@Returns: +@v: <!-- ##### FUNCTION gtk_marshal_NONE__C_CALLBACK ##### --> <para> @@ -443,6 +443,12 @@ will not be used again. @textview: the object which received the signal. +<!-- ##### STRUCT GtkDialogButton ##### --> +<para> +Deprecated. +</para> + + <!-- ##### FUNCTION gtk_marshal_BOOL__POINTER ##### --> <para> @@ -612,16 +618,6 @@ will not be used again. @func_data: @args: -<!-- ##### FUNCTION gtk_paned_compute_position ##### --> -<para> -Internal function used by #GtkHPaned and #GtkVPaned -</para> - -@paned: -@allocation: -@child1_req: -@child2_req: - <!-- ##### FUNCTION gtk_marshal_NONE__INT_FLOAT_BOOL ##### --> <para> @@ -632,6 +628,16 @@ Internal function used by #GtkHPaned and #GtkVPaned @func_data: @args: +<!-- ##### FUNCTION gtk_paned_compute_position ##### --> +<para> +Internal function used by #GtkHPaned and #GtkVPaned +</para> + +@paned: +@allocation: +@child1_req: +@child2_req: + <!-- ##### MACRO gtk_marshal_NONE__POINTER_STRING_STRING ##### --> <para> @@ -719,21 +725,21 @@ Register a new set of flags @values and give them the name in @values: GtkFlagValue* @Returns: -<!-- ##### SIGNAL GtkTextView::scroll-text ##### --> +<!-- ##### FUNCTION gtk_selection_clear_targets ##### --> <para> </para> -@textview: the object which received the signal. -@arg1: +@widget: +@selection: -<!-- ##### FUNCTION gtk_selection_clear_targets ##### --> +<!-- ##### SIGNAL GtkTextView::scroll-text ##### --> <para> </para> -@widget: -@selection: +@textview: the object which received the signal. +@arg1: <!-- ##### ENUM GtkPrivateFlags ##### --> <para> @@ -949,8 +955,7 @@ Get the varargs type associated with @foreign_type </para> @clipboard: -@Returns: -<!-- +@Returns: <!-- Local variables: mode: sgml sgml-parent-document: ("../gtk-docs.sgml" "book" "refsect2" "") @@ -1325,14 +1330,6 @@ gtkenums.sgml @func_data: @args: -<!-- ##### USER_FUNCTION GtkMenuCallback ##### --> -<para> - -</para> - -@widget: -@user_data: - <!-- ##### FUNCTION gtk_type_check_object_cast ##### --> <para> Given a pointer to a GtkTypeObject @type_object, and a GtkType @cast_type, @@ -1343,6 +1340,14 @@ make sure that it's okay to cast @type_object into a @cast_type. @cast_type: GtkType @Returns: the same GtkTypeObject* as @type_object +<!-- ##### USER_FUNCTION GtkMenuCallback ##### --> +<para> + +</para> + +@widget: +@user_data: + <!-- ##### FUNCTION gtk_themes_exit ##### --> <para> @@ -1381,13 +1386,13 @@ will be informed that the attempt to get the data failed. @user_data_or_owner: the @user_data argument passed to gtk_clipboard_set_with_data(), or the @owner argument passed to gtk_clipboard_set_owner() -<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:Long_Description ##### --> +<!-- ##### MACRO gtk_marshal_NONE__OBJECT ##### --> <para> </para> -<!-- ##### MACRO gtk_marshal_NONE__OBJECT ##### --> +<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:Long_Description ##### --> <para> </para> @@ -1637,13 +1642,12 @@ Internal function. </para> -<!-- ##### MACRO gtk_widget_push_visual ##### --> +<!-- ##### FUNCTION gtk_container_register_toplevel ##### --> <para> </para> -@v: -@visual: +@container: <!-- ##### MACRO gtk_marshal_ENUM__ENUM ##### --> <para> @@ -1651,12 +1655,13 @@ Internal function. </para> -<!-- ##### FUNCTION gtk_container_register_toplevel ##### --> +<!-- ##### MACRO gtk_widget_push_visual ##### --> <para> </para> -@container: +@v: +@visual: <!-- ##### SECTION ./tmpl/gtkimcontextsimple.sgml:Title ##### --> GtkIMContextSimple diff --git a/docs/reference/gtk/tmpl/gtkdialog.sgml b/docs/reference/gtk/tmpl/gtkdialog.sgml index 9c0b709470..4bc84eba01 100644 --- a/docs/reference/gtk/tmpl/gtkdialog.sgml +++ b/docs/reference/gtk/tmpl/gtkdialog.sgml @@ -6,56 +6,91 @@ GtkDialog create popup windows. <!-- ##### SECTION Long_Description ##### --> + <para> Dialog boxes are a convenient way to prompt the user for a small amount of -input, eg. to display -a message, ask a question, or anything else that does not require extensive -effort on the user's part. +input, eg. to display a message, ask a question, or anything else that does not +require extensive effort on the user's part. </para> + <para> Gtk+ treats a dialog as a window split horizontally. The top section is a #GtkVBox, and is where widgets such as a #GtkLabel or a #GtkEntry should be -packed. The second area is known as the <structfield>action_area</structfield>. This is generally used -for packing buttons into the dialog which may perform functions such as cancel, ok, or apply. The two -areas are separated by a #GtkHSeparator. +packed. The second area is known as the +<structfield>action_area</structfield>. This is generally used for packing +buttons into the dialog which may perform functions such as cancel, ok, or +apply. The two areas are separated by a #GtkHSeparator. </para> + <para> -#GtkDialog boxes are created with a call to gtk_dialog_new(). +#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. </para> + <para> If 'dialog' is a newly created dialog, the two primary areas of the window can be accessed as GTK_DIALOG(dialog)->vbox and GTK_DIALOG(dialog)->action_area, as can be seen from the example, below. </para> + +<para> +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. +</para> + <para> -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. +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 +"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 +"response" signal will be emitted with a response ID of GTK_RESPONSE_NONE. </para> + + <para> +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. +</para> + +<para> +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. <example> -<title>Using a #GtkDialog to keep the user informed.</title> +<title>Simple #GtkDialog usage.</title> <programlisting> /* Function to open a dialog box displaying the message provided. */ void quick_message(#gchar *message) { - #GtkWidget *dialog, *label, *okay_button; + #GtkWidget *dialog, *label; /* Create the widgets */ - dialog = gtk_dialog_new(); + dialog = gtk_dialog_new_with_buttons ("Message", + main_application_window, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_STOCK_BUTTON_OK, + GTK_RESPONSE_NONE, + NULL); label = gtk_label_new (message); - okay_button = gtk_button_new_with_label("Okay"); - /* Ensure that the dialog box is destroyed when the user clicks ok. */ + /* Ensure that the dialog box is destroyed when the user responds. */ - gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked", - GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog); - gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), - okay_button); + gtk_signal_connect_object (GTK_OBJECT (dialog), "response", + GTK_SIGNAL_FUNC (gtk_widget_destroy), + GTK_OBJECT (dialog)); /* Add the label, and show everything we've added to the dialog. */ @@ -102,11 +137,13 @@ gtk_window_set_title(). See the #GtkWindow section for more). </para> -<!-- ##### STRUCT GtkDialogButton ##### --> +<!-- ##### ENUM GtkDialogFlags ##### --> <para> -Deprecated. + </para> +@GTK_DIALOG_MODAL: +@GTK_DIALOG_DESTROY_WITH_PARENT: <!-- ##### FUNCTION gtk_dialog_new ##### --> <para> @@ -117,3 +154,77 @@ directly, but into the vbox and action_area, as described above. @Returns: a #GtkWidget - the newly created dialog box. +<!-- ##### FUNCTION gtk_dialog_new_with_buttons ##### --> +<para> + +</para> + +@title: +@parent: +@flags: +@first_button_text: +@Varargs: +@Returns: + + +<!-- ##### FUNCTION gtk_dialog_run ##### --> +<para> + +</para> + +@dialog: +@Returns: + + +<!-- ##### FUNCTION gtk_dialog_response ##### --> +<para> + +</para> + +@dialog: +@response_id: + + +<!-- ##### FUNCTION gtk_dialog_add_button ##### --> +<para> + +</para> + +@dialog: +@button_text: +@response_id: + + +<!-- ##### FUNCTION gtk_dialog_add_buttons ##### --> +<para> + +</para> + +@dialog: +@first_button_text: +@Varargs: + + +<!-- ##### FUNCTION gtk_dialog_add_action_widget ##### --> +<para> + +</para> + +@dialog: +@child: +@response_id: +<!-- # Unused Parameters # --> +@widget: + + +<!-- ##### SIGNAL GtkDialog::response ##### --> +<para> +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_NONE. Otherwise, it depends on which action widget +was clicked. +</para> + +@dialog: the object which received the signal. +@arg1: the response ID + diff --git a/docs/reference/gtk/tmpl/gtkenums.sgml b/docs/reference/gtk/tmpl/gtkenums.sgml index 5c7195c77a..e740b63ec1 100644 --- a/docs/reference/gtk/tmpl/gtkenums.sgml +++ b/docs/reference/gtk/tmpl/gtkenums.sgml @@ -322,6 +322,7 @@ Window placement can be influenced using this enumeration. @GTK_WIN_POS_CENTER: Windows should be placed in the center of the screen. @GTK_WIN_POS_MOUSE: Windows should be placed at the current mouse position. @GTK_WIN_POS_CENTER_ALWAYS: +@GTK_WIN_POS_CENTER_ON_PARENT: <!-- ##### ENUM GtkWindowType ##### --> <para> diff --git a/docs/reference/gtk/tmpl/gtkrc.sgml b/docs/reference/gtk/tmpl/gtkrc.sgml index ba0fccecd6..f79231d519 100644 --- a/docs/reference/gtk/tmpl/gtkrc.sgml +++ b/docs/reference/gtk/tmpl/gtkrc.sgml @@ -266,7 +266,7 @@ elements are: </listitem> </varlistentry> <varlistentry> - <term><literal>stock[<replaceable>"stock-id"</replaceable>]</literal> = { <replaceable>icon source specifications</replaceable> }</literal></term> + <term><literal>stock[<replaceable>"stock-id"</replaceable>] = { <replaceable>icon source specifications</replaceable> }</literal></term> <listitem> <para> Defines the icon for a stock item. @@ -327,7 +327,7 @@ state of the widget. The states are: <listitem> <para> A color used for the background of widgets that have - been set insenstivie with gtk_widget_set_senstive() + been set insensitive with gtk_widget_set_sensitive() </para> </listitem> </varlistentry> diff --git a/docs/reference/gtk/tmpl/gtktextmark.sgml b/docs/reference/gtk/tmpl/gtktextmark.sgml index 23557ebfb2..1e7d2681a3 100644 --- a/docs/reference/gtk/tmpl/gtktextmark.sgml +++ b/docs/reference/gtk/tmpl/gtktextmark.sgml @@ -55,3 +55,12 @@ gtktextmark @mark: +<!-- ##### FUNCTION gtk_text_mark_get_deleted ##### --> +<para> + +</para> + +@mark: +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkwindow.sgml b/docs/reference/gtk/tmpl/gtkwindow.sgml index 599d833483..feb13700f8 100644 --- a/docs/reference/gtk/tmpl/gtkwindow.sgml +++ b/docs/reference/gtk/tmpl/gtkwindow.sgml @@ -219,6 +219,15 @@ it's larger @parent: +<!-- ##### FUNCTION gtk_window_set_destroy_with_parent ##### --> +<para> + +</para> + +@window: +@setting: + + <!-- ##### FUNCTION gtk_window_list_toplevels ##### --> <para> @@ -280,3 +289,8 @@ The position of the window. </para> +<!-- ##### ARG GtkWindow:destroy_with_parent ##### --> +<para> + +</para> + diff --git a/gtk/Makefile.am b/gtk/Makefile.am index 5687bde019..14921862af 100644 --- a/gtk/Makefile.am +++ b/gtk/Makefile.am @@ -122,6 +122,7 @@ gtk_public_h_sources = @STRIP_BEGIN@ \ gtkmenufactory.h \ gtkmenuitem.h \ gtkmenushell.h \ + gtkmessagedialog.h \ gtkmisc.h \ gtkmodelsimple.h \ gtknotebook.h \ @@ -290,6 +291,7 @@ gtk_c_sources = @STRIP_BEGIN@ \ gtkmenufactory.c \ gtkmenuitem.c \ gtkmenushell.c \ + gtkmessagedialog.c \ gtkmisc.c \ gtkmodelsimple.c \ gtknotebook.c \ @@ -99,6 +99,7 @@ #include <gtk/gtkmenufactory.h> #include <gtk/gtkmenuitem.h> #include <gtk/gtkmenushell.h> +#include <gtk/gtkmessagedialog.h> #include <gtk/gtkmisc.h> #include <gtk/gtkmodelsimple.h> #include <gtk/gtknotebook.h> diff --git a/gtk/gtkdialog.c b/gtk/gtkdialog.c index 41d8a3e236..d21be69c24 100644 --- a/gtk/gtkdialog.c +++ b/gtk/gtkdialog.c @@ -26,14 +26,34 @@ #include "gtkbutton.h" #include "gtkdialog.h" -#include "gtkhbox.h" +#include "gtkhbbox.h" #include "gtkhseparator.h" #include "gtkvbox.h" - +#include "gtksignal.h" +#include "gdkkeysyms.h" +#include "gtkmain.h" static void gtk_dialog_class_init (GtkDialogClass *klass); static void gtk_dialog_init (GtkDialog *dialog); +static gint gtk_dialog_key_press (GtkWidget *widget, + GdkEventKey *key); + +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); + + +enum { + RESPONSE, + LAST_SIGNAL +}; +static gpointer parent_class; +static guint dialog_signals[LAST_SIGNAL]; GtkType gtk_dialog_get_type (void) @@ -63,6 +83,26 @@ gtk_dialog_get_type (void) static void gtk_dialog_class_init (GtkDialogClass *class) { + GtkObjectClass *object_class; + GtkWidgetClass *widget_class; + + object_class = (GtkObjectClass*) class; + widget_class = (GtkWidgetClass*) class; + + parent_class = g_type_class_peek_parent (class); + + dialog_signals[RESPONSE] = + gtk_signal_new ("response", + GTK_RUN_LAST, + GTK_CLASS_TYPE (object_class), + GTK_SIGNAL_OFFSET (GtkDialogClass, response), + gtk_marshal_NONE__INT, + GTK_TYPE_NONE, 1, + GTK_TYPE_INT); + + gtk_object_class_add_signals (object_class, dialog_signals, LAST_SIGNAL); + + widget_class->key_press_event = gtk_dialog_key_press; } static void @@ -70,13 +110,30 @@ gtk_dialog_init (GtkDialog *dialog) { GtkWidget *separator; + /* To avoid breaking old code that prevents destroy on delete event + * by connecting a handler, we have to have the FIRST signal + * connection on the dialog. + */ + gtk_signal_connect (GTK_OBJECT (dialog), + "delete_event", + GTK_SIGNAL_FUNC (gtk_dialog_delete_event_handler), + NULL); + dialog->vbox = gtk_vbox_new (FALSE, 0); + + gtk_container_set_border_width (GTK_CONTAINER (dialog->vbox), 2); + gtk_container_add (GTK_CONTAINER (dialog), dialog->vbox); gtk_widget_show (dialog->vbox); - dialog->action_area = gtk_hbox_new (TRUE, 5); + dialog->action_area = gtk_hbutton_box_new (); + + gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog->action_area), + GTK_BUTTONBOX_SPREAD); + gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 10); - gtk_box_pack_end (GTK_BOX (dialog->vbox), dialog->action_area, FALSE, TRUE, 0); + gtk_box_pack_end (GTK_BOX (dialog->vbox), dialog->action_area, + FALSE, TRUE, 0); gtk_widget_show (dialog->action_area); separator = gtk_hseparator_new (); @@ -84,8 +141,493 @@ gtk_dialog_init (GtkDialog *dialog) gtk_widget_show (separator); } +static gint +gtk_dialog_delete_event_handler (GtkWidget *widget, + GdkEventAny *event, + gpointer user_data) +{ + /* emit response signal */ + gtk_dialog_response (GTK_DIALOG (widget), GTK_RESPONSE_NONE); + + /* Do the destroy by default */ + return FALSE; +} + +static gint +gtk_dialog_key_press (GtkWidget *widget, + GdkEventKey *key) +{ + GdkEventAny event; + + event.type = GDK_DELETE; + event.window = widget->window; + event.send_event = TRUE; + + if (GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, key)) + return TRUE; + + if (key->keyval != GDK_Escape) + return FALSE; + + /* Synthesize delete_event on key press. */ + g_object_ref (G_OBJECT (event.window)); + + gtk_main_do_event ((GdkEvent*)&event); + + g_object_unref (G_OBJECT (event.window)); + + return TRUE; +} + GtkWidget* gtk_dialog_new (void) { return GTK_WIDGET (gtk_type_new (GTK_TYPE_DIALOG)); } + +static GtkWidget* +gtk_dialog_new_empty (const gchar *title, + GtkWindow *parent, + GtkDialogFlags flags) +{ + GtkDialog *dialog; + + dialog = GTK_DIALOG (g_object_new (GTK_TYPE_DIALOG, NULL)); + + if (title) + gtk_window_set_title (GTK_WINDOW (dialog), title); + + if (parent) + gtk_window_set_transient_for (GTK_WINDOW (dialog), parent); + + 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); + + return GTK_WIDGET (dialog); +} + +/** + * gtk_dialog_new_with_buttons: + * @title: Title of the dialog, or NULL + * @parent: 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 + * + * 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 + * argument can be used to make the dialog modal (GTK_DIALOG_MODAL) + * and/or to have it destroyed along with its transient parent + * (GTK_DIALOG_DESTROY_WITH_PARENT). After @flags, button + * text/response ID pairs should be listed, with a NULL pointer ending + * the list. Button text can be either a stock ID such as + * GTK_STOCK_BUTTON_OK, or some arbitrary text. A response ID can be + * 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 "response" signal with the corresponding + * response ID. If a #GtkDialog receives the "delete_event" signal, it + * will emit "response" with a response ID of GTK_RESPONSE_NONE. + * However, destroying a dialog does not emit the "response" signal; + * 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. + * + * Here's a simple example: + * <programlisting> + * GtkWidget *dialog = gtk_dialog_new_with_buttons ("My dialog", + * main_app_window, + * GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, + * GTK_STOCK_BUTTON_OK, + * GTK_RESPONSE_ACCEPT, + * GTK_STOCK_BUTTON_CANCEL, + * GTK_RESPONSE_NONE, + * NULL); + * </programlisting> + * + * Return value: a new #GtkDialog + **/ +GtkWidget* +gtk_dialog_new_with_buttons (const gchar *title, + GtkWindow *parent, + GtkDialogFlags flags, + const gchar *first_button_text, + ...) +{ + GtkDialog *dialog; + va_list args; + + dialog = GTK_DIALOG (gtk_dialog_new_empty (title, parent, flags)); + + va_start (args, first_button_text); + + gtk_dialog_add_buttons_valist (dialog, + first_button_text, + args); + + va_end (args); + + return GTK_WIDGET (dialog); +} + +typedef struct _ResponseData ResponseData; + +struct _ResponseData +{ + gint response_id; +}; + +static ResponseData* +get_response_data (GtkWidget *widget) +{ + ResponseData *ad = gtk_object_get_data (GTK_OBJECT (widget), + "gtk-dialog-response-data"); + + if (ad == NULL) + { + ad = g_new (ResponseData, 1); + + gtk_object_set_data_full (GTK_OBJECT (widget), + "gtk-dialog-response-data", + ad, + g_free); + } + + return ad; +} + +static void +action_widget_activated (GtkWidget *widget, GtkDialog *dialog) +{ + ResponseData *ad; + gint response_id; + + g_return_if_fail (GTK_IS_DIALOG (dialog)); + + response_id = GTK_RESPONSE_NONE; + + ad = get_response_data (widget); + + g_assert (ad != NULL); + + response_id = ad->response_id; + + gtk_dialog_response (dialog, response_id); +} +/** + * gtk_dialog_add_action_widget: + * @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 "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 + * <literal>action_area</literal> field of the #GtkDialog struct. + * + **/ +void +gtk_dialog_add_action_widget (GtkDialog *dialog, + GtkWidget *child, + gint response_id) +{ + ResponseData *ad; + + g_return_if_fail (GTK_IS_DIALOG (dialog)); + g_return_if_fail (GTK_IS_WIDGET (child)); + + ad = get_response_data (child); + + ad->response_id = response_id; + + if (GTK_WIDGET_GET_CLASS (child)->activate_signal != 0) + { + const gchar* name = + gtk_signal_name (GTK_WIDGET_GET_CLASS (child)->activate_signal); + + gtk_signal_connect_while_alive (GTK_OBJECT (child), + name, + GTK_SIGNAL_FUNC (action_widget_activated), + dialog, + GTK_OBJECT (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), + child, + FALSE, TRUE, 5); +} + +/** + * gtk_dialog_add_button: + * @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 + * "response" signal with the given @response_id. The button is appended to the + * end of the dialog's action area. + * + **/ +void +gtk_dialog_add_button (GtkDialog *dialog, + const gchar *button_text, + gint response_id) +{ + GtkWidget *button; + + g_return_if_fail (GTK_IS_DIALOG (dialog)); + g_return_if_fail (button_text != NULL); + + button = gtk_button_new_stock (button_text, + gtk_window_get_default_accel_group (GTK_WINDOW (dialog))); + + gtk_widget_show (button); + + gtk_dialog_add_action_widget (dialog, + button, + response_id); +} + +static void +gtk_dialog_add_buttons_valist(GtkDialog *dialog, + const gchar *first_button_text, + va_list args) +{ + const gchar* text; + gint response_id; + + if (first_button_text == NULL) + return; + + text = first_button_text; + response_id = va_arg (args, gint); + + while (text != NULL) + { + gtk_dialog_add_button (dialog, text, response_id); + + text = va_arg (args, gchar*); + if (text == NULL) + break; + response_id = va_arg (args, int); + } +} + +/** + * 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 + * + * 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); + + gtk_dialog_add_buttons_valist (dialog, + first_button_text, + args); + + va_end (args); +} + +/** + * gtk_dialog_response: + * @dialog: a #GtkDialog + * @response_id: response ID + * + * Emits the "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. + **/ +void +gtk_dialog_response (GtkDialog *dialog, + gint response_id) +{ + g_return_if_fail (dialog != NULL); + g_return_if_fail (GTK_IS_DIALOG (dialog)); + + gtk_signal_emit (GTK_OBJECT (dialog), + dialog_signals[RESPONSE], + response_id); +} + +typedef struct +{ + GtkDialog *dialog; + gint response_id; + GMainLoop *loop; +} RunInfo; + +static void +shutdown_loop (RunInfo *ri) +{ + if (ri->loop != NULL) + { + g_main_quit (ri->loop); + g_main_destroy (ri->loop); + ri->loop = NULL; + } +} + +static void +run_destroy_handler (GtkDialog *dialog, gpointer data) +{ + RunInfo *ri = data; + + shutdown_loop (ri); +} + +static void +run_response_handler (GtkDialog *dialog, + gint response_id, + gpointer data) +{ + RunInfo *ri; + + ri = data; + + ri->response_id = response_id; + + shutdown_loop (ri); +} + +static gint +run_delete_handler (GtkDialog *dialog, + GdkEventAny *event, + gpointer data) +{ + RunInfo *ri = data; + + shutdown_loop (ri); + + /* emit response signal */ + gtk_dialog_response (dialog, GTK_RESPONSE_NONE); + + return TRUE; /* Do not destroy */ +} + +/** + * gtk_dialog_run: + * @dialog: a #GtkDialog + * + * Blocks in a recursive main loop until the @dialog either emits the + * response signal, or is destroyed. If the dialog is destroyed, + * 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 "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_NONE. 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 post-run code won't know whether the dialog was + * destroyed or not. + * + * After gtk_dialog_run() returns, you are responsible for hiding or + * destroying the dialog if you wish to do so. + * + * Typical usage of this function might be: + * <programlisting> + * gint result = gtk_dialog_run (GTK_DIALOG (dialog)); + * switch (result) + * { + * case GTK_RESPONSE_ACCEPT: + * do_application_specific_something (); + * break; + * default: + * do_nothing_since_dialog_was_cancelled (); + * break; + * } + * gtk_widget_destroy (dialog); + * </programlisting> + * + * Return value: response ID + **/ +gint +gtk_dialog_run (GtkDialog *dialog) +{ + RunInfo ri = { NULL, GTK_RESPONSE_NONE, NULL }; + gboolean was_modal; + guint response_handler; + guint destroy_handler; + guint delete_handler; + + g_return_val_if_fail (GTK_IS_DIALOG (dialog), -1); + + gtk_object_ref (GTK_OBJECT (dialog)); + + if (!GTK_WIDGET_VISIBLE (dialog)) + gtk_widget_show (GTK_WIDGET (dialog)); + + was_modal = GTK_WINDOW (dialog)->modal; + if (!was_modal) + gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); + + response_handler = + gtk_signal_connect (GTK_OBJECT (dialog), + "response", + GTK_SIGNAL_FUNC (run_response_handler), + &ri); + + destroy_handler = + gtk_signal_connect (GTK_OBJECT (dialog), + "destroy", + GTK_SIGNAL_FUNC (run_destroy_handler), + &ri); + + delete_handler = + gtk_signal_connect (GTK_OBJECT (dialog), + "delete_event", + GTK_SIGNAL_FUNC (run_delete_handler), + &ri); + + ri.loop = g_main_new (FALSE); + + g_main_run (ri.loop); + + g_assert (ri.loop == NULL); + + if (!GTK_OBJECT_DESTROYED (dialog)) + { + if (!was_modal) + gtk_window_set_modal (GTK_WINDOW(dialog), FALSE); + + gtk_signal_disconnect (GTK_OBJECT (dialog), destroy_handler); + gtk_signal_disconnect (GTK_OBJECT (dialog), response_handler); + gtk_signal_disconnect (GTK_OBJECT (dialog), delete_handler); + } + + gtk_object_unref (GTK_OBJECT (dialog)); + + return ri.response_id; +} + + + + diff --git a/gtk/gtkdialog.h b/gtk/gtkdialog.h index cb2340ee08..fb8d10cf6c 100644 --- a/gtk/gtkdialog.h +++ b/gtk/gtkdialog.h @@ -36,6 +36,35 @@ extern "C" { #endif /* __cplusplus */ +/* Parameters for dialog construction */ +typedef enum +{ + GTK_DIALOG_MODAL, /* call gtk_window_set_modal (win, TRUE) */ + GTK_DIALOG_DESTROY_WITH_PARENT /* call gtk_window_set_destroy_with_parent () */ + +} GtkDialogFlags; + +/* Convenience enum to use for action_id's. Positive values are + * totally user-interpreted. GTK will sometimes return + * GTK_ACTION_NONE if no action_id is available. + * + * Typical usage is: + * if (gtk_dialog_run(dialog) == GTK_ACTION_ACCEPT) + * blah(); + */ +typedef enum +{ + /* GTK returns this if a response widget has no response_id, + * or the dialog gets destroyed with no response + */ + GTK_RESPONSE_NONE = -1, + /* GTK won't return these unless you pass them in + * as the response for an action widget + */ + GTK_RESPONSE_REJECT = -2, + GTK_RESPONSE_ACCEPT = -3 +} GtkResponseType; + #define GTK_TYPE_DIALOG (gtk_dialog_get_type ()) #define GTK_DIALOG(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_DIALOG, GtkDialog)) @@ -47,8 +76,6 @@ extern "C" { typedef struct _GtkDialog GtkDialog; typedef struct _GtkDialogClass GtkDialogClass; -typedef struct _GtkDialogButton GtkDialogButton; - struct _GtkDialog { @@ -61,12 +88,38 @@ struct _GtkDialog struct _GtkDialogClass { GtkWindowClass parent_class; + + void (* response) (GtkDialog *dialog, gint response_id); }; GtkType gtk_dialog_get_type (void) G_GNUC_CONST; GtkWidget* gtk_dialog_new (void); +GtkWidget* gtk_dialog_new_with_buttons (const gchar *title, + GtkWindow *parent, + GtkDialogFlags flags, + const gchar *first_button_text, + ...); + +void gtk_dialog_add_action_widget (GtkDialog *dialog, + GtkWidget *child, + gint response_id); + +void gtk_dialog_add_button (GtkDialog *dialog, + const gchar *button_text, + gint response_id); + +void gtk_dialog_add_buttons (GtkDialog *dialog, + const gchar *first_button_text, + ...); + +/* Emit response signal */ +void gtk_dialog_response (GtkDialog *dialog, + gint response_id); + +/* Returns response_id */ +gint gtk_dialog_run (GtkDialog *dialog); #ifdef __cplusplus } diff --git a/gtk/gtkenums.h b/gtk/gtkenums.h index dd8fe45fc0..9f8e1f93d8 100644 --- a/gtk/gtkenums.h +++ b/gtk/gtkenums.h @@ -338,7 +338,8 @@ typedef enum GTK_WIN_POS_NONE, GTK_WIN_POS_CENTER, GTK_WIN_POS_MOUSE, - GTK_WIN_POS_CENTER_ALWAYS + GTK_WIN_POS_CENTER_ALWAYS, + GTK_WIN_POS_CENTER_ON_PARENT } GtkWindowPosition; /* Window types */ diff --git a/gtk/gtkmessagedialog.c b/gtk/gtkmessagedialog.c new file mode 100644 index 0000000000..6ecb161c0b --- /dev/null +++ b/gtk/gtkmessagedialog.c @@ -0,0 +1,251 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 2000 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library 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. + */ + +/* + * Modified by the GTK+ Team and others 1997-1999. 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/. + */ + +#include "gtkmessagedialog.h" +#include "gtklabel.h" +#include "gtkhbox.h" +#include "gtkimage.h" +#include "gtkstock.h" +#include "gtkiconfactory.h" + +static void gtk_message_dialog_class_init (GtkMessageDialogClass *klass); +static void gtk_message_dialog_init (GtkMessageDialog *dialog); + + +GtkType +gtk_message_dialog_get_type (void) +{ + static GtkType dialog_type = 0; + + if (!dialog_type) + { + static const GtkTypeInfo dialog_info = + { + "GtkMessageDialog", + sizeof (GtkMessageDialog), + sizeof (GtkMessageDialogClass), + (GtkClassInitFunc) gtk_message_dialog_class_init, + (GtkObjectInitFunc) gtk_message_dialog_init, + /* reserved_1 */ NULL, + /* reserved_2 */ NULL, + (GtkClassInitFunc) NULL, + }; + + dialog_type = gtk_type_unique (GTK_TYPE_DIALOG, &dialog_info); + } + + return dialog_type; +} + +static void +gtk_message_dialog_class_init (GtkMessageDialogClass *class) +{ +} + +static void +gtk_message_dialog_init (GtkMessageDialog *dialog) +{ + GtkWidget *hbox; + + dialog->label = gtk_label_new (NULL); + dialog->image = gtk_image_new_from_stock (NULL, GTK_ICON_SIZE_DIALOG); + + gtk_label_set_line_wrap (GTK_LABEL (dialog->label), TRUE); + + hbox = gtk_hbox_new (FALSE, 10); + + gtk_container_set_border_width (GTK_CONTAINER (hbox), 10); + + gtk_box_pack_start (GTK_BOX (hbox), dialog->image, + FALSE, FALSE, 2); + + gtk_box_pack_start (GTK_BOX (hbox), dialog->label, + TRUE, TRUE, 2); + + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), + hbox, + FALSE, FALSE, 10); + + gtk_widget_show_all (hbox); +} + +static void +setup_type(GtkMessageDialog *dialog, GtkMessageType type) +{ + /* Note: this function can be called more than once, + * and after showing the dialog, due to object args + */ + + const gchar *stock_id = NULL; + GtkStockItem item; + + switch (type) + { + case GTK_MESSAGE_INFO: + stock_id = GTK_STOCK_DIALOG_INFO; + break; + + case GTK_MESSAGE_QUESTION: + stock_id = GTK_STOCK_DIALOG_QUESTION; + break; + + case GTK_MESSAGE_WARNING: + stock_id = GTK_STOCK_DIALOG_WARNING; + break; + + case GTK_MESSAGE_ERROR: + stock_id = GTK_STOCK_DIALOG_ERROR; + break; + + default: + g_warning ("Unknown GtkMessageType %d", type); + break; + } + + if (stock_id == NULL) + stock_id = GTK_STOCK_DIALOG_INFO; + + if (gtk_stock_lookup (stock_id, &item)) + { + gtk_image_set_from_stock (GTK_IMAGE (dialog->image), stock_id, + GTK_ICON_SIZE_DIALOG); + + gtk_window_set_title (GTK_WINDOW (dialog), item.label); + } + else + g_warning ("Stock dialog ID doesn't exist?"); +} + +/** + * gtk_message_dialog_new: + * @parent: transient parent, or NULL for none + * @flags: flags + * @type: type of message + * @buttons: set of buttons to use + * @message_format: printf()-style format string, or NULL + * @Varargs: arguments for @message_format + * + * Creates a new message dialog, which is a simple dialog with an icon + * indicating the dialog type (error, warning, etc.) and some text the + * user may want to see. If the button set you select with the @buttons + * argument has positive buttons (OK, Yes) they will result in a response ID + * of GTK_RESPONSE_ACCEPT. If it has negative buttons (Cancel, No) they will + * result in a response ID of GTK_RESPONSE_REJECT. See #GtkDialog for more + * details. + * + * Return value: a new #GtkMessageDialog + **/ +GtkWidget* +gtk_message_dialog_new (GtkWindow *parent, + GtkDialogFlags flags, + GtkMessageType type, + GtkButtonsType buttons, + const gchar *message_format, + ...) +{ + GtkWidget *widget; + GtkDialog *dialog; + gchar* msg; + va_list args; + + widget = GTK_WIDGET (gtk_type_new (GTK_TYPE_MESSAGE_DIALOG)); + dialog = GTK_DIALOG (widget); + + if (message_format) + { + va_start (args, message_format); + msg = g_strdup_vprintf(message_format, args); + va_end (args); + + + gtk_label_set_text (GTK_LABEL (GTK_MESSAGE_DIALOG (widget)->label), + msg); + + g_free (msg); + } + + if (parent != NULL) + gtk_window_set_transient_for (GTK_WINDOW (widget), + GTK_WINDOW (parent)); + + + 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); + + setup_type (GTK_MESSAGE_DIALOG (dialog), type); + + switch (buttons) + { + case GTK_BUTTONS_NONE: + /* nothing */ + break; + + case GTK_BUTTONS_OK: + gtk_dialog_add_button (dialog, + GTK_STOCK_BUTTON_OK, + GTK_RESPONSE_ACCEPT); + break; + + case GTK_BUTTONS_CLOSE: + gtk_dialog_add_button (dialog, + GTK_STOCK_BUTTON_CLOSE, + GTK_RESPONSE_ACCEPT); + break; + + case GTK_BUTTONS_CANCEL: + gtk_dialog_add_button (dialog, + GTK_STOCK_BUTTON_CANCEL, + GTK_RESPONSE_REJECT); + break; + + case GTK_BUTTONS_YES_NO: + gtk_dialog_add_button (dialog, + GTK_STOCK_BUTTON_YES, + GTK_RESPONSE_ACCEPT); + gtk_dialog_add_button (dialog, + GTK_STOCK_BUTTON_NO, + GTK_RESPONSE_REJECT); + break; + + case GTK_BUTTONS_OK_CANCEL: + gtk_dialog_add_button (dialog, + GTK_STOCK_BUTTON_OK, + GTK_RESPONSE_ACCEPT); + gtk_dialog_add_button (dialog, + GTK_STOCK_BUTTON_CANCEL, + GTK_RESPONSE_REJECT); + break; + + default: + g_warning ("Unknown GtkButtonsType"); + break; + } + + return widget; +} diff --git a/gtk/gtkmessagedialog.h b/gtk/gtkmessagedialog.h new file mode 100644 index 0000000000..688798c652 --- /dev/null +++ b/gtk/gtkmessagedialog.h @@ -0,0 +1,98 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 2000 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * 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. + */ + +/* + * 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/. + */ + +#ifndef __GTK_MESSAGE_DIALOG_H__ +#define __GTK_MESSAGE_DIALOG_H__ + +#include <gtk/gtkdialog.h> + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +typedef enum +{ + GTK_MESSAGE_INFO, + GTK_MESSAGE_WARNING, + GTK_MESSAGE_QUESTION, + GTK_MESSAGE_ERROR +} GtkMessageType; + +typedef enum +{ + GTK_BUTTONS_NONE, + GTK_BUTTONS_OK, + GTK_BUTTONS_CLOSE, + GTK_BUTTONS_CANCEL, + GTK_BUTTONS_YES_NO, + GTK_BUTTONS_OK_CANCEL +} GtkButtonsType; + +#define GTK_TYPE_MESSAGE_DIALOG (gtk_message_dialog_get_type ()) +#define GTK_MESSAGE_DIALOG(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialog)) +#define GTK_MESSAGE_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass)) +#define GTK_IS_MESSAGE_DIALOG(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_MESSAGE_DIALOG)) +#define GTK_IS_MESSAGE_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MESSAGE_DIALOG)) +#define GTK_MESSAGE_DIALOG_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass)) + + +typedef struct _GtkMessageDialog GtkMessageDialog; +typedef struct _GtkMessageDialogClass GtkMessageDialogClass; + +struct _GtkMessageDialog +{ + /*< private >*/ + + GtkDialog parent_instance; + + GtkWidget *image; + GtkWidget *label; +}; + +struct _GtkMessageDialogClass +{ + GtkDialogClass parent_class; + + +}; + +GtkType gtk_message_dialog_get_type (void); + +GtkWidget* gtk_message_dialog_new (GtkWindow *parent, + GtkDialogFlags flags, + GtkMessageType type, + GtkButtonsType buttons, + const gchar *message_format, + ...) G_GNUC_PRINTF (5, 6); + + + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __GTK_MESSAGE_DIALOG_H__ */ diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c index bfd2a46e72..481f1d2c71 100644 --- a/gtk/gtkwindow.c +++ b/gtk/gtkwindow.c @@ -45,6 +45,7 @@ #include "gtkwindow.h" #include "gtkbindings.h" #include "gtkmain.h" +#include "gtkiconfactory.h" /* TODO: remove this define and assorted code in 1.3 and fix up the * real culprits. @@ -65,7 +66,8 @@ enum { ARG_MODAL, ARG_WIN_POS, ARG_DEFAULT_WIDTH, - ARG_DEFAULT_HEIGHT + ARG_DEFAULT_HEIGHT, + ARG_DESTROY_WITH_PARENT }; typedef struct { @@ -225,6 +227,7 @@ gtk_window_class_init (GtkWindowClass *klass) gtk_object_add_arg_type ("GtkWindow::window_position", GTK_TYPE_WINDOW_POSITION, GTK_ARG_READWRITE, ARG_WIN_POS); gtk_object_add_arg_type ("GtkWindow::default_width", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_DEFAULT_WIDTH); gtk_object_add_arg_type ("GtkWindow::default_height", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_DEFAULT_HEIGHT); + gtk_object_add_arg_type ("GtkWindow::destroy_with_parent", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DESTROY_WITH_PARENT); window_signals[SET_FOCUS] = gtk_signal_new ("set_focus", @@ -335,6 +338,9 @@ gtk_window_set_arg (GtkObject *object, case ARG_DEFAULT_HEIGHT: gtk_window_set_default_size (window, -2, GTK_VALUE_INT (*arg)); break; + case ARG_DESTROY_WITH_PARENT: + gtk_window_set_destroy_with_parent (window, GTK_VALUE_BOOL (*arg)); + break; default: break; } @@ -387,6 +393,9 @@ gtk_window_get_arg (GtkObject *object, else GTK_VALUE_INT (*arg) = info->height; break; + case ARG_DESTROY_WITH_PARENT: + GTK_VALUE_BOOL (*arg) = window->destroy_with_parent; + break; default: arg->type = GTK_TYPE_INVALID; break; @@ -527,6 +536,29 @@ gtk_window_remove_accel_group (GtkWindow *window, gtk_accel_group_detach (accel_group, GTK_OBJECT (window)); } +GtkAccelGroup* +gtk_window_get_default_accel_group (GtkWindow *window) +{ + GtkAccelGroup *group; + + g_return_val_if_fail (GTK_IS_WINDOW (window), NULL); + + group = gtk_object_get_data (GTK_OBJECT (window), + "gtk-accel-group"); + + if (group == NULL) + { + group = gtk_accel_group_new (); + gtk_window_add_accel_group (window, group); + gtk_object_set_data (GTK_OBJECT (window), + "gtk-accel-group", + group); + gtk_accel_group_unref (group); + } + + return group; +} + void gtk_window_set_position (GtkWindow *window, GtkWindowPosition position) @@ -688,6 +720,35 @@ gtk_window_shutdown (GObject *object) } static void +parent_destroyed_callback (GtkWindow *parent, GtkWindow *child) +{ + gtk_widget_destroy (GTK_WIDGET (child)); +} + +static void +connect_parent_destroyed (GtkWindow *window) +{ + if (window->transient_parent) + { + gtk_signal_connect (GTK_OBJECT (window->transient_parent), + "destroy", + GTK_SIGNAL_FUNC (parent_destroyed_callback), + window); + } +} + +static void +disconnect_parent_destroyed (GtkWindow *window) +{ + if (window->transient_parent) + { + gtk_signal_disconnect_by_func (GTK_OBJECT (window->transient_parent), + GTK_SIGNAL_FUNC (parent_destroyed_callback), + window); + } +} + +static void gtk_window_transient_parent_realized (GtkWidget *parent, GtkWidget *window) { @@ -719,6 +780,9 @@ gtk_window_unset_transient_for (GtkWindow *window) GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window->transient_parent); + if (window->destroy_with_parent) + disconnect_parent_destroyed (window); + window->transient_parent = NULL; } } @@ -727,8 +791,11 @@ void gtk_window_set_transient_for (GtkWindow *window, GtkWindow *parent) { - g_return_if_fail (window != 0); + g_return_if_fail (GTK_IS_WINDOW (window)); + g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent)); + g_return_if_fail (window != parent); + if (window->transient_parent) { if (GTK_WIDGET_REALIZED (window) && @@ -754,6 +821,9 @@ gtk_window_set_transient_for (GtkWindow *window, GTK_SIGNAL_FUNC (gtk_window_transient_parent_unrealized), window); + if (window->destroy_with_parent) + connect_parent_destroyed (window); + if (GTK_WIDGET_REALIZED (window) && GTK_WIDGET_REALIZED (parent)) gtk_window_transient_parent_realized (GTK_WIDGET (parent), @@ -761,6 +831,37 @@ gtk_window_set_transient_for (GtkWindow *window, } } +/** + * gtk_window_set_destroy_with_parent: + * @window: a #GtkWindow + * @setting: whether to destroy @window with its transient parent + * + * If @setting is TRUE, then destroying the transient parent of @window + * will also destroy @window itself. This is useful for dialogs that + * shouldn't persist beyond the lifetime of the main window they're + * associated with, for example. + **/ +void +gtk_window_set_destroy_with_parent (GtkWindow *window, + gboolean setting) +{ + g_return_if_fail (GTK_IS_WINDOW (window)); + + if (window->destroy_with_parent == (setting != FALSE)) + return; + + if (window->destroy_with_parent) + { + disconnect_parent_destroyed (window); + } + else + { + connect_parent_destroyed (window); + } + + window->destroy_with_parent = setting; +} + static void gtk_window_geometry_destroy (GtkWindowGeometryInfo *info) { @@ -859,7 +960,7 @@ gtk_window_destroy (GtkObject *object) window = GTK_WINDOW (object); if (window->transient_parent) - gtk_window_unset_transient_for (window); + gtk_window_set_transient_for (window, NULL); if (window->has_user_ref_count) { @@ -1432,10 +1533,15 @@ gtk_window_read_rcfiles (GtkWidget *widget, * of date, so we need to reset all our widgets. Our other * toplevel windows will also get the message, but by * then, the RC file will up to date, so we have to tell - * them now. + * them now. Also, we have to invalidate cached icons in + * icon sets so they get re-rendered. */ - GList *list, *toplevels = gtk_window_list_toplevels (); + GList *list, *toplevels; + _gtk_icon_set_invalidate_caches (); + + toplevels = gtk_window_list_toplevels (); + for (list = toplevels; list; list = list->next) { gtk_widget_reset_rc_styles (list->data); @@ -2056,14 +2162,24 @@ gtk_window_compute_reposition (GtkWindow *window, gint *y) { GtkWidget *widget; - + GtkWindowPosition pos; + GtkWidget *parent_widget; + widget = GTK_WIDGET (window); *x = -1; *y = -1; + + parent_widget = (GtkWidget*) window->transient_parent; - switch (window->position) - { + pos = window->position; + if (pos == GTK_WIN_POS_CENTER_ON_PARENT && + (parent_widget == NULL || + !GTK_WIDGET_MAPPED (parent_widget))) + pos = GTK_WIN_POS_NONE; + + switch (pos) + { case GTK_WIN_POS_CENTER: case GTK_WIN_POS_CENTER_ALWAYS: if (window->use_uposition) @@ -2075,6 +2191,19 @@ gtk_window_compute_reposition (GtkWindow *window, *y = (screen_height - new_height) / 2; } break; + + case GTK_WIN_POS_CENTER_ON_PARENT: + if (window->use_uposition) + { + gint ox, oy; + gdk_window_get_origin (parent_widget->window, + &ox, &oy); + + *x = ox + (parent_widget->allocation.width - new_width) / 2; + *y = oy + (parent_widget->allocation.height - new_height) / 2; + } + break; + case GTK_WIN_POS_MOUSE: if (window->use_uposition) { diff --git a/gtk/gtkwindow.h b/gtk/gtkwindow.h index 1b86c76d5e..058da9fc51 100644 --- a/gtk/gtkwindow.h +++ b/gtk/gtkwindow.h @@ -79,6 +79,7 @@ struct _GtkWindow */ guint use_uposition : 1; guint modal : 1; + guint destroy_with_parent : 1; }; struct _GtkWindowClass @@ -112,6 +113,8 @@ gint gtk_window_activate_default (GtkWindow *window); void gtk_window_set_transient_for (GtkWindow *window, GtkWindow *parent); +void gtk_window_set_destroy_with_parent (GtkWindow *window, + gboolean setting); void gtk_window_set_geometry_hints (GtkWindow *window, GtkWidget *geometry_widget, GdkGeometry *geometry, @@ -129,6 +132,8 @@ void gtk_window_set_modal (GtkWindow *window, gboolean modal); GList* gtk_window_list_toplevels (void); +/* Get the "built-in" accel group (convenience thing) */ +GtkAccelGroup* gtk_window_get_default_accel_group (GtkWindow *window); /* --- internal functions --- */ void gtk_window_set_focus (GtkWindow *window, diff --git a/gtk/testgtk.c b/gtk/testgtk.c index 86d9be5915..a24554f6bc 100644 --- a/gtk/testgtk.c +++ b/gtk/testgtk.c @@ -161,8 +161,12 @@ create_buttons (void) if (!window) { + GtkAccelGroup *accel_group; + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + accel_group = gtk_window_get_default_accel_group (GTK_WINDOW (window)); + gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); @@ -180,15 +184,15 @@ create_buttons (void) gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0); button[0] = gtk_button_new_with_label ("button1"); - button[1] = gtk_button_new_with_label ("button2"); + button[1] = gtk_button_new_accel ("_button2", accel_group); button[2] = gtk_button_new_with_label ("button3"); - button[3] = gtk_button_new_with_label ("button4"); + button[3] = gtk_button_new_stock (GTK_STOCK_BUTTON_OK, NULL); button[4] = gtk_button_new_with_label ("button5"); button[5] = gtk_button_new_with_label ("button6"); button[6] = gtk_button_new_with_label ("button7"); - button[7] = gtk_button_new_with_label ("button8"); + button[7] = gtk_button_new_stock (GTK_STOCK_BUTTON_CLOSE, accel_group); button[8] = gtk_button_new_with_label ("button9"); - + gtk_signal_connect (GTK_OBJECT (button[0]), "clicked", GTK_SIGNAL_FUNC(button_window), button[1]); @@ -2222,6 +2226,65 @@ create_tooltips (void) } /* + * GtkImage + */ + +static void +pack_image (GtkWidget *box, + const gchar *text, + GtkWidget *image) +{ + gtk_box_pack_start (GTK_BOX (box), + gtk_label_new (text), + FALSE, FALSE, 0); + + gtk_box_pack_start (GTK_BOX (box), + image, + TRUE, TRUE, 0); +} + +static void +create_image (void) +{ + static GtkWidget *window = NULL; + + if (window == NULL) + { + GtkWidget *vbox; + GdkPixmap *pixmap; + GdkBitmap *mask; + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); + + vbox = gtk_vbox_new (FALSE, 5); + + gtk_container_add (GTK_CONTAINER (window), vbox); + + pack_image (vbox, "Stock Warning Dialog", + gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, + GTK_ICON_SIZE_DIALOG)); + + pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, + gtk_widget_get_colormap (window), + &mask, + NULL, + openfile); + + pack_image (vbox, "Pixmap", + gtk_image_new_from_pixmap (pixmap, mask)); + } + + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show_all (window); + else + gtk_widget_destroy (window); +} + +/* * Menu demo */ @@ -2609,12 +2672,12 @@ create_modal_window (void) /* Pack widgets */ gtk_container_add (GTK_CONTAINER (window), box1); - gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4); - gtk_container_add (GTK_CONTAINER (frame1), box2); - gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4); - gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4); - gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4); - gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4); + gtk_container_add (GTK_CONTAINER (frame1), box2); + gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4); /* connect signals */ gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked", @@ -2637,6 +2700,53 @@ create_modal_window (void) } /* + * GtkMessageDialog + */ + +static void +make_message_dialog (GtkWidget **dialog, + GtkMessageType type, + GtkButtonsType buttons) +{ + if (*dialog) + { + if (GTK_WIDGET_REALIZED (*dialog)) + gdk_window_show ((*dialog)->window); + + return; + } + + *dialog = gtk_message_dialog_new (NULL, 0, type, buttons, + "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)"); + + gtk_signal_connect_object (GTK_OBJECT (*dialog), + "response", + GTK_SIGNAL_FUNC (gtk_widget_destroy), + GTK_OBJECT (*dialog)); + + gtk_signal_connect (GTK_OBJECT (*dialog), + "destroy", + GTK_SIGNAL_FUNC (gtk_widget_destroyed), + dialog); + + gtk_widget_show (*dialog); +} + +static void +create_message_dialog (void) +{ + static GtkWidget *info = NULL; + static GtkWidget *warning = NULL; + static GtkWidget *error = NULL; + static GtkWidget *question = NULL; + + make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK); + make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE); + make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL); + make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO); +} + +/* * GtkScrolledWindow */ @@ -8624,11 +8734,13 @@ create_main_window (void) { "font selection", create_font_selection }, { "gamma curve", create_gamma_curve }, { "handle box", create_handle_box }, + { "image", create_image }, { "item factory", create_item_factory }, { "labels", create_labels }, { "layout", create_layout }, { "list", create_list }, { "menus", create_menus }, + { "message dialog", create_message_dialog }, { "modal window", create_modal_window }, { "notebook", create_notebook }, { "panes", create_panes }, @@ -8771,8 +8883,6 @@ main (int argc, char *argv[]) gtk_init (&argc, &argv); - gdk_rgb_init (); - /* bindings test */ binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET)); diff --git a/gtk/testgtkrc b/gtk/testgtkrc index 85fb904530..170ad4d1f1 100644 --- a/gtk/testgtkrc +++ b/gtk/testgtkrc @@ -29,6 +29,16 @@ style "defaultfont" font_name = "Sans 12" } +style "myicons" +{ + stock["gtk-dialog-warning"] = + { + { "3DRings.xpm", *, *, *} + } +} + +class "GtkImage" style "myicons" + # common default class "GtkWidget" style "defaultfont" diff --git a/tests/testgtk.c b/tests/testgtk.c index 86d9be5915..a24554f6bc 100644 --- a/tests/testgtk.c +++ b/tests/testgtk.c @@ -161,8 +161,12 @@ create_buttons (void) if (!window) { + GtkAccelGroup *accel_group; + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + accel_group = gtk_window_get_default_accel_group (GTK_WINDOW (window)); + gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); @@ -180,15 +184,15 @@ create_buttons (void) gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0); button[0] = gtk_button_new_with_label ("button1"); - button[1] = gtk_button_new_with_label ("button2"); + button[1] = gtk_button_new_accel ("_button2", accel_group); button[2] = gtk_button_new_with_label ("button3"); - button[3] = gtk_button_new_with_label ("button4"); + button[3] = gtk_button_new_stock (GTK_STOCK_BUTTON_OK, NULL); button[4] = gtk_button_new_with_label ("button5"); button[5] = gtk_button_new_with_label ("button6"); button[6] = gtk_button_new_with_label ("button7"); - button[7] = gtk_button_new_with_label ("button8"); + button[7] = gtk_button_new_stock (GTK_STOCK_BUTTON_CLOSE, accel_group); button[8] = gtk_button_new_with_label ("button9"); - + gtk_signal_connect (GTK_OBJECT (button[0]), "clicked", GTK_SIGNAL_FUNC(button_window), button[1]); @@ -2222,6 +2226,65 @@ create_tooltips (void) } /* + * GtkImage + */ + +static void +pack_image (GtkWidget *box, + const gchar *text, + GtkWidget *image) +{ + gtk_box_pack_start (GTK_BOX (box), + gtk_label_new (text), + FALSE, FALSE, 0); + + gtk_box_pack_start (GTK_BOX (box), + image, + TRUE, TRUE, 0); +} + +static void +create_image (void) +{ + static GtkWidget *window = NULL; + + if (window == NULL) + { + GtkWidget *vbox; + GdkPixmap *pixmap; + GdkBitmap *mask; + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + + gtk_signal_connect (GTK_OBJECT (window), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), + &window); + + vbox = gtk_vbox_new (FALSE, 5); + + gtk_container_add (GTK_CONTAINER (window), vbox); + + pack_image (vbox, "Stock Warning Dialog", + gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, + GTK_ICON_SIZE_DIALOG)); + + pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, + gtk_widget_get_colormap (window), + &mask, + NULL, + openfile); + + pack_image (vbox, "Pixmap", + gtk_image_new_from_pixmap (pixmap, mask)); + } + + if (!GTK_WIDGET_VISIBLE (window)) + gtk_widget_show_all (window); + else + gtk_widget_destroy (window); +} + +/* * Menu demo */ @@ -2609,12 +2672,12 @@ create_modal_window (void) /* Pack widgets */ gtk_container_add (GTK_CONTAINER (window), box1); - gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4); - gtk_container_add (GTK_CONTAINER (frame1), box2); - gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4); - gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4); - gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4); - gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4); + gtk_container_add (GTK_CONTAINER (frame1), box2); + gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4); + gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4); /* connect signals */ gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked", @@ -2637,6 +2700,53 @@ create_modal_window (void) } /* + * GtkMessageDialog + */ + +static void +make_message_dialog (GtkWidget **dialog, + GtkMessageType type, + GtkButtonsType buttons) +{ + if (*dialog) + { + if (GTK_WIDGET_REALIZED (*dialog)) + gdk_window_show ((*dialog)->window); + + return; + } + + *dialog = gtk_message_dialog_new (NULL, 0, type, buttons, + "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)"); + + gtk_signal_connect_object (GTK_OBJECT (*dialog), + "response", + GTK_SIGNAL_FUNC (gtk_widget_destroy), + GTK_OBJECT (*dialog)); + + gtk_signal_connect (GTK_OBJECT (*dialog), + "destroy", + GTK_SIGNAL_FUNC (gtk_widget_destroyed), + dialog); + + gtk_widget_show (*dialog); +} + +static void +create_message_dialog (void) +{ + static GtkWidget *info = NULL; + static GtkWidget *warning = NULL; + static GtkWidget *error = NULL; + static GtkWidget *question = NULL; + + make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK); + make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE); + make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL); + make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO); +} + +/* * GtkScrolledWindow */ @@ -8624,11 +8734,13 @@ create_main_window (void) { "font selection", create_font_selection }, { "gamma curve", create_gamma_curve }, { "handle box", create_handle_box }, + { "image", create_image }, { "item factory", create_item_factory }, { "labels", create_labels }, { "layout", create_layout }, { "list", create_list }, { "menus", create_menus }, + { "message dialog", create_message_dialog }, { "modal window", create_modal_window }, { "notebook", create_notebook }, { "panes", create_panes }, @@ -8771,8 +8883,6 @@ main (int argc, char *argv[]) gtk_init (&argc, &argv); - gdk_rgb_init (); - /* bindings test */ binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET)); diff --git a/tests/testgtkrc b/tests/testgtkrc index 85fb904530..170ad4d1f1 100644 --- a/tests/testgtkrc +++ b/tests/testgtkrc @@ -29,6 +29,16 @@ style "defaultfont" font_name = "Sans 12" } +style "myicons" +{ + stock["gtk-dialog-warning"] = + { + { "3DRings.xpm", *, *, *} + } +} + +class "GtkImage" style "myicons" + # common default class "GtkWidget" style "defaultfont" |