diff --git a/Cargo.lock b/Cargo.lock index 86a93753b..932327d1c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -443,7 +443,7 @@ dependencies = [ "bitflags 2.9.4", "cexpr", "clang-sys", - "itertools", + "itertools 0.13.0", "proc-macro2", "quote", "regex", @@ -1927,6 +1927,15 @@ dependencies = [ "either", ] +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + [[package]] name = "itoa" version = "1.0.15" @@ -2358,6 +2367,7 @@ dependencies = [ "glam", "input", "insta", + "itertools 0.14.0", "keyframe", "libc", "libdisplay-info", diff --git a/Cargo.toml b/Cargo.toml index 5346708f9..bc950f9c4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -109,6 +109,7 @@ wayland-backend = "0.3.11" wayland-scanner = "0.31.7" xcursor = "0.3.10" zbus = { version = "5.11.0", optional = true } +itertools = "0.14.0" [dependencies.smithay] workspace = true diff --git a/README.md b/README.md index 31a0fb30f..3898b3365 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,8 @@ -# niri +# niri (fork) + +

+ +

This repo houses a fork of [niri](https://github/com/YaLTeR/niri), a scrollable tiling Wayland compositor. @@ -111,6 +115,21 @@ When using `move-window-into-or-out-of-group` on a non-grouped tile, but there i direction you're attempting to move to, the behavior will instead be similar to `consume-or-expel-window`, `-left` or `-right` respectively, or `move-window`, `-up` or `-down` respectively. +By default, tab titles will be rendered above tab bars. Their appearance can be adjusted under the `tab-indicator` +setting: + +```kdl +layout { + tab-indicator { + // default is 12 + title-font-size 18 + + // optional, if you don't want titles to show at all + hide-titles + } +} +``` + #### Caveats - When maximizing or fullscreening a grouped tile, the tab indicator will disappear. However, you can still cycle tabs diff --git a/assets/screenshots/groups-blur.png b/assets/screenshots/groups-blur.png new file mode 100644 index 000000000..c3183978c --- /dev/null +++ b/assets/screenshots/groups-blur.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b0e47c03a827ac9d9af72acc5cc406cf60fc7d1568a2c12a8e49c5c3dbb5a12 +size 800755 diff --git a/niri-config/src/appearance.rs b/niri-config/src/appearance.rs index 3aee86ce4..9b9a4eac7 100644 --- a/niri-config/src/appearance.rs +++ b/niri-config/src/appearance.rs @@ -489,6 +489,8 @@ impl MergeWith for WorkspaceShadow { pub struct TabIndicator { pub off: bool, pub hide_when_single_tab: bool, + pub hide_titles: bool, + pub title_font_size: u32, pub gap: f64, pub width: f64, pub length: TabIndicatorLength, @@ -508,6 +510,8 @@ impl Default for TabIndicator { Self { off: false, hide_when_single_tab: false, + hide_titles: false, + title_font_size: 12, gap: 5., width: 4., length: TabIndicatorLength { @@ -535,6 +539,7 @@ impl MergeWith for TabIndicator { merge!( (self, part), + hide_titles, hide_when_single_tab, gap, width, @@ -542,7 +547,7 @@ impl MergeWith for TabIndicator { corner_radius, ); - merge_clone!((self, part), length, position); + merge_clone!((self, part), title_font_size, length, position); merge_color_gradient_opt!( (self, part), @@ -560,6 +565,10 @@ pub struct TabIndicatorPart { #[knuffel(child)] pub on: bool, #[knuffel(child)] + pub hide_titles: Option, + #[knuffel(child, unwrap(argument))] + pub title_font_size: Option, + #[knuffel(child)] pub hide_when_single_tab: Option, #[knuffel(child, unwrap(argument))] pub gap: Option>, diff --git a/src/layout/mod.rs b/src/layout/mod.rs index 7feb32883..aa64bdb70 100644 --- a/src/layout/mod.rs +++ b/src/layout/mod.rs @@ -286,6 +286,11 @@ pub trait LayoutElement { fn interactive_resize_data(&self) -> Option; fn on_commit(&mut self, serial: Serial); + + /// The name / title of this layout element + fn title(&self) -> Option { + None + } } #[derive(Debug)] diff --git a/src/layout/scrolling.rs b/src/layout/scrolling.rs index 3b7caf0ac..fcf9d9f0d 100644 --- a/src/layout/scrolling.rs +++ b/src/layout/scrolling.rs @@ -1931,7 +1931,7 @@ impl ScrollingSpace { let source_tile = &mut self.columns[source_col_idx].tiles[source_tile_idx]; if let Some(window) = source_tile.ungroup_single(&id) { - let extra_offset = Point::new(0., source_tile.tab_indicator_extra_size().h); + let extra_offset = source_tile.tab_indicator_content_offset(); let to_update = source_tile.focused_window().id().clone(); // we need to refresh the window here to avoid triggering its resize animation @@ -1979,14 +1979,21 @@ impl ScrollingSpace { Some(self.options.animations.window_movement.0), ); + let source_position = self + .tile_render_pos(source_col_idx + 1, source_tile_idx) + .expect("should determine source tile render pos"); + + let target_position = self + .tile_render_pos(source_col_idx, 0) + .expect("should determine source tile render pos"); + let inserted_tile = self.columns[source_col_idx] .tiles .first_mut() .expect("should have first tile"); - inserted_tile.animate_move_from(Point::new( - inserted_tile.tile_bounding_box().w + self.options.layout.gaps, - extra_offset.y, - )); + inserted_tile.animate_move_from( + source_position - target_position + extra_offset, + ); inserted_tile.focused_window().id().clone() } WindowMoveDirection::Right => { @@ -2001,14 +2008,17 @@ impl ScrollingSpace { Some(self.options.animations.window_movement.0), ); + let target_position = self + .tile_render_pos(source_col_idx + 1, 0) + .expect("should determine source tile render pos"); + let inserted_tile = self.columns[source_col_idx + 1] .tiles .first_mut() .expect("should have first tile"); - inserted_tile.animate_move_from(Point::new( - -(inserted_tile.tile_bounding_box().w + self.options.layout.gaps), - extra_offset.y, - )); + inserted_tile.animate_move_from( + source_position - target_position + extra_offset, + ); inserted_tile.focused_window().id().clone() } @@ -2059,7 +2069,7 @@ impl ScrollingSpace { if let Some(ungrouped) = source_tile.ungroup_single(&id) { let to_update = source_tile.focused_window().id().clone(); - let extra_offset = Point::new(0., source_tile.tab_indicator_extra_size().h); + let extra_offset = source_tile.tab_indicator_content_offset(); // we need to refresh the window here to avoid triggering its resize animation source_tile.focused_window().refresh(); self.update_window(&to_update, None); diff --git a/src/layout/tab_indicator.rs b/src/layout/tab_indicator.rs index adc24a66c..220e554e9 100644 --- a/src/layout/tab_indicator.rs +++ b/src/layout/tab_indicator.rs @@ -1,24 +1,40 @@ +use std::cell::RefCell; +use std::cmp::min; use std::iter::zip; use std::mem; +use anyhow::ensure; +use itertools::izip; use niri_config::{CornerRadius, Gradient, GradientRelativeTo, TabIndicatorPosition}; -use smithay::utils::{Logical, Point, Rectangle, Size}; +use pango::glib::property::PropertySet; +use pango::FontDescription; +use pangocairo::cairo::{self, ImageSurface}; +use smithay::backend::allocator::Fourcc; +use smithay::backend::renderer::element::Kind; +use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture}; +use smithay::utils::{Logical, Physical, Point, Rectangle, Size, Transform}; -use super::tile::Tile; use super::LayoutElement; use crate::animation::{Animation, Clock}; use crate::niri_render_elements; use crate::render_helpers::border::BorderRenderElement; +use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement; use crate::render_helpers::renderer::NiriRenderer; +use crate::render_helpers::texture::{TextureBuffer, TextureRenderElement}; use crate::utils::{ floor_logical_in_physical_max1, round_logical_in_physical, round_logical_in_physical_max1, + to_physical_precise_round, }; +const MIN_DIST_TO_EDGES: f64 = 20.; + #[derive(Debug)] pub struct TabIndicator { shader_locs: Vec>, shaders: Vec, open_anim: Option, + tabs: Vec, + title_textures: Vec, config: niri_config::TabIndicator, } @@ -28,19 +44,36 @@ pub struct TabInfo { pub gradient: Gradient, /// Tab geometry in the same coordinate system as the area. pub geometry: Rectangle, + /// The title for this tab. + pub title: String, } niri_render_elements! { TabIndicatorRenderElement => { Gradient = BorderRenderElement, + Title = PrimaryGpuTextureRenderElement, } } +#[derive(Debug, Default)] +struct TitleTexture { + title: String, + scale: f64, + max_size: Size, + // cached result of the rendered title texture + texture: RefCell>>, + // the maximum size wanted by the title texture if it had infinite space + wanted_size: RefCell>>, + font_size: u32, +} + impl TabIndicator { pub fn new(config: niri_config::TabIndicator) -> Self { Self { shader_locs: Vec::new(), shaders: Vec::new(), + tabs: Vec::new(), + title_textures: Vec::new(), open_anim: None, config, } @@ -108,7 +141,7 @@ impl TabIndicator { (count - 1) as f64 * (px_per_tab + gaps_between) + px_per_tab * progress; let mut ones_left = ((length - floored_length) / pixel).round() as usize; - let mut shader_loc = Point::from((-gap - width, round((side - length) / 2.))); + let mut shader_loc = Point::from((-width, round((side - length) / 2.))); match position { TabIndicatorPosition::Top => mem::swap(&mut shader_loc.x, &mut shader_loc.y), TabIndicatorPosition::Bottom => { @@ -141,17 +174,18 @@ impl TabIndicator { #[allow(clippy::too_many_arguments)] pub fn update_render_elements( &mut self, + tabs: Vec, enabled: bool, // Geometry of the tabs area. area: Rectangle, // View rect relative to the tabs area. area_view_rect: Rectangle, - // Tab count, should match the tabs iterator length. - tab_count: usize, - tabs: impl Iterator, is_active: bool, scale: f64, ) { + self.tabs = tabs; + let tab_count = self.tabs.len(); + if !enabled || self.config.off { self.shader_locs.clear(); self.shaders.clear(); @@ -172,10 +206,40 @@ impl TabIndicator { let shared_rounded_corners = self.config.gaps_between_tabs == 0.; let mut tabs_left = tab_count; - let rects = self.tab_rects(area, count, scale); - for ((shader, loc), (tab, rect)) in zip( - zip(&mut self.shaders, &mut self.shader_locs), - zip(tabs, rects), + let rects = self.tab_rects(area, count, scale).collect::>(); + + if self.title_textures.len() != self.tabs.len() { + self.title_textures = zip(self.tabs.iter(), rects.iter()) + .map(|(t, rect)| { + TitleTexture::new( + t.title.clone(), + scale, + Size::new((rect.size.w - 20.).max(0.), 24.), + self.config.title_font_size, + ) + }) + .collect(); + } else { + izip!( + self.title_textures.iter_mut(), + self.tabs.iter(), + rects.iter(), + ) + .for_each(|(tex, t, rect)| { + tex.update_config( + Some(t.title.clone()), + Some(scale), + Some(Size::new((rect.size.w - MIN_DIST_TO_EDGES).max(0.), 16384.)), + Some(self.config.title_font_size), + ); + }); + } + + for (shader, loc, tab, rect) in izip!( + &mut self.shaders, + &mut self.shader_locs, + &self.tabs, + rects.iter(), ) { *loc = rect.loc; @@ -257,9 +321,9 @@ impl TabIndicator { .find_map(|(idx, rect)| rect.contains(point).then_some(idx)) } - pub fn render( + pub fn render( &self, - renderer: &mut impl NiriRenderer, + renderer: &mut R, pos: Point, ) -> impl Iterator + '_ { let has_border_shader = BorderRenderElement::has_shader(renderer); @@ -267,9 +331,58 @@ impl TabIndicator { return None.into_iter().flatten(); } - let rv = zip(&self.shaders, &self.shader_locs) - .map(move |(shader, loc)| shader.clone().with_location(pos + *loc)) - .map(TabIndicatorRenderElement::from); + let titles = (!self.config.hide_titles).then(|| { + zip(&self.title_textures, &self.shader_locs) + .filter_map(|(tex, loc)| match tex.get(renderer.as_gles_renderer()) { + Ok(texture) => { + let gap_to_bar = 5.; + + let pos_x = (tex.max_size.w + MIN_DIST_TO_EDGES) / 2. + - texture.logical_size().w / 2.; + + let pos_y = match self.config.position { + TabIndicatorPosition::Top => -gap_to_bar, + TabIndicatorPosition::Bottom => gap_to_bar - texture.logical_size().h, + }; + + Some( + PrimaryGpuTextureRenderElement( + TextureRenderElement::from_texture_buffer( + texture, + pos + *loc + Point::new(pos_x, pos_y), + 1., + None, + None, + Kind::Unspecified, + ), + ) + .into(), + ) + } + Err(_) => { + // silent fail is ok, we just won't show the title + None + } + }) + .collect::>() + .into_iter() + }); + + let rv = izip!(&self.shaders, &self.title_textures, &self.shader_locs) + .map(move |(shader, tex, loc)| { + let offset = if !self.config.hide_titles { + match self.config.position { + TabIndicatorPosition::Top => Point::new(0., tex.size().h), + TabIndicatorPosition::Bottom => Point::new(0., -tex.size().h), + } + } else { + Point::default() + }; + + shader.clone().with_location(pos + *loc + offset) + }) + .map(TabIndicatorRenderElement::from) + .chain(titles.into_iter().flatten()); Some(rv).into_iter().flatten() } @@ -283,10 +396,26 @@ impl TabIndicator { let round = |logical: f64| round_logical_in_physical(scale, logical); let width = round(self.config.width); let gap = round(self.config.gap); + let font_height = if !self.config.hide_titles { + // we need an initial approximate value here, because when we first spawn the tab + // indicator, the textures are not yet rendered, but the tile resize animation plays + // immediately. + self.title_textures + .iter() + .fold(self.config.title_font_size as f64, |acc, curr| { + if let Some(texture) = curr.texture.borrow().as_ref() { + texture.logical_size().h.max(acc) + } else { + acc + } + }) + } else { + 0. + }; // No, I am *not* falling into the rabbit hole of "what if the tab indicator is wide enough // that it peeks from the other side of the window". - let size = f64::max(0., width + gap); + let size = f64::max(0., width + gap + font_height); Size::from((0., size)) } @@ -305,14 +434,17 @@ impl TabIndicator { } impl TabInfo { - pub fn from_tile( - tile: &Tile, - position: Point, + #[allow(clippy::too_many_arguments)] + pub fn new( + window: &W, + focus_ring_config: &niri_config::FocusRing, + border_config: &niri_config::FocusRing, is_active: bool, is_urgent: bool, config: &niri_config::TabIndicator, + tile_size: Size, ) -> Self { - let rules = tile.focused_window().rules(); + let rules = window.rules(); let rule = rules.tab_indicator; let gradient_from_rule = || { @@ -342,8 +474,6 @@ impl TabInfo { let gradient_from_border = || { // Come up with tab indicator gradient matching the focus ring or the border, whichever // one is enabled. - let focus_ring_config = tile.focus_ring().config(); - let border_config = tile.border().config(); let config = if focus_ring_config.off { border_config } else { @@ -364,8 +494,174 @@ impl TabInfo { .or_else(gradient_from_config) .unwrap_or_else(gradient_from_border); - let geometry = Rectangle::new(position, tile.animated_tile_size()); + let geometry = Rectangle::new(Point::default(), tile_size); - TabInfo { gradient, geometry } + TabInfo { + gradient, + geometry, + title: window.title().unwrap_or_default(), + } } } + +impl TitleTexture { + fn new(title: String, scale: f64, max_size: Size, font_size: u32) -> Self { + Self { + title, + scale, + texture: Default::default(), + max_size, + wanted_size: Default::default(), + font_size, + } + } + + fn update_config( + &mut self, + new_title: Option, + new_scale: Option, + new_max_size: Option>, + new_font_size: Option, + ) { + if let Some(new_font_size) = new_font_size { + if new_font_size != self.font_size { + self.texture.set(None); + self.wanted_size.set(None); + } + self.font_size = new_font_size; + } + if let Some(new_title) = new_title { + if new_title != self.title { + self.texture.set(None); + self.wanted_size.set(None); + } + self.title = new_title; + } + + if let Some(new_scale) = new_scale { + if new_scale != self.scale { + self.texture.set(None); + self.wanted_size.set(None); + } + self.scale = new_scale; + } + + if let Some(new_max_size) = new_max_size { + if new_max_size != self.max_size { + // if we have a size adjustment, we only need to re-render if either: + // a) the texture's wanted size is larger than the current max size _and_ the new + // max size is larger + // b) the new max size is smaller than the current texture + // + // otherwise the texture will still fully fit within the current allocated space + let should_dirty = if let (Some(texture), Some(wanted_size)) = ( + self.texture.borrow().as_ref(), + self.wanted_size.borrow().as_ref(), + ) { + let wanted_size = wanted_size.to_f64().to_logical(self.scale); + let tex_size = texture.logical_size(); + (wanted_size.w >= self.max_size.w && new_max_size.w > self.max_size.w) + || (wanted_size.h >= self.max_size.h && new_max_size.h > self.max_size.h) + || (tex_size.w > new_max_size.w) + || (tex_size.h > new_max_size.h) + } else { + true + }; + + if should_dirty { + self.texture.set(None); + self.wanted_size.set(None); + } + } + self.max_size = new_max_size; + } + } + + fn get(&self, renderer: &mut GlesRenderer) -> anyhow::Result> { + let mut tex = self.texture.borrow_mut(); + + if self.title.is_empty() { + return Err(anyhow::anyhow!( + "cannot render title texture if title is empty" + )); + } + + match &*tex { + Some(texture) => Ok(texture.clone()), + None => { + let (new_tex, wanted_size) = render_title_texture( + renderer, + &self.title, + self.scale, + self.max_size, + self.font_size, + )?; + *tex = Some(new_tex.clone()); + self.wanted_size.set(Some(wanted_size)); + Ok(new_tex) + } + } + } + + fn size(&self) -> Size { + self.texture + .borrow() + .as_ref() + .map(|tex| tex.logical_size()) + .unwrap_or_default() + } +} + +fn render_title_texture( + renderer: &mut GlesRenderer, + title: &str, + scale: f64, + max_size: Size, + font_size: u32, +) -> anyhow::Result<(TextureBuffer, Size)> { + let _span = tracy_client::span!("tab_indicator::render_title_texture"); + + // TODO: expose in config + let mut font = FontDescription::from_string(&format!("sans {font_size}px")); + font.set_absolute_size(to_physical_precise_round(scale, font.size())); + + let surface = ImageSurface::create(cairo::Format::ARgb32, 0, 0)?; + let cr = cairo::Context::new(&surface)?; + let layout = pangocairo::functions::create_layout(&cr); + layout.context().set_round_glyph_positions(false); + + layout.set_single_paragraph_mode(true); + layout.set_font_description(Some(&font)); + layout.set_text(title); + + let (width, height) = layout.pixel_size(); + let wanted_size = Size::new(width, height); + + // Guard against overly long window titles. + let max_size = max_size.to_physical_precise_round(scale); + let width = min(width, max_size.w); + let height = min(height, max_size.h); + + ensure!(width > 0 && height > 0); + + let surface = ImageSurface::create(cairo::Format::ARgb32, width, height)?; + let cr = cairo::Context::new(&surface)?; + cr.set_source_rgb(1., 1., 1.); + pangocairo::functions::show_layout(&cr, &layout); + + drop(cr); + + let data = surface.take_data().unwrap(); + let buffer = TextureBuffer::from_memory( + renderer, + &data, + Fourcc::Argb8888, + (width, height), + false, + scale, + Transform::Normal, + Vec::new(), + )?; + + Ok((buffer, wanted_size)) +} diff --git a/src/layout/tests/animations.rs b/src/layout/tests/animations.rs index 3bf90af72..b08be0cc4 100644 --- a/src/layout/tests/animations.rs +++ b/src/layout/tests/animations.rs @@ -842,7 +842,7 @@ fn appear_group_indicator() { // when initiating the tab spawn animation, the tile should have a slight offset in the // beginning - assert_snapshot!(format_tiles(&layout), @"100 × 100 at x: 0 y: -9"); + assert_snapshot!(format_tiles(&layout), @"100 × 100 at x: 0 y:-20"); let ops = [Op::AdvanceAnimations { msec_delta: 1000 }]; @@ -901,7 +901,7 @@ fn move_window_into_and_out_of_group_down() { // y on the ejected window should be slightly positive due to the tab indicator offset assert_snapshot!(format_tiles(&layout), @r" 100 × 100 at x: 0 y: 0 - 100 × 100 at x: 0 y: 14 + 100 × 100 at x: 0 y: 26 "); let ops = [Op::CompleteAnimations]; @@ -913,7 +913,7 @@ fn move_window_into_and_out_of_group_down() { // grouped tiles have a larger bounding box) assert_snapshot!(format_tiles(&layout), @r" 100 × 100 at x: 0 y: 0 - 100 × 100 at x: 0 y:109 + 100 × 100 at x: 0 y:121 "); let ops = [Op::FocusWindowUp, Op::ToggleGroup, Op::CompleteAnimations]; @@ -976,7 +976,7 @@ fn move_window_into_and_out_of_group_up() { // y on the ejected window should be slightly positive due to the tab indicator offset assert_snapshot!(format_tiles(&layout), @r" 100 × 100 at x: 0 y: 5 - 100 × 100 at x: 0 y: 9 + 100 × 100 at x: 0 y: 20 "); let ops = [Op::CompleteAnimations]; @@ -1041,7 +1041,7 @@ fn move_window_into_and_out_of_group_right() { // important: the x difference here should be the same as in the "left" variant of this test. assert_snapshot!(format_tiles(&layout), @r" 100 × 100 at x: 0 y: 0 - 100 × 100 at x: 5 y: 9 + 100 × 100 at x: 5 y: 20 "); let ops = [Op::CompleteAnimations]; @@ -1106,7 +1106,7 @@ fn move_window_into_and_out_of_group_left() { // important: the x difference here should be the same as in the "right" variant of this test. assert_snapshot!(format_tiles(&layout), @r" 100 × 100 at x: 41 y: 0 - 100 × 100 at x: 36 y: 9 + 100 × 100 at x: 36 y: 20 "); let ops = [Op::CompleteAnimations]; diff --git a/src/layout/tile.rs b/src/layout/tile.rs index 98c25dac1..0cedd10e7 100644 --- a/src/layout/tile.rs +++ b/src/layout/tile.rs @@ -850,35 +850,36 @@ impl Tile { match &self.window { WindowInner::Single(_) => { self.tab_indicator.update_render_elements( + vec![], false, - Rectangle::new(Point::default(), self.tile_bounding_box()), + Rectangle::new(Point::default(), self.animated_bounding_box()), view_rect, - 1, - std::iter::empty(), is_active, self.scale, ); } WindowInner::Multiple { windows, focus_idx } => { + let tabs = windows + .iter() + .enumerate() + .map(|(idx, w)| { + TabInfo::new( + w, + self.focus_ring().config(), + self.border().config(), + idx == *focus_idx, + w.is_urgent(), + &self.tab_indicator.config(), + self.animated_tile_size(), + ) + }) + .collect(); + self.tab_indicator.update_render_elements( + tabs, true, - Rectangle::new(Point::default(), self.tile_bounding_box()), + Rectangle::new(Point::default(), self.animated_bounding_box()), view_rect, - windows.len(), - windows - .iter() - .enumerate() - .map(|(idx, w)| { - TabInfo::from_tile( - self, - Point::default(), - idx == *focus_idx, - w.is_urgent(), - &self.tab_indicator.config(), - ) - }) - .collect::>() - .into_iter(), is_active, self.scale, ); @@ -1082,7 +1083,7 @@ impl Tile { let out = self.window.ungroup_single(id); if matches!(&self.window, WindowInner::Single(_)) && extra_size.h > 0. { - self.animate_move_from(Point::new(0., extra_size.h)); + self.animate_move_from(self.tab_indicator_content_offset()); } self.focused_window_mut() @@ -1096,7 +1097,7 @@ impl Tile { self.window.group(); if will_group { - self.animate_move_from(Point::new(0., -self.tab_indicator_extra_size().h)); + self.animate_move_from(Point::new(0., 0.) - self.tab_indicator_content_offset()); } } @@ -1139,7 +1140,7 @@ impl Tile { let extra_size = self.tab_indicator_extra_size(); if extra_size.h > 0. { - self.animate_move_from(Point::new(0., extra_size.h)); + self.animate_move_from(self.tab_indicator_content_offset()); } self.window.ungroup_all( @@ -1292,11 +1293,11 @@ impl Tile { } pub fn tile_bounding_box(&self) -> Size { - let mut size = self.tile_size(); + self.tile_size() + self.tab_indicator_extra_size() + } - size += self.tab_indicator_extra_size(); - - size + pub fn animated_bounding_box(&self) -> Size { + self.animated_tile_size() + self.tab_indicator_extra_size() } pub fn tile_expected_or_current_size(&self) -> Size { @@ -1953,7 +1954,7 @@ impl Tile { match open.render( renderer, &elements, - self.animated_tile_size(), + self.animated_bounding_box(), location, scale, tile_alpha, @@ -2035,7 +2036,7 @@ impl Tile { contents: contents.collect(), blocked_out_contents: blocked_out_contents.collect(), block_out_from: self.window.focused_window().rules().block_out_from, - size: self.animated_tile_size(), + size: self.animated_bounding_box(), texture: Default::default(), blocked_out_texture: Default::default(), } diff --git a/src/window/mapped.rs b/src/window/mapped.rs index 4ee98d603..eba507c0d 100644 --- a/src/window/mapped.rs +++ b/src/window/mapped.rs @@ -1368,4 +1368,8 @@ impl LayoutElement for Mapped { } }); } + + fn title(&self) -> Option { + with_toplevel_role(self.toplevel(), |role| role.title.clone()) + } }