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