df_displmgr 0.1.1

A unified cross-platform display configuration manager for Windows (CCD/GDI) and Linux (Wayland/wlroots/DRM/KDE/udev).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Stub backend for unsupported platforms.
//!
//! This module provides a no-op implementation of [`UniversalTopology`] and
//! [`OutputEditable`] so the crate compiles on platforms other than Windows
//! and Linux (e.g., macOS, WASM targets, or docs.rs documentation builds).
//!
//! All methods return [`DisplayError::UnsupportedFeature`] to ensure callers
//! receive a clear, idiomatic error at runtime.

use async_trait::async_trait;

use crate::error::{DisplayError, DisplayResult};
use crate::traits::{OutputEditable, UniversalTopology};
use crate::types::{DisplayId, DisplayRotation, Extent2D, HdrMode, HdrState, OutputState, Point2D};

/// Stub topology for unsupported platforms.
///
/// Every method returns an [`DisplayError::UnsupportedFeature`] error.
/// This type exists solely to satisfy the [`UniversalTopology`] trait
/// bound on [`NativeTopology`](super::NativeTopology) during documentation
/// builds and cross-platform compilation.
pub struct StubTopology;

/// Stub output editor for unsupported platforms.
///
/// All mutation methods return
/// [`DisplayError::UnsupportedFeature`].
pub struct StubOutputEditor;

impl OutputEditable for StubOutputEditor {
    fn set_rotation(
        &mut self,
        _rotation: DisplayRotation,
    ) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_resolution(&mut self, _extent: Extent2D) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_position(&mut self, _position: Point2D) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_refresh_rate(&mut self, _rate: u32) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_primary(&mut self) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_hdr(
        &mut self,
        _state: HdrState,
        _mode: HdrMode,
    ) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_scale(&mut self, _scale: f64) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_enabled(&mut self, _enabled: bool) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn clone_from(&mut self, _source_id: &DisplayId) -> DisplayResult<&mut dyn OutputEditable> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn get_state(&self) -> OutputState {
        OutputState::default()
    }
}

#[async_trait]
impl UniversalTopology for StubTopology {
    fn acquire() -> DisplayResult<Self> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn get_outputs(&self) -> Vec<OutputState> {
        Vec::new()
    }

    fn edit_output(&mut self, _id: &DisplayId) -> DisplayResult<Box<dyn OutputEditable + '_>> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    fn set_persistence(&mut self, _enabled: bool) -> &mut Self {
        self
    }

    async fn validate(&self) -> DisplayResult<()> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }

    async fn commit(&mut self) -> DisplayResult<()> {
        Err(DisplayError::UnsupportedFeature(
            "platform not supported".into(),
        ))
    }
}