Struct Reorder 

pub struct Reorder<Id>(/* private fields */);

A strip’s tabs in motion: the one being dragged, and the ones sliding aside for it. Kept by the view beside its Strip, one per strip.

The order changes while the drag is held, so a drop needs no handler: the tab is already where it was let go. Four places to wire:

tabs::bar("panel-tabs")
    .on_drag_move(cx.listener(|view, event: &DragMoveEvent<TabDrag>, _, cx| {
        view.reorder.follow(&mut view.strip, event.event.position, cx);
        cx.notify();
    }))
    .children(self.strip.tabs().iter().map(|id| {
        let tab = tabs::tab(&theme, key, label, state).on_drag(TabDrag(*id), {
            let (reorder, id) = (self.reorder.clone(), *id);
            move |_, at, _, cx| {
                reorder.grab(id, at);
                cx.new(|_| gpui::Empty)
            }
        });
        self.reorder.tab(id, tab, &theme, cx)
    }))

The ghost on_drag returns is still painted at the pointer; an empty one leaves the carried tab as the only thing that moves.

follow runs for every move of the drag, wherever the pointer is. Pointer travel off the strip’s axis is ignored.

The carried tab paints deferred, over its neighbours and outside the strip’s clip.

Implementations

impl<Id: Clone + PartialEq + 'static> Reorder<Id>

pub fn new(painter: Painter) -> Self

painter is the view the strip renders in: it is redrawn while tabs slide.

pub fn grab(&self, id: Id, at: Point<Pixels>)

Pick id up. Call it from the tab’s on_drag constructor, with the press offset that constructor is handed.

pub fn follow( &self, strip: &mut Strip<Id>, pointer: Point<Pixels>, cx: &App, ) -> bool

Carry the held tab to pointer, reordering strip as it passes its neighbours. true when the order changed.

pub fn tab( &self, id: &Id, tab: Stateful<Div>, theme: &Theme, cx: &mut App, ) -> AnyElement

tab, placed: at the pointer while carried, sliding while it makes way, in its slot otherwise.

Trait Implementations

impl<Id> Clone for Reorder<Id>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.