Skip to content

Commit 2c91864

Browse files
marc2332marc2332
committed
clean up
1 parent cc9ff9d commit 2c91864

3 files changed

Lines changed: 108 additions & 108 deletions

File tree

‎crates/freya-components/src/docking.rs‎

Lines changed: 32 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -43,12 +43,12 @@ impl<TabId, PanelId> DockPanel<TabId, PanelId> {
4343
}
4444
}
4545

46-
/// Insert `tab` at `position`.
47-
pub fn insert_tab(&mut self, tab: TabId, position: usize)
46+
/// Insert `tab_id` at `position`.
47+
pub fn insert_tab(&mut self, tab_id: TabId, position: usize)
4848
where
4949
TabId: Clone + PartialEq,
5050
{
51-
let target = match self.tabs.iter().position(|item| *item == tab) {
51+
let target = match self.tabs.iter().position(|item| *item == tab_id) {
5252
Some(existing) => {
5353
self.tabs.remove(existing);
5454
if position > existing {
@@ -59,18 +59,18 @@ impl<TabId, PanelId> DockPanel<TabId, PanelId> {
5959
}
6060
None => position,
6161
};
62-
self.active_tab_id = Some(tab.clone());
63-
self.tabs.insert(target.min(self.tabs.len()), tab);
62+
self.active_tab_id = Some(tab_id.clone());
63+
self.tabs.insert(target.min(self.tabs.len()), tab_id);
6464
}
6565

66-
/// Add `tab` at the end.
67-
pub fn append_tab(&mut self, tab: TabId)
66+
/// Add `tab_id` at the end.
67+
pub fn append_tab(&mut self, tab_id: TabId)
6868
where
6969
TabId: Clone + PartialEq,
7070
{
71-
self.tabs.retain(|item| *item != tab);
72-
self.active_tab_id = Some(tab.clone());
73-
self.tabs.push(tab);
71+
self.tabs.retain(|item| *item != tab_id);
72+
self.active_tab_id = Some(tab_id.clone());
73+
self.tabs.push(tab_id);
7474
}
7575
}
7676

@@ -98,20 +98,22 @@ where
9898
}
9999

100100
/// Find the panel with the given id.
101-
pub fn panel(&self, id: &PanelId) -> Option<&DockPanel<TabId, PanelId>> {
101+
pub fn panel(&self, panel_id: &PanelId) -> Option<&DockPanel<TabId, PanelId>> {
102102
match self {
103-
DockNode::Panel(panel) => (&panel.panel_id == id).then_some(panel),
104-
DockNode::Split { children, .. } => children.iter().find_map(|child| child.panel(id)),
103+
DockNode::Panel(panel) => (&panel.panel_id == panel_id).then_some(panel),
104+
DockNode::Split { children, .. } => {
105+
children.iter().find_map(|child| child.panel(panel_id))
106+
}
105107
}
106108
}
107109

108110
/// Mutable version of [`DockNode::panel`].
109-
pub fn panel_mut(&mut self, id: &PanelId) -> Option<&mut DockPanel<TabId, PanelId>> {
111+
pub fn panel_mut(&mut self, panel_id: &PanelId) -> Option<&mut DockPanel<TabId, PanelId>> {
110112
match self {
111-
DockNode::Panel(panel) => (&panel.panel_id == id).then_some(panel),
112-
DockNode::Split { children, .. } => {
113-
children.iter_mut().find_map(|child| child.panel_mut(id))
114-
}
113+
DockNode::Panel(panel) => (&panel.panel_id == panel_id).then_some(panel),
114+
DockNode::Split { children, .. } => children
115+
.iter_mut()
116+
.find_map(|child| child.panel_mut(panel_id)),
115117
}
116118
}
117119

@@ -133,39 +135,39 @@ where
133135
}
134136
}
135137

136-
/// Find `tab` under this node.
137-
pub fn find_tab(&self, tab: &TabId) -> Option<(PanelId, usize)> {
138+
/// Find `tab_id` under this node.
139+
pub fn find_tab(&self, tab_id: &TabId) -> Option<(PanelId, usize)> {
138140
match self {
139141
DockNode::Panel(panel) => panel
140142
.tabs
141143
.iter()
142-
.position(|item| item == tab)
144+
.position(|item| item == tab_id)
143145
.map(|position| (panel.panel_id, position)),
144146
DockNode::Split { children, .. } => {
145-
children.iter().find_map(|child| child.find_tab(tab))
147+
children.iter().find_map(|child| child.find_tab(tab_id))
146148
}
147149
}
148150
}
149151

150-
/// Remove `tab` from every panel except `except_panel`.
151-
pub fn remove_tab_except(&mut self, tab: &TabId, except_panel: Option<&PanelId>) -> bool {
152+
/// Remove `tab_id` from every panel except `except_panel_id`.
153+
pub fn remove_tab_except(&mut self, tab_id: &TabId, except_panel_id: Option<&PanelId>) -> bool {
152154
match self {
153155
DockNode::Panel(panel) => {
154-
if except_panel == Some(&panel.panel_id) {
156+
if except_panel_id == Some(&panel.panel_id) {
155157
return false;
156158
}
157-
let Some(position) = panel.tabs.iter().position(|item| item == tab) else {
159+
let Some(position) = panel.tabs.iter().position(|item| item == tab_id) else {
158160
return false;
159161
};
160162
panel.tabs.remove(position);
161-
if panel.active_tab_id.as_ref() == Some(tab) {
163+
if panel.active_tab_id.as_ref() == Some(tab_id) {
162164
panel.active_tab_id = panel.tabs.first().cloned();
163165
}
164166
true
165167
}
166168
DockNode::Split { children, .. } => children
167169
.iter_mut()
168-
.any(|child| child.remove_tab_except(tab, except_panel)),
170+
.any(|child| child.remove_tab_except(tab_id, except_panel_id)),
169171
}
170172
}
171173

@@ -252,8 +254,8 @@ pub trait DockingModel: 'static {
252254
/// Apply a dropped [`Self::DropValue`] at `target`. Returns `true` if
253255
/// something changed.
254256
fn on_drop(&mut self, value: Self::DropValue, target: DropTarget<Self::PanelId>) -> bool;
255-
/// Make `tab` the active one in `panel`. Returns `true` if it was found.
256-
fn set_active(&mut self, panel: Self::PanelId, tab: Self::TabId) -> bool;
257+
/// Make `tab_id` the active one in `panel_id`. Returns `true` if it was found.
258+
fn set_active(&mut self, panel_id: Self::PanelId, tab_id: Self::TabId) -> bool;
257259
}
258260

259261
/// The payload carried by a drag in a docking area.

‎crates/freya-components/tests/docking.rs‎

Lines changed: 52 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -37,50 +37,50 @@ impl DockingState {
3737
id
3838
}
3939

40-
fn find_tab(&self, tab: TabId) -> Option<(PanelId, usize)> {
41-
self.root.as_ref().and_then(|root| root.find_tab(&tab))
40+
fn find_tab(&self, tab_id: TabId) -> Option<(PanelId, usize)> {
41+
self.root.as_ref().and_then(|root| root.find_tab(&tab_id))
4242
}
4343

44-
fn set_active(&mut self, panel: PanelId, tab: TabId) -> bool {
45-
let Some(target) = self.root.as_mut().and_then(|root| root.panel_mut(&panel)) else {
44+
fn set_active(&mut self, panel_id: PanelId, tab_id: TabId) -> bool {
45+
let Some(target) = self
46+
.root
47+
.as_mut()
48+
.and_then(|root| root.panel_mut(&panel_id))
49+
else {
4650
return false;
4751
};
48-
if !target.tabs.contains(&tab) {
52+
if !target.tabs.contains(&tab_id) {
4953
return false;
5054
}
51-
target.active_tab_id = Some(tab);
55+
target.active_tab_id = Some(tab_id);
5256
true
5357
}
5458

55-
fn close_tab(&mut self, tab: TabId) -> bool {
59+
fn close_tab(&mut self, tab_id: TabId) -> bool {
5660
let Some(root) = self.root.as_mut() else {
5761
return false;
5862
};
59-
let removed = root.remove_tab_except(&tab, None);
63+
let removed = root.remove_tab_except(&tab_id, None);
6064
self.compact();
6165
removed
6266
}
6367

64-
fn move_tab(&mut self, tab: TabId, target: Target) -> bool {
68+
fn move_tab(&mut self, tab_id: TabId, target: Target) -> bool {
6569
let Some(root) = self.root.as_mut() else {
6670
return false;
6771
};
6872
let success = match target {
69-
DropTarget::Tab {
70-
panel_id: target_panel,
71-
position,
72-
} => insert_at(root, target_panel, tab, Some(position)),
73-
DropTarget::Center(target_panel) => insert_at(root, target_panel, tab, None),
74-
DropTarget::Split {
75-
panel_id: target_panel,
76-
side,
77-
} => {
73+
DropTarget::Tab { panel_id, position } => {
74+
insert_at(root, panel_id, tab_id, Some(position))
75+
}
76+
DropTarget::Center(panel_id) => insert_at(root, panel_id, tab_id, None),
77+
DropTarget::Split { panel_id, side } => {
7878
let new_panel_id = self.next_panel_id;
79-
let new_panel = Panel::new(new_panel_id, vec![tab]);
80-
if !root.split_panel(&target_panel, side, &new_panel) {
79+
let new_panel = Panel::new(new_panel_id, vec![tab_id]);
80+
if !root.split_panel(&panel_id, side, &new_panel) {
8181
return false;
8282
}
83-
root.remove_tab_except(&tab, Some(&new_panel_id));
83+
root.remove_tab_except(&tab_id, Some(&new_panel_id));
8484
self.next_panel_id += 1;
8585
true
8686
}
@@ -100,15 +100,15 @@ impl DockingState {
100100
}
101101
}
102102

103-
fn insert_at(root: &mut Node, target_panel: PanelId, tab: TabId, position: Option<usize>) -> bool {
104-
let Some(panel) = root.panel_mut(&target_panel) else {
103+
fn insert_at(root: &mut Node, panel_id: PanelId, tab_id: TabId, position: Option<usize>) -> bool {
104+
let Some(panel) = root.panel_mut(&panel_id) else {
105105
return false;
106106
};
107107
match position {
108-
Some(at) => panel.insert_tab(tab, at),
109-
None => panel.append_tab(tab),
108+
Some(at) => panel.insert_tab(tab_id, at),
109+
None => panel.append_tab(tab_id),
110110
}
111-
root.remove_tab_except(&tab, Some(&target_panel));
111+
root.remove_tab_except(&tab_id, Some(&panel_id));
112112
true
113113
}
114114

@@ -128,32 +128,32 @@ fn new_panel(state: &mut DockingState, tabs: Vec<TabId>) -> PanelId {
128128
#[test]
129129
fn find_tab_in_simple_panel() {
130130
let mut state = DockingState::new();
131-
let panel = new_panel(&mut state, vec![10, 11, 12]);
132-
assert_eq!(state.find_tab(11), Some((panel, 1)));
131+
let panel_id = new_panel(&mut state, vec![10, 11, 12]);
132+
assert_eq!(state.find_tab(11), Some((panel_id, 1)));
133133
assert_eq!(state.find_tab(99), None);
134134
}
135135

136136
#[test]
137137
fn move_tab_between_panels() {
138138
let mut state = DockingState::new();
139-
let source_panel = new_panel(&mut state, vec![1, 2, 3]);
140-
let target_panel = new_panel(&mut state, vec![4]);
139+
let source_panel_id = new_panel(&mut state, vec![1, 2, 3]);
140+
let target_panel_id = new_panel(&mut state, vec![4]);
141141

142142
assert!(state.move_tab(
143143
2,
144144
DropTarget::Tab {
145-
panel_id: target_panel,
145+
panel_id: target_panel_id,
146146
position: 0,
147147
},
148148
));
149149

150-
assert_eq!(state.find_tab(2), Some((target_panel, 0)));
151-
let (origin, _) = state.find_tab(1).unwrap();
152-
assert_eq!(origin, source_panel);
150+
assert_eq!(state.find_tab(2), Some((target_panel_id, 0)));
151+
let (origin_panel_id, _) = state.find_tab(1).unwrap();
152+
assert_eq!(origin_panel_id, source_panel_id);
153153
if let Some(DockNode::Split { children, .. }) = &state.root {
154154
for child in children {
155155
if let DockNode::Panel(panel) = child
156-
&& panel.panel_id == target_panel
156+
&& panel.panel_id == target_panel_id
157157
{
158158
assert_eq!(panel.tabs, vec![2, 4]);
159159
assert_eq!(panel.active_tab_id, Some(2));
@@ -165,14 +165,14 @@ fn move_tab_between_panels() {
165165
#[test]
166166
fn moving_last_tab_collapses_panel() {
167167
let mut state = DockingState::new();
168-
let _source = new_panel(&mut state, vec![1]);
169-
let target = new_panel(&mut state, vec![2]);
168+
let _source_panel_id = new_panel(&mut state, vec![1]);
169+
let target_panel_id = new_panel(&mut state, vec![2]);
170170

171-
assert!(state.move_tab(1, DropTarget::Center(target)));
171+
assert!(state.move_tab(1, DropTarget::Center(target_panel_id)));
172172

173173
match state.root.as_ref().unwrap() {
174174
DockNode::Panel(panel) => {
175-
assert_eq!(panel.panel_id, target);
175+
assert_eq!(panel.panel_id, target_panel_id);
176176
assert_eq!(panel.tabs, vec![2, 1]);
177177
}
178178
other => panic!("expected panel, got {other:?}"),
@@ -182,7 +182,7 @@ fn moving_last_tab_collapses_panel() {
182182
#[test]
183183
fn reorder_within_same_panel() {
184184
let mut state = DockingState::new();
185-
let panel = new_panel(&mut state, vec![1, 2, 3, 4]);
185+
let panel_id = new_panel(&mut state, vec![1, 2, 3, 4]);
186186

187187
assert!(state.move_tab(
188188
1,
@@ -202,7 +202,7 @@ fn reorder_within_same_panel() {
202202
#[test]
203203
fn split_creates_new_panel() {
204204
let mut state = DockingState::new();
205-
let panel = new_panel(&mut state, vec![1, 2]);
205+
let panel_id = new_panel(&mut state, vec![1, 2]);
206206

207207
assert!(state.move_tab(
208208
1,
@@ -225,7 +225,7 @@ fn split_creates_new_panel() {
225225
let DockNode::Panel(right) = &children[1] else {
226226
panic!("expected panel");
227227
};
228-
assert_eq!(left.panel_id, panel);
228+
assert_eq!(left.panel_id, panel_id);
229229
assert_eq!(left.tabs, vec![2]);
230230
assert_eq!(right.tabs, vec![1]);
231231
assert_eq!(right.active_tab_id, Some(1));
@@ -237,7 +237,7 @@ fn split_creates_new_panel() {
237237
#[test]
238238
fn split_left_places_new_panel_first() {
239239
let mut state = DockingState::new();
240-
let panel = new_panel(&mut state, vec![1, 2]);
240+
let panel_id = new_panel(&mut state, vec![1, 2]);
241241

242242
assert!(state.move_tab(
243243
2,
@@ -260,12 +260,12 @@ fn split_left_places_new_panel_first() {
260260
#[test]
261261
fn split_top_uses_vertical_direction() {
262262
let mut state = DockingState::new();
263-
let panel = new_panel(&mut state, vec![1, 2]);
263+
let panel_id = new_panel(&mut state, vec![1, 2]);
264264

265265
state.move_tab(
266266
2,
267267
DropTarget::Split {
268-
panel_id: panel,
268+
panel_id,
269269
side: Side::Top,
270270
},
271271
);
@@ -280,14 +280,14 @@ fn split_top_uses_vertical_direction() {
280280
#[test]
281281
fn close_tab_removes_and_compacts() {
282282
let mut state = DockingState::new();
283-
let removed = new_panel(&mut state, vec![1]);
284-
let _kept = new_panel(&mut state, vec![2, 3]);
283+
let removed_panel_id = new_panel(&mut state, vec![1]);
284+
let _kept_panel_id = new_panel(&mut state, vec![2, 3]);
285285

286286
state.close_tab(1);
287287

288288
match state.root.as_ref().unwrap() {
289289
DockNode::Panel(panel) => {
290-
assert_ne!(panel.panel_id, removed);
290+
assert_ne!(panel.panel_id, removed_panel_id);
291291
assert_eq!(panel.tabs, vec![2, 3]);
292292
}
293293
other => panic!("expected single panel, got {other:?}"),
@@ -297,8 +297,8 @@ fn close_tab_removes_and_compacts() {
297297
#[test]
298298
fn closing_active_tab_promotes_first() {
299299
let mut state = DockingState::new();
300-
let panel = new_panel(&mut state, vec![1, 2, 3]);
301-
state.set_active(panel, 2);
300+
let panel_id = new_panel(&mut state, vec![1, 2, 3]);
301+
state.set_active(panel_id, 2);
302302
state.close_tab(2);
303303

304304
if let Some(DockNode::Panel(panel)) = &state.root {
@@ -322,12 +322,12 @@ fn with_layout_advances_id_counter() {
322322
#[test]
323323
fn split_self_then_drop_keeps_tab_in_new_panel() {
324324
let mut state = DockingState::new();
325-
let panel = new_panel(&mut state, vec![1, 2]);
325+
let panel_id = new_panel(&mut state, vec![1, 2]);
326326

327327
state.move_tab(
328328
1,
329329
DropTarget::Split {
330-
panel_id: panel,
330+
panel_id,
331331
side: Side::Right,
332332
},
333333
);

0 commit comments

Comments
 (0)