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