aboutsummaryrefslogtreecommitdiff
path: root/src/backend
diff options
context:
space:
mode:
Diffstat (limited to 'src/backend')
-rw-r--r--src/backend/mod.rs41
-rw-r--r--src/backend/tty.rs120
-rw-r--r--src/backend/winit.rs103
3 files changed, 132 insertions, 132 deletions
diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index 5c0f62a5..d70ee2aa 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -1,6 +1,7 @@
use smithay::backend::renderer::gles::GlesRenderer;
use smithay::output::Output;
+use crate::input::CompositorMod;
use crate::niri::OutputRenderElements;
use crate::Niri;
@@ -49,19 +50,47 @@ impl Backend {
}
}
- pub fn tty(&mut self) -> Option<&mut Tty> {
+ pub fn mod_key(&self) -> CompositorMod {
+ match self {
+ Backend::Tty(_) => CompositorMod::Super,
+ Backend::Winit(_) => CompositorMod::Alt,
+ }
+ }
+
+ pub fn change_vt(&mut self, vt: i32) {
+ match self {
+ Backend::Tty(tty) => tty.change_vt(vt),
+ Backend::Winit(_) => (),
+ }
+ }
+
+ pub fn suspend(&mut self) {
+ match self {
+ Backend::Tty(tty) => tty.suspend(),
+ Backend::Winit(_) => (),
+ }
+ }
+
+ pub fn toggle_debug_tint(&mut self) {
+ match self {
+ Backend::Tty(tty) => tty.toggle_debug_tint(),
+ Backend::Winit(winit) => winit.toggle_debug_tint(),
+ }
+ }
+
+ pub fn tty(&mut self) -> &mut Tty {
if let Self::Tty(v) = self {
- Some(v)
+ v
} else {
- None
+ panic!("backend is not Tty");
}
}
- pub fn winit(&mut self) -> Option<&mut Winit> {
+ pub fn winit(&mut self) -> &mut Winit {
if let Self::Winit(v) = self {
- Some(v)
+ v
} else {
- None
+ panic!("backend is not Winit")
}
}
}
diff --git a/src/backend/tty.rs b/src/backend/tty.rs
index e5ee4551..eec796f1 100644
--- a/src/backend/tty.rs
+++ b/src/backend/tty.rs
@@ -30,16 +30,15 @@ use smithay::utils::DeviceFd;
use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};
use smithay_drm_extras::edid::EdidInfo;
-use crate::input::{BackendAction, CompositorMod};
-use crate::niri::{Data, OutputRenderElements};
-use crate::Niri;
+use crate::niri::OutputRenderElements;
+use crate::{LoopData, Niri};
const BACKGROUND_COLOR: [f32; 4] = [0.1, 0.1, 0.1, 1.];
const SUPPORTED_COLOR_FORMATS: &[Fourcc] = &[Fourcc::Argb8888, Fourcc::Abgr8888];
pub struct Tty {
session: LibSeatSession,
- udev_dispatcher: Dispatcher<'static, UdevBackend, Data>,
+ udev_dispatcher: Dispatcher<'static, UdevBackend, LoopData>,
primary_gpu_path: PathBuf,
output_device: Option<OutputDevice>,
}
@@ -69,44 +68,45 @@ struct TtyOutputState {
}
impl Tty {
- pub fn new(event_loop: LoopHandle<'static, Data>) -> Self {
+ pub fn new(event_loop: LoopHandle<'static, LoopData>) -> Self {
let (session, notifier) = LibSeatSession::new().unwrap();
let seat_name = session.seat();
let udev_backend = UdevBackend::new(session.seat()).unwrap();
- let udev_dispatcher = Dispatcher::new(udev_backend, move |event, _, data: &mut Data| {
- let tty = data.backend.tty().unwrap();
- let niri = &mut data.niri;
+ let udev_dispatcher =
+ Dispatcher::new(udev_backend, move |event, _, data: &mut LoopData| {
+ let tty = data.state.backend.tty();
+ let niri = &mut data.state.niri;
- match event {
- UdevEvent::Added { device_id, path } => {
- if !tty.session.is_active() {
- debug!("skipping UdevEvent::Added as session is inactive");
- return;
- }
+ match event {
+ UdevEvent::Added { device_id, path } => {
+ if !tty.session.is_active() {
+ debug!("skipping UdevEvent::Added as session is inactive");
+ return;
+ }
- if let Err(err) = tty.device_added(device_id, &path, niri) {
- warn!("error adding device: {err:?}");
- }
- }
- UdevEvent::Changed { device_id } => {
- if !tty.session.is_active() {
- debug!("skipping UdevEvent::Changed as session is inactive");
- return;
+ if let Err(err) = tty.device_added(device_id, &path, niri) {
+ warn!("error adding device: {err:?}");
+ }
}
+ UdevEvent::Changed { device_id } => {
+ if !tty.session.is_active() {
+ debug!("skipping UdevEvent::Changed as session is inactive");
+ return;
+ }
- tty.device_changed(device_id, niri)
- }
- UdevEvent::Removed { device_id } => {
- if !tty.session.is_active() {
- debug!("skipping UdevEvent::Removed as session is inactive");
- return;
+ tty.device_changed(device_id, niri)
}
+ UdevEvent::Removed { device_id } => {
+ if !tty.session.is_active() {
+ debug!("skipping UdevEvent::Removed as session is inactive");
+ return;
+ }
- tty.device_removed(device_id, niri)
+ tty.device_removed(device_id, niri)
+ }
}
- }
- });
+ });
event_loop
.register_dispatcher(udev_dispatcher.clone())
.unwrap();
@@ -117,43 +117,16 @@ impl Tty {
let input_backend = LibinputInputBackend::new(libinput.clone());
event_loop
.insert_source(input_backend, |mut event, _, data| {
- let tty = data.backend.tty().unwrap();
- let niri = &mut data.niri;
-
- niri.process_libinput_event(&mut event);
- match niri.process_input_event(CompositorMod::Super, event) {
- BackendAction::None => (),
- BackendAction::ChangeVt(vt) => tty.change_vt(vt),
- BackendAction::Suspend => {
- if let Err(err) = suspend() {
- warn!("error suspending: {err:?}");
- }
- }
- BackendAction::Screenshot => {
- let active = niri.monitor_set.active_output().cloned();
- if let Some(active) = active {
- if let Err(err) = niri.screenshot(tty.renderer(), &active) {
- warn!("error taking screenshot: {err:?}");
- }
- }
- }
- BackendAction::ToggleDebugTint => {
- if let Some(device) = tty.output_device.as_mut() {
- for (_, compositor) in &mut device.surfaces {
- compositor
- .set_debug_flags(compositor.debug_flags() ^ DebugFlags::TINT);
- }
- }
- }
- };
+ data.state.process_libinput_event(&mut event);
+ data.state.process_input_event(event);
})
.unwrap();
let udev_dispatcher_c = udev_dispatcher.clone();
event_loop
.insert_source(notifier, move |event, _, data| {
- let tty = data.backend.tty().unwrap();
- let niri = &mut data.niri;
+ let tty = data.state.backend.tty();
+ let niri = &mut data.state.niri;
match event {
SessionEvent::PauseSession => {
@@ -289,7 +262,7 @@ impl Tty {
let token = niri
.event_loop
.insert_source(drm_notifier, move |event, metadata, data| {
- let tty = data.backend.tty().unwrap();
+ let tty = data.state.backend.tty();
match event {
DrmEvent::VBlank(crtc) => {
tracy_client::Client::running()
@@ -336,6 +309,7 @@ impl Tty {
}
let output = data
+ .state
.niri
.global_space
.outputs()
@@ -345,10 +319,10 @@ impl Tty {
})
.unwrap()
.clone();
- let output_state = data.niri.output_state.get_mut(&output).unwrap();
+ let output_state = data.state.niri.output_state.get_mut(&output).unwrap();
output_state.waiting_for_vblank = false;
output_state.frame_clock.presented(presentation_time);
- data.niri.queue_redraw(output);
+ data.state.niri.queue_redraw(output);
}
DrmEvent::Error(error) => error!("DRM error: {error}"),
};
@@ -589,11 +563,25 @@ impl Tty {
}
}
- fn change_vt(&mut self, vt: i32) {
+ pub fn change_vt(&mut self, vt: i32) {
if let Err(err) = self.session.change_vt(vt) {
error!("error changing VT: {err}");
}
}
+
+ pub fn suspend(&self) {
+ if let Err(err) = suspend() {
+ warn!("error suspending: {err:?}");
+ }
+ }
+
+ pub fn toggle_debug_tint(&mut self) {
+ if let Some(device) = self.output_device.as_mut() {
+ for (_, compositor) in &mut device.surfaces {
+ compositor.set_debug_flags(compositor.debug_flags() ^ DebugFlags::TINT);
+ }
+ }
+ }
}
fn refresh_interval(mode: DrmMode) -> Duration {
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 74485469..767bf7f4 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -3,7 +3,7 @@ use std::time::Duration;
use smithay::backend::renderer::damage::OutputDamageTracker;
use smithay::backend::renderer::gles::GlesRenderer;
use smithay::backend::renderer::{DebugFlags, Renderer};
-use smithay::backend::winit::{self, WinitError, WinitEvent, WinitEventLoop, WinitGraphicsBackend};
+use smithay::backend::winit::{self, WinitError, WinitEvent, WinitGraphicsBackend};
use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
use smithay::reexports::calloop::LoopHandle;
@@ -12,25 +12,23 @@ use smithay::reexports::winit::dpi::LogicalSize;
use smithay::reexports::winit::window::WindowBuilder;
use smithay::utils::Transform;
-use crate::input::{BackendAction, CompositorMod};
-use crate::niri::{Data, OutputRenderElements};
+use crate::niri::OutputRenderElements;
use crate::utils::get_monotonic_time;
-use crate::Niri;
+use crate::{LoopData, Niri};
pub struct Winit {
output: Output,
backend: WinitGraphicsBackend<GlesRenderer>,
- winit_event_loop: WinitEventLoop,
damage_tracker: OutputDamageTracker,
}
impl Winit {
- pub fn new(event_loop: LoopHandle<Data>) -> Self {
+ pub fn new(event_loop: LoopHandle<LoopData>) -> Self {
let builder = WindowBuilder::new()
.with_inner_size(LogicalSize::new(1280.0, 800.0))
// .with_resizable(false)
.with_title("niri");
- let (backend, winit_event_loop) = winit::init_from_builder(builder).unwrap();
+ let (backend, mut winit_event_loop) = winit::init_from_builder(builder).unwrap();
let mode = Mode {
size: backend.window_size().physical_size,
@@ -59,8 +57,39 @@ impl Winit {
let timer = Timer::immediate();
event_loop
.insert_source(timer, move |_, _, data| {
- let winit = data.backend.winit().unwrap();
- winit.dispatch(&mut data.niri);
+ let res = winit_event_loop.dispatch_new_events(|event| match event {
+ WinitEvent::Resized { size, .. } => {
+ let winit = data.state.backend.winit();
+ winit.output.change_current_state(
+ Some(Mode {
+ size,
+ refresh: 60_000,
+ }),
+ None,
+ None,
+ None,
+ );
+ data.state.niri.output_resized(winit.output.clone());
+ }
+ WinitEvent::Input(event) => data.state.process_input_event(event),
+ WinitEvent::Focus(_) => (),
+ WinitEvent::Refresh => data
+ .state
+ .niri
+ .queue_redraw(data.state.backend.winit().output.clone()),
+ });
+
+ // I want this to stop compiling if more errors are added.
+ #[allow(clippy::single_match)]
+ match res {
+ Err(WinitError::WindowClosed) => {
+ data.state.niri.stop_signal.stop();
+ data.state
+ .niri
+ .remove_output(&data.state.backend.winit().output);
+ }
+ Ok(()) => (),
+ }
TimeoutAction::ToDuration(Duration::from_micros(16667))
})
.unwrap();
@@ -68,7 +97,6 @@ impl Winit {
Self {
output,
backend,
- winit_event_loop,
damage_tracker,
}
}
@@ -88,56 +116,6 @@ impl Winit {
niri.add_output(self.output.clone(), None);
}
- fn dispatch(&mut self, niri: &mut Niri) {
- let renderer = self.backend.renderer();
- let res = self
- .winit_event_loop
- .dispatch_new_events(|event| match event {
- WinitEvent::Resized { size, .. } => {
- self.output.change_current_state(
- Some(Mode {
- size,
- refresh: 60_000,
- }),
- None,
- None,
- None,
- );
- niri.output_resized(self.output.clone());
- }
- WinitEvent::Input(event) => {
- match niri.process_input_event(CompositorMod::Alt, event) {
- BackendAction::None => (),
- BackendAction::ChangeVt(_) => (),
- BackendAction::Suspend => (),
- BackendAction::Screenshot => {
- let active = niri.monitor_set.active_output().cloned();
- if let Some(active) = active {
- if let Err(err) = niri.screenshot(renderer, &active) {
- warn!("error taking screenshot: {err:?}");
- }
- }
- }
- BackendAction::ToggleDebugTint => {
- renderer.set_debug_flags(renderer.debug_flags() ^ DebugFlags::TINT);
- }
- }
- }
- WinitEvent::Focus(_) => (),
- WinitEvent::Refresh => niri.queue_redraw(self.output.clone()),
- });
-
- // I want this to stop compiling if more errors are added.
- #[allow(clippy::single_match)]
- match res {
- Err(WinitError::WindowClosed) => {
- niri.stop_signal.stop();
- niri.remove_output(&self.output);
- }
- Ok(()) => (),
- }
- }
-
pub fn seat_name(&self) -> String {
"winit".to_owned()
}
@@ -175,4 +153,9 @@ impl Winit {
self.backend.window().request_redraw();
}
}
+
+ pub fn toggle_debug_tint(&mut self) {
+ let renderer = self.backend.renderer();
+ renderer.set_debug_flags(renderer.debug_flags() ^ DebugFlags::TINT);
+ }
}
generated by cgit (git 2.34.1) at 2026-02-06 10:34:13 +0000