Merge pull request #758 from mahkoh/jorth/modes-no-config

output: don't use config Vrr and Tearing modes

src/compositor.rs

@@ -333,9 +333,9 @@ fn start_compositor2(
         tablet_tool_ids: Default::default(),
         tablet_pad_ids: Default::default(),
         damage_visualizer: DamageVisualizer::new(&engine, &color_manager),
-        default_vrr_mode: Cell::new(VrrMode::NEVER),
+        default_vrr_mode: Cell::new(*VrrMode::NEVER),
         default_vrr_cursor_hz: Cell::new(None),
-        default_tearing_mode: Cell::new(TearingMode::VARIANT_3),
+        default_tearing_mode: Cell::new(*TearingMode::VARIANT_3),
         ei_acceptor: Default::default(),
         ei_acceptor_future: Default::default(),
         enable_ei_acceptor: Default::default(),
@@ -682,10 +682,10 @@ fn create_dummy_output(state: &Rc<State>) {
         inherent_non_desktop: false,
         override_non_desktop: None,
         vrr: false,
-        vrr_mode: VrrMode::Never.to_config(),
+        vrr_mode: VrrMode::Never,
         tearing_enabled: backend_state.tearing,
         tearing_active: false,
-        tearing_mode: TearingMode::Never.to_config(),
+        tearing_mode: TearingMode::Never,
         format: XRGB8888,
         color_space: backend_state.color_space,
         eotf: backend_state.eotf,

src/config/handler.rs

@@ -1512,7 +1512,7 @@ impl ConfigProxyHandler {
                 let connector = self.get_output_node(c)?;
                 connector.set_vrr_mode(mode);
             }
-            _ => self.state.default_vrr_mode.set(mode),
+            _ => self.state.default_vrr_mode.set(*mode),
         }
         Ok(())
     }
@@ -1550,7 +1550,7 @@ impl ConfigProxyHandler {
                 let connector = self.get_output_node(c)?;
                 connector.set_tearing_mode(mode);
             }
-            _ => self.state.default_tearing_mode.set(mode),
+            _ => self.state.default_tearing_mode.set(*mode),
         }
         Ok(())
     }

src/ifs/head_management.rs

@@ -13,11 +13,10 @@ use {
         },
         scale::Scale,
         state::OutputData,
-        tree::{OutputNode, Transform},
+        tree::{OutputNode, TearingMode, Transform, VrrMode},
         utils::{copyhashmap::CopyHashMap, hash_map_ext::HashMapExt, rc_eq::RcEq},
         wire::JayHeadManagerSessionV1Id,
     },
-    jay_config::video::{TearingMode, VrrMode},
     std::{
         cell::{Cell, RefCell},
         rc::Rc,
@@ -239,8 +238,8 @@ impl HeadManagers {
             state.size = n.global.pos.get().size();
             state.mode = n.global.mode.get();
             state.transform = n.global.persistent.transform.get();
-            state.vrr_mode = n.global.persistent.vrr_mode.get().to_config();
+            state.vrr_mode = n.global.persistent.vrr_mode.get();
-            state.tearing_mode = n.global.persistent.tearing_mode.get().to_config();
+            state.tearing_mode = n.global.persistent.tearing_mode.get();
         }
         for head in self.managers.lock().values() {
             skip_in_transaction!(head);
@@ -431,9 +430,9 @@ impl HeadManagers {
         }
     }
 
-    pub fn handle_vrr_mode_change(&self, vrr_mode: VrrMode) {
+    pub fn handle_vrr_mode_change(&self, vrr_mode: &VrrMode) {
         let state = &mut *self.state.borrow_mut();
-        state.vrr_mode = vrr_mode;
+        state.vrr_mode = *vrr_mode;
         for head in self.managers.lock().values() {
             skip_in_transaction!(head);
             if let Some(ext) = &head.ext.jay_vrr_mode_info_v1 {
@@ -467,9 +466,9 @@ impl HeadManagers {
         }
     }
 
-    pub fn handle_tearing_mode_change(&self, tearing_mode: TearingMode) {
+    pub fn handle_tearing_mode_change(&self, tearing_mode: &TearingMode) {
         let state = &mut *self.state.borrow_mut();
-        state.tearing_mode = tearing_mode;
+        state.tearing_mode = *tearing_mode;
         for head in self.managers.lock().values() {
             skip_in_transaction!(head);
             if let Some(ext) = &head.ext.jay_tearing_mode_info_v1 {

src/ifs/head_management/jay_head_ext/jay_head_ext_jay_tearing_mode_info_v1.rs

@@ -31,7 +31,7 @@ impl HeadName {
     pub(in super::super) fn send_mode(&self, state: &HeadState) {
         self.client.event(Mode {
             self_id: self.id,
-            mode: state.tearing_mode.0,
+            mode: state.tearing_mode.to_config().0,
         });
     }
 }

src/ifs/head_management/jay_head_ext/jay_head_ext_jay_tearing_mode_setter_v1.rs

@@ -1,6 +1,7 @@
 use {
     crate::{
         ifs::head_management::{HeadOp, HeadState},
+        tree::TearingMode,
         wire::{
             jay_head_ext_jay_tearing_mode_setter_v1::{
                 JayHeadExtJayTearingModeSetterV1RequestHandler, SetMode, SupportedMode,
@@ -8,7 +9,7 @@ use {
             jay_head_manager_ext_jay_tearing_mode_setter_v1::JayHeadManagerExtJayTearingModeSetterV1RequestHandler,
         },
     },
-    jay_config::video::TearingMode,
+    jay_config::video::TearingMode as ConfigTearingMode,
     std::rc::Rc,
 };
 
@@ -26,10 +27,10 @@ impl HeadName {
         self.send_supported_mode(TearingMode::VARIANT_3);
     }
 
-    pub(in super::super) fn send_supported_mode(&self, mode: TearingMode) {
+    pub(in super::super) fn send_supported_mode(&self, mode: &TearingMode) {
         self.client.event(SupportedMode {
             self_id: self.id,
-            mode: mode.0,
+            mode: mode.to_config().0,
         });
     }
 }
@@ -46,11 +47,10 @@ impl JayHeadExtJayTearingModeSetterV1RequestHandler for HeadName {
     head_common_req!();
 
     fn set_mode(&self, req: SetMode, _slf: &Rc<Self>) -> Result<(), Self::Error> {
-        if req.mode > TearingMode::VARIANT_3.0 {
+        let Some(mode) = TearingMode::from_config(ConfigTearingMode(req.mode)) else {
             return Err(ErrorName::UnknownMode(req.mode));
-        }
+        };
-        self.common
+        self.common.push_op(HeadOp::SetTearingMode(*mode))?;
-            .push_op(HeadOp::SetTearingMode(TearingMode(req.mode)))?;
         Ok(())
     }
 }

src/ifs/head_management/jay_head_ext/jay_head_ext_jay_vrr_mode_info_v1.rs

@@ -29,7 +29,7 @@ impl HeadName {
     pub(in super::super) fn send_mode(&self, state: &HeadState) {
         self.client.event(Mode {
             self_id: self.id,
-            mode: state.vrr_mode.0,
+            mode: state.vrr_mode.to_config().0,
         });
     }
 }

src/ifs/head_management/jay_head_ext/jay_head_ext_jay_vrr_mode_setter_v1.rs

@@ -1,6 +1,7 @@
 use {
     crate::{
         ifs::head_management::{HeadOp, HeadState},
+        tree::VrrMode,
         wire::{
             jay_head_ext_jay_vrr_mode_setter_v1::{
                 JayHeadExtJayVrrModeSetterV1RequestHandler, SetMode, SupportedMode,
@@ -8,7 +9,7 @@ use {
             jay_head_manager_ext_jay_vrr_mode_setter_v1::JayHeadManagerExtJayVrrModeSetterV1RequestHandler,
         },
     },
-    jay_config::video::VrrMode,
+    jay_config::video::VrrMode as ConfigVrrMode,
     std::rc::Rc,
 };
 
@@ -26,10 +27,10 @@ impl HeadName {
         self.send_supported_mode(VrrMode::VARIANT_3);
     }
 
-    pub(in super::super) fn send_supported_mode(&self, mode: VrrMode) {
+    pub(in super::super) fn send_supported_mode(&self, mode: &VrrMode) {
         self.client.event(SupportedMode {
             self_id: self.id,
-            mode: mode.0,
+            mode: mode.to_config().0,
         });
     }
 }
@@ -46,10 +47,10 @@ impl JayHeadExtJayVrrModeSetterV1RequestHandler for HeadName {
     head_common_req!();
 
     fn set_mode(&self, req: SetMode, _slf: &Rc<Self>) -> Result<(), Self::Error> {
-        if req.mode > VrrMode::VARIANT_3.0 {
+        let Some(mode) = VrrMode::from_config(ConfigVrrMode(req.mode)) else {
             return Err(ErrorName::UnknownMode(req.mode));
-        }
+        };
-        self.common.push_op(HeadOp::SetVrrMode(VrrMode(req.mode)))?;
+        self.common.push_op(HeadOp::SetVrrMode(*mode))?;
         Ok(())
     }
 }

src/ifs/head_management/jay_head_manager_session_v1.rs

@@ -14,7 +14,6 @@ use {
         leaks::Tracker,
         object::{Object, Version},
         state::{ConnectorData, State},
-        tree::{TearingMode, VrrMode},
         utils::{copyhashmap::CopyHashMap, numcell::NumCell},
         wire::{
             JayHeadManagerSessionV1Id, JayHeadTransactionResultV1Id,
@@ -558,8 +557,8 @@ impl JayHeadManagerSessionV1RequestHandler for JayHeadManagerSessionV1 {
                 node.set_position(desired.position.0, desired.position.1);
                 node.set_preferred_scale(desired.scale);
                 node.update_transform(desired.transform);
-                node.set_vrr_mode(VrrMode::from_config(desired.vrr_mode).unwrap());
+                node.set_vrr_mode(&desired.vrr_mode);
-                node.set_tearing_mode(TearingMode::from_config(desired.tearing_mode).unwrap());
+                node.set_tearing_mode(&desired.tearing_mode);
                 node.set_brightness(desired.brightness);
             } else if let Some(mi) = &desired.monitor_info {
                 let pos = &self.client.state.persistent_output_states;
@@ -567,10 +566,8 @@ impl JayHeadManagerSessionV1RequestHandler for JayHeadManagerSessionV1 {
                 pos.pos.set(desired.position);
                 pos.scale.set(desired.scale);
                 pos.transform.set(desired.transform);
-                pos.vrr_mode
+                pos.vrr_mode.set(desired.vrr_mode);
-                    .set(VrrMode::from_config(desired.vrr_mode).unwrap());
+                pos.tearing_mode.set(desired.tearing_mode);
-                pos.tearing_mode
-                    .set(TearingMode::from_config(desired.tearing_mode).unwrap());
                 pos.brightness.set(desired.brightness);
             }
         }

src/ifs/wl_output.rs

@@ -134,9 +134,9 @@ pub struct PersistentOutputState {
     pub transform: Cell<Transform>,
     pub scale: Cell<crate::scale::Scale>,
     pub pos: Cell<(i32, i32)>,
-    pub vrr_mode: Cell<&'static VrrMode>,
+    pub vrr_mode: Cell<VrrMode>,
     pub vrr_cursor_hz: Cell<Option<f64>>,
-    pub tearing_mode: Cell<&'static TearingMode>,
+    pub tearing_mode: Cell<TearingMode>,
     pub brightness: Cell<Option<f64>>,
     pub blend_space: Cell<BlendSpace>,
     pub use_native_gamut: Cell<bool>,
@@ -148,9 +148,9 @@ impl Default for PersistentOutputState {
             transform: Default::default(),
             scale: Default::default(),
             pos: Default::default(),
-            vrr_mode: Cell::new(&VrrMode::Never),
+            vrr_mode: Cell::new(VrrMode::Never),
             vrr_cursor_hz: Default::default(),
-            tearing_mode: Cell::new(&TearingMode::Never),
+            tearing_mode: Cell::new(TearingMode::Never),
             brightness: Default::default(),
             blend_space: Cell::new(BlendSpace::Srgb),
             use_native_gamut: Cell::new(false),

src/ifs/wlr_output_manager/zwlr_output_configuration_head.rs

@@ -29,7 +29,7 @@ pub struct ZwlrOutputConfigurationHeadV1 {
 pub struct OutputConfig {
     pub(super) transform: Option<Transform>,
     pub(super) scale: Option<Scale>,
-    pub(super) vrr_mode: Option<&'static VrrMode>,
+    pub(super) vrr_mode: Option<VrrMode>,
     pub(super) pos: Option<(i32, i32)>,
     pub(super) mode: Option<Mode>,
 }
@@ -112,7 +112,7 @@ impl ZwlrOutputConfigurationHeadV1RequestHandler for ZwlrOutputConfigurationHead
                 );
             }
         };
-        config.vrr_mode = Some(state);
+        config.vrr_mode = Some(*state);
         Ok(())
     }
 }

src/ifs/wlr_output_manager/zwlr_output_configuration_v1.rs

@@ -114,7 +114,7 @@ impl ZwlrOutputConfigurationV1 {
                 if let Some(v) = config.scale {
                     node.set_preferred_scale(v);
                 }
-                if let Some(v) = config.vrr_mode {
+                if let Some(v) = &config.vrr_mode {
                     node.set_vrr_mode(v);
                 }
                 if let Some(v) = config.pos {

src/ifs/wlr_output_manager/zwlr_output_manager_v1.rs

@@ -209,7 +209,7 @@ impl ZwlrOutputManagerV1 {
             head.send_position(p.pos.get().0, p.pos.get().1);
             head.send_transform(p.transform.get());
             if head.version >= ADAPTIVE_SYNC_SINCE {
-                head.send_adaptive_sync(p.vrr_mode.get());
+                head.send_adaptive_sync(&p.vrr_mode.get());
             }
         }
         self.schedule_done();

src/state.rs

@@ -248,9 +248,9 @@ pub struct State {
     pub tablet_tool_ids: TabletToolIds,
     pub tablet_pad_ids: TabletPadIds,
     pub damage_visualizer: DamageVisualizer,
-    pub default_vrr_mode: Cell<&'static VrrMode>,
+    pub default_vrr_mode: Cell<VrrMode>,
     pub default_vrr_cursor_hz: Cell<Option<f64>>,
-    pub default_tearing_mode: Cell<&'static TearingMode>,
+    pub default_tearing_mode: Cell<TearingMode>,
     pub ei_acceptor: CloneCell<Option<Rc<EiAcceptor>>>,
     pub ei_acceptor_future: CloneCell<Option<SpawnedFuture<()>>>,
     pub enable_ei_acceptor: Cell<bool>,

src/tree/output.rs

@@ -1460,28 +1460,28 @@ impl OutputNode {
         self.state.tree_changed();
     }
 
-    pub fn set_vrr_mode(&self, mode: &'static VrrMode) {
+    pub fn set_vrr_mode(&self, mode: &VrrMode) {
-        let old = self.global.persistent.vrr_mode.replace(mode);
+        let old = self.global.persistent.vrr_mode.replace(*mode);
-        if old != mode {
+        if old != *mode {
             self.update_presentation_type();
             self.global
                 .connector
                 .head_managers
-                .handle_vrr_mode_change(mode.to_config());
+                .handle_vrr_mode_change(mode);
             for head in self.global.connector.wlr_output_heads.lock().values() {
                 head.handle_vrr_mode_change(mode);
             }
         }
     }
 
-    pub fn set_tearing_mode(&self, mode: &'static TearingMode) {
+    pub fn set_tearing_mode(&self, mode: &TearingMode) {
-        let old = self.global.persistent.tearing_mode.replace(mode);
+        let old = self.global.persistent.tearing_mode.replace(*mode);
-        if old != mode {
+        if old != *mode {
             self.update_presentation_type();
             self.global
                 .connector
                 .head_managers
-                .handle_tearing_mode_change(mode.to_config());
+                .handle_tearing_mode_change(mode);
         }
     }
 
@@ -1892,8 +1892,9 @@ pub fn calculate_logical_size(
     (width, height)
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
 pub enum VrrMode {
+    #[default]
     Never,
     Always,
     Fullscreen {
@@ -1957,8 +1958,9 @@ impl VrrMode {
     }
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Default)]
 pub enum TearingMode {
+    #[default]
     Never,
     Always,
     Fullscreen {