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

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

use crate::{Device, DevicePadFeature};
use glib::{prelude::*, translate::*};
use std::fmt;

glib::wrapper! {
    /// [`DevicePad`][crate::DevicePad] is an interface implemented by devices of type
    /// [`InputSource::TabletPad`][crate::InputSource::TabletPad]
    ///
    /// It allows querying the features provided by the pad device.
    ///
    /// Tablet pads may contain one or more groups, each containing a subset
    /// of the buttons/rings/strips available. [`DevicePadExt::n_groups()`][crate::prelude::DevicePadExt::n_groups()]
    /// can be used to obtain the number of groups, [`DevicePadExt::n_features()`][crate::prelude::DevicePadExt::n_features()]
    /// and [`DevicePadExt::feature_group()`][crate::prelude::DevicePadExt::feature_group()] can be combined to find out
    /// the number of buttons/rings/strips the device has, and how are they grouped.
    ///
    /// Each of those groups have different modes, which may be used to map each
    /// individual pad feature to multiple actions. Only one mode is effective
    /// (current) for each given group, different groups may have different
    /// current modes. The number of available modes in a group can be found
    /// out through [`DevicePadExt::group_n_modes()`][crate::prelude::DevicePadExt::group_n_modes()], and the current mode
    /// for a given group will be notified through events of type `GDK_PAD_GROUP_MODE`.
    ///
    /// # Implements
    ///
    /// [`DevicePadExt`][trait@crate::prelude::DevicePadExt], [`DeviceExt`][trait@crate::prelude::DeviceExt]
    #[doc(alias = "GdkDevicePad")]
    pub struct DevicePad(Interface<ffi::GdkDevicePad, ffi::GdkDevicePadInterface>) @requires Device;

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

impl DevicePad {
    pub const NONE: Option<&'static DevicePad> = None;
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::DevicePad>> Sealed for T {}
}

/// Trait containing all [`struct@DevicePad`] methods.
///
/// # Implementors
///
/// [`DevicePad`][struct@crate::DevicePad]
pub trait DevicePadExt: IsA<DevicePad> + sealed::Sealed + 'static {
    /// Returns the group the given @feature and @idx belong to.
    ///
    /// f the feature or index do not exist in @self, -1 is returned.
    /// ## `feature`
    /// the feature type to get the group from
    /// ## `feature_idx`
    /// the index of the feature to get the group from
    ///
    /// # Returns
    ///
    /// The group number of the queried pad feature.
    #[doc(alias = "gdk_device_pad_get_feature_group")]
    #[doc(alias = "get_feature_group")]
    fn feature_group(&self, feature: DevicePadFeature, feature_idx: i32) -> i32 {
        unsafe {
            ffi::gdk_device_pad_get_feature_group(
                self.as_ref().to_glib_none().0,
                feature.into_glib(),
                feature_idx,
            )
        }
    }

    /// Returns the number of modes that @group may have.
    /// ## `group_idx`
    /// group to get the number of available modes from
    ///
    /// # Returns
    ///
    /// The number of modes available in @group.
    #[doc(alias = "gdk_device_pad_get_group_n_modes")]
    #[doc(alias = "get_group_n_modes")]
    fn group_n_modes(&self, group_idx: i32) -> i32 {
        unsafe { ffi::gdk_device_pad_get_group_n_modes(self.as_ref().to_glib_none().0, group_idx) }
    }

    /// Returns the number of features a tablet pad has.
    /// ## `feature`
    /// a pad feature
    ///
    /// # Returns
    ///
    /// The amount of elements of type @feature that this pad has.
    #[doc(alias = "gdk_device_pad_get_n_features")]
    #[doc(alias = "get_n_features")]
    fn n_features(&self, feature: DevicePadFeature) -> i32 {
        unsafe {
            ffi::gdk_device_pad_get_n_features(self.as_ref().to_glib_none().0, feature.into_glib())
        }
    }

    /// Returns the number of groups this pad device has.
    ///
    /// Pads have at least one group. A pad group is a subcollection of
    /// buttons/strip/rings that is affected collectively by a same
    /// current mode.
    ///
    /// # Returns
    ///
    /// The number of button/ring/strip groups in the pad.
    #[doc(alias = "gdk_device_pad_get_n_groups")]
    #[doc(alias = "get_n_groups")]
    fn n_groups(&self) -> i32 {
        unsafe { ffi::gdk_device_pad_get_n_groups(self.as_ref().to_glib_none().0) }
    }
}

impl<O: IsA<DevicePad>> DevicePadExt for O {}

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