backend: remove Copy from BackendConnectorState

src/backend.rs

@@ -617,7 +617,7 @@ linear_ids!(
     u64
 );
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct BackendConnectorState {
     pub serial: BackendConnectorStateSerial,
     pub enabled: bool,

src/backend/transaction.rs

@@ -193,7 +193,7 @@ impl ConnectorTransaction {
             Entry::Occupied(v) => v.into_mut(),
             Entry::Vacant(v) => v.insert(connector.create_transaction()?),
         };
-        tran.add(connector, state)?;
+        tran.add(connector, state.clone())?;
         self.common.states.insert(connector.id(), state);
         Ok(())
     }

src/backends/metal/transaction.rs

@@ -189,7 +189,7 @@ impl MetalDrmDeviceData {
                 ConnectorConfig {
                     obj: connector.clone(),
                     new: dd.drm_state.clone(),
-                    state: *dd.persistent.state.borrow(),
+                    state: dd.persistent.state.borrow().clone(),
                     requested: false,
                     changed: Default::default(),
                 },

src/backends/metal/video.rs

@@ -637,7 +637,7 @@ impl MetalConnector {
             | FrontState::Connected { non_desktop: true } => return,
             FrontState::Connected { non_desktop: false } => {}
         }
-        let mut state = *self.display.borrow().persistent.state.borrow();
+        let mut state = self.display.borrow().persistent.state.borrow().clone();
         state.serial = self.state.backend_connector_state_serials.next();
         self.send_event(ConnectorEvent::State(state));
     }
@@ -1928,7 +1928,7 @@ impl MetalBackend {
         if dd.supports_bt2020 {
             color_spaces.push(BackendColorSpace::Bt2020);
         }
-        let mut state = *dd.persistent.state.borrow();
+        let mut state = dd.persistent.state.borrow().clone();
         state.serial = self.state.backend_connector_state_serials.next();
         connector.send_event(ConnectorEvent::Connected(MonitorInfo {
             modes,
@@ -2573,7 +2573,7 @@ impl MetalBackend {
             let mut tran = dev.create_transaction();
             for c in dev.connectors.lock().values() {
                 let dd = &*c.display.borrow();
-                let mut state = *dd.persistent.state.borrow();
+                let mut state = dd.persistent.state.borrow().clone();
                 let mut changed_any = false;
                 if disable_non_default_format && state.format != XRGB8888 {
                     state.format = XRGB8888;

src/backends/x.rs

@@ -506,7 +506,7 @@ impl XBackend {
             next_image: Default::default(),
             cb: CloneCell::new(None),
             images,
-            state: Cell::new(state),
+            state: RefCell::new(state),
         });
         {
             let class = "jay\0jay\0";
@@ -604,7 +604,7 @@ impl XBackend {
             color_spaces: vec![],
             primaries: Primaries::SRGB,
             luminance: None,
-            state: output.state.get(),
+            state: output.state.borrow().clone(),
         }));
         output.changed();
         self.present(output).await;
@@ -983,11 +983,11 @@ impl XBackend {
                 old.tex.set(new.tex.get());
                 old.pixmap.set(new.pixmap.get());
             }
-            let mut state = output.state.get();
+            let mut state = output.state.borrow().clone();
             state.serial = self.state.backend_connector_state_serials.next();
             state.mode.width = width;
             state.mode.height = height;
-            output.state.set(state);
+            *output.state.borrow_mut() = state.clone();
             output.events.push(ConnectorEvent::State(state));
             output.changed();
         }
@@ -1057,7 +1057,7 @@ struct XOutput {
     next_image: NumCell<usize>,
     images: [XImage; 2],
     cb: CloneCell<Option<Rc<dyn Fn()>>>,
-    state: Cell<BackendConnectorState>,
+    state: RefCell<BackendConnectorState>,
 }
 
 struct XImage {
@@ -1133,7 +1133,7 @@ struct XTransaction {
 impl XTransaction {
     fn send_state(&self) {
         for con in self.connectors.values() {
-            let mut state = con.state.get();
+            let mut state = con.state.borrow().clone();
             state.serial = con.backend.state.backend_connector_state_serials.next();
             con.events.push(ConnectorEvent::State(state));
         }

src/compositor.rs

@@ -86,7 +86,15 @@ use {
         video::{GfxApi, Transform},
         workspace::WorkspaceDisplayOrder,
     },
-    std::{cell::Cell, env, future::Future, ops::Deref, rc::Rc, sync::Arc, time::Duration},
+    std::{
+        cell::{Cell, RefCell},
+        env,
+        future::Future,
+        ops::Deref,
+        rc::Rc,
+        sync::Arc,
+        time::Duration,
+    },
     thiserror::Error,
     uapi::c,
 };
@@ -694,7 +702,7 @@ fn create_dummy_output(state: &Rc<State>) {
         damage: Default::default(),
         needs_vblank_emulation: Cell::new(false),
         damage_intersect: Default::default(),
-        state: Cell::new(backend_state),
+        state: RefCell::new(backend_state),
         head_managers: HeadManagers::new(head_name, head_state),
         wlr_output_heads: Default::default(),
     });

src/ifs/head_management/jay_head_manager_session_v1.rs

@@ -258,8 +258,8 @@ impl JayHeadManagerSessionV1 {
             let Some(connector) = self.client.state.connectors.get(&head.common.id) else {
                 return Err(HeadTransactionError::HeadRemoved(head.common.id));
             };
-            let old = connector.state.get();
+            let old = connector.state.borrow().clone();
-            let mut new = old;
+            let mut new = old.clone();
             new.enabled = desired.connector_enabled;
             new.mode = desired.mode;
             new.non_desktop_override = desired.override_non_desktop;

src/ifs/jay_randr.rs

@@ -72,7 +72,7 @@ impl JayRandr {
     }
 
     fn send_connector(&self, data: &ConnectorData) {
-        let state = data.state.get();
+        let state_enabled = data.state.borrow().enabled;
         self.client.event(Connector {
             self_id: self.id,
             id: data.connector.id().raw() as _,
@@ -81,7 +81,7 @@ impl JayRandr {
                 .as_ref()
                 .map(|d| d.dev.id().raw() as _)
                 .unwrap_or_default(),
-            enabled: state.enabled as _,
+            enabled: state_enabled as _,
             name: &data.name,
         });
         let Some(output) = self.client.state.outputs.get(&data.connector.id()) else {

src/ifs/wl_output.rs

@@ -206,7 +206,7 @@ impl WlOutputGlobal {
     ) -> Self {
         let (x, y) = persistent_state.pos.get();
         let scale = persistent_state.scale.get();
-        let connector_state = connector.state.get();
+        let connector_state = connector.state.borrow();
         let (width, height) = calculate_logical_size(
             (connector_state.mode.width, connector_state.mode.height),
             persistent_state.transform.get(),

src/ifs/wlr_output_manager/zwlr_output_configuration_v1.rs

@@ -73,7 +73,7 @@ impl ZwlrOutputConfigurationV1 {
         }
         let mut tran = ConnectorTransaction::new(&self.client.state);
         for output in self.client.state.outputs.lock().values() {
-            let mut state = output.connector.state.get();
+            let mut state = output.connector.state.borrow().clone();
             match self.enabled_outputs.get(&output.connector.id) {
                 None => {
                     if self.configured_outputs.not_contains(&output.connector.id) {

src/ifs/wlr_output_manager/zwlr_output_manager_v1.rs

@@ -131,7 +131,7 @@ impl ZwlrOutputManagerV1 {
             }
         };
         let mi = &output.monitor_info;
-        let state = output.connector.state.get();
+        let state_mode = output.connector.state.borrow().mode;
         let head_id = self.client.state.wlr_output_managers.head_ids.next();
         let mut modes_list = vec![];
         let mut modes = AHashMap::new();
@@ -140,7 +140,7 @@ impl ZwlrOutputManagerV1 {
             if modes.contains_key(mode) {
                 continue;
             }
-            let current = !have_current && *mode == state.mode;
+            let current = !have_current && *mode == state_mode;
             if current {
                 have_current = true;
             }

src/state.rs

@@ -420,7 +420,7 @@ pub struct ConnectorData {
     pub damage: RefCell<Vec<Rect>>,
     pub needs_vblank_emulation: Cell<bool>,
     pub damage_intersect: Cell<Rect>,
-    pub state: Cell<BackendConnectorState>,
+    pub state: RefCell<BackendConnectorState>,
     pub head_managers: HeadManagers,
     pub wlr_output_heads: CopyHashMap<WlrOutputManagerId, Rc<ZwlrOutputHeadV1>>,
 }
@@ -456,26 +456,26 @@ impl ConnectorData {
         state: &State,
         f: impl FnOnce(&mut BackendConnectorState),
     ) -> Result<(), BackendConnectorTransactionError> {
-        let old = self.state.get();
+        let old = self.state.borrow().clone();
-        let mut s = old;
+        let mut s = old.clone();
         f(&mut s);
         if old == s {
             return Ok(());
         }
         s.serial = state.backend_connector_state_serials.next();
         let mut tran = self.connector.create_transaction()?;
-        tran.add(&self.connector, s)?;
+        tran.add(&self.connector, s.clone())?;
         tran.prepare()?.apply()?.commit();
         self.set_state(state, s);
         Ok(())
     }
 
     pub fn set_state(&self, state: &State, s: BackendConnectorState) {
-        let old = self.state.get();
+        let old = self.state.borrow().clone();
         if old.serial >= s.serial {
             return;
         }
-        self.state.set(s);
+        *self.state.borrow_mut() = s.clone();
         if old.enabled != s.enabled {
             self.head_managers.handle_enabled_change(s.enabled);
         }

src/tasks/connector.rs

@@ -19,7 +19,12 @@ use {
         },
     },
     jay_config::video::Transform,
-    std::{cell::Cell, collections::VecDeque, fmt, rc::Rc},
+    std::{
+        cell::{Cell, RefCell},
+        collections::VecDeque,
+        fmt,
+        rc::Rc,
+    },
 };
 
 pub fn handle(state: &Rc<State>, connector: &Rc<dyn Connector>) {
@@ -83,7 +88,7 @@ pub fn handle(state: &Rc<State>, connector: &Rc<dyn Connector>) {
         damage: Default::default(),
         needs_vblank_emulation: Cell::new(false),
         damage_intersect: Default::default(),
-        state: Cell::new(backend_state),
+        state: RefCell::new(backend_state),
         head_managers: HeadManagers::new(state.head_names.next(), head_state),
         wlr_output_heads: Default::default(),
     });
@@ -144,7 +149,7 @@ impl ConnectorHandler {
     async fn handle_connected(&self, info: MonitorInfo) {
         log::info!("Connector {} connected", self.data.connector.kernel_id());
         self.data.connected.set(true);
-        self.data.set_state(&self.state, info.state);
+        self.data.set_state(&self.state, info.state.clone());
         *self.data.description.borrow_mut() = create_description(&info);
         let name = self.state.globals.name();
         if info.non_desktop_effective {

src/tasks/idle.rs

@@ -138,7 +138,7 @@ impl Idle {
     fn try_set_idle(&self, idle: bool) -> Result<(), BackendConnectorTransactionError> {
         let mut tran = ConnectorTransaction::new(&self.state);
         for connector in self.state.connectors.lock().values() {
-            let mut state = connector.state.get();
+            let mut state = connector.state.borrow().clone();
             state.active = !idle;
             tran.add(&connector.connector, state)?;
         }