Struct ObjectPropMeta

pub struct ObjectPropMeta<'card> { /* private fields */ }

Implementations

impl<'card> ObjectPropMeta<'card>

pub fn property_id(&self) -> PropertyId

Examples found in repository

examples/modesetting-atomic.rs (line 295)

    pub fn populate_from<'card>(&mut self, from: linux_drm::modeset::ObjectPropMeta<'card>) {
        match from.name() {
            "CRTC_ID" => self.crtc_id = from.property_id(),
            _ => {}
        }
    }
}

#[derive(Debug)]
struct CrtcPropIds {
    active: PropertyId,
}

impl CrtcPropIds {
    pub fn new(crtc_id: CrtcId, card: &linux_drm::Card) -> Result<Self, Error> {
        let mut ret: Self = unsafe { core::mem::zeroed() };
        card.each_object_property_meta(linux_drm::modeset::ObjectId::Crtc(crtc_id), |meta, _| {
            ret.populate_from(meta)
        })?;
        Ok(ret)
    }

    pub fn populate_from<'card>(&mut self, from: linux_drm::modeset::ObjectPropMeta<'card>) {
        match from.name() {
            "ACTIVE" => self.active = from.property_id(),
            _ => {}
        }
    }
}

#[derive(Debug)]
struct PlanePropIds {
    typ: PropertyId,
    fb_id: PropertyId,
    crtc_id: PropertyId,
    crtc_x: PropertyId,
    crtc_y: PropertyId,
    crtc_w: PropertyId,
    crtc_h: PropertyId,
    src_x: PropertyId,
    src_y: PropertyId,
    src_w: PropertyId,
    src_h: PropertyId,
}

impl PlanePropIds {
    pub fn new(plane_id: PlaneId, card: &linux_drm::Card) -> Result<Self, Error> {
        let mut ret: Self = unsafe { core::mem::zeroed() };
        card.each_object_property_meta(plane_id, |meta, _| ret.populate_from(meta))?;
        Ok(ret)
    }

    pub fn populate_from<'card>(&mut self, from: linux_drm::modeset::ObjectPropMeta<'card>) {
        let field: &mut PropertyId = match from.name() {
            "type" => &mut self.typ,
            "FB_ID" => &mut self.fb_id,
            "CRTC_ID" => &mut self.crtc_id,
            "CRTC_X" => &mut self.crtc_x,
            "CRTC_Y" => &mut self.crtc_y,
            "CRTC_W" => &mut self.crtc_w,
            "CRTC_H" => &mut self.crtc_h,
            "SRC_X" => &mut self.src_x,
            "SRC_Y" => &mut self.src_y,
            "SRC_W" => &mut self.src_w,
            "SRC_H" => &mut self.src_h,
            _ => return,
        };
        *field = from.property_id()
    }

pub fn name(&self) -> &str

Examples found in repository

examples/modesetting-atomic.rs (line 294)

    pub fn populate_from<'card>(&mut self, from: linux_drm::modeset::ObjectPropMeta<'card>) {
        match from.name() {
            "CRTC_ID" => self.crtc_id = from.property_id(),
            _ => {}
        }
    }
}

#[derive(Debug)]
struct CrtcPropIds {
    active: PropertyId,
}

impl CrtcPropIds {
    pub fn new(crtc_id: CrtcId, card: &linux_drm::Card) -> Result<Self, Error> {
        let mut ret: Self = unsafe { core::mem::zeroed() };
        card.each_object_property_meta(linux_drm::modeset::ObjectId::Crtc(crtc_id), |meta, _| {
            ret.populate_from(meta)
        })?;
        Ok(ret)
    }

    pub fn populate_from<'card>(&mut self, from: linux_drm::modeset::ObjectPropMeta<'card>) {
        match from.name() {
            "ACTIVE" => self.active = from.property_id(),
            _ => {}
        }
    }
}

#[derive(Debug)]
struct PlanePropIds {
    typ: PropertyId,
    fb_id: PropertyId,
    crtc_id: PropertyId,
    crtc_x: PropertyId,
    crtc_y: PropertyId,
    crtc_w: PropertyId,
    crtc_h: PropertyId,
    src_x: PropertyId,
    src_y: PropertyId,
    src_w: PropertyId,
    src_h: PropertyId,
}

impl PlanePropIds {
    pub fn new(plane_id: PlaneId, card: &linux_drm::Card) -> Result<Self, Error> {
        let mut ret: Self = unsafe { core::mem::zeroed() };
        card.each_object_property_meta(plane_id, |meta, _| ret.populate_from(meta))?;
        Ok(ret)
    }

    pub fn populate_from<'card>(&mut self, from: linux_drm::modeset::ObjectPropMeta<'card>) {
        let field: &mut PropertyId = match from.name() {
            "type" => &mut self.typ,
            "FB_ID" => &mut self.fb_id,
            "CRTC_ID" => &mut self.crtc_id,
            "CRTC_X" => &mut self.crtc_x,
            "CRTC_Y" => &mut self.crtc_y,
            "CRTC_W" => &mut self.crtc_w,
            "CRTC_H" => &mut self.crtc_h,
            "SRC_X" => &mut self.src_x,
            "SRC_Y" => &mut self.src_y,
            "SRC_W" => &mut self.src_w,
            "SRC_H" => &mut self.src_h,
            _ => return,
        };
        *field = from.property_id()
    }

examples/properties.rs (line 177)

fn property_meta<'a, 'card>(
    prop_id: PropertyId,
    prop_meta: &'a mut HashMap<u32, PropertyMeta>,
    card: &Card,
) -> Result<&'a PropertyMeta, Error> {
    Ok(prop_meta.entry(prop_id.0).or_insert_with(|| {
        card.property_meta(prop_id)
            .map(|meta| {
                let mut enum_names = BTreeMap::new();
                for member in meta.enum_members().unwrap() {
                    enum_names.insert(member.value(), member.name().to_string());
                }
                PropertyMeta {
                    name: meta.name().to_string(),
                    typ: meta.property_type(),
                    immutable: meta.is_immutable(),
                    values: meta.values().unwrap(),
                    enum_names,
                }
            })
            .unwrap_or(PropertyMeta {
                name: String::from("<unknown>"),
                typ: PropertyType::Unknown,
                immutable: true,
                values: Vec::new(),
                enum_names: BTreeMap::new(),
            })
    }))
}

pub fn property_type(&self) -> PropertyType

Examples found in repository

examples/properties.rs (line 178)

fn property_meta<'a, 'card>(
    prop_id: PropertyId,
    prop_meta: &'a mut HashMap<u32, PropertyMeta>,
    card: &Card,
) -> Result<&'a PropertyMeta, Error> {
    Ok(prop_meta.entry(prop_id.0).or_insert_with(|| {
        card.property_meta(prop_id)
            .map(|meta| {
                let mut enum_names = BTreeMap::new();
                for member in meta.enum_members().unwrap() {
                    enum_names.insert(member.value(), member.name().to_string());
                }
                PropertyMeta {
                    name: meta.name().to_string(),
                    typ: meta.property_type(),
                    immutable: meta.is_immutable(),
                    values: meta.values().unwrap(),
                    enum_names,
                }
            })
            .unwrap_or(PropertyMeta {
                name: String::from("<unknown>"),
                typ: PropertyType::Unknown,
                immutable: true,
                values: Vec::new(),
                enum_names: BTreeMap::new(),
            })
    }))
}

pub fn is_immutable(&self) -> bool

Examples found in repository

examples/properties.rs (line 179)

fn property_meta<'a, 'card>(
    prop_id: PropertyId,
    prop_meta: &'a mut HashMap<u32, PropertyMeta>,
    card: &Card,
) -> Result<&'a PropertyMeta, Error> {
    Ok(prop_meta.entry(prop_id.0).or_insert_with(|| {
        card.property_meta(prop_id)
            .map(|meta| {
                let mut enum_names = BTreeMap::new();
                for member in meta.enum_members().unwrap() {
                    enum_names.insert(member.value(), member.name().to_string());
                }
                PropertyMeta {
                    name: meta.name().to_string(),
                    typ: meta.property_type(),
                    immutable: meta.is_immutable(),
                    values: meta.values().unwrap(),
                    enum_names,
                }
            })
            .unwrap_or(PropertyMeta {
                name: String::from("<unknown>"),
                typ: PropertyType::Unknown,
                immutable: true,
                values: Vec::new(),
                enum_names: BTreeMap::new(),
            })
    }))
}

pub fn is_mutable(&self) -> bool

pub fn range(&self) -> Result<(u64, u64), Error>

Get the minimum and maximum value for a range-typed property.

This is essentially the same as Self::values, except that because it’s guaranteed that a range property always has exactly two values this function can avoid making a dynamic memory allocation and can instead retrieve the values directly into a stack object and then return those values.

pub fn values(&self) -> Result<Vec<u64>, Error>

Get a vector of describing the values that are acceptable for this property.

The meaning of the result depends on the property type:

• For a range or signed range, the result always has length 2 and describes the minimum and maximum values respectively.

  You can avoid a dynamic memory allocation in this case by using Self::range instead.

• For an enum or bitmask, the result describes the values of the valid enumeration members.

  For these it’s typically better to use Self::enum_members since that can also return the name associated with each value.

Examples found in repository

examples/properties.rs (line 180)

fn property_meta<'a, 'card>(
    prop_id: PropertyId,
    prop_meta: &'a mut HashMap<u32, PropertyMeta>,
    card: &Card,
) -> Result<&'a PropertyMeta, Error> {
    Ok(prop_meta.entry(prop_id.0).or_insert_with(|| {
        card.property_meta(prop_id)
            .map(|meta| {
                let mut enum_names = BTreeMap::new();
                for member in meta.enum_members().unwrap() {
                    enum_names.insert(member.value(), member.name().to_string());
                }
                PropertyMeta {
                    name: meta.name().to_string(),
                    typ: meta.property_type(),
                    immutable: meta.is_immutable(),
                    values: meta.values().unwrap(),
                    enum_names,
                }
            })
            .unwrap_or(PropertyMeta {
                name: String::from("<unknown>"),
                typ: PropertyType::Unknown,
                immutable: true,
                values: Vec::new(),
                enum_names: BTreeMap::new(),
            })
    }))
}

pub fn enum_members(&self) -> Result<Vec<ObjectPropEnumMember>, Error>

Get a vector describing the valid values for an enum, or the bitfield values for a bitmask.

Examples found in repository

examples/properties.rs (line 173)

fn property_meta<'a, 'card>(
    prop_id: PropertyId,
    prop_meta: &'a mut HashMap<u32, PropertyMeta>,
    card: &Card,
) -> Result<&'a PropertyMeta, Error> {
    Ok(prop_meta.entry(prop_id.0).or_insert_with(|| {
        card.property_meta(prop_id)
            .map(|meta| {
                let mut enum_names = BTreeMap::new();
                for member in meta.enum_members().unwrap() {
                    enum_names.insert(member.value(), member.name().to_string());
                }
                PropertyMeta {
                    name: meta.name().to_string(),
                    typ: meta.property_type(),
                    immutable: meta.is_immutable(),
                    values: meta.values().unwrap(),
                    enum_names,
                }
            })
            .unwrap_or(PropertyMeta {
                name: String::from("<unknown>"),
                typ: PropertyType::Unknown,
                immutable: true,
                values: Vec::new(),
                enum_names: BTreeMap::new(),
            })
    }))
}

Trait Implementations

impl<'card> Debug for ObjectPropMeta<'card>

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

Formats the value using the given formatter.