Something went wrong. Try again.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334use niri_config::utils::MergeWith as _;use niri_config::{Config, LayerRule};use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;use smithay::backend::renderer::element::Kind;use smithay::desktop::{LayerSurface, PopupKind, PopupManager};use smithay::utils::{Logical, Point, Rectangle, Scale, Size};use smithay::wayland::compositor::{remove_pre_commit_hook, HookId};use smithay::wayland::shell::wlr_layer::{ExclusiveZone, Layer};
use super::ResolvedLayerRules;use crate::animation::Clock;use crate::layout::shadow::Shadow;use crate::niri_render_elements;use crate::render_helpers::background_effect::BackgroundEffectElement;use crate::render_helpers::renderer::NiriRenderer;use crate::render_helpers::shadow::ShadowRenderElement;use crate::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};use crate::render_helpers::surface::push_elements_from_surface_tree;use crate::render_helpers::xray::XrayPos;use crate::render_helpers::{background_effect, RenderCtx};use crate::utils::{baba_is_float_offset, round_logical_in_physical};
#[derive(Debug)]pub struct MappedLayer { /// The surface itself. surface: LayerSurface,
/// Pre-commit hook that we have on all mapped layer surfaces. pre_commit_hook: HookId,
/// Up-to-date rules. rules: ResolvedLayerRules,
/// Whether to recompute layer rules on the next commit. /// /// Set in the pre-commit hook when the layer changes; consumed in the commit handler. recompute_rules_on_commit: bool,
/// Buffer to draw instead of the surface when it should be blocked out. block_out_buffer: SolidColorBuffer,
/// The shadow around the surface. shadow: Shadow,
/// The blur config, passed for background effect rendering. blur_config: niri_config::Blur,
/// The view size for the layer surface's output. view_size: Size<f64, Logical>,
/// Scale of the output the layer surface is on (and rounds its sizes to). scale: f64,
/// Clock for driving animations. clock: Clock,}
niri_render_elements! { LayerSurfaceRenderElement<R> => { Wayland = WaylandSurfaceRenderElement<R>, SolidColor = SolidColorRenderElement, Shadow = ShadowRenderElement, BackgroundEffect = BackgroundEffectElement, }}
impl MappedLayer { pub fn new( surface: LayerSurface, pre_commit_hook: HookId, rules: ResolvedLayerRules, view_size: Size<f64, Logical>, scale: f64, clock: Clock, config: &Config, ) -> Self { let mut shadow_config = config.layout.shadow; // Shadows for layer surfaces need to be explicitly enabled. shadow_config.on = false; shadow_config.merge_with(&rules.shadow);
Self { surface, pre_commit_hook, rules, recompute_rules_on_commit: false, block_out_buffer: SolidColorBuffer::new((0., 0.), [0., 0., 0., 1.]), view_size, scale, shadow: Shadow::new(shadow_config), blur_config: config.blur, clock, } }
pub fn update_config(&mut self, config: &Config) { let mut shadow_config = config.layout.shadow; // Shadows for layer surfaces need to be explicitly enabled. shadow_config.on = false; shadow_config.merge_with(&self.rules.shadow); self.shadow.update_config(shadow_config);
self.blur_config = config.blur; }
pub fn update_shaders(&mut self) { self.shadow.update_shaders(); }
pub fn update_sizes(&mut self, view_size: Size<f64, Logical>, scale: f64) { self.view_size = view_size; self.scale = scale; }
pub fn update_render_elements(&mut self, size: Size<f64, Logical>) { // Round to physical pixels. let size = size .to_physical_precise_round(self.scale) .to_logical(self.scale);
self.block_out_buffer.resize(size);
let radius = self.rules.geometry_corner_radius.unwrap_or_default(); // FIXME: is_active based on keyboard focus? self.shadow .update_render_elements(size, true, radius, self.scale, 1.); }
pub fn are_animations_ongoing(&self) -> bool { self.rules.baba_is_float }
pub fn surface(&self) -> &LayerSurface { &self.surface }
pub fn rules(&self) -> &ResolvedLayerRules { &self.rules }
/// Recomputes the resolved layer rules and returns whether they changed. pub fn recompute_layer_rules(&mut self, rules: &[LayerRule], is_at_startup: bool) -> bool { let new_rules = ResolvedLayerRules::compute(rules, &self.surface, is_at_startup); if new_rules == self.rules { return false; }
self.rules = new_rules; true }
pub fn set_recompute_rules_on_commit(&mut self) { self.recompute_rules_on_commit = true; }
pub fn take_recompute_rules_on_commit(&mut self) -> bool { std::mem::take(&mut self.recompute_rules_on_commit) }
pub fn place_within_backdrop(&self) -> bool { if !self.rules.place_within_backdrop { return false; }
if self.surface.layer() != Layer::Background { return false; }
let state = self.surface.cached_state(); if state.exclusive_zone != ExclusiveZone::DontCare { return false; }
true }
pub fn bob_offset(&self) -> Point<f64, Logical> { if !self.rules.baba_is_float { return Point::from((0., 0.)); }
let y = baba_is_float_offset(self.clock.now(), self.view_size.h); let y = round_logical_in_physical(self.scale, y); Point::from((0., y)) }
pub fn render_normal<R: NiriRenderer>( &self, mut ctx: RenderCtx<R>, ns: Option<usize>, location: Point<f64, Logical>, xray_pos: XrayPos, push: &mut dyn FnMut(LayerSurfaceRenderElement<R>), ) { let scale = Scale::from(self.scale); let alpha = self.rules.opacity.unwrap_or(1.).clamp(0., 1.);
let bob_offset = self.bob_offset(); let location = location + bob_offset; let xray_pos = xray_pos.offset(bob_offset);
let surface = self.surface.wl_surface();
let should_block_out = ctx.target.should_block_out(self.rules.block_out_from); if should_block_out { // Round to physical pixels. let location = location.to_physical_precise_round(scale).to_logical(scale);
// FIXME: take geometry-corner-radius into account. let elem = SolidColorRenderElement::from_buffer( &self.block_out_buffer, location, alpha, Kind::Unspecified, ); push(elem.into()); } else { // Layer surfaces don't have extra geometry like windows. let buf_pos = location;
push_elements_from_surface_tree( ctx.renderer, surface, buf_pos.to_physical_precise_round(scale), scale, alpha, Kind::ScanoutCandidate, &mut |elem| push(elem.into()), ); }
let location = location.to_physical_precise_round(scale).to_logical(scale); self.shadow .render(ctx.renderer, location, &mut |elem| push(elem.into()));
let geometry = Rectangle::new(location, self.block_out_buffer.size()); let surface_off = Point::new(0., 0.); // No geometry on layer surfaces. let surface_anim_scale = Scale::from(1.); let radius = self.rules.geometry_corner_radius.unwrap_or_default(); background_effect::render_for_tile( ctx.as_gles(), ns, geometry, self.scale, false, surface, surface_off, surface_anim_scale, self.blur_config, radius, self.rules.background_effect, should_block_out, xray_pos, &mut |elem| push(elem.into()), ); }
pub fn render_popups<R: NiriRenderer>( &self, mut ctx: RenderCtx<R>, ns: Option<usize>, location: Point<f64, Logical>, xray_pos: XrayPos, push: &mut dyn FnMut(LayerSurfaceRenderElement<R>), ) { if ctx.target.should_block_out(self.rules.block_out_from) { return; }
let scale = Scale::from(self.scale); let alpha = self.rules.opacity.unwrap_or(1.).clamp(0., 1.);
let bob_offset = self.bob_offset(); let location = location + bob_offset; let xray_pos = xray_pos.offset(bob_offset);
let surface = self.surface.wl_surface(); for (popup, offset) in PopupManager::popups_for_surface(surface) { let popup_rules = match popup { PopupKind::Xdg(_) => self.rules.popups, // IME popups aren't affected by rules for regular popups. PopupKind::InputMethod(_) => niri_config::ResolvedPopupsRules::default(), }; let alpha = alpha * popup_rules.opacity.unwrap_or(1.).clamp(0., 1.);
let surface = popup.wl_surface(); let popup_geo = popup.geometry(); let surface_loc = location + (offset - popup_geo.loc).to_f64();
push_elements_from_surface_tree( ctx.renderer, surface, surface_loc.to_physical_precise_round(scale), scale, alpha, Kind::ScanoutCandidate, &mut |elem| push(elem.into()), );
let geometry = Rectangle::new(location + offset.to_f64(), popup_geo.size.to_f64()); let surface_off = popup_geo.loc.upscale(-1).to_f64(); let surface_anim_scale = Scale::from(1.); let mut effect = popup_rules.background_effect; // Default xray to false for pop-ups since they're always on top of something. if effect.xray.is_none() { effect.xray = Some(false); } let xray_pos = xray_pos.offset(offset.to_f64()); background_effect::render_for_tile( ctx.as_gles(), ns, geometry, self.scale, false, surface, surface_off, surface_anim_scale, self.blur_config, popup_rules.geometry_corner_radius.unwrap_or_default(), effect, false, xray_pos, &mut |elem| push(elem.into()), ); } }}
impl Drop for MappedLayer { fn drop(&mut self) { remove_pre_commit_hook(self.surface.wl_surface(), &self.pre_commit_hook); }}