entailz/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

output: don't use config Vrr and Tearing modes

Browse source
This commit is contained in:
Julian Orth 2026-02-25 12:06:04 +01:00
parent e063b7c14b
commit fb9b83994a
14 changed files with 55 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/compositor.rs
View file

@ -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,

4
src/config/handler.rs
View file

@ -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(())
}

15
src/ifs/head_management.rs
View file

@ -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.tearing_mode = n.global.persistent.tearing_mode.get().to_config();
state.vrr_mode = n.global.persistent.vrr_mode.get();
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 {

2
src/ifs/head_management/jay_head_ext/jay_head_ext_jay_tearing_mode_info_v1.rs
View file

@ -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,
});
}
}

14
src/ifs/head_management/jay_head_ext/jay_head_ext_jay_tearing_mode_setter_v1.rs
View file

@ -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
.push_op(HeadOp::SetTearingMode(TearingMode(req.mode)))?;
};
self.common.push_op(HeadOp::SetTearingMode(*mode))?;
Ok(())
}
}

2
src/ifs/head_management/jay_head_ext/jay_head_ext_jay_vrr_mode_info_v1.rs
View file

@ -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,
});
}
}

13
src/ifs/head_management/jay_head_ext/jay_head_ext_jay_vrr_mode_setter_v1.rs
View file

@ -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(())
}
}

11
src/ifs/head_management/jay_head_manager_session_v1.rs
View file

@ -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_tearing_mode(TearingMode::from_config(desired.tearing_mode).unwrap());
node.set_vrr_mode(&desired.vrr_mode);
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
.set(VrrMode::from_config(desired.vrr_mode).unwrap());
pos.tearing_mode
.set(TearingMode::from_config(desired.tearing_mode).unwrap());
pos.vrr_mode.set(desired.vrr_mode);
pos.tearing_mode.set(desired.tearing_mode);
pos.brightness.set(desired.brightness);
}
}

8
src/ifs/wl_output.rs
View file

@ -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),

4
src/ifs/wlr_output_manager/zwlr_output_configuration_head.rs
View file

@ -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(())
}
}

2
src/ifs/wlr_output_manager/zwlr_output_configuration_v1.rs
View file

@ -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 {

2
src/ifs/wlr_output_manager/zwlr_output_manager_v1.rs
View file

@ -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();

4
src/state.rs
View file

@ -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>,

22
src/tree/output.rs
View file

@ -1460,28 +1460,28 @@ impl OutputNode {
self.state.tree_changed();
}
pub fn set_vrr_mode(&self, mode: &'static VrrMode) {
let old = self.global.persistent.vrr_mode.replace(mode);
if old != mode {
pub fn set_vrr_mode(&self, mode: &VrrMode) {
let old = self.global.persistent.vrr_mode.replace(*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) {
let old = self.global.persistent.tearing_mode.replace(mode);
if old != mode {
pub fn set_tearing_mode(&self, mode: &TearingMode) {
let old = self.global.persistent.tearing_mode.replace(*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 {