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>Efl UI autorepeat interface</summary>
  13 [Efl.Ui.IAutorepeatConcrete.NativeMethods]
  14 public interface IAutorepeat :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>The initial timeout before the autorepeat event is generated
  18 /// 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.
  19 ///
  20 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatEnabled"/>, <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
  21 /// <returns>Timeout in seconds</returns>
  22 double GetAutorepeatInitialTimeout();
  23     /// <summary>The initial timeout before the autorepeat event is generated
  24 /// 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.
  25 ///
  26 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatEnabled"/>, <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
  27 /// <param name="t">Timeout in seconds</param>
  28 void SetAutorepeatInitialTimeout(double t);
  29     /// <summary>The interval between each generated autorepeat event
  30 /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
  31 ///
  32 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>.</summary>
  33 /// <returns>Interval in seconds</returns>
  34 double GetAutorepeatGapTimeout();
  35     /// <summary>The interval between each generated autorepeat event
  36 /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
  37 ///
  38 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>.</summary>
  39 /// <param name="t">Interval in seconds</param>
  40 void SetAutorepeatGapTimeout(double t);
  41     /// <summary>Turn on/off the autorepeat event generated when the button is kept pressed
  42 /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> signal when they are clicked.
  43 ///
  44 /// When on, keeping a button pressed will continuously emit a <c>repeated</c> signal until the button is released. The time it takes until it starts emitting the signal is given by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
  45 /// <returns>A bool to turn on/off the event</returns>
  46 bool GetAutorepeatEnabled();
  47     /// <summary>Turn on/off the autorepeat event generated when the button is kept pressed
  48 /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> signal when they are clicked.
  49 ///
  50 /// When on, keeping a button pressed will continuously emit a <c>repeated</c> signal until the button is released. The time it takes until it starts emitting the signal is given by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
  51 /// <param name="on">A bool to turn on/off the event</param>
  52 void SetAutorepeatEnabled(bool on);
  53     /// <summary>Whether the button supports autorepeat.</summary>
  54 /// <returns><c>true</c> if autorepeat is supported, <c>false</c> otherwise</returns>
  55 bool GetAutorepeatSupported();
  56                                 /// <summary>The initial timeout before the autorepeat event is generated
  57 /// 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.
  58 ///
  59 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatEnabled"/>, <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
  60 /// <value>Timeout in seconds</value>
  61     double AutorepeatInitialTimeout {
  62         get ;
  63         set ;
  64     }
  65     /// <summary>The interval between each generated autorepeat event
  66 /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
  67 ///
  68 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>.</summary>
  69 /// <value>Interval in seconds</value>
  70     double AutorepeatGapTimeout {
  71         get ;
  72         set ;
  73     }
  74     /// <summary>Turn on/off the autorepeat event generated when the button is kept pressed
  75 /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> signal when they are clicked.
  76 ///
  77 /// When on, keeping a button pressed will continuously emit a <c>repeated</c> signal until the button is released. The time it takes until it starts emitting the signal is given by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
  78 /// <value>A bool to turn on/off the event</value>
  79     bool AutorepeatEnabled {
  80         get ;
  81         set ;
  82     }
  83     /// <summary>Whether the button supports autorepeat.</summary>
  84 /// <value><c>true</c> if autorepeat is supported, <c>false</c> otherwise</value>
  85     bool AutorepeatSupported {
  86         get ;
  87     }
  88 }
  89 /// <summary>Efl UI autorepeat interface</summary>
  90 sealed public class IAutorepeatConcrete :
  91
  92 IAutorepeat
  93
  94 {
  95     ///<summary>Pointer to the native class description.</summary>
  96     public System.IntPtr NativeClass
  97     {
  98         get
  99         {
 100             if (((object)this).GetType() == typeof(IAutorepeatConcrete))
 101             {
 102                 return GetEflClassStatic();
 103             }
 104             else
 105             {
 106                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 107             }
 108         }
 109     }
 110
 111     private  System.IntPtr handle;
 112     ///<summary>Pointer to the native instance.</summary>
 113     public System.IntPtr NativeHandle
 114     {
 115         get { return handle; }
 116     }
 117
 118     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 119         efl_ui_autorepeat_interface_get();
 120     /// <summary>Initializes a new instance of the <see cref="IAutorepeat"/> class.
 121     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 122     private IAutorepeatConcrete(System.IntPtr raw)
 123     {
 124         handle = raw;
 125     }
 126     ///<summary>Destructor.</summary>
 127     ~IAutorepeatConcrete()
 128     {
 129         Dispose(false);
 130     }
 131
 132     ///<summary>Releases the underlying native instance.</summary>
 133     private void Dispose(bool disposing)
 134     {
 135         if (handle != System.IntPtr.Zero)
 136         {
 137             IntPtr h = handle;
 138             handle = IntPtr.Zero;
 139
 140             IntPtr gcHandlePtr = IntPtr.Zero;
 141             if (disposing)
 142             {
 143                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 144             }
 145             else
 146             {
 147                 Monitor.Enter(Efl.All.InitLock);
 148                 if (Efl.All.MainLoopInitialized)
 149                 {
 150                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 151                 }
 152
 153                 Monitor.Exit(Efl.All.InitLock);
 154             }
 155         }
 156
 157     }
 158
 159     ///<summary>Releases the underlying native instance.</summary>
 160     public void Dispose()
 161     {
 162         Dispose(true);
 163         GC.SuppressFinalize(this);
 164     }
 165
 166     /// <summary>Verifies if the given object is equal to this one.</summary>
 167     /// <param name="instance">The object to compare to.</param>
 168     /// <returns>True if both objects point to the same native object.</returns>
 169     public override bool Equals(object instance)
 170     {
 171         var other = instance as Efl.Object;
 172         if (other == null)
 173         {
 174             return false;
 175         }
 176         return this.NativeHandle == other.NativeHandle;
 177     }
 178
 179     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 180     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 181     public override int GetHashCode()
 182     {
 183         return this.NativeHandle.ToInt32();
 184     }
 185
 186     /// <summary>Turns the native pointer into a string representation.</summary>
 187     /// <returns>A string with the type and the native pointer for this object.</returns>
 188     public override String ToString()
 189     {
 190         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 191     }
 192
 193     /// <summary>The initial timeout before the autorepeat event is generated
 194     /// 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.
 195     ///
 196     /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatEnabled"/>, <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
 197     /// <returns>Timeout in seconds</returns>
 198     public double GetAutorepeatInitialTimeout() {
 199          var _ret_var = Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_initial_timeout_get_ptr.Value.Delegate(this.NativeHandle);
 200         Eina.Error.RaiseIfUnhandledException();
 201         return _ret_var;
 202  }
 203     /// <summary>The initial timeout before the autorepeat event is generated
 204     /// 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.
 205     ///
 206     /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatEnabled"/>, <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
 207     /// <param name="t">Timeout in seconds</param>
 208     public void SetAutorepeatInitialTimeout(double t) {
 209                                  Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_initial_timeout_set_ptr.Value.Delegate(this.NativeHandle,t);
 210         Eina.Error.RaiseIfUnhandledException();
 211                          }
 212     /// <summary>The interval between each generated autorepeat event
 213     /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
 214     ///
 215     /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>.</summary>
 216     /// <returns>Interval in seconds</returns>
 217     public double GetAutorepeatGapTimeout() {
 218          var _ret_var = Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_gap_timeout_get_ptr.Value.Delegate(this.NativeHandle);
 219         Eina.Error.RaiseIfUnhandledException();
 220         return _ret_var;
 221  }
 222     /// <summary>The interval between each generated autorepeat event
 223     /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
 224     ///
 225     /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>.</summary>
 226     /// <param name="t">Interval in seconds</param>
 227     public void SetAutorepeatGapTimeout(double t) {
 228                                  Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_gap_timeout_set_ptr.Value.Delegate(this.NativeHandle,t);
 229         Eina.Error.RaiseIfUnhandledException();
 230                          }
 231     /// <summary>Turn on/off the autorepeat event generated when the button is kept pressed
 232     /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> signal when they are clicked.
 233     ///
 234     /// When on, keeping a button pressed will continuously emit a <c>repeated</c> signal until the button is released. The time it takes until it starts emitting the signal is given by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
 235     /// <returns>A bool to turn on/off the event</returns>
 236     public bool GetAutorepeatEnabled() {
 237          var _ret_var = Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_enabled_get_ptr.Value.Delegate(this.NativeHandle);
 238         Eina.Error.RaiseIfUnhandledException();
 239         return _ret_var;
 240  }
 241     /// <summary>Turn on/off the autorepeat event generated when the button is kept pressed
 242     /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> signal when they are clicked.
 243     ///
 244     /// When on, keeping a button pressed will continuously emit a <c>repeated</c> signal until the button is released. The time it takes until it starts emitting the signal is given by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
 245     /// <param name="on">A bool to turn on/off the event</param>
 246     public void SetAutorepeatEnabled(bool on) {
 247                                  Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_enabled_set_ptr.Value.Delegate(this.NativeHandle,on);
 248         Eina.Error.RaiseIfUnhandledException();
 249                          }
 250     /// <summary>Whether the button supports autorepeat.</summary>
 251     /// <returns><c>true</c> if autorepeat is supported, <c>false</c> otherwise</returns>
 252     public bool GetAutorepeatSupported() {
 253          var _ret_var = Efl.Ui.IAutorepeatConcrete.NativeMethods.efl_ui_autorepeat_supported_get_ptr.Value.Delegate(this.NativeHandle);
 254         Eina.Error.RaiseIfUnhandledException();
 255         return _ret_var;
 256  }
 257     /// <summary>The initial timeout before the autorepeat event is generated
 258 /// 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.
 259 ///
 260 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatEnabled"/>, <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
 261 /// <value>Timeout in seconds</value>
 262     public double AutorepeatInitialTimeout {
 263         get { return GetAutorepeatInitialTimeout(); }
 264         set { SetAutorepeatInitialTimeout(value); }
 265     }
 266     /// <summary>The interval between each generated autorepeat event
 267 /// After the first <c>repeated</c> event is fired, all subsequent ones will follow after a delay of <c>t</c> seconds for each.
 268 ///
 269 /// See also <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>.</summary>
 270 /// <value>Interval in seconds</value>
 271     public double AutorepeatGapTimeout {
 272         get { return GetAutorepeatGapTimeout(); }
 273         set { SetAutorepeatGapTimeout(value); }
 274     }
 275     /// <summary>Turn on/off the autorepeat event generated when the button is kept pressed
 276 /// When off, no autorepeat is performed and buttons emit a normal <c>clicked</c> signal when they are clicked.
 277 ///
 278 /// When on, keeping a button pressed will continuously emit a <c>repeated</c> signal until the button is released. The time it takes until it starts emitting the signal is given by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatInitialTimeout"/>, and the time between each new emission by <see cref="Efl.Ui.IAutorepeat.SetAutorepeatGapTimeout"/>.</summary>
 279 /// <value>A bool to turn on/off the event</value>
 280     public bool AutorepeatEnabled {
 281         get { return GetAutorepeatEnabled(); }
 282         set { SetAutorepeatEnabled(value); }
 283     }
 284     /// <summary>Whether the button supports autorepeat.</summary>
 285 /// <value><c>true</c> if autorepeat is supported, <c>false</c> otherwise</value>
 286     public bool AutorepeatSupported {
 287         get { return GetAutorepeatSupported(); }
 288     }
 289     private static IntPtr GetEflClassStatic()
 290     {
 291         return Efl.Ui.IAutorepeatConcrete.efl_ui_autorepeat_interface_get();
 292     }
 293     /// <summary>Wrapper for native methods and virtual method delegates.
 294     /// For internal use by generated code only.</summary>
 295     public class NativeMethods  : Efl.Eo.NativeClass
 296     {
 297         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 298         /// <summary>Gets the list of Eo operations to override.</summary>
 299         /// <returns>The list of Eo operations to be overload.</returns>
 300         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 301         {
 302             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 303             var methods = Efl.Eo.Globals.GetUserMethods(type);
 304
 305             if (efl_ui_autorepeat_initial_timeout_get_static_delegate == null)
 306             {
 307                 efl_ui_autorepeat_initial_timeout_get_static_delegate = new efl_ui_autorepeat_initial_timeout_get_delegate(autorepeat_initial_timeout_get);
 308             }
 309
 310             if (methods.FirstOrDefault(m => m.Name == "GetAutorepeatInitialTimeout") != null)
 311             {
 312                 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) });
 313             }
 314
 315             if (efl_ui_autorepeat_initial_timeout_set_static_delegate == null)
 316             {
 317                 efl_ui_autorepeat_initial_timeout_set_static_delegate = new efl_ui_autorepeat_initial_timeout_set_delegate(autorepeat_initial_timeout_set);
 318             }
 319
 320             if (methods.FirstOrDefault(m => m.Name == "SetAutorepeatInitialTimeout") != null)
 321             {
 322                 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) });
 323             }
 324
 325             if (efl_ui_autorepeat_gap_timeout_get_static_delegate == null)
 326             {
 327                 efl_ui_autorepeat_gap_timeout_get_static_delegate = new efl_ui_autorepeat_gap_timeout_get_delegate(autorepeat_gap_timeout_get);
 328             }
 329
 330             if (methods.FirstOrDefault(m => m.Name == "GetAutorepeatGapTimeout") != null)
 331             {
 332                 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) });
 333             }
 334
 335             if (efl_ui_autorepeat_gap_timeout_set_static_delegate == null)
 336             {
 337                 efl_ui_autorepeat_gap_timeout_set_static_delegate = new efl_ui_autorepeat_gap_timeout_set_delegate(autorepeat_gap_timeout_set);
 338             }
 339
 340             if (methods.FirstOrDefault(m => m.Name == "SetAutorepeatGapTimeout") != null)
 341             {
 342                 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) });
 343             }
 344
 345             if (efl_ui_autorepeat_enabled_get_static_delegate == null)
 346             {
 347                 efl_ui_autorepeat_enabled_get_static_delegate = new efl_ui_autorepeat_enabled_get_delegate(autorepeat_enabled_get);
 348             }
 349
 350             if (methods.FirstOrDefault(m => m.Name == "GetAutorepeatEnabled") != null)
 351             {
 352                 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) });
 353             }
 354
 355             if (efl_ui_autorepeat_enabled_set_static_delegate == null)
 356             {
 357                 efl_ui_autorepeat_enabled_set_static_delegate = new efl_ui_autorepeat_enabled_set_delegate(autorepeat_enabled_set);
 358             }
 359
 360             if (methods.FirstOrDefault(m => m.Name == "SetAutorepeatEnabled") != null)
 361             {
 362                 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) });
 363             }
 364
 365             if (efl_ui_autorepeat_supported_get_static_delegate == null)
 366             {
 367                 efl_ui_autorepeat_supported_get_static_delegate = new efl_ui_autorepeat_supported_get_delegate(autorepeat_supported_get);
 368             }
 369
 370             if (methods.FirstOrDefault(m => m.Name == "GetAutorepeatSupported") != null)
 371             {
 372                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_autorepeat_supported_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_autorepeat_supported_get_static_delegate) });
 373             }
 374
 375             return descs;
 376         }
 377         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 378         /// <returns>The native class pointer.</returns>
 379         public override IntPtr GetEflClass()
 380         {
 381             return Efl.Ui.IAutorepeatConcrete.efl_ui_autorepeat_interface_get();
 382         }
 383
 384         #pragma warning disable CA1707, SA1300, SA1600
 385
 386
 387         private delegate double efl_ui_autorepeat_initial_timeout_get_delegate(System.IntPtr obj, System.IntPtr pd);
 388
 389
 390         public delegate double efl_ui_autorepeat_initial_timeout_get_api_delegate(System.IntPtr obj);
 391
 392         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");
 393
 394         private static double autorepeat_initial_timeout_get(System.IntPtr obj, System.IntPtr pd)
 395         {
 396             Eina.Log.Debug("function efl_ui_autorepeat_initial_timeout_get was called");
 397             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 398             if (wrapper != null)
 399             {
 400             double _ret_var = default(double);
 401                 try
 402                 {
 403                     _ret_var = ((IAutorepeat)wrapper).GetAutorepeatInitialTimeout();
 404                 }
 405                 catch (Exception e)
 406                 {
 407                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 408                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 409                 }
 410
 411         return _ret_var;
 412
 413             }
 414             else
 415             {
 416                 return efl_ui_autorepeat_initial_timeout_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 417             }
 418         }
 419
 420         private static efl_ui_autorepeat_initial_timeout_get_delegate efl_ui_autorepeat_initial_timeout_get_static_delegate;
 421
 422
 423         private delegate void efl_ui_autorepeat_initial_timeout_set_delegate(System.IntPtr obj, System.IntPtr pd,  double t);
 424
 425
 426         public delegate void efl_ui_autorepeat_initial_timeout_set_api_delegate(System.IntPtr obj,  double t);
 427
 428         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");
 429
 430         private static void autorepeat_initial_timeout_set(System.IntPtr obj, System.IntPtr pd, double t)
 431         {
 432             Eina.Log.Debug("function efl_ui_autorepeat_initial_timeout_set was called");
 433             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 434             if (wrapper != null)
 435             {
 436
 437                 try
 438                 {
 439                     ((IAutorepeat)wrapper).SetAutorepeatInitialTimeout(t);
 440                 }
 441                 catch (Exception e)
 442                 {
 443                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 444                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 445                 }
 446
 447
 448             }
 449             else
 450             {
 451                 efl_ui_autorepeat_initial_timeout_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), t);
 452             }
 453         }
 454
 455         private static efl_ui_autorepeat_initial_timeout_set_delegate efl_ui_autorepeat_initial_timeout_set_static_delegate;
 456
 457
 458         private delegate double efl_ui_autorepeat_gap_timeout_get_delegate(System.IntPtr obj, System.IntPtr pd);
 459
 460
 461         public delegate double efl_ui_autorepeat_gap_timeout_get_api_delegate(System.IntPtr obj);
 462
 463         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");
 464
 465         private static double autorepeat_gap_timeout_get(System.IntPtr obj, System.IntPtr pd)
 466         {
 467             Eina.Log.Debug("function efl_ui_autorepeat_gap_timeout_get was called");
 468             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 469             if (wrapper != null)
 470             {
 471             double _ret_var = default(double);
 472                 try
 473                 {
 474                     _ret_var = ((IAutorepeat)wrapper).GetAutorepeatGapTimeout();
 475                 }
 476                 catch (Exception e)
 477                 {
 478                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 479                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 480                 }
 481
 482         return _ret_var;
 483
 484             }
 485             else
 486             {
 487                 return efl_ui_autorepeat_gap_timeout_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 488             }
 489         }
 490
 491         private static efl_ui_autorepeat_gap_timeout_get_delegate efl_ui_autorepeat_gap_timeout_get_static_delegate;
 492
 493
 494         private delegate void efl_ui_autorepeat_gap_timeout_set_delegate(System.IntPtr obj, System.IntPtr pd,  double t);
 495
 496
 497         public delegate void efl_ui_autorepeat_gap_timeout_set_api_delegate(System.IntPtr obj,  double t);
 498
 499         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");
 500
 501         private static void autorepeat_gap_timeout_set(System.IntPtr obj, System.IntPtr pd, double t)
 502         {
 503             Eina.Log.Debug("function efl_ui_autorepeat_gap_timeout_set was called");
 504             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 505             if (wrapper != null)
 506             {
 507
 508                 try
 509                 {
 510                     ((IAutorepeat)wrapper).SetAutorepeatGapTimeout(t);
 511                 }
 512                 catch (Exception e)
 513                 {
 514                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 515                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 516                 }
 517
 518
 519             }
 520             else
 521             {
 522                 efl_ui_autorepeat_gap_timeout_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), t);
 523             }
 524         }
 525
 526         private static efl_ui_autorepeat_gap_timeout_set_delegate efl_ui_autorepeat_gap_timeout_set_static_delegate;
 527
 528         [return: MarshalAs(UnmanagedType.U1)]
 529         private delegate bool efl_ui_autorepeat_enabled_get_delegate(System.IntPtr obj, System.IntPtr pd);
 530
 531         [return: MarshalAs(UnmanagedType.U1)]
 532         public delegate bool efl_ui_autorepeat_enabled_get_api_delegate(System.IntPtr obj);
 533
 534         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");
 535
 536         private static bool autorepeat_enabled_get(System.IntPtr obj, System.IntPtr pd)
 537         {
 538             Eina.Log.Debug("function efl_ui_autorepeat_enabled_get was called");
 539             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 540             if (wrapper != null)
 541             {
 542             bool _ret_var = default(bool);
 543                 try
 544                 {
 545                     _ret_var = ((IAutorepeat)wrapper).GetAutorepeatEnabled();
 546                 }
 547                 catch (Exception e)
 548                 {
 549                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 550                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 551                 }
 552
 553         return _ret_var;
 554
 555             }
 556             else
 557             {
 558                 return efl_ui_autorepeat_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 559             }
 560         }
 561
 562         private static efl_ui_autorepeat_enabled_get_delegate efl_ui_autorepeat_enabled_get_static_delegate;
 563
 564
 565         private delegate void efl_ui_autorepeat_enabled_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool on);
 566
 567
 568         public delegate void efl_ui_autorepeat_enabled_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool on);
 569
 570         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");
 571
 572         private static void autorepeat_enabled_set(System.IntPtr obj, System.IntPtr pd, bool on)
 573         {
 574             Eina.Log.Debug("function efl_ui_autorepeat_enabled_set was called");
 575             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 576             if (wrapper != null)
 577             {
 578
 579                 try
 580                 {
 581                     ((IAutorepeat)wrapper).SetAutorepeatEnabled(on);
 582                 }
 583                 catch (Exception e)
 584                 {
 585                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 586                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 587                 }
 588
 589
 590             }
 591             else
 592             {
 593                 efl_ui_autorepeat_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), on);
 594             }
 595         }
 596
 597         private static efl_ui_autorepeat_enabled_set_delegate efl_ui_autorepeat_enabled_set_static_delegate;
 598
 599         [return: MarshalAs(UnmanagedType.U1)]
 600         private delegate bool efl_ui_autorepeat_supported_get_delegate(System.IntPtr obj, System.IntPtr pd);
 601
 602         [return: MarshalAs(UnmanagedType.U1)]
 603         public delegate bool efl_ui_autorepeat_supported_get_api_delegate(System.IntPtr obj);
 604
 605         public static Efl.Eo.FunctionWrapper<efl_ui_autorepeat_supported_get_api_delegate> efl_ui_autorepeat_supported_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_autorepeat_supported_get_api_delegate>(Module, "efl_ui_autorepeat_supported_get");
 606
 607         private static bool autorepeat_supported_get(System.IntPtr obj, System.IntPtr pd)
 608         {
 609             Eina.Log.Debug("function efl_ui_autorepeat_supported_get was called");
 610             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 611             if (wrapper != null)
 612             {
 613             bool _ret_var = default(bool);
 614                 try
 615                 {
 616                     _ret_var = ((IAutorepeat)wrapper).GetAutorepeatSupported();
 617                 }
 618                 catch (Exception e)
 619                 {
 620                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 621                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 622                 }
 623
 624         return _ret_var;
 625
 626             }
 627             else
 628             {
 629                 return efl_ui_autorepeat_supported_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 630             }
 631         }
 632
 633         private static efl_ui_autorepeat_supported_get_delegate efl_ui_autorepeat_supported_get_static_delegate;
 634
 635         #pragma warning restore CA1707, SA1300, SA1600
 636
 637 }
 638 }
 639 }
 640
 641 }
 642