gtk2/docs/reference/gtk/tmpl/gtkdialog.sgml
Matthias Clasen 317ba5b267 Small additions.
* gtk/tmpl/gtktextview.sgml: Small additions.

        * gtk/tmpl/gtksignal.sgml: Explain what to use instead.

        * gtk/question_index.sgml, gtk/text_widget.sgml, gtk/tree_widget.sgml,
        gtk/changes-1.2.sgml, gtk/changes-2.0.sgml,
        gtk/framebuffer.sgml: SGML fixes and additions.

        * gtk/tmpl/gtksignal.sgml, gtk/tmpl/gtkdialog.sgml,
        gtk/tmpl/gtkeditable.sgml, gtk/tmpl/gtkfilesel.sgml,
        gtk/tmpl/gtkmain.sgml, gtk/tmpl/gtkmenu.sgml,
        gtk/tmpl/gtkmessagedialog.sgml, gtk/tmpl/gtkrc.sgml,
        gtk/tmpl/gtktogglebutton.sgml, gtk/tmpl/gtkspinbutton.sgml,
        gtk/tmpl/gtkpaned.sgml, gtk/tmpl/gtkwindow.sgml:
        Replace references to deprecated functions.
2002-01-03 23:04:44 +00:00

301 lines
7.2 KiB
Plaintext

<!-- ##### SECTION Title ##### -->
GtkDialog
<!-- ##### SECTION Short_Description ##### -->
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.
</para>
<para>
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
<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() 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 <literal>GTK_DIALOG(dialog)->vbox</literal> and
<literal>GTK_DIALOG(dialog)->action_area</literal>,
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>
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>Simple <structname>GtkDialog</structname> usage.</title>
<programlisting>
/* Function to open a dialog box displaying the message provided. */
void quick_message (gchar *message) {
GtkWidget *dialog, *label;
/* Create the widgets */
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);
/* Ensure that the dialog box is destroyed when the user responds. */
g_signal_connect_swapped (GTK_OBJECT (dialog),
"response",
G_CALLBACK (gtk_widget_destroy),
GTK_OBJECT (dialog));
/* Add the label, and show everything we've added to the dialog. */
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
label);
gtk_widget_show_all (dialog);
}
</programlisting>
</example>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
<variablelist>
<varlistentry>
<term>#GtkVBox</term>
<listitem><para>Pack widgets vertically.</para></listitem>
</varlistentry>
<varlistentry>
<term>#GtkWindow</term>
<listitem><para>Alter the properties of your dialog box.</para></listitem>
</varlistentry>
<varlistentry>
<term>#GtkButton</term>
<listitem><para>Add them to the <structfield>action_area</structfield> to get a
response from the user.</para></listitem>
</varlistentry>
</variablelist>
</para>
<!-- ##### STRUCT GtkDialog ##### -->
<para>
<structfield>window</structfield> is a #GtkWindow, but should not be
modified directly, (use the functions provided, such as
gtk_window_set_title(). See the #GtkWindow section for more).
</para>
<para>
<structfield>vbox</structfield> is a #GtkVBox - the main part of the dialog box.
</para>
<para>
<structfield>action_area</structfield> is a #GtkHBox packed below the dividing #GtkHSeparator in the dialog. It is treated exactly the same as any other #GtkHBox.
</para>
<!-- ##### ENUM GtkDialogFlags ##### -->
<para>
</para>
@GTK_DIALOG_MODAL:
@GTK_DIALOG_DESTROY_WITH_PARENT:
@GTK_DIALOG_NO_SEPARATOR:
<!-- ##### ENUM GtkResponseType ##### -->
<para>
</para>
@GTK_RESPONSE_NONE:
@GTK_RESPONSE_REJECT:
@GTK_RESPONSE_ACCEPT:
@GTK_RESPONSE_DELETE_EVENT:
@GTK_RESPONSE_OK:
@GTK_RESPONSE_CANCEL:
@GTK_RESPONSE_CLOSE:
@GTK_RESPONSE_YES:
@GTK_RESPONSE_NO:
@GTK_RESPONSE_APPLY:
@GTK_RESPONSE_HELP:
<!-- ##### FUNCTION gtk_dialog_new ##### -->
<para>
Creates a new dialog box. Widgets should not be packed into this #GtkWindow
directly, but into the @vbox and @action_area, as described above.
</para>
@Returns: a new #GtkDialog.
<!-- ##### 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:
@Returns:
<!-- ##### 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:
<!-- ##### FUNCTION gtk_dialog_get_has_separator ##### -->
<para>
</para>
@dialog:
@Returns:
<!-- ##### FUNCTION gtk_dialog_set_default_response ##### -->
<para>
</para>
@dialog:
@response_id:
<!-- ##### FUNCTION gtk_dialog_set_has_separator ##### -->
<para>
</para>
@dialog:
@setting:
<!-- ##### FUNCTION gtk_dialog_set_response_sensitive ##### -->
<para>
</para>
@dialog:
@response_id:
@setting:
<!-- ##### SIGNAL GtkDialog::close ##### -->
<para>
</para>
@dialog: the object which received the signal.
<!-- ##### 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
<!-- ##### ARG GtkDialog:has-separator ##### -->
<para>
</para>