Struct gtk::Dialog [−][src]
pub struct Dialog(_);
Expand description
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(), gtk_dialog_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:
<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], WidgetExtManual, BuildableExtManual
Implementations
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.
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
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
Returns the type identifier of Self.
Auto Trait Implementations
impl RefUnwindSafe for Dialogimpl UnwindSafe for DialogBlanket Implementations
Mutably borrows from an owned value. Read more
Upcasts an object to a superclass or interface T. Read more
Upcasts an object to a reference of its superclass or interface T. Read more
Tries to downcast to a subclass or interface implementor T. Read more
Tries to downcast to a reference of its subclass or interface implementor T. Read more
Tries to cast to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Tries to cast to reference to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Casts to T unconditionally. Read more
Casts to &T unconditionally. Read more
Returns true if the object is an instance of (can be cast to) T.
pub fn set_properties_from_value(
&self,
property_values: &[(&str, Value)]
) -> Result<(), BoolError>pub fn set_property<'a, N, V>(
&self,
property_name: N,
value: V
) -> Result<(), BoolError> where
V: ToValue,
N: Into<&'a str>, pub fn set_property_from_value<'a, N>(
&self,
property_name: N,
value: &Value
) -> Result<(), BoolError> where
N: Into<&'a str>, Safety Read more
Safety Read more
Safety Read more
Safety Read more
pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync, pub fn connect_notify_local<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec), pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec), pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>, pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>, pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
N: Into<&'a str>, Same as connect but takes a SignalId instead of a signal name.
pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value> + 'static,
N: Into<&'a str>, Same as connect_local but takes a SignalId instead of a signal name.
pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value]) -> Option<Value>,
N: Into<&'a str>, Same as connect_unsafe but takes a SignalId instead of a signal name.
Emit signal by signal id.
Emit signal with details by signal id.
Emit signal by it’s name.
pub fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
O: ObjectType,
N: Into<&'a str>,
M: Into<&'a str>, Same as emit but takes Value for the arguments.
Same as emit_by_name but takes Value for the arguments.
Returns a SendValue clone of self.
impl<'a, T, C> FromValueOptional<'a> for T where
C: ValueTypeChecker<Error = ValueTypeMismatchOrNoneError>,
T: FromValue<'a, Checker = C>,