Trait glib::subclass::object::ObjectClassSubclassExt

pub unsafe trait ObjectClassSubclassExt: Sized + 'static {
    fn install_properties<'a, T: Borrow<Property<'a>>>(
        &mut self, 
        properties: &[T]
    ) { ... }
    fn add_signal(
        &mut self, 
        name: &str, 
        flags: SignalFlags, 
        arg_types: &[Type], 
        ret_type: Type
    ) { ... }
    fn add_signal_with_class_handler<F>(
        &mut self, 
        name: &str, 
        flags: SignalFlags, 
        arg_types: &[Type], 
        ret_type: Type, 
        class_handler: F
    )
    where
        F: Fn(&SignalClassHandlerToken, &[Value]) -> Option<Value> + Send + Sync + 'static,
    { ... }
    fn add_signal_with_accumulator<F>(
        &mut self, 
        name: &str, 
        flags: SignalFlags, 
        arg_types: &[Type], 
        ret_type: Type, 
        accumulator: F
    )
    where
        F: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
    { ... }
    fn add_signal_with_class_handler_and_accumulator<F, G>(
        &mut self, 
        name: &str, 
        flags: SignalFlags, 
        arg_types: &[Type], 
        ret_type: Type, 
        class_handler: F, 
        accumulator: G
    )
    where
        F: Fn(&SignalClassHandlerToken, &[Value]) -> Option<Value> + Send + Sync + 'static,
        G: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
    { ... }
    fn override_signal_class_handler<F>(&mut self, name: &str, class_handler: F)
    where
        F: Fn(&SignalClassHandlerToken, &[Value]) -> Option<Value> + Send + Sync + 'static,
    { ... }
}

Extension trait for glib::Object's class struct.

This contains various class methods and allows subclasses to override the virtual methods.

Provided methods

fn install_properties<'a, T: Borrow<Property<'a>>>(&mut self, properties: &[T])

Install properties on the subclass.

The index in the properties array is going to be the index passed to the property setters and getters.

fn add_signal(
    &mut self,
    name: &str,
    flags: SignalFlags,
    arg_types: &[Type],
    ret_type: Type
)

Add a new signal to the subclass.

This can be emitted later by glib::Object::emit and external code can connect to the signal to get notified about emissions.

fn add_signal_with_class_handler<F>(
    &mut self,
    name: &str,
    flags: SignalFlags,
    arg_types: &[Type],
    ret_type: Type,
    class_handler: F
) where
    F: Fn(&SignalClassHandlerToken, &[Value]) -> Option<Value> + Send + Sync + 'static, 

Add a new signal with class handler to the subclass.

This can be emitted later by glib::Object::emit and external code can connect to the signal to get notified about emissions.

The class handler will be called during the signal emission at the corresponding stage.

fn add_signal_with_accumulator<F>(
    &mut self,
    name: &str,
    flags: SignalFlags,
    arg_types: &[Type],
    ret_type: Type,
    accumulator: F
) where
    F: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static, 

Add a new signal with accumulator to the subclass.

This can be emitted later by glib::Object::emit and external code can connect to the signal to get notified about emissions.

The accumulator function is used for accumulating the return values of multiple signal handlers. The new value is passed as second argument and should be combined with the old value in the first argument. If no further signal handlers should be called, false should be returned.

fn add_signal_with_class_handler_and_accumulator<F, G>(
    &mut self,
    name: &str,
    flags: SignalFlags,
    arg_types: &[Type],
    ret_type: Type,
    class_handler: F,
    accumulator: G
) where
    F: Fn(&SignalClassHandlerToken, &[Value]) -> Option<Value> + Send + Sync + 'static,
    G: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static, 

Add a new signal with accumulator and class handler to the subclass.

This can be emitted later by glib::Object::emit and external code can connect to the signal to get notified about emissions.

The accumulator function is used for accumulating the return values of multiple signal handlers. The new value is passed as second argument and should be combined with the old value in the first argument. If no further signal handlers should be called, false should be returned.

The class handler will be called during the signal emission at the corresponding stage.

fn override_signal_class_handler<F>(&mut self, name: &str, class_handler: F) where
    F: Fn(&SignalClassHandlerToken, &[Value]) -> Option<Value> + Send + Sync + 'static, 

Loading content...

Implementors

impl ObjectClassSubclassExt for ObjectClass

Loading content...