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 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
// 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::EventController; use crate::PadActionType; use crate::PropagationPhase; use crate::Widget; use crate::Window; use glib::object::Cast; use glib::object::IsA; use glib::object::ObjectType as ObjectType_; use glib::translate::*; use glib::StaticType; use glib::ToValue; use std::fmt; glib::wrapper! { /// [`PadController`][crate::PadController] is an event controller for the pads found in drawing /// tablets (The collection of buttons and tactile sensors often found around /// the stylus-sensitive area). /// /// These buttons and sensors have no implicit meaning, and by default they /// perform no action, this event controller is provided to map those to /// `GAction` objects, thus letting the application give those a more semantic /// meaning. /// /// Buttons and sensors are not constrained to triggering a single action, some /// `GDK_SOURCE_TABLET_PAD` devices feature multiple "modes", all these input /// elements have one current mode, which may determine the final action /// being triggered. Pad devices often divide buttons and sensors into groups, /// all elements in a group share the same current mode, but different groups /// may have different modes. See `gdk_device_pad_get_n_groups()` and /// `gdk_device_pad_get_group_n_modes()`. /// /// Each of the actions that a given button/strip/ring performs for a given /// mode is defined by [`PadActionEntry`][crate::PadActionEntry], it contains an action name that /// will be looked up in the given [`gio::ActionGroup`][crate::gio::ActionGroup] and activated whenever the /// specified input element and mode are triggered. /// /// A simple example of [`PadController`][crate::PadController] usage, assigning button 1 in all /// modes and pad devices to an "invert-selection" action: /// /// ```text /// GtkPadActionEntry *pad_actions[] = { /// { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" }, /// … /// }; /// /// … /// action_group = g_simple_action_group_new (); /// action = g_simple_action_new ("pad-actions.invert-selection", NULL); /// g_signal_connect (action, "activate", on_invert_selection_activated, NULL); /// g_action_map_add_action (G_ACTION_MAP (action_group), action); /// … /// pad_controller = gtk_pad_controller_new (window, action_group, NULL); /// ``` /// /// The actions belonging to rings/strips will be activated with a parameter /// of type `G_VARIANT_TYPE_DOUBLE` bearing the value of the given axis, it /// is required that those are made stateful and accepting this [`glib::VariantType`][crate::glib::VariantType]. /// /// # Implements /// /// [`EventControllerExt`][trait@crate::prelude::EventControllerExt], [`trait@glib::ObjectExt`] #[doc(alias = "GtkPadController")] pub struct PadController(Object<ffi::GtkPadController, ffi::GtkPadControllerClass>) @extends EventController; match fn { type_ => || ffi::gtk_pad_controller_get_type(), } } impl PadController { /// Creates a new [`PadController`][crate::PadController] that will associate events from `pad` to /// actions. A [`None`] pad may be provided so the controller manages all pad devices /// generically, it is discouraged to mix [`PadController`][crate::PadController] objects with [`None`] /// and non-[`None`] `pad` argument on the same `window`, as execution order is not /// guaranteed. /// /// The [`PadController`][crate::PadController] is created with no mapped actions. In order to map pad /// events to actions, use [`set_action_entries()`][Self::set_action_entries()] or /// [`set_action()`][Self::set_action()]. /// ## `window` /// a [`Window`][crate::Window] /// ## `group` /// [`gio::ActionGroup`][crate::gio::ActionGroup] to trigger actions from /// ## `pad` /// A `GDK_SOURCE_TABLET_PAD` device, or [`None`] to handle all pads /// /// # Returns /// /// A newly created [`PadController`][crate::PadController] #[doc(alias = "gtk_pad_controller_new")] pub fn new<P: IsA<Window>, Q: IsA<gio::ActionGroup>>( window: &P, group: &Q, pad: Option<&gdk::Device>, ) -> PadController { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gtk_pad_controller_new( window.as_ref().to_glib_none().0, group.as_ref().to_glib_none().0, pad.to_glib_none().0, )) } } // rustdoc-stripper-ignore-next /// Creates a new builder-pattern struct instance to construct [`PadController`] objects. /// /// This method returns an instance of [`PadControllerBuilder`] which can be used to create [`PadController`] objects. pub fn builder() -> PadControllerBuilder { PadControllerBuilder::default() } /// Adds an individual action to `self`. This action will only be activated /// if the given button/ring/strip number in `index` is interacted while /// the current mode is `mode`. -1 may be used for simple cases, so the action /// is triggered on all modes. /// /// The given `label` should be considered user-visible, so internationalization /// rules apply. Some windowing systems may be able to use those for user /// feedback. /// ## `type_` /// the type of pad feature that will trigger this action /// ## `index` /// the 0-indexed button/ring/strip number that will trigger this action /// ## `mode` /// the mode that will trigger this action, or -1 for all modes. /// ## `label` /// Human readable description of this action, this string should /// be deemed user-visible. /// ## `action_name` /// action name that will be activated in the [`gio::ActionGroup`][crate::gio::ActionGroup] #[doc(alias = "gtk_pad_controller_set_action")] pub fn set_action( &self, type_: PadActionType, index: i32, mode: i32, label: &str, action_name: &str, ) { unsafe { ffi::gtk_pad_controller_set_action( self.to_glib_none().0, type_.into_glib(), index, mode, label.to_glib_none().0, action_name.to_glib_none().0, ); } } #[doc(alias = "action-group")] pub fn action_group(&self) -> Option<gio::ActionGroup> { unsafe { let mut value = glib::Value::from_type(<gio::ActionGroup as StaticType>::static_type()); glib::gobject_ffi::g_object_get_property( self.as_ptr() as *mut glib::gobject_ffi::GObject, b"action-group\0".as_ptr() as *const _, value.to_glib_none_mut().0, ); value .get() .expect("Return Value for property `action-group` getter") } } pub fn pad(&self) -> Option<gdk::Device> { unsafe { let mut value = glib::Value::from_type(<gdk::Device as StaticType>::static_type()); glib::gobject_ffi::g_object_get_property( self.as_ptr() as *mut glib::gobject_ffi::GObject, b"pad\0".as_ptr() as *const _, value.to_glib_none_mut().0, ); value.get().expect("Return Value for property `pad` getter") } } } #[derive(Clone, Default)] // rustdoc-stripper-ignore-next /// A [builder-pattern] type to construct [`PadController`] objects. /// /// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html pub struct PadControllerBuilder { action_group: Option<gio::ActionGroup>, pad: Option<gdk::Device>, propagation_phase: Option<PropagationPhase>, widget: Option<Widget>, } impl PadControllerBuilder { // rustdoc-stripper-ignore-next /// Create a new [`PadControllerBuilder`]. pub fn new() -> Self { Self::default() } // rustdoc-stripper-ignore-next /// Build the [`PadController`]. pub fn build(self) -> PadController { let mut properties: Vec<(&str, &dyn ToValue)> = vec![]; if let Some(ref action_group) = self.action_group { properties.push(("action-group", action_group)); } if let Some(ref pad) = self.pad { properties.push(("pad", pad)); } if let Some(ref propagation_phase) = self.propagation_phase { properties.push(("propagation-phase", propagation_phase)); } if let Some(ref widget) = self.widget { properties.push(("widget", widget)); } glib::Object::new::<PadController>(&properties) .expect("Failed to create an instance of PadController") } pub fn action_group<P: IsA<gio::ActionGroup>>(mut self, action_group: &P) -> Self { self.action_group = Some(action_group.clone().upcast()); self } pub fn pad(mut self, pad: &gdk::Device) -> Self { self.pad = Some(pad.clone()); self } /// The propagation phase at which this controller will handle events. pub fn propagation_phase(mut self, propagation_phase: PropagationPhase) -> Self { self.propagation_phase = Some(propagation_phase); self } /// The widget receiving the `GdkEvents` that the controller will handle. pub fn widget<P: IsA<Widget>>(mut self, widget: &P) -> Self { self.widget = Some(widget.clone().upcast()); self } } impl fmt::Display for PadController { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("PadController") } }