plate-tool/src/components/plates/source_plate.rs

#![allow(non_snake_case)]

use std::collections::HashMap;
use yew::prelude::*;
use yewdux::prelude::*;

use crate::components::states::{CurrentTransfer, MainState};
use crate::data::plate_instances::PlateInstance;
use crate::data::transfer::Transfer;
use crate::data::transfer_region::Region;

// Color Palette for the Source Plates, can be changed here
use crate::components::plates::util::Palettes;
const PALETTE: super::util::ColorPalette = Palettes::RAINBOW;

use super::super::transfer_menu::{num_to_letters, RegionDisplay};

#[derive(PartialEq, Properties)]
pub struct SourcePlateProps {
    pub source_plate: PlateInstance,
    pub destination_plate: PlateInstance,
    pub cell_height: f64,
}

#[function_component]
pub fn SourcePlate(props: &SourcePlateProps) -> Html {
    let (main_state, _) = use_store::<MainState>();
    let (ct_state, ct_dispatch) = use_store::<CurrentTransfer>();
    let m_start_handle: UseStateHandle<Option<(u8, u8)>> = use_state_eq(|| None);
    let m_end_handle: UseStateHandle<Option<(u8, u8)>> = use_state_eq(|| None);
    let m_stat_handle: UseStateHandle<bool> = use_state_eq(|| false);

    if !(*m_stat_handle) {
        let (pt1, pt2) = match ct_state.transfer.transfer_region.source_region {
            Region::Point((x, y)) => ((x, y), (x, y)),
            Region::Rect(c1, c2) => (c1, c2),
        };
        m_start_handle.set(Some(pt1));
        m_end_handle.set(Some(pt2));
    }

    let transfer_map = {
        let ts = main_state
            .transfers
            .iter()
            .filter(|t| t.source_id == props.source_plate.get_uuid());
        let mut tooltip_map: HashMap<(u8, u8), Vec<&Transfer>> = HashMap::new();
        for t in ts {
            let sws = t.transfer_region.get_source_wells();
            for sw in sws {
                if let Some(val) = tooltip_map.get_mut(&sw) {
                    val.push(t);
                } else {
                    tooltip_map.insert(sw, vec![t]);
                }
            }
        }
        tooltip_map
    };

    let source_wells = ct_state.transfer.transfer_region.get_source_wells();

    let mouse_callback = {
        let m_start_handle = m_start_handle.clone();
        let m_end_handle = m_end_handle.clone();
        let m_stat_handle = m_stat_handle.clone();

        Callback::from(move |(i, j, t)| match t {
            MouseEventType::Mousedown => {
                m_start_handle.set(Some((i, j)));
                m_end_handle.set(Some((i, j)));
                m_stat_handle.set(true);
            }
            MouseEventType::Mouseenter => {
                if *m_stat_handle {
                    m_end_handle.set(Some((i, j)));
                }
            }
        })
    };

    let mouseup_callback = {
        let m_start_handle = m_start_handle.clone();
        let m_end_handle = m_end_handle.clone();

        Callback::from(move |_: MouseEvent| {
            m_stat_handle.set(false);
            if let Some(ul) = *m_start_handle {
                if let Some(br) = *m_end_handle {
                    if let Ok(rd) = RegionDisplay::try_from((ul.0, ul.1, br.0, br.1)) {
                        ct_dispatch.reduce_mut(|state| {
                            state.transfer.transfer_region.source_region = Region::from(&rd);
                        });
                    }
                }
            }
        })
    };

    let mouseleave_callback = Callback::clone(&mouseup_callback);

    let column_header = {
        let headers = (1..=props.source_plate.plate.size().1)
            .map(|j| {
                html! {<th>
                {format!("{:0>2}", j)}
                </th>}
            })
            .collect::<Html>();
        html! {<tr><th />{ headers }</tr>}
    };
    let rows = (1..=props.source_plate.plate.size().0)
        .map(|i| {
            let row_header = html! {<th>{num_to_letters(i)}</th>};
            let row = (1..=props.source_plate.plate.size().1)
                .map(|j| {
                    html! {
                        <SourcePlateCell i={i} j={j}
                        selected={in_rect(*m_start_handle.clone(), *m_end_handle.clone(), (i,j))}
                        mouse={mouse_callback.clone()}
                        in_transfer={source_wells.contains(&(i,j))}
                        color={transfer_map.get(&(i,j))
                            .and_then(|t| t.last())
                            .map(|t| PALETTE.get_uuid(t.get_uuid()))
                        }
                        cell_height={props.cell_height}
                        title={transfer_map.get(&(i,j)).map(|transfers| format!("Used by: {}", transfers.iter().map(|t| t.name.clone())
                                    .collect::<Vec<_>>().join(", ")))}
                        />
                    }
                })
                .collect::<Html>();
            html! {
                <tr>
                    { row_header }{ row }
                </tr>
            }
        })
        .collect::<Html>();

    html! {
        <div class={classes!{"source_plate",
        "W".to_owned()+&props.source_plate.plate.plate_format.to_string()}}>
            <table
            onmouseup={move |e| {
                mouseup_callback.emit(e);
            }}
            onmouseleave={move |e| {
                mouseleave_callback.emit(e);
            }}>
                { column_header }
                { rows }
            </table>
        </div>
    }
}

#[derive(PartialEq, Properties)]
pub struct SourcePlateCellProps {
    i: u8,
    j: u8,
    selected: bool,
    mouse: Callback<(u8, u8, MouseEventType)>,
    in_transfer: Option<bool>,
    color: Option<[f64; 3]>,
    cell_height: f64,
    title: Option<String>,
}
#[derive(Debug)]
pub enum MouseEventType {
    Mousedown,
    Mouseenter,
}

#[function_component]
fn SourcePlateCell(props: &SourcePlateCellProps) -> Html {
    let selected_class = match props.selected {
        true => Some("current_select"),
        false => None,
    };
    let in_transfer_class = match props.in_transfer {
        Some(true) => Some("in_transfer"),
        _ => None,
    };
    let color = props.color.unwrap_or([255.0, 255.0, 255.0]);
    let mouse = Callback::clone(&props.mouse);
    let mouse2 = Callback::clone(&props.mouse);
    let (i, j) = (props.i, props.j);

    html! {
        <td class={classes!("plate_cell", selected_class, in_transfer_class)}
            style={format!("height: {}px;", props.cell_height)}
            id={format!("color={:?}", props.color)}
            onmousedown={move |_| {
                mouse.emit((i,j, MouseEventType::Mousedown))
            }}
            onmouseenter={move |_| {
                mouse2.emit((i,j, MouseEventType::Mouseenter))
            }}>
            <div class="plate_cell_inner"
            style={format!("background: rgba({},{},{},1);", color[0], color[1], color[2])}
            title={if let Some(text) = &props.title {
                text.clone()
            } else {"".to_string()}}/>
        </td>
    }
}

pub fn in_rect(corner1: Option<(u8, u8)>, corner2: Option<(u8, u8)>, pt: (u8, u8)) -> bool {
    if let (Some(c1), Some(c2)) = (corner1, corner2) {
        pt.0 <= u8::max(c1.0, c2.0)
            && pt.0 >= u8::min(c1.0, c2.0)
            && pt.1 <= u8::max(c1.1, c2.1)
            && pt.1 >= u8::min(c1.1, c2.1)
    } else {
        false
    }
}

#[cfg(test)]
mod tests {
    use wasm_bindgen_test::*;

    use super::in_rect;

    // in_rect tests
    #[test]
    #[wasm_bindgen_test]
    fn test_in_rect1() {
        // Test in center of rect
        let c1 = (1, 1);
        let c2 = (10, 10);
        let pt = (5, 5);
        assert!(in_rect(Some(c1), Some(c2), pt));
        // Order of the corners should not matter:
        assert!(in_rect(Some(c2), Some(c1), pt));
    }

    #[test]
    #[wasm_bindgen_test]
    fn test_in_rect2() {
        // Test on top/bottom edges of rect
        let c1 = (1, 1);
        let c2 = (10, 10);
        let pt1 = (1, 5);
        let pt2 = (10, 5);
        assert!(in_rect(Some(c1), Some(c2), pt1));
        assert!(in_rect(Some(c1), Some(c2), pt2));
        // Order of the corners should not matter:
        assert!(in_rect(Some(c2), Some(c1), pt1));
        assert!(in_rect(Some(c2), Some(c1), pt2));
    }

    #[test]
    #[wasm_bindgen_test]
    fn test_in_rect3() {
        // Test on left/right edges of rect
        let c1 = (1, 1);
        let c2 = (10, 10);
        let pt1 = (5, 1);
        let pt2 = (5, 10);
        assert!(in_rect(Some(c1), Some(c2), pt1));
        assert!(in_rect(Some(c1), Some(c2), pt2));
        // Order of the corners should not matter:
        assert!(in_rect(Some(c2), Some(c1), pt1));
        assert!(in_rect(Some(c2), Some(c1), pt2));
    }

    #[test]
    #[wasm_bindgen_test]
    fn test_in_rect4() {
        // Test cases that should fail
        let c1 = (1, 1);
        let c2 = (10, 10);
        let pt1 = (0, 0);
        let pt2 = (15, 15);
        assert!(!in_rect(Some(c1), Some(c2), pt1));
        assert!(!in_rect(Some(c1), Some(c2), pt2));
    }
}
Initial 2023-05-11 21:49:03 +00:00			`#![allow(non_snake_case)]`

Highlight wells used in transfers 2023-06-06 01:33:23 +00:00			`use std::collections::HashMap;`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`use yew::prelude::*;`
Glue source_plate to transfer_menu 2023-05-22 17:25:16 +00:00			`use yewdux::prelude::*;`

Highlight wells used in transfers 2023-06-06 01:33:23 +00:00			`use crate::components::states::{CurrentTransfer, MainState};`
Give plate components their instance 2023-05-24 20:10:33 +00:00			`use crate::data::plate_instances::PlateInstance;`
Use UUID to calculate colors Ensures that a transfer will always be represented by the same color. 2023-06-13 23:32:39 +00:00			`use crate::data::transfer::Transfer;`
Format and clean warnings 2023-06-07 21:17:40 +00:00			`use crate::data::transfer_region::Region;`
Give plate components their instance 2023-05-24 20:10:33 +00:00
Highlight wells used in transfers 2023-06-06 01:33:23 +00:00			`// Color Palette for the Source Plates, can be changed here`
			`use crate::components::plates::util::Palettes;`
			`const PALETTE: super::util::ColorPalette = Palettes::RAINBOW;`

format 2023-06-08 15:14:50 +00:00			`use super::super::transfer_menu::{num_to_letters, RegionDisplay};`
Initial 2023-05-11 21:49:03 +00:00
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`#[derive(PartialEq, Properties)]`
Initial 2023-05-11 21:49:03 +00:00			`pub struct SourcePlateProps {`
Visualize transfers 2023-05-24 22:39:38 +00:00			`pub source_plate: PlateInstance,`
			`pub destination_plate: PlateInstance,`
Dynamic sizing of plate cells Calculates available size and allocates 2023-06-13 16:02:32 +00:00			`pub cell_height: f64,`
Initial 2023-05-11 21:49:03 +00:00			`}`

Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`#[function_component]`
			`pub fn SourcePlate(props: &SourcePlateProps) -> Html {`
Highlight wells used in transfers 2023-06-06 01:33:23 +00:00			`let (main_state, _) = use_store::<MainState>();`
Visualize transfers 2023-05-24 22:39:38 +00:00			`let (ct_state, ct_dispatch) = use_store::<CurrentTransfer>();`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`let m_start_handle: UseStateHandle<Option<(u8, u8)>> = use_state_eq(\|\| None);`
			`let m_end_handle: UseStateHandle<Option<(u8, u8)>> = use_state_eq(\|\| None);`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`let m_stat_handle: UseStateHandle<bool> = use_state_eq(\|\| false);`

Visualize transfers 2023-05-24 22:39:38 +00:00			`if !(*m_stat_handle) {`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`let (pt1, pt2) = match ct_state.transfer.transfer_region.source_region {`
			`Region::Point((x, y)) => ((x, y), (x, y)),`
Remove NewTransferState It was bad not very good design! Use CurrentTransfer instead. 2023-05-25 16:07:21 +00:00			`Region::Rect(c1, c2) => (c1, c2),`
			`};`
Visualize transfers 2023-05-24 22:39:38 +00:00			`m_start_handle.set(Some(pt1));`
			`m_end_handle.set(Some(pt2));`
			`}`
Glue source_plate to transfer_menu 2023-05-22 17:25:16 +00:00
Use UUID to calculate colors Ensures that a transfer will always be represented by the same color. 2023-06-13 23:32:39 +00:00			`let transfer_map = {`
Format (I should set up `cargo fmt` as a commit hook) 2023-06-07 20:14:19 +00:00			`let ts = main_state`
			`.transfers`
			`.iter()`
			`.filter(\|t\| t.source_id == props.source_plate.get_uuid());`
chore: clippy & fmt 2023-06-16 02:23:12 +00:00			`let mut tooltip_map: HashMap<(u8, u8), Vec<&Transfer>> = HashMap::new();`
Add tooltip for wells Currently shows which transfers are using a well 2023-06-13 21:04:22 +00:00			`for t in ts {`
			`let sws = t.transfer_region.get_source_wells();`
			`for sw in sws {`
			`if let Some(val) = tooltip_map.get_mut(&sw) {`
Use UUID to calculate colors Ensures that a transfer will always be represented by the same color. 2023-06-13 23:32:39 +00:00			`val.push(t);`
Add tooltip for wells Currently shows which transfers are using a well 2023-06-13 21:04:22 +00:00			`} else {`
Use UUID to calculate colors Ensures that a transfer will always be represented by the same color. 2023-06-13 23:32:39 +00:00			`tooltip_map.insert(sw, vec![t]);`
Add tooltip for wells Currently shows which transfers are using a well 2023-06-13 21:04:22 +00:00			`}`
			`}`
			`}`
			`tooltip_map`
			`};`

Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`let source_wells = ct_state.transfer.transfer_region.get_source_wells();`
Glue source_plate to transfer_menu 2023-05-22 17:25:16 +00:00
			`let mouse_callback = {`
			`let m_start_handle = m_start_handle.clone();`
			`let m_end_handle = m_end_handle.clone();`
			`let m_stat_handle = m_stat_handle.clone();`

Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`Callback::from(move \|(i, j, t)\| match t {`
i love clippy 2023-06-08 15:57:03 +00:00			`MouseEventType::Mousedown => {`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`m_start_handle.set(Some((i, j)));`
			`m_end_handle.set(Some((i, j)));`
			`m_stat_handle.set(true);`
			`}`
i love clippy 2023-06-08 15:57:03 +00:00			`MouseEventType::Mouseenter => {`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`if *m_stat_handle {`
			`m_end_handle.set(Some((i, j)));`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`}`
Wireframing and restructure 2023-05-21 16:45:12 +00:00			`}`
Glue source_plate to transfer_menu 2023-05-22 17:25:16 +00:00			`})`
			`};`

			`let mouseup_callback = {`
			`let m_start_handle = m_start_handle.clone();`
			`let m_end_handle = m_end_handle.clone();`

			`Callback::from(move \|_: MouseEvent\| {`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`m_stat_handle.set(false);`
			`if let Some(ul) = *m_start_handle {`
			`if let Some(br) = *m_end_handle {`
			`if let Ok(rd) = RegionDisplay::try_from((ul.0, ul.1, br.0, br.1)) {`
			`ct_dispatch.reduce_mut(\|state\| {`
			`state.transfer.transfer_region.source_region = Region::from(&rd);`
			`});`
			`}`
Fix unchecked try_from 2023-05-22 17:29:19 +00:00			`}`
Glue source_plate to transfer_menu 2023-05-22 17:25:16 +00:00			`}`
			`})`
			`};`

Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`let mouseleave_callback = Callback::clone(&mouseup_callback);`

Add row and column headers to plates 2023-06-08 15:14:15 +00:00			`let column_header = {`
			`let headers = (1..=props.source_plate.plate.size().1)`
			`.map(\|j\| {`
Fix miniscule column/row headers 2023-06-13 16:51:16 +00:00			`html! {<th>`
chore: clippy & fmt 2023-06-16 02:23:12 +00:00			`{format!("{:0>2}", j)}`
			`</th>}`
Add row and column headers to plates 2023-06-08 15:14:15 +00:00			`})`
			`.collect::<Html>();`
format 2023-06-08 15:14:50 +00:00			`html! {<tr><th />{ headers }</tr>}`
Add row and column headers to plates 2023-06-08 15:14:15 +00:00			`};`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`let rows = (1..=props.source_plate.plate.size().0)`
			`.map(\|i\| {`
Add row and column headers to plates 2023-06-08 15:14:15 +00:00			`let row_header = html! {<th>{num_to_letters(i)}</th>};`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`let row = (1..=props.source_plate.plate.size().1)`
			`.map(\|j\| {`
			`html! {`
			`<SourcePlateCell i={i} j={j}`
i love clippy 2023-06-08 15:57:03 +00:00			`selected={in_rect(m_start_handle.clone(), m_end_handle.clone(), (i,j))}`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`mouse={mouse_callback.clone()}`
			`in_transfer={source_wells.contains(&(i,j))}`
Use UUID to calculate colors Ensures that a transfer will always be represented by the same color. 2023-06-13 23:32:39 +00:00			`color={transfer_map.get(&(i,j))`
			`.and_then(\|t\| t.last())`
			`.map(\|t\| PALETTE.get_uuid(t.get_uuid()))`
			`}`
Dynamic sizing of plate cells Calculates available size and allocates 2023-06-13 16:02:32 +00:00			`cell_height={props.cell_height}`
chore: clippy & fmt 2023-06-16 02:23:12 +00:00			`title={transfer_map.get(&(i,j)).map(\|transfers\| format!("Used by: {}", transfers.iter().map(\|t\| t.name.clone())`
			`.collect::<Vec<_>>().join(", ")))}`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`/>`
			`}`
			`})`
			`.collect::<Html>();`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`html! {`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`<tr>`
Add row and column headers to plates 2023-06-08 15:14:15 +00:00			`{ row_header }{ row }`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`</tr>`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`}`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`})`
			`.collect::<Html>();`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00
			`html! {`
Specific styling for very large plates 2023-06-13 19:51:23 +00:00			`<div class={classes!{"source_plate",`
			`"W".to_owned()+&props.source_plate.plate.plate_format.to_string()}}>`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`<table`
			`onmouseup={move \|e\| {`
			`mouseup_callback.emit(e);`
			`}}`
			`onmouseleave={move \|e\| {`
			`mouseleave_callback.emit(e);`
			`}}>`
Add row and column headers to plates 2023-06-08 15:14:15 +00:00			`{ column_header }`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`{ rows }`
			`</table>`
			`</div>`
			`}`
Initial 2023-05-11 21:49:03 +00:00			`}`

Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`#[derive(PartialEq, Properties)]`
			`pub struct SourcePlateCellProps {`
			`i: u8,`
			`j: u8,`
			`selected: bool,`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`mouse: Callback<(u8, u8, MouseEventType)>,`
Visualize transfers 2023-05-24 22:39:38 +00:00			`in_transfer: Option<bool>,`
Use UUID to calculate colors Ensures that a transfer will always be represented by the same color. 2023-06-13 23:32:39 +00:00			`color: Option<[f64; 3]>,`
Dynamic sizing of plate cells Calculates available size and allocates 2023-06-13 16:02:32 +00:00			`cell_height: f64,`
Add tooltip for wells Currently shows which transfers are using a well 2023-06-13 21:04:22 +00:00			`title: Option<String>,`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`}`
			`#[derive(Debug)]`
			`pub enum MouseEventType {`
i love clippy 2023-06-08 15:57:03 +00:00			`Mousedown,`
			`Mouseenter,`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`}`

			`#[function_component]`
			`fn SourcePlateCell(props: &SourcePlateCellProps) -> Html {`
			`let selected_class = match props.selected {`
			`true => Some("current_select"),`
			`false => None,`
Initial 2023-05-11 21:49:03 +00:00			`};`
Visualize transfers 2023-05-24 22:39:38 +00:00			`let in_transfer_class = match props.in_transfer {`
			`Some(true) => Some("in_transfer"),`
Add, modify, delete transfers 2023-06-01 17:04:03 +00:00			`_ => None,`
Cells can now have color changed from parent component 2023-05-11 22:39:25 +00:00			`};`
chore: clippy & fmt 2023-06-16 02:23:12 +00:00			`let color = props.color.unwrap_or([255.0, 255.0, 255.0]);`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`let mouse = Callback::clone(&props.mouse);`
			`let mouse2 = Callback::clone(&props.mouse);`
i love clippy 2023-06-08 15:57:03 +00:00			`let (i, j) = (props.i, props.j);`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00
			`html! {`
Visualize transfers 2023-05-24 22:39:38 +00:00			`<td class={classes!("plate_cell", selected_class, in_transfer_class)}`
Dynamic sizing of plate cells Calculates available size and allocates 2023-06-13 16:02:32 +00:00			`style={format!("height: {}px;", props.cell_height)}`
Highlight wells used in transfers 2023-06-06 01:33:23 +00:00			`id={format!("color={:?}", props.color)}`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`onmousedown={move \|_\| {`
i love clippy 2023-06-08 15:57:03 +00:00			`mouse.emit((i,j, MouseEventType::Mousedown))`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`}}`
			`onmouseenter={move \|_\| {`
i love clippy 2023-06-08 15:57:03 +00:00			`mouse2.emit((i,j, MouseEventType::Mouseenter))`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`}}>`
Format (I should set up `cargo fmt` as a commit hook) 2023-06-07 20:14:19 +00:00			`<div class="plate_cell_inner"`
Add tooltip for wells Currently shows which transfers are using a well 2023-06-13 21:04:22 +00:00			`style={format!("background: rgba({},{},{},1);", color[0], color[1], color[2])}`
			`title={if let Some(text) = &props.title {`
			`text.clone()`
			`} else {"".to_string()}}/>`
Complete port to yew This is the biggest commit of all time. Yew requires so much cloning smh As a side note, if you drag to select the plate a lot, it uses a lot of CPU resources. 2023-05-22 15:26:08 +00:00			`</td>`
			`}`
Initial 2023-05-11 21:49:03 +00:00			`}`

Allow single well selection in source 2023-05-22 17:46:29 +00:00			`pub fn in_rect(corner1: Option<(u8, u8)>, corner2: Option<(u8, u8)>, pt: (u8, u8)) -> bool {`
Initial 2023-05-11 21:49:03 +00:00			`if let (Some(c1), Some(c2)) = (corner1, corner2) {`
i love clippy 2023-06-08 15:57:03 +00:00			`pt.0 <= u8::max(c1.0, c2.0)`
Format and a comment 2023-05-11 21:51:09 +00:00			`&& pt.0 >= u8::min(c1.0, c2.0)`
			`&& pt.1 <= u8::max(c1.1, c2.1)`
i love clippy 2023-06-08 15:57:03 +00:00			`&& pt.1 >= u8::min(c1.1, c2.1)`
Format and a comment 2023-05-11 21:51:09 +00:00			`} else {`
i love clippy 2023-06-08 15:57:03 +00:00			`false`
Format and a comment 2023-05-11 21:51:09 +00:00			`}`
Initial 2023-05-11 21:49:03 +00:00			`}`

Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`#[cfg(test)]`
			`mod tests {`
Fix tests for wasm32-unknown-unknown 2023-05-26 20:20:52 +00:00			`use wasm_bindgen_test::*;`

Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`use super::in_rect;`

			`// in_rect tests`
			`#[test]`
Fix tests for wasm32-unknown-unknown 2023-05-26 20:20:52 +00:00			`#[wasm_bindgen_test]`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`fn test_in_rect1() {`
			`// Test in center of rect`
chore: format 2023-05-13 23:13:03 +00:00			`let c1 = (1, 1);`
			`let c2 = (10, 10);`
			`let pt = (5, 5);`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`assert!(in_rect(Some(c1), Some(c2), pt));`
			`// Order of the corners should not matter:`
			`assert!(in_rect(Some(c2), Some(c1), pt));`
			`}`

			`#[test]`
Fix tests for wasm32-unknown-unknown 2023-05-26 20:20:52 +00:00			`#[wasm_bindgen_test]`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`fn test_in_rect2() {`
			`// Test on top/bottom edges of rect`
chore: format 2023-05-13 23:13:03 +00:00			`let c1 = (1, 1);`
			`let c2 = (10, 10);`
			`let pt1 = (1, 5);`
			`let pt2 = (10, 5);`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`assert!(in_rect(Some(c1), Some(c2), pt1));`
			`assert!(in_rect(Some(c1), Some(c2), pt2));`
			`// Order of the corners should not matter:`
			`assert!(in_rect(Some(c2), Some(c1), pt1));`
			`assert!(in_rect(Some(c2), Some(c1), pt2));`
			`}`

			`#[test]`
Fix tests for wasm32-unknown-unknown 2023-05-26 20:20:52 +00:00			`#[wasm_bindgen_test]`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`fn test_in_rect3() {`
			`// Test on left/right edges of rect`
chore: format 2023-05-13 23:13:03 +00:00			`let c1 = (1, 1);`
			`let c2 = (10, 10);`
			`let pt1 = (5, 1);`
			`let pt2 = (5, 10);`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`assert!(in_rect(Some(c1), Some(c2), pt1));`
			`assert!(in_rect(Some(c1), Some(c2), pt2));`
			`// Order of the corners should not matter:`
			`assert!(in_rect(Some(c2), Some(c1), pt1));`
			`assert!(in_rect(Some(c2), Some(c1), pt2));`
			`}`

			`#[test]`
Fix tests for wasm32-unknown-unknown 2023-05-26 20:20:52 +00:00			`#[wasm_bindgen_test]`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`fn test_in_rect4() {`
chore: format 2023-05-13 23:13:03 +00:00			`// Test cases that should fail`
			`let c1 = (1, 1);`
			`let c2 = (10, 10);`
			`let pt1 = (0, 0);`
			`let pt2 = (15, 15);`
chore: clippy & fmt 2023-06-16 02:23:12 +00:00			`assert!(!in_rect(Some(c1), Some(c2), pt1));`
			`assert!(!in_rect(Some(c1), Some(c2), pt2));`
Add tests for source_plate component 2023-05-12 00:39:43 +00:00			`}`
			`}`