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.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>Efl UI clock class</summary>
   9 [ClockNativeInherit]
  10 public class Clock : Efl.Ui.LayoutBase, Efl.Eo.IWrapper
  11 {
  12     ///<summary>Pointer to the native class description.</summary>
  13     public override System.IntPtr NativeClass {
  14         get {
  15             if (((object)this).GetType() == typeof (Clock))
  16                 return Efl.Ui.ClockNativeInherit.GetEflClassStatic();
  17             else
  18                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  19         }
  20     }
  21     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  22         efl_ui_clock_class_get();
  23     ///<summary>Creates a new instance.</summary>
  24     ///<param name="parent">Parent instance.</param>
  25     ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  26     public Clock(Efl.Object parent
  27             , System.String style = null) :
  28         base(efl_ui_clock_class_get(), typeof(Clock), parent)
  29     {
  30         if (Efl.Eo.Globals.ParamHelperCheck(style))
  31             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  32         FinishInstantiation();
  33     }
  34     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  35     protected Clock(System.IntPtr raw) : base(raw)
  36     {
  37                 RegisterEventProxies();
  38     }
  39     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  40     protected Clock(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  41     ///<summary>Verifies if the given object is equal to this one.</summary>
  42     public override bool Equals(object obj)
  43     {
  44         var other = obj as Efl.Object;
  45         if (other == null)
  46             return false;
  47         return this.NativeHandle == other.NativeHandle;
  48     }
  49     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  50     public override int GetHashCode()
  51     {
  52         return this.NativeHandle.ToInt32();
  53     }
  54     ///<summary>Turns the native pointer into a string representation.</summary>
  55     public override String ToString()
  56     {
  57         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  58     }
  59 private static object ChangedEvtKey = new object();
  60     /// <summary>Called when clock changed</summary>
  61     public event EventHandler ChangedEvt
  62     {
  63         add {
  64             lock (eventLock) {
  65                 string key = "_EFL_UI_CLOCK_EVENT_CHANGED";
  66                 if (AddNativeEventHandler(efl.Libs.Elementary, key, this.evt_ChangedEvt_delegate)) {
  67                     eventHandlers.AddHandler(ChangedEvtKey , value);
  68                 } else
  69                     Eina.Log.Error($"Error adding proxy for event {key}");
  70             }
  71         }
  72         remove {
  73             lock (eventLock) {
  74                 string key = "_EFL_UI_CLOCK_EVENT_CHANGED";
  75                 if (RemoveNativeEventHandler(key, this.evt_ChangedEvt_delegate)) {
  76                     eventHandlers.RemoveHandler(ChangedEvtKey , value);
  77                 } else
  78                     Eina.Log.Error($"Error removing proxy for event {key}");
  79             }
  80         }
  81     }
  82     ///<summary>Method to raise event ChangedEvt.</summary>
  83     public void On_ChangedEvt(EventArgs e)
  84     {
  85         EventHandler evt;
  86         lock (eventLock) {
  87         evt = (EventHandler)eventHandlers[ChangedEvtKey];
  88         }
  89         evt?.Invoke(this, e);
  90     }
  91     Efl.EventCb evt_ChangedEvt_delegate;
  92     private void on_ChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
  93     {
  94         EventArgs args = EventArgs.Empty;
  95         try {
  96             On_ChangedEvt(args);
  97         } catch (Exception e) {
  98             Eina.Log.Error(e.ToString());
  99             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 100         }
 101     }
 102
 103     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 104     protected override void RegisterEventProxies()
 105     {
 106         base.RegisterEventProxies();
 107         evt_ChangedEvt_delegate = new Efl.EventCb(on_ChangedEvt_NativeCallback);
 108     }
 109     /// <summary>The current clock format. Format is a combination of allowed Libc date format specifiers like: &quot;%b %d, %Y %I : %M %p&quot;.
 110     /// Maximum allowed format length is 64 chars.
 111     ///
 112     /// Format can include separators for each individual clock field except for AM/PM field.
 113     ///
 114     /// Each separator can be a maximum of 6 UTF-8 bytes. Space is also taken as a separator.
 115     ///
 116     /// These specifiers can be arranged in any order and the widget will display the fields accordingly.
 117     ///
 118     /// Default format is taken as per the system locale settings.</summary>
 119     /// <returns>The clock format.</returns>
 120     virtual public System.String GetFormat() {
 121          var _ret_var = Efl.Ui.ClockNativeInherit.efl_ui_clock_format_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 122         Eina.Error.RaiseIfUnhandledException();
 123         return _ret_var;
 124  }
 125     /// <summary>The current clock format. Format is a combination of allowed Libc date format specifiers like: &quot;%b %d, %Y %I : %M %p&quot;.
 126     /// Maximum allowed format length is 64 chars.
 127     ///
 128     /// Format can include separators for each individual clock field except for AM/PM field.
 129     ///
 130     /// Each separator can be a maximum of 6 UTF-8 bytes. Space is also taken as a separator.
 131     ///
 132     /// These specifiers can be arranged in any order and the widget will display the fields accordingly.
 133     ///
 134     /// Default format is taken as per the system locale settings.</summary>
 135     /// <param name="fmt">The clock format.</param>
 136     /// <returns></returns>
 137     virtual public void SetFormat( System.String fmt) {
 138                                  Efl.Ui.ClockNativeInherit.efl_ui_clock_format_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), fmt);
 139         Eina.Error.RaiseIfUnhandledException();
 140                          }
 141     /// <summary>Whether the given clock widget should be paused or not.
 142     /// This function pauses or starts the clock widget.</summary>
 143     /// <returns><c>true</c> to pause clock, <c>false</c> otherwise</returns>
 144     virtual public bool GetPause() {
 145          var _ret_var = Efl.Ui.ClockNativeInherit.efl_ui_clock_pause_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 146         Eina.Error.RaiseIfUnhandledException();
 147         return _ret_var;
 148  }
 149     /// <summary>Whether the given clock widget should be paused or not.
 150     /// This function pauses or starts the clock widget.</summary>
 151     /// <param name="paused"><c>true</c> to pause clock, <c>false</c> otherwise</param>
 152     /// <returns></returns>
 153     virtual public void SetPause( bool paused) {
 154                                  Efl.Ui.ClockNativeInherit.efl_ui_clock_pause_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), paused);
 155         Eina.Error.RaiseIfUnhandledException();
 156                          }
 157     /// <summary>Digits of the given clock widget should be editable when in editing mode.</summary>
 158     /// <returns><c>true</c> to set edit mode, <c>false</c> otherwise</returns>
 159     virtual public bool GetEditMode() {
 160          var _ret_var = Efl.Ui.ClockNativeInherit.efl_ui_clock_edit_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 161         Eina.Error.RaiseIfUnhandledException();
 162         return _ret_var;
 163  }
 164     /// <summary>Digits of the given clock widget should be editable when in editing mode.</summary>
 165     /// <param name="value"><c>true</c> to set edit mode, <c>false</c> otherwise</param>
 166     /// <returns></returns>
 167     virtual public void SetEditMode( bool value) {
 168                                  Efl.Ui.ClockNativeInherit.efl_ui_clock_edit_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), value);
 169         Eina.Error.RaiseIfUnhandledException();
 170                          }
 171     /// <summary>The lower boundary of a field.
 172     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 173     ///
 174     /// Month: default value range is from 0 to 11.
 175     ///
 176     /// Date: default value range is from 1 to 31 according to the month value.
 177     ///
 178     /// Hour: default value will be in terms of 24 hr format (0~23)
 179     ///
 180     /// Minute: default value range is from 0 to 59.</summary>
 181     /// <returns>Time structure containing the minimum time value.</returns>
 182     virtual public Efl.Time GetTimeMin() {
 183          var _ret_var = Efl.Ui.ClockNativeInherit.efl_ui_clock_time_min_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 184         Eina.Error.RaiseIfUnhandledException();
 185         return _ret_var;
 186  }
 187     /// <summary>The lower boundary of a field.
 188     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 189     ///
 190     /// Month: default value range is from 0 to 11.
 191     ///
 192     /// Date: default value range is from 1 to 31 according to the month value.
 193     ///
 194     /// Hour: default value will be in terms of 24 hr format (0~23)
 195     ///
 196     /// Minute: default value range is from 0 to 59.</summary>
 197     /// <param name="mintime">Time structure containing the minimum time value.</param>
 198     /// <returns></returns>
 199     virtual public void SetTimeMin( Efl.Time mintime) {
 200          Efl.Time.NativeStruct _in_mintime = mintime;
 201                         Efl.Ui.ClockNativeInherit.efl_ui_clock_time_min_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_mintime);
 202         Eina.Error.RaiseIfUnhandledException();
 203                          }
 204     /// <summary>The upper boundary of a field.
 205     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 206     ///
 207     /// Month: default value range is from 0 to 11.
 208     ///
 209     /// Date: default value range is from 1 to 31 according to the month value.
 210     ///
 211     /// Hour: default value will be in terms of 24 hr format (0~23)
 212     ///
 213     /// Minute: default value range is from 0 to 59.</summary>
 214     /// <returns>Time structure containing the maximum time value.</returns>
 215     virtual public Efl.Time GetTimeMax() {
 216          var _ret_var = Efl.Ui.ClockNativeInherit.efl_ui_clock_time_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 217         Eina.Error.RaiseIfUnhandledException();
 218         return _ret_var;
 219  }
 220     /// <summary>The upper boundary of a field.
 221     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 222     ///
 223     /// Month: default value range is from 0 to 11.
 224     ///
 225     /// Date: default value range is from 1 to 31 according to the month value.
 226     ///
 227     /// Hour: default value will be in terms of 24 hr format (0~23)
 228     ///
 229     /// Minute: default value range is from 0 to 59.</summary>
 230     /// <param name="maxtime">Time structure containing the maximum time value.</param>
 231     /// <returns></returns>
 232     virtual public void SetTimeMax( Efl.Time maxtime) {
 233          Efl.Time.NativeStruct _in_maxtime = maxtime;
 234                         Efl.Ui.ClockNativeInherit.efl_ui_clock_time_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_maxtime);
 235         Eina.Error.RaiseIfUnhandledException();
 236                          }
 237     /// <summary>The current value of a clock object.
 238     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 239     ///
 240     /// Month: default value range is from 0 to 11.
 241     ///
 242     /// Date: default value range is from 1 to 31 according to the month value.
 243     ///
 244     /// Hour: default value will be in terms of 24 hr format (0~23)
 245     ///
 246     /// Minute: default value range is from 0 to 59.</summary>
 247     /// <returns>Time structure containing the time value.</returns>
 248     virtual public Efl.Time GetTime() {
 249          var _ret_var = Efl.Ui.ClockNativeInherit.efl_ui_clock_time_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 250         Eina.Error.RaiseIfUnhandledException();
 251         return _ret_var;
 252  }
 253     /// <summary>The current value of a clock object.
 254     /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 255     ///
 256     /// Month: default value range is from 0 to 11.
 257     ///
 258     /// Date: default value range is from 1 to 31 according to the month value.
 259     ///
 260     /// Hour: default value will be in terms of 24 hr format (0~23)
 261     ///
 262     /// Minute: default value range is from 0 to 59.</summary>
 263     /// <param name="curtime">Time structure containing the time value.</param>
 264     /// <returns></returns>
 265     virtual public void SetTime( Efl.Time curtime) {
 266          Efl.Time.NativeStruct _in_curtime = curtime;
 267                         Efl.Ui.ClockNativeInherit.efl_ui_clock_time_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_curtime);
 268         Eina.Error.RaiseIfUnhandledException();
 269                          }
 270     /// <summary>The field to be visible/not.</summary>
 271     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 272     /// <returns><c>true</c> field can be visible, <c>false</c> otherwise.</returns>
 273     virtual public bool GetFieldVisible( Efl.Ui.ClockType fieldtype) {
 274                                  var _ret_var = Efl.Ui.ClockNativeInherit.efl_ui_clock_field_visible_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), fieldtype);
 275         Eina.Error.RaiseIfUnhandledException();
 276                         return _ret_var;
 277  }
 278     /// <summary>The field to be visible/not.</summary>
 279     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 280     /// <param name="visible"><c>true</c> field can be visible, <c>false</c> otherwise.</param>
 281     /// <returns></returns>
 282     virtual public void SetFieldVisible( Efl.Ui.ClockType fieldtype,  bool visible) {
 283                                                          Efl.Ui.ClockNativeInherit.efl_ui_clock_field_visible_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), fieldtype,  visible);
 284         Eina.Error.RaiseIfUnhandledException();
 285                                          }
 286     /// <summary>Get the field limits of a field.
 287     /// 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.
 288     ///
 289     /// There is no provision to set the limits of AM/PM field.</summary>
 290     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 291     /// <param name="min">Reference to field&apos;s minimum value.</param>
 292     /// <param name="max">Reference to field&apos;s maximum value.</param>
 293     /// <returns></returns>
 294     virtual public void GetFieldLimit( Efl.Ui.ClockType fieldtype,  out int min,  out int max) {
 295                                                                                  Efl.Ui.ClockNativeInherit.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);
 296         Eina.Error.RaiseIfUnhandledException();
 297                                                          }
 298     /// <summary>Set a field to be visible or not.
 299     /// 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.
 300     ///
 301     /// By default the field visibility is set to <c>true</c>.</summary>
 302     /// <param name="fieldtype">Type of the field. #EFL_UI_CLOCK_TYPE_YEAR etc.</param>
 303     /// <param name="min">Reference to field&apos;s minimum value.</param>
 304     /// <param name="max">Reference to field&apos;s maximum value.</param>
 305     /// <returns></returns>
 306     virtual public void SetFieldLimit( Efl.Ui.ClockType fieldtype,  int min,  int max) {
 307                                                                                  Efl.Ui.ClockNativeInherit.efl_ui_clock_field_limit_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), fieldtype,  min,  max);
 308         Eina.Error.RaiseIfUnhandledException();
 309                                                          }
 310     /// <summary>The current clock format. Format is a combination of allowed Libc date format specifiers like: &quot;%b %d, %Y %I : %M %p&quot;.
 311 /// Maximum allowed format length is 64 chars.
 312 ///
 313 /// Format can include separators for each individual clock field except for AM/PM field.
 314 ///
 315 /// Each separator can be a maximum of 6 UTF-8 bytes. Space is also taken as a separator.
 316 ///
 317 /// These specifiers can be arranged in any order and the widget will display the fields accordingly.
 318 ///
 319 /// Default format is taken as per the system locale settings.</summary>
 320 /// <value>The clock format.</value>
 321     public System.String Format {
 322         get { return GetFormat(); }
 323         set { SetFormat( value); }
 324     }
 325     /// <summary>Whether the given clock widget should be paused or not.
 326 /// This function pauses or starts the clock widget.</summary>
 327 /// <value><c>true</c> to pause clock, <c>false</c> otherwise</value>
 328     public bool Pause {
 329         get { return GetPause(); }
 330         set { SetPause( value); }
 331     }
 332     /// <summary>Digits of the given clock widget should be editable when in editing mode.</summary>
 333 /// <value><c>true</c> to set edit mode, <c>false</c> otherwise</value>
 334     public bool EditMode {
 335         get { return GetEditMode(); }
 336         set { SetEditMode( value); }
 337     }
 338     /// <summary>The lower boundary of a field.
 339 /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 340 ///
 341 /// Month: default value range is from 0 to 11.
 342 ///
 343 /// Date: default value range is from 1 to 31 according to the month value.
 344 ///
 345 /// Hour: default value will be in terms of 24 hr format (0~23)
 346 ///
 347 /// Minute: default value range is from 0 to 59.</summary>
 348 /// <value>Time structure containing the minimum time value.</value>
 349     public Efl.Time TimeMin {
 350         get { return GetTimeMin(); }
 351         set { SetTimeMin( value); }
 352     }
 353     /// <summary>The upper boundary of a field.
 354 /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 355 ///
 356 /// Month: default value range is from 0 to 11.
 357 ///
 358 /// Date: default value range is from 1 to 31 according to the month value.
 359 ///
 360 /// Hour: default value will be in terms of 24 hr format (0~23)
 361 ///
 362 /// Minute: default value range is from 0 to 59.</summary>
 363 /// <value>Time structure containing the maximum time value.</value>
 364     public Efl.Time TimeMax {
 365         get { return GetTimeMax(); }
 366         set { SetTimeMax( value); }
 367     }
 368     /// <summary>The current value of a clock object.
 369 /// Year: years since 1900. Negative value represents year below 1900 (year value -30 represents 1870). Year default range is from 70 to 137.
 370 ///
 371 /// Month: default value range is from 0 to 11.
 372 ///
 373 /// Date: default value range is from 1 to 31 according to the month value.
 374 ///
 375 /// Hour: default value will be in terms of 24 hr format (0~23)
 376 ///
 377 /// Minute: default value range is from 0 to 59.</summary>
 378 /// <value>Time structure containing the time value.</value>
 379     public Efl.Time Time {
 380         get { return GetTime(); }
 381         set { SetTime( value); }
 382     }
 383     private static IntPtr GetEflClassStatic()
 384     {
 385         return Efl.Ui.Clock.efl_ui_clock_class_get();
 386     }
 387 }
 388 public class ClockNativeInherit : Efl.Ui.LayoutBaseNativeInherit{
 389     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 390     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 391     {
 392         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 393         var methods = Efl.Eo.Globals.GetUserMethods(type);
 394         if (efl_ui_clock_format_get_static_delegate == null)
 395             efl_ui_clock_format_get_static_delegate = new efl_ui_clock_format_get_delegate(format_get);
 396         if (methods.FirstOrDefault(m => m.Name == "GetFormat") != null)
 397             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)});
 398         if (efl_ui_clock_format_set_static_delegate == null)
 399             efl_ui_clock_format_set_static_delegate = new efl_ui_clock_format_set_delegate(format_set);
 400         if (methods.FirstOrDefault(m => m.Name == "SetFormat") != null)
 401             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)});
 402         if (efl_ui_clock_pause_get_static_delegate == null)
 403             efl_ui_clock_pause_get_static_delegate = new efl_ui_clock_pause_get_delegate(pause_get);
 404         if (methods.FirstOrDefault(m => m.Name == "GetPause") != null)
 405             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)});
 406         if (efl_ui_clock_pause_set_static_delegate == null)
 407             efl_ui_clock_pause_set_static_delegate = new efl_ui_clock_pause_set_delegate(pause_set);
 408         if (methods.FirstOrDefault(m => m.Name == "SetPause") != null)
 409             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)});
 410         if (efl_ui_clock_edit_mode_get_static_delegate == null)
 411             efl_ui_clock_edit_mode_get_static_delegate = new efl_ui_clock_edit_mode_get_delegate(edit_mode_get);
 412         if (methods.FirstOrDefault(m => m.Name == "GetEditMode") != null)
 413             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)});
 414         if (efl_ui_clock_edit_mode_set_static_delegate == null)
 415             efl_ui_clock_edit_mode_set_static_delegate = new efl_ui_clock_edit_mode_set_delegate(edit_mode_set);
 416         if (methods.FirstOrDefault(m => m.Name == "SetEditMode") != null)
 417             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)});
 418         if (efl_ui_clock_time_min_get_static_delegate == null)
 419             efl_ui_clock_time_min_get_static_delegate = new efl_ui_clock_time_min_get_delegate(time_min_get);
 420         if (methods.FirstOrDefault(m => m.Name == "GetTimeMin") != null)
 421             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)});
 422         if (efl_ui_clock_time_min_set_static_delegate == null)
 423             efl_ui_clock_time_min_set_static_delegate = new efl_ui_clock_time_min_set_delegate(time_min_set);
 424         if (methods.FirstOrDefault(m => m.Name == "SetTimeMin") != null)
 425             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)});
 426         if (efl_ui_clock_time_max_get_static_delegate == null)
 427             efl_ui_clock_time_max_get_static_delegate = new efl_ui_clock_time_max_get_delegate(time_max_get);
 428         if (methods.FirstOrDefault(m => m.Name == "GetTimeMax") != null)
 429             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)});
 430         if (efl_ui_clock_time_max_set_static_delegate == null)
 431             efl_ui_clock_time_max_set_static_delegate = new efl_ui_clock_time_max_set_delegate(time_max_set);
 432         if (methods.FirstOrDefault(m => m.Name == "SetTimeMax") != null)
 433             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)});
 434         if (efl_ui_clock_time_get_static_delegate == null)
 435             efl_ui_clock_time_get_static_delegate = new efl_ui_clock_time_get_delegate(time_get);
 436         if (methods.FirstOrDefault(m => m.Name == "GetTime") != null)
 437             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)});
 438         if (efl_ui_clock_time_set_static_delegate == null)
 439             efl_ui_clock_time_set_static_delegate = new efl_ui_clock_time_set_delegate(time_set);
 440         if (methods.FirstOrDefault(m => m.Name == "SetTime") != null)
 441             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)});
 442         if (efl_ui_clock_field_visible_get_static_delegate == null)
 443             efl_ui_clock_field_visible_get_static_delegate = new efl_ui_clock_field_visible_get_delegate(field_visible_get);
 444         if (methods.FirstOrDefault(m => m.Name == "GetFieldVisible") != null)
 445             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)});
 446         if (efl_ui_clock_field_visible_set_static_delegate == null)
 447             efl_ui_clock_field_visible_set_static_delegate = new efl_ui_clock_field_visible_set_delegate(field_visible_set);
 448         if (methods.FirstOrDefault(m => m.Name == "SetFieldVisible") != null)
 449             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)});
 450         if (efl_ui_clock_field_limit_get_static_delegate == null)
 451             efl_ui_clock_field_limit_get_static_delegate = new efl_ui_clock_field_limit_get_delegate(field_limit_get);
 452         if (methods.FirstOrDefault(m => m.Name == "GetFieldLimit") != null)
 453             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)});
 454         if (efl_ui_clock_field_limit_set_static_delegate == null)
 455             efl_ui_clock_field_limit_set_static_delegate = new efl_ui_clock_field_limit_set_delegate(field_limit_set);
 456         if (methods.FirstOrDefault(m => m.Name == "SetFieldLimit") != null)
 457             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)});
 458         descs.AddRange(base.GetEoOps(type));
 459         return descs;
 460     }
 461     public override IntPtr GetEflClass()
 462     {
 463         return Efl.Ui.Clock.efl_ui_clock_class_get();
 464     }
 465     public static new  IntPtr GetEflClassStatic()
 466     {
 467         return Efl.Ui.Clock.efl_ui_clock_class_get();
 468     }
 469
 470
 471      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_ui_clock_format_get_delegate(System.IntPtr obj, System.IntPtr pd);
 472
 473
 474      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_ui_clock_format_get_api_delegate(System.IntPtr obj);
 475      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");
 476      private static System.String format_get(System.IntPtr obj, System.IntPtr pd)
 477     {
 478         Eina.Log.Debug("function efl_ui_clock_format_get was called");
 479         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 480         if(wrapper != null) {
 481                         System.String _ret_var = default(System.String);
 482             try {
 483                 _ret_var = ((Clock)wrapper).GetFormat();
 484             } catch (Exception e) {
 485                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 486                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 487             }
 488         return _ret_var;
 489         } else {
 490             return efl_ui_clock_format_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 491         }
 492     }
 493     private static efl_ui_clock_format_get_delegate efl_ui_clock_format_get_static_delegate;
 494
 495
 496      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);
 497
 498
 499      public delegate void efl_ui_clock_format_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String fmt);
 500      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");
 501      private static void format_set(System.IntPtr obj, System.IntPtr pd,  System.String fmt)
 502     {
 503         Eina.Log.Debug("function efl_ui_clock_format_set was called");
 504         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 505         if(wrapper != null) {
 506
 507             try {
 508                 ((Clock)wrapper).SetFormat( fmt);
 509             } catch (Exception e) {
 510                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 511                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 512             }
 513                                 } else {
 514             efl_ui_clock_format_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  fmt);
 515         }
 516     }
 517     private static efl_ui_clock_format_set_delegate efl_ui_clock_format_set_static_delegate;
 518
 519
 520      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_clock_pause_get_delegate(System.IntPtr obj, System.IntPtr pd);
 521
 522
 523      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_clock_pause_get_api_delegate(System.IntPtr obj);
 524      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");
 525      private static bool pause_get(System.IntPtr obj, System.IntPtr pd)
 526     {
 527         Eina.Log.Debug("function efl_ui_clock_pause_get was called");
 528         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 529         if(wrapper != null) {
 530                         bool _ret_var = default(bool);
 531             try {
 532                 _ret_var = ((Clock)wrapper).GetPause();
 533             } catch (Exception e) {
 534                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 535                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 536             }
 537         return _ret_var;
 538         } else {
 539             return efl_ui_clock_pause_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 540         }
 541     }
 542     private static efl_ui_clock_pause_get_delegate efl_ui_clock_pause_get_static_delegate;
 543
 544
 545      private delegate void efl_ui_clock_pause_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool paused);
 546
 547
 548      public delegate void efl_ui_clock_pause_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool paused);
 549      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");
 550      private static void pause_set(System.IntPtr obj, System.IntPtr pd,  bool paused)
 551     {
 552         Eina.Log.Debug("function efl_ui_clock_pause_set was called");
 553         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 554         if(wrapper != null) {
 555
 556             try {
 557                 ((Clock)wrapper).SetPause( paused);
 558             } catch (Exception e) {
 559                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 560                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 561             }
 562                                 } else {
 563             efl_ui_clock_pause_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  paused);
 564         }
 565     }
 566     private static efl_ui_clock_pause_set_delegate efl_ui_clock_pause_set_static_delegate;
 567
 568
 569      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_clock_edit_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 570
 571
 572      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_clock_edit_mode_get_api_delegate(System.IntPtr obj);
 573      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");
 574      private static bool edit_mode_get(System.IntPtr obj, System.IntPtr pd)
 575     {
 576         Eina.Log.Debug("function efl_ui_clock_edit_mode_get was called");
 577         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 578         if(wrapper != null) {
 579                         bool _ret_var = default(bool);
 580             try {
 581                 _ret_var = ((Clock)wrapper).GetEditMode();
 582             } catch (Exception e) {
 583                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 584                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 585             }
 586         return _ret_var;
 587         } else {
 588             return efl_ui_clock_edit_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 589         }
 590     }
 591     private static efl_ui_clock_edit_mode_get_delegate efl_ui_clock_edit_mode_get_static_delegate;
 592
 593
 594      private delegate void efl_ui_clock_edit_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool value);
 595
 596
 597      public delegate void efl_ui_clock_edit_mode_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool value);
 598      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");
 599      private static void edit_mode_set(System.IntPtr obj, System.IntPtr pd,  bool value)
 600     {
 601         Eina.Log.Debug("function efl_ui_clock_edit_mode_set was called");
 602         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 603         if(wrapper != null) {
 604
 605             try {
 606                 ((Clock)wrapper).SetEditMode( value);
 607             } catch (Exception e) {
 608                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 609                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 610             }
 611                                 } else {
 612             efl_ui_clock_edit_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  value);
 613         }
 614     }
 615     private static efl_ui_clock_edit_mode_set_delegate efl_ui_clock_edit_mode_set_static_delegate;
 616
 617
 618      private delegate Efl.Time.NativeStruct efl_ui_clock_time_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 619
 620
 621      public delegate Efl.Time.NativeStruct efl_ui_clock_time_min_get_api_delegate(System.IntPtr obj);
 622      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");
 623      private static Efl.Time.NativeStruct time_min_get(System.IntPtr obj, System.IntPtr pd)
 624     {
 625         Eina.Log.Debug("function efl_ui_clock_time_min_get was called");
 626         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 627         if(wrapper != null) {
 628                         Efl.Time _ret_var = default(Efl.Time);
 629             try {
 630                 _ret_var = ((Clock)wrapper).GetTimeMin();
 631             } catch (Exception e) {
 632                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 633                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 634             }
 635         return _ret_var;
 636         } else {
 637             return efl_ui_clock_time_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 638         }
 639     }
 640     private static efl_ui_clock_time_min_get_delegate efl_ui_clock_time_min_get_static_delegate;
 641
 642
 643      private delegate void efl_ui_clock_time_min_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Time.NativeStruct mintime);
 644
 645
 646      public delegate void efl_ui_clock_time_min_set_api_delegate(System.IntPtr obj,   Efl.Time.NativeStruct mintime);
 647      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");
 648      private static void time_min_set(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct mintime)
 649     {
 650         Eina.Log.Debug("function efl_ui_clock_time_min_set was called");
 651         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 652         if(wrapper != null) {
 653                     Efl.Time _in_mintime = mintime;
 654
 655             try {
 656                 ((Clock)wrapper).SetTimeMin( _in_mintime);
 657             } catch (Exception e) {
 658                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 659                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 660             }
 661                                 } else {
 662             efl_ui_clock_time_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  mintime);
 663         }
 664     }
 665     private static efl_ui_clock_time_min_set_delegate efl_ui_clock_time_min_set_static_delegate;
 666
 667
 668      private delegate Efl.Time.NativeStruct efl_ui_clock_time_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 669
 670
 671      public delegate Efl.Time.NativeStruct efl_ui_clock_time_max_get_api_delegate(System.IntPtr obj);
 672      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");
 673      private static Efl.Time.NativeStruct time_max_get(System.IntPtr obj, System.IntPtr pd)
 674     {
 675         Eina.Log.Debug("function efl_ui_clock_time_max_get was called");
 676         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 677         if(wrapper != null) {
 678                         Efl.Time _ret_var = default(Efl.Time);
 679             try {
 680                 _ret_var = ((Clock)wrapper).GetTimeMax();
 681             } catch (Exception e) {
 682                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 683                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 684             }
 685         return _ret_var;
 686         } else {
 687             return efl_ui_clock_time_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 688         }
 689     }
 690     private static efl_ui_clock_time_max_get_delegate efl_ui_clock_time_max_get_static_delegate;
 691
 692
 693      private delegate void efl_ui_clock_time_max_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Time.NativeStruct maxtime);
 694
 695
 696      public delegate void efl_ui_clock_time_max_set_api_delegate(System.IntPtr obj,   Efl.Time.NativeStruct maxtime);
 697      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");
 698      private static void time_max_set(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct maxtime)
 699     {
 700         Eina.Log.Debug("function efl_ui_clock_time_max_set was called");
 701         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 702         if(wrapper != null) {
 703                     Efl.Time _in_maxtime = maxtime;
 704
 705             try {
 706                 ((Clock)wrapper).SetTimeMax( _in_maxtime);
 707             } catch (Exception e) {
 708                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 709                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 710             }
 711                                 } else {
 712             efl_ui_clock_time_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  maxtime);
 713         }
 714     }
 715     private static efl_ui_clock_time_max_set_delegate efl_ui_clock_time_max_set_static_delegate;
 716
 717
 718      private delegate Efl.Time.NativeStruct efl_ui_clock_time_get_delegate(System.IntPtr obj, System.IntPtr pd);
 719
 720
 721      public delegate Efl.Time.NativeStruct efl_ui_clock_time_get_api_delegate(System.IntPtr obj);
 722      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");
 723      private static Efl.Time.NativeStruct time_get(System.IntPtr obj, System.IntPtr pd)
 724     {
 725         Eina.Log.Debug("function efl_ui_clock_time_get was called");
 726         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 727         if(wrapper != null) {
 728                         Efl.Time _ret_var = default(Efl.Time);
 729             try {
 730                 _ret_var = ((Clock)wrapper).GetTime();
 731             } catch (Exception e) {
 732                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 733                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 734             }
 735         return _ret_var;
 736         } else {
 737             return efl_ui_clock_time_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 738         }
 739     }
 740     private static efl_ui_clock_time_get_delegate efl_ui_clock_time_get_static_delegate;
 741
 742
 743      private delegate void efl_ui_clock_time_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Time.NativeStruct curtime);
 744
 745
 746      public delegate void efl_ui_clock_time_set_api_delegate(System.IntPtr obj,   Efl.Time.NativeStruct curtime);
 747      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");
 748      private static void time_set(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct curtime)
 749     {
 750         Eina.Log.Debug("function efl_ui_clock_time_set was called");
 751         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 752         if(wrapper != null) {
 753                     Efl.Time _in_curtime = curtime;
 754
 755             try {
 756                 ((Clock)wrapper).SetTime( _in_curtime);
 757             } catch (Exception e) {
 758                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 759                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 760             }
 761                                 } else {
 762             efl_ui_clock_time_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  curtime);
 763         }
 764     }
 765     private static efl_ui_clock_time_set_delegate efl_ui_clock_time_set_static_delegate;
 766
 767
 768      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_clock_field_visible_get_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.ClockType fieldtype);
 769
 770
 771      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_clock_field_visible_get_api_delegate(System.IntPtr obj,   Efl.Ui.ClockType fieldtype);
 772      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");
 773      private static bool field_visible_get(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype)
 774     {
 775         Eina.Log.Debug("function efl_ui_clock_field_visible_get was called");
 776         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 777         if(wrapper != null) {
 778                                                 bool _ret_var = default(bool);
 779             try {
 780                 _ret_var = ((Clock)wrapper).GetFieldVisible( fieldtype);
 781             } catch (Exception e) {
 782                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 783                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 784             }
 785                         return _ret_var;
 786         } else {
 787             return efl_ui_clock_field_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  fieldtype);
 788         }
 789     }
 790     private static efl_ui_clock_field_visible_get_delegate efl_ui_clock_field_visible_get_static_delegate;
 791
 792
 793      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);
 794
 795
 796      public delegate void efl_ui_clock_field_visible_set_api_delegate(System.IntPtr obj,   Efl.Ui.ClockType fieldtype,  [MarshalAs(UnmanagedType.U1)]  bool visible);
 797      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");
 798      private static void field_visible_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype,  bool visible)
 799     {
 800         Eina.Log.Debug("function efl_ui_clock_field_visible_set was called");
 801         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 802         if(wrapper != null) {
 803
 804             try {
 805                 ((Clock)wrapper).SetFieldVisible( fieldtype,  visible);
 806             } catch (Exception e) {
 807                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 808                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 809             }
 810                                                 } else {
 811             efl_ui_clock_field_visible_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  fieldtype,  visible);
 812         }
 813     }
 814     private static efl_ui_clock_field_visible_set_delegate efl_ui_clock_field_visible_set_static_delegate;
 815
 816
 817      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);
 818
 819
 820      public delegate void efl_ui_clock_field_limit_get_api_delegate(System.IntPtr obj,   Efl.Ui.ClockType fieldtype,   out int min,   out int max);
 821      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");
 822      private static void field_limit_get(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype,  out int min,  out int max)
 823     {
 824         Eina.Log.Debug("function efl_ui_clock_field_limit_get was called");
 825         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 826         if(wrapper != null) {
 827                                                     min = default(int);        max = default(int);
 828             try {
 829                 ((Clock)wrapper).GetFieldLimit( fieldtype,  out min,  out max);
 830             } catch (Exception e) {
 831                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 832                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 833             }
 834                                                                 } else {
 835             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);
 836         }
 837     }
 838     private static efl_ui_clock_field_limit_get_delegate efl_ui_clock_field_limit_get_static_delegate;
 839
 840
 841      private delegate void efl_ui_clock_field_limit_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.ClockType fieldtype,   int min,   int max);
 842
 843
 844      public delegate void efl_ui_clock_field_limit_set_api_delegate(System.IntPtr obj,   Efl.Ui.ClockType fieldtype,   int min,   int max);
 845      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");
 846      private static void field_limit_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ClockType fieldtype,  int min,  int max)
 847     {
 848         Eina.Log.Debug("function efl_ui_clock_field_limit_set was called");
 849         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 850         if(wrapper != null) {
 851
 852             try {
 853                 ((Clock)wrapper).SetFieldLimit( fieldtype,  min,  max);
 854             } catch (Exception e) {
 855                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 856                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 857             }
 858                                                                 } else {
 859             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);
 860         }
 861     }
 862     private static efl_ui_clock_field_limit_set_delegate efl_ui_clock_field_limit_set_static_delegate;
 863 }
 864 } }
 865 namespace Efl { namespace Ui {
 866 /// <summary>Identifies a clock field, The widget supports 6 fields : Year, month, Date, Hour, Minute, AM/PM</summary>
 867 public enum ClockType
 868 {
 869 /// <summary>Indicates Year field.</summary>
 870 Year = 0,
 871 /// <summary>Indicates Month field.</summary>
 872 Month = 1,
 873 /// <summary>Indicates Date field.</summary>
 874 Date = 2,
 875 /// <summary>Indicates Hour field.</summary>
 876 Hour = 3,
 877 /// <summary>Indicates Minute field.</summary>
 878 Minute = 4,
 879 /// <summary>Indicates Second field.</summary>
 880 Second = 5,
 881 /// <summary>Indicated Day field.</summary>
 882 Day = 6,
 883 /// <summary>Indicates AM/PM field .</summary>
 884 Ampm = 7,
 885 }
 886 } }