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