internals/src/EflSharp/EflSharp/efl/efl_input_device.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Input {
  11
  12 /// <summary>Represents a pointing device such as a touch finger, pen or mouse.</summary>
  13 [Efl.Input.Device.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public class Device : Efl.Object
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(Device))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
  34         efl_input_device_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="Device"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     public Device(Efl.Object parent= null
  38             ) : base(efl_input_device_class_get(), parent)
  39     {
  40         FinishInstantiation();
  41     }
  42
  43     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  44     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  45     protected Device(ConstructingHandle ch) : base(ch)
  46     {
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="Device"/> class.
  50     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  51     /// <param name="wh">The native pointer to be wrapped.</param>
  52     protected Device(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="Device"/> class.
  57     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  58     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected Device(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  61     {
  62     }
  63
  64     /// <summary>Device type property</summary>
  65     /// <returns>Input device class</returns>
  66     virtual public Efl.Input.DeviceType GetDeviceType() {
  67          var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_type_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  68         Eina.Error.RaiseIfUnhandledException();
  69         return _ret_var;
  70  }
  71     /// <summary>Device type property</summary>
  72     /// <param name="klass">Input device class</param>
  73     virtual public void SetDeviceType(Efl.Input.DeviceType klass) {
  74                                  Efl.Input.Device.NativeMethods.efl_input_device_type_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),klass);
  75         Eina.Error.RaiseIfUnhandledException();
  76                          }
  77     /// <summary>Device source property</summary>
  78     /// <returns>Input device</returns>
  79     virtual public Efl.Input.Device GetSource() {
  80          var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_source_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  81         Eina.Error.RaiseIfUnhandledException();
  82         return _ret_var;
  83  }
  84     /// <summary>Device source property</summary>
  85     /// <param name="src">Input device</param>
  86     virtual public void SetSource(Efl.Input.Device src) {
  87                                  Efl.Input.Device.NativeMethods.efl_input_device_source_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),src);
  88         Eina.Error.RaiseIfUnhandledException();
  89                          }
  90     /// <summary>Get the <see cref="Efl.Input.Device"/> that represents a seat.
  91     /// This method will find the seat the device belongs to.
  92     ///
  93     /// For this, it walk through device&apos;s parents looking for a device with <see cref="Efl.Input.DeviceType.Seat"/>. It may be the device itself.
  94     ///
  95     /// In case no seat is found, <c>null</c> is returned.</summary>
  96     /// <returns>The seat this device belongs to.</returns>
  97     virtual public Efl.Input.Device GetSeat() {
  98          var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_seat_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  99         Eina.Error.RaiseIfUnhandledException();
 100         return _ret_var;
 101  }
 102     /// <summary>Seat id number</summary>
 103     /// <returns>The id of the seat</returns>
 104     virtual public uint GetSeatId() {
 105          var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_seat_id_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 106         Eina.Error.RaiseIfUnhandledException();
 107         return _ret_var;
 108  }
 109     /// <summary>Seat id number</summary>
 110     /// <param name="id">The id of the seat</param>
 111     virtual public void SetSeatId(uint id) {
 112                                  Efl.Input.Device.NativeMethods.efl_input_device_seat_id_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),id);
 113         Eina.Error.RaiseIfUnhandledException();
 114                          }
 115     /// <summary>The number of pointer devices in this seat.
 116     /// Pointer devices are the ones whose <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>. In case this device is not of the type <c>seat</c>, -1 is returned.</summary>
 117     /// <returns>The number of pointer devices.</returns>
 118     virtual public int GetPointerDeviceCount() {
 119          var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_pointer_device_count_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 120         Eina.Error.RaiseIfUnhandledException();
 121         return _ret_var;
 122  }
 123     /// <summary><c>true</c> if <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>.</summary>
 124     /// <returns><c>true</c> if the device has pointing capabilities.</returns>
 125     virtual public bool GetIsPointerType() {
 126          var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_is_pointer_type_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 127         Eina.Error.RaiseIfUnhandledException();
 128         return _ret_var;
 129  }
 130     /// <summary>Lists the children attached to this device.
 131     /// This is only meaningful with seat devices, as they are groups of real input devices.</summary>
 132     /// <returns>List of device children</returns>
 133     virtual public Eina.Iterator<Efl.Input.Device> ChildrenIterate() {
 134          var _ret_var = Efl.Input.Device.NativeMethods.efl_input_device_children_iterate_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 135         Eina.Error.RaiseIfUnhandledException();
 136         return new Eina.Iterator<Efl.Input.Device>(_ret_var, true);
 137  }
 138     /// <summary>Device type property</summary>
 139     /// <value>Input device class</value>
 140     public Efl.Input.DeviceType DeviceType {
 141         get { return GetDeviceType(); }
 142         set { SetDeviceType(value); }
 143     }
 144     /// <summary>Device source property</summary>
 145     /// <value>Input device</value>
 146     public Efl.Input.Device Source {
 147         get { return GetSource(); }
 148         set { SetSource(value); }
 149     }
 150     /// <summary>Get the <see cref="Efl.Input.Device"/> that represents a seat.
 151     /// This method will find the seat the device belongs to.
 152     ///
 153     /// For this, it walk through device&apos;s parents looking for a device with <see cref="Efl.Input.DeviceType.Seat"/>. It may be the device itself.
 154     ///
 155     /// In case no seat is found, <c>null</c> is returned.</summary>
 156     /// <value>The seat this device belongs to.</value>
 157     public Efl.Input.Device Seat {
 158         get { return GetSeat(); }
 159     }
 160     /// <summary>Seat id number</summary>
 161     /// <value>The id of the seat</value>
 162     public uint SeatId {
 163         get { return GetSeatId(); }
 164         set { SetSeatId(value); }
 165     }
 166     /// <summary>The number of pointer devices in this seat.
 167     /// Pointer devices are the ones whose <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>. In case this device is not of the type <c>seat</c>, -1 is returned.</summary>
 168     /// <value>The number of pointer devices.</value>
 169     public int PointerDeviceCount {
 170         get { return GetPointerDeviceCount(); }
 171     }
 172     /// <summary><c>true</c> if <see cref="Efl.Input.Device.DeviceType"/> is <c>mouse</c>, <c>pen</c>, <c>touch</c> or <c>wand</c>.</summary>
 173     /// <value><c>true</c> if the device has pointing capabilities.</value>
 174     public bool IsPointerType {
 175         get { return GetIsPointerType(); }
 176     }
 177     private static IntPtr GetEflClassStatic()
 178     {
 179         return Efl.Input.Device.efl_input_device_class_get();
 180     }
 181     /// <summary>Wrapper for native methods and virtual method delegates.
 182     /// For internal use by generated code only.</summary>
 183     public new class NativeMethods : Efl.Object.NativeMethods
 184     {
 185         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 186         /// <summary>Gets the list of Eo operations to override.</summary>
 187         /// <returns>The list of Eo operations to be overload.</returns>
 188         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 189         {
 190             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 191             var methods = Efl.Eo.Globals.GetUserMethods(type);
 192
 193             if (efl_input_device_type_get_static_delegate == null)
 194             {
 195                 efl_input_device_type_get_static_delegate = new efl_input_device_type_get_delegate(device_type_get);
 196             }
 197
 198             if (methods.FirstOrDefault(m => m.Name == "GetDeviceType") != null)
 199             {
 200                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_type_get_static_delegate) });
 201             }
 202
 203             if (efl_input_device_type_set_static_delegate == null)
 204             {
 205                 efl_input_device_type_set_static_delegate = new efl_input_device_type_set_delegate(device_type_set);
 206             }
 207
 208             if (methods.FirstOrDefault(m => m.Name == "SetDeviceType") != null)
 209             {
 210                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_type_set_static_delegate) });
 211             }
 212
 213             if (efl_input_device_source_get_static_delegate == null)
 214             {
 215                 efl_input_device_source_get_static_delegate = new efl_input_device_source_get_delegate(source_get);
 216             }
 217
 218             if (methods.FirstOrDefault(m => m.Name == "GetSource") != null)
 219             {
 220                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_source_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_source_get_static_delegate) });
 221             }
 222
 223             if (efl_input_device_source_set_static_delegate == null)
 224             {
 225                 efl_input_device_source_set_static_delegate = new efl_input_device_source_set_delegate(source_set);
 226             }
 227
 228             if (methods.FirstOrDefault(m => m.Name == "SetSource") != null)
 229             {
 230                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_source_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_source_set_static_delegate) });
 231             }
 232
 233             if (efl_input_device_seat_get_static_delegate == null)
 234             {
 235                 efl_input_device_seat_get_static_delegate = new efl_input_device_seat_get_delegate(seat_get);
 236             }
 237
 238             if (methods.FirstOrDefault(m => m.Name == "GetSeat") != null)
 239             {
 240                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_seat_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_seat_get_static_delegate) });
 241             }
 242
 243             if (efl_input_device_seat_id_get_static_delegate == null)
 244             {
 245                 efl_input_device_seat_id_get_static_delegate = new efl_input_device_seat_id_get_delegate(seat_id_get);
 246             }
 247
 248             if (methods.FirstOrDefault(m => m.Name == "GetSeatId") != null)
 249             {
 250                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_seat_id_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_seat_id_get_static_delegate) });
 251             }
 252
 253             if (efl_input_device_seat_id_set_static_delegate == null)
 254             {
 255                 efl_input_device_seat_id_set_static_delegate = new efl_input_device_seat_id_set_delegate(seat_id_set);
 256             }
 257
 258             if (methods.FirstOrDefault(m => m.Name == "SetSeatId") != null)
 259             {
 260                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_seat_id_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_seat_id_set_static_delegate) });
 261             }
 262
 263             if (efl_input_device_pointer_device_count_get_static_delegate == null)
 264             {
 265                 efl_input_device_pointer_device_count_get_static_delegate = new efl_input_device_pointer_device_count_get_delegate(pointer_device_count_get);
 266             }
 267
 268             if (methods.FirstOrDefault(m => m.Name == "GetPointerDeviceCount") != null)
 269             {
 270                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_pointer_device_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_pointer_device_count_get_static_delegate) });
 271             }
 272
 273             if (efl_input_device_is_pointer_type_get_static_delegate == null)
 274             {
 275                 efl_input_device_is_pointer_type_get_static_delegate = new efl_input_device_is_pointer_type_get_delegate(is_pointer_type_get);
 276             }
 277
 278             if (methods.FirstOrDefault(m => m.Name == "GetIsPointerType") != null)
 279             {
 280                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_is_pointer_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_is_pointer_type_get_static_delegate) });
 281             }
 282
 283             if (efl_input_device_children_iterate_static_delegate == null)
 284             {
 285                 efl_input_device_children_iterate_static_delegate = new efl_input_device_children_iterate_delegate(children_iterate);
 286             }
 287
 288             if (methods.FirstOrDefault(m => m.Name == "ChildrenIterate") != null)
 289             {
 290                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_children_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_children_iterate_static_delegate) });
 291             }
 292
 293             descs.AddRange(base.GetEoOps(type));
 294             return descs;
 295         }
 296         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 297         /// <returns>The native class pointer.</returns>
 298         public override IntPtr GetEflClass()
 299         {
 300             return Efl.Input.Device.efl_input_device_class_get();
 301         }
 302
 303         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 304
 305
 306         private delegate Efl.Input.DeviceType efl_input_device_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 307
 308
 309         public delegate Efl.Input.DeviceType efl_input_device_type_get_api_delegate(System.IntPtr obj);
 310
 311         public static Efl.Eo.FunctionWrapper<efl_input_device_type_get_api_delegate> efl_input_device_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_type_get_api_delegate>(Module, "efl_input_device_type_get");
 312
 313         private static Efl.Input.DeviceType device_type_get(System.IntPtr obj, System.IntPtr pd)
 314         {
 315             Eina.Log.Debug("function efl_input_device_type_get was called");
 316             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 317             if (ws != null)
 318             {
 319             Efl.Input.DeviceType _ret_var = default(Efl.Input.DeviceType);
 320                 try
 321                 {
 322                     _ret_var = ((Device)ws.Target).GetDeviceType();
 323                 }
 324                 catch (Exception e)
 325                 {
 326                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 327                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 328                 }
 329
 330         return _ret_var;
 331
 332             }
 333             else
 334             {
 335                 return efl_input_device_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 336             }
 337         }
 338
 339         private static efl_input_device_type_get_delegate efl_input_device_type_get_static_delegate;
 340
 341
 342         private delegate void efl_input_device_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.DeviceType klass);
 343
 344
 345         public delegate void efl_input_device_type_set_api_delegate(System.IntPtr obj,  Efl.Input.DeviceType klass);
 346
 347         public static Efl.Eo.FunctionWrapper<efl_input_device_type_set_api_delegate> efl_input_device_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_type_set_api_delegate>(Module, "efl_input_device_type_set");
 348
 349         private static void device_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.DeviceType klass)
 350         {
 351             Eina.Log.Debug("function efl_input_device_type_set was called");
 352             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 353             if (ws != null)
 354             {
 355
 356                 try
 357                 {
 358                     ((Device)ws.Target).SetDeviceType(klass);
 359                 }
 360                 catch (Exception e)
 361                 {
 362                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 363                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 364                 }
 365
 366
 367             }
 368             else
 369             {
 370                 efl_input_device_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), klass);
 371             }
 372         }
 373
 374         private static efl_input_device_type_set_delegate efl_input_device_type_set_static_delegate;
 375
 376         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 377         private delegate Efl.Input.Device efl_input_device_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
 378
 379         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 380         public delegate Efl.Input.Device efl_input_device_source_get_api_delegate(System.IntPtr obj);
 381
 382         public static Efl.Eo.FunctionWrapper<efl_input_device_source_get_api_delegate> efl_input_device_source_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_source_get_api_delegate>(Module, "efl_input_device_source_get");
 383
 384         private static Efl.Input.Device source_get(System.IntPtr obj, System.IntPtr pd)
 385         {
 386             Eina.Log.Debug("function efl_input_device_source_get was called");
 387             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 388             if (ws != null)
 389             {
 390             Efl.Input.Device _ret_var = default(Efl.Input.Device);
 391                 try
 392                 {
 393                     _ret_var = ((Device)ws.Target).GetSource();
 394                 }
 395                 catch (Exception e)
 396                 {
 397                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 398                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 399                 }
 400
 401         return _ret_var;
 402
 403             }
 404             else
 405             {
 406                 return efl_input_device_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 407             }
 408         }
 409
 410         private static efl_input_device_source_get_delegate efl_input_device_source_get_static_delegate;
 411
 412
 413         private delegate void efl_input_device_source_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device src);
 414
 415
 416         public delegate void efl_input_device_source_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device src);
 417
 418         public static Efl.Eo.FunctionWrapper<efl_input_device_source_set_api_delegate> efl_input_device_source_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_source_set_api_delegate>(Module, "efl_input_device_source_set");
 419
 420         private static void source_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Device src)
 421         {
 422             Eina.Log.Debug("function efl_input_device_source_set was called");
 423             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 424             if (ws != null)
 425             {
 426
 427                 try
 428                 {
 429                     ((Device)ws.Target).SetSource(src);
 430                 }
 431                 catch (Exception e)
 432                 {
 433                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 434                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 435                 }
 436
 437
 438             }
 439             else
 440             {
 441                 efl_input_device_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), src);
 442             }
 443         }
 444
 445         private static efl_input_device_source_set_delegate efl_input_device_source_set_static_delegate;
 446
 447         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 448         private delegate Efl.Input.Device efl_input_device_seat_get_delegate(System.IntPtr obj, System.IntPtr pd);
 449
 450         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 451         public delegate Efl.Input.Device efl_input_device_seat_get_api_delegate(System.IntPtr obj);
 452
 453         public static Efl.Eo.FunctionWrapper<efl_input_device_seat_get_api_delegate> efl_input_device_seat_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_seat_get_api_delegate>(Module, "efl_input_device_seat_get");
 454
 455         private static Efl.Input.Device seat_get(System.IntPtr obj, System.IntPtr pd)
 456         {
 457             Eina.Log.Debug("function efl_input_device_seat_get was called");
 458             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 459             if (ws != null)
 460             {
 461             Efl.Input.Device _ret_var = default(Efl.Input.Device);
 462                 try
 463                 {
 464                     _ret_var = ((Device)ws.Target).GetSeat();
 465                 }
 466                 catch (Exception e)
 467                 {
 468                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 469                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 470                 }
 471
 472         return _ret_var;
 473
 474             }
 475             else
 476             {
 477                 return efl_input_device_seat_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 478             }
 479         }
 480
 481         private static efl_input_device_seat_get_delegate efl_input_device_seat_get_static_delegate;
 482
 483
 484         private delegate uint efl_input_device_seat_id_get_delegate(System.IntPtr obj, System.IntPtr pd);
 485
 486
 487         public delegate uint efl_input_device_seat_id_get_api_delegate(System.IntPtr obj);
 488
 489         public static Efl.Eo.FunctionWrapper<efl_input_device_seat_id_get_api_delegate> efl_input_device_seat_id_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_seat_id_get_api_delegate>(Module, "efl_input_device_seat_id_get");
 490
 491         private static uint seat_id_get(System.IntPtr obj, System.IntPtr pd)
 492         {
 493             Eina.Log.Debug("function efl_input_device_seat_id_get was called");
 494             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 495             if (ws != null)
 496             {
 497             uint _ret_var = default(uint);
 498                 try
 499                 {
 500                     _ret_var = ((Device)ws.Target).GetSeatId();
 501                 }
 502                 catch (Exception e)
 503                 {
 504                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 505                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 506                 }
 507
 508         return _ret_var;
 509
 510             }
 511             else
 512             {
 513                 return efl_input_device_seat_id_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 514             }
 515         }
 516
 517         private static efl_input_device_seat_id_get_delegate efl_input_device_seat_id_get_static_delegate;
 518
 519
 520         private delegate void efl_input_device_seat_id_set_delegate(System.IntPtr obj, System.IntPtr pd,  uint id);
 521
 522
 523         public delegate void efl_input_device_seat_id_set_api_delegate(System.IntPtr obj,  uint id);
 524
 525         public static Efl.Eo.FunctionWrapper<efl_input_device_seat_id_set_api_delegate> efl_input_device_seat_id_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_seat_id_set_api_delegate>(Module, "efl_input_device_seat_id_set");
 526
 527         private static void seat_id_set(System.IntPtr obj, System.IntPtr pd, uint id)
 528         {
 529             Eina.Log.Debug("function efl_input_device_seat_id_set was called");
 530             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 531             if (ws != null)
 532             {
 533
 534                 try
 535                 {
 536                     ((Device)ws.Target).SetSeatId(id);
 537                 }
 538                 catch (Exception e)
 539                 {
 540                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 541                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 542                 }
 543
 544
 545             }
 546             else
 547             {
 548                 efl_input_device_seat_id_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), id);
 549             }
 550         }
 551
 552         private static efl_input_device_seat_id_set_delegate efl_input_device_seat_id_set_static_delegate;
 553
 554
 555         private delegate int efl_input_device_pointer_device_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 556
 557
 558         public delegate int efl_input_device_pointer_device_count_get_api_delegate(System.IntPtr obj);
 559
 560         public static Efl.Eo.FunctionWrapper<efl_input_device_pointer_device_count_get_api_delegate> efl_input_device_pointer_device_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_pointer_device_count_get_api_delegate>(Module, "efl_input_device_pointer_device_count_get");
 561
 562         private static int pointer_device_count_get(System.IntPtr obj, System.IntPtr pd)
 563         {
 564             Eina.Log.Debug("function efl_input_device_pointer_device_count_get was called");
 565             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 566             if (ws != null)
 567             {
 568             int _ret_var = default(int);
 569                 try
 570                 {
 571                     _ret_var = ((Device)ws.Target).GetPointerDeviceCount();
 572                 }
 573                 catch (Exception e)
 574                 {
 575                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 576                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 577                 }
 578
 579         return _ret_var;
 580
 581             }
 582             else
 583             {
 584                 return efl_input_device_pointer_device_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 585             }
 586         }
 587
 588         private static efl_input_device_pointer_device_count_get_delegate efl_input_device_pointer_device_count_get_static_delegate;
 589
 590         [return: MarshalAs(UnmanagedType.U1)]
 591         private delegate bool efl_input_device_is_pointer_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 592
 593         [return: MarshalAs(UnmanagedType.U1)]
 594         public delegate bool efl_input_device_is_pointer_type_get_api_delegate(System.IntPtr obj);
 595
 596         public static Efl.Eo.FunctionWrapper<efl_input_device_is_pointer_type_get_api_delegate> efl_input_device_is_pointer_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_is_pointer_type_get_api_delegate>(Module, "efl_input_device_is_pointer_type_get");
 597
 598         private static bool is_pointer_type_get(System.IntPtr obj, System.IntPtr pd)
 599         {
 600             Eina.Log.Debug("function efl_input_device_is_pointer_type_get was called");
 601             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 602             if (ws != null)
 603             {
 604             bool _ret_var = default(bool);
 605                 try
 606                 {
 607                     _ret_var = ((Device)ws.Target).GetIsPointerType();
 608                 }
 609                 catch (Exception e)
 610                 {
 611                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 612                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 613                 }
 614
 615         return _ret_var;
 616
 617             }
 618             else
 619             {
 620                 return efl_input_device_is_pointer_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 621             }
 622         }
 623
 624         private static efl_input_device_is_pointer_type_get_delegate efl_input_device_is_pointer_type_get_static_delegate;
 625
 626
 627         private delegate System.IntPtr efl_input_device_children_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 628
 629
 630         public delegate System.IntPtr efl_input_device_children_iterate_api_delegate(System.IntPtr obj);
 631
 632         public static Efl.Eo.FunctionWrapper<efl_input_device_children_iterate_api_delegate> efl_input_device_children_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_children_iterate_api_delegate>(Module, "efl_input_device_children_iterate");
 633
 634         private static System.IntPtr children_iterate(System.IntPtr obj, System.IntPtr pd)
 635         {
 636             Eina.Log.Debug("function efl_input_device_children_iterate was called");
 637             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 638             if (ws != null)
 639             {
 640             Eina.Iterator<Efl.Input.Device> _ret_var = default(Eina.Iterator<Efl.Input.Device>);
 641                 try
 642                 {
 643                     _ret_var = ((Device)ws.Target).ChildrenIterate();
 644                 }
 645                 catch (Exception e)
 646                 {
 647                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 648                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 649                 }
 650
 651         _ret_var.Own = false; return _ret_var.Handle;
 652
 653             }
 654             else
 655             {
 656                 return efl_input_device_children_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 657             }
 658         }
 659
 660         private static efl_input_device_children_iterate_delegate efl_input_device_children_iterate_static_delegate;
 661
 662         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 663
 664 }
 665 }
 666 }
 667
 668 }
 669
 670 namespace Efl {
 671
 672 namespace Input {
 673
 674 /// <summary>General type of input device.
 675 /// Legacy support since 1.8 as <c>Evas_Device_Class</c>.</summary>
 676 [Efl.Eo.BindingEntity]
 677 public enum DeviceType
 678 {
 679 /// <summary>Not a device.</summary>
 680 None = 0,
 681 /// <summary>The user/seat (the user themselves).</summary>
 682 Seat = 1,
 683 /// <summary>A regular keyboard, numberpad or attached buttons.</summary>
 684 Keyboard = 2,
 685 /// <summary>A mouse, trackball or touchpad relative motion device.</summary>
 686 Mouse = 3,
 687 /// <summary>A touchscreen with fingers or stylus.</summary>
 688 Touch = 4,
 689 /// <summary>A special pen device.</summary>
 690 Pen = 5,
 691 /// <summary>A laser pointer, wii-style or &quot;Minority Report&quot; pointing device.</summary>
 692 Wand = 6,
 693 /// <summary>A gamepad controller or joystick.</summary>
 694 Gamepad = 7,
 695 }
 696
 697 }
 698
 699 }
 700
 701 namespace Efl {
 702
 703 namespace Input {
 704
 705 /// <summary>General type of input device.
 706 /// Legacy support since 1.8 as <c>Evas_Device_Subclass</c>.</summary>
 707 [Efl.Eo.BindingEntity]
 708 public enum DeviceSubtype
 709 {
 710 /// <summary>Not a device.</summary>
 711 None = 0,
 712 /// <summary>The normal flat of your finger.</summary>
 713 Finger = 1,
 714 /// <summary>A fingernai.</summary>
 715 Fingernail = 2,
 716 /// <summary>A Knuckle.</summary>
 717 Knuckle = 3,
 718 /// <summary>The palm of a users hand.</summary>
 719 Palm = 4,
 720 /// <summary>The side of your hand.</summary>
 721 HandSize = 5,
 722 /// <summary>The flat of your hand.</summary>
 723 HandFlat = 6,
 724 /// <summary>The tip of a pen.</summary>
 725 PenTip = 7,
 726 /// <summary>A trackpad style mouse.</summary>
 727 Trackpad = 8,
 728 /// <summary>A trackpoint style mouse.</summary>
 729 Trackpoint = 9,
 730 /// <summary>A trackball style mouse.</summary>
 731 Trackball = 10,
 732 /// <summary>A remote controller.</summary>
 733 Remocon = 11,
 734 /// <summary>A virtual keyboard.</summary>
 735 VirtualKeyboard = 12,
 736 }
 737
 738 }
 739
 740 }
 741