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 [Efl.Eo.BindingEntity]
  16 public class Calendar : Efl.Ui.LayoutBase, Efl.Ui.IFormat, Efl.Ui.Focus.IComposition
  17 {
  18     ///<summary>Pointer to the native class description.</summary>
  19     public override System.IntPtr NativeClass
  20     {
  21         get
  22         {
  23             if (((object)this).GetType() == typeof(Calendar))
  24             {
  25                 return GetEflClassStatic();
  26             }
  27             else
  28             {
  29                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  30             }
  31         }
  32     }
  33
  34     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  35         efl_ui_calendar_class_get();
  36     /// <summary>Initializes a new instance of the <see cref="Calendar"/> class.</summary>
  37     /// <param name="parent">Parent instance.</param>
  38     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  39     public Calendar(Efl.Object parent
  40             , System.String style = null) : base(efl_ui_calendar_class_get(), parent)
  41     {
  42         if (Efl.Eo.Globals.ParamHelperCheck(style))
  43         {
  44             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  45         }
  46
  47         FinishInstantiation();
  48     }
  49
  50     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  51     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  52     protected Calendar(ConstructingHandle ch) : base(ch)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="Calendar"/> class.
  57     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  58     /// <param name="wh">The native pointer to be wrapped.</param>
  59     protected Calendar(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  60     {
  61     }
  62
  63     /// <summary>Initializes a new instance of the <see cref="Calendar"/> class.
  64     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  65     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  66     /// <param name="parent">The Efl.Object parent of this instance.</param>
  67     protected Calendar(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  68     {
  69     }
  70
  71     /// <summary>Emitted when the selected date in the calendar is changed</summary>
  72     public event EventHandler ChangedEvt
  73     {
  74         add
  75         {
  76             lock (eflBindingEventLock)
  77             {
  78                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  79                 {
  80                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  81                     if (obj != null)
  82                     {
  83                         EventArgs args = EventArgs.Empty;
  84                         try
  85                         {
  86                             value?.Invoke(obj, args);
  87                         }
  88                         catch (Exception e)
  89                         {
  90                             Eina.Log.Error(e.ToString());
  91                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  92                         }
  93                     }
  94                 };
  95
  96                 string key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
  97                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  98             }
  99         }
 100
 101         remove
 102         {
 103             lock (eflBindingEventLock)
 104             {
 105                 string key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
 106                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 107             }
 108         }
 109     }
 110     ///<summary>Method to raise event ChangedEvt.</summary>
 111     public void OnChangedEvt(EventArgs e)
 112     {
 113         var key = "_EFL_UI_CALENDAR_EVENT_CHANGED";
 114         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 115         if (desc == IntPtr.Zero)
 116         {
 117             Eina.Log.Error($"Failed to get native event {key}");
 118             return;
 119         }
 120
 121         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 122     }
 123     /// <summary>The first day of week to use on calendar widgets.
 124     /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 125     /// <returns>The first day of the week.</returns>
 126     virtual public Efl.Ui.CalendarWeekday GetFirstDayOfWeek() {
 127          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_first_day_of_week_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 128         Eina.Error.RaiseIfUnhandledException();
 129         return _ret_var;
 130  }
 131     /// <summary>The first day of week to use on calendar widgets.
 132     /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 133     /// <param name="day">The first day of the week.</param>
 134     virtual public void SetFirstDayOfWeek(Efl.Ui.CalendarWeekday day) {
 135                                  Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_first_day_of_week_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),day);
 136         Eina.Error.RaiseIfUnhandledException();
 137                          }
 138     /// <summary>Get the minimum date.
 139     /// Default value is 1 JAN,1902.</summary>
 140     /// <returns>Time structure containing the minimum date.</returns>
 141     virtual public Efl.Time GetDateMin() {
 142          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_min_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 143         Eina.Error.RaiseIfUnhandledException();
 144         return _ret_var;
 145  }
 146     /// <summary>Set the minimum date on calendar.
 147     /// 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>
 148     /// <param name="min">Time structure containing the minimum date.</param>
 149     /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 150     virtual public bool SetDateMin(Efl.Time min) {
 151          Efl.Time.NativeStruct _in_min = min;
 152                         var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_min_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_min);
 153         Eina.Error.RaiseIfUnhandledException();
 154                         return _ret_var;
 155  }
 156     /// <summary>Get the maximum date.
 157     /// Default maximum year is -1. Default maximum day and month are 31 and DEC.
 158     ///
 159     /// If the maximum year is a negative value, it will be limited depending on the platform architecture (year 2037 for 32 bits);</summary>
 160     /// <returns>Time structure containing the maximum date.</returns>
 161     virtual public Efl.Time GetDateMax() {
 162          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_max_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 163         Eina.Error.RaiseIfUnhandledException();
 164         return _ret_var;
 165  }
 166     /// <summary>Set the maximum date on calendar.
 167     /// 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>
 168     /// <param name="max">Time structure containing the maximum date.</param>
 169     /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 170     virtual public bool SetDateMax(Efl.Time max) {
 171          Efl.Time.NativeStruct _in_max = max;
 172                         var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_max_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_max);
 173         Eina.Error.RaiseIfUnhandledException();
 174                         return _ret_var;
 175  }
 176     /// <summary>The selected date on calendar.</summary>
 177     /// <returns>Time structure containing the selected date.</returns>
 178     virtual public Efl.Time GetDate() {
 179          var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 180         Eina.Error.RaiseIfUnhandledException();
 181         return _ret_var;
 182  }
 183     /// <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>
 184     /// <param name="date">Time structure containing the selected date.</param>
 185     /// <returns><c>true</c>, on success, <c>false</c> otherwise</returns>
 186     virtual public bool SetDate(Efl.Time date) {
 187          Efl.Time.NativeStruct _in_date = date;
 188                         var _ret_var = Efl.Ui.Calendar.NativeMethods.efl_ui_calendar_date_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_date);
 189         Eina.Error.RaiseIfUnhandledException();
 190                         return _ret_var;
 191  }
 192     /// <summary>User-provided function which takes care of converting an <see cref="Eina.Value"/> into a text string. The user is then completely in control of how the string is generated, but it is the most cumbersome method to use. If the conversion fails the other mechanisms will be tried, according to their priorities.</summary>
 193     /// <returns>User-provided formatting function.</returns>
 194     virtual public Efl.Ui.FormatFunc GetFormatFunc() {
 195          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_func_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 196         Eina.Error.RaiseIfUnhandledException();
 197         return _ret_var;
 198  }
 199     /// <summary>User-provided function which takes care of converting an <see cref="Eina.Value"/> into a text string. The user is then completely in control of how the string is generated, but it is the most cumbersome method to use. If the conversion fails the other mechanisms will be tried, according to their priorities.</summary>
 200     /// <param name="func">User-provided formatting function.</param>
 201     virtual public void SetFormatFunc(Efl.Ui.FormatFunc func) {
 202                          GCHandle func_handle = GCHandle.Alloc(func);
 203         Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_func_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),GCHandle.ToIntPtr(func_handle), Efl.Ui.FormatFuncWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 204         Eina.Error.RaiseIfUnhandledException();
 205                          }
 206     /// <summary>User-provided list of values which are to be rendered using specific text strings. This is more convenient to use than <see cref="Efl.Ui.IFormat.FormatFunc"/> and is perfectly suited for cases where the strings make more sense than the numerical values. For example, weekday names (&quot;Monday&quot;, &quot;Tuesday&quot;, ...) are friendlier than numbers 1 to 7. If a value is not found in the list, the other mechanisms will be tried according to their priorities. List members do not need to be in any particular order. They are sorted internally for performance reasons.</summary>
 207     /// <returns>Accessor over a list of value-text pairs. The method will dispose of the accessor, but not of its contents. For convenience, Eina offers a range of helper methods to obtain accessors from Eina.Array, Eina.List or even plain C arrays.</returns>
 208     virtual public Eina.Accessor<Efl.Ui.FormatValue> GetFormatValues() {
 209          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_values_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 210         Eina.Error.RaiseIfUnhandledException();
 211         return new Eina.Accessor<Efl.Ui.FormatValue>(_ret_var, false);
 212  }
 213     /// <summary>User-provided list of values which are to be rendered using specific text strings. This is more convenient to use than <see cref="Efl.Ui.IFormat.FormatFunc"/> and is perfectly suited for cases where the strings make more sense than the numerical values. For example, weekday names (&quot;Monday&quot;, &quot;Tuesday&quot;, ...) are friendlier than numbers 1 to 7. If a value is not found in the list, the other mechanisms will be tried according to their priorities. List members do not need to be in any particular order. They are sorted internally for performance reasons.</summary>
 214     /// <param name="values">Accessor over a list of value-text pairs. The method will dispose of the accessor, but not of its contents. For convenience, Eina offers a range of helper methods to obtain accessors from Eina.Array, Eina.List or even plain C arrays.</param>
 215     virtual public void SetFormatValues(Eina.Accessor<Efl.Ui.FormatValue> values) {
 216          var _in_values = values.Handle;
 217                         Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_values_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_values);
 218         Eina.Error.RaiseIfUnhandledException();
 219                          }
 220     /// <summary>A user-provided, string used to format the numerical value.
 221     /// For example, &quot;%1.2f meters&quot;, &quot;%.0%%&quot; or &quot;%d items&quot;.
 222     ///
 223     /// This is the simplest formatting mechanism, working pretty much like <c>printf</c>.
 224     ///
 225     /// Different format specifiers (the character after the %) are available, depending on the <c>type</c> used. Use <see cref="Efl.Ui.FormatStringType.Simple"/> for simple numerical values and <see cref="Efl.Ui.FormatStringType.Time"/> for time and date values. For instance, %d means &quot;integer&quot; when the first type is used, but it means &quot;day of the month as a decimal number&quot; in the second.
 226     ///
 227     /// Pass <c>NULL</c> to disable this mechanism.</summary>
 228     /// <param name="kw_string">Formatting string containing regular characters and format specifiers.</param>
 229     /// <param name="type">Type of formatting string, which controls how the different format specifiers are to be traslated.</param>
 230     virtual public void GetFormatString(out System.String kw_string, out Efl.Ui.FormatStringType type) {
 231                                                          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out kw_string, out type);
 232         Eina.Error.RaiseIfUnhandledException();
 233                                          }
 234     /// <summary>A user-provided, string used to format the numerical value.
 235     /// For example, &quot;%1.2f meters&quot;, &quot;%.0%%&quot; or &quot;%d items&quot;.
 236     ///
 237     /// This is the simplest formatting mechanism, working pretty much like <c>printf</c>.
 238     ///
 239     /// Different format specifiers (the character after the %) are available, depending on the <c>type</c> used. Use <see cref="Efl.Ui.FormatStringType.Simple"/> for simple numerical values and <see cref="Efl.Ui.FormatStringType.Time"/> for time and date values. For instance, %d means &quot;integer&quot; when the first type is used, but it means &quot;day of the month as a decimal number&quot; in the second.
 240     ///
 241     /// Pass <c>NULL</c> to disable this mechanism.</summary>
 242     /// <param name="kw_string">Formatting string containing regular characters and format specifiers.</param>
 243     /// <param name="type">Type of formatting string, which controls how the different format specifiers are to be traslated.</param>
 244     virtual public void SetFormatString(System.String kw_string, Efl.Ui.FormatStringType type) {
 245                                                          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_string_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),kw_string, type);
 246         Eina.Error.RaiseIfUnhandledException();
 247                                          }
 248     /// <summary>Internal method to be used by widgets including this mixin to perform the conversion from the internal numerical value into the text representation (Users of these widgets do not need to call this method).
 249     /// <see cref="Efl.Ui.IFormat.GetFormattedValue"/> uses any user-provided mechanism to perform the conversion, according to their priorities, and implements a simple fallback if all mechanisms fail.</summary>
 250     /// <param name="str">Output formatted string. Its contents will be overwritten by this method.</param>
 251     /// <param name="value">The <see cref="Eina.Value"/> to convert to text.</param>
 252     virtual public void GetFormattedValue(Eina.Strbuf str, Eina.Value value) {
 253                                                          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_formatted_value_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),str, value);
 254         Eina.Error.RaiseIfUnhandledException();
 255                                          }
 256     /// <summary>Internal method to be used by widgets including this mixin. It can only be used when a <see cref="Efl.Ui.IFormat.GetFormatString"/> has been supplied, and it returns the number of decimal places that the format string will produce for floating point values.
 257     /// For example, &quot;%.2f&quot; returns 2, and &quot;%d&quot; returns 0;</summary>
 258     /// <returns>Number of decimal places, or 0 for non-floating point types.</returns>
 259     virtual public int GetDecimalPlaces() {
 260          var _ret_var = Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_decimal_places_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 261         Eina.Error.RaiseIfUnhandledException();
 262         return _ret_var;
 263  }
 264     /// <summary>Internal method to be implemented by widgets including this mixin.
 265     /// The mixin will call this method to signal the widget that the formatting has changed and therefore the current value should be converted and rendered again. Widgets must typically call <see cref="Efl.Ui.IFormat.GetFormattedValue"/> and display the returned string. This is something they are already doing (whenever the value changes, for example) so there should be no extra code written to implement this method.</summary>
 266     virtual public void ApplyFormattedValue() {
 267          Efl.Ui.IFormatConcrete.NativeMethods.efl_ui_format_apply_formatted_value_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 268         Eina.Error.RaiseIfUnhandledException();
 269          }
 270     /// <summary>Set the order of elements that will be used for composition
 271     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 272     ///
 273     /// 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.
 274     ///
 275     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 276     ///
 277     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 278     /// <returns>The order to use</returns>
 279     virtual public Eina.List<Efl.Gfx.IEntity> GetCompositionElements() {
 280          var _ret_var = Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_elements_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 281         Eina.Error.RaiseIfUnhandledException();
 282         return new Eina.List<Efl.Gfx.IEntity>(_ret_var, true, false);
 283  }
 284     /// <summary>Set the order of elements that will be used for composition
 285     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 286     ///
 287     /// 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.
 288     ///
 289     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 290     ///
 291     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 292     /// <param name="logical_order">The order to use</param>
 293     virtual public void SetCompositionElements(Eina.List<Efl.Gfx.IEntity> logical_order) {
 294          var _in_logical_order = logical_order.Handle;
 295 logical_order.Own = false;
 296                         Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_elements_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_logical_order);
 297         Eina.Error.RaiseIfUnhandledException();
 298                          }
 299     /// <summary>Set to true if all children should be registered as logicals</summary>
 300     /// <returns><c>true</c> or <c>false</c></returns>
 301     virtual public bool GetLogicalMode() {
 302          var _ret_var = Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_logical_mode_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 303         Eina.Error.RaiseIfUnhandledException();
 304         return _ret_var;
 305  }
 306     /// <summary>Set to true if all children should be registered as logicals</summary>
 307     /// <param name="logical_mode"><c>true</c> or <c>false</c></param>
 308     virtual public void SetLogicalMode(bool logical_mode) {
 309                                  Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_logical_mode_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),logical_mode);
 310         Eina.Error.RaiseIfUnhandledException();
 311                          }
 312     /// <summary>Mark this widget as dirty, the children can be considered to be changed after that call</summary>
 313     virtual public void Dirty() {
 314          Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_dirty_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 315         Eina.Error.RaiseIfUnhandledException();
 316          }
 317     /// <summary>A call to prepare the children of this element, called if marked as dirty
 318     /// You can use this function to call composition_elements.</summary>
 319     virtual public void Prepare() {
 320          Efl.Ui.Focus.ICompositionConcrete.NativeMethods.efl_ui_focus_composition_prepare_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 321         Eina.Error.RaiseIfUnhandledException();
 322          }
 323     /// <summary>The first day of week to use on calendar widgets.
 324     /// This is the day that will appear in the left-most column (eg. Monday in France or Sunday in the US).</summary>
 325     /// <value>The first day of the week.</value>
 326     public Efl.Ui.CalendarWeekday FirstDayOfWeek {
 327         get { return GetFirstDayOfWeek(); }
 328         set { SetFirstDayOfWeek(value); }
 329     }
 330     /// <summary>Minimum date on calendar.</summary>
 331     /// <value>Time structure containing the minimum date.</value>
 332     public Efl.Time DateMin {
 333         get { return GetDateMin(); }
 334         set { SetDateMin(value); }
 335     }
 336     /// <summary>Maximum date on calendar.</summary>
 337     /// <value>Time structure containing the maximum date.</value>
 338     public Efl.Time DateMax {
 339         get { return GetDateMax(); }
 340         set { SetDateMax(value); }
 341     }
 342     /// <summary>The selected date on calendar.</summary>
 343     /// <value>Time structure containing the selected date.</value>
 344     public Efl.Time Date {
 345         get { return GetDate(); }
 346         set { SetDate(value); }
 347     }
 348     /// <summary>User-provided function which takes care of converting an <see cref="Eina.Value"/> into a text string. The user is then completely in control of how the string is generated, but it is the most cumbersome method to use. If the conversion fails the other mechanisms will be tried, according to their priorities.</summary>
 349     /// <value>User-provided formatting function.</value>
 350     public Efl.Ui.FormatFunc FormatFunc {
 351         get { return GetFormatFunc(); }
 352         set { SetFormatFunc(value); }
 353     }
 354     /// <summary>User-provided list of values which are to be rendered using specific text strings. This is more convenient to use than <see cref="Efl.Ui.IFormat.FormatFunc"/> and is perfectly suited for cases where the strings make more sense than the numerical values. For example, weekday names (&quot;Monday&quot;, &quot;Tuesday&quot;, ...) are friendlier than numbers 1 to 7. If a value is not found in the list, the other mechanisms will be tried according to their priorities. List members do not need to be in any particular order. They are sorted internally for performance reasons.</summary>
 355     /// <value>Accessor over a list of value-text pairs. The method will dispose of the accessor, but not of its contents. For convenience, Eina offers a range of helper methods to obtain accessors from Eina.Array, Eina.List or even plain C arrays.</value>
 356     public Eina.Accessor<Efl.Ui.FormatValue> FormatValues {
 357         get { return GetFormatValues(); }
 358         set { SetFormatValues(value); }
 359     }
 360     /// <summary>Set the order of elements that will be used for composition
 361     /// Elements of the list can be either an Efl.Ui.Widget, an Efl.Ui.Focus.Object or an Efl.Gfx.
 362     ///
 363     /// 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.
 364     ///
 365     /// If the element is an Efl.Ui.Focus.Object, then the mixin will take care of registering the element.
 366     ///
 367     /// If the element is a Efl.Ui.Widget nothing is done and the widget is simply part of the order.</summary>
 368     /// <value>The order to use</value>
 369     public Eina.List<Efl.Gfx.IEntity> CompositionElements {
 370         get { return GetCompositionElements(); }
 371         set { SetCompositionElements(value); }
 372     }
 373     /// <summary>Set to true if all children should be registered as logicals</summary>
 374     /// <value><c>true</c> or <c>false</c></value>
 375     public bool LogicalMode {
 376         get { return GetLogicalMode(); }
 377         set { SetLogicalMode(value); }
 378     }
 379     private static IntPtr GetEflClassStatic()
 380     {
 381         return Efl.Ui.Calendar.efl_ui_calendar_class_get();
 382     }
 383     /// <summary>Wrapper for native methods and virtual method delegates.
 384     /// For internal use by generated code only.</summary>
 385     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 386     {
 387         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 388         /// <summary>Gets the list of Eo operations to override.</summary>
 389         /// <returns>The list of Eo operations to be overload.</returns>
 390         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 391         {
 392             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 393             var methods = Efl.Eo.Globals.GetUserMethods(type);
 394
 395             if (efl_ui_calendar_first_day_of_week_get_static_delegate == null)
 396             {
 397                 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);
 398             }
 399
 400             if (methods.FirstOrDefault(m => m.Name == "GetFirstDayOfWeek") != null)
 401             {
 402                 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) });
 403             }
 404
 405             if (efl_ui_calendar_first_day_of_week_set_static_delegate == null)
 406             {
 407                 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);
 408             }
 409
 410             if (methods.FirstOrDefault(m => m.Name == "SetFirstDayOfWeek") != null)
 411             {
 412                 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) });
 413             }
 414
 415             if (efl_ui_calendar_date_min_get_static_delegate == null)
 416             {
 417                 efl_ui_calendar_date_min_get_static_delegate = new efl_ui_calendar_date_min_get_delegate(date_min_get);
 418             }
 419
 420             if (methods.FirstOrDefault(m => m.Name == "GetDateMin") != null)
 421             {
 422                 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) });
 423             }
 424
 425             if (efl_ui_calendar_date_min_set_static_delegate == null)
 426             {
 427                 efl_ui_calendar_date_min_set_static_delegate = new efl_ui_calendar_date_min_set_delegate(date_min_set);
 428             }
 429
 430             if (methods.FirstOrDefault(m => m.Name == "SetDateMin") != null)
 431             {
 432                 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) });
 433             }
 434
 435             if (efl_ui_calendar_date_max_get_static_delegate == null)
 436             {
 437                 efl_ui_calendar_date_max_get_static_delegate = new efl_ui_calendar_date_max_get_delegate(date_max_get);
 438             }
 439
 440             if (methods.FirstOrDefault(m => m.Name == "GetDateMax") != null)
 441             {
 442                 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) });
 443             }
 444
 445             if (efl_ui_calendar_date_max_set_static_delegate == null)
 446             {
 447                 efl_ui_calendar_date_max_set_static_delegate = new efl_ui_calendar_date_max_set_delegate(date_max_set);
 448             }
 449
 450             if (methods.FirstOrDefault(m => m.Name == "SetDateMax") != null)
 451             {
 452                 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) });
 453             }
 454
 455             if (efl_ui_calendar_date_get_static_delegate == null)
 456             {
 457                 efl_ui_calendar_date_get_static_delegate = new efl_ui_calendar_date_get_delegate(date_get);
 458             }
 459
 460             if (methods.FirstOrDefault(m => m.Name == "GetDate") != null)
 461             {
 462                 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) });
 463             }
 464
 465             if (efl_ui_calendar_date_set_static_delegate == null)
 466             {
 467                 efl_ui_calendar_date_set_static_delegate = new efl_ui_calendar_date_set_delegate(date_set);
 468             }
 469
 470             if (methods.FirstOrDefault(m => m.Name == "SetDate") != null)
 471             {
 472                 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) });
 473             }
 474
 475             if (efl_ui_format_func_get_static_delegate == null)
 476             {
 477                 efl_ui_format_func_get_static_delegate = new efl_ui_format_func_get_delegate(format_func_get);
 478             }
 479
 480             if (methods.FirstOrDefault(m => m.Name == "GetFormatFunc") != null)
 481             {
 482                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_func_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_func_get_static_delegate) });
 483             }
 484
 485             if (efl_ui_format_func_set_static_delegate == null)
 486             {
 487                 efl_ui_format_func_set_static_delegate = new efl_ui_format_func_set_delegate(format_func_set);
 488             }
 489
 490             if (methods.FirstOrDefault(m => m.Name == "SetFormatFunc") != null)
 491             {
 492                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_func_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_func_set_static_delegate) });
 493             }
 494
 495             if (efl_ui_format_values_get_static_delegate == null)
 496             {
 497                 efl_ui_format_values_get_static_delegate = new efl_ui_format_values_get_delegate(format_values_get);
 498             }
 499
 500             if (methods.FirstOrDefault(m => m.Name == "GetFormatValues") != null)
 501             {
 502                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_values_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_values_get_static_delegate) });
 503             }
 504
 505             if (efl_ui_format_values_set_static_delegate == null)
 506             {
 507                 efl_ui_format_values_set_static_delegate = new efl_ui_format_values_set_delegate(format_values_set);
 508             }
 509
 510             if (methods.FirstOrDefault(m => m.Name == "SetFormatValues") != null)
 511             {
 512                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_values_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_values_set_static_delegate) });
 513             }
 514
 515             if (efl_ui_format_string_get_static_delegate == null)
 516             {
 517                 efl_ui_format_string_get_static_delegate = new efl_ui_format_string_get_delegate(format_string_get);
 518             }
 519
 520             if (methods.FirstOrDefault(m => m.Name == "GetFormatString") != null)
 521             {
 522                 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) });
 523             }
 524
 525             if (efl_ui_format_string_set_static_delegate == null)
 526             {
 527                 efl_ui_format_string_set_static_delegate = new efl_ui_format_string_set_delegate(format_string_set);
 528             }
 529
 530             if (methods.FirstOrDefault(m => m.Name == "SetFormatString") != null)
 531             {
 532                 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) });
 533             }
 534
 535             if (efl_ui_format_formatted_value_get_static_delegate == null)
 536             {
 537                 efl_ui_format_formatted_value_get_static_delegate = new efl_ui_format_formatted_value_get_delegate(formatted_value_get);
 538             }
 539
 540             if (methods.FirstOrDefault(m => m.Name == "GetFormattedValue") != null)
 541             {
 542                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_formatted_value_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_formatted_value_get_static_delegate) });
 543             }
 544
 545             if (efl_ui_format_decimal_places_get_static_delegate == null)
 546             {
 547                 efl_ui_format_decimal_places_get_static_delegate = new efl_ui_format_decimal_places_get_delegate(decimal_places_get);
 548             }
 549
 550             if (methods.FirstOrDefault(m => m.Name == "GetDecimalPlaces") != null)
 551             {
 552                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_decimal_places_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_decimal_places_get_static_delegate) });
 553             }
 554
 555             if (efl_ui_format_apply_formatted_value_static_delegate == null)
 556             {
 557                 efl_ui_format_apply_formatted_value_static_delegate = new efl_ui_format_apply_formatted_value_delegate(apply_formatted_value);
 558             }
 559
 560             if (methods.FirstOrDefault(m => m.Name == "ApplyFormattedValue") != null)
 561             {
 562                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_format_apply_formatted_value"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_format_apply_formatted_value_static_delegate) });
 563             }
 564
 565             if (efl_ui_focus_composition_elements_get_static_delegate == null)
 566             {
 567                 efl_ui_focus_composition_elements_get_static_delegate = new efl_ui_focus_composition_elements_get_delegate(composition_elements_get);
 568             }
 569
 570             if (methods.FirstOrDefault(m => m.Name == "GetCompositionElements") != null)
 571             {
 572                 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) });
 573             }
 574
 575             if (efl_ui_focus_composition_elements_set_static_delegate == null)
 576             {
 577                 efl_ui_focus_composition_elements_set_static_delegate = new efl_ui_focus_composition_elements_set_delegate(composition_elements_set);
 578             }
 579
 580             if (methods.FirstOrDefault(m => m.Name == "SetCompositionElements") != null)
 581             {
 582                 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) });
 583             }
 584
 585             if (efl_ui_focus_composition_logical_mode_get_static_delegate == null)
 586             {
 587                 efl_ui_focus_composition_logical_mode_get_static_delegate = new efl_ui_focus_composition_logical_mode_get_delegate(logical_mode_get);
 588             }
 589
 590             if (methods.FirstOrDefault(m => m.Name == "GetLogicalMode") != null)
 591             {
 592                 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) });
 593             }
 594
 595             if (efl_ui_focus_composition_logical_mode_set_static_delegate == null)
 596             {
 597                 efl_ui_focus_composition_logical_mode_set_static_delegate = new efl_ui_focus_composition_logical_mode_set_delegate(logical_mode_set);
 598             }
 599
 600             if (methods.FirstOrDefault(m => m.Name == "SetLogicalMode") != null)
 601             {
 602                 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) });
 603             }
 604
 605             if (efl_ui_focus_composition_dirty_static_delegate == null)
 606             {
 607                 efl_ui_focus_composition_dirty_static_delegate = new efl_ui_focus_composition_dirty_delegate(dirty);
 608             }
 609
 610             if (methods.FirstOrDefault(m => m.Name == "Dirty") != null)
 611             {
 612                 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) });
 613             }
 614
 615             if (efl_ui_focus_composition_prepare_static_delegate == null)
 616             {
 617                 efl_ui_focus_composition_prepare_static_delegate = new efl_ui_focus_composition_prepare_delegate(prepare);
 618             }
 619
 620             if (methods.FirstOrDefault(m => m.Name == "Prepare") != null)
 621             {
 622                 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) });
 623             }
 624
 625             descs.AddRange(base.GetEoOps(type));
 626             return descs;
 627         }
 628         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 629         /// <returns>The native class pointer.</returns>
 630         public override IntPtr GetEflClass()
 631         {
 632             return Efl.Ui.Calendar.efl_ui_calendar_class_get();
 633         }
 634
 635         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 636
 637
 638         private delegate Efl.Ui.CalendarWeekday efl_ui_calendar_first_day_of_week_get_delegate(System.IntPtr obj, System.IntPtr pd);
 639
 640
 641         public delegate Efl.Ui.CalendarWeekday efl_ui_calendar_first_day_of_week_get_api_delegate(System.IntPtr obj);
 642
 643         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");
 644
 645         private static Efl.Ui.CalendarWeekday first_day_of_week_get(System.IntPtr obj, System.IntPtr pd)
 646         {
 647             Eina.Log.Debug("function efl_ui_calendar_first_day_of_week_get was called");
 648             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 649             if (ws != null)
 650             {
 651             Efl.Ui.CalendarWeekday _ret_var = default(Efl.Ui.CalendarWeekday);
 652                 try
 653                 {
 654                     _ret_var = ((Calendar)ws.Target).GetFirstDayOfWeek();
 655                 }
 656                 catch (Exception e)
 657                 {
 658                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 659                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 660                 }
 661
 662         return _ret_var;
 663
 664             }
 665             else
 666             {
 667                 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)));
 668             }
 669         }
 670
 671         private static efl_ui_calendar_first_day_of_week_get_delegate efl_ui_calendar_first_day_of_week_get_static_delegate;
 672
 673
 674         private delegate void efl_ui_calendar_first_day_of_week_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.CalendarWeekday day);
 675
 676
 677         public delegate void efl_ui_calendar_first_day_of_week_set_api_delegate(System.IntPtr obj,  Efl.Ui.CalendarWeekday day);
 678
 679         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");
 680
 681         private static void first_day_of_week_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.CalendarWeekday day)
 682         {
 683             Eina.Log.Debug("function efl_ui_calendar_first_day_of_week_set was called");
 684             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 685             if (ws != null)
 686             {
 687
 688                 try
 689                 {
 690                     ((Calendar)ws.Target).SetFirstDayOfWeek(day);
 691                 }
 692                 catch (Exception e)
 693                 {
 694                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 695                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 696                 }
 697
 698
 699             }
 700             else
 701             {
 702                 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);
 703             }
 704         }
 705
 706         private static efl_ui_calendar_first_day_of_week_set_delegate efl_ui_calendar_first_day_of_week_set_static_delegate;
 707
 708
 709         private delegate Efl.Time.NativeStruct efl_ui_calendar_date_min_get_delegate(System.IntPtr obj, System.IntPtr pd);
 710
 711
 712         public delegate Efl.Time.NativeStruct efl_ui_calendar_date_min_get_api_delegate(System.IntPtr obj);
 713
 714         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");
 715
 716         private static Efl.Time.NativeStruct date_min_get(System.IntPtr obj, System.IntPtr pd)
 717         {
 718             Eina.Log.Debug("function efl_ui_calendar_date_min_get was called");
 719             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 720             if (ws != null)
 721             {
 722             Efl.Time _ret_var = default(Efl.Time);
 723                 try
 724                 {
 725                     _ret_var = ((Calendar)ws.Target).GetDateMin();
 726                 }
 727                 catch (Exception e)
 728                 {
 729                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 730                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 731                 }
 732
 733         return _ret_var;
 734
 735             }
 736             else
 737             {
 738                 return efl_ui_calendar_date_min_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 739             }
 740         }
 741
 742         private static efl_ui_calendar_date_min_get_delegate efl_ui_calendar_date_min_get_static_delegate;
 743
 744         [return: MarshalAs(UnmanagedType.U1)]
 745         private delegate bool efl_ui_calendar_date_min_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct min);
 746
 747         [return: MarshalAs(UnmanagedType.U1)]
 748         public delegate bool efl_ui_calendar_date_min_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct min);
 749
 750         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");
 751
 752         private static bool date_min_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct min)
 753         {
 754             Eina.Log.Debug("function efl_ui_calendar_date_min_set was called");
 755             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 756             if (ws != null)
 757             {
 758         Efl.Time _in_min = min;
 759                             bool _ret_var = default(bool);
 760                 try
 761                 {
 762                     _ret_var = ((Calendar)ws.Target).SetDateMin(_in_min);
 763                 }
 764                 catch (Exception e)
 765                 {
 766                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 767                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 768                 }
 769
 770                         return _ret_var;
 771
 772             }
 773             else
 774             {
 775                 return efl_ui_calendar_date_min_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), min);
 776             }
 777         }
 778
 779         private static efl_ui_calendar_date_min_set_delegate efl_ui_calendar_date_min_set_static_delegate;
 780
 781
 782         private delegate Efl.Time.NativeStruct efl_ui_calendar_date_max_get_delegate(System.IntPtr obj, System.IntPtr pd);
 783
 784
 785         public delegate Efl.Time.NativeStruct efl_ui_calendar_date_max_get_api_delegate(System.IntPtr obj);
 786
 787         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");
 788
 789         private static Efl.Time.NativeStruct date_max_get(System.IntPtr obj, System.IntPtr pd)
 790         {
 791             Eina.Log.Debug("function efl_ui_calendar_date_max_get was called");
 792             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 793             if (ws != null)
 794             {
 795             Efl.Time _ret_var = default(Efl.Time);
 796                 try
 797                 {
 798                     _ret_var = ((Calendar)ws.Target).GetDateMax();
 799                 }
 800                 catch (Exception e)
 801                 {
 802                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 803                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 804                 }
 805
 806         return _ret_var;
 807
 808             }
 809             else
 810             {
 811                 return efl_ui_calendar_date_max_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 812             }
 813         }
 814
 815         private static efl_ui_calendar_date_max_get_delegate efl_ui_calendar_date_max_get_static_delegate;
 816
 817         [return: MarshalAs(UnmanagedType.U1)]
 818         private delegate bool efl_ui_calendar_date_max_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct max);
 819
 820         [return: MarshalAs(UnmanagedType.U1)]
 821         public delegate bool efl_ui_calendar_date_max_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct max);
 822
 823         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");
 824
 825         private static bool date_max_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct max)
 826         {
 827             Eina.Log.Debug("function efl_ui_calendar_date_max_set was called");
 828             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 829             if (ws != null)
 830             {
 831         Efl.Time _in_max = max;
 832                             bool _ret_var = default(bool);
 833                 try
 834                 {
 835                     _ret_var = ((Calendar)ws.Target).SetDateMax(_in_max);
 836                 }
 837                 catch (Exception e)
 838                 {
 839                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 840                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 841                 }
 842
 843                         return _ret_var;
 844
 845             }
 846             else
 847             {
 848                 return efl_ui_calendar_date_max_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), max);
 849             }
 850         }
 851
 852         private static efl_ui_calendar_date_max_set_delegate efl_ui_calendar_date_max_set_static_delegate;
 853
 854
 855         private delegate Efl.Time.NativeStruct efl_ui_calendar_date_get_delegate(System.IntPtr obj, System.IntPtr pd);
 856
 857
 858         public delegate Efl.Time.NativeStruct efl_ui_calendar_date_get_api_delegate(System.IntPtr obj);
 859
 860         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");
 861
 862         private static Efl.Time.NativeStruct date_get(System.IntPtr obj, System.IntPtr pd)
 863         {
 864             Eina.Log.Debug("function efl_ui_calendar_date_get was called");
 865             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 866             if (ws != null)
 867             {
 868             Efl.Time _ret_var = default(Efl.Time);
 869                 try
 870                 {
 871                     _ret_var = ((Calendar)ws.Target).GetDate();
 872                 }
 873                 catch (Exception e)
 874                 {
 875                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 876                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 877                 }
 878
 879         return _ret_var;
 880
 881             }
 882             else
 883             {
 884                 return efl_ui_calendar_date_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 885             }
 886         }
 887
 888         private static efl_ui_calendar_date_get_delegate efl_ui_calendar_date_get_static_delegate;
 889
 890         [return: MarshalAs(UnmanagedType.U1)]
 891         private delegate bool efl_ui_calendar_date_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Time.NativeStruct date);
 892
 893         [return: MarshalAs(UnmanagedType.U1)]
 894         public delegate bool efl_ui_calendar_date_set_api_delegate(System.IntPtr obj,  Efl.Time.NativeStruct date);
 895
 896         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");
 897
 898         private static bool date_set(System.IntPtr obj, System.IntPtr pd, Efl.Time.NativeStruct date)
 899         {
 900             Eina.Log.Debug("function efl_ui_calendar_date_set was called");
 901             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 902             if (ws != null)
 903             {
 904         Efl.Time _in_date = date;
 905                             bool _ret_var = default(bool);
 906                 try
 907                 {
 908                     _ret_var = ((Calendar)ws.Target).SetDate(_in_date);
 909                 }
 910                 catch (Exception e)
 911                 {
 912                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 913                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 914                 }
 915
 916                         return _ret_var;
 917
 918             }
 919             else
 920             {
 921                 return efl_ui_calendar_date_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), date);
 922             }
 923         }
 924
 925         private static efl_ui_calendar_date_set_delegate efl_ui_calendar_date_set_static_delegate;
 926
 927
 928         private delegate Efl.Ui.FormatFunc efl_ui_format_func_get_delegate(System.IntPtr obj, System.IntPtr pd);
 929
 930
 931         public delegate Efl.Ui.FormatFunc efl_ui_format_func_get_api_delegate(System.IntPtr obj);
 932
 933         public static Efl.Eo.FunctionWrapper<efl_ui_format_func_get_api_delegate> efl_ui_format_func_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_func_get_api_delegate>(Module, "efl_ui_format_func_get");
 934
 935         private static Efl.Ui.FormatFunc format_func_get(System.IntPtr obj, System.IntPtr pd)
 936         {
 937             Eina.Log.Debug("function efl_ui_format_func_get was called");
 938             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 939             if (ws != null)
 940             {
 941             Efl.Ui.FormatFunc _ret_var = default(Efl.Ui.FormatFunc);
 942                 try
 943                 {
 944                     _ret_var = ((Calendar)ws.Target).GetFormatFunc();
 945                 }
 946                 catch (Exception e)
 947                 {
 948                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 949                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 950                 }
 951
 952         return _ret_var;
 953
 954             }
 955             else
 956             {
 957                 return efl_ui_format_func_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 958             }
 959         }
 960
 961         private static efl_ui_format_func_get_delegate efl_ui_format_func_get_static_delegate;
 962
 963
 964         private delegate void efl_ui_format_func_set_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, Efl.Ui.FormatFuncInternal func, EinaFreeCb func_free_cb);
 965
 966
 967         public delegate void efl_ui_format_func_set_api_delegate(System.IntPtr obj,  IntPtr func_data, Efl.Ui.FormatFuncInternal func, EinaFreeCb func_free_cb);
 968
 969         public static Efl.Eo.FunctionWrapper<efl_ui_format_func_set_api_delegate> efl_ui_format_func_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_func_set_api_delegate>(Module, "efl_ui_format_func_set");
 970
 971         private static void format_func_set(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, Efl.Ui.FormatFuncInternal func, EinaFreeCb func_free_cb)
 972         {
 973             Eina.Log.Debug("function efl_ui_format_func_set was called");
 974             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 975             if (ws != null)
 976             {
 977                             Efl.Ui.FormatFuncWrapper func_wrapper = new Efl.Ui.FormatFuncWrapper(func, func_data, func_free_cb);
 978
 979                 try
 980                 {
 981                     ((Calendar)ws.Target).SetFormatFunc(func_wrapper.ManagedCb);
 982                 }
 983                 catch (Exception e)
 984                 {
 985                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 986                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 987                 }
 988
 989
 990             }
 991             else
 992             {
 993                 efl_ui_format_func_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
 994             }
 995         }
 996
 997         private static efl_ui_format_func_set_delegate efl_ui_format_func_set_static_delegate;
 998
 999
1000         private delegate System.IntPtr efl_ui_format_values_get_delegate(System.IntPtr obj, System.IntPtr pd);
1001
1002
1003         public delegate System.IntPtr efl_ui_format_values_get_api_delegate(System.IntPtr obj);
1004
1005         public static Efl.Eo.FunctionWrapper<efl_ui_format_values_get_api_delegate> efl_ui_format_values_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_values_get_api_delegate>(Module, "efl_ui_format_values_get");
1006
1007         private static System.IntPtr format_values_get(System.IntPtr obj, System.IntPtr pd)
1008         {
1009             Eina.Log.Debug("function efl_ui_format_values_get was called");
1010             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1011             if (ws != null)
1012             {
1013             Eina.Accessor<Efl.Ui.FormatValue> _ret_var = default(Eina.Accessor<Efl.Ui.FormatValue>);
1014                 try
1015                 {
1016                     _ret_var = ((Calendar)ws.Target).GetFormatValues();
1017                 }
1018                 catch (Exception e)
1019                 {
1020                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1021                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1022                 }
1023
1024         return _ret_var.Handle;
1025
1026             }
1027             else
1028             {
1029                 return efl_ui_format_values_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1030             }
1031         }
1032
1033         private static efl_ui_format_values_get_delegate efl_ui_format_values_get_static_delegate;
1034
1035
1036         private delegate void efl_ui_format_values_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr values);
1037
1038
1039         public delegate void efl_ui_format_values_set_api_delegate(System.IntPtr obj,  System.IntPtr values);
1040
1041         public static Efl.Eo.FunctionWrapper<efl_ui_format_values_set_api_delegate> efl_ui_format_values_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_values_set_api_delegate>(Module, "efl_ui_format_values_set");
1042
1043         private static void format_values_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr values)
1044         {
1045             Eina.Log.Debug("function efl_ui_format_values_set was called");
1046             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1047             if (ws != null)
1048             {
1049         var _in_values = new Eina.Accessor<Efl.Ui.FormatValue>(values, false);
1050
1051                 try
1052                 {
1053                     ((Calendar)ws.Target).SetFormatValues(_in_values);
1054                 }
1055                 catch (Exception e)
1056                 {
1057                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1058                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1059                 }
1060
1061
1062             }
1063             else
1064             {
1065                 efl_ui_format_values_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), values);
1066             }
1067         }
1068
1069         private static efl_ui_format_values_set_delegate efl_ui_format_values_set_static_delegate;
1070
1071
1072         private delegate void efl_ui_format_string_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String kw_string,  out Efl.Ui.FormatStringType type);
1073
1074
1075         public delegate void efl_ui_format_string_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String kw_string,  out Efl.Ui.FormatStringType type);
1076
1077         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");
1078
1079         private static void format_string_get(System.IntPtr obj, System.IntPtr pd, out System.String kw_string, out Efl.Ui.FormatStringType type)
1080         {
1081             Eina.Log.Debug("function efl_ui_format_string_get was called");
1082             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1083             if (ws != null)
1084             {
1085                         System.String _out_kw_string = default(System.String);
1086         type = default(Efl.Ui.FormatStringType);
1087                 try
1088                 {
1089                     ((Calendar)ws.Target).GetFormatString(out _out_kw_string, out type);
1090                 }
1091                 catch (Exception e)
1092                 {
1093                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1094                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1095                 }
1096
1097         kw_string = _out_kw_string;
1098
1099             }
1100             else
1101             {
1102                 efl_ui_format_string_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out kw_string, out type);
1103             }
1104         }
1105
1106         private static efl_ui_format_string_get_delegate efl_ui_format_string_get_static_delegate;
1107
1108
1109         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 kw_string,  Efl.Ui.FormatStringType type);
1110
1111
1112         public delegate void efl_ui_format_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String kw_string,  Efl.Ui.FormatStringType type);
1113
1114         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");
1115
1116         private static void format_string_set(System.IntPtr obj, System.IntPtr pd, System.String kw_string, Efl.Ui.FormatStringType type)
1117         {
1118             Eina.Log.Debug("function efl_ui_format_string_set was called");
1119             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1120             if (ws != null)
1121             {
1122
1123                 try
1124                 {
1125                     ((Calendar)ws.Target).SetFormatString(kw_string, type);
1126                 }
1127                 catch (Exception e)
1128                 {
1129                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1130                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1131                 }
1132
1133
1134             }
1135             else
1136             {
1137                 efl_ui_format_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), kw_string, type);
1138             }
1139         }
1140
1141         private static efl_ui_format_string_set_delegate efl_ui_format_string_set_static_delegate;
1142
1143
1144         private delegate void efl_ui_format_formatted_value_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))] Eina.Strbuf str,  Eina.ValueNative value);
1145
1146
1147         public delegate void efl_ui_format_formatted_value_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StrbufKeepOwnershipMarshaler))] Eina.Strbuf str,  Eina.ValueNative value);
1148
1149         public static Efl.Eo.FunctionWrapper<efl_ui_format_formatted_value_get_api_delegate> efl_ui_format_formatted_value_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_formatted_value_get_api_delegate>(Module, "efl_ui_format_formatted_value_get");
1150
1151         private static void formatted_value_get(System.IntPtr obj, System.IntPtr pd, Eina.Strbuf str, Eina.ValueNative value)
1152         {
1153             Eina.Log.Debug("function efl_ui_format_formatted_value_get was called");
1154             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1155             if (ws != null)
1156             {
1157
1158                 try
1159                 {
1160                     ((Calendar)ws.Target).GetFormattedValue(str, value);
1161                 }
1162                 catch (Exception e)
1163                 {
1164                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1165                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1166                 }
1167
1168
1169             }
1170             else
1171             {
1172                 efl_ui_format_formatted_value_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), str, value);
1173             }
1174         }
1175
1176         private static efl_ui_format_formatted_value_get_delegate efl_ui_format_formatted_value_get_static_delegate;
1177
1178
1179         private delegate int efl_ui_format_decimal_places_get_delegate(System.IntPtr obj, System.IntPtr pd);
1180
1181
1182         public delegate int efl_ui_format_decimal_places_get_api_delegate(System.IntPtr obj);
1183
1184         public static Efl.Eo.FunctionWrapper<efl_ui_format_decimal_places_get_api_delegate> efl_ui_format_decimal_places_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_decimal_places_get_api_delegate>(Module, "efl_ui_format_decimal_places_get");
1185
1186         private static int decimal_places_get(System.IntPtr obj, System.IntPtr pd)
1187         {
1188             Eina.Log.Debug("function efl_ui_format_decimal_places_get was called");
1189             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1190             if (ws != null)
1191             {
1192             int _ret_var = default(int);
1193                 try
1194                 {
1195                     _ret_var = ((Calendar)ws.Target).GetDecimalPlaces();
1196                 }
1197                 catch (Exception e)
1198                 {
1199                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1200                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1201                 }
1202
1203         return _ret_var;
1204
1205             }
1206             else
1207             {
1208                 return efl_ui_format_decimal_places_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1209             }
1210         }
1211
1212         private static efl_ui_format_decimal_places_get_delegate efl_ui_format_decimal_places_get_static_delegate;
1213
1214
1215         private delegate void efl_ui_format_apply_formatted_value_delegate(System.IntPtr obj, System.IntPtr pd);
1216
1217
1218         public delegate void efl_ui_format_apply_formatted_value_api_delegate(System.IntPtr obj);
1219
1220         public static Efl.Eo.FunctionWrapper<efl_ui_format_apply_formatted_value_api_delegate> efl_ui_format_apply_formatted_value_ptr = new Efl.Eo.FunctionWrapper<efl_ui_format_apply_formatted_value_api_delegate>(Module, "efl_ui_format_apply_formatted_value");
1221
1222         private static void apply_formatted_value(System.IntPtr obj, System.IntPtr pd)
1223         {
1224             Eina.Log.Debug("function efl_ui_format_apply_formatted_value was called");
1225             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1226             if (ws != null)
1227             {
1228
1229                 try
1230                 {
1231                     ((Calendar)ws.Target).ApplyFormattedValue();
1232                 }
1233                 catch (Exception e)
1234                 {
1235                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1236                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1237                 }
1238
1239
1240             }
1241             else
1242             {
1243                 efl_ui_format_apply_formatted_value_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1244             }
1245         }
1246
1247         private static efl_ui_format_apply_formatted_value_delegate efl_ui_format_apply_formatted_value_static_delegate;
1248
1249
1250         private delegate System.IntPtr efl_ui_focus_composition_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
1251
1252
1253         public delegate System.IntPtr efl_ui_focus_composition_elements_get_api_delegate(System.IntPtr obj);
1254
1255         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");
1256
1257         private static System.IntPtr composition_elements_get(System.IntPtr obj, System.IntPtr pd)
1258         {
1259             Eina.Log.Debug("function efl_ui_focus_composition_elements_get was called");
1260             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1261             if (ws != null)
1262             {
1263             Eina.List<Efl.Gfx.IEntity> _ret_var = default(Eina.List<Efl.Gfx.IEntity>);
1264                 try
1265                 {
1266                     _ret_var = ((Calendar)ws.Target).GetCompositionElements();
1267                 }
1268                 catch (Exception e)
1269                 {
1270                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1271                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1272                 }
1273
1274         _ret_var.Own = false; return _ret_var.Handle;
1275
1276             }
1277             else
1278             {
1279                 return efl_ui_focus_composition_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1280             }
1281         }
1282
1283         private static efl_ui_focus_composition_elements_get_delegate efl_ui_focus_composition_elements_get_static_delegate;
1284
1285
1286         private delegate void efl_ui_focus_composition_elements_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr logical_order);
1287
1288
1289         public delegate void efl_ui_focus_composition_elements_set_api_delegate(System.IntPtr obj,  System.IntPtr logical_order);
1290
1291         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");
1292
1293         private static void composition_elements_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr logical_order)
1294         {
1295             Eina.Log.Debug("function efl_ui_focus_composition_elements_set was called");
1296             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1297             if (ws != null)
1298             {
1299         var _in_logical_order = new Eina.List<Efl.Gfx.IEntity>(logical_order, true, false);
1300
1301                 try
1302                 {
1303                     ((Calendar)ws.Target).SetCompositionElements(_in_logical_order);
1304                 }
1305                 catch (Exception e)
1306                 {
1307                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1308                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1309                 }
1310
1311
1312             }
1313             else
1314             {
1315                 efl_ui_focus_composition_elements_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), logical_order);
1316             }
1317         }
1318
1319         private static efl_ui_focus_composition_elements_set_delegate efl_ui_focus_composition_elements_set_static_delegate;
1320
1321         [return: MarshalAs(UnmanagedType.U1)]
1322         private delegate bool efl_ui_focus_composition_logical_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
1323
1324         [return: MarshalAs(UnmanagedType.U1)]
1325         public delegate bool efl_ui_focus_composition_logical_mode_get_api_delegate(System.IntPtr obj);
1326
1327         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");
1328
1329         private static bool logical_mode_get(System.IntPtr obj, System.IntPtr pd)
1330         {
1331             Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_get was called");
1332             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1333             if (ws != null)
1334             {
1335             bool _ret_var = default(bool);
1336                 try
1337                 {
1338                     _ret_var = ((Calendar)ws.Target).GetLogicalMode();
1339                 }
1340                 catch (Exception e)
1341                 {
1342                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1343                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1344                 }
1345
1346         return _ret_var;
1347
1348             }
1349             else
1350             {
1351                 return efl_ui_focus_composition_logical_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1352             }
1353         }
1354
1355         private static efl_ui_focus_composition_logical_mode_get_delegate efl_ui_focus_composition_logical_mode_get_static_delegate;
1356
1357
1358         private delegate void efl_ui_focus_composition_logical_mode_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool logical_mode);
1359
1360
1361         public delegate void efl_ui_focus_composition_logical_mode_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool logical_mode);
1362
1363         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");
1364
1365         private static void logical_mode_set(System.IntPtr obj, System.IntPtr pd, bool logical_mode)
1366         {
1367             Eina.Log.Debug("function efl_ui_focus_composition_logical_mode_set was called");
1368             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1369             if (ws != null)
1370             {
1371
1372                 try
1373                 {
1374                     ((Calendar)ws.Target).SetLogicalMode(logical_mode);
1375                 }
1376                 catch (Exception e)
1377                 {
1378                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1379                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1380                 }
1381
1382
1383             }
1384             else
1385             {
1386                 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);
1387             }
1388         }
1389
1390         private static efl_ui_focus_composition_logical_mode_set_delegate efl_ui_focus_composition_logical_mode_set_static_delegate;
1391
1392
1393         private delegate void efl_ui_focus_composition_dirty_delegate(System.IntPtr obj, System.IntPtr pd);
1394
1395
1396         public delegate void efl_ui_focus_composition_dirty_api_delegate(System.IntPtr obj);
1397
1398         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");
1399
1400         private static void dirty(System.IntPtr obj, System.IntPtr pd)
1401         {
1402             Eina.Log.Debug("function efl_ui_focus_composition_dirty was called");
1403             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1404             if (ws != null)
1405             {
1406
1407                 try
1408                 {
1409                     ((Calendar)ws.Target).Dirty();
1410                 }
1411                 catch (Exception e)
1412                 {
1413                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1414                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1415                 }
1416
1417
1418             }
1419             else
1420             {
1421                 efl_ui_focus_composition_dirty_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1422             }
1423         }
1424
1425         private static efl_ui_focus_composition_dirty_delegate efl_ui_focus_composition_dirty_static_delegate;
1426
1427
1428         private delegate void efl_ui_focus_composition_prepare_delegate(System.IntPtr obj, System.IntPtr pd);
1429
1430
1431         public delegate void efl_ui_focus_composition_prepare_api_delegate(System.IntPtr obj);
1432
1433         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");
1434
1435         private static void prepare(System.IntPtr obj, System.IntPtr pd)
1436         {
1437             Eina.Log.Debug("function efl_ui_focus_composition_prepare was called");
1438             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1439             if (ws != null)
1440             {
1441
1442                 try
1443                 {
1444                     ((Calendar)ws.Target).Prepare();
1445                 }
1446                 catch (Exception e)
1447                 {
1448                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1449                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1450                 }
1451
1452
1453             }
1454             else
1455             {
1456                 efl_ui_focus_composition_prepare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1457             }
1458         }
1459
1460         private static efl_ui_focus_composition_prepare_delegate efl_ui_focus_composition_prepare_static_delegate;
1461
1462         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1463
1464 }
1465 }
1466 }
1467
1468 }
1469
1470 namespace Efl {
1471
1472 namespace Ui {
1473
1474 /// <summary>A weekday
1475 /// See also <see cref="Efl.Ui.Calendar.SetFirstDayOfWeek"/>.</summary>
1476 [Efl.Eo.BindingEntity]
1477 public enum CalendarWeekday
1478 {
1479 /// <summary>Sunday weekday</summary>
1480 Sunday = 0,
1481 /// <summary>Monday weekday</summary>
1482 Monday = 1,
1483 /// <summary>Tuesday weekday</summary>
1484 Tuesday = 2,
1485 /// <summary>Wednesday weekday</summary>
1486 Wednesday = 3,
1487 /// <summary>Thursday weekday</summary>
1488 Thursday = 4,
1489 /// <summary>Friday weekday</summary>
1490 Friday = 5,
1491 /// <summary>Saturday weekday</summary>
1492 Saturday = 6,
1493 /// <summary>Sentinel value to indicate last enum field during iteration</summary>
1494 Last = 7,
1495 }
1496
1497 }
1498
1499 }
1500