Struct gtk::Dialog

#[repr(transparent)]
pub struct Dialog { /* private fields */ }

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 Label or a Entry 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.

Dialog boxes are created with a call to 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 DialogExt::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 GtkWindowExt::set_modal() on the dialog. Use the GTK_WINDOW() macro to cast the widget returned from new() into a Window. When using gtk_dialog_new_with_buttons() you can also pass the DialogFlags::MODAL flag to make a dialog modal.

If you add buttons to Dialog using gtk_dialog_new_with_buttons(), DialogExt::add_button(), DialogExtManual::add_buttons(), or DialogExt::add_action_widget(), clicking the button will emit a signal called signal::Dialog::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 ResponseType enumeration (these all have values less than zero). If a dialog receives a delete event, the signal::Dialog::response signal will be emitted with a response ID of ResponseType::DeleteEvent.

If you want to block waiting for a dialog to return before returning control flow to your code, you can call DialogExt::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 MessageDialog 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.

An example for simple GtkDialog usage:

⚠️ The following code is in C ⚠️

// Function to open a dialog box with a message
void
quick_message (GtkWindow *parent, gchar *message)
{
 GtkWidget *dialog, *label, *content_area;
 GtkDialogFlags flags;

 // Create the widgets
 flags = GTK_DIALOG_DESTROY_WITH_PARENT;
 dialog = gtk_dialog_new_with_buttons ("Message",
                                       parent,
                                       flags,
                                       _("_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

 gtk_container_add (GTK_CONTAINER (content_area), label);
 gtk_widget_show_all (dialog);
}

GtkDialog as GtkBuildable

The GtkDialog implementation of the Buildable 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). To mark a response as default, set the “default“ attribute of the <action-widget> element to true.

GtkDialog supports adding action widgets by specifying “action“ as the “type“ attribute of a <child> element. The widget will be added either to the action area or the headerbar of the dialog, depending on the “use-header-bar“ property. The response id has to be associated with the action widget using the <action-widgets> element.

An example of a Dialog UI definition fragment:

⚠️ The following code is in xml ⚠️

<object class="GtkDialog" id="dialog1">
  <child type="action">
    <object class="GtkButton" id="button_cancel"/>
  </child>
  <child type="action">
    <object class="GtkButton" id="button_ok">
      <property name="can-default">True</property>
    </object>
  </child>
  <action-widgets>
    <action-widget response="cancel">button_cancel</action-widget>
    <action-widget response="ok" default="true">button_ok</action-widget>
  </action-widgets>
</object>

Implements

DialogExt, GtkWindowExt, BinExt, ContainerExt, WidgetExt, glib::ObjectExt, BuildableExt, DialogExtManual, [GtkWindowExtManual][trait@crate::prelude::GtkWindowExtManual], ContainerExtManual, WidgetExtManual, BuildableExtManual

Implementations

impl Dialog

pub const NONE: Option<&'static Dialog> = None

pub fn new() -> Dialog

Creates a new dialog box.

Widgets should not be packed into this Window directly, but into the vbox and action_area, as described above.

Returns

the new dialog as a Widget

pub fn builder() -> DialogBuilder

Creates a new builder-pattern struct instance to construct Dialog objects.

This method returns an instance of DialogBuilder which can be used to create Dialog objects.

impl Dialog

pub fn with_buttons<T: IsA<Window>>(
    title: Option<&str>,
    parent: Option<&T>,
    flags: DialogFlags,
    buttons: &[(&str, ResponseType)]
) -> Dialog

Creates a new Dialog with title title (or None for the default title; see GtkWindowExt::set_title()) and transient parent parent (or None for none; see GtkWindowExt::set_transient_for()). The flags argument can be used to make the dialog modal (DialogFlags::MODAL) and/or to have it destroyed along with its transient parent (DialogFlags::DESTROY_WITH_PARENT). After flags, button text/response ID pairs should be listed, with a None pointer ending the list. Button text can be arbitrary text. A response ID can be any positive number, or one of the values in the ResponseType enumeration. If the user clicks one of these dialog buttons, Dialog will emit the signal::Dialog::response signal with the corresponding response ID. If a Dialog receives the signal::Widget::delete-event signal, it will emit ::response with a response ID of ResponseType::DeleteEvent. However, destroying a dialog does not emit the ::response signal; so be careful relying on ::response when using the DialogFlags::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:

⚠️ The following code is in C ⚠️

 GtkWidget *main_app_window; // Window the dialog should show up on
 GtkWidget *dialog;
 GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
 dialog = gtk_dialog_new_with_buttons ("My dialog",
                                       main_app_window,
                                       flags,
                                       _("_OK"),
                                       GTK_RESPONSE_ACCEPT,
                                       _("_Cancel"),
                                       GTK_RESPONSE_REJECT,
                                       NULL);

title

Title of the dialog, or None

parent

Transient parent of the dialog, or None

flags

from DialogFlags

first_button_text

text to go in first button, or None

Returns

a new Dialog

Trait Implementations

impl Clone for Dialog

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Dialog

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Dialog

fn default() -> Self

Returns the “default value” for a type.

impl Display for Dialog

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Dialog

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T: DialogImpl> IsSubclassable<T> for Dialog

fn class_init(class: &mut Class<Self>)

Override the virtual methods of this class for the given subclass and do other class initialization.

fn instance_init(instance: &mut InitializingObject<T>)

Instance specific initialization.

impl Ord for Dialog

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl ParentClassIs for Dialog

type Parent = Window

impl<OT: ObjectType> PartialEq<OT> for Dialog

fn eq(&self, other: &OT) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<OT: ObjectType> PartialOrd<OT> for Dialog

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Dialog

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Dialog

impl IsA<Bin> for Dialog

impl IsA<Buildable> for Dialog

impl IsA<Container> for Dialog

impl IsA<Dialog> for AboutDialog

impl IsA<Dialog> for AppChooserDialog

impl IsA<Dialog> for ColorChooserDialog

impl IsA<Dialog> for FileChooserDialog

impl IsA<Dialog> for FontChooserDialog

impl IsA<Dialog> for MessageDialog

impl IsA<Dialog> for RecentChooserDialog

impl IsA<Widget> for Dialog

impl IsA<Window> for Dialog