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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::AxisFlags;
use crate::DeviceToolType;
use glib::object::Cast;
use glib::translate::*;
use glib::StaticType;
use glib::ToValue;
use std::fmt;

glib::wrapper! {
    /// A physical tool associated to a [`Device`][crate::Device].
    #[doc(alias = "GdkDeviceTool")]
    pub struct DeviceTool(Object<ffi::GdkDeviceTool>);

    match fn {
        type_ => || ffi::gdk_device_tool_get_type(),
    }
}

impl DeviceTool {
    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`DeviceTool`] objects.
    ///
    /// This method returns an instance of [`DeviceToolBuilder`] which can be used to create [`DeviceTool`] objects.
    pub fn builder() -> DeviceToolBuilder {
        DeviceToolBuilder::default()
    }

    /// Gets the axes of the tool.
    ///
    /// # Returns
    ///
    /// the axes of `self`
    #[doc(alias = "gdk_device_tool_get_axes")]
    #[doc(alias = "get_axes")]
    pub fn axes(&self) -> AxisFlags {
        unsafe { from_glib(ffi::gdk_device_tool_get_axes(self.to_glib_none().0)) }
    }

    /// Gets the hardware ID of this tool, or 0 if it's not known.
    ///
    /// When non-zero, the identificator is unique for the given tool model,
    /// meaning that two identical tools will share the same `hardware_id`,
    /// but will have different serial numbers (see
    /// [``serial()``][`Self::serial()`]).
    ///
    /// This is a more concrete (and device specific) method to identify
    /// a [`DeviceTool`][crate::DeviceTool] than [``tool_type()``][`Self::tool_type()`],
    /// as a tablet may support multiple devices with the same
    /// [`DeviceToolType`][crate::DeviceToolType], but different hardware identificators.
    ///
    /// # Returns
    ///
    /// The hardware identificator of this tool.
    #[doc(alias = "gdk_device_tool_get_hardware_id")]
    #[doc(alias = "get_hardware_id")]
    pub fn hardware_id(&self) -> u64 {
        unsafe { ffi::gdk_device_tool_get_hardware_id(self.to_glib_none().0) }
    }

    /// Gets the serial number of this tool.
    ///
    /// This value can be used to identify a physical tool
    /// (eg. a tablet pen) across program executions.
    ///
    /// # Returns
    ///
    /// The serial ID for this tool
    #[doc(alias = "gdk_device_tool_get_serial")]
    #[doc(alias = "get_serial")]
    pub fn serial(&self) -> u64 {
        unsafe { ffi::gdk_device_tool_get_serial(self.to_glib_none().0) }
    }

    /// Gets the [`DeviceToolType`][crate::DeviceToolType] of the tool.
    ///
    /// # Returns
    ///
    /// The physical type for this tool. This can be used to
    ///  figure out what sort of pen is being used, such as an airbrush
    ///  or a pencil.
    #[doc(alias = "gdk_device_tool_get_tool_type")]
    #[doc(alias = "get_tool_type")]
    pub fn tool_type(&self) -> DeviceToolType {
        unsafe { from_glib(ffi::gdk_device_tool_get_tool_type(self.to_glib_none().0)) }
    }
}

#[derive(Clone, Default)]
// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`DeviceTool`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
pub struct DeviceToolBuilder {
    axes: Option<AxisFlags>,
    hardware_id: Option<u64>,
    serial: Option<u64>,
    tool_type: Option<DeviceToolType>,
}

impl DeviceToolBuilder {
    // rustdoc-stripper-ignore-next
    /// Create a new [`DeviceToolBuilder`].
    pub fn new() -> Self {
        Self::default()
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`DeviceTool`].
    pub fn build(self) -> DeviceTool {
        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
        if let Some(ref axes) = self.axes {
            properties.push(("axes", axes));
        }
        if let Some(ref hardware_id) = self.hardware_id {
            properties.push(("hardware-id", hardware_id));
        }
        if let Some(ref serial) = self.serial {
            properties.push(("serial", serial));
        }
        if let Some(ref tool_type) = self.tool_type {
            properties.push(("tool-type", tool_type));
        }
        glib::Object::new::<DeviceTool>(&properties)
            .expect("Failed to create an instance of DeviceTool")
    }

    /// The axes of the tool.
    pub fn axes(mut self, axes: AxisFlags) -> Self {
        self.axes = Some(axes);
        self
    }

    /// The hardware ID of the tool.
    pub fn hardware_id(mut self, hardware_id: u64) -> Self {
        self.hardware_id = Some(hardware_id);
        self
    }

    /// The serial number of the tool.
    pub fn serial(mut self, serial: u64) -> Self {
        self.serial = Some(serial);
        self
    }

    /// The type of the tool.
    pub fn tool_type(mut self, tool_type: DeviceToolType) -> Self {
        self.tool_type = Some(tool_type);
        self
    }
}

impl fmt::Display for DeviceTool {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("DeviceTool")
    }
}