use crate::client::Client;
use crate::client::ClientId;
use crate::criteria::CritDestroyListener;
use crate::criteria::CritMatcherId;
use crate::criteria::tlm::TL_CHANGED_APP_ID;
use crate::criteria::tlm::TL_CHANGED_CONTENT_TY;
use crate::criteria::tlm::TL_CHANGED_DESTROYED;
use crate::criteria::tlm::TL_CHANGED_FLOATING;
use crate::criteria::tlm::TL_CHANGED_FULLSCREEN;
use crate::criteria::tlm::TL_CHANGED_IS_WORKSPACE_CONTAINER;
use crate::criteria::tlm::TL_CHANGED_NEW;
use crate::criteria::tlm::TL_CHANGED_TITLE;
use crate::criteria::tlm::TL_CHANGED_URGENT;
use crate::criteria::tlm::TL_CHANGED_VISIBLE;
use crate::criteria::tlm::TL_CHANGED_WORKSPACE;
use crate::criteria::tlm::TlMatcherChange;
use crate::ifs::ext_foreign_toplevel_handle_v1::ExtForeignToplevelHandleV1;
use crate::ifs::ext_foreign_toplevel_list_v1::ExtForeignToplevelListV1;
use crate::ifs::ext_image_copy::ext_image_copy_capture_session_v1::ExtImageCopyCaptureSessionV1;
use crate::ifs::jay_screencast::JayScreencast;
use crate::ifs::jay_toplevel::JayToplevel;
use crate::ifs::wl_seat::NodeSeatState;
use crate::ifs::wl_seat::SeatId;
use crate::ifs::wl_seat::collect_kb_foci;
use crate::ifs::wl_surface::WlSurface;
use crate::ifs::wl_surface::icon_surface::jay_icon_surface_factory_v1::JayIconSurfaceFactoryV1;
use crate::ifs::wl_surface::x_surface::xwindow::XwindowData;
use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevelToplevelData;
use crate::ifs::wp_content_type_v1::ContentType;
use crate::ifs::zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1;
use crate::ifs::zwlr_foreign_toplevel_manager_v1::ZwlrForeignToplevelManagerV1;
use crate::rect::Rect;
use crate::sm::ToplevelSession;
use crate::state::ConnectorData;
use crate::state::OutputEventListener;
use crate::state::State;
use crate::theme::ToplevelTheme;
use crate::tree::ContainerNode;
use crate::tree::ContainerSplit;
use crate::tree::ContainerTarget;
use crate::tree::ContainingNode;
use crate::tree::Direction;
use crate::tree::FloatNode;
use crate::tree::Node;
use crate::tree::NodeBase;
use crate::tree::NodeId;
use crate::tree::NodeLayerLink;
use crate::tree::OutputNode;
use crate::tree::PlaceholderNode;
use crate::tree::SplitView;
use crate::tree::ToplevelThemeType::ParentTheme;
use crate::tree::ToplevelThemeType::SelfTheme;
use crate::tree::TreeTimeline;
use crate::tree::TreeTimeline::LiveTL;
use crate::tree::TreeTimeline::RenderTL;
use crate::tree::WorkspaceEventListener;
use crate::tree::WorkspaceNode;
use crate::tree::WorkspaceType;
use crate::utils::array_to_tuple::ArrayToTuple;
use crate::utils::as_double_deref::AsDoubleDeref;
use crate::utils::box_cache::BoxUninit;
use crate::utils::box_cache::CachedBox;
use crate::utils::clonecell::CloneCell;
use crate::utils::copyhashmap::CopyHashMap;
use crate::utils::event_listener::EventListener;
use crate::utils::hash_map_ext::HashMapExt;
use crate::utils::lazy_event_source::LazyEventSource;
use crate::utils::liveness::GetLiveness;
use crate::utils::liveness::Liveness;
use crate::utils::numcell::NumCell;
use crate::utils::rc_eq::rc_eq;
use crate::utils::threshold_counter::ThresholdCounter;
use crate::wire::ExtForeignToplevelHandleV1Id;
use crate::wire::ExtImageCopyCaptureSessionV1Id;
use crate::wire::JayScreencastId;
use crate::wire::JayToplevelId;
use crate::wire::ZwlrForeignToplevelHandleV1Id;
use jay_config::window;
use jay_config::window::WindowType;
use jay_proc::GetLiveness;
use linearize::Linearize;
use linearize::StaticMap;
use std::borrow::Borrow;
use std::cell::Cell;
use std::cell::OnceCell;
use std::cell::RefCell;
use std::ops::Deref;
use std::rc::Rc;
use std::rc::Weak;
mod toplevel_dfs_g_fuse;
opaque!(ToplevelIdentifier, toplevel_identifier);
tree_id!(ToplevelNodeId);
pub trait ToplevelNode: ToplevelNodeBase {
fn tl_surface_active_changed(&self, active: bool);
fn tl_set_fullscreen(self: Rc<Self>, fullscreen: bool, ws: Option<Rc<WorkspaceNode>>);
fn tl_title_changed(&self);
fn tl_set_parent(&self, parent: Rc<dyn ContainingNode>);
fn tl_extents_changed(&self);
fn tl_set_workspace(&self, ws: &Rc<WorkspaceNode>);
fn tl_change_extents(self: Rc<Self>, rect: &Rect);
fn tl_set_visible(&self, visible: bool);
fn tl_destroy(self: &Rc<Self>)
where
Self: Sized;
fn tl_destroy_dyn(self: Rc<Self>);
fn tl_pinned(&self) -> bool;
fn tl_set_pinned(&self, self_pinned: bool, pinned: bool);
fn tl_set_float(&self, float: Option<&Rc<FloatNode>>);
fn tl_mark_ancestor_fullscreen(&self, fullscreen: bool);
fn tl_mark_fullscreen(&self, connector: Option<&Rc<ConnectorData>>);
fn tl_resize(&self, dx1: i32, dy1: i32, dx2: i32, dy2: i32);
}
impl<T: ToplevelNodeBase> ToplevelNode for T {
fn tl_surface_active_changed(&self, active: bool) {
let data = self.tl_data();
data.update_active(self, || {
data.active_surfaces.adj(active);
});
}
fn tl_set_fullscreen(self: Rc<Self>, fullscreen: bool, ws: Option<Rc<WorkspaceNode>>) {
let data = self.tl_data();
if fullscreen {
if let Some(ws) = ws.or_else(|| data.workspace[LiveTL].get()) {
data.set_fullscreen(&data.state, self.clone(), &ws);
}
} else {
data.unset_fullscreen(&data.state, self.clone());
}
}
fn tl_title_changed(&self) {
let data = self.tl_data();
let title = data.title.borrow_mut();
if let Some(parent) = data.parent.get() {
parent.node_child_title_changed(self, &title);
}
if let Some(data) = data.fullscrceen_data.borrow_mut().deref() {
data.placeholder
.tl_data()
.title
.borrow_mut()
.clone_from(&title);
data.placeholder.tl_title_changed();
}
data.property_changed(TL_CHANGED_TITLE);
}
fn tl_set_parent(&self, parent: Rc<dyn ContainingNode>) {
let data = self.tl_data();
if !data.is_fullscreen[LiveTL].get() {
self.tl_mark_ancestor_fullscreen(parent.cnode_self_or_ancestor_fullscreen());
}
let mut is_root_container = false;
let mut is_overlay_root_container = false;
if let ToplevelType::Container = data.kind
&& let Some(ws) = parent.clone().node_into_workspace()
{
is_root_container = true;
is_overlay_root_container = ws.ty == WorkspaceType::Overlay;
}
data.set_is_root_container(is_root_container, is_overlay_root_container);
let parent_was_none = data.parent.set(Some(parent.clone())).is_none();
if parent_was_none {
data.mapped_during_iteration.set(data.state.eng.iteration());
data.property_changed(TL_CHANGED_NEW);
}
let was_floating = data.parent_is_float.get();
let is_floating = parent.node_is_float();
data.parent_is_float.set(is_floating);
self.tl_set_workspace(&parent.clone().cnode_workspace());
if was_floating != is_floating {
data.property_changed(TL_CHANGED_FLOATING);
if let Some(session) = data.session.get() {
session.set_float_pos(data);
}
}
{
let float = parent.cnode_get_float();
let prev = data.float.set(float.clone());
let same = match (&prev, &float) {
(None, None) => true,
(Some(prev), Some(float)) => rc_eq(prev, float),
_ => false,
};
if !same {
self.tl_push_float(float.as_ref());
}
}
}
fn tl_extents_changed(&self) {
let data = self.tl_data();
if let Some(parent) = data.parent.get() {
let pos = data.content_size.get();
parent.node_child_size_changed(self, pos.width(), pos.height());
data.state.tree_changed();
}
}
fn tl_set_workspace(&self, ws: &Rc<WorkspaceNode>) {
let data = self.tl_data();
data.workspace_type[LiveTL].set(Some(ws.ty));
let prev = data.workspace[LiveTL].set(Some(ws.clone()));
data.schedule_op(ToplevelDataTransactionOp::SetWorkspace(Some(ws.clone())));
data.workspace_listener.attach(&ws.listeners);
self.tl_set_workspace_ext(ws);
self.tl_data().property_changed(TL_CHANGED_WORKSPACE);
if let Some(session) = data.session.get() {
session.set_workspace(ws, data);
}
let prev_output = match &prev {
Some(n) => n.node_state[LiveTL].output.get(),
_ => ws.state.dummy_output.get().unwrap(),
};
let new_output = ws.node_state[LiveTL].output.get();
if prev.is_none() || prev_output.id != new_output.id {
data.workspace_output_changed(&prev_output, &new_output);
data.output_listener
.attach(&new_output.global.connector.listeners);
}
}
fn tl_change_extents(self: Rc<Self>, rect: &Rect) {
let data = self.tl_data();
let prev = data.desired_extents.replace(*rect);
if prev.size() != rect.size() {
for sc in data.jay_screencasts.lock().values() {
sc.schedule_realloc_or_reconfigure();
}
for sc in data.ext_copy_sessions.lock().values() {
sc.buffer_size_changed();
}
}
if data.parent_is_float.get() {
data.float_width.set(rect.width());
data.float_height.set(rect.height());
if let Some(session) = data.session.get() {
session.set_float_pos(data);
}
}
self.tl_change_extents_impl(rect);
}
fn tl_set_visible(&self, visible: bool) {
self.tl_set_visible_impl(visible);
self.tl_data().set_visible(self, visible);
}
fn tl_destroy(self: &Rc<Self>) {
self.tl_data().destroy_node(&**self);
self.tl_destroy_impl();
}
fn tl_destroy_dyn(self: Rc<Self>) {
self.tl_destroy();
}
fn tl_pinned(&self) -> bool {
let Some(parent) = self.tl_data().parent.get() else {
return false;
};
parent.cnode_pinned()
}
fn tl_set_pinned(&self, self_pinned: bool, pinned: bool) {
let data = self.tl_data();
if self_pinned {
data.pinned.set(pinned);
}
let Some(parent) = data.parent.get() else {
return;
};
parent.cnode_set_pinned(pinned);
}
fn tl_set_float(&self, float: Option<&Rc<FloatNode>>) {
self.tl_data().float.set(float.cloned());
self.tl_push_float(float);
}
fn tl_mark_ancestor_fullscreen(&self, fullscreen: bool) {
let old = self
.tl_data()
.self_or_ancestor_is_fullscreen
.replace(fullscreen);
if old == fullscreen {
return;
}
self.tl_mark_ancestor_fullscreen_ext(fullscreen);
}
fn tl_mark_fullscreen(&self, connector: Option<&Rc<ConnectorData>>) {
let fullscreen = connector.is_some();
self.tl_data().is_fullscreen[LiveTL].set(fullscreen);
self.tl_data()
.schedule_op(ToplevelDataTransactionOp::SetIsFullscreen(fullscreen));
self.tl_mark_ancestor_fullscreen(fullscreen);
self.tl_mark_fullscreen_ext();
if let Some(session) = self.tl_data().session.get() {
session.set_fullscreen(fullscreen);
}
if let Some(surface) = self.tl_surface() {
surface.mark_fullscreen(connector);
}
}
fn tl_resize(&self, dx1: i32, dy1: i32, dx2: i32, dy2: i32) {
let Some(parent) = self.tl_data().parent.get() else {
return;
};
let pos = self.node_absolute_position(LiveTL);
let x1 = (dx1 != 0).then_some(pos.x1().saturating_add(dx1));
let y1 = (dy1 != 0).then_some(pos.y1().saturating_add(dy1));
let x2 = (dx2 != 0).then_some(pos.x2().saturating_add(dx2));
let y2 = (dy2 != 0).then_some(pos.y2().saturating_add(dy2));
parent.cnode_resize_child(self, x1, y1, x2, y2);
}
}
pub trait ToplevelNodeBase:
OutputEventListener + WorkspaceEventListener + Node + GetLiveness
{
fn tl_data(&self) -> &ToplevelData;
fn tl_accepts_keyboard_focus(&self) -> bool {
true
}
fn tl_set_active(&self, active: bool) {
let _ = active;
}
fn tl_focus_child(&self) -> Option<Rc<dyn Node>> {
None
}
fn tl_set_workspace_ext(&self, ws: &Rc<WorkspaceNode>) {
let _ = ws;
}
fn tl_change_extents_impl(self: Rc<Self>, rect: &Rect);
fn tl_is_root_container_changed(self: Rc<Self>) {}
fn tl_close(self: Rc<Self>);
fn tl_set_visible_impl(&self, visible: bool);
fn tl_destroy_impl(self: &Rc<Self>)
where
Self: Sized;
fn tl_last_active_child(self: Rc<Self>) -> Rc<dyn ToplevelNode>;
fn tl_surface(&self) -> Option<Rc<WlSurface>> {
None
}
fn tl_restack_popups(&self) {
}
fn tl_admits_children(&self) -> bool;
fn tl_tile_drag_destination(
self: Rc<Self>,
source: NodeId,
split: Option<ContainerSplit>,
abs_bounds: Rect,
abs_x: i32,
abs_y: i32,
) -> Option<TileDragDestination>;
fn tl_tile_drag_bounds(&self, split: ContainerSplit, start: bool) -> i32 {
let _ = start;
default_tile_drag_bounds(self, split)
}
fn tl_render_bounds(&self) -> Option<Rect> {
self.tl_data()
.parent
.is_some()
.then_some(self.node_absolute_position(RenderTL))
}
fn tl_push_float(&self, float: Option<&Rc<FloatNode>>) {
let _ = float;
}
fn tl_mark_ancestor_fullscreen_ext(&self, fullscreen: bool) {
let _ = fullscreen;
}
fn tl_mark_fullscreen_ext(&self) {
}
fn tl_icon_surface_factory(&self) -> Option<Rc<JayIconSurfaceFactoryV1>> {
None
}
fn tl_schedule_data_op(self: Rc<Self>, op: ToplevelDataTransactionOp);
fn tl_theme_changed(self: Rc<Self>) {
}
}
pub enum ToplevelDataTransactionOp {
SetIsFullscreen(bool),
SetWorkspace(Option<Rc<WorkspaceNode>>),
SetVisible(bool),
SetIsRootContainer(bool, bool),
}
pub struct FullscreenedData {
placeholder: Rc<PlaceholderNode>,
workspace: Rc<WorkspaceNode>,
}
#[derive(Clone)]
pub struct ToplevelOpt {
toplevel: Weak<dyn ToplevelNode>,
identifier: ToplevelIdentifier,
}
impl ToplevelOpt {
pub fn get(&self) -> Option<Rc<dyn ToplevelNode>> {
let tl = self.toplevel.upgrade()?;
if tl.tl_data().identifier.get() == self.identifier {
Some(tl)
} else {
None
}
}
}
pub enum ToplevelType {
Container,
Placeholder(Option<ToplevelIdentifier>),
XdgToplevel(Rc<XdgToplevelToplevelData>),
XWindow(Rc<XwindowData>),
}
impl ToplevelType {
pub fn to_window_type(&self) -> WindowType {
match self {
ToplevelType::Container => window::CONTAINER,
ToplevelType::Placeholder { .. } => window::PLACEHOLDER,
ToplevelType::XdgToplevel { .. } => window::XDG_TOPLEVEL,
ToplevelType::XWindow { .. } => window::X_WINDOW,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Linearize)]
pub enum ToplevelThemeType {
ParentTheme,
SelfTheme,
}
#[derive(GetLiveness)]
pub struct ToplevelData {
pub node_id: NodeId,
pub kind: ToplevelType,
self_active: Cell<bool>,
pub client: Option<Rc<Client>>,
pub state: Rc<State>,
pub active_surfaces: ThresholdCounter,
pub visible: SplitView<Cell<bool>>,
pub parent_is_float: Cell<bool>,
pub float: CloneCell<Option<Rc<FloatNode>>>,
pub float_width: Cell<i32>,
pub float_height: Cell<i32>,
pub min_width: Cell<Option<i32>>,
pub min_height: Cell<Option<i32>>,
pub max_width: Cell<Option<i32>>,
pub max_height: Cell<Option<i32>>,
pub pinned: Cell<bool>,
pub is_fullscreen: SplitView<Cell<bool>>,
pub self_or_ancestor_is_fullscreen: Cell<bool>,
fullscrceen_data: RefCell<Option<FullscreenedData>>,
pub workspace: SplitView<CloneCell<Option<Rc<WorkspaceNode>>>>,
workspace_type: SplitView<Cell<Option<WorkspaceType>>>,
pub title: RefCell<String>,
pub parent: CloneCell<Option<Rc<dyn ContainingNode>>>,
mapped_during_iteration: Cell<u64>,
pub content_size: Cell<Rect>,
pub desired_extents: Cell<Rect>,
pub seat_state: NodeSeatState,
pub wants_attention: Cell<bool>,
requested_attention: Cell<bool>,
pub app_id: RefCell<String>,
pub identifier: Cell<ToplevelIdentifier>,
pub handles:
CopyHashMap<(ClientId, ExtForeignToplevelHandleV1Id), Rc<ExtForeignToplevelHandleV1>>,
pub manager_handles:
CopyHashMap<(ClientId, ZwlrForeignToplevelHandleV1Id), Rc<ZwlrForeignToplevelHandleV1>>,
pub render_highlight: NumCell<u32>,
pub jay_toplevels: CopyHashMap<(ClientId, JayToplevelId), Rc<JayToplevel>>,
pub jay_screencasts: CopyHashMap<(ClientId, JayScreencastId), Rc<JayScreencast>>,
pub ext_copy_sessions:
CopyHashMap<(ClientId, ExtImageCopyCaptureSessionV1Id), Rc<ExtImageCopyCaptureSessionV1>>,
pub slf: Weak<dyn ToplevelNode>,
pub destroyed: CopyHashMap<CritMatcherId, Weak<dyn CritDestroyListener<ToplevelData>>>,
pub changed_properties: Cell<TlMatcherChange>,
pub just_mapped_scheduled: Cell<bool>,
pub seat_foci: CopyHashMap<SeatId, ()>,
pub content_type: Cell<Option<ContentType>>,
property_changed_source: OnceCell<Rc<LazyEventSource>>,
pub session: CloneCell<Option<Rc<ToplevelSession>>>,
pub is_root_container: SplitView<Cell<bool>>,
pub is_overlay_root_container: SplitView<Cell<bool>>,
output_listener: EventListener<dyn OutputEventListener>,
workspace_listener: EventListener<dyn WorkspaceEventListener>,
theme: StaticMap<ToplevelThemeType, OnceCell<CachedBox<ToplevelTheme, BoxUninit>>>,
theme_change_queued: Cell<bool>,
theme_change: StaticMap<ToplevelThemeType, Cell<bool>>,
liveness: Liveness,
}
impl ToplevelData {
pub fn new(
state: &Rc<State>,
title: String,
client: Option<Rc<Client>>,
kind: ToplevelType,
node_id: impl Into<NodeId>,
slf: &Weak<impl ToplevelNode>,
) -> Self {
Self::new_(state, title, client, kind, node_id.into(), slf.clone())
}
fn new_(
state: &Rc<State>,
title: String,
client: Option<Rc<Client>>,
kind: ToplevelType,
node_id: NodeId,
slf: Weak<dyn ToplevelNode>,
) -> Self {
let id = toplevel_identifier();
state.toplevels.set(id, slf.clone());
Self {
node_id,
kind,
self_active: Cell::new(false),
client,
state: state.clone(),
active_surfaces: Default::default(),
visible: Default::default(),
parent_is_float: Default::default(),
float: Default::default(),
float_width: Default::default(),
float_height: Default::default(),
min_width: Default::default(),
min_height: Default::default(),
max_width: Default::default(),
max_height: Default::default(),
pinned: Cell::new(false),
is_fullscreen: Default::default(),
self_or_ancestor_is_fullscreen: Default::default(),
fullscrceen_data: Default::default(),
workspace: Default::default(),
workspace_type: Default::default(),
title: RefCell::new(title),
parent: Default::default(),
mapped_during_iteration: Cell::new(0),
content_size: Default::default(),
desired_extents: Default::default(),
seat_state: Default::default(),
wants_attention: Cell::new(false),
requested_attention: Cell::new(false),
app_id: Default::default(),
identifier: Cell::new(id),
handles: Default::default(),
manager_handles: Default::default(),
render_highlight: Default::default(),
jay_toplevels: Default::default(),
jay_screencasts: Default::default(),
ext_copy_sessions: Default::default(),
slf: slf.clone(),
destroyed: Default::default(),
changed_properties: Default::default(),
just_mapped_scheduled: Cell::new(false),
seat_foci: Default::default(),
content_type: Default::default(),
property_changed_source: Default::default(),
session: Default::default(),
is_root_container: Default::default(),
is_overlay_root_container: Default::default(),
output_listener: EventListener::new(slf.clone()),
workspace_listener: EventListener::new(slf.clone()),
theme: Default::default(),
theme_change_queued: Default::default(),
theme_change: Default::default(),
liveness: Default::default(),
}
}
pub fn active(&self) -> bool {
self.active_surfaces.active() || self.self_active.get()
}
fn update_active<T: ToplevelNode, F: FnOnce()>(&self, tl: &T, f: F) {
let active_old = self.active();
f();
let active_new = self.active();
if active_old != active_new {
tl.tl_set_active(active_new);
if let Some(parent) = self.parent.get() {
parent.node_child_active_changed(tl, active_new, 1);
}
for handle in self.manager_handles.borrow().lock().values() {
handle.send_state(active_new, self.is_fullscreen[LiveTL].get());
handle.send_done();
}
}
}
pub fn update_self_active<T: ToplevelNode>(&self, node: &T, active: bool) {
self.update_active(node, || self.self_active.set(active));
}
pub fn float_size(&self, ws: &WorkspaceNode) -> (i32, i32) {
let output = ws.node_state[LiveTL].output.get().node_state[LiveTL]
.pos
.get();
let mut width = self.float_width.get();
let mut height = self.float_height.get();
if width == 0 {
width = output.width() / 2;
}
if height == 0 {
height = output.height() / 2;
}
macro_rules! constrain {
($val:ident, $min:ident, $max:ident) => {
if let Some(min) = self.$min.get()
&& $val < min
{
$val = min;
} else if let Some(max) = self.$max.get()
&& $val > max
{
$val = max;
}
};
}
constrain!(width, min_width, max_width);
constrain!(height, min_height, max_height);
(width, height)
}
pub fn is_fixed_size_in_any_dimension(&self) -> bool {
macro_rules! check {
($min:ident, $max:ident) => {
if let (Some(min), Some(max)) = (self.$min.get(), self.$max.get())
&& min == max
{
return true;
}
};
}
check!(min_width, max_width);
check!(min_height, max_height);
false
}
fn trigger_property_source(&self) {
if let Some(source) = self.property_changed_source.get() {
source.trigger();
}
}
pub fn property_changed(&self, change: TlMatcherChange) {
self.trigger_property_source();
let mgr = &self.state.tl_matcher_manager;
let props = self.changed_properties.get();
if props.is_none() && mgr.has_no_interest(self, change) {
return;
}
self.changed_properties.set(props | change);
if props.is_none()
&& change.is_some()
&& let Some(node) = self.slf.upgrade()
{
mgr.changed(node);
}
}
fn destroy_node(&self, node: &dyn Node) {
for jay_tl in self.jay_toplevels.lock().drain_values() {
jay_tl.destroy();
}
for screencast in self.jay_screencasts.lock().drain_values() {
screencast.do_destroy();
}
for screencast in self.ext_copy_sessions.lock().drain_values() {
screencast.stop();
}
{
let id = toplevel_identifier();
let prev = self.identifier.replace(id);
self.state.remove_toplevel_id(prev);
self.state.toplevels.set(id, self.slf.clone());
}
{
let mut handles = self.handles.lock();
for handle in handles.drain_values() {
handle.send_closed();
}
}
{
let mut manager_handles = self.manager_handles.lock();
for handle in manager_handles.drain_values() {
handle.send_closed();
}
}
self.detach_node(node);
self.property_changed(TL_CHANGED_DESTROYED);
}
pub fn detach_node(&self, node: &dyn Node) {
if let Some(fd) = self.fullscrceen_data.borrow_mut().take() {
fd.placeholder.tl_destroy();
}
if let Some(parent) = self.parent.take() {
parent.cnode_remove_child(node);
}
self.float.take();
self.workspace[LiveTL].take();
self.workspace_type[LiveTL].take();
self.schedule_op(ToplevelDataTransactionOp::SetWorkspace(None));
self.output_listener.detach();
self.workspace_listener.detach();
self.seat_state.destroy_node(node);
self.set_is_root_container(false, false);
}
pub fn broadcast(&self, toplevel: Rc<dyn ToplevelNode>) {
let id = self.identifier.get().to_string();
let title = self.title.borrow();
let app_id = self.app_id.borrow();
let activated = self.active();
let fullscreen = self.is_fullscreen[LiveTL].get();
let class;
let manager_app_id = match &self.kind {
ToplevelType::XWindow(w) => {
class = w.info.class.borrow();
class.as_deref().unwrap_or_default()
}
_ => &app_id,
};
for list in self.state.toplevel_lists.lock().values() {
self.send_once(&toplevel, list, &id, &title, &app_id);
}
for manager in self.state.toplevel_managers.lock().values() {
self.manager_send_once(
&toplevel,
manager,
&title,
manager_app_id,
activated,
fullscreen,
);
}
}
pub fn send(&self, toplevel: Rc<dyn ToplevelNode>, list: &ExtForeignToplevelListV1) {
let id = self.identifier.get().to_string();
let title = self.title.borrow();
let app_id = self.app_id.borrow();
self.send_once(&toplevel, list, &id, &title, &app_id);
}
fn send_once(
&self,
toplevel: &Rc<dyn ToplevelNode>,
list: &ExtForeignToplevelListV1,
id: &str,
title: &str,
app_id: &str,
) {
let opt = ToplevelOpt {
toplevel: Rc::downgrade(toplevel),
identifier: self.identifier.get(),
};
let handle = list.publish_toplevel(opt);
handle.send_identifier(id);
handle.send_title(title);
handle.send_app_id(app_id);
handle.send_done();
self.handles
.set((handle.client.id, handle.id), handle.clone());
}
pub fn manager_send(
&self,
toplevel: Rc<dyn ToplevelNode>,
manager: &ZwlrForeignToplevelManagerV1,
) {
let title = self.title.borrow();
let activated = self.active();
let fullscreen = self.is_fullscreen[LiveTL].get();
let app_id;
let class;
let manager_app_id = match &self.kind {
ToplevelType::XWindow(w) => {
class = w.info.class.borrow();
class.as_deref().unwrap_or_default()
}
_ => {
app_id = self.app_id.borrow();
&app_id
}
};
self.manager_send_once(
&toplevel,
manager,
&title,
manager_app_id,
activated,
fullscreen,
);
}
fn manager_send_once(
&self,
toplevel: &Rc<dyn ToplevelNode>,
manager: &ZwlrForeignToplevelManagerV1,
title: &str,
app_id: &str,
activated: bool,
fullscreen: bool,
) {
let opt = ToplevelOpt {
toplevel: Rc::downgrade(toplevel),
identifier: self.identifier.get(),
};
let handle = manager.publish_toplevel(opt);
if !app_id.is_empty() {
handle.send_app_id(app_id);
}
if !title.is_empty() {
handle.send_title(title);
}
handle.enter_output(&self.output(LiveTL));
handle.send_state(activated, fullscreen);
handle.send_done();
self.manager_handles
.set((handle.client.id, handle.id), handle.clone());
}
pub fn set_title(&self, title: &str) {
*self.title.borrow_mut() = title.to_string();
for handle in self.handles.lock().values() {
handle.send_title(title);
handle.send_done();
}
for handle in self.manager_handles.lock().values() {
handle.send_title(title);
handle.send_done();
}
}
pub fn set_app_id(&self, app_id: &str) {
let dst = &mut *self.app_id.borrow_mut();
if *dst == app_id {
return;
}
*dst = app_id.to_string();
for handle in self.handles.lock().values() {
handle.send_app_id(app_id);
handle.send_done();
}
for handle in self.manager_handles.lock().values() {
handle.send_app_id(app_id);
handle.send_done();
}
self.property_changed(TL_CHANGED_APP_ID);
}
pub fn set_fullscreen(
&self,
state: &Rc<State>,
node: Rc<dyn ToplevelNode>,
ws: &Rc<WorkspaceNode>,
) {
let wns = &ws.node_state[LiveTL];
if wns.fullscreen.is_some() {
log::info!(
"Cannot fullscreen a node on a workspace that already has a fullscreen node attached"
);
return;
}
if node.node_is_placeholder() {
log::info!("Cannot fullscreen a placeholder node");
return;
}
let mut data = self.fullscrceen_data.borrow_mut();
if data.is_some() {
log::info!("Cannot fullscreen a node that is already fullscreen");
return;
}
let Some(parent) = node.tl_data().parent.get() else {
log::warn!("Cannot fullscreen a node without a parent");
return;
};
if parent.node_is_workspace() {
log::warn!("Cannot fullscreen root container in a workspace");
return;
}
let placeholder =
Rc::new_cyclic(|weak| PlaceholderNode::new_for(state, node.clone(), weak));
parent.cnode_replace_child(&*node, placeholder.clone());
let mut kb_foci = Default::default();
if wns.visible.get() {
kb_foci = ws.collect_kb_foci();
}
*data = Some(FullscreenedData {
placeholder,
workspace: ws.clone(),
});
drop(data);
let output = wns.output.get();
node.tl_mark_fullscreen(Some(&output.global.connector));
self.property_changed(TL_CHANGED_FULLSCREEN);
node.tl_set_parent(ws.clone());
ws.set_fullscreen_node(&node);
node.clone()
.tl_change_extents(&output.node_state[LiveTL].pos.get());
for seat in kb_foci {
node.clone()
.node_do_focus_dyn(&seat, Direction::Unspecified);
}
for handle in self.manager_handles.lock().values() {
handle.send_state(self.active(), true);
handle.send_done();
}
}
pub fn unset_fullscreen(&self, state: &Rc<State>, node: Rc<dyn ToplevelNode>) {
if !self.is_fullscreen[LiveTL].get() {
log::warn!("Cannot unset fullscreen on a node that is not fullscreen");
return;
}
let Some(fd) = self.fullscrceen_data.borrow_mut().take() else {
log::error!("is_fullscreen = true but data is None");
return;
};
node.tl_mark_fullscreen(None);
self.property_changed(TL_CHANGED_FULLSCREEN);
match fd.workspace.node_state[LiveTL].fullscreen.get() {
None => {
log::error!(
"Node is supposed to be fullscreened on a workspace but workspace has not fullscreen node."
);
return;
}
Some(f) if f.node_id() != node.node_id() => {
log::error!(
"Node is supposed to be fullscreened on a workspace but the workspace has a different node attached."
);
return;
}
_ => {}
}
fd.workspace.remove_fullscreen_node();
if fd.placeholder.is_destroyed() {
state.map_tiled(node);
return;
}
let parent = fd.placeholder.tl_data().parent.take().unwrap();
parent.clone().cnode_make_visible(&*fd.placeholder);
parent.cnode_replace_child(fd.placeholder.deref(), node.clone());
if node.node_visible(LiveTL) {
let kb_foci = collect_kb_foci(fd.placeholder.clone());
for seat in kb_foci {
node.clone()
.node_do_focus_dyn(&seat, Direction::Unspecified);
}
}
fd.placeholder.tl_destroy();
for handle in self.manager_handles.lock().values() {
handle.send_state(self.active(), false);
handle.send_done();
}
}
fn set_visible(&self, node: &dyn Node, visible: bool) {
if self.visible[LiveTL].replace(visible) != visible {
self.property_changed(TL_CHANGED_VISIBLE);
self.schedule_op(ToplevelDataTransactionOp::SetVisible(visible));
}
self.seat_state.set_visible(node, visible);
for sc in self.jay_screencasts.lock().values() {
sc.update_latch_listener();
}
for sc in self.ext_copy_sessions.lock().values() {
sc.update_latch_listener();
}
if !visible {
return;
}
if !self.requested_attention.replace(false) {
return;
}
self.set_wants_attention(false);
if let Some(parent) = self.parent.get() {
parent.cnode_child_attention_request_changed(node, false);
}
}
pub fn request_attention(&self, node: &dyn Node) {
if self.visible[LiveTL].get() {
return;
}
if self.requested_attention.replace(true) {
return;
}
self.set_wants_attention(true);
if let Some(parent) = self.parent.get() {
parent.cnode_child_attention_request_changed(node, true);
}
}
pub fn set_wants_attention(&self, value: bool) {
if self.wants_attention.replace(value) != value {
self.property_changed(TL_CHANGED_URGENT);
}
}
pub fn output(&self, tl: TreeTimeline) -> Rc<OutputNode> {
match self.output_opt(tl) {
None => self.state.dummy_output.get().unwrap(),
Some(o) => o,
}
}
pub fn output_opt(&self, tl: TreeTimeline) -> Option<Rc<OutputNode>> {
self.workspace[tl]
.get()
.map(|ws| ws.node_state[tl].output.get())
}
pub fn desired_pixel_size(&self, tl: TreeTimeline) -> (i32, i32) {
let (dw, dh) = self.desired_extents.get().size();
if let Some(ws) = self.workspace[tl].get() {
let scale = ws.node_state[tl].output.get().node_state[tl].scale.get();
return scale.pixel_size([dw, dh]).to_tuple();
}
(0, 0)
}
pub fn just_mapped(&self) -> bool {
self.mapped_during_iteration.get() == self.state.eng.iteration()
}
pub fn set_content_type(&self, content_type: Option<ContentType>) {
if self.content_type.replace(content_type) != content_type {
self.property_changed(TL_CHANGED_CONTENT_TY);
}
}
pub fn make_visible(&self, slf: &dyn Node) {
if self.visible[LiveTL].get() {
return;
}
if let Some(parent) = self.parent.get() {
parent.cnode_make_visible(slf);
}
}
pub fn node_layer(&self) -> NodeLayerLink {
let ty = self.workspace_type[LiveTL]
.get()
.unwrap_or(WorkspaceType::Normal);
if self.self_or_ancestor_is_fullscreen.get() {
return match ty {
WorkspaceType::Normal => NodeLayerLink::Fullscreen,
WorkspaceType::Overlay => NodeLayerLink::OverlayFullscreen,
};
}
if let Some(float) = self.float.get() {
return float.node_layer();
}
match ty {
WorkspaceType::Normal => NodeLayerLink::Tiled,
WorkspaceType::Overlay => NodeLayerLink::OverlayTiled,
}
}
pub fn property_changed_source(&self) -> &Rc<LazyEventSource> {
self.property_changed_source
.get_or_init(|| self.state.lazy_event_sources.create_source())
}
pub fn set_session(&self, session: &Rc<ToplevelSession>, restore: bool) {
if !restore {
if let Some(ws) = &self.workspace[LiveTL].get() {
session.set_workspace(&ws, self);
}
if self.parent_is_float.get() {
session.set_float_pos(self);
}
session.set_fullscreen(self.is_fullscreen[LiveTL].get());
}
self.session.set(Some(session.clone()));
}
pub fn disown_session(&self) {
if let Some(session) = self.session.take() {
session.disown_to_peer();
}
}
fn set_is_root_container(&self, value: bool, overlay: bool) {
let mut changed = false;
changed |= self.is_root_container[LiveTL].replace(value) != value;
changed |= self.is_overlay_root_container[LiveTL].replace(overlay) != overlay;
if changed {
self.property_changed(TL_CHANGED_IS_WORKSPACE_CONTAINER);
if let Some(slf) = self.slf.upgrade() {
slf.clone()
.tl_schedule_data_op(ToplevelDataTransactionOp::SetIsRootContainer(
value, overlay,
));
slf.tl_is_root_container_changed();
}
}
}
fn schedule_op(&self, op: ToplevelDataTransactionOp) {
if let Some(slf) = self.slf.upgrade() {
slf.tl_schedule_data_op(op);
}
}
pub fn run_op(&self, op: ToplevelDataTransactionOp) {
match op {
ToplevelDataTransactionOp::SetIsFullscreen(v) => {
self.is_fullscreen[RenderTL].set(v);
}
ToplevelDataTransactionOp::SetWorkspace(v) => {
let ty = v.as_ref().map(|v| v.ty);
self.workspace_type[RenderTL].set(ty);
self.workspace[RenderTL].set(v);
}
ToplevelDataTransactionOp::SetVisible(v) => {
self.visible[RenderTL].set(v);
}
ToplevelDataTransactionOp::SetIsRootContainer(v, o) => {
self.is_root_container[RenderTL].set(v);
self.is_overlay_root_container[RenderTL].set(o);
}
}
}
pub fn workspace_output_changed(&self, prev: &Rc<OutputNode>, new: &Rc<OutputNode>) {
self.output_listener.attach(&new.global.connector.listeners);
for sc in self.jay_screencasts.lock().values() {
sc.update_latch_listener();
}
for sc in self.ext_copy_sessions.lock().values() {
sc.update_latch_listener();
}
if prev.id != new.id {
for handle in self.manager_handles.borrow().lock().values() {
handle.leave_output(prev);
handle.enter_output(new);
handle.send_done();
}
}
if let Some(session) = self.session.get() {
session.set_output(new, self);
}
}
pub fn scale_changed(&self) {
for sc in self.jay_screencasts.lock().values() {
sc.schedule_realloc_or_reconfigure();
}
for sc in self.ext_copy_sessions.lock().values() {
sc.buffer_size_changed();
}
}
pub fn theme(&self, ty: ToplevelThemeType) -> Option<&ToplevelTheme> {
self.theme[ty].get().as_double_deref()
}
pub fn modify_theme<R>(&self, ty: ToplevelThemeType, f: impl FnOnce(&ToplevelTheme) -> R) -> R {
let theme = &self.theme[ty];
let r = f(theme.get_or_init(|| self.state.toplevel_theme_cache.get(Default::default())));
self.theme_change[ty].set(true);
if !self.theme_change_queued.replace(true) {
self.state.toplevel_theme_changed.push(self.slf.clone());
}
r
}
}
impl Drop for ToplevelData {
fn drop(&mut self) {
self.state.remove_toplevel_id(self.identifier.get());
}
}
pub struct TileDragDestination {
pub highlight: Rect,
pub ty: TddType,
}
pub enum TddType {
Replace(Rc<dyn ToplevelNode>),
Split {
node: Rc<dyn ToplevelNode>,
split: ContainerSplit,
before: bool,
},
Insert {
container: Rc<ContainerNode>,
neighbor: Rc<dyn ToplevelNode>,
before: bool,
},
NewWorkspace {
output: Rc<OutputNode>,
},
NewContainer {
workspace: Rc<WorkspaceNode>,
},
MoveToWorkspace {
workspace: Rc<WorkspaceNode>,
},
MoveToNewWorkspace {
output: Rc<OutputNode>,
},
}
pub fn default_tile_drag_bounds<T: ToplevelNodeBase + ?Sized>(t: &T, split: ContainerSplit) -> i32 {
const FACTOR: i32 = 5;
match split {
ContainerSplit::Horizontal => t.node_absolute_position(LiveTL).width() / FACTOR,
ContainerSplit::Vertical => t.node_absolute_position(LiveTL).height() / FACTOR,
}
}
pub fn toplevel_parent_container(tl: &dyn ToplevelNode) -> Option<Rc<ContainerNode>> {
toplevel_data_parent_container(tl.tl_data())
}
pub fn toplevel_data_parent_container(data: &ToplevelData) -> Option<Rc<ContainerNode>> {
if let Some(parent) = data.parent.get() {
return parent.node_into_container();
}
None
}
pub fn toplevel_target_container(
tl: &Rc<dyn ToplevelNode>,
target: ContainerTarget,
) -> Option<Rc<ContainerNode>> {
let itself = || tl.clone().node_into_container();
let parent = || toplevel_parent_container(&**tl);
match target {
ContainerTarget::Parent => parent(),
ContainerTarget::Itself => itself(),
ContainerTarget::Auto => itself().or_else(parent),
}
}
pub fn toplevel_set_target_mono(tl: &Rc<dyn ToplevelNode>, target: ContainerTarget, mono: bool) {
let Some(c) = toplevel_target_container(tl, target) else {
return;
};
match c.node_id() == tl.node_id() {
true => c.set_own_mono(mono),
false => c.set_mono(mono.then_some(&**tl)),
}
}
pub fn toplevel_create_split(state: &Rc<State>, tl: Rc<dyn ToplevelNode>, axis: ContainerSplit) {
if tl.tl_data().is_fullscreen[LiveTL].get() {
return;
}
let Some(ws) = tl.tl_data().workspace[LiveTL].get() else {
return;
};
if state.split_reuses_container.get()
&& let Some(pn) = toplevel_parent_container(&*tl)
&& pn.node_state[LiveTL].num_children.get() == 1
{
pn.set_split(axis);
return;
}
let Some(pn) = tl.tl_data().parent.get() else {
return;
};
if let Some(pn) = pn.node_into_containing_node() {
let cn = ContainerNode::new(state, &ws, tl.clone(), axis);
pn.cnode_replace_child(&*tl, cn);
}
}
pub fn toplevel_set_floating(state: &Rc<State>, tl: Rc<dyn ToplevelNode>, floating: bool) {
let data = tl.tl_data();
if data.is_fullscreen[LiveTL].get() {
return;
}
if data.parent_is_float.get() == floating {
return;
}
let Some(parent) = data.parent.get() else {
return;
};
if !floating {
parent.cnode_remove_child2(&*tl, true);
state.map_tiled(tl);
} else if let Some(ws) = data.workspace[LiveTL].get() {
parent.cnode_remove_child2(&*tl, true);
let (width, height) = data.float_size(&ws);
state.map_floating(tl, width, height, &ws, None, false);
}
}
pub fn toplevel_set_workspace(state: &Rc<State>, tl: Rc<dyn ToplevelNode>, ws: &Rc<WorkspaceNode>) {
let Some(old_ws) = tl.tl_data().workspace[LiveTL].get() else {
return;
};
if old_ws.id == ws.id {
return;
}
let data = tl.tl_data();
let fullscreen = data.is_fullscreen[LiveTL].get();
let wns = &ws.node_state[LiveTL];
if fullscreen {
if let Some(old) = wns.fullscreen.get() {
old.tl_set_fullscreen(false, None);
}
if wns.fullscreen.is_some() {
return;
}
tl.clone().tl_set_fullscreen(false, None);
if data.is_fullscreen[LiveTL].get() {
return;
}
}
let Some(cn) = tl.tl_data().parent.get() else {
return;
};
let kb_foci = collect_kb_foci(tl.clone());
cn.cnode_remove_child2(&*tl, true);
if !wns.visible.get() {
for focus in kb_foci {
old_ws.do_focus(&focus, Direction::Unspecified);
}
}
if tl.tl_data().parent_is_float.get() {
let (width, height) = tl.tl_data().float_size(ws);
state.map_floating(tl.clone(), width, height, ws, None, false);
} else {
state.map_tiled_on(tl.clone(), ws);
}
if fullscreen {
tl.tl_set_fullscreen(true, Some(ws.clone()));
}
}
pub async fn handle_toplevel_theme_change(state: Rc<State>) {
loop {
let tl = state.toplevel_theme_changed.pop().await;
if let Some(tl) = tl.upgrade() {
let data = tl.tl_data();
data.theme_change_queued.set(false);
if data.theme_change[SelfTheme].take() {
tl.clone().tl_theme_changed();
}
if data.theme_change[ParentTheme].take()
&& let Some(parent) = data.parent.get()
{
parent.cnode_child_theme_changed(data.node_id);
}
data.trigger_property_source();
}
}
}