vtimofei
/
smithay
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

shell: fix warnings

This commit is contained in:
Victor Berger 2017-09-06 15:21:12 +02:00
parent 6dec2cb5da
commit 3171160cff
3 changed files with 110 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/shell/mod.rs
View File

@ -381,7 +381,9 @@ where
///
/// Returns `None` if the surface does actually no longer exist.
pub fn client(&self) -> Option<ShellClient<SD>> {
if !self.alive() { return None }
if !self.alive() {
return None;
}
match self.shell_surface {
SurfaceKind::Wl(ref s) => {
let &(_, ref shell) =
@ -517,7 +519,9 @@ where
///
/// Returns `None` if the surface does actually no longer exist.
pub fn client(&self) -> Option<ShellClient<SD>> {
if !self.alive() { return None }
if !self.alive() {
return None;
}
match self.shell_surface {
SurfaceKind::Wl(ref s) => {
let &(_, ref shell) =

75
src/shell/wl_handlers.rs
View File

@ -9,7 +9,7 @@ use std::sync::Mutex;
use wayland_protocols::unstable::xdg_shell::server::{zxdg_positioner_v6 as xdg_positioner, zxdg_toplevel_v6};
use wayland_server::{Client, Destroy, EventLoopHandle, Init, Resource};
use wayland_server::{Client, Destroy, EventLoopHandle, Resource};
use wayland_server::protocol::{wl_output, wl_seat, wl_shell, wl_shell_surface, wl_surface};
pub struct WlShellDestructor<SD> {
@ -27,6 +27,8 @@ impl<SD> Destroy<wl_shell::WlShell> for WlShellDestructor<SD> {
let ptr = shell.get_user_data();
shell.set_user_data(::std::ptr::null_mut());
let data = unsafe { Box::from_raw(ptr as *mut ShellUserData<SD>) };
// explicitly call drop to not forget what we're doing here
::std::mem::drop(data);
}
}
@ -45,9 +47,8 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn get_shell_surface(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &wl_shell::WlShell, id: wl_shell_surface::WlShellSurface,
surface: &wl_surface::WlSurface) {
fn get_shell_surface(&mut self, evlh: &mut EventLoopHandle, _: &Client, resource: &wl_shell::WlShell,
id: wl_shell_surface::WlShellSurface, surface: &wl_surface::WlSurface) {
trace!(self.log, "Creating new wl_shell_surface.");
let role_data = ShellSurfaceRole {
pending_state: ShellSurfacePendingState::None,
@ -65,7 +66,7 @@ where
id.set_user_data(
Box::into_raw(Box::new(unsafe { surface.clone_unchecked() })) as *mut _,
);
evqh.register_with_destructor::<_, Self, WlShellDestructor<SD>>(&id, self.my_id);
evlh.register_with_destructor::<_, Self, WlShellDestructor<SD>>(&id, self.my_id);
// register ourselves to the wl_shell for ping handling
let mutex = unsafe { &*(resource.get_user_data() as *mut ShellUserData<SD>) };
@ -98,6 +99,8 @@ impl<SD> Destroy<wl_shell_surface::WlShellSurface> for WlShellDestructor<SD> {
shell_surface.set_user_data(::std::ptr::null_mut());
// drop the WlSurface object
let surface = unsafe { Box::from_raw(ptr as *mut ShellSurfaceUserData) };
// explicitly call drop to not forget what we're doing here
::std::mem::drop(surface);
}
}
@ -145,7 +148,7 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn wl_handle_display_state_change(&mut self, evqh: &mut EventLoopHandle,
fn wl_handle_display_state_change(&mut self, evlh: &mut EventLoopHandle,
resource: &wl_shell_surface::WlShellSurface,
maximized: Option<bool>, minimized: Option<bool>,
fullscreen: Option<bool>, output: Option<&wl_output::WlOutput>) {
@ -153,13 +156,13 @@ where
// handler callback
let configure =
self.handler
.change_display_state(evqh, handle, maximized, minimized, fullscreen, output);
.change_display_state(evlh, handle, maximized, minimized, fullscreen, output);
// send the configure response to client
let (w, h) = configure.size.unwrap_or((0, 0));
resource.configure(wl_shell_surface::None, w, h);
}
fn wl_ensure_toplevel(&mut self, evqh: &mut EventLoopHandle,
fn wl_ensure_toplevel(&mut self, evlh: &mut EventLoopHandle,
resource: &wl_shell_surface::WlShellSurface) {
let ptr = resource.get_user_data();
let &(ref wl_surface, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) };
@ -198,7 +201,7 @@ where
// we need to notify about this new toplevel surface
if need_send {
let handle = make_toplevel_handle(self.token, resource);
let configure = self.handler.new_toplevel(evqh, handle);
let configure = self.handler.new_toplevel(evlh, handle);
send_toplevel_configure(resource, configure);
}
}
@ -212,7 +215,7 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn pong(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn pong(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, serial: u32) {
let &(_, ref shell) = unsafe { &*(resource.get_user_data() as *mut ShellSurfaceUserData) };
let valid = {
@ -226,35 +229,35 @@ where
}
};
if valid {
self.handler.client_pong(evqh, make_shell_client(shell));
self.handler.client_pong(evlh, make_shell_client(shell));
}
}
fn move_(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn move_(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, seat: &wl_seat::WlSeat, serial: u32) {
let handle = make_toplevel_handle(self.token, resource);
self.handler.move_(evqh, handle, seat, serial);
self.handler.move_(evlh, handle, seat, serial);
}
fn resize(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn resize(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, seat: &wl_seat::WlSeat, serial: u32,
edges: wl_shell_surface::Resize) {
let edges = zxdg_toplevel_v6::ResizeEdge::from_raw(edges.bits())
.unwrap_or(zxdg_toplevel_v6::ResizeEdge::None);
let handle = make_toplevel_handle(self.token, resource);
self.handler.resize(evqh, handle, seat, serial, edges);
self.handler.resize(evlh, handle, seat, serial, edges);
}
fn set_toplevel(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_toplevel(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface) {
self.wl_ensure_toplevel(evqh, resource);
self.wl_handle_display_state_change(evqh, resource, Some(false), Some(false), Some(false), None)
self.wl_ensure_toplevel(evlh, resource);
self.wl_handle_display_state_change(evlh, resource, Some(false), Some(false), Some(false), None)
}
fn set_transient(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &wl_shell_surface::WlShellSurface, parent: &wl_surface::WlSurface, x: i32,
y: i32, flags: wl_shell_surface::Transient) {
self.wl_ensure_toplevel(evqh, resource);
fn set_transient(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, parent: &wl_surface::WlSurface, _x: i32,
_y: i32, _flags: wl_shell_surface::Transient) {
self.wl_ensure_toplevel(evlh, resource);
// set the parent
let ptr = resource.get_user_data();
let &(ref wl_surface, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) };
@ -267,20 +270,20 @@ where
})
.unwrap();
// set as regular surface
self.wl_handle_display_state_change(evqh, resource, Some(false), Some(false), Some(false), None)
self.wl_handle_display_state_change(evlh, resource, Some(false), Some(false), Some(false), None)
}
fn set_fullscreen(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_fullscreen(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface,
method: wl_shell_surface::FullscreenMethod, framerate: u32,
_method: wl_shell_surface::FullscreenMethod, _framerate: u32,
output: Option<&wl_output::WlOutput>) {
self.wl_ensure_toplevel(evqh, resource);
self.wl_handle_display_state_change(evqh, resource, Some(false), Some(false), Some(true), output)
self.wl_ensure_toplevel(evlh, resource);
self.wl_handle_display_state_change(evlh, resource, Some(false), Some(false), Some(true), output)
}
fn set_popup(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_popup(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, seat: &wl_seat::WlSeat, serial: u32,
parent: &wl_surface::WlSurface, x: i32, y: i32, flags: wl_shell_surface::Transient) {
parent: &wl_surface::WlSurface, x: i32, y: i32, _: wl_shell_surface::Transient) {
let ptr = resource.get_user_data();
let &(ref wl_surface, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) };
// we are reseting the popup state, so remove this surface from everywhere
@ -319,17 +322,19 @@ where
// notify the handler about this new popup
let handle = make_popup_handle(self.token, resource);
let configure = self.handler.new_popup(evqh, handle);
let configure = self.handler.new_popup(evlh, handle);
send_popup_configure(resource, configure);
self.handler
.grab(evlh, make_popup_handle(self.token, resource), seat, serial);
}
fn set_maximized(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_maximized(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, output: Option<&wl_output::WlOutput>) {
self.wl_ensure_toplevel(evqh, resource);
self.wl_handle_display_state_change(evqh, resource, Some(true), Some(false), Some(false), output)
self.wl_ensure_toplevel(evlh, resource);
self.wl_handle_display_state_change(evlh, resource, Some(true), Some(false), Some(false), output)
}
fn set_title(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_title(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, title: String) {
let ptr = resource.get_user_data();
let &(ref surface, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) };
@ -343,7 +348,7 @@ where
.expect("wl_shell_surface exists but wl_surface has wrong role?!");
}
fn set_class(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_class(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &wl_shell_surface::WlShellSurface, class_: String) {
let ptr = resource.get_user_data();
let &(ref surface, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) };

123
src/shell/xdg_handlers.rs
View File

@ -9,7 +9,7 @@ use std::sync::Mutex;
use wayland_protocols::unstable::xdg_shell::server::{zxdg_popup_v6, zxdg_positioner_v6, zxdg_shell_v6,
zxdg_surface_v6, zxdg_toplevel_v6};
use wayland_server::{Client, Destroy, EventLoopHandle, Init, Resource};
use wayland_server::{Client, Destroy, EventLoopHandle, Resource};
use wayland_server::protocol::{wl_output, wl_seat, wl_surface};
pub struct XdgShellDestructor<SD> {
@ -27,6 +27,8 @@ impl<SD> Destroy<zxdg_shell_v6::ZxdgShellV6> for XdgShellDestructor<SD> {
let ptr = shell.get_user_data();
shell.set_user_data(::std::ptr::null_mut());
let data = unsafe { Box::from_raw(ptr as *mut ShellUserData<SD>) };
// explicit call to drop to not forget what we're doing here
::std::mem::drop(data);
}
}
@ -45,11 +47,9 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn destroy(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &zxdg_shell_v6::ZxdgShellV6) {
}
fn create_positioner(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &zxdg_shell_v6::ZxdgShellV6, id: zxdg_positioner_v6::ZxdgPositionerV6) {
fn destroy(&mut self, _: &mut EventLoopHandle, _: &Client, _: &zxdg_shell_v6::ZxdgShellV6) {}
fn create_positioner(&mut self, evlh: &mut EventLoopHandle, _: &Client,
_: &zxdg_shell_v6::ZxdgShellV6, id: zxdg_positioner_v6::ZxdgPositionerV6) {
trace!(self.log, "Creating new xdg_positioner.");
id.set_user_data(Box::into_raw(Box::new(PositionerState {
rect_size: (0, 0),
@ -64,9 +64,9 @@ where
constraint_adjustment: zxdg_positioner_v6::ConstraintAdjustment::empty(),
offset: (0, 0),
})) as *mut _);
evqh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
evlh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
}
fn get_xdg_surface(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn get_xdg_surface(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_shell_v6::ZxdgShellV6, id: zxdg_surface_v6::ZxdgSurfaceV6,
surface: &wl_surface::WlSurface) {
trace!(self.log, "Creating new wl_shell_surface.");
@ -88,10 +88,10 @@ where
resource.clone_unchecked()
}))) as *mut _,
);
evqh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
evlh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
}
fn pong(&mut self, evqh: &mut EventLoopHandle, client: &Client, resource: &zxdg_shell_v6::ZxdgShellV6,
fn pong(&mut self, evlh: &mut EventLoopHandle, _: &Client, resource: &zxdg_shell_v6::ZxdgShellV6,
serial: u32) {
let valid = {
let mutex = unsafe { &*(resource.get_user_data() as *mut ShellUserData<SD>) };
@ -104,7 +104,7 @@ where
}
};
if valid {
self.handler.client_pong(evqh, make_shell_client(resource));
self.handler.client_pong(evlh, make_shell_client(resource));
}
}
}
@ -125,6 +125,8 @@ impl<SD> Destroy<zxdg_positioner_v6::ZxdgPositionerV6> for XdgShellDestructor<SD
positioner.set_user_data(::std::ptr::null_mut());
// drop the PositionerState
let surface = unsafe { Box::from_raw(ptr as *mut PositionerState) };
// explicit call to drop to not forget what we're doing here
::std::mem::drop(surface);
}
}
@ -136,11 +138,9 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn destroy(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &zxdg_positioner_v6::ZxdgPositionerV6) {
}
fn destroy(&mut self, _: &mut EventLoopHandle, _: &Client, _: &zxdg_positioner_v6::ZxdgPositionerV6) {}
fn set_size(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_size(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_positioner_v6::ZxdgPositionerV6, width: i32, height: i32) {
if width < 1 || height < 1 {
resource.post_error(
@ -154,7 +154,7 @@ where
}
}
fn set_anchor_rect(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_anchor_rect(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_positioner_v6::ZxdgPositionerV6, x: i32, y: i32, width: i32,
height: i32) {
if width < 1 || height < 1 {
@ -174,7 +174,7 @@ where
}
}
fn set_anchor(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_anchor(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_positioner_v6::ZxdgPositionerV6, anchor: zxdg_positioner_v6::Anchor) {
use self::zxdg_positioner_v6::{AnchorBottom, AnchorLeft, AnchorRight, AnchorTop};
if anchor.contains(AnchorLeft | AnchorRight) || anchor.contains(AnchorTop | AnchorBottom) {
@ -189,7 +189,7 @@ where
}
}
fn set_gravity(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_gravity(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_positioner_v6::ZxdgPositionerV6, gravity: zxdg_positioner_v6::Gravity) {
use self::zxdg_positioner_v6::{GravityBottom, GravityLeft, GravityRight, GravityTop};
if gravity.contains(GravityLeft | GravityRight) || gravity.contains(GravityTop | GravityBottom) {
@ -204,7 +204,7 @@ where
}
}
fn set_constraint_adjustment(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_constraint_adjustment(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_positioner_v6::ZxdgPositionerV6,
constraint_adjustment: u32) {
let constraint_adjustment =
@ -214,7 +214,7 @@ where
state.constraint_adjustment = constraint_adjustment;
}
fn set_offset(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_offset(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_positioner_v6::ZxdgPositionerV6, x: i32, y: i32) {
let ptr = resource.get_user_data();
let state = unsafe { &mut *(ptr as *mut PositionerState) };
@ -242,6 +242,8 @@ impl<SD> Destroy<zxdg_surface_v6::ZxdgSurfaceV6> for XdgShellDestructor<SD> {
ptr as *mut (zxdg_surface_v6::ZxdgSurfaceV6, zxdg_shell_v6::ZxdgShellV6),
)
};
// explicit call to drop to not forget what we're doing here
::std::mem::drop(data);
}
}
@ -253,8 +255,7 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn destroy(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &zxdg_surface_v6::ZxdgSurfaceV6) {
fn destroy(&mut self, _: &mut EventLoopHandle, _: &Client, resource: &zxdg_surface_v6::ZxdgSurfaceV6) {
let ptr = resource.get_user_data();
let &(ref surface, ref shell) =
unsafe { &*(ptr as *mut (wl_surface::WlSurface, zxdg_shell_v6::ZxdgShellV6)) };
@ -274,7 +275,7 @@ where
);
}
fn get_toplevel(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn get_toplevel(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_surface_v6::ZxdgSurfaceV6, id: zxdg_toplevel_v6::ZxdgToplevelV6) {
let ptr = resource.get_user_data();
let &(ref surface, ref shell) =
@ -300,7 +301,7 @@ where
resource.clone_unchecked(),
)
})) as *mut _);
evqh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
evlh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
// register to self
self.known_toplevels
@ -308,11 +309,11 @@ where
// intial configure event
let handle = make_toplevel_handle(self.token, &id);
let configure = self.handler.new_toplevel(evqh, handle);
let configure = self.handler.new_toplevel(evlh, handle);
send_toplevel_configure(self.token, &id, configure);
}
fn get_popup(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn get_popup(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_surface_v6::ZxdgSurfaceV6, id: zxdg_popup_v6::ZxdgPopupV6,
parent: &zxdg_surface_v6::ZxdgSurfaceV6,
positioner: &zxdg_positioner_v6::ZxdgPositionerV6) {
@ -324,7 +325,7 @@ where
let parent_ptr = parent.get_user_data();
let &(ref parent_surface, _) =
unsafe { &*(ptr as *mut (wl_surface::WlSurface, zxdg_shell_v6::ZxdgShellV6)) };
unsafe { &*(parent_ptr as *mut (wl_surface::WlSurface, zxdg_shell_v6::ZxdgShellV6)) };
self.token
.with_role_data::<ShellSurfaceRole, _, _>(surface, |data| {
@ -344,18 +345,18 @@ where
resource.clone_unchecked(),
)
})) as *mut _);
evqh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
evlh.register_with_destructor::<_, Self, XdgShellDestructor<SD>>(&id, self.my_id);
// register to self
self.known_popups.push(make_popup_handle(self.token, &id));
// intial configure event
let handle = make_popup_handle(self.token, &id);
let configure = self.handler.new_popup(evqh, handle);
let configure = self.handler.new_popup(evlh, handle);
send_popup_configure(self.token, &id, configure);
}
fn set_window_geometry(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_window_geometry(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_surface_v6::ZxdgSurfaceV6, x: i32, y: i32, width: i32,
height: i32) {
let ptr = resource.get_user_data();
@ -375,7 +376,7 @@ where
);
}
fn ack_configure(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn ack_configure(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_surface_v6::ZxdgSurfaceV6, serial: u32) {
let ptr = resource.get_user_data();
let &(ref surface, ref shell) =
@ -426,6 +427,8 @@ impl<SD> Destroy<zxdg_toplevel_v6::ZxdgToplevelV6> for XdgShellDestructor<SD> {
surface.set_user_data(::std::ptr::null_mut());
// drop the PositionerState
let data = unsafe { Box::from_raw(ptr as *mut ShellSurfaceUserData) };
// explicit call to drop to not forget what we're doing there
::std::mem::drop(data);
}
}
@ -454,7 +457,7 @@ where
);
}
fn xdg_handle_display_state_change(&mut self, evqh: &mut EventLoopHandle,
fn xdg_handle_display_state_change(&mut self, evlh: &mut EventLoopHandle,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6,
maximized: Option<bool>, minimized: Option<bool>,
fullscreen: Option<bool>, output: Option<&wl_output::WlOutput>) {
@ -462,7 +465,7 @@ where
// handler callback
let configure =
self.handler
.change_display_state(evqh, handle, maximized, minimized, fullscreen, output);
.change_display_state(evlh, handle, maximized, minimized, fullscreen, output);
// send the configure response to client
send_toplevel_configure(self.token, resource, configure);
}
@ -520,8 +523,7 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn destroy(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6) {
fn destroy(&mut self, _: &mut EventLoopHandle, _: &Client, resource: &zxdg_toplevel_v6::ZxdgToplevelV6) {
let ptr = resource.get_user_data();
let &(ref surface, _, _) = unsafe { &*(ptr as *mut ShellSurfaceUserData) };
self.token
@ -541,7 +543,7 @@ where
});
}
fn set_parent(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_parent(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6,
parent: Option<&zxdg_toplevel_v6::ZxdgToplevelV6>) {
self.with_surface_toplevel_data(resource, |toplevel_data| {
@ -554,75 +556,75 @@ where
});
}
fn set_title(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_title(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, title: String) {
self.with_surface_toplevel_data(resource, |toplevel_data| { toplevel_data.title = title; });
}
fn set_app_id(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_app_id(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, app_id: String) {
self.with_surface_toplevel_data(resource, |toplevel_data| { toplevel_data.app_id = app_id; });
}
fn show_window_menu(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn show_window_menu(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, seat: &wl_seat::WlSeat, serial: u32,
x: i32, y: i32) {
let handle = make_toplevel_handle(self.token, resource);
self.handler
.show_window_menu(evqh, handle, seat, serial, x, y);
.show_window_menu(evlh, handle, seat, serial, x, y);
}
fn move_(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn move_(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, seat: &wl_seat::WlSeat, serial: u32) {
let handle = make_toplevel_handle(self.token, resource);
self.handler.move_(evqh, handle, seat, serial);
self.handler.move_(evlh, handle, seat, serial);
}
fn resize(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn resize(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, seat: &wl_seat::WlSeat, serial: u32, edges: u32) {
let edges =
zxdg_toplevel_v6::ResizeEdge::from_raw(edges).unwrap_or(zxdg_toplevel_v6::ResizeEdge::None);
let handle = make_toplevel_handle(self.token, resource);
self.handler.resize(evqh, handle, seat, serial, edges);
self.handler.resize(evlh, handle, seat, serial, edges);
}
fn set_max_size(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_max_size(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, width: i32, height: i32) {
self.with_surface_toplevel_data(resource, |toplevel_data| {
toplevel_data.max_size = (width, height);
});
}
fn set_min_size(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_min_size(&mut self, _: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, width: i32, height: i32) {
self.with_surface_toplevel_data(resource, |toplevel_data| {
toplevel_data.min_size = (width, height);
});
}
fn set_maximized(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_maximized(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6) {
self.xdg_handle_display_state_change(evqh, resource, Some(true), None, None, None);
self.xdg_handle_display_state_change(evlh, resource, Some(true), None, None, None);
}
fn unset_maximized(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn unset_maximized(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6) {
self.xdg_handle_display_state_change(evqh, resource, Some(false), None, None, None);
self.xdg_handle_display_state_change(evlh, resource, Some(false), None, None, None);
}
fn set_fullscreen(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_fullscreen(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6, output: Option<&wl_output::WlOutput>) {
self.xdg_handle_display_state_change(evqh, resource, None, None, Some(true), output);
self.xdg_handle_display_state_change(evlh, resource, None, None, Some(true), output);
}
fn unset_fullscreen(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn unset_fullscreen(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6) {
self.xdg_handle_display_state_change(evqh, resource, None, None, Some(false), None);
self.xdg_handle_display_state_change(evlh, resource, None, None, Some(false), None);
}
fn set_minimized(&mut self, evqh: &mut EventLoopHandle, client: &Client,
fn set_minimized(&mut self, evlh: &mut EventLoopHandle, _: &Client,
resource: &zxdg_toplevel_v6::ZxdgToplevelV6) {
self.xdg_handle_display_state_change(evqh, resource, None, Some(true), None, None);
self.xdg_handle_display_state_change(evlh, resource, None, Some(true), None, None);
}
}
@ -644,6 +646,8 @@ impl<SD> Destroy<zxdg_popup_v6::ZxdgPopupV6> for XdgShellDestructor<SD> {
surface.set_user_data(::std::ptr::null_mut());
// drop the PositionerState
let data = unsafe { Box::from_raw(ptr as *mut ShellSurfaceUserData) };
// explicit call to drop to not forget what we're doing
::std::mem::drop(data);
}
}
@ -689,8 +693,7 @@ where
SH: UserHandler<U, R, H, SD> + Send + 'static,
SD: Send + 'static,
{
fn destroy(&mut self, evqh: &mut EventLoopHandle, client: &Client,
resource: &zxdg_popup_v6::ZxdgPopupV6) {
fn destroy(&mut self, _: &mut EventLoopHandle, _: &Client, resource: &zxdg_popup_v6::ZxdgPopupV6) {
let ptr = resource.get_user_data();
let &(ref surface, _, _) = unsafe {
&*(ptr as
@ -717,10 +720,10 @@ where
});
}
fn grab(&mut self, evqh: &mut EventLoopHandle, client: &Client, resource: &zxdg_popup_v6::ZxdgPopupV6,
fn grab(&mut self, evlh: &mut EventLoopHandle, _: &Client, resource: &zxdg_popup_v6::ZxdgPopupV6,
seat: &wl_seat::WlSeat, serial: u32) {
let handle = make_popup_handle(self.token, resource);
self.handler.grab(evqh, handle, seat, serial);
self.handler.grab(evlh, handle, seat, serial);
}
}