zng-ext-input 0.15.2

#![cfg(feature = "drag_drop")]

//! Drag & drop gesture events and service.
//!
//! # Events
//!
//! Events this extension provides.
//!
//! * [`DROP_EVENT`]
//! * [`DRAG_HOVERED_EVENT`]
//! * [`DRAG_MOVE_EVENT`]
//! * [`DRAG_START_EVENT`]
//! * [`DRAG_END_EVENT`]
//! * [`DROP_EVENT`]
//!
//! # Services
//!
//! Services this extension provides.
//!
//! * [`DRAG_DROP`]

use std::mem;

use parking_lot::Mutex;
use zng_app::{
    event::{event, event_args},
    hn, static_id,
    view_process::raw_events::{
        RAW_APP_DRAG_ENDED_EVENT, RAW_DRAG_CANCELLED_EVENT, RAW_DRAG_DROPPED_EVENT, RAW_DRAG_HOVERED_EVENT, RAW_DRAG_MOVED_EVENT,
    },
    widget::{
        WidgetId,
        info::{HitTestInfo, InteractionPath, WidgetInfo, WidgetInfoBuilder},
    },
    window::WindowId,
};
use zng_app_context::app_local;
use zng_ext_window::{NestedWindowWidgetInfoExt as _, WINDOWS, WINDOWS_DRAG_DROP};
use zng_handle::{Handle, HandleOwner, WeakHandle};
use zng_layout::unit::{DipPoint, DipToPx as _, PxToDip as _};
use zng_state_map::StateId;
use zng_task::channel::IpcBytes;
use zng_txt::{Txt, formatx};
use zng_var::{ArcEq, Var, var};
use zng_view_api::{DragDropId, mouse::ButtonState, touch::TouchPhase};

use crate::{mouse::MOUSE_INPUT_EVENT, touch::TOUCH_INPUT_EVENT};

pub use zng_view_api::drag_drop::{DragDropData, DragDropEffect};

/// Drag & drop service.
#[allow(non_camel_case_types)]
pub struct DRAG_DROP;
impl DRAG_DROP {
    /// All data current dragging.
    pub fn dragging_data(&self) -> Var<Vec<DragDropData>> {
        DRAG_DROP_SV.read().data.read_only()
    }

    /// Start dragging `data`.
    ///
    /// This method will only work if a [`DRAG_START_EVENT`] is notifying. Handlers of draggable widgets
    /// can provide custom drag data using this method.
    ///
    /// Returns a handle that can be dropped to cancel the drag operation. A [`DRAG_END_EVENT`] notifies
    /// the draggable widget on cancel or drop. Logs an error message and returns a dummy handle on error.
    ///
    /// Note that the `allowed_effects` apply to all data, if a previous handler already set data with an incompatible
    /// effect the call is an error and the data ignored.
    pub fn drag(&self, data: DragDropData, allowed_effects: DragDropEffect) -> DragHandle {
        let mut sv = DRAG_DROP_SV.write();
        if let Some(d) = &mut sv.app_drag {
            if allowed_effects.is_empty() {
                tracing::error!("cannot drag, no `allowed_effects`");
                return DragHandle::dummy();
            }

            if d.allowed.is_empty() {
                d.allowed = allowed_effects;
            } else {
                if !d.allowed.contains(allowed_effects) {
                    tracing::error!("cannot drag, other data already set with incompatible `allowed_effects`");
                    return DragHandle::dummy();
                }
                d.allowed |= allowed_effects
            }

            d.data.push(data);
            let (owner, handle) = DragHandle::new();
            d.handles.push(owner);
            return handle;
        }
        tracing::error!("cannot drag, not in `DRAG_START_EVENT` interval");
        DragHandle::dummy()
    }
}

app_local! {
    static DRAG_DROP_SV: DragDropService = {
        hooks();
        DragDropService {
            data: var(vec![]),
            system_dragging: vec![],
            app_drag: None,
            app_dragging: vec![],

            pos: Default::default(),
            pos_window: None,
            hits: None,
            hovered: Default::default(),
        }
    };
}
struct DragDropService {
    data: Var<Vec<DragDropData>>,

    system_dragging: Vec<DragDropData>,

    app_drag: Option<AppDragging>,
    app_dragging: Vec<AppDragging>,

    // last cursor move position.
    pos: DipPoint,
    // last cursor move over window.
    pos_window: Option<WindowId>,
    // last cursor move hit-test (on the pos_window or a nested window).
    hits: Option<HitTestInfo>,
    hovered: Option<InteractionPath>,
}
struct AppDragging {
    target: InteractionPath,
    data: Vec<DragDropData>,
    handles: Vec<HandleOwner<()>>,
    allowed: DragDropEffect,
    view_id: DragDropId,
}

fn hooks() {
    RAW_DRAG_DROPPED_EVENT
        .hook(|args| {
            // system drop
            let mut s = DRAG_DROP_SV.write();
            let s = &mut *s;
            let len = s.system_dragging.len();
            for data in &args.data {
                s.system_dragging.retain(|d| d != data);
            }
            if s.system_dragging.len() != len {
                s.data.set(s.system_dragging.clone());
            }

            if s.pos_window == Some(args.window_id)
                && let Some(hovered) = &s.hovered
            {
                let hits = s.hits.take().unwrap_or_else(|| HitTestInfo::no_hits(args.window_id));
                DRAG_HOVERED_EVENT.notify(DragHoveredArgs::now(Some(hovered.clone()), None, s.pos, hits.clone()));
                DROP_EVENT.notify(DropArgs::now(
                    hovered.clone(),
                    args.data.clone(),
                    args.allowed,
                    s.pos,
                    hits,
                    args.drop_id,
                    ArcEq::new(Mutex::new(DragDropEffect::empty())),
                ));
            }

            true
        })
        .perm();

    RAW_DRAG_HOVERED_EVENT
        .hook(|args| {
            let mut s = DRAG_DROP_SV.write();
            s.system_dragging.extend(args.data.iter().cloned());
            s.data.set(s.system_dragging.clone());
            true
        })
        .perm();

    RAW_DRAG_MOVED_EVENT
        .hook(|args| {
            let mut s = DRAG_DROP_SV.write();
            let moved = s.pos != args.position || s.pos_window != Some(args.window_id);
            if moved {
                s.pos = args.position;
                s.pos_window = Some(args.window_id);

                let mut position = args.position;

                // mouse_move data
                let mut frame_info = match WINDOWS.widget_tree(args.window_id) {
                    Some(f) => f,
                    None => {
                        // window not found
                        if let Some(hovered) = s.hovered.take() {
                            DRAG_HOVERED_EVENT.notify(DragHoveredArgs::now(
                                Some(hovered),
                                None,
                                position,
                                HitTestInfo::no_hits(args.window_id),
                            ));
                            s.pos_window = None;
                        }
                        return true;
                    }
                };

                let mut pos_hits = frame_info.root().hit_test(position.to_px(frame_info.scale_factor()));

                let target = if let Some(t) = pos_hits.target() {
                    if let Some(w) = frame_info.get(t.widget_id) {
                        if let Some(f) = w.nested_window_tree() {
                            // nested window hit
                            frame_info = f;
                            let factor = frame_info.scale_factor();
                            let pos = position.to_px(factor);
                            let pos = w.inner_transform().inverse().and_then(|t| t.transform_point(pos)).unwrap_or(pos);
                            pos_hits = frame_info.root().hit_test(pos);
                            position = pos.to_dip(factor);
                            pos_hits
                                .target()
                                .and_then(|h| frame_info.get(h.widget_id))
                                .map(|w| w.interaction_path())
                                .unwrap_or_else(|| frame_info.root().interaction_path())
                        } else {
                            w.interaction_path()
                        }
                    } else {
                        tracing::error!("hits target `{}` not found", t.widget_id);
                        frame_info.root().interaction_path()
                    }
                } else {
                    frame_info.root().interaction_path()
                }
                .unblocked();

                s.hits = Some(pos_hits.clone());

                // drag_enter/leave.
                let hovered_args = if s.hovered != target {
                    let prev_target = mem::replace(&mut s.hovered, target.clone());
                    let args = DragHoveredArgs::now(prev_target, target.clone(), position, pos_hits.clone());
                    Some(args)
                } else {
                    None
                };

                // mouse_move
                if let Some(target) = target {
                    let args = DragMoveArgs::now(frame_info.window_id(), args.coalesced_pos.clone(), position, pos_hits, target);
                    DRAG_MOVE_EVENT.notify(args);
                }

                if let Some(args) = hovered_args {
                    DRAG_HOVERED_EVENT.notify(args);
                }
            }
            true
        })
        .perm();

    // system drag cancelled of dragged out of all app windows
    RAW_DRAG_CANCELLED_EVENT
        .hook(|args| {
            let mut s = DRAG_DROP_SV.write();
            let changed = !s.system_dragging.is_empty();
            s.system_dragging.clear();
            if changed {
                s.data.set(s.system_dragging.clone());
            }

            if let Some(prev) = s.hovered.take() {
                s.pos_window = None;
                DRAG_HOVERED_EVENT.notify(DragHoveredArgs::now(
                    Some(prev),
                    None,
                    s.pos,
                    s.hits.take().unwrap_or_else(|| HitTestInfo::no_hits(args.window_id)),
                ));
            }

            true
        })
        .perm();

    RAW_APP_DRAG_ENDED_EVENT
        .hook(|args| {
            let mut s = DRAG_DROP_SV.write();
            s.app_dragging.retain(|d| {
                if d.view_id != args.id {
                    return true;
                }

                if !args.applied.is_empty() && !d.allowed.contains(args.applied) {
                    tracing::error!(
                        "drop target applied disallowed effect, allowed={:?}, applied={:?}",
                        d.allowed,
                        args.applied
                    );
                }

                DRAG_END_EVENT.notify(DragEndArgs::now(d.target.clone(), args.applied));

                false
            });
            true
        })
        .perm();

    MOUSE_INPUT_EVENT
        .on_event(
            false,
            hn!(|args| {
                if matches!(args.state, ButtonState::Pressed)
                    && let Some(wgt) = WINDOWS.widget_info(args.target.widget_id())
                    && let Some(wgt) = wgt.self_and_ancestors().find(|w| w.is_draggable())
                {
                    // unhandled mouse press on draggable
                    args.propagation.stop();
                    let target = wgt.interaction_path();
                    let args = DragStartArgs::now(target.clone());
                    DRAG_START_EVENT.notify(args);
                    DRAG_DROP_SV.write().app_drag = Some(AppDragging {
                        target,
                        data: vec![],
                        handles: vec![],
                        allowed: DragDropEffect::empty(),
                        view_id: DragDropId(0),
                    }); // calls to DRAG_DROP.drag are now valid
                }
            }),
        )
        .perm();

    TOUCH_INPUT_EVENT
        .on_event(
            false,
            hn!(|args| {
                if matches!(args.phase, TouchPhase::Start)
                    && let Some(wgt) = WINDOWS.widget_info(args.target.widget_id())
                    && let Some(wgt) = wgt.self_and_ancestors().find(|w| w.is_draggable())
                {
                    // unhandled touch start on draggable
                    args.propagation.stop();
                    let target = wgt.interaction_path();
                    let args = DragStartArgs::now(target.clone());
                    DRAG_START_EVENT.notify(args);
                    DRAG_DROP_SV.write().app_drag = Some(AppDragging {
                        target,
                        data: vec![],
                        handles: vec![],
                        allowed: DragDropEffect::empty(),
                        view_id: DragDropId(0),
                    }); // calls to DRAG_DROP.drag are now valid
                }
            }),
        )
        .perm();

    DRAG_START_EVENT
        .hook(|args| {
            // finished notifying draggable drag start
            let mut s = DRAG_DROP_SV.write();
            let mut data = s.app_drag.take();
            let mut cancel = args.propagation.is_stopped();
            if !cancel {
                if let Some(d) = &mut data {
                    if d.data.is_empty() {
                        d.data.push(encode_widget_id(args.target.widget_id()));
                        d.allowed = DragDropEffect::all();
                    }
                    match WINDOWS_DRAG_DROP.start_drag_drop(d.target.window_id(), mem::take(&mut d.data), d.allowed) {
                        Ok(id) => {
                            d.view_id = id;
                            s.app_dragging.push(data.take().unwrap());
                        }
                        Err(e) => {
                            tracing::error!("cannot start drag&drop, {e}");
                            cancel = true;
                        }
                    }
                } else {
                    tracing::warn!("external notification of DRAG_START_EVENT ignored")
                }
            }
            if cancel && let Some(d) = data {
                DRAG_END_EVENT.notify(DragEndArgs::now(d.target, DragDropEffect::empty()));
            }

            true
        })
        .perm();

    DROP_EVENT
        .hook(|args| {
            WINDOWS_DRAG_DROP.drag_dropped(args.target.window_id(), args.drop_id, *args.applied.lock());
            true
        })
        .perm();
}

/// Represents dragging data.
///
/// Drop all clones of this handle to cancel the drag operation.
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
#[repr(transparent)]
#[must_use = "dropping the handle cancels the drag operation"]
pub struct DragHandle(Handle<()>);
impl DragHandle {
    fn new() -> (HandleOwner<()>, Self) {
        let (owner, handle) = Handle::new(());
        (owner, Self(handle))
    }

    /// New handle to nothing.
    pub fn dummy() -> Self {
        Self(Handle::dummy(()))
    }

    /// Drops the handle but does **not** cancel the drag operation.
    ///
    /// The drag data stays alive until the user completes or cancels the operation.
    pub fn perm(self) {
        self.0.perm();
    }

    /// If another handle has called [`perm`](Self::perm).
    ///
    /// If `true` operation will run to completion.
    pub fn is_permanent(&self) -> bool {
        self.0.is_permanent()
    }

    /// Drops the handle and forces operation the cancel.
    pub fn cancel(self) {
        self.0.force_drop()
    }

    /// If another handle has called [`cancel`](Self::cancel).
    pub fn is_canceled(&self) -> bool {
        self.0.is_dropped()
    }

    /// Create a weak handle.
    pub fn downgrade(&self) -> WeakDragHandle {
        WeakDragHandle(self.0.downgrade())
    }
}
/// Weak [`DragHandle`].
#[derive(Clone, PartialEq, Eq, Hash, Default, Debug)]
pub struct WeakDragHandle(WeakHandle<()>);
impl WeakDragHandle {
    /// New weak handle that does not upgrade.
    pub fn new() -> Self {
        Self(WeakHandle::new())
    }

    /// Gets the strong handle if it is still subscribed.
    pub fn upgrade(&self) -> Option<DragHandle> {
        self.0.upgrade().map(DragHandle)
    }
}

/// [`WidgetInfo`] extensions for drag & drop service.
pub trait WidgetInfoDragDropExt {
    /// If this widget can be dragged and dropped.
    fn is_draggable(&self) -> bool;
}
impl WidgetInfoDragDropExt for WidgetInfo {
    fn is_draggable(&self) -> bool {
        self.meta().flagged(*IS_DRAGGABLE_ID)
    }
}

/// [`WidgetInfoBuilder`] extensions for drag & drop service.
pub trait WidgetInfoBuilderDragDropExt {
    /// Flag the widget as draggable.
    fn draggable(&mut self);
}
impl WidgetInfoBuilderDragDropExt for WidgetInfoBuilder {
    fn draggable(&mut self) {
        self.flag_meta(*IS_DRAGGABLE_ID);
    }
}

static_id! {
    static ref IS_DRAGGABLE_ID: StateId<()>;
}

event_args! {
    /// Arguments for [`DROP_EVENT`].
    pub struct DropArgs {
        /// Hovered target of the drag&drop gesture.
        pub target: InteractionPath,
        /// Drag&drop data payload.
        pub data: Vec<DragDropData>,
        /// Drop effects that the drag source allows.
        pub allowed: DragDropEffect,
        /// Position of the cursor in the window's content area.
        pub position: DipPoint,
        /// Hit-test result for the cursor point in the window.
        pub hits: HitTestInfo,

        drop_id: DragDropId,
        applied: ArcEq<Mutex<DragDropEffect>>,

        ..

        /// If is in [`target`].
        ///
        /// [`target`]: DropArgs::target
        fn is_in_target(&self, id: WidgetId) -> bool {
            self.target.contains(id)
        }
    }

    /// Arguments for [`DRAG_HOVERED_EVENT`].
    pub struct DragHoveredArgs {
        /// Previous hovered target.
        pub prev_target: Option<InteractionPath>,
        /// New hovered target.
        pub target: Option<InteractionPath>,
        /// Position of the cursor in the window's content area.
        pub position: DipPoint,
        /// Hit-test result for the cursor point in the window.
        pub hits: HitTestInfo,

        ..

        /// If is in [`prev_target`] or [`target`].
        ///
        /// [`prev_target`]: DropArgs::prev_target
        /// [`target`]: DropArgs::target
        fn is_in_target(&self, id: WidgetId) -> bool {
            if let Some(p) = &self.prev_target
                && p.contains(id)
            {
                return true;
            }
            if let Some(p) = &self.target
                && p.contains(id)
            {
                return true;
            }
            false
        }
    }

    /// [`DRAG_MOVE_EVENT`] arguments.
    pub struct DragMoveArgs {
        /// Id of window that received the event.
        pub window_id: WindowId,

        /// Positions of the cursor in between the previous event and this one.
        ///
        /// Drag move events can be coalesced, i.e. multiple moves packed into a single event.
        pub coalesced_pos: Vec<DipPoint>,

        /// Position of the cursor in the window's content area.
        pub position: DipPoint,

        /// Hit-test result for the cursor point in the window.
        pub hits: HitTestInfo,

        /// Full path to the top-most hit in [`hits`](DragMoveArgs::hits).
        pub target: InteractionPath,

        ..

        /// If is in [`target`].
        ///
        /// [`target`]: Self::target
        fn is_in_target(&self, id: WidgetId) -> bool {
            self.target.contains(id)
        }
    }

    /// Arguments for [`DRAG_START_EVENT`].
    pub struct DragStartArgs {
        /// Draggable widget that has started dragging.
        pub target: InteractionPath,

        ..

        /// If is in [`target`].
        ///
        /// [`target`]: Self::target
        fn is_in_target(&self, id: WidgetId) -> bool {
            self.target.contains(id)
        }
    }

    /// Arguments for [`DRAG_END_EVENT`].
    pub struct DragEndArgs {
        /// Draggable widget that was dragging.
        pub target: InteractionPath,

        /// Effect applied by the drop target on the data.
        ///
        /// Is empty or a single flag.
        pub applied: DragDropEffect,

        ..

        /// If is in [`target`].
        ///
        /// [`target`]: Self::target
        fn is_in_target(&self, id: WidgetId) -> bool {
            self.target.contains(id)
        }

        /// The `applied` field can only be empty or only have a single flag set.
        fn validate(&self) -> Result<(), Txt> {
            if self.applied.is_empty() && self.applied.len() > 1 {
                return Err("only one or none `DragDropEffect` can be applied".into());
            }
            Ok(())
        }
    }
}
event! {
    /// Drag&drop action finished over some drop target widget.
    pub static DROP_EVENT: DropArgs {
        let _ = DRAG_DROP_SV.read();
    };
    /// Drag&drop enter or exit a drop target widget.
    pub static DRAG_HOVERED_EVENT: DragHoveredArgs {
        let _ = DRAG_DROP_SV.read();
    };
    /// Drag&drop is dragging over the target widget.
    pub static DRAG_MOVE_EVENT: DragMoveArgs {
        let _ = DRAG_DROP_SV.read();
    };
    /// Drag&drop started dragging a draggable widget.
    ///
    /// If propagation is stopped the drag operation is cancelled. Handlers can use
    /// [`DRAG_DROP.drag`] to set the data, otherwise the widget ID will be dragged.
    ///
    /// [`DRAG_DROP.drag`]: DRAG_DROP::drag
    pub static DRAG_START_EVENT: DragStartArgs {
        let _ = DRAG_DROP_SV.read();
    };

    /// Drag&drop gesture started from the draggable widget has ended.
    pub static DRAG_END_EVENT: DragEndArgs {
        let _ = DRAG_DROP_SV.read();
    };
}

impl DropArgs {
    /// Stop propagation and set the `effect` that was applied to the data.
    ///
    /// Logs an error if propagation is already stopped.
    ///
    /// # Panics
    ///
    /// Panics if `effect` sets more then one flag or is not [`allowed`].
    ///
    /// [`allowed`]: Self::allowed
    pub fn applied(&self, effect: DragDropEffect) {
        assert!(effect.len() > 1, "can only apply one effect");
        assert!(self.allowed.contains(effect), "source does not allow this effect");

        let mut e = self.applied.lock();
        if !self.propagation.is_stopped() {
            self.propagation.stop();
            *e = effect;
        } else {
            tracing::error!("drop already handled");
        }
    }
}

impl DragHoveredArgs {
    /// Gets the [`DRAG_DROP.dragging_data`].
    ///
    /// [`DRAG_DROP.dragging_data`]: DRAG_DROP::dragging_data
    pub fn data(&self) -> Var<Vec<DragDropData>> {
        DRAG_DROP.dragging_data()
    }

    /// Returns `true` if the `wgt` was not hovered, but now is.
    pub fn is_drag_enter(&self, wgt: WidgetId) -> bool {
        !self.was_over(wgt) && self.is_over(wgt)
    }

    /// Returns `true` if the `wgt` was hovered, but now isn't.
    pub fn is_drag_leave(&self, wgt: WidgetId) -> bool {
        self.was_over(wgt) && !self.is_over(wgt)
    }

    /// Returns `true` if the `wgt` is in [`prev_target`].
    ///
    /// [`prev_target`]: Self::prev_target
    pub fn was_over(&self, wgt: WidgetId) -> bool {
        if let Some(t) = &self.prev_target {
            return t.contains(wgt);
        }
        false
    }

    /// Returns `true` if the `wgt` is in [`target`].
    ///
    /// [`target`]: Self::target
    pub fn is_over(&self, wgt: WidgetId) -> bool {
        if let Some(t) = &self.target {
            return t.contains(wgt);
        }
        false
    }

    /// Returns `true` if the widget was enabled in [`prev_target`].
    ///
    /// [`prev_target`]: Self::prev_target
    pub fn was_enabled(&self, widget_id: WidgetId) -> bool {
        match &self.prev_target {
            Some(t) => t.contains_enabled(widget_id),
            None => false,
        }
    }

    /// Returns `true` if the widget was disabled in [`prev_target`].
    ///
    /// [`prev_target`]: Self::prev_target
    pub fn was_disabled(&self, widget_id: WidgetId) -> bool {
        match &self.prev_target {
            Some(t) => t.contains_disabled(widget_id),
            None => false,
        }
    }

    /// Returns `true` if the widget is enabled in [`target`].
    ///
    /// [`target`]: Self::target
    pub fn is_enabled(&self, widget_id: WidgetId) -> bool {
        match &self.target {
            Some(t) => t.contains_enabled(widget_id),
            None => false,
        }
    }

    /// Returns `true` if the widget is disabled in [`target`].
    ///
    /// [`target`]: Self::target
    pub fn is_disabled(&self, widget_id: WidgetId) -> bool {
        match &self.target {
            Some(t) => t.contains_disabled(widget_id),
            None => false,
        }
    }

    /// Returns `true` if the `wgt` was not hovered or was disabled, but now is hovered and enabled.
    pub fn is_drag_enter_enabled(&self, wgt: WidgetId) -> bool {
        (!self.was_over(wgt) || self.was_disabled(wgt)) && self.is_over(wgt) && self.is_enabled(wgt)
    }

    /// Returns `true` if the `wgt` was hovered and enabled, but now is not hovered or is disabled.
    pub fn is_drag_leave_enabled(&self, wgt: WidgetId) -> bool {
        self.was_over(wgt) && self.was_enabled(wgt) && (!self.is_over(wgt) || self.is_disabled(wgt))
    }

    /// Returns `true` if the `wgt` was not hovered or was enabled, but now is hovered and disabled.
    pub fn is_drag_enter_disabled(&self, wgt: WidgetId) -> bool {
        (!self.was_over(wgt) || self.was_enabled(wgt)) && self.is_over(wgt) && self.is_disabled(wgt)
    }

    /// Returns `true` if the `wgt` was hovered and disabled, but now is not hovered or is enabled.
    pub fn is_drag_leave_disabled(&self, wgt: WidgetId) -> bool {
        self.was_over(wgt) && self.was_disabled(wgt) && (!self.is_over(wgt) || self.is_enabled(wgt))
    }
}

impl DragEndArgs {
    /// Data was dropped on a valid target.
    pub fn was_dropped(&self) -> bool {
        !self.applied.is_empty()
    }

    /// Stopped dragging without dropping on a valid drop target.
    pub fn was_canceled(&self) -> bool {
        self.applied.is_empty()
    }
}

/// Encode an widget ID for drag&drop data.
pub fn encode_widget_id(id: WidgetId) -> DragDropData {
    DragDropData::Extension {
        data_type: formatx!("zng/{}", APP_INSTANCE_GUID.read().simple()),
        data: IpcBytes::from_slice_blocking(&id.get().to_le_bytes()).unwrap(),
    }
}

/// Decode an widget ID from drag&drop data.
///
/// The ID will only decode if it was encoded by the same app instance.
pub fn decode_widget_id(data: &DragDropData) -> Option<WidgetId> {
    if let DragDropData::Extension { data_type, data } = data
        && data.len() == 8
        && let Some(guid) = data_type.strip_prefix("zng/")
        && guid == APP_INSTANCE_GUID.read().simple().to_string()
    {
        let mut id = [0u8; 8];
        id.copy_from_slice(data);
        return Some(WidgetId::from_raw(u64::from_le_bytes(id)));
    }
    None
}

app_local! {
    static APP_INSTANCE_GUID: uuid::Uuid = uuid::Uuid::new_v4();
}