Struct respo::RespoEffectArg

pub struct RespoEffectArg(_);

(internal) abstraction on effect argument

Implementations

impl RespoEffectArg

pub fn new(v: Value) -> Self

Examples found in repository

src/respo/primes.rs (line 558)

  pub fn new<U, V>(args: Vec<V>, handler: U) -> Self
  where
    U: Fn(Vec<RespoEffectArg>, RespoEffectType, &Node) -> Result<(), String> + 'static,
    V: Serialize,
  {
    Self {
      args: args
        .iter()
        .map(|v| RespoEffectArg::new(serde_json::to_value(v).expect("to json")))
        .collect(),
      handler: Rc::new(handler),
    }
  }

pub fn cast_into<U>(&self) -> Result<U, String>where
    U: DeserializeOwned,

Examples found in repository

src/dialog.rs (line 26)

pub(crate) fn effect_focus(args: Vec<RespoEffectArg>, effect_type: RespoEffectType, el: &Node) -> Result<(), String> {
  let show: bool = args[0].cast_into()?;
  if effect_type == RespoEffectType::Updated && show {
    focus_element(el, BUTTON_NAME)?;
  }

  Ok(())
}

fn focus_element(el: &Node, name: &str) -> Result<(), String> {
  match el.dyn_ref::<Element>().unwrap().query_selector(&format!(".{}", name)) {
    Ok(Some(element)) => {
      match element.dyn_ref::<HtmlElement>() {
        Some(el) => el.focus().unwrap(),
        None => {
          respo::util::log!("focus_element: {} is not an HTML element", name);
        }
      };
    }
    Ok(None) => {
      respo::util::log!("focus_element: {} not found", name);
    }
    Err(e) => {
      respo::util::log!("focus_element: {} not found: {:?}", name, e);
    }
  }
  Ok(())
}

pub(crate) fn effect_modal_fade(args: Vec<RespoEffectArg>, effect_type: RespoEffectType, el: &Node) -> Result<(), String> {
  let show: bool = args[0].cast_into()?;
  match effect_type {
    RespoEffectType::BeforeUpdate => {
      if !show {
        // when closing, fade out the cloned element
        match el.first_child() {
          Some(target) => {
            let d = target.clone_node_with_deep(true).unwrap();
            let cloned = Rc::new(d.dyn_ref::<HtmlElement>().unwrap().to_owned()); // outlive
            let cloned2 = cloned.clone();
            let document = el.owner_document().unwrap();
            document.body().unwrap().append_child(&cloned).unwrap();
            // setTimeout
            let window = web_sys::window().unwrap();
            let immediate_call: Closure<dyn FnMut()> = Closure::once(move || {
              let style = cloned.style();
              style.set_property("opacity", "0").unwrap();
              let card = cloned.first_child().unwrap();
              let card_style = card.dyn_ref::<HtmlElement>().unwrap().style();
              card_style.set_property("transition-duration", "240ms").unwrap();
              card_style.set_property("transform", "scale(0.94) translate(0px,-20px)").unwrap();
            });
            window
              .set_timeout_with_callback_and_timeout_and_arguments_0(immediate_call.as_ref().unchecked_ref(), 10)
              .unwrap();
            immediate_call.forget();
            let delay_call: Closure<dyn FnMut()> = Closure::once(move || {
              cloned2.remove();
            });
            window
              .set_timeout_with_callback_and_timeout_and_arguments_0(delay_call.as_ref().unchecked_ref(), 250)
              .unwrap();
            delay_call.forget();
          }
          None => {
            respo::util::log!("content not found");
          }
        }
      }
    }
    RespoEffectType::Updated => {
      if show {
        // when opening, fade in the cloned element
        let target = el.first_child().unwrap();
        let style = target.dyn_ref::<HtmlElement>().unwrap().style();
        let card_style = target.first_child().unwrap().dyn_ref::<HtmlElement>().unwrap().style();
        style.set_property("opacity", "0").unwrap();
        card_style.set_property("transform", "scale(0.94) translate(0px,-12px)").unwrap();
        let call = Closure::once(move || {
          style.set_property("transition-duration", "240ms").unwrap();
          card_style.set_property("transition-duration", "240ms").unwrap();
          style.set_property("opacity", "1").unwrap();
          card_style.set_property("transform", "scale(1) translate(0px,0px)").unwrap();
        });
        let window = web_sys::window().unwrap();
        window
          .set_timeout_with_callback_and_timeout_and_arguments_0(call.as_ref().unchecked_ref(), 10)
          .unwrap();
        call.forget();
      }
    }
    _ => {}
  }
  Ok(())
}

pub(crate) fn effect_drawer_fade(args: Vec<RespoEffectArg>, effect_type: RespoEffectType, el: &Node) -> Result<(), String> {
  let show: bool = args[0].cast_into()?;

  match effect_type {
    RespoEffectType::BeforeUpdate => {
      if !show {
        // when closing, fade out the cloned element
        match el.first_child() {
          Some(target) => {
            let d = target.clone_node_with_deep(true).unwrap();
            let cloned = Rc::new(d.dyn_ref::<HtmlElement>().unwrap().to_owned()); // outlive
            let cloned2 = cloned.clone();
            let document = el.owner_document().unwrap();
            document.body().unwrap().append_child(&cloned).unwrap();
            // setTimeout
            let window = web_sys::window().unwrap();
            let immediate_call: Closure<dyn FnMut()> = Closure::once(move || {
              let style = cloned.style();
              style.set_property("opacity", "0").unwrap();
              let card = cloned.first_child().unwrap();
              let card_style = card.dyn_ref::<HtmlElement>().unwrap().style();
              card_style.set_property("transition-duration", "240ms").unwrap();
              card_style.set_property("transform", "translate(100%,0px)").unwrap();
            });
            window
              .set_timeout_with_callback_and_timeout_and_arguments_0(immediate_call.as_ref().unchecked_ref(), 10)
              .unwrap();
            immediate_call.forget();
            let delay_call: Closure<dyn FnMut()> = Closure::once(move || {
              cloned2.remove();
            });
            window
              .set_timeout_with_callback_and_timeout_and_arguments_0(delay_call.as_ref().unchecked_ref(), 250)
              .unwrap();
            delay_call.forget();
          }
          None => {
            respo::util::log!("content not found");
          }
        }
      }
    }
    RespoEffectType::Updated => {
      if show {
        // when opening, fade in the cloned element
        let target = el.first_child().unwrap();
        let style = target.dyn_ref::<HtmlElement>().unwrap().style();
        let card_style = target.first_child().unwrap().dyn_ref::<HtmlElement>().unwrap().style();
        style.set_property("opacity", "0").unwrap();
        card_style.set_property("transform", "translate(100%, 0px)").unwrap();
        let call = Closure::once(move || {
          style.set_property("transition-duration", "240ms").unwrap();
          card_style.set_property("transition-duration", "240ms").unwrap();
          style.set_property("opacity", "1").unwrap();
          card_style.set_property("transform", "translate(0px,0px)").unwrap();
        });
        let window = web_sys::window().unwrap();
        window
          .set_timeout_with_callback_and_timeout_and_arguments_0(call.as_ref().unchecked_ref(), 10)
          .unwrap();
        call.forget();
      }
    }
    _ => {}
  }

  Ok(())
}

Trait Implementations

impl Clone for RespoEffectArg

fn clone(&self) -> RespoEffectArg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RespoEffectArg

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RespoEffectArg

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<RespoEffectArg> for RespoEffectArg

fn eq(&self, other: &RespoEffectArg) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RespoEffectArg

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RespoEffectArg

impl StructuralEq for RespoEffectArg

impl StructuralPartialEq for RespoEffectArg