1b-agent/OneCAD-Draft
1
0 Fork 0
forked from 1b-agent/opencadstudio-upstream
Code Pull Requests Activity

feat(ui): anchor every ribbon dropdown and status-bar popup to its widget, flipping at window edges

Browse Source 
All ribbon dropdowns (tool dropdowns, undo/redo history, and the layer /
colour / linetype / lineweight / style combos) and all status-bar popups
(scale, units, OSNAP, isolate, filter, customization menu, layout list)
now open directly at their widget instead of at a layout-estimated
position, and flip to the other side when the panel would cross a window
edge.

Each dropdown/pill widget is wrapped in a transparent PosReport that
records its screen bounds into a thread-local map on draw. The overlays
read those bounds:
- Ribbon: Ribbon::dd_anchor(id, panel_w, win_w) returns
  (align_right, h_pad, top); position_ribbon_dropdown places the panel
  below the widget, flipping right-aligned near the right edge.
- Status bar: popup builders take (pill_bounds, win_size) and call
  popup::position_statusbar_popup / popup_anchor, opening just above the
  pill and flipping left/right at the window edge.

The window size is now tracked (win_size, set on WindowResized). The old
layout estimators compute_dropdown_left / compute_layer_combo_left /
compute_prop_combo_left / compute_history_dropdown_left and
osnap_popup_right_offset are deleted.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Hakan SevenandClaude Opus 4.8 committed 2026-07-05 18:51:54 +03:00
1 parent 56e48b8d0f
commit 39043e6e56
13 files changed
+310 -383
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/ui/ribbon/mod.rs
+97 -117
View File
@@ -91,6 +91,33 @@ fn dropdown_backdrop<'a>(positioned: Element<'a, Message>) -> Element<'a, Messag
.into()
}
/// Position a ribbon dropdown `panel` in a full-window container just below its
/// widget, growing left or right per `align_right` (see [`Ribbon::dd_anchor`]).
fn position_ribbon_dropdown<'a>(
panel: Element<'a, Message>,
align_right: bool,
h_pad: f32,
top: f32,
) -> Element<'a, Message> {
let pad = Padding {
top,
bottom: 0.0,
left: if align_right { 0.0 } else { h_pad },
right: if align_right { h_pad } else { 0.0 },
};
let c = container(panel)
.align_top(Fill)
.width(Fill)
.height(Fill)
.padding(pad);
let c = if align_right {
c.align_right(Fill)
} else {
c.align_left(Fill)
};
c.into()
}
impl Ribbon {
pub fn new() -> Self {
Self {
@@ -140,14 +167,22 @@ impl Ribbon {
f32::from_bits(self.tool_bar_h.load(Ordering::Relaxed))
}
/// (top, left) screen offset at which to anchor the open dropdown `id`'s
/// overlay — just below its widget. Falls back to below the whole ribbon
/// when the widget's position hasn't been recorded yet.
fn dd_anchor(&self, id: &str) -> (f32, f32) {
if let Some(b) = crate::ui::wrap_bar::dropdown_bounds(id) {
(b.y + b.height, b.x)
} else {
(self.tab_bar_height() + self.tool_bar_height(), 0.0)
/// (align_right, horizontal_pad, top) to anchor the open dropdown `id`'s
/// overlay just below its widget. It grows rightward from the widget's left
/// edge, but flips to right-aligned (growing left) when a panel of `panel_w`
/// would cross the right window edge `win_w`. Falls back to below the whole
/// ribbon when the widget's position hasn't been recorded yet.
fn dd_anchor(&self, id: &str, panel_w: f32, win_w: f32) -> (bool, f32, f32) {
match crate::ui::wrap_bar::dropdown_bounds(id) {
Some(b) => {
let top = b.y + b.height;
if b.x + panel_w > win_w - 2.0 {
(true, (win_w - (b.x + b.width)).max(4.0), top)
} else {
(false, b.x.max(0.0), top)
}
}
None => (false, 0.0, self.tab_bar_height() + self.tool_bar_height()),
}
}
@@ -561,6 +596,7 @@ impl Ribbon {
&self,
undo_labels: &[String],
redo_labels: &[String],
win: (f32, f32),
) -> Option<Element<'_, Message>> {
let open_id = self.open_dropdown.as_deref()?;
@@ -607,39 +643,30 @@ impl Ribbon {
})
.width(Length::Fixed(170.0));
let (top, left) = self.dd_anchor(open_id);
let positioned = container(panel)
.align_left(Fill)
.align_top(Fill)
.padding(Padding {
top,
left,
..Default::default()
})
.width(Fill)
.height(Fill);
let (align_right, h_pad, top) = self.dd_anchor(open_id, 170.0, win.0);
let positioned = position_ribbon_dropdown(panel.into(), align_right, h_pad, top);
return Some(dropdown_backdrop(positioned.into()));
return Some(dropdown_backdrop(positioned));
}
if open_id == LAYER_COMBO_ID {
return self.layer_combo_overlay();
return self.layer_combo_overlay(win);
}
if open_id == PROP_COLOR_ID {
return self.prop_color_overlay();
return self.prop_color_overlay(win);
}
if open_id == PROP_LINETYPE_ID {
return self.prop_linetype_overlay();
return self.prop_linetype_overlay(win);
}
if open_id == PROP_LW_ID {
return self.prop_lw_overlay();
return self.prop_lw_overlay(win);
}
// Style combo dropdowns (annotate tab) float as overlays so the list
// isn't clipped by the fixed ribbon-row height, the way the Draw-tab
// dropdowns already are. (#153)
if let Some(ov) = self.style_combo_overlay(open_id) {
if let Some(ov) = self.style_combo_overlay(open_id, win) {
return Some(ov);
}
@@ -732,22 +759,16 @@ impl Ribbon {
})
.width(Length::Fixed(190.0));
let (top_offset, left_offset) = self.dd_anchor(open_id);
let positioned = container(panel)
.align_left(Fill)
.align_top(Fill)
.padding(Padding {
top: top_offset,
left: left_offset,
..Default::default()
})
.width(Fill)
.height(Fill);
Some(dropdown_backdrop(positioned.into()))
let (align_right, h_pad, top) = self.dd_anchor(open_id, 190.0, win.0);
Some(dropdown_backdrop(position_ribbon_dropdown(
panel.into(),
align_right,
h_pad,
top,
)))
}
fn layer_combo_overlay(&self) -> Option<Element<'_, Message>> {
fn layer_combo_overlay(&self, win: (f32, f32)) -> Option<Element<'_, Message>> {
// A toggle icon (visible / freeze / lock) is its own button so a click
// on it flips that state instead of bubbling up to the row's
// make-active handler (#133).
@@ -854,21 +875,10 @@ impl Ribbon {
})
.width(Length::Fixed(220.0));
let top_offset = self.tab_bar_height() + self.tool_bar_height();
let groups = self.modules.get(self.active)?.ribbon_groups();
let left_offset = compute_layer_combo_left(&groups);
let positioned = container(panel)
.align_left(Fill)
.align_top(Fill)
.padding(Padding {
top: top_offset,
left: left_offset,
..Default::default()
})
.width(Fill)
.height(Fill);
let (align_right, h_pad, top) = self.dd_anchor(LAYER_COMBO_ID, 220.0, win.0);
let positioned = position_ribbon_dropdown(panel.into(), align_right, h_pad, top);
Some(dropdown_backdrop(positioned.into()))
Some(dropdown_backdrop(positioned))
}
/// Floating popup for an annotate-tab style combo (text / dimension /
@@ -876,7 +886,7 @@ impl Ribbon {
/// style combo. Built as an overlay — like the layer combo and the
/// Draw-tab dropdowns — so the list grows to fit its entries instead of
/// being clipped to the ribbon-row height. (#153)
fn style_combo_overlay(&self, open_id: &str) -> Option<Element<'_, Message>> {
fn style_combo_overlay(&self, open_id: &str, win: (f32, f32)) -> Option<Element<'_, Message>> {
let groups = self.modules.get(self.active)?.ribbon_groups();
// Locate the open style combo; capture its style key + manager command.
@@ -978,23 +988,16 @@ impl Ribbon {
})
.width(Length::Fixed(LARGE_W * 2.3));
let top_offset = self.tab_bar_height() + self.tool_bar_height();
let left_offset = compute_dropdown_left(&groups, open_id);
let positioned = container(panel)
.align_left(Fill)
.align_top(Fill)
.padding(Padding {
top: top_offset,
left: left_offset,
..Default::default()
})
.width(Fill)
.height(Fill);
Some(dropdown_backdrop(positioned.into()))
let (align_right, h_pad, top) = self.dd_anchor(open_id, LARGE_W * 2.3, win.0);
Some(dropdown_backdrop(position_ribbon_dropdown(
panel.into(),
align_right,
h_pad,
top,
)))
}
fn prop_color_overlay(&self) -> Option<Element<'_, Message>> {
fn prop_color_overlay(&self, win: (f32, f32)) -> Option<Element<'_, Message>> {
let picker = crate::ui::color_select::color_list(
crate::ui::color_select::ColorExtras {
by_layer: true,
@@ -1016,24 +1019,16 @@ impl Ribbon {
})
.width(Length::Fixed(200.0));
let top_offset = self.tab_bar_height() + self.tool_bar_height();
let groups = self.modules.get(self.active)?.ribbon_groups();
let left_offset = compute_prop_combo_left(&groups, PROP_COLOR_ID);
let positioned = container(panel)
.align_left(Fill)
.align_top(Fill)
.padding(Padding {
top: top_offset,
left: left_offset,
..Default::default()
})
.width(Fill)
.height(Fill);
Some(dropdown_backdrop(positioned.into()))
let (align_right, h_pad, top) = self.dd_anchor(PROP_COLOR_ID, 200.0, win.0);
Some(dropdown_backdrop(position_ribbon_dropdown(
panel.into(),
align_right,
h_pad,
top,
)))
}
fn prop_linetype_overlay(&self) -> Option<Element<'_, Message>> {
fn prop_linetype_overlay(&self, win: (f32, f32)) -> Option<Element<'_, Message>> {
let active_lt = &self.active_linetype;
let mut items: Vec<LinetypeItem> = vec![
@@ -1105,24 +1100,16 @@ impl Ribbon {
})
.width(Length::Fixed(220.0));
let top_offset = self.tab_bar_height() + self.tool_bar_height();
let groups = self.modules.get(self.active)?.ribbon_groups();
let left_offset = compute_prop_combo_left(&groups, PROP_LINETYPE_ID);
let positioned = container(list)
.align_left(Fill)
.align_top(Fill)
.padding(Padding {
top: top_offset,
left: left_offset,
..Default::default()
})
.width(Fill)
.height(Fill);
Some(dropdown_backdrop(positioned.into()))
let (align_right, h_pad, top) = self.dd_anchor(PROP_LINETYPE_ID, 220.0, win.0);
Some(dropdown_backdrop(position_ribbon_dropdown(
list.into(),
align_right,
h_pad,
top,
)))
}
fn prop_lw_overlay(&self) -> Option<Element<'_, Message>> {
fn prop_lw_overlay(&self, win: (f32, f32)) -> Option<Element<'_, Message>> {
let active_lw = self.active_lineweight;
let rows: Vec<Element<Message>> = lw_options()
.into_iter()
@@ -1160,7 +1147,7 @@ impl Ribbon {
})
.collect();
self.prop_overlay_positioned(rows, PROP_LW_ID, 140.0)
self.prop_overlay_positioned(rows, PROP_LW_ID, 140.0, win)
}
fn prop_overlay_positioned<'a>(
@@ -1168,6 +1155,7 @@ impl Ribbon {
rows: Vec<Element<'a, Message>>,
dd_id: &str,
width: f32,
win: (f32, f32),
) -> Option<Element<'a, Message>> {
let panel = container(column(rows))
.style(|_: &Theme| container::Style {
@@ -1181,21 +1169,13 @@ impl Ribbon {
})
.width(Length::Fixed(width));
let top_offset = self.tab_bar_height() + self.tool_bar_height();
let groups = self.modules.get(self.active)?.ribbon_groups();
let left_offset = compute_prop_combo_left(&groups, dd_id);
let positioned = container(panel)
.align_left(Fill)
.align_top(Fill)
.padding(Padding {
top: top_offset,
left: left_offset,
..Default::default()
})
.width(Fill)
.height(Fill);
Some(dropdown_backdrop(positioned.into()))
let (align_right, h_pad, top) = self.dd_anchor(dd_id, width, win.0);
Some(dropdown_backdrop(position_ribbon_dropdown(
panel.into(),
align_right,
h_pad,
top,
)))
}
}
src/ui/ribbon/widgets.rs
+16 -110
View File
@@ -12,7 +12,7 @@ use iced::widget::{button, column, container, row, svg, text, tooltip};
use iced::{Background, Border, Color, Element, Fill, Length, Padding, Theme};
use crate::app::Message;
use crate::modules::{IconKind, ModuleEvent, RibbonGroup, RibbonItem, StyleKey, ToolDef};
use crate::modules::{IconKind, ModuleEvent, RibbonItem, StyleKey, ToolDef};
use crate::ui::wrap_bar::PosReport;
use crate::ui::icons;
use crate::ui::properties::{acad_color_display, LwItem};
@@ -744,9 +744,13 @@ pub(super) fn render_large<'a>(
let tools_row3 = make_tool_row(row3);
container(
column![combo_btn, tools_row2, tools_row3]
.spacing(3)
.align_x(iced::Left),
column![
PosReport::new(LAYER_COMBO_ID, combo_btn),
tools_row2,
tools_row3
]
.spacing(3)
.align_x(iced::Left),
)
.width(Length::Fixed(COMBO_W))
.height(Fill)
@@ -864,9 +868,13 @@ pub(super) fn render_large<'a>(
let lw_row = prop_row(LwItem(active_lineweight).to_string(), PROP_LW_ID, None);
let combos = container(
column![color_row, lt_row, lw_row]
.spacing(2)
.align_x(iced::Left),
column![
PosReport::new(PROP_COLOR_ID, color_row),
PosReport::new(PROP_LINETYPE_ID, lt_row),
PosReport::new(PROP_LW_ID, lw_row),
]
.spacing(2)
.align_x(iced::Left),
)
.height(Fill)
.align_y(iced::Center)
@@ -968,7 +976,7 @@ pub(super) fn render_large<'a>(
};
let mut col_items: Vec<Element<Message>> =
vec![container(row![combo_btn, items_panel].spacing(0))
vec![container(row![PosReport::new(*combo_id, combo_btn), items_panel].spacing(0))
.width(Fill)
.into()];
for row_tools in rows {
@@ -990,108 +998,6 @@ pub(super) fn render_large<'a>(
}
}
// ── Dropdown position helpers ──────────────────────────────────────────────
/// Calculate the left pixel offset of a dropdown button inside the ribbon tool area.
pub(super) fn compute_dropdown_left(groups: &[RibbonGroup], open_id: &str) -> f32 {
let sum_with_spacing = |widths: &[f32]| -> f32 {
widths
.iter()
.enumerate()
.map(|(i, &w)| if i == 0 { w } else { 2.0 + w })
.sum::<f32>()
};
let next_item_x = |widths: &[f32]| -> f32 {
if widths.is_empty() {
0.0
} else {
sum_with_spacing(widths) + 2.0
}
};
let mut x = 0.0f32;
for (g_idx, group) in groups.iter().enumerate() {
if g_idx > 0 {
x += 1.0;
}
x += 4.0;
let mut row_widths: Vec<f32> = Vec::new();
let mut small_col_w: f32 = 0.0;
let mut small_col_n: usize = 0;
for item in &group.tools {
let is_large = matches!(
item,
RibbonItem::LargeTool(_)
| RibbonItem::LargeDropdown { .. }
| RibbonItem::LayerComboGroup { .. }
| RibbonItem::PropertiesGroup { .. }
| RibbonItem::StyleComboGroup { .. }
);
let id: &str = match item {
RibbonItem::LargeTool(t) => t.id,
RibbonItem::LargeDropdown { id, .. } => *id,
RibbonItem::Tool(t) => t.id,
RibbonItem::Dropdown { id, .. } => *id,
RibbonItem::LayerComboGroup { .. } => LAYER_COMBO_ID,
RibbonItem::PropertiesGroup { match_prop } => match_prop.id,
RibbonItem::StyleComboGroup { combo_id, .. } => combo_id,
};
let item_w = match item {
RibbonItem::LargeTool(_) | RibbonItem::LargeDropdown { .. } => LARGE_W,
RibbonItem::LayerComboGroup { .. } => LARGE_W * 2.5,
RibbonItem::PropertiesGroup { .. } => LARGE_W + 4.0 + 130.0,
RibbonItem::StyleComboGroup { .. } => LARGE_W * 2.3,
RibbonItem::Dropdown { .. } => SMALL_W + ARROW_W,
_ => SMALL_W,
};
if is_large {
if small_col_n > 0 {
row_widths.push(small_col_w);
small_col_w = 0.0;
small_col_n = 0;
}
if id == open_id {
return x + next_item_x(&row_widths);
}
row_widths.push(item_w);
} else {
if id == open_id {
return x + next_item_x(&row_widths);
}
small_col_w = small_col_w.max(item_w);
small_col_n += 1;
if small_col_n == 3 {
row_widths.push(small_col_w);
small_col_w = 0.0;
small_col_n = 0;
}
}
}
if small_col_n > 0 {
row_widths.push(small_col_w);
}
x += sum_with_spacing(&row_widths) + 4.0;
}
60.0
}
pub(super) fn compute_layer_combo_left(groups: &[RibbonGroup]) -> f32 {
compute_dropdown_left(groups, LAYER_COMBO_ID)
}
/// Left offset for a Properties combo dropdown.
pub(super) fn compute_prop_combo_left(groups: &[RibbonGroup], _dd_id: &str) -> f32 {
let base = compute_dropdown_left(groups, "MATCHPROP");
base + LARGE_W + 4.0
}
// ── Message helpers ────────────────────────────────────────────────────────
#[allow(dead_code)]