internals/src/EflSharp/EflSharp/efl/efl_input_key.eo.cs

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Input {
  12
  13 /// <summary>Represents a single key event from a keyboard or similar device.</summary>
  14 [Efl.Input.Key.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public class Key : Efl.Object, Efl.IDuplicate, Efl.Input.IEvent, Efl.Input.IState
  17 {
  18     /// <summary>Pointer to the native class description.</summary>
  19     public override System.IntPtr NativeClass
  20     {
  21         get
  22         {
  23             if (((object)this).GetType() == typeof(Key))
  24             {
  25                 return GetEflClassStatic();
  26             }
  27             else
  28             {
  29                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  30             }
  31         }
  32     }
  33
  34     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  35         efl_input_key_class_get();
  36     /// <summary>Initializes a new instance of the <see cref="Key"/> class.</summary>
  37     /// <param name="parent">Parent instance.</param>
  38     public Key(Efl.Object parent= null
  39             ) : base(efl_input_key_class_get(), parent)
  40     {
  41         FinishInstantiation();
  42     }
  43
  44     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  45     /// Do not call this constructor directly.</summary>
  46     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  47     protected Key(ConstructingHandle ch) : base(ch)
  48     {
  49     }
  50
  51     /// <summary>Initializes a new instance of the <see cref="Key"/> class.
  52     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  53     /// <param name="wh">The native pointer to be wrapped.</param>
  54     protected Key(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  55     {
  56     }
  57
  58     /// <summary>Initializes a new instance of the <see cref="Key"/> class.
  59     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  60     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  61     /// <param name="parent">The Efl.Object parent of this instance.</param>
  62     protected Key(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  63     {
  64     }
  65
  66     /// <summary><c>true</c> if the key is down, <c>false</c> if it is released.</summary>
  67     /// <returns><c>true</c> if the key is pressed, <c>false</c> otherwise.</returns>
  68     virtual public bool GetPressed() {
  69          var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_pressed_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  70         Eina.Error.RaiseIfUnhandledException();
  71         return _ret_var;
  72  }
  73     /// <summary><c>true</c> if the key is down, <c>false</c> if it is released.</summary>
  74     /// <param name="val"><c>true</c> if the key is pressed, <c>false</c> otherwise.</param>
  75     virtual public void SetPressed(bool val) {
  76                                  Efl.Input.Key.NativeMethods.efl_input_key_pressed_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
  77         Eina.Error.RaiseIfUnhandledException();
  78                          }
  79     /// <summary>Name string of the physical key that produced this event.
  80     /// This typically matches what is printed on the key. For example, &quot;1&quot; or &quot;a&quot;. Note that both &quot;a&quot; and &quot;A&quot; are obtained with the same physical key, so both events will have the same <see cref="Efl.Input.Key.KeyName"/> &quot;a&quot; but different <see cref="Efl.Input.Key.KeySym"/>.
  81     ///
  82     /// Commonly used in keyboard remapping menus to uniquely identify a physical key.</summary>
  83     /// <returns>Name of the key that produced this event.</returns>
  84     virtual public System.String GetKeyName() {
  85          var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_name_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  86         Eina.Error.RaiseIfUnhandledException();
  87         return _ret_var;
  88  }
  89     /// <summary>Name string of the physical key that produced this event.
  90     /// This typically matches what is printed on the key. For example, &quot;1&quot; or &quot;a&quot;. Note that both &quot;a&quot; and &quot;A&quot; are obtained with the same physical key, so both events will have the same <see cref="Efl.Input.Key.KeyName"/> &quot;a&quot; but different <see cref="Efl.Input.Key.KeySym"/>.
  91     ///
  92     /// Commonly used in keyboard remapping menus to uniquely identify a physical key.</summary>
  93     /// <param name="val">Name of the key that produced this event.</param>
  94     virtual public void SetKeyName(System.String val) {
  95                                  Efl.Input.Key.NativeMethods.efl_input_key_name_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
  96         Eina.Error.RaiseIfUnhandledException();
  97                          }
  98     /// <summary>Name of the symbol produced by this key event.
  99     /// For example, &quot;a&quot;, &quot;A&quot;, &quot;1&quot; or &quot;exclam&quot;. The same physical key can produce different symbols when combined with other keys like &quot;shift&quot; or &quot;alt gr&quot;. For example, &quot;a&quot; and &quot;A&quot; have different <see cref="Efl.Input.Key.KeySym"/> but the same <see cref="Efl.Input.Key.KeyName"/> &quot;a&quot;.
 100     ///
 101     /// This is the field you typically use to uniquely identify a keyboard symbol, in keyboard shortcuts for example.</summary>
 102     /// <returns>Symbol name produced by key event.</returns>
 103     virtual public System.String GetKeySym() {
 104          var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_sym_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 105         Eina.Error.RaiseIfUnhandledException();
 106         return _ret_var;
 107  }
 108     /// <summary>Name of the symbol produced by this key event.
 109     /// For example, &quot;a&quot;, &quot;A&quot;, &quot;1&quot; or &quot;exclam&quot;. The same physical key can produce different symbols when combined with other keys like &quot;shift&quot; or &quot;alt gr&quot;. For example, &quot;a&quot; and &quot;A&quot; have different <see cref="Efl.Input.Key.KeySym"/> but the same <see cref="Efl.Input.Key.KeyName"/> &quot;a&quot;.
 110     ///
 111     /// This is the field you typically use to uniquely identify a keyboard symbol, in keyboard shortcuts for example.</summary>
 112     /// <param name="val">Symbol name produced by key event.</param>
 113     virtual public void SetKeySym(System.String val) {
 114                                  Efl.Input.Key.NativeMethods.efl_input_key_sym_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 115         Eina.Error.RaiseIfUnhandledException();
 116                          }
 117     /// <summary>A UTF8 string if this keystroke has produced a visible string to be added.</summary>
 118     /// <returns>Visible string produced by this key event, in UTF8.</returns>
 119     virtual public System.String GetString() {
 120          var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_string_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 121         Eina.Error.RaiseIfUnhandledException();
 122         return _ret_var;
 123  }
 124     /// <summary>A UTF8 string if this keystroke has produced a visible string to be added.</summary>
 125     /// <param name="val">Visible string produced by this key event, in UTF8.</param>
 126     virtual public void SetString(System.String val) {
 127                                  Efl.Input.Key.NativeMethods.efl_input_key_string_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 128         Eina.Error.RaiseIfUnhandledException();
 129                          }
 130     /// <summary>A UTF8 string if this keystroke has modified a string in the middle of being composed.
 131     /// Note: This string replaces the previous one.</summary>
 132     /// <returns>Composed string in UTF8.</returns>
 133     virtual public System.String GetComposeString() {
 134          var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_compose_string_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 135         Eina.Error.RaiseIfUnhandledException();
 136         return _ret_var;
 137  }
 138     /// <summary>A UTF8 string if this keystroke has modified a string in the middle of being composed.
 139     /// Note: This string replaces the previous one.</summary>
 140     /// <param name="val">Composed string in UTF8.</param>
 141     virtual public void SetComposeString(System.String val) {
 142                                  Efl.Input.Key.NativeMethods.efl_input_key_compose_string_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 143         Eina.Error.RaiseIfUnhandledException();
 144                          }
 145     /// <summary>Keyboard scan code of the physical key that produced this event.
 146     /// You typically do not need to use this field, because the system maps scan codes to the more convenient <see cref="Efl.Input.Key.KeyName"/>. Us this in keyboard remapping applications or when trying to use a keyboard unknown to your operating system.</summary>
 147     /// <returns>Keyboard scan code.</returns>
 148     virtual public int GetKeyCode() {
 149          var _ret_var = Efl.Input.Key.NativeMethods.efl_input_key_code_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 150         Eina.Error.RaiseIfUnhandledException();
 151         return _ret_var;
 152  }
 153     /// <summary>Keyboard scan code of the physical key that produced this event.
 154     /// You typically do not need to use this field, because the system maps scan codes to the more convenient <see cref="Efl.Input.Key.KeyName"/>. Us this in keyboard remapping applications or when trying to use a keyboard unknown to your operating system.</summary>
 155     /// <param name="val">Keyboard scan code.</param>
 156     virtual public void SetKeyCode(int val) {
 157                                  Efl.Input.Key.NativeMethods.efl_input_key_code_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 158         Eina.Error.RaiseIfUnhandledException();
 159                          }
 160     /// <summary>Creates a carbon copy of this object and returns it.
 161     /// The newly created object will have no event handlers or anything of the sort.</summary>
 162     /// <returns>Returned carbon copy</returns>
 163     virtual public Efl.IDuplicate Duplicate() {
 164          var _ret_var = Efl.IDuplicateConcrete.NativeMethods.efl_duplicate_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 165         Eina.Error.RaiseIfUnhandledException();
 166         return _ret_var;
 167  }
 168     /// <summary>The time at which an event was generated.
 169     /// 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>
 170     /// <returns>Time in milliseconds when the event happened.</returns>
 171     virtual public double GetTimestamp() {
 172          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_timestamp_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 173         Eina.Error.RaiseIfUnhandledException();
 174         return _ret_var;
 175  }
 176     /// <summary>Call this when generating events manually.</summary>
 177     /// <param name="ms">Time in milliseconds when the event happened.</param>
 178     virtual public void SetTimestamp(double ms) {
 179                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_timestamp_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),ms);
 180         Eina.Error.RaiseIfUnhandledException();
 181                          }
 182     /// <summary>Input device that originated this event.</summary>
 183     /// <returns>Input device origin</returns>
 184     virtual public Efl.Input.Device GetDevice() {
 185          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_device_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 186         Eina.Error.RaiseIfUnhandledException();
 187         return _ret_var;
 188  }
 189     /// <summary>Input device that originated this event.</summary>
 190     /// <param name="dev">Input device origin</param>
 191     virtual public void SetDevice(Efl.Input.Device dev) {
 192                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_device_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dev);
 193         Eina.Error.RaiseIfUnhandledException();
 194                          }
 195     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 196     /// <returns>Input event flags</returns>
 197     virtual public Efl.Input.Flags GetEventFlags() {
 198          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_event_flags_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 199         Eina.Error.RaiseIfUnhandledException();
 200         return _ret_var;
 201  }
 202     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 203     /// <param name="flags">Input event flags</param>
 204     virtual public void SetEventFlags(Efl.Input.Flags flags) {
 205                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_event_flags_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),flags);
 206         Eina.Error.RaiseIfUnhandledException();
 207                          }
 208     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 209     /// <returns><c>true</c> if the event is on hold, <c>false</c> otherwise</returns>
 210     virtual public bool GetProcessed() {
 211          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_processed_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 212         Eina.Error.RaiseIfUnhandledException();
 213         return _ret_var;
 214  }
 215     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 216     /// <param name="val"><c>true</c> if the event is on hold, <c>false</c> otherwise</param>
 217     virtual public void SetProcessed(bool val) {
 218                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_processed_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 219         Eina.Error.RaiseIfUnhandledException();
 220                          }
 221     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 222     /// <returns><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</returns>
 223     virtual public bool GetScrolling() {
 224          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_scrolling_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 225         Eina.Error.RaiseIfUnhandledException();
 226         return _ret_var;
 227  }
 228     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 229     /// <param name="val"><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</param>
 230     virtual public void SetScrolling(bool val) {
 231                                  Efl.Input.IEventConcrete.NativeMethods.efl_input_scrolling_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 232         Eina.Error.RaiseIfUnhandledException();
 233                          }
 234     /// <summary><c>true</c> if the event was fake, not triggered by real hardware.</summary>
 235     /// <returns><c>true</c> if the event was not from real hardware, <c>false</c> otherwise</returns>
 236     virtual public bool GetFake() {
 237          var _ret_var = Efl.Input.IEventConcrete.NativeMethods.efl_input_fake_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 238         Eina.Error.RaiseIfUnhandledException();
 239         return _ret_var;
 240  }
 241     /// <summary>Resets the internal data to 0 or default values.</summary>
 242     virtual public void Reset() {
 243          Efl.Input.IEventConcrete.NativeMethods.efl_input_reset_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 244         Eina.Error.RaiseIfUnhandledException();
 245          }
 246     /// <summary>Indicates whether a key modifier is on, such as Ctrl, Shift, ...
 247     /// (Since EFL 1.22)
 248     ///
 249     /// <b>This is a BETA method</b>. It can be modified or removed in the future. Do not use it for product development.</summary>
 250     /// <param name="mod">The modifier key to test.</param>
 251     /// <param name="seat">The seat device, may be <c>null</c></param>
 252     /// <returns><c>true</c> if the key modifier is pressed.</returns>
 253     virtual public bool GetModifierEnabled(Efl.Input.Modifier mod, Efl.Input.Device seat) {
 254                                                          var _ret_var = Efl.Input.IStateConcrete.NativeMethods.efl_input_modifier_enabled_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),mod, seat);
 255         Eina.Error.RaiseIfUnhandledException();
 256                                         return _ret_var;
 257  }
 258     /// <summary>Indicates whether a key lock is on, such as NumLock, CapsLock, ...
 259     /// (Since EFL 1.22)
 260     ///
 261     /// <b>This is a BETA method</b>. It can be modified or removed in the future. Do not use it for product development.</summary>
 262     /// <param name="kw_lock">The lock key to test.</param>
 263     /// <param name="seat">The seat device, may be <c>null</c></param>
 264     /// <returns><c>true</c> if the key lock is on.</returns>
 265     virtual public bool GetLockEnabled(Efl.Input.Lock kw_lock, Efl.Input.Device seat) {
 266                                                          var _ret_var = Efl.Input.IStateConcrete.NativeMethods.efl_input_lock_enabled_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),kw_lock, seat);
 267         Eina.Error.RaiseIfUnhandledException();
 268                                         return _ret_var;
 269  }
 270     /// <summary><c>true</c> if the key is down, <c>false</c> if it is released.</summary>
 271     /// <value><c>true</c> if the key is pressed, <c>false</c> otherwise.</value>
 272     public bool Pressed {
 273         get { return GetPressed(); }
 274         set { SetPressed(value); }
 275     }
 276     /// <summary>Name string of the physical key that produced this event.
 277     /// This typically matches what is printed on the key. For example, &quot;1&quot; or &quot;a&quot;. Note that both &quot;a&quot; and &quot;A&quot; are obtained with the same physical key, so both events will have the same <see cref="Efl.Input.Key.KeyName"/> &quot;a&quot; but different <see cref="Efl.Input.Key.KeySym"/>.
 278     ///
 279     /// Commonly used in keyboard remapping menus to uniquely identify a physical key.</summary>
 280     /// <value>Name of the key that produced this event.</value>
 281     public System.String KeyName {
 282         get { return GetKeyName(); }
 283         set { SetKeyName(value); }
 284     }
 285     /// <summary>Name of the symbol produced by this key event.
 286     /// For example, &quot;a&quot;, &quot;A&quot;, &quot;1&quot; or &quot;exclam&quot;. The same physical key can produce different symbols when combined with other keys like &quot;shift&quot; or &quot;alt gr&quot;. For example, &quot;a&quot; and &quot;A&quot; have different <see cref="Efl.Input.Key.KeySym"/> but the same <see cref="Efl.Input.Key.KeyName"/> &quot;a&quot;.
 287     ///
 288     /// This is the field you typically use to uniquely identify a keyboard symbol, in keyboard shortcuts for example.</summary>
 289     /// <value>Symbol name produced by key event.</value>
 290     public System.String KeySym {
 291         get { return GetKeySym(); }
 292         set { SetKeySym(value); }
 293     }
 294     /// <summary>A UTF8 string if this keystroke has produced a visible string to be added.</summary>
 295     /// <value>Visible string produced by this key event, in UTF8.</value>
 296     public System.String String {
 297         get { return GetString(); }
 298         set { SetString(value); }
 299     }
 300     /// <summary>A UTF8 string if this keystroke has modified a string in the middle of being composed.
 301     /// Note: This string replaces the previous one.</summary>
 302     /// <value>Composed string in UTF8.</value>
 303     public System.String ComposeString {
 304         get { return GetComposeString(); }
 305         set { SetComposeString(value); }
 306     }
 307     /// <summary>Keyboard scan code of the physical key that produced this event.
 308     /// You typically do not need to use this field, because the system maps scan codes to the more convenient <see cref="Efl.Input.Key.KeyName"/>. Us this in keyboard remapping applications or when trying to use a keyboard unknown to your operating system.</summary>
 309     /// <value>Keyboard scan code.</value>
 310     public int KeyCode {
 311         get { return GetKeyCode(); }
 312         set { SetKeyCode(value); }
 313     }
 314     /// <summary>The time at which an event was generated.
 315     /// 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>
 316     /// <value>Time in milliseconds when the event happened.</value>
 317     public double Timestamp {
 318         get { return GetTimestamp(); }
 319         set { SetTimestamp(value); }
 320     }
 321     /// <summary>Input device that originated this event.</summary>
 322     /// <value>Input device origin</value>
 323     public Efl.Input.Device Device {
 324         get { return GetDevice(); }
 325         set { SetDevice(value); }
 326     }
 327     /// <summary>Extra flags for this event, may be changed by the user.</summary>
 328     /// <value>Input event flags</value>
 329     public Efl.Input.Flags EventFlags {
 330         get { return GetEventFlags(); }
 331         set { SetEventFlags(value); }
 332     }
 333     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event is on hold.</summary>
 334     /// <value><c>true</c> if the event is on hold, <c>false</c> otherwise</value>
 335     public bool Processed {
 336         get { return GetProcessed(); }
 337         set { SetProcessed(value); }
 338     }
 339     /// <summary><c>true</c> if <see cref="Efl.Input.IEvent.EventFlags"/> indicates the event happened while scrolling.</summary>
 340     /// <value><c>true</c> if the event happened while scrolling, <c>false</c> otherwise</value>
 341     public bool Scrolling {
 342         get { return GetScrolling(); }
 343         set { SetScrolling(value); }
 344     }
 345     /// <summary><c>true</c> if the event was fake, not triggered by real hardware.</summary>
 346     /// <value><c>true</c> if the event was not from real hardware, <c>false</c> otherwise</value>
 347     public bool Fake {
 348         get { return GetFake(); }
 349     }
 350     private static IntPtr GetEflClassStatic()
 351     {
 352         return Efl.Input.Key.efl_input_key_class_get();
 353     }
 354     /// <summary>Wrapper for native methods and virtual method delegates.
 355     /// For internal use by generated code only.</summary>
 356     public new class NativeMethods : Efl.Object.NativeMethods
 357     {
 358         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 359         /// <summary>Gets the list of Eo operations to override.</summary>
 360         /// <returns>The list of Eo operations to be overload.</returns>
 361         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 362         {
 363             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 364             var methods = Efl.Eo.Globals.GetUserMethods(type);
 365
 366             if (efl_input_key_pressed_get_static_delegate == null)
 367             {
 368                 efl_input_key_pressed_get_static_delegate = new efl_input_key_pressed_get_delegate(pressed_get);
 369             }
 370
 371             if (methods.FirstOrDefault(m => m.Name == "GetPressed") != null)
 372             {
 373                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_pressed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_pressed_get_static_delegate) });
 374             }
 375
 376             if (efl_input_key_pressed_set_static_delegate == null)
 377             {
 378                 efl_input_key_pressed_set_static_delegate = new efl_input_key_pressed_set_delegate(pressed_set);
 379             }
 380
 381             if (methods.FirstOrDefault(m => m.Name == "SetPressed") != null)
 382             {
 383                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_pressed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_pressed_set_static_delegate) });
 384             }
 385
 386             if (efl_input_key_name_get_static_delegate == null)
 387             {
 388                 efl_input_key_name_get_static_delegate = new efl_input_key_name_get_delegate(key_name_get);
 389             }
 390
 391             if (methods.FirstOrDefault(m => m.Name == "GetKeyName") != null)
 392             {
 393                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_name_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_name_get_static_delegate) });
 394             }
 395
 396             if (efl_input_key_name_set_static_delegate == null)
 397             {
 398                 efl_input_key_name_set_static_delegate = new efl_input_key_name_set_delegate(key_name_set);
 399             }
 400
 401             if (methods.FirstOrDefault(m => m.Name == "SetKeyName") != null)
 402             {
 403                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_name_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_name_set_static_delegate) });
 404             }
 405
 406             if (efl_input_key_sym_get_static_delegate == null)
 407             {
 408                 efl_input_key_sym_get_static_delegate = new efl_input_key_sym_get_delegate(key_sym_get);
 409             }
 410
 411             if (methods.FirstOrDefault(m => m.Name == "GetKeySym") != null)
 412             {
 413                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_sym_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_sym_get_static_delegate) });
 414             }
 415
 416             if (efl_input_key_sym_set_static_delegate == null)
 417             {
 418                 efl_input_key_sym_set_static_delegate = new efl_input_key_sym_set_delegate(key_sym_set);
 419             }
 420
 421             if (methods.FirstOrDefault(m => m.Name == "SetKeySym") != null)
 422             {
 423                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_sym_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_sym_set_static_delegate) });
 424             }
 425
 426             if (efl_input_key_string_get_static_delegate == null)
 427             {
 428                 efl_input_key_string_get_static_delegate = new efl_input_key_string_get_delegate(string_get);
 429             }
 430
 431             if (methods.FirstOrDefault(m => m.Name == "GetString") != null)
 432             {
 433                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_string_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_string_get_static_delegate) });
 434             }
 435
 436             if (efl_input_key_string_set_static_delegate == null)
 437             {
 438                 efl_input_key_string_set_static_delegate = new efl_input_key_string_set_delegate(string_set);
 439             }
 440
 441             if (methods.FirstOrDefault(m => m.Name == "SetString") != null)
 442             {
 443                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_string_set_static_delegate) });
 444             }
 445
 446             if (efl_input_key_compose_string_get_static_delegate == null)
 447             {
 448                 efl_input_key_compose_string_get_static_delegate = new efl_input_key_compose_string_get_delegate(compose_string_get);
 449             }
 450
 451             if (methods.FirstOrDefault(m => m.Name == "GetComposeString") != null)
 452             {
 453                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_compose_string_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_compose_string_get_static_delegate) });
 454             }
 455
 456             if (efl_input_key_compose_string_set_static_delegate == null)
 457             {
 458                 efl_input_key_compose_string_set_static_delegate = new efl_input_key_compose_string_set_delegate(compose_string_set);
 459             }
 460
 461             if (methods.FirstOrDefault(m => m.Name == "SetComposeString") != null)
 462             {
 463                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_compose_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_compose_string_set_static_delegate) });
 464             }
 465
 466             if (efl_input_key_code_get_static_delegate == null)
 467             {
 468                 efl_input_key_code_get_static_delegate = new efl_input_key_code_get_delegate(key_code_get);
 469             }
 470
 471             if (methods.FirstOrDefault(m => m.Name == "GetKeyCode") != null)
 472             {
 473                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_code_get"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_code_get_static_delegate) });
 474             }
 475
 476             if (efl_input_key_code_set_static_delegate == null)
 477             {
 478                 efl_input_key_code_set_static_delegate = new efl_input_key_code_set_delegate(key_code_set);
 479             }
 480
 481             if (methods.FirstOrDefault(m => m.Name == "SetKeyCode") != null)
 482             {
 483                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_input_key_code_set"), func = Marshal.GetFunctionPointerForDelegate(efl_input_key_code_set_static_delegate) });
 484             }
 485
 486             if (efl_duplicate_static_delegate == null)
 487             {
 488                 efl_duplicate_static_delegate = new efl_duplicate_delegate(duplicate);
 489             }
 490
 491             if (methods.FirstOrDefault(m => m.Name == "Duplicate") != null)
 492             {
 493                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_duplicate"), func = Marshal.GetFunctionPointerForDelegate(efl_duplicate_static_delegate) });
 494             }
 495
 496             if (efl_input_timestamp_get_static_delegate == null)
 497             {
 498                 efl_input_timestamp_get_static_delegate = new efl_input_timestamp_get_delegate(timestamp_get);
 499             }
 500
 501             if (methods.FirstOrDefault(m => m.Name == "GetTimestamp") != null)
 502             {
 503                 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) });
 504             }
 505
 506             if (efl_input_timestamp_set_static_delegate == null)
 507             {
 508                 efl_input_timestamp_set_static_delegate = new efl_input_timestamp_set_delegate(timestamp_set);
 509             }
 510
 511             if (methods.FirstOrDefault(m => m.Name == "SetTimestamp") != null)
 512             {
 513                 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) });
 514             }
 515
 516             if (efl_input_device_get_static_delegate == null)
 517             {
 518                 efl_input_device_get_static_delegate = new efl_input_device_get_delegate(device_get);
 519             }
 520
 521             if (methods.FirstOrDefault(m => m.Name == "GetDevice") != null)
 522             {
 523                 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) });
 524             }
 525
 526             if (efl_input_device_set_static_delegate == null)
 527             {
 528                 efl_input_device_set_static_delegate = new efl_input_device_set_delegate(device_set);
 529             }
 530
 531             if (methods.FirstOrDefault(m => m.Name == "SetDevice") != null)
 532             {
 533                 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) });
 534             }
 535
 536             if (efl_input_event_flags_get_static_delegate == null)
 537             {
 538                 efl_input_event_flags_get_static_delegate = new efl_input_event_flags_get_delegate(event_flags_get);
 539             }
 540
 541             if (methods.FirstOrDefault(m => m.Name == "GetEventFlags") != null)
 542             {
 543                 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) });
 544             }
 545
 546             if (efl_input_event_flags_set_static_delegate == null)
 547             {
 548                 efl_input_event_flags_set_static_delegate = new efl_input_event_flags_set_delegate(event_flags_set);
 549             }
 550
 551             if (methods.FirstOrDefault(m => m.Name == "SetEventFlags") != null)
 552             {
 553                 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) });
 554             }
 555
 556             if (efl_input_processed_get_static_delegate == null)
 557             {
 558                 efl_input_processed_get_static_delegate = new efl_input_processed_get_delegate(processed_get);
 559             }
 560
 561             if (methods.FirstOrDefault(m => m.Name == "GetProcessed") != null)
 562             {
 563                 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) });
 564             }
 565
 566             if (efl_input_processed_set_static_delegate == null)
 567             {
 568                 efl_input_processed_set_static_delegate = new efl_input_processed_set_delegate(processed_set);
 569             }
 570
 571             if (methods.FirstOrDefault(m => m.Name == "SetProcessed") != null)
 572             {
 573                 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) });
 574             }
 575
 576             if (efl_input_scrolling_get_static_delegate == null)
 577             {
 578                 efl_input_scrolling_get_static_delegate = new efl_input_scrolling_get_delegate(scrolling_get);
 579             }
 580
 581             if (methods.FirstOrDefault(m => m.Name == "GetScrolling") != null)
 582             {
 583                 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) });
 584             }
 585
 586             if (efl_input_scrolling_set_static_delegate == null)
 587             {
 588                 efl_input_scrolling_set_static_delegate = new efl_input_scrolling_set_delegate(scrolling_set);
 589             }
 590
 591             if (methods.FirstOrDefault(m => m.Name == "SetScrolling") != null)
 592             {
 593                 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) });
 594             }
 595
 596             if (efl_input_fake_get_static_delegate == null)
 597             {
 598                 efl_input_fake_get_static_delegate = new efl_input_fake_get_delegate(fake_get);
 599             }
 600
 601             if (methods.FirstOrDefault(m => m.Name == "GetFake") != null)
 602             {
 603                 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) });
 604             }
 605
 606             if (efl_input_reset_static_delegate == null)
 607             {
 608                 efl_input_reset_static_delegate = new efl_input_reset_delegate(reset);
 609             }
 610
 611             if (methods.FirstOrDefault(m => m.Name == "Reset") != null)
 612             {
 613                 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) });
 614             }
 615
 616             if (efl_input_modifier_enabled_get_static_delegate == null)
 617             {
 618                 efl_input_modifier_enabled_get_static_delegate = new efl_input_modifier_enabled_get_delegate(modifier_enabled_get);
 619             }
 620
 621             if (methods.FirstOrDefault(m => m.Name == "GetModifierEnabled") != null)
 622             {
 623                 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) });
 624             }
 625
 626             if (efl_input_lock_enabled_get_static_delegate == null)
 627             {
 628                 efl_input_lock_enabled_get_static_delegate = new efl_input_lock_enabled_get_delegate(lock_enabled_get);
 629             }
 630
 631             if (methods.FirstOrDefault(m => m.Name == "GetLockEnabled") != null)
 632             {
 633                 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) });
 634             }
 635
 636             descs.AddRange(base.GetEoOps(type));
 637             return descs;
 638         }
 639         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 640         /// <returns>The native class pointer.</returns>
 641         public override IntPtr GetEflClass()
 642         {
 643             return Efl.Input.Key.efl_input_key_class_get();
 644         }
 645
 646         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 647
 648         [return: MarshalAs(UnmanagedType.U1)]
 649         private delegate bool efl_input_key_pressed_get_delegate(System.IntPtr obj, System.IntPtr pd);
 650
 651         [return: MarshalAs(UnmanagedType.U1)]
 652         public delegate bool efl_input_key_pressed_get_api_delegate(System.IntPtr obj);
 653
 654         public static Efl.Eo.FunctionWrapper<efl_input_key_pressed_get_api_delegate> efl_input_key_pressed_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_pressed_get_api_delegate>(Module, "efl_input_key_pressed_get");
 655
 656         private static bool pressed_get(System.IntPtr obj, System.IntPtr pd)
 657         {
 658             Eina.Log.Debug("function efl_input_key_pressed_get was called");
 659             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 660             if (ws != null)
 661             {
 662             bool _ret_var = default(bool);
 663                 try
 664                 {
 665                     _ret_var = ((Key)ws.Target).GetPressed();
 666                 }
 667                 catch (Exception e)
 668                 {
 669                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 670                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 671                 }
 672
 673         return _ret_var;
 674
 675             }
 676             else
 677             {
 678                 return efl_input_key_pressed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 679             }
 680         }
 681
 682         private static efl_input_key_pressed_get_delegate efl_input_key_pressed_get_static_delegate;
 683
 684
 685         private delegate void efl_input_key_pressed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
 686
 687
 688         public delegate void efl_input_key_pressed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
 689
 690         public static Efl.Eo.FunctionWrapper<efl_input_key_pressed_set_api_delegate> efl_input_key_pressed_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_pressed_set_api_delegate>(Module, "efl_input_key_pressed_set");
 691
 692         private static void pressed_set(System.IntPtr obj, System.IntPtr pd, bool val)
 693         {
 694             Eina.Log.Debug("function efl_input_key_pressed_set was called");
 695             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 696             if (ws != null)
 697             {
 698
 699                 try
 700                 {
 701                     ((Key)ws.Target).SetPressed(val);
 702                 }
 703                 catch (Exception e)
 704                 {
 705                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 706                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 707                 }
 708
 709
 710             }
 711             else
 712             {
 713                 efl_input_key_pressed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 714             }
 715         }
 716
 717         private static efl_input_key_pressed_set_delegate efl_input_key_pressed_set_static_delegate;
 718
 719         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 720         private delegate System.String efl_input_key_name_get_delegate(System.IntPtr obj, System.IntPtr pd);
 721
 722         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 723         public delegate System.String efl_input_key_name_get_api_delegate(System.IntPtr obj);
 724
 725         public static Efl.Eo.FunctionWrapper<efl_input_key_name_get_api_delegate> efl_input_key_name_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_name_get_api_delegate>(Module, "efl_input_key_name_get");
 726
 727         private static System.String key_name_get(System.IntPtr obj, System.IntPtr pd)
 728         {
 729             Eina.Log.Debug("function efl_input_key_name_get was called");
 730             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 731             if (ws != null)
 732             {
 733             System.String _ret_var = default(System.String);
 734                 try
 735                 {
 736                     _ret_var = ((Key)ws.Target).GetKeyName();
 737                 }
 738                 catch (Exception e)
 739                 {
 740                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 741                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 742                 }
 743
 744         return _ret_var;
 745
 746             }
 747             else
 748             {
 749                 return efl_input_key_name_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 750             }
 751         }
 752
 753         private static efl_input_key_name_get_delegate efl_input_key_name_get_static_delegate;
 754
 755
 756         private delegate void efl_input_key_name_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 757
 758
 759         public delegate void efl_input_key_name_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 760
 761         public static Efl.Eo.FunctionWrapper<efl_input_key_name_set_api_delegate> efl_input_key_name_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_name_set_api_delegate>(Module, "efl_input_key_name_set");
 762
 763         private static void key_name_set(System.IntPtr obj, System.IntPtr pd, System.String val)
 764         {
 765             Eina.Log.Debug("function efl_input_key_name_set was called");
 766             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 767             if (ws != null)
 768             {
 769
 770                 try
 771                 {
 772                     ((Key)ws.Target).SetKeyName(val);
 773                 }
 774                 catch (Exception e)
 775                 {
 776                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 777                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 778                 }
 779
 780
 781             }
 782             else
 783             {
 784                 efl_input_key_name_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 785             }
 786         }
 787
 788         private static efl_input_key_name_set_delegate efl_input_key_name_set_static_delegate;
 789
 790         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 791         private delegate System.String efl_input_key_sym_get_delegate(System.IntPtr obj, System.IntPtr pd);
 792
 793         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 794         public delegate System.String efl_input_key_sym_get_api_delegate(System.IntPtr obj);
 795
 796         public static Efl.Eo.FunctionWrapper<efl_input_key_sym_get_api_delegate> efl_input_key_sym_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_sym_get_api_delegate>(Module, "efl_input_key_sym_get");
 797
 798         private static System.String key_sym_get(System.IntPtr obj, System.IntPtr pd)
 799         {
 800             Eina.Log.Debug("function efl_input_key_sym_get was called");
 801             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 802             if (ws != null)
 803             {
 804             System.String _ret_var = default(System.String);
 805                 try
 806                 {
 807                     _ret_var = ((Key)ws.Target).GetKeySym();
 808                 }
 809                 catch (Exception e)
 810                 {
 811                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 812                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 813                 }
 814
 815         return _ret_var;
 816
 817             }
 818             else
 819             {
 820                 return efl_input_key_sym_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 821             }
 822         }
 823
 824         private static efl_input_key_sym_get_delegate efl_input_key_sym_get_static_delegate;
 825
 826
 827         private delegate void efl_input_key_sym_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 828
 829
 830         public delegate void efl_input_key_sym_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 831
 832         public static Efl.Eo.FunctionWrapper<efl_input_key_sym_set_api_delegate> efl_input_key_sym_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_sym_set_api_delegate>(Module, "efl_input_key_sym_set");
 833
 834         private static void key_sym_set(System.IntPtr obj, System.IntPtr pd, System.String val)
 835         {
 836             Eina.Log.Debug("function efl_input_key_sym_set was called");
 837             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 838             if (ws != null)
 839             {
 840
 841                 try
 842                 {
 843                     ((Key)ws.Target).SetKeySym(val);
 844                 }
 845                 catch (Exception e)
 846                 {
 847                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 848                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 849                 }
 850
 851
 852             }
 853             else
 854             {
 855                 efl_input_key_sym_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 856             }
 857         }
 858
 859         private static efl_input_key_sym_set_delegate efl_input_key_sym_set_static_delegate;
 860
 861         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 862         private delegate System.String efl_input_key_string_get_delegate(System.IntPtr obj, System.IntPtr pd);
 863
 864         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 865         public delegate System.String efl_input_key_string_get_api_delegate(System.IntPtr obj);
 866
 867         public static Efl.Eo.FunctionWrapper<efl_input_key_string_get_api_delegate> efl_input_key_string_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_string_get_api_delegate>(Module, "efl_input_key_string_get");
 868
 869         private static System.String string_get(System.IntPtr obj, System.IntPtr pd)
 870         {
 871             Eina.Log.Debug("function efl_input_key_string_get was called");
 872             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 873             if (ws != null)
 874             {
 875             System.String _ret_var = default(System.String);
 876                 try
 877                 {
 878                     _ret_var = ((Key)ws.Target).GetString();
 879                 }
 880                 catch (Exception e)
 881                 {
 882                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 883                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 884                 }
 885
 886         return _ret_var;
 887
 888             }
 889             else
 890             {
 891                 return efl_input_key_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 892             }
 893         }
 894
 895         private static efl_input_key_string_get_delegate efl_input_key_string_get_static_delegate;
 896
 897
 898         private delegate void efl_input_key_string_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 899
 900
 901         public delegate void efl_input_key_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 902
 903         public static Efl.Eo.FunctionWrapper<efl_input_key_string_set_api_delegate> efl_input_key_string_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_string_set_api_delegate>(Module, "efl_input_key_string_set");
 904
 905         private static void string_set(System.IntPtr obj, System.IntPtr pd, System.String val)
 906         {
 907             Eina.Log.Debug("function efl_input_key_string_set was called");
 908             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 909             if (ws != null)
 910             {
 911
 912                 try
 913                 {
 914                     ((Key)ws.Target).SetString(val);
 915                 }
 916                 catch (Exception e)
 917                 {
 918                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 919                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 920                 }
 921
 922
 923             }
 924             else
 925             {
 926                 efl_input_key_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 927             }
 928         }
 929
 930         private static efl_input_key_string_set_delegate efl_input_key_string_set_static_delegate;
 931
 932         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 933         private delegate System.String efl_input_key_compose_string_get_delegate(System.IntPtr obj, System.IntPtr pd);
 934
 935         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 936         public delegate System.String efl_input_key_compose_string_get_api_delegate(System.IntPtr obj);
 937
 938         public static Efl.Eo.FunctionWrapper<efl_input_key_compose_string_get_api_delegate> efl_input_key_compose_string_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_compose_string_get_api_delegate>(Module, "efl_input_key_compose_string_get");
 939
 940         private static System.String compose_string_get(System.IntPtr obj, System.IntPtr pd)
 941         {
 942             Eina.Log.Debug("function efl_input_key_compose_string_get was called");
 943             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 944             if (ws != null)
 945             {
 946             System.String _ret_var = default(System.String);
 947                 try
 948                 {
 949                     _ret_var = ((Key)ws.Target).GetComposeString();
 950                 }
 951                 catch (Exception e)
 952                 {
 953                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 954                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 955                 }
 956
 957         return _ret_var;
 958
 959             }
 960             else
 961             {
 962                 return efl_input_key_compose_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 963             }
 964         }
 965
 966         private static efl_input_key_compose_string_get_delegate efl_input_key_compose_string_get_static_delegate;
 967
 968
 969         private delegate void efl_input_key_compose_string_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 970
 971
 972         public delegate void efl_input_key_compose_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String val);
 973
 974         public static Efl.Eo.FunctionWrapper<efl_input_key_compose_string_set_api_delegate> efl_input_key_compose_string_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_compose_string_set_api_delegate>(Module, "efl_input_key_compose_string_set");
 975
 976         private static void compose_string_set(System.IntPtr obj, System.IntPtr pd, System.String val)
 977         {
 978             Eina.Log.Debug("function efl_input_key_compose_string_set was called");
 979             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 980             if (ws != null)
 981             {
 982
 983                 try
 984                 {
 985                     ((Key)ws.Target).SetComposeString(val);
 986                 }
 987                 catch (Exception e)
 988                 {
 989                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 990                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 991                 }
 992
 993
 994             }
 995             else
 996             {
 997                 efl_input_key_compose_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 998             }
 999         }
1000
1001         private static efl_input_key_compose_string_set_delegate efl_input_key_compose_string_set_static_delegate;
1002
1003
1004         private delegate int efl_input_key_code_get_delegate(System.IntPtr obj, System.IntPtr pd);
1005
1006
1007         public delegate int efl_input_key_code_get_api_delegate(System.IntPtr obj);
1008
1009         public static Efl.Eo.FunctionWrapper<efl_input_key_code_get_api_delegate> efl_input_key_code_get_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_code_get_api_delegate>(Module, "efl_input_key_code_get");
1010
1011         private static int key_code_get(System.IntPtr obj, System.IntPtr pd)
1012         {
1013             Eina.Log.Debug("function efl_input_key_code_get was called");
1014             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1015             if (ws != null)
1016             {
1017             int _ret_var = default(int);
1018                 try
1019                 {
1020                     _ret_var = ((Key)ws.Target).GetKeyCode();
1021                 }
1022                 catch (Exception e)
1023                 {
1024                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1025                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1026                 }
1027
1028         return _ret_var;
1029
1030             }
1031             else
1032             {
1033                 return efl_input_key_code_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1034             }
1035         }
1036
1037         private static efl_input_key_code_get_delegate efl_input_key_code_get_static_delegate;
1038
1039
1040         private delegate void efl_input_key_code_set_delegate(System.IntPtr obj, System.IntPtr pd,  int val);
1041
1042
1043         public delegate void efl_input_key_code_set_api_delegate(System.IntPtr obj,  int val);
1044
1045         public static Efl.Eo.FunctionWrapper<efl_input_key_code_set_api_delegate> efl_input_key_code_set_ptr = new Efl.Eo.FunctionWrapper<efl_input_key_code_set_api_delegate>(Module, "efl_input_key_code_set");
1046
1047         private static void key_code_set(System.IntPtr obj, System.IntPtr pd, int val)
1048         {
1049             Eina.Log.Debug("function efl_input_key_code_set was called");
1050             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1051             if (ws != null)
1052             {
1053
1054                 try
1055                 {
1056                     ((Key)ws.Target).SetKeyCode(val);
1057                 }
1058                 catch (Exception e)
1059                 {
1060                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1061                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1062                 }
1063
1064
1065             }
1066             else
1067             {
1068                 efl_input_key_code_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1069             }
1070         }
1071
1072         private static efl_input_key_code_set_delegate efl_input_key_code_set_static_delegate;
1073
1074         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
1075         private delegate Efl.IDuplicate efl_duplicate_delegate(System.IntPtr obj, System.IntPtr pd);
1076
1077         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
1078         public delegate Efl.IDuplicate efl_duplicate_api_delegate(System.IntPtr obj);
1079
1080         public static Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate> efl_duplicate_ptr = new Efl.Eo.FunctionWrapper<efl_duplicate_api_delegate>(Module, "efl_duplicate");
1081
1082         private static Efl.IDuplicate duplicate(System.IntPtr obj, System.IntPtr pd)
1083         {
1084             Eina.Log.Debug("function efl_duplicate was called");
1085             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1086             if (ws != null)
1087             {
1088             Efl.IDuplicate _ret_var = default(Efl.IDuplicate);
1089                 try
1090                 {
1091                     _ret_var = ((Key)ws.Target).Duplicate();
1092                 }
1093                 catch (Exception e)
1094                 {
1095                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1096                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1097                 }
1098
1099         return _ret_var;
1100
1101             }
1102             else
1103             {
1104                 return efl_duplicate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1105             }
1106         }
1107
1108         private static efl_duplicate_delegate efl_duplicate_static_delegate;
1109
1110
1111         private delegate double efl_input_timestamp_get_delegate(System.IntPtr obj, System.IntPtr pd);
1112
1113
1114         public delegate double efl_input_timestamp_get_api_delegate(System.IntPtr obj);
1115
1116         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");
1117
1118         private static double timestamp_get(System.IntPtr obj, System.IntPtr pd)
1119         {
1120             Eina.Log.Debug("function efl_input_timestamp_get was called");
1121             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1122             if (ws != null)
1123             {
1124             double _ret_var = default(double);
1125                 try
1126                 {
1127                     _ret_var = ((Key)ws.Target).GetTimestamp();
1128                 }
1129                 catch (Exception e)
1130                 {
1131                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1132                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1133                 }
1134
1135         return _ret_var;
1136
1137             }
1138             else
1139             {
1140                 return efl_input_timestamp_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1141             }
1142         }
1143
1144         private static efl_input_timestamp_get_delegate efl_input_timestamp_get_static_delegate;
1145
1146
1147         private delegate void efl_input_timestamp_set_delegate(System.IntPtr obj, System.IntPtr pd,  double ms);
1148
1149
1150         public delegate void efl_input_timestamp_set_api_delegate(System.IntPtr obj,  double ms);
1151
1152         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");
1153
1154         private static void timestamp_set(System.IntPtr obj, System.IntPtr pd, double ms)
1155         {
1156             Eina.Log.Debug("function efl_input_timestamp_set was called");
1157             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1158             if (ws != null)
1159             {
1160
1161                 try
1162                 {
1163                     ((Key)ws.Target).SetTimestamp(ms);
1164                 }
1165                 catch (Exception e)
1166                 {
1167                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1168                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1169                 }
1170
1171
1172             }
1173             else
1174             {
1175                 efl_input_timestamp_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ms);
1176             }
1177         }
1178
1179         private static efl_input_timestamp_set_delegate efl_input_timestamp_set_static_delegate;
1180
1181         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1182         private delegate Efl.Input.Device efl_input_device_get_delegate(System.IntPtr obj, System.IntPtr pd);
1183
1184         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1185         public delegate Efl.Input.Device efl_input_device_get_api_delegate(System.IntPtr obj);
1186
1187         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");
1188
1189         private static Efl.Input.Device device_get(System.IntPtr obj, System.IntPtr pd)
1190         {
1191             Eina.Log.Debug("function efl_input_device_get was called");
1192             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1193             if (ws != null)
1194             {
1195             Efl.Input.Device _ret_var = default(Efl.Input.Device);
1196                 try
1197                 {
1198                     _ret_var = ((Key)ws.Target).GetDevice();
1199                 }
1200                 catch (Exception e)
1201                 {
1202                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1203                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1204                 }
1205
1206         return _ret_var;
1207
1208             }
1209             else
1210             {
1211                 return efl_input_device_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1212             }
1213         }
1214
1215         private static efl_input_device_get_delegate efl_input_device_get_static_delegate;
1216
1217
1218         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);
1219
1220
1221         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);
1222
1223         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");
1224
1225         private static void device_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Device dev)
1226         {
1227             Eina.Log.Debug("function efl_input_device_set was called");
1228             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1229             if (ws != null)
1230             {
1231
1232                 try
1233                 {
1234                     ((Key)ws.Target).SetDevice(dev);
1235                 }
1236                 catch (Exception e)
1237                 {
1238                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1239                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1240                 }
1241
1242
1243             }
1244             else
1245             {
1246                 efl_input_device_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dev);
1247             }
1248         }
1249
1250         private static efl_input_device_set_delegate efl_input_device_set_static_delegate;
1251
1252
1253         private delegate Efl.Input.Flags efl_input_event_flags_get_delegate(System.IntPtr obj, System.IntPtr pd);
1254
1255
1256         public delegate Efl.Input.Flags efl_input_event_flags_get_api_delegate(System.IntPtr obj);
1257
1258         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");
1259
1260         private static Efl.Input.Flags event_flags_get(System.IntPtr obj, System.IntPtr pd)
1261         {
1262             Eina.Log.Debug("function efl_input_event_flags_get was called");
1263             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1264             if (ws != null)
1265             {
1266             Efl.Input.Flags _ret_var = default(Efl.Input.Flags);
1267                 try
1268                 {
1269                     _ret_var = ((Key)ws.Target).GetEventFlags();
1270                 }
1271                 catch (Exception e)
1272                 {
1273                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1274                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1275                 }
1276
1277         return _ret_var;
1278
1279             }
1280             else
1281             {
1282                 return efl_input_event_flags_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1283             }
1284         }
1285
1286         private static efl_input_event_flags_get_delegate efl_input_event_flags_get_static_delegate;
1287
1288
1289         private delegate void efl_input_event_flags_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Input.Flags flags);
1290
1291
1292         public delegate void efl_input_event_flags_set_api_delegate(System.IntPtr obj,  Efl.Input.Flags flags);
1293
1294         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");
1295
1296         private static void event_flags_set(System.IntPtr obj, System.IntPtr pd, Efl.Input.Flags flags)
1297         {
1298             Eina.Log.Debug("function efl_input_event_flags_set was called");
1299             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1300             if (ws != null)
1301             {
1302
1303                 try
1304                 {
1305                     ((Key)ws.Target).SetEventFlags(flags);
1306                 }
1307                 catch (Exception e)
1308                 {
1309                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1310                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1311                 }
1312
1313
1314             }
1315             else
1316             {
1317                 efl_input_event_flags_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), flags);
1318             }
1319         }
1320
1321         private static efl_input_event_flags_set_delegate efl_input_event_flags_set_static_delegate;
1322
1323         [return: MarshalAs(UnmanagedType.U1)]
1324         private delegate bool efl_input_processed_get_delegate(System.IntPtr obj, System.IntPtr pd);
1325
1326         [return: MarshalAs(UnmanagedType.U1)]
1327         public delegate bool efl_input_processed_get_api_delegate(System.IntPtr obj);
1328
1329         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");
1330
1331         private static bool processed_get(System.IntPtr obj, System.IntPtr pd)
1332         {
1333             Eina.Log.Debug("function efl_input_processed_get was called");
1334             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1335             if (ws != null)
1336             {
1337             bool _ret_var = default(bool);
1338                 try
1339                 {
1340                     _ret_var = ((Key)ws.Target).GetProcessed();
1341                 }
1342                 catch (Exception e)
1343                 {
1344                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1345                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1346                 }
1347
1348         return _ret_var;
1349
1350             }
1351             else
1352             {
1353                 return efl_input_processed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1354             }
1355         }
1356
1357         private static efl_input_processed_get_delegate efl_input_processed_get_static_delegate;
1358
1359
1360         private delegate void efl_input_processed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
1361
1362
1363         public delegate void efl_input_processed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
1364
1365         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");
1366
1367         private static void processed_set(System.IntPtr obj, System.IntPtr pd, bool val)
1368         {
1369             Eina.Log.Debug("function efl_input_processed_set was called");
1370             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1371             if (ws != null)
1372             {
1373
1374                 try
1375                 {
1376                     ((Key)ws.Target).SetProcessed(val);
1377                 }
1378                 catch (Exception e)
1379                 {
1380                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1381                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1382                 }
1383
1384
1385             }
1386             else
1387             {
1388                 efl_input_processed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1389             }
1390         }
1391
1392         private static efl_input_processed_set_delegate efl_input_processed_set_static_delegate;
1393
1394         [return: MarshalAs(UnmanagedType.U1)]
1395         private delegate bool efl_input_scrolling_get_delegate(System.IntPtr obj, System.IntPtr pd);
1396
1397         [return: MarshalAs(UnmanagedType.U1)]
1398         public delegate bool efl_input_scrolling_get_api_delegate(System.IntPtr obj);
1399
1400         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");
1401
1402         private static bool scrolling_get(System.IntPtr obj, System.IntPtr pd)
1403         {
1404             Eina.Log.Debug("function efl_input_scrolling_get was called");
1405             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1406             if (ws != null)
1407             {
1408             bool _ret_var = default(bool);
1409                 try
1410                 {
1411                     _ret_var = ((Key)ws.Target).GetScrolling();
1412                 }
1413                 catch (Exception e)
1414                 {
1415                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1416                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1417                 }
1418
1419         return _ret_var;
1420
1421             }
1422             else
1423             {
1424                 return efl_input_scrolling_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1425             }
1426         }
1427
1428         private static efl_input_scrolling_get_delegate efl_input_scrolling_get_static_delegate;
1429
1430
1431         private delegate void efl_input_scrolling_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
1432
1433
1434         public delegate void efl_input_scrolling_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
1435
1436         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");
1437
1438         private static void scrolling_set(System.IntPtr obj, System.IntPtr pd, bool val)
1439         {
1440             Eina.Log.Debug("function efl_input_scrolling_set was called");
1441             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1442             if (ws != null)
1443             {
1444
1445                 try
1446                 {
1447                     ((Key)ws.Target).SetScrolling(val);
1448                 }
1449                 catch (Exception e)
1450                 {
1451                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1452                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1453                 }
1454
1455
1456             }
1457             else
1458             {
1459                 efl_input_scrolling_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1460             }
1461         }
1462
1463         private static efl_input_scrolling_set_delegate efl_input_scrolling_set_static_delegate;
1464
1465         [return: MarshalAs(UnmanagedType.U1)]
1466         private delegate bool efl_input_fake_get_delegate(System.IntPtr obj, System.IntPtr pd);
1467
1468         [return: MarshalAs(UnmanagedType.U1)]
1469         public delegate bool efl_input_fake_get_api_delegate(System.IntPtr obj);
1470
1471         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");
1472
1473         private static bool fake_get(System.IntPtr obj, System.IntPtr pd)
1474         {
1475             Eina.Log.Debug("function efl_input_fake_get was called");
1476             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1477             if (ws != null)
1478             {
1479             bool _ret_var = default(bool);
1480                 try
1481                 {
1482                     _ret_var = ((Key)ws.Target).GetFake();
1483                 }
1484                 catch (Exception e)
1485                 {
1486                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1487                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1488                 }
1489
1490         return _ret_var;
1491
1492             }
1493             else
1494             {
1495                 return efl_input_fake_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1496             }
1497         }
1498
1499         private static efl_input_fake_get_delegate efl_input_fake_get_static_delegate;
1500
1501
1502         private delegate void efl_input_reset_delegate(System.IntPtr obj, System.IntPtr pd);
1503
1504
1505         public delegate void efl_input_reset_api_delegate(System.IntPtr obj);
1506
1507         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");
1508
1509         private static void reset(System.IntPtr obj, System.IntPtr pd)
1510         {
1511             Eina.Log.Debug("function efl_input_reset was called");
1512             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1513             if (ws != null)
1514             {
1515
1516                 try
1517                 {
1518                     ((Key)ws.Target).Reset();
1519                 }
1520                 catch (Exception e)
1521                 {
1522                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1523                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1524                 }
1525
1526
1527             }
1528             else
1529             {
1530                 efl_input_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1531             }
1532         }
1533
1534         private static efl_input_reset_delegate efl_input_reset_static_delegate;
1535
1536         [return: MarshalAs(UnmanagedType.U1)]
1537         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);
1538
1539         [return: MarshalAs(UnmanagedType.U1)]
1540         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);
1541
1542         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");
1543
1544         private static bool modifier_enabled_get(System.IntPtr obj, System.IntPtr pd, Efl.Input.Modifier mod, Efl.Input.Device seat)
1545         {
1546             Eina.Log.Debug("function efl_input_modifier_enabled_get was called");
1547             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1548             if (ws != null)
1549             {
1550                                                             bool _ret_var = default(bool);
1551                 try
1552                 {
1553                     _ret_var = ((Key)ws.Target).GetModifierEnabled(mod, seat);
1554                 }
1555                 catch (Exception e)
1556                 {
1557                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1558                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1559                 }
1560
1561                                         return _ret_var;
1562
1563             }
1564             else
1565             {
1566                 return efl_input_modifier_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mod, seat);
1567             }
1568         }
1569
1570         private static efl_input_modifier_enabled_get_delegate efl_input_modifier_enabled_get_static_delegate;
1571
1572         [return: MarshalAs(UnmanagedType.U1)]
1573         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);
1574
1575         [return: MarshalAs(UnmanagedType.U1)]
1576         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);
1577
1578         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");
1579
1580         private static bool lock_enabled_get(System.IntPtr obj, System.IntPtr pd, Efl.Input.Lock kw_lock, Efl.Input.Device seat)
1581         {
1582             Eina.Log.Debug("function efl_input_lock_enabled_get was called");
1583             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1584             if (ws != null)
1585             {
1586                                                             bool _ret_var = default(bool);
1587                 try
1588                 {
1589                     _ret_var = ((Key)ws.Target).GetLockEnabled(kw_lock, seat);
1590                 }
1591                 catch (Exception e)
1592                 {
1593                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1594                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1595                 }
1596
1597                                         return _ret_var;
1598
1599             }
1600             else
1601             {
1602                 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);
1603             }
1604         }
1605
1606         private static efl_input_lock_enabled_get_delegate efl_input_lock_enabled_get_static_delegate;
1607
1608         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1609
1610 }
1611 }
1612 }
1613
1614 }
1615
1616 #if EFL_BETA
1617 #pragma warning disable CS1591
1618 public static class Efl_InputKey_ExtensionMethods {
1619     public static Efl.BindableProperty<bool> Pressed<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1620         return new Efl.BindableProperty<bool>("pressed", fac);
1621     }
1622
1623     public static Efl.BindableProperty<System.String> KeyName<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1624         return new Efl.BindableProperty<System.String>("key_name", fac);
1625     }
1626
1627     public static Efl.BindableProperty<System.String> KeySym<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1628         return new Efl.BindableProperty<System.String>("key_sym", fac);
1629     }
1630
1631     public static Efl.BindableProperty<System.String> String<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1632         return new Efl.BindableProperty<System.String>("string", fac);
1633     }
1634
1635     public static Efl.BindableProperty<System.String> ComposeString<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1636         return new Efl.BindableProperty<System.String>("compose_string", fac);
1637     }
1638
1639     public static Efl.BindableProperty<int> KeyCode<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1640         return new Efl.BindableProperty<int>("key_code", fac);
1641     }
1642
1643     public static Efl.BindableProperty<double> Timestamp<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1644         return new Efl.BindableProperty<double>("timestamp", fac);
1645     }
1646
1647     public static Efl.BindableProperty<Efl.Input.Device> Device<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1648         return new Efl.BindableProperty<Efl.Input.Device>("device", fac);
1649     }
1650
1651     public static Efl.BindableProperty<Efl.Input.Flags> EventFlags<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1652         return new Efl.BindableProperty<Efl.Input.Flags>("event_flags", fac);
1653     }
1654
1655     public static Efl.BindableProperty<bool> Processed<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1656         return new Efl.BindableProperty<bool>("processed", fac);
1657     }
1658
1659     public static Efl.BindableProperty<bool> Scrolling<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Input.Key, T>magic = null) where T : Efl.Input.Key {
1660         return new Efl.BindableProperty<bool>("scrolling", fac);
1661     }
1662
1663
1664
1665
1666 }
1667 #pragma warning restore CS1591
1668 #endif