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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Interface for autorepeating clicks.
  13 /// This interface abstracts functions for enabling / disabling this feature. When enabled, keeping a button pressed will continuously emit the <c>repeated</c> event until the button is released. The time it takes until it starts emitting the event is given by <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
  14 [Efl.Ui.IAutorepeatConcrete.NativeMethods]
  15 public interface IAutorepeat :
  16     Efl.Eo.IWrapper, IDisposable
  17 {
  18     /// <summary>The initial timeout before the autorepeat event is generated.
  19 /// Sets the timeout, in seconds, since the button is pressed until the first <c>repeated</c> signal is emitted. If <c>t</c> is 0.0 or less, there won&apos;t be any delay and the event will be fired the moment the button is pressed.
  20 ///
  21 /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatEnabled"/> and <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
  22 /// <returns>Timeout in seconds.</returns>
  23 double GetAutorepeatInitialTimeout();
  24     /// <summary>The initial timeout before the autorepeat event is generated.
  25 /// Sets the timeout, in seconds, since the button is pressed until the first <c>repeated</c> signal is emitted. If <c>t</c> is 0.0 or less, there won&apos;t be any delay and the event will be fired the moment the button is pressed.
  26 ///
  27 /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatEnabled"/> and <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
  28 /// <param name="t">Timeout in seconds.</param>
  29 void SetAutorepeatInitialTimeout(double t);
  30     /// <summary>The interval between each generated autorepeat event.
  31 /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
  32 ///
  33 /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>.</summary>
  34 /// <returns>Time interval in seconds.</returns>
  35 double GetAutorepeatGapTimeout();
  36     /// <summary>The interval between each generated autorepeat event.
  37 /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
  38 ///
  39 /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>.</summary>
  40 /// <param name="t">Time interval in seconds.</param>
  41 void SetAutorepeatGapTimeout(double t);
  42     /// <summary>Turn on/off the autorepeat event generated when a button is kept pressed.
  43 /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> event when they are clicked.</summary>
  44 /// <returns>A bool to turn on/off the repeat event generation.</returns>
  45 bool GetAutorepeatEnabled();
  46     /// <summary>Turn on/off the autorepeat event generated when a button is kept pressed.
  47 /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> event when they are clicked.</summary>
  48 /// <param name="on">A bool to turn on/off the repeat event generation.</param>
  49 void SetAutorepeatEnabled(bool on);
  50                             /// <summary>Called when a repeated event is emitted</summary>
  51     event EventHandler RepeatedEvt;
  52     /// <summary>The initial timeout before the autorepeat event is generated.
  53     /// Sets the timeout, in seconds, since the button is pressed until the first <c>repeated</c> signal is emitted. If <c>t</c> is 0.0 or less, there won&apos;t be any delay and the event will be fired the moment the button is pressed.
  54     ///
  55     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatEnabled"/> and <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
  56     /// <value>Timeout in seconds.</value>
  57     double AutorepeatInitialTimeout {
  58         get ;
  59         set ;
  60     }
  61     /// <summary>The interval between each generated autorepeat event.
  62     /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
  63     ///
  64     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>.</summary>
  65     /// <value>Time interval in seconds.</value>
  66     double AutorepeatGapTimeout {
  67         get ;
  68         set ;
  69     }
  70     /// <summary>Turn on/off the autorepeat event generated when a button is kept pressed.
  71     /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> event when they are clicked.</summary>
  72     /// <value>A bool to turn on/off the repeat event generation.</value>
  73     bool AutorepeatEnabled {
  74         get ;
  75         set ;
  76     }
  77 }
  78 /// <summary>Interface for autorepeating clicks.
  79 /// This interface abstracts functions for enabling / disabling this feature. When enabled, keeping a button pressed will continuously emit the <c>repeated</c> event until the button is released. The time it takes until it starts emitting the event is given by <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
  80 sealed public class IAutorepeatConcrete :
  81     Efl.Eo.EoWrapper
  82     , IAutorepeat
  83
  84 {
  85     ///<summary>Pointer to the native class description.</summary>
  86     public override System.IntPtr NativeClass
  87     {
  88         get
  89         {
  90             if (((object)this).GetType() == typeof(IAutorepeatConcrete))
  91             {
  92                 return GetEflClassStatic();
  93             }
  94             else
  95             {
  96                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  97             }
  98         }
  99     }
 100
 101     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 102         efl_ui_autorepeat_interface_get();
 103     /// <summary>Initializes a new instance of the <see cref="IAutorepeat"/> class.
 104     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 105     private IAutorepeatConcrete(System.IntPtr raw) : base(raw)
 106     {
 107     }
 108
 109     /// <summary>Called when a repeated event is emitted</summary>
 110     public event EventHandler RepeatedEvt
 111     {
 112         add
 113         {
 114             lock (eventLock)
 115             {
 116                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 117                 {
 118                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 119                     if (obj != null)
 120                     {
 121                         EventArgs args = EventArgs.Empty;
 122                         try
 123                         {
 124                             value?.Invoke(obj, args);
 125                         }
 126                         catch (Exception e)
 127                         {
 128                             Eina.Log.Error(e.ToString());
 129                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 130                         }
 131                     }
 132                 };
 133
 134                 string key = "_EFL_UI_AUTOREPEAT_EVENT_REPEATED";
 135                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 136             }
 137         }
 138
 139         remove
 140         {
 141             lock (eventLock)
 142             {
 143                 string key = "_EFL_UI_AUTOREPEAT_EVENT_REPEATED";
 144                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 145             }
 146         }
 147     }
 148     ///<summary>Method to raise event RepeatedEvt.</summary>
 149     public void OnRepeatedEvt(EventArgs e)
 150     {
 151         var key = "_EFL_UI_AUTOREPEAT_EVENT_REPEATED";
 152         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 153         if (desc == IntPtr.Zero)
 154         {
 155             Eina.Log.Error($"Failed to get native event {key}");
 156             return;
 157         }
 158
 159         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 160     }
 161     /// <summary>The initial timeout before the autorepeat event is generated.
 162     /// Sets the timeout, in seconds, since the button is pressed until the first <c>repeated</c> signal is emitted. If <c>t</c> is 0.0 or less, there won&apos;t be any delay and the event will be fired the moment the button is pressed.
 163     ///
 164     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatEnabled"/> and <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
 165     /// <returns>Timeout in seconds.</returns>
 166     public double GetAutorepeatInitialTimeout() {
 167          var _ret_var = Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_initial_timeout_get_ptr.Value.Delegate(this.NativeHandle);
 168         Eina.Error.RaiseIfUnhandledException();
 169         return _ret_var;
 170  }
 171     /// <summary>The initial timeout before the autorepeat event is generated.
 172     /// Sets the timeout, in seconds, since the button is pressed until the first <c>repeated</c> signal is emitted. If <c>t</c> is 0.0 or less, there won&apos;t be any delay and the event will be fired the moment the button is pressed.
 173     ///
 174     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatEnabled"/> and <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
 175     /// <param name="t">Timeout in seconds.</param>
 176     public void SetAutorepeatInitialTimeout(double t) {
 177                                  Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_initial_timeout_set_ptr.Value.Delegate(this.NativeHandle,t);
 178         Eina.Error.RaiseIfUnhandledException();
 179                          }
 180     /// <summary>The interval between each generated autorepeat event.
 181     /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
 182     ///
 183     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>.</summary>
 184     /// <returns>Time interval in seconds.</returns>
 185     public double GetAutorepeatGapTimeout() {
 186          var _ret_var = Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_gap_timeout_get_ptr.Value.Delegate(this.NativeHandle);
 187         Eina.Error.RaiseIfUnhandledException();
 188         return _ret_var;
 189  }
 190     /// <summary>The interval between each generated autorepeat event.
 191     /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
 192     ///
 193     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>.</summary>
 194     /// <param name="t">Time interval in seconds.</param>
 195     public void SetAutorepeatGapTimeout(double t) {
 196                                  Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_gap_timeout_set_ptr.Value.Delegate(this.NativeHandle,t);
 197         Eina.Error.RaiseIfUnhandledException();
 198                          }
 199     /// <summary>Turn on/off the autorepeat event generated when a button is kept pressed.
 200     /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> event when they are clicked.</summary>
 201     /// <returns>A bool to turn on/off the repeat event generation.</returns>
 202     public bool GetAutorepeatEnabled() {
 203          var _ret_var = Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_enabled_get_ptr.Value.Delegate(this.NativeHandle);
 204         Eina.Error.RaiseIfUnhandledException();
 205         return _ret_var;
 206  }
 207     /// <summary>Turn on/off the autorepeat event generated when a button is kept pressed.
 208     /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> event when they are clicked.</summary>
 209     /// <param name="on">A bool to turn on/off the repeat event generation.</param>
 210     public void SetAutorepeatEnabled(bool on) {
 211                                  Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_enabled_set_ptr.Value.Delegate(this.NativeHandle,on);
 212         Eina.Error.RaiseIfUnhandledException();
 213                          }
 214     /// <summary>The initial timeout before the autorepeat event is generated.
 215     /// Sets the timeout, in seconds, since the button is pressed until the first <c>repeated</c> signal is emitted. If <c>t</c> is 0.0 or less, there won&apos;t be any delay and the event will be fired the moment the button is pressed.
 216     ///
 217     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatEnabled"/> and <see cref="Efl.Ui.IAutorepeat.AutorepeatGapTimeout"/>.</summary>
 218     /// <value>Timeout in seconds.</value>
 219     public double AutorepeatInitialTimeout {
 220         get { return GetAutorepeatInitialTimeout(); }
 221         set { SetAutorepeatInitialTimeout(value); }
 222     }
 223     /// <summary>The interval between each generated autorepeat event.
 224     /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
 225     ///
 226     /// See also <see cref="Efl.Ui.IAutorepeat.AutorepeatInitialTimeout"/>.</summary>
 227     /// <value>Time interval in seconds.</value>
 228     public double AutorepeatGapTimeout {
 229         get { return GetAutorepeatGapTimeout(); }
 230         set { SetAutorepeatGapTimeout(value); }
 231     }
 232     /// <summary>Turn on/off the autorepeat event generated when a button is kept pressed.
 233     /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> event when they are clicked.</summary>
 234     /// <value>A bool to turn on/off the repeat event generation.</value>
 235     public bool AutorepeatEnabled {
 236         get { return GetAutorepeatEnabled(); }
 237         set { SetAutorepeatEnabled(value); }
 238     }
 239     private static IntPtr GetEflClassStatic()
 240     {
 241         return Efl.Ui.IAutorepeatConcrete.efl_ui_autorepeat_interface_get();
 242     }
 243     /// <summary>Wrapper for native methods and virtual method delegates.
 244     /// For internal use by generated code only.</summary>
 245     public class NativeMethods  : Efl.Eo.NativeClass
 246     {
 247         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 248         /// <summary>Gets the list of Eo operations to override.</summary>
 249         /// <returns>The list of Eo operations to be overload.</returns>
 250         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 251         {
 252             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 253             var methods = Efl.Eo.Globals.GetUserMethods(type);
 254
 255             if (efl_ui_autorepeat_initial_timeout_get_static_delegate == null)
 256             {
 257                 efl_ui_autorepeat_initial_timeout_get_static_delegate = new efl_ui_autorepeat_initial_timeout_get_delegate(autorepeat_initial_timeout_get);
 258             }
 259
 260             if (methods.FirstOrDefault(m => m.Name == "GetAutorepeatInitialTimeout") != null)
 261             {
 262                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_autorepeat_initial_timeout_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_autorepeat_initial_timeout_get_static_delegate) });
 263             }
 264
 265             if (efl_ui_autorepeat_initial_timeout_set_static_delegate == null)
 266             {
 267                 efl_ui_autorepeat_initial_timeout_set_static_delegate = new efl_ui_autorepeat_initial_timeout_set_delegate(autorepeat_initial_timeout_set);
 268             }
 269
 270             if (methods.FirstOrDefault(m => m.Name == "SetAutorepeatInitialTimeout") != null)
 271             {
 272                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_autorepeat_initial_timeout_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_autorepeat_initial_timeout_set_static_delegate) });
 273             }
 274
 275             if (efl_ui_autorepeat_gap_timeout_get_static_delegate == null)
 276             {
 277                 efl_ui_autorepeat_gap_timeout_get_static_delegate = new efl_ui_autorepeat_gap_timeout_get_delegate(autorepeat_gap_timeout_get);
 278             }
 279
 280             if (methods.FirstOrDefault(m => m.Name == "GetAutorepeatGapTimeout") != null)
 281             {
 282                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_autorepeat_gap_timeout_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_autorepeat_gap_timeout_get_static_delegate) });
 283             }
 284
 285             if (efl_ui_autorepeat_gap_timeout_set_static_delegate == null)
 286             {
 287                 efl_ui_autorepeat_gap_timeout_set_static_delegate = new efl_ui_autorepeat_gap_timeout_set_delegate(autorepeat_gap_timeout_set);
 288             }
 289
 290             if (methods.FirstOrDefault(m => m.Name == "SetAutorepeatGapTimeout") != null)
 291             {
 292                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_autorepeat_gap_timeout_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_autorepeat_gap_timeout_set_static_delegate) });
 293             }
 294
 295             if (efl_ui_autorepeat_enabled_get_static_delegate == null)
 296             {
 297                 efl_ui_autorepeat_enabled_get_static_delegate = new efl_ui_autorepeat_enabled_get_delegate(autorepeat_enabled_get);
 298             }
 299
 300             if (methods.FirstOrDefault(m => m.Name == "GetAutorepeatEnabled") != null)
 301             {
 302                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_autorepeat_enabled_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_autorepeat_enabled_get_static_delegate) });
 303             }
 304
 305             if (efl_ui_autorepeat_enabled_set_static_delegate == null)
 306             {
 307                 efl_ui_autorepeat_enabled_set_static_delegate = new efl_ui_autorepeat_enabled_set_delegate(autorepeat_enabled_set);
 308             }
 309
 310             if (methods.FirstOrDefault(m => m.Name == "SetAutorepeatEnabled") != null)
 311             {
 312                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_autorepeat_enabled_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_autorepeat_enabled_set_static_delegate) });
 313             }
 314
 315             return descs;
 316         }
 317         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 318         /// <returns>The native class pointer.</returns>
 319         public override IntPtr GetEflClass()
 320         {
 321             return Efl.Ui.IAutorepeatConcrete.efl_ui_autorepeat_interface_get();
 322         }
 323
 324         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 325
 326
 327         private delegate double efl_ui_autorepeat_initial_timeout_get_delegate(System.IntPtr obj, System.IntPtr pd);
 328
 329
 330         public delegate double efl_ui_autorepeat_initial_timeout_get_api_delegate(System.IntPtr obj);
 331
 332         public static Efl.Eo.FunctionWrapper<efl_ui_autorepeat_initial_timeout_get_api_delegate> efl_ui_autorepeat_initial_timeout_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_autorepeat_initial_timeout_get_api_delegate>(Module, "efl_ui_autorepeat_initial_timeout_get");
 333
 334         private static double autorepeat_initial_timeout_get(System.IntPtr obj, System.IntPtr pd)
 335         {
 336             Eina.Log.Debug("function efl_ui_autorepeat_initial_timeout_get was called");
 337             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 338             if (ws != null)
 339             {
 340             double _ret_var = default(double);
 341                 try
 342                 {
 343                     _ret_var = ((IAutorepeat)ws.Target).GetAutorepeatInitialTimeout();
 344                 }
 345                 catch (Exception e)
 346                 {
 347                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 348                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 349                 }
 350
 351         return _ret_var;
 352
 353             }
 354             else
 355             {
 356                 return efl_ui_autorepeat_initial_timeout_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 357             }
 358         }
 359
 360         private static efl_ui_autorepeat_initial_timeout_get_delegate efl_ui_autorepeat_initial_timeout_get_static_delegate;
 361
 362
 363         private delegate void efl_ui_autorepeat_initial_timeout_set_delegate(System.IntPtr obj, System.IntPtr pd,  double t);
 364
 365
 366         public delegate void efl_ui_autorepeat_initial_timeout_set_api_delegate(System.IntPtr obj,  double t);
 367
 368         public static Efl.Eo.FunctionWrapper<efl_ui_autorepeat_initial_timeout_set_api_delegate> efl_ui_autorepeat_initial_timeout_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_autorepeat_initial_timeout_set_api_delegate>(Module, "efl_ui_autorepeat_initial_timeout_set");
 369
 370         private static void autorepeat_initial_timeout_set(System.IntPtr obj, System.IntPtr pd, double t)
 371         {
 372             Eina.Log.Debug("function efl_ui_autorepeat_initial_timeout_set was called");
 373             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 374             if (ws != null)
 375             {
 376
 377                 try
 378                 {
 379                     ((IAutorepeat)ws.Target).SetAutorepeatInitialTimeout(t);
 380                 }
 381                 catch (Exception e)
 382                 {
 383                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 384                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 385                 }
 386
 387
 388             }
 389             else
 390             {
 391                 efl_ui_autorepeat_initial_timeout_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), t);
 392             }
 393         }
 394
 395         private static efl_ui_autorepeat_initial_timeout_set_delegate efl_ui_autorepeat_initial_timeout_set_static_delegate;
 396
 397
 398         private delegate double efl_ui_autorepeat_gap_timeout_get_delegate(System.IntPtr obj, System.IntPtr pd);
 399
 400
 401         public delegate double efl_ui_autorepeat_gap_timeout_get_api_delegate(System.IntPtr obj);
 402
 403         public static Efl.Eo.FunctionWrapper<efl_ui_autorepeat_gap_timeout_get_api_delegate> efl_ui_autorepeat_gap_timeout_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_autorepeat_gap_timeout_get_api_delegate>(Module, "efl_ui_autorepeat_gap_timeout_get");
 404
 405         private static double autorepeat_gap_timeout_get(System.IntPtr obj, System.IntPtr pd)
 406         {
 407             Eina.Log.Debug("function efl_ui_autorepeat_gap_timeout_get was called");
 408             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 409             if (ws != null)
 410             {
 411             double _ret_var = default(double);
 412                 try
 413                 {
 414                     _ret_var = ((IAutorepeat)ws.Target).GetAutorepeatGapTimeout();
 415                 }
 416                 catch (Exception e)
 417                 {
 418                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 419                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 420                 }
 421
 422         return _ret_var;
 423
 424             }
 425             else
 426             {
 427                 return efl_ui_autorepeat_gap_timeout_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 428             }
 429         }
 430
 431         private static efl_ui_autorepeat_gap_timeout_get_delegate efl_ui_autorepeat_gap_timeout_get_static_delegate;
 432
 433
 434         private delegate void efl_ui_autorepeat_gap_timeout_set_delegate(System.IntPtr obj, System.IntPtr pd,  double t);
 435
 436
 437         public delegate void efl_ui_autorepeat_gap_timeout_set_api_delegate(System.IntPtr obj,  double t);
 438
 439         public static Efl.Eo.FunctionWrapper<efl_ui_autorepeat_gap_timeout_set_api_delegate> efl_ui_autorepeat_gap_timeout_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_autorepeat_gap_timeout_set_api_delegate>(Module, "efl_ui_autorepeat_gap_timeout_set");
 440
 441         private static void autorepeat_gap_timeout_set(System.IntPtr obj, System.IntPtr pd, double t)
 442         {
 443             Eina.Log.Debug("function efl_ui_autorepeat_gap_timeout_set was called");
 444             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 445             if (ws != null)
 446             {
 447
 448                 try
 449                 {
 450                     ((IAutorepeat)ws.Target).SetAutorepeatGapTimeout(t);
 451                 }
 452                 catch (Exception e)
 453                 {
 454                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 455                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 456                 }
 457
 458
 459             }
 460             else
 461             {
 462                 efl_ui_autorepeat_gap_timeout_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), t);
 463             }
 464         }
 465
 466         private static efl_ui_autorepeat_gap_timeout_set_delegate efl_ui_autorepeat_gap_timeout_set_static_delegate;
 467
 468         [return: MarshalAs(UnmanagedType.U1)]
 469         private delegate bool efl_ui_autorepeat_enabled_get_delegate(System.IntPtr obj, System.IntPtr pd);
 470
 471         [return: MarshalAs(UnmanagedType.U1)]
 472         public delegate bool efl_ui_autorepeat_enabled_get_api_delegate(System.IntPtr obj);
 473
 474         public static Efl.Eo.FunctionWrapper<efl_ui_autorepeat_enabled_get_api_delegate> efl_ui_autorepeat_enabled_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_autorepeat_enabled_get_api_delegate>(Module, "efl_ui_autorepeat_enabled_get");
 475
 476         private static bool autorepeat_enabled_get(System.IntPtr obj, System.IntPtr pd)
 477         {
 478             Eina.Log.Debug("function efl_ui_autorepeat_enabled_get was called");
 479             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 480             if (ws != null)
 481             {
 482             bool _ret_var = default(bool);
 483                 try
 484                 {
 485                     _ret_var = ((IAutorepeat)ws.Target).GetAutorepeatEnabled();
 486                 }
 487                 catch (Exception e)
 488                 {
 489                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 490                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 491                 }
 492
 493         return _ret_var;
 494
 495             }
 496             else
 497             {
 498                 return efl_ui_autorepeat_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 499             }
 500         }
 501
 502         private static efl_ui_autorepeat_enabled_get_delegate efl_ui_autorepeat_enabled_get_static_delegate;
 503
 504
 505         private delegate void efl_ui_autorepeat_enabled_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool on);
 506
 507
 508         public delegate void efl_ui_autorepeat_enabled_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool on);
 509
 510         public static Efl.Eo.FunctionWrapper<efl_ui_autorepeat_enabled_set_api_delegate> efl_ui_autorepeat_enabled_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_autorepeat_enabled_set_api_delegate>(Module, "efl_ui_autorepeat_enabled_set");
 511
 512         private static void autorepeat_enabled_set(System.IntPtr obj, System.IntPtr pd, bool on)
 513         {
 514             Eina.Log.Debug("function efl_ui_autorepeat_enabled_set was called");
 515             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 516             if (ws != null)
 517             {
 518
 519                 try
 520                 {
 521                     ((IAutorepeat)ws.Target).SetAutorepeatEnabled(on);
 522                 }
 523                 catch (Exception e)
 524                 {
 525                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 526                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 527                 }
 528
 529
 530             }
 531             else
 532             {
 533                 efl_ui_autorepeat_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), on);
 534             }
 535         }
 536
 537         private static efl_ui_autorepeat_enabled_set_delegate efl_ui_autorepeat_enabled_set_static_delegate;
 538
 539         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 540
 541 }
 542 }
 543 }
 544
 545 }
 546