Struct libadwaita::Breakpoint

pub struct Breakpoint { /* private fields */ }

Available on crate feature v1_4 only.

Describes a breakpoint for Window or Dialog.

Breakpoints are used to create adaptive UI, allowing to change the layout depending on available size.

Breakpoint is a size threshold, specified by its condition, as well as one or more setters.

Each setter has a target object, a property and a value. When a breakpoint is applied, each setter sets the target property on their target object to the specified value, and reset it back to the original value when it’s unapplied.

For more complicated scenarios, apply and unapply can be used instead.

Breakpoints can be used within Window, ApplicationWindow, Dialog or BreakpointBin.

Breakpoint as gtk::Buildable:

Breakpoint supports specifying its condition via the <condition> element. The contents of the element must be a string in a format accepted by parse().

It also supports adding setters via the <setter> element. Each <setter> element must have the object attribute specifying the target object, and the property attribute specifying the property name. The contents of the element are used as the setter value.

For G_TYPE_OBJECT and G_TYPE_BOXED derived properties, empty contents are treated as NULL.

Setter values can be translated with the usual translatable, context and comments attributes.

Example of an Breakpoint UI definition:

<object class="AdwBreakpoint">
  <condition>max-width: 400px</condition>
  <setter object="button" property="visible">True</setter>
  <setter object="box" property="orientation">vertical</setter>
  <setter object="page" property="title" translatable="yes">Example</setter>
</object>

Properties

condition

The breakpoint’s condition.

Readable | Writeable

Signals

apply

Emitted when the breakpoint is applied.

This signal is emitted after the setters have been applied.

unapply

Emitted when the breakpoint is unapplied.

This signal is emitted before resetting the setter values.

Implements

[trait@glib::ObjectExt], gtk::prelude::BuildableExt

Implementations

impl Breakpoint

pub fn new(condition: BreakpointCondition) -> Breakpoint

Creates a new Breakpoint with @condition.

condition

the condition

Returns

the newly created Breakpoint

pub fn add_setter( &self, object: &impl IsA<Object>, property: &str, value: &Value )

Adds a setter to @self.

The setter will automatically set @property on @object to @value when applying the breakpoint, and set it back to its original value upon unapplying it.

::: note Setting properties to their original values does not work for properties that have irreversible side effects. For example, changing [label][struct@crate::Gtk::Button#label] while [icon-name][struct@crate::Gtk::Button#icon-name] is set will reset the icon. However, resetting the label will not set icon-name to its original value.

Use the apply and unapply signals for those properties instead, as follows:

⚠️ The following code is in c ⚠️

static void
breakpoint_apply_cb (MyWidget *self)
{
  gtk_button_set_icon_name (self->button, "go-previous-symbolic");
}

static void
breakpoint_apply_cb (MyWidget *self)
{
  gtk_button_set_label (self->button, _("_Back"));
}

// ...

g_signal_connect_swapped (breakpoint, "apply",
                          G_CALLBACK (breakpoint_apply_cb), self);
g_signal_connect_swapped (breakpoint, "unapply",
                          G_CALLBACK (breakpoint_unapply_cb), self);

object

the target object

property

the target property

value

the value to set

pub fn condition(&self) -> Option<BreakpointCondition>

Gets the condition for @self.

Returns

the condition

pub fn set_condition(&self, condition: Option<&BreakpointCondition>)

Sets the condition for @self.

condition

the new condition

pub fn connect_apply<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId

Emitted when the breakpoint is applied.

This signal is emitted after the setters have been applied.

pub fn connect_unapply<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId

Emitted when the breakpoint is unapplied.

This signal is emitted before resetting the setter values.

pub fn connect_condition_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

impl Breakpoint

pub fn add_setters(&self, additions: &[(&impl IsA<Object>, &str, impl ToValue)])

Adds @n_setters setters to @self.

This is a convenience function for adding multiple setters at once.

See add_setter().

This function is meant to be used by language bindings.

objects

setter target object

names

setter target properties

values

setter values

Trait Implementations

impl Clone for Breakpoint

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 Breakpoint

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

Formats the value using the given formatter.

impl HasParamSpec for Breakpoint

type ParamSpec = ParamSpecObject

type SetValue = Breakpoint

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, Breakpoint>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Breakpoint

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Breakpoint

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl ParentClassIs for Breakpoint

type Parent = Object

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

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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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 Breakpoint

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Breakpoint

impl IsA<Buildable> for Breakpoint