Struct drm_mode_property_enum

Source

#[repr(C)]pub struct drm_mode_property_enum {
    pub value: c_ulonglong,
    pub name: [c_char; 32],
}

Fields§

§value: c_ulonglong§name: [c_char; 32]

Implementations§

Source §

impl drm_mode_property_enum

Source

pub fn name(&self) -> String

Examples found in repository ?

examples/drm_mode.rs (line 62)

4fn main() {
5    let fd = {
6        use std::os::fd::IntoRawFd;
7
8        let f = File::open("/dev/dri/card0").unwrap();
9
10        f.into_raw_fd()
11    };
12
13    let libdrm = LibDrm::new().unwrap();
14    libdrm.set_all_client_caps(fd);
15    let drm_mode_res = libdrm.get_drm_mode_resources(fd).unwrap();
16    let current_connectors = drm_mode_res.get_drm_mode_all_connector_current(fd);
17
18    for connector in current_connectors.iter() {
19        println!(
20            "Connector {} ({}-{}), {}",
21            connector.connector_id(),
22            connector.connector_type(),
23            connector.connector_type_id(),
24            connector.connection(),
25        );
26
27        let modes = connector.get_modes();
28
29        if !modes.is_empty() {
30            println!("    Modes");
31            for mode in connector.get_modes() {
32                println!(
33                    "        {}x{}@{:.2}{}{}",
34                    mode.vdisplay,
35                    mode.hdisplay,
36                    mode.refresh_rate(),
37                    if mode.type_is_preferred() { " preferred" } else { "" },
38                    if mode.type_is_driver() { " driver" } else { "" },
39                );
40            }
41        }
42
43        if let Some(conn_prop) = connector.get_drm_mode_connector_properties(fd) {
44            let mode_props = conn_prop.get_mode_property(fd);
45
46            for (prop, value) in mode_props {
47                let type_ = prop.property_type();
48
49                println!(
50                    "    {:?}, id: {}, value: {}, type: {}",
51                    prop.name(),
52                    prop.prop_id(),
53                    value,
54                    type_,
55                );
56
57                match type_ {
58                    drmModePropType::RANGE => println!("        values: {:?}", prop.values()),
59                    drmModePropType::ENUM => {
60                        print!("        enums: [");
61                        for enum_ in prop.enums().iter() {
62                            print!("{:?}={}, ", enum_.name(), enum_.value);
63                        }
64                        println!("] ");
65                    },
66                    drmModePropType::BLOB => {
67                        if let Some(b) = libdrm.get_drm_mode_property_blob(fd, value as u32) {
68                            print!("        blob:");
69
70                            for (i, byte) in b.data().iter().enumerate() {
71                                if (i % 16) == 0 { print!("\n            "); }
72                                print!("{byte:02x}");
73                            }
74
75                            println!();
76                        }
77                    },
78                    _ => {},
79                }
80            }
81        }
82        println!();
83    }
84}