Struct KdeOutputDeviceV2

pub struct KdeOutputDeviceV2 { /* private fields */ }

output configuration representation

An output device describes a display device available to the compositor. output_device is similar to wl_output, but focuses on output configuration management.

A client can query all global output_device objects to enlist all available display devices, even those that may currently not be represented by the compositor as a wl_output.

The client sends configuration changes to the server through the outputconfiguration interface, and the server applies the configuration changes to the hardware and signals changes to the output devices accordingly.

This object is published as global during start up for every available display devices, or when one later becomes available, for example by being hotplugged via a physical connector.

Warning! The protocol described in this file is a desktop environment implementation detail. Regular clients must not use this protocol. Backward incompatible changes may be added without bumping the major version of the extension.

This interface has no requests.

Implementations

impl KdeOutputDeviceV2

pub fn geometry( &self, x: i32, y: i32, physical_width: i32, physical_height: i32, subpixel: i32, make: String, model: String, transform: i32, )

geometric properties of the output

The geometry event describes geometric properties of the output. The event is sent when binding to the output object and whenever any of the properties change.

pub fn current_mode(&self, mode: &KdeOutputDeviceModeV2)

current mode

This event describes the mode currently in use for this head. It is only sent if the output is enabled.

pub fn mode(&self, mode: &KdeOutputDeviceModeV2)

advertise available output modes and current one

The mode event describes an available mode for the output.

When the client binds to the output_device object, the server sends this event once for every available mode the output_device can be operated by.

There will always be at least one event sent out on initial binding, which represents the current mode.

Later if an output changes, its mode event is sent again for the eventual added modes and lastly the current mode. In other words, the current mode is always represented by the latest event sent with the current flag set.

The size of a mode is given in physical hardware units of the output device. This is not necessarily the same as the output size in the global compositor space. For instance, the output may be scaled, as described in kde_output_device_v2.scale, or transformed, as described in kde_output_device_v2.transform.

pub fn done(&self)

sent all information about output

This event is sent after all other properties have been sent on binding to the output object as well as after any other output property change have been applied later on. This allows to see changes to the output properties as atomic, even if multiple events successively announce them.

pub fn scale(&self, factor: f64)

output scaling properties

This event contains scaling geometry information that is not in the geometry event. It may be sent after binding the output object or if the output scale changes later. If it is not sent, the client should assume a scale of 1.

A scale larger than 1 means that the compositor will automatically scale surface buffers by this amount when rendering. This is used for high resolution displays where applications rendering at the native resolution would be too small to be legible.

It is intended that scaling aware clients track the current output of a surface, and if it is on a scaled output it should use wl_surface.set_buffer_scale with the scale of the output. That way the compositor can avoid scaling the surface, and the client can supply a higher detail image.

pub fn edid(&self, raw: String)

advertise EDID data for the output

The edid event encapsulates the EDID data for the outputdevice.

The event is sent when binding to the output object. The EDID data may be empty, in which case this event is sent anyway. If the EDID information is empty, you can fall back to the name et al. properties of the outputdevice.

pub fn enabled(&self, enabled: i32)

output is enabled or disabled

The enabled event notifies whether this output is currently enabled and used for displaying content by the server. The event is sent when binding to the output object and whenever later on an output changes its state by becoming enabled or disabled.

pub fn uuid(&self, uuid: String)

A unique id for this outputdevice

The uuid can be used to identify the output. It’s controlled by the server entirely. The server should make sure the uuid is persistent across restarts. An empty uuid is considered invalid.

pub fn serial_number(&self, serialNumber: String)

Serial Number

Serial ID of the monitor, sent on startup before the first done event.

pub fn eisa_id(&self, eisaId: String)

EISA ID

EISA ID of the monitor, sent on startup before the first done event.

pub fn capabilities(&self, flags: Capability)

capability flags

What capabilities this device has, sent on startup before the first done event.

pub fn overscan(&self, overscan: u32)

overscan

Overscan value of the monitor in percent, sent on startup before the first done event.

pub fn vrr_policy(&self, vrr_policy: VrrPolicy)

Variable Refresh Rate Policy

What policy the compositor will employ regarding its use of variable refresh rate.

pub fn rgb_range(&self, rgb_range: RgbRange)

RGB range

What rgb range the compositor is using for this output

pub fn name(&self, name: String)

Output’s name

Name of the output, it’s useful to cross-reference to an zxdg_output_v1 and ultimately QScreen

pub fn high_dynamic_range(&self, hdr_enabled: u32)

if HDR is enabled

Whether or not high dynamic range is enabled for this output

pub fn sdr_brightness(&self, sdr_brightness: u32)

the brightness of sdr if hdr is enabled

If high dynamic range is used, this value defines the brightness in nits for content that’s in standard dynamic range format. Note that while the value is in nits, that doesn’t necessarily translate to the same brightness on the screen.

pub fn wide_color_gamut(&self, wcg_enabled: u32)

if WCG is enabled

Whether or not the use of a wide color gamut is enabled for this output

pub fn auto_rotate_policy(&self, policy: AutoRotatePolicy)

describes when auto rotate is used

pub fn icc_profile_path(&self, profile_path: String)

describes when auto rotate is used

pub fn brightness_metadata( &self, max_peak_brightness: u32, max_frame_average_brightness: u32, min_brightness: u32, )

metadata about the screen’s brightness limits

pub fn brightness_overrides( &self, max_peak_brightness: i32, max_average_brightness: i32, min_brightness: i32, )

overrides for the screen’s brightness limits

pub fn sdr_gamut_wideness(&self, gamut_wideness: u32)

describes which gamut is assumed for sRGB applications

This can be used to provide the colors users assume sRGB applications should have based on the default experience on many modern sRGB screens.

pub fn color_profile_source(&self, source: ColorProfileSource)

describes which source the compositor uses for the color profile on an output

pub fn brightness(&self, brightness: u32)

brightness multiplier

This is the brightness modifier of the output. It doesn’t specify any absolute values, but is merely a multiplier on top of other brightness values, like sdr_brightness and brightness_metadata. 0 is the minimum brightness (not completely dark) and 10000 is the maximum brightness. This is currently only supported / meaningful while HDR is active.

pub fn color_power_tradeoff(&self, preference: ColorPowerTradeoff)

the preferred color/power tradeoff

pub fn dimming(&self, multiplier: u32)

dimming multiplier

This is the dimming multiplier of the output. This is similar to the brightness setting, except it’s meant to be a temporary setting only, not persistent and may be implemented differently depending on the display. 0 is the minimum dimming factor (not completely dark) and 10000 means the output is not dimmed.

Trait Implementations

impl Borrow<ObjectId> for KdeOutputDeviceV2

fn borrow(&self) -> &ObjectId

Immutably borrows from an owned value.

impl Clone for KdeOutputDeviceV2

fn clone(&self) -> KdeOutputDeviceV2

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KdeOutputDeviceV2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for KdeOutputDeviceV2

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<Weak<KdeOutputDeviceV2>> for KdeOutputDeviceV2

fn eq(&self, other: &Weak<KdeOutputDeviceV2>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for KdeOutputDeviceV2

fn eq(&self, other: &KdeOutputDeviceV2) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Resource for KdeOutputDeviceV2

type Request = Request

The request enum for this interface

type Event<'event> = Event<'event>

The event enum for this interface

fn interface() -> &'static Interface

The interface description

fn id(&self) -> ObjectId

The ID of this object

fn version(&self) -> u32

The version of this object

fn data<U: 'static>(&self) -> Option<&U>

Access the user-data associated with this object

fn object_data(&self) -> Option<&Arc<dyn Any + Send + Sync>>

Access the raw data associated with this object.

fn handle(&self) -> &WeakHandle

Access the backend handle associated with this object

fn from_id(conn: &DisplayHandle, id: ObjectId) -> Result<Self, InvalidId>

Create an object resource from its ID

fn send_event(&self, evt: Self::Event<'_>) -> Result<(), InvalidId>

Send an event to this object

fn parse_request( conn: &DisplayHandle, msg: Message<ObjectId, OwnedFd>, ) -> Result<(Self, Self::Request), DispatchError>

Parse a event for this object

fn write_event<'a>( &self, conn: &DisplayHandle, msg: Self::Event<'a>, ) -> Result<Message<ObjectId, BorrowedFd<'a>>, InvalidId>

Serialize an event for this object

fn client(&self) -> Option<Client>

The client owning this object

fn is_alive(&self) -> bool

Checks if the Wayland object associated with this proxy is still alive

fn post_error(&self, code: impl Into<u32>, error: impl Into<String>)

Trigger a protocol error on this object

fn downgrade(&self) -> Weak<Self>

Creates a weak handle to this object

impl Eq for KdeOutputDeviceV2