internals/src/EflSharp/EflSharp/efl/efl_ui_calendar.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>Calendar widget
  13 /// It helps applications to flexibly display a calendar with day of the week, date, year and month. Applications are able to set specific dates to be reported back, when selected, in the smart callbacks of the calendar widget.</summary>
  14 [Efl.Ui.Calendar.NativeMethods]
  15 public class Calendar : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.Ui.IFormat,Efl.Ui.Focus.IComposition
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(Calendar))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  34         efl_ui_calendar_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="Calendar"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  38     public Calendar(Efl.Object parent
  39             , System.String style = null) : base(efl_ui_calendar_class_get(), typeof(Calendar), parent)
  40     {
  41         if (Efl.Eo.Globals.ParamHelperCheck(style))
  42         {
  43             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  44         }
  45
  46         FinishInstantiation();
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="Calendar"/> class.
  50     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  51     /// <param name="raw">The native pointer to be wrapped.</param>
  52     protected Calendar(System.IntPtr raw) : base(raw)
  53     {
  54             }
  55
  56     /// <summary>Initializes a new instance of the <see cref="Calendar"/> class.
  57     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  58     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  59     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  60     /// <param name="parent">The Efl.Object parent of this instance.</param>
  61     protected Calendar(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  62     {
  63     }
  64
  65     /// <summary>Verifies if the given object is equal to this one.</summary>
  66     /// <param name="instance">The object to compare to.</param>
  67     /// <returns>True if both objects point to the same native object.</returns>
  68     public override bool Equals(object instance)
  69     {
  70         var other = instance as Efl.Object;
  71         if (other == null)
  72         {
  73             return false;
  74         }
  75         return this.NativeHandle == other.NativeHandle;
  76     }
  77
  78     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  79     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  80     public override int GetHashCode()
  81     {
  82         return this.NativeHandle.ToInt32();
  83     }
  84
  85     /// <summary>Turns the native pointer into a string representation.</summary>
  86     /// <returns>A string with the type and the native pointer for this object.</returns>
  87     public override String ToString()
  88     {
  89         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  90     }
  91
  92     /// <summary>Emitted when the selected date in the calendar is changed</summary>
  93     public event EventHandler ChangedEvt
  94     {
  95         add
  96         {
  97             lock (eventLock)
  98             {
  99                 var wRef = new WeakReference(this);
 100                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 101                 {
 102                     var obj = wRef.Target as Efl.Eo.IWrapper;
 103                     if (obj != null)
 104                     {
 105                         EventArgs args = EventArgs.Empty;
 106                         try
 107                         {
 108                             value?.Invoke(obj, args);
 109                         }
 110                         catch (Exception e)
 111                         {
 112                             Eina.Log.Error(e.ToString());
 113                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 114                         }
 115                     }
 116                 };
 117
 118                 string key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
 119                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 120             }
 121         }
 122
 123         remove
 124         {
 125             lock (eventLock)
 126             {
 127                 string key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
 128                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 129             }
 130         }
 131     }
 132     ///<summary>Method to raise event ChangedEvt.</summary>
 133     public void OnChangedEvt(EventArgs e)
 134     {
 135         var key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
 136         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 137         if (desc == IntPtr.Zero)
 138         {
 139             Eina.Log.Error($"Failed to get native event {key}");
 140             return;
 141         }
 142
 143         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 144     }
 145     /// <summary>The first day of week to use on calendar widgets.
 146     /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 147     /// <returns>The first day of the week.</returns>
 148     virtual public Efl.Ui.CalendarWeekday GetFirstDayOfWeek() {
 149          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_first_day_of_week_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 150         Eina.Error.RaiseIfUnhandledException();
 151         return _ret_var;
 152  }
 153     /// <summary>The first day of week to use on calendar widgets.
 154     /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 155     /// <param name="day">The first day of the week.</param>
 156     virtual public void SetFirstDayOfWeek(Efl.Ui.CalendarWeekday day) {
 157                                  Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_first_day_of_week_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),day);
 158         Eina.Error.RaiseIfUnhandledException();
 159                          }
 160     /// <summary>Get the minimum date.
 161     /// Default value is 1 JAN,1902.</summary>
 162     /// <returns>Time structure containing the minimum date.</returns>
 163     virtual public Efl.Time GetDateMin() {
 164          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_min_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 165         Eina.Error.RaiseIfUnhandledException();
 166         return _ret_var;
 167  }
 168     /// <summary>Set the minimum date on calendar.
 169     /// Set the minimum date, changing the displayed month or year if needed. Displayed day also to be disabled if it is smaller than minimum date. If the minimum date is greater than current maximum date, the minimum date would be changed to the maximum date with returning <c>false</c>.</summary>
 170     /// <param name="min">Time structure containing the minimum date.</param>
 171     /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 172     virtual public bool SetDateMin(Efl.Time min) {
 173          Efl.Time.NativeStruct _in_min = min;
 174                         var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_min_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_min);
 175         Eina.Error.RaiseIfUnhandledException();
 176                         return _ret_var;
 177  }
 178     /// <summary>Get the maximum date.
 179     /// Default maximum year is -1. Default maximum day and month are 31 and DEC.
 180     ///
 181     /// If the maximum year is a negative value, it will be limited depending on the platform architecture (year 2037 for 32 bits);</summary>
 182     /// <returns>Time structure containing the maximum date.</returns>
 183     virtual public Efl.Time GetDateMax() {
 184          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 185         Eina.Error.RaiseIfUnhandledException();
 186         return _ret_var;
 187  }
 188     /// <summary>Set the maximum date on calendar.
 189     /// Set the maximum date, changing the displayed month or year if needed. Displayed day also to be disabled if it is bigger than maximum date. If the maximum date is less than current minimum date, the maximum date would be changed to the minimum date with returning <c>false</c>.</summary>
 190     /// <param name="max">Time structure containing the maximum date.</param>
 191     /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 192     virtual public bool SetDateMax(Efl.Time max) {
 193          Efl.Time.NativeStruct _in_max = max;
 194                         var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_max);
 195         Eina.Error.RaiseIfUnhandledException();
 196                         return _ret_var;
 197  }
 198     /// <summary>The selected date on calendar.</summary>
 199     /// <returns>Time structure containing the selected date.</returns>
 200     virtual public Efl.Time GetDate() {
 201          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 202         Eina.Error.RaiseIfUnhandledException();
 203         return _ret_var;
 204  }
 205     /// <summary>Set the selected date. If the date is greater than the maximum date, the date would be changed to the maximum date with returning <c>false</c>. In the opposite case with the minimum date, this would give the same result.</summary>
 206     /// <param name="date">Time structure containing the selected date.</param>
 207     /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 208     virtual public bool SetDate(Efl.Time date) {
 209          Efl.Time.NativeStruct _in_date = date;
 210                         var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_date);
 211         Eina.Error.RaiseIfUnhandledException();
 212                         return _ret_var;
 213  }
 214     /// <summary>Set the format function pointer to format the string.</summary>
 215     /// <param name="func">The format function callback</param>
 216     virtual public void SetFormatCb(Efl.Ui.FormatFuncCb func) {
 217                          GCHandle func_handle = GCHandle.Alloc(func);
 218         Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_cb_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),GCHandle.ToIntPtr(func_handle), Efl.Ui.FormatFuncCbWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 219         Eina.Error.RaiseIfUnhandledException();
 220                          }
 221     /// <summary>Control the format string for a given units label
 222     /// If <c>NULL</c> is passed to <c>format</c>, it will hide <c>obj</c>&apos;s units area completely. If not, it&apos;ll set the &lt;b&gt;format string&lt;/b&gt; for the units label text. The units label is provided as a floating point value, so the units text can display at most one floating point value. Note that the units label is optional. Use a format string such as &quot;%1.2f meters&quot; for example.
 223     ///
 224     /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 225     /// <returns>The format string for <c>obj</c>&apos;s units label.</returns>
 226     virtual public System.String GetFormatString() {
 227          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 228         Eina.Error.RaiseIfUnhandledException();
 229         return _ret_var;
 230  }
 231     /// <summary>Control the format string for a given units label
 232     /// If <c>NULL</c> is passed to <c>format</c>, it will hide <c>obj</c>&apos;s units area completely. If not, it&apos;ll set the &lt;b&gt;format string&lt;/b&gt; for the units label text. The units label is provided as a floating point value, so the units text can display at most one floating point value. Note that the units label is optional. Use a format string such as &quot;%1.2f meters&quot; for example.
 233     ///
 234     /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 235     /// <param name="units">The format string for <c>obj</c>&apos;s units label.</param>
 236     virtual public void SetFormatString(System.String units) {
 237                                  Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),units);
 238         Eina.Error.RaiseIfUnhandledException();
 239                          }
 240     /// <summary>Set the order of elements that will be used for composition
 241     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 242     ///
 243     /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
 244     ///
 245     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 246     ///
 247     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 248     /// <returns>The order to use</returns>
 249     virtual public Eina.List<Efl.Gfx.IEntity> GetCompositionElements() {
 250          var _ret_var = Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 251         Eina.Error.RaiseIfUnhandledException();
 252         return new Eina.List<Efl.Gfx.IEntity>(_ret_var, true, false);
 253  }
 254     /// <summary>Set the order of elements that will be used for composition
 255     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 256     ///
 257     /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
 258     ///
 259     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 260     ///
 261     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 262     /// <param name="logical_order">The order to use</param>
 263     virtual public void SetCompositionElements(Eina.List<Efl.Gfx.IEntity> logical_order) {
 264          var _in_logical_order = logical_order.Handle;
 265 logical_order.Own = false;
 266                         Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_elements_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_logical_order);
 267         Eina.Error.RaiseIfUnhandledException();
 268                          }
 269     /// <summary>Set to true if all children should be registered as logicals</summary>
 270     /// <returns><c>true</c> or <c>false</c></returns>
 271     virtual public bool GetLogicalMode() {
 272          var _ret_var = Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_logical_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 273         Eina.Error.RaiseIfUnhandledException();
 274         return _ret_var;
 275  }
 276     /// <summary>Set to true if all children should be registered as logicals</summary>
 277     /// <param name="logical_mode"><c>true</c> or <c>false</c></param>
 278     virtual public void SetLogicalMode(bool logical_mode) {
 279                                  Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_logical_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),logical_mode);
 280         Eina.Error.RaiseIfUnhandledException();
 281                          }
 282     /// <summary>Mark this widget as dirty, the children can be considered to be changed after that call</summary>
 283     virtual public void Dirty() {
 284          Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_dirty_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 285         Eina.Error.RaiseIfUnhandledException();
 286          }
 287     /// <summary>A call to prepare the children of this element, called if marked as dirty
 288     /// You can use this function to call composition_elements.</summary>
 289     virtual public void Prepare() {
 290          Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_prepare_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 291         Eina.Error.RaiseIfUnhandledException();
 292          }
 293     /// <summary>The first day of week to use on calendar widgets.
 294 /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 295 /// <value>The first day of the week.</value>
 296     public Efl.Ui.CalendarWeekday FirstDayOfWeek {
 297         get { return GetFirstDayOfWeek(); }
 298         set { SetFirstDayOfWeek(value); }
 299     }
 300     /// <summary>Minimum date on calendar.</summary>
 301 /// <value>Time structure containing the minimum date.</value>
 302     public Efl.Time DateMin {
 303         get { return GetDateMin(); }
 304         set { SetDateMin(value); }
 305     }
 306     /// <summary>Maximum date on calendar.</summary>
 307 /// <value>Time structure containing the maximum date.</value>
 308     public Efl.Time DateMax {
 309         get { return GetDateMax(); }
 310         set { SetDateMax(value); }
 311     }
 312     /// <summary>The selected date on calendar.</summary>
 313 /// <value>Time structure containing the selected date.</value>
 314     public Efl.Time Date {
 315         get { return GetDate(); }
 316         set { SetDate(value); }
 317     }
 318     /// <summary>Set the format function pointer to format the string.</summary>
 319 /// <value>The format function callback</value>
 320     public Efl.Ui.FormatFuncCb FormatCb {
 321         set { SetFormatCb(value); }
 322     }
 323     /// <summary>Control the format string for a given units label
 324 /// If <c>NULL</c> is passed to <c>format</c>, it will hide <c>obj</c>&apos;s units area completely. If not, it&apos;ll set the &lt;b&gt;format string&lt;/b&gt; for the units label text. The units label is provided as a floating point value, so the units text can display at most one floating point value. Note that the units label is optional. Use a format string such as &quot;%1.2f meters&quot; for example.
 325 ///
 326 /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 327 /// <value>The format string for <c>obj</c>&apos;s units label.</value>
 328     public System.String FormatString {
 329         get { return GetFormatString(); }
 330         set { SetFormatString(value); }
 331     }
 332     /// <summary>Set the order of elements that will be used for composition
 333 /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 334 ///
 335 /// If the element is an Efl.Gfx.Entity, then the geometry is used as focus geometry, the focus property is redirected to the evas focus property. The mixin will take care of registration.
 336 ///
 337 /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 338 ///
 339 /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 340 /// <value>The order to use</value>
 341     public Eina.List<Efl.Gfx.IEntity> CompositionElements {
 342         get { return GetCompositionElements(); }
 343         set { SetCompositionElements(value); }
 344     }
 345     /// <summary>Set to true if all children should be registered as logicals</summary>
 346 /// <value><c>true</c> or <c>false</c></value>
 347     public bool LogicalMode {
 348         get { return GetLogicalMode(); }
 349         set { SetLogicalMode(value); }
 350     }
 351     private static IntPtr GetEflClassStatic()
 352     {
 353         return Efl.Ui.Calendar.efl_ui_calendar_class_get();
 354     }
 355     /// <summary>Wrapper for native methods and virtual method delegates.
 356     /// For internal use by generated code only.</summary>
 357     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 358     {
 359         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 360         /// <summary>Gets the list of Eo operations to override.</summary>
 361         /// <returns>The list of Eo operations to be overload.</returns>
 362         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 363         {
 364             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 365             var methods = Efl.Eo.Globals.GetUserMethods(type);
 366
 367             if (efl_ui_calendar_first_day_of_week_get_static_delegate == null)
 368             {
 369                 efl_ui_calendar_first_day_of_week_get_static_delegate = new efl_ui_calendar_first_day_of_week_get_delegate(first_day_of_week_get);
 370             }
 371
 372             if (methods.FirstOrDefault(m => m.Name == "GetFirstDayOfWeek") != null)
 373             {
 374                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_first_day_of_week_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_first_day_of_week_get_static_delegate) });
 375             }
 376
 377             if (efl_ui_calendar_first_day_of_week_set_static_delegate == null)
 378             {
 379                 efl_ui_calendar_first_day_of_week_set_static_delegate = new efl_ui_calendar_first_day_of_week_set_delegate(first_day_of_week_set);
 380             }
 381
 382             if (methods.FirstOrDefault(m => m.Name == "SetFirstDayOfWeek") != null)
 383             {
 384                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_first_day_of_week_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_first_day_of_week_set_static_delegate) });
 385             }
 386
 387             if (efl_ui_calendar_date_min_get_static_delegate == null)
 388             {
 389                 efl_ui_calendar_date_min_get_static_delegate = new efl_ui_calendar_date_min_get_delegate(date_min_get);
 390             }
 391
 392             if (methods.FirstOrDefault(m => m.Name == "GetDateMin") != null)
 393             {
 394                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_date_min_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_date_min_get_static_delegate) });
 395             }
 396
 397             if (efl_ui_calendar_date_min_set_static_delegate == null)
 398             {
 399                 efl_ui_calendar_date_min_set_static_delegate = new efl_ui_calendar_date_min_set_delegate(date_min_set);
 400             }
 401
 402             if (methods.FirstOrDefault(m => m.Name == "SetDateMin") != null)
 403             {
 404                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_date_min_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_date_min_set_static_delegate) });
 405             }
 406
 407             if (efl_ui_calendar_date_max_get_static_delegate == null)
 408             {
 409                 efl_ui_calendar_date_max_get_static_delegate = new efl_ui_calendar_date_max_get_delegate(date_max_get);
 410             }
 411
 412             if (methods.FirstOrDefault(m => m.Name == "GetDateMax") != null)
 413             {
 414                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_date_max_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_date_max_get_static_delegate) });
 415             }
 416
 417             if (efl_ui_calendar_date_max_set_static_delegate == null)
 418             {
 419                 efl_ui_calendar_date_max_set_static_delegate = new efl_ui_calendar_date_max_set_delegate(date_max_set);
 420             }
 421
 422             if (methods.FirstOrDefault(m => m.Name == "SetDateMax") != null)
 423             {
 424                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_date_max_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_date_max_set_static_delegate) });
 425             }
 426
 427             if (efl_ui_calendar_date_get_static_delegate == null)
 428             {
 429                 efl_ui_calendar_date_get_static_delegate = new efl_ui_calendar_date_get_delegate(date_get);
 430             }
 431
 432             if (methods.FirstOrDefault(m => m.Name == "GetDate") != null)
 433             {
 434                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_date_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_date_get_static_delegate) });
 435             }
 436
 437             if (efl_ui_calendar_date_set_static_delegate == null)
 438             {
 439                 efl_ui_calendar_date_set_static_delegate = new efl_ui_calendar_date_set_delegate(date_set);
 440             }
 441
 442             if (methods.FirstOrDefault(m => m.Name == "SetDate") != null)
 443             {
 444                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_calendar_date_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_calendar_date_set_static_delegate) });
 445             }
 446
 447             if (efl_ui_format_cb_set_static_delegate == null)
 448             {
 449                 efl_ui_format_cb_set_static_delegate = new efl_ui_format_cb_set_delegate(format_cb_set);
 450             }
 451
 452             if (methods.FirstOrDefault(m => m.Name == "SetFormatCb") != null)
 453             {
 454                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_cb_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_cb_set_static_delegate) });
 455             }
 456
 457             if (efl_ui_format_string_get_static_delegate == null)
 458             {
 459                 efl_ui_format_string_get_static_delegate = new efl_ui_format_string_get_delegate(format_string_get);
 460             }
 461
 462             if (methods.FirstOrDefault(m => m.Name == "GetFormatString") != null)
 463             {
 464                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_string_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_string_get_static_delegate) });
 465             }
 466
 467             if (efl_ui_format_string_set_static_delegate == null)
 468             {
 469                 efl_ui_format_string_set_static_delegate = new efl_ui_format_string_set_delegate(format_string_set);
 470             }
 471
 472             if (methods.FirstOrDefault(m => m.Name == "SetFormatString") != null)
 473             {
 474                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_string_set_static_delegate) });
 475             }
 476
 477             if (efl_ui_focus_composition_elements_get_static_delegate == null)
 478             {
 479                 efl_ui_focus_composition_elements_get_static_delegate = new efl_ui_focus_composition_elements_get_delegate(composition_elements_get);
 480             }
 481
 482             if (methods.FirstOrDefault(m => m.Name == "GetCompositionElements") != null)
 483             {
 484                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_elements_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_elements_get_static_delegate) });
 485             }
 486
 487             if (efl_ui_focus_composition_elements_set_static_delegate == null)
 488             {
 489                 efl_ui_focus_composition_elements_set_static_delegate = new efl_ui_focus_composition_elements_set_delegate(composition_elements_set);
 490             }
 491
 492             if (methods.FirstOrDefault(m => m.Name == "SetCompositionElements") != null)
 493             {
 494                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_elements_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_elements_set_static_delegate) });
 495             }
 496
 497             if (efl_ui_focus_composition_logical_mode_get_static_delegate == null)
 498             {
 499                 efl_ui_focus_composition_logical_mode_get_static_delegate = new efl_ui_focus_composition_logical_mode_get_delegate(logical_mode_get);
 500             }
 501
 502             if (methods.FirstOrDefault(m => m.Name == "GetLogicalMode") != null)
 503             {
 504                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_logical_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_logical_mode_get_static_delegate) });
 505             }
 506
 507             if (efl_ui_focus_composition_logical_mode_set_static_delegate == null)
 508             {
 509                 efl_ui_focus_composition_logical_mode_set_static_delegate = new efl_ui_focus_composition_logical_mode_set_delegate(logical_mode_set);
 510             }
 511
 512             if (methods.FirstOrDefault(m => m.Name == "SetLogicalMode") != null)
 513             {
 514                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_logical_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_logical_mode_set_static_delegate) });
 515             }
 516
 517             if (efl_ui_focus_composition_dirty_static_delegate == null)
 518             {
 519                 efl_ui_focus_composition_dirty_static_delegate = new efl_ui_focus_composition_dirty_delegate(dirty);
 520             }
 521
 522             if (methods.FirstOrDefault(m => m.Name == "Dirty") != null)
 523             {
 524                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_dirty"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_dirty_static_delegate) });
 525             }
 526
 527             if (efl_ui_focus_composition_prepare_static_delegate == null)
 528             {
 529                 efl_ui_focus_composition_prepare_static_delegate = new efl_ui_focus_composition_prepare_delegate(prepare);
 530             }
 531
 532             if (methods.FirstOrDefault(m => m.Name == "Prepare") != null)
 533             {
 534                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_composition_prepare"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_composition_prepare_static_delegate) });
 535             }
 536
 537             descs.AddRange(base.GetEoOps(type));
 538             return descs;
 539         }
 540         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 541         /// <returns>The native class pointer.</returns>
 542         public override IntPtr GetEflClass()
 543         {
 544             return Efl.Ui.Calendar.efl_ui_calendar_class_get();
 545         }
 546
 547         #pragma warning disable CA1707, SA1300, SA1600
 548
 549
 550         private delegate Efl.Ui.CalendarWeekday efl_ui_calendar_first_day_of_week_get_delegate(System.IntPtr obj, System.IntPtr pd);
 551
 552
 553         public delegate Efl.Ui.CalendarWeekday efl_ui_calendar_first_day_of_week_get_api_delegate(System.IntPtr obj);
 554
 555         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_first_day_of_week_get_api_delegate> efl_ui_calendar_first_day_of_week_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_first_day_of_week_get_api_delegate>(Module, "efl_ui_calendar_first_day_of_week_get");
 556
 557         private static Efl.Ui.CalendarWeekday first_day_of_week_get(System.IntPtr obj, System.IntPtr pd)
 558         {
 559             Eina.Log.Debug("function efl_ui_calendar_first_day_of_week_get was called");
 560             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 561             if (wrapper != null)
 562             {
 563             Efl.Ui.CalendarWeekday _ret_var = default(Efl.Ui.CalendarWeekday);
 564                 try
 565                 {
 566                     _ret_var = ((Calendar)wrapper).GetFirstDayOfWeek();
 567                 }
 568                 catch (Exception e)
 569                 {
 570                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 571                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 572                 }
 573
 574         return _ret_var;
 575
 576             }
 577             else
 578             {
 579                 return efl_ui_calendar_first_day_of_week_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 580             }
 581         }
 582
 583         private static efl_ui_calendar_first_day_of_week_get_delegate efl_ui_calendar_first_day_of_week_get_static_delegate;
 584
 585
 586         private delegate void efl_ui_calendar_first_day_of_week_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.CalendarWeekday day);
 587
 588
 589         public delegate void efl_ui_calendar_first_day_of_week_set_api_delegate(System.IntPtr obj,  Efl.Ui.CalendarWeekday day);
 590
 591         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_first_day_of_week_set_api_delegate> efl_ui_calendar_first_day_of_week_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_first_day_of_week_set_api_delegate>(Module, "efl_ui_calendar_first_day_of_week_set");
 592
 593         private static void first_day_of_week_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.CalendarWeekday day)
 594         {
 595             Eina.Log.Debug("function efl_ui_calendar_first_day_of_week_set was called");
 596             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 597             if (wrapper != null)
 598             {
 599
 600                 try
 601                 {
 602                     ((Calendar)wrapper).SetFirstDayOfWeek(day);
 603                 }
 604                 catch (Exception e)
 605                 {
 606                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 607                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 608                 }
 609
 610
 611             }
 612             else
 613             {
 614                 efl_ui_calendar_first_day_of_week_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), day);
 615             }
 616         }
 617
 618         private static efl_ui_calendar_first_day_of_week_set_delegate efl_ui_calendar_first_day_of_week_set_static_delegate;
 619
 620
 621         private delegate Efl.Time.NativeStruct efl_ui_calendar_date_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 622
 623
 624         public delegate Efl.Time.NativeStruct efl_ui_calendar_date_min_get_api_delegate(System.IntPtr obj);
 625
 626         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_date_min_get_api_delegate> efl_ui_calendar_date_min_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_date_min_get_api_delegate>(Module, "efl_ui_calendar_date_min_get");
 627
 628         private static Efl.Time.NativeStruct date_min_get(System.IntPtr obj, System.IntPtr pd)
 629         {
 630             Eina.Log.Debug("function efl_ui_calendar_date_min_get was called");
 631             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 632             if (wrapper != null)
 633             {
 634             Efl.Time _ret_var = default(Efl.Time);
 635                 try
 636                 {
 637                     _ret_var = ((Calendar)wrapper).GetDateMin();
 638                 }
 639                 catch (Exception e)
 640                 {
 641                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 642                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 643                 }
 644
 645         return _ret_var;
 646
 647             }
 648             else
 649             {
 650                 return efl_ui_calendar_date_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 651             }
 652         }
 653
 654         private static efl_ui_calendar_date_min_get_delegate efl_ui_calendar_date_min_get_static_delegate;
 655
 656         [return: MarshalAs(UnmanagedType.U1)]
 657         private delegate bool efl_ui_calendar_date_min_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct min);
 658
 659         [return: MarshalAs(UnmanagedType.U1)]
 660         public delegate bool efl_ui_calendar_date_min_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct min);
 661
 662         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_date_min_set_api_delegate> efl_ui_calendar_date_min_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_date_min_set_api_delegate>(Module, "efl_ui_calendar_date_min_set");
 663
 664         private static bool date_min_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct min)
 665         {
 666             Eina.Log.Debug("function efl_ui_calendar_date_min_set was called");
 667             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 668             if (wrapper != null)
 669             {
 670         Efl.Time _in_min = min;
 671                             bool _ret_var = default(bool);
 672                 try
 673                 {
 674                     _ret_var = ((Calendar)wrapper).SetDateMin(_in_min);
 675                 }
 676                 catch (Exception e)
 677                 {
 678                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 679                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 680                 }
 681
 682                         return _ret_var;
 683
 684             }
 685             else
 686             {
 687                 return efl_ui_calendar_date_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min);
 688             }
 689         }
 690
 691         private static efl_ui_calendar_date_min_set_delegate efl_ui_calendar_date_min_set_static_delegate;
 692
 693
 694         private delegate Efl.Time.NativeStruct efl_ui_calendar_date_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 695
 696
 697         public delegate Efl.Time.NativeStruct efl_ui_calendar_date_max_get_api_delegate(System.IntPtr obj);
 698
 699         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_date_max_get_api_delegate> efl_ui_calendar_date_max_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_date_max_get_api_delegate>(Module, "efl_ui_calendar_date_max_get");
 700
 701         private static Efl.Time.NativeStruct date_max_get(System.IntPtr obj, System.IntPtr pd)
 702         {
 703             Eina.Log.Debug("function efl_ui_calendar_date_max_get was called");
 704             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 705             if (wrapper != null)
 706             {
 707             Efl.Time _ret_var = default(Efl.Time);
 708                 try
 709                 {
 710                     _ret_var = ((Calendar)wrapper).GetDateMax();
 711                 }
 712                 catch (Exception e)
 713                 {
 714                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 715                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 716                 }
 717
 718         return _ret_var;
 719
 720             }
 721             else
 722             {
 723                 return efl_ui_calendar_date_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 724             }
 725         }
 726
 727         private static efl_ui_calendar_date_max_get_delegate efl_ui_calendar_date_max_get_static_delegate;
 728
 729         [return: MarshalAs(UnmanagedType.U1)]
 730         private delegate bool efl_ui_calendar_date_max_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct max);
 731
 732         [return: MarshalAs(UnmanagedType.U1)]
 733         public delegate bool efl_ui_calendar_date_max_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct max);
 734
 735         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_date_max_set_api_delegate> efl_ui_calendar_date_max_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_date_max_set_api_delegate>(Module, "efl_ui_calendar_date_max_set");
 736
 737         private static bool date_max_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct max)
 738         {
 739             Eina.Log.Debug("function efl_ui_calendar_date_max_set was called");
 740             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 741             if (wrapper != null)
 742             {
 743         Efl.Time _in_max = max;
 744                             bool _ret_var = default(bool);
 745                 try
 746                 {
 747                     _ret_var = ((Calendar)wrapper).SetDateMax(_in_max);
 748                 }
 749                 catch (Exception e)
 750                 {
 751                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 752                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 753                 }
 754
 755                         return _ret_var;
 756
 757             }
 758             else
 759             {
 760                 return efl_ui_calendar_date_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), max);
 761             }
 762         }
 763
 764         private static efl_ui_calendar_date_max_set_delegate efl_ui_calendar_date_max_set_static_delegate;
 765
 766
 767         private delegate Efl.Time.NativeStruct efl_ui_calendar_date_get_delegate(System.IntPtr obj, System.IntPtr pd);
 768
 769
 770         public delegate Efl.Time.NativeStruct efl_ui_calendar_date_get_api_delegate(System.IntPtr obj);
 771
 772         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_date_get_api_delegate> efl_ui_calendar_date_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_date_get_api_delegate>(Module, "efl_ui_calendar_date_get");
 773
 774         private static Efl.Time.NativeStruct date_get(System.IntPtr obj, System.IntPtr pd)
 775         {
 776             Eina.Log.Debug("function efl_ui_calendar_date_get was called");
 777             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 778             if (wrapper != null)
 779             {
 780             Efl.Time _ret_var = default(Efl.Time);
 781                 try
 782                 {
 783                     _ret_var = ((Calendar)wrapper).GetDate();
 784                 }
 785                 catch (Exception e)
 786                 {
 787                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 788                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 789                 }
 790
 791         return _ret_var;
 792
 793             }
 794             else
 795             {
 796                 return efl_ui_calendar_date_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 797             }
 798         }
 799
 800         private static efl_ui_calendar_date_get_delegate efl_ui_calendar_date_get_static_delegate;
 801
 802         [return: MarshalAs(UnmanagedType.U1)]
 803         private delegate bool efl_ui_calendar_date_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct date);
 804
 805         [return: MarshalAs(UnmanagedType.U1)]
 806         public delegate bool efl_ui_calendar_date_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct date);
 807
 808         public static Efl.Eo.FunctionWrapper<efl_ui_calendar_date_set_api_delegate> efl_ui_calendar_date_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_calendar_date_set_api_delegate>(Module, "efl_ui_calendar_date_set");
 809
 810         private static bool date_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct date)
 811         {
 812             Eina.Log.Debug("function efl_ui_calendar_date_set was called");
 813             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 814             if (wrapper != null)
 815             {
 816         Efl.Time _in_date = date;
 817                             bool _ret_var = default(bool);
 818                 try
 819                 {
 820                     _ret_var = ((Calendar)wrapper).SetDate(_in_date);
 821                 }
 822                 catch (Exception e)
 823                 {
 824                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 825                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 826                 }
 827
 828                         return _ret_var;
 829
 830             }
 831             else
 832             {
 833                 return efl_ui_calendar_date_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), date);
 834             }
 835         }
 836
 837         private static efl_ui_calendar_date_set_delegate efl_ui_calendar_date_set_static_delegate;
 838
 839
 840         private delegate void efl_ui_format_cb_set_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb);
 841
 842
 843         public delegate void efl_ui_format_cb_set_api_delegate(System.IntPtr obj,  IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb);
 844
 845         public static Efl.Eo.FunctionWrapper<efl_ui_format_cb_set_api_delegate> efl_ui_format_cb_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_cb_set_api_delegate>(Module, "efl_ui_format_cb_set");
 846
 847         private static void format_cb_set(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb)
 848         {
 849             Eina.Log.Debug("function efl_ui_format_cb_set was called");
 850             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 851             if (wrapper != null)
 852             {
 853                             Efl.Ui.FormatFuncCbWrapper func_wrapper = new Efl.Ui.FormatFuncCbWrapper(func, func_data, func_free_cb);
 854
 855                 try
 856                 {
 857                     ((Calendar)wrapper).SetFormatCb(func_wrapper.ManagedCb);
 858                 }
 859                 catch (Exception e)
 860                 {
 861                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 862                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 863                 }
 864
 865
 866             }
 867             else
 868             {
 869                 efl_ui_format_cb_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
 870             }
 871         }
 872
 873         private static efl_ui_format_cb_set_delegate efl_ui_format_cb_set_static_delegate;
 874
 875         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 876         private delegate System.String efl_ui_format_string_get_delegate(System.IntPtr obj, System.IntPtr pd);
 877
 878         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 879         public delegate System.String efl_ui_format_string_get_api_delegate(System.IntPtr obj);
 880
 881         public static Efl.Eo.FunctionWrapper<efl_ui_format_string_get_api_delegate> efl_ui_format_string_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_string_get_api_delegate>(Module, "efl_ui_format_string_get");
 882
 883         private static System.String format_string_get(System.IntPtr obj, System.IntPtr pd)
 884         {
 885             Eina.Log.Debug("function efl_ui_format_string_get was called");
 886             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 887             if (wrapper != null)
 888             {
 889             System.String _ret_var = default(System.String);
 890                 try
 891                 {
 892                     _ret_var = ((Calendar)wrapper).GetFormatString();
 893                 }
 894                 catch (Exception e)
 895                 {
 896                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 897                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 898                 }
 899
 900         return _ret_var;
 901
 902             }
 903             else
 904             {
 905                 return efl_ui_format_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 906             }
 907         }
 908
 909         private static efl_ui_format_string_get_delegate efl_ui_format_string_get_static_delegate;
 910
 911
 912         private delegate void efl_ui_format_string_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String units);
 913
 914
 915         public delegate void efl_ui_format_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String units);
 916
 917         public static Efl.Eo.FunctionWrapper<efl_ui_format_string_set_api_delegate> efl_ui_format_string_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_string_set_api_delegate>(Module, "efl_ui_format_string_set");
 918
 919         private static void format_string_set(System.IntPtr obj, System.IntPtr pd, System.String units)
 920         {
 921             Eina.Log.Debug("function efl_ui_format_string_set was called");
 922             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 923             if (wrapper != null)
 924             {
 925
 926                 try
 927                 {
 928                     ((Calendar)wrapper).SetFormatString(units);
 929                 }
 930                 catch (Exception e)
 931                 {
 932                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 933                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 934                 }
 935
 936
 937             }
 938             else
 939             {
 940                 efl_ui_format_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), units);
 941             }
 942         }
 943
 944         private static efl_ui_format_string_set_delegate efl_ui_format_string_set_static_delegate;
 945
 946
 947         private delegate System.IntPtr efl_ui_focus_composition_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
 948
 949
 950         public delegate System.IntPtr efl_ui_focus_composition_elements_get_api_delegate(System.IntPtr obj);
 951
 952         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_get_api_delegate> efl_ui_focus_composition_elements_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_get_api_delegate>(Module, "efl_ui_focus_composition_elements_get");
 953
 954         private static System.IntPtr composition_elements_get(System.IntPtr obj, System.IntPtr pd)
 955         {
 956             Eina.Log.Debug("function efl_ui_focus_composition_elements_get was called");
 957             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 958             if (wrapper != null)
 959             {
 960             Eina.List<Efl.Gfx.IEntity> _ret_var = default(Eina.List<Efl.Gfx.IEntity>);
 961                 try
 962                 {
 963                     _ret_var = ((Calendar)wrapper).GetCompositionElements();
 964                 }
 965                 catch (Exception e)
 966                 {
 967                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 968                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 969                 }
 970
 971         _ret_var.Own = false; return _ret_var.Handle;
 972
 973             }
 974             else
 975             {
 976                 return efl_ui_focus_composition_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 977             }
 978         }
 979
 980         private static efl_ui_focus_composition_elements_get_delegate efl_ui_focus_composition_elements_get_static_delegate;
 981
 982
 983         private delegate void efl_ui_focus_composition_elements_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr logical_order);
 984
 985
 986         public delegate void efl_ui_focus_composition_elements_set_api_delegate(System.IntPtr obj,  System.IntPtr logical_order);
 987
 988         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_set_api_delegate> efl_ui_focus_composition_elements_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_elements_set_api_delegate>(Module, "efl_ui_focus_composition_elements_set");
 989
 990         private static void composition_elements_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr logical_order)
 991         {
 992             Eina.Log.Debug("function efl_ui_focus_composition_elements_set was called");
 993             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 994             if (wrapper != null)
 995             {
 996         var _in_logical_order = new Eina.List<Efl.Gfx.IEntity>(logical_order, true, false);
 997
 998                 try
 999                 {
1000                     ((Calendar)wrapper).SetCompositionElements(_in_logical_order);
1001                 }
1002                 catch (Exception e)
1003                 {
1004                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1005                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1006                 }
1007
1008
1009             }
1010             else
1011             {
1012                 efl_ui_focus_composition_elements_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), logical_order);
1013             }
1014         }
1015
1016         private static efl_ui_focus_composition_elements_set_delegate efl_ui_focus_composition_elements_set_static_delegate;
1017
1018         [return: MarshalAs(UnmanagedType.U1)]
1019         private delegate bool efl_ui_focus_composition_logical_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
1020
1021         [return: MarshalAs(UnmanagedType.U1)]
1022         public delegate bool efl_ui_focus_composition_logical_mode_get_api_delegate(System.IntPtr obj);
1023
1024         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_get_api_delegate> efl_ui_focus_composition_logical_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_get_api_delegate>(Module, "efl_ui_focus_composition_logical_mode_get");
1025
1026         private static bool logical_mode_get(System.IntPtr obj, System.IntPtr pd)
1027         {
1028             Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_get was called");
1029             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1030             if (wrapper != null)
1031             {
1032             bool _ret_var = default(bool);
1033                 try
1034                 {
1035                     _ret_var = ((Calendar)wrapper).GetLogicalMode();
1036                 }
1037                 catch (Exception e)
1038                 {
1039                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1040                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1041                 }
1042
1043         return _ret_var;
1044
1045             }
1046             else
1047             {
1048                 return efl_ui_focus_composition_logical_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1049             }
1050         }
1051
1052         private static efl_ui_focus_composition_logical_mode_get_delegate efl_ui_focus_composition_logical_mode_get_static_delegate;
1053
1054
1055         private delegate void efl_ui_focus_composition_logical_mode_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool logical_mode);
1056
1057
1058         public delegate void efl_ui_focus_composition_logical_mode_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool logical_mode);
1059
1060         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_set_api_delegate> efl_ui_focus_composition_logical_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_logical_mode_set_api_delegate>(Module, "efl_ui_focus_composition_logical_mode_set");
1061
1062         private static void logical_mode_set(System.IntPtr obj, System.IntPtr pd, bool logical_mode)
1063         {
1064             Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_set was called");
1065             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1066             if (wrapper != null)
1067             {
1068
1069                 try
1070                 {
1071                     ((Calendar)wrapper).SetLogicalMode(logical_mode);
1072                 }
1073                 catch (Exception e)
1074                 {
1075                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1076                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1077                 }
1078
1079
1080             }
1081             else
1082             {
1083                 efl_ui_focus_composition_logical_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), logical_mode);
1084             }
1085         }
1086
1087         private static efl_ui_focus_composition_logical_mode_set_delegate efl_ui_focus_composition_logical_mode_set_static_delegate;
1088
1089
1090         private delegate void efl_ui_focus_composition_dirty_delegate(System.IntPtr obj, System.IntPtr pd);
1091
1092
1093         public delegate void efl_ui_focus_composition_dirty_api_delegate(System.IntPtr obj);
1094
1095         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_dirty_api_delegate> efl_ui_focus_composition_dirty_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_dirty_api_delegate>(Module, "efl_ui_focus_composition_dirty");
1096
1097         private static void dirty(System.IntPtr obj, System.IntPtr pd)
1098         {
1099             Eina.Log.Debug("function efl_ui_focus_composition_dirty was called");
1100             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1101             if (wrapper != null)
1102             {
1103
1104                 try
1105                 {
1106                     ((Calendar)wrapper).Dirty();
1107                 }
1108                 catch (Exception e)
1109                 {
1110                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1111                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1112                 }
1113
1114
1115             }
1116             else
1117             {
1118                 efl_ui_focus_composition_dirty_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1119             }
1120         }
1121
1122         private static efl_ui_focus_composition_dirty_delegate efl_ui_focus_composition_dirty_static_delegate;
1123
1124
1125         private delegate void efl_ui_focus_composition_prepare_delegate(System.IntPtr obj, System.IntPtr pd);
1126
1127
1128         public delegate void efl_ui_focus_composition_prepare_api_delegate(System.IntPtr obj);
1129
1130         public static Efl.Eo.FunctionWrapper<efl_ui_focus_composition_prepare_api_delegate> efl_ui_focus_composition_prepare_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_composition_prepare_api_delegate>(Module, "efl_ui_focus_composition_prepare");
1131
1132         private static void prepare(System.IntPtr obj, System.IntPtr pd)
1133         {
1134             Eina.Log.Debug("function efl_ui_focus_composition_prepare was called");
1135             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1136             if (wrapper != null)
1137             {
1138
1139                 try
1140                 {
1141                     ((Calendar)wrapper).Prepare();
1142                 }
1143                 catch (Exception e)
1144                 {
1145                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1146                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1147                 }
1148
1149
1150             }
1151             else
1152             {
1153                 efl_ui_focus_composition_prepare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1154             }
1155         }
1156
1157         private static efl_ui_focus_composition_prepare_delegate efl_ui_focus_composition_prepare_static_delegate;
1158
1159         #pragma warning restore CA1707, SA1300, SA1600
1160
1161 }
1162 }
1163 }
1164
1165 }
1166
1167 namespace Efl {
1168
1169 namespace Ui {
1170
1171 /// <summary>A weekday
1172 /// See also <see cref="Efl.Ui.Calendar.SetFirstDayOfWeek"/>.</summary>
1173 public enum CalendarWeekday
1174 {
1175 /// <summary>Sunday weekday</summary>
1176 Sunday = 0,
1177 /// <summary>Monday weekday</summary>
1178 Monday = 1,
1179 /// <summary>Tuesday weekday</summary>
1180 Tuesday = 2,
1181 /// <summary>Wednesday weekday</summary>
1182 Wednesday = 3,
1183 /// <summary>Thursday weekday</summary>
1184 Thursday = 4,
1185 /// <summary>Friday weekday</summary>
1186 Friday = 5,
1187 /// <summary>Saturday weekday</summary>
1188 Saturday = 6,
1189 /// <summary>Sentinel value to indicate last enum field during iteration</summary>
1190 Last = 7,
1191 }
1192
1193 }
1194
1195 }
1196