Struct respo::RespoEventMark

pub struct RespoEventMark {
    pub coord: Vec<RespoCoord>,
    pub name: String,
    pub event_info: RespoEvent,
}

marks on virtual DOM to declare that there’s an event event handler is HIDDEN from this mark.

Fields

coord: Vec<RespoCoord>

location of element in the tree

name: String

TODO event type

event_info: RespoEvent

partial copy of DOM events, that shares across threads, but being async, methods like .prevent_default() and .stop_propagation() will not work

Implementations

impl RespoEventMark

pub fn new(name: &str, coord: &[RespoCoord], event: RespoEvent) -> Self

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(())
}

Trait Implementations

impl Clone for RespoEventMark

fn clone(&self) -> RespoEventMark

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RespoEventMark

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

Formats the value using the given formatter.