kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

fix some bugs relating to tab behavior and border rendering

Browse source
This commit is contained in:
kossLAN 2026-05-03 04:17:23 -04:00
parent f056727621
commit 206a5fb19e
No known key found for this signature in database
12 changed files with 240 additions and 172 deletions
Download patch file Download diff file Expand all files Collapse all files

234
src/renderer.rs
View file

@ -284,8 +284,6 @@ impl Renderer<'_> {
let srgb_srgb = self.state.color_manager.srgb_gamma22();
let srgb = &srgb_srgb.linear;
let perceptual = RenderIntent::Perceptual;
let scalef = self.base.scalef as f32;
let radius = self.state.theme.sizes.tab_bar_radius.get();
let border_width = self.state.theme.sizes.tab_bar_border_width.get();
let text_padding = self.state.theme.sizes.tab_bar_text_padding.get();
@ -294,10 +292,10 @@ impl Renderer<'_> {
// Vulkan sorts ops: Fill < RoundedFill (by z_order, color) < Tex/RoundedTex (by index).
// We use:
// FillRect – tiny strip for Vulkan paint regions (hidden)
// RoundedFillRect z0 – solid rounded bg
// RoundedFillRect z1 – rounded border ring (on top of bg)
// RoundedCopyTexture – title text (on top of everything)
// FillRect - tiny strip for Vulkan paint regions (hidden)
// RoundedFillRect z0 - solid rounded bg
// RoundedFillRect z1 - rounded border ring (on top of bg)
// RoundedCopyTexture - title text (on top of everything)
for entry in &tab_bar.entries {
let (bg_color, border_color, _text_color) = TabBar::entry_colors(self.state, entry);
let ex = entry.x.get();
@ -323,7 +321,7 @@ impl Renderer<'_> {
None,
srgb,
perceptual,
tab_cr.scaled_by(scalef),
self.scale_corner_radius(tab_cr),
0.0,
0,
);
@ -336,8 +334,8 @@ impl Renderer<'_> {
None,
srgb,
perceptual,
tab_cr.scaled_by(scalef),
border_width as f32 * scalef,
self.scale_corner_radius(tab_cr),
self.scale_len(border_width),
1,
);
}
@ -386,6 +384,65 @@ impl Renderer<'_> {
}
}
fn scale_len(&self, len: i32) -> f32 {
if self.base.scaled {
(len as f64 * self.base.scalef).round() as f32
} else {
len as f32
}
}
fn scale_corner_radius(&self, cr: CornerRadius) -> CornerRadius {
if !self.base.scaled {
return cr;
}
let scale = self.base.scalef as f32;
CornerRadius {
top_left: (cr.top_left * scale).round(),
top_right: (cr.top_right * scale).round(),
bottom_right: (cr.bottom_right * scale).round(),
bottom_left: (cr.bottom_left * scale).round(),
}
}
fn render_rounded_frame(
&mut self,
rect: Rect,
color: &Color,
corner_radius: CornerRadius,
border_width: i32,
x: i32,
y: i32,
) {
if border_width <= 0 {
return;
}
let srgb_srgb = self.state.color_manager.srgb_gamma22();
let srgb = &srgb_srgb.linear;
let perceptual = RenderIntent::Perceptual;
if corner_radius.is_zero() {
let bw = border_width;
let frame_rects = [
Rect::new_sized_saturating(rect.x1(), rect.y1(), bw, rect.height()),
Rect::new_sized_saturating(rect.x2() - bw, rect.y1(), bw, rect.height()),
Rect::new_sized_saturating(rect.x1(), rect.y1(), rect.width(), bw),
Rect::new_sized_saturating(rect.x1(), rect.y2() - bw, rect.width(), bw),
];
self.base
.fill_boxes2(&frame_rects, color, srgb, perceptual, x, y);
} else {
self.base.fill_rounded_rect(
rect.move_(x, y),
color,
None,
srgb,
perceptual,
self.scale_corner_radius(corner_radius),
self.scale_len(border_width),
);
}
}
fn render_container_decorations(&mut self, container: &ContainerNode, x: i32, y: i32) {
let srgb_srgb = self.state.color_manager.srgb_gamma22();
let srgb = &srgb_srgb.linear;
@ -409,60 +466,29 @@ impl Renderer<'_> {
}
let mb = container.mono_body.get();
if self.state.theme.sizes.gap.get() != 0 {
let srgb_srgb = self.state.color_manager.srgb_gamma22();
let bw = self.state.theme.sizes.border_width.get();
let border_color = self.state.theme.colors.border.get();
let focused_border_color = self.state.theme.colors.focused_title_background.get();
let focused_border_color = self.state.theme.colors.active_border.get();
let c = if child.active.get() {
&focused_border_color
} else {
&border_color
};
let full_w = mb.width();
let srgb = &srgb_srgb.linear;
let perceptual = RenderIntent::Perceptual;
if !child.node.node_is_container() {
let cr = self.state.theme.corner_radius.get();
let frame_y = mb.y1();
let frame_h = mb.height();
if cr.is_zero() {
let frame_rects = [
Rect::new_sized_saturating(mb.x1() - bw, frame_y, bw, frame_h),
Rect::new_sized_saturating(mb.x2(), frame_y, bw, frame_h),
Rect::new_sized_saturating(
mb.x1() - bw,
frame_y - bw,
full_w + 2 * bw,
bw,
),
Rect::new_sized_saturating(
mb.x1() - bw,
frame_y + frame_h,
full_w + 2 * bw,
bw,
),
];
self.base
.fill_boxes2(&frame_rects, c, srgb, perceptual, x, y);
} else {
let outer = Rect::new_sized_saturating(
mb.x1() - bw,
frame_y - bw,
full_w + 2 * bw,
frame_h + 2 * bw,
);
let scalef = self.base.scalef as f32;
let scaled_cr = cr.scaled_by(scalef);
self.base.fill_rounded_rect(
outer.move_(x, y),
c,
None,
srgb,
perceptual,
scaled_cr,
bw as f32 * scalef,
);
}
let frame = Rect::new_sized_saturating(
mb.x1() - bw,
mb.y1() - bw,
mb.width() + 2 * bw,
mb.height() + 2 * bw,
);
self.render_rounded_frame(
frame,
c,
self.state.theme.corner_radius.get(),
bw,
x,
y,
);
}
}
let body = mb.move_(x, y);
@ -476,9 +502,8 @@ impl Renderer<'_> {
if self.state.theme.sizes.gap.get() != 0 && !child.node.node_is_container() {
let cr = self.state.theme.corner_radius.get();
if !cr.is_zero() {
let scalef = self.base.scalef as f32;
let bw = self.state.theme.sizes.border_width.get();
let inner_cr = cr.expanded_by(-(bw as f32)).scaled_by(scalef);
let inner_cr = self.scale_corner_radius(cr.expanded_by(-(bw as f32)));
self.corner_radius = Some(inner_cr);
}
}
@ -489,14 +514,13 @@ impl Renderer<'_> {
self.corner_radius = None;
} else {
let gap = self.state.theme.sizes.gap.get();
let (srgb_srgb, bw, border_color, focused_border_color) = if gap != 0 {
let srgb_srgb = self.state.color_manager.srgb_gamma22();
let (bw, border_color, focused_border_color) = if gap != 0 {
let bw = self.state.theme.sizes.border_width.get();
let border_color = self.state.theme.colors.border.get();
let focused_border_color = self.state.theme.colors.focused_title_background.get();
(Some(srgb_srgb), bw, border_color, focused_border_color)
let focused_border_color = self.state.theme.colors.active_border.get();
(bw, border_color, focused_border_color)
} else {
(None, 0, Color::SOLID_BLACK, Color::SOLID_BLACK)
(0, Color::SOLID_BLACK, Color::SOLID_BLACK)
};
let cr = self.state.theme.corner_radius.get();
for child in container.children.iter() {
@ -504,55 +528,20 @@ impl Renderer<'_> {
if body.x1() >= container.width.get() || body.y1() >= container.height.get() {
break;
}
if let Some(srgb_srgb) = srgb_srgb {
let srgb = &srgb_srgb.linear;
if gap != 0 {
let c = if child.border_color_is_focused.get() {
&focused_border_color
} else {
&border_color
};
if !child.node.node_is_container() && gap != 0 {
let full_w = body.width();
let perceptual = RenderIntent::Perceptual;
let full_h = body.height();
if cr.is_zero() {
let frame_rects = [
Rect::new_sized_saturating(body.x1() - bw, body.y1(), bw, full_h),
Rect::new_sized_saturating(body.x2(), body.y1(), bw, full_h),
Rect::new_sized_saturating(
body.x1() - bw,
body.y1() - bw,
full_w + 2 * bw,
bw,
),
Rect::new_sized_saturating(
body.x1() - bw,
body.y2(),
full_w + 2 * bw,
bw,
),
];
self.base
.fill_boxes2(&frame_rects, c, srgb, perceptual, x, y);
} else {
let outer = Rect::new_sized_saturating(
body.x1() - bw,
body.y1() - bw,
full_w + 2 * bw,
full_h + 2 * bw,
);
let scalef = self.base.scalef as f32;
let scaled_cr = cr.scaled_by(scalef);
self.base.fill_rounded_rect(
outer.move_(x, y),
c,
None,
srgb,
perceptual,
scaled_cr,
bw as f32 * scalef,
);
}
let frame = Rect::new_sized_saturating(
body.x1() - bw,
body.y1() - bw,
body.width() + 2 * bw,
body.height() + 2 * bw,
);
self.render_rounded_frame(frame, c, cr, bw, x, y);
}
}
let content = child.content.get();
@ -563,8 +552,7 @@ impl Renderer<'_> {
None
};
if !cr.is_zero() && !child.node.node_is_container() && gap != 0 {
let scalef = self.base.scalef as f32;
let inner_cr = cr.expanded_by(-(bw as f32)).scaled_by(scalef);
let inner_cr = self.scale_corner_radius(cr.expanded_by(-(bw as f32)));
self.corner_radius = Some(inner_cr);
}
let body = body.move_(x, y);
@ -808,42 +796,18 @@ impl Renderer<'_> {
let theme = &self.state.theme;
let bw = theme.sizes.border_width.get();
let bc = if floating.active.get() {
theme.colors.focused_title_background.get()
theme.colors.active_border.get()
} else {
theme.colors.border.get()
};
let srgb_srgb = self.state.color_manager.srgb_gamma22();
let srgb = &srgb_srgb.linear;
let perceptual = RenderIntent::Perceptual;
let cr = theme.corner_radius.get();
if cr.is_zero() {
let borders = [
Rect::new_sized_saturating(x, y, pos.width(), bw),
Rect::new_sized_saturating(x, y + bw, bw, pos.height() - bw),
Rect::new_sized_saturating(x + pos.width() - bw, y + bw, bw, pos.height() - bw),
Rect::new_sized_saturating(x + bw, y + pos.height() - bw, pos.width() - 2 * bw, bw),
];
self.base.fill_boxes(&borders, &bc, srgb, perceptual);
} else {
let outer = Rect::new_sized_saturating(x, y, pos.width(), pos.height());
let scalef = self.base.scalef as f32;
let scaled_cr = cr.scaled_by(scalef);
self.base.fill_rounded_rect(
outer,
&bc,
None,
srgb,
perceptual,
scaled_cr,
bw as f32 * scalef,
);
}
let outer = Rect::new_sized_saturating(0, 0, pos.width(), pos.height());
self.render_rounded_frame(outer, &bc, cr, bw, x, y);
let body =
Rect::new_sized_saturating(x + bw, y + bw, pos.width() - 2 * bw, pos.height() - 2 * bw);
let scissor_body = self.base.scale_rect(body);
if !cr.is_zero() {
let scalef = self.base.scalef as f32;
let inner_cr = cr.expanded_by(-(bw as f32)).scaled_by(scalef);
let inner_cr = self.scale_corner_radius(cr.expanded_by(-(bw as f32)));
self.corner_radius = Some(inner_cr);
}
child.node_render(self, body.x1(), body.y1(), Some(&scissor_body));