Trait gstreamer_editing_services::subclass::prelude::ObjectSubclass

pub trait ObjectSubclass: Sized + ObjectSubclassType + 'static {
    type Type: ObjectType + ObjectSubclassIs<Subclass = Self> + FromGlibPtrFull<*mut <Self::Type as ObjectType>::GlibType> + FromGlibPtrBorrow<*mut <Self::Type as ObjectType>::GlibType> + FromGlibPtrNone<*mut <Self::Type as ObjectType>::GlibType>;
    type ParentType: IsSubclassable<Self> + FromGlibPtrFull<*mut <Self::ParentType as ObjectType>::GlibType> + FromGlibPtrBorrow<*mut <Self::ParentType as ObjectType>::GlibType> + FromGlibPtrNone<*mut <Self::ParentType as ObjectType>::GlibType>;
    type Interfaces: InterfaceList<Self>;
    type Instance: InstanceStruct<Type = Self>;
    type Class: ClassStruct<Type = Self>;

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

    // Provided methods
    fn type_init(_type_: &mut InitializingType<Self>) { ... }
    fn class_init(_klass: &mut Self::Class) { ... }
    fn new() -> Self { ... }
    fn with_class(_klass: &Self::Class) -> Self { ... }
    fn instance_init(_obj: &InitializingObject<Self>) { ... }
}

The central trait for subclassing a GObject type.

Links together the type name, parent type and the instance and class structs for type registration and allows subclasses to hook into various steps of the type registration and initialization.

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

Required Associated Types

type Type: ObjectType + ObjectSubclassIs<Subclass = Self> + FromGlibPtrFull<*mut <Self::Type as ObjectType>::GlibType> + FromGlibPtrBorrow<*mut <Self::Type as ObjectType>::GlibType> + FromGlibPtrNone<*mut <Self::Type as ObjectType>::GlibType>

Wrapper around this subclass defined with wrapper!

type ParentType: IsSubclassable<Self> + FromGlibPtrFull<*mut <Self::ParentType as ObjectType>::GlibType> + FromGlibPtrBorrow<*mut <Self::ParentType as ObjectType>::GlibType> + FromGlibPtrNone<*mut <Self::ParentType as ObjectType>::GlibType>

Parent Rust type to inherit from.

type Interfaces: InterfaceList<Self>

List of interfaces implemented by this type.

type Instance: InstanceStruct<Type = Self>

The C instance struct.

See basic::InstanceStruct for an basic instance struct that should be used in most cases.

type Class: ClassStruct<Type = Self>

The C class struct.

See basic::ClassStruct for an basic class struct that should be used in most cases.

Required Associated Constants

const NAME: &'static str

GObject type name.

This must be unique in the whole process.

Provided Associated Constants

const ABSTRACT: bool = false

If this subclass is an abstract class or not.

By default, all subclasses are non-abstract types but setting this to true will create an abstract class instead.

Abstract classes can’t be instantiated and require a non-abstract subclass.

Optional.

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 subclasses to do additional type-specific initialization, e.g. for implementing GObject interfaces.

Optional

fn class_init(_klass: &mut Self::Class)

Class initialization.

This is called after type_init and before the first instance of the subclass is created. Subclasses can use this to do class- specific initialization, e.g. for registering signals on the class or calling class methods.

Optional

fn new() -> Self

Constructor.

This is called during object instantiation before further subclasses are initialized, and should return a new instance of the subclass private struct.

Optional, either implement this or with_class().

fn with_class(_klass: &Self::Class) -> Self

Constructor.

This is called during object instantiation before further subclasses are initialized, and should return a new instance of the subclass private struct.

Different to new() above it also gets the class of this type passed to itself for providing additional context.

Optional, either implement this or new().

fn instance_init(_obj: &InitializingObject<Self>)

Performs additional instance initialization.

Called just after with_class(). At this point the initialization has not completed yet, so only a limited set of operations is safe (see InitializingObject).

Object Safety

This trait is not object safe.

Implementors