Close #8 - introduce BuilderSingalConnector to replace old signal c…

…onnection

examples/example_actor_per_row.rs

@@ -47,7 +47,7 @@ impl actix::StreamHandler<WindowSignal> for WindowActor {
  match signal {
  WindowSignal::ClickButton => {
  let addend = self.factories.row_addend.instantiate().actor()
- .connect_signals::<AddendSignal>()
+ .connect_signals(AddendSignal::connector())
  .create(|builder_ctx| {
  let widgets: AddendWidgets = builder_ctx.widgets().unwrap();
  self.widgets.lst_addition.add(&widgets.row_addend);
@@ -166,7 +166,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
  woab::run_actix_inside_gtk_event_loop("example")?;
 
  factories.win_app.instantiate().actor()
- .connect_signals::<WindowSignal>()
+ .connect_signals(WindowSignal::connector())
  .create(|ctx| {
  WindowActor {
  widgets: ctx.widgets().unwrap(),

examples/example_events.rs

@@ -89,7 +89,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
  woab::run_actix_inside_gtk_event_loop("example")?;
 
  factories.win_app.instantiate().actor()
- .connect_signals::<WindowSignal>()
+ .connect_signals(WindowSignal::connector())
  .create(|ctx| WindowActor {
  widgets: ctx.widgets().unwrap(),
  press_times: Default::default(),

examples/example_taggged_signals.rs

@@ -46,9 +46,9 @@ impl actix::StreamHandler<WindowSignal> for WindowActor {
  WindowSignal::ClickButton => {
  let addend_id = self.next_addend_id;
  self.next_addend_id += 1;
- let builder = self.factories.row_addend.instantiate();
- builder.connect_signals_tagged(addend_id, ctx);
- let widgets = builder.widgets::<AddendWidgets>().unwrap();
+ let widgets: AddendWidgets = self.factories.row_addend.instantiate()
+  .connect_signals(ctx, AddendSignal::connector().tag(addend_id))
+  .widgets().unwrap();
  self.widgets.lst_addition.add(&widgets.row_addend);
  self.addends.insert(addend_id, (widgets, Some(0)));
  self.recalculate();
@@ -112,7 +112,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
  woab::run_actix_inside_gtk_event_loop("example")?;
 
  factories.win_app.instantiate().actor()
- .connect_signals::<WindowSignal>()
+ .connect_signals(WindowSignal::connector())
  .create(|ctx| {
  WindowActor {
  widgets: ctx.widgets().unwrap(),

macros/src/builder_signal_derive.rs

@@ -131,5 +131,11 @@ pub fn impl_builder_signal_derive(ast: &syn::DeriveInput) -> Result<proc_macro2:
  ]
  }
  }
+
+ impl #enum_ident {
+ fn connector() -> woab::BuilderSingalConnector<Self, ()> {
+ <Self as woab::BuilderSignal>::connector()
+ }
+ }
  })
 }

src/builder.rs

@@ -4,7 +4,6 @@ use std::cell::RefCell;
 
 use gtk::Builder;
 use tokio::sync::mpsc;
-use tokio::stream::StreamExt;
 
 /// Holds instructions for generating a GTK builder.
 ///
@@ -64,8 +63,8 @@ impl BuilderFactory {
 /// # use gtk::prelude::*;
 /// #[derive(woab::Factories)]
 /// struct Factories {
-/// window: woab::Factory,
-/// row: woab::Factory,
+/// window: woab::BuilderFactory,
+/// row: woab::BuilderFactory,
 /// }
 ///
 /// struct WindowActor {
@@ -115,16 +114,19 @@ impl BuilderFactory {
 /// }
 ///
 /// fn create_window_with_rows(factory: &Factories) {
-/// factory.window.build().actor(|ctx, widgets| {
-/// for row_number in 0..10 {
-/// let row_widgets = factory.row.build()
-/// .connect_tagged_builder_signals(ctx, row_number)
-/// .widgets().unwrap();
-/// row_widgets.label.set_text(&format!("Roe number {}", row_number));
-/// widgets.list_box.add(&row_widgets.row);
-/// }
-/// WindowActor { widgets }
-/// }).unwrap();
+/// factory.window.instantiate().actor()
+/// .connect_signals(WindowSignal::connector())
+/// .create(|ctx| {
+/// let widgets: WindowWidgets = ctx.widgets().unwrap();
+/// for row_number in 0..10 {
+/// let row_widgets: RowWidgets = factory.row.instantiate()
+/// .connect_signals(ctx, RowSignal::connector().tag(row_number))
+/// .widgets().unwrap();
+/// row_widgets.label.set_text(&format!("Roe number {}", row_number));
+/// widgets.list_box.add(&row_widgets.row);
+/// }
+/// WindowActor { widgets }
+/// });
 /// }
 /// ```
 
@@ -133,7 +135,7 @@ impl BuilderFactory {
 /// It wraps a `gtk::Builder` instance and provides methods to create actors that are
 /// connected to the widgets in that builder.
 ///
-/// See [`woab::Factory`](struct.Factory.html) for usage example.
+/// See [`woab::BuilderFactory`](struct.BuilderFactory.html) for usage example.
 pub struct BuilderConnector {
  builder: gtk::Builder,
  callbacks: RefCell<HashMap<&'static str, crate::RawSignalCallback>>,
@@ -169,52 +171,23 @@ impl BuilderConnector {
  }
 
  /// Create a widgets struct (as defined by the `W` generic parameter of
- /// [`woab::Factory`](struct.Factory.html)) and map the builder's widgets to its fields.
- pub fn widgets<W>(&self) -> Result<W, <gtk::Builder as TryInto<W>>::Error> 
+ /// [`woab::BuilderFactory`](struct.BuilderFactory.html)) and map the builder's widgets to its fields.
+ pub fn widgets<W>(&self) -> Result<W, <gtk::Builder as TryInto<W>>::Error>
  where gtk::Builder: TryInto<W>
  {
  self.builder.clone().try_into()
  }
 
- pub fn connect_signals<A, S>(&self, ctx: &mut actix::Context<A>)
- where
- A: actix::Actor<Context = actix::Context<A>>,
- A: actix::StreamHandler<S>,
- S: crate::BuilderSignal,
- {
- let (tx, rx) = mpsc::channel(16);
- let mut callbacks = self.callbacks.borrow_mut();
- for signal in S::list_signals() {
- callbacks.insert(signal, S::bridge_signal(signal, tx.clone()).unwrap());
- }
- A::add_stream(rx, ctx);
- }
-
- /// 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 `GtkListBoxRow`s) 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!!!**
- pub fn connect_signals_tagged<A, S, T>(&self, tag: T, ctx: &mut actix::Context<A>)
+ pub fn connect_signals<A, R>(&self, ctx: &mut actix::Context<A>, register_signal_handlers: R) -> &Self
  where
- T: Clone + 'static,
  A: actix::Actor<Context = actix::Context<A>>,
- A: actix::StreamHandler<(T, S)>,
- S: crate::BuilderSignal,
+ R: crate::RegisterSignalHandlers,
+ R::MessageType: 'static,
+ A: actix::StreamHandler<R::MessageType>,
  {
- let (tx, rx) = mpsc::channel(16);
- let rx = rx.map(move |s| (tag.clone(), s));
  let mut callbacks = self.callbacks.borrow_mut();
- for signal in S::list_signals() {
- callbacks.insert(signal, S::bridge_signal(signal, tx.clone()).unwrap());
- }
- use actix::AsyncContext;
- ctx.add_stream(rx);
+ register_signal_handlers.register_signal_handlers::<A>(ctx, &mut callbacks);
+ self
  }
 
  pub fn actor<A: actix::Actor<Context = actix::Context<A>>>(&self) -> ActorBuilder<A> {
@@ -284,7 +257,7 @@ pub struct ActorBuilder<'a, A: actix::Actor<Context = actix::Context<A>>> {
 }
 
 impl<'a, A: actix::Actor<Context = actix::Context<A>>> ActorBuilder<'a, A> {
- pub fn run(self, actor: A) -> actix::Addr<A> {
+ pub fn start(self, actor: A) -> actix::Addr<A> {
  self.actor_context.run(actor)
  }
 
@@ -297,22 +270,22 @@ impl<'a, A: actix::Actor<Context = actix::Context<A>>> ActorBuilder<'a, A> {
  actor_builder_context.actor_context.run(actor)
  }
 
- pub fn connect_signals<S>(mut self) -> Self
- where
- A: actix::StreamHandler<S>,
- S: crate::BuilderSignal,
- {
- self.builder_connector.connect_signals(&mut self.actor_context);
- self
+ pub fn try_create<'b, E>(self, dlg: impl FnOnce(&mut ActorBuilderContext<'a, A>) -> Result<A, E>) -> Result<actix::Addr<A>, E> where 'a: 'b {
+  let mut actor_builder_context = ActorBuilderContext {
+  builder_connector: self.builder_connector,
+  actor_context: self.actor_context,
+  };
+ let actor = dlg(&mut actor_builder_context)?;
+ Ok(actor_builder_context.actor_context.run(actor))
  }
 
- pub fn connect_signals_tagged<S, T>(mut self, tag: T) -> Self
+ pub fn connect_signals<R>(mut self, register_signal_handlers: R) -> Self
  where
- T: Clone + 'static,
- A: actix::StreamHandler<(T, S)>,
- S: crate::BuilderSignal,
+ R: crate::RegisterSignalHandlers,
+ R::MessageType: 'static,
+ A: actix::StreamHandler<R::MessageType>,
  {
- self.builder_connector.connect_signals_tagged(tag, &mut self.actor_context);
+ self.builder_connector.connect_signals(&mut self.actor_context, register_signal_handlers);
  self
  }
 }

src/builder_signal.rs

@@ -1,16 +1,101 @@
+use std::collections::HashMap;
+
 use tokio::sync::mpsc;
 
 /// Type of a gtk signal callback function that operates on uncast glib values
 pub type RawSignalCallback = Box<dyn Fn(&[glib::Value]) -> Option<glib::Value>>;
 
 /// Represent a GTK signal that originates from a GTK builder. Refer to [the corresponding derive](derive.BuilderSignal.html).
 pub trait BuilderSignal: Sized + 'static {
-
  /// Generate a signal handler function for GTK.
  ///
  /// The returned function should convert the signals it revceives to the signal type, and
  /// transmit them over `tx`.
  fn bridge_signal(signal: &str, tx: mpsc::Sender<Self>) -> Option<RawSignalCallback>;
 
  fn list_signals() -> &'static [&'static str];
+
+ fn connector() -> BuilderSingalConnector<Self, ()> {
+ BuilderSingalConnector {
+ transformer: (),
+ _phantom_data: Default::default(),
+ }
+ }
+}
+
+pub trait RegisterSignalHandlers {
+ type MessageType;
+
+ fn register_signal_handlers<A>(self, ctx: &mut A::Context, callbacks: &mut HashMap<&'static str, crate::RawSignalCallback>)
+ where
+ A: actix::Actor<Context = actix::Context<A>>,
+ A: actix::StreamHandler<Self::MessageType>;
+}
+
+pub trait SignalTransformer<S>: Clone {
+ type Output: 'static;
+
+ fn transform(&self, signal: S) -> Self::Output;
+}
+
+impl<S: 'static> SignalTransformer<S> for () {
+ type Output = S;
+
+ fn transform(&self, signal: S) -> Self::Output {
+ signal
+ }
+}
+
+impl<S: 'static, T: 'static + Clone> SignalTransformer<S> for (T,) {
+ type Output = (T, S);
+
+ fn transform(&self, signal: S) -> Self::Output {
+ (self.0.clone(), signal)
+ }
+}
+
+pub struct BuilderSingalConnector<S, T>
+where
+ S: BuilderSignal,
+ T: Clone,
+{
+ transformer: T,
+ _phantom_data: core::marker::PhantomData<S>,
+}
+
+impl<S> BuilderSingalConnector<S, ()>
+where
+ S: BuilderSignal,
+{
+ pub fn tag<T: Clone>(self, tag: T) -> BuilderSingalConnector<S, (T,)> {
+ BuilderSingalConnector {
+ transformer: (tag,),
+ _phantom_data: Default::default(),
+ }
+ }
+}
+
+impl<S, T> RegisterSignalHandlers for BuilderSingalConnector<S, T>
+where
+ S: 'static,
+ S: BuilderSignal,
+ T: 'static,
+ T: SignalTransformer<S>,
+{
+ type MessageType = T::Output;
+ // type MessageType = S;
+
+ fn register_signal_handlers<A>(self, ctx: &mut A::Context, callbacks: &mut HashMap<&'static str, crate::RawSignalCallback>)
+ where
+ A: actix::Actor<Context = actix::Context<A>>,
+ A: actix::StreamHandler<Self::MessageType>,
+ {
+ let (tx, rx) = mpsc::channel(16);
+ for signal in S::list_signals() {
+ callbacks.insert(signal, S::bridge_signal(signal, tx.clone()).unwrap());
+ }
+ use tokio::stream::StreamExt;
+ let rx = rx.map(move|s| self.transformer.transform(s));
+ A::add_stream(rx, ctx);
+ }
 }