285 lines
8.5 KiB
Rust
285 lines
8.5 KiB
Rust
mod types;
|
|
pub mod xdg_popup;
|
|
pub mod xdg_toplevel;
|
|
|
|
use crate::client::DynEventFormatter;
|
|
use crate::ifs::wl_surface::xdg_surface::xdg_popup::{XdgPopup, XdgPopupId};
|
|
use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
|
|
use crate::ifs::wl_surface::{CommitAction, CommitContext, SurfaceExt, SurfaceRole, WlSurface};
|
|
use crate::ifs::xdg_wm_base::XdgWmBaseObj;
|
|
use crate::object::{Interface, Object, ObjectId};
|
|
use crate::rect::Rect;
|
|
use crate::tree::Node;
|
|
use crate::utils::buffd::MsgParser;
|
|
use crate::utils::clonecell::CloneCell;
|
|
use crate::utils::copyhashmap::CopyHashMap;
|
|
use crate::NumCell;
|
|
use std::cell::Cell;
|
|
use std::rc::Rc;
|
|
pub use types::*;
|
|
|
|
const DESTROY: u32 = 0;
|
|
const GET_TOPLEVEL: u32 = 1;
|
|
const GET_POPUP: u32 = 2;
|
|
const SET_WINDOW_GEOMETRY: u32 = 3;
|
|
const ACK_CONFIGURE: u32 = 4;
|
|
|
|
const CONFIGURE: u32 = 0;
|
|
|
|
#[allow(dead_code)]
|
|
const NOT_CONSTRUCTED: u32 = 1;
|
|
const ALREADY_CONSTRUCTED: u32 = 2;
|
|
#[allow(dead_code)]
|
|
const UNCONFIGURED_BUFFER: u32 = 3;
|
|
|
|
id!(XdgSurfaceId);
|
|
|
|
pub struct XdgSurface {
|
|
id: XdgSurfaceId,
|
|
base: Rc<XdgWmBaseObj>,
|
|
pub surface: Rc<WlSurface>,
|
|
requested_serial: NumCell<u32>,
|
|
acked_serial: Cell<Option<u32>>,
|
|
geometry: Cell<Option<Rect>>,
|
|
extents: Cell<Rect>,
|
|
ext: CloneCell<Option<Rc<dyn XdgSurfaceExt>>>,
|
|
popups: CopyHashMap<XdgPopupId, Rc<XdgPopup>>,
|
|
pending: PendingXdgSurfaceData,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct PendingXdgSurfaceData {
|
|
geometry: Cell<Option<Rect>>,
|
|
}
|
|
|
|
trait XdgSurfaceExt {
|
|
fn initial_configure(self: Rc<Self>) {
|
|
// nothing
|
|
}
|
|
|
|
fn pre_commit(self: Rc<Self>) {
|
|
// nothing
|
|
}
|
|
|
|
fn post_commit(self: Rc<Self>) {
|
|
// nothing
|
|
}
|
|
|
|
fn into_node(self: Rc<Self>) -> Option<Rc<dyn Node>> {
|
|
None
|
|
}
|
|
|
|
fn extents_changed(&self) {
|
|
// nothing
|
|
}
|
|
}
|
|
|
|
impl XdgSurface {
|
|
pub fn new(wm_base: &Rc<XdgWmBaseObj>, id: XdgSurfaceId, surface: &Rc<WlSurface>) -> Self {
|
|
Self {
|
|
id,
|
|
base: wm_base.clone(),
|
|
surface: surface.clone(),
|
|
requested_serial: NumCell::new(0),
|
|
acked_serial: Cell::new(None),
|
|
geometry: Cell::new(None),
|
|
extents: Cell::new(Default::default()),
|
|
ext: Default::default(),
|
|
popups: Default::default(),
|
|
pending: Default::default(),
|
|
}
|
|
}
|
|
|
|
pub fn geometry(&self) -> Option<Rect> {
|
|
self.geometry.get()
|
|
}
|
|
|
|
pub fn send_configure(self: &Rc<Self>) {
|
|
let serial = self.requested_serial.fetch_add(1) + 1;
|
|
self.surface.client.event(self.configure(serial));
|
|
}
|
|
|
|
pub fn configure(self: &Rc<Self>, serial: u32) -> DynEventFormatter {
|
|
Box::new(Configure {
|
|
obj: self.clone(),
|
|
serial,
|
|
})
|
|
}
|
|
|
|
pub fn install(self: &Rc<Self>) -> Result<(), XdgSurfaceError> {
|
|
self.surface.set_role(SurfaceRole::XdgSurface)?;
|
|
if self.surface.ext.get().is_some() {
|
|
return Err(XdgSurfaceError::AlreadyAttached(self.surface.id));
|
|
}
|
|
self.surface.ext.set(self.clone());
|
|
Ok(())
|
|
}
|
|
|
|
fn destroy(&self, parser: MsgParser<'_, '_>) -> Result<(), DestroyError> {
|
|
let _req: Destroy = self.surface.client.parse(self, parser)?;
|
|
if self.ext.get().is_some() {
|
|
return Err(DestroyError::RoleNotYetDestroyed(self.id));
|
|
}
|
|
{
|
|
let children = self.popups.lock();
|
|
for child in children.values() {
|
|
child.parent.set(None);
|
|
}
|
|
}
|
|
self.surface.unset_ext();
|
|
self.base.surfaces.remove(&self.id);
|
|
self.surface.client.remove_obj(self)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn get_toplevel(self: &Rc<Self>, parser: MsgParser<'_, '_>) -> Result<(), GetToplevelError> {
|
|
let req: GetToplevel = self.surface.client.parse(&**self, parser)?;
|
|
self.surface.set_role(SurfaceRole::XdgToplevel)?;
|
|
if self.ext.get().is_some() {
|
|
self.surface.client.protocol_error(
|
|
&**self,
|
|
ALREADY_CONSTRUCTED,
|
|
format!(
|
|
"wl_surface {} already has an assigned xdg_toplevel",
|
|
self.surface.id
|
|
),
|
|
);
|
|
return Err(GetToplevelError::AlreadyConstructed);
|
|
}
|
|
let toplevel = Rc::new(XdgToplevel::new(req.id, self));
|
|
self.surface.client.add_client_obj(&toplevel)?;
|
|
self.ext.set(Some(toplevel));
|
|
Ok(())
|
|
}
|
|
|
|
fn get_popup(self: &Rc<Self>, parser: MsgParser<'_, '_>) -> Result<(), GetPopupError> {
|
|
let req: GetPopup = self.surface.client.parse(&**self, parser)?;
|
|
self.surface.set_role(SurfaceRole::XdgPopup)?;
|
|
let mut parent = None;
|
|
if req.parent.is_some() {
|
|
parent = Some(self.surface.client.get_xdg_surface(req.parent)?);
|
|
}
|
|
if self.ext.get().is_some() {
|
|
self.surface.client.protocol_error(
|
|
&**self,
|
|
ALREADY_CONSTRUCTED,
|
|
format!(
|
|
"wl_surface {} already has an assigned xdg_popup",
|
|
self.surface.id
|
|
),
|
|
);
|
|
return Err(GetPopupError::AlreadyConstructed);
|
|
}
|
|
let popup = Rc::new(XdgPopup::new(req.id, self, parent.as_ref()));
|
|
self.surface.client.add_client_obj(&popup)?;
|
|
if let Some(parent) = &parent {
|
|
parent.popups.set(req.id, popup.clone());
|
|
}
|
|
self.ext.set(Some(popup));
|
|
Ok(())
|
|
}
|
|
|
|
fn set_window_geometry(&self, parser: MsgParser<'_, '_>) -> Result<(), SetWindowGeometryError> {
|
|
let req: SetWindowGeometry = self.surface.client.parse(self, parser)?;
|
|
if req.height <= 0 || req.width <= 0 {
|
|
return Err(SetWindowGeometryError::NonPositiveWidthHeight);
|
|
}
|
|
let extents = Rect::new_sized(req.x, req.y, req.width, req.height).unwrap();
|
|
self.pending.geometry.set(Some(extents));
|
|
Ok(())
|
|
}
|
|
|
|
fn ack_configure(&self, parser: MsgParser<'_, '_>) -> Result<(), AckConfigureError> {
|
|
let req: AckConfigure = self.surface.client.parse(self, parser)?;
|
|
if self.requested_serial.get() == req.serial {
|
|
self.acked_serial.set(Some(req.serial));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_request_(
|
|
self: &Rc<Self>,
|
|
request: u32,
|
|
parser: MsgParser<'_, '_>,
|
|
) -> Result<(), XdgSurfaceError> {
|
|
match request {
|
|
DESTROY => self.destroy(parser)?,
|
|
GET_TOPLEVEL => self.get_toplevel(parser)?,
|
|
GET_POPUP => self.get_popup(parser)?,
|
|
SET_WINDOW_GEOMETRY => self.set_window_geometry(parser)?,
|
|
ACK_CONFIGURE => self.ack_configure(parser)?,
|
|
_ => unreachable!(),
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn update_extents(&self) {
|
|
let old_extents = self.extents.get();
|
|
let mut new_extents = self.surface.extents.get();
|
|
if let Some(geometry) = self.geometry.get() {
|
|
new_extents = new_extents.intersect(geometry);
|
|
}
|
|
self.extents.set(new_extents);
|
|
if old_extents != new_extents {
|
|
if let Some(ext) = self.ext.get() {
|
|
ext.extents_changed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_request!(XdgSurface);
|
|
|
|
impl Object for XdgSurface {
|
|
fn id(&self) -> ObjectId {
|
|
self.id.into()
|
|
}
|
|
|
|
fn interface(&self) -> Interface {
|
|
Interface::XdgSurface
|
|
}
|
|
|
|
fn num_requests(&self) -> u32 {
|
|
ACK_CONFIGURE + 1
|
|
}
|
|
}
|
|
|
|
impl SurfaceExt for XdgSurface {
|
|
fn pre_commit(self: Rc<Self>, _ctx: CommitContext) -> CommitAction {
|
|
{
|
|
let ase = self.acked_serial.get();
|
|
let rse = self.requested_serial.get();
|
|
if ase != Some(rse) {
|
|
if ase.is_none() {
|
|
if let Some(ext) = self.ext.get() {
|
|
ext.initial_configure();
|
|
}
|
|
self.surface.client.event(self.configure(rse));
|
|
}
|
|
// return CommitAction::AbortCommit;
|
|
}
|
|
}
|
|
if let Some(geometry) = self.pending.geometry.take() {
|
|
self.geometry.set(Some(geometry));
|
|
self.update_extents();
|
|
}
|
|
CommitAction::ContinueCommit
|
|
}
|
|
|
|
fn post_commit(&self) {
|
|
if let Some(ext) = self.ext.get() {
|
|
ext.post_commit();
|
|
}
|
|
}
|
|
|
|
fn extents_changed(&self) {
|
|
self.update_extents();
|
|
}
|
|
|
|
fn into_node(self: Rc<Self>) -> Option<Rc<dyn Node>> {
|
|
match self.ext.get() {
|
|
Some(e) => e.into_node(),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|