internals/src/EflSharp/EflSharp/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.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>Calendar widget
   9 /// 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>
  10 [CalendarNativeInherit]
  11 public class Calendar : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.Ui.Format,Efl.Ui.Focus.Composition
  12 {
  13    public new static System.IntPtr klass = System.IntPtr.Zero;
  14    public new static Efl.Ui.CalendarNativeInherit nativeInherit = new Efl.Ui.CalendarNativeInherit();
  15    ///<summary>Pointer to the native class description.</summary>
  16    public override System.IntPtr NativeClass {
  17       get {
  18          if (((object)this).GetType() == typeof (Calendar))
  19             return Efl.Ui.CalendarNativeInherit.GetEflClassStatic();
  20          else
  21             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  22       }
  23    }
  24    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  25       efl_ui_calendar_class_get();
  26    ///<summary>Creates a new instance.</summary>
  27    ///<param name="parent">Parent instance.</param>
  28    ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  29    public Calendar(Efl.Object parent
  30          ,  System.String style = null) :
  31       base(efl_ui_calendar_class_get(), typeof(Calendar), parent)
  32    {
  33       if (Efl.Eo.Globals.ParamHelperCheck(style))
  34          SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  35       FinishInstantiation();
  36    }
  37    ///<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>
  38    public Calendar(System.IntPtr raw) : base(raw)
  39    {
  40             register_event_proxies();
  41    }
  42    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  43    protected Calendar(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  44    ///<summary>Casts obj into an instance of this type.</summary>
  45    public new static Calendar static_cast(Efl.Object obj)
  46    {
  47       if (obj == null)
  48          throw new System.ArgumentNullException("obj");
  49       return new Calendar(obj.NativeHandle);
  50    }
  51    ///<summary>Verifies if the given object is equal to this one.</summary>
  52    public override bool Equals(object obj)
  53    {
  54       var other = obj as Efl.Object;
  55       if (other == null)
  56          return false;
  57       return this.NativeHandle == other.NativeHandle;
  58    }
  59    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  60    public override int GetHashCode()
  61    {
  62       return this.NativeHandle.ToInt32();
  63    }
  64    ///<summary>Turns the native pointer into a string representation.</summary>
  65    public override String ToString()
  66    {
  67       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  68    }
  69 private static object ChangedEvtKey = new object();
  70    /// <summary>Emitted when the selected date in the calendar is changed</summary>
  71    public event EventHandler ChangedEvt
  72    {
  73       add {
  74          lock (eventLock) {
  75             string key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
  76             if (add_cpp_event_handler(efl.Libs.Elementary, key, this.evt_ChangedEvt_delegate)) {
  77                eventHandlers.AddHandler(ChangedEvtKey , value);
  78             } else
  79                Eina.Log.Error($"Error adding proxy for event {key}");
  80          }
  81       }
  82       remove {
  83          lock (eventLock) {
  84             string key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
  85             if (remove_cpp_event_handler(key, this.evt_ChangedEvt_delegate)) {
  86                eventHandlers.RemoveHandler(ChangedEvtKey , value);
  87             } else
  88                Eina.Log.Error($"Error removing proxy for event {key}");
  89          }
  90       }
  91    }
  92    ///<summary>Method to raise event ChangedEvt.</summary>
  93    public void On_ChangedEvt(EventArgs e)
  94    {
  95       EventHandler evt;
  96       lock (eventLock) {
  97       evt = (EventHandler)eventHandlers[ChangedEvtKey];
  98       }
  99       evt?.Invoke(this, e);
 100    }
 101    Efl.EventCb evt_ChangedEvt_delegate;
 102    private void on_ChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 103    {
 104       EventArgs args = EventArgs.Empty;
 105       try {
 106          On_ChangedEvt(args);
 107       } catch (Exception e) {
 108          Eina.Log.Error(e.ToString());
 109          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 110       }
 111    }
 112
 113    protected override void register_event_proxies()
 114    {
 115       base.register_event_proxies();
 116       evt_ChangedEvt_delegate = new Efl.EventCb(on_ChangedEvt_NativeCallback);
 117    }
 118    /// <summary>The first day of week to use on calendar widgets.
 119    /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 120    /// <returns>The first day of the week.</returns>
 121    virtual public Efl.Ui.CalendarWeekday GetFirstDayOfWeek() {
 122        var _ret_var = Efl.Ui.CalendarNativeInherit.efl_ui_calendar_first_day_of_week_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 123       Eina.Error.RaiseIfUnhandledException();
 124       return _ret_var;
 125  }
 126    /// <summary>The first day of week to use on calendar widgets.
 127    /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 128    /// <param name="day">The first day of the week.</param>
 129    /// <returns></returns>
 130    virtual public  void SetFirstDayOfWeek( Efl.Ui.CalendarWeekday day) {
 131                          Efl.Ui.CalendarNativeInherit.efl_ui_calendar_first_day_of_week_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), day);
 132       Eina.Error.RaiseIfUnhandledException();
 133                    }
 134    /// <summary>Get the minimum date.
 135    /// Default value is 1 JAN,1902.</summary>
 136    /// <returns>Time structure containing the minimum date.</returns>
 137    virtual public Efl.Time GetDateMin() {
 138        var _ret_var = Efl.Ui.CalendarNativeInherit.efl_ui_calendar_date_min_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 139       Eina.Error.RaiseIfUnhandledException();
 140       return Efl.Time_StructConversion.ToManaged(_ret_var);
 141  }
 142    /// <summary>Set the minimum date on calendar.
 143    /// 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>
 144    /// <param name="min">Time structure containing the minimum date.</param>
 145    /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 146    virtual public bool SetDateMin( Efl.Time min) {
 147        var _in_min = Efl.Time_StructConversion.ToInternal(min);
 148                   var _ret_var = Efl.Ui.CalendarNativeInherit.efl_ui_calendar_date_min_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_min);
 149       Eina.Error.RaiseIfUnhandledException();
 150                   return _ret_var;
 151  }
 152    /// <summary>Get the maximum date.
 153    /// Default maximum year is -1. Default maximum day and month are 31 and DEC.
 154    ///
 155    /// If the maximum year is a negative value, it will be limited depending on the platform architecture (year 2037 for 32 bits);</summary>
 156    /// <returns>Time structure containing the maximum date.</returns>
 157    virtual public Efl.Time GetDateMax() {
 158        var _ret_var = Efl.Ui.CalendarNativeInherit.efl_ui_calendar_date_max_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 159       Eina.Error.RaiseIfUnhandledException();
 160       return Efl.Time_StructConversion.ToManaged(_ret_var);
 161  }
 162    /// <summary>Set the maximum date on calendar.
 163    /// 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>
 164    /// <param name="max">Time structure containing the maximum date.</param>
 165    /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 166    virtual public bool SetDateMax( Efl.Time max) {
 167        var _in_max = Efl.Time_StructConversion.ToInternal(max);
 168                   var _ret_var = Efl.Ui.CalendarNativeInherit.efl_ui_calendar_date_max_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_max);
 169       Eina.Error.RaiseIfUnhandledException();
 170                   return _ret_var;
 171  }
 172    /// <summary>The selected date on calendar.</summary>
 173    /// <returns>Time structure containing the selected date.</returns>
 174    virtual public Efl.Time GetDate() {
 175        var _ret_var = Efl.Ui.CalendarNativeInherit.efl_ui_calendar_date_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 176       Eina.Error.RaiseIfUnhandledException();
 177       return Efl.Time_StructConversion.ToManaged(_ret_var);
 178  }
 179    /// <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>
 180    /// <param name="date">Time structure containing the selected date.</param>
 181    /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 182    virtual public bool SetDate( Efl.Time date) {
 183        var _in_date = Efl.Time_StructConversion.ToInternal(date);
 184                   var _ret_var = Efl.Ui.CalendarNativeInherit.efl_ui_calendar_date_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_date);
 185       Eina.Error.RaiseIfUnhandledException();
 186                   return _ret_var;
 187  }
 188    /// <summary>Set the format function pointer to format the string.</summary>
 189    /// <param name="func">The format function callback</param>
 190    /// <returns></returns>
 191    virtual public  void SetFormatCb( Efl.Ui.FormatFuncCb func) {
 192                    GCHandle func_handle = GCHandle.Alloc(func);
 193       Efl.Ui.FormatNativeInherit.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);
 194       Eina.Error.RaiseIfUnhandledException();
 195                    }
 196    /// <summary>Control the format string for a given units label
 197    /// 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.
 198    ///
 199    /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 200    /// <returns>The format string for <c>obj</c>&apos;s units label.</returns>
 201    virtual public  System.String GetFormatString() {
 202        var _ret_var = Efl.Ui.FormatNativeInherit.efl_ui_format_string_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 203       Eina.Error.RaiseIfUnhandledException();
 204       return _ret_var;
 205  }
 206    /// <summary>Control the format string for a given units label
 207    /// 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.
 208    ///
 209    /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 210    /// <param name="units">The format string for <c>obj</c>&apos;s units label.</param>
 211    /// <returns></returns>
 212    virtual public  void SetFormatString(  System.String units) {
 213                          Efl.Ui.FormatNativeInherit.efl_ui_format_string_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), units);
 214       Eina.Error.RaiseIfUnhandledException();
 215                    }
 216    /// <summary>Set the order of elements that will be used for composition
 217    /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 218    ///
 219    /// 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.
 220    ///
 221    /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 222    ///
 223    /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 224    /// <returns>The order to use</returns>
 225    virtual public Eina.List<Efl.Gfx.Entity> GetCompositionElements() {
 226        var _ret_var = Efl.Ui.Focus.CompositionNativeInherit.efl_ui_focus_composition_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 227       Eina.Error.RaiseIfUnhandledException();
 228       return new Eina.List<Efl.Gfx.Entity>(_ret_var, true, false);
 229  }
 230    /// <summary>Set the order of elements that will be used for composition
 231    /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 232    ///
 233    /// 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.
 234    ///
 235    /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 236    ///
 237    /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 238    /// <param name="logical_order">The order to use</param>
 239    /// <returns></returns>
 240    virtual public  void SetCompositionElements( Eina.List<Efl.Gfx.Entity> logical_order) {
 241        var _in_logical_order = logical_order.Handle;
 242 logical_order.Own = false;
 243                   Efl.Ui.Focus.CompositionNativeInherit.efl_ui_focus_composition_elements_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_logical_order);
 244       Eina.Error.RaiseIfUnhandledException();
 245                    }
 246    /// <summary>Set to true if all children should be registered as logicals</summary>
 247    /// <returns><c>true</c> or <c>false</c></returns>
 248    virtual public bool GetLogicalMode() {
 249        var _ret_var = Efl.Ui.Focus.CompositionNativeInherit.efl_ui_focus_composition_logical_mode_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>Set to true if all children should be registered as logicals</summary>
 254    /// <param name="logical_mode"><c>true</c> or <c>false</c></param>
 255    /// <returns></returns>
 256    virtual public  void SetLogicalMode( bool logical_mode) {
 257                          Efl.Ui.Focus.CompositionNativeInherit.efl_ui_focus_composition_logical_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), logical_mode);
 258       Eina.Error.RaiseIfUnhandledException();
 259                    }
 260    /// <summary>Mark this widget as dirty, the children can be considered to be changed after that call</summary>
 261    /// <returns></returns>
 262    virtual public  void Dirty() {
 263        Efl.Ui.Focus.CompositionNativeInherit.efl_ui_focus_composition_dirty_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 264       Eina.Error.RaiseIfUnhandledException();
 265        }
 266    /// <summary>A call to prepare the children of this element, called if marked as dirty
 267    /// You can use this function to call composition_elements.</summary>
 268    /// <returns></returns>
 269    virtual public  void Prepare() {
 270        Efl.Ui.Focus.CompositionNativeInherit.efl_ui_focus_composition_prepare_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 271       Eina.Error.RaiseIfUnhandledException();
 272        }
 273    /// <summary>The first day of week to use on calendar widgets.
 274 /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 275 /// <value>The first day of the week.</value>
 276    public Efl.Ui.CalendarWeekday FirstDayOfWeek {
 277       get { return GetFirstDayOfWeek(); }
 278       set { SetFirstDayOfWeek( value); }
 279    }
 280    /// <summary>Minimum date on calendar.</summary>
 281 /// <value>Time structure containing the minimum date.</value>
 282    public Efl.Time DateMin {
 283       get { return GetDateMin(); }
 284       set { SetDateMin( value); }
 285    }
 286    /// <summary>Maximum date on calendar.</summary>
 287 /// <value>Time structure containing the maximum date.</value>
 288    public Efl.Time DateMax {
 289       get { return GetDateMax(); }
 290       set { SetDateMax( value); }
 291    }
 292    /// <summary>The selected date on calendar.</summary>
 293 /// <value>Time structure containing the selected date.</value>
 294    public Efl.Time Date {
 295       get { return GetDate(); }
 296       set { SetDate( value); }
 297    }
 298    /// <summary>Set the format function pointer to format the string.</summary>
 299 /// <value>The format function callback</value>
 300    public Efl.Ui.FormatFuncCb FormatCb {
 301       set { SetFormatCb( value); }
 302    }
 303    /// <summary>Control the format string for a given units label
 304 /// 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.
 305 ///
 306 /// Note: The default format string is an integer percentage, as in $&quot;%.0f %%&quot;.</summary>
 307 /// <value>The format string for <c>obj</c>&apos;s units label.</value>
 308    public  System.String FormatString {
 309       get { return GetFormatString(); }
 310       set { SetFormatString( value); }
 311    }
 312    /// <summary>Set the order of elements that will be used for composition
 313 /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 314 ///
 315 /// 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.
 316 ///
 317 /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 318 ///
 319 /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 320 /// <value>The order to use</value>
 321    public Eina.List<Efl.Gfx.Entity> CompositionElements {
 322       get { return GetCompositionElements(); }
 323       set { SetCompositionElements( value); }
 324    }
 325    /// <summary>Set to true if all children should be registered as logicals</summary>
 326 /// <value><c>true</c> or <c>false</c></value>
 327    public bool LogicalMode {
 328       get { return GetLogicalMode(); }
 329       set { SetLogicalMode( value); }
 330    }
 331    private static new  IntPtr GetEflClassStatic()
 332    {
 333       return Efl.Ui.Calendar.efl_ui_calendar_class_get();
 334    }
 335 }
 336 public class CalendarNativeInherit : Efl.Ui.LayoutBaseNativeInherit{
 337    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 338    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 339    {
 340       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 341       if (efl_ui_calendar_first_day_of_week_get_static_delegate == null)
 342       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);
 343       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)});
 344       if (efl_ui_calendar_first_day_of_week_set_static_delegate == null)
 345       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);
 346       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)});
 347       if (efl_ui_calendar_date_min_get_static_delegate == null)
 348       efl_ui_calendar_date_min_get_static_delegate = new efl_ui_calendar_date_min_get_delegate(date_min_get);
 349       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)});
 350       if (efl_ui_calendar_date_min_set_static_delegate == null)
 351       efl_ui_calendar_date_min_set_static_delegate = new efl_ui_calendar_date_min_set_delegate(date_min_set);
 352       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)});
 353       if (efl_ui_calendar_date_max_get_static_delegate == null)
 354       efl_ui_calendar_date_max_get_static_delegate = new efl_ui_calendar_date_max_get_delegate(date_max_get);
 355       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)});
 356       if (efl_ui_calendar_date_max_set_static_delegate == null)
 357       efl_ui_calendar_date_max_set_static_delegate = new efl_ui_calendar_date_max_set_delegate(date_max_set);
 358       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)});
 359       if (efl_ui_calendar_date_get_static_delegate == null)
 360       efl_ui_calendar_date_get_static_delegate = new efl_ui_calendar_date_get_delegate(date_get);
 361       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)});
 362       if (efl_ui_calendar_date_set_static_delegate == null)
 363       efl_ui_calendar_date_set_static_delegate = new efl_ui_calendar_date_set_delegate(date_set);
 364       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)});
 365       if (efl_ui_format_cb_set_static_delegate == null)
 366       efl_ui_format_cb_set_static_delegate = new efl_ui_format_cb_set_delegate(format_cb_set);
 367       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)});
 368       if (efl_ui_format_string_get_static_delegate == null)
 369       efl_ui_format_string_get_static_delegate = new efl_ui_format_string_get_delegate(format_string_get);
 370       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)});
 371       if (efl_ui_format_string_set_static_delegate == null)
 372       efl_ui_format_string_set_static_delegate = new efl_ui_format_string_set_delegate(format_string_set);
 373       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)});
 374       if (efl_ui_focus_composition_elements_get_static_delegate == null)
 375       efl_ui_focus_composition_elements_get_static_delegate = new efl_ui_focus_composition_elements_get_delegate(composition_elements_get);
 376       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)});
 377       if (efl_ui_focus_composition_elements_set_static_delegate == null)
 378       efl_ui_focus_composition_elements_set_static_delegate = new efl_ui_focus_composition_elements_set_delegate(composition_elements_set);
 379       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)});
 380       if (efl_ui_focus_composition_logical_mode_get_static_delegate == null)
 381       efl_ui_focus_composition_logical_mode_get_static_delegate = new efl_ui_focus_composition_logical_mode_get_delegate(logical_mode_get);
 382       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)});
 383       if (efl_ui_focus_composition_logical_mode_set_static_delegate == null)
 384       efl_ui_focus_composition_logical_mode_set_static_delegate = new efl_ui_focus_composition_logical_mode_set_delegate(logical_mode_set);
 385       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)});
 386       if (efl_ui_focus_composition_dirty_static_delegate == null)
 387       efl_ui_focus_composition_dirty_static_delegate = new efl_ui_focus_composition_dirty_delegate(dirty);
 388       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)});
 389       if (efl_ui_focus_composition_prepare_static_delegate == null)
 390       efl_ui_focus_composition_prepare_static_delegate = new efl_ui_focus_composition_prepare_delegate(prepare);
 391       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)});
 392       descs.AddRange(base.GetEoOps(type));
 393       return descs;
 394    }
 395    public override IntPtr GetEflClass()
 396    {
 397       return Efl.Ui.Calendar.efl_ui_calendar_class_get();
 398    }
 399    public static new  IntPtr GetEflClassStatic()
 400    {
 401       return Efl.Ui.Calendar.efl_ui_calendar_class_get();
 402    }
 403
 404
 405     private delegate Efl.Ui.CalendarWeekday efl_ui_calendar_first_day_of_week_get_delegate(System.IntPtr obj, System.IntPtr pd);
 406
 407
 408     public delegate Efl.Ui.CalendarWeekday efl_ui_calendar_first_day_of_week_get_api_delegate(System.IntPtr obj);
 409     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");
 410     private static Efl.Ui.CalendarWeekday first_day_of_week_get(System.IntPtr obj, System.IntPtr pd)
 411    {
 412       Eina.Log.Debug("function efl_ui_calendar_first_day_of_week_get was called");
 413       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 414       if(wrapper != null) {
 415                   Efl.Ui.CalendarWeekday _ret_var = default(Efl.Ui.CalendarWeekday);
 416          try {
 417             _ret_var = ((Calendar)wrapper).GetFirstDayOfWeek();
 418          } catch (Exception e) {
 419             Eina.Log.Warning($"Callback error: {e.ToString()}");
 420             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 421          }
 422       return _ret_var;
 423       } else {
 424          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)));
 425       }
 426    }
 427    private static efl_ui_calendar_first_day_of_week_get_delegate efl_ui_calendar_first_day_of_week_get_static_delegate;
 428
 429
 430     private delegate  void efl_ui_calendar_first_day_of_week_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.CalendarWeekday day);
 431
 432
 433     public delegate  void efl_ui_calendar_first_day_of_week_set_api_delegate(System.IntPtr obj,   Efl.Ui.CalendarWeekday day);
 434     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");
 435     private static  void first_day_of_week_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.CalendarWeekday day)
 436    {
 437       Eina.Log.Debug("function efl_ui_calendar_first_day_of_week_set was called");
 438       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 439       if(wrapper != null) {
 440
 441          try {
 442             ((Calendar)wrapper).SetFirstDayOfWeek( day);
 443          } catch (Exception e) {
 444             Eina.Log.Warning($"Callback error: {e.ToString()}");
 445             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 446          }
 447                         } else {
 448          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);
 449       }
 450    }
 451    private static efl_ui_calendar_first_day_of_week_set_delegate efl_ui_calendar_first_day_of_week_set_static_delegate;
 452
 453
 454     private delegate Efl.Time_StructInternal efl_ui_calendar_date_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 455
 456
 457     public delegate Efl.Time_StructInternal efl_ui_calendar_date_min_get_api_delegate(System.IntPtr obj);
 458     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");
 459     private static Efl.Time_StructInternal date_min_get(System.IntPtr obj, System.IntPtr pd)
 460    {
 461       Eina.Log.Debug("function efl_ui_calendar_date_min_get was called");
 462       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 463       if(wrapper != null) {
 464                   Efl.Time _ret_var = default(Efl.Time);
 465          try {
 466             _ret_var = ((Calendar)wrapper).GetDateMin();
 467          } catch (Exception e) {
 468             Eina.Log.Warning($"Callback error: {e.ToString()}");
 469             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 470          }
 471       return Efl.Time_StructConversion.ToInternal(_ret_var);
 472       } else {
 473          return efl_ui_calendar_date_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 474       }
 475    }
 476    private static efl_ui_calendar_date_min_get_delegate efl_ui_calendar_date_min_get_static_delegate;
 477
 478
 479     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_calendar_date_min_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Time_StructInternal min);
 480
 481
 482     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_calendar_date_min_set_api_delegate(System.IntPtr obj,   Efl.Time_StructInternal min);
 483     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");
 484     private static bool date_min_set(System.IntPtr obj, System.IntPtr pd,  Efl.Time_StructInternal min)
 485    {
 486       Eina.Log.Debug("function efl_ui_calendar_date_min_set was called");
 487       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 488       if(wrapper != null) {
 489                var _in_min = Efl.Time_StructConversion.ToManaged(min);
 490                      bool _ret_var = default(bool);
 491          try {
 492             _ret_var = ((Calendar)wrapper).SetDateMin( _in_min);
 493          } catch (Exception e) {
 494             Eina.Log.Warning($"Callback error: {e.ToString()}");
 495             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 496          }
 497                   return _ret_var;
 498       } else {
 499          return efl_ui_calendar_date_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  min);
 500       }
 501    }
 502    private static efl_ui_calendar_date_min_set_delegate efl_ui_calendar_date_min_set_static_delegate;
 503
 504
 505     private delegate Efl.Time_StructInternal efl_ui_calendar_date_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 506
 507
 508     public delegate Efl.Time_StructInternal efl_ui_calendar_date_max_get_api_delegate(System.IntPtr obj);
 509     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");
 510     private static Efl.Time_StructInternal date_max_get(System.IntPtr obj, System.IntPtr pd)
 511    {
 512       Eina.Log.Debug("function efl_ui_calendar_date_max_get was called");
 513       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 514       if(wrapper != null) {
 515                   Efl.Time _ret_var = default(Efl.Time);
 516          try {
 517             _ret_var = ((Calendar)wrapper).GetDateMax();
 518          } catch (Exception e) {
 519             Eina.Log.Warning($"Callback error: {e.ToString()}");
 520             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 521          }
 522       return Efl.Time_StructConversion.ToInternal(_ret_var);
 523       } else {
 524          return efl_ui_calendar_date_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 525       }
 526    }
 527    private static efl_ui_calendar_date_max_get_delegate efl_ui_calendar_date_max_get_static_delegate;
 528
 529
 530     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_calendar_date_max_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Time_StructInternal max);
 531
 532
 533     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_calendar_date_max_set_api_delegate(System.IntPtr obj,   Efl.Time_StructInternal max);
 534     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");
 535     private static bool date_max_set(System.IntPtr obj, System.IntPtr pd,  Efl.Time_StructInternal max)
 536    {
 537       Eina.Log.Debug("function efl_ui_calendar_date_max_set was called");
 538       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 539       if(wrapper != null) {
 540                var _in_max = Efl.Time_StructConversion.ToManaged(max);
 541                      bool _ret_var = default(bool);
 542          try {
 543             _ret_var = ((Calendar)wrapper).SetDateMax( _in_max);
 544          } catch (Exception e) {
 545             Eina.Log.Warning($"Callback error: {e.ToString()}");
 546             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 547          }
 548                   return _ret_var;
 549       } else {
 550          return efl_ui_calendar_date_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  max);
 551       }
 552    }
 553    private static efl_ui_calendar_date_max_set_delegate efl_ui_calendar_date_max_set_static_delegate;
 554
 555
 556     private delegate Efl.Time_StructInternal efl_ui_calendar_date_get_delegate(System.IntPtr obj, System.IntPtr pd);
 557
 558
 559     public delegate Efl.Time_StructInternal efl_ui_calendar_date_get_api_delegate(System.IntPtr obj);
 560     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");
 561     private static Efl.Time_StructInternal date_get(System.IntPtr obj, System.IntPtr pd)
 562    {
 563       Eina.Log.Debug("function efl_ui_calendar_date_get was called");
 564       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 565       if(wrapper != null) {
 566                   Efl.Time _ret_var = default(Efl.Time);
 567          try {
 568             _ret_var = ((Calendar)wrapper).GetDate();
 569          } catch (Exception e) {
 570             Eina.Log.Warning($"Callback error: {e.ToString()}");
 571             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 572          }
 573       return Efl.Time_StructConversion.ToInternal(_ret_var);
 574       } else {
 575          return efl_ui_calendar_date_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 576       }
 577    }
 578    private static efl_ui_calendar_date_get_delegate efl_ui_calendar_date_get_static_delegate;
 579
 580
 581     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_calendar_date_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Time_StructInternal date);
 582
 583
 584     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_calendar_date_set_api_delegate(System.IntPtr obj,   Efl.Time_StructInternal date);
 585     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");
 586     private static bool date_set(System.IntPtr obj, System.IntPtr pd,  Efl.Time_StructInternal date)
 587    {
 588       Eina.Log.Debug("function efl_ui_calendar_date_set was called");
 589       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 590       if(wrapper != null) {
 591                var _in_date = Efl.Time_StructConversion.ToManaged(date);
 592                      bool _ret_var = default(bool);
 593          try {
 594             _ret_var = ((Calendar)wrapper).SetDate( _in_date);
 595          } catch (Exception e) {
 596             Eina.Log.Warning($"Callback error: {e.ToString()}");
 597             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 598          }
 599                   return _ret_var;
 600       } else {
 601          return efl_ui_calendar_date_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  date);
 602       }
 603    }
 604    private static efl_ui_calendar_date_set_delegate efl_ui_calendar_date_set_static_delegate;
 605
 606
 607     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);
 608
 609
 610     public delegate  void efl_ui_format_cb_set_api_delegate(System.IntPtr obj,  IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb);
 611     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");
 612     private static  void format_cb_set(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, Efl.Ui.FormatFuncCbInternal func, EinaFreeCb func_free_cb)
 613    {
 614       Eina.Log.Debug("function efl_ui_format_cb_set was called");
 615       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 616       if(wrapper != null) {
 617                               Efl.Ui.FormatFuncCbWrapper func_wrapper = new Efl.Ui.FormatFuncCbWrapper(func, func_data, func_free_cb);
 618
 619          try {
 620             ((Calendar)wrapper).SetFormatCb( func_wrapper.ManagedCb);
 621          } catch (Exception e) {
 622             Eina.Log.Warning($"Callback error: {e.ToString()}");
 623             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 624          }
 625                         } else {
 626          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);
 627       }
 628    }
 629    private static efl_ui_format_cb_set_delegate efl_ui_format_cb_set_static_delegate;
 630
 631
 632     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_ui_format_string_get_delegate(System.IntPtr obj, System.IntPtr pd);
 633
 634
 635     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_ui_format_string_get_api_delegate(System.IntPtr obj);
 636     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");
 637     private static  System.String format_string_get(System.IntPtr obj, System.IntPtr pd)
 638    {
 639       Eina.Log.Debug("function efl_ui_format_string_get was called");
 640       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 641       if(wrapper != null) {
 642                    System.String _ret_var = default( System.String);
 643          try {
 644             _ret_var = ((Calendar)wrapper).GetFormatString();
 645          } catch (Exception e) {
 646             Eina.Log.Warning($"Callback error: {e.ToString()}");
 647             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 648          }
 649       return _ret_var;
 650       } else {
 651          return efl_ui_format_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 652       }
 653    }
 654    private static efl_ui_format_string_get_delegate efl_ui_format_string_get_static_delegate;
 655
 656
 657     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);
 658
 659
 660     public delegate  void efl_ui_format_string_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]   System.String units);
 661     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");
 662     private static  void format_string_set(System.IntPtr obj, System.IntPtr pd,   System.String units)
 663    {
 664       Eina.Log.Debug("function efl_ui_format_string_set was called");
 665       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 666       if(wrapper != null) {
 667
 668          try {
 669             ((Calendar)wrapper).SetFormatString( units);
 670          } catch (Exception e) {
 671             Eina.Log.Warning($"Callback error: {e.ToString()}");
 672             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 673          }
 674                         } else {
 675          efl_ui_format_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  units);
 676       }
 677    }
 678    private static efl_ui_format_string_set_delegate efl_ui_format_string_set_static_delegate;
 679
 680
 681     private delegate  System.IntPtr efl_ui_focus_composition_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
 682
 683
 684     public delegate  System.IntPtr efl_ui_focus_composition_elements_get_api_delegate(System.IntPtr obj);
 685     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");
 686     private static  System.IntPtr composition_elements_get(System.IntPtr obj, System.IntPtr pd)
 687    {
 688       Eina.Log.Debug("function efl_ui_focus_composition_elements_get was called");
 689       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 690       if(wrapper != null) {
 691                   Eina.List<Efl.Gfx.Entity> _ret_var = default(Eina.List<Efl.Gfx.Entity>);
 692          try {
 693             _ret_var = ((Calendar)wrapper).GetCompositionElements();
 694          } catch (Exception e) {
 695             Eina.Log.Warning($"Callback error: {e.ToString()}");
 696             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 697          }
 698       _ret_var.Own = false; return _ret_var.Handle;
 699       } else {
 700          return efl_ui_focus_composition_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 701       }
 702    }
 703    private static efl_ui_focus_composition_elements_get_delegate efl_ui_focus_composition_elements_get_static_delegate;
 704
 705
 706     private delegate  void efl_ui_focus_composition_elements_set_delegate(System.IntPtr obj, System.IntPtr pd,    System.IntPtr logical_order);
 707
 708
 709     public delegate  void efl_ui_focus_composition_elements_set_api_delegate(System.IntPtr obj,    System.IntPtr logical_order);
 710     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");
 711     private static  void composition_elements_set(System.IntPtr obj, System.IntPtr pd,   System.IntPtr logical_order)
 712    {
 713       Eina.Log.Debug("function efl_ui_focus_composition_elements_set was called");
 714       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 715       if(wrapper != null) {
 716                var _in_logical_order = new Eina.List<Efl.Gfx.Entity>(logical_order, true, false);
 717
 718          try {
 719             ((Calendar)wrapper).SetCompositionElements( _in_logical_order);
 720          } catch (Exception e) {
 721             Eina.Log.Warning($"Callback error: {e.ToString()}");
 722             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 723          }
 724                         } else {
 725          efl_ui_focus_composition_elements_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  logical_order);
 726       }
 727    }
 728    private static efl_ui_focus_composition_elements_set_delegate efl_ui_focus_composition_elements_set_static_delegate;
 729
 730
 731     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_focus_composition_logical_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 732
 733
 734     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_focus_composition_logical_mode_get_api_delegate(System.IntPtr obj);
 735     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");
 736     private static bool logical_mode_get(System.IntPtr obj, System.IntPtr pd)
 737    {
 738       Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_get was called");
 739       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 740       if(wrapper != null) {
 741                   bool _ret_var = default(bool);
 742          try {
 743             _ret_var = ((Calendar)wrapper).GetLogicalMode();
 744          } catch (Exception e) {
 745             Eina.Log.Warning($"Callback error: {e.ToString()}");
 746             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 747          }
 748       return _ret_var;
 749       } else {
 750          return efl_ui_focus_composition_logical_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 751       }
 752    }
 753    private static efl_ui_focus_composition_logical_mode_get_delegate efl_ui_focus_composition_logical_mode_get_static_delegate;
 754
 755
 756     private delegate  void efl_ui_focus_composition_logical_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool logical_mode);
 757
 758
 759     public delegate  void efl_ui_focus_composition_logical_mode_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool logical_mode);
 760     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");
 761     private static  void logical_mode_set(System.IntPtr obj, System.IntPtr pd,  bool logical_mode)
 762    {
 763       Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_set was called");
 764       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 765       if(wrapper != null) {
 766
 767          try {
 768             ((Calendar)wrapper).SetLogicalMode( logical_mode);
 769          } catch (Exception e) {
 770             Eina.Log.Warning($"Callback error: {e.ToString()}");
 771             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 772          }
 773                         } else {
 774          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);
 775       }
 776    }
 777    private static efl_ui_focus_composition_logical_mode_set_delegate efl_ui_focus_composition_logical_mode_set_static_delegate;
 778
 779
 780     private delegate  void efl_ui_focus_composition_dirty_delegate(System.IntPtr obj, System.IntPtr pd);
 781
 782
 783     public delegate  void efl_ui_focus_composition_dirty_api_delegate(System.IntPtr obj);
 784     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");
 785     private static  void dirty(System.IntPtr obj, System.IntPtr pd)
 786    {
 787       Eina.Log.Debug("function efl_ui_focus_composition_dirty was called");
 788       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 789       if(wrapper != null) {
 790
 791          try {
 792             ((Calendar)wrapper).Dirty();
 793          } catch (Exception e) {
 794             Eina.Log.Warning($"Callback error: {e.ToString()}");
 795             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 796          }
 797             } else {
 798          efl_ui_focus_composition_dirty_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 799       }
 800    }
 801    private static efl_ui_focus_composition_dirty_delegate efl_ui_focus_composition_dirty_static_delegate;
 802
 803
 804     private delegate  void efl_ui_focus_composition_prepare_delegate(System.IntPtr obj, System.IntPtr pd);
 805
 806
 807     public delegate  void efl_ui_focus_composition_prepare_api_delegate(System.IntPtr obj);
 808     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");
 809     private static  void prepare(System.IntPtr obj, System.IntPtr pd)
 810    {
 811       Eina.Log.Debug("function efl_ui_focus_composition_prepare was called");
 812       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 813       if(wrapper != null) {
 814
 815          try {
 816             ((Calendar)wrapper).Prepare();
 817          } catch (Exception e) {
 818             Eina.Log.Warning($"Callback error: {e.ToString()}");
 819             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 820          }
 821             } else {
 822          efl_ui_focus_composition_prepare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 823       }
 824    }
 825    private static efl_ui_focus_composition_prepare_delegate efl_ui_focus_composition_prepare_static_delegate;
 826 }
 827 } }
 828 namespace Efl { namespace Ui {
 829 /// <summary>A weekday
 830 /// See also <see cref="Efl.Ui.Calendar.SetFirstDayOfWeek"/>.</summary>
 831 public enum CalendarWeekday
 832 {
 833 /// <summary>Sunday weekday</summary>
 834 Sunday = 0,
 835 /// <summary>Monday weekday</summary>
 836 Monday = 1,
 837 /// <summary>Tuesday weekday</summary>
 838 Tuesday = 2,
 839 /// <summary>Wednesday weekday</summary>
 840 Wednesday = 3,
 841 /// <summary>Thursday weekday</summary>
 842 Thursday = 4,
 843 /// <summary>Friday weekday</summary>
 844 Friday = 5,
 845 /// <summary>Saturday weekday</summary>
 846 Saturday = 6,
 847 /// <summary>Sentinel value to indicate last enum field during iteration</summary>
 848 Last = 7,
 849 }
 850 } }