internals/src/EflSharp/EflSharp/efl/efl_input_pointer.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 carried over with any pointer event (mouse, touch, pen, ...)</summary>
  13 [Efl.Input.Pointer.NativeMethods]
  14 public class Pointer : Efl.Object, Efl.Eo.IWrapper,Efl.IDuplicate,Efl.Input.IEvent,Efl.Input.IState
  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(Pointer))
  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_pointer_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Pointer"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     public Pointer(Efl.Object parent= null
  37             ) : base(efl_input_pointer_class_get(), typeof(Pointer), parent)
  38     {
  39         FinishInstantiation();
  40     }
  41
  42     /// <summary>Initializes a new instance of the <see cref="Pointer"/> 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 Pointer(System.IntPtr raw) : base(raw)
  46     {
  47             }
  48
  49     /// <summary>Initializes a new instance of the <see cref="Pointer"/> 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 Pointer(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>The action represented by this event.</summary>
  86     /// <returns>Event action</returns>
  87     virtual public Efl.Pointer.Action GetAction() {
  88          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_action_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>The action represented by this event.</summary>
  93     /// <param name="act">Event action</param>
  94     virtual public void SetAction(Efl.Pointer.Action act) {
  95                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_action_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),act);
  96         Eina.Error.RaiseIfUnhandledException();
  97                          }
  98     /// <summary><c>true</c> if this event carries a valid value for the specified <c>key</c>.</summary>
  99     /// <param name="key">Pressed <c>key</c></param>
 100     /// <returns><c>true</c> if input value is valid, <c>false</c> otherwise</returns>
 101     virtual public bool GetValueHas(Efl.Input.Value key) {
 102                                  var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_value_has_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),key);
 103         Eina.Error.RaiseIfUnhandledException();
 104                         return _ret_var;
 105  }
 106     /// <summary>Represents a generic value for this event.
 107     /// Refer to the documentation of <see cref="Efl.Input.Value"/> for each value&apos;s meaning, type and range. Call <see cref="Efl.Input.Pointer.GetValueHas"/> to determine whether the returned value is valid or not for this event.
 108     ///
 109     /// Most values are precise floating point values, usually in pixels, radians, or in a range of [-1, 1] or [0, 1]. Some values are discrete values (integers) and thus should preferably be queried with the other methods of this class.</summary>
 110     /// <param name="key"><c>key</c></param>
 111     /// <returns><c>key</c> value</returns>
 112     virtual public double GetValue(Efl.Input.Value key) {
 113                                  var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_value_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),key);
 114         Eina.Error.RaiseIfUnhandledException();
 115                         return _ret_var;
 116  }
 117     /// <summary>Represents a generic value for this event.
 118     /// Refer to the documentation of <see cref="Efl.Input.Value"/> for each value&apos;s meaning, type and range. Call <see cref="Efl.Input.Pointer.GetValueHas"/> to determine whether the returned value is valid or not for this event.
 119     ///
 120     /// Most values are precise floating point values, usually in pixels, radians, or in a range of [-1, 1] or [0, 1]. Some values are discrete values (integers) and thus should preferably be queried with the other methods of this class.</summary>
 121     /// <param name="key"><c>key</c></param>
 122     /// <param name="val"><c>key</c> value</param>
 123     /// <returns><c>false</c> if the value could not be set (eg. delta).</returns>
 124     virtual public bool SetValue(Efl.Input.Value key, double val) {
 125                                                          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_value_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),key, val);
 126         Eina.Error.RaiseIfUnhandledException();
 127                                         return _ret_var;
 128  }
 129     /// <summary>The mouse button that triggered the event.
 130     /// Valid if and only if <see cref="Efl.Input.Pointer.GetValueHas"/>(<c>button</c>) is <c>true</c>.</summary>
 131     /// <returns>1 to 32, 0 if not a button event.</returns>
 132     virtual public int GetButton() {
 133          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_button_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 134         Eina.Error.RaiseIfUnhandledException();
 135         return _ret_var;
 136  }
 137     /// <summary>The mouse button that triggered the event.
 138     /// Valid if and only if <see cref="Efl.Input.Pointer.GetValueHas"/>(<c>button</c>) is <c>true</c>.</summary>
 139     /// <param name="but">1 to 32, 0 if not a button event.</param>
 140     virtual public void SetButton(int but) {
 141                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_button_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),but);
 142         Eina.Error.RaiseIfUnhandledException();
 143                          }
 144     /// <summary>Whether a mouse button is pressed at the moment of the event.
 145     /// Valid if and only if <see cref="Efl.Input.Pointer.GetValueHas"/>(<c>button_pressed</c>) is <c>true</c>.</summary>
 146     /// <param name="button">1 to 32, 0 if not a button event.</param>
 147     /// <returns><c>true</c> when the button was pressed, <c>false</c> otherwise</returns>
 148     virtual public bool GetButtonPressed(int button) {
 149                                  var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_button_pressed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),button);
 150         Eina.Error.RaiseIfUnhandledException();
 151                         return _ret_var;
 152  }
 153     /// <summary>Whether a mouse button is pressed at the moment of the event.
 154     /// Valid if and only if <see cref="Efl.Input.Pointer.GetValueHas"/>(<c>button_pressed</c>) is <c>true</c>.</summary>
 155     /// <param name="button">1 to 32, 0 if not a button event.</param>
 156     /// <param name="pressed"><c>true</c> when the button was pressed, <c>false</c> otherwise</param>
 157     virtual public void SetButtonPressed(int button, bool pressed) {
 158                                                          Efl.Input.Pointer.NativeMethods.efl_input_pointer_button_pressed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),button, pressed);
 159         Eina.Error.RaiseIfUnhandledException();
 160                                          }
 161     /// <summary>Position where the event happened, relative to the window.
 162     /// See <see cref="Efl.Input.Pointer.PrecisePosition"/> for floating point precision (subpixel location).</summary>
 163     /// <returns>The position of the event, in pixels.</returns>
 164     virtual public Eina.Position2D GetPosition() {
 165          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 166         Eina.Error.RaiseIfUnhandledException();
 167         return _ret_var;
 168  }
 169     /// <summary>Position where the event happened, relative to the window.
 170     /// See <see cref="Efl.Input.Pointer.PrecisePosition"/> for floating point precision (subpixel location).</summary>
 171     /// <param name="pos">The position of the event, in pixels.</param>
 172     virtual public void SetPosition(Eina.Position2D pos) {
 173          Eina.Position2D.NativeStruct _in_pos = pos;
 174                         Efl.Input.Pointer.NativeMethods.efl_input_pointer_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_pos);
 175         Eina.Error.RaiseIfUnhandledException();
 176                          }
 177     /// <summary>Position where the event happened, relative to the window.
 178     /// This position is in floating point values, for more precise coordinates, in subpixels. Note that many input devices are unable to give better precision than a single pixel, so this may be equal to <see cref="Efl.Input.Pointer.Position"/>.
 179     ///
 180     /// See also <see cref="Efl.Input.Pointer.Position"/>.</summary>
 181     /// <returns>The position of the event, in pixels.</returns>
 182     virtual public Eina.Vector2 GetPrecisePosition() {
 183          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_precise_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 184         Eina.Error.RaiseIfUnhandledException();
 185         return _ret_var;
 186  }
 187     /// <summary>Position where the event happened, relative to the window.
 188     /// This position is in floating point values, for more precise coordinates, in subpixels. Note that many input devices are unable to give better precision than a single pixel, so this may be equal to <see cref="Efl.Input.Pointer.Position"/>.
 189     ///
 190     /// See also <see cref="Efl.Input.Pointer.Position"/>.</summary>
 191     /// <param name="pos">The position of the event, in pixels.</param>
 192     virtual public void SetPrecisePosition(Eina.Vector2 pos) {
 193          Eina.Vector2.NativeStruct _in_pos = pos;
 194                         Efl.Input.Pointer.NativeMethods.efl_input_pointer_precise_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_pos);
 195         Eina.Error.RaiseIfUnhandledException();
 196                          }
 197     /// <summary>Position of the previous event, valid for move events.
 198     /// Relative to the window. May be equal to <see cref="Efl.Input.Pointer.Position"/> (by default).
 199     ///
 200     /// This position, in integers, is an approximation of <see cref="Efl.Input.Pointer.GetValue"/>(<c>previous_x</c>), <see cref="Efl.Input.Pointer.GetValue"/>(<c>previous_y</c>). Use <see cref="Efl.Input.Pointer.PreviousPosition"/> if you need simple pixel positions, but prefer the generic interface if you need precise coordinates.</summary>
 201     /// <returns>The position of the event, in pixels.</returns>
 202     virtual public Eina.Position2D GetPreviousPosition() {
 203          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_previous_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 204         Eina.Error.RaiseIfUnhandledException();
 205         return _ret_var;
 206  }
 207     /// <summary>Position of the previous event, valid for move events.
 208     /// Relative to the window. May be equal to <see cref="Efl.Input.Pointer.Position"/> (by default).
 209     ///
 210     /// This position, in integers, is an approximation of <see cref="Efl.Input.Pointer.GetValue"/>(<c>previous_x</c>), <see cref="Efl.Input.Pointer.GetValue"/>(<c>previous_y</c>). Use <see cref="Efl.Input.Pointer.PreviousPosition"/> if you need simple pixel positions, but prefer the generic interface if you need precise coordinates.</summary>
 211     /// <param name="pos">The position of the event, in pixels.</param>
 212     virtual public void SetPreviousPosition(Eina.Position2D pos) {
 213          Eina.Position2D.NativeStruct _in_pos = pos;
 214                         Efl.Input.Pointer.NativeMethods.efl_input_pointer_previous_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_pos);
 215         Eina.Error.RaiseIfUnhandledException();
 216                          }
 217     /// <summary>ID of the tool (eg. pen) that triggered this event.</summary>
 218     /// <returns>Tool ID</returns>
 219     virtual public int GetTool() {
 220          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_tool_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 221         Eina.Error.RaiseIfUnhandledException();
 222         return _ret_var;
 223  }
 224     /// <summary>ID of the tool (eg. pen) that triggered this event.</summary>
 225     /// <param name="id">Tool ID</param>
 226     virtual public void SetTool(int id) {
 227                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_tool_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),id);
 228         Eina.Error.RaiseIfUnhandledException();
 229                          }
 230     /// <summary>The object where this event first originated, in case of propagation or repetition of the event.</summary>
 231     /// <returns>Source object: <see cref="Efl.Gfx.IEntity"/></returns>
 232     virtual public Efl.Object GetSource() {
 233          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_source_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 234         Eina.Error.RaiseIfUnhandledException();
 235         return _ret_var;
 236  }
 237     /// <summary>The object where this event first originated, in case of propagation or repetition of the event.</summary>
 238     /// <param name="src">Source object: <see cref="Efl.Gfx.IEntity"/></param>
 239     virtual public void SetSource(Efl.Object src) {
 240                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_source_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),src);
 241         Eina.Error.RaiseIfUnhandledException();
 242                          }
 243     /// <summary>Double or triple click information.</summary>
 244     /// <returns>Button information flags</returns>
 245     virtual public Efl.Pointer.Flags GetButtonFlags() {
 246          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_button_flags_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 247         Eina.Error.RaiseIfUnhandledException();
 248         return _ret_var;
 249  }
 250     /// <summary>Double or triple click information.</summary>
 251     /// <param name="flags">Button information flags</param>
 252     virtual public void SetButtonFlags(Efl.Pointer.Flags flags) {
 253                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_button_flags_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),flags);
 254         Eina.Error.RaiseIfUnhandledException();
 255                          }
 256     /// <summary><c>true</c> if <see cref="Efl.Input.Pointer.ButtonFlags"/> indicates a double click (2nd press).
 257     /// This is just a helper function around <see cref="Efl.Input.Pointer.ButtonFlags"/>.</summary>
 258     /// <returns><c>true</c> if the button press was a double click, <c>false</c> otherwise</returns>
 259     virtual public bool GetDoubleClick() {
 260          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_double_click_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 261         Eina.Error.RaiseIfUnhandledException();
 262         return _ret_var;
 263  }
 264     /// <summary><c>true</c> if <see cref="Efl.Input.Pointer.ButtonFlags"/> indicates a double click (2nd press).
 265     /// This is just a helper function around <see cref="Efl.Input.Pointer.ButtonFlags"/>.</summary>
 266     /// <param name="val"><c>true</c> if the button press was a double click, <c>false</c> otherwise</param>
 267     virtual public void SetDoubleClick(bool val) {
 268                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_double_click_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
 269         Eina.Error.RaiseIfUnhandledException();
 270                          }
 271     /// <summary><c>true</c> if <see cref="Efl.Input.Pointer.ButtonFlags"/> indicates a triple click (3rd press).
 272     /// This is just a helper function around <see cref="Efl.Input.Pointer.ButtonFlags"/>.</summary>
 273     /// <returns><c>true</c> if the button press was a triple click, <c>false</c> otherwise</returns>
 274     virtual public bool GetTripleClick() {
 275          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_triple_click_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 276         Eina.Error.RaiseIfUnhandledException();
 277         return _ret_var;
 278  }
 279     /// <summary><c>true</c> if <see cref="Efl.Input.Pointer.ButtonFlags"/> indicates a triple click (3rd press).
 280     /// This is just a helper function around <see cref="Efl.Input.Pointer.ButtonFlags"/>.</summary>
 281     /// <param name="val"><c>true</c> if the button press was a triple click, <c>false</c> otherwise</param>
 282     virtual public void SetTripleClick(bool val) {
 283                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_triple_click_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
 284         Eina.Error.RaiseIfUnhandledException();
 285                          }
 286     /// <summary>Direction of the wheel, usually vertical.</summary>
 287     /// <returns>If <c>true</c> this was a horizontal wheel.</returns>
 288     virtual public bool GetWheelHorizontal() {
 289          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_wheel_horizontal_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 290         Eina.Error.RaiseIfUnhandledException();
 291         return _ret_var;
 292  }
 293     /// <summary>Direction of the wheel, usually vertical.</summary>
 294     /// <param name="horizontal">If <c>true</c> this was a horizontal wheel.</param>
 295     virtual public void SetWheelHorizontal(bool horizontal) {
 296                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_wheel_horizontal_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),horizontal);
 297         Eina.Error.RaiseIfUnhandledException();
 298                          }
 299     /// <summary>Delta movement of the wheel in discrete steps.</summary>
 300     /// <returns>Wheel movement delta</returns>
 301     virtual public int GetWheelDelta() {
 302          var _ret_var = Efl.Input.Pointer.NativeMethods.efl_input_pointer_wheel_delta_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 303         Eina.Error.RaiseIfUnhandledException();
 304         return _ret_var;
 305  }
 306     /// <summary>Delta movement of the wheel in discrete steps.</summary>
 307     /// <param name="dist">Wheel movement delta</param>
 308     virtual public void SetWheelDelta(int dist) {
 309                                  Efl.Input.Pointer.NativeMethods.efl_input_pointer_wheel_delta_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dist);
 310         Eina.Error.RaiseIfUnhandledException();
 311                          }
 312     /// <summary>Creates a carbon copy of this object and returns it.
 313     /// The newly created object will have no event handlers or anything of the sort.</summary>
 314     /// <returns>Returned carbon copy</returns>
 315     virtual public Efl.IDuplicate Duplicate() {
 316          var _ret_var = Efl.IDuplicateConcrete.NativeMethods.efl_duplicate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 317         Eina.Error.RaiseIfUnhandledException();
 318         return _ret_var;
 319  }
 320     /// <summary>The time at which an event was generated.
 321     /// 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>
 322     /// <returns>Time in milliseconds when the event happened.</returns>
 323     virtual public double GetTimestamp() {
 324          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));
 325         Eina.Error.RaiseIfUnhandledException();
 326         return _ret_var;
 327  }
 328     /// <summary>Call this when generating events manually.</summary>
 329     /// <param name="ms">Time in milliseconds when the event happened.</param>
 330     virtual public void SetTimestamp(double ms) {
 331                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_timestamp_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ms);
 332         Eina.Error.RaiseIfUnhandledException();
 333                          }
 334     /// <summary>Input device that originated this event.</summary>
 335     /// <returns>Input device origin</returns>
 336     virtual public Efl.Input.Device GetDevice() {
 337          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));
 338         Eina.Error.RaiseIfUnhandledException();
 339         return _ret_var;
 340  }
 341     /// <summary>Input device that originated this event.</summary>
 342     /// <param name="dev">Input device origin</param>
 343     virtual public void SetDevice(Efl.Input.Device dev) {
 344                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_device_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dev);
 345         Eina.Error.RaiseIfUnhandledException();
 346                          }
 347     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 348     /// <returns>Input event flags</returns>
 349     virtual public Efl.Input.Flags GetEventFlags() {
 350          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));
 351         Eina.Error.RaiseIfUnhandledException();
 352         return _ret_var;
 353  }
 354     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 355     /// <param name="flags">Input event flags</param>
 356     virtual public void SetEventFlags(Efl.Input.Flags flags) {
 357                                  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);
 358         Eina.Error.RaiseIfUnhandledException();
 359                          }
 360     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 361     /// <returns><c>true</c> if the event is on hold, <c>false</c> otherwise</returns>
 362     virtual public bool GetProcessed() {
 363          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));
 364         Eina.Error.RaiseIfUnhandledException();
 365         return _ret_var;
 366  }
 367     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 368     /// <param name="val"><c>true</c> if the event is on hold, <c>false</c> otherwise</param>
 369     virtual public void SetProcessed(bool val) {
 370                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_processed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
 371         Eina.Error.RaiseIfUnhandledException();
 372                          }
 373     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 374     /// <returns><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</returns>
 375     virtual public bool GetScrolling() {
 376          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));
 377         Eina.Error.RaiseIfUnhandledException();
 378         return _ret_var;
 379  }
 380     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 381     /// <param name="val"><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</param>
 382     virtual public void SetScrolling(bool val) {
 383                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_scrolling_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
 384         Eina.Error.RaiseIfUnhandledException();
 385                          }
 386     /// <summary><c>true</c> if the event was fake, not triggered by real hardware.</summary>
 387     /// <returns><c>true</c> if the event was not from real hardware, <c>false</c> otherwise</returns>
 388     virtual public bool GetFake() {
 389          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));
 390         Eina.Error.RaiseIfUnhandledException();
 391         return _ret_var;
 392  }
 393     /// <summary>Resets the internal data to 0 or default values.</summary>
 394     virtual public void Reset() {
 395          Efl.Input.IEventConcrete.NativeMethods.efl_input_reset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 396         Eina.Error.RaiseIfUnhandledException();
 397          }
 398     /// <summary>Indicates whether a key modifier is on, such as Ctrl, Shift, ...
 399     /// (Since EFL 1.22)</summary>
 400     /// <param name="mod">The modifier key to test.</param>
 401     /// <param name="seat">The seat device, may be <c>null</c></param>
 402     /// <returns><c>true</c> if the key modifier is pressed.</returns>
 403     virtual public bool GetModifierEnabled(Efl.Input.Modifier mod, Efl.Input.Device seat) {
 404                                                          var _ret_var = Efl.Input.IStateConcrete.NativeMethods.efl_input_modifier_enabled_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),mod, seat);
 405         Eina.Error.RaiseIfUnhandledException();
 406                                         return _ret_var;
 407  }
 408     /// <summary>Indicates whether a key lock is on, such as NumLock, CapsLock, ...
 409     /// (Since EFL 1.22)</summary>
 410     /// <param name="kw_lock">The lock key to test.</param>
 411     /// <param name="seat">The seat device, may be <c>null</c></param>
 412     /// <returns><c>true</c> if the key lock is on.</returns>
 413     virtual public bool GetLockEnabled(Efl.Input.Lock kw_lock, Efl.Input.Device seat) {
 414                                                          var _ret_var = Efl.Input.IStateConcrete.NativeMethods.efl_input_lock_enabled_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),kw_lock, seat);
 415         Eina.Error.RaiseIfUnhandledException();
 416                                         return _ret_var;
 417  }
 418     /// <summary>The action represented by this event.</summary>
 419 /// <value>Event action</value>
 420     public Efl.Pointer.Action Action {
 421         get { return GetAction(); }
 422         set { SetAction(value); }
 423     }
 424     /// <summary>The mouse button that triggered the event.
 425 /// Valid if and only if <see cref="Efl.Input.Pointer.GetValueHas"/>(<c>button</c>) is <c>true</c>.</summary>
 426 /// <value>1 to 32, 0 if not a button event.</value>
 427     public int Button {
 428         get { return GetButton(); }
 429         set { SetButton(value); }
 430     }
 431     /// <summary>Position where the event happened, relative to the window.
 432 /// See <see cref="Efl.Input.Pointer.PrecisePosition"/> for floating point precision (subpixel location).</summary>
 433 /// <value>The position of the event, in pixels.</value>
 434     public Eina.Position2D Position {
 435         get { return GetPosition(); }
 436         set { SetPosition(value); }
 437     }
 438     /// <summary>Position where the event happened, relative to the window.
 439 /// This position is in floating point values, for more precise coordinates, in subpixels. Note that many input devices are unable to give better precision than a single pixel, so this may be equal to <see cref="Efl.Input.Pointer.Position"/>.
 440 ///
 441 /// See also <see cref="Efl.Input.Pointer.Position"/>.</summary>
 442 /// <value>The position of the event, in pixels.</value>
 443     public Eina.Vector2 PrecisePosition {
 444         get { return GetPrecisePosition(); }
 445         set { SetPrecisePosition(value); }
 446     }
 447     /// <summary>Position of the previous event, valid for move events.
 448 /// Relative to the window. May be equal to <see cref="Efl.Input.Pointer.Position"/> (by default).
 449 ///
 450 /// This position, in integers, is an approximation of <see cref="Efl.Input.Pointer.GetValue"/>(<c>previous_x</c>), <see cref="Efl.Input.Pointer.GetValue"/>(<c>previous_y</c>). Use <see cref="Efl.Input.Pointer.PreviousPosition"/> if you need simple pixel positions, but prefer the generic interface if you need precise coordinates.</summary>
 451 /// <value>The position of the event, in pixels.</value>
 452     public Eina.Position2D PreviousPosition {
 453         get { return GetPreviousPosition(); }
 454         set { SetPreviousPosition(value); }
 455     }
 456     /// <summary>ID of the tool (eg. pen) that triggered this event.</summary>
 457 /// <value>Tool ID</value>
 458     public int Tool {
 459         get { return GetTool(); }
 460         set { SetTool(value); }
 461     }
 462     /// <summary>The object where this event first originated, in case of propagation or repetition of the event.</summary>
 463 /// <value>Source object: <see cref="Efl.Gfx.IEntity"/></value>
 464     public Efl.Object Source {
 465         get { return GetSource(); }
 466         set { SetSource(value); }
 467     }
 468     /// <summary>Double or triple click information.</summary>
 469 /// <value>Button information flags</value>
 470     public Efl.Pointer.Flags ButtonFlags {
 471         get { return GetButtonFlags(); }
 472         set { SetButtonFlags(value); }
 473     }
 474     /// <summary><c>true</c> if <see cref="Efl.Input.Pointer.ButtonFlags"/> indicates a double click (2nd press).
 475 /// This is just a helper function around <see cref="Efl.Input.Pointer.ButtonFlags"/>.</summary>
 476 /// <value><c>true</c> if the button press was a double click, <c>false</c> otherwise</value>
 477     public bool DoubleClick {
 478         get { return GetDoubleClick(); }
 479         set { SetDoubleClick(value); }
 480     }
 481     /// <summary><c>true</c> if <see cref="Efl.Input.Pointer.ButtonFlags"/> indicates a triple click (3rd press).
 482 /// This is just a helper function around <see cref="Efl.Input.Pointer.ButtonFlags"/>.</summary>
 483 /// <value><c>true</c> if the button press was a triple click, <c>false</c> otherwise</value>
 484     public bool TripleClick {
 485         get { return GetTripleClick(); }
 486         set { SetTripleClick(value); }
 487     }
 488     /// <summary>Direction of the wheel, usually vertical.</summary>
 489 /// <value>If <c>true</c> this was a horizontal wheel.</value>
 490     public bool WheelHorizontal {
 491         get { return GetWheelHorizontal(); }
 492         set { SetWheelHorizontal(value); }
 493     }
 494     /// <summary>Delta movement of the wheel in discrete steps.</summary>
 495 /// <value>Wheel movement delta</value>
 496     public int WheelDelta {
 497         get { return GetWheelDelta(); }
 498         set { SetWheelDelta(value); }
 499     }
 500     /// <summary>The time at which an event was generated.
 501 /// 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>
 502 /// <value>Time in milliseconds when the event happened.</value>
 503     public double Timestamp {
 504         get { return GetTimestamp(); }
 505         set { SetTimestamp(value); }
 506     }
 507     /// <summary>Input device that originated this event.</summary>
 508 /// <value>Input device origin</value>
 509     public Efl.Input.Device Device {
 510         get { return GetDevice(); }
 511         set { SetDevice(value); }
 512     }
 513     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 514 /// <value>Input event flags</value>
 515     public Efl.Input.Flags EventFlags {
 516         get { return GetEventFlags(); }
 517         set { SetEventFlags(value); }
 518     }
 519     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 520 /// <value><c>true</c> if the event is on hold, <c>false</c> otherwise</value>
 521     public bool Processed {
 522         get { return GetProcessed(); }
 523         set { SetProcessed(value); }
 524     }
 525     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 526 /// <value><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</value>
 527     public bool Scrolling {
 528         get { return GetScrolling(); }
 529         set { SetScrolling(value); }
 530     }
 531     /// <summary><c>true</c> if the event was fake, not triggered by real hardware.</summary>
 532 /// <value><c>true</c> if the event was not from real hardware, <c>false</c> otherwise</value>
 533     public bool Fake {
 534         get { return GetFake(); }
 535     }
 536     private static IntPtr GetEflClassStatic()
 537     {
 538         return Efl.Input.Pointer.efl_input_pointer_class_get();
 539     }
 540     /// <summary>Wrapper for native methods and virtual method delegates.
 541     /// For internal use by generated code only.</summary>
 542     public new class NativeMethods : Efl.Object.NativeMethods
 543     {
 544         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 545         /// <summary>Gets the list of Eo operations to override.</summary>
 546         /// <returns>The list of Eo operations to be overload.</returns>
 547         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 548         {
 549             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 550             var methods = Efl.Eo.Globals.GetUserMethods(type);
 551
 552             if (efl_input_pointer_action_get_static_delegate == null)
 553             {
 554                 efl_input_pointer_action_get_static_delegate = new efl_input_pointer_action_get_delegate(action_get);
 555             }
 556
 557             if (methods.FirstOrDefault(m => m.Name == "GetAction") != null)
 558             {
 559                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_action_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_action_get_static_delegate) });
 560             }
 561
 562             if (efl_input_pointer_action_set_static_delegate == null)
 563             {
 564                 efl_input_pointer_action_set_static_delegate = new efl_input_pointer_action_set_delegate(action_set);
 565             }
 566
 567             if (methods.FirstOrDefault(m => m.Name == "SetAction") != null)
 568             {
 569                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_action_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_action_set_static_delegate) });
 570             }
 571
 572             if (efl_input_pointer_value_has_get_static_delegate == null)
 573             {
 574                 efl_input_pointer_value_has_get_static_delegate = new efl_input_pointer_value_has_get_delegate(value_has_get);
 575             }
 576
 577             if (methods.FirstOrDefault(m => m.Name == "GetValueHas") != null)
 578             {
 579                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_value_has_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_value_has_get_static_delegate) });
 580             }
 581
 582             if (efl_input_pointer_value_get_static_delegate == null)
 583             {
 584                 efl_input_pointer_value_get_static_delegate = new efl_input_pointer_value_get_delegate(value_get);
 585             }
 586
 587             if (methods.FirstOrDefault(m => m.Name == "GetValue") != null)
 588             {
 589                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_value_get_static_delegate) });
 590             }
 591
 592             if (efl_input_pointer_value_set_static_delegate == null)
 593             {
 594                 efl_input_pointer_value_set_static_delegate = new efl_input_pointer_value_set_delegate(value_set);
 595             }
 596
 597             if (methods.FirstOrDefault(m => m.Name == "SetValue") != null)
 598             {
 599                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_value_set_static_delegate) });
 600             }
 601
 602             if (efl_input_pointer_button_get_static_delegate == null)
 603             {
 604                 efl_input_pointer_button_get_static_delegate = new efl_input_pointer_button_get_delegate(button_get);
 605             }
 606
 607             if (methods.FirstOrDefault(m => m.Name == "GetButton") != null)
 608             {
 609                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_button_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_button_get_static_delegate) });
 610             }
 611
 612             if (efl_input_pointer_button_set_static_delegate == null)
 613             {
 614                 efl_input_pointer_button_set_static_delegate = new efl_input_pointer_button_set_delegate(button_set);
 615             }
 616
 617             if (methods.FirstOrDefault(m => m.Name == "SetButton") != null)
 618             {
 619                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_button_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_button_set_static_delegate) });
 620             }
 621
 622             if (efl_input_pointer_button_pressed_get_static_delegate == null)
 623             {
 624                 efl_input_pointer_button_pressed_get_static_delegate = new efl_input_pointer_button_pressed_get_delegate(button_pressed_get);
 625             }
 626
 627             if (methods.FirstOrDefault(m => m.Name == "GetButtonPressed") != null)
 628             {
 629                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_button_pressed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_button_pressed_get_static_delegate) });
 630             }
 631
 632             if (efl_input_pointer_button_pressed_set_static_delegate == null)
 633             {
 634                 efl_input_pointer_button_pressed_set_static_delegate = new efl_input_pointer_button_pressed_set_delegate(button_pressed_set);
 635             }
 636
 637             if (methods.FirstOrDefault(m => m.Name == "SetButtonPressed") != null)
 638             {
 639                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_button_pressed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_button_pressed_set_static_delegate) });
 640             }
 641
 642             if (efl_input_pointer_position_get_static_delegate == null)
 643             {
 644                 efl_input_pointer_position_get_static_delegate = new efl_input_pointer_position_get_delegate(position_get);
 645             }
 646
 647             if (methods.FirstOrDefault(m => m.Name == "GetPosition") != null)
 648             {
 649                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_position_get_static_delegate) });
 650             }
 651
 652             if (efl_input_pointer_position_set_static_delegate == null)
 653             {
 654                 efl_input_pointer_position_set_static_delegate = new efl_input_pointer_position_set_delegate(position_set);
 655             }
 656
 657             if (methods.FirstOrDefault(m => m.Name == "SetPosition") != null)
 658             {
 659                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_position_set_static_delegate) });
 660             }
 661
 662             if (efl_input_pointer_precise_position_get_static_delegate == null)
 663             {
 664                 efl_input_pointer_precise_position_get_static_delegate = new efl_input_pointer_precise_position_get_delegate(precise_position_get);
 665             }
 666
 667             if (methods.FirstOrDefault(m => m.Name == "GetPrecisePosition") != null)
 668             {
 669                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_precise_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_precise_position_get_static_delegate) });
 670             }
 671
 672             if (efl_input_pointer_precise_position_set_static_delegate == null)
 673             {
 674                 efl_input_pointer_precise_position_set_static_delegate = new efl_input_pointer_precise_position_set_delegate(precise_position_set);
 675             }
 676
 677             if (methods.FirstOrDefault(m => m.Name == "SetPrecisePosition") != null)
 678             {
 679                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_precise_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_precise_position_set_static_delegate) });
 680             }
 681
 682             if (efl_input_pointer_previous_position_get_static_delegate == null)
 683             {
 684                 efl_input_pointer_previous_position_get_static_delegate = new efl_input_pointer_previous_position_get_delegate(previous_position_get);
 685             }
 686
 687             if (methods.FirstOrDefault(m => m.Name == "GetPreviousPosition") != null)
 688             {
 689                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_previous_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_previous_position_get_static_delegate) });
 690             }
 691
 692             if (efl_input_pointer_previous_position_set_static_delegate == null)
 693             {
 694                 efl_input_pointer_previous_position_set_static_delegate = new efl_input_pointer_previous_position_set_delegate(previous_position_set);
 695             }
 696
 697             if (methods.FirstOrDefault(m => m.Name == "SetPreviousPosition") != null)
 698             {
 699                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_previous_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_previous_position_set_static_delegate) });
 700             }
 701
 702             if (efl_input_pointer_tool_get_static_delegate == null)
 703             {
 704                 efl_input_pointer_tool_get_static_delegate = new efl_input_pointer_tool_get_delegate(tool_get);
 705             }
 706
 707             if (methods.FirstOrDefault(m => m.Name == "GetTool") != null)
 708             {
 709                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_tool_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_tool_get_static_delegate) });
 710             }
 711
 712             if (efl_input_pointer_tool_set_static_delegate == null)
 713             {
 714                 efl_input_pointer_tool_set_static_delegate = new efl_input_pointer_tool_set_delegate(tool_set);
 715             }
 716
 717             if (methods.FirstOrDefault(m => m.Name == "SetTool") != null)
 718             {
 719                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_tool_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_tool_set_static_delegate) });
 720             }
 721
 722             if (efl_input_pointer_source_get_static_delegate == null)
 723             {
 724                 efl_input_pointer_source_get_static_delegate = new efl_input_pointer_source_get_delegate(source_get);
 725             }
 726
 727             if (methods.FirstOrDefault(m => m.Name == "GetSource") != null)
 728             {
 729                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_source_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_source_get_static_delegate) });
 730             }
 731
 732             if (efl_input_pointer_source_set_static_delegate == null)
 733             {
 734                 efl_input_pointer_source_set_static_delegate = new efl_input_pointer_source_set_delegate(source_set);
 735             }
 736
 737             if (methods.FirstOrDefault(m => m.Name == "SetSource") != null)
 738             {
 739                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_source_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_source_set_static_delegate) });
 740             }
 741
 742             if (efl_input_pointer_button_flags_get_static_delegate == null)
 743             {
 744                 efl_input_pointer_button_flags_get_static_delegate = new efl_input_pointer_button_flags_get_delegate(button_flags_get);
 745             }
 746
 747             if (methods.FirstOrDefault(m => m.Name == "GetButtonFlags") != null)
 748             {
 749                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_button_flags_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_button_flags_get_static_delegate) });
 750             }
 751
 752             if (efl_input_pointer_button_flags_set_static_delegate == null)
 753             {
 754                 efl_input_pointer_button_flags_set_static_delegate = new efl_input_pointer_button_flags_set_delegate(button_flags_set);
 755             }
 756
 757             if (methods.FirstOrDefault(m => m.Name == "SetButtonFlags") != null)
 758             {
 759                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_button_flags_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_button_flags_set_static_delegate) });
 760             }
 761
 762             if (efl_input_pointer_double_click_get_static_delegate == null)
 763             {
 764                 efl_input_pointer_double_click_get_static_delegate = new efl_input_pointer_double_click_get_delegate(double_click_get);
 765             }
 766
 767             if (methods.FirstOrDefault(m => m.Name == "GetDoubleClick") != null)
 768             {
 769                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_double_click_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_double_click_get_static_delegate) });
 770             }
 771
 772             if (efl_input_pointer_double_click_set_static_delegate == null)
 773             {
 774                 efl_input_pointer_double_click_set_static_delegate = new efl_input_pointer_double_click_set_delegate(double_click_set);
 775             }
 776
 777             if (methods.FirstOrDefault(m => m.Name == "SetDoubleClick") != null)
 778             {
 779                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_double_click_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_double_click_set_static_delegate) });
 780             }
 781
 782             if (efl_input_pointer_triple_click_get_static_delegate == null)
 783             {
 784                 efl_input_pointer_triple_click_get_static_delegate = new efl_input_pointer_triple_click_get_delegate(triple_click_get);
 785             }
 786
 787             if (methods.FirstOrDefault(m => m.Name == "GetTripleClick") != null)
 788             {
 789                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_triple_click_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_triple_click_get_static_delegate) });
 790             }
 791
 792             if (efl_input_pointer_triple_click_set_static_delegate == null)
 793             {
 794                 efl_input_pointer_triple_click_set_static_delegate = new efl_input_pointer_triple_click_set_delegate(triple_click_set);
 795             }
 796
 797             if (methods.FirstOrDefault(m => m.Name == "SetTripleClick") != null)
 798             {
 799                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_triple_click_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_triple_click_set_static_delegate) });
 800             }
 801
 802             if (efl_input_pointer_wheel_horizontal_get_static_delegate == null)
 803             {
 804                 efl_input_pointer_wheel_horizontal_get_static_delegate = new efl_input_pointer_wheel_horizontal_get_delegate(wheel_horizontal_get);
 805             }
 806
 807             if (methods.FirstOrDefault(m => m.Name == "GetWheelHorizontal") != null)
 808             {
 809                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_wheel_horizontal_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_wheel_horizontal_get_static_delegate) });
 810             }
 811
 812             if (efl_input_pointer_wheel_horizontal_set_static_delegate == null)
 813             {
 814                 efl_input_pointer_wheel_horizontal_set_static_delegate = new efl_input_pointer_wheel_horizontal_set_delegate(wheel_horizontal_set);
 815             }
 816
 817             if (methods.FirstOrDefault(m => m.Name == "SetWheelHorizontal") != null)
 818             {
 819                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_wheel_horizontal_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_wheel_horizontal_set_static_delegate) });
 820             }
 821
 822             if (efl_input_pointer_wheel_delta_get_static_delegate == null)
 823             {
 824                 efl_input_pointer_wheel_delta_get_static_delegate = new efl_input_pointer_wheel_delta_get_delegate(wheel_delta_get);
 825             }
 826
 827             if (methods.FirstOrDefault(m => m.Name == "GetWheelDelta") != null)
 828             {
 829                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_wheel_delta_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_wheel_delta_get_static_delegate) });
 830             }
 831
 832             if (efl_input_pointer_wheel_delta_set_static_delegate == null)
 833             {
 834                 efl_input_pointer_wheel_delta_set_static_delegate = new efl_input_pointer_wheel_delta_set_delegate(wheel_delta_set);
 835             }
 836
 837             if (methods.FirstOrDefault(m => m.Name == "SetWheelDelta") != null)
 838             {
 839                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_pointer_wheel_delta_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_pointer_wheel_delta_set_static_delegate) });
 840             }
 841
 842             if (efl_duplicate_static_delegate == null)
 843             {
 844                 efl_duplicate_static_delegate = new efl_duplicate_delegate(duplicate);
 845             }
 846
 847             if (methods.FirstOrDefault(m => m.Name == "Duplicate") != null)
 848             {
 849                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_duplicate"), func = Marshal.GetFunctionPointerForDelegate(efl_duplicate_static_delegate) });
 850             }
 851
 852             if (efl_input_timestamp_get_static_delegate == null)
 853             {
 854                 efl_input_timestamp_get_static_delegate = new efl_input_timestamp_get_delegate(timestamp_get);
 855             }
 856
 857             if (methods.FirstOrDefault(m => m.Name == "GetTimestamp") != null)
 858             {
 859                 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) });
 860             }
 861
 862             if (efl_input_timestamp_set_static_delegate == null)
 863             {
 864                 efl_input_timestamp_set_static_delegate = new efl_input_timestamp_set_delegate(timestamp_set);
 865             }
 866
 867             if (methods.FirstOrDefault(m => m.Name == "SetTimestamp") != null)
 868             {
 869                 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) });
 870             }
 871
 872             if (efl_input_device_get_static_delegate == null)
 873             {
 874                 efl_input_device_get_static_delegate = new efl_input_device_get_delegate(device_get);
 875             }
 876
 877             if (methods.FirstOrDefault(m => m.Name == "GetDevice") != null)
 878             {
 879                 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) });
 880             }
 881
 882             if (efl_input_device_set_static_delegate == null)
 883             {
 884                 efl_input_device_set_static_delegate = new efl_input_device_set_delegate(device_set);
 885             }
 886
 887             if (methods.FirstOrDefault(m => m.Name == "SetDevice") != null)
 888             {
 889                 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) });
 890             }
 891
 892             if (efl_input_event_flags_get_static_delegate == null)
 893             {
 894                 efl_input_event_flags_get_static_delegate = new efl_input_event_flags_get_delegate(event_flags_get);
 895             }
 896
 897             if (methods.FirstOrDefault(m => m.Name == "GetEventFlags") != null)
 898             {
 899                 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) });
 900             }
 901
 902             if (efl_input_event_flags_set_static_delegate == null)
 903             {
 904                 efl_input_event_flags_set_static_delegate = new efl_input_event_flags_set_delegate(event_flags_set);
 905             }
 906
 907             if (methods.FirstOrDefault(m => m.Name == "SetEventFlags") != null)
 908             {
 909                 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) });
 910             }
 911
 912             if (efl_input_processed_get_static_delegate == null)
 913             {
 914                 efl_input_processed_get_static_delegate = new efl_input_processed_get_delegate(processed_get);
 915             }
 916
 917             if (methods.FirstOrDefault(m => m.Name == "GetProcessed") != null)
 918             {
 919                 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) });
 920             }
 921
 922             if (efl_input_processed_set_static_delegate == null)
 923             {
 924                 efl_input_processed_set_static_delegate = new efl_input_processed_set_delegate(processed_set);
 925             }
 926
 927             if (methods.FirstOrDefault(m => m.Name == "SetProcessed") != null)
 928             {
 929                 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) });
 930             }
 931
 932             if (efl_input_scrolling_get_static_delegate == null)
 933             {
 934                 efl_input_scrolling_get_static_delegate = new efl_input_scrolling_get_delegate(scrolling_get);
 935             }
 936
 937             if (methods.FirstOrDefault(m => m.Name == "GetScrolling") != null)
 938             {
 939                 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) });
 940             }
 941
 942             if (efl_input_scrolling_set_static_delegate == null)
 943             {
 944                 efl_input_scrolling_set_static_delegate = new efl_input_scrolling_set_delegate(scrolling_set);
 945             }
 946
 947             if (methods.FirstOrDefault(m => m.Name == "SetScrolling") != null)
 948             {
 949                 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) });
 950             }
 951
 952             if (efl_input_fake_get_static_delegate == null)
 953             {
 954                 efl_input_fake_get_static_delegate = new efl_input_fake_get_delegate(fake_get);
 955             }
 956
 957             if (methods.FirstOrDefault(m => m.Name == "GetFake") != null)
 958             {
 959                 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) });
 960             }
 961
 962             if (efl_input_reset_static_delegate == null)
 963             {
 964                 efl_input_reset_static_delegate = new efl_input_reset_delegate(reset);
 965             }
 966
 967             if (methods.FirstOrDefault(m => m.Name == "Reset") != null)
 968             {
 969                 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) });
 970             }
 971
 972             if (efl_input_modifier_enabled_get_static_delegate == null)
 973             {
 974                 efl_input_modifier_enabled_get_static_delegate = new efl_input_modifier_enabled_get_delegate(modifier_enabled_get);
 975             }
 976
 977             if (methods.FirstOrDefault(m => m.Name == "GetModifierEnabled") != null)
 978             {
 979                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_modifier_enabled_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_modifier_enabled_get_static_delegate) });
 980             }
 981
 982             if (efl_input_lock_enabled_get_static_delegate == null)
 983             {
 984                 efl_input_lock_enabled_get_static_delegate = new efl_input_lock_enabled_get_delegate(lock_enabled_get);
 985             }
 986
 987             if (methods.FirstOrDefault(m => m.Name == "GetLockEnabled") != null)
 988             {
 989                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_lock_enabled_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_lock_enabled_get_static_delegate) });
 990             }
 991
 992             descs.AddRange(base.GetEoOps(type));
 993             return descs;
 994         }
 995         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 996         /// <returns>The native class pointer.</returns>
 997         public override IntPtr GetEflClass()
 998         {
 999             return Efl.Input.Pointer.efl_input_pointer_class_get();
1000         }
1001
1002         #pragma warning disable CA1707, SA1300, SA1600
1003
1004
1005         private delegate Efl.Pointer.Action efl_input_pointer_action_get_delegate(System.IntPtr obj, System.IntPtr pd);
1006
1007
1008         public delegate Efl.Pointer.Action efl_input_pointer_action_get_api_delegate(System.IntPtr obj);
1009
1010         public static Efl.Eo.FunctionWrapper<efl_input_pointer_action_get_api_delegate> efl_input_pointer_action_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_action_get_api_delegate>(Module, "efl_input_pointer_action_get");
1011
1012         private static Efl.Pointer.Action action_get(System.IntPtr obj, System.IntPtr pd)
1013         {
1014             Eina.Log.Debug("function efl_input_pointer_action_get was called");
1015             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1016             if (wrapper != null)
1017             {
1018             Efl.Pointer.Action _ret_var = default(Efl.Pointer.Action);
1019                 try
1020                 {
1021                     _ret_var = ((Pointer)wrapper).GetAction();
1022                 }
1023                 catch (Exception e)
1024                 {
1025                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1026                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1027                 }
1028
1029         return _ret_var;
1030
1031             }
1032             else
1033             {
1034                 return efl_input_pointer_action_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1035             }
1036         }
1037
1038         private static efl_input_pointer_action_get_delegate efl_input_pointer_action_get_static_delegate;
1039
1040
1041         private delegate void efl_input_pointer_action_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Pointer.Action act);
1042
1043
1044         public delegate void efl_input_pointer_action_set_api_delegate(System.IntPtr obj,  Efl.Pointer.Action act);
1045
1046         public static Efl.Eo.FunctionWrapper<efl_input_pointer_action_set_api_delegate> efl_input_pointer_action_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_action_set_api_delegate>(Module, "efl_input_pointer_action_set");
1047
1048         private static void action_set(System.IntPtr obj, System.IntPtr pd, Efl.Pointer.Action act)
1049         {
1050             Eina.Log.Debug("function efl_input_pointer_action_set was called");
1051             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1052             if (wrapper != null)
1053             {
1054
1055                 try
1056                 {
1057                     ((Pointer)wrapper).SetAction(act);
1058                 }
1059                 catch (Exception e)
1060                 {
1061                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1062                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1063                 }
1064
1065
1066             }
1067             else
1068             {
1069                 efl_input_pointer_action_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), act);
1070             }
1071         }
1072
1073         private static efl_input_pointer_action_set_delegate efl_input_pointer_action_set_static_delegate;
1074
1075         [return: MarshalAs(UnmanagedType.U1)]
1076         private delegate bool efl_input_pointer_value_has_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Value key);
1077
1078         [return: MarshalAs(UnmanagedType.U1)]
1079         public delegate bool efl_input_pointer_value_has_get_api_delegate(System.IntPtr obj,  Efl.Input.Value key);
1080
1081         public static Efl.Eo.FunctionWrapper<efl_input_pointer_value_has_get_api_delegate> efl_input_pointer_value_has_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_value_has_get_api_delegate>(Module, "efl_input_pointer_value_has_get");
1082
1083         private static bool value_has_get(System.IntPtr obj, System.IntPtr pd, Efl.Input.Value key)
1084         {
1085             Eina.Log.Debug("function efl_input_pointer_value_has_get was called");
1086             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1087             if (wrapper != null)
1088             {
1089                                     bool _ret_var = default(bool);
1090                 try
1091                 {
1092                     _ret_var = ((Pointer)wrapper).GetValueHas(key);
1093                 }
1094                 catch (Exception e)
1095                 {
1096                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1097                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1098                 }
1099
1100                         return _ret_var;
1101
1102             }
1103             else
1104             {
1105                 return efl_input_pointer_value_has_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1106             }
1107         }
1108
1109         private static efl_input_pointer_value_has_get_delegate efl_input_pointer_value_has_get_static_delegate;
1110
1111
1112         private delegate double efl_input_pointer_value_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Value key);
1113
1114
1115         public delegate double efl_input_pointer_value_get_api_delegate(System.IntPtr obj,  Efl.Input.Value key);
1116
1117         public static Efl.Eo.FunctionWrapper<efl_input_pointer_value_get_api_delegate> efl_input_pointer_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_value_get_api_delegate>(Module, "efl_input_pointer_value_get");
1118
1119         private static double value_get(System.IntPtr obj, System.IntPtr pd, Efl.Input.Value key)
1120         {
1121             Eina.Log.Debug("function efl_input_pointer_value_get was called");
1122             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1123             if (wrapper != null)
1124             {
1125                                     double _ret_var = default(double);
1126                 try
1127                 {
1128                     _ret_var = ((Pointer)wrapper).GetValue(key);
1129                 }
1130                 catch (Exception e)
1131                 {
1132                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1133                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1134                 }
1135
1136                         return _ret_var;
1137
1138             }
1139             else
1140             {
1141                 return efl_input_pointer_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1142             }
1143         }
1144
1145         private static efl_input_pointer_value_get_delegate efl_input_pointer_value_get_static_delegate;
1146
1147         [return: MarshalAs(UnmanagedType.U1)]
1148         private delegate bool efl_input_pointer_value_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Value key,  double val);
1149
1150         [return: MarshalAs(UnmanagedType.U1)]
1151         public delegate bool efl_input_pointer_value_set_api_delegate(System.IntPtr obj,  Efl.Input.Value key,  double val);
1152
1153         public static Efl.Eo.FunctionWrapper<efl_input_pointer_value_set_api_delegate> efl_input_pointer_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_value_set_api_delegate>(Module, "efl_input_pointer_value_set");
1154
1155         private static bool value_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Value key, double val)
1156         {
1157             Eina.Log.Debug("function efl_input_pointer_value_set was called");
1158             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1159             if (wrapper != null)
1160             {
1161                                                             bool _ret_var = default(bool);
1162                 try
1163                 {
1164                     _ret_var = ((Pointer)wrapper).SetValue(key, val);
1165                 }
1166                 catch (Exception e)
1167                 {
1168                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1169                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1170                 }
1171
1172                                         return _ret_var;
1173
1174             }
1175             else
1176             {
1177                 return efl_input_pointer_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key, val);
1178             }
1179         }
1180
1181         private static efl_input_pointer_value_set_delegate efl_input_pointer_value_set_static_delegate;
1182
1183
1184         private delegate int efl_input_pointer_button_get_delegate(System.IntPtr obj, System.IntPtr pd);
1185
1186
1187         public delegate int efl_input_pointer_button_get_api_delegate(System.IntPtr obj);
1188
1189         public static Efl.Eo.FunctionWrapper<efl_input_pointer_button_get_api_delegate> efl_input_pointer_button_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_button_get_api_delegate>(Module, "efl_input_pointer_button_get");
1190
1191         private static int button_get(System.IntPtr obj, System.IntPtr pd)
1192         {
1193             Eina.Log.Debug("function efl_input_pointer_button_get was called");
1194             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1195             if (wrapper != null)
1196             {
1197             int _ret_var = default(int);
1198                 try
1199                 {
1200                     _ret_var = ((Pointer)wrapper).GetButton();
1201                 }
1202                 catch (Exception e)
1203                 {
1204                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1205                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1206                 }
1207
1208         return _ret_var;
1209
1210             }
1211             else
1212             {
1213                 return efl_input_pointer_button_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1214             }
1215         }
1216
1217         private static efl_input_pointer_button_get_delegate efl_input_pointer_button_get_static_delegate;
1218
1219
1220         private delegate void efl_input_pointer_button_set_delegate(System.IntPtr obj, System.IntPtr pd,  int but);
1221
1222
1223         public delegate void efl_input_pointer_button_set_api_delegate(System.IntPtr obj,  int but);
1224
1225         public static Efl.Eo.FunctionWrapper<efl_input_pointer_button_set_api_delegate> efl_input_pointer_button_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_button_set_api_delegate>(Module, "efl_input_pointer_button_set");
1226
1227         private static void button_set(System.IntPtr obj, System.IntPtr pd, int but)
1228         {
1229             Eina.Log.Debug("function efl_input_pointer_button_set was called");
1230             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1231             if (wrapper != null)
1232             {
1233
1234                 try
1235                 {
1236                     ((Pointer)wrapper).SetButton(but);
1237                 }
1238                 catch (Exception e)
1239                 {
1240                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1241                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1242                 }
1243
1244
1245             }
1246             else
1247             {
1248                 efl_input_pointer_button_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), but);
1249             }
1250         }
1251
1252         private static efl_input_pointer_button_set_delegate efl_input_pointer_button_set_static_delegate;
1253
1254         [return: MarshalAs(UnmanagedType.U1)]
1255         private delegate bool efl_input_pointer_button_pressed_get_delegate(System.IntPtr obj, System.IntPtr pd,  int button);
1256
1257         [return: MarshalAs(UnmanagedType.U1)]
1258         public delegate bool efl_input_pointer_button_pressed_get_api_delegate(System.IntPtr obj,  int button);
1259
1260         public static Efl.Eo.FunctionWrapper<efl_input_pointer_button_pressed_get_api_delegate> efl_input_pointer_button_pressed_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_button_pressed_get_api_delegate>(Module, "efl_input_pointer_button_pressed_get");
1261
1262         private static bool button_pressed_get(System.IntPtr obj, System.IntPtr pd, int button)
1263         {
1264             Eina.Log.Debug("function efl_input_pointer_button_pressed_get was called");
1265             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1266             if (wrapper != null)
1267             {
1268                                     bool _ret_var = default(bool);
1269                 try
1270                 {
1271                     _ret_var = ((Pointer)wrapper).GetButtonPressed(button);
1272                 }
1273                 catch (Exception e)
1274                 {
1275                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1276                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1277                 }
1278
1279                         return _ret_var;
1280
1281             }
1282             else
1283             {
1284                 return efl_input_pointer_button_pressed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button);
1285             }
1286         }
1287
1288         private static efl_input_pointer_button_pressed_get_delegate efl_input_pointer_button_pressed_get_static_delegate;
1289
1290
1291         private delegate void efl_input_pointer_button_pressed_set_delegate(System.IntPtr obj, System.IntPtr pd,  int button, [MarshalAs(UnmanagedType.U1)] bool pressed);
1292
1293
1294         public delegate void efl_input_pointer_button_pressed_set_api_delegate(System.IntPtr obj,  int button, [MarshalAs(UnmanagedType.U1)] bool pressed);
1295
1296         public static Efl.Eo.FunctionWrapper<efl_input_pointer_button_pressed_set_api_delegate> efl_input_pointer_button_pressed_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_button_pressed_set_api_delegate>(Module, "efl_input_pointer_button_pressed_set");
1297
1298         private static void button_pressed_set(System.IntPtr obj, System.IntPtr pd, int button, bool pressed)
1299         {
1300             Eina.Log.Debug("function efl_input_pointer_button_pressed_set was called");
1301             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1302             if (wrapper != null)
1303             {
1304
1305                 try
1306                 {
1307                     ((Pointer)wrapper).SetButtonPressed(button, pressed);
1308                 }
1309                 catch (Exception e)
1310                 {
1311                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1312                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1313                 }
1314
1315
1316             }
1317             else
1318             {
1319                 efl_input_pointer_button_pressed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), button, pressed);
1320             }
1321         }
1322
1323         private static efl_input_pointer_button_pressed_set_delegate efl_input_pointer_button_pressed_set_static_delegate;
1324
1325
1326         private delegate Eina.Position2D.NativeStruct efl_input_pointer_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
1327
1328
1329         public delegate Eina.Position2D.NativeStruct efl_input_pointer_position_get_api_delegate(System.IntPtr obj);
1330
1331         public static Efl.Eo.FunctionWrapper<efl_input_pointer_position_get_api_delegate> efl_input_pointer_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_position_get_api_delegate>(Module, "efl_input_pointer_position_get");
1332
1333         private static Eina.Position2D.NativeStruct position_get(System.IntPtr obj, System.IntPtr pd)
1334         {
1335             Eina.Log.Debug("function efl_input_pointer_position_get was called");
1336             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1337             if (wrapper != null)
1338             {
1339             Eina.Position2D _ret_var = default(Eina.Position2D);
1340                 try
1341                 {
1342                     _ret_var = ((Pointer)wrapper).GetPosition();
1343                 }
1344                 catch (Exception e)
1345                 {
1346                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1347                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1348                 }
1349
1350         return _ret_var;
1351
1352             }
1353             else
1354             {
1355                 return efl_input_pointer_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1356             }
1357         }
1358
1359         private static efl_input_pointer_position_get_delegate efl_input_pointer_position_get_static_delegate;
1360
1361
1362         private delegate void efl_input_pointer_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos);
1363
1364
1365         public delegate void efl_input_pointer_position_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos);
1366
1367         public static Efl.Eo.FunctionWrapper<efl_input_pointer_position_set_api_delegate> efl_input_pointer_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_position_set_api_delegate>(Module, "efl_input_pointer_position_set");
1368
1369         private static void position_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos)
1370         {
1371             Eina.Log.Debug("function efl_input_pointer_position_set was called");
1372             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1373             if (wrapper != null)
1374             {
1375         Eina.Position2D _in_pos = pos;
1376
1377                 try
1378                 {
1379                     ((Pointer)wrapper).SetPosition(_in_pos);
1380                 }
1381                 catch (Exception e)
1382                 {
1383                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1384                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1385                 }
1386
1387
1388             }
1389             else
1390             {
1391                 efl_input_pointer_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos);
1392             }
1393         }
1394
1395         private static efl_input_pointer_position_set_delegate efl_input_pointer_position_set_static_delegate;
1396
1397
1398         private delegate Eina.Vector2.NativeStruct efl_input_pointer_precise_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
1399
1400
1401         public delegate Eina.Vector2.NativeStruct efl_input_pointer_precise_position_get_api_delegate(System.IntPtr obj);
1402
1403         public static Efl.Eo.FunctionWrapper<efl_input_pointer_precise_position_get_api_delegate> efl_input_pointer_precise_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_precise_position_get_api_delegate>(Module, "efl_input_pointer_precise_position_get");
1404
1405         private static Eina.Vector2.NativeStruct precise_position_get(System.IntPtr obj, System.IntPtr pd)
1406         {
1407             Eina.Log.Debug("function efl_input_pointer_precise_position_get was called");
1408             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1409             if (wrapper != null)
1410             {
1411             Eina.Vector2 _ret_var = default(Eina.Vector2);
1412                 try
1413                 {
1414                     _ret_var = ((Pointer)wrapper).GetPrecisePosition();
1415                 }
1416                 catch (Exception e)
1417                 {
1418                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1419                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1420                 }
1421
1422         return _ret_var;
1423
1424             }
1425             else
1426             {
1427                 return efl_input_pointer_precise_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1428             }
1429         }
1430
1431         private static efl_input_pointer_precise_position_get_delegate efl_input_pointer_precise_position_get_static_delegate;
1432
1433
1434         private delegate void efl_input_pointer_precise_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Vector2.NativeStruct pos);
1435
1436
1437         public delegate void efl_input_pointer_precise_position_set_api_delegate(System.IntPtr obj,  Eina.Vector2.NativeStruct pos);
1438
1439         public static Efl.Eo.FunctionWrapper<efl_input_pointer_precise_position_set_api_delegate> efl_input_pointer_precise_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_precise_position_set_api_delegate>(Module, "efl_input_pointer_precise_position_set");
1440
1441         private static void precise_position_set(System.IntPtr obj, System.IntPtr pd, Eina.Vector2.NativeStruct pos)
1442         {
1443             Eina.Log.Debug("function efl_input_pointer_precise_position_set was called");
1444             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1445             if (wrapper != null)
1446             {
1447         Eina.Vector2 _in_pos = pos;
1448
1449                 try
1450                 {
1451                     ((Pointer)wrapper).SetPrecisePosition(_in_pos);
1452                 }
1453                 catch (Exception e)
1454                 {
1455                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1456                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1457                 }
1458
1459
1460             }
1461             else
1462             {
1463                 efl_input_pointer_precise_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos);
1464             }
1465         }
1466
1467         private static efl_input_pointer_precise_position_set_delegate efl_input_pointer_precise_position_set_static_delegate;
1468
1469
1470         private delegate Eina.Position2D.NativeStruct efl_input_pointer_previous_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
1471
1472
1473         public delegate Eina.Position2D.NativeStruct efl_input_pointer_previous_position_get_api_delegate(System.IntPtr obj);
1474
1475         public static Efl.Eo.FunctionWrapper<efl_input_pointer_previous_position_get_api_delegate> efl_input_pointer_previous_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_previous_position_get_api_delegate>(Module, "efl_input_pointer_previous_position_get");
1476
1477         private static Eina.Position2D.NativeStruct previous_position_get(System.IntPtr obj, System.IntPtr pd)
1478         {
1479             Eina.Log.Debug("function efl_input_pointer_previous_position_get was called");
1480             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1481             if (wrapper != null)
1482             {
1483             Eina.Position2D _ret_var = default(Eina.Position2D);
1484                 try
1485                 {
1486                     _ret_var = ((Pointer)wrapper).GetPreviousPosition();
1487                 }
1488                 catch (Exception e)
1489                 {
1490                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1491                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1492                 }
1493
1494         return _ret_var;
1495
1496             }
1497             else
1498             {
1499                 return efl_input_pointer_previous_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1500             }
1501         }
1502
1503         private static efl_input_pointer_previous_position_get_delegate efl_input_pointer_previous_position_get_static_delegate;
1504
1505
1506         private delegate void efl_input_pointer_previous_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos);
1507
1508
1509         public delegate void efl_input_pointer_previous_position_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos);
1510
1511         public static Efl.Eo.FunctionWrapper<efl_input_pointer_previous_position_set_api_delegate> efl_input_pointer_previous_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_previous_position_set_api_delegate>(Module, "efl_input_pointer_previous_position_set");
1512
1513         private static void previous_position_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos)
1514         {
1515             Eina.Log.Debug("function efl_input_pointer_previous_position_set was called");
1516             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1517             if (wrapper != null)
1518             {
1519         Eina.Position2D _in_pos = pos;
1520
1521                 try
1522                 {
1523                     ((Pointer)wrapper).SetPreviousPosition(_in_pos);
1524                 }
1525                 catch (Exception e)
1526                 {
1527                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1528                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1529                 }
1530
1531
1532             }
1533             else
1534             {
1535                 efl_input_pointer_previous_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos);
1536             }
1537         }
1538
1539         private static efl_input_pointer_previous_position_set_delegate efl_input_pointer_previous_position_set_static_delegate;
1540
1541
1542         private delegate int efl_input_pointer_tool_get_delegate(System.IntPtr obj, System.IntPtr pd);
1543
1544
1545         public delegate int efl_input_pointer_tool_get_api_delegate(System.IntPtr obj);
1546
1547         public static Efl.Eo.FunctionWrapper<efl_input_pointer_tool_get_api_delegate> efl_input_pointer_tool_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_tool_get_api_delegate>(Module, "efl_input_pointer_tool_get");
1548
1549         private static int tool_get(System.IntPtr obj, System.IntPtr pd)
1550         {
1551             Eina.Log.Debug("function efl_input_pointer_tool_get was called");
1552             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1553             if (wrapper != null)
1554             {
1555             int _ret_var = default(int);
1556                 try
1557                 {
1558                     _ret_var = ((Pointer)wrapper).GetTool();
1559                 }
1560                 catch (Exception e)
1561                 {
1562                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1563                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1564                 }
1565
1566         return _ret_var;
1567
1568             }
1569             else
1570             {
1571                 return efl_input_pointer_tool_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1572             }
1573         }
1574
1575         private static efl_input_pointer_tool_get_delegate efl_input_pointer_tool_get_static_delegate;
1576
1577
1578         private delegate void efl_input_pointer_tool_set_delegate(System.IntPtr obj, System.IntPtr pd,  int id);
1579
1580
1581         public delegate void efl_input_pointer_tool_set_api_delegate(System.IntPtr obj,  int id);
1582
1583         public static Efl.Eo.FunctionWrapper<efl_input_pointer_tool_set_api_delegate> efl_input_pointer_tool_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_tool_set_api_delegate>(Module, "efl_input_pointer_tool_set");
1584
1585         private static void tool_set(System.IntPtr obj, System.IntPtr pd, int id)
1586         {
1587             Eina.Log.Debug("function efl_input_pointer_tool_set was called");
1588             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1589             if (wrapper != null)
1590             {
1591
1592                 try
1593                 {
1594                     ((Pointer)wrapper).SetTool(id);
1595                 }
1596                 catch (Exception e)
1597                 {
1598                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1599                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1600                 }
1601
1602
1603             }
1604             else
1605             {
1606                 efl_input_pointer_tool_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), id);
1607             }
1608         }
1609
1610         private static efl_input_pointer_tool_set_delegate efl_input_pointer_tool_set_static_delegate;
1611
1612         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1613         private delegate Efl.Object efl_input_pointer_source_get_delegate(System.IntPtr obj, System.IntPtr pd);
1614
1615         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1616         public delegate Efl.Object efl_input_pointer_source_get_api_delegate(System.IntPtr obj);
1617
1618         public static Efl.Eo.FunctionWrapper<efl_input_pointer_source_get_api_delegate> efl_input_pointer_source_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_source_get_api_delegate>(Module, "efl_input_pointer_source_get");
1619
1620         private static Efl.Object source_get(System.IntPtr obj, System.IntPtr pd)
1621         {
1622             Eina.Log.Debug("function efl_input_pointer_source_get was called");
1623             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1624             if (wrapper != null)
1625             {
1626             Efl.Object _ret_var = default(Efl.Object);
1627                 try
1628                 {
1629                     _ret_var = ((Pointer)wrapper).GetSource();
1630                 }
1631                 catch (Exception e)
1632                 {
1633                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1634                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1635                 }
1636
1637         return _ret_var;
1638
1639             }
1640             else
1641             {
1642                 return efl_input_pointer_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1643             }
1644         }
1645
1646         private static efl_input_pointer_source_get_delegate efl_input_pointer_source_get_static_delegate;
1647
1648
1649         private delegate void efl_input_pointer_source_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object src);
1650
1651
1652         public delegate void efl_input_pointer_source_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object src);
1653
1654         public static Efl.Eo.FunctionWrapper<efl_input_pointer_source_set_api_delegate> efl_input_pointer_source_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_source_set_api_delegate>(Module, "efl_input_pointer_source_set");
1655
1656         private static void source_set(System.IntPtr obj, System.IntPtr pd, Efl.Object src)
1657         {
1658             Eina.Log.Debug("function efl_input_pointer_source_set was called");
1659             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1660             if (wrapper != null)
1661             {
1662
1663                 try
1664                 {
1665                     ((Pointer)wrapper).SetSource(src);
1666                 }
1667                 catch (Exception e)
1668                 {
1669                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1670                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1671                 }
1672
1673
1674             }
1675             else
1676             {
1677                 efl_input_pointer_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), src);
1678             }
1679         }
1680
1681         private static efl_input_pointer_source_set_delegate efl_input_pointer_source_set_static_delegate;
1682
1683
1684         private delegate Efl.Pointer.Flags efl_input_pointer_button_flags_get_delegate(System.IntPtr obj, System.IntPtr pd);
1685
1686
1687         public delegate Efl.Pointer.Flags efl_input_pointer_button_flags_get_api_delegate(System.IntPtr obj);
1688
1689         public static Efl.Eo.FunctionWrapper<efl_input_pointer_button_flags_get_api_delegate> efl_input_pointer_button_flags_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_button_flags_get_api_delegate>(Module, "efl_input_pointer_button_flags_get");
1690
1691         private static Efl.Pointer.Flags button_flags_get(System.IntPtr obj, System.IntPtr pd)
1692         {
1693             Eina.Log.Debug("function efl_input_pointer_button_flags_get was called");
1694             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1695             if (wrapper != null)
1696             {
1697             Efl.Pointer.Flags _ret_var = default(Efl.Pointer.Flags);
1698                 try
1699                 {
1700                     _ret_var = ((Pointer)wrapper).GetButtonFlags();
1701                 }
1702                 catch (Exception e)
1703                 {
1704                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1705                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1706                 }
1707
1708         return _ret_var;
1709
1710             }
1711             else
1712             {
1713                 return efl_input_pointer_button_flags_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1714             }
1715         }
1716
1717         private static efl_input_pointer_button_flags_get_delegate efl_input_pointer_button_flags_get_static_delegate;
1718
1719
1720         private delegate void efl_input_pointer_button_flags_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Pointer.Flags flags);
1721
1722
1723         public delegate void efl_input_pointer_button_flags_set_api_delegate(System.IntPtr obj,  Efl.Pointer.Flags flags);
1724
1725         public static Efl.Eo.FunctionWrapper<efl_input_pointer_button_flags_set_api_delegate> efl_input_pointer_button_flags_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_button_flags_set_api_delegate>(Module, "efl_input_pointer_button_flags_set");
1726
1727         private static void button_flags_set(System.IntPtr obj, System.IntPtr pd, Efl.Pointer.Flags flags)
1728         {
1729             Eina.Log.Debug("function efl_input_pointer_button_flags_set was called");
1730             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1731             if (wrapper != null)
1732             {
1733
1734                 try
1735                 {
1736                     ((Pointer)wrapper).SetButtonFlags(flags);
1737                 }
1738                 catch (Exception e)
1739                 {
1740                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1741                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1742                 }
1743
1744
1745             }
1746             else
1747             {
1748                 efl_input_pointer_button_flags_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), flags);
1749             }
1750         }
1751
1752         private static efl_input_pointer_button_flags_set_delegate efl_input_pointer_button_flags_set_static_delegate;
1753
1754         [return: MarshalAs(UnmanagedType.U1)]
1755         private delegate bool efl_input_pointer_double_click_get_delegate(System.IntPtr obj, System.IntPtr pd);
1756
1757         [return: MarshalAs(UnmanagedType.U1)]
1758         public delegate bool efl_input_pointer_double_click_get_api_delegate(System.IntPtr obj);
1759
1760         public static Efl.Eo.FunctionWrapper<efl_input_pointer_double_click_get_api_delegate> efl_input_pointer_double_click_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_double_click_get_api_delegate>(Module, "efl_input_pointer_double_click_get");
1761
1762         private static bool double_click_get(System.IntPtr obj, System.IntPtr pd)
1763         {
1764             Eina.Log.Debug("function efl_input_pointer_double_click_get was called");
1765             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1766             if (wrapper != null)
1767             {
1768             bool _ret_var = default(bool);
1769                 try
1770                 {
1771                     _ret_var = ((Pointer)wrapper).GetDoubleClick();
1772                 }
1773                 catch (Exception e)
1774                 {
1775                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1776                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1777                 }
1778
1779         return _ret_var;
1780
1781             }
1782             else
1783             {
1784                 return efl_input_pointer_double_click_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1785             }
1786         }
1787
1788         private static efl_input_pointer_double_click_get_delegate efl_input_pointer_double_click_get_static_delegate;
1789
1790
1791         private delegate void efl_input_pointer_double_click_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
1792
1793
1794         public delegate void efl_input_pointer_double_click_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
1795
1796         public static Efl.Eo.FunctionWrapper<efl_input_pointer_double_click_set_api_delegate> efl_input_pointer_double_click_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_double_click_set_api_delegate>(Module, "efl_input_pointer_double_click_set");
1797
1798         private static void double_click_set(System.IntPtr obj, System.IntPtr pd, bool val)
1799         {
1800             Eina.Log.Debug("function efl_input_pointer_double_click_set was called");
1801             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1802             if (wrapper != null)
1803             {
1804
1805                 try
1806                 {
1807                     ((Pointer)wrapper).SetDoubleClick(val);
1808                 }
1809                 catch (Exception e)
1810                 {
1811                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1812                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1813                 }
1814
1815
1816             }
1817             else
1818             {
1819                 efl_input_pointer_double_click_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1820             }
1821         }
1822
1823         private static efl_input_pointer_double_click_set_delegate efl_input_pointer_double_click_set_static_delegate;
1824
1825         [return: MarshalAs(UnmanagedType.U1)]
1826         private delegate bool efl_input_pointer_triple_click_get_delegate(System.IntPtr obj, System.IntPtr pd);
1827
1828         [return: MarshalAs(UnmanagedType.U1)]
1829         public delegate bool efl_input_pointer_triple_click_get_api_delegate(System.IntPtr obj);
1830
1831         public static Efl.Eo.FunctionWrapper<efl_input_pointer_triple_click_get_api_delegate> efl_input_pointer_triple_click_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_triple_click_get_api_delegate>(Module, "efl_input_pointer_triple_click_get");
1832
1833         private static bool triple_click_get(System.IntPtr obj, System.IntPtr pd)
1834         {
1835             Eina.Log.Debug("function efl_input_pointer_triple_click_get was called");
1836             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1837             if (wrapper != null)
1838             {
1839             bool _ret_var = default(bool);
1840                 try
1841                 {
1842                     _ret_var = ((Pointer)wrapper).GetTripleClick();
1843                 }
1844                 catch (Exception e)
1845                 {
1846                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1847                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1848                 }
1849
1850         return _ret_var;
1851
1852             }
1853             else
1854             {
1855                 return efl_input_pointer_triple_click_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1856             }
1857         }
1858
1859         private static efl_input_pointer_triple_click_get_delegate efl_input_pointer_triple_click_get_static_delegate;
1860
1861
1862         private delegate void efl_input_pointer_triple_click_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
1863
1864
1865         public delegate void efl_input_pointer_triple_click_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
1866
1867         public static Efl.Eo.FunctionWrapper<efl_input_pointer_triple_click_set_api_delegate> efl_input_pointer_triple_click_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_triple_click_set_api_delegate>(Module, "efl_input_pointer_triple_click_set");
1868
1869         private static void triple_click_set(System.IntPtr obj, System.IntPtr pd, bool val)
1870         {
1871             Eina.Log.Debug("function efl_input_pointer_triple_click_set was called");
1872             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1873             if (wrapper != null)
1874             {
1875
1876                 try
1877                 {
1878                     ((Pointer)wrapper).SetTripleClick(val);
1879                 }
1880                 catch (Exception e)
1881                 {
1882                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1883                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1884                 }
1885
1886
1887             }
1888             else
1889             {
1890                 efl_input_pointer_triple_click_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1891             }
1892         }
1893
1894         private static efl_input_pointer_triple_click_set_delegate efl_input_pointer_triple_click_set_static_delegate;
1895
1896         [return: MarshalAs(UnmanagedType.U1)]
1897         private delegate bool efl_input_pointer_wheel_horizontal_get_delegate(System.IntPtr obj, System.IntPtr pd);
1898
1899         [return: MarshalAs(UnmanagedType.U1)]
1900         public delegate bool efl_input_pointer_wheel_horizontal_get_api_delegate(System.IntPtr obj);
1901
1902         public static Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_horizontal_get_api_delegate> efl_input_pointer_wheel_horizontal_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_horizontal_get_api_delegate>(Module, "efl_input_pointer_wheel_horizontal_get");
1903
1904         private static bool wheel_horizontal_get(System.IntPtr obj, System.IntPtr pd)
1905         {
1906             Eina.Log.Debug("function efl_input_pointer_wheel_horizontal_get was called");
1907             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1908             if (wrapper != null)
1909             {
1910             bool _ret_var = default(bool);
1911                 try
1912                 {
1913                     _ret_var = ((Pointer)wrapper).GetWheelHorizontal();
1914                 }
1915                 catch (Exception e)
1916                 {
1917                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1918                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1919                 }
1920
1921         return _ret_var;
1922
1923             }
1924             else
1925             {
1926                 return efl_input_pointer_wheel_horizontal_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1927             }
1928         }
1929
1930         private static efl_input_pointer_wheel_horizontal_get_delegate efl_input_pointer_wheel_horizontal_get_static_delegate;
1931
1932
1933         private delegate void efl_input_pointer_wheel_horizontal_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool horizontal);
1934
1935
1936         public delegate void efl_input_pointer_wheel_horizontal_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool horizontal);
1937
1938         public static Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_horizontal_set_api_delegate> efl_input_pointer_wheel_horizontal_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_horizontal_set_api_delegate>(Module, "efl_input_pointer_wheel_horizontal_set");
1939
1940         private static void wheel_horizontal_set(System.IntPtr obj, System.IntPtr pd, bool horizontal)
1941         {
1942             Eina.Log.Debug("function efl_input_pointer_wheel_horizontal_set was called");
1943             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1944             if (wrapper != null)
1945             {
1946
1947                 try
1948                 {
1949                     ((Pointer)wrapper).SetWheelHorizontal(horizontal);
1950                 }
1951                 catch (Exception e)
1952                 {
1953                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1954                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1955                 }
1956
1957
1958             }
1959             else
1960             {
1961                 efl_input_pointer_wheel_horizontal_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), horizontal);
1962             }
1963         }
1964
1965         private static efl_input_pointer_wheel_horizontal_set_delegate efl_input_pointer_wheel_horizontal_set_static_delegate;
1966
1967
1968         private delegate int efl_input_pointer_wheel_delta_get_delegate(System.IntPtr obj, System.IntPtr pd);
1969
1970
1971         public delegate int efl_input_pointer_wheel_delta_get_api_delegate(System.IntPtr obj);
1972
1973         public static Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_delta_get_api_delegate> efl_input_pointer_wheel_delta_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_delta_get_api_delegate>(Module, "efl_input_pointer_wheel_delta_get");
1974
1975         private static int wheel_delta_get(System.IntPtr obj, System.IntPtr pd)
1976         {
1977             Eina.Log.Debug("function efl_input_pointer_wheel_delta_get was called");
1978             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1979             if (wrapper != null)
1980             {
1981             int _ret_var = default(int);
1982                 try
1983                 {
1984                     _ret_var = ((Pointer)wrapper).GetWheelDelta();
1985                 }
1986                 catch (Exception e)
1987                 {
1988                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1989                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1990                 }
1991
1992         return _ret_var;
1993
1994             }
1995             else
1996             {
1997                 return efl_input_pointer_wheel_delta_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1998             }
1999         }
2000
2001         private static efl_input_pointer_wheel_delta_get_delegate efl_input_pointer_wheel_delta_get_static_delegate;
2002
2003
2004         private delegate void efl_input_pointer_wheel_delta_set_delegate(System.IntPtr obj, System.IntPtr pd,  int dist);
2005
2006
2007         public delegate void efl_input_pointer_wheel_delta_set_api_delegate(System.IntPtr obj,  int dist);
2008
2009         public static Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_delta_set_api_delegate> efl_input_pointer_wheel_delta_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_pointer_wheel_delta_set_api_delegate>(Module, "efl_input_pointer_wheel_delta_set");
2010
2011         private static void wheel_delta_set(System.IntPtr obj, System.IntPtr pd, int dist)
2012         {
2013             Eina.Log.Debug("function efl_input_pointer_wheel_delta_set was called");
2014             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2015             if (wrapper != null)
2016             {
2017
2018                 try
2019                 {
2020                     ((Pointer)wrapper).SetWheelDelta(dist);
2021                 }
2022                 catch (Exception e)
2023                 {
2024                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2025                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2026                 }
2027
2028
2029             }
2030             else
2031             {
2032                 efl_input_pointer_wheel_delta_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dist);
2033             }
2034         }
2035
2036         private static efl_input_pointer_wheel_delta_set_delegate efl_input_pointer_wheel_delta_set_static_delegate;
2037
2038         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
2039         private delegate Efl.IDuplicate efl_duplicate_delegate(System.IntPtr obj, System.IntPtr pd);
2040
2041         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
2042         public delegate Efl.IDuplicate efl_duplicate_api_delegate(System.IntPtr obj);
2043
2044         public static Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate> efl_duplicate_ptr = new Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate>(Module, "efl_duplicate");
2045
2046         private static Efl.IDuplicate duplicate(System.IntPtr obj, System.IntPtr pd)
2047         {
2048             Eina.Log.Debug("function efl_duplicate was called");
2049             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2050             if (wrapper != null)
2051             {
2052             Efl.IDuplicate _ret_var = default(Efl.IDuplicate);
2053                 try
2054                 {
2055                     _ret_var = ((Pointer)wrapper).Duplicate();
2056                 }
2057                 catch (Exception e)
2058                 {
2059                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2060                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2061                 }
2062
2063         return _ret_var;
2064
2065             }
2066             else
2067             {
2068                 return efl_duplicate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2069             }
2070         }
2071
2072         private static efl_duplicate_delegate efl_duplicate_static_delegate;
2073
2074
2075         private delegate double efl_input_timestamp_get_delegate(System.IntPtr obj, System.IntPtr pd);
2076
2077
2078         public delegate double efl_input_timestamp_get_api_delegate(System.IntPtr obj);
2079
2080         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");
2081
2082         private static double timestamp_get(System.IntPtr obj, System.IntPtr pd)
2083         {
2084             Eina.Log.Debug("function efl_input_timestamp_get was called");
2085             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2086             if (wrapper != null)
2087             {
2088             double _ret_var = default(double);
2089                 try
2090                 {
2091                     _ret_var = ((Pointer)wrapper).GetTimestamp();
2092                 }
2093                 catch (Exception e)
2094                 {
2095                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2096                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2097                 }
2098
2099         return _ret_var;
2100
2101             }
2102             else
2103             {
2104                 return efl_input_timestamp_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2105             }
2106         }
2107
2108         private static efl_input_timestamp_get_delegate efl_input_timestamp_get_static_delegate;
2109
2110
2111         private delegate void efl_input_timestamp_set_delegate(System.IntPtr obj, System.IntPtr pd,  double ms);
2112
2113
2114         public delegate void efl_input_timestamp_set_api_delegate(System.IntPtr obj,  double ms);
2115
2116         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");
2117
2118         private static void timestamp_set(System.IntPtr obj, System.IntPtr pd, double ms)
2119         {
2120             Eina.Log.Debug("function efl_input_timestamp_set was called");
2121             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2122             if (wrapper != null)
2123             {
2124
2125                 try
2126                 {
2127                     ((Pointer)wrapper).SetTimestamp(ms);
2128                 }
2129                 catch (Exception e)
2130                 {
2131                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2132                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2133                 }
2134
2135
2136             }
2137             else
2138             {
2139                 efl_input_timestamp_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ms);
2140             }
2141         }
2142
2143         private static efl_input_timestamp_set_delegate efl_input_timestamp_set_static_delegate;
2144
2145         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2146         private delegate Efl.Input.Device efl_input_device_get_delegate(System.IntPtr obj, System.IntPtr pd);
2147
2148         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2149         public delegate Efl.Input.Device efl_input_device_get_api_delegate(System.IntPtr obj);
2150
2151         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");
2152
2153         private static Efl.Input.Device device_get(System.IntPtr obj, System.IntPtr pd)
2154         {
2155             Eina.Log.Debug("function efl_input_device_get was called");
2156             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2157             if (wrapper != null)
2158             {
2159             Efl.Input.Device _ret_var = default(Efl.Input.Device);
2160                 try
2161                 {
2162                     _ret_var = ((Pointer)wrapper).GetDevice();
2163                 }
2164                 catch (Exception e)
2165                 {
2166                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2167                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2168                 }
2169
2170         return _ret_var;
2171
2172             }
2173             else
2174             {
2175                 return efl_input_device_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2176             }
2177         }
2178
2179         private static efl_input_device_get_delegate efl_input_device_get_static_delegate;
2180
2181
2182         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);
2183
2184
2185         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);
2186
2187         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");
2188
2189         private static void device_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Device dev)
2190         {
2191             Eina.Log.Debug("function efl_input_device_set was called");
2192             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2193             if (wrapper != null)
2194             {
2195
2196                 try
2197                 {
2198                     ((Pointer)wrapper).SetDevice(dev);
2199                 }
2200                 catch (Exception e)
2201                 {
2202                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2203                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2204                 }
2205
2206
2207             }
2208             else
2209             {
2210                 efl_input_device_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dev);
2211             }
2212         }
2213
2214         private static efl_input_device_set_delegate efl_input_device_set_static_delegate;
2215
2216
2217         private delegate Efl.Input.Flags efl_input_event_flags_get_delegate(System.IntPtr obj, System.IntPtr pd);
2218
2219
2220         public delegate Efl.Input.Flags efl_input_event_flags_get_api_delegate(System.IntPtr obj);
2221
2222         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");
2223
2224         private static Efl.Input.Flags event_flags_get(System.IntPtr obj, System.IntPtr pd)
2225         {
2226             Eina.Log.Debug("function efl_input_event_flags_get was called");
2227             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2228             if (wrapper != null)
2229             {
2230             Efl.Input.Flags _ret_var = default(Efl.Input.Flags);
2231                 try
2232                 {
2233                     _ret_var = ((Pointer)wrapper).GetEventFlags();
2234                 }
2235                 catch (Exception e)
2236                 {
2237                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2238                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2239                 }
2240
2241         return _ret_var;
2242
2243             }
2244             else
2245             {
2246                 return efl_input_event_flags_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2247             }
2248         }
2249
2250         private static efl_input_event_flags_get_delegate efl_input_event_flags_get_static_delegate;
2251
2252
2253         private delegate void efl_input_event_flags_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Flags flags);
2254
2255
2256         public delegate void efl_input_event_flags_set_api_delegate(System.IntPtr obj,  Efl.Input.Flags flags);
2257
2258         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");
2259
2260         private static void event_flags_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Flags flags)
2261         {
2262             Eina.Log.Debug("function efl_input_event_flags_set was called");
2263             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2264             if (wrapper != null)
2265             {
2266
2267                 try
2268                 {
2269                     ((Pointer)wrapper).SetEventFlags(flags);
2270                 }
2271                 catch (Exception e)
2272                 {
2273                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2274                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2275                 }
2276
2277
2278             }
2279             else
2280             {
2281                 efl_input_event_flags_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), flags);
2282             }
2283         }
2284
2285         private static efl_input_event_flags_set_delegate efl_input_event_flags_set_static_delegate;
2286
2287         [return: MarshalAs(UnmanagedType.U1)]
2288         private delegate bool efl_input_processed_get_delegate(System.IntPtr obj, System.IntPtr pd);
2289
2290         [return: MarshalAs(UnmanagedType.U1)]
2291         public delegate bool efl_input_processed_get_api_delegate(System.IntPtr obj);
2292
2293         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");
2294
2295         private static bool processed_get(System.IntPtr obj, System.IntPtr pd)
2296         {
2297             Eina.Log.Debug("function efl_input_processed_get was called");
2298             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2299             if (wrapper != null)
2300             {
2301             bool _ret_var = default(bool);
2302                 try
2303                 {
2304                     _ret_var = ((Pointer)wrapper).GetProcessed();
2305                 }
2306                 catch (Exception e)
2307                 {
2308                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2309                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2310                 }
2311
2312         return _ret_var;
2313
2314             }
2315             else
2316             {
2317                 return efl_input_processed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2318             }
2319         }
2320
2321         private static efl_input_processed_get_delegate efl_input_processed_get_static_delegate;
2322
2323
2324         private delegate void efl_input_processed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
2325
2326
2327         public delegate void efl_input_processed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
2328
2329         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");
2330
2331         private static void processed_set(System.IntPtr obj, System.IntPtr pd, bool val)
2332         {
2333             Eina.Log.Debug("function efl_input_processed_set was called");
2334             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2335             if (wrapper != null)
2336             {
2337
2338                 try
2339                 {
2340                     ((Pointer)wrapper).SetProcessed(val);
2341                 }
2342                 catch (Exception e)
2343                 {
2344                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2345                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2346                 }
2347
2348
2349             }
2350             else
2351             {
2352                 efl_input_processed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
2353             }
2354         }
2355
2356         private static efl_input_processed_set_delegate efl_input_processed_set_static_delegate;
2357
2358         [return: MarshalAs(UnmanagedType.U1)]
2359         private delegate bool efl_input_scrolling_get_delegate(System.IntPtr obj, System.IntPtr pd);
2360
2361         [return: MarshalAs(UnmanagedType.U1)]
2362         public delegate bool efl_input_scrolling_get_api_delegate(System.IntPtr obj);
2363
2364         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");
2365
2366         private static bool scrolling_get(System.IntPtr obj, System.IntPtr pd)
2367         {
2368             Eina.Log.Debug("function efl_input_scrolling_get was called");
2369             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2370             if (wrapper != null)
2371             {
2372             bool _ret_var = default(bool);
2373                 try
2374                 {
2375                     _ret_var = ((Pointer)wrapper).GetScrolling();
2376                 }
2377                 catch (Exception e)
2378                 {
2379                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2380                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2381                 }
2382
2383         return _ret_var;
2384
2385             }
2386             else
2387             {
2388                 return efl_input_scrolling_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2389             }
2390         }
2391
2392         private static efl_input_scrolling_get_delegate efl_input_scrolling_get_static_delegate;
2393
2394
2395         private delegate void efl_input_scrolling_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
2396
2397
2398         public delegate void efl_input_scrolling_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
2399
2400         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");
2401
2402         private static void scrolling_set(System.IntPtr obj, System.IntPtr pd, bool val)
2403         {
2404             Eina.Log.Debug("function efl_input_scrolling_set was called");
2405             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2406             if (wrapper != null)
2407             {
2408
2409                 try
2410                 {
2411                     ((Pointer)wrapper).SetScrolling(val);
2412                 }
2413                 catch (Exception e)
2414                 {
2415                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2416                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2417                 }
2418
2419
2420             }
2421             else
2422             {
2423                 efl_input_scrolling_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
2424             }
2425         }
2426
2427         private static efl_input_scrolling_set_delegate efl_input_scrolling_set_static_delegate;
2428
2429         [return: MarshalAs(UnmanagedType.U1)]
2430         private delegate bool efl_input_fake_get_delegate(System.IntPtr obj, System.IntPtr pd);
2431
2432         [return: MarshalAs(UnmanagedType.U1)]
2433         public delegate bool efl_input_fake_get_api_delegate(System.IntPtr obj);
2434
2435         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");
2436
2437         private static bool fake_get(System.IntPtr obj, System.IntPtr pd)
2438         {
2439             Eina.Log.Debug("function efl_input_fake_get was called");
2440             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2441             if (wrapper != null)
2442             {
2443             bool _ret_var = default(bool);
2444                 try
2445                 {
2446                     _ret_var = ((Pointer)wrapper).GetFake();
2447                 }
2448                 catch (Exception e)
2449                 {
2450                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2451                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2452                 }
2453
2454         return _ret_var;
2455
2456             }
2457             else
2458             {
2459                 return efl_input_fake_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2460             }
2461         }
2462
2463         private static efl_input_fake_get_delegate efl_input_fake_get_static_delegate;
2464
2465
2466         private delegate void efl_input_reset_delegate(System.IntPtr obj, System.IntPtr pd);
2467
2468
2469         public delegate void efl_input_reset_api_delegate(System.IntPtr obj);
2470
2471         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");
2472
2473         private static void reset(System.IntPtr obj, System.IntPtr pd)
2474         {
2475             Eina.Log.Debug("function efl_input_reset was called");
2476             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2477             if (wrapper != null)
2478             {
2479
2480                 try
2481                 {
2482                     ((Pointer)wrapper).Reset();
2483                 }
2484                 catch (Exception e)
2485                 {
2486                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2487                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2488                 }
2489
2490
2491             }
2492             else
2493             {
2494                 efl_input_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2495             }
2496         }
2497
2498         private static efl_input_reset_delegate efl_input_reset_static_delegate;
2499
2500         [return: MarshalAs(UnmanagedType.U1)]
2501         private delegate bool efl_input_modifier_enabled_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Modifier mod, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device seat);
2502
2503         [return: MarshalAs(UnmanagedType.U1)]
2504         public delegate bool efl_input_modifier_enabled_get_api_delegate(System.IntPtr obj,  Efl.Input.Modifier mod, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device seat);
2505
2506         public static Efl.Eo.FunctionWrapper<efl_input_modifier_enabled_get_api_delegate> efl_input_modifier_enabled_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_modifier_enabled_get_api_delegate>(Module, "efl_input_modifier_enabled_get");
2507
2508         private static bool modifier_enabled_get(System.IntPtr obj, System.IntPtr pd, Efl.Input.Modifier mod, Efl.Input.Device seat)
2509         {
2510             Eina.Log.Debug("function efl_input_modifier_enabled_get was called");
2511             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2512             if (wrapper != null)
2513             {
2514                                                             bool _ret_var = default(bool);
2515                 try
2516                 {
2517                     _ret_var = ((Pointer)wrapper).GetModifierEnabled(mod, seat);
2518                 }
2519                 catch (Exception e)
2520                 {
2521                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2522                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2523                 }
2524
2525                                         return _ret_var;
2526
2527             }
2528             else
2529             {
2530                 return efl_input_modifier_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mod, seat);
2531             }
2532         }
2533
2534         private static efl_input_modifier_enabled_get_delegate efl_input_modifier_enabled_get_static_delegate;
2535
2536         [return: MarshalAs(UnmanagedType.U1)]
2537         private delegate bool efl_input_lock_enabled_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Lock kw_lock, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device seat);
2538
2539         [return: MarshalAs(UnmanagedType.U1)]
2540         public delegate bool efl_input_lock_enabled_get_api_delegate(System.IntPtr obj,  Efl.Input.Lock kw_lock, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Input.Device seat);
2541
2542         public static Efl.Eo.FunctionWrapper<efl_input_lock_enabled_get_api_delegate> efl_input_lock_enabled_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_lock_enabled_get_api_delegate>(Module, "efl_input_lock_enabled_get");
2543
2544         private static bool lock_enabled_get(System.IntPtr obj, System.IntPtr pd, Efl.Input.Lock kw_lock, Efl.Input.Device seat)
2545         {
2546             Eina.Log.Debug("function efl_input_lock_enabled_get was called");
2547             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2548             if (wrapper != null)
2549             {
2550                                                             bool _ret_var = default(bool);
2551                 try
2552                 {
2553                     _ret_var = ((Pointer)wrapper).GetLockEnabled(kw_lock, seat);
2554                 }
2555                 catch (Exception e)
2556                 {
2557                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2558                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2559                 }
2560
2561                                         return _ret_var;
2562
2563             }
2564             else
2565             {
2566                 return efl_input_lock_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), kw_lock, seat);
2567             }
2568         }
2569
2570         private static efl_input_lock_enabled_get_delegate efl_input_lock_enabled_get_static_delegate;
2571
2572         #pragma warning restore CA1707, SA1300, SA1600
2573
2574 }
2575 }
2576 }
2577
2578 }
2579