internals/src/EflSharp/EflSharp/efl/efl_ui_progressbar.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>Elementary progressbar class</summary>
  13 [Efl.Ui.Progressbar.NativeMethods]
  14 public class Progressbar : Efl.Ui.LayoutBase, Efl.IContent, Efl.IText, Efl.ITextMarkup, Efl.Access.IValue, Efl.Ui.IFormat, Efl.Ui.ILayoutOrientable, Efl.Ui.IRangeDisplay
  15 {
  16     ///<summary>Pointer to the native class description.</summary>
  17     public override System.IntPtr NativeClass
  18     {
  19         get
  20         {
  21             if (((object)this).GetType() == typeof(Progressbar))
  22             {
  23                 return GetEflClassStatic();
  24             }
  25             else
  26             {
  27                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  28             }
  29         }
  30     }
  31
  32     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  33         efl_ui_progressbar_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Progressbar"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  37     public Progressbar(Efl.Object parent
  38             , System.String style = null) : base(efl_ui_progressbar_class_get(), typeof(Progressbar), parent)
  39     {
  40         if (Efl.Eo.Globals.ParamHelperCheck(style))
  41         {
  42             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  43         }
  44
  45         FinishInstantiation();
  46     }
  47
  48     /// <summary>Initializes a new instance of the <see cref="Progressbar"/> class.
  49     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  50     /// <param name="raw">The native pointer to be wrapped.</param>
  51     protected Progressbar(System.IntPtr raw) : base(raw)
  52     {
  53     }
  54
  55     /// <summary>Initializes a new instance of the <see cref="Progressbar"/> class.
  56     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  57     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  58     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected Progressbar(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  61     {
  62     }
  63
  64     /// <summary>Called when progressbar changed</summary>
  65     public event EventHandler ChangedEvt
  66     {
  67         add
  68         {
  69             lock (eventLock)
  70             {
  71                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  72                 {
  73                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  74                     if (obj != null)
  75                     {
  76                         EventArgs args = EventArgs.Empty;
  77                         try
  78                         {
  79                             value?.Invoke(obj, args);
  80                         }
  81                         catch (Exception e)
  82                         {
  83                             Eina.Log.Error(e.ToString());
  84                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  85                         }
  86                     }
  87                 };
  88
  89                 string key = "_EFL_UI_PROGRESSBAR_EVENT_CHANGED";
  90                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  91             }
  92         }
  93
  94         remove
  95         {
  96             lock (eventLock)
  97             {
  98                 string key = "_EFL_UI_PROGRESSBAR_EVENT_CHANGED";
  99                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 100             }
 101         }
 102     }
 103     ///<summary>Method to raise event ChangedEvt.</summary>
 104     public void OnChangedEvt(EventArgs e)
 105     {
 106         var key = "_EFL_UI_PROGRESSBAR_EVENT_CHANGED";
 107         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 108         if (desc == IntPtr.Zero)
 109         {
 110             Eina.Log.Error($"Failed to get native event {key}");
 111             return;
 112         }
 113
 114         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 115     }
 116     /// <summary>Sent after the content is set or unset using the current content object.
 117     /// (Since EFL 1.22)</summary>
 118     public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
 119     {
 120         add
 121         {
 122             lock (eventLock)
 123             {
 124                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 125                 {
 126                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 127                     if (obj != null)
 128                     {
 129                         Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
 130                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 131                         try
 132                         {
 133                             value?.Invoke(obj, args);
 134                         }
 135                         catch (Exception e)
 136                         {
 137                             Eina.Log.Error(e.ToString());
 138                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 139                         }
 140                     }
 141                 };
 142
 143                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 144                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 145             }
 146         }
 147
 148         remove
 149         {
 150             lock (eventLock)
 151             {
 152                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 153                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 154             }
 155         }
 156     }
 157     ///<summary>Method to raise event ContentChangedEvt.</summary>
 158     public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
 159     {
 160         var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 161         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 162         if (desc == IntPtr.Zero)
 163         {
 164             Eina.Log.Error($"Failed to get native event {key}");
 165             return;
 166         }
 167
 168         IntPtr info = e.arg.NativeHandle;
 169         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 170     }
 171     /// <summary>Control whether a given progress bar widget is at &quot;pulsing mode&quot; or not.
 172     /// By default progress bars display values from low to high boundaries. There are situations however in which the progress of a given task is unknown. In these cases, you can set a progress bar widget to a &quot;pulsing state&quot; to give the user an idea that some computation is being done without showing the precise progress rate. In the default theme, it will animate the bar with content, switching constantly between filling it and back to non-filled in a loop. To start and stop this pulsing animation you need to explicitly call <see cref="Efl.Ui.Progressbar.SetPulse"/>.</summary>
 173     /// <returns><c>true</c> to put <c>obj</c> in pulsing mode, <c>false</c> to put it back to its default one</returns>
 174     virtual public bool GetPulseMode() {
 175          var _ret_var = Efl.Ui.Progressbar.NativeMethods.efl_ui_progressbar_pulse_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 176         Eina.Error.RaiseIfUnhandledException();
 177         return _ret_var;
 178  }
 179     /// <summary>Control whether a given progress bar widget is at &quot;pulsing mode&quot; or not.
 180     /// By default progress bars display values from low to high boundaries. There are situations however in which the progress of a given task is unknown. In these cases, you can set a progress bar widget to a &quot;pulsing state&quot; to give the user an idea that some computation is being done without showing the precise progress rate. In the default theme, it will animate the bar with content, switching constantly between filling it and back to non-filled in a loop. To start and stop this pulsing animation you need to explicitly call <see cref="Efl.Ui.Progressbar.SetPulse"/>.</summary>
 181     /// <param name="pulse"><c>true</c> to put <c>obj</c> in pulsing mode, <c>false</c> to put it back to its default one</param>
 182     virtual public void SetPulseMode(bool pulse) {
 183                                  Efl.Ui.Progressbar.NativeMethods.efl_ui_progressbar_pulse_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),pulse);
 184         Eina.Error.RaiseIfUnhandledException();
 185                          }
 186     /// <summary>Get the pulsing state on a given progressbar widget. See <see cref="Efl.Ui.Progressbar.PulseMode"/>.</summary>
 187     /// <returns><c>true</c>, to start the pulsing animation, <c>false</c> to stop it</returns>
 188     virtual public bool GetPulse() {
 189          var _ret_var = Efl.Ui.Progressbar.NativeMethods.efl_ui_progressbar_pulse_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 190         Eina.Error.RaiseIfUnhandledException();
 191         return _ret_var;
 192  }
 193     /// <summary>Start/stop a given progress bar &quot;pulsing&quot; animation, if its under that mode
 194     /// Note: This call won&apos;t do anything if <c>obj</c> is not under &quot;pulsing mode&quot;. See <see cref="Efl.Ui.Progressbar.PulseMode"/>.</summary>
 195     /// <param name="state"><c>true</c>, to start the pulsing animation, <c>false</c> to stop it</param>
 196     virtual public void SetPulse(bool state) {
 197                                  Efl.Ui.Progressbar.NativeMethods.efl_ui_progressbar_pulse_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),state);
 198         Eina.Error.RaiseIfUnhandledException();
 199                          }
 200     /// <summary>Sub-object currently set as this object&apos;s single content.
 201     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 202     /// (Since EFL 1.22)</summary>
 203     /// <returns>The sub-object.</returns>
 204     virtual public Efl.Gfx.IEntity GetContent() {
 205          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 206         Eina.Error.RaiseIfUnhandledException();
 207         return _ret_var;
 208  }
 209     /// <summary>Sub-object currently set as this object&apos;s single content.
 210     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 211     /// (Since EFL 1.22)</summary>
 212     /// <param name="content">The sub-object.</param>
 213     /// <returns><c>true</c> if <c>content</c> was successfully swallowed.</returns>
 214     virtual public bool SetContent(Efl.Gfx.IEntity content) {
 215                                  var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
 216         Eina.Error.RaiseIfUnhandledException();
 217                         return _ret_var;
 218  }
 219     /// <summary>Remove the sub-object currently set as content of this object and return it. This object becomes empty.
 220     /// (Since EFL 1.22)</summary>
 221     /// <returns>Unswallowed object</returns>
 222     virtual public Efl.Gfx.IEntity UnsetContent() {
 223          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 224         Eina.Error.RaiseIfUnhandledException();
 225         return _ret_var;
 226  }
 227     /// <summary>Retrieves the text string currently being displayed by the given text object.
 228     /// Do not free() the return value.
 229     ///
 230     /// See also <see cref="Efl.IText.GetText"/>.
 231     /// (Since EFL 1.22)</summary>
 232     /// <returns>Text string to display on it.</returns>
 233     virtual public System.String GetText() {
 234          var _ret_var = Efl.ITextConcrete.NativeMethods.efl_text_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 235         Eina.Error.RaiseIfUnhandledException();
 236         return _ret_var;
 237  }
 238     /// <summary>Sets the text string to be displayed by the given text object.
 239     /// See also <see cref="Efl.IText.GetText"/>.
 240     /// (Since EFL 1.22)</summary>
 241     /// <param name="text">Text string to display on it.</param>
 242     virtual public void SetText(System.String text) {
 243                                  Efl.ITextConcrete.NativeMethods.efl_text_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),text);
 244         Eina.Error.RaiseIfUnhandledException();
 245                          }
 246     /// <summary>Markup property</summary>
 247     /// <returns>The markup-text representation set to this text.</returns>
 248     virtual public System.String GetMarkup() {
 249          var _ret_var = Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 250         Eina.Error.RaiseIfUnhandledException();
 251         return _ret_var;
 252  }
 253     /// <summary>Markup property</summary>
 254     /// <param name="markup">The markup-text representation set to this text.</param>
 255     virtual public void SetMarkup(System.String markup) {
 256                                  Efl.ITextMarkupConcrete.NativeMethods.efl_text_markup_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),markup);
 257         Eina.Error.RaiseIfUnhandledException();
 258                          }
 259     /// <summary>Gets value displayed by a accessible widget.</summary>
 260     /// <param name="value">Value of widget casted to floating point number.</param>
 261     /// <param name="text">string describing value in given context eg. small, enough</param>
 262     virtual public void GetValueAndText(out double value, out System.String text) {
 263                                                          Efl.Access.IValueConcrete.NativeMethods.efl_access_value_and_text_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out value, out text);
 264         Eina.Error.RaiseIfUnhandledException();
 265                                          }
 266     /// <summary>Value and text property</summary>
 267     /// <param name="value">Value of widget casted to floating point number.</param>
 268     /// <param name="text">string describing value in given context eg. small, enough</param>
 269     /// <returns><c>true</c> if setting widgets value has succeeded, otherwise <c>false</c> .</returns>
 270     virtual public bool SetValueAndText(double value, System.String text) {
 271                                                          var _ret_var = Efl.Access.IValueConcrete.NativeMethods.efl_access_value_and_text_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value, text);
 272         Eina.Error.RaiseIfUnhandledException();
 273                                         return _ret_var;
 274  }
 275     /// <summary>Gets a range of all possible values and its description</summary>
 276     /// <param name="lower_limit">Lower limit of the range</param>
 277     /// <param name="upper_limit">Upper limit of the range</param>
 278     /// <param name="description">Description of the range</param>
 279     virtual public void GetRange(out double lower_limit, out double upper_limit, out System.String description) {
 280                                                                                  Efl.Access.IValueConcrete.NativeMethods.efl_access_value_range_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out lower_limit, out upper_limit, out description);
 281         Eina.Error.RaiseIfUnhandledException();
 282                                                          }
 283     /// <summary>Gets an minimal incrementation value</summary>
 284     /// <returns>Minimal incrementation value</returns>
 285     virtual public double GetIncrement() {
 286          var _ret_var = Efl.Access.IValueConcrete.NativeMethods.efl_access_value_increment_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 287         Eina.Error.RaiseIfUnhandledException();
 288         return _ret_var;
 289  }
 290     /// <summary>Set the format function pointer to format the string.</summary>
 291     /// <param name="func">The format function callback</param>
 292     virtual public void SetFormatCb(Efl.Ui.FormatFuncCb func) {
 293                          GCHandle func_handle = GCHandle.Alloc(func);
 294         Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_cb_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),GCHandle.ToIntPtr(func_handle), Efl.Ui.FormatFuncCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 295         Eina.Error.RaiseIfUnhandledException();
 296                          }
 297     /// <summary>Control the format string for a given units label
 298     /// If <c>NULL</c> is passed to <c>format</c>, it will hide <c>obj</c>&apos;s units area completely. If not, it&apos;ll set the &lt;b&gt;format string&lt;/b&gt; for the units label text. The units label is provided as a floating point value, so the units text can display at most one floating point value. Note that the units label is optional. Use a format string such as &quot;%1.2f meters&quot; for example.
 299     ///
 300     /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 301     /// <returns>The format string for <c>obj</c>&apos;s units label.</returns>
 302     virtual public System.String GetFormatString() {
 303          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 304         Eina.Error.RaiseIfUnhandledException();
 305         return _ret_var;
 306  }
 307     /// <summary>Control the format string for a given units label
 308     /// If <c>NULL</c> is passed to <c>format</c>, it will hide <c>obj</c>&apos;s units area completely. If not, it&apos;ll set the &lt;b&gt;format string&lt;/b&gt; for the units label text. The units label is provided as a floating point value, so the units text can display at most one floating point value. Note that the units label is optional. Use a format string such as &quot;%1.2f meters&quot; for example.
 309     ///
 310     /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 311     /// <param name="units">The format string for <c>obj</c>&apos;s units label.</param>
 312     virtual public void SetFormatString(System.String units) {
 313                                  Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),units);
 314         Eina.Error.RaiseIfUnhandledException();
 315                          }
 316     /// <summary>Control the direction of a given widget.
 317     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 318     ///
 319     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 320     /// <returns>Direction of the widget.</returns>
 321     virtual public Efl.Ui.LayoutOrientation GetOrientation() {
 322          var _ret_var = Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 323         Eina.Error.RaiseIfUnhandledException();
 324         return _ret_var;
 325  }
 326     /// <summary>Control the direction of a given widget.
 327     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 328     ///
 329     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 330     /// <param name="dir">Direction of the widget.</param>
 331     virtual public void SetOrientation(Efl.Ui.LayoutOrientation dir) {
 332                                  Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dir);
 333         Eina.Error.RaiseIfUnhandledException();
 334                          }
 335     /// <summary>Control the range value (in percentage) on a given range widget
 336     /// Use this call to set range levels.
 337     ///
 338     /// 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>
 339     /// <returns>The range value (must be between $0.0 and 1.0)</returns>
 340     virtual public double GetRangeValue() {
 341          var _ret_var = Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_value_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 342         Eina.Error.RaiseIfUnhandledException();
 343         return _ret_var;
 344  }
 345     /// <summary>Control the range value (in percentage) on a given range widget
 346     /// Use this call to set range levels.
 347     ///
 348     /// 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>
 349     /// <param name="val">The range value (must be between $0.0 and 1.0)</param>
 350     virtual public void SetRangeValue(double val) {
 351                                  Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_value_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),val);
 352         Eina.Error.RaiseIfUnhandledException();
 353                          }
 354     /// <summary>Get the minimum and maximum values of the given range widget.
 355     /// Note: If only one value is needed, the other pointer can be passed as <c>null</c>.</summary>
 356     /// <param name="min">The minimum value.</param>
 357     /// <param name="max">The maximum value.</param>
 358     virtual public void GetRangeLimits(out double min, out double max) {
 359                                                          Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out min, out max);
 360         Eina.Error.RaiseIfUnhandledException();
 361                                          }
 362     /// <summary>Set the minimum and maximum values for given range widget.
 363     /// Define the allowed range of values to be selected by the user.
 364     ///
 365     /// 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"/>
 366     ///
 367     /// The minimum and maximum values may be different for each class.
 368     ///
 369     /// Warning: maximum must be greater than minimum, otherwise behavior is undefined.</summary>
 370     /// <param name="min">The minimum value.</param>
 371     /// <param name="max">The maximum value.</param>
 372     virtual public void SetRangeLimits(double min, double max) {
 373                                                          Efl.Ui.IRangeDisplayConcrete.NativeMethods.efl_ui_range_limits_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),min, max);
 374         Eina.Error.RaiseIfUnhandledException();
 375                                          }
 376     /// <summary>Control whether a given progress bar widget is at &quot;pulsing mode&quot; or not.
 377     /// By default progress bars display values from low to high boundaries. There are situations however in which the progress of a given task is unknown. In these cases, you can set a progress bar widget to a &quot;pulsing state&quot; to give the user an idea that some computation is being done without showing the precise progress rate. In the default theme, it will animate the bar with content, switching constantly between filling it and back to non-filled in a loop. To start and stop this pulsing animation you need to explicitly call <see cref="Efl.Ui.Progressbar.SetPulse"/>.</summary>
 378     /// <value><c>true</c> to put <c>obj</c> in pulsing mode, <c>false</c> to put it back to its default one</value>
 379     public bool PulseMode {
 380         get { return GetPulseMode(); }
 381         set { SetPulseMode(value); }
 382     }
 383     /// <summary>Get the pulsing state on a given progressbar widget. See <see cref="Efl.Ui.Progressbar.PulseMode"/>.</summary>
 384     /// <value><c>true</c>, to start the pulsing animation, <c>false</c> to stop it</value>
 385     public bool Pulse {
 386         get { return GetPulse(); }
 387         set { SetPulse(value); }
 388     }
 389     /// <summary>Sub-object currently set as this object&apos;s single content.
 390     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
 391     /// (Since EFL 1.22)</summary>
 392     /// <value>The sub-object.</value>
 393     public Efl.Gfx.IEntity Content {
 394         get { return GetContent(); }
 395         set { SetContent(value); }
 396     }
 397     /// <summary>Markup property</summary>
 398     /// <value>The markup-text representation set to this text.</value>
 399     public System.String Markup {
 400         get { return GetMarkup(); }
 401         set { SetMarkup(value); }
 402     }
 403     /// <summary>Gets an minimal incrementation value</summary>
 404     /// <value>Minimal incrementation value</value>
 405     public double Increment {
 406         get { return GetIncrement(); }
 407     }
 408     /// <summary>Set the format function pointer to format the string.</summary>
 409     /// <value>The format function callback</value>
 410     public Efl.Ui.FormatFuncCb FormatCb {
 411         set { SetFormatCb(value); }
 412     }
 413     /// <summary>Control the format string for a given units label
 414     /// If <c>NULL</c> is passed to <c>format</c>, it will hide <c>obj</c>&apos;s units area completely. If not, it&apos;ll set the &lt;b&gt;format string&lt;/b&gt; for the units label text. The units label is provided as a floating point value, so the units text can display at most one floating point value. Note that the units label is optional. Use a format string such as &quot;%1.2f meters&quot; for example.
 415     ///
 416     /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 417     /// <value>The format string for <c>obj</c>&apos;s units label.</value>
 418     public System.String FormatString {
 419         get { return GetFormatString(); }
 420         set { SetFormatString(value); }
 421     }
 422     /// <summary>Control the direction of a given widget.
 423     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 424     ///
 425     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 426     /// <value>Direction of the widget.</value>
 427     public Efl.Ui.LayoutOrientation Orientation {
 428         get { return GetOrientation(); }
 429         set { SetOrientation(value); }
 430     }
 431     /// <summary>Control the range value (in percentage) on a given range widget
 432     /// Use this call to set range levels.
 433     ///
 434     /// 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>
 435     /// <value>The range value (must be between $0.0 and 1.0)</value>
 436     public double RangeValue {
 437         get { return GetRangeValue(); }
 438         set { SetRangeValue(value); }
 439     }
 440     private static IntPtr GetEflClassStatic()
 441     {
 442         return Efl.Ui.Progressbar.efl_ui_progressbar_class_get();
 443     }
 444     /// <summary>Wrapper for native methods and virtual method delegates.
 445     /// For internal use by generated code only.</summary>
 446     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 447     {
 448         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 449         /// <summary>Gets the list of Eo operations to override.</summary>
 450         /// <returns>The list of Eo operations to be overload.</returns>
 451         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 452         {
 453             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 454             var methods = Efl.Eo.Globals.GetUserMethods(type);
 455
 456             if (efl_ui_progressbar_pulse_mode_get_static_delegate == null)
 457             {
 458                 efl_ui_progressbar_pulse_mode_get_static_delegate = new efl_ui_progressbar_pulse_mode_get_delegate(pulse_mode_get);
 459             }
 460
 461             if (methods.FirstOrDefault(m => m.Name == "GetPulseMode") != null)
 462             {
 463                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_progressbar_pulse_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_progressbar_pulse_mode_get_static_delegate) });
 464             }
 465
 466             if (efl_ui_progressbar_pulse_mode_set_static_delegate == null)
 467             {
 468                 efl_ui_progressbar_pulse_mode_set_static_delegate = new efl_ui_progressbar_pulse_mode_set_delegate(pulse_mode_set);
 469             }
 470
 471             if (methods.FirstOrDefault(m => m.Name == "SetPulseMode") != null)
 472             {
 473                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_progressbar_pulse_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_progressbar_pulse_mode_set_static_delegate) });
 474             }
 475
 476             if (efl_ui_progressbar_pulse_get_static_delegate == null)
 477             {
 478                 efl_ui_progressbar_pulse_get_static_delegate = new efl_ui_progressbar_pulse_get_delegate(pulse_get);
 479             }
 480
 481             if (methods.FirstOrDefault(m => m.Name == "GetPulse") != null)
 482             {
 483                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_progressbar_pulse_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_progressbar_pulse_get_static_delegate) });
 484             }
 485
 486             if (efl_ui_progressbar_pulse_set_static_delegate == null)
 487             {
 488                 efl_ui_progressbar_pulse_set_static_delegate = new efl_ui_progressbar_pulse_set_delegate(pulse_set);
 489             }
 490
 491             if (methods.FirstOrDefault(m => m.Name == "SetPulse") != null)
 492             {
 493                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_progressbar_pulse_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_progressbar_pulse_set_static_delegate) });
 494             }
 495
 496             if (efl_content_get_static_delegate == null)
 497             {
 498                 efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
 499             }
 500
 501             if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
 502             {
 503                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_content_get_static_delegate) });
 504             }
 505
 506             if (efl_content_set_static_delegate == null)
 507             {
 508                 efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
 509             }
 510
 511             if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
 512             {
 513                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_content_set_static_delegate) });
 514             }
 515
 516             if (efl_content_unset_static_delegate == null)
 517             {
 518                 efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
 519             }
 520
 521             if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
 522             {
 523                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_content_unset_static_delegate) });
 524             }
 525
 526             if (efl_text_get_static_delegate == null)
 527             {
 528                 efl_text_get_static_delegate = new efl_text_get_delegate(text_get);
 529             }
 530
 531             if (methods.FirstOrDefault(m => m.Name == "GetText") != null)
 532             {
 533                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_get_static_delegate) });
 534             }
 535
 536             if (efl_text_set_static_delegate == null)
 537             {
 538                 efl_text_set_static_delegate = new efl_text_set_delegate(text_set);
 539             }
 540
 541             if (methods.FirstOrDefault(m => m.Name == "SetText") != null)
 542             {
 543                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_set_static_delegate) });
 544             }
 545
 546             if (efl_text_markup_get_static_delegate == null)
 547             {
 548                 efl_text_markup_get_static_delegate = new efl_text_markup_get_delegate(markup_get);
 549             }
 550
 551             if (methods.FirstOrDefault(m => m.Name == "GetMarkup") != null)
 552             {
 553                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_get"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_get_static_delegate) });
 554             }
 555
 556             if (efl_text_markup_set_static_delegate == null)
 557             {
 558                 efl_text_markup_set_static_delegate = new efl_text_markup_set_delegate(markup_set);
 559             }
 560
 561             if (methods.FirstOrDefault(m => m.Name == "SetMarkup") != null)
 562             {
 563                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_text_markup_set"), func = Marshal.GetFunctionPointerForDelegate(efl_text_markup_set_static_delegate) });
 564             }
 565
 566             if (efl_access_value_and_text_get_static_delegate == null)
 567             {
 568                 efl_access_value_and_text_get_static_delegate = new efl_access_value_and_text_get_delegate(value_and_text_get);
 569             }
 570
 571             if (methods.FirstOrDefault(m => m.Name == "GetValueAndText") != null)
 572             {
 573                 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) });
 574             }
 575
 576             if (efl_access_value_and_text_set_static_delegate == null)
 577             {
 578                 efl_access_value_and_text_set_static_delegate = new efl_access_value_and_text_set_delegate(value_and_text_set);
 579             }
 580
 581             if (methods.FirstOrDefault(m => m.Name == "SetValueAndText") != null)
 582             {
 583                 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) });
 584             }
 585
 586             if (efl_access_value_range_get_static_delegate == null)
 587             {
 588                 efl_access_value_range_get_static_delegate = new efl_access_value_range_get_delegate(range_get);
 589             }
 590
 591             if (methods.FirstOrDefault(m => m.Name == "GetRange") != null)
 592             {
 593                 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) });
 594             }
 595
 596             if (efl_access_value_increment_get_static_delegate == null)
 597             {
 598                 efl_access_value_increment_get_static_delegate = new efl_access_value_increment_get_delegate(increment_get);
 599             }
 600
 601             if (methods.FirstOrDefault(m => m.Name == "GetIncrement") != null)
 602             {
 603                 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) });
 604             }
 605
 606             if (efl_ui_format_cb_set_static_delegate == null)
 607             {
 608                 efl_ui_format_cb_set_static_delegate = new efl_ui_format_cb_set_delegate(format_cb_set);
 609             }
 610
 611             if (methods.FirstOrDefault(m => m.Name == "SetFormatCb") != null)
 612             {
 613                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_cb_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_cb_set_static_delegate) });
 614             }
 615
 616             if (efl_ui_format_string_get_static_delegate == null)
 617             {
 618                 efl_ui_format_string_get_static_delegate = new efl_ui_format_string_get_delegate(format_string_get);
 619             }
 620
 621             if (methods.FirstOrDefault(m => m.Name == "GetFormatString") != null)
 622             {
 623                 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) });
 624             }
 625
 626             if (efl_ui_format_string_set_static_delegate == null)
 627             {
 628                 efl_ui_format_string_set_static_delegate = new efl_ui_format_string_set_delegate(format_string_set);
 629             }
 630
 631             if (methods.FirstOrDefault(m => m.Name == "SetFormatString") != null)
 632             {
 633                 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) });
 634             }
 635
 636             if (efl_ui_layout_orientation_get_static_delegate == null)
 637             {
 638                 efl_ui_layout_orientation_get_static_delegate = new efl_ui_layout_orientation_get_delegate(orientation_get);
 639             }
 640
 641             if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
 642             {
 643                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_get_static_delegate) });
 644             }
 645
 646             if (efl_ui_layout_orientation_set_static_delegate == null)
 647             {
 648                 efl_ui_layout_orientation_set_static_delegate = new efl_ui_layout_orientation_set_delegate(orientation_set);
 649             }
 650
 651             if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
 652             {
 653                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_set_static_delegate) });
 654             }
 655
 656             if (efl_ui_range_value_get_static_delegate == null)
 657             {
 658                 efl_ui_range_value_get_static_delegate = new efl_ui_range_value_get_delegate(range_value_get);
 659             }
 660
 661             if (methods.FirstOrDefault(m => m.Name == "GetRangeValue") != null)
 662             {
 663                 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) });
 664             }
 665
 666             if (efl_ui_range_value_set_static_delegate == null)
 667             {
 668                 efl_ui_range_value_set_static_delegate = new efl_ui_range_value_set_delegate(range_value_set);
 669             }
 670
 671             if (methods.FirstOrDefault(m => m.Name == "SetRangeValue") != null)
 672             {
 673                 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) });
 674             }
 675
 676             if (efl_ui_range_limits_get_static_delegate == null)
 677             {
 678                 efl_ui_range_limits_get_static_delegate = new efl_ui_range_limits_get_delegate(range_limits_get);
 679             }
 680
 681             if (methods.FirstOrDefault(m => m.Name == "GetRangeLimits") != null)
 682             {
 683                 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) });
 684             }
 685
 686             if (efl_ui_range_limits_set_static_delegate == null)
 687             {
 688                 efl_ui_range_limits_set_static_delegate = new efl_ui_range_limits_set_delegate(range_limits_set);
 689             }
 690
 691             if (methods.FirstOrDefault(m => m.Name == "SetRangeLimits") != null)
 692             {
 693                 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) });
 694             }
 695
 696             descs.AddRange(base.GetEoOps(type));
 697             return descs;
 698         }
 699         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 700         /// <returns>The native class pointer.</returns>
 701         public override IntPtr GetEflClass()
 702         {
 703             return Efl.Ui.Progressbar.efl_ui_progressbar_class_get();
 704         }
 705
 706         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 707
 708         [return: MarshalAs(UnmanagedType.U1)]
 709         private delegate bool efl_ui_progressbar_pulse_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 710
 711         [return: MarshalAs(UnmanagedType.U1)]
 712         public delegate bool efl_ui_progressbar_pulse_mode_get_api_delegate(System.IntPtr obj);
 713
 714         public static Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_mode_get_api_delegate> efl_ui_progressbar_pulse_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_mode_get_api_delegate>(Module, "efl_ui_progressbar_pulse_mode_get");
 715
 716         private static bool pulse_mode_get(System.IntPtr obj, System.IntPtr pd)
 717         {
 718             Eina.Log.Debug("function efl_ui_progressbar_pulse_mode_get was called");
 719             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 720             if (ws != null)
 721             {
 722             bool _ret_var = default(bool);
 723                 try
 724                 {
 725                     _ret_var = ((Progressbar)ws.Target).GetPulseMode();
 726                 }
 727                 catch (Exception e)
 728                 {
 729                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 730                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 731                 }
 732
 733         return _ret_var;
 734
 735             }
 736             else
 737             {
 738                 return efl_ui_progressbar_pulse_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 739             }
 740         }
 741
 742         private static efl_ui_progressbar_pulse_mode_get_delegate efl_ui_progressbar_pulse_mode_get_static_delegate;
 743
 744
 745         private delegate void efl_ui_progressbar_pulse_mode_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool pulse);
 746
 747
 748         public delegate void efl_ui_progressbar_pulse_mode_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool pulse);
 749
 750         public static Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_mode_set_api_delegate> efl_ui_progressbar_pulse_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_mode_set_api_delegate>(Module, "efl_ui_progressbar_pulse_mode_set");
 751
 752         private static void pulse_mode_set(System.IntPtr obj, System.IntPtr pd, bool pulse)
 753         {
 754             Eina.Log.Debug("function efl_ui_progressbar_pulse_mode_set was called");
 755             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 756             if (ws != null)
 757             {
 758
 759                 try
 760                 {
 761                     ((Progressbar)ws.Target).SetPulseMode(pulse);
 762                 }
 763                 catch (Exception e)
 764                 {
 765                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 766                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 767                 }
 768
 769
 770             }
 771             else
 772             {
 773                 efl_ui_progressbar_pulse_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pulse);
 774             }
 775         }
 776
 777         private static efl_ui_progressbar_pulse_mode_set_delegate efl_ui_progressbar_pulse_mode_set_static_delegate;
 778
 779         [return: MarshalAs(UnmanagedType.U1)]
 780         private delegate bool efl_ui_progressbar_pulse_get_delegate(System.IntPtr obj, System.IntPtr pd);
 781
 782         [return: MarshalAs(UnmanagedType.U1)]
 783         public delegate bool efl_ui_progressbar_pulse_get_api_delegate(System.IntPtr obj);
 784
 785         public static Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_get_api_delegate> efl_ui_progressbar_pulse_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_get_api_delegate>(Module, "efl_ui_progressbar_pulse_get");
 786
 787         private static bool pulse_get(System.IntPtr obj, System.IntPtr pd)
 788         {
 789             Eina.Log.Debug("function efl_ui_progressbar_pulse_get was called");
 790             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 791             if (ws != null)
 792             {
 793             bool _ret_var = default(bool);
 794                 try
 795                 {
 796                     _ret_var = ((Progressbar)ws.Target).GetPulse();
 797                 }
 798                 catch (Exception e)
 799                 {
 800                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 801                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 802                 }
 803
 804         return _ret_var;
 805
 806             }
 807             else
 808             {
 809                 return efl_ui_progressbar_pulse_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 810             }
 811         }
 812
 813         private static efl_ui_progressbar_pulse_get_delegate efl_ui_progressbar_pulse_get_static_delegate;
 814
 815
 816         private delegate void efl_ui_progressbar_pulse_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool state);
 817
 818
 819         public delegate void efl_ui_progressbar_pulse_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool state);
 820
 821         public static Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_set_api_delegate> efl_ui_progressbar_pulse_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_progressbar_pulse_set_api_delegate>(Module, "efl_ui_progressbar_pulse_set");
 822
 823         private static void pulse_set(System.IntPtr obj, System.IntPtr pd, bool state)
 824         {
 825             Eina.Log.Debug("function efl_ui_progressbar_pulse_set was called");
 826             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 827             if (ws != null)
 828             {
 829
 830                 try
 831                 {
 832                     ((Progressbar)ws.Target).SetPulse(state);
 833                 }
 834                 catch (Exception e)
 835                 {
 836                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 837                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 838                 }
 839
 840
 841             }
 842             else
 843             {
 844                 efl_ui_progressbar_pulse_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), state);
 845             }
 846         }
 847
 848         private static efl_ui_progressbar_pulse_set_delegate efl_ui_progressbar_pulse_set_static_delegate;
 849
 850         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 851         private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
 852
 853         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 854         public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
 855
 856         public static Efl.Eo.FunctionWrapper<efl_content_get_api_delegate> efl_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_content_get_api_delegate>(Module, "efl_content_get");
 857
 858         private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
 859         {
 860             Eina.Log.Debug("function efl_content_get was called");
 861             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 862             if (ws != null)
 863             {
 864             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 865                 try
 866                 {
 867                     _ret_var = ((Progressbar)ws.Target).GetContent();
 868                 }
 869                 catch (Exception e)
 870                 {
 871                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 872                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 873                 }
 874
 875         return _ret_var;
 876
 877             }
 878             else
 879             {
 880                 return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 881             }
 882         }
 883
 884         private static efl_content_get_delegate efl_content_get_static_delegate;
 885
 886         [return: MarshalAs(UnmanagedType.U1)]
 887         private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
 888
 889         [return: MarshalAs(UnmanagedType.U1)]
 890         public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
 891
 892         public static Efl.Eo.FunctionWrapper<efl_content_set_api_delegate> efl_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_content_set_api_delegate>(Module, "efl_content_set");
 893
 894         private static bool content_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity content)
 895         {
 896             Eina.Log.Debug("function efl_content_set was called");
 897             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 898             if (ws != null)
 899             {
 900                                     bool _ret_var = default(bool);
 901                 try
 902                 {
 903                     _ret_var = ((Progressbar)ws.Target).SetContent(content);
 904                 }
 905                 catch (Exception e)
 906                 {
 907                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 908                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 909                 }
 910
 911                         return _ret_var;
 912
 913             }
 914             else
 915             {
 916                 return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
 917             }
 918         }
 919
 920         private static efl_content_set_delegate efl_content_set_static_delegate;
 921
 922         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 923         private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
 924
 925         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 926         public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
 927
 928         public static Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate> efl_content_unset_ptr = new Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate>(Module, "efl_content_unset");
 929
 930         private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
 931         {
 932             Eina.Log.Debug("function efl_content_unset was called");
 933             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 934             if (ws != null)
 935             {
 936             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 937                 try
 938                 {
 939                     _ret_var = ((Progressbar)ws.Target).UnsetContent();
 940                 }
 941                 catch (Exception e)
 942                 {
 943                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 944                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 945                 }
 946
 947         return _ret_var;
 948
 949             }
 950             else
 951             {
 952                 return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 953             }
 954         }
 955
 956         private static efl_content_unset_delegate efl_content_unset_static_delegate;
 957
 958         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 959         private delegate System.String efl_text_get_delegate(System.IntPtr obj, System.IntPtr pd);
 960
 961         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 962         public delegate System.String efl_text_get_api_delegate(System.IntPtr obj);
 963
 964         public static Efl.Eo.FunctionWrapper<efl_text_get_api_delegate> efl_text_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_get_api_delegate>(Module, "efl_text_get");
 965
 966         private static System.String text_get(System.IntPtr obj, System.IntPtr pd)
 967         {
 968             Eina.Log.Debug("function efl_text_get was called");
 969             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 970             if (ws != null)
 971             {
 972             System.String _ret_var = default(System.String);
 973                 try
 974                 {
 975                     _ret_var = ((Progressbar)ws.Target).GetText();
 976                 }
 977                 catch (Exception e)
 978                 {
 979                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 980                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 981                 }
 982
 983         return _ret_var;
 984
 985             }
 986             else
 987             {
 988                 return efl_text_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 989             }
 990         }
 991
 992         private static efl_text_get_delegate efl_text_get_static_delegate;
 993
 994
 995         private delegate void efl_text_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
 996
 997
 998         public delegate void efl_text_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String text);
 999
1000         public static Efl.Eo.FunctionWrapper<efl_text_set_api_delegate> efl_text_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_set_api_delegate>(Module, "efl_text_set");
1001
1002         private static void text_set(System.IntPtr obj, System.IntPtr pd, System.String text)
1003         {
1004             Eina.Log.Debug("function efl_text_set was called");
1005             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1006             if (ws != null)
1007             {
1008
1009                 try
1010                 {
1011                     ((Progressbar)ws.Target).SetText(text);
1012                 }
1013                 catch (Exception e)
1014                 {
1015                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1016                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1017                 }
1018
1019
1020             }
1021             else
1022             {
1023                 efl_text_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), text);
1024             }
1025         }
1026
1027         private static efl_text_set_delegate efl_text_set_static_delegate;
1028
1029         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1030         private delegate System.String efl_text_markup_get_delegate(System.IntPtr obj, System.IntPtr pd);
1031
1032         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1033         public delegate System.String efl_text_markup_get_api_delegate(System.IntPtr obj);
1034
1035         public static Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate> efl_text_markup_get_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_get_api_delegate>(Module, "efl_text_markup_get");
1036
1037         private static System.String markup_get(System.IntPtr obj, System.IntPtr pd)
1038         {
1039             Eina.Log.Debug("function efl_text_markup_get was called");
1040             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1041             if (ws != null)
1042             {
1043             System.String _ret_var = default(System.String);
1044                 try
1045                 {
1046                     _ret_var = ((Progressbar)ws.Target).GetMarkup();
1047                 }
1048                 catch (Exception e)
1049                 {
1050                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1051                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1052                 }
1053
1054         return _ret_var;
1055
1056             }
1057             else
1058             {
1059                 return efl_text_markup_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1060             }
1061         }
1062
1063         private static efl_text_markup_get_delegate efl_text_markup_get_static_delegate;
1064
1065
1066         private delegate void efl_text_markup_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
1067
1068
1069         public delegate void efl_text_markup_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String markup);
1070
1071         public static Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate> efl_text_markup_set_ptr = new Efl.Eo.FunctionWrapper<efl_text_markup_set_api_delegate>(Module, "efl_text_markup_set");
1072
1073         private static void markup_set(System.IntPtr obj, System.IntPtr pd, System.String markup)
1074         {
1075             Eina.Log.Debug("function efl_text_markup_set was called");
1076             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1077             if (ws != null)
1078             {
1079
1080                 try
1081                 {
1082                     ((Progressbar)ws.Target).SetMarkup(markup);
1083                 }
1084                 catch (Exception e)
1085                 {
1086                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1087                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1088                 }
1089
1090
1091             }
1092             else
1093             {
1094                 efl_text_markup_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), markup);
1095             }
1096         }
1097
1098         private static efl_text_markup_set_delegate efl_text_markup_set_static_delegate;
1099
1100
1101         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);
1102
1103
1104         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);
1105
1106         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");
1107
1108         private static void value_and_text_get(System.IntPtr obj, System.IntPtr pd, out double value, out System.String text)
1109         {
1110             Eina.Log.Debug("function efl_access_value_and_text_get was called");
1111             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1112             if (ws != null)
1113             {
1114                         value = default(double);        System.String _out_text = default(System.String);
1115
1116                 try
1117                 {
1118                     ((Progressbar)ws.Target).GetValueAndText(out value, out _out_text);
1119                 }
1120                 catch (Exception e)
1121                 {
1122                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1123                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1124                 }
1125
1126                 text = _out_text;
1127
1128             }
1129             else
1130             {
1131                 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);
1132             }
1133         }
1134
1135         private static efl_access_value_and_text_get_delegate efl_access_value_and_text_get_static_delegate;
1136
1137         [return: MarshalAs(UnmanagedType.U1)]
1138         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);
1139
1140         [return: MarshalAs(UnmanagedType.U1)]
1141         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);
1142
1143         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");
1144
1145         private static bool value_and_text_set(System.IntPtr obj, System.IntPtr pd, double value, System.String text)
1146         {
1147             Eina.Log.Debug("function efl_access_value_and_text_set was called");
1148             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1149             if (ws != null)
1150             {
1151                                                             bool _ret_var = default(bool);
1152                 try
1153                 {
1154                     _ret_var = ((Progressbar)ws.Target).SetValueAndText(value, text);
1155                 }
1156                 catch (Exception e)
1157                 {
1158                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1159                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1160                 }
1161
1162                                         return _ret_var;
1163
1164             }
1165             else
1166             {
1167                 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);
1168             }
1169         }
1170
1171         private static efl_access_value_and_text_set_delegate efl_access_value_and_text_set_static_delegate;
1172
1173
1174         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);
1175
1176
1177         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);
1178
1179         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");
1180
1181         private static void range_get(System.IntPtr obj, System.IntPtr pd, out double lower_limit, out double upper_limit, out System.String description)
1182         {
1183             Eina.Log.Debug("function efl_access_value_range_get was called");
1184             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1185             if (ws != null)
1186             {
1187                                 lower_limit = default(double);        upper_limit = default(double);        System.String _out_description = default(System.String);
1188
1189                 try
1190                 {
1191                     ((Progressbar)ws.Target).GetRange(out lower_limit, out upper_limit, out _out_description);
1192                 }
1193                 catch (Exception e)
1194                 {
1195                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1196                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1197                 }
1198
1199                         description = _out_description;
1200
1201             }
1202             else
1203             {
1204                 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);
1205             }
1206         }
1207
1208         private static efl_access_value_range_get_delegate efl_access_value_range_get_static_delegate;
1209
1210
1211         private delegate double efl_access_value_increment_get_delegate(System.IntPtr obj, System.IntPtr pd);
1212
1213
1214         public delegate double efl_access_value_increment_get_api_delegate(System.IntPtr obj);
1215
1216         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");
1217
1218         private static double increment_get(System.IntPtr obj, System.IntPtr pd)
1219         {
1220             Eina.Log.Debug("function efl_access_value_increment_get was called");
1221             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1222             if (ws != null)
1223             {
1224             double _ret_var = default(double);
1225                 try
1226                 {
1227                     _ret_var = ((Progressbar)ws.Target).GetIncrement();
1228                 }
1229                 catch (Exception e)
1230                 {
1231                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1232                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1233                 }
1234
1235         return _ret_var;
1236
1237             }
1238             else
1239             {
1240                 return efl_access_value_increment_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1241             }
1242         }
1243
1244         private static efl_access_value_increment_get_delegate efl_access_value_increment_get_static_delegate;
1245
1246
1247         private delegate void efl_ui_format_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb);
1248
1249
1250         public delegate void efl_ui_format_cb_set_api_delegate(System.IntPtr obj,  IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb);
1251
1252         public static Efl.Eo.FunctionWrapper<efl_ui_format_cb_set_api_delegate> efl_ui_format_cb_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_cb_set_api_delegate>(Module, "efl_ui_format_cb_set");
1253
1254         private static void format_cb_set(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb)
1255         {
1256             Eina.Log.Debug("function efl_ui_format_cb_set was called");
1257             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1258             if (ws != null)
1259             {
1260                             Efl.Ui.FormatFuncCbWrapper func_wrapper = new Efl.Ui.FormatFuncCbWrapper(func, func_data, func_free_cb);
1261
1262                 try
1263                 {
1264                     ((Progressbar)ws.Target).SetFormatCb(func_wrapper.ManagedCb);
1265                 }
1266                 catch (Exception e)
1267                 {
1268                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1269                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1270                 }
1271
1272
1273             }
1274             else
1275             {
1276                 efl_ui_format_cb_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
1277             }
1278         }
1279
1280         private static efl_ui_format_cb_set_delegate efl_ui_format_cb_set_static_delegate;
1281
1282         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1283         private delegate System.String efl_ui_format_string_get_delegate(System.IntPtr obj, System.IntPtr pd);
1284
1285         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1286         public delegate System.String efl_ui_format_string_get_api_delegate(System.IntPtr obj);
1287
1288         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");
1289
1290         private static System.String format_string_get(System.IntPtr obj, System.IntPtr pd)
1291         {
1292             Eina.Log.Debug("function efl_ui_format_string_get was called");
1293             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1294             if (ws != null)
1295             {
1296             System.String _ret_var = default(System.String);
1297                 try
1298                 {
1299                     _ret_var = ((Progressbar)ws.Target).GetFormatString();
1300                 }
1301                 catch (Exception e)
1302                 {
1303                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1304                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1305                 }
1306
1307         return _ret_var;
1308
1309             }
1310             else
1311             {
1312                 return efl_ui_format_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1313             }
1314         }
1315
1316         private static efl_ui_format_string_get_delegate efl_ui_format_string_get_static_delegate;
1317
1318
1319         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 units);
1320
1321
1322         public delegate void efl_ui_format_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String units);
1323
1324         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");
1325
1326         private static void format_string_set(System.IntPtr obj, System.IntPtr pd, System.String units)
1327         {
1328             Eina.Log.Debug("function efl_ui_format_string_set was called");
1329             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1330             if (ws != null)
1331             {
1332
1333                 try
1334                 {
1335                     ((Progressbar)ws.Target).SetFormatString(units);
1336                 }
1337                 catch (Exception e)
1338                 {
1339                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1340                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1341                 }
1342
1343
1344             }
1345             else
1346             {
1347                 efl_ui_format_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), units);
1348             }
1349         }
1350
1351         private static efl_ui_format_string_set_delegate efl_ui_format_string_set_static_delegate;
1352
1353
1354         private delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1355
1356
1357         public delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_api_delegate(System.IntPtr obj);
1358
1359         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate> efl_ui_layout_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate>(Module, "efl_ui_layout_orientation_get");
1360
1361         private static Efl.Ui.LayoutOrientation orientation_get(System.IntPtr obj, System.IntPtr pd)
1362         {
1363             Eina.Log.Debug("function efl_ui_layout_orientation_get was called");
1364             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1365             if (ws != null)
1366             {
1367             Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
1368                 try
1369                 {
1370                     _ret_var = ((Progressbar)ws.Target).GetOrientation();
1371                 }
1372                 catch (Exception e)
1373                 {
1374                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1375                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1376                 }
1377
1378         return _ret_var;
1379
1380             }
1381             else
1382             {
1383                 return efl_ui_layout_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1384             }
1385         }
1386
1387         private static efl_ui_layout_orientation_get_delegate efl_ui_layout_orientation_get_static_delegate;
1388
1389
1390         private delegate void efl_ui_layout_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
1391
1392
1393         public delegate void efl_ui_layout_orientation_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
1394
1395         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate> efl_ui_layout_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate>(Module, "efl_ui_layout_orientation_set");
1396
1397         private static void orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
1398         {
1399             Eina.Log.Debug("function efl_ui_layout_orientation_set was called");
1400             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1401             if (ws != null)
1402             {
1403
1404                 try
1405                 {
1406                     ((Progressbar)ws.Target).SetOrientation(dir);
1407                 }
1408                 catch (Exception e)
1409                 {
1410                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1411                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1412                 }
1413
1414
1415             }
1416             else
1417             {
1418                 efl_ui_layout_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
1419             }
1420         }
1421
1422         private static efl_ui_layout_orientation_set_delegate efl_ui_layout_orientation_set_static_delegate;
1423
1424
1425         private delegate double efl_ui_range_value_get_delegate(System.IntPtr obj, System.IntPtr pd);
1426
1427
1428         public delegate double efl_ui_range_value_get_api_delegate(System.IntPtr obj);
1429
1430         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");
1431
1432         private static double range_value_get(System.IntPtr obj, System.IntPtr pd)
1433         {
1434             Eina.Log.Debug("function efl_ui_range_value_get was called");
1435             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1436             if (ws != null)
1437             {
1438             double _ret_var = default(double);
1439                 try
1440                 {
1441                     _ret_var = ((Progressbar)ws.Target).GetRangeValue();
1442                 }
1443                 catch (Exception e)
1444                 {
1445                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1446                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1447                 }
1448
1449         return _ret_var;
1450
1451             }
1452             else
1453             {
1454                 return efl_ui_range_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1455             }
1456         }
1457
1458         private static efl_ui_range_value_get_delegate efl_ui_range_value_get_static_delegate;
1459
1460
1461         private delegate void efl_ui_range_value_set_delegate(System.IntPtr obj, System.IntPtr pd,  double val);
1462
1463
1464         public delegate void efl_ui_range_value_set_api_delegate(System.IntPtr obj,  double val);
1465
1466         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");
1467
1468         private static void range_value_set(System.IntPtr obj, System.IntPtr pd, double val)
1469         {
1470             Eina.Log.Debug("function efl_ui_range_value_set was called");
1471             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1472             if (ws != null)
1473             {
1474
1475                 try
1476                 {
1477                     ((Progressbar)ws.Target).SetRangeValue(val);
1478                 }
1479                 catch (Exception e)
1480                 {
1481                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1482                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1483                 }
1484
1485
1486             }
1487             else
1488             {
1489                 efl_ui_range_value_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1490             }
1491         }
1492
1493         private static efl_ui_range_value_set_delegate efl_ui_range_value_set_static_delegate;
1494
1495
1496         private delegate void efl_ui_range_limits_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double min,  out double max);
1497
1498
1499         public delegate void efl_ui_range_limits_get_api_delegate(System.IntPtr obj,  out double min,  out double max);
1500
1501         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");
1502
1503         private static void range_limits_get(System.IntPtr obj, System.IntPtr pd, out double min, out double max)
1504         {
1505             Eina.Log.Debug("function efl_ui_range_limits_get was called");
1506             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1507             if (ws != null)
1508             {
1509                         min = default(double);        max = default(double);
1510                 try
1511                 {
1512                     ((Progressbar)ws.Target).GetRangeLimits(out min, out max);
1513                 }
1514                 catch (Exception e)
1515                 {
1516                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1517                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1518                 }
1519
1520
1521             }
1522             else
1523             {
1524                 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);
1525             }
1526         }
1527
1528         private static efl_ui_range_limits_get_delegate efl_ui_range_limits_get_static_delegate;
1529
1530
1531         private delegate void efl_ui_range_limits_set_delegate(System.IntPtr obj, System.IntPtr pd,  double min,  double max);
1532
1533
1534         public delegate void efl_ui_range_limits_set_api_delegate(System.IntPtr obj,  double min,  double max);
1535
1536         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");
1537
1538         private static void range_limits_set(System.IntPtr obj, System.IntPtr pd, double min, double max)
1539         {
1540             Eina.Log.Debug("function efl_ui_range_limits_set was called");
1541             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1542             if (ws != null)
1543             {
1544
1545                 try
1546                 {
1547                     ((Progressbar)ws.Target).SetRangeLimits(min, max);
1548                 }
1549                 catch (Exception e)
1550                 {
1551                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1552                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1553                 }
1554
1555
1556             }
1557             else
1558             {
1559                 efl_ui_range_limits_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min, max);
1560             }
1561         }
1562
1563         private static efl_ui_range_limits_set_delegate efl_ui_range_limits_set_static_delegate;
1564
1565         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1566
1567 }
1568 }
1569 }
1570
1571 }
1572