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