use std::cell::Cell;
use std::cell::RefCell;
use std::rc::Rc;
use crate::core::config::StateFlags;
use crate::core::dirty_registry;
use crate::core::element::DirtyFlags;
use crate::core::ElementId;
use crate::style::{Color, Point, Vec2};
pub fn take_drag_z_request() -> Option<(ElementId, bool)> {
crate::core::app_context::current_app().take_drag_z_request()
}
fn request_drag_z(eid: ElementId, elevate: bool) {
crate::core::app_context::current_app().request_drag_z(eid, elevate);
}
pub const GHOST_DIM: Color = Color::rgba8(0, 0, 0, 35);
pub const DROP_HIGHLIGHT: Color = Color::rgba8(59, 130, 246, 50);
pub struct ReorderController {
item_ids: Rc<RefCell<Vec<ElementId>>>,
offsets: Rc<RefCell<Vec<Rc<Cell<Vec2>>>>>,
on_reorder: Rc<RefCell<Option<Box<dyn Fn(usize, usize)>>>>,
item_size: Cell<f32>,
horizontal: Cell<bool>,
source: Cell<Option<usize>>,
target: Cell<Option<usize>>,
press_anchor: Cell<f32>,
saved_src_bg: Cell<Option<Color>>,
}
impl ReorderController {
pub fn new() -> Self {
Self {
item_ids: Rc::new(RefCell::new(Vec::new())),
offsets: Rc::new(RefCell::new(Vec::new())),
on_reorder: Rc::new(RefCell::new(None)),
item_size: Cell::new(36.0),
horizontal: Cell::new(false),
source: Cell::new(None),
target: Cell::new(None),
press_anchor: Cell::new(0.0),
saved_src_bg: Cell::new(None),
}
}
pub fn configure(&self, ids: Vec<ElementId>, offsets: Vec<Rc<Cell<Vec2>>>) {
*self.item_ids.borrow_mut() = ids;
*self.offsets.borrow_mut() = offsets;
}
pub fn set_item_height(&self, h: f32) {
self.item_size.set(h);
}
pub fn set_horizontal(&self, w: f32) {
self.horizontal.set(true);
self.item_size.set(w);
}
pub fn on_reorder(&self, f: impl Fn(usize, usize) + 'static) {
self.on_reorder.borrow_mut().replace(Box::new(f));
}
pub fn begin(&self, pressed_id: ElementId, abs: Point) -> Option<usize> {
let ids = self.item_ids.borrow();
let src = ids.iter().position(|&id| id == pressed_id)?;
self.saved_src_bg.set(crate::core::element::with_ct(|ct| {
ct.style.get(&pressed_id).and_then(|s| s.background)
}));
crate::core::element::with_ct_mut(|ct| {
if let Some(s) = ct.style.get_mut(&pressed_id) {
s.background = Some(GHOST_DIM);
}
});
self.source.set(Some(src));
self.target.set(Some(src));
let anchor = if self.horizontal.get() { abs.x } else { abs.y };
self.press_anchor.set(anchor);
self.set_ghost(0.0);
request_drag_z(pressed_id, true);
Some(src)
}
pub fn update(&self, abs: Point) -> Option<usize> {
let src = self.source.get()?;
let horiz = self.horizontal.get();
let cursor = if horiz { abs.x } else { abs.y };
let delta = cursor - self.press_anchor.get();
self.set_ghost(delta);
let sz = self.item_size.get();
let raw = src as f32 + delta / sz;
let tgt_idx = (if raw < 0.0 { raw - 0.5 } else { raw + 0.5 }) as isize;
let len = self.item_ids.borrow().len() as isize;
let new_tgt = tgt_idx.max(0).min(len.saturating_sub(1)) as usize;
let old_tgt = self.target.get();
if old_tgt != Some(new_tgt) {
if let Some(old) = old_tgt {
if let Some(&eid) = self.item_ids.borrow().get(old) {
dirty_registry::set_state(eid, StateFlags::DRAG_OVER, false);
}
}
if let Some(&eid) = self.item_ids.borrow().get(new_tgt) {
dirty_registry::set_state(eid, StateFlags::DRAG_OVER, true);
}
}
self.target.set(Some(new_tgt));
Some(new_tgt)
}
pub fn end(&self) -> Option<(usize, usize)> {
let src = self.source.get()?;
let dst = self.target.get()?;
self.source.set(None);
self.target.set(None);
if let Some(&eid) = self.item_ids.borrow().get(dst) {
dirty_registry::set_state(eid, StateFlags::DRAG_OVER, false);
}
self.reset_ghost(src);
if src == dst {
return None;
}
if let Some(ref cb) = *self.on_reorder.borrow() {
cb(src, dst);
}
let ids = self.item_ids.borrow();
if let Some(&eid) = ids.get(src) {
request_drag_z(eid, false);
}
Some((src, dst))
}
pub fn source(&self) -> Option<usize> {
self.source.get()
}
pub fn target(&self) -> Option<usize> {
self.target.get()
}
pub fn cancel(&self) {
if let Some(src) = self.source.get() {
if let Some(dst) = self.target.get() {
if let Some(&eid) = self.item_ids.borrow().get(dst) {
dirty_registry::set_state(eid, StateFlags::DRAG_OVER, false);
}
}
self.reset_ghost(src);
let ids = self.item_ids.borrow();
if let Some(&eid) = ids.get(src) {
request_drag_z(eid, false);
}
}
self.source.set(None);
self.target.set(None);
}
fn set_ghost(&self, offset: f32) {
let src = match self.source.get() {
Some(s) => s,
None => return,
};
let ids = self.item_ids.borrow();
let eid = match ids.get(src) {
Some(&id) => id,
None => return,
};
let offs = self.offsets.borrow();
if let Some(off_cell) = offs.get(src) {
let v = if self.horizontal.get() {
Vec2::new(offset, 0.0)
} else {
Vec2::new(0.0, offset)
};
off_cell.set(v);
}
dirty_registry::mark_dirty(eid, DirtyFlags::REPAINT);
dirty_registry::register_dirty(eid, DirtyFlags::REPAINT);
dirty_registry::bump_surface_gen_remote(eid);
}
fn reset_ghost(&self, src: usize) {
let ids = self.item_ids.borrow();
let eid = match ids.get(src) {
Some(&id) => id,
None => return,
};
let offs = self.offsets.borrow();
if let Some(off_cell) = offs.get(src) {
off_cell.set(Vec2::ZERO);
}
crate::core::element::with_ct_mut(|ct| {
if let Some(s) = ct.style.get_mut(&eid) {
s.background = self.saved_src_bg.get();
}
});
dirty_registry::mark_dirty(eid, DirtyFlags::REPAINT);
dirty_registry::register_dirty(eid, DirtyFlags::REPAINT);
}
}
impl Default for ReorderController {
fn default() -> Self {
Self::new()
}
}
impl std::fmt::Debug for ReorderController {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ReorderController")
.field("items", &self.item_ids.borrow().len())
.field("source", &self.source.get())
.field("target", &self.target.get())
.finish()
}
}