poetrymagnets.online

app.rs (7121B)

---

 use std::sync::Arc;
 
 use egui::{
     Area, Color32, CornerRadius, CursorIcon, FontData, FontDefinitions, FontFamily, Frame, Id,
     Label, Margin, Pos2, Rect, Sense, Shadow, TextWrapMode, Vec2, Visuals,
 };
 use web_sys::js_sys::Math::random;
 
 const APP_KEY: &str = "poetrymagnets.online";
 const FONT_KEY: &str = "Libre Baskerville";
 
 const TOP_LEFT: Pos2 = Pos2::ZERO;
 const BOTTOM_RIGHT: Pos2 = Pos2::new(2048., 2048.);
 const WORLD_BOUNDARY: Rect = Rect::from_min_max(TOP_LEFT, BOTTOM_RIGHT);
 
 #[derive(serde::Deserialize, serde::Serialize)]
 struct Magnet {
     id: Id,
     text: String,
     position: Pos2,
 }
 
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)]
 pub struct PoetryMagnetsOnlineApp {
     zoom_level: f32,
     zoom_level_target: f32,
     pan_offset: Pos2,
     magnets: Vec<Magnet>,
 }
 
 impl Default for PoetryMagnetsOnlineApp {
     fn default() -> Self {
         let mut magnets =
             serde_json::from_str::<Vec<Magnet>>(include_str!("../words.json")).unwrap_or_default();
         for magnet in magnets.iter_mut() {
             magnet.position = Pos2::new(
                 random() as f32 * (BOTTOM_RIGHT.x - 50.),
                 random() as f32 * (BOTTOM_RIGHT.y - 25.),
             );
         }
         Self {
             zoom_level: 2.,
             zoom_level_target: 2.,
             pan_offset: Pos2::ZERO,
             magnets,
         }
     }
 }
 
 impl PoetryMagnetsOnlineApp {
     pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
         let mut fonts = FontDefinitions::default();
         fonts.font_data.insert(
             FONT_KEY.to_owned(),
             Arc::new(FontData::from_static(include_bytes!(
                 "../assets/LibreBaskerville-Regular.ttf"
             ))),
         );
         fonts
             .families
             .get_mut(&FontFamily::Proportional)
             .unwrap()
             .insert(0, FONT_KEY.to_owned());
         cc.egui_ctx.set_fonts(fonts);
         cc.egui_ctx.set_visuals(Visuals::light());
 
         if let Some(storage) = cc.storage {
             eframe::get_value(storage, APP_KEY).unwrap_or_default()
         } else {
             PoetryMagnetsOnlineApp::default()
         }
     }
 }
 
 impl eframe::App for PoetryMagnetsOnlineApp {
     fn save(&mut self, storage: &mut dyn eframe::Storage) {
         eframe::set_value(storage, APP_KEY, self);
     }
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         egui::CentralPanel::default()
             .frame(egui::Frame::NONE.fill(Color32::GRAY))
             .show(ctx, |ui| {
                 let response =
                     ui.allocate_rect(ui.available_rect_before_wrap(), Sense::click_and_drag());
 
                 if response.dragged() {
                     let new_pan_offset = self.pan_offset + response.drag_delta();
                     let new_viewport = ctx.viewport_rect().translate(-new_pan_offset.to_vec2());
                     if new_viewport.left() < WORLD_BOUNDARY.left() {
                         self.pan_offset.x = 0.;
                     } else if WORLD_BOUNDARY.right() < new_viewport.right() {
                         self.pan_offset.x = new_viewport.width() - WORLD_BOUNDARY.right();
                     } else {
                         self.pan_offset.x += response.drag_delta().x;
                     }
                     if new_viewport.top() <= WORLD_BOUNDARY.top() {
                         self.pan_offset.y = 0.;
                     } else if WORLD_BOUNDARY.bottom() <= new_viewport.bottom() {
                         self.pan_offset.y = new_viewport.height() - WORLD_BOUNDARY.bottom();
                     } else {
                         self.pan_offset.y += response.drag_delta().y;
                     }
                     ctx.set_cursor_icon(CursorIcon::Move);
                 }
 
                 let zoom_delta_raw = ui.input(|i| {
                     if let Some(multi_touch) = i.multi_touch() {
                         multi_touch.zoom_delta
                     } else {
                         1. - i.raw_scroll_delta.y * 0.001
                     }
                 });
                 if zoom_delta_raw != 1. {
                     self.zoom_level_target *= zoom_delta_raw;
                     self.zoom_level_target = self.zoom_level_target.clamp(1., 5.);
                     let zoom_delta_smooth = (self.zoom_level_target - self.zoom_level) * 0.25;
                     self.zoom_level += zoom_delta_smooth;
                     self.zoom_level = self.zoom_level.clamp(1., 5.);
                 }
                 ctx.set_zoom_factor(self.zoom_level);
             });
         for magnet in self.magnets.iter_mut() {
             let magnet_position_with_offset = self.pan_offset + magnet.position.to_vec2();
             let magnet_rect_with_buffer =
                 Rect::from_min_size(magnet_position_with_offset, Vec2::new(50., 50.));
             if !ctx.content_rect().intersects(magnet_rect_with_buffer) {
                 continue;
             }
             let response = Area::new(magnet.id)
                 .current_pos(magnet_position_with_offset)
                 .constrain(false)
                 .show(ctx, |ui| {
                     Frame::NONE
                         .inner_margin(Margin::symmetric(5, 3))
                         .shadow(Shadow {
                             offset: [1, 1],
                             blur: 0,
                             spread: 0,
                             color: Color32::GRAY,
                         })
                         .fill(Color32::WHITE)
                         .corner_radius(CornerRadius::same(1))
                         .show(ui, |ui| {
                             ui.add(
                                 Label::new(magnet.text.clone())
                                     .selectable(false)
                                     .wrap_mode(TextWrapMode::Extend),
                             );
                         });
                 })
                 .response;
             if response.dragged() {
                 let new_magnet_position = magnet.position + response.drag_delta();
                 let magnet_rect = response.rect.translate(-self.pan_offset.to_vec2());
                 if magnet_rect.left() <= WORLD_BOUNDARY.left() {
                     magnet.position.x = WORLD_BOUNDARY.left();
                 } else if WORLD_BOUNDARY.right() <= magnet_rect.right() {
                     magnet.position.x = WORLD_BOUNDARY.width() - magnet_rect.width();
                 } else {
                     magnet.position.x = new_magnet_position.x;
                 }
                 if magnet_rect.top() <= WORLD_BOUNDARY.top() {
                     magnet.position.y = WORLD_BOUNDARY.top();
                 } else if WORLD_BOUNDARY.bottom() <= magnet_rect.bottom() {
                     magnet.position.y = WORLD_BOUNDARY.height() - magnet_rect.height();
                 } else {
                     magnet.position.y = new_magnet_position.y;
                 }
                 ctx.set_cursor_icon(CursorIcon::Grabbing);
             } else if response.hovered() {
                 ctx.set_cursor_icon(CursorIcon::Grab);
             }
         }
     }
 }