Struct fidl_fuchsia_hardware_display::Info

pub struct Info {
    pub id: DisplayId,
    pub modes: Vec<Mode>,
    pub pixel_format: Vec<PixelFormat>,
    pub manufacturer_name: String,
    pub monitor_name: String,
    pub monitor_serial: String,
    pub horizontal_size_mm: u32,
    pub vertical_size_mm: u32,
    pub using_fallback_size: bool,
}

Description for a display device attached to the system.

Display devices include external monitors and internal panels.

Fields

id: DisplayId

Uniquely identifies the display in a Controller connection.

See [fuchsia.hardware.display.types/DisplayId].

modes: Vec<Mode>

Operational modes supported by the described display device.

The first entry is the device’s preferred mode.

pixel_format: Vec<PixelFormat>

Pixel formats that can be directly displayed on the attached display.

This field will be revised to better reflect the subtleties around modern display hardware, such as multiple layer types, and around pixel format modifiers, such as tiling and framebuffer compression formats. See https://fxbug.dev/42072347 and https://fxbug.dev/42076907.

The formats listed here reflect support from both the display engine hardware and the display device. This means some of the formats may be subject to conversion inside the display engine hardware.

The first entry in the list is the display’s preferred format. This format is likely to be supported for transferring data between the display engine and the display hardware, and not require any conversion inside the display engine.

Format conversion inside the display engine is likely to be significantly more power-efficient than a GPU render stage or software conversion. So, using any format in this list is better than using the GPU to convert to the preferred format.

manufacturer_name: String

Part of a display device identifier that persists across boot cycles.

If the manufacturer_name, monitor_name and monitor_serial fields are all non-empty, they make up an identifier that is likely to be unique to the attached device, and is highly unlikely to change across boot cycles. Software that needs to identify displays (for example, to honor display-specific preferences) should use this triplet.

monitor_name: String

Part of a display device identifier that persists across boot cycles.

See manufacturer_name for details.

monitor_serial: String

Part of a display device identifier that persists across boot cycles.

See manufacturer_name for details.

horizontal_size_mm: u32

Physical horizontal size of the displayed image area, in millimeters.

If using_fallback_size is true, the value is a best guess from the driver. Otherwise, the value here is reported by the display device.

vertical_size_mm: u32

Physical vertical size of the displayed image area, in millimeters.

See horizontal_size_mm for more details.

using_fallback_size: bool

True if the driver does not have the display’s physical sizing info.

Trait Implementations

impl Clone for Info

fn clone(&self) -> Info

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Info

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

Formats the value using the given formatter.

impl Decode<Info> for Info

fn new_empty() -> Self

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_>, offset: usize, _depth: Depth ) -> Result<()>

Decodes an object of type T from the decoder’s buffers into self.

impl Encode<Info> for &Info

unsafe fn encode( self, encoder: &mut Encoder<'_>, offset: usize, _depth: Depth ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl<T0: Encode<DisplayId>, T1: Encode<UnboundedVector<Mode>>, T2: Encode<UnboundedVector<PixelFormat>>, T3: Encode<BoundedString<128>>, T4: Encode<BoundedString<128>>, T5: Encode<BoundedString<128>>, T6: Encode<u32>, T7: Encode<u32>, T8: Encode<bool>> Encode<Info> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

unsafe fn encode( self, encoder: &mut Encoder<'_>, offset: usize, depth: Depth ) -> Result<()>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl PartialEq for Info

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl TypeMarker for Info

type Owned = Info

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl ValueTypeMarker for Info

type Borrowed<'a> = &'a Info

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &Self::Owned. There are three cases:

fn borrow<'a>(value: &'a <Self as TypeMarker>::Owned) -> Self::Borrowed<'a>

Cheaply converts from &Self::Owned to Self::Borrowed.

impl Persistable for Info

impl StructuralPartialEq for Info