Struct woab::BuilderUtilizer

pub struct BuilderUtilizer<A, W, S> { /* fields omitted */ }

Context for utilizing a gtk::Builder and connecting it to he Actix world.

See woab::Factory for usage example.

Implementations

impl<A, W, S> BuilderUtilizer<A, W, S> where
    &'a Builder: TryInto<W>, 

pub fn widgets(&self) -> Result<W, <&Builder as TryInto<W>>::Error>

Create a widgets struct (as defined by the W generic parameter of woab::Factory) and map the builder's widgets to its fields.

impl<A, W, S> BuilderUtilizer<A, W, S> where
    A: Actor<Context = Context<A>>,
    &'a Builder: TryInto<W>,
    S: BuilderSignal,
    A: StreamHandler<S>, 

pub fn actor(
    &self,
    make_actor: impl FnOnce(&mut A::Context, W) -> A
) -> Result<Addr<A>, <&Builder as TryInto<W>>::Error>

Create an Actix actor and connect it to the builder's widgets and signals.

make_actor is a function that receives the actor context and the widgets, and is responsible for constructing the actor struct with the widgets inside it. It can also be used for configuring and or showing the widgets GTK-wise (though this can also be handled by the actor afterwards)

impl<A, W, S> BuilderUtilizer<A, W, S> where
    S: BuilderSignal, 

pub fn stream_builder_signals(&self) -> Option<Receiver<S>>

Create a stream (based on Tokio's MSPC) of signals that arrive from the builder.

• The signals are all represented by the third generic parameter (S) of woab::Factory - if the builder sends signals not covered by S's variants they'll be ignored.
• If the builder defines no signals, or if none of the signals it defines are covered by S, this method will return None. This is important because otherwise it would have returned a stream stream will be closed automatically for having no transmitters, which - by default - will make Actix close the actor.

pub fn connect_tagged_builder_signals<T, C, AA>(
    &self,
    ctx: &mut C,
    tag: T
) -> &Self where
    T: Clone + 'static,
    AA: Actor<Context = C>,
    C: AsyncContext<AA>,
    AA: StreamHandler<(T, S)>, 

Stream the signals generated by the builder to an actor represented by ctx, together with a tag.

When using the same actor to handle multiple copies of the same set of widgets (e.g. multiple GtkListBoxRows) the tag can be used to determine which copy generated the signal.

If multiple tagged signals are streamed to the same actor - which is the typical use case for tagged signals - StreamHandler::finished should be overridden to avoid stopping the actor when one instance of the widgets is removed!!!

Trait Implementations

impl<A, W, S> From<Builder> for BuilderUtilizer<A, W, S>

fn from(builder: Builder) -> Self

Performs the conversion.