internals/src/EflSharp/EflSharp/efl/efl_ui_clock.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Efl UI clock class</summary>
  13 [Efl.Ui.Clock.NativeMethods]
  14 public class Clock : Efl.Ui.LayoutBase, Efl.Eo.IWrapper
  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(Clock))
  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_clock_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Clock"/> 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 Clock(Efl.Object parent
  38             , System.String style = null) : base(efl_ui_clock_class_get(), typeof(Clock), 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="Clock"/> 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 Clock(System.IntPtr raw) : base(raw)
  52     {
  53             }
  54
  55     /// <summary>Initializes a new instance of the <see cref="Clock"/> 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 Clock(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 clock 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_CLOCK_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_CLOCK_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_CLOCK_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>The current clock format. Format is a combination of allowed Libc date format specifiers like: &quot;%b %d, %Y %I : %M %p&quot;.
 145     /// Maximum allowed format length is 64 chars.
 146     ///
 147     /// Format can include separators for each individual clock field except for AM/PM field.
 148     ///
 149     /// Each separator can be a maximum of 6 UTF-8 bytes. Space is also taken as a separator.
 150     ///
 151     /// These specifiers can be arranged in any order and the widget will display the fields accordingly.
 152     ///
 153     /// Default format is taken as per the system locale settings.</summary>
 154     /// <returns>The clock format.</returns>
 155     virtual public System.String GetFormat() {
 156          var _ret_var = Efl.Ui.Clock.NativeMethods.efl_ui_clock_format_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 157         Eina.Error.RaiseIfUnhandledException();
 158         return _ret_var;
 159  }
 160     /// <summary>The current clock format. Format is a combination of allowed Libc date format specifiers like: &quot;%b %d, %Y %I : %M %p&quot;.
 161     /// Maximum allowed format length is 64 chars.
 162     ///
 163     /// Format can include separators for each individual clock field except for AM/PM field.
 164     ///
 165     /// Each separator can be a maximum of 6 UTF-8 bytes. Space is also taken as a separator.
 166     ///
 167     /// These specifiers can be arranged in any order and the widget will display the fields accordingly.
 168     ///
 169     /// Default format is taken as per the system locale settings.</summary>
 170     /// <param name="fmt">The clock format.</param>
 171     virtual public void SetFormat(System.String fmt) {
 172                                  Efl.Ui.Clock.NativeMethods.efl_ui_clock_format_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),fmt);
 173         Eina.Error.RaiseIfUnhandledException();
 174                          }
 175     /// <summary>Whether the given clock widget should be paused or not.
 176     /// This function pauses or starts the clock widget.</summary>
 177     /// <returns><c>true</c> to pause clock, <c>false</c> otherwise</returns>
 178     virtual public bool GetPause() {
 179          var _ret_var = Efl.Ui.Clock.NativeMethods.efl_ui_clock_pause_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 180         Eina.Error.RaiseIfUnhandledException();
 181         return _ret_var;
 182  }
 183     /// <summary>Whether the given clock widget should be paused or not.
 184     /// This function pauses or starts the clock widget.</summary>
 185     /// <param name="paused"><c>true</c> to pause clock, <c>false</c> otherwise</param>
 186     virtual public void SetPause(bool paused) {
 187                                  Efl.Ui.Clock.NativeMethods.efl_ui_clock_pause_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),paused);
 188         Eina.Error.RaiseIfUnhandledException();
 189                          }
 190     /// <summary>Digits of the given clock widget should be editable when in editing mode.</summary>
 191     /// <returns><c>true</c> to set edit mode, <c>false</c> otherwise</returns>
 192     virtual public bool GetEditMode() {
 193          var _ret_var = Efl.Ui.Clock.NativeMethods.efl_ui_clock_edit_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 194         Eina.Error.RaiseIfUnhandledException();
 195         return _ret_var;
 196  }
 197     /// <summary>Digits of the given clock widget should be editable when in editing mode.</summary>
 198     /// <param name="value"><c>true</c> to set edit mode, <c>false</c> otherwise</param>
 199     virtual public void SetEditMode(bool value) {
 200                                  Efl.Ui.Clock.NativeMethods.efl_ui_clock_edit_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),value);
 201         Eina.Error.RaiseIfUnhandledException();
 202                          }
 203     /// <summary>The lower boundary of a field.
 204     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 205     ///
 206     /// Month: default value range is from 0 to 11.
 207     ///
 208     /// Date: default value range is from 1 to 31 according to the month value.
 209     ///
 210     /// Hour: default value will be in terms of 24 hr format (0~23)
 211     ///
 212     /// Minute: default value range is from 0 to 59.</summary>
 213     /// <returns>Time structure containing the minimum time value.</returns>
 214     virtual public Efl.Time GetTimeMin() {
 215          var _ret_var = Efl.Ui.Clock.NativeMethods.efl_ui_clock_time_min_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 216         Eina.Error.RaiseIfUnhandledException();
 217         return _ret_var;
 218  }
 219     /// <summary>The lower boundary of a field.
 220     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 221     ///
 222     /// Month: default value range is from 0 to 11.
 223     ///
 224     /// Date: default value range is from 1 to 31 according to the month value.
 225     ///
 226     /// Hour: default value will be in terms of 24 hr format (0~23)
 227     ///
 228     /// Minute: default value range is from 0 to 59.</summary>
 229     /// <param name="mintime">Time structure containing the minimum time value.</param>
 230     virtual public void SetTimeMin(Efl.Time mintime) {
 231          Efl.Time.NativeStruct _in_mintime = mintime;
 232                         Efl.Ui.Clock.NativeMethods.efl_ui_clock_time_min_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_mintime);
 233         Eina.Error.RaiseIfUnhandledException();
 234                          }
 235     /// <summary>The upper boundary of a field.
 236     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 237     ///
 238     /// Month: default value range is from 0 to 11.
 239     ///
 240     /// Date: default value range is from 1 to 31 according to the month value.
 241     ///
 242     /// Hour: default value will be in terms of 24 hr format (0~23)
 243     ///
 244     /// Minute: default value range is from 0 to 59.</summary>
 245     /// <returns>Time structure containing the maximum time value.</returns>
 246     virtual public Efl.Time GetTimeMax() {
 247          var _ret_var = Efl.Ui.Clock.NativeMethods.efl_ui_clock_time_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 248         Eina.Error.RaiseIfUnhandledException();
 249         return _ret_var;
 250  }
 251     /// <summary>The upper boundary of a field.
 252     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 253     ///
 254     /// Month: default value range is from 0 to 11.
 255     ///
 256     /// Date: default value range is from 1 to 31 according to the month value.
 257     ///
 258     /// Hour: default value will be in terms of 24 hr format (0~23)
 259     ///
 260     /// Minute: default value range is from 0 to 59.</summary>
 261     /// <param name="maxtime">Time structure containing the maximum time value.</param>
 262     virtual public void SetTimeMax(Efl.Time maxtime) {
 263          Efl.Time.NativeStruct _in_maxtime = maxtime;
 264                         Efl.Ui.Clock.NativeMethods.efl_ui_clock_time_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_maxtime);
 265         Eina.Error.RaiseIfUnhandledException();
 266                          }
 267     /// <summary>The current value of a clock object.
 268     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 269     ///
 270     /// Month: default value range is from 0 to 11.
 271     ///
 272     /// Date: default value range is from 1 to 31 according to the month value.
 273     ///
 274     /// Hour: default value will be in terms of 24 hr format (0~23)
 275     ///
 276     /// Minute: default value range is from 0 to 59.</summary>
 277     /// <returns>Time structure containing the time value.</returns>
 278     virtual public Efl.Time GetTime() {
 279          var _ret_var = Efl.Ui.Clock.NativeMethods.efl_ui_clock_time_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 280         Eina.Error.RaiseIfUnhandledException();
 281         return _ret_var;
 282  }
 283     /// <summary>The current value of a clock object.
 284     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 285     ///
 286     /// Month: default value range is from 0 to 11.
 287     ///
 288     /// Date: default value range is from 1 to 31 according to the month value.
 289     ///
 290     /// Hour: default value will be in terms of 24 hr format (0~23)
 291     ///
 292     /// Minute: default value range is from 0 to 59.</summary>
 293     /// <param name="curtime">Time structure containing the time value.</param>
 294     virtual public void SetTime(Efl.Time curtime) {
 295          Efl.Time.NativeStruct _in_curtime = curtime;
 296                         Efl.Ui.Clock.NativeMethods.efl_ui_clock_time_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_curtime);
 297         Eina.Error.RaiseIfUnhandledException();
 298                          }
 299     /// <summary>The field to be visible/not.</summary>
 300     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 301     /// <returns><c>true</c> field can be visible, <c>false</c> otherwise.</returns>
 302     virtual public bool GetFieldVisible(Efl.Ui.ClockType fieldtype) {
 303                                  var _ret_var = Efl.Ui.Clock.NativeMethods.efl_ui_clock_field_visible_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),fieldtype);
 304         Eina.Error.RaiseIfUnhandledException();
 305                         return _ret_var;
 306  }
 307     /// <summary>The field to be visible/not.</summary>
 308     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 309     /// <param name="visible"><c>true</c> field can be visible, <c>false</c> otherwise.</param>
 310     virtual public void SetFieldVisible(Efl.Ui.ClockType fieldtype, bool visible) {
 311                                                          Efl.Ui.Clock.NativeMethods.efl_ui_clock_field_visible_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),fieldtype, visible);
 312         Eina.Error.RaiseIfUnhandledException();
 313                                          }
 314     /// <summary>Get the field limits of a field.
 315     /// Limits can be set to individual fields, independently, except for the AM/PM field. Any field can display the values only in between these minimum and maximum limits unless the corresponding time value is restricted from MinTime to MaxTime. That is, min/max field limits always work under the limitations of mintime/maxtime.
 316     ///
 317     /// There is no provision to set the limits of AM/PM field.</summary>
 318     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 319     /// <param name="min">Reference to field&apos;s minimum value.</param>
 320     /// <param name="max">Reference to field&apos;s maximum value.</param>
 321     virtual public void GetFieldLimit(Efl.Ui.ClockType fieldtype, out int min, out int max) {
 322                                                                                  Efl.Ui.Clock.NativeMethods.efl_ui_clock_field_limit_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),fieldtype, out min, out max);
 323         Eina.Error.RaiseIfUnhandledException();
 324                                                          }
 325     /// <summary>Set a field to be visible or not.
 326     /// Setting this API to <c>true</c> in itself doen&apos;t ensure that the field is visible. The field&apos;s format also must be present in the overall clock format.  If a field&apos;s visibility is set to <c>false</c> then it won&apos;t appear even though its format is present. In summary, if this API is set to true and the corresponding field&apos;s format is present in clock format, the field is visible.
 327     ///
 328     /// By default the field visibility is set to <c>true</c>.</summary>
 329     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 330     /// <param name="min">Reference to field&apos;s minimum value.</param>
 331     /// <param name="max">Reference to field&apos;s maximum value.</param>
 332     virtual public void SetFieldLimit(Efl.Ui.ClockType fieldtype, int min, int max) {
 333                                                                                  Efl.Ui.Clock.NativeMethods.efl_ui_clock_field_limit_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),fieldtype, min, max);
 334         Eina.Error.RaiseIfUnhandledException();
 335                                                          }
 336     /// <summary>The current clock format. Format is a combination of allowed Libc date format specifiers like: &quot;%b %d, %Y %I : %M %p&quot;.
 337 /// Maximum allowed format length is 64 chars.
 338 ///
 339 /// Format can include separators for each individual clock field except for AM/PM field.
 340 ///
 341 /// Each separator can be a maximum of 6 UTF-8 bytes. Space is also taken as a separator.
 342 ///
 343 /// These specifiers can be arranged in any order and the widget will display the fields accordingly.
 344 ///
 345 /// Default format is taken as per the system locale settings.</summary>
 346 /// <value>The clock format.</value>
 347     public System.String Format {
 348         get { return GetFormat(); }
 349         set { SetFormat(value); }
 350     }
 351     /// <summary>Whether the given clock widget should be paused or not.
 352 /// This function pauses or starts the clock widget.</summary>
 353 /// <value><c>true</c> to pause clock, <c>false</c> otherwise</value>
 354     public bool Pause {
 355         get { return GetPause(); }
 356         set { SetPause(value); }
 357     }
 358     /// <summary>Digits of the given clock widget should be editable when in editing mode.</summary>
 359 /// <value><c>true</c> to set edit mode, <c>false</c> otherwise</value>
 360     public bool EditMode {
 361         get { return GetEditMode(); }
 362         set { SetEditMode(value); }
 363     }
 364     /// <summary>The lower boundary of a field.
 365 /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 366 ///
 367 /// Month: default value range is from 0 to 11.
 368 ///
 369 /// Date: default value range is from 1 to 31 according to the month value.
 370 ///
 371 /// Hour: default value will be in terms of 24 hr format (0~23)
 372 ///
 373 /// Minute: default value range is from 0 to 59.</summary>
 374 /// <value>Time structure containing the minimum time value.</value>
 375     public Efl.Time TimeMin {
 376         get { return GetTimeMin(); }
 377         set { SetTimeMin(value); }
 378     }
 379     /// <summary>The upper boundary of a field.
 380 /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 381 ///
 382 /// Month: default value range is from 0 to 11.
 383 ///
 384 /// Date: default value range is from 1 to 31 according to the month value.
 385 ///
 386 /// Hour: default value will be in terms of 24 hr format (0~23)
 387 ///
 388 /// Minute: default value range is from 0 to 59.</summary>
 389 /// <value>Time structure containing the maximum time value.</value>
 390     public Efl.Time TimeMax {
 391         get { return GetTimeMax(); }
 392         set { SetTimeMax(value); }
 393     }
 394     /// <summary>The current value of a clock object.
 395 /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 396 ///
 397 /// Month: default value range is from 0 to 11.
 398 ///
 399 /// Date: default value range is from 1 to 31 according to the month value.
 400 ///
 401 /// Hour: default value will be in terms of 24 hr format (0~23)
 402 ///
 403 /// Minute: default value range is from 0 to 59.</summary>
 404 /// <value>Time structure containing the time value.</value>
 405     public Efl.Time Time {
 406         get { return GetTime(); }
 407         set { SetTime(value); }
 408     }
 409     private static IntPtr GetEflClassStatic()
 410     {
 411         return Efl.Ui.Clock.efl_ui_clock_class_get();
 412     }
 413     /// <summary>Wrapper for native methods and virtual method delegates.
 414     /// For internal use by generated code only.</summary>
 415     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 416     {
 417         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 418         /// <summary>Gets the list of Eo operations to override.</summary>
 419         /// <returns>The list of Eo operations to be overload.</returns>
 420         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 421         {
 422             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 423             var methods = Efl.Eo.Globals.GetUserMethods(type);
 424
 425             if (efl_ui_clock_format_get_static_delegate == null)
 426             {
 427                 efl_ui_clock_format_get_static_delegate = new efl_ui_clock_format_get_delegate(format_get);
 428             }
 429
 430             if (methods.FirstOrDefault(m => m.Name == "GetFormat") != null)
 431             {
 432                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_format_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_format_get_static_delegate) });
 433             }
 434
 435             if (efl_ui_clock_format_set_static_delegate == null)
 436             {
 437                 efl_ui_clock_format_set_static_delegate = new efl_ui_clock_format_set_delegate(format_set);
 438             }
 439
 440             if (methods.FirstOrDefault(m => m.Name == "SetFormat") != null)
 441             {
 442                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_format_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_format_set_static_delegate) });
 443             }
 444
 445             if (efl_ui_clock_pause_get_static_delegate == null)
 446             {
 447                 efl_ui_clock_pause_get_static_delegate = new efl_ui_clock_pause_get_delegate(pause_get);
 448             }
 449
 450             if (methods.FirstOrDefault(m => m.Name == "GetPause") != null)
 451             {
 452                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_pause_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_pause_get_static_delegate) });
 453             }
 454
 455             if (efl_ui_clock_pause_set_static_delegate == null)
 456             {
 457                 efl_ui_clock_pause_set_static_delegate = new efl_ui_clock_pause_set_delegate(pause_set);
 458             }
 459
 460             if (methods.FirstOrDefault(m => m.Name == "SetPause") != null)
 461             {
 462                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_pause_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_pause_set_static_delegate) });
 463             }
 464
 465             if (efl_ui_clock_edit_mode_get_static_delegate == null)
 466             {
 467                 efl_ui_clock_edit_mode_get_static_delegate = new efl_ui_clock_edit_mode_get_delegate(edit_mode_get);
 468             }
 469
 470             if (methods.FirstOrDefault(m => m.Name == "GetEditMode") != null)
 471             {
 472                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_edit_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_edit_mode_get_static_delegate) });
 473             }
 474
 475             if (efl_ui_clock_edit_mode_set_static_delegate == null)
 476             {
 477                 efl_ui_clock_edit_mode_set_static_delegate = new efl_ui_clock_edit_mode_set_delegate(edit_mode_set);
 478             }
 479
 480             if (methods.FirstOrDefault(m => m.Name == "SetEditMode") != null)
 481             {
 482                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_edit_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_edit_mode_set_static_delegate) });
 483             }
 484
 485             if (efl_ui_clock_time_min_get_static_delegate == null)
 486             {
 487                 efl_ui_clock_time_min_get_static_delegate = new efl_ui_clock_time_min_get_delegate(time_min_get);
 488             }
 489
 490             if (methods.FirstOrDefault(m => m.Name == "GetTimeMin") != null)
 491             {
 492                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_time_min_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_time_min_get_static_delegate) });
 493             }
 494
 495             if (efl_ui_clock_time_min_set_static_delegate == null)
 496             {
 497                 efl_ui_clock_time_min_set_static_delegate = new efl_ui_clock_time_min_set_delegate(time_min_set);
 498             }
 499
 500             if (methods.FirstOrDefault(m => m.Name == "SetTimeMin") != null)
 501             {
 502                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_time_min_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_time_min_set_static_delegate) });
 503             }
 504
 505             if (efl_ui_clock_time_max_get_static_delegate == null)
 506             {
 507                 efl_ui_clock_time_max_get_static_delegate = new efl_ui_clock_time_max_get_delegate(time_max_get);
 508             }
 509
 510             if (methods.FirstOrDefault(m => m.Name == "GetTimeMax") != null)
 511             {
 512                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_time_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_time_max_get_static_delegate) });
 513             }
 514
 515             if (efl_ui_clock_time_max_set_static_delegate == null)
 516             {
 517                 efl_ui_clock_time_max_set_static_delegate = new efl_ui_clock_time_max_set_delegate(time_max_set);
 518             }
 519
 520             if (methods.FirstOrDefault(m => m.Name == "SetTimeMax") != null)
 521             {
 522                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_time_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_time_max_set_static_delegate) });
 523             }
 524
 525             if (efl_ui_clock_time_get_static_delegate == null)
 526             {
 527                 efl_ui_clock_time_get_static_delegate = new efl_ui_clock_time_get_delegate(time_get);
 528             }
 529
 530             if (methods.FirstOrDefault(m => m.Name == "GetTime") != null)
 531             {
 532                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_time_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_time_get_static_delegate) });
 533             }
 534
 535             if (efl_ui_clock_time_set_static_delegate == null)
 536             {
 537                 efl_ui_clock_time_set_static_delegate = new efl_ui_clock_time_set_delegate(time_set);
 538             }
 539
 540             if (methods.FirstOrDefault(m => m.Name == "SetTime") != null)
 541             {
 542                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_time_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_time_set_static_delegate) });
 543             }
 544
 545             if (efl_ui_clock_field_visible_get_static_delegate == null)
 546             {
 547                 efl_ui_clock_field_visible_get_static_delegate = new efl_ui_clock_field_visible_get_delegate(field_visible_get);
 548             }
 549
 550             if (methods.FirstOrDefault(m => m.Name == "GetFieldVisible") != null)
 551             {
 552                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_field_visible_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_field_visible_get_static_delegate) });
 553             }
 554
 555             if (efl_ui_clock_field_visible_set_static_delegate == null)
 556             {
 557                 efl_ui_clock_field_visible_set_static_delegate = new efl_ui_clock_field_visible_set_delegate(field_visible_set);
 558             }
 559
 560             if (methods.FirstOrDefault(m => m.Name == "SetFieldVisible") != null)
 561             {
 562                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_field_visible_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_field_visible_set_static_delegate) });
 563             }
 564
 565             if (efl_ui_clock_field_limit_get_static_delegate == null)
 566             {
 567                 efl_ui_clock_field_limit_get_static_delegate = new efl_ui_clock_field_limit_get_delegate(field_limit_get);
 568             }
 569
 570             if (methods.FirstOrDefault(m => m.Name == "GetFieldLimit") != null)
 571             {
 572                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_field_limit_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_field_limit_get_static_delegate) });
 573             }
 574
 575             if (efl_ui_clock_field_limit_set_static_delegate == null)
 576             {
 577                 efl_ui_clock_field_limit_set_static_delegate = new efl_ui_clock_field_limit_set_delegate(field_limit_set);
 578             }
 579
 580             if (methods.FirstOrDefault(m => m.Name == "SetFieldLimit") != null)
 581             {
 582                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_clock_field_limit_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_clock_field_limit_set_static_delegate) });
 583             }
 584
 585             descs.AddRange(base.GetEoOps(type));
 586             return descs;
 587         }
 588         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 589         /// <returns>The native class pointer.</returns>
 590         public override IntPtr GetEflClass()
 591         {
 592             return Efl.Ui.Clock.efl_ui_clock_class_get();
 593         }
 594
 595         #pragma warning disable CA1707, SA1300, SA1600
 596
 597         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 598         private delegate System.String efl_ui_clock_format_get_delegate(System.IntPtr obj, System.IntPtr pd);
 599
 600         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 601         public delegate System.String efl_ui_clock_format_get_api_delegate(System.IntPtr obj);
 602
 603         public static Efl.Eo.FunctionWrapper<efl_ui_clock_format_get_api_delegate> efl_ui_clock_format_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_format_get_api_delegate>(Module, "efl_ui_clock_format_get");
 604
 605         private static System.String format_get(System.IntPtr obj, System.IntPtr pd)
 606         {
 607             Eina.Log.Debug("function efl_ui_clock_format_get was called");
 608             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 609             if (wrapper != null)
 610             {
 611             System.String _ret_var = default(System.String);
 612                 try
 613                 {
 614                     _ret_var = ((Clock)wrapper).GetFormat();
 615                 }
 616                 catch (Exception e)
 617                 {
 618                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 619                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 620                 }
 621
 622         return _ret_var;
 623
 624             }
 625             else
 626             {
 627                 return efl_ui_clock_format_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 628             }
 629         }
 630
 631         private static efl_ui_clock_format_get_delegate efl_ui_clock_format_get_static_delegate;
 632
 633
 634         private delegate void efl_ui_clock_format_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String fmt);
 635
 636
 637         public delegate void efl_ui_clock_format_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String fmt);
 638
 639         public static Efl.Eo.FunctionWrapper<efl_ui_clock_format_set_api_delegate> efl_ui_clock_format_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_format_set_api_delegate>(Module, "efl_ui_clock_format_set");
 640
 641         private static void format_set(System.IntPtr obj, System.IntPtr pd, System.String fmt)
 642         {
 643             Eina.Log.Debug("function efl_ui_clock_format_set was called");
 644             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 645             if (wrapper != null)
 646             {
 647
 648                 try
 649                 {
 650                     ((Clock)wrapper).SetFormat(fmt);
 651                 }
 652                 catch (Exception e)
 653                 {
 654                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 655                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 656                 }
 657
 658
 659             }
 660             else
 661             {
 662                 efl_ui_clock_format_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fmt);
 663             }
 664         }
 665
 666         private static efl_ui_clock_format_set_delegate efl_ui_clock_format_set_static_delegate;
 667
 668         [return: MarshalAs(UnmanagedType.U1)]
 669         private delegate bool efl_ui_clock_pause_get_delegate(System.IntPtr obj, System.IntPtr pd);
 670
 671         [return: MarshalAs(UnmanagedType.U1)]
 672         public delegate bool efl_ui_clock_pause_get_api_delegate(System.IntPtr obj);
 673
 674         public static Efl.Eo.FunctionWrapper<efl_ui_clock_pause_get_api_delegate> efl_ui_clock_pause_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_pause_get_api_delegate>(Module, "efl_ui_clock_pause_get");
 675
 676         private static bool pause_get(System.IntPtr obj, System.IntPtr pd)
 677         {
 678             Eina.Log.Debug("function efl_ui_clock_pause_get was called");
 679             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 680             if (wrapper != null)
 681             {
 682             bool _ret_var = default(bool);
 683                 try
 684                 {
 685                     _ret_var = ((Clock)wrapper).GetPause();
 686                 }
 687                 catch (Exception e)
 688                 {
 689                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 690                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 691                 }
 692
 693         return _ret_var;
 694
 695             }
 696             else
 697             {
 698                 return efl_ui_clock_pause_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 699             }
 700         }
 701
 702         private static efl_ui_clock_pause_get_delegate efl_ui_clock_pause_get_static_delegate;
 703
 704
 705         private delegate void efl_ui_clock_pause_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool paused);
 706
 707
 708         public delegate void efl_ui_clock_pause_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool paused);
 709
 710         public static Efl.Eo.FunctionWrapper<efl_ui_clock_pause_set_api_delegate> efl_ui_clock_pause_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_pause_set_api_delegate>(Module, "efl_ui_clock_pause_set");
 711
 712         private static void pause_set(System.IntPtr obj, System.IntPtr pd, bool paused)
 713         {
 714             Eina.Log.Debug("function efl_ui_clock_pause_set was called");
 715             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 716             if (wrapper != null)
 717             {
 718
 719                 try
 720                 {
 721                     ((Clock)wrapper).SetPause(paused);
 722                 }
 723                 catch (Exception e)
 724                 {
 725                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 726                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 727                 }
 728
 729
 730             }
 731             else
 732             {
 733                 efl_ui_clock_pause_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), paused);
 734             }
 735         }
 736
 737         private static efl_ui_clock_pause_set_delegate efl_ui_clock_pause_set_static_delegate;
 738
 739         [return: MarshalAs(UnmanagedType.U1)]
 740         private delegate bool efl_ui_clock_edit_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 741
 742         [return: MarshalAs(UnmanagedType.U1)]
 743         public delegate bool efl_ui_clock_edit_mode_get_api_delegate(System.IntPtr obj);
 744
 745         public static Efl.Eo.FunctionWrapper<efl_ui_clock_edit_mode_get_api_delegate> efl_ui_clock_edit_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_edit_mode_get_api_delegate>(Module, "efl_ui_clock_edit_mode_get");
 746
 747         private static bool edit_mode_get(System.IntPtr obj, System.IntPtr pd)
 748         {
 749             Eina.Log.Debug("function efl_ui_clock_edit_mode_get was called");
 750             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 751             if (wrapper != null)
 752             {
 753             bool _ret_var = default(bool);
 754                 try
 755                 {
 756                     _ret_var = ((Clock)wrapper).GetEditMode();
 757                 }
 758                 catch (Exception e)
 759                 {
 760                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 761                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 762                 }
 763
 764         return _ret_var;
 765
 766             }
 767             else
 768             {
 769                 return efl_ui_clock_edit_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 770             }
 771         }
 772
 773         private static efl_ui_clock_edit_mode_get_delegate efl_ui_clock_edit_mode_get_static_delegate;
 774
 775
 776         private delegate void efl_ui_clock_edit_mode_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool value);
 777
 778
 779         public delegate void efl_ui_clock_edit_mode_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool value);
 780
 781         public static Efl.Eo.FunctionWrapper<efl_ui_clock_edit_mode_set_api_delegate> efl_ui_clock_edit_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_edit_mode_set_api_delegate>(Module, "efl_ui_clock_edit_mode_set");
 782
 783         private static void edit_mode_set(System.IntPtr obj, System.IntPtr pd, bool value)
 784         {
 785             Eina.Log.Debug("function efl_ui_clock_edit_mode_set was called");
 786             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 787             if (wrapper != null)
 788             {
 789
 790                 try
 791                 {
 792                     ((Clock)wrapper).SetEditMode(value);
 793                 }
 794                 catch (Exception e)
 795                 {
 796                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 797                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 798                 }
 799
 800
 801             }
 802             else
 803             {
 804                 efl_ui_clock_edit_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), value);
 805             }
 806         }
 807
 808         private static efl_ui_clock_edit_mode_set_delegate efl_ui_clock_edit_mode_set_static_delegate;
 809
 810
 811         private delegate Efl.Time.NativeStruct efl_ui_clock_time_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 812
 813
 814         public delegate Efl.Time.NativeStruct efl_ui_clock_time_min_get_api_delegate(System.IntPtr obj);
 815
 816         public static Efl.Eo.FunctionWrapper<efl_ui_clock_time_min_get_api_delegate> efl_ui_clock_time_min_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_time_min_get_api_delegate>(Module, "efl_ui_clock_time_min_get");
 817
 818         private static Efl.Time.NativeStruct time_min_get(System.IntPtr obj, System.IntPtr pd)
 819         {
 820             Eina.Log.Debug("function efl_ui_clock_time_min_get was called");
 821             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 822             if (wrapper != null)
 823             {
 824             Efl.Time _ret_var = default(Efl.Time);
 825                 try
 826                 {
 827                     _ret_var = ((Clock)wrapper).GetTimeMin();
 828                 }
 829                 catch (Exception e)
 830                 {
 831                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 832                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 833                 }
 834
 835         return _ret_var;
 836
 837             }
 838             else
 839             {
 840                 return efl_ui_clock_time_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 841             }
 842         }
 843
 844         private static efl_ui_clock_time_min_get_delegate efl_ui_clock_time_min_get_static_delegate;
 845
 846
 847         private delegate void efl_ui_clock_time_min_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct mintime);
 848
 849
 850         public delegate void efl_ui_clock_time_min_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct mintime);
 851
 852         public static Efl.Eo.FunctionWrapper<efl_ui_clock_time_min_set_api_delegate> efl_ui_clock_time_min_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_time_min_set_api_delegate>(Module, "efl_ui_clock_time_min_set");
 853
 854         private static void time_min_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct mintime)
 855         {
 856             Eina.Log.Debug("function efl_ui_clock_time_min_set was called");
 857             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 858             if (wrapper != null)
 859             {
 860         Efl.Time _in_mintime = mintime;
 861
 862                 try
 863                 {
 864                     ((Clock)wrapper).SetTimeMin(_in_mintime);
 865                 }
 866                 catch (Exception e)
 867                 {
 868                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 869                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 870                 }
 871
 872
 873             }
 874             else
 875             {
 876                 efl_ui_clock_time_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mintime);
 877             }
 878         }
 879
 880         private static efl_ui_clock_time_min_set_delegate efl_ui_clock_time_min_set_static_delegate;
 881
 882
 883         private delegate Efl.Time.NativeStruct efl_ui_clock_time_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 884
 885
 886         public delegate Efl.Time.NativeStruct efl_ui_clock_time_max_get_api_delegate(System.IntPtr obj);
 887
 888         public static Efl.Eo.FunctionWrapper<efl_ui_clock_time_max_get_api_delegate> efl_ui_clock_time_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_time_max_get_api_delegate>(Module, "efl_ui_clock_time_max_get");
 889
 890         private static Efl.Time.NativeStruct time_max_get(System.IntPtr obj, System.IntPtr pd)
 891         {
 892             Eina.Log.Debug("function efl_ui_clock_time_max_get was called");
 893             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 894             if (wrapper != null)
 895             {
 896             Efl.Time _ret_var = default(Efl.Time);
 897                 try
 898                 {
 899                     _ret_var = ((Clock)wrapper).GetTimeMax();
 900                 }
 901                 catch (Exception e)
 902                 {
 903                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 904                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 905                 }
 906
 907         return _ret_var;
 908
 909             }
 910             else
 911             {
 912                 return efl_ui_clock_time_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 913             }
 914         }
 915
 916         private static efl_ui_clock_time_max_get_delegate efl_ui_clock_time_max_get_static_delegate;
 917
 918
 919         private delegate void efl_ui_clock_time_max_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct maxtime);
 920
 921
 922         public delegate void efl_ui_clock_time_max_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct maxtime);
 923
 924         public static Efl.Eo.FunctionWrapper<efl_ui_clock_time_max_set_api_delegate> efl_ui_clock_time_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_time_max_set_api_delegate>(Module, "efl_ui_clock_time_max_set");
 925
 926         private static void time_max_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct maxtime)
 927         {
 928             Eina.Log.Debug("function efl_ui_clock_time_max_set was called");
 929             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 930             if (wrapper != null)
 931             {
 932         Efl.Time _in_maxtime = maxtime;
 933
 934                 try
 935                 {
 936                     ((Clock)wrapper).SetTimeMax(_in_maxtime);
 937                 }
 938                 catch (Exception e)
 939                 {
 940                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 941                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 942                 }
 943
 944
 945             }
 946             else
 947             {
 948                 efl_ui_clock_time_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), maxtime);
 949             }
 950         }
 951
 952         private static efl_ui_clock_time_max_set_delegate efl_ui_clock_time_max_set_static_delegate;
 953
 954
 955         private delegate Efl.Time.NativeStruct efl_ui_clock_time_get_delegate(System.IntPtr obj, System.IntPtr pd);
 956
 957
 958         public delegate Efl.Time.NativeStruct efl_ui_clock_time_get_api_delegate(System.IntPtr obj);
 959
 960         public static Efl.Eo.FunctionWrapper<efl_ui_clock_time_get_api_delegate> efl_ui_clock_time_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_time_get_api_delegate>(Module, "efl_ui_clock_time_get");
 961
 962         private static Efl.Time.NativeStruct time_get(System.IntPtr obj, System.IntPtr pd)
 963         {
 964             Eina.Log.Debug("function efl_ui_clock_time_get was called");
 965             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 966             if (wrapper != null)
 967             {
 968             Efl.Time _ret_var = default(Efl.Time);
 969                 try
 970                 {
 971                     _ret_var = ((Clock)wrapper).GetTime();
 972                 }
 973                 catch (Exception e)
 974                 {
 975                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 976                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 977                 }
 978
 979         return _ret_var;
 980
 981             }
 982             else
 983             {
 984                 return efl_ui_clock_time_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 985             }
 986         }
 987
 988         private static efl_ui_clock_time_get_delegate efl_ui_clock_time_get_static_delegate;
 989
 990
 991         private delegate void efl_ui_clock_time_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct curtime);
 992
 993
 994         public delegate void efl_ui_clock_time_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct curtime);
 995
 996         public static Efl.Eo.FunctionWrapper<efl_ui_clock_time_set_api_delegate> efl_ui_clock_time_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_time_set_api_delegate>(Module, "efl_ui_clock_time_set");
 997
 998         private static void time_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct curtime)
 999         {
1000             Eina.Log.Debug("function efl_ui_clock_time_set was called");
1001             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1002             if (wrapper != null)
1003             {
1004         Efl.Time _in_curtime = curtime;
1005
1006                 try
1007                 {
1008                     ((Clock)wrapper).SetTime(_in_curtime);
1009                 }
1010                 catch (Exception e)
1011                 {
1012                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1013                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1014                 }
1015
1016
1017             }
1018             else
1019             {
1020                 efl_ui_clock_time_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), curtime);
1021             }
1022         }
1023
1024         private static efl_ui_clock_time_set_delegate efl_ui_clock_time_set_static_delegate;
1025
1026         [return: MarshalAs(UnmanagedType.U1)]
1027         private delegate bool efl_ui_clock_field_visible_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype);
1028
1029         [return: MarshalAs(UnmanagedType.U1)]
1030         public delegate bool efl_ui_clock_field_visible_get_api_delegate(System.IntPtr obj,  Efl.Ui.ClockType fieldtype);
1031
1032         public static Efl.Eo.FunctionWrapper<efl_ui_clock_field_visible_get_api_delegate> efl_ui_clock_field_visible_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_field_visible_get_api_delegate>(Module, "efl_ui_clock_field_visible_get");
1033
1034         private static bool field_visible_get(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ClockType fieldtype)
1035         {
1036             Eina.Log.Debug("function efl_ui_clock_field_visible_get was called");
1037             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1038             if (wrapper != null)
1039             {
1040                                     bool _ret_var = default(bool);
1041                 try
1042                 {
1043                     _ret_var = ((Clock)wrapper).GetFieldVisible(fieldtype);
1044                 }
1045                 catch (Exception e)
1046                 {
1047                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1048                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1049                 }
1050
1051                         return _ret_var;
1052
1053             }
1054             else
1055             {
1056                 return efl_ui_clock_field_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fieldtype);
1057             }
1058         }
1059
1060         private static efl_ui_clock_field_visible_get_delegate efl_ui_clock_field_visible_get_static_delegate;
1061
1062
1063         private delegate void efl_ui_clock_field_visible_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype, [MarshalAs(UnmanagedType.U1)] bool visible);
1064
1065
1066         public delegate void efl_ui_clock_field_visible_set_api_delegate(System.IntPtr obj,  Efl.Ui.ClockType fieldtype, [MarshalAs(UnmanagedType.U1)] bool visible);
1067
1068         public static Efl.Eo.FunctionWrapper<efl_ui_clock_field_visible_set_api_delegate> efl_ui_clock_field_visible_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_field_visible_set_api_delegate>(Module, "efl_ui_clock_field_visible_set");
1069
1070         private static void field_visible_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ClockType fieldtype, bool visible)
1071         {
1072             Eina.Log.Debug("function efl_ui_clock_field_visible_set was called");
1073             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1074             if (wrapper != null)
1075             {
1076
1077                 try
1078                 {
1079                     ((Clock)wrapper).SetFieldVisible(fieldtype, visible);
1080                 }
1081                 catch (Exception e)
1082                 {
1083                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1084                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1085                 }
1086
1087
1088             }
1089             else
1090             {
1091                 efl_ui_clock_field_visible_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fieldtype, visible);
1092             }
1093         }
1094
1095         private static efl_ui_clock_field_visible_set_delegate efl_ui_clock_field_visible_set_static_delegate;
1096
1097
1098         private delegate void efl_ui_clock_field_limit_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype,  out int min,  out int max);
1099
1100
1101         public delegate void efl_ui_clock_field_limit_get_api_delegate(System.IntPtr obj,  Efl.Ui.ClockType fieldtype,  out int min,  out int max);
1102
1103         public static Efl.Eo.FunctionWrapper<efl_ui_clock_field_limit_get_api_delegate> efl_ui_clock_field_limit_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_field_limit_get_api_delegate>(Module, "efl_ui_clock_field_limit_get");
1104
1105         private static void field_limit_get(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ClockType fieldtype, out int min, out int max)
1106         {
1107             Eina.Log.Debug("function efl_ui_clock_field_limit_get was called");
1108             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1109             if (wrapper != null)
1110             {
1111                                         min = default(int);        max = default(int);
1112                 try
1113                 {
1114                     ((Clock)wrapper).GetFieldLimit(fieldtype, out min, out max);
1115                 }
1116                 catch (Exception e)
1117                 {
1118                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1119                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1120                 }
1121
1122
1123             }
1124             else
1125             {
1126                 efl_ui_clock_field_limit_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fieldtype, out min, out max);
1127             }
1128         }
1129
1130         private static efl_ui_clock_field_limit_get_delegate efl_ui_clock_field_limit_get_static_delegate;
1131
1132
1133         private delegate void efl_ui_clock_field_limit_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype,  int min,  int max);
1134
1135
1136         public delegate void efl_ui_clock_field_limit_set_api_delegate(System.IntPtr obj,  Efl.Ui.ClockType fieldtype,  int min,  int max);
1137
1138         public static Efl.Eo.FunctionWrapper<efl_ui_clock_field_limit_set_api_delegate> efl_ui_clock_field_limit_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_clock_field_limit_set_api_delegate>(Module, "efl_ui_clock_field_limit_set");
1139
1140         private static void field_limit_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ClockType fieldtype, int min, int max)
1141         {
1142             Eina.Log.Debug("function efl_ui_clock_field_limit_set was called");
1143             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1144             if (wrapper != null)
1145             {
1146
1147                 try
1148                 {
1149                     ((Clock)wrapper).SetFieldLimit(fieldtype, min, max);
1150                 }
1151                 catch (Exception e)
1152                 {
1153                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1154                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1155                 }
1156
1157
1158             }
1159             else
1160             {
1161                 efl_ui_clock_field_limit_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fieldtype, min, max);
1162             }
1163         }
1164
1165         private static efl_ui_clock_field_limit_set_delegate efl_ui_clock_field_limit_set_static_delegate;
1166
1167         #pragma warning restore CA1707, SA1300, SA1600
1168
1169 }
1170 }
1171 }
1172
1173 }
1174
1175 namespace Efl {
1176
1177 namespace Ui {
1178
1179 /// <summary>Identifies a clock field, The widget supports 6 fields : Year, month, Date, Hour, Minute, AM/PM</summary>
1180 public enum ClockType
1181 {
1182 /// <summary>Indicates Year field.</summary>
1183 Year = 0,
1184 /// <summary>Indicates Month field.</summary>
1185 Month = 1,
1186 /// <summary>Indicates Date field.</summary>
1187 Date = 2,
1188 /// <summary>Indicates Hour field.</summary>
1189 Hour = 3,
1190 /// <summary>Indicates Minute field.</summary>
1191 Minute = 4,
1192 /// <summary>Indicates Second field.</summary>
1193 Second = 5,
1194 /// <summary>Indicated Day field.</summary>
1195 Day = 6,
1196 /// <summary>Indicates AM/PM field .</summary>
1197 Ampm = 7,
1198 }
1199
1200 }
1201
1202 }
1203