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