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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>The box widget.
   9 /// A box arranges objects in a linear fashion, governed by a layout function that defines the details of this arrangement.
  10 ///
  11 /// By default, the box will use an internal function to set the layout to a single row, either vertical or horizontal. This layout is affected by a number of parameters. The values given by <see cref="Efl.Pack.GetPackPadding"/> and <see cref="Efl.Pack.GetPackAlign"/> and the hints set to each object in the box.
  12 ///
  13 /// FIXME: THIS CLASS NEEDS GOOD UP TO DATE DOCUMENTATION. LEGACY BOX AND UI BOX BEHAVE SLIGHTLY DIFFERENTLY AND USE VASTLY DIFFERENT APIS.</summary>
  14 [BoxNativeInherit]
  15 public class Box : Efl.Ui.Widget, Efl.Eo.IWrapper,Efl.Container,Efl.Pack,Efl.PackLayout,Efl.PackLinear,Efl.Ui.Direction
  16 {
  17    public new static System.IntPtr klass = System.IntPtr.Zero;
  18    public new static Efl.Ui.BoxNativeInherit nativeInherit = new Efl.Ui.BoxNativeInherit();
  19    ///<summary>Pointer to the native class description.</summary>
  20    public override System.IntPtr NativeClass {
  21       get {
  22          if (((object)this).GetType() == typeof (Box))
  23             return Efl.Ui.BoxNativeInherit.GetEflClassStatic();
  24          else
  25             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  26       }
  27    }
  28    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  29       efl_ui_box_class_get();
  30    ///<summary>Creates a new instance.</summary>
  31    ///<param name="parent">Parent instance.</param>
  32    ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  33    public Box(Efl.Object parent
  34          ,  System.String style = null) :
  35       base(efl_ui_box_class_get(), typeof(Box), parent)
  36    {
  37       if (Efl.Eo.Globals.ParamHelperCheck(style))
  38          SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  39       FinishInstantiation();
  40    }
  41    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  42    public Box(System.IntPtr raw) : base(raw)
  43    {
  44             register_event_proxies();
  45    }
  46    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  47    protected Box(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  48    ///<summary>Casts obj into an instance of this type.</summary>
  49    public new static Box static_cast(Efl.Object obj)
  50    {
  51       if (obj == null)
  52          throw new System.ArgumentNullException("obj");
  53       return new Box(obj.NativeHandle);
  54    }
  55    ///<summary>Verifies if the given object is equal to this one.</summary>
  56    public override bool Equals(object obj)
  57    {
  58       var other = obj as Efl.Object;
  59       if (other == null)
  60          return false;
  61       return this.NativeHandle == other.NativeHandle;
  62    }
  63    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  64    public override int GetHashCode()
  65    {
  66       return this.NativeHandle.ToInt32();
  67    }
  68    ///<summary>Turns the native pointer into a string representation.</summary>
  69    public override String ToString()
  70    {
  71       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  72    }
  73 private static object ContentAddedEvtKey = new object();
  74    /// <summary>Sent after a new item was added.</summary>
  75    public event EventHandler<Efl.ContainerContentAddedEvt_Args> ContentAddedEvt
  76    {
  77       add {
  78          lock (eventLock) {
  79             string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  80             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ContentAddedEvt_delegate)) {
  81                eventHandlers.AddHandler(ContentAddedEvtKey , value);
  82             } else
  83                Eina.Log.Error($"Error adding proxy for event {key}");
  84          }
  85       }
  86       remove {
  87          lock (eventLock) {
  88             string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  89             if (remove_cpp_event_handler(key, this.evt_ContentAddedEvt_delegate)) {
  90                eventHandlers.RemoveHandler(ContentAddedEvtKey , value);
  91             } else
  92                Eina.Log.Error($"Error removing proxy for event {key}");
  93          }
  94       }
  95    }
  96    ///<summary>Method to raise event ContentAddedEvt.</summary>
  97    public void On_ContentAddedEvt(Efl.ContainerContentAddedEvt_Args e)
  98    {
  99       EventHandler<Efl.ContainerContentAddedEvt_Args> evt;
 100       lock (eventLock) {
 101       evt = (EventHandler<Efl.ContainerContentAddedEvt_Args>)eventHandlers[ContentAddedEvtKey];
 102       }
 103       evt?.Invoke(this, e);
 104    }
 105    Efl.EventCb evt_ContentAddedEvt_delegate;
 106    private void on_ContentAddedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 107    {
 108       Efl.ContainerContentAddedEvt_Args args = new Efl.ContainerContentAddedEvt_Args();
 109       args.arg = new Efl.Gfx.EntityConcrete(evt.Info);
 110       try {
 111          On_ContentAddedEvt(args);
 112       } catch (Exception e) {
 113          Eina.Log.Error(e.ToString());
 114          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 115       }
 116    }
 117
 118 private static object ContentRemovedEvtKey = new object();
 119    /// <summary>Sent after an item was removed, before unref.</summary>
 120    public event EventHandler<Efl.ContainerContentRemovedEvt_Args> ContentRemovedEvt
 121    {
 122       add {
 123          lock (eventLock) {
 124             string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 125             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ContentRemovedEvt_delegate)) {
 126                eventHandlers.AddHandler(ContentRemovedEvtKey , value);
 127             } else
 128                Eina.Log.Error($"Error adding proxy for event {key}");
 129          }
 130       }
 131       remove {
 132          lock (eventLock) {
 133             string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 134             if (remove_cpp_event_handler(key, this.evt_ContentRemovedEvt_delegate)) {
 135                eventHandlers.RemoveHandler(ContentRemovedEvtKey , value);
 136             } else
 137                Eina.Log.Error($"Error removing proxy for event {key}");
 138          }
 139       }
 140    }
 141    ///<summary>Method to raise event ContentRemovedEvt.</summary>
 142    public void On_ContentRemovedEvt(Efl.ContainerContentRemovedEvt_Args e)
 143    {
 144       EventHandler<Efl.ContainerContentRemovedEvt_Args> evt;
 145       lock (eventLock) {
 146       evt = (EventHandler<Efl.ContainerContentRemovedEvt_Args>)eventHandlers[ContentRemovedEvtKey];
 147       }
 148       evt?.Invoke(this, e);
 149    }
 150    Efl.EventCb evt_ContentRemovedEvt_delegate;
 151    private void on_ContentRemovedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 152    {
 153       Efl.ContainerContentRemovedEvt_Args args = new Efl.ContainerContentRemovedEvt_Args();
 154       args.arg = new Efl.Gfx.EntityConcrete(evt.Info);
 155       try {
 156          On_ContentRemovedEvt(args);
 157       } catch (Exception e) {
 158          Eina.Log.Error(e.ToString());
 159          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 160       }
 161    }
 162
 163 private static object LayoutUpdatedEvtKey = new object();
 164    /// <summary>Sent after the layout was updated.</summary>
 165    public event EventHandler LayoutUpdatedEvt
 166    {
 167       add {
 168          lock (eventLock) {
 169             string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 170             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_LayoutUpdatedEvt_delegate)) {
 171                eventHandlers.AddHandler(LayoutUpdatedEvtKey , value);
 172             } else
 173                Eina.Log.Error($"Error adding proxy for event {key}");
 174          }
 175       }
 176       remove {
 177          lock (eventLock) {
 178             string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 179             if (remove_cpp_event_handler(key, this.evt_LayoutUpdatedEvt_delegate)) {
 180                eventHandlers.RemoveHandler(LayoutUpdatedEvtKey , value);
 181             } else
 182                Eina.Log.Error($"Error removing proxy for event {key}");
 183          }
 184       }
 185    }
 186    ///<summary>Method to raise event LayoutUpdatedEvt.</summary>
 187    public void On_LayoutUpdatedEvt(EventArgs e)
 188    {
 189       EventHandler evt;
 190       lock (eventLock) {
 191       evt = (EventHandler)eventHandlers[LayoutUpdatedEvtKey];
 192       }
 193       evt?.Invoke(this, e);
 194    }
 195    Efl.EventCb evt_LayoutUpdatedEvt_delegate;
 196    private void on_LayoutUpdatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 197    {
 198       EventArgs args = EventArgs.Empty;
 199       try {
 200          On_LayoutUpdatedEvt(args);
 201       } catch (Exception e) {
 202          Eina.Log.Error(e.ToString());
 203          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 204       }
 205    }
 206
 207    protected override void register_event_proxies()
 208    {
 209       base.register_event_proxies();
 210       evt_ContentAddedEvt_delegate = new Efl.EventCb(on_ContentAddedEvt_NativeCallback);
 211       evt_ContentRemovedEvt_delegate = new Efl.EventCb(on_ContentRemovedEvt_NativeCallback);
 212       evt_LayoutUpdatedEvt_delegate = new Efl.EventCb(on_LayoutUpdatedEvt_NativeCallback);
 213    }
 214    /// <summary>Control homogeneous mode.
 215    /// This will enable the homogeneous mode where children are of the same weight and of the same min size which is determined by maximum min size of children.</summary>
 216    /// <returns><c>true</c> if the box is homogeneous, <c>false</c> otherwise</returns>
 217    virtual public bool GetHomogeneous() {
 218        var _ret_var = Efl.Ui.BoxNativeInherit.efl_ui_box_homogeneous_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 219       Eina.Error.RaiseIfUnhandledException();
 220       return _ret_var;
 221  }
 222    /// <summary>Control homogeneous mode.
 223    /// This will enable the homogeneous mode where children are of the same weight and of the same min size which is determined by maximum min size of children.</summary>
 224    /// <param name="homogeneous"><c>true</c> if the box is homogeneous, <c>false</c> otherwise</param>
 225    /// <returns></returns>
 226    virtual public  void SetHomogeneous( bool homogeneous) {
 227                          Efl.Ui.BoxNativeInherit.efl_ui_box_homogeneous_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), homogeneous);
 228       Eina.Error.RaiseIfUnhandledException();
 229                    }
 230    /// <summary>Begin iterating over this object&apos;s contents.</summary>
 231    /// <returns>Iterator to object content</returns>
 232    virtual public Eina.Iterator<Efl.Gfx.Entity> ContentIterate() {
 233        var _ret_var = Efl.ContainerNativeInherit.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 234       Eina.Error.RaiseIfUnhandledException();
 235       return new Eina.Iterator<Efl.Gfx.Entity>(_ret_var, true, false);
 236  }
 237    /// <summary>Returns the number of UI elements packed in this container.</summary>
 238    /// <returns>Number of packed UI elements</returns>
 239    virtual public  int ContentCount() {
 240        var _ret_var = Efl.ContainerNativeInherit.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 241       Eina.Error.RaiseIfUnhandledException();
 242       return _ret_var;
 243  }
 244    /// <summary>Alignment of the container within its bounds</summary>
 245    /// <param name="align_horiz">Horizontal alignment</param>
 246    /// <param name="align_vert">Vertical alignment</param>
 247    /// <returns></returns>
 248    virtual public  void GetPackAlign( out double align_horiz,  out double align_vert) {
 249                                            Efl.PackNativeInherit.efl_pack_align_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out align_horiz,  out align_vert);
 250       Eina.Error.RaiseIfUnhandledException();
 251                                }
 252    /// <summary>Alignment of the container within its bounds</summary>
 253    /// <param name="align_horiz">Horizontal alignment</param>
 254    /// <param name="align_vert">Vertical alignment</param>
 255    /// <returns></returns>
 256    virtual public  void SetPackAlign( double align_horiz,  double align_vert) {
 257                                            Efl.PackNativeInherit.efl_pack_align_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), align_horiz,  align_vert);
 258       Eina.Error.RaiseIfUnhandledException();
 259                                }
 260    /// <summary>Padding between items contained in this object.</summary>
 261    /// <param name="pad_horiz">Horizontal padding</param>
 262    /// <param name="pad_vert">Vertical padding</param>
 263    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 264    /// <returns></returns>
 265    virtual public  void GetPackPadding( out double pad_horiz,  out double pad_vert,  out bool scalable) {
 266                                                              Efl.PackNativeInherit.efl_pack_padding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out pad_horiz,  out pad_vert,  out scalable);
 267       Eina.Error.RaiseIfUnhandledException();
 268                                            }
 269    /// <summary>Padding between items contained in this object.</summary>
 270    /// <param name="pad_horiz">Horizontal padding</param>
 271    /// <param name="pad_vert">Vertical padding</param>
 272    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 273    /// <returns></returns>
 274    virtual public  void SetPackPadding( double pad_horiz,  double pad_vert,  bool scalable) {
 275                                                              Efl.PackNativeInherit.efl_pack_padding_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), pad_horiz,  pad_vert,  scalable);
 276       Eina.Error.RaiseIfUnhandledException();
 277                                            }
 278    /// <summary>Removes all packed contents, and unreferences them.</summary>
 279    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 280    virtual public bool ClearPack() {
 281        var _ret_var = Efl.PackNativeInherit.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 282       Eina.Error.RaiseIfUnhandledException();
 283       return _ret_var;
 284  }
 285    /// <summary>Removes all packed contents, without unreferencing them.
 286    /// Use with caution.</summary>
 287    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 288    virtual public bool UnpackAll() {
 289        var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 290       Eina.Error.RaiseIfUnhandledException();
 291       return _ret_var;
 292  }
 293    /// <summary>Removes an existing item from the container, without deleting it.</summary>
 294    /// <param name="subobj">The unpacked object.</param>
 295    /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t a child or can&apos;t be removed</returns>
 296    virtual public bool Unpack( Efl.Gfx.Entity subobj) {
 297                          var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 298       Eina.Error.RaiseIfUnhandledException();
 299                   return _ret_var;
 300  }
 301    /// <summary>Adds an item to this container.
 302    /// 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.
 303    ///
 304    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 305    /// <param name="subobj">An object to pack.</param>
 306    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 307    virtual public bool DoPack( Efl.Gfx.Entity subobj) {
 308                          var _ret_var = Efl.PackNativeInherit.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 309       Eina.Error.RaiseIfUnhandledException();
 310                   return _ret_var;
 311  }
 312    /// <summary>Requests EFL to call the <see cref="Efl.PackLayout.UpdateLayout"/> method on this object.
 313    /// This <see cref="Efl.PackLayout.UpdateLayout"/> may be called asynchronously.</summary>
 314    /// <returns></returns>
 315    virtual public  void LayoutRequest() {
 316        Efl.PackLayoutNativeInherit.efl_pack_layout_request_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 317       Eina.Error.RaiseIfUnhandledException();
 318        }
 319    /// <summary>Implementation of this container&apos;s layout algorithm.
 320    /// EFL will call this function whenever the contents of this container need to be re-layed out on the canvas.
 321    ///
 322    /// This can be overriden to implement custom layout behaviours.</summary>
 323    /// <returns></returns>
 324    virtual public  void UpdateLayout() {
 325        Efl.PackLayoutNativeInherit.efl_pack_layout_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 326       Eina.Error.RaiseIfUnhandledException();
 327        }
 328    /// <summary>Prepend an object at the beginning of this container.
 329    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, 0).
 330    ///
 331    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 332    /// <param name="subobj">Item to pack.</param>
 333    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
 334    virtual public bool PackBegin( Efl.Gfx.Entity subobj) {
 335                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_begin_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 336       Eina.Error.RaiseIfUnhandledException();
 337                   return _ret_var;
 338  }
 339    /// <summary>Append object at the end of this container.
 340    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, -1).
 341    ///
 342    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 343    /// <param name="subobj">Item to pack at the end.</param>
 344    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
 345    virtual public bool PackEnd( Efl.Gfx.Entity subobj) {
 346                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 347       Eina.Error.RaiseIfUnhandledException();
 348                   return _ret_var;
 349  }
 350    /// <summary>Prepend item before other sub object.
 351    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 352    /// <param name="subobj">Item to pack before <c>existing</c>.</param>
 353    /// <param name="existing">Item to refer to.</param>
 354    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 355    virtual public bool PackBefore( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
 356                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_before_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  existing);
 357       Eina.Error.RaiseIfUnhandledException();
 358                               return _ret_var;
 359  }
 360    /// <summary>Append item after other sub object.
 361    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 362    /// <param name="subobj">Item to pack after <c>existing</c>.</param>
 363    /// <param name="existing">Item to refer to.</param>
 364    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 365    virtual public bool PackAfter( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
 366                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_after_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  existing);
 367       Eina.Error.RaiseIfUnhandledException();
 368                               return _ret_var;
 369  }
 370    /// <summary>Inserts <c>subobj</c> at the specified <c>index</c>.
 371    /// Valid range: -<c>count</c> to +<c>count</c>. -1 refers to the last element. Out of range indices will trigger an append.
 372    ///
 373    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 374    /// <param name="subobj">Item to pack at given index.</param>
 375    /// <param name="index">A position.</param>
 376    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 377    virtual public bool PackAt( Efl.Gfx.Entity subobj,   int index) {
 378                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  index);
 379       Eina.Error.RaiseIfUnhandledException();
 380                               return _ret_var;
 381  }
 382    /// <summary>Content at a given index in this container.
 383    /// Index -1 refers to the last item. The valid range is -(count - 1) to (count - 1).</summary>
 384    /// <param name="index">Index number</param>
 385    /// <returns>The object contained at the given <c>index</c>.</returns>
 386    virtual public Efl.Gfx.Entity GetPackContent(  int index) {
 387                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), index);
 388       Eina.Error.RaiseIfUnhandledException();
 389                   return _ret_var;
 390  }
 391    /// <summary>Get the index of a child in this container.</summary>
 392    /// <param name="subobj">An object contained in this pack.</param>
 393    /// <returns>-1 in case of failure, or the index of this item.</returns>
 394    virtual public  int GetPackIndex( Efl.Gfx.Entity subobj) {
 395                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 396       Eina.Error.RaiseIfUnhandledException();
 397                   return _ret_var;
 398  }
 399    /// <summary>Pop out item at specified <c>index</c>.
 400    /// Equivalent to unpack(content_at(<c>index</c>)).</summary>
 401    /// <param name="index">Index number</param>
 402    /// <returns>The child item if it could be removed.</returns>
 403    virtual public Efl.Gfx.Entity PackUnpackAt(  int index) {
 404                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_unpack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), index);
 405       Eina.Error.RaiseIfUnhandledException();
 406                   return _ret_var;
 407  }
 408    /// <summary>Control the direction of a given widget.
 409    /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 410    ///
 411    /// Mirroring as defined in <see cref="Efl.Ui.I18n"/> 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>
 412    /// <returns>Direction of the widget.</returns>
 413    virtual public Efl.Ui.Dir GetDirection() {
 414        var _ret_var = Efl.Ui.DirectionNativeInherit.efl_ui_direction_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 415       Eina.Error.RaiseIfUnhandledException();
 416       return _ret_var;
 417  }
 418    /// <summary>Control the direction of a given widget.
 419    /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 420    ///
 421    /// Mirroring as defined in <see cref="Efl.Ui.I18n"/> 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>
 422    /// <param name="dir">Direction of the widget.</param>
 423    /// <returns></returns>
 424    virtual public  void SetDirection( Efl.Ui.Dir dir) {
 425                          Efl.Ui.DirectionNativeInherit.efl_ui_direction_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir);
 426       Eina.Error.RaiseIfUnhandledException();
 427                    }
 428    /// <summary>Control homogeneous mode.
 429 /// This will enable the homogeneous mode where children are of the same weight and of the same min size which is determined by maximum min size of children.</summary>
 430 /// <value><c>true</c> if the box is homogeneous, <c>false</c> otherwise</value>
 431    public bool Homogeneous {
 432       get { return GetHomogeneous(); }
 433       set { SetHomogeneous( value); }
 434    }
 435    /// <summary>Control the direction of a given widget.
 436 /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 437 ///
 438 /// Mirroring as defined in <see cref="Efl.Ui.I18n"/> 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>
 439 /// <value>Direction of the widget.</value>
 440    public Efl.Ui.Dir Direction {
 441       get { return GetDirection(); }
 442       set { SetDirection( value); }
 443    }
 444    private static new  IntPtr GetEflClassStatic()
 445    {
 446       return Efl.Ui.Box.efl_ui_box_class_get();
 447    }
 448 }
 449 public class BoxNativeInherit : Efl.Ui.WidgetNativeInherit{
 450    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 451    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 452    {
 453       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 454       if (efl_ui_box_homogeneous_get_static_delegate == null)
 455       efl_ui_box_homogeneous_get_static_delegate = new efl_ui_box_homogeneous_get_delegate(homogeneous_get);
 456       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)});
 457       if (efl_ui_box_homogeneous_set_static_delegate == null)
 458       efl_ui_box_homogeneous_set_static_delegate = new efl_ui_box_homogeneous_set_delegate(homogeneous_set);
 459       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)});
 460       if (efl_content_iterate_static_delegate == null)
 461       efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 462       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)});
 463       if (efl_content_count_static_delegate == null)
 464       efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 465       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)});
 466       if (efl_pack_align_get_static_delegate == null)
 467       efl_pack_align_get_static_delegate = new efl_pack_align_get_delegate(pack_align_get);
 468       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_align_get_static_delegate)});
 469       if (efl_pack_align_set_static_delegate == null)
 470       efl_pack_align_set_static_delegate = new efl_pack_align_set_delegate(pack_align_set);
 471       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_align_set_static_delegate)});
 472       if (efl_pack_padding_get_static_delegate == null)
 473       efl_pack_padding_get_static_delegate = new efl_pack_padding_get_delegate(pack_padding_get);
 474       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_padding_get_static_delegate)});
 475       if (efl_pack_padding_set_static_delegate == null)
 476       efl_pack_padding_set_static_delegate = new efl_pack_padding_set_delegate(pack_padding_set);
 477       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_padding_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_padding_set_static_delegate)});
 478       if (efl_pack_clear_static_delegate == null)
 479       efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 480       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)});
 481       if (efl_pack_unpack_all_static_delegate == null)
 482       efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 483       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)});
 484       if (efl_pack_unpack_static_delegate == null)
 485       efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 486       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)});
 487       if (efl_pack_static_delegate == null)
 488       efl_pack_static_delegate = new efl_pack_delegate(pack);
 489       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate)});
 490       if (efl_pack_layout_request_static_delegate == null)
 491       efl_pack_layout_request_static_delegate = new efl_pack_layout_request_delegate(layout_request);
 492       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)});
 493       if (efl_pack_layout_update_static_delegate == null)
 494       efl_pack_layout_update_static_delegate = new efl_pack_layout_update_delegate(layout_update);
 495       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)});
 496       if (efl_pack_begin_static_delegate == null)
 497       efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 498       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)});
 499       if (efl_pack_end_static_delegate == null)
 500       efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 501       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)});
 502       if (efl_pack_before_static_delegate == null)
 503       efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 504       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)});
 505       if (efl_pack_after_static_delegate == null)
 506       efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 507       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)});
 508       if (efl_pack_at_static_delegate == null)
 509       efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 510       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)});
 511       if (efl_pack_content_get_static_delegate == null)
 512       efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 513       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)});
 514       if (efl_pack_index_get_static_delegate == null)
 515       efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 516       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)});
 517       if (efl_pack_unpack_at_static_delegate == null)
 518       efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 519       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)});
 520       if (efl_ui_direction_get_static_delegate == null)
 521       efl_ui_direction_get_static_delegate = new efl_ui_direction_get_delegate(direction_get);
 522       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_direction_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_direction_get_static_delegate)});
 523       if (efl_ui_direction_set_static_delegate == null)
 524       efl_ui_direction_set_static_delegate = new efl_ui_direction_set_delegate(direction_set);
 525       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_direction_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_direction_set_static_delegate)});
 526       descs.AddRange(base.GetEoOps(type));
 527       return descs;
 528    }
 529    public override IntPtr GetEflClass()
 530    {
 531       return Efl.Ui.Box.efl_ui_box_class_get();
 532    }
 533    public static new  IntPtr GetEflClassStatic()
 534    {
 535       return Efl.Ui.Box.efl_ui_box_class_get();
 536    }
 537
 538
 539     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_box_homogeneous_get_delegate(System.IntPtr obj, System.IntPtr pd);
 540
 541
 542     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_box_homogeneous_get_api_delegate(System.IntPtr obj);
 543     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");
 544     private static bool homogeneous_get(System.IntPtr obj, System.IntPtr pd)
 545    {
 546       Eina.Log.Debug("function efl_ui_box_homogeneous_get was called");
 547       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 548       if(wrapper != null) {
 549                   bool _ret_var = default(bool);
 550          try {
 551             _ret_var = ((Box)wrapper).GetHomogeneous();
 552          } catch (Exception e) {
 553             Eina.Log.Warning($"Callback error: {e.ToString()}");
 554             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 555          }
 556       return _ret_var;
 557       } else {
 558          return efl_ui_box_homogeneous_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 559       }
 560    }
 561    private static efl_ui_box_homogeneous_get_delegate efl_ui_box_homogeneous_get_static_delegate;
 562
 563
 564     private delegate  void efl_ui_box_homogeneous_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool homogeneous);
 565
 566
 567     public delegate  void efl_ui_box_homogeneous_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool homogeneous);
 568     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");
 569     private static  void homogeneous_set(System.IntPtr obj, System.IntPtr pd,  bool homogeneous)
 570    {
 571       Eina.Log.Debug("function efl_ui_box_homogeneous_set was called");
 572       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 573       if(wrapper != null) {
 574
 575          try {
 576             ((Box)wrapper).SetHomogeneous( homogeneous);
 577          } catch (Exception e) {
 578             Eina.Log.Warning($"Callback error: {e.ToString()}");
 579             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 580          }
 581                         } else {
 582          efl_ui_box_homogeneous_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  homogeneous);
 583       }
 584    }
 585    private static efl_ui_box_homogeneous_set_delegate efl_ui_box_homogeneous_set_static_delegate;
 586
 587
 588     private delegate  System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 589
 590
 591     public delegate  System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
 592     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");
 593     private static  System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
 594    {
 595       Eina.Log.Debug("function efl_content_iterate was called");
 596       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 597       if(wrapper != null) {
 598                   Eina.Iterator<Efl.Gfx.Entity> _ret_var = default(Eina.Iterator<Efl.Gfx.Entity>);
 599          try {
 600             _ret_var = ((Box)wrapper).ContentIterate();
 601          } catch (Exception e) {
 602             Eina.Log.Warning($"Callback error: {e.ToString()}");
 603             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 604          }
 605       _ret_var.Own = false; return _ret_var.Handle;
 606       } else {
 607          return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 608       }
 609    }
 610    private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
 611
 612
 613     private delegate  int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
 614
 615
 616     public delegate  int efl_content_count_api_delegate(System.IntPtr obj);
 617     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");
 618     private static  int content_count(System.IntPtr obj, System.IntPtr pd)
 619    {
 620       Eina.Log.Debug("function efl_content_count was called");
 621       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 622       if(wrapper != null) {
 623                    int _ret_var = default( int);
 624          try {
 625             _ret_var = ((Box)wrapper).ContentCount();
 626          } catch (Exception e) {
 627             Eina.Log.Warning($"Callback error: {e.ToString()}");
 628             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 629          }
 630       return _ret_var;
 631       } else {
 632          return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 633       }
 634    }
 635    private static efl_content_count_delegate efl_content_count_static_delegate;
 636
 637
 638     private delegate  void efl_pack_align_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double align_horiz,   out double align_vert);
 639
 640
 641     public delegate  void efl_pack_align_get_api_delegate(System.IntPtr obj,   out double align_horiz,   out double align_vert);
 642     public static Efl.Eo.FunctionWrapper<efl_pack_align_get_api_delegate> efl_pack_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_align_get_api_delegate>(_Module, "efl_pack_align_get");
 643     private static  void pack_align_get(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert)
 644    {
 645       Eina.Log.Debug("function efl_pack_align_get was called");
 646       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 647       if(wrapper != null) {
 648                            align_horiz = default(double);      align_vert = default(double);
 649          try {
 650             ((Box)wrapper).GetPackAlign( out align_horiz,  out align_vert);
 651          } catch (Exception e) {
 652             Eina.Log.Warning($"Callback error: {e.ToString()}");
 653             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 654          }
 655                                     } else {
 656          efl_pack_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out align_horiz,  out align_vert);
 657       }
 658    }
 659    private static efl_pack_align_get_delegate efl_pack_align_get_static_delegate;
 660
 661
 662     private delegate  void efl_pack_align_set_delegate(System.IntPtr obj, System.IntPtr pd,   double align_horiz,   double align_vert);
 663
 664
 665     public delegate  void efl_pack_align_set_api_delegate(System.IntPtr obj,   double align_horiz,   double align_vert);
 666     public static Efl.Eo.FunctionWrapper<efl_pack_align_set_api_delegate> efl_pack_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_align_set_api_delegate>(_Module, "efl_pack_align_set");
 667     private static  void pack_align_set(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert)
 668    {
 669       Eina.Log.Debug("function efl_pack_align_set was called");
 670       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 671       if(wrapper != null) {
 672
 673          try {
 674             ((Box)wrapper).SetPackAlign( align_horiz,  align_vert);
 675          } catch (Exception e) {
 676             Eina.Log.Warning($"Callback error: {e.ToString()}");
 677             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 678          }
 679                                     } else {
 680          efl_pack_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  align_horiz,  align_vert);
 681       }
 682    }
 683    private static efl_pack_align_set_delegate efl_pack_align_set_static_delegate;
 684
 685
 686     private delegate  void efl_pack_padding_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double pad_horiz,   out double pad_vert,  [MarshalAs(UnmanagedType.U1)]  out bool scalable);
 687
 688
 689     public delegate  void efl_pack_padding_get_api_delegate(System.IntPtr obj,   out double pad_horiz,   out double pad_vert,  [MarshalAs(UnmanagedType.U1)]  out bool scalable);
 690     public static Efl.Eo.FunctionWrapper<efl_pack_padding_get_api_delegate> efl_pack_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_padding_get_api_delegate>(_Module, "efl_pack_padding_get");
 691     private static  void pack_padding_get(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert,  out bool scalable)
 692    {
 693       Eina.Log.Debug("function efl_pack_padding_get was called");
 694       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 695       if(wrapper != null) {
 696                                  pad_horiz = default(double);      pad_vert = default(double);      scalable = default(bool);
 697          try {
 698             ((Box)wrapper).GetPackPadding( out pad_horiz,  out pad_vert,  out scalable);
 699          } catch (Exception e) {
 700             Eina.Log.Warning($"Callback error: {e.ToString()}");
 701             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 702          }
 703                                                 } else {
 704          efl_pack_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);
 705       }
 706    }
 707    private static efl_pack_padding_get_delegate efl_pack_padding_get_static_delegate;
 708
 709
 710     private delegate  void efl_pack_padding_set_delegate(System.IntPtr obj, System.IntPtr pd,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
 711
 712
 713     public delegate  void efl_pack_padding_set_api_delegate(System.IntPtr obj,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
 714     public static Efl.Eo.FunctionWrapper<efl_pack_padding_set_api_delegate> efl_pack_padding_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_padding_set_api_delegate>(_Module, "efl_pack_padding_set");
 715     private static  void pack_padding_set(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert,  bool scalable)
 716    {
 717       Eina.Log.Debug("function efl_pack_padding_set was called");
 718       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 719       if(wrapper != null) {
 720
 721          try {
 722             ((Box)wrapper).SetPackPadding( pad_horiz,  pad_vert,  scalable);
 723          } catch (Exception e) {
 724             Eina.Log.Warning($"Callback error: {e.ToString()}");
 725             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 726          }
 727                                                 } else {
 728          efl_pack_padding_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  pad_horiz,  pad_vert,  scalable);
 729       }
 730    }
 731    private static efl_pack_padding_set_delegate efl_pack_padding_set_static_delegate;
 732
 733
 734     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 735
 736
 737     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 738     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");
 739     private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 740    {
 741       Eina.Log.Debug("function efl_pack_clear was called");
 742       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 743       if(wrapper != null) {
 744                   bool _ret_var = default(bool);
 745          try {
 746             _ret_var = ((Box)wrapper).ClearPack();
 747          } catch (Exception e) {
 748             Eina.Log.Warning($"Callback error: {e.ToString()}");
 749             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 750          }
 751       return _ret_var;
 752       } else {
 753          return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 754       }
 755    }
 756    private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 757
 758
 759     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 760
 761
 762     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 763     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");
 764     private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 765    {
 766       Eina.Log.Debug("function efl_pack_unpack_all was called");
 767       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 768       if(wrapper != null) {
 769                   bool _ret_var = default(bool);
 770          try {
 771             _ret_var = ((Box)wrapper).UnpackAll();
 772          } catch (Exception e) {
 773             Eina.Log.Warning($"Callback error: {e.ToString()}");
 774             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 775          }
 776       return _ret_var;
 777       } else {
 778          return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 779       }
 780    }
 781    private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 782
 783
 784     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 785
 786
 787     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 788     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");
 789     private static bool unpack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 790    {
 791       Eina.Log.Debug("function efl_pack_unpack was called");
 792       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 793       if(wrapper != null) {
 794                                     bool _ret_var = default(bool);
 795          try {
 796             _ret_var = ((Box)wrapper).Unpack( subobj);
 797          } catch (Exception e) {
 798             Eina.Log.Warning($"Callback error: {e.ToString()}");
 799             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 800          }
 801                   return _ret_var;
 802       } else {
 803          return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 804       }
 805    }
 806    private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 807
 808
 809     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 810
 811
 812     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 813     public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(_Module, "efl_pack");
 814     private static bool pack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 815    {
 816       Eina.Log.Debug("function efl_pack was called");
 817       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 818       if(wrapper != null) {
 819                                     bool _ret_var = default(bool);
 820          try {
 821             _ret_var = ((Box)wrapper).DoPack( subobj);
 822          } catch (Exception e) {
 823             Eina.Log.Warning($"Callback error: {e.ToString()}");
 824             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 825          }
 826                   return _ret_var;
 827       } else {
 828          return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 829       }
 830    }
 831    private static efl_pack_delegate efl_pack_static_delegate;
 832
 833
 834     private delegate  void efl_pack_layout_request_delegate(System.IntPtr obj, System.IntPtr pd);
 835
 836
 837     public delegate  void efl_pack_layout_request_api_delegate(System.IntPtr obj);
 838     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");
 839     private static  void layout_request(System.IntPtr obj, System.IntPtr pd)
 840    {
 841       Eina.Log.Debug("function efl_pack_layout_request was called");
 842       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 843       if(wrapper != null) {
 844
 845          try {
 846             ((Box)wrapper).LayoutRequest();
 847          } catch (Exception e) {
 848             Eina.Log.Warning($"Callback error: {e.ToString()}");
 849             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 850          }
 851             } else {
 852          efl_pack_layout_request_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 853       }
 854    }
 855    private static efl_pack_layout_request_delegate efl_pack_layout_request_static_delegate;
 856
 857
 858     private delegate  void efl_pack_layout_update_delegate(System.IntPtr obj, System.IntPtr pd);
 859
 860
 861     public delegate  void efl_pack_layout_update_api_delegate(System.IntPtr obj);
 862     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");
 863     private static  void layout_update(System.IntPtr obj, System.IntPtr pd)
 864    {
 865       Eina.Log.Debug("function efl_pack_layout_update was called");
 866       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 867       if(wrapper != null) {
 868
 869          try {
 870             ((Box)wrapper).UpdateLayout();
 871          } catch (Exception e) {
 872             Eina.Log.Warning($"Callback error: {e.ToString()}");
 873             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 874          }
 875             } else {
 876          efl_pack_layout_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 877       }
 878    }
 879    private static efl_pack_layout_update_delegate efl_pack_layout_update_static_delegate;
 880
 881
 882     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 883
 884
 885     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 886     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");
 887     private static bool pack_begin(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 888    {
 889       Eina.Log.Debug("function efl_pack_begin was called");
 890       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 891       if(wrapper != null) {
 892                                     bool _ret_var = default(bool);
 893          try {
 894             _ret_var = ((Box)wrapper).PackBegin( subobj);
 895          } catch (Exception e) {
 896             Eina.Log.Warning($"Callback error: {e.ToString()}");
 897             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 898          }
 899                   return _ret_var;
 900       } else {
 901          return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 902       }
 903    }
 904    private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
 905
 906
 907     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 908
 909
 910     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 911     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");
 912     private static bool pack_end(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 913    {
 914       Eina.Log.Debug("function efl_pack_end was called");
 915       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 916       if(wrapper != null) {
 917                                     bool _ret_var = default(bool);
 918          try {
 919             _ret_var = ((Box)wrapper).PackEnd( subobj);
 920          } catch (Exception e) {
 921             Eina.Log.Warning($"Callback error: {e.ToString()}");
 922             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 923          }
 924                   return _ret_var;
 925       } else {
 926          return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 927       }
 928    }
 929    private static efl_pack_end_delegate efl_pack_end_static_delegate;
 930
 931
 932     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
 933
 934
 935     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
 936     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");
 937     private static bool pack_before(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
 938    {
 939       Eina.Log.Debug("function efl_pack_before was called");
 940       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 941       if(wrapper != null) {
 942                                                       bool _ret_var = default(bool);
 943          try {
 944             _ret_var = ((Box)wrapper).PackBefore( subobj,  existing);
 945          } catch (Exception e) {
 946             Eina.Log.Warning($"Callback error: {e.ToString()}");
 947             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 948          }
 949                               return _ret_var;
 950       } else {
 951          return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
 952       }
 953    }
 954    private static efl_pack_before_delegate efl_pack_before_static_delegate;
 955
 956
 957     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
 958
 959
 960     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
 961     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");
 962     private static bool pack_after(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
 963    {
 964       Eina.Log.Debug("function efl_pack_after was called");
 965       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 966       if(wrapper != null) {
 967                                                       bool _ret_var = default(bool);
 968          try {
 969             _ret_var = ((Box)wrapper).PackAfter( subobj,  existing);
 970          } catch (Exception e) {
 971             Eina.Log.Warning($"Callback error: {e.ToString()}");
 972             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 973          }
 974                               return _ret_var;
 975       } else {
 976          return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
 977       }
 978    }
 979    private static efl_pack_after_delegate efl_pack_after_static_delegate;
 980
 981
 982     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj,    int index);
 983
 984
 985     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj,    int index);
 986     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");
 987     private static bool pack_at(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,   int index)
 988    {
 989       Eina.Log.Debug("function efl_pack_at was called");
 990       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 991       if(wrapper != null) {
 992                                                       bool _ret_var = default(bool);
 993          try {
 994             _ret_var = ((Box)wrapper).PackAt( subobj,  index);
 995          } catch (Exception e) {
 996             Eina.Log.Warning($"Callback error: {e.ToString()}");
 997             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 998          }
 999                               return _ret_var;
1000       } else {
1001          return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  index);
1002       }
1003    }
1004    private static efl_pack_at_delegate efl_pack_at_static_delegate;
1005
1006
1007    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,    int index);
1008
1009
1010    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_pack_content_get_api_delegate(System.IntPtr obj,    int index);
1011     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");
1012     private static Efl.Gfx.Entity pack_content_get(System.IntPtr obj, System.IntPtr pd,   int index)
1013    {
1014       Eina.Log.Debug("function efl_pack_content_get was called");
1015       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1016       if(wrapper != null) {
1017                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
1018          try {
1019             _ret_var = ((Box)wrapper).GetPackContent( index);
1020          } catch (Exception e) {
1021             Eina.Log.Warning($"Callback error: {e.ToString()}");
1022             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1023          }
1024                   return _ret_var;
1025       } else {
1026          return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
1027       }
1028    }
1029    private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
1030
1031
1032     private delegate  int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
1033
1034
1035     public delegate  int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
1036     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");
1037     private static  int pack_index_get(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
1038    {
1039       Eina.Log.Debug("function efl_pack_index_get was called");
1040       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1041       if(wrapper != null) {
1042                                      int _ret_var = default( int);
1043          try {
1044             _ret_var = ((Box)wrapper).GetPackIndex( subobj);
1045          } catch (Exception e) {
1046             Eina.Log.Warning($"Callback error: {e.ToString()}");
1047             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1048          }
1049                   return _ret_var;
1050       } else {
1051          return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
1052       }
1053    }
1054    private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
1055
1056
1057    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,    int index);
1058
1059
1060    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_pack_unpack_at_api_delegate(System.IntPtr obj,    int index);
1061     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");
1062     private static Efl.Gfx.Entity pack_unpack_at(System.IntPtr obj, System.IntPtr pd,   int index)
1063    {
1064       Eina.Log.Debug("function efl_pack_unpack_at was called");
1065       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1066       if(wrapper != null) {
1067                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
1068          try {
1069             _ret_var = ((Box)wrapper).PackUnpackAt( index);
1070          } catch (Exception e) {
1071             Eina.Log.Warning($"Callback error: {e.ToString()}");
1072             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1073          }
1074                   return _ret_var;
1075       } else {
1076          return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
1077       }
1078    }
1079    private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
1080
1081
1082     private delegate Efl.Ui.Dir efl_ui_direction_get_delegate(System.IntPtr obj, System.IntPtr pd);
1083
1084
1085     public delegate Efl.Ui.Dir efl_ui_direction_get_api_delegate(System.IntPtr obj);
1086     public static Efl.Eo.FunctionWrapper<efl_ui_direction_get_api_delegate> efl_ui_direction_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_direction_get_api_delegate>(_Module, "efl_ui_direction_get");
1087     private static Efl.Ui.Dir direction_get(System.IntPtr obj, System.IntPtr pd)
1088    {
1089       Eina.Log.Debug("function efl_ui_direction_get was called");
1090       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1091       if(wrapper != null) {
1092                   Efl.Ui.Dir _ret_var = default(Efl.Ui.Dir);
1093          try {
1094             _ret_var = ((Box)wrapper).GetDirection();
1095          } catch (Exception e) {
1096             Eina.Log.Warning($"Callback error: {e.ToString()}");
1097             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1098          }
1099       return _ret_var;
1100       } else {
1101          return efl_ui_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1102       }
1103    }
1104    private static efl_ui_direction_get_delegate efl_ui_direction_get_static_delegate;
1105
1106
1107     private delegate  void efl_ui_direction_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Dir dir);
1108
1109
1110     public delegate  void efl_ui_direction_set_api_delegate(System.IntPtr obj,   Efl.Ui.Dir dir);
1111     public static Efl.Eo.FunctionWrapper<efl_ui_direction_set_api_delegate> efl_ui_direction_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_direction_set_api_delegate>(_Module, "efl_ui_direction_set");
1112     private static  void direction_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Dir dir)
1113    {
1114       Eina.Log.Debug("function efl_ui_direction_set was called");
1115       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1116       if(wrapper != null) {
1117
1118          try {
1119             ((Box)wrapper).SetDirection( dir);
1120          } catch (Exception e) {
1121             Eina.Log.Warning($"Callback error: {e.ToString()}");
1122             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1123          }
1124                         } else {
1125          efl_ui_direction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir);
1126       }
1127    }
1128    private static efl_ui_direction_set_delegate efl_ui_direction_set_static_delegate;
1129 }
1130 } }