internals/src/EflSharp/EflSharp/efl/efl_ui_spin.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>A Spin.
  13 /// This is a widget which allows the user to increase or decrease a numeric value using arrow buttons. It&apos;s a basic type of widget for choosing and displaying values.</summary>
  14 [Efl.Ui.Spin.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public class Spin : Efl.Ui.LayoutBase, Efl.Access.IValue, Efl.Ui.IFormat, Efl.Ui.IRangeDisplay, Efl.Ui.IRangeInteractive
  17 {
  18     ///<summary>Pointer to the native class description.</summary>
  19     public override System.IntPtr NativeClass
  20     {
  21         get
  22         {
  23             if (((object)this).GetType() == typeof(Spin))
  24             {
  25                 return GetEflClassStatic();
  26             }
  27             else
  28             {
  29                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  30             }
  31         }
  32     }
  33
  34     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  35         efl_ui_spin_class_get();
  36     /// <summary>Initializes a new instance of the <see cref="Spin"/> class.</summary>
  37     /// <param name="parent">Parent instance.</param>
  38     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  39     public Spin(Efl.Object parent
  40             , System.String style = null) : base(efl_ui_spin_class_get(), parent)
  41     {
  42         if (Efl.Eo.Globals.ParamHelperCheck(style))
  43         {
  44             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  45         }
  46
  47         FinishInstantiation();
  48     }
  49
  50     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  51     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  52     protected Spin(ConstructingHandle ch) : base(ch)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="Spin"/> class.
  57     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  58     /// <param name="wh">The native pointer to be wrapped.</param>
  59     protected Spin(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  60     {
  61     }
  62
  63     /// <summary>Initializes a new instance of the <see cref="Spin"/> class.
  64     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  65     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  66     /// <param name="parent">The Efl.Object parent of this instance.</param>
  67     protected Spin(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  68     {
  69     }
  70
  71     /// <summary>Called when spin changed</summary>
  72     public event EventHandler ChangedEvt
  73     {
  74         add
  75         {
  76             lock (eflBindingEventLock)
  77             {
  78                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  79                 {
  80                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  81                     if (obj != null)
  82                     {
  83                         EventArgs args = EventArgs.Empty;
  84                         try
  85                         {
  86                             value?.Invoke(obj, args);
  87                         }
  88                         catch (Exception e)
  89                         {
  90                             Eina.Log.Error(e.ToString());
  91                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  92                         }
  93                     }
  94                 };
  95
  96                 string key = "_EFL_UI_SPIN_EVENT_CHANGED";
  97                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  98             }
  99         }
 100
 101         remove
 102         {
 103             lock (eflBindingEventLock)
 104             {
 105                 string key = "_EFL_UI_SPIN_EVENT_CHANGED";
 106                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 107             }
 108         }
 109     }
 110     ///<summary>Method to raise event ChangedEvt.</summary>
 111     public void OnChangedEvt(EventArgs e)
 112     {
 113         var key = "_EFL_UI_SPIN_EVENT_CHANGED";
 114         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 115         if (desc == IntPtr.Zero)
 116         {
 117             Eina.Log.Error($"Failed to get native event {key}");
 118             return;
 119         }
 120
 121         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 122     }
 123     /// <summary>Called when spin value reached min</summary>
 124     public event EventHandler MinReachedEvt
 125     {
 126         add
 127         {
 128             lock (eflBindingEventLock)
 129             {
 130                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 131                 {
 132                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 133                     if (obj != null)
 134                     {
 135                         EventArgs args = EventArgs.Empty;
 136                         try
 137                         {
 138                             value?.Invoke(obj, args);
 139                         }
 140                         catch (Exception e)
 141                         {
 142                             Eina.Log.Error(e.ToString());
 143                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 144                         }
 145                     }
 146                 };
 147
 148                 string key = "_EFL_UI_SPIN_EVENT_MIN_REACHED";
 149                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 150             }
 151         }
 152
 153         remove
 154         {
 155             lock (eflBindingEventLock)
 156             {
 157                 string key = "_EFL_UI_SPIN_EVENT_MIN_REACHED";
 158                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 159             }
 160         }
 161     }
 162     ///<summary>Method to raise event MinReachedEvt.</summary>
 163     public void OnMinReachedEvt(EventArgs e)
 164     {
 165         var key = "_EFL_UI_SPIN_EVENT_MIN_REACHED";
 166         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 167         if (desc == IntPtr.Zero)
 168         {
 169             Eina.Log.Error($"Failed to get native event {key}");
 170             return;
 171         }
 172
 173         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 174     }
 175     /// <summary>Called when spin value reached max</summary>
 176     public event EventHandler MaxReachedEvt
 177     {
 178         add
 179         {
 180             lock (eflBindingEventLock)
 181             {
 182                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 183                 {
 184                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 185                     if (obj != null)
 186                     {
 187                         EventArgs args = EventArgs.Empty;
 188                         try
 189                         {
 190                             value?.Invoke(obj, args);
 191                         }
 192                         catch (Exception e)
 193                         {
 194                             Eina.Log.Error(e.ToString());
 195                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 196                         }
 197                     }
 198                 };
 199
 200                 string key = "_EFL_UI_SPIN_EVENT_MAX_REACHED";
 201                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 202             }
 203         }
 204
 205         remove
 206         {
 207             lock (eflBindingEventLock)
 208             {
 209                 string key = "_EFL_UI_SPIN_EVENT_MAX_REACHED";
 210                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 211             }
 212         }
 213     }
 214     ///<summary>Method to raise event MaxReachedEvt.</summary>
 215     public void OnMaxReachedEvt(EventArgs e)
 216     {
 217         var key = "_EFL_UI_SPIN_EVENT_MAX_REACHED";
 218         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 219         if (desc == IntPtr.Zero)
 220         {
 221             Eina.Log.Error($"Failed to get native event {key}");
 222             return;
 223         }
 224
 225         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 226     }
 227     /// <summary>Gets value displayed by a accessible widget.</summary>
 228     /// <param name="value">Value of widget casted to floating point number.</param>
 229     /// <param name="text">string describing value in given context eg. small, enough</param>
 230     virtual public void GetValueAndText(out double value, out System.String text) {
 231                                                          Efl.Access.IValueConcrete.NativeMethods.efl_access_value_and_text_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out value, out text);
 232         Eina.Error.RaiseIfUnhandledException();
 233                                          }
 234     /// <summary>Value and text property</summary>
 235     /// <param name="value">Value of widget casted to floating point number.</param>
 236     /// <param name="text">string describing value in given context eg. small, enough</param>
 237     /// <returns><c>true</c> if setting widgets value has succeeded, otherwise <c>false</c> .</returns>
 238     virtual public bool SetValueAndText(double value, System.String text) {
 239                                                          var _ret_var = Efl.Access.IValueConcrete.NativeMethods.efl_access_value_and_text_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),value, text);
 240         Eina.Error.RaiseIfUnhandledException();
 241                                         return _ret_var;
 242  }
 243     /// <summary>Gets a range of all possible values and its description</summary>
 244     /// <param name="lower_limit">Lower limit of the range</param>
 245     /// <param name="upper_limit">Upper limit of the range</param>
 246     /// <param name="description">Description of the range</param>
 247     virtual public void GetRange(out double lower_limit, out double upper_limit, out System.String description) {
 248                                                                                  Efl.Access.IValueConcrete.NativeMethods.efl_access_value_range_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out lower_limit, out upper_limit, out description);
 249         Eina.Error.RaiseIfUnhandledException();
 250                                                          }
 251     /// <summary>Gets an minimal incrementation value</summary>
 252     /// <returns>Minimal incrementation value</returns>
 253     virtual public double GetIncrement() {
 254          var _ret_var = Efl.Access.IValueConcrete.NativeMethods.efl_access_value_increment_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 255         Eina.Error.RaiseIfUnhandledException();
 256         return _ret_var;
 257  }
 258     /// <summary>User-provided function which takes care of converting an <see cref="Eina.Value"/> into a text string. The user is then completely in control of how the string is generated, but it is the most cumbersome method to use. If the conversion fails the other mechanisms will be tried, according to their priorities.</summary>
 259     /// <returns>User-provided formatting function.</returns>
 260     virtual public Efl.Ui.FormatFunc GetFormatFunc() {
 261          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_func_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 262         Eina.Error.RaiseIfUnhandledException();
 263         return _ret_var;
 264  }
 265     /// <summary>User-provided function which takes care of converting an <see cref="Eina.Value"/> into a text string. The user is then completely in control of how the string is generated, but it is the most cumbersome method to use. If the conversion fails the other mechanisms will be tried, according to their priorities.</summary>
 266     /// <param name="func">User-provided formatting function.</param>
 267     virtual public void SetFormatFunc(Efl.Ui.FormatFunc func) {
 268                          GCHandle func_handle = GCHandle.Alloc(func);
 269         Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_func_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),GCHandle.ToIntPtr(func_handle), Efl.Ui.FormatFuncWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 270         Eina.Error.RaiseIfUnhandledException();
 271                          }
 272     /// <summary>User-provided list of values which are to be rendered using specific text strings. This is more convenient to use than <see cref="Efl.Ui.IFormat.FormatFunc"/> and is perfectly suited for cases where the strings make more sense than the numerical values. For example, weekday names (&quot;Monday&quot;, &quot;Tuesday&quot;, ...) are friendlier than numbers 1 to 7. If a value is not found in the list, the other mechanisms will be tried according to their priorities. List members do not need to be in any particular order. They are sorted internally for performance reasons.</summary>
 273     /// <returns>Accessor over a list of value-text pairs. The method will dispose of the accessor, but not of its contents. For convenience, Eina offers a range of helper methods to obtain accessors from Eina.Array, Eina.List or even plain C arrays.</returns>
 274     virtual public Eina.Accessor<Efl.Ui.FormatValue> GetFormatValues() {
 275          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_values_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 276         Eina.Error.RaiseIfUnhandledException();
 277         return new Eina.Accessor<Efl.Ui.FormatValue>(_ret_var, false);
 278  }
 279     /// <summary>User-provided list of values which are to be rendered using specific text strings. This is more convenient to use than <see cref="Efl.Ui.IFormat.FormatFunc"/> and is perfectly suited for cases where the strings make more sense than the numerical values. For example, weekday names (&quot;Monday&quot;, &quot;Tuesday&quot;, ...) are friendlier than numbers 1 to 7. If a value is not found in the list, the other mechanisms will be tried according to their priorities. List members do not need to be in any particular order. They are sorted internally for performance reasons.</summary>
 280     /// <param name="values">Accessor over a list of value-text pairs. The method will dispose of the accessor, but not of its contents. For convenience, Eina offers a range of helper methods to obtain accessors from Eina.Array, Eina.List or even plain C arrays.</param>
 281     virtual public void SetFormatValues(Eina.Accessor<Efl.Ui.FormatValue> values) {
 282          var _in_values = values.Handle;
 283                         Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_values_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_values);
 284         Eina.Error.RaiseIfUnhandledException();
 285                          }
 286     /// <summary>A user-provided, string used to format the numerical value.
 287     /// For example, &quot;%1.2f meters&quot;, &quot;%.0%%&quot; or &quot;%d items&quot;.
 288     ///
 289     /// This is the simplest formatting mechanism, working pretty much like <c>printf</c>.
 290     ///
 291     /// Different format specifiers (the character after the %) are available, depending on the <c>type</c> used. Use <see cref="Efl.Ui.FormatStringType.Simple"/> for simple numerical values and <see cref="Efl.Ui.FormatStringType.Time"/> for time and date values. For instance, %d means &quot;integer&quot; when the first type is used, but it means &quot;day of the month as a decimal number&quot; in the second.
 292     ///
 293     /// Pass <c>NULL</c> to disable this mechanism.</summary>
 294     /// <param name="kw_string">Formatting string containing regular characters and format specifiers.</param>
 295     /// <param name="type">Type of formatting string, which controls how the different format specifiers are to be traslated.</param>
 296     virtual public void GetFormatString(out System.String kw_string, out Efl.Ui.FormatStringType type) {
 297                                                          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out kw_string, out type);
 298         Eina.Error.RaiseIfUnhandledException();
 299                                          }
 300     /// <summary>A user-provided, string used to format the numerical value.
 301     /// For example, &quot;%1.2f meters&quot;, &quot;%.0%%&quot; or &quot;%d items&quot;.
 302     ///
 303     /// This is the simplest formatting mechanism, working pretty much like <c>printf</c>.
 304     ///
 305     /// Different format specifiers (the character after the %) are available, depending on the <c>type</c> used. Use <see cref="Efl.Ui.FormatStringType.Simple"/> for simple numerical values and <see cref="Efl.Ui.FormatStringType.Time"/> for time and date values. For instance, %d means &quot;integer&quot; when the first type is used, but it means &quot;day of the month as a decimal number&quot; in the second.
 306     ///
 307     /// Pass <c>NULL</c> to disable this mechanism.</summary>
 308     /// <param name="kw_string">Formatting string containing regular characters and format specifiers.</param>
 309     /// <param name="type">Type of formatting string, which controls how the different format specifiers are to be traslated.</param>
 310     virtual public void SetFormatString(System.String kw_string, Efl.Ui.FormatStringType type) {
 311                                                          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),kw_string, type);
 312         Eina.Error.RaiseIfUnhandledException();
 313                                          }
 314     /// <summary>Internal method to be used by widgets including this mixin to perform the conversion from the internal numerical value into the text representation (Users of these widgets do not need to call this method).
 315     /// <see cref="Efl.Ui.IFormat.GetFormattedValue"/> uses any user-provided mechanism to perform the conversion, according to their priorities, and implements a simple fallback if all mechanisms fail.</summary>
 316     /// <param name="str">Output formatted string. Its contents will be overwritten by this method.</param>
 317     /// <param name="value">The <see cref="Eina.Value"/> to convert to text.</param>
 318     virtual public void GetFormattedValue(Eina.Strbuf str, Eina.Value value) {
 319                                                          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_formatted_value_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),str, value);
 320         Eina.Error.RaiseIfUnhandledException();
 321                                          }
 322     /// <summary>Internal method to be used by widgets including this mixin. It can only be used when a <see cref="Efl.Ui.IFormat.GetFormatString"/> has been supplied, and it returns the number of decimal places that the format string will produce for floating point values.
 323     /// For example, &quot;%.2f&quot; returns 2, and &quot;%d&quot; returns 0;</summary>
 324     /// <returns>Number of decimal places, or 0 for non-floating point types.</returns>
 325     virtual public int GetDecimalPlaces() {
 326          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_decimal_places_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 327         Eina.Error.RaiseIfUnhandledException();
 328         return _ret_var;
 329  }
 330     /// <summary>Internal method to be implemented by widgets including this mixin.
 331     /// The mixin will call this method to signal the widget that the formatting has changed and therefore the current value should be converted and rendered again. Widgets must typically call <see cref="Efl.Ui.IFormat.GetFormattedValue"/> and display the returned string. This is something they are already doing (whenever the value changes, for example) so there should be no extra code written to implement this method.</summary>
 332     virtual public void ApplyFormattedValue() {
 333          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_apply_formatted_value_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 334         Eina.Error.RaiseIfUnhandledException();
 335          }
 336     /// <summary>Control the range value (in percentage) on a given range widget
 337     /// Use this call to set range levels.
 338     ///
 339     /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
 340     /// <returns>The range value (must be between $0.0 and 1.0)</returns>
 341     virtual public double GetRangeValue() {
 342          var _ret_var = Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_value_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 343         Eina.Error.RaiseIfUnhandledException();
 344         return _ret_var;
 345  }
 346     /// <summary>Control the range value (in percentage) on a given range widget
 347     /// Use this call to set range levels.
 348     ///
 349     /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
 350     /// <param name="val">The range value (must be between $0.0 and 1.0)</param>
 351     virtual public void SetRangeValue(double val) {
 352                                  Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_value_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 353         Eina.Error.RaiseIfUnhandledException();
 354                          }
 355     /// <summary>Get the minimum and maximum values of the given range widget.
 356     /// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
 357     /// <param name="min">The minimum value.</param>
 358     /// <param name="max">The maximum value.</param>
 359     virtual public void GetRangeLimits(out double min, out double max) {
 360                                                          Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out min, out max);
 361         Eina.Error.RaiseIfUnhandledException();
 362                                          }
 363     /// <summary>Set the minimum and maximum values for given range widget.
 364     /// Define the allowed range of values to be selected by the user.
 365     ///
 366     /// If actual value is less than <c>min</c>, it will be updated to <c>min</c>. If it is bigger then <c>max</c>, will be updated to <c>max</c>. The actual value can be obtained with <see cref="Efl.Ui.IRangeDisplay.GetRangeValue"/>
 367     ///
 368     /// The minimum and maximum values may be different for each class.
 369     ///
 370     /// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
 371     /// <param name="min">The minimum value.</param>
 372     /// <param name="max">The maximum value.</param>
 373     virtual public void SetRangeLimits(double min, double max) {
 374                                                          Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),min, max);
 375         Eina.Error.RaiseIfUnhandledException();
 376                                          }
 377     /// <summary>Control the step used to increment or decrement values for given widget.
 378     /// This value will be incremented or decremented to the displayed value.
 379     ///
 380     /// By default step value is equal to 1.
 381     ///
 382     /// Warning: The step value should be bigger than 0.</summary>
 383     /// <returns>The step value.</returns>
 384     virtual public double GetRangeStep() {
 385          var _ret_var = Efl.Ui.IRangeInteractiveConcrete.NativeMethods.efl_ui_range_step_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 386         Eina.Error.RaiseIfUnhandledException();
 387         return _ret_var;
 388  }
 389     /// <summary>Control the step used to increment or decrement values for given widget.
 390     /// This value will be incremented or decremented to the displayed value.
 391     ///
 392     /// By default step value is equal to 1.
 393     ///
 394     /// Warning: The step value should be bigger than 0.</summary>
 395     /// <param name="step">The step value.</param>
 396     virtual public void SetRangeStep(double step) {
 397                                  Efl.Ui.IRangeInteractiveConcrete.NativeMethods.efl_ui_range_step_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),step);
 398         Eina.Error.RaiseIfUnhandledException();
 399                          }
 400     /// <summary>Gets an minimal incrementation value</summary>
 401     /// <value>Minimal incrementation value</value>
 402     public double Increment {
 403         get { return GetIncrement(); }
 404     }
 405     /// <summary>User-provided function which takes care of converting an <see cref="Eina.Value"/> into a text string. The user is then completely in control of how the string is generated, but it is the most cumbersome method to use. If the conversion fails the other mechanisms will be tried, according to their priorities.</summary>
 406     /// <value>User-provided formatting function.</value>
 407     public Efl.Ui.FormatFunc FormatFunc {
 408         get { return GetFormatFunc(); }
 409         set { SetFormatFunc(value); }
 410     }
 411     /// <summary>User-provided list of values which are to be rendered using specific text strings. This is more convenient to use than <see cref="Efl.Ui.IFormat.FormatFunc"/> and is perfectly suited for cases where the strings make more sense than the numerical values. For example, weekday names (&quot;Monday&quot;, &quot;Tuesday&quot;, ...) are friendlier than numbers 1 to 7. If a value is not found in the list, the other mechanisms will be tried according to their priorities. List members do not need to be in any particular order. They are sorted internally for performance reasons.</summary>
 412     /// <value>Accessor over a list of value-text pairs. The method will dispose of the accessor, but not of its contents. For convenience, Eina offers a range of helper methods to obtain accessors from Eina.Array, Eina.List or even plain C arrays.</value>
 413     public Eina.Accessor<Efl.Ui.FormatValue> FormatValues {
 414         get { return GetFormatValues(); }
 415         set { SetFormatValues(value); }
 416     }
 417     /// <summary>Control the range value (in percentage) on a given range widget
 418     /// Use this call to set range levels.
 419     ///
 420     /// Note: If you pass a value out of the specified interval for <c>val</c>, it will be interpreted as the closest of the boundary values in the interval.</summary>
 421     /// <value>The range value (must be between $0.0 and 1.0)</value>
 422     public double RangeValue {
 423         get { return GetRangeValue(); }
 424         set { SetRangeValue(value); }
 425     }
 426     /// <summary>Control the step used to increment or decrement values for given widget.
 427     /// This value will be incremented or decremented to the displayed value.
 428     ///
 429     /// By default step value is equal to 1.
 430     ///
 431     /// Warning: The step value should be bigger than 0.</summary>
 432     /// <value>The step value.</value>
 433     public double RangeStep {
 434         get { return GetRangeStep(); }
 435         set { SetRangeStep(value); }
 436     }
 437     private static IntPtr GetEflClassStatic()
 438     {
 439         return Efl.Ui.Spin.efl_ui_spin_class_get();
 440     }
 441     /// <summary>Wrapper for native methods and virtual method delegates.
 442     /// For internal use by generated code only.</summary>
 443     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 444     {
 445         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 446         /// <summary>Gets the list of Eo operations to override.</summary>
 447         /// <returns>The list of Eo operations to be overload.</returns>
 448         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 449         {
 450             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 451             var methods = Efl.Eo.Globals.GetUserMethods(type);
 452
 453             if (efl_access_value_and_text_get_static_delegate == null)
 454             {
 455                 efl_access_value_and_text_get_static_delegate = new efl_access_value_and_text_get_delegate(value_and_text_get);
 456             }
 457
 458             if (methods.FirstOrDefault(m => m.Name == "GetValueAndText") != null)
 459             {
 460                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_value_and_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_value_and_text_get_static_delegate) });
 461             }
 462
 463             if (efl_access_value_and_text_set_static_delegate == null)
 464             {
 465                 efl_access_value_and_text_set_static_delegate = new efl_access_value_and_text_set_delegate(value_and_text_set);
 466             }
 467
 468             if (methods.FirstOrDefault(m => m.Name == "SetValueAndText") != null)
 469             {
 470                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_value_and_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_access_value_and_text_set_static_delegate) });
 471             }
 472
 473             if (efl_access_value_range_get_static_delegate == null)
 474             {
 475                 efl_access_value_range_get_static_delegate = new efl_access_value_range_get_delegate(range_get);
 476             }
 477
 478             if (methods.FirstOrDefault(m => m.Name == "GetRange") != null)
 479             {
 480                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_value_range_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_value_range_get_static_delegate) });
 481             }
 482
 483             if (efl_access_value_increment_get_static_delegate == null)
 484             {
 485                 efl_access_value_increment_get_static_delegate = new efl_access_value_increment_get_delegate(increment_get);
 486             }
 487
 488             if (methods.FirstOrDefault(m => m.Name == "GetIncrement") != null)
 489             {
 490                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_access_value_increment_get"), func = Marshal.GetFunctionPointerForDelegate(efl_access_value_increment_get_static_delegate) });
 491             }
 492
 493             if (efl_ui_format_func_get_static_delegate == null)
 494             {
 495                 efl_ui_format_func_get_static_delegate = new efl_ui_format_func_get_delegate(format_func_get);
 496             }
 497
 498             if (methods.FirstOrDefault(m => m.Name == "GetFormatFunc") != null)
 499             {
 500                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_func_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_func_get_static_delegate) });
 501             }
 502
 503             if (efl_ui_format_func_set_static_delegate == null)
 504             {
 505                 efl_ui_format_func_set_static_delegate = new efl_ui_format_func_set_delegate(format_func_set);
 506             }
 507
 508             if (methods.FirstOrDefault(m => m.Name == "SetFormatFunc") != null)
 509             {
 510                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_func_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_func_set_static_delegate) });
 511             }
 512
 513             if (efl_ui_format_values_get_static_delegate == null)
 514             {
 515                 efl_ui_format_values_get_static_delegate = new efl_ui_format_values_get_delegate(format_values_get);
 516             }
 517
 518             if (methods.FirstOrDefault(m => m.Name == "GetFormatValues") != null)
 519             {
 520                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_values_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_values_get_static_delegate) });
 521             }
 522
 523             if (efl_ui_format_values_set_static_delegate == null)
 524             {
 525                 efl_ui_format_values_set_static_delegate = new efl_ui_format_values_set_delegate(format_values_set);
 526             }
 527
 528             if (methods.FirstOrDefault(m => m.Name == "SetFormatValues") != null)
 529             {
 530                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_values_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_values_set_static_delegate) });
 531             }
 532
 533             if (efl_ui_format_string_get_static_delegate == null)
 534             {
 535                 efl_ui_format_string_get_static_delegate = new efl_ui_format_string_get_delegate(format_string_get);
 536             }
 537
 538             if (methods.FirstOrDefault(m => m.Name == "GetFormatString") != null)
 539             {
 540                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_string_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_string_get_static_delegate) });
 541             }
 542
 543             if (efl_ui_format_string_set_static_delegate == null)
 544             {
 545                 efl_ui_format_string_set_static_delegate = new efl_ui_format_string_set_delegate(format_string_set);
 546             }
 547
 548             if (methods.FirstOrDefault(m => m.Name == "SetFormatString") != null)
 549             {
 550                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_string_set_static_delegate) });
 551             }
 552
 553             if (efl_ui_format_formatted_value_get_static_delegate == null)
 554             {
 555                 efl_ui_format_formatted_value_get_static_delegate = new efl_ui_format_formatted_value_get_delegate(formatted_value_get);
 556             }
 557
 558             if (methods.FirstOrDefault(m => m.Name == "GetFormattedValue") != null)
 559             {
 560                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_formatted_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_formatted_value_get_static_delegate) });
 561             }
 562
 563             if (efl_ui_format_decimal_places_get_static_delegate == null)
 564             {
 565                 efl_ui_format_decimal_places_get_static_delegate = new efl_ui_format_decimal_places_get_delegate(decimal_places_get);
 566             }
 567
 568             if (methods.FirstOrDefault(m => m.Name == "GetDecimalPlaces") != null)
 569             {
 570                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_decimal_places_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_decimal_places_get_static_delegate) });
 571             }
 572
 573             if (efl_ui_format_apply_formatted_value_static_delegate == null)
 574             {
 575                 efl_ui_format_apply_formatted_value_static_delegate = new efl_ui_format_apply_formatted_value_delegate(apply_formatted_value);
 576             }
 577
 578             if (methods.FirstOrDefault(m => m.Name == "ApplyFormattedValue") != null)
 579             {
 580                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_apply_formatted_value"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_apply_formatted_value_static_delegate) });
 581             }
 582
 583             if (efl_ui_range_value_get_static_delegate == null)
 584             {
 585                 efl_ui_range_value_get_static_delegate = new efl_ui_range_value_get_delegate(range_value_get);
 586             }
 587
 588             if (methods.FirstOrDefault(m => m.Name == "GetRangeValue") != null)
 589             {
 590                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_get_static_delegate) });
 591             }
 592
 593             if (efl_ui_range_value_set_static_delegate == null)
 594             {
 595                 efl_ui_range_value_set_static_delegate = new efl_ui_range_value_set_delegate(range_value_set);
 596             }
 597
 598             if (methods.FirstOrDefault(m => m.Name == "SetRangeValue") != null)
 599             {
 600                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_value_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_value_set_static_delegate) });
 601             }
 602
 603             if (efl_ui_range_limits_get_static_delegate == null)
 604             {
 605                 efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
 606             }
 607
 608             if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
 609             {
 610                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_get_static_delegate) });
 611             }
 612
 613             if (efl_ui_range_limits_set_static_delegate == null)
 614             {
 615                 efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
 616             }
 617
 618             if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
 619             {
 620                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_limits_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_limits_set_static_delegate) });
 621             }
 622
 623             if (efl_ui_range_step_get_static_delegate == null)
 624             {
 625                 efl_ui_range_step_get_static_delegate = new efl_ui_range_step_get_delegate(range_step_get);
 626             }
 627
 628             if (methods.FirstOrDefault(m => m.Name == "GetRangeStep") != null)
 629             {
 630                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_step_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_step_get_static_delegate) });
 631             }
 632
 633             if (efl_ui_range_step_set_static_delegate == null)
 634             {
 635                 efl_ui_range_step_set_static_delegate = new efl_ui_range_step_set_delegate(range_step_set);
 636             }
 637
 638             if (methods.FirstOrDefault(m => m.Name == "SetRangeStep") != null)
 639             {
 640                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_range_step_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_range_step_set_static_delegate) });
 641             }
 642
 643             descs.AddRange(base.GetEoOps(type));
 644             return descs;
 645         }
 646         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 647         /// <returns>The native class pointer.</returns>
 648         public override IntPtr GetEflClass()
 649         {
 650             return Efl.Ui.Spin.efl_ui_spin_class_get();
 651         }
 652
 653         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 654
 655
 656         private delegate void efl_access_value_and_text_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double value, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String text);
 657
 658
 659         public delegate void efl_access_value_and_text_get_api_delegate(System.IntPtr obj,  out double value, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String text);
 660
 661         public static Efl.Eo.FunctionWrapper<efl_access_value_and_text_get_api_delegate> efl_access_value_and_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_value_and_text_get_api_delegate>(Module, "efl_access_value_and_text_get");
 662
 663         private static void value_and_text_get(System.IntPtr obj, System.IntPtr pd, out double value, out System.String text)
 664         {
 665             Eina.Log.Debug("function efl_access_value_and_text_get was called");
 666             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 667             if (ws != null)
 668             {
 669                         value = default(double);        System.String _out_text = default(System.String);
 670
 671                 try
 672                 {
 673                     ((Spin)ws.Target).GetValueAndText(out value, out _out_text);
 674                 }
 675                 catch (Exception e)
 676                 {
 677                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 678                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 679                 }
 680
 681                 text = _out_text;
 682
 683             }
 684             else
 685             {
 686                 efl_access_value_and_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out value, out text);
 687             }
 688         }
 689
 690         private static efl_access_value_and_text_get_delegate efl_access_value_and_text_get_static_delegate;
 691
 692         [return: MarshalAs(UnmanagedType.U1)]
 693         private delegate bool efl_access_value_and_text_set_delegate(System.IntPtr obj, System.IntPtr pd,  double value, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
 694
 695         [return: MarshalAs(UnmanagedType.U1)]
 696         public delegate bool efl_access_value_and_text_set_api_delegate(System.IntPtr obj,  double value, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
 697
 698         public static Efl.Eo.FunctionWrapper<efl_access_value_and_text_set_api_delegate> efl_access_value_and_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_access_value_and_text_set_api_delegate>(Module, "efl_access_value_and_text_set");
 699
 700         private static bool value_and_text_set(System.IntPtr obj, System.IntPtr pd, double value, System.String text)
 701         {
 702             Eina.Log.Debug("function efl_access_value_and_text_set was called");
 703             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 704             if (ws != null)
 705             {
 706                                                             bool _ret_var = default(bool);
 707                 try
 708                 {
 709                     _ret_var = ((Spin)ws.Target).SetValueAndText(value, text);
 710                 }
 711                 catch (Exception e)
 712                 {
 713                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 714                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 715                 }
 716
 717                                         return _ret_var;
 718
 719             }
 720             else
 721             {
 722                 return efl_access_value_and_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value, text);
 723             }
 724         }
 725
 726         private static efl_access_value_and_text_set_delegate efl_access_value_and_text_set_static_delegate;
 727
 728
 729         private delegate void efl_access_value_range_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double lower_limit,  out double upper_limit, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String description);
 730
 731
 732         public delegate void efl_access_value_range_get_api_delegate(System.IntPtr obj,  out double lower_limit,  out double upper_limit, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String description);
 733
 734         public static Efl.Eo.FunctionWrapper<efl_access_value_range_get_api_delegate> efl_access_value_range_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_value_range_get_api_delegate>(Module, "efl_access_value_range_get");
 735
 736         private static void range_get(System.IntPtr obj, System.IntPtr pd, out double lower_limit, out double upper_limit, out System.String description)
 737         {
 738             Eina.Log.Debug("function efl_access_value_range_get was called");
 739             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 740             if (ws != null)
 741             {
 742                                 lower_limit = default(double);        upper_limit = default(double);        System.String _out_description = default(System.String);
 743
 744                 try
 745                 {
 746                     ((Spin)ws.Target).GetRange(out lower_limit, out upper_limit, out _out_description);
 747                 }
 748                 catch (Exception e)
 749                 {
 750                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 751                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 752                 }
 753
 754                         description = _out_description;
 755
 756             }
 757             else
 758             {
 759                 efl_access_value_range_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out lower_limit, out upper_limit, out description);
 760             }
 761         }
 762
 763         private static efl_access_value_range_get_delegate efl_access_value_range_get_static_delegate;
 764
 765
 766         private delegate double efl_access_value_increment_get_delegate(System.IntPtr obj, System.IntPtr pd);
 767
 768
 769         public delegate double efl_access_value_increment_get_api_delegate(System.IntPtr obj);
 770
 771         public static Efl.Eo.FunctionWrapper<efl_access_value_increment_get_api_delegate> efl_access_value_increment_get_ptr = new Efl.Eo.FunctionWrapper<efl_access_value_increment_get_api_delegate>(Module, "efl_access_value_increment_get");
 772
 773         private static double increment_get(System.IntPtr obj, System.IntPtr pd)
 774         {
 775             Eina.Log.Debug("function efl_access_value_increment_get was called");
 776             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 777             if (ws != null)
 778             {
 779             double _ret_var = default(double);
 780                 try
 781                 {
 782                     _ret_var = ((Spin)ws.Target).GetIncrement();
 783                 }
 784                 catch (Exception e)
 785                 {
 786                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 787                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 788                 }
 789
 790         return _ret_var;
 791
 792             }
 793             else
 794             {
 795                 return efl_access_value_increment_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 796             }
 797         }
 798
 799         private static efl_access_value_increment_get_delegate efl_access_value_increment_get_static_delegate;
 800
 801
 802         private delegate Efl.Ui.FormatFunc efl_ui_format_func_get_delegate(System.IntPtr obj, System.IntPtr pd);
 803
 804
 805         public delegate Efl.Ui.FormatFunc efl_ui_format_func_get_api_delegate(System.IntPtr obj);
 806
 807         public static Efl.Eo.FunctionWrapper<efl_ui_format_func_get_api_delegate> efl_ui_format_func_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_func_get_api_delegate>(Module, "efl_ui_format_func_get");
 808
 809         private static Efl.Ui.FormatFunc format_func_get(System.IntPtr obj, System.IntPtr pd)
 810         {
 811             Eina.Log.Debug("function efl_ui_format_func_get was called");
 812             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 813             if (ws != null)
 814             {
 815             Efl.Ui.FormatFunc _ret_var = default(Efl.Ui.FormatFunc);
 816                 try
 817                 {
 818                     _ret_var = ((Spin)ws.Target).GetFormatFunc();
 819                 }
 820                 catch (Exception e)
 821                 {
 822                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 823                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 824                 }
 825
 826         return _ret_var;
 827
 828             }
 829             else
 830             {
 831                 return efl_ui_format_func_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 832             }
 833         }
 834
 835         private static efl_ui_format_func_get_delegate efl_ui_format_func_get_static_delegate;
 836
 837
 838         private delegate void efl_ui_format_func_set_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, Efl.Ui.FormatFuncInternal func, EinaFreeCb func_free_cb);
 839
 840
 841         public delegate void efl_ui_format_func_set_api_delegate(System.IntPtr obj,  IntPtr func_data, Efl.Ui.FormatFuncInternal func, EinaFreeCb func_free_cb);
 842
 843         public static Efl.Eo.FunctionWrapper<efl_ui_format_func_set_api_delegate> efl_ui_format_func_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_func_set_api_delegate>(Module, "efl_ui_format_func_set");
 844
 845         private static void format_func_set(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, Efl.Ui.FormatFuncInternal func, EinaFreeCb func_free_cb)
 846         {
 847             Eina.Log.Debug("function efl_ui_format_func_set was called");
 848             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 849             if (ws != null)
 850             {
 851                             Efl.Ui.FormatFuncWrapper func_wrapper = new Efl.Ui.FormatFuncWrapper(func, func_data, func_free_cb);
 852
 853                 try
 854                 {
 855                     ((Spin)ws.Target).SetFormatFunc(func_wrapper.ManagedCb);
 856                 }
 857                 catch (Exception e)
 858                 {
 859                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 860                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 861                 }
 862
 863
 864             }
 865             else
 866             {
 867                 efl_ui_format_func_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
 868             }
 869         }
 870
 871         private static efl_ui_format_func_set_delegate efl_ui_format_func_set_static_delegate;
 872
 873
 874         private delegate System.IntPtr efl_ui_format_values_get_delegate(System.IntPtr obj, System.IntPtr pd);
 875
 876
 877         public delegate System.IntPtr efl_ui_format_values_get_api_delegate(System.IntPtr obj);
 878
 879         public static Efl.Eo.FunctionWrapper<efl_ui_format_values_get_api_delegate> efl_ui_format_values_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_values_get_api_delegate>(Module, "efl_ui_format_values_get");
 880
 881         private static System.IntPtr format_values_get(System.IntPtr obj, System.IntPtr pd)
 882         {
 883             Eina.Log.Debug("function efl_ui_format_values_get was called");
 884             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 885             if (ws != null)
 886             {
 887             Eina.Accessor<Efl.Ui.FormatValue> _ret_var = default(Eina.Accessor<Efl.Ui.FormatValue>);
 888                 try
 889                 {
 890                     _ret_var = ((Spin)ws.Target).GetFormatValues();
 891                 }
 892                 catch (Exception e)
 893                 {
 894                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 895                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 896                 }
 897
 898         return _ret_var.Handle;
 899
 900             }
 901             else
 902             {
 903                 return efl_ui_format_values_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 904             }
 905         }
 906
 907         private static efl_ui_format_values_get_delegate efl_ui_format_values_get_static_delegate;
 908
 909
 910         private delegate void efl_ui_format_values_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr values);
 911
 912
 913         public delegate void efl_ui_format_values_set_api_delegate(System.IntPtr obj,  System.IntPtr values);
 914
 915         public static Efl.Eo.FunctionWrapper<efl_ui_format_values_set_api_delegate> efl_ui_format_values_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_values_set_api_delegate>(Module, "efl_ui_format_values_set");
 916
 917         private static void format_values_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr values)
 918         {
 919             Eina.Log.Debug("function efl_ui_format_values_set was called");
 920             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 921             if (ws != null)
 922             {
 923         var _in_values = new Eina.Accessor<Efl.Ui.FormatValue>(values, false);
 924
 925                 try
 926                 {
 927                     ((Spin)ws.Target).SetFormatValues(_in_values);
 928                 }
 929                 catch (Exception e)
 930                 {
 931                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 932                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 933                 }
 934
 935
 936             }
 937             else
 938             {
 939                 efl_ui_format_values_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), values);
 940             }
 941         }
 942
 943         private static efl_ui_format_values_set_delegate efl_ui_format_values_set_static_delegate;
 944
 945
 946         private delegate void efl_ui_format_string_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String kw_string,  out Efl.Ui.FormatStringType type);
 947
 948
 949         public delegate void efl_ui_format_string_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String kw_string,  out Efl.Ui.FormatStringType type);
 950
 951         public static Efl.Eo.FunctionWrapper<efl_ui_format_string_get_api_delegate> efl_ui_format_string_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_string_get_api_delegate>(Module, "efl_ui_format_string_get");
 952
 953         private static void format_string_get(System.IntPtr obj, System.IntPtr pd, out System.String kw_string, out Efl.Ui.FormatStringType type)
 954         {
 955             Eina.Log.Debug("function efl_ui_format_string_get was called");
 956             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 957             if (ws != null)
 958             {
 959                         System.String _out_kw_string = default(System.String);
 960         type = default(Efl.Ui.FormatStringType);
 961                 try
 962                 {
 963                     ((Spin)ws.Target).GetFormatString(out _out_kw_string, out type);
 964                 }
 965                 catch (Exception e)
 966                 {
 967                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 968                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 969                 }
 970
 971         kw_string = _out_kw_string;
 972
 973             }
 974             else
 975             {
 976                 efl_ui_format_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out kw_string, out type);
 977             }
 978         }
 979
 980         private static efl_ui_format_string_get_delegate efl_ui_format_string_get_static_delegate;
 981
 982
 983         private delegate void efl_ui_format_string_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String kw_string,  Efl.Ui.FormatStringType type);
 984
 985
 986         public delegate void efl_ui_format_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String kw_string,  Efl.Ui.FormatStringType type);
 987
 988         public static Efl.Eo.FunctionWrapper<efl_ui_format_string_set_api_delegate> efl_ui_format_string_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_string_set_api_delegate>(Module, "efl_ui_format_string_set");
 989
 990         private static void format_string_set(System.IntPtr obj, System.IntPtr pd, System.String kw_string, Efl.Ui.FormatStringType type)
 991         {
 992             Eina.Log.Debug("function efl_ui_format_string_set was called");
 993             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 994             if (ws != null)
 995             {
 996
 997                 try
 998                 {
 999                     ((Spin)ws.Target).SetFormatString(kw_string, type);
1000                 }
1001                 catch (Exception e)
1002                 {
1003                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1004                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1005                 }
1006
1007
1008             }
1009             else
1010             {
1011                 efl_ui_format_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), kw_string, type);
1012             }
1013         }
1014
1015         private static efl_ui_format_string_set_delegate efl_ui_format_string_set_static_delegate;
1016
1017
1018         private delegate void efl_ui_format_formatted_value_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))] Eina.Strbuf str,  Eina.ValueNative value);
1019
1020
1021         public delegate void efl_ui_format_formatted_value_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))] Eina.Strbuf str,  Eina.ValueNative value);
1022
1023         public static Efl.Eo.FunctionWrapper<efl_ui_format_formatted_value_get_api_delegate> efl_ui_format_formatted_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_formatted_value_get_api_delegate>(Module, "efl_ui_format_formatted_value_get");
1024
1025         private static void formatted_value_get(System.IntPtr obj, System.IntPtr pd, Eina.Strbuf str, Eina.ValueNative value)
1026         {
1027             Eina.Log.Debug("function efl_ui_format_formatted_value_get was called");
1028             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1029             if (ws != null)
1030             {
1031
1032                 try
1033                 {
1034                     ((Spin)ws.Target).GetFormattedValue(str, value);
1035                 }
1036                 catch (Exception e)
1037                 {
1038                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1039                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1040                 }
1041
1042
1043             }
1044             else
1045             {
1046                 efl_ui_format_formatted_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), str, value);
1047             }
1048         }
1049
1050         private static efl_ui_format_formatted_value_get_delegate efl_ui_format_formatted_value_get_static_delegate;
1051
1052
1053         private delegate int efl_ui_format_decimal_places_get_delegate(System.IntPtr obj, System.IntPtr pd);
1054
1055
1056         public delegate int efl_ui_format_decimal_places_get_api_delegate(System.IntPtr obj);
1057
1058         public static Efl.Eo.FunctionWrapper<efl_ui_format_decimal_places_get_api_delegate> efl_ui_format_decimal_places_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_decimal_places_get_api_delegate>(Module, "efl_ui_format_decimal_places_get");
1059
1060         private static int decimal_places_get(System.IntPtr obj, System.IntPtr pd)
1061         {
1062             Eina.Log.Debug("function efl_ui_format_decimal_places_get was called");
1063             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1064             if (ws != null)
1065             {
1066             int _ret_var = default(int);
1067                 try
1068                 {
1069                     _ret_var = ((Spin)ws.Target).GetDecimalPlaces();
1070                 }
1071                 catch (Exception e)
1072                 {
1073                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1074                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1075                 }
1076
1077         return _ret_var;
1078
1079             }
1080             else
1081             {
1082                 return efl_ui_format_decimal_places_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1083             }
1084         }
1085
1086         private static efl_ui_format_decimal_places_get_delegate efl_ui_format_decimal_places_get_static_delegate;
1087
1088
1089         private delegate void efl_ui_format_apply_formatted_value_delegate(System.IntPtr obj, System.IntPtr pd);
1090
1091
1092         public delegate void efl_ui_format_apply_formatted_value_api_delegate(System.IntPtr obj);
1093
1094         public static Efl.Eo.FunctionWrapper<efl_ui_format_apply_formatted_value_api_delegate> efl_ui_format_apply_formatted_value_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_apply_formatted_value_api_delegate>(Module, "efl_ui_format_apply_formatted_value");
1095
1096         private static void apply_formatted_value(System.IntPtr obj, System.IntPtr pd)
1097         {
1098             Eina.Log.Debug("function efl_ui_format_apply_formatted_value was called");
1099             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1100             if (ws != null)
1101             {
1102
1103                 try
1104                 {
1105                     ((Spin)ws.Target).ApplyFormattedValue();
1106                 }
1107                 catch (Exception e)
1108                 {
1109                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1110                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1111                 }
1112
1113
1114             }
1115             else
1116             {
1117                 efl_ui_format_apply_formatted_value_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1118             }
1119         }
1120
1121         private static efl_ui_format_apply_formatted_value_delegate efl_ui_format_apply_formatted_value_static_delegate;
1122
1123
1124         private delegate double efl_ui_range_value_get_delegate(System.IntPtr obj, System.IntPtr pd);
1125
1126
1127         public delegate double efl_ui_range_value_get_api_delegate(System.IntPtr obj);
1128
1129         public static Efl.Eo.FunctionWrapper<efl_ui_range_value_get_api_delegate> efl_ui_range_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_value_get_api_delegate>(Module, "efl_ui_range_value_get");
1130
1131         private static double range_value_get(System.IntPtr obj, System.IntPtr pd)
1132         {
1133             Eina.Log.Debug("function efl_ui_range_value_get was called");
1134             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1135             if (ws != null)
1136             {
1137             double _ret_var = default(double);
1138                 try
1139                 {
1140                     _ret_var = ((Spin)ws.Target).GetRangeValue();
1141                 }
1142                 catch (Exception e)
1143                 {
1144                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1145                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1146                 }
1147
1148         return _ret_var;
1149
1150             }
1151             else
1152             {
1153                 return efl_ui_range_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1154             }
1155         }
1156
1157         private static efl_ui_range_value_get_delegate efl_ui_range_value_get_static_delegate;
1158
1159
1160         private delegate void efl_ui_range_value_set_delegate(System.IntPtr obj, System.IntPtr pd,  double val);
1161
1162
1163         public delegate void efl_ui_range_value_set_api_delegate(System.IntPtr obj,  double val);
1164
1165         public static Efl.Eo.FunctionWrapper<efl_ui_range_value_set_api_delegate> efl_ui_range_value_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_value_set_api_delegate>(Module, "efl_ui_range_value_set");
1166
1167         private static void range_value_set(System.IntPtr obj, System.IntPtr pd, double val)
1168         {
1169             Eina.Log.Debug("function efl_ui_range_value_set was called");
1170             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1171             if (ws != null)
1172             {
1173
1174                 try
1175                 {
1176                     ((Spin)ws.Target).SetRangeValue(val);
1177                 }
1178                 catch (Exception e)
1179                 {
1180                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1181                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1182                 }
1183
1184
1185             }
1186             else
1187             {
1188                 efl_ui_range_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1189             }
1190         }
1191
1192         private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
1193
1194
1195         private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double min,  out double max);
1196
1197
1198         public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj,  out double min,  out double max);
1199
1200         public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate> efl_ui_range_limits_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_get_api_delegate>(Module, "efl_ui_range_limits_get");
1201
1202         private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
1203         {
1204             Eina.Log.Debug("function efl_ui_range_limits_get was called");
1205             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1206             if (ws != null)
1207             {
1208                         min = default(double);        max = default(double);
1209                 try
1210                 {
1211                     ((Spin)ws.Target).GetRangeLimits(out min, out max);
1212                 }
1213                 catch (Exception e)
1214                 {
1215                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1216                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1217                 }
1218
1219
1220             }
1221             else
1222             {
1223                 efl_ui_range_limits_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out min, out max);
1224             }
1225         }
1226
1227         private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
1228
1229
1230         private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd,  double min,  double max);
1231
1232
1233         public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj,  double min,  double max);
1234
1235         public static Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate> efl_ui_range_limits_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_limits_set_api_delegate>(Module, "efl_ui_range_limits_set");
1236
1237         private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
1238         {
1239             Eina.Log.Debug("function efl_ui_range_limits_set was called");
1240             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1241             if (ws != null)
1242             {
1243
1244                 try
1245                 {
1246                     ((Spin)ws.Target).SetRangeLimits(min, max);
1247                 }
1248                 catch (Exception e)
1249                 {
1250                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1251                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1252                 }
1253
1254
1255             }
1256             else
1257             {
1258                 efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
1259             }
1260         }
1261
1262         private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
1263
1264
1265         private delegate double efl_ui_range_step_get_delegate(System.IntPtr obj, System.IntPtr pd);
1266
1267
1268         public delegate double efl_ui_range_step_get_api_delegate(System.IntPtr obj);
1269
1270         public static Efl.Eo.FunctionWrapper<efl_ui_range_step_get_api_delegate> efl_ui_range_step_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_step_get_api_delegate>(Module, "efl_ui_range_step_get");
1271
1272         private static double range_step_get(System.IntPtr obj, System.IntPtr pd)
1273         {
1274             Eina.Log.Debug("function efl_ui_range_step_get was called");
1275             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1276             if (ws != null)
1277             {
1278             double _ret_var = default(double);
1279                 try
1280                 {
1281                     _ret_var = ((Spin)ws.Target).GetRangeStep();
1282                 }
1283                 catch (Exception e)
1284                 {
1285                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1286                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1287                 }
1288
1289         return _ret_var;
1290
1291             }
1292             else
1293             {
1294                 return efl_ui_range_step_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1295             }
1296         }
1297
1298         private static efl_ui_range_step_get_delegate efl_ui_range_step_get_static_delegate;
1299
1300
1301         private delegate void efl_ui_range_step_set_delegate(System.IntPtr obj, System.IntPtr pd,  double step);
1302
1303
1304         public delegate void efl_ui_range_step_set_api_delegate(System.IntPtr obj,  double step);
1305
1306         public static Efl.Eo.FunctionWrapper<efl_ui_range_step_set_api_delegate> efl_ui_range_step_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_range_step_set_api_delegate>(Module, "efl_ui_range_step_set");
1307
1308         private static void range_step_set(System.IntPtr obj, System.IntPtr pd, double step)
1309         {
1310             Eina.Log.Debug("function efl_ui_range_step_set was called");
1311             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1312             if (ws != null)
1313             {
1314
1315                 try
1316                 {
1317                     ((Spin)ws.Target).SetRangeStep(step);
1318                 }
1319                 catch (Exception e)
1320                 {
1321                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1322                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1323                 }
1324
1325
1326             }
1327             else
1328             {
1329                 efl_ui_range_step_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), step);
1330             }
1331         }
1332
1333         private static efl_ui_range_step_set_delegate efl_ui_range_step_set_static_delegate;
1334
1335         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1336
1337 }
1338 }
1339 }
1340
1341 }
1342