internals/src/EflSharp/EflSharp/efl/efl_input_hold.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>Event data sent when inputs are put on hold or resumed.</summary>
  13 [Efl.Input.Hold.NativeMethods]
  14 public class Hold : Efl.Object, Efl.Eo.IWrapper,Efl.IDuplicate,Efl.Input.IEvent
  15 {
  16     ///<summary>Pointer to the native class description.</summary>
  17     public override System.IntPtr NativeClass
  18     {
  19         get
  20         {
  21             if (((object)this).GetType() == typeof(Hold))
  22             {
  23                 return GetEflClassStatic();
  24             }
  25             else
  26             {
  27                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  28             }
  29         }
  30     }
  31
  32     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  33         efl_input_hold_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Hold"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     public Hold(Efl.Object parent= null
  37             ) : base(efl_input_hold_class_get(), typeof(Hold), parent)
  38     {
  39         FinishInstantiation();
  40     }
  41
  42     /// <summary>Initializes a new instance of the <see cref="Hold"/> class.
  43     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  44     /// <param name="raw">The native pointer to be wrapped.</param>
  45     protected Hold(System.IntPtr raw) : base(raw)
  46     {
  47             }
  48
  49     /// <summary>Initializes a new instance of the <see cref="Hold"/> class.
  50     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  51     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  52     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  53     /// <param name="parent">The Efl.Object parent of this instance.</param>
  54     protected Hold(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  55     {
  56     }
  57
  58     /// <summary>Verifies if the given object is equal to this one.</summary>
  59     /// <param name="instance">The object to compare to.</param>
  60     /// <returns>True if both objects point to the same native object.</returns>
  61     public override bool Equals(object instance)
  62     {
  63         var other = instance as Efl.Object;
  64         if (other == null)
  65         {
  66             return false;
  67         }
  68         return this.NativeHandle == other.NativeHandle;
  69     }
  70
  71     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  72     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  73     public override int GetHashCode()
  74     {
  75         return this.NativeHandle.ToInt32();
  76     }
  77
  78     /// <summary>Turns the native pointer into a string representation.</summary>
  79     /// <returns>A string with the type and the native pointer for this object.</returns>
  80     public override String ToString()
  81     {
  82         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  83     }
  84
  85     /// <summary>Property to show if inputs are now on hold.</summary>
  86     /// <returns><c>true</c> if inputs are on hold, <c>false</c> otherwise</returns>
  87     virtual public bool GetHold() {
  88          var _ret_var = Efl.Input.Hold.NativeMethods.efl_input_hold_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  89         Eina.Error.RaiseIfUnhandledException();
  90         return _ret_var;
  91  }
  92     /// <summary>Property to show if inputs are now on hold.</summary>
  93     /// <param name="val"><c>true</c> if inputs are on hold, <c>false</c> otherwise</param>
  94     virtual public void SetHold(bool val) {
  95                                  Efl.Input.Hold.NativeMethods.efl_input_hold_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
  96         Eina.Error.RaiseIfUnhandledException();
  97                          }
  98     /// <summary>Creates a carbon copy of this object and returns it.
  99     /// The newly created object will have no event handlers or anything of the sort.</summary>
 100     /// <returns>Returned carbon copy</returns>
 101     virtual public Efl.IDuplicate Duplicate() {
 102          var _ret_var = Efl.IDuplicateConcrete.NativeMethods.efl_duplicate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 103         Eina.Error.RaiseIfUnhandledException();
 104         return _ret_var;
 105  }
 106     /// <summary>The time at which an event was generated.
 107     /// If the event is generated by a server (eg. X.org or Wayland), then the time may be set by the server. Usually this time will be based on the monotonic clock, if available, but this class can not guarantee it.</summary>
 108     /// <returns>Time in milliseconds when the event happened.</returns>
 109     virtual public double GetTimestamp() {
 110          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_timestamp_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 111         Eina.Error.RaiseIfUnhandledException();
 112         return _ret_var;
 113  }
 114     /// <summary>Call this when generating events manually.</summary>
 115     /// <param name="ms">Time in milliseconds when the event happened.</param>
 116     virtual public void SetTimestamp(double ms) {
 117                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_timestamp_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ms);
 118         Eina.Error.RaiseIfUnhandledException();
 119                          }
 120     /// <summary>Input device that originated this event.</summary>
 121     /// <returns>Input device origin</returns>
 122     virtual public Efl.Input.Device GetDevice() {
 123          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_device_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 124         Eina.Error.RaiseIfUnhandledException();
 125         return _ret_var;
 126  }
 127     /// <summary>Input device that originated this event.</summary>
 128     /// <param name="dev">Input device origin</param>
 129     virtual public void SetDevice(Efl.Input.Device dev) {
 130                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_device_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dev);
 131         Eina.Error.RaiseIfUnhandledException();
 132                          }
 133     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 134     /// <returns>Input event flags</returns>
 135     virtual public Efl.Input.Flags GetEventFlags() {
 136          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_event_flags_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 137         Eina.Error.RaiseIfUnhandledException();
 138         return _ret_var;
 139  }
 140     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 141     /// <param name="flags">Input event flags</param>
 142     virtual public void SetEventFlags(Efl.Input.Flags flags) {
 143                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_event_flags_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),flags);
 144         Eina.Error.RaiseIfUnhandledException();
 145                          }
 146     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 147     /// <returns><c>true</c> if the event is on hold, <c>false</c> otherwise</returns>
 148     virtual public bool GetProcessed() {
 149          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_processed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 150         Eina.Error.RaiseIfUnhandledException();
 151         return _ret_var;
 152  }
 153     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 154     /// <param name="val"><c>true</c> if the event is on hold, <c>false</c> otherwise</param>
 155     virtual public void SetProcessed(bool val) {
 156                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_processed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
 157         Eina.Error.RaiseIfUnhandledException();
 158                          }
 159     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 160     /// <returns><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</returns>
 161     virtual public bool GetScrolling() {
 162          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_scrolling_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 163         Eina.Error.RaiseIfUnhandledException();
 164         return _ret_var;
 165  }
 166     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 167     /// <param name="val"><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</param>
 168     virtual public void SetScrolling(bool val) {
 169                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_scrolling_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
 170         Eina.Error.RaiseIfUnhandledException();
 171                          }
 172     /// <summary><c>true</c> if the event was fake, not triggered by real hardware.</summary>
 173     /// <returns><c>true</c> if the event was not from real hardware, <c>false</c> otherwise</returns>
 174     virtual public bool GetFake() {
 175          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_fake_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 176         Eina.Error.RaiseIfUnhandledException();
 177         return _ret_var;
 178  }
 179     /// <summary>Resets the internal data to 0 or default values.</summary>
 180     virtual public void Reset() {
 181          Efl.Input.IEventConcrete.NativeMethods.efl_input_reset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 182         Eina.Error.RaiseIfUnhandledException();
 183          }
 184     /// <summary>The time at which an event was generated.
 185 /// If the event is generated by a server (eg. X.org or Wayland), then the time may be set by the server. Usually this time will be based on the monotonic clock, if available, but this class can not guarantee it.</summary>
 186 /// <value>Time in milliseconds when the event happened.</value>
 187     public double Timestamp {
 188         get { return GetTimestamp(); }
 189         set { SetTimestamp(value); }
 190     }
 191     /// <summary>Input device that originated this event.</summary>
 192 /// <value>Input device origin</value>
 193     public Efl.Input.Device Device {
 194         get { return GetDevice(); }
 195         set { SetDevice(value); }
 196     }
 197     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 198 /// <value>Input event flags</value>
 199     public Efl.Input.Flags EventFlags {
 200         get { return GetEventFlags(); }
 201         set { SetEventFlags(value); }
 202     }
 203     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 204 /// <value><c>true</c> if the event is on hold, <c>false</c> otherwise</value>
 205     public bool Processed {
 206         get { return GetProcessed(); }
 207         set { SetProcessed(value); }
 208     }
 209     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 210 /// <value><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</value>
 211     public bool Scrolling {
 212         get { return GetScrolling(); }
 213         set { SetScrolling(value); }
 214     }
 215     /// <summary><c>true</c> if the event was fake, not triggered by real hardware.</summary>
 216 /// <value><c>true</c> if the event was not from real hardware, <c>false</c> otherwise</value>
 217     public bool Fake {
 218         get { return GetFake(); }
 219     }
 220     private static IntPtr GetEflClassStatic()
 221     {
 222         return Efl.Input.Hold.efl_input_hold_class_get();
 223     }
 224     /// <summary>Wrapper for native methods and virtual method delegates.
 225     /// For internal use by generated code only.</summary>
 226     public new class NativeMethods : Efl.Object.NativeMethods
 227     {
 228         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 229         /// <summary>Gets the list of Eo operations to override.</summary>
 230         /// <returns>The list of Eo operations to be overload.</returns>
 231         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 232         {
 233             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 234             var methods = Efl.Eo.Globals.GetUserMethods(type);
 235
 236             if (efl_input_hold_get_static_delegate == null)
 237             {
 238                 efl_input_hold_get_static_delegate = new efl_input_hold_get_delegate(hold_get);
 239             }
 240
 241             if (methods.FirstOrDefault(m => m.Name == "GetHold") != null)
 242             {
 243                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_hold_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_hold_get_static_delegate) });
 244             }
 245
 246             if (efl_input_hold_set_static_delegate == null)
 247             {
 248                 efl_input_hold_set_static_delegate = new efl_input_hold_set_delegate(hold_set);
 249             }
 250
 251             if (methods.FirstOrDefault(m => m.Name == "SetHold") != null)
 252             {
 253                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_hold_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_hold_set_static_delegate) });
 254             }
 255
 256             if (efl_duplicate_static_delegate == null)
 257             {
 258                 efl_duplicate_static_delegate = new efl_duplicate_delegate(duplicate);
 259             }
 260
 261             if (methods.FirstOrDefault(m => m.Name == "Duplicate") != null)
 262             {
 263                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_duplicate"), func = Marshal.GetFunctionPointerForDelegate(efl_duplicate_static_delegate) });
 264             }
 265
 266             if (efl_input_timestamp_get_static_delegate == null)
 267             {
 268                 efl_input_timestamp_get_static_delegate = new efl_input_timestamp_get_delegate(timestamp_get);
 269             }
 270
 271             if (methods.FirstOrDefault(m => m.Name == "GetTimestamp") != null)
 272             {
 273                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_timestamp_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_timestamp_get_static_delegate) });
 274             }
 275
 276             if (efl_input_timestamp_set_static_delegate == null)
 277             {
 278                 efl_input_timestamp_set_static_delegate = new efl_input_timestamp_set_delegate(timestamp_set);
 279             }
 280
 281             if (methods.FirstOrDefault(m => m.Name == "SetTimestamp") != null)
 282             {
 283                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_timestamp_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_timestamp_set_static_delegate) });
 284             }
 285
 286             if (efl_input_device_get_static_delegate == null)
 287             {
 288                 efl_input_device_get_static_delegate = new efl_input_device_get_delegate(device_get);
 289             }
 290
 291             if (methods.FirstOrDefault(m => m.Name == "GetDevice") != null)
 292             {
 293                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_get_static_delegate) });
 294             }
 295
 296             if (efl_input_device_set_static_delegate == null)
 297             {
 298                 efl_input_device_set_static_delegate = new efl_input_device_set_delegate(device_set);
 299             }
 300
 301             if (methods.FirstOrDefault(m => m.Name == "SetDevice") != null)
 302             {
 303                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_device_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_device_set_static_delegate) });
 304             }
 305
 306             if (efl_input_event_flags_get_static_delegate == null)
 307             {
 308                 efl_input_event_flags_get_static_delegate = new efl_input_event_flags_get_delegate(event_flags_get);
 309             }
 310
 311             if (methods.FirstOrDefault(m => m.Name == "GetEventFlags") != null)
 312             {
 313                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_event_flags_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_event_flags_get_static_delegate) });
 314             }
 315
 316             if (efl_input_event_flags_set_static_delegate == null)
 317             {
 318                 efl_input_event_flags_set_static_delegate = new efl_input_event_flags_set_delegate(event_flags_set);
 319             }
 320
 321             if (methods.FirstOrDefault(m => m.Name == "SetEventFlags") != null)
 322             {
 323                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_event_flags_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_event_flags_set_static_delegate) });
 324             }
 325
 326             if (efl_input_processed_get_static_delegate == null)
 327             {
 328                 efl_input_processed_get_static_delegate = new efl_input_processed_get_delegate(processed_get);
 329             }
 330
 331             if (methods.FirstOrDefault(m => m.Name == "GetProcessed") != null)
 332             {
 333                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_processed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_processed_get_static_delegate) });
 334             }
 335
 336             if (efl_input_processed_set_static_delegate == null)
 337             {
 338                 efl_input_processed_set_static_delegate = new efl_input_processed_set_delegate(processed_set);
 339             }
 340
 341             if (methods.FirstOrDefault(m => m.Name == "SetProcessed") != null)
 342             {
 343                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_processed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_processed_set_static_delegate) });
 344             }
 345
 346             if (efl_input_scrolling_get_static_delegate == null)
 347             {
 348                 efl_input_scrolling_get_static_delegate = new efl_input_scrolling_get_delegate(scrolling_get);
 349             }
 350
 351             if (methods.FirstOrDefault(m => m.Name == "GetScrolling") != null)
 352             {
 353                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_scrolling_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_scrolling_get_static_delegate) });
 354             }
 355
 356             if (efl_input_scrolling_set_static_delegate == null)
 357             {
 358                 efl_input_scrolling_set_static_delegate = new efl_input_scrolling_set_delegate(scrolling_set);
 359             }
 360
 361             if (methods.FirstOrDefault(m => m.Name == "SetScrolling") != null)
 362             {
 363                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_scrolling_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_scrolling_set_static_delegate) });
 364             }
 365
 366             if (efl_input_fake_get_static_delegate == null)
 367             {
 368                 efl_input_fake_get_static_delegate = new efl_input_fake_get_delegate(fake_get);
 369             }
 370
 371             if (methods.FirstOrDefault(m => m.Name == "GetFake") != null)
 372             {
 373                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_fake_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_fake_get_static_delegate) });
 374             }
 375
 376             if (efl_input_reset_static_delegate == null)
 377             {
 378                 efl_input_reset_static_delegate = new efl_input_reset_delegate(reset);
 379             }
 380
 381             if (methods.FirstOrDefault(m => m.Name == "Reset") != null)
 382             {
 383                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_reset"), func = Marshal.GetFunctionPointerForDelegate(efl_input_reset_static_delegate) });
 384             }
 385
 386             descs.AddRange(base.GetEoOps(type));
 387             return descs;
 388         }
 389         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 390         /// <returns>The native class pointer.</returns>
 391         public override IntPtr GetEflClass()
 392         {
 393             return Efl.Input.Hold.efl_input_hold_class_get();
 394         }
 395
 396         #pragma warning disable CA1707, SA1300, SA1600
 397
 398         [return: MarshalAs(UnmanagedType.U1)]
 399         private delegate bool efl_input_hold_get_delegate(System.IntPtr obj, System.IntPtr pd);
 400
 401         [return: MarshalAs(UnmanagedType.U1)]
 402         public delegate bool efl_input_hold_get_api_delegate(System.IntPtr obj);
 403
 404         public static Efl.Eo.FunctionWrapper<efl_input_hold_get_api_delegate> efl_input_hold_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_hold_get_api_delegate>(Module, "efl_input_hold_get");
 405
 406         private static bool hold_get(System.IntPtr obj, System.IntPtr pd)
 407         {
 408             Eina.Log.Debug("function efl_input_hold_get was called");
 409             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 410             if (wrapper != null)
 411             {
 412             bool _ret_var = default(bool);
 413                 try
 414                 {
 415                     _ret_var = ((Hold)wrapper).GetHold();
 416                 }
 417                 catch (Exception e)
 418                 {
 419                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 420                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 421                 }
 422
 423         return _ret_var;
 424
 425             }
 426             else
 427             {
 428                 return efl_input_hold_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 429             }
 430         }
 431
 432         private static efl_input_hold_get_delegate efl_input_hold_get_static_delegate;
 433
 434
 435         private delegate void efl_input_hold_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
 436
 437
 438         public delegate void efl_input_hold_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
 439
 440         public static Efl.Eo.FunctionWrapper<efl_input_hold_set_api_delegate> efl_input_hold_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_hold_set_api_delegate>(Module, "efl_input_hold_set");
 441
 442         private static void hold_set(System.IntPtr obj, System.IntPtr pd, bool val)
 443         {
 444             Eina.Log.Debug("function efl_input_hold_set was called");
 445             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 446             if (wrapper != null)
 447             {
 448
 449                 try
 450                 {
 451                     ((Hold)wrapper).SetHold(val);
 452                 }
 453                 catch (Exception e)
 454                 {
 455                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 456                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 457                 }
 458
 459
 460             }
 461             else
 462             {
 463                 efl_input_hold_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 464             }
 465         }
 466
 467         private static efl_input_hold_set_delegate efl_input_hold_set_static_delegate;
 468
 469         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
 470         private delegate Efl.IDuplicate efl_duplicate_delegate(System.IntPtr obj, System.IntPtr pd);
 471
 472         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
 473         public delegate Efl.IDuplicate efl_duplicate_api_delegate(System.IntPtr obj);
 474
 475         public static Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate> efl_duplicate_ptr = new Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate>(Module, "efl_duplicate");
 476
 477         private static Efl.IDuplicate duplicate(System.IntPtr obj, System.IntPtr pd)
 478         {
 479             Eina.Log.Debug("function efl_duplicate was called");
 480             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 481             if (wrapper != null)
 482             {
 483             Efl.IDuplicate _ret_var = default(Efl.IDuplicate);
 484                 try
 485                 {
 486                     _ret_var = ((Hold)wrapper).Duplicate();
 487                 }
 488                 catch (Exception e)
 489                 {
 490                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 491                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 492                 }
 493
 494         return _ret_var;
 495
 496             }
 497             else
 498             {
 499                 return efl_duplicate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 500             }
 501         }
 502
 503         private static efl_duplicate_delegate efl_duplicate_static_delegate;
 504
 505
 506         private delegate double efl_input_timestamp_get_delegate(System.IntPtr obj, System.IntPtr pd);
 507
 508
 509         public delegate double efl_input_timestamp_get_api_delegate(System.IntPtr obj);
 510
 511         public static Efl.Eo.FunctionWrapper<efl_input_timestamp_get_api_delegate> efl_input_timestamp_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_timestamp_get_api_delegate>(Module, "efl_input_timestamp_get");
 512
 513         private static double timestamp_get(System.IntPtr obj, System.IntPtr pd)
 514         {
 515             Eina.Log.Debug("function efl_input_timestamp_get was called");
 516             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 517             if (wrapper != null)
 518             {
 519             double _ret_var = default(double);
 520                 try
 521                 {
 522                     _ret_var = ((Hold)wrapper).GetTimestamp();
 523                 }
 524                 catch (Exception e)
 525                 {
 526                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 527                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 528                 }
 529
 530         return _ret_var;
 531
 532             }
 533             else
 534             {
 535                 return efl_input_timestamp_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 536             }
 537         }
 538
 539         private static efl_input_timestamp_get_delegate efl_input_timestamp_get_static_delegate;
 540
 541
 542         private delegate void efl_input_timestamp_set_delegate(System.IntPtr obj, System.IntPtr pd,  double ms);
 543
 544
 545         public delegate void efl_input_timestamp_set_api_delegate(System.IntPtr obj,  double ms);
 546
 547         public static Efl.Eo.FunctionWrapper<efl_input_timestamp_set_api_delegate> efl_input_timestamp_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_timestamp_set_api_delegate>(Module, "efl_input_timestamp_set");
 548
 549         private static void timestamp_set(System.IntPtr obj, System.IntPtr pd, double ms)
 550         {
 551             Eina.Log.Debug("function efl_input_timestamp_set was called");
 552             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 553             if (wrapper != null)
 554             {
 555
 556                 try
 557                 {
 558                     ((Hold)wrapper).SetTimestamp(ms);
 559                 }
 560                 catch (Exception e)
 561                 {
 562                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 563                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 564                 }
 565
 566
 567             }
 568             else
 569             {
 570                 efl_input_timestamp_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ms);
 571             }
 572         }
 573
 574         private static efl_input_timestamp_set_delegate efl_input_timestamp_set_static_delegate;
 575
 576         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 577         private delegate Efl.Input.Device efl_input_device_get_delegate(System.IntPtr obj, System.IntPtr pd);
 578
 579         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 580         public delegate Efl.Input.Device efl_input_device_get_api_delegate(System.IntPtr obj);
 581
 582         public static Efl.Eo.FunctionWrapper<efl_input_device_get_api_delegate> efl_input_device_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_get_api_delegate>(Module, "efl_input_device_get");
 583
 584         private static Efl.Input.Device device_get(System.IntPtr obj, System.IntPtr pd)
 585         {
 586             Eina.Log.Debug("function efl_input_device_get was called");
 587             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 588             if (wrapper != null)
 589             {
 590             Efl.Input.Device _ret_var = default(Efl.Input.Device);
 591                 try
 592                 {
 593                     _ret_var = ((Hold)wrapper).GetDevice();
 594                 }
 595                 catch (Exception e)
 596                 {
 597                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 598                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 599                 }
 600
 601         return _ret_var;
 602
 603             }
 604             else
 605             {
 606                 return efl_input_device_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 607             }
 608         }
 609
 610         private static efl_input_device_get_delegate efl_input_device_get_static_delegate;
 611
 612
 613         private delegate void efl_input_device_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device dev);
 614
 615
 616         public delegate void efl_input_device_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device dev);
 617
 618         public static Efl.Eo.FunctionWrapper<efl_input_device_set_api_delegate> efl_input_device_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_device_set_api_delegate>(Module, "efl_input_device_set");
 619
 620         private static void device_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Device dev)
 621         {
 622             Eina.Log.Debug("function efl_input_device_set was called");
 623             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 624             if (wrapper != null)
 625             {
 626
 627                 try
 628                 {
 629                     ((Hold)wrapper).SetDevice(dev);
 630                 }
 631                 catch (Exception e)
 632                 {
 633                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 634                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 635                 }
 636
 637
 638             }
 639             else
 640             {
 641                 efl_input_device_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dev);
 642             }
 643         }
 644
 645         private static efl_input_device_set_delegate efl_input_device_set_static_delegate;
 646
 647
 648         private delegate Efl.Input.Flags efl_input_event_flags_get_delegate(System.IntPtr obj, System.IntPtr pd);
 649
 650
 651         public delegate Efl.Input.Flags efl_input_event_flags_get_api_delegate(System.IntPtr obj);
 652
 653         public static Efl.Eo.FunctionWrapper<efl_input_event_flags_get_api_delegate> efl_input_event_flags_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_event_flags_get_api_delegate>(Module, "efl_input_event_flags_get");
 654
 655         private static Efl.Input.Flags event_flags_get(System.IntPtr obj, System.IntPtr pd)
 656         {
 657             Eina.Log.Debug("function efl_input_event_flags_get was called");
 658             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 659             if (wrapper != null)
 660             {
 661             Efl.Input.Flags _ret_var = default(Efl.Input.Flags);
 662                 try
 663                 {
 664                     _ret_var = ((Hold)wrapper).GetEventFlags();
 665                 }
 666                 catch (Exception e)
 667                 {
 668                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 669                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 670                 }
 671
 672         return _ret_var;
 673
 674             }
 675             else
 676             {
 677                 return efl_input_event_flags_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 678             }
 679         }
 680
 681         private static efl_input_event_flags_get_delegate efl_input_event_flags_get_static_delegate;
 682
 683
 684         private delegate void efl_input_event_flags_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Flags flags);
 685
 686
 687         public delegate void efl_input_event_flags_set_api_delegate(System.IntPtr obj,  Efl.Input.Flags flags);
 688
 689         public static Efl.Eo.FunctionWrapper<efl_input_event_flags_set_api_delegate> efl_input_event_flags_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_event_flags_set_api_delegate>(Module, "efl_input_event_flags_set");
 690
 691         private static void event_flags_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Flags flags)
 692         {
 693             Eina.Log.Debug("function efl_input_event_flags_set was called");
 694             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 695             if (wrapper != null)
 696             {
 697
 698                 try
 699                 {
 700                     ((Hold)wrapper).SetEventFlags(flags);
 701                 }
 702                 catch (Exception e)
 703                 {
 704                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 705                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 706                 }
 707
 708
 709             }
 710             else
 711             {
 712                 efl_input_event_flags_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), flags);
 713             }
 714         }
 715
 716         private static efl_input_event_flags_set_delegate efl_input_event_flags_set_static_delegate;
 717
 718         [return: MarshalAs(UnmanagedType.U1)]
 719         private delegate bool efl_input_processed_get_delegate(System.IntPtr obj, System.IntPtr pd);
 720
 721         [return: MarshalAs(UnmanagedType.U1)]
 722         public delegate bool efl_input_processed_get_api_delegate(System.IntPtr obj);
 723
 724         public static Efl.Eo.FunctionWrapper<efl_input_processed_get_api_delegate> efl_input_processed_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_processed_get_api_delegate>(Module, "efl_input_processed_get");
 725
 726         private static bool processed_get(System.IntPtr obj, System.IntPtr pd)
 727         {
 728             Eina.Log.Debug("function efl_input_processed_get was called");
 729             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 730             if (wrapper != null)
 731             {
 732             bool _ret_var = default(bool);
 733                 try
 734                 {
 735                     _ret_var = ((Hold)wrapper).GetProcessed();
 736                 }
 737                 catch (Exception e)
 738                 {
 739                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 740                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 741                 }
 742
 743         return _ret_var;
 744
 745             }
 746             else
 747             {
 748                 return efl_input_processed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 749             }
 750         }
 751
 752         private static efl_input_processed_get_delegate efl_input_processed_get_static_delegate;
 753
 754
 755         private delegate void efl_input_processed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
 756
 757
 758         public delegate void efl_input_processed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
 759
 760         public static Efl.Eo.FunctionWrapper<efl_input_processed_set_api_delegate> efl_input_processed_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_processed_set_api_delegate>(Module, "efl_input_processed_set");
 761
 762         private static void processed_set(System.IntPtr obj, System.IntPtr pd, bool val)
 763         {
 764             Eina.Log.Debug("function efl_input_processed_set was called");
 765             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 766             if (wrapper != null)
 767             {
 768
 769                 try
 770                 {
 771                     ((Hold)wrapper).SetProcessed(val);
 772                 }
 773                 catch (Exception e)
 774                 {
 775                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 776                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 777                 }
 778
 779
 780             }
 781             else
 782             {
 783                 efl_input_processed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 784             }
 785         }
 786
 787         private static efl_input_processed_set_delegate efl_input_processed_set_static_delegate;
 788
 789         [return: MarshalAs(UnmanagedType.U1)]
 790         private delegate bool efl_input_scrolling_get_delegate(System.IntPtr obj, System.IntPtr pd);
 791
 792         [return: MarshalAs(UnmanagedType.U1)]
 793         public delegate bool efl_input_scrolling_get_api_delegate(System.IntPtr obj);
 794
 795         public static Efl.Eo.FunctionWrapper<efl_input_scrolling_get_api_delegate> efl_input_scrolling_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_scrolling_get_api_delegate>(Module, "efl_input_scrolling_get");
 796
 797         private static bool scrolling_get(System.IntPtr obj, System.IntPtr pd)
 798         {
 799             Eina.Log.Debug("function efl_input_scrolling_get was called");
 800             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 801             if (wrapper != null)
 802             {
 803             bool _ret_var = default(bool);
 804                 try
 805                 {
 806                     _ret_var = ((Hold)wrapper).GetScrolling();
 807                 }
 808                 catch (Exception e)
 809                 {
 810                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 811                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 812                 }
 813
 814         return _ret_var;
 815
 816             }
 817             else
 818             {
 819                 return efl_input_scrolling_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 820             }
 821         }
 822
 823         private static efl_input_scrolling_get_delegate efl_input_scrolling_get_static_delegate;
 824
 825
 826         private delegate void efl_input_scrolling_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
 827
 828
 829         public delegate void efl_input_scrolling_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
 830
 831         public static Efl.Eo.FunctionWrapper<efl_input_scrolling_set_api_delegate> efl_input_scrolling_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_scrolling_set_api_delegate>(Module, "efl_input_scrolling_set");
 832
 833         private static void scrolling_set(System.IntPtr obj, System.IntPtr pd, bool val)
 834         {
 835             Eina.Log.Debug("function efl_input_scrolling_set was called");
 836             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 837             if (wrapper != null)
 838             {
 839
 840                 try
 841                 {
 842                     ((Hold)wrapper).SetScrolling(val);
 843                 }
 844                 catch (Exception e)
 845                 {
 846                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 847                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 848                 }
 849
 850
 851             }
 852             else
 853             {
 854                 efl_input_scrolling_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 855             }
 856         }
 857
 858         private static efl_input_scrolling_set_delegate efl_input_scrolling_set_static_delegate;
 859
 860         [return: MarshalAs(UnmanagedType.U1)]
 861         private delegate bool efl_input_fake_get_delegate(System.IntPtr obj, System.IntPtr pd);
 862
 863         [return: MarshalAs(UnmanagedType.U1)]
 864         public delegate bool efl_input_fake_get_api_delegate(System.IntPtr obj);
 865
 866         public static Efl.Eo.FunctionWrapper<efl_input_fake_get_api_delegate> efl_input_fake_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_fake_get_api_delegate>(Module, "efl_input_fake_get");
 867
 868         private static bool fake_get(System.IntPtr obj, System.IntPtr pd)
 869         {
 870             Eina.Log.Debug("function efl_input_fake_get was called");
 871             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 872             if (wrapper != null)
 873             {
 874             bool _ret_var = default(bool);
 875                 try
 876                 {
 877                     _ret_var = ((Hold)wrapper).GetFake();
 878                 }
 879                 catch (Exception e)
 880                 {
 881                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 882                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 883                 }
 884
 885         return _ret_var;
 886
 887             }
 888             else
 889             {
 890                 return efl_input_fake_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 891             }
 892         }
 893
 894         private static efl_input_fake_get_delegate efl_input_fake_get_static_delegate;
 895
 896
 897         private delegate void efl_input_reset_delegate(System.IntPtr obj, System.IntPtr pd);
 898
 899
 900         public delegate void efl_input_reset_api_delegate(System.IntPtr obj);
 901
 902         public static Efl.Eo.FunctionWrapper<efl_input_reset_api_delegate> efl_input_reset_ptr = new Efl.Eo.FunctionWrapper<efl_input_reset_api_delegate>(Module, "efl_input_reset");
 903
 904         private static void reset(System.IntPtr obj, System.IntPtr pd)
 905         {
 906             Eina.Log.Debug("function efl_input_reset was called");
 907             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 908             if (wrapper != null)
 909             {
 910
 911                 try
 912                 {
 913                     ((Hold)wrapper).Reset();
 914                 }
 915                 catch (Exception e)
 916                 {
 917                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 918                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 919                 }
 920
 921
 922             }
 923             else
 924             {
 925                 efl_input_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 926             }
 927         }
 928
 929         private static efl_input_reset_delegate efl_input_reset_static_delegate;
 930
 931         #pragma warning restore CA1707, SA1300, SA1600
 932
 933 }
 934 }
 935 }
 936
 937 }
 938