From 222350149385a3e7c84b94fa26311cd2b826be4e Mon Sep 17 00:00:00 2001 From: Lorenzo Golluscio <149246609+ssupt@users.noreply.github.com> Date: Fri, 9 Oct 2026 05:21:51 +0200 Subject: [PATCH 1/2] Preserve non-stereo DTD flags and avoid false pending overrides Only classify a detailed timing as stereo when bits 6:5 are nonzero. Keep bit 0 and the checksum unchanged for non-stereo timings, including the reported 0x19 and 0x1b flags. Cover base and CTA timings, mixed stereo/non-stereo descriptors, pending override detection, and a VRR export that preserves all unrelated bytes. Reported by neheb in issue #3; the detection correction follows their proposed fix at bbcc068c619365efe3cad8348c57ac6d10c62eec. --- src/edid.rs | 52 +++++++++++++++++++++++++++++++++++++++++-- src/export.rs | 58 ++++++++++++++++++++++++++++++++++++++++++++++++ src/workspace.rs | 15 +++++++++++++ 3 files changed, 123 insertions(+), 2 deletions(-) diff --git a/src/edid.rs b/src/edid.rs index 7528c86..212407d 100644 --- a/src/edid.rs +++ b/src/edid.rs @@ -711,6 +711,7 @@ fn repair_block_checksum(block: &mut [u8]) { /// Remove stereoscopic DTD flags from a desktop EDID override. Preserve sync, /// interlace, monitor descriptors, data blocks, and unsupported extensions. +/// Bit 0 only selects a stereo format when bits 6:5 are nonzero. pub fn clear_detailed_timing_stereo(raw: &mut [u8]) -> usize { if raw.len() < BASE_BLOCK_LEN || raw[..8] != HEADER { return 0; @@ -733,7 +734,7 @@ pub fn clear_detailed_timing_stereo(raw: &mut [u8]) -> usize { }; let mut changed = false; for descriptor in block[range].chunks_exact_mut(DTD_LEN) { - if (descriptor[0] != 0 || descriptor[1] != 0) && descriptor[17] & 0x61 != 0 { + if (descriptor[0] != 0 || descriptor[1] != 0) && descriptor[17] & 0x60 != 0 { descriptor[17] &= !0x61; cleared += 1; changed = true; @@ -1468,7 +1469,7 @@ mod tests { #[test] fn clears_all_stereo_encodings_without_changing_other_dtd_fields() { - for stereo in [0x01, 0x20, 0x21, 0x40, 0x41, 0x60, 0x61] { + for stereo in [0x20, 0x21, 0x40, 0x41, 0x60, 0x61] { let mut raw = minimal_base_edid(1); let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); descriptor[17] = 0x9e | stereo; @@ -1499,6 +1500,53 @@ mod tests { } } + #[test] + fn non_stereo_dtd_flags_and_checksums_are_preserved() { + let mut raw = minimal_base_edid(1); + for (slot, flags) in [0x19, 0x1b].into_iter().enumerate() { + let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); + descriptor[17] = flags; + let offset = DTD_START + slot * DTD_LEN; + raw[offset..offset + DTD_LEN].copy_from_slice(&descriptor); + } + repair_block_checksum(&mut raw); + let mut cta = vec![0; EDID_BLOCK_LEN]; + cta[0] = CTA_TAG; + cta[1] = 3; + cta[2] = 4; + for (slot, flags) in [0x19, 0x1b].into_iter().enumerate() { + let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); + descriptor[17] = flags; + let offset = 4 + slot * DTD_LEN; + cta[offset..offset + DTD_LEN].copy_from_slice(&descriptor); + } + repair_block_checksum(&mut cta); + raw.extend_from_slice(&cta); + let before = raw.clone(); + + assert_eq!(clear_detailed_timing_stereo(&mut raw), 0); + assert_eq!(raw, before); + assert!(raw.chunks_exact(EDID_BLOCK_LEN).all(block_checksum_valid)); + } + + #[test] + fn stereo_cleanup_preserves_adjacent_non_stereo_dtds() { + let mut raw = minimal_base_edid(0); + for (slot, flags) in [0x19, 0x7b, 0x1b].into_iter().enumerate() { + let mut descriptor = encode_detailed_timing(&sample_timing()).unwrap(); + descriptor[17] = flags; + let offset = DTD_START + slot * DTD_LEN; + raw[offset..offset + DTD_LEN].copy_from_slice(&descriptor); + } + repair_block_checksum(&mut raw); + let mut expected = raw.clone(); + expected[DTD_START + DTD_LEN + 17] = 0x1a; + repair_block_checksum(&mut expected); + + assert_eq!(clear_detailed_timing_stereo(&mut raw), 1); + assert_eq!(raw, expected); + } + #[test] fn displayid_product_id_does_not_hide_following_timings() { let mut edid = minimal_base_edid(1); diff --git a/src/export.rs b/src/export.rs index eee9a52..882baf9 100644 --- a/src/export.rs +++ b/src/export.rs @@ -316,6 +316,64 @@ mod tests { fs::remove_dir_all(directory).unwrap(); } + #[test] + fn vrr_export_preserves_non_stereo_timing_flags_and_extension_bytes() { + let mut monitor = crate::demo::monitors().unwrap().remove(0); + let mut raw = monitor.edid.as_ref().unwrap().raw.clone(); + for (offset, flags) in [(71, 0x19), (89, 0x1b), (154, 0x1b), (172, 0x19)] { + raw[offset] = flags; + } + for block in raw.chunks_exact_mut(128) { + block[127] = 0u8.wrapping_sub( + block[..127] + .iter() + .fold(0u8, |sum, byte| sum.wrapping_add(*byte)), + ); + } + monitor.edid = Some(crate::edid::parse_edid(raw.clone()).unwrap()); + let mut workspace = EdidWorkspace::new(raw.clone()).unwrap(); + assert!(!workspace.has_changes()); + workspace + .set_vrr_range(crate::edid::VrrRange { + min_hz: 40, + max_hz: 144, + }) + .unwrap(); + assert!( + workspace + .diff_summary() + .iter() + .all(|line| !line.contains("stereo")) + ); + let directory = std::env::temp_dir().join(format!( + "drmcru-vrr-export-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_nanos() + )); + fs::create_dir(&directory).unwrap(); + let result = + export_workspace_edid(&monitor, &workspace, "2560x1440@144", &directory).unwrap(); + let exported = fs::read(result.path).unwrap(); + let mut expected = raw; + expected[95] = 40; + expected[127] = 0u8.wrapping_sub( + expected[..127] + .iter() + .fold(0u8, |sum, byte| sum.wrapping_add(*byte)), + ); + + assert_eq!(exported, expected); + assert!( + exported + .chunks_exact(128) + .all(crate::edid::block_checksum_valid) + ); + fs::remove_dir_all(directory).unwrap(); + } + #[test] fn instructions_shell_quote_generated_path() { let plan = build_export_plan_with_file("DP-1", "custom.bin", sample_timing()); diff --git a/src/workspace.rs b/src/workspace.rs index 4ae2739..9ccc94d 100644 --- a/src/workspace.rs +++ b/src/workspace.rs @@ -542,6 +542,21 @@ mod tests { ); } + #[test] + fn non_stereo_bit_zero_is_not_a_pending_override() { + for flags in [0x19, 0x1b] { + let mut raw = + patch_base_detailed_timing(&minimal_base_edid(0), 0, &sample_timing()).unwrap(); + raw[71] = flags; + repair_checksum(&mut raw); + let workspace = EdidWorkspace::new(raw.clone()).unwrap(); + + assert!(!workspace.has_changes()); + assert_eq!(workspace.export_bytes(), raw); + assert_eq!(workspace.diff_summary(), vec!["No EDID byte changes."]); + } + } + #[test] fn range_changes_export_with_a_valid_checksum_and_can_be_reset() { let mut raw = minimal_base_edid(0); From 8cfd1a3adabe7b9c248aef3cfd61a4dee24712c2 Mon Sep 17 00:00:00 2001 From: Lorenzo Golluscio <149246609+ssupt@users.noreply.github.com> Date: Fri, 9 Oct 2026 05:27:11 +0200 Subject: [PATCH 2/2] Stop unchanged exports from inserting a draft timing Require pending workspace changes before Export opens confirmation or writes files, matching Install/Update. Remove the fallback that inserted the current draft timing when no EDID edits were pending. Keep real stereo cleanup eligible for export and validate the working EDID rather than the unused draft. Preserve explicit Add operations that append a CTA extension, and retain validation of all checksums and timing fields. Document the export behavior and cover unchanged, stereo-only, invalid, and missing-EDID cases. This follows the export behavior change proposed by neheb in the issue #3 follow-up, with additional regression coverage and missing-EDID messages. --- README.md | 4 ++ src/export.rs | 130 ++++++++++++++------------------------------- src/tui/actions.rs | 105 +++++++++++------------------------- src/tui/mod.rs | 78 +++++++++++++++++++++++++-- src/tui/state.rs | 6 +-- 5 files changed, 151 insertions(+), 172 deletions(-) diff --git a/README.md b/README.md index ae1a0b4..4eda770 100644 --- a/README.md +++ b/README.md @@ -94,6 +94,10 @@ reading or changing a real monitor. `Switch` only selects modes already exposed by DRM/Hyprland. It does not make a new EDID mode appear. +Export writes the current working EDID. With no pending changes, it asks you to +make an edit before writing any files. VRR edits and stereo cleanup also count +as pending changes. + ## What It Can Edit - Established timing inspection diff --git a/src/export.rs b/src/export.rs index 882baf9..6404553 100644 --- a/src/export.rs +++ b/src/export.rs @@ -1,74 +1,24 @@ -use crate::edid::{DtdLocation, EdidError, insert_detailed_timing}; use crate::hyprland_config; -use crate::models::{ExportPlan, Monitor, TimingDescriptor}; +use crate::models::{ExportPlan, Monitor}; use crate::workspace::EdidWorkspace; use std::fs; use std::io; use std::path::{Path, PathBuf}; use thiserror::Error; -pub fn build_export_plan_with_file( - connector: impl Into, - edid_file_name: impl Into, - timing: TimingDescriptor, -) -> ExportPlan { - let connector = connector.into(); - let hyprland_mode = timing.hyprland_mode(); - ExportPlan { - hyprland_rule: format!("monitor={connector},{hyprland_mode},auto,1"), - connector, - edid_file_name: edid_file_name.into(), - hyprland_mode, - position: "auto".to_string(), - scale: "1".to_string(), - } -} - #[derive(Debug, Clone, PartialEq)] pub struct ExportResult { pub path: PathBuf, pub instructions_path: PathBuf, pub plan: ExportPlan, - pub insert_location: Option, } #[derive(Debug, Error)] pub enum ExportError { - #[error("selected monitor has no readable EDID")] - MissingEdid, - #[error("failed to patch EDID: {0}")] - Edid(#[from] EdidError), #[error("failed to write {path}: {source}")] Write { path: PathBuf, source: io::Error }, } -pub fn export_patched_edid( - monitor: &Monitor, - timing: &TimingDescriptor, - output_dir: &Path, -) -> Result { - let edid = monitor.edid.as_ref().ok_or(ExportError::MissingEdid)?; - let (mut patched, insert_location) = insert_detailed_timing(&edid.raw, timing)?; - crate::edid::clear_detailed_timing_stereo(&mut patched); - let file_name = custom_edid_file_name(&monitor.connector); - let path = output_dir.join(&file_name); - let instructions_path = output_dir.join(instructions_file_name(&monitor.connector)); - let plan = build_export_plan_for_monitor(monitor, file_name, timing.clone()); - - fs::write(&path, patched).map_err(|source| ExportError::Write { - path: path.clone(), - source, - })?; - write_instructions(&instructions_path, &path, &plan)?; - - Ok(ExportResult { - path, - instructions_path, - plan, - insert_location: Some(insert_location), - }) -} - pub fn export_workspace_edid( monitor: &Monitor, workspace: &EdidWorkspace, @@ -91,7 +41,6 @@ pub fn export_workspace_edid( path, instructions_path, plan, - insert_location: None, }) } @@ -133,23 +82,6 @@ pub fn custom_edid_file_name(connector: &str) -> String { format!("drmcru_custom_{}.bin", file_safe_connector(connector)) } -fn build_export_plan_for_monitor( - monitor: &Monitor, - edid_file_name: impl Into, - timing: TimingDescriptor, -) -> ExportPlan { - let mut plan = build_export_plan_with_file(&monitor.connector, edid_file_name, timing); - plan.position = monitor_position(monitor); - plan.scale = monitor_scale(monitor); - plan.hyprland_rule = hyprland_config::format_monitor_rule( - &plan.connector, - &plan.hyprland_mode, - &plan.position, - &plan.scale, - ); - plan -} - fn build_export_plan_for_monitor_mode( monitor: &Monitor, edid_file_name: impl Into, @@ -238,7 +170,24 @@ fn write_instructions( #[cfg(test)] mod tests { use super::*; - use crate::models::{ConnectorStatus, HyprlandMonitor}; + use crate::models::{ConnectorStatus, HyprlandMonitor, TimingDescriptor}; + + fn build_export_plan_with_file( + connector: impl Into, + edid_file_name: impl Into, + timing: TimingDescriptor, + ) -> ExportPlan { + let connector = connector.into(); + let hyprland_mode = timing.hyprland_mode(); + ExportPlan { + hyprland_rule: format!("monitor={connector},{hyprland_mode},auto,1"), + connector, + edid_file_name: edid_file_name.into(), + hyprland_mode, + position: "auto".to_string(), + scale: "1".to_string(), + } + } fn sample_timing() -> TimingDescriptor { TimingDescriptor { @@ -272,7 +221,7 @@ mod tests { } #[test] - fn both_export_paths_clear_existing_stereo_flags() { + fn workspace_export_clears_stereo_without_inserting_draft_timings() { let monitor = crate::demo::monitors().unwrap().remove(0); let mut monitor = monitor; let mut raw = monitor.edid.as_ref().unwrap().raw.clone(); @@ -296,23 +245,23 @@ mod tests { .as_nanos() )); fs::create_dir(&directory).unwrap(); - let workspace = EdidWorkspace::new(raw).unwrap(); - for workspace_export in [true, false] { - let result = if workspace_export { - export_workspace_edid(&monitor, &workspace, "2560x1440@144", &directory) - } else { - export_patched_edid(&monitor, &sample_timing(), &directory) - }; - let result = result.unwrap(); - let bytes = fs::read(result.path).unwrap(); - assert_eq!(bytes[71] & 0x61, 0); - assert_eq!(bytes[154] & 0x61, 0); - assert!( - bytes - .chunks_exact(128) - .all(crate::edid::block_checksum_valid) - ); + let workspace = EdidWorkspace::new(raw.clone()).unwrap(); + let result = + export_workspace_edid(&monitor, &workspace, "2560x1440@144", &directory).unwrap(); + let bytes = fs::read(result.path).unwrap(); + assert_eq!(bytes.len(), raw.len()); + assert_eq!(bytes[71] & 0x61, 0); + assert_eq!(bytes[154] & 0x61, 0); + for offset in 0..bytes.len() { + if ![71, 127, 154, 255].contains(&offset) { + assert_eq!(bytes[offset], raw[offset]); + } } + assert!( + bytes + .chunks_exact(128) + .all(crate::edid::block_checksum_valid) + ); fs::remove_dir_all(directory).unwrap(); } @@ -407,8 +356,11 @@ mod tests { edid: None, }; - let plan = - build_export_plan_for_monitor(&monitor, "drmcru_custom_DP-1.bin", sample_timing()); + let plan = build_export_plan_for_monitor_mode( + &monitor, + "drmcru_custom_DP-1.bin", + &sample_timing().hyprland_mode(), + ); let rule = plan.hyprland_monitor_rule(); if rule.starts_with("monitor=") { diff --git a/src/tui/actions.rs b/src/tui/actions.rs index d2fb808..d96da61 100644 --- a/src/tui/actions.rs +++ b/src/tui/actions.rs @@ -7,7 +7,7 @@ use super::{ App, ExtensionRow, FocusArea, ModeKey, ModeProvenance, PendingSystemAction, SystemExecution, }; use crate::edid::DtdLocation; -use crate::export::{custom_edid_file_name, export_patched_edid, export_workspace_edid}; +use crate::export::{custom_edid_file_name, export_workspace_edid}; use crate::hyprland::{self, ModeRequest}; use crate::hyprland_config::{self, MonitorRuleInspection}; use crate::install::{self, InstallPlan, InstallPreview, UninstallPlan, UninstallPreview}; @@ -971,7 +971,22 @@ impl App { } pub(super) fn export_selected_monitor(&mut self) { - let issues = self.export_validation_issues(); + if self.selected_monitor().is_none() { + self.status = "No monitor selected.".to_string(); + return; + } + let Some(workspace) = self.selected_workspace() else { + self.status = "Selected monitor has no readable EDID to export.".to_string(); + return; + }; + if !workspace.has_changes() { + self.status = + "No workspace changes are pending. Add, edit, delete, or import a timing first." + .to_string(); + return; + } + + let issues = self.workspace_validation_issues(workspace); let blocking = issues .iter() .filter(|issue| issue.starts_with("Error:")) @@ -1021,18 +1036,21 @@ impl App { return; }; - let result = match self.selected_workspace() { - Some(workspace) if workspace.has_changes() => { - let Some(mode) = self.workspace_target_mode() else { - self.status = - "Export needs at least one resolution to generate a Hyprland rule." - .to_string(); - return; - }; - export_workspace_edid(monitor, workspace, &mode, &output_dir) - } - _ => export_patched_edid(monitor, &self.draft_timing, &output_dir), + let Some(workspace) = self + .selected_workspace() + .filter(|workspace| workspace.has_changes()) + else { + self.status = + "No workspace changes are pending. Add, edit, delete, or import a timing first." + .to_string(); + return; + }; + let Some(mode) = self.workspace_target_mode() else { + self.status = + "Export needs at least one resolution to generate a Hyprland rule.".to_string(); + return; }; + let result = export_workspace_edid(monitor, workspace, &mode, &output_dir); match result { Ok(result) => { @@ -1054,67 +1072,6 @@ impl App { } } - fn export_validation_issues(&self) -> Vec { - let mut issues = Vec::new(); - let Some(monitor) = self.selected_monitor() else { - issues.push("Error: No monitor is selected.".to_string()); - return issues; - }; - - let exporting_workspace = self - .selected_workspace() - .map(EdidWorkspace::has_changes) - .unwrap_or(false); - - if exporting_workspace { - if let Some(workspace) = self.selected_workspace() { - issues.extend(self.workspace_validation_issues(workspace)); - } - } else { - let Some(edid) = monitor.edid.as_ref() else { - issues.push("Error: Selected monitor has no readable EDID to patch.".to_string()); - return issues; - }; - - if let Ok(mut workspace) = EdidWorkspace::from_edid(edid) { - issues.extend(self.workspace_validation_issues(&workspace)); - if let Err(error) = workspace.add_dtd(self.draft_timing.clone()) { - issues.push(format!("Error: Cannot insert draft timing: {error}")); - } - } - issues.push( - "Warning: No workspace EDID changes are pending; export will insert the current draft detailed timing." - .to_string(), - ); - } - - if !exporting_workspace { - issues.extend( - validate_timing(&self.draft_timing) - .into_iter() - .map(|warning| { - format!("{}: Draft timing: {}", warning.label(), warning.message) - }), - ); - if let Some(warning) = self.internal_panel_timing_warning() { - issues.push(format!("Warning: Internal panel: {}", warning.message)); - } - - if let Some(key) = ModeKey::from_timing(&self.draft_timing) { - let provenance = self.mode_provenance(key); - if provenance.sources.len() > 1 { - issues.push(format!( - "Warning: Draft timing duplicates an existing mode in {} source(s): {}.", - provenance.sources.len(), - provenance.sources.join(", ") - )); - } - } - } - - issues - } - fn workspace_validation_issues(&self, workspace: &EdidWorkspace) -> Vec { let mut issues = workspace .validate() diff --git a/src/tui/mod.rs b/src/tui/mod.rs index 8113004..c561fb4 100644 --- a/src/tui/mod.rs +++ b/src/tui/mod.rs @@ -831,7 +831,7 @@ mod tests { } #[test] - fn draft_export_checks_unknown_extension_checksums_and_length() { + fn workspace_export_checks_unknown_extension_checksums_and_length() { for truncate in [false, true] { let mut monitor = monitor_with_cta_dtd(); let mut raw = monitor.edid.take().unwrap().raw; @@ -844,6 +844,10 @@ mod tests { } monitor.edid = Some(parse_edid(raw).unwrap()); let mut app = App::new(vec![monitor]); + app.selected_workspace_mut() + .unwrap() + .add_dtd(timing()) + .unwrap(); app.export_selected_monitor(); assert!( app.details_dialog @@ -855,7 +859,7 @@ mod tests { } #[test] - fn draft_export_can_append_a_cta_when_existing_slots_are_full() { + fn adding_a_timing_explicitly_can_append_a_cta_when_existing_slots_are_full() { let mut monitor = monitor_with_cta_dtd(); let mut raw = monitor.edid.take().unwrap().raw; for slot in 0..4 { @@ -875,9 +879,70 @@ mod tests { } monitor.edid = Some(parse_edid(raw).unwrap()); let mut app = App::new(vec![monitor]); + app.open_detailed_editor(state::EditorMode::Add); + app.apply_detailed_editor(); + + assert!(app.detailed_editor.is_none()); + let workspace = app.selected_workspace().unwrap(); + assert!(workspace.has_changes()); + assert_eq!(workspace.parsed().raw.len(), 384); + assert!(workspace.validate().is_empty()); + } + + #[test] + fn export_without_a_monitor_or_edid_has_an_actionable_error() { + let mut app = App::new(Vec::new()); + app.export_selected_monitor(); + assert_eq!(app.status, "No monitor selected."); + + let mut monitor = monitor_with_cta_dtd(); + monitor.edid = None; + let mut app = App::new(vec![monitor]); + app.export_selected_monitor(); + assert_eq!( + app.status, + "Selected monitor has no readable EDID to export." + ); + assert!(app.export_confirm_dialog.is_none()); + assert!(app.export_dialog.is_none()); + } + + #[test] + fn export_refuses_unchanged_non_stereo_workspace() { + for flags in [0x1a, 0x19, 0x1b] { + let mut monitor = monitor_with_cta_dtd(); + let mut raw = monitor.edid.take().unwrap().raw; + raw[151] = flags; + repair_checksum(&mut raw[128..]); + monitor.edid = Some(parse_edid(raw.clone()).unwrap()); + let mut app = App::new(vec![monitor]); + + app.export_selected_monitor(); + + assert!(app.export_confirm_dialog.is_none()); + assert!(app.export_dialog.is_none()); + assert!(app.details_dialog.is_none()); + assert!(app.status.contains("No workspace changes")); + assert_eq!(app.selected_workspace().unwrap().export_bytes(), raw); + } + } + + #[test] + fn stereo_only_export_uses_workspace_validation_instead_of_the_draft() { + let mut monitor = monitor_with_cta_dtd(); + let mut raw = monitor.edid.take().unwrap().raw; + raw[151] |= 0xe1; + repair_checksum(&mut raw[128..]); + monitor.edid = Some(parse_edid(raw.clone()).unwrap()); + let mut app = App::new(vec![monitor]); + app.draft_timing.pixel_clock_khz = 0; + app.export_selected_monitor(); + + assert!(app.selected_workspace().unwrap().has_changes()); assert!(app.export_confirm_dialog.is_some()); assert!(app.details_dialog.is_none()); + assert_eq!(app.selected_workspace().unwrap().parsed().raw, raw); } #[test] @@ -986,9 +1051,14 @@ mod tests { } #[test] - fn export_validation_errors_cannot_be_bypassed() { + fn workspace_export_validation_errors_cannot_be_bypassed() { let mut app = App::new(vec![monitor_with_cta_dtd()]); - app.draft_timing.pixel_clock_khz = 0; + let mut invalid_timing = timing(); + invalid_timing.h_blanking = 16; + app.selected_workspace_mut() + .unwrap() + .add_dtd(invalid_timing) + .unwrap(); app.export_selected_monitor(); diff --git a/src/tui/state.rs b/src/tui/state.rs index 2fc14b2..9f5a453 100644 --- a/src/tui/state.rs +++ b/src/tui/state.rs @@ -4,7 +4,6 @@ use crate::export::ExportResult; use crate::models::{StandardTiming, StandardTimingAspect, TimingDescriptor}; use crate::timings::{CvtRequest, TimingPreset, timing_for_preset}; use crate::validation::validate_timing; -use crate::workspace::format_location; use ratatui::prelude::*; #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -179,10 +178,7 @@ impl ExportDialog { Self { path: result.path.display().to_string(), instructions_path: result.instructions_path.display().to_string(), - location: result - .insert_location - .map(format_location) - .unwrap_or_else(|| "workspace EDID".to_string()), + location: "workspace EDID".to_string(), kernel_parameter: result.plan.drm_kernel_parameter(), hyprland_rule: result.plan.hyprland_monitor_rule(), }