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

autocommit 2022-01-08 18:38:24 CET

Browse source
This commit is contained in:
Julian Orth 2022-01-08 18:38:24 +01:00
parent 33549184d4
commit d061a5c313
38 changed files with 179 additions and 371 deletions
Download patch file Download diff file Expand all files Collapse all files

5
build.rs
View file

@ -63,11 +63,6 @@ fn main() -> anyhow::Result<()> {
write_ty(&mut f, pixman::OPS, "PixmanOp")?;
let mut f = open("xkbcommon_tys.rs")?;
write_ty(
&mut f,
xkbcommon::XKB_X11_SETUP_XKB_EXTENSION_FLAGS,
"xkb_x11_setup_xkb_extension_flags",
)?;
write_ty(&mut f, xkbcommon::XKB_LOG_LEVEL, "xkb_log_level")?;
write_ty(&mut f, xkbcommon::XKB_CONTEXT_FLAGS, "xkb_context_flags")?;
write_ty(

24
src/backends/xorg/mod.rs
View file

@ -374,7 +374,7 @@ impl XorgBackend {
let seat = Rc::new(XorgSeat {
id: self.state.seat_ids.next(),
backend: self.clone(),
kb: info.deviceid,
_kb: info.deviceid,
mouse: info.attachment,
removed: Cell::new(false),
cb: RefCell::new(None),
@ -481,7 +481,7 @@ impl XorgBackend {
1 => BTN_LEFT,
2 => BTN_MIDDLE,
3 => BTN_RIGHT,
n => n + BTN_SIDE - 8,
n => BTN_SIDE + n - 8,
};
seat.event(SeatEvent::Button(button, state));
}
@ -516,7 +516,9 @@ impl XorgBackend {
};
for info in infos {
if info.flags & ffi::XCB_INPUT_HIERARCHY_MASK_MASTER_ADDED != 0 {
self.query_devices(info.deviceid);
if let Err(e) = self.query_devices(info.deviceid) {
log::error!("Could not query device {}: {:#}", info.deviceid, e);
}
} else if info.flags & ffi::XCB_INPUT_HIERARCHY_MASK_MASTER_REMOVED != 0 {
self.mouse_seats.remove(&info.attachment);
if let Some(seat) = self.seats.remove(&info.deviceid) {
@ -654,7 +656,7 @@ impl XorgBackend {
node_extents.x - surface_extents.x1,
node_extents.y - surface_extents.y1,
);
image.fill_insert_border(
let _ = image.fill_insert_border(
255,
0,
0,
@ -700,7 +702,15 @@ impl XorgBackend {
}
fn render_buffer(&self, image: &Image<Rc<ServerMem>>, buffer: &Rc<WlBuffer>, x: i32, y: i32) {
image.add_image(&buffer.image, x, y);
if let Err(e) = image.add_image(&buffer.image, x, y) {
let client = &buffer.client;
log::error!("Could not access client {} memory: {:#}", client.id, e);
if let Ok(d) = client.display() {
client.fatal_event(d.implementation_error(format!("Could not access memory: {:#}", e)));
} else {
self.state.clients.kill(client.id);
}
}
}
fn render(&self) -> Result<(), XorgBackendError> {
@ -711,7 +721,7 @@ impl XorgBackend {
Some(i) => i,
None => continue,
};
image.fill(0, 0, 0, 255);
let _ = image.fill(0, 0, 0, 255);
let node = match self.state.root.outputs.get(&output.id) {
Some(n) => n,
_ => continue,
@ -808,7 +818,7 @@ impl Output for XorgOutput {
struct XorgSeat {
id: SeatId,
backend: Rc<XorgBackend>,
kb: ffi::xcb_input_device_id_t,
_kb: ffi::xcb_input_device_id_t,
mouse: ffi::xcb_input_device_id_t,
removed: Cell<bool>,
cb: RefCell<Option<Rc<dyn Fn()>>>,

2
src/client/mod.rs
View file

@ -217,7 +217,7 @@ impl Clients {
global: &Rc<State>,
socket: OwnedFd,
) -> Result<(), ClientError> {
let (uid, pid) = unsafe {
let (uid, pid) = {
let mut cred = c::ucred {
pid: 0,
uid: 0,

1
src/client/objects.rs
View file

@ -63,6 +63,7 @@ impl Objects {
self.buffers.clear();
}
#[allow(dead_code)]
fn id<T>(&self, client_data: &Client) -> Result<T, ClientError>
where
ObjectId: Into<T>,

1
src/format.rs
View file

@ -17,6 +17,7 @@ pub fn formats() -> AHashMap<u32, &'static Format> {
map
}
#[allow(dead_code)]
const fn fourcc_code(a: char, b: char, c: char, d: char) -> u32 {
(a as u32) | ((b as u32) << 8) | ((c as u32) << 16) | ((d as u32) << 24)
}

5
src/globals.rs
View file

@ -82,7 +82,6 @@ pub trait Global: GlobalBind {
fn singleton(&self) -> bool;
fn interface(&self) -> Interface;
fn version(&self) -> u32;
fn pre_remove(&self);
fn break_loops(&self) {}
}
@ -127,8 +126,7 @@ impl Globals {
}
pub async fn remove(&self, state: &State, name: GlobalName) -> Result<(), GlobalError> {
let global = self.take(name, true)?;
global.pre_remove();
let _global = self.take(name, true)?;
self.broadcast(state, |r| r.global_remove(name)).await;
Ok(())
}
@ -187,6 +185,7 @@ impl Globals {
}
}
#[allow(dead_code)]
pub fn get_output(&self, output: GlobalName) -> Result<Rc<WlOutputGlobal>, GlobalError> {
match self.outputs.get(&output) {
Some(o) => Ok(o),

14
src/ifs/wl_buffer/mod.rs
View file

@ -19,12 +19,12 @@ id!(WlBufferId);
pub struct WlBuffer {
id: WlBufferId,
client: Rc<Client>,
offset: usize,
pub client: Rc<Client>,
_offset: usize,
pub width: u32,
pub height: u32,
stride: u32,
format: &'static Format,
_stride: u32,
_format: &'static Format,
pub image: Rc<pixman::Image<ClientMemOffset>>,
pub(super) surfaces: CopyHashMap<WlSurfaceId, Rc<WlSurface>>,
}
@ -54,11 +54,11 @@ impl WlBuffer {
Ok(Self {
id,
client: client.clone(),
offset,
_offset: offset,
width,
height,
stride,
format,
_stride: stride,
_format: format,
image: Rc::new(image),
surfaces: Default::default(),
})

10
src/ifs/wl_compositor/mod.rs
View file

@ -19,10 +19,9 @@ pub struct WlCompositorGlobal {
}
pub struct WlCompositorObj {
global: Rc<WlCompositorGlobal>,
id: WlCompositorId,
client: Rc<Client>,
version: u32,
_version: u32,
}
impl WlCompositorGlobal {
@ -37,10 +36,9 @@ impl WlCompositorGlobal {
version: u32,
) -> Result<(), WlCompositorError> {
let obj = Rc::new(WlCompositorObj {
global: self,
id,
client: client.clone(),
version,
_version: version,
});
client.add_client_obj(&obj)?;
Ok(())
@ -94,10 +92,6 @@ impl Global for WlCompositorGlobal {
fn version(&self) -> u32 {
4
}
fn pre_remove(&self) {
unreachable!()
}
}
handle_request!(WlCompositorObj);

2
src/ifs/wl_data_device/mod.rs
View file

@ -17,7 +17,7 @@ const MOTION: u32 = 4;
const DROP: u32 = 5;
const SELECTION: u32 = 5;
const ROLE: u32 = 0;
#[allow(dead_code)] const ROLE: u32 = 0;
id!(WlDataDeviceId);

12
src/ifs/wl_data_device_manager/mod.rs
View file

@ -12,10 +12,10 @@ use crate::ifs::wl_data_source::WlDataSource;
const CREATE_DATA_SOURCE: u32 = 0;
const GET_DATA_DEVICE: u32 = 1;
const DND_NONE: u32 = 0;
const DND_COPY: u32 = 1;
const DND_MOVE: u32 = 2;
const DND_ASK: u32 = 4;
#[allow(dead_code)] const DND_NONE: u32 = 0;
#[allow(dead_code)] const DND_COPY: u32 = 1;
#[allow(dead_code)] const DND_MOVE: u32 = 2;
#[allow(dead_code)] const DND_ASK: u32 = 4;
id!(WlDataDeviceManagerId);
@ -98,10 +98,6 @@ impl Global for WlDataDeviceManagerGlobal {
fn version(&self) -> u32 {
3
}
fn pre_remove(&self) {
unreachable!()
}
}
handle_request!(WlDataDeviceManagerObj);

10
src/ifs/wl_data_offer/mod.rs
View file

@ -16,10 +16,10 @@ const OFFER: u32 = 0;
const SOURCE_ACTIONS: u32 = 1;
const ACTION: u32 = 2;
const INVALID_FINISH: u32 = 0;
const INVALID_ACTION_MASK: u32 = 1;
const INVALID_ACTION: u32 = 2;
const INVALID_OFFER: u32 = 3;
#[allow(dead_code)] const INVALID_FINISH: u32 = 0;
#[allow(dead_code)] const INVALID_ACTION_MASK: u32 = 1;
#[allow(dead_code)] const INVALID_ACTION: u32 = 2;
#[allow(dead_code)] const INVALID_OFFER: u32 = 3;
id!(WlDataOfferId);
@ -80,7 +80,7 @@ impl Object for WlDataOffer {
}
fn interface(&self) -> Interface {
Interface::WlDataSource
Interface::WlDataOffer
}
fn num_requests(&self) -> u32 {

4
src/ifs/wl_data_source/mod.rs
View file

@ -17,8 +17,8 @@ const DND_DROP_PERFORMED: u32 = 4;
const DND_FINISHED: u32 = 5;
const ACTION: u32 = 5;
const INVALID_ACTION_MASK: u32 = 0;
const INVALID_SOURCE: u32 = 1;
#[allow(dead_code)] const INVALID_ACTION_MASK: u32 = 0;
#[allow(dead_code)] const INVALID_SOURCE: u32 = 1;
id!(WlDataSourceId);

2
src/ifs/wl_display/mod.rs
View file

@ -16,7 +16,7 @@ const DELETE_ID: u32 = 1;
const INVALID_OBJECT: u32 = 0;
const INVALID_METHOD: u32 = 1;
const NO_MEMORY: u32 = 2;
#[allow(dead_code)] const NO_MEMORY: u32 = 2;
const IMPLEMENTATION: u32 = 3;
pub struct WlDisplay {

54
src/ifs/wl_output/mod.rs
View file

@ -22,23 +22,23 @@ const DONE: u32 = 2;
const SCALE: u32 = 3;
const SP_UNKNOWN: i32 = 0;
const SP_NONE: i32 = 1;
const SP_HORIZONTAL_RGB: i32 = 2;
const SP_HORIZONTAL_BGR: i32 = 3;
const SP_VERTICAL_RGB: i32 = 4;
const SP_VERTICAL_BGR: i32 = 5;
#[allow(dead_code)] const SP_NONE: i32 = 1;
#[allow(dead_code)] const SP_HORIZONTAL_RGB: i32 = 2;
#[allow(dead_code)] const SP_HORIZONTAL_BGR: i32 = 3;
#[allow(dead_code)] const SP_VERTICAL_RGB: i32 = 4;
#[allow(dead_code)] const SP_VERTICAL_BGR: i32 = 5;
const TF_NORMAL: i32 = 0;
const TF_90: i32 = 1;
const TF_180: i32 = 2;
const TF_270: i32 = 3;
const TF_FLIPPED: i32 = 4;
const TF_FLIPPED_90: i32 = 5;
const TF_FLIPPED_180: i32 = 6;
const TF_FLIPPED_270: i32 = 7;
#[allow(dead_code)] const TF_90: i32 = 1;
#[allow(dead_code)] const TF_180: i32 = 2;
#[allow(dead_code)] const TF_270: i32 = 3;
#[allow(dead_code)] const TF_FLIPPED: i32 = 4;
#[allow(dead_code)] const TF_FLIPPED_90: i32 = 5;
#[allow(dead_code)] const TF_FLIPPED_180: i32 = 6;
#[allow(dead_code)] const TF_FLIPPED_270: i32 = 7;
const MODE_CURRENT: u32 = 1;
const MODE_PREFERRED: u32 = 2;
#[allow(dead_code)] const MODE_PREFERRED: u32 = 2;
pub struct WlOutputGlobal {
name: GlobalName,
@ -109,13 +109,18 @@ impl WlOutputGlobal {
global: self.clone(),
id,
client: client.clone(),
version,
});
client.add_client_obj(&obj)?;
self.bindings.set((client.id, id), obj.clone());
client.event(obj.geometry()).await?;
client.event(obj.mode()).await?;
client.event(obj.scale()).await?;
client.event(obj.done()).await?;
if obj.send_scale() {
client.event(obj.scale()).await?;
}
if obj.send_done() {
client.event(obj.done()).await?;
}
Ok(())
}
}
@ -139,10 +144,6 @@ impl Global for WlOutputGlobal {
3
}
fn pre_remove(&self) {
//
}
fn break_loops(&self) {
self.bindings.clear();
}
@ -152,9 +153,18 @@ pub struct WlOutputObj {
global: Rc<WlOutputGlobal>,
id: WlOutputId,
client: Rc<Client>,
version: u32,
}
impl WlOutputObj {
fn send_done(&self) -> bool {
self.version >= 2
}
fn send_scale(&self) -> bool {
self.version >= 2
}
fn geometry(self: &Rc<Self>) -> DynEventFormatter {
Box::new(Geometry {
obj: self.clone(),
@ -222,7 +232,11 @@ impl Object for WlOutputObj {
}
fn num_requests(&self) -> u32 {
RELEASE + 1
if self.version < 3 {
0
} else {
RELEASE + 1
}
}
fn break_loops(&self) {

24
src/ifs/wl_seat/mod.rs
View file

@ -36,14 +36,14 @@ const NAME: u32 = 1;
const POINTER: u32 = 1;
const KEYBOARD: u32 = 2;
const TOUCH: u32 = 4;
#[allow(dead_code)] const TOUCH: u32 = 4;
const MISSING_CAPABILITY: u32 = 0;
#[allow(dead_code)] const MISSING_CAPABILITY: u32 = 0;
pub struct WlSeatGlobal {
name: GlobalName,
state: Rc<State>,
seat: Rc<dyn Seat>,
_seat: Rc<dyn Seat>,
move_: Cell<bool>,
move_start_pos: Cell<(Fixed, Fixed)>,
extents_start_pos: Cell<(i32, i32)>,
@ -75,7 +75,7 @@ impl WlSeatGlobal {
Self {
name,
state: state.clone(),
seat: seat.clone(),
_seat: seat.clone(),
move_: Cell::new(false),
move_start_pos: Cell::new((Fixed(0), Fixed(0))),
extents_start_pos: Cell::new((0, 0)),
@ -217,7 +217,7 @@ impl WlSeatGlobal {
}
}
async fn key_event(&self, key: u32, state: KeyState) {}
async fn key_event(&self, _key: u32, _state: KeyState) {}
async fn bind_(
self: Rc<Self>,
@ -231,6 +231,7 @@ impl WlSeatGlobal {
client: client.clone(),
pointers: Default::default(),
keyboards: Default::default(),
version,
});
client.add_client_obj(&obj)?;
client.event(obj.capabilities()).await?;
@ -261,11 +262,7 @@ impl Global for WlSeatGlobal {
}
fn version(&self) -> u32 {
3
}
fn pre_remove(&self) {
//
7
}
fn break_loops(&self) {
@ -279,6 +276,7 @@ pub struct WlSeatObj {
client: Rc<Client>,
pointers: CopyHashMap<WlPointerId, Rc<WlPointer>>,
keyboards: CopyHashMap<WlKeyboardId, Rc<WlKeyboard>>,
version: u32,
}
impl WlSeatObj {
@ -369,7 +367,11 @@ impl Object for WlSeatObj {
}
fn num_requests(&self) -> u32 {
RELEASE + 1
if self.version < 5 {
GET_TOUCH + 1
} else {
RELEASE + 1
}
}
fn break_loops(&self) {

11
src/ifs/wl_seat/wl_keyboard/mod.rs
View file

@ -18,11 +18,11 @@ const KEY: u32 = 3;
const MODIFIERS: u32 = 4;
const REPEAT_INFO: u32 = 5;
const NO_KEYMAP: u32 = 0;
#[allow(dead_code)] const NO_KEYMAP: u32 = 0;
pub(super) const XKB_V1: u32 = 1;
const RELEASED: u32 = 0;
const PRESSED: u32 = 1;
#[allow(dead_code)] const RELEASED: u32 = 0;
#[allow(dead_code)] const PRESSED: u32 = 1;
id!(WlKeyboardId);
@ -48,6 +48,7 @@ impl WlKeyboard {
})
}
#[allow(dead_code)]
pub fn enter(
self: &Rc<Self>,
serial: u32,
@ -62,6 +63,7 @@ impl WlKeyboard {
})
}
#[allow(dead_code)]
pub fn leave(self: &Rc<Self>, serial: u32, surface: WlSurfaceId) -> DynEventFormatter {
Box::new(Leave {
obj: self.clone(),
@ -70,6 +72,7 @@ impl WlKeyboard {
})
}
#[allow(dead_code)]
pub fn key(self: &Rc<Self>, serial: u32, time: u32, key: u32, state: u32) -> DynEventFormatter {
Box::new(Key {
obj: self.clone(),
@ -80,6 +83,7 @@ impl WlKeyboard {
})
}
#[allow(dead_code)]
pub fn modifiers(
self: &Rc<Self>,
serial: u32,
@ -98,6 +102,7 @@ impl WlKeyboard {
})
}
#[allow(dead_code)]
pub fn repeat_info(self: &Rc<Self>, rate: i32, delay: i32) -> DynEventFormatter {
Box::new(RepeatInfo {
obj: self.clone(),

14
src/ifs/wl_seat/wl_pointer/mod.rs
View file

@ -22,7 +22,7 @@ const AXIS_SOURCE: u32 = 6;
const AXIS_STOP: u32 = 7;
const AXIS_DISCRETE: u32 = 8;
const ROLE: u32 = 0;
#[allow(dead_code)] const ROLE: u32 = 0;
pub(super) const RELEASED: u32 = 0;
pub(super) const PRESSED: u32 = 1;
@ -30,10 +30,10 @@ pub(super) const PRESSED: u32 = 1;
pub(super) const VERTICAL_SCROLL: u32 = 0;
pub(super) const HORIZONTAL_SCROLL: u32 = 1;
const WHEEL: u32 = 0;
const FINGER: u32 = 1;
const CONTINUOUS: u32 = 2;
const WHEEL_TILT: u32 = 3;
#[allow(dead_code)] const WHEEL: u32 = 0;
#[allow(dead_code)] const FINGER: u32 = 1;
#[allow(dead_code)] const CONTINUOUS: u32 = 2;
#[allow(dead_code)] const WHEEL_TILT: u32 = 3;
id!(WlPointerId);
@ -108,10 +108,12 @@ impl WlPointer {
})
}
#[allow(dead_code)]
pub fn frame(self: &Rc<Self>) -> DynEventFormatter {
Box::new(Frame { obj: self.clone() })
}
#[allow(dead_code)]
pub fn axis_source(self: &Rc<Self>, axis_source: u32) -> DynEventFormatter {
Box::new(AxisSource {
obj: self.clone(),
@ -119,6 +121,7 @@ impl WlPointer {
})
}
#[allow(dead_code)]
pub fn axis_stop(self: &Rc<Self>, time: u32, axis: u32) -> DynEventFormatter {
Box::new(AxisStop {
obj: self.clone(),
@ -127,6 +130,7 @@ impl WlPointer {
})
}
#[allow(dead_code)]
pub fn axis_discrete(self: &Rc<Self>, axis: u32, discrete: i32) -> DynEventFormatter {
Box::new(AxisDiscrete {
obj: self.clone(),

14
src/ifs/wl_seat/wl_touch/mod.rs
View file

@ -9,13 +9,13 @@ pub use types::*;
const RELEASE: u32 = 0;
const DOWN: u32 = 0;
const UP: u32 = 1;
const MOTION: u32 = 2;
const FRAME: u32 = 3;
const CANCEL: u32 = 4;
const SHAPE: u32 = 5;
const ORIENTATION: u32 = 6;
#[allow(dead_code)] const DOWN: u32 = 0;
#[allow(dead_code)] const UP: u32 = 1;
#[allow(dead_code)] const MOTION: u32 = 2;
#[allow(dead_code)] const FRAME: u32 = 3;
#[allow(dead_code)] const CANCEL: u32 = 4;
#[allow(dead_code)] const SHAPE: u32 = 5;
#[allow(dead_code)] const ORIENTATION: u32 = 6;
id!(WlTouchId);

8
src/ifs/wl_shm/mod.rs
View file

@ -19,7 +19,7 @@ pub struct WlShmGlobal {
}
pub struct WlShmObj {
global: Rc<WlShmGlobal>,
_global: Rc<WlShmGlobal>,
id: WlShmId,
client: Rc<Client>,
}
@ -36,7 +36,7 @@ impl WlShmGlobal {
_version: u32,
) -> Result<(), WlShmError> {
let obj = Rc::new(WlShmObj {
global: self,
_global: self,
id,
client: client.clone(),
});
@ -100,10 +100,6 @@ impl Global for WlShmGlobal {
fn version(&self) -> u32 {
1
}
fn pre_remove(&self) {
unreachable!()
}
}
handle_request!(WlShmObj);

8
src/ifs/wl_subcompositor/mod.rs
View file

@ -11,7 +11,7 @@ pub use types::*;
const DESTROY: u32 = 0;
const GET_SUBSURFACE: u32 = 1;
const BAD_SURFACE: u32 = 0;
#[allow(dead_code)] const BAD_SURFACE: u32 = 0;
id!(WlSubcompositorId);
@ -20,7 +20,6 @@ pub struct WlSubcompositorGlobal {
}
pub struct WlSubcompositorObj {
global: Rc<WlSubcompositorGlobal>,
id: WlSubcompositorId,
client: Rc<Client>,
}
@ -37,7 +36,6 @@ impl WlSubcompositorGlobal {
_version: u32,
) -> Result<(), WlSubcompositorError> {
let obj = Rc::new(WlSubcompositorObj {
global: self,
id,
client: client.clone(),
});
@ -95,10 +93,6 @@ impl Global for WlSubcompositorGlobal {
fn version(&self) -> u32 {
1
}
fn pre_remove(&self) {
unreachable!()
}
}
handle_request!(WlSubcompositorObj);

26
src/ifs/wl_surface/mod.rs
View file

@ -33,12 +33,12 @@ const SET_BUFFER_TRANSFORM: u32 = 7;
const SET_BUFFER_SCALE: u32 = 8;
const DAMAGE_BUFFER: u32 = 9;
const ENTER: u32 = 0;
const LEAVE: u32 = 1;
#[allow(dead_code)] const ENTER: u32 = 0;
#[allow(dead_code)] const LEAVE: u32 = 1;
const INVALID_SCALE: u32 = 0;
const INVALID_TRANSFORM: u32 = 1;
const INVALID_SIZE: u32 = 2;
#[allow(dead_code)] const INVALID_SCALE: u32 = 0;
#[allow(dead_code)] const INVALID_TRANSFORM: u32 = 1;
#[allow(dead_code)] const INVALID_SIZE: u32 = 2;
id!(WlSurfaceId);
@ -143,7 +143,7 @@ impl XdgSurfaceRoleData {
}
struct XdgPopupData {
popup: Rc<XdgPopup>,
_popup: Rc<XdgPopup>,
parent: Option<Rc<XdgSurface>>,
}
@ -229,7 +229,7 @@ impl WlSurface {
for surface in children.subsurfaces.values() {
let rd = surface.role_data.borrow();
if let RoleData::Subsurface(ss) = &*rd {
let mut ss_extents = surface.extents.get();
let ss_extents = surface.extents.get();
extents.x1 = extents.x1.min(ss_extents.x1 + ss.x);
extents.y1 = extents.y1.min(ss_extents.y1 + ss.y);
extents.x2 = extents.x2.max(ss_extents.x2 + ss.x);
@ -249,10 +249,6 @@ impl WlSurface {
parent.calculate_extents();
}
pub fn is_subsurface(&self) -> bool {
self.role.get() == SurfaceRole::Subsurface
}
pub fn get_root(self: &Rc<Self>) -> Rc<WlSurface> {
let mut root = self.clone();
loop {
@ -381,7 +377,7 @@ impl WlSurface {
}
async fn damage(&self, parser: MsgParser<'_, '_>) -> Result<(), DamageError> {
let req: Damage = self.parse(parser)?;
let _req: Damage = self.parse(parser)?;
Ok(())
}
@ -518,17 +514,17 @@ impl WlSurface {
&self,
parser: MsgParser<'_, '_>,
) -> Result<(), SetBufferTransformError> {
let req: SetBufferTransform = self.parse(parser)?;
let _req: SetBufferTransform = self.parse(parser)?;
Ok(())
}
async fn set_buffer_scale(&self, parser: MsgParser<'_, '_>) -> Result<(), SetBufferScaleError> {
let req: SetBufferScale = self.parse(parser)?;
let _req: SetBufferScale = self.parse(parser)?;
Ok(())
}
async fn damage_buffer(&self, parser: MsgParser<'_, '_>) -> Result<(), DamageBufferError> {
let req: DamageBuffer = self.parse(parser)?;
let _req: DamageBuffer = self.parse(parser)?;
Ok(())
}

7
src/ifs/wl_surface/wl_subsurface/mod.rs
View file

@ -17,7 +17,7 @@ const PLACE_BELOW: u32 = 3;
const SET_SYNC: u32 = 4;
const SET_DESYNC: u32 = 5;
const BAD_SURFACE: u32 = 0;
#[allow(dead_code)] const BAD_SURFACE: u32 = 0;
const MAX_SUBSURFACE_DEPTH: u32 = 100;
@ -29,7 +29,7 @@ pub struct WlSubsurface {
pub(super) parent: Rc<WlSurface>,
}
fn update_children_sync(surface: &Rc<WlSurface>, sync: bool) -> Result<(), WlSubsurfaceError> {
fn update_children_sync(surface: &Rc<WlSurface>, sync: bool) {
let children = surface.children.borrow();
if let Some(children) = &*children {
for child in children.subsurfaces.values() {
@ -44,7 +44,6 @@ fn update_children_sync(surface: &Rc<WlSurface>, sync: bool) -> Result<(), WlSub
}
}
}
Ok(())
}
fn update_children_attach(
@ -63,7 +62,7 @@ fn update_children_attach(
}
data.sync_ancestor = sync;
let sync = data.sync_ancestor || data.sync_requested;
update_children_attach(child, sync, depth + 1);
update_children_attach(child, sync, depth + 1)?;
}
}
}

20
src/ifs/wl_surface/xdg_surface/mod.rs
View file

@ -24,17 +24,16 @@ const ACK_CONFIGURE: u32 = 4;
const CONFIGURE: u32 = 0;
const NOT_CONSTRUCTED: u32 = 1;
#[allow(dead_code)] const NOT_CONSTRUCTED: u32 = 1;
const ALREADY_CONSTRUCTED: u32 = 2;
const UNCONFIGURED_BUFFER: u32 = 3;
#[allow(dead_code)] const UNCONFIGURED_BUFFER: u32 = 3;
id!(XdgSurfaceId);
pub struct XdgSurface {
id: XdgSurfaceId,
wm_base: Rc<XdgWmBaseObj>,
base: Rc<XdgWmBaseObj>,
pub surface: Rc<WlSurface>,
version: u32,
}
impl XdgSurface {
@ -42,13 +41,11 @@ impl XdgSurface {
wm_base: &Rc<XdgWmBaseObj>,
id: XdgSurfaceId,
surface: &Rc<WlSurface>,
version: u32,
) -> Self {
Self {
id,
wm_base: wm_base.clone(),
base: wm_base.clone(),
surface: surface.clone(),
version,
}
}
@ -64,6 +61,7 @@ impl XdgSurface {
if !matches!(old_role, SurfaceRole::None | SurfaceRole::XdgSurface) {
return Err(XdgSurfaceError::IncompatibleRole(self.surface.id, old_role));
}
self.surface.role.set(SurfaceRole::XdgSurface);
let mut data = self.surface.role_data.borrow_mut();
if data.is_some() {
return Err(XdgSurfaceError::AlreadyAttached(self.surface.id));
@ -101,7 +99,7 @@ impl XdgSurface {
}
*data = RoleData::None;
}
self.wm_base.surfaces.remove(&self.id);
self.base.surfaces.remove(&self.id);
self.surface.client.remove_obj(self).await?;
Ok(())
}
@ -128,7 +126,7 @@ impl XdgSurface {
return Err(GetToplevelError::AlreadyConstructed);
}
data.role = XdgSurfaceRole::Toplevel;
let toplevel = Rc::new(XdgToplevel::new(req.id, self, self.version));
let toplevel = Rc::new(XdgToplevel::new(req.id, self));
self.surface.client.add_client_obj(&toplevel)?;
data.role_data = XdgSurfaceRoleData::Toplevel(XdgToplevelData {
toplevel,
@ -161,7 +159,7 @@ impl XdgSurface {
return Err(GetPopupError::AlreadyConstructed);
}
data.role = XdgSurfaceRole::Popup;
let popup = Rc::new(XdgPopup::new(req.id, self, self.version));
let popup = Rc::new(XdgPopup::new(req.id, self));
self.surface.client.add_client_obj(&popup)?;
if let Some(parent) = &parent {
let mut data = parent.surface.role_data.borrow_mut();
@ -169,7 +167,7 @@ impl XdgSurface {
xdg.popups.set(self.surface.id, popup.clone());
}
}
data.role_data = XdgSurfaceRoleData::Popup(XdgPopupData { popup, parent });
data.role_data = XdgSurfaceRoleData::Popup(XdgPopupData { _popup: popup, parent });
}
Ok(())
}

6
src/ifs/wl_surface/xdg_surface/xdg_popup/mod.rs
View file

@ -15,22 +15,20 @@ const CONFIGURE: u32 = 0;
const POPUP_DONE: u32 = 1;
const REPOSITIONED: u32 = 2;
const INVALID_GRAB: u32 = 1;
#[allow(dead_code)] const INVALID_GRAB: u32 = 1;
id!(XdgPopupId);
pub struct XdgPopup {
id: XdgPopupId,
pub(in super::super) surface: Rc<XdgSurface>,
version: u32,
}
impl XdgPopup {
pub fn new(id: XdgPopupId, surface: &Rc<XdgSurface>, version: u32) -> Self {
pub fn new(id: XdgPopupId, surface: &Rc<XdgSurface>) -> Self {
Self {
id,
surface: surface.clone(),
version,
}
}

20
src/ifs/wl_surface/xdg_surface/xdg_toplevel/mod.rs
View file

@ -40,29 +40,27 @@ pub enum ResizeEdge {
BottomRight = 10,
}
const STATE_MAXIMIZED: u32 = 1;
const STATE_FULLSCREEN: u32 = 2;
const STATE_RESIZING: u32 = 3;
const STATE_ACTIVATED: u32 = 4;
const STATE_TILED_LEFT: u32 = 5;
const STATE_TILED_RIGHT: u32 = 6;
const STATE_TILED_TOP: u32 = 7;
const STATE_TILED_BOTTOM: u32 = 8;
#[allow(dead_code)] const STATE_MAXIMIZED: u32 = 1;
#[allow(dead_code)] const STATE_FULLSCREEN: u32 = 2;
#[allow(dead_code)] const STATE_RESIZING: u32 = 3;
#[allow(dead_code)] const STATE_ACTIVATED: u32 = 4;
#[allow(dead_code)] const STATE_TILED_LEFT: u32 = 5;
#[allow(dead_code)] const STATE_TILED_RIGHT: u32 = 6;
#[allow(dead_code)] const STATE_TILED_TOP: u32 = 7;
#[allow(dead_code)] const STATE_TILED_BOTTOM: u32 = 8;
id!(XdgToplevelId);
pub struct XdgToplevel {
id: XdgToplevelId,
pub surface: Rc<XdgSurface>,
version: u32,
}
impl XdgToplevel {
pub fn new(id: XdgToplevelId, surface: &Rc<XdgSurface>, version: u32) -> Self {
pub fn new(id: XdgToplevelId, surface: &Rc<XdgSurface>) -> Self {
Self {
id,
surface: surface.clone(),
version,
}
}

14
src/ifs/xdg_positioner/mod.rs
View file

@ -9,6 +9,7 @@ use num_traits::FromPrimitive;
use std::cell::RefCell;
use std::rc::Rc;
pub use types::*;
use crate::ifs::xdg_wm_base::XdgWmBaseObj;
const DESTROY: u32 = 0;
const SET_SIZE: u32 = 1;
@ -78,8 +79,8 @@ id!(XdgPositionerId);
pub struct XdgPositioner {
id: XdgPositionerId,
base: Rc<XdgWmBaseObj>,
client: Rc<Client>,
version: u32,
position: RefCell<XdgPositioned>,
}
@ -103,15 +104,16 @@ pub struct XdgPositioned {
}
impl XdgPositioner {
pub fn new(id: XdgPositionerId, client: &Rc<Client>, version: u32) -> Self {
pub fn new(base: &Rc<XdgWmBaseObj>, id: XdgPositionerId, client: &Rc<Client>) -> Self {
Self {
id,
client: client.clone(),
version,
base: base.clone(),
position: RefCell::new(Default::default()),
}
}
#[allow(dead_code)]
pub fn clone(&self) -> Box<XdgPositioned> {
Box::new(*self.position.borrow())
}
@ -266,6 +268,10 @@ impl Object for XdgPositioner {
}
fn num_requests(&self) -> u32 {
SET_PARENT_CONFIGURE + 1
if self.base.version < 3 {
SET_OFFSET + 1
} else {
SET_PARENT_CONFIGURE + 1
}
}
}

26
src/ifs/xdg_wm_base/mod.rs
View file

@ -17,12 +17,12 @@ const PONG: u32 = 3;
const PING: u32 = 0;
const ROLE: u32 = 0;
#[allow(dead_code)] const ROLE: u32 = 0;
const DEFUNCT_SURFACES: u32 = 1;
const NOT_THE_TOPMOST_POPUP: u32 = 2;
const INVALID_POPUP_PARENT: u32 = 3;
const INVALID_SURFACE_STATE: u32 = 4;
const INVALID_POSITIONER: u32 = 5;
#[allow(dead_code)] const NOT_THE_TOPMOST_POPUP: u32 = 2;
#[allow(dead_code)] const INVALID_POPUP_PARENT: u32 = 3;
#[allow(dead_code)] const INVALID_SURFACE_STATE: u32 = 4;
#[allow(dead_code)] const INVALID_POSITIONER: u32 = 5;
id!(XdgWmBaseId);
@ -31,10 +31,9 @@ pub struct XdgWmBaseGlobal {
}
pub struct XdgWmBaseObj {
global: Rc<XdgWmBaseGlobal>,
id: XdgWmBaseId,
client: Rc<Client>,
version: u32,
pub version: u32,
pub(super) surfaces: CopyHashMap<XdgSurfaceId, Rc<XdgSurface>>,
}
@ -50,7 +49,6 @@ impl XdgWmBaseGlobal {
version: u32,
) -> Result<(), XdgWmBaseError> {
let obj = Rc::new(XdgWmBaseObj {
global: self,
id,
client: client.clone(),
version,
@ -80,11 +78,11 @@ impl XdgWmBaseObj {
}
async fn create_positioner(
&self,
self: &Rc<Self>,
parser: MsgParser<'_, '_>,
) -> Result<(), CreatePositionerError> {
let req: CreatePositioner = self.client.parse(self, parser)?;
let pos = Rc::new(XdgPositioner::new(req.id, &self.client, 3));
let req: CreatePositioner = self.client.parse(&**self, parser)?;
let pos = Rc::new(XdgPositioner::new(self, req.id, &self.client));
self.client.add_client_obj(&pos)?;
Ok(())
}
@ -95,7 +93,7 @@ impl XdgWmBaseObj {
) -> Result<(), GetXdgSurfaceError> {
let req: GetXdgSurface = self.client.parse(&**self, parser)?;
let surface = self.client.get_surface(req.surface)?;
let xdg_surface = Rc::new(XdgSurface::new(self, req.id, &surface, 3));
let xdg_surface = Rc::new(XdgSurface::new(self, req.id, &surface));
self.client.add_client_obj(&xdg_surface)?;
xdg_surface.install()?;
self.surfaces.set(req.id, xdg_surface);
@ -141,10 +139,6 @@ impl Global for XdgWmBaseGlobal {
fn version(&self) -> u32 {
3
}
fn pre_remove(&self) {
unreachable!()
}
}
handle_request!(XdgWmBaseObj);

1
src/macros.rs
View file

@ -117,6 +117,7 @@ macro_rules! linear_ids {
pub struct $id(u32);
impl $id {
#[allow(dead_code)]
pub fn raw(&self) -> u32 {
self.0
}

2
src/object.rs
View file

@ -11,8 +11,6 @@ pub const WL_DISPLAY_ID: ObjectId = ObjectId(1);
pub struct ObjectId(u32);
impl ObjectId {
pub const NONE: Self = ObjectId(0);
pub fn from_raw(raw: u32) -> Self {
Self(raw)
}

1
src/pixman/mod.rs
View file

@ -350,6 +350,7 @@ where
Ok(())
}
#[allow(dead_code)]
pub fn memory(&self) -> &T {
&self.memory
}

4
src/tasks.rs
View file

@ -99,7 +99,7 @@ impl OutputHandler {
ae.triggered().await;
}
self.state.outputs.remove(&self.output.id());
self.state.globals.remove(&self.state, name).await;
let _ = self.state.globals.remove(&self.state, name).await;
self.state
.output_handlers
.borrow_mut()
@ -131,7 +131,7 @@ impl SeatHandler {
}
ae.triggered().await;
}
self.state.globals.remove(&self.state, name).await;
let _ = self.state.globals.remove(&self.state, name).await;
self.state
.seat_handlers
.borrow_mut()

8
src/tree.rs
View file

@ -1,5 +1,4 @@
use crate::backend::{Output, OutputId};
use crate::ifs::wl_seat::WlSeatGlobal;
use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
use crate::utils::copyhashmap::CopyHashMap;
use crate::utils::linkedlist::{LinkedList, Node as LinkedNode};
@ -47,12 +46,6 @@ pub enum NodeKind {
Container(Rc<ContainerNode>),
}
impl NodeKind {
pub async fn leave(&self, seat: &WlSeatGlobal) {}
pub async fn enter(&self, seat: &WlSeatGlobal) {}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
pub struct NodeExtents {
pub x: i32,
@ -195,6 +188,7 @@ impl Node for ToplevelNode {
}
}
#[allow(dead_code)]
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum ContainerSplit {
Horizontal,

1
src/utils/buffd/parser.rs
View file

@ -57,6 +57,7 @@ impl<'a, 'b> MsgParser<'a, 'b> {
self.int().map(|i| GlobalName::from_raw(i as u32))
}
#[allow(dead_code)]
pub fn fixed(&mut self) -> Result<Fixed, MsgParserError> {
self.int().map(|i| Fixed(i))
}

8
src/utils/copyhashmap.rs
View file

@ -28,14 +28,6 @@ impl<K: Eq + Hash, V: Clone> CopyHashMap<K, V> {
self.map.borrow_mut().get(k).cloned()
}
pub fn get_or_insert_default(&self, k: K) -> V
where
V: Default,
{
let mut map = self.map.borrow_mut();
map.entry(k).or_insert_with(|| Default::default()).clone()
}
pub fn remove(&self, k: &K) -> Option<V> {
self.map.borrow_mut().remove(k)
}

63
src/utils/lock.rs
View file

@ -1,63 +0,0 @@
use std::cell::{RefCell, RefMut};
use std::future::Future;
use std::ops::{Deref, DerefMut};
use std::pin::Pin;
use std::task::{Context, Poll, Waker};
pub struct AsyncLock<T> {
data: RefCell<T>,
waiters: RefCell<Vec<Waker>>,
}
impl<T> AsyncLock<T> {
pub fn lock<'a>(&'a self) -> LockedFuture<'a, T> {
LockedFuture { lock: self }
}
}
pub struct LockedFuture<'a, T> {
lock: &'a AsyncLock<T>,
}
impl<'a, T> Future for LockedFuture<'a, T> {
type Output = Locked<'a, T>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
if let Ok(data) = self.lock.data.try_borrow_mut() {
Poll::Ready(Locked {
data,
lock: self.lock,
})
} else {
self.lock.waiters.borrow_mut().push(cx.waker().clone());
Poll::Pending
}
}
}
pub struct Locked<'a, T> {
data: RefMut<'a, T>,
lock: &'a AsyncLock<T>,
}
impl<'a, T> Deref for Locked<'a, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
self.data.deref()
}
}
impl<'a, T> DerefMut for Locked<'a, T> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.data.deref_mut()
}
}
impl<'a, T> Drop for Locked<'a, T> {
fn drop(&mut self) {
for waiter in self.lock.waiters.borrow_mut().drain(..) {
waiter.wake();
}
}
}

1
src/utils/mod.rs
View file

@ -2,7 +2,6 @@ pub mod asyncevent;
pub mod buffd;
pub mod copyhashmap;
pub mod linkedlist;
pub mod lock;
pub mod numcell;
pub mod oneshot;
pub mod ptr_ext;

8
src/xkbcommon/consts.rs
View file

@ -1,13 +1,5 @@
#![allow(dead_code)]
cenum! {
XkbX11SetupXkbExtensionFlags, XKB_X11_SETUP_XKB_EXTENSION_FLAGS;
XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS = 0,
}
bitor!(XkbX11SetupXkbExtensionFlags);
cenum! {
XkbLogLevel, XKB_LOG_LEVEL;

109
src/xkbcommon/mod.rs
View file

@ -1,4 +1,4 @@
#![allow(non_camel_case_types)]
#![allow(non_camel_case_types, improper_ctypes)]
mod consts;
@ -11,21 +11,11 @@ use std::ops::Deref;
use std::ptr;
use crate::utils::ptr_ext::PtrExt;
use libloading::Library;
use thiserror::Error;
use uapi::c;
use xcb_dl::ffi::xcb_connection_t;
#[derive(Debug, Error)]
pub enum XkbCommonError {
#[error("xkbcommon-x11 could not be loaded")]
LoadXkbCommonX11(#[source] libloading::Error),
#[error("One of the xkbcommon-x11 symbols could not be loaded")]
LoadXkbCommonX11Sym(#[source] libloading::Error),
#[error("Could not create keymap from X11 device")]
CreateKeymapFromDevice,
#[error("Could not create state from X11 device")]
CreateStateFromDevice,
#[error("Could not create an xkbcommon context")]
CreateContext,
#[error("Could not create keymap from names")]
@ -81,10 +71,8 @@ extern "C" {
keymap: *mut xkb_keymap,
format: xkb_keymap_format,
) -> *mut c::c_char;
fn xkb_keymap_ref(keymap: *mut xkb_keymap) -> *mut xkb_keymap;
fn xkb_keymap_unref(keymap: *mut xkb_keymap);
fn xkb_state_unref(state: *mut xkb_state);
fn xkb_state_get_keymap(state: *mut xkb_state) -> *mut xkb_keymap;
}
pub struct XkbContext {
@ -170,16 +158,6 @@ pub struct XkbState {
state: *mut xkb_state,
}
impl XkbState {
pub fn keymap(&self) -> XkbKeymap {
unsafe {
let res = xkb_state_get_keymap(self.state);
xkb_keymap_ref(res);
XkbKeymap { keymap: res }
}
}
}
impl Drop for XkbState {
fn drop(&mut self) {
unsafe {
@ -188,91 +166,6 @@ impl Drop for XkbState {
}
}
pub struct XkbCommonX11 {
library: Library,
fns: XkbCommonX11Fns,
}
struct XkbCommonX11Fns {
xkb_x11_keymap_new_from_device: unsafe fn(
context: *mut xkb_context,
c: *mut xcb_connection_t,
device_id: i32,
flags: xkb_x11_setup_xkb_extension_flags,
) -> *mut xkb_keymap,
xkb_x11_state_new_from_device: unsafe fn(
keymap: *mut xkb_keymap,
c: *mut xcb_connection_t,
device_id: i32,
) -> *mut xkb_state,
}
impl XkbCommonX11 {
pub fn load() -> Result<Self, XkbCommonError> {
let library = unsafe {
match Library::new("libxkbcommon-x11.so") {
Ok(l) => l,
Err(e) => return Err(XkbCommonError::LoadXkbCommonX11(e)),
}
};
let fns = match get_xkbcommon_x11_fns(&library) {
Ok(f) => f,
Err(e) => return Err(XkbCommonError::LoadXkbCommonX11Sym(e)),
};
Ok(Self { library, fns })
}
pub unsafe fn keymap_from_device(
&self,
context: &XkbContext,
c: *mut xcb_connection_t,
device_id: i32,
flags: XkbX11SetupXkbExtensionFlags,
) -> Result<XkbKeymap, XkbCommonError> {
let res = (self.fns.xkb_x11_keymap_new_from_device)(
context.context,
c,
device_id,
flags.raw() as _,
);
if res.is_null() {
return Err(XkbCommonError::CreateKeymapFromDevice);
}
Ok(XkbKeymap { keymap: res })
}
pub unsafe fn state_from_device(
&self,
keymap: &XkbKeymap,
c: *mut xcb_connection_t,
device_id: i32,
) -> Result<XkbState, XkbCommonError> {
let res = (self.fns.xkb_x11_state_new_from_device)(keymap.keymap, c, device_id);
if res.is_null() {
return Err(XkbCommonError::CreateStateFromDevice);
}
Ok(XkbState { state: res })
}
}
fn get_xkbcommon_x11_fns(lib: &Library) -> Result<XkbCommonX11Fns, libloading::Error> {
macro_rules! syms {
($($sym:ident,)*) => {
Ok(XkbCommonX11Fns {
$(
$sym: std::mem::transmute(lib.get::<usize>(concat!(stringify!($sym), "\0").as_bytes())?.into_raw().into_raw()),
)*
})
}
}
unsafe {
syms! {
xkb_x11_keymap_new_from_device,
xkb_x11_state_new_from_device,
}
}
}
unsafe extern "C" fn xkbcommon_logger(
_ctx: *mut xkb_context,
level: xkb_log_level,