internals/src/EflSharp/EflSharp/efl/efl_ui_box.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>A container that arranges children widgets in a vertical or horizontal fashion.
  13 /// The Box widget is the most basic (and the most used) of the container widgets. Other widgets are added to the Box through the <see cref="Efl.IPackLinear"/> interface, and the layout direction (either vertical or horizontal) is controlled through the <see cref="Efl.Ui.ILayoutOrientable.Orientation"/> property.
  14 ///
  15 /// The Box widget itself is invisible, as are most container widgets: Their purpose is to handle the position and size of all their children so you don&apos;t have to.
  16 ///
  17 /// All widgets inside a vertical Box container will have the same width as the container, and their heights will be automatically chosen so that they cover the whole surface of the container from top to bottom (Imagine a stack of pizza boxes neatly fitting inside your oven). The <see cref="Efl.Ui.Box.Homogeneous"/> property then controls whether all widgets have the same height (homogeneous) or not.
  18 ///
  19 /// A horizontal Box container example would be the button toolbar at the top of most word processing programs.
  20 ///
  21 /// Precise layout can be further customized through the <see cref="Efl.Gfx.IArrangement"/> interface on the Box itself, or through the <see cref="Efl.Gfx.IHint"/> interface on each of the children widgets.</summary>
  22 [Efl.Ui.Box.NativeMethods]
  23 [Efl.Eo.BindingEntity]
  24 public class Box : Efl.Ui.Widget, Efl.IContainer, Efl.IPack, Efl.IPackLayout, Efl.IPackLinear, Efl.Gfx.IArrangement, Efl.Ui.ILayoutOrientable
  25 {
  26     ///<summary>Pointer to the native class description.</summary>
  27     public override System.IntPtr NativeClass
  28     {
  29         get
  30         {
  31             if (((object)this).GetType() == typeof(Box))
  32             {
  33                 return GetEflClassStatic();
  34             }
  35             else
  36             {
  37                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  38             }
  39         }
  40     }
  41
  42     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  43         efl_ui_box_class_get();
  44     /// <summary>Initializes a new instance of the <see cref="Box"/> class.</summary>
  45     /// <param name="parent">Parent instance.</param>
  46     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  47     public Box(Efl.Object parent
  48             , System.String style = null) : base(efl_ui_box_class_get(), parent)
  49     {
  50         if (Efl.Eo.Globals.ParamHelperCheck(style))
  51         {
  52             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  53         }
  54
  55         FinishInstantiation();
  56     }
  57
  58     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  59     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  60     protected Box(ConstructingHandle ch) : base(ch)
  61     {
  62     }
  63
  64     /// <summary>Initializes a new instance of the <see cref="Box"/> class.
  65     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  66     /// <param name="wh">The native pointer to be wrapped.</param>
  67     protected Box(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  68     {
  69     }
  70
  71     /// <summary>Initializes a new instance of the <see cref="Box"/> class.
  72     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  73     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  74     /// <param name="parent">The Efl.Object parent of this instance.</param>
  75     protected Box(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  76     {
  77     }
  78
  79     /// <summary>Sent after a new sub-object was added.
  80     /// (Since EFL 1.22)</summary>
  81     public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
  82     {
  83         add
  84         {
  85             lock (eflBindingEventLock)
  86             {
  87                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  88                 {
  89                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  90                     if (obj != null)
  91                     {
  92                         Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
  93                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
  94                         try
  95                         {
  96                             value?.Invoke(obj, args);
  97                         }
  98                         catch (Exception e)
  99                         {
 100                             Eina.Log.Error(e.ToString());
 101                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 102                         }
 103                     }
 104                 };
 105
 106                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 107                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 108             }
 109         }
 110
 111         remove
 112         {
 113             lock (eflBindingEventLock)
 114             {
 115                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 116                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 117             }
 118         }
 119     }
 120     ///<summary>Method to raise event ContentAddedEvt.</summary>
 121     public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
 122     {
 123         var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 124         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 125         if (desc == IntPtr.Zero)
 126         {
 127             Eina.Log.Error($"Failed to get native event {key}");
 128             return;
 129         }
 130
 131         IntPtr info = e.arg.NativeHandle;
 132         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 133     }
 134     /// <summary>Sent after a sub-object was removed, before unref.
 135     /// (Since EFL 1.22)</summary>
 136     public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
 137     {
 138         add
 139         {
 140             lock (eflBindingEventLock)
 141             {
 142                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 143                 {
 144                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 145                     if (obj != null)
 146                     {
 147                         Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
 148                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 149                         try
 150                         {
 151                             value?.Invoke(obj, args);
 152                         }
 153                         catch (Exception e)
 154                         {
 155                             Eina.Log.Error(e.ToString());
 156                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 157                         }
 158                     }
 159                 };
 160
 161                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 162                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 163             }
 164         }
 165
 166         remove
 167         {
 168             lock (eflBindingEventLock)
 169             {
 170                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 171                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 172             }
 173         }
 174     }
 175     ///<summary>Method to raise event ContentRemovedEvt.</summary>
 176     public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
 177     {
 178         var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 179         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 180         if (desc == IntPtr.Zero)
 181         {
 182             Eina.Log.Error($"Failed to get native event {key}");
 183             return;
 184         }
 185
 186         IntPtr info = e.arg.NativeHandle;
 187         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 188     }
 189     /// <summary>Sent after the layout was updated.</summary>
 190     public event EventHandler LayoutUpdatedEvt
 191     {
 192         add
 193         {
 194             lock (eflBindingEventLock)
 195             {
 196                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 197                 {
 198                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 199                     if (obj != null)
 200                     {
 201                         EventArgs args = EventArgs.Empty;
 202                         try
 203                         {
 204                             value?.Invoke(obj, args);
 205                         }
 206                         catch (Exception e)
 207                         {
 208                             Eina.Log.Error(e.ToString());
 209                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 210                         }
 211                     }
 212                 };
 213
 214                 string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 215                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 216             }
 217         }
 218
 219         remove
 220         {
 221             lock (eflBindingEventLock)
 222             {
 223                 string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 224                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 225             }
 226         }
 227     }
 228     ///<summary>Method to raise event LayoutUpdatedEvt.</summary>
 229     public void OnLayoutUpdatedEvt(EventArgs e)
 230     {
 231         var key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 232         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 233         if (desc == IntPtr.Zero)
 234         {
 235             Eina.Log.Error($"Failed to get native event {key}");
 236             return;
 237         }
 238
 239         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 240     }
 241     /// <summary>In homogeneous mode all children of a vertical Box have the same height, equal to the height of the tallest widget. Children of a horizontal Box have the same width, equal to the width of the widest widget. Otherwise, individual widget sizes are not modified.</summary>
 242     /// <returns><c>true</c> if the Box is homogeneous, <c>false</c> otherwise.</returns>
 243     virtual public bool GetHomogeneous() {
 244          var _ret_var = Efl.Ui.Box.NativeMethods.efl_ui_box_homogeneous_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 245         Eina.Error.RaiseIfUnhandledException();
 246         return _ret_var;
 247  }
 248     /// <summary>In homogeneous mode all children of a vertical Box have the same height, equal to the height of the tallest widget. Children of a horizontal Box have the same width, equal to the width of the widest widget. Otherwise, individual widget sizes are not modified.</summary>
 249     /// <param name="homogeneous"><c>true</c> if the Box is homogeneous, <c>false</c> otherwise.</param>
 250     virtual public void SetHomogeneous(bool homogeneous) {
 251                                  Efl.Ui.Box.NativeMethods.efl_ui_box_homogeneous_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),homogeneous);
 252         Eina.Error.RaiseIfUnhandledException();
 253                          }
 254     /// <summary>Begin iterating over this object&apos;s contents.
 255     /// (Since EFL 1.22)</summary>
 256     /// <returns>Iterator on object&apos;s content.</returns>
 257     virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 258          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 259         Eina.Error.RaiseIfUnhandledException();
 260         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true);
 261  }
 262     /// <summary>Returns the number of contained sub-objects.
 263     /// (Since EFL 1.22)</summary>
 264     /// <returns>Number of sub-objects.</returns>
 265     virtual public int ContentCount() {
 266          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 267         Eina.Error.RaiseIfUnhandledException();
 268         return _ret_var;
 269  }
 270     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
 271     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 272     virtual public bool ClearPack() {
 273          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 274         Eina.Error.RaiseIfUnhandledException();
 275         return _ret_var;
 276  }
 277     /// <summary>Removes all packed sub-objects without unreferencing them.
 278     /// Use with caution.</summary>
 279     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 280     virtual public bool UnpackAll() {
 281          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_all_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 282         Eina.Error.RaiseIfUnhandledException();
 283         return _ret_var;
 284  }
 285     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
 286     /// <param name="subobj">The sub-object to unpack.</param>
 287     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
 288     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
 289                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 290         Eina.Error.RaiseIfUnhandledException();
 291                         return _ret_var;
 292  }
 293     /// <summary>Adds a sub-object to this container.
 294     /// Depending on the container this will either fill in the default spot, replacing any already existing element or append to the end of the container if there is no default part.
 295     ///
 296     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 297     /// <param name="subobj">The object to pack.</param>
 298     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 299     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 300                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 301         Eina.Error.RaiseIfUnhandledException();
 302                         return _ret_var;
 303  }
 304     /// <summary>Requests EFL to call the <see cref="Efl.IPackLayout.UpdateLayout"/> method on this object.
 305     /// This <see cref="Efl.IPackLayout.UpdateLayout"/> may be called asynchronously.</summary>
 306     virtual public void LayoutRequest() {
 307          Efl.IPackLayoutConcrete.NativeMethods.efl_pack_layout_request_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 308         Eina.Error.RaiseIfUnhandledException();
 309          }
 310     /// <summary>Implementation of this container&apos;s layout algorithm.
 311     /// EFL will call this function whenever the contents of this container need to be re-laid out on the canvas.
 312     ///
 313     /// This can be overriden to implement custom layout behaviors.</summary>
 314     virtual public void UpdateLayout() {
 315          Efl.IPackLayoutConcrete.NativeMethods.efl_pack_layout_update_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 316         Eina.Error.RaiseIfUnhandledException();
 317          }
 318     /// <summary>Prepend an object at the beginning of this container.
 319     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
 320     ///
 321     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 322     /// <param name="subobj">Object to pack at the beginning.</param>
 323     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 324     virtual public bool PackBegin(Efl.Gfx.IEntity subobj) {
 325                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_begin_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 326         Eina.Error.RaiseIfUnhandledException();
 327                         return _ret_var;
 328  }
 329     /// <summary>Append object at the end of this container.
 330     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
 331     ///
 332     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 333     /// <param name="subobj">Object to pack at the end.</param>
 334     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 335     virtual public bool PackEnd(Efl.Gfx.IEntity subobj) {
 336                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_end_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 337         Eina.Error.RaiseIfUnhandledException();
 338                         return _ret_var;
 339  }
 340     /// <summary>Prepend an object before an existing sub-object.
 341     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 342     /// <param name="subobj">Object to pack before <c>existing</c>.</param>
 343     /// <param name="existing">Existing reference sub-object.</param>
 344     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 345     virtual public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 346                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_before_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, existing);
 347         Eina.Error.RaiseIfUnhandledException();
 348                                         return _ret_var;
 349  }
 350     /// <summary>Append an object after an existing sub-object.
 351     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 352     /// <param name="subobj">Object to pack after <c>existing</c>.</param>
 353     /// <param name="existing">Existing reference sub-object.</param>
 354     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 355     virtual public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 356                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_after_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, existing);
 357         Eina.Error.RaiseIfUnhandledException();
 358                                         return _ret_var;
 359  }
 360     /// <summary>Inserts <c>subobj</c> BEFORE the sub-object at position <c>index</c>.
 361     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 362     ///
 363     /// If <c>index</c> is less than -<c>count</c>, it will trigger <see cref="Efl.IPackLinear.PackBegin"/>(<c>subobj</c>) whereas <c>index</c> greater than <c>count</c>-1 will trigger <see cref="Efl.IPackLinear.PackEnd"/>(<c>subobj</c>).
 364     ///
 365     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 366     /// <param name="subobj">Object to pack.</param>
 367     /// <param name="index">Index of existing sub-object to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 368     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 369     virtual public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
 370                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_at_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, index);
 371         Eina.Error.RaiseIfUnhandledException();
 372                                         return _ret_var;
 373  }
 374     /// <summary>Sub-object at a given <c>index</c> in this container.
 375     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 376     ///
 377     /// If <c>index</c> is less than -<c>count</c>, it will return the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will return the last sub-object.</summary>
 378     /// <param name="index">Index of the existing sub-object to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 379     /// <returns>The sub-object contained at the given <c>index</c>.</returns>
 380     virtual public Efl.Gfx.IEntity GetPackContent(int index) {
 381                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_content_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),index);
 382         Eina.Error.RaiseIfUnhandledException();
 383                         return _ret_var;
 384  }
 385     /// <summary>Get the index of a sub-object in this container.</summary>
 386     /// <param name="subobj">An existing sub-object in this container.</param>
 387     /// <returns>-1 in case <c>subobj</c> is not found, or the index of <c>subobj</c> in the range 0 to (<c>count</c>-1).</returns>
 388     virtual public int GetPackIndex(Efl.Gfx.IEntity subobj) {
 389                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_index_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 390         Eina.Error.RaiseIfUnhandledException();
 391                         return _ret_var;
 392  }
 393     /// <summary>Pop out (remove) the sub-object at the specified <c>index</c>.
 394     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 395     ///
 396     /// If <c>index</c> is less than -<c>count</c>, it will remove the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will remove the last sub-object.</summary>
 397     /// <param name="index">Index of the sub-object to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 398     /// <returns>The sub-object if it could be removed.</returns>
 399     virtual public Efl.Gfx.IEntity PackUnpackAt(int index) {
 400                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_unpack_at_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),index);
 401         Eina.Error.RaiseIfUnhandledException();
 402                         return _ret_var;
 403  }
 404     /// <summary>Alignment of the container within its bounds</summary>
 405     /// <param name="align_horiz">Horizontal alignment</param>
 406     /// <param name="align_vert">Vertical alignment</param>
 407     virtual public void GetContentAlign(out double align_horiz, out double align_vert) {
 408                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out align_horiz, out align_vert);
 409         Eina.Error.RaiseIfUnhandledException();
 410                                          }
 411     /// <summary>Alignment of the container within its bounds</summary>
 412     /// <param name="align_horiz">Horizontal alignment</param>
 413     /// <param name="align_vert">Vertical alignment</param>
 414     virtual public void SetContentAlign(double align_horiz, double align_vert) {
 415                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),align_horiz, align_vert);
 416         Eina.Error.RaiseIfUnhandledException();
 417                                          }
 418     /// <summary>Padding between items contained in this object.</summary>
 419     /// <param name="pad_horiz">Horizontal padding</param>
 420     /// <param name="pad_vert">Vertical padding</param>
 421     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 422     virtual public void GetContentPadding(out double pad_horiz, out double pad_vert, out bool scalable) {
 423                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out pad_horiz, out pad_vert, out scalable);
 424         Eina.Error.RaiseIfUnhandledException();
 425                                                          }
 426     /// <summary>Padding between items contained in this object.</summary>
 427     /// <param name="pad_horiz">Horizontal padding</param>
 428     /// <param name="pad_vert">Vertical padding</param>
 429     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 430     virtual public void SetContentPadding(double pad_horiz, double pad_vert, bool scalable) {
 431                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),pad_horiz, pad_vert, scalable);
 432         Eina.Error.RaiseIfUnhandledException();
 433                                                          }
 434     /// <summary>Control the direction of a given widget.
 435     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 436     ///
 437     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 438     /// <returns>Direction of the widget.</returns>
 439     virtual public Efl.Ui.LayoutOrientation GetOrientation() {
 440          var _ret_var = Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 441         Eina.Error.RaiseIfUnhandledException();
 442         return _ret_var;
 443  }
 444     /// <summary>Control the direction of a given widget.
 445     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 446     ///
 447     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 448     /// <param name="dir">Direction of the widget.</param>
 449     virtual public void SetOrientation(Efl.Ui.LayoutOrientation dir) {
 450                                  Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir);
 451         Eina.Error.RaiseIfUnhandledException();
 452                          }
 453     /// <summary>In homogeneous mode all children of a vertical Box have the same height, equal to the height of the tallest widget. Children of a horizontal Box have the same width, equal to the width of the widest widget. Otherwise, individual widget sizes are not modified.</summary>
 454     /// <value><c>true</c> if the Box is homogeneous, <c>false</c> otherwise.</value>
 455     public bool Homogeneous {
 456         get { return GetHomogeneous(); }
 457         set { SetHomogeneous(value); }
 458     }
 459     /// <summary>Control the direction of a given widget.
 460     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 461     ///
 462     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 463     /// <value>Direction of the widget.</value>
 464     public Efl.Ui.LayoutOrientation Orientation {
 465         get { return GetOrientation(); }
 466         set { SetOrientation(value); }
 467     }
 468     private static IntPtr GetEflClassStatic()
 469     {
 470         return Efl.Ui.Box.efl_ui_box_class_get();
 471     }
 472     /// <summary>Wrapper for native methods and virtual method delegates.
 473     /// For internal use by generated code only.</summary>
 474     public new class NativeMethods : Efl.Ui.Widget.NativeMethods
 475     {
 476         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 477         /// <summary>Gets the list of Eo operations to override.</summary>
 478         /// <returns>The list of Eo operations to be overload.</returns>
 479         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 480         {
 481             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 482             var methods = Efl.Eo.Globals.GetUserMethods(type);
 483
 484             if (efl_ui_box_homogeneous_get_static_delegate == null)
 485             {
 486                 efl_ui_box_homogeneous_get_static_delegate = new efl_ui_box_homogeneous_get_delegate(homogeneous_get);
 487             }
 488
 489             if (methods.FirstOrDefault(m => m.Name == "GetHomogeneous") != null)
 490             {
 491                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_box_homogeneous_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_box_homogeneous_get_static_delegate) });
 492             }
 493
 494             if (efl_ui_box_homogeneous_set_static_delegate == null)
 495             {
 496                 efl_ui_box_homogeneous_set_static_delegate = new efl_ui_box_homogeneous_set_delegate(homogeneous_set);
 497             }
 498
 499             if (methods.FirstOrDefault(m => m.Name == "SetHomogeneous") != null)
 500             {
 501                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_box_homogeneous_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_box_homogeneous_set_static_delegate) });
 502             }
 503
 504             if (efl_content_iterate_static_delegate == null)
 505             {
 506                 efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 507             }
 508
 509             if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 510             {
 511                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_content_iterate_static_delegate) });
 512             }
 513
 514             if (efl_content_count_static_delegate == null)
 515             {
 516                 efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 517             }
 518
 519             if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 520             {
 521                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_count"), func = Marshal.GetFunctionPointerForDelegate(efl_content_count_static_delegate) });
 522             }
 523
 524             if (efl_pack_clear_static_delegate == null)
 525             {
 526                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 527             }
 528
 529             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 530             {
 531                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_clear_static_delegate) });
 532             }
 533
 534             if (efl_pack_unpack_all_static_delegate == null)
 535             {
 536                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 537             }
 538
 539             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 540             {
 541                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack_all"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_all_static_delegate) });
 542             }
 543
 544             if (efl_pack_unpack_static_delegate == null)
 545             {
 546                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 547             }
 548
 549             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 550             {
 551                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_static_delegate) });
 552             }
 553
 554             if (efl_pack_static_delegate == null)
 555             {
 556                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 557             }
 558
 559             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 560             {
 561                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 562             }
 563
 564             if (efl_pack_layout_request_static_delegate == null)
 565             {
 566                 efl_pack_layout_request_static_delegate = new efl_pack_layout_request_delegate(layout_request);
 567             }
 568
 569             if (methods.FirstOrDefault(m => m.Name == "LayoutRequest") != null)
 570             {
 571                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_layout_request"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_layout_request_static_delegate) });
 572             }
 573
 574             if (efl_pack_layout_update_static_delegate == null)
 575             {
 576                 efl_pack_layout_update_static_delegate = new efl_pack_layout_update_delegate(layout_update);
 577             }
 578
 579             if (methods.FirstOrDefault(m => m.Name == "UpdateLayout") != null)
 580             {
 581                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_layout_update"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_layout_update_static_delegate) });
 582             }
 583
 584             if (efl_pack_begin_static_delegate == null)
 585             {
 586                 efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 587             }
 588
 589             if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
 590             {
 591                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_begin"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_begin_static_delegate) });
 592             }
 593
 594             if (efl_pack_end_static_delegate == null)
 595             {
 596                 efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 597             }
 598
 599             if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
 600             {
 601                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_end"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_end_static_delegate) });
 602             }
 603
 604             if (efl_pack_before_static_delegate == null)
 605             {
 606                 efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 607             }
 608
 609             if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
 610             {
 611                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_before"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_before_static_delegate) });
 612             }
 613
 614             if (efl_pack_after_static_delegate == null)
 615             {
 616                 efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 617             }
 618
 619             if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
 620             {
 621                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_after"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_after_static_delegate) });
 622             }
 623
 624             if (efl_pack_at_static_delegate == null)
 625             {
 626                 efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 627             }
 628
 629             if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
 630             {
 631                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_at_static_delegate) });
 632             }
 633
 634             if (efl_pack_content_get_static_delegate == null)
 635             {
 636                 efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 637             }
 638
 639             if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
 640             {
 641                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_content_get_static_delegate) });
 642             }
 643
 644             if (efl_pack_index_get_static_delegate == null)
 645             {
 646                 efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 647             }
 648
 649             if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
 650             {
 651                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_index_get_static_delegate) });
 652             }
 653
 654             if (efl_pack_unpack_at_static_delegate == null)
 655             {
 656                 efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 657             }
 658
 659             if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
 660             {
 661                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_at_static_delegate) });
 662             }
 663
 664             if (efl_gfx_arrangement_content_align_get_static_delegate == null)
 665             {
 666                 efl_gfx_arrangement_content_align_get_static_delegate = new efl_gfx_arrangement_content_align_get_delegate(content_align_get);
 667             }
 668
 669             if (methods.FirstOrDefault(m => m.Name == "GetContentAlign") != null)
 670             {
 671                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_align_get_static_delegate) });
 672             }
 673
 674             if (efl_gfx_arrangement_content_align_set_static_delegate == null)
 675             {
 676                 efl_gfx_arrangement_content_align_set_static_delegate = new efl_gfx_arrangement_content_align_set_delegate(content_align_set);
 677             }
 678
 679             if (methods.FirstOrDefault(m => m.Name == "SetContentAlign") != null)
 680             {
 681                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_align_set_static_delegate) });
 682             }
 683
 684             if (efl_gfx_arrangement_content_padding_get_static_delegate == null)
 685             {
 686                 efl_gfx_arrangement_content_padding_get_static_delegate = new efl_gfx_arrangement_content_padding_get_delegate(content_padding_get);
 687             }
 688
 689             if (methods.FirstOrDefault(m => m.Name == "GetContentPadding") != null)
 690             {
 691                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_padding_get_static_delegate) });
 692             }
 693
 694             if (efl_gfx_arrangement_content_padding_set_static_delegate == null)
 695             {
 696                 efl_gfx_arrangement_content_padding_set_static_delegate = new efl_gfx_arrangement_content_padding_set_delegate(content_padding_set);
 697             }
 698
 699             if (methods.FirstOrDefault(m => m.Name == "SetContentPadding") != null)
 700             {
 701                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_padding_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_padding_set_static_delegate) });
 702             }
 703
 704             if (efl_ui_layout_orientation_get_static_delegate == null)
 705             {
 706                 efl_ui_layout_orientation_get_static_delegate = new efl_ui_layout_orientation_get_delegate(orientation_get);
 707             }
 708
 709             if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
 710             {
 711                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_get_static_delegate) });
 712             }
 713
 714             if (efl_ui_layout_orientation_set_static_delegate == null)
 715             {
 716                 efl_ui_layout_orientation_set_static_delegate = new efl_ui_layout_orientation_set_delegate(orientation_set);
 717             }
 718
 719             if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
 720             {
 721                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_set_static_delegate) });
 722             }
 723
 724             descs.AddRange(base.GetEoOps(type));
 725             return descs;
 726         }
 727         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 728         /// <returns>The native class pointer.</returns>
 729         public override IntPtr GetEflClass()
 730         {
 731             return Efl.Ui.Box.efl_ui_box_class_get();
 732         }
 733
 734         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 735
 736         [return: MarshalAs(UnmanagedType.U1)]
 737         private delegate bool efl_ui_box_homogeneous_get_delegate(System.IntPtr obj, System.IntPtr pd);
 738
 739         [return: MarshalAs(UnmanagedType.U1)]
 740         public delegate bool efl_ui_box_homogeneous_get_api_delegate(System.IntPtr obj);
 741
 742         public static Efl.Eo.FunctionWrapper<efl_ui_box_homogeneous_get_api_delegate> efl_ui_box_homogeneous_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_box_homogeneous_get_api_delegate>(Module, "efl_ui_box_homogeneous_get");
 743
 744         private static bool homogeneous_get(System.IntPtr obj, System.IntPtr pd)
 745         {
 746             Eina.Log.Debug("function efl_ui_box_homogeneous_get was called");
 747             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 748             if (ws != null)
 749             {
 750             bool _ret_var = default(bool);
 751                 try
 752                 {
 753                     _ret_var = ((Box)ws.Target).GetHomogeneous();
 754                 }
 755                 catch (Exception e)
 756                 {
 757                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 758                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 759                 }
 760
 761         return _ret_var;
 762
 763             }
 764             else
 765             {
 766                 return efl_ui_box_homogeneous_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 767             }
 768         }
 769
 770         private static efl_ui_box_homogeneous_get_delegate efl_ui_box_homogeneous_get_static_delegate;
 771
 772
 773         private delegate void efl_ui_box_homogeneous_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool homogeneous);
 774
 775
 776         public delegate void efl_ui_box_homogeneous_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool homogeneous);
 777
 778         public static Efl.Eo.FunctionWrapper<efl_ui_box_homogeneous_set_api_delegate> efl_ui_box_homogeneous_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_box_homogeneous_set_api_delegate>(Module, "efl_ui_box_homogeneous_set");
 779
 780         private static void homogeneous_set(System.IntPtr obj, System.IntPtr pd, bool homogeneous)
 781         {
 782             Eina.Log.Debug("function efl_ui_box_homogeneous_set was called");
 783             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 784             if (ws != null)
 785             {
 786
 787                 try
 788                 {
 789                     ((Box)ws.Target).SetHomogeneous(homogeneous);
 790                 }
 791                 catch (Exception e)
 792                 {
 793                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 794                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 795                 }
 796
 797
 798             }
 799             else
 800             {
 801                 efl_ui_box_homogeneous_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), homogeneous);
 802             }
 803         }
 804
 805         private static efl_ui_box_homogeneous_set_delegate efl_ui_box_homogeneous_set_static_delegate;
 806
 807
 808         private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 809
 810
 811         public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
 812
 813         public static Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate> efl_content_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate>(Module, "efl_content_iterate");
 814
 815         private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
 816         {
 817             Eina.Log.Debug("function efl_content_iterate was called");
 818             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 819             if (ws != null)
 820             {
 821             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
 822                 try
 823                 {
 824                     _ret_var = ((Box)ws.Target).ContentIterate();
 825                 }
 826                 catch (Exception e)
 827                 {
 828                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 829                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 830                 }
 831
 832         _ret_var.Own = false; return _ret_var.Handle;
 833
 834             }
 835             else
 836             {
 837                 return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 838             }
 839         }
 840
 841         private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
 842
 843
 844         private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
 845
 846
 847         public delegate int efl_content_count_api_delegate(System.IntPtr obj);
 848
 849         public static Efl.Eo.FunctionWrapper<efl_content_count_api_delegate> efl_content_count_ptr = new Efl.Eo.FunctionWrapper<efl_content_count_api_delegate>(Module, "efl_content_count");
 850
 851         private static int content_count(System.IntPtr obj, System.IntPtr pd)
 852         {
 853             Eina.Log.Debug("function efl_content_count was called");
 854             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 855             if (ws != null)
 856             {
 857             int _ret_var = default(int);
 858                 try
 859                 {
 860                     _ret_var = ((Box)ws.Target).ContentCount();
 861                 }
 862                 catch (Exception e)
 863                 {
 864                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 865                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 866                 }
 867
 868         return _ret_var;
 869
 870             }
 871             else
 872             {
 873                 return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 874             }
 875         }
 876
 877         private static efl_content_count_delegate efl_content_count_static_delegate;
 878
 879         [return: MarshalAs(UnmanagedType.U1)]
 880         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 881
 882         [return: MarshalAs(UnmanagedType.U1)]
 883         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 884
 885         public static Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate> efl_pack_clear_ptr = new Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate>(Module, "efl_pack_clear");
 886
 887         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 888         {
 889             Eina.Log.Debug("function efl_pack_clear was called");
 890             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 891             if (ws != null)
 892             {
 893             bool _ret_var = default(bool);
 894                 try
 895                 {
 896                     _ret_var = ((Box)ws.Target).ClearPack();
 897                 }
 898                 catch (Exception e)
 899                 {
 900                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 901                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 902                 }
 903
 904         return _ret_var;
 905
 906             }
 907             else
 908             {
 909                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 910             }
 911         }
 912
 913         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 914
 915         [return: MarshalAs(UnmanagedType.U1)]
 916         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 917
 918         [return: MarshalAs(UnmanagedType.U1)]
 919         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 920
 921         public static Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate> efl_pack_unpack_all_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate>(Module, "efl_pack_unpack_all");
 922
 923         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 924         {
 925             Eina.Log.Debug("function efl_pack_unpack_all was called");
 926             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 927             if (ws != null)
 928             {
 929             bool _ret_var = default(bool);
 930                 try
 931                 {
 932                     _ret_var = ((Box)ws.Target).UnpackAll();
 933                 }
 934                 catch (Exception e)
 935                 {
 936                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 937                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 938                 }
 939
 940         return _ret_var;
 941
 942             }
 943             else
 944             {
 945                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 946             }
 947         }
 948
 949         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 950
 951         [return: MarshalAs(UnmanagedType.U1)]
 952         private delegate bool efl_pack_unpack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 953
 954         [return: MarshalAs(UnmanagedType.U1)]
 955         public delegate bool efl_pack_unpack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 956
 957         public static Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate> efl_pack_unpack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate>(Module, "efl_pack_unpack");
 958
 959         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 960         {
 961             Eina.Log.Debug("function efl_pack_unpack was called");
 962             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 963             if (ws != null)
 964             {
 965                                     bool _ret_var = default(bool);
 966                 try
 967                 {
 968                     _ret_var = ((Box)ws.Target).Unpack(subobj);
 969                 }
 970                 catch (Exception e)
 971                 {
 972                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 973                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 974                 }
 975
 976                         return _ret_var;
 977
 978             }
 979             else
 980             {
 981                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 982             }
 983         }
 984
 985         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 986
 987         [return: MarshalAs(UnmanagedType.U1)]
 988         private delegate bool efl_pack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 989
 990         [return: MarshalAs(UnmanagedType.U1)]
 991         public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 992
 993         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
 994
 995         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 996         {
 997             Eina.Log.Debug("function efl_pack was called");
 998             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 999             if (ws != null)
1000             {
1001                                     bool _ret_var = default(bool);
1002                 try
1003                 {
1004                     _ret_var = ((Box)ws.Target).Pack(subobj);
1005                 }
1006                 catch (Exception e)
1007                 {
1008                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1009                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1010                 }
1011
1012                         return _ret_var;
1013
1014             }
1015             else
1016             {
1017                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1018             }
1019         }
1020
1021         private static efl_pack_delegate efl_pack_static_delegate;
1022
1023
1024         private delegate void efl_pack_layout_request_delegate(System.IntPtr obj, System.IntPtr pd);
1025
1026
1027         public delegate void efl_pack_layout_request_api_delegate(System.IntPtr obj);
1028
1029         public static Efl.Eo.FunctionWrapper<efl_pack_layout_request_api_delegate> efl_pack_layout_request_ptr = new Efl.Eo.FunctionWrapper<efl_pack_layout_request_api_delegate>(Module, "efl_pack_layout_request");
1030
1031         private static void layout_request(System.IntPtr obj, System.IntPtr pd)
1032         {
1033             Eina.Log.Debug("function efl_pack_layout_request was called");
1034             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1035             if (ws != null)
1036             {
1037
1038                 try
1039                 {
1040                     ((Box)ws.Target).LayoutRequest();
1041                 }
1042                 catch (Exception e)
1043                 {
1044                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1045                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1046                 }
1047
1048
1049             }
1050             else
1051             {
1052                 efl_pack_layout_request_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1053             }
1054         }
1055
1056         private static efl_pack_layout_request_delegate efl_pack_layout_request_static_delegate;
1057
1058
1059         private delegate void efl_pack_layout_update_delegate(System.IntPtr obj, System.IntPtr pd);
1060
1061
1062         public delegate void efl_pack_layout_update_api_delegate(System.IntPtr obj);
1063
1064         public static Efl.Eo.FunctionWrapper<efl_pack_layout_update_api_delegate> efl_pack_layout_update_ptr = new Efl.Eo.FunctionWrapper<efl_pack_layout_update_api_delegate>(Module, "efl_pack_layout_update");
1065
1066         private static void layout_update(System.IntPtr obj, System.IntPtr pd)
1067         {
1068             Eina.Log.Debug("function efl_pack_layout_update was called");
1069             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1070             if (ws != null)
1071             {
1072
1073                 try
1074                 {
1075                     ((Box)ws.Target).UpdateLayout();
1076                 }
1077                 catch (Exception e)
1078                 {
1079                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1080                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1081                 }
1082
1083
1084             }
1085             else
1086             {
1087                 efl_pack_layout_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1088             }
1089         }
1090
1091         private static efl_pack_layout_update_delegate efl_pack_layout_update_static_delegate;
1092
1093         [return: MarshalAs(UnmanagedType.U1)]
1094         private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1095
1096         [return: MarshalAs(UnmanagedType.U1)]
1097         public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1098
1099         public static Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate> efl_pack_begin_ptr = new Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate>(Module, "efl_pack_begin");
1100
1101         private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1102         {
1103             Eina.Log.Debug("function efl_pack_begin was called");
1104             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1105             if (ws != null)
1106             {
1107                                     bool _ret_var = default(bool);
1108                 try
1109                 {
1110                     _ret_var = ((Box)ws.Target).PackBegin(subobj);
1111                 }
1112                 catch (Exception e)
1113                 {
1114                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1115                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1116                 }
1117
1118                         return _ret_var;
1119
1120             }
1121             else
1122             {
1123                 return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1124             }
1125         }
1126
1127         private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
1128
1129         [return: MarshalAs(UnmanagedType.U1)]
1130         private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1131
1132         [return: MarshalAs(UnmanagedType.U1)]
1133         public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1134
1135         public static Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate> efl_pack_end_ptr = new Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate>(Module, "efl_pack_end");
1136
1137         private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1138         {
1139             Eina.Log.Debug("function efl_pack_end was called");
1140             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1141             if (ws != null)
1142             {
1143                                     bool _ret_var = default(bool);
1144                 try
1145                 {
1146                     _ret_var = ((Box)ws.Target).PackEnd(subobj);
1147                 }
1148                 catch (Exception e)
1149                 {
1150                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1151                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1152                 }
1153
1154                         return _ret_var;
1155
1156             }
1157             else
1158             {
1159                 return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1160             }
1161         }
1162
1163         private static efl_pack_end_delegate efl_pack_end_static_delegate;
1164
1165         [return: MarshalAs(UnmanagedType.U1)]
1166         private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1167
1168         [return: MarshalAs(UnmanagedType.U1)]
1169         public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1170
1171         public static Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate> efl_pack_before_ptr = new Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate>(Module, "efl_pack_before");
1172
1173         private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1174         {
1175             Eina.Log.Debug("function efl_pack_before was called");
1176             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1177             if (ws != null)
1178             {
1179                                                             bool _ret_var = default(bool);
1180                 try
1181                 {
1182                     _ret_var = ((Box)ws.Target).PackBefore(subobj, existing);
1183                 }
1184                 catch (Exception e)
1185                 {
1186                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1187                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1188                 }
1189
1190                                         return _ret_var;
1191
1192             }
1193             else
1194             {
1195                 return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1196             }
1197         }
1198
1199         private static efl_pack_before_delegate efl_pack_before_static_delegate;
1200
1201         [return: MarshalAs(UnmanagedType.U1)]
1202         private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1203
1204         [return: MarshalAs(UnmanagedType.U1)]
1205         public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
1206
1207         public static Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate> efl_pack_after_ptr = new Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate>(Module, "efl_pack_after");
1208
1209         private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1210         {
1211             Eina.Log.Debug("function efl_pack_after was called");
1212             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1213             if (ws != null)
1214             {
1215                                                             bool _ret_var = default(bool);
1216                 try
1217                 {
1218                     _ret_var = ((Box)ws.Target).PackAfter(subobj, existing);
1219                 }
1220                 catch (Exception e)
1221                 {
1222                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1223                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1224                 }
1225
1226                                         return _ret_var;
1227
1228             }
1229             else
1230             {
1231                 return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1232             }
1233         }
1234
1235         private static efl_pack_after_delegate efl_pack_after_static_delegate;
1236
1237         [return: MarshalAs(UnmanagedType.U1)]
1238         private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
1239
1240         [return: MarshalAs(UnmanagedType.U1)]
1241         public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
1242
1243         public static Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate> efl_pack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate>(Module, "efl_pack_at");
1244
1245         private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
1246         {
1247             Eina.Log.Debug("function efl_pack_at was called");
1248             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1249             if (ws != null)
1250             {
1251                                                             bool _ret_var = default(bool);
1252                 try
1253                 {
1254                     _ret_var = ((Box)ws.Target).PackAt(subobj, index);
1255                 }
1256                 catch (Exception e)
1257                 {
1258                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1259                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1260                 }
1261
1262                                         return _ret_var;
1263
1264             }
1265             else
1266             {
1267                 return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
1268             }
1269         }
1270
1271         private static efl_pack_at_delegate efl_pack_at_static_delegate;
1272
1273         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1274         private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
1275
1276         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1277         public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj,  int index);
1278
1279         public static Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate> efl_pack_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate>(Module, "efl_pack_content_get");
1280
1281         private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
1282         {
1283             Eina.Log.Debug("function efl_pack_content_get was called");
1284             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1285             if (ws != null)
1286             {
1287                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1288                 try
1289                 {
1290                     _ret_var = ((Box)ws.Target).GetPackContent(index);
1291                 }
1292                 catch (Exception e)
1293                 {
1294                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1295                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1296                 }
1297
1298                         return _ret_var;
1299
1300             }
1301             else
1302             {
1303                 return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1304             }
1305         }
1306
1307         private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
1308
1309
1310         private delegate int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1311
1312
1313         public delegate int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1314
1315         public static Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate> efl_pack_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate>(Module, "efl_pack_index_get");
1316
1317         private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1318         {
1319             Eina.Log.Debug("function efl_pack_index_get was called");
1320             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1321             if (ws != null)
1322             {
1323                                     int _ret_var = default(int);
1324                 try
1325                 {
1326                     _ret_var = ((Box)ws.Target).GetPackIndex(subobj);
1327                 }
1328                 catch (Exception e)
1329                 {
1330                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1331                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1332                 }
1333
1334                         return _ret_var;
1335
1336             }
1337             else
1338             {
1339                 return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1340             }
1341         }
1342
1343         private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
1344
1345         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1346         private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
1347
1348         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1349         public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj,  int index);
1350
1351         public static Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate> efl_pack_unpack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate>(Module, "efl_pack_unpack_at");
1352
1353         private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
1354         {
1355             Eina.Log.Debug("function efl_pack_unpack_at was called");
1356             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1357             if (ws != null)
1358             {
1359                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1360                 try
1361                 {
1362                     _ret_var = ((Box)ws.Target).PackUnpackAt(index);
1363                 }
1364                 catch (Exception e)
1365                 {
1366                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1367                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1368                 }
1369
1370                         return _ret_var;
1371
1372             }
1373             else
1374             {
1375                 return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1376             }
1377         }
1378
1379         private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
1380
1381
1382         private delegate void efl_gfx_arrangement_content_align_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert);
1383
1384
1385         public delegate void efl_gfx_arrangement_content_align_get_api_delegate(System.IntPtr obj,  out double align_horiz,  out double align_vert);
1386
1387         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_get_api_delegate> efl_gfx_arrangement_content_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_get_api_delegate>(Module, "efl_gfx_arrangement_content_align_get");
1388
1389         private static void content_align_get(System.IntPtr obj, System.IntPtr pd, out double align_horiz, out double align_vert)
1390         {
1391             Eina.Log.Debug("function efl_gfx_arrangement_content_align_get was called");
1392             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1393             if (ws != null)
1394             {
1395                         align_horiz = default(double);        align_vert = default(double);
1396                 try
1397                 {
1398                     ((Box)ws.Target).GetContentAlign(out align_horiz, out align_vert);
1399                 }
1400                 catch (Exception e)
1401                 {
1402                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1403                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1404                 }
1405
1406
1407             }
1408             else
1409             {
1410                 efl_gfx_arrangement_content_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out align_horiz, out align_vert);
1411             }
1412         }
1413
1414         private static efl_gfx_arrangement_content_align_get_delegate efl_gfx_arrangement_content_align_get_static_delegate;
1415
1416
1417         private delegate void efl_gfx_arrangement_content_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert);
1418
1419
1420         public delegate void efl_gfx_arrangement_content_align_set_api_delegate(System.IntPtr obj,  double align_horiz,  double align_vert);
1421
1422         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_set_api_delegate> efl_gfx_arrangement_content_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_set_api_delegate>(Module, "efl_gfx_arrangement_content_align_set");
1423
1424         private static void content_align_set(System.IntPtr obj, System.IntPtr pd, double align_horiz, double align_vert)
1425         {
1426             Eina.Log.Debug("function efl_gfx_arrangement_content_align_set was called");
1427             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1428             if (ws != null)
1429             {
1430
1431                 try
1432                 {
1433                     ((Box)ws.Target).SetContentAlign(align_horiz, align_vert);
1434                 }
1435                 catch (Exception e)
1436                 {
1437                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1438                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1439                 }
1440
1441
1442             }
1443             else
1444             {
1445                 efl_gfx_arrangement_content_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), align_horiz, align_vert);
1446             }
1447         }
1448
1449         private static efl_gfx_arrangement_content_align_set_delegate efl_gfx_arrangement_content_align_set_static_delegate;
1450
1451
1452         private delegate void efl_gfx_arrangement_content_padding_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert, [MarshalAs(UnmanagedType.U1)] out bool scalable);
1453
1454
1455         public delegate void efl_gfx_arrangement_content_padding_get_api_delegate(System.IntPtr obj,  out double pad_horiz,  out double pad_vert, [MarshalAs(UnmanagedType.U1)] out bool scalable);
1456
1457         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_get_api_delegate> efl_gfx_arrangement_content_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_get_api_delegate>(Module, "efl_gfx_arrangement_content_padding_get");
1458
1459         private static void content_padding_get(System.IntPtr obj, System.IntPtr pd, out double pad_horiz, out double pad_vert, out bool scalable)
1460         {
1461             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_get was called");
1462             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1463             if (ws != null)
1464             {
1465                                 pad_horiz = default(double);        pad_vert = default(double);        scalable = default(bool);
1466                 try
1467                 {
1468                     ((Box)ws.Target).GetContentPadding(out pad_horiz, out pad_vert, out scalable);
1469                 }
1470                 catch (Exception e)
1471                 {
1472                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1473                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1474                 }
1475
1476
1477             }
1478             else
1479             {
1480                 efl_gfx_arrangement_content_padding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out pad_horiz, out pad_vert, out scalable);
1481             }
1482         }
1483
1484         private static efl_gfx_arrangement_content_padding_get_delegate efl_gfx_arrangement_content_padding_get_static_delegate;
1485
1486
1487         private delegate void efl_gfx_arrangement_content_padding_set_delegate(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert, [MarshalAs(UnmanagedType.U1)] bool scalable);
1488
1489
1490         public delegate void efl_gfx_arrangement_content_padding_set_api_delegate(System.IntPtr obj,  double pad_horiz,  double pad_vert, [MarshalAs(UnmanagedType.U1)] bool scalable);
1491
1492         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_set_api_delegate> efl_gfx_arrangement_content_padding_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_set_api_delegate>(Module, "efl_gfx_arrangement_content_padding_set");
1493
1494         private static void content_padding_set(System.IntPtr obj, System.IntPtr pd, double pad_horiz, double pad_vert, bool scalable)
1495         {
1496             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_set was called");
1497             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1498             if (ws != null)
1499             {
1500
1501                 try
1502                 {
1503                     ((Box)ws.Target).SetContentPadding(pad_horiz, pad_vert, scalable);
1504                 }
1505                 catch (Exception e)
1506                 {
1507                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1508                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1509                 }
1510
1511
1512             }
1513             else
1514             {
1515                 efl_gfx_arrangement_content_padding_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pad_horiz, pad_vert, scalable);
1516             }
1517         }
1518
1519         private static efl_gfx_arrangement_content_padding_set_delegate efl_gfx_arrangement_content_padding_set_static_delegate;
1520
1521
1522         private delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1523
1524
1525         public delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_api_delegate(System.IntPtr obj);
1526
1527         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate> efl_ui_layout_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate>(Module, "efl_ui_layout_orientation_get");
1528
1529         private static Efl.Ui.LayoutOrientation orientation_get(System.IntPtr obj, System.IntPtr pd)
1530         {
1531             Eina.Log.Debug("function efl_ui_layout_orientation_get was called");
1532             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1533             if (ws != null)
1534             {
1535             Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
1536                 try
1537                 {
1538                     _ret_var = ((Box)ws.Target).GetOrientation();
1539                 }
1540                 catch (Exception e)
1541                 {
1542                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1543                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1544                 }
1545
1546         return _ret_var;
1547
1548             }
1549             else
1550             {
1551                 return efl_ui_layout_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1552             }
1553         }
1554
1555         private static efl_ui_layout_orientation_get_delegate efl_ui_layout_orientation_get_static_delegate;
1556
1557
1558         private delegate void efl_ui_layout_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
1559
1560
1561         public delegate void efl_ui_layout_orientation_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
1562
1563         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate> efl_ui_layout_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate>(Module, "efl_ui_layout_orientation_set");
1564
1565         private static void orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
1566         {
1567             Eina.Log.Debug("function efl_ui_layout_orientation_set was called");
1568             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1569             if (ws != null)
1570             {
1571
1572                 try
1573                 {
1574                     ((Box)ws.Target).SetOrientation(dir);
1575                 }
1576                 catch (Exception e)
1577                 {
1578                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1579                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1580                 }
1581
1582
1583             }
1584             else
1585             {
1586                 efl_ui_layout_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
1587             }
1588         }
1589
1590         private static efl_ui_layout_orientation_set_delegate efl_ui_layout_orientation_set_static_delegate;
1591
1592         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1593
1594 }
1595 }
1596 }
1597
1598 }
1599