state: Add basic input handling
This commit is contained in:
Victoria Brekenfeld
parent
e7ecfc8903
commit
d0304415eb
6 changed files with 503 additions and 43 deletions
392
src/input/mod.rs
392
src/input/mod.rs
|
|
@ -3,19 +3,66 @@
|
|||
use crate::state::State;
|
||||
use smithay::{
|
||||
backend::input::{Device, DeviceCapability, InputBackend, InputEvent},
|
||||
reexports::wayland_server::Display,
|
||||
desktop::{layer_map_for_output, Space},
|
||||
reexports::wayland_server::{protocol::wl_surface::WlSurface, Display},
|
||||
utils::{Logical, Point},
|
||||
wayland::{
|
||||
data_device::set_data_device_focus,
|
||||
output::Output,
|
||||
seat::{CursorImageStatus, Keysym, Seat, XkbConfig},
|
||||
seat::{CursorImageStatus, FilterResult, Keysym, Seat, XkbConfig},
|
||||
shell::wlr_layer::Layer as WlrLayer,
|
||||
SERIAL_COUNTER,
|
||||
},
|
||||
};
|
||||
use std::{cell::RefCell, collections::HashMap};
|
||||
|
||||
pub struct ActiveOutput(pub RefCell<Output>);
|
||||
|
||||
pub struct Devices(RefCell<HashMap<String, Vec<DeviceCapability>>>);
|
||||
|
||||
impl Devices {
|
||||
fn new() -> Devices {
|
||||
Devices(RefCell::new(HashMap::new()))
|
||||
}
|
||||
|
||||
fn add_device<D: Device>(&self, device: &D) -> Vec<DeviceCapability> {
|
||||
let id = device.id();
|
||||
let mut map = self.0.borrow_mut();
|
||||
let caps = [DeviceCapability::Keyboard, DeviceCapability::Pointer]
|
||||
.iter()
|
||||
.cloned()
|
||||
.filter(|c| device.has_capability(*c))
|
||||
.collect::<Vec<_>>();
|
||||
let new_caps = caps
|
||||
.iter()
|
||||
.cloned()
|
||||
.filter(|c| map.values().flatten().all(|has| *c != *has))
|
||||
.collect::<Vec<_>>();
|
||||
map.insert(id, caps);
|
||||
new_caps
|
||||
}
|
||||
|
||||
pub fn has_device<D: Device>(&self, device: &D) -> bool {
|
||||
self.0.borrow().contains_key(&device.id())
|
||||
}
|
||||
|
||||
fn remove_device<D: Device>(&self, device: &D) -> Vec<DeviceCapability> {
|
||||
let id = device.id();
|
||||
let mut map = self.0.borrow_mut();
|
||||
map.remove(&id)
|
||||
.unwrap_or(Vec::new())
|
||||
.into_iter()
|
||||
.filter(|c| map.values().flatten().all(|has| *c != *has))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn add_seat(display: &mut Display, name: String) -> Seat {
|
||||
let (seat, _) = Seat::new(display, name, None);
|
||||
let userdata = seat.user_data();
|
||||
userdata.insert_if_missing(|| Devices::new());
|
||||
userdata.insert_if_missing(|| RefCell::new(CursorImageStatus::Hidden));
|
||||
userdata.insert_if_missing(|| Vec::<Keysym>::new());
|
||||
seat
|
||||
}
|
||||
|
||||
|
|
@ -32,3 +79,344 @@ pub fn active_output(seat: &Seat, state: &State) -> Output {
|
|||
.expect("Backend has no outputs?")
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_active_output(seat: &Seat, output: &Output) {
|
||||
if !seat
|
||||
.user_data()
|
||||
.insert_if_missing(|| ActiveOutput(RefCell::new(output.clone())))
|
||||
{
|
||||
*seat
|
||||
.user_data()
|
||||
.get::<ActiveOutput>()
|
||||
.unwrap()
|
||||
.0
|
||||
.borrow_mut() = output.clone();
|
||||
}
|
||||
}
|
||||
|
||||
impl State {
|
||||
pub fn process_input_event<B: InputBackend>(&mut self, event: InputEvent<B>) {
|
||||
use smithay::backend::input::Event;
|
||||
|
||||
match event {
|
||||
InputEvent::DeviceAdded { device } => {
|
||||
let seat = &mut self.last_active_seat;
|
||||
let userdata = seat.user_data();
|
||||
let devices = userdata.get::<Devices>().unwrap();
|
||||
for cap in devices.add_device(&device) {
|
||||
match cap {
|
||||
DeviceCapability::Keyboard => {
|
||||
let _ =
|
||||
seat.add_keyboard(XkbConfig::default(), 200, 25, |seat, focus| {
|
||||
set_data_device_focus(
|
||||
seat,
|
||||
focus.and_then(|s| s.as_ref().client()),
|
||||
)
|
||||
});
|
||||
}
|
||||
DeviceCapability::Pointer => {
|
||||
let output = self
|
||||
.spaces
|
||||
.outputs()
|
||||
.next()
|
||||
.expect("Backend initialized without output")
|
||||
.clone();
|
||||
seat.user_data()
|
||||
.insert_if_missing(|| ActiveOutput(RefCell::new(output)));
|
||||
let owned_seat = seat.clone();
|
||||
seat.add_pointer(move |status| {
|
||||
*owned_seat
|
||||
.user_data()
|
||||
.get::<RefCell<CursorImageStatus>>()
|
||||
.unwrap()
|
||||
.borrow_mut() = status;
|
||||
});
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
InputEvent::DeviceRemoved { device } => {
|
||||
for seat in &mut self.seats {
|
||||
let userdata = seat.user_data();
|
||||
let devices = userdata.get::<Devices>().unwrap();
|
||||
if devices.has_device(&device) {
|
||||
for cap in devices.remove_device(&device) {
|
||||
match cap {
|
||||
DeviceCapability::Keyboard => {
|
||||
seat.remove_keyboard();
|
||||
}
|
||||
DeviceCapability::Pointer => {
|
||||
seat.remove_pointer();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
InputEvent::Keyboard { event, .. } => {
|
||||
use smithay::backend::input::KeyboardKeyEvent;
|
||||
|
||||
let device = event.device();
|
||||
for seat in self.seats.clone().iter() {
|
||||
let userdata = seat.user_data();
|
||||
let devices = userdata.get::<Devices>().unwrap();
|
||||
if devices.has_device(&device) {
|
||||
let keycode = event.key_code();
|
||||
let state = event.state();
|
||||
slog_scope::trace!("key"; "keycode" => keycode, "state" => format!("{:?}", state));
|
||||
|
||||
let serial = SERIAL_COUNTER.next_serial();
|
||||
let time = Event::time(&event);
|
||||
seat.get_keyboard().unwrap().input::<(), _>(
|
||||
keycode,
|
||||
state,
|
||||
serial,
|
||||
time,
|
||||
|modifiers, handle| {
|
||||
// here we can handle global shortcuts and the like
|
||||
let _ = (modifiers, handle);
|
||||
FilterResult::Forward
|
||||
},
|
||||
);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
InputEvent::PointerMotion { event, .. } => {
|
||||
use smithay::backend::input::PointerMotionEvent;
|
||||
|
||||
let device = event.device();
|
||||
for seat in self.seats.clone().iter() {
|
||||
let userdata = seat.user_data();
|
||||
let devices = userdata.get::<Devices>().unwrap();
|
||||
if devices.has_device(&device) {
|
||||
let current_output = active_output(seat, &self);
|
||||
|
||||
let mut position = seat.get_pointer().unwrap().current_location();
|
||||
position += event.delta();
|
||||
|
||||
let output = self
|
||||
.spaces
|
||||
.outputs()
|
||||
.find(|output| {
|
||||
self.spaces
|
||||
.output_geometry(output)
|
||||
.to_f64()
|
||||
.contains(position)
|
||||
})
|
||||
.unwrap_or(¤t_output);
|
||||
if output != ¤t_output {
|
||||
set_active_output(seat, output);
|
||||
}
|
||||
let output_geometry = self.spaces.output_geometry(output);
|
||||
|
||||
position.x = 0.0f64
|
||||
.max(position.x)
|
||||
.min((output_geometry.loc.x + output_geometry.size.w) as f64);
|
||||
position.y = 0.0f64
|
||||
.max(position.y)
|
||||
.min((output_geometry.loc.y + output_geometry.size.h) as f64);
|
||||
|
||||
let serial = SERIAL_COUNTER.next_serial();
|
||||
let space = self.spaces.active_space(&output);
|
||||
let under = State::surface_under(position, output, space);
|
||||
seat.get_pointer()
|
||||
.unwrap()
|
||||
.motion(position, under, serial, event.time());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
InputEvent::PointerMotionAbsolute { event, .. } => {
|
||||
use smithay::backend::input::PointerMotionAbsoluteEvent;
|
||||
|
||||
let device = event.device();
|
||||
for seat in self.seats.clone().iter() {
|
||||
let userdata = seat.user_data();
|
||||
let devices = userdata.get::<Devices>().unwrap();
|
||||
if devices.has_device(&device) {
|
||||
let output = active_output(seat, &self);
|
||||
let space = self.spaces.active_space(&output);
|
||||
let geometry = self.spaces.output_geometry(&output);
|
||||
let position =
|
||||
geometry.loc.to_f64() + event.position_transformed(geometry.size);
|
||||
let serial = SERIAL_COUNTER.next_serial();
|
||||
let under = State::surface_under(position, &output, space);
|
||||
seat.get_pointer()
|
||||
.unwrap()
|
||||
.motion(position, under, serial, event.time());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
InputEvent::PointerButton { event, .. } => {
|
||||
use smithay::{
|
||||
backend::input::{ButtonState, PointerButtonEvent},
|
||||
reexports::wayland_server::protocol::wl_pointer,
|
||||
};
|
||||
|
||||
let device = event.device();
|
||||
for seat in self.seats.clone().iter() {
|
||||
let userdata = seat.user_data();
|
||||
let devices = userdata.get::<Devices>().unwrap();
|
||||
if devices.has_device(&device) {
|
||||
let serial = SERIAL_COUNTER.next_serial();
|
||||
let button = event.button_code();
|
||||
let state = match event.state() {
|
||||
ButtonState::Pressed => {
|
||||
// change the keyboard focus unless the pointer is grabbed
|
||||
if !seat.get_pointer().unwrap().is_grabbed() {
|
||||
let output = active_output(seat, &self);
|
||||
let mut pos = seat.get_pointer().unwrap().current_location();
|
||||
let output_geo = self.spaces.output_geometry(&output);
|
||||
let space = self.spaces.active_space_mut(&output);
|
||||
let layers = layer_map_for_output(&output);
|
||||
pos -= output_geo.loc.to_f64();
|
||||
let mut under = None;
|
||||
|
||||
if let Some(layer) = layers
|
||||
.layer_under(WlrLayer::Overlay, pos)
|
||||
.or_else(|| layers.layer_under(WlrLayer::Top, pos))
|
||||
{
|
||||
if layer.can_receive_keyboard_focus() {
|
||||
let layer_loc = layers.layer_geometry(layer).loc;
|
||||
under = layer
|
||||
.surface_under(pos - layer_loc.to_f64())
|
||||
.map(|(s, _)| s);
|
||||
}
|
||||
} else if let Some(window) = space.window_under(pos).cloned() {
|
||||
let window_loc =
|
||||
space.window_geometry(&window).unwrap().loc;
|
||||
under = window
|
||||
.surface_under(pos - window_loc.to_f64())
|
||||
.map(|(s, _)| s);
|
||||
space.raise_window(&window);
|
||||
} else if let Some(layer) = layers
|
||||
.layer_under(WlrLayer::Bottom, pos)
|
||||
.or_else(|| layers.layer_under(WlrLayer::Background, pos))
|
||||
{
|
||||
if layer.can_receive_keyboard_focus() {
|
||||
let layer_loc = layers.layer_geometry(layer).loc;
|
||||
under = layer
|
||||
.surface_under(pos - layer_loc.to_f64())
|
||||
.map(|(s, _)| s);
|
||||
}
|
||||
};
|
||||
|
||||
if let Some(keyboard) = seat.get_keyboard() {
|
||||
keyboard.set_focus(under.as_ref(), serial);
|
||||
}
|
||||
}
|
||||
wl_pointer::ButtonState::Pressed
|
||||
}
|
||||
ButtonState::Released => wl_pointer::ButtonState::Released,
|
||||
};
|
||||
seat.get_pointer()
|
||||
.unwrap()
|
||||
.button(button, state, serial, event.time());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
InputEvent::PointerAxis { event, .. } => {
|
||||
use smithay::{
|
||||
backend::input::{Axis, AxisSource, PointerAxisEvent},
|
||||
reexports::wayland_server::protocol::wl_pointer,
|
||||
wayland::seat::AxisFrame,
|
||||
};
|
||||
|
||||
let device = event.device();
|
||||
for seat in self.seats.clone().iter() {
|
||||
let userdata = seat.user_data();
|
||||
let devices = userdata.get::<Devices>().unwrap();
|
||||
if devices.has_device(&device) {
|
||||
let source = match event.source() {
|
||||
AxisSource::Continuous => wl_pointer::AxisSource::Continuous,
|
||||
AxisSource::Finger => wl_pointer::AxisSource::Finger,
|
||||
AxisSource::Wheel | AxisSource::WheelTilt => {
|
||||
wl_pointer::AxisSource::Wheel
|
||||
}
|
||||
};
|
||||
let horizontal_amount =
|
||||
event.amount(Axis::Horizontal).unwrap_or_else(|| {
|
||||
event.amount_discrete(Axis::Horizontal).unwrap() * 3.0
|
||||
});
|
||||
let vertical_amount = event.amount(Axis::Vertical).unwrap_or_else(|| {
|
||||
event.amount_discrete(Axis::Vertical).unwrap() * 3.0
|
||||
});
|
||||
let horizontal_amount_discrete = event.amount_discrete(Axis::Horizontal);
|
||||
let vertical_amount_discrete = event.amount_discrete(Axis::Vertical);
|
||||
|
||||
{
|
||||
let mut frame = AxisFrame::new(event.time()).source(source);
|
||||
if horizontal_amount != 0.0 {
|
||||
frame = frame
|
||||
.value(wl_pointer::Axis::HorizontalScroll, horizontal_amount);
|
||||
if let Some(discrete) = horizontal_amount_discrete {
|
||||
frame = frame.discrete(
|
||||
wl_pointer::Axis::HorizontalScroll,
|
||||
discrete as i32,
|
||||
);
|
||||
}
|
||||
} else if source == wl_pointer::AxisSource::Finger {
|
||||
frame = frame.stop(wl_pointer::Axis::HorizontalScroll);
|
||||
}
|
||||
if vertical_amount != 0.0 {
|
||||
frame =
|
||||
frame.value(wl_pointer::Axis::VerticalScroll, vertical_amount);
|
||||
if let Some(discrete) = vertical_amount_discrete {
|
||||
frame = frame.discrete(
|
||||
wl_pointer::Axis::VerticalScroll,
|
||||
discrete as i32,
|
||||
);
|
||||
}
|
||||
} else if source == wl_pointer::AxisSource::Finger {
|
||||
frame = frame.stop(wl_pointer::Axis::VerticalScroll);
|
||||
}
|
||||
seat.get_pointer().unwrap().axis(frame);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => { /* TODO e.g. tablet or touch events */ }
|
||||
}
|
||||
}
|
||||
|
||||
pub fn surface_under(
|
||||
pos: Point<f64, Logical>,
|
||||
output: &Output,
|
||||
space: &Space,
|
||||
) -> Option<(WlSurface, Point<i32, Logical>)> {
|
||||
let layers = layer_map_for_output(output);
|
||||
let output_geo = space.output_geometry(output).unwrap();
|
||||
|
||||
if let Some(layer) = layers
|
||||
.layer_under(WlrLayer::Overlay, pos)
|
||||
.or_else(|| layers.layer_under(WlrLayer::Top, pos))
|
||||
{
|
||||
let layer_loc = layers.layer_geometry(layer).loc;
|
||||
layer
|
||||
.surface_under(pos - output_geo.loc.to_f64() - layer_loc.to_f64())
|
||||
.map(|(s, loc)| (s, loc + layer_loc))
|
||||
} else if let Some(window) = space.window_under(pos) {
|
||||
let window_loc = space.window_geometry(window).unwrap().loc;
|
||||
window
|
||||
.surface_under(pos - window_loc.to_f64())
|
||||
.map(|(s, loc)| (s, loc + window_loc))
|
||||
} else if let Some(layer) = layers
|
||||
.layer_under(WlrLayer::Bottom, pos)
|
||||
.or_else(|| layers.layer_under(WlrLayer::Background, pos))
|
||||
{
|
||||
let layer_loc = layers.layer_geometry(layer).loc;
|
||||
layer
|
||||
.surface_under(pos - output_geo.loc.to_f64() - layer_loc.to_f64())
|
||||
.map(|(s, loc)| (s, loc + layer_loc))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue