Struct respo::RespoEventMarkFn

pub struct RespoEventMarkFn(_);

(internal) function to handle event marks at first phase of event handling

Implementations

impl RespoEventMarkFn

pub fn run(&self, e: RespoEventMark) -> Result<(), String>

Examples found in repository

src/respo/patch.rs (line 307)

pub fn attach_event(element: &Element, key: &str, coord: &[RespoCoord], handle_event: RespoEventMarkFn) -> Result<(), String> {
  let coord = coord.to_owned();
  // crate::util::log!("attach event {}", key);
  match key {
    "click" => {
      let handler = Closure::wrap(Box::new(move |e: MouseEvent| {
        let wrap_event = RespoEvent::Click {
          client_x: e.client_x() as f64,
          client_y: e.client_y() as f64,
          original_event: e,
        };
        handle_event
          .run(RespoEventMark::new("click", &coord, wrap_event))
          .expect("handle click event");
      }) as Box<dyn FnMut(MouseEvent)>);
      element
        .dyn_ref::<HtmlElement>()
        .expect("convert to html element")
        .set_onclick(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }

    "dblclick" => {
      let handler = Closure::wrap(Box::new(move |e: MouseEvent| {
        let wrap_event = RespoEvent::Click {
          client_x: e.client_x() as f64,
          client_y: e.client_y() as f64,
          original_event: e,
        };
        handle_event
          .run(RespoEventMark::new("dblclick", &coord, wrap_event))
          .expect("handle dblclick event");
      }) as Box<dyn FnMut(MouseEvent)>);
      element
        .dyn_ref::<HtmlElement>()
        .expect("convert to html element")
        .set_ondblclick(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }
    "input" => {
      let handler = Closure::wrap(Box::new(move |e: InputEvent| {
        let target = e.target().expect("get target");
        let el = target.dyn_ref::<Element>().unwrap();
        let value = match el.tag_name().as_str() {
          "INPUT" => el.dyn_ref::<HtmlInputElement>().expect("to convert to html input element").value(),
          "TEXTAREA" => el
            .dyn_ref::<HtmlTextAreaElement>()
            .expect("to convert to html text area element")
            .value(),
          _ => {
            // TODO Error
            return;
          }
        };
        let wrap_event = RespoEvent::Input { value, original_event: e };
        handle_event
          .run(RespoEventMark::new("input", &coord, wrap_event))
          .expect("handle input event");
      }) as Box<dyn FnMut(InputEvent)>);
      match element.tag_name().as_str() {
        "INPUT" => {
          element
            .dyn_ref::<HtmlInputElement>()
            .expect("convert to html input element")
            .set_oninput(Some(handler.as_ref().unchecked_ref()));
        }
        "TEXTAREA" => {
          element
            .dyn_ref::<HtmlTextAreaElement>()
            .expect("convert to html textarea element")
            .set_oninput(Some(handler.as_ref().unchecked_ref()));
        }
        _ => {
          return Err(format!("unsupported input event: {}", element.tag_name()));
        }
      }

      handler.forget();
    }
    "change" => {
      let handler = Closure::wrap(Box::new(move |e: InputEvent| {
        let wrap_event = RespoEvent::Input {
          value: e
            .target()
            .expect("to reach event target")
            .dyn_ref::<HtmlInputElement>()
            .expect("to convert to html input element")
            .value(),
          original_event: e,
        };
        handle_event
          .run(RespoEventMark::new("change", &coord, wrap_event))
          .expect("handle change event");
      }) as Box<dyn FnMut(InputEvent)>);
      element
        .dyn_ref::<HtmlInputElement>()
        .expect("convert to html input element")
        .set_onchange(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }
    "keydown" => {
      let handler = Closure::wrap(Box::new(move |e: KeyboardEvent| {
        // crate::util::log!("calling handler");
        let wrap_event = RespoEvent::Keyboard {
          key: e.key(),
          key_code: e.key_code(),
          shift_key: e.shift_key(),
          ctrl_key: e.ctrl_key(),
          alt_key: e.alt_key(),
          meta_key: e.meta_key(),
          repeat: e.repeat(),
          original_event: e,
        };
        handle_event
          .run(RespoEventMark::new("keydown", &coord, wrap_event))
          .expect("handle keydown event");
      }) as Box<dyn FnMut(KeyboardEvent)>);
      element
        .dyn_ref::<HtmlInputElement>()
        .expect("convert to html input element")
        .set_onkeydown(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }
    "keyup" => {
      let handler = Closure::wrap(Box::new(move |e: KeyboardEvent| {
        let wrap_event = RespoEvent::Keyboard {
          key: e.key(),
          key_code: e.key_code(),
          shift_key: e.shift_key(),
          ctrl_key: e.ctrl_key(),
          alt_key: e.alt_key(),
          meta_key: e.meta_key(),
          repeat: e.repeat(),
          original_event: e,
        };
        handle_event
          .run(RespoEventMark::new("keyup", &coord, wrap_event))
          .expect("handle keyup event");
      }) as Box<dyn FnMut(KeyboardEvent)>);
      element
        .dyn_ref::<HtmlInputElement>()
        .expect("convert to html input element")
        .set_onkeyup(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }
    "keypress" => {
      let handler = Closure::wrap(Box::new(move |e: KeyboardEvent| {
        let wrap_event = RespoEvent::Keyboard {
          key: e.key(),
          key_code: e.key_code(),
          shift_key: e.shift_key(),
          ctrl_key: e.ctrl_key(),
          alt_key: e.alt_key(),
          meta_key: e.meta_key(),
          repeat: e.repeat(),
          original_event: e,
        };
        handle_event
          .run(RespoEventMark::new("keypress", &coord, wrap_event))
          .expect("handle keypress event");
      }) as Box<dyn FnMut(KeyboardEvent)>);
      element
        .dyn_ref::<HtmlInputElement>()
        .expect("convert to html input element")
        .set_onkeypress(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }
    "focus" => {
      let handler = Closure::wrap(Box::new(move |e: FocusEvent| {
        handle_event
          .run(RespoEventMark::new("focus", &coord, RespoEvent::Focus(e)))
          .expect("handle focus event");
      }) as Box<dyn FnMut(FocusEvent)>);
      element
        .dyn_ref::<HtmlInputElement>()
        .expect("convert to html input element")
        .set_onfocus(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }
    "blur" => {
      let handler = Closure::wrap(Box::new(move |e: FocusEvent| {
        handle_event
          .run(RespoEventMark::new("blur", &coord, RespoEvent::Focus(e)))
          .expect("handle blur event");
      }) as Box<dyn FnMut(FocusEvent)>);
      element
        .dyn_ref::<HtmlInputElement>()
        .expect("convert to html input element")
        .set_onblur(Some(handler.as_ref().unchecked_ref()));
      handler.forget();
    }
    _ => {
      warn_1(&format!("unhandled event: {}", key).into());
    }
  }
  Ok(())
}

pub fn new<U>(f: U) -> Selfwhere
    U: Fn(RespoEventMark) -> Result<(), String> + 'static,

Examples found in repository

src/respo.rs (lines 71-88)

pub fn render_node<T, U>(
  mount_target: Node,
  // TODO it copies the whole store, need to optimize
  get_store: Box<dyn Fn() -> U>,
  mut renderer: Box<dyn FnMut() -> Result<RespoNode<T>, String>>,
  dispatch_action: DispatchFn<T>,
  interval: Option<i32>,
) -> Result<(), JsValue>
where
  T: 'static + Debug + Clone,
  U: Debug + Clone + PartialEq + 'static,
{
  let prev_store = RefCell::new(get_store());
  let tree0: RespoNode<T> = renderer()?;
  let prev_tree = Rc::new(RefCell::new(tree0.clone()));

  let to_prev_tree = prev_tree.clone();
  let handle_event = RespoEventMarkFn::new(move |mark: RespoEventMark| -> Result<(), String> {
    match request_for_target_handler(&to_prev_tree.borrow(), &mark.name, &mark.coord) {
      Ok(handler) => match handler.run(mark.event_info, dispatch_action.clone()) {
        Ok(()) => {
          // util::log!("finished event: {} {:?}", mark.name, mark.coord);
          mark_need_rerender();
        }
        Err(e) => {
          error_1(&format!("event handler error: {:?}", e).into());
        }
      },
      Err(msg) => {
        error_1(&format!("event not handled: {}", msg).into());
      }
    }

    Ok(())
  });

  let handler = handle_event.clone();
  let element = build_dom_tree(&tree0, &[], handler)?;

  // collection mounted effects
  let mut mount_changes: Vec<DomChange<T>> = vec![];
  collect_effects_outside_in_as(&tree0, &[], &[], RespoEffectType::Mounted, &mut mount_changes)?;

  mount_target.append_child(&element)?;
  let handler = handle_event.clone();
  // util::log!("mounted changed: {:?}", mount_changes);
  patch_tree(&tree0, &prev_tree.borrow(), &mount_target, &mount_changes, handler)?;

  let to_prev_tree = prev_tree.clone();
  match interval {
    Some(v) => {
      util::raf_loop_slow(
        v,
        Box::new(move || -> Result<(), String> {
          if drain_rerender_status() {
            let store = get_store();
            if store == prev_store.borrow().to_owned() {
              // no need to update if store not changed
              return Ok(());
            }

            prev_store.replace(store);

            let new_tree = renderer()?;
            let mut changes: Vec<DomChange<T>> = vec![];
            diff_tree(&new_tree, &to_prev_tree.borrow(), &Vec::new(), &Vec::new(), &mut changes)?;

            // let to_prev_tree2 = to_prev_tree.clone();
            // util::log!(
            //   "prev tree: {}",
            //   cirru_parser::format(
            //     &[to_prev_tree2.borrow().to_owned().into()],
            //     cirru_parser::CirruWriterOptions { use_inline: true }
            //   )
            //   .unwrap()
            // );
            // util::log!(
            //   "changes: {}",
            //   cirru_parser::format(&[changes_to_cirru(&changes)], cirru_parser::CirruWriterOptions { use_inline: true }).unwrap()
            // );

            let handler = handle_event.clone();
            patch_tree(&new_tree, &prev_tree.borrow(), &mount_target, &changes, handler)?;
            prev_tree.replace(new_tree);
          }

          Ok(())
        }),
      );
    }
    None => {
      util::raf_loop(Box::new(move || -> Result<(), String> {
        // let to_prev_tree2 = to_prev_tree.clone();
        if drain_rerender_status() {
          let new_tree = renderer()?;
          let mut changes: Vec<DomChange<T>> = vec![];
          diff_tree(&new_tree, &to_prev_tree.borrow(), &Vec::new(), &Vec::new(), &mut changes)?;

          let handler = handle_event.clone();
          patch_tree(&new_tree, &prev_tree.borrow(), &mount_target, &changes, handler)?;
          prev_tree.replace(new_tree);
        }

        Ok(())
      }));
    }
  }

  Ok(())
}

Trait Implementations

impl Clone for RespoEventMarkFn

fn clone(&self) -> RespoEventMarkFn

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RespoEventMarkFn

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Rc<dyn Fn(RespoEventMark) -> Result<(), String> + 'static>> for RespoEventMarkFn

fn from(f: Rc<dyn Fn(RespoEventMark) -> Result<(), String>>) -> Self

Converts to this type from the input type.