internals/src/EflSharp/EflSharp/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.ComponentModel;
   7 namespace Efl { namespace Input {
   8 /// <summary>Represents a pointing device such as a touch finger, pen or mouse.
   9 /// 1.18</summary>
  10 [DeviceNativeInherit]
  11 public class Device : Efl.Object, Efl.Eo.IWrapper
  12 {
  13    public new static System.IntPtr klass = System.IntPtr.Zero;
  14    public new static Efl.Input.DeviceNativeInherit nativeInherit = new Efl.Input.DeviceNativeInherit();
  15    ///<summary>Pointer to the native class description.</summary>
  16    public override System.IntPtr NativeClass {
  17       get {
  18          if (((object)this).GetType() == typeof (Device))
  19             return Efl.Input.DeviceNativeInherit.GetEflClassStatic();
  20          else
  21             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  22       }
  23    }
  24    [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
  25       efl_input_device_class_get();
  26    ///<summary>Creates a new instance.</summary>
  27    ///<param name="parent">Parent instance.</param>
  28    public Device(Efl.Object parent= null
  29          ) :
  30       base(efl_input_device_class_get(), typeof(Device), parent)
  31    {
  32       FinishInstantiation();
  33    }
  34    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  35    public Device(System.IntPtr raw) : base(raw)
  36    {
  37             register_event_proxies();
  38    }
  39    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  40    protected Device(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  41    ///<summary>Casts obj into an instance of this type.</summary>
  42    public new static Device static_cast(Efl.Object obj)
  43    {
  44       if (obj == null)
  45          throw new System.ArgumentNullException("obj");
  46       return new Device(obj.NativeHandle);
  47    }
  48    ///<summary>Verifies if the given object is equal to this one.</summary>
  49    public override bool Equals(object obj)
  50    {
  51       var other = obj as Efl.Object;
  52       if (other == null)
  53          return false;
  54       return this.NativeHandle == other.NativeHandle;
  55    }
  56    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  57    public override int GetHashCode()
  58    {
  59       return this.NativeHandle.ToInt32();
  60    }
  61    ///<summary>Turns the native pointer into a string representation.</summary>
  62    public override String ToString()
  63    {
  64       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  65    }
  66    protected override void register_event_proxies()
  67    {
  68       base.register_event_proxies();
  69    }
  70    /// <summary>Device type property
  71    /// 1.18</summary>
  72    /// <returns>Input device class
  73    /// 1.18</returns>
  74    virtual public Efl.Input.DeviceType GetDeviceType() {
  75        var _ret_var = Efl.Input.DeviceNativeInherit.efl_input_device_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  76       Eina.Error.RaiseIfUnhandledException();
  77       return _ret_var;
  78  }
  79    /// <summary>Device type property
  80    /// 1.18</summary>
  81    /// <param name="klass">Input device class
  82    /// 1.18</param>
  83    /// <returns></returns>
  84    virtual public  void SetDeviceType( Efl.Input.DeviceType klass) {
  85                          Efl.Input.DeviceNativeInherit.efl_input_device_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), klass);
  86       Eina.Error.RaiseIfUnhandledException();
  87                    }
  88    /// <summary>Device source property
  89    /// 1.18</summary>
  90    /// <returns>Input device
  91    /// 1.18</returns>
  92    virtual public Efl.Input.Device GetSource() {
  93        var _ret_var = Efl.Input.DeviceNativeInherit.efl_input_device_source_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  94       Eina.Error.RaiseIfUnhandledException();
  95       return _ret_var;
  96  }
  97    /// <summary>Device source property
  98    /// 1.18</summary>
  99    /// <param name="src">Input device
 100    /// 1.18</param>
 101    /// <returns></returns>
 102    virtual public  void SetSource( Efl.Input.Device src) {
 103                          Efl.Input.DeviceNativeInherit.efl_input_device_source_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), src);
 104       Eina.Error.RaiseIfUnhandledException();
 105                    }
 106    /// <summary>Get the <see cref="Efl.Input.Device"/> that represents a seat.
 107    /// This method will find the seat the device belongs to.
 108    ///
 109    /// 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.
 110    ///
 111    /// In case no seat is found, <c>null</c> is returned.
 112    /// 1.18</summary>
 113    /// <returns>The seat this device belongs to.
 114    /// 1.18</returns>
 115    virtual public Efl.Input.Device GetSeat() {
 116        var _ret_var = Efl.Input.DeviceNativeInherit.efl_input_device_seat_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 117       Eina.Error.RaiseIfUnhandledException();
 118       return _ret_var;
 119  }
 120    /// <summary>Seat id number
 121    /// 1.20</summary>
 122    /// <returns>The id of the seat
 123    /// 1.18</returns>
 124    virtual public  uint GetSeatId() {
 125        var _ret_var = Efl.Input.DeviceNativeInherit.efl_input_device_seat_id_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 126       Eina.Error.RaiseIfUnhandledException();
 127       return _ret_var;
 128  }
 129    /// <summary>Seat id number
 130    /// 1.20</summary>
 131    /// <param name="id">The id of the seat
 132    /// 1.18</param>
 133    /// <returns></returns>
 134    virtual public  void SetSeatId(  uint id) {
 135                          Efl.Input.DeviceNativeInherit.efl_input_device_seat_id_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), id);
 136       Eina.Error.RaiseIfUnhandledException();
 137                    }
 138    /// <summary>Lists the children attached to this device.
 139    /// This is only meaningful with seat devices, as they are groups of real input devices.
 140    /// 1.20</summary>
 141    /// <returns>List of device children
 142    /// 1.18</returns>
 143    virtual public Eina.Iterator<Efl.Input.Device> ChildrenIterate() {
 144        var _ret_var = Efl.Input.DeviceNativeInherit.efl_input_device_children_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 145       Eina.Error.RaiseIfUnhandledException();
 146       return new Eina.Iterator<Efl.Input.Device>(_ret_var, true, false);
 147  }
 148    /// <summary>Determine whether a device has pointer capabilities.
 149    /// Returns 1 for Mouse, Touch, Pen, Pointer, and Wand type devices.
 150    ///
 151    /// If a seat device is passed returns the number of pointer devices in the seat.
 152    /// 1.20</summary>
 153    /// <returns>Pointer caps
 154    /// 1.18</returns>
 155    virtual public  uint HasPointerCaps() {
 156        var _ret_var = Efl.Input.DeviceNativeInherit.efl_input_device_has_pointer_caps_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 157       Eina.Error.RaiseIfUnhandledException();
 158       return _ret_var;
 159  }
 160    /// <summary>Device type property
 161 /// 1.18</summary>
 162 /// <value>Input device class
 163 /// 1.18</value>
 164    public Efl.Input.DeviceType DeviceType {
 165       get { return GetDeviceType(); }
 166       set { SetDeviceType( value); }
 167    }
 168    /// <summary>Device source property
 169 /// 1.18</summary>
 170 /// <value>Input device
 171 /// 1.18</value>
 172    public Efl.Input.Device Source {
 173       get { return GetSource(); }
 174       set { SetSource( value); }
 175    }
 176    /// <summary>Get the <see cref="Efl.Input.Device"/> that represents a seat.
 177 /// This method will find the seat the device belongs to.
 178 ///
 179 /// 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.
 180 ///
 181 /// In case no seat is found, <c>null</c> is returned.
 182 /// 1.18</summary>
 183 /// <value>The seat this device belongs to.
 184 /// 1.18</value>
 185    public Efl.Input.Device Seat {
 186       get { return GetSeat(); }
 187    }
 188    /// <summary>Seat id number
 189 /// 1.20</summary>
 190 /// <value>The id of the seat
 191 /// 1.18</value>
 192    public  uint SeatId {
 193       get { return GetSeatId(); }
 194       set { SetSeatId( value); }
 195    }
 196    private static new  IntPtr GetEflClassStatic()
 197    {
 198       return Efl.Input.Device.efl_input_device_class_get();
 199    }
 200 }
 201 public class DeviceNativeInherit : Efl.ObjectNativeInherit{
 202    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 203    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 204    {
 205       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 206       if (efl_input_device_type_get_static_delegate == null)
 207       efl_input_device_type_get_static_delegate = new efl_input_device_type_get_delegate(device_type_get);
 208       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)});
 209       if (efl_input_device_type_set_static_delegate == null)
 210       efl_input_device_type_set_static_delegate = new efl_input_device_type_set_delegate(device_type_set);
 211       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)});
 212       if (efl_input_device_source_get_static_delegate == null)
 213       efl_input_device_source_get_static_delegate = new efl_input_device_source_get_delegate(source_get);
 214       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)});
 215       if (efl_input_device_source_set_static_delegate == null)
 216       efl_input_device_source_set_static_delegate = new efl_input_device_source_set_delegate(source_set);
 217       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)});
 218       if (efl_input_device_seat_get_static_delegate == null)
 219       efl_input_device_seat_get_static_delegate = new efl_input_device_seat_get_delegate(seat_get);
 220       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)});
 221       if (efl_input_device_seat_id_get_static_delegate == null)
 222       efl_input_device_seat_id_get_static_delegate = new efl_input_device_seat_id_get_delegate(seat_id_get);
 223       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)});
 224       if (efl_input_device_seat_id_set_static_delegate == null)
 225       efl_input_device_seat_id_set_static_delegate = new efl_input_device_seat_id_set_delegate(seat_id_set);
 226       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)});
 227       if (efl_input_device_children_iterate_static_delegate == null)
 228       efl_input_device_children_iterate_static_delegate = new efl_input_device_children_iterate_delegate(children_iterate);
 229       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)});
 230       if (efl_input_device_has_pointer_caps_static_delegate == null)
 231       efl_input_device_has_pointer_caps_static_delegate = new efl_input_device_has_pointer_caps_delegate(has_pointer_caps);
 232       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_input_device_has_pointer_caps"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_has_pointer_caps_static_delegate)});
 233       descs.AddRange(base.GetEoOps(type));
 234       return descs;
 235    }
 236    public override IntPtr GetEflClass()
 237    {
 238       return Efl.Input.Device.efl_input_device_class_get();
 239    }
 240    public static new  IntPtr GetEflClassStatic()
 241    {
 242       return Efl.Input.Device.efl_input_device_class_get();
 243    }
 244
 245
 246     private delegate Efl.Input.DeviceType efl_input_device_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 247
 248
 249     public delegate Efl.Input.DeviceType efl_input_device_type_get_api_delegate(System.IntPtr obj);
 250     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");
 251     private static Efl.Input.DeviceType device_type_get(System.IntPtr obj, System.IntPtr pd)
 252    {
 253       Eina.Log.Debug("function efl_input_device_type_get was called");
 254       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 255       if(wrapper != null) {
 256                   Efl.Input.DeviceType _ret_var = default(Efl.Input.DeviceType);
 257          try {
 258             _ret_var = ((Device)wrapper).GetDeviceType();
 259          } catch (Exception e) {
 260             Eina.Log.Warning($"Callback error: {e.ToString()}");
 261             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 262          }
 263       return _ret_var;
 264       } else {
 265          return efl_input_device_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 266       }
 267    }
 268    private static efl_input_device_type_get_delegate efl_input_device_type_get_static_delegate;
 269
 270
 271     private delegate  void efl_input_device_type_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Input.DeviceType klass);
 272
 273
 274     public delegate  void efl_input_device_type_set_api_delegate(System.IntPtr obj,   Efl.Input.DeviceType klass);
 275     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");
 276     private static  void device_type_set(System.IntPtr obj, System.IntPtr pd,  Efl.Input.DeviceType klass)
 277    {
 278       Eina.Log.Debug("function efl_input_device_type_set was called");
 279       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 280       if(wrapper != null) {
 281
 282          try {
 283             ((Device)wrapper).SetDeviceType( klass);
 284          } catch (Exception e) {
 285             Eina.Log.Warning($"Callback error: {e.ToString()}");
 286             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 287          }
 288                         } else {
 289          efl_input_device_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  klass);
 290       }
 291    }
 292    private static efl_input_device_type_set_delegate efl_input_device_type_set_static_delegate;
 293
 294
 295    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))] private delegate Efl.Input.Device efl_input_device_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
 296
 297
 298    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))] public delegate Efl.Input.Device efl_input_device_source_get_api_delegate(System.IntPtr obj);
 299     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");
 300     private static Efl.Input.Device source_get(System.IntPtr obj, System.IntPtr pd)
 301    {
 302       Eina.Log.Debug("function efl_input_device_source_get was called");
 303       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 304       if(wrapper != null) {
 305                   Efl.Input.Device _ret_var = default(Efl.Input.Device);
 306          try {
 307             _ret_var = ((Device)wrapper).GetSource();
 308          } catch (Exception e) {
 309             Eina.Log.Warning($"Callback error: {e.ToString()}");
 310             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 311          }
 312       return _ret_var;
 313       } else {
 314          return efl_input_device_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 315       }
 316    }
 317    private static efl_input_device_source_get_delegate efl_input_device_source_get_static_delegate;
 318
 319
 320     private delegate  void efl_input_device_source_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))]  Efl.Input.Device src);
 321
 322
 323     public delegate  void efl_input_device_source_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))]  Efl.Input.Device src);
 324     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");
 325     private static  void source_set(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Device src)
 326    {
 327       Eina.Log.Debug("function efl_input_device_source_set was called");
 328       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 329       if(wrapper != null) {
 330
 331          try {
 332             ((Device)wrapper).SetSource( src);
 333          } catch (Exception e) {
 334             Eina.Log.Warning($"Callback error: {e.ToString()}");
 335             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 336          }
 337                         } else {
 338          efl_input_device_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  src);
 339       }
 340    }
 341    private static efl_input_device_source_set_delegate efl_input_device_source_set_static_delegate;
 342
 343
 344    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))] private delegate Efl.Input.Device efl_input_device_seat_get_delegate(System.IntPtr obj, System.IntPtr pd);
 345
 346
 347    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Input.Device, Efl.Eo.NonOwnTag>))] public delegate Efl.Input.Device efl_input_device_seat_get_api_delegate(System.IntPtr obj);
 348     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");
 349     private static Efl.Input.Device seat_get(System.IntPtr obj, System.IntPtr pd)
 350    {
 351       Eina.Log.Debug("function efl_input_device_seat_get was called");
 352       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 353       if(wrapper != null) {
 354                   Efl.Input.Device _ret_var = default(Efl.Input.Device);
 355          try {
 356             _ret_var = ((Device)wrapper).GetSeat();
 357          } catch (Exception e) {
 358             Eina.Log.Warning($"Callback error: {e.ToString()}");
 359             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 360          }
 361       return _ret_var;
 362       } else {
 363          return efl_input_device_seat_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 364       }
 365    }
 366    private static efl_input_device_seat_get_delegate efl_input_device_seat_get_static_delegate;
 367
 368
 369     private delegate  uint efl_input_device_seat_id_get_delegate(System.IntPtr obj, System.IntPtr pd);
 370
 371
 372     public delegate  uint efl_input_device_seat_id_get_api_delegate(System.IntPtr obj);
 373     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");
 374     private static  uint seat_id_get(System.IntPtr obj, System.IntPtr pd)
 375    {
 376       Eina.Log.Debug("function efl_input_device_seat_id_get was called");
 377       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 378       if(wrapper != null) {
 379                    uint _ret_var = default( uint);
 380          try {
 381             _ret_var = ((Device)wrapper).GetSeatId();
 382          } catch (Exception e) {
 383             Eina.Log.Warning($"Callback error: {e.ToString()}");
 384             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 385          }
 386       return _ret_var;
 387       } else {
 388          return efl_input_device_seat_id_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 389       }
 390    }
 391    private static efl_input_device_seat_id_get_delegate efl_input_device_seat_id_get_static_delegate;
 392
 393
 394     private delegate  void efl_input_device_seat_id_set_delegate(System.IntPtr obj, System.IntPtr pd,    uint id);
 395
 396
 397     public delegate  void efl_input_device_seat_id_set_api_delegate(System.IntPtr obj,    uint id);
 398     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");
 399     private static  void seat_id_set(System.IntPtr obj, System.IntPtr pd,   uint id)
 400    {
 401       Eina.Log.Debug("function efl_input_device_seat_id_set was called");
 402       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 403       if(wrapper != null) {
 404
 405          try {
 406             ((Device)wrapper).SetSeatId( id);
 407          } catch (Exception e) {
 408             Eina.Log.Warning($"Callback error: {e.ToString()}");
 409             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 410          }
 411                         } else {
 412          efl_input_device_seat_id_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  id);
 413       }
 414    }
 415    private static efl_input_device_seat_id_set_delegate efl_input_device_seat_id_set_static_delegate;
 416
 417
 418     private delegate  System.IntPtr efl_input_device_children_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 419
 420
 421     public delegate  System.IntPtr efl_input_device_children_iterate_api_delegate(System.IntPtr obj);
 422     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");
 423     private static  System.IntPtr children_iterate(System.IntPtr obj, System.IntPtr pd)
 424    {
 425       Eina.Log.Debug("function efl_input_device_children_iterate was called");
 426       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 427       if(wrapper != null) {
 428                   Eina.Iterator<Efl.Input.Device> _ret_var = default(Eina.Iterator<Efl.Input.Device>);
 429          try {
 430             _ret_var = ((Device)wrapper).ChildrenIterate();
 431          } catch (Exception e) {
 432             Eina.Log.Warning($"Callback error: {e.ToString()}");
 433             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 434          }
 435       _ret_var.Own = false; return _ret_var.Handle;
 436       } else {
 437          return efl_input_device_children_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 438       }
 439    }
 440    private static efl_input_device_children_iterate_delegate efl_input_device_children_iterate_static_delegate;
 441
 442
 443     private delegate  uint efl_input_device_has_pointer_caps_delegate(System.IntPtr obj, System.IntPtr pd);
 444
 445
 446     public delegate  uint efl_input_device_has_pointer_caps_api_delegate(System.IntPtr obj);
 447     public static Efl.Eo.FunctionWrapper<efl_input_device_has_pointer_caps_api_delegate> efl_input_device_has_pointer_caps_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_has_pointer_caps_api_delegate>(_Module, "efl_input_device_has_pointer_caps");
 448     private static  uint has_pointer_caps(System.IntPtr obj, System.IntPtr pd)
 449    {
 450       Eina.Log.Debug("function efl_input_device_has_pointer_caps was called");
 451       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 452       if(wrapper != null) {
 453                    uint _ret_var = default( uint);
 454          try {
 455             _ret_var = ((Device)wrapper).HasPointerCaps();
 456          } catch (Exception e) {
 457             Eina.Log.Warning($"Callback error: {e.ToString()}");
 458             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 459          }
 460       return _ret_var;
 461       } else {
 462          return efl_input_device_has_pointer_caps_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 463       }
 464    }
 465    private static efl_input_device_has_pointer_caps_delegate efl_input_device_has_pointer_caps_static_delegate;
 466 }
 467 } }
 468 namespace Efl { namespace Input {
 469 /// <summary>General type of input device.
 470 /// Legacy support since 1.8 as <c>Evas_Device_Class</c>.</summary>
 471 public enum DeviceType
 472 {
 473 /// <summary>Not a device.</summary>
 474 None = 0,
 475 /// <summary>The user/seat (the user themselves).</summary>
 476 Seat = 1,
 477 /// <summary>A regular keyboard, numberpad or attached buttons.</summary>
 478 Keyboard = 2,
 479 /// <summary>A mouse, trackball or touchpad relative motion device.</summary>
 480 Mouse = 3,
 481 /// <summary>A touchscreen with fingers or stylus.</summary>
 482 Touch = 4,
 483 /// <summary>A special pen device.</summary>
 484 Pen = 5,
 485 /// <summary>A laser pointer, wii-style or &quot;Minority Report&quot; pointing device.</summary>
 486 Wand = 6,
 487 /// <summary>A gamepad controller or joystick.</summary>
 488 Gamepad = 7,
 489 }
 490 } }
 491 namespace Efl { namespace Input {
 492 /// <summary>General type of input device.
 493 /// Legacy support since 1.8 as <c>Evas_Device_Subclass</c>.</summary>
 494 public enum DeviceSubtype
 495 {
 496 /// <summary>Not a device.</summary>
 497 None = 0,
 498 /// <summary>The normal flat of your finger.</summary>
 499 Finger = 1,
 500 /// <summary>A fingernai.</summary>
 501 Fingernail = 2,
 502 /// <summary>A Knuckle.</summary>
 503 Knuckle = 3,
 504 /// <summary>The palm of a users hand.</summary>
 505 Palm = 4,
 506 /// <summary>The side of your hand.</summary>
 507 HandSize = 5,
 508 /// <summary>The flat of your hand.</summary>
 509 HandFlat = 6,
 510 /// <summary>The tip of a pen.</summary>
 511 PenTip = 7,
 512 /// <summary>A trackpad style mouse.</summary>
 513 Trackpad = 8,
 514 /// <summary>A trackpoint style mouse.</summary>
 515 Trackpoint = 9,
 516 /// <summary>A trackball style mouse.</summary>
 517 Trackball = 10,
 518 /// <summary>A remote controller.</summary>
 519 Remocon = 11,
 520 /// <summary>A virtual keyboard.</summary>
 521 VirtualKeyboard = 12,
 522 }
 523 } }