Struct gtk4::ApplicationWindow[−][src]

pub struct ApplicationWindow(_);

Expand description

ApplicationWindow is a Window subclass that integrates with Application.

Notably, ApplicationWindow can handle an application menubar.

This class implements the GActionGroup and GActionMap interfaces, to let you add window-specific actions that will be exported by the associated gio::Application, together with its application-wide actions. Window-specific actions are prefixed with the “win.” prefix and application-wide actions are prefixed with the “app.” prefix. Actions must be addressed with the prefixed name when referring to them from a GMenuModel.

Note that widgets that are placed inside a ApplicationWindow can also activate these actions, if they implement the Actionable interface.

The settings property::Settings::gtk-shell-shows-app-menu and property::Settings::gtk-shell-shows-menubar tell GTK whether the desktop environment is showing the application menu and menubar models outside the application as part of the desktop shell. For instance, on OS X, both menus will be displayed remotely; on Windows neither will be.

If the desktop environment does not display the menubar, then ApplicationWindow will automatically show a menubar for it. This behaviour can be overridden with the property::ApplicationWindow::show-menubar property. If the desktop environment does not display the application menu, then it will automatically be included in the menubar or in the windows client-side decorations.

See PopoverMenu for information about the XML language used by Builder for menu models.

A GtkApplicationWindow with a menubar

The code sample below shows how to set up a ApplicationWindow with a menu bar defined on the gio::Application:

⚠️ The following code is in c ⚠️

GtkApplication *app = gtk_application_new ("org.gtk.test", 0);

GtkBuilder *builder = gtk_builder_new_from_string (
    "<interface>"
    "  <menu id='menubar'>"
    "    <submenu>"
    "      <attribute name='label' translatable='yes'>_Edit</attribute>"
    "      <item>"
    "        <attribute name='label' translatable='yes'>_Copy</attribute>"
    "        <attribute name='action'>win.copy</attribute>"
    "      </item>"
    "      <item>"
    "        <attribute name='label' translatable='yes'>_Paste</attribute>"
    "        <attribute name='action'>win.paste</attribute>"
    "      </item>"
    "    </submenu>"
    "  </menu>"
    "</interface>",
    -1);

GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
g_object_unref (builder);

// ...

GtkWidget *window = gtk_application_window_new (app);

Implements

ApplicationWindowExt, GtkWindowExt, WidgetExt, glib::ObjectExt, AccessibleExt, BuildableExt, ConstraintTargetExt, NativeExt, RootExt, ShortcutManagerExt, gio::prelude::ActionGroupExt, gio::prelude::ActionMapExt, WidgetExtManual, AccessibleExtManual

Struct gtk4::ApplicationWindow[−][src]

Implementations

impl ApplicationWindow

pub fn new<P: IsA<Application>>(application: &P) -> ApplicationWindow

pub fn builder() -> ApplicationWindowBuilder

Trait Implementations

impl Clone for ApplicationWindow

fn clone(&self) -> ApplicationWindow

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

impl Debug for ApplicationWindow

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

impl Default for ApplicationWindow

fn default() -> Self

impl Display for ApplicationWindow

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

impl Hash for ApplicationWindow

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

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

impl<T: ApplicationWindowImpl> IsSubclassable<T> for ApplicationWindow

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

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

impl Ord for ApplicationWindow

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

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

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

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

impl ParentClassIs for ApplicationWindow

type Parent = Window

impl<T: ObjectType> PartialEq<T> for ApplicationWindow

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

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

impl<T: ObjectType> PartialOrd<T> for ApplicationWindow

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

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

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

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

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

impl StaticType for ApplicationWindow

fn static_type() -> Type

impl Eq for ApplicationWindow

impl IsA<Accessible> for ApplicationWindow

impl IsA<ActionGroup> for ApplicationWindow

impl IsA<ActionMap> for ApplicationWindow

impl IsA<Buildable> for ApplicationWindow

impl IsA<ConstraintTarget> for ApplicationWindow

impl IsA<Native> for ApplicationWindow

impl IsA<Root> for ApplicationWindow

impl IsA<ShortcutManager> for ApplicationWindow

impl IsA<Widget> for ApplicationWindow

impl IsA<Window> for ApplicationWindow

impl StructuralEq for ApplicationWindow

Auto Trait Implementations

impl RefUnwindSafe for ApplicationWindow

impl !Send for ApplicationWindow

impl !Sync for ApplicationWindow

impl Unpin for ApplicationWindow

impl UnwindSafe for ApplicationWindow

Blanket Implementations

impl<O> ActionGroupExt for O where O: IsA<ActionGroup>,

pub fn action_added(&self, action_name: &str)

pub fn action_enabled_changed(&self, action_name: &str, enabled: bool)

pub fn action_removed(&self, action_name: &str)

pub fn action_state_changed(&self, action_name: &str, state: &Variant)

pub fn activate_action(&self, action_name: &str, parameter: Option<&Variant>)

pub fn change_action_state(&self, action_name: &str, value: &Variant)

pub fn is_action_enabled(&self, action_name: &str) -> bool

pub fn action_parameter_type(&self, action_name: &str) -> Option<VariantType>

pub fn action_state(&self, action_name: &str) -> Option<Variant>

pub fn action_state_hint(&self, action_name: &str) -> Option<Variant>

pub fn action_state_type(&self, action_name: &str) -> Option<VariantType>

pub fn has_action(&self, action_name: &str) -> bool

pub fn list_actions(&self) -> Vec<GString, Global>

pub fn connect_action_added<F>( &self, detail: Option<&str>, f: F) -> SignalHandlerId where F: 'static + Fn(&O, &str),

pub fn connect_action_enabled_changed<F>( &self, detail: Option<&str>, f: F) -> SignalHandlerId where F: 'static + Fn(&O, &str, bool),

pub fn connect_action_removed<F>( &self, detail: Option<&str>, f: F) -> SignalHandlerId where F: 'static + Fn(&O, &str),

pub fn connect_action_state_changed<F>( &self, detail: Option<&str>, f: F) -> SignalHandlerId where F: 'static + Fn(&O, &str, &Variant),

impl<O> ActionMapExt for O where O: IsA<ActionMap>,

pub fn add_action<P>(&self, action: &P) where P: IsA<Action>,

pub fn lookup_action(&self, action_name: &str) -> Option<Action>

pub fn remove_action(&self, action_name: &str)

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

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

impl<O> ActionGroupExt for O where
O: IsA<ActionGroup>,

pub fn connect_action_added<F>(
&self,
detail: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&O, &str),

pub fn connect_action_enabled_changed<F>(
&self,
detail: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&O, &str, bool),

pub fn connect_action_removed<F>(
&self,
detail: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&O, &str),

pub fn connect_action_state_changed<F>(
&self,
detail: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&O, &str, &Variant),

impl<O> ActionMapExt for O where
O: IsA<ActionMap>,

pub fn add_action<P>(&self, action: &P) where
P: IsA<Action>,

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T> Cast for T where
T: ObjectType,

fn upcast<T>(self) -> T where
T: ObjectType,
Self: IsA<T>,

fn upcast_ref<T>(&self) -> &T where
T: ObjectType,
Self: IsA<T>,

fn downcast<T>(self) -> Result<T, Self> where
T: ObjectType,
Self: CanDowncast<T>,

fn downcast_ref<T>(&self) -> Option<&T> where
T: ObjectType,
Self: CanDowncast<T>,

fn dynamic_cast<T>(self) -> Result<T, Self> where
T: ObjectType,

fn dynamic_cast_ref<T>(&self) -> Option<&T> where
T: ObjectType,

unsafe fn unsafe_cast<T>(self) -> T where
T: ObjectType,

unsafe fn unsafe_cast_ref<T>(&self) -> &T where
T: ObjectType,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ObjectExt for T where
T: ObjectType,

pub fn is<U>(&self) -> bool where
U: StaticType,

pub fn class(&self) -> &Class<T> where
T: IsClass,

pub fn class_of<U>(&self) -> Option<&Class<U>> where
U: IsClass,

pub fn interface<U>(&self) -> Option<InterfaceRef<'_, U>> where
U: IsInterface,

pub fn set_property<'a, N, V>(
&self,
property_name: N,
value: V
) -> Result<(), BoolError> where
N: Into<&'a str>,
V: ToValue,

pub fn set_property_from_value<'a, N>(
&self,
property_name: N,
value: &Value
) -> Result<(), BoolError> where
N: Into<&'a str>,

pub fn set_properties(
&self,
property_values: &[(&str, &dyn ToValue )]
) -> Result<(), BoolError>

pub fn set_properties_from_value(
&self,
property_values: &[(&str, Value )]
) -> Result<(), BoolError>

pub fn property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where
N: Into<&'a str>,

pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>,

pub fn property_type<'a, N>(&self, property_name: N) -> Option<Type> where
N: Into<&'a str>,

pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>,

pub unsafe fn set_qdata<QD>(&self, key: Quark, value: QD) where
QD: 'static,

pub unsafe fn qdata<QD>(&self, key: Quark) -> Option<NonNull<QD>> where
QD: 'static,

pub unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD> where
QD: 'static,

pub unsafe fn set_data<QD>(&self, key: &str, value: QD) where
QD: 'static,

pub unsafe fn data<QD>(&self, key: &str) -> Option<NonNull<QD>> where
QD: 'static,

pub unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD> where
QD: 'static,

pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn connect_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub fn connect_local_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value ]) -> Option<Value>,

pub unsafe fn connect_unsafe_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value ]) -> Option<Value>,

pub fn emit(
&self,
signal_id: SignalId,
args: &[&dyn ToValue ]
) -> Result<Option<Value>, BoolError>

pub fn emit_with_values(
&self,
signal_id: SignalId,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

pub fn emit_by_name<'a, N>(
&self,
signal_name: N,
args: &[&dyn ToValue ]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,

pub fn emit_by_name_with_values<'a, N>(
&self,
signal_name: N,
args: &[Value ]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,

pub fn emit_with_details(
&self,
signal_id: SignalId,
details: Quark,
args: &[&dyn ToValue ]
) -> Result<Option<Value>, BoolError>

pub fn emit_with_details_and_values(
&self,
signal_id: SignalId,
details: Quark,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

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),