fret-core 0.1.0

Core contracts, IDs, geometry, events, and shared data types for the Fret framework.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use crate::{AppWindowId, DockNodeId, DropZone, PanelKey, Rect, WindowAnchor};

/// High-level docking operations emitted by the UI layer and applied by the app layer.
///
/// This is the transaction vocabulary that enables persistence, undo/redo, and plugins
/// without letting UI widgets mutate the dock graph ad-hoc.
#[derive(Debug, Clone, PartialEq)]
pub enum DockOp {
    SetActiveTab {
        tabs: DockNodeId,
        active: usize,
    },

    ClosePanel {
        window: AppWindowId,
        panel: PanelKey,
    },

    MovePanel {
        source_window: AppWindowId,
        panel: PanelKey,
        target_window: AppWindowId,
        target_tabs: DockNodeId,
        zone: DropZone,
        insert_index: Option<usize>,
    },

    /// Move a panel into a window that currently has no dock root tabs.
    ///
    /// This creates the initial root tab stack for `target_window` and inserts `panel` into it.
    MovePanelToEmptyDockSpace {
        source_window: AppWindowId,
        panel: PanelKey,
        target_window: AppWindowId,
    },

    /// Move an entire tab stack ("dock node") as a group.
    ///
    /// This is used for editor-grade interactions like dragging the tab bar empty space to
    /// undock/move the whole group, rather than a single tab.
    MoveTabs {
        source_window: AppWindowId,
        source_tabs: DockNodeId,
        target_window: AppWindowId,
        target_tabs: DockNodeId,
        zone: DropZone,
        insert_index: Option<usize>,
    },

    /// Move an entire tab stack ("dock node") into a window that currently has no dock root tabs.
    ///
    /// This creates the initial root tab stack for `target_window` and moves the whole group.
    MoveTabsToEmptyDockSpace {
        source_window: AppWindowId,
        source_tabs: DockNodeId,
        target_window: AppWindowId,
    },

    FloatPanelToWindow {
        source_window: AppWindowId,
        panel: PanelKey,
        new_window: AppWindowId,
    },

    /// Request creating a new floating OS window and moving the panel into it.
    ///
    /// This is interpreted by the app/runner layer, because `fret-core` does not own window creation.
    RequestFloatPanelToNewWindow {
        source_window: AppWindowId,
        panel: PanelKey,
        anchor: Option<WindowAnchor>,
    },

    /// Request creating a new floating OS window and moving an entire tab stack ("tabs node") into it.
    ///
    /// This is interpreted by the app/runner layer, because `fret-core` does not own window creation.
    ///
    /// Note: `panel` is a representative panel key used for correlating window creation and for
    /// policy hooks; the runtime is responsible for moving the full `source_tabs` contents.
    RequestFloatTabsToNewWindow {
        source_window: AppWindowId,
        source_tabs: DockNodeId,
        panel: PanelKey,
        anchor: Option<WindowAnchor>,
    },

    /// Float a panel into an in-window floating dock container (ImGui docking, viewports disabled).
    ///
    /// This does not create a new OS window; the floating container is rendered within
    /// `target_window`'s dock host.
    FloatPanelInWindow {
        source_window: AppWindowId,
        panel: PanelKey,
        target_window: AppWindowId,
        rect: Rect,
    },

    /// Float a whole tab stack into an in-window floating dock container.
    FloatTabsInWindow {
        source_window: AppWindowId,
        source_tabs: DockNodeId,
        target_window: AppWindowId,
        rect: Rect,
    },

    /// Update the bounds of an in-window floating dock container.
    SetFloatingRect {
        window: AppWindowId,
        floating: DockNodeId,
        rect: Rect,
    },

    /// Raise an in-window floating dock container above other floating containers in the window.
    RaiseFloating {
        window: AppWindowId,
        floating: DockNodeId,
    },

    /// Merge an in-window floating dock container back into an existing tab stack.
    MergeFloatingInto {
        window: AppWindowId,
        floating: DockNodeId,
        target_tabs: DockNodeId,
    },

    /// Merge all panels from `source_window` into `target_tabs` in `target_window`, then remove
    /// the dock root for `source_window`.
    ///
    /// Recommended default behavior when a floating window is closed is to merge its panels back
    /// into the main window rather than discarding them.
    MergeWindowInto {
        source_window: AppWindowId,
        target_window: AppWindowId,
        target_tabs: DockNodeId,
    },

    /// Update a split node's normalized `fractions` (length must match `children.len()`).
    SetSplitFractions {
        split: DockNodeId,
        fractions: Vec<f32>,
    },

    /// Atomically update multiple split nodes' normalized `fractions`.
    ///
    /// This is intended for editor-grade splitter drags where a single pointer interaction may
    /// need to update nested same-axis splits to avoid oscillation.
    SetSplitFractionsMany {
        updates: Vec<SplitFractionsUpdate>,
    },

    SetSplitFractionTwo {
        split: DockNodeId,
        first_fraction: f32,
    },
}

#[derive(Debug, Clone, PartialEq)]
pub struct SplitFractionsUpdate {
    pub split: DockNodeId,
    pub fractions: Vec<f32>,
}