Trait libhandy4::subclass::prelude::ObjectClassSubclassExt

pub unsafe trait ObjectClassSubclassExt: 'static {
    pub fn install_properties<'a, T>(&mut self, properties: &[T])
    where
        T: Borrow<Property<'a>>,
    { ... }
    pub fn add_signal(
        &mut self, 
        name: &str, 
        flags: SignalFlags, 
        arg_types: &[Type], 
        ret_type: Type
    ) { ... }
    pub 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,
    { ... }
    pub 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,
    { ... }
    pub 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,
    { ... }
    pub 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

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

Install properties on the subclass.

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

pub 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.

pub 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.

pub 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.

pub 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.

pub 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...

Implementations on Foreign Types

impl ObjectClassSubclassExt for Class<Object>

Loading content...

Implementors

Loading content...