Trait libbismuth::subclass::prelude::ObjectInterface

pub trait ObjectInterface: Sized + ObjectInterfaceType + 'static {
    type Prerequisites: PrerequisiteList;
    type Instance;
    type Interface: InterfaceStruct<Type = Self>;

    const NAME: &'static str;
    const ALLOW_NAME_CONFLICT: bool = false;

    // Provided methods
    fn type_init(_type_: &mut InitializingType<Self>) { ... }
    fn interface_init(_klass: &mut Self::Interface) { ... }
    fn properties() -> &'static [ParamSpec] { ... }
    fn signals() -> &'static [Signal] { ... }
}

The central trait for defining a GObject interface.

Links together the type name, the empty instance and class structs for type registration and allows hooking into various steps of the type registration and initialization.

See register_interface for registering an implementation of this trait with the type system.

Required Associated Types

type Prerequisites: PrerequisiteList

Prerequisites for this interface.

Any implementer of the interface must be a subclass of the prerequisites or implement them in case of interfaces.

type Instance

The C instance struct. This is usually either std::ffi::c_void or a newtype wrapper around it.

Optional

type Interface: InterfaceStruct<Type = Self>

The C class struct.

Required Associated Constants

const NAME: &'static str

GObject type name.

This must be unique in the whole process.

Provided Associated Constants

const ALLOW_NAME_CONFLICT: bool = false

Allow name conflicts for this class.

By default, trying to register a type with a name that was registered before will panic. If this is set to true then a new name will be selected by appending a counter.

This is useful for defining new types in Rust library crates that might be linked multiple times in the same process.

A consequence of setting this to true is that it’s not guaranteed that glib::Type::from_name(Self::NAME).unwrap() == Self::type_().

Note that this is not allowed for dynamic types. If a dynamic type is registered and a type with that name exists already, it is assumed that they’re the same.

Optional.

Provided Methods

fn type_init(_type_: &mut InitializingType<Self>)

Additional type initialization.

This is called right after the type was registered and allows interfaces to do additional type-specific initialization.

Optional

fn interface_init(_klass: &mut Self::Interface)

Interface initialization.

This is called after type_init and before the first implementor of the interface is created. Interfaces can use this to do interface- specific initialization, e.g. for installing signals on the interface, and for setting default implementations of interface functions.

Optional

fn properties() -> &'static [ParamSpec]

Properties installed for this interface.

All implementors of the interface must provide these properties.

fn signals() -> &'static [Signal]

Signals installed for this interface.

Object Safety

This trait is not object safe.

Implementors