internals/src/EflSharp/EflSharp/efl/efl_ui_box.eo.cs

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