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

Fix formatting

This commit is contained in:
Drakulix 2017-04-26 20:10:22 +02:00
parent 4c5e2be11e
commit f7d3b3dee3
5 changed files with 186 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
src/backend/glutin.rs
View File

@ -4,9 +4,12 @@
use backend::{SeatInternal, TouchSlotInternal};
use backend::graphics::GraphicsBackend;
use backend::graphics::opengl::{Api, OpenglGraphicsBackend, PixelFormat, SwapBuffersError};
use backend::input::{Axis, AxisSource, InputBackend, InputHandler, KeyState, MouseButton, MouseButtonState,
Seat, SeatCapabilities, TouchSlot, Event as BackendEvent, KeyboardKeyEvent, PointerAxisEvent, PointerButtonEvent, PointerMotionAbsoluteEvent, TouchDownEvent, TouchUpEvent, TouchMotionEvent, TouchCancelEvent};
use glutin::{Api as GlutinApi, MouseButton as GlutinMouseButton, PixelFormat as GlutinPixelFormat, MouseCursor};
use backend::input::{Axis, AxisSource, Event as BackendEvent, InputBackend, InputHandler, KeyState,
KeyboardKeyEvent, MouseButton, MouseButtonState, PointerAxisEvent, PointerButtonEvent,
PointerMotionAbsoluteEvent, Seat, SeatCapabilities, TouchCancelEvent, TouchDownEvent,
TouchMotionEvent, TouchSlot, TouchUpEvent};
use glutin::{Api as GlutinApi, MouseButton as GlutinMouseButton, MouseCursor,
PixelFormat as GlutinPixelFormat};
use glutin::{ContextError, CreationError, ElementState, Event, GlContext, HeadlessContext,
HeadlessRendererBuilder, MouseScrollDelta, Touch, TouchPhase, Window, WindowBuilder};
use nix::c_void;
@ -85,7 +88,7 @@ impl GraphicsBackend for GlutinHeadlessRenderer {
type CursorFormat = ();
fn set_cursor_position(&mut self, _x: u32, _y: u32) -> Result<(), ()> {
//FIXME: Maybe save position? Is it of any use?
// FIXME: Maybe save position? Is it of any use?
Ok(())
}
@ -290,11 +293,21 @@ impl PointerMotionAbsoluteEvent for GlutinMouseMovedEvent {
}
fn x_transformed(&self, width: u32) -> u32 {
cmp::min(self.x * width as i32 / self.window.get_inner_size_points().unwrap_or((width, 0)).0 as i32, 0) as u32
cmp::min(self.x * width as i32 /
self.window
.get_inner_size_points()
.unwrap_or((width, 0))
.0 as i32,
0) as u32
}
fn y_transformed(&self, height: u32) -> u32 {
cmp::min(self.y * height as i32 / self.window.get_inner_size_points().unwrap_or((0, height)).1 as i32, 0) as u32
cmp::min(self.y * height as i32 /
self.window
.get_inner_size_points()
.unwrap_or((0, height))
.1 as i32,
0) as u32
}
}
@ -326,8 +339,10 @@ impl PointerAxisEvent for GlutinMouseWheelEvent {
fn amount(&self) -> f64 {
match (self.axis, self.delta) {
(Axis::Horizontal, MouseScrollDelta::LineDelta(x, _)) | (Axis::Horizontal, MouseScrollDelta::PixelDelta(x, _)) => x as f64,
(Axis::Vertical, MouseScrollDelta::LineDelta(_, y)) | (Axis::Vertical, MouseScrollDelta::PixelDelta(_, y)) => y as f64,
(Axis::Horizontal, MouseScrollDelta::LineDelta(x, _)) |
(Axis::Horizontal, MouseScrollDelta::PixelDelta(x, _)) => x as f64,
(Axis::Vertical, MouseScrollDelta::LineDelta(_, y)) |
(Axis::Vertical, MouseScrollDelta::PixelDelta(_, y)) => y as f64,
}
}
}
@ -385,11 +400,21 @@ impl TouchDownEvent for GlutinTouchStartedEvent {
}
fn x_transformed(&self, width: u32) -> u32 {
cmp::min(self.location.0 as i32 * width as i32 / self.window.get_inner_size_points().unwrap_or((width, 0)).0 as i32, 0) as u32
cmp::min(self.location.0 as i32 * width as i32 /
self.window
.get_inner_size_points()
.unwrap_or((width, 0))
.0 as i32,
0) as u32
}
fn y_transformed(&self, height: u32) -> u32 {
cmp::min(self.location.1 as i32 * height as i32 / self.window.get_inner_size_points().unwrap_or((0, height)).1 as i32, 0) as u32
cmp::min(self.location.1 as i32 * height as i32 /
self.window
.get_inner_size_points()
.unwrap_or((0, height))
.1 as i32,
0) as u32
}
}
@ -422,11 +447,19 @@ impl TouchMotionEvent for GlutinTouchMovedEvent {
}
fn x_transformed(&self, width: u32) -> u32 {
self.location.0 as u32 * width / self.window.get_inner_size_points().unwrap_or((width, 0)).0
self.location.0 as u32 * width /
self.window
.get_inner_size_points()
.unwrap_or((width, 0))
.0
}
fn y_transformed(&self, height: u32) -> u32 {
self.location.1 as u32 * height / self.window.get_inner_size_points().unwrap_or((0, height)).1
self.location.1 as u32 * height /
self.window
.get_inner_size_points()
.unwrap_or((0, height))
.1
}
}
@ -526,7 +559,9 @@ impl InputBackend for GlutinInputBackend {
Event::KeyboardInput(state, key_code, _) => {
match state {
ElementState::Pressed => self.key_counter += 1,
ElementState::Released => self.key_counter = self.key_counter.checked_sub(1).unwrap_or(0),
ElementState::Released => {
self.key_counter = self.key_counter.checked_sub(1).unwrap_or(0)
}
};
handler.on_keyboard_key(&self.seat,
GlutinKeyboardInputEvent {
@ -537,21 +572,23 @@ impl InputBackend for GlutinInputBackend {
})
}
Event::MouseMoved(x, y) => {
handler.on_pointer_move_absolute(&self.seat, GlutinMouseMovedEvent {
window: self.window.clone(),
time: self.time_counter,
x: x,
y: y,
})
handler.on_pointer_move_absolute(&self.seat,
GlutinMouseMovedEvent {
window: self.window.clone(),
time: self.time_counter,
x: x,
y: y,
})
}
Event::MouseWheel(delta, _) => {
let event = GlutinMouseWheelEvent {
axis: Axis::Horizontal,
time: self.time_counter,
delta: delta,
};
axis: Axis::Horizontal,
time: self.time_counter,
delta: delta,
};
match delta {
MouseScrollDelta::LineDelta(x, y) | MouseScrollDelta::PixelDelta(x, y) => {
MouseScrollDelta::LineDelta(x, y) |
MouseScrollDelta::PixelDelta(x, y) => {
if x != 0.0 {
handler.on_pointer_axis(&self.seat, event.clone());
}
@ -562,11 +599,12 @@ impl InputBackend for GlutinInputBackend {
}
}
Event::MouseInput(state, button) => {
handler.on_pointer_button(&self.seat, GlutinMouseInputEvent {
time: self.time_counter,
button: button,
state: state,
})
handler.on_pointer_button(&self.seat,
GlutinMouseInputEvent {
time: self.time_counter,
button: button,
state: state,
})
}
Event::Touch(Touch {
phase: TouchPhase::Started,
@ -574,12 +612,12 @@ impl InputBackend for GlutinInputBackend {
id,
}) => {
handler.on_touch_down(&self.seat,
GlutinTouchStartedEvent {
window: self.window.clone(),
time: self.time_counter,
location: (x, y),
id: id,
})
GlutinTouchStartedEvent {
window: self.window.clone(),
time: self.time_counter,
location: (x, y),
id: id,
})
}
Event::Touch(Touch {
phase: TouchPhase::Moved,
@ -587,12 +625,12 @@ impl InputBackend for GlutinInputBackend {
id,
}) => {
handler.on_touch_motion(&self.seat,
GlutinTouchMovedEvent {
window: self.window.clone(),
time: self.time_counter,
location: (x, y),
id: id,
})
GlutinTouchMovedEvent {
window: self.window.clone(),
time: self.time_counter,
location: (x, y),
id: id,
})
}
Event::Touch(Touch {
phase: TouchPhase::Ended,
@ -600,17 +638,17 @@ impl InputBackend for GlutinInputBackend {
id,
}) => {
handler.on_touch_motion(&self.seat,
GlutinTouchMovedEvent {
window: self.window.clone(),
time: self.time_counter,
location: (x, y),
id: id,
});
GlutinTouchMovedEvent {
window: self.window.clone(),
time: self.time_counter,
location: (x, y),
id: id,
});
handler.on_touch_up(&self.seat,
GlutinTouchEndedEvent {
time: self.time_counter,
id: id,
});
GlutinTouchEndedEvent {
time: self.time_counter,
id: id,
});
}
Event::Touch(Touch {
phase: TouchPhase::Cancelled,
@ -618,10 +656,10 @@ impl InputBackend for GlutinInputBackend {
..
}) => {
handler.on_touch_cancel(&self.seat,
GlutinTouchCancelledEvent {
time: self.time_counter,
id: id,
})
GlutinTouchCancelledEvent {
time: self.time_counter,
id: id,
})
}
Event::Closed => return Err(GlutinInputError::WindowClosed),
_ => {}

2
src/backend/graphics/opengl.rs
View File

@ -1,8 +1,8 @@
//! Common traits and types for opengl rendering on graphics backends
use nix::c_void;
use super::GraphicsBackend;
use nix::c_void;
/// Error that can happen when swapping buffers.
#[derive(Debug, Clone)]

4
src/backend/graphics/software.rs
View File

@ -1,9 +1,9 @@
//! Common traits and types used for software rendering on graphics backends
use std::error::Error;
use wayland_server::protocol::wl_shm::Format;
use super::GraphicsBackend;
use std::error::Error;
use wayland_server::protocol::wl_shm::Format;
/// Trait that describes objects providing a software rendering implementation
pub trait CpuGraphicsBackend<E: Error>: GraphicsBackend {

4
src/backend/input.rs
View File

@ -48,7 +48,9 @@ impl ::std::cmp::PartialEq for Seat {
}
impl ::std::hash::Hash for Seat {
fn hash<H>(&self, state: &mut H) where H: ::std::hash::Hasher {
fn hash<H>(&self, state: &mut H)
where H: ::std::hash::Hasher
{
self.id.hash(state);
}
}

139
src/backend/libinput.rs
View File

@ -4,10 +4,10 @@ use backend::{SeatInternal, TouchSlotInternal};
use backend::input as backend;
use input as libinput;
use input::event;
use std::io::Error as IoError;
use std::collections::hash_map::{DefaultHasher, Entry, HashMap};
use std::hash::{Hash, Hasher};
use std::io::Error as IoError;
use std::rc::Rc;
/// Libinput based `InputBackend`.
@ -48,12 +48,12 @@ impl backend::Event for event::keyboard::KeyboardKeyEvent {
impl backend::KeyboardKeyEvent for event::keyboard::KeyboardKeyEvent {
fn key_code(&self) -> u32 {
use ::input::event::keyboard::KeyboardEventTrait;
use input::event::keyboard::KeyboardEventTrait;
self.key()
}
fn state(&self) -> backend::KeyState {
use ::input::event::keyboard::KeyboardEventTrait;
use input::event::keyboard::KeyboardEventTrait;
self.key_state().into()
}
@ -70,7 +70,7 @@ pub struct PointerAxisEvent {
impl<'a> backend::Event for PointerAxisEvent {
fn time(&self) -> u32 {
use ::input::event::pointer::PointerEventTrait;
use input::event::pointer::PointerEventTrait;
self.event.time()
}
}
@ -86,10 +86,10 @@ impl<'a> backend::PointerAxisEvent for PointerAxisEvent {
fn amount(&self) -> f64 {
match self.source() {
backend::AxisSource::Finger | backend::AxisSource::Continuous =>
self.event.axis_value(self.axis),
backend::AxisSource::Wheel | backend::AxisSource::WheelTilt =>
self.event.axis_value_discrete(self.axis).unwrap(),
backend::AxisSource::Finger |
backend::AxisSource::Continuous => self.event.axis_value(self.axis),
backend::AxisSource::Wheel |
backend::AxisSource::WheelTilt => self.event.axis_value_discrete(self.axis).unwrap(),
}
}
}
@ -324,18 +324,19 @@ impl backend::InputBackend for LibinputInputBackend {
trace!(self.logger, "Calling on_seat_changed with {:?}", old_seat);
handler.on_seat_changed(&old_seat);
}
},
}
Entry::Vacant(seat_entry) => {
let mut hasher = DefaultHasher::default();
seat_entry.key().hash(&mut hasher);
let seat = seat_entry.insert(backend::Seat::new(hasher.finish(), new_caps));
let seat = seat_entry.insert(backend::Seat::new(hasher.finish(),
new_caps));
if let Some(ref mut handler) = self.handler {
trace!(self.logger, "Calling on_seat_created with {:?}", seat);
handler.on_seat_created(&seat);
}
}
}
},
}
DeviceEvent::Removed(device_removed_event) => {
let removed = device_removed_event.device();
@ -347,9 +348,21 @@ impl backend::InputBackend for LibinputInputBackend {
// update capabilities, so they appear correctly on `on_seat_changed` and `on_seat_destroyed`.
if let Some(seat) = self.seats.get_mut(&device_seat) {
let caps = seat.capabilities_mut();
caps.pointer = self.devices.iter().filter(|x| x.seat() == device_seat).any(|x| x.has_capability(libinput::DeviceCapability::Pointer));
caps.keyboard = self.devices.iter().filter(|x| x.seat() == device_seat).any(|x| x.has_capability(libinput::DeviceCapability::Keyboard));
caps.touch = self.devices.iter().filter(|x| x.seat() == device_seat).any(|x| x.has_capability(libinput::DeviceCapability::Touch));
caps.pointer =
self.devices
.iter()
.filter(|x| x.seat() == device_seat)
.any(|x| x.has_capability(libinput::DeviceCapability::Pointer));
caps.keyboard =
self.devices
.iter()
.filter(|x| x.seat() == device_seat)
.any(|x| x.has_capability(libinput::DeviceCapability::Keyboard));
caps.touch =
self.devices
.iter()
.filter(|x| x.seat() == device_seat)
.any(|x| x.has_capability(libinput::DeviceCapability::Touch));
} else {
panic!("Seat changed that was never created")
}
@ -373,95 +386,117 @@ impl backend::InputBackend for LibinputInputBackend {
handler.on_seat_changed(&seat);
}
}
},
}
}
if let Some(ref mut handler) = self.handler {
handler.on_input_config_changed(&mut self.devices);
handler.on_input_config_changed(&mut self.devices);
}
},
}
libinput::Event::Touch(touch_event) => {
use ::input::event::touch::*;
use input::event::touch::*;
if let Some(ref mut handler) = self.handler {
let device_seat = touch_event.device().seat();
let seat = &self.seats.get(&device_seat).expect("Recieved key event of non existing Seat");
let seat = &self.seats
.get(&device_seat)
.expect("Recieved key event of non existing Seat");
match touch_event {
TouchEvent::Down(down_event) => {
trace!(self.logger, "Calling on_touch_down with {:?}", down_event);
handler.on_touch_down(seat, down_event)
},
}
TouchEvent::Motion(motion_event) => {
trace!(self.logger, "Calling on_touch_motion with {:?}", motion_event);
trace!(self.logger,
"Calling on_touch_motion with {:?}",
motion_event);
handler.on_touch_motion(seat, motion_event)
},
}
TouchEvent::Up(up_event) => {
trace!(self.logger, "Calling on_touch_up with {:?}", up_event);
handler.on_touch_up(seat, up_event)
},
}
TouchEvent::Cancel(cancel_event) => {
trace!(self.logger, "Calling on_touch_cancel with {:?}", cancel_event);
trace!(self.logger,
"Calling on_touch_cancel with {:?}",
cancel_event);
handler.on_touch_cancel(seat, cancel_event)
},
}
TouchEvent::Frame(frame_event) => {
trace!(self.logger, "Calling on_touch_frame with {:?}", frame_event);
handler.on_touch_frame(seat, frame_event)
},
}
}
}
},
}
libinput::Event::Keyboard(keyboard_event) => {
use ::input::event::keyboard::*;
use input::event::keyboard::*;
match keyboard_event {
KeyboardEvent::Key(key_event) => {
if let Some(ref mut handler) = self.handler {
let device_seat = key_event.device().seat();
let seat = &self.seats.get(&device_seat).expect("Recieved key event of non existing Seat");
let seat = &self.seats
.get(&device_seat)
.expect("Recieved key event of non existing Seat");
trace!(self.logger, "Calling on_keyboard_key with {:?}", key_event);
handler.on_keyboard_key(seat, key_event);
}
}
}
},
}
libinput::Event::Pointer(pointer_event) => {
use ::input::event::pointer::*;
use input::event::pointer::*;
if let Some(ref mut handler) = self.handler {
let device_seat = pointer_event.device().seat();
let seat = &self.seats.get(&device_seat).expect("Recieved key event of non existing Seat");
let seat = &self.seats
.get(&device_seat)
.expect("Recieved key event of non existing Seat");
match pointer_event {
PointerEvent::Motion(motion_event) => {
trace!(self.logger, "Calling on_pointer_move with {:?}", motion_event);
trace!(self.logger,
"Calling on_pointer_move with {:?}",
motion_event);
handler.on_pointer_move(seat, motion_event);
},
}
PointerEvent::MotionAbsolute(motion_abs_event) => {
trace!(self.logger, "Calling on_pointer_move_absolute with {:?}", motion_abs_event);
trace!(self.logger,
"Calling on_pointer_move_absolute with {:?}",
motion_abs_event);
handler.on_pointer_move_absolute(seat, motion_abs_event);
},
}
PointerEvent::Axis(axis_event) => {
let rc_axis_event = Rc::new(axis_event);
if rc_axis_event.has_axis(Axis::Vertical) {
trace!(self.logger, "Calling on_pointer_axis for Axis::Vertical with {:?}", *rc_axis_event);
handler.on_pointer_axis(seat, self::PointerAxisEvent {
axis: Axis::Vertical,
event: rc_axis_event.clone()
});
trace!(self.logger,
"Calling on_pointer_axis for Axis::Vertical with {:?}",
*rc_axis_event);
handler.on_pointer_axis(seat,
self::PointerAxisEvent {
axis: Axis::Vertical,
event: rc_axis_event.clone(),
});
}
if rc_axis_event.has_axis(Axis::Horizontal) {
trace!(self.logger, "Calling on_pointer_axis for Axis::Horizontal with {:?}", *rc_axis_event);
handler.on_pointer_axis(seat, self::PointerAxisEvent {
axis: Axis::Horizontal,
event: rc_axis_event.clone()
});
trace!(self.logger,
"Calling on_pointer_axis for Axis::Horizontal with {:?}",
*rc_axis_event);
handler.on_pointer_axis(seat,
self::PointerAxisEvent {
axis: Axis::Horizontal,
event: rc_axis_event.clone(),
});
}
},
}
PointerEvent::Button(button_event) => {
trace!(self.logger, "Calling on_pointer_button with {:?}", button_event);
trace!(self.logger,
"Calling on_pointer_button with {:?}",
button_event);
handler.on_pointer_button(seat, button_event);
}
}
}
},
_ => {}, //FIXME: What to do with the rest.
}
_ => {} //FIXME: What to do with the rest.
}
};
}
Ok(())
}
}