internals/src/EflSharp/EflSharp/efl_canvas_layout_part_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 Canvas {
   8 /// <summary>Represents a Box created as part of a layout.
   9 /// Its lifetime is limited to one function call only, unless an extra reference is explicitly held.</summary>
  10 [LayoutPartBoxNativeInherit]
  11 public class LayoutPartBox : Efl.Canvas.LayoutPart, Efl.Eo.IWrapper,Efl.Container,Efl.Pack,Efl.PackLinear,Efl.Ui.Direction,Efl.Ui.DirectionReadonly
  12 {
  13    public new static System.IntPtr klass = System.IntPtr.Zero;
  14    public new static Efl.Canvas.LayoutPartBoxNativeInherit nativeInherit = new Efl.Canvas.LayoutPartBoxNativeInherit();
  15    ///<summary>Pointer to the native class description.</summary>
  16    public override System.IntPtr NativeClass {
  17       get {
  18          if (((object)this).GetType() == typeof (LayoutPartBox))
  19             return Efl.Canvas.LayoutPartBoxNativeInherit.GetEflClassStatic();
  20          else
  21             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  22       }
  23    }
  24    [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  25       efl_canvas_layout_part_box_class_get();
  26    ///<summary>Creates a new instance.</summary>
  27    ///<param name="parent">Parent instance.</param>
  28    public LayoutPartBox(Efl.Object parent= null
  29          ) :
  30       base(efl_canvas_layout_part_box_class_get(), typeof(LayoutPartBox), parent)
  31    {
  32       FinishInstantiation();
  33    }
  34    ///<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>
  35    public LayoutPartBox(System.IntPtr raw) : base(raw)
  36    {
  37             register_event_proxies();
  38    }
  39    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  40    protected LayoutPartBox(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  41    ///<summary>Casts obj into an instance of this type.</summary>
  42    public new static LayoutPartBox static_cast(Efl.Object obj)
  43    {
  44       if (obj == null)
  45          throw new System.ArgumentNullException("obj");
  46       return new LayoutPartBox(obj.NativeHandle);
  47    }
  48    ///<summary>Verifies if the given object is equal to this one.</summary>
  49    public override bool Equals(object obj)
  50    {
  51       var other = obj as Efl.Object;
  52       if (other == null)
  53          return false;
  54       return this.NativeHandle == other.NativeHandle;
  55    }
  56    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  57    public override int GetHashCode()
  58    {
  59       return this.NativeHandle.ToInt32();
  60    }
  61    ///<summary>Turns the native pointer into a string representation.</summary>
  62    public override String ToString()
  63    {
  64       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  65    }
  66 private static object ContentAddedEvtKey = new object();
  67    /// <summary>Sent after a new item was added.</summary>
  68    public event EventHandler<Efl.ContainerContentAddedEvt_Args> ContentAddedEvt
  69    {
  70       add {
  71          lock (eventLock) {
  72             string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  73             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ContentAddedEvt_delegate)) {
  74                eventHandlers.AddHandler(ContentAddedEvtKey , value);
  75             } else
  76                Eina.Log.Error($"Error adding proxy for event {key}");
  77          }
  78       }
  79       remove {
  80          lock (eventLock) {
  81             string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  82             if (remove_cpp_event_handler(key, this.evt_ContentAddedEvt_delegate)) {
  83                eventHandlers.RemoveHandler(ContentAddedEvtKey , value);
  84             } else
  85                Eina.Log.Error($"Error removing proxy for event {key}");
  86          }
  87       }
  88    }
  89    ///<summary>Method to raise event ContentAddedEvt.</summary>
  90    public void On_ContentAddedEvt(Efl.ContainerContentAddedEvt_Args e)
  91    {
  92       EventHandler<Efl.ContainerContentAddedEvt_Args> evt;
  93       lock (eventLock) {
  94       evt = (EventHandler<Efl.ContainerContentAddedEvt_Args>)eventHandlers[ContentAddedEvtKey];
  95       }
  96       evt?.Invoke(this, e);
  97    }
  98    Efl.EventCb evt_ContentAddedEvt_delegate;
  99    private void on_ContentAddedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 100    {
 101       Efl.ContainerContentAddedEvt_Args args = new Efl.ContainerContentAddedEvt_Args();
 102       args.arg = new Efl.Gfx.EntityConcrete(evt.Info);
 103       try {
 104          On_ContentAddedEvt(args);
 105       } catch (Exception e) {
 106          Eina.Log.Error(e.ToString());
 107          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 108       }
 109    }
 110
 111 private static object ContentRemovedEvtKey = new object();
 112    /// <summary>Sent after an item was removed, before unref.</summary>
 113    public event EventHandler<Efl.ContainerContentRemovedEvt_Args> ContentRemovedEvt
 114    {
 115       add {
 116          lock (eventLock) {
 117             string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 118             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ContentRemovedEvt_delegate)) {
 119                eventHandlers.AddHandler(ContentRemovedEvtKey , value);
 120             } else
 121                Eina.Log.Error($"Error adding proxy for event {key}");
 122          }
 123       }
 124       remove {
 125          lock (eventLock) {
 126             string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 127             if (remove_cpp_event_handler(key, this.evt_ContentRemovedEvt_delegate)) {
 128                eventHandlers.RemoveHandler(ContentRemovedEvtKey , value);
 129             } else
 130                Eina.Log.Error($"Error removing proxy for event {key}");
 131          }
 132       }
 133    }
 134    ///<summary>Method to raise event ContentRemovedEvt.</summary>
 135    public void On_ContentRemovedEvt(Efl.ContainerContentRemovedEvt_Args e)
 136    {
 137       EventHandler<Efl.ContainerContentRemovedEvt_Args> evt;
 138       lock (eventLock) {
 139       evt = (EventHandler<Efl.ContainerContentRemovedEvt_Args>)eventHandlers[ContentRemovedEvtKey];
 140       }
 141       evt?.Invoke(this, e);
 142    }
 143    Efl.EventCb evt_ContentRemovedEvt_delegate;
 144    private void on_ContentRemovedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 145    {
 146       Efl.ContainerContentRemovedEvt_Args args = new Efl.ContainerContentRemovedEvt_Args();
 147       args.arg = new Efl.Gfx.EntityConcrete(evt.Info);
 148       try {
 149          On_ContentRemovedEvt(args);
 150       } catch (Exception e) {
 151          Eina.Log.Error(e.ToString());
 152          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 153       }
 154    }
 155
 156    protected override void register_event_proxies()
 157    {
 158       base.register_event_proxies();
 159       evt_ContentAddedEvt_delegate = new Efl.EventCb(on_ContentAddedEvt_NativeCallback);
 160       evt_ContentRemovedEvt_delegate = new Efl.EventCb(on_ContentRemovedEvt_NativeCallback);
 161    }
 162    /// <summary>Begin iterating over this object&apos;s contents.</summary>
 163    /// <returns>Iterator to object content</returns>
 164    virtual public Eina.Iterator<Efl.Gfx.Entity> ContentIterate() {
 165        var _ret_var = Efl.ContainerNativeInherit.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 166       Eina.Error.RaiseIfUnhandledException();
 167       return new Eina.Iterator<Efl.Gfx.Entity>(_ret_var, true, false);
 168  }
 169    /// <summary>Returns the number of UI elements packed in this container.</summary>
 170    /// <returns>Number of packed UI elements</returns>
 171    virtual public  int ContentCount() {
 172        var _ret_var = Efl.ContainerNativeInherit.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 173       Eina.Error.RaiseIfUnhandledException();
 174       return _ret_var;
 175  }
 176    /// <summary>Alignment of the container within its bounds</summary>
 177    /// <param name="align_horiz">Horizontal alignment</param>
 178    /// <param name="align_vert">Vertical alignment</param>
 179    /// <returns></returns>
 180    virtual public  void GetPackAlign( out double align_horiz,  out double align_vert) {
 181                                            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);
 182       Eina.Error.RaiseIfUnhandledException();
 183                                }
 184    /// <summary>Alignment of the container within its bounds</summary>
 185    /// <param name="align_horiz">Horizontal alignment</param>
 186    /// <param name="align_vert">Vertical alignment</param>
 187    /// <returns></returns>
 188    virtual public  void SetPackAlign( double align_horiz,  double align_vert) {
 189                                            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);
 190       Eina.Error.RaiseIfUnhandledException();
 191                                }
 192    /// <summary>Padding between items contained in this object.</summary>
 193    /// <param name="pad_horiz">Horizontal padding</param>
 194    /// <param name="pad_vert">Vertical padding</param>
 195    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 196    /// <returns></returns>
 197    virtual public  void GetPackPadding( out double pad_horiz,  out double pad_vert,  out bool scalable) {
 198                                                              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);
 199       Eina.Error.RaiseIfUnhandledException();
 200                                            }
 201    /// <summary>Padding between items contained in this object.</summary>
 202    /// <param name="pad_horiz">Horizontal padding</param>
 203    /// <param name="pad_vert">Vertical padding</param>
 204    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 205    /// <returns></returns>
 206    virtual public  void SetPackPadding( double pad_horiz,  double pad_vert,  bool scalable) {
 207                                                              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);
 208       Eina.Error.RaiseIfUnhandledException();
 209                                            }
 210    /// <summary>Removes all packed contents, and unreferences them.</summary>
 211    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 212    virtual public bool ClearPack() {
 213        var _ret_var = Efl.PackNativeInherit.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 214       Eina.Error.RaiseIfUnhandledException();
 215       return _ret_var;
 216  }
 217    /// <summary>Removes all packed contents, without unreferencing them.
 218    /// Use with caution.</summary>
 219    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 220    virtual public bool UnpackAll() {
 221        var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 222       Eina.Error.RaiseIfUnhandledException();
 223       return _ret_var;
 224  }
 225    /// <summary>Removes an existing item from the container, without deleting it.</summary>
 226    /// <param name="subobj">The unpacked object.</param>
 227    /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t a child or can&apos;t be removed</returns>
 228    virtual public bool Unpack( Efl.Gfx.Entity subobj) {
 229                          var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 230       Eina.Error.RaiseIfUnhandledException();
 231                   return _ret_var;
 232  }
 233    /// <summary>Adds an item to this container.
 234    /// 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.
 235    ///
 236    /// 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>
 237    /// <param name="subobj">An object to pack.</param>
 238    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 239    virtual public bool DoPack( Efl.Gfx.Entity subobj) {
 240                          var _ret_var = Efl.PackNativeInherit.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 241       Eina.Error.RaiseIfUnhandledException();
 242                   return _ret_var;
 243  }
 244    /// <summary>Prepend an object at the beginning of this container.
 245    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, 0).
 246    ///
 247    /// 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>
 248    /// <param name="subobj">Item to pack.</param>
 249    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
 250    virtual public bool PackBegin( Efl.Gfx.Entity subobj) {
 251                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_begin_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 252       Eina.Error.RaiseIfUnhandledException();
 253                   return _ret_var;
 254  }
 255    /// <summary>Append object at the end of this container.
 256    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, -1).
 257    ///
 258    /// 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>
 259    /// <param name="subobj">Item to pack at the end.</param>
 260    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
 261    virtual public bool PackEnd( Efl.Gfx.Entity subobj) {
 262                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 263       Eina.Error.RaiseIfUnhandledException();
 264                   return _ret_var;
 265  }
 266    /// <summary>Prepend item before other sub object.
 267    /// 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>
 268    /// <param name="subobj">Item to pack before <c>existing</c>.</param>
 269    /// <param name="existing">Item to refer to.</param>
 270    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 271    virtual public bool PackBefore( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
 272                                            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);
 273       Eina.Error.RaiseIfUnhandledException();
 274                               return _ret_var;
 275  }
 276    /// <summary>Append item after other sub object.
 277    /// 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>
 278    /// <param name="subobj">Item to pack after <c>existing</c>.</param>
 279    /// <param name="existing">Item to refer to.</param>
 280    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 281    virtual public bool PackAfter( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
 282                                            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);
 283       Eina.Error.RaiseIfUnhandledException();
 284                               return _ret_var;
 285  }
 286    /// <summary>Inserts <c>subobj</c> at the specified <c>index</c>.
 287    /// Valid range: -<c>count</c> to +<c>count</c>. -1 refers to the last element. Out of range indices will trigger an append.
 288    ///
 289    /// 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>
 290    /// <param name="subobj">Item to pack at given index.</param>
 291    /// <param name="index">A position.</param>
 292    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 293    virtual public bool PackAt( Efl.Gfx.Entity subobj,   int index) {
 294                                            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);
 295       Eina.Error.RaiseIfUnhandledException();
 296                               return _ret_var;
 297  }
 298    /// <summary>Content at a given index in this container.
 299    /// Index -1 refers to the last item. The valid range is -(count - 1) to (count - 1).</summary>
 300    /// <param name="index">Index number</param>
 301    /// <returns>The object contained at the given <c>index</c>.</returns>
 302    virtual public Efl.Gfx.Entity GetPackContent(  int index) {
 303                          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);
 304       Eina.Error.RaiseIfUnhandledException();
 305                   return _ret_var;
 306  }
 307    /// <summary>Get the index of a child in this container.</summary>
 308    /// <param name="subobj">An object contained in this pack.</param>
 309    /// <returns>-1 in case of failure, or the index of this item.</returns>
 310    virtual public  int GetPackIndex( Efl.Gfx.Entity subobj) {
 311                          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);
 312       Eina.Error.RaiseIfUnhandledException();
 313                   return _ret_var;
 314  }
 315    /// <summary>Pop out item at specified <c>index</c>.
 316    /// Equivalent to unpack(content_at(<c>index</c>)).</summary>
 317    /// <param name="index">Index number</param>
 318    /// <returns>The child item if it could be removed.</returns>
 319    virtual public Efl.Gfx.Entity PackUnpackAt(  int index) {
 320                          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);
 321       Eina.Error.RaiseIfUnhandledException();
 322                   return _ret_var;
 323  }
 324    /// <summary>Control the direction of a given widget.
 325    /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 326    ///
 327    /// 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>
 328    /// <returns>Direction of the widget.</returns>
 329    virtual public Efl.Ui.Dir GetDirection() {
 330        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));
 331       Eina.Error.RaiseIfUnhandledException();
 332       return _ret_var;
 333  }
 334    /// <summary>Control the direction of a given widget.
 335    /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 336    ///
 337    /// 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>
 338    /// <param name="dir">Direction of the widget.</param>
 339    /// <returns></returns>
 340    virtual public  void SetDirection( Efl.Ui.Dir dir) {
 341                          Efl.Ui.DirectionNativeInherit.efl_ui_direction_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir);
 342       Eina.Error.RaiseIfUnhandledException();
 343                    }
 344    /// <summary>Control the direction of a given widget.
 345 /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 346 ///
 347 /// 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>
 348 /// <value>Direction of the widget.</value>
 349    public Efl.Ui.Dir Direction {
 350       get { return GetDirection(); }
 351       set { SetDirection( value); }
 352    }
 353    private static new  IntPtr GetEflClassStatic()
 354    {
 355       return Efl.Canvas.LayoutPartBox.efl_canvas_layout_part_box_class_get();
 356    }
 357 }
 358 public class LayoutPartBoxNativeInherit : Efl.Canvas.LayoutPartNativeInherit{
 359    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Edje);
 360    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 361    {
 362       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 363       if (efl_content_iterate_static_delegate == null)
 364       efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 365       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)});
 366       if (efl_content_count_static_delegate == null)
 367       efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 368       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)});
 369       if (efl_pack_align_get_static_delegate == null)
 370       efl_pack_align_get_static_delegate = new efl_pack_align_get_delegate(pack_align_get);
 371       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)});
 372       if (efl_pack_align_set_static_delegate == null)
 373       efl_pack_align_set_static_delegate = new efl_pack_align_set_delegate(pack_align_set);
 374       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)});
 375       if (efl_pack_padding_get_static_delegate == null)
 376       efl_pack_padding_get_static_delegate = new efl_pack_padding_get_delegate(pack_padding_get);
 377       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)});
 378       if (efl_pack_padding_set_static_delegate == null)
 379       efl_pack_padding_set_static_delegate = new efl_pack_padding_set_delegate(pack_padding_set);
 380       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)});
 381       if (efl_pack_clear_static_delegate == null)
 382       efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 383       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)});
 384       if (efl_pack_unpack_all_static_delegate == null)
 385       efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 386       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)});
 387       if (efl_pack_unpack_static_delegate == null)
 388       efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 389       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)});
 390       if (efl_pack_static_delegate == null)
 391       efl_pack_static_delegate = new efl_pack_delegate(pack);
 392       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate)});
 393       if (efl_pack_begin_static_delegate == null)
 394       efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 395       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)});
 396       if (efl_pack_end_static_delegate == null)
 397       efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 398       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)});
 399       if (efl_pack_before_static_delegate == null)
 400       efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 401       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)});
 402       if (efl_pack_after_static_delegate == null)
 403       efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 404       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)});
 405       if (efl_pack_at_static_delegate == null)
 406       efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 407       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)});
 408       if (efl_pack_content_get_static_delegate == null)
 409       efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 410       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)});
 411       if (efl_pack_index_get_static_delegate == null)
 412       efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 413       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)});
 414       if (efl_pack_unpack_at_static_delegate == null)
 415       efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 416       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)});
 417       if (efl_ui_direction_get_static_delegate == null)
 418       efl_ui_direction_get_static_delegate = new efl_ui_direction_get_delegate(direction_get);
 419       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)});
 420       if (efl_ui_direction_set_static_delegate == null)
 421       efl_ui_direction_set_static_delegate = new efl_ui_direction_set_delegate(direction_set);
 422       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)});
 423       descs.AddRange(base.GetEoOps(type));
 424       return descs;
 425    }
 426    public override IntPtr GetEflClass()
 427    {
 428       return Efl.Canvas.LayoutPartBox.efl_canvas_layout_part_box_class_get();
 429    }
 430    public static new  IntPtr GetEflClassStatic()
 431    {
 432       return Efl.Canvas.LayoutPartBox.efl_canvas_layout_part_box_class_get();
 433    }
 434
 435
 436     private delegate  System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 437
 438
 439     public delegate  System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
 440     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");
 441     private static  System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
 442    {
 443       Eina.Log.Debug("function efl_content_iterate was called");
 444       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 445       if(wrapper != null) {
 446                   Eina.Iterator<Efl.Gfx.Entity> _ret_var = default(Eina.Iterator<Efl.Gfx.Entity>);
 447          try {
 448             _ret_var = ((LayoutPartBox)wrapper).ContentIterate();
 449          } catch (Exception e) {
 450             Eina.Log.Warning($"Callback error: {e.ToString()}");
 451             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 452          }
 453       _ret_var.Own = false; return _ret_var.Handle;
 454       } else {
 455          return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 456       }
 457    }
 458    private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
 459
 460
 461     private delegate  int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
 462
 463
 464     public delegate  int efl_content_count_api_delegate(System.IntPtr obj);
 465     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");
 466     private static  int content_count(System.IntPtr obj, System.IntPtr pd)
 467    {
 468       Eina.Log.Debug("function efl_content_count was called");
 469       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 470       if(wrapper != null) {
 471                    int _ret_var = default( int);
 472          try {
 473             _ret_var = ((LayoutPartBox)wrapper).ContentCount();
 474          } catch (Exception e) {
 475             Eina.Log.Warning($"Callback error: {e.ToString()}");
 476             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 477          }
 478       return _ret_var;
 479       } else {
 480          return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 481       }
 482    }
 483    private static efl_content_count_delegate efl_content_count_static_delegate;
 484
 485
 486     private delegate  void efl_pack_align_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double align_horiz,   out double align_vert);
 487
 488
 489     public delegate  void efl_pack_align_get_api_delegate(System.IntPtr obj,   out double align_horiz,   out double align_vert);
 490     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");
 491     private static  void pack_align_get(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert)
 492    {
 493       Eina.Log.Debug("function efl_pack_align_get was called");
 494       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 495       if(wrapper != null) {
 496                            align_horiz = default(double);      align_vert = default(double);
 497          try {
 498             ((LayoutPartBox)wrapper).GetPackAlign( out align_horiz,  out align_vert);
 499          } catch (Exception e) {
 500             Eina.Log.Warning($"Callback error: {e.ToString()}");
 501             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 502          }
 503                                     } else {
 504          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);
 505       }
 506    }
 507    private static efl_pack_align_get_delegate efl_pack_align_get_static_delegate;
 508
 509
 510     private delegate  void efl_pack_align_set_delegate(System.IntPtr obj, System.IntPtr pd,   double align_horiz,   double align_vert);
 511
 512
 513     public delegate  void efl_pack_align_set_api_delegate(System.IntPtr obj,   double align_horiz,   double align_vert);
 514     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");
 515     private static  void pack_align_set(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert)
 516    {
 517       Eina.Log.Debug("function efl_pack_align_set was called");
 518       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 519       if(wrapper != null) {
 520
 521          try {
 522             ((LayoutPartBox)wrapper).SetPackAlign( align_horiz,  align_vert);
 523          } catch (Exception e) {
 524             Eina.Log.Warning($"Callback error: {e.ToString()}");
 525             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 526          }
 527                                     } else {
 528          efl_pack_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  align_horiz,  align_vert);
 529       }
 530    }
 531    private static efl_pack_align_set_delegate efl_pack_align_set_static_delegate;
 532
 533
 534     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);
 535
 536
 537     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);
 538     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");
 539     private static  void pack_padding_get(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert,  out bool scalable)
 540    {
 541       Eina.Log.Debug("function efl_pack_padding_get was called");
 542       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 543       if(wrapper != null) {
 544                                  pad_horiz = default(double);      pad_vert = default(double);      scalable = default(bool);
 545          try {
 546             ((LayoutPartBox)wrapper).GetPackPadding( out pad_horiz,  out pad_vert,  out scalable);
 547          } catch (Exception e) {
 548             Eina.Log.Warning($"Callback error: {e.ToString()}");
 549             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 550          }
 551                                                 } else {
 552          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);
 553       }
 554    }
 555    private static efl_pack_padding_get_delegate efl_pack_padding_get_static_delegate;
 556
 557
 558     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);
 559
 560
 561     public delegate  void efl_pack_padding_set_api_delegate(System.IntPtr obj,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
 562     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");
 563     private static  void pack_padding_set(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert,  bool scalable)
 564    {
 565       Eina.Log.Debug("function efl_pack_padding_set was called");
 566       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 567       if(wrapper != null) {
 568
 569          try {
 570             ((LayoutPartBox)wrapper).SetPackPadding( pad_horiz,  pad_vert,  scalable);
 571          } catch (Exception e) {
 572             Eina.Log.Warning($"Callback error: {e.ToString()}");
 573             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 574          }
 575                                                 } else {
 576          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);
 577       }
 578    }
 579    private static efl_pack_padding_set_delegate efl_pack_padding_set_static_delegate;
 580
 581
 582     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 583
 584
 585     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 586     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");
 587     private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 588    {
 589       Eina.Log.Debug("function efl_pack_clear was called");
 590       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 591       if(wrapper != null) {
 592                   bool _ret_var = default(bool);
 593          try {
 594             _ret_var = ((LayoutPartBox)wrapper).ClearPack();
 595          } catch (Exception e) {
 596             Eina.Log.Warning($"Callback error: {e.ToString()}");
 597             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 598          }
 599       return _ret_var;
 600       } else {
 601          return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 602       }
 603    }
 604    private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 605
 606
 607     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 608
 609
 610     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 611     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");
 612     private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 613    {
 614       Eina.Log.Debug("function efl_pack_unpack_all was called");
 615       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 616       if(wrapper != null) {
 617                   bool _ret_var = default(bool);
 618          try {
 619             _ret_var = ((LayoutPartBox)wrapper).UnpackAll();
 620          } catch (Exception e) {
 621             Eina.Log.Warning($"Callback error: {e.ToString()}");
 622             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 623          }
 624       return _ret_var;
 625       } else {
 626          return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 627       }
 628    }
 629    private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 630
 631
 632     [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);
 633
 634
 635     [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);
 636     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");
 637     private static bool unpack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 638    {
 639       Eina.Log.Debug("function efl_pack_unpack was called");
 640       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 641       if(wrapper != null) {
 642                                     bool _ret_var = default(bool);
 643          try {
 644             _ret_var = ((LayoutPartBox)wrapper).Unpack( subobj);
 645          } catch (Exception e) {
 646             Eina.Log.Warning($"Callback error: {e.ToString()}");
 647             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 648          }
 649                   return _ret_var;
 650       } else {
 651          return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 652       }
 653    }
 654    private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 655
 656
 657     [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);
 658
 659
 660     [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);
 661     public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(_Module, "efl_pack");
 662     private static bool pack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 663    {
 664       Eina.Log.Debug("function efl_pack was called");
 665       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 666       if(wrapper != null) {
 667                                     bool _ret_var = default(bool);
 668          try {
 669             _ret_var = ((LayoutPartBox)wrapper).DoPack( subobj);
 670          } catch (Exception e) {
 671             Eina.Log.Warning($"Callback error: {e.ToString()}");
 672             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 673          }
 674                   return _ret_var;
 675       } else {
 676          return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 677       }
 678    }
 679    private static efl_pack_delegate efl_pack_static_delegate;
 680
 681
 682     [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);
 683
 684
 685     [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);
 686     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");
 687     private static bool pack_begin(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 688    {
 689       Eina.Log.Debug("function efl_pack_begin was called");
 690       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 691       if(wrapper != null) {
 692                                     bool _ret_var = default(bool);
 693          try {
 694             _ret_var = ((LayoutPartBox)wrapper).PackBegin( subobj);
 695          } catch (Exception e) {
 696             Eina.Log.Warning($"Callback error: {e.ToString()}");
 697             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 698          }
 699                   return _ret_var;
 700       } else {
 701          return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 702       }
 703    }
 704    private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
 705
 706
 707     [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);
 708
 709
 710     [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);
 711     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");
 712     private static bool pack_end(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 713    {
 714       Eina.Log.Debug("function efl_pack_end was called");
 715       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 716       if(wrapper != null) {
 717                                     bool _ret_var = default(bool);
 718          try {
 719             _ret_var = ((LayoutPartBox)wrapper).PackEnd( subobj);
 720          } catch (Exception e) {
 721             Eina.Log.Warning($"Callback error: {e.ToString()}");
 722             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 723          }
 724                   return _ret_var;
 725       } else {
 726          return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 727       }
 728    }
 729    private static efl_pack_end_delegate efl_pack_end_static_delegate;
 730
 731
 732     [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);
 733
 734
 735     [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);
 736     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");
 737     private static bool pack_before(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
 738    {
 739       Eina.Log.Debug("function efl_pack_before was called");
 740       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 741       if(wrapper != null) {
 742                                                       bool _ret_var = default(bool);
 743          try {
 744             _ret_var = ((LayoutPartBox)wrapper).PackBefore( subobj,  existing);
 745          } catch (Exception e) {
 746             Eina.Log.Warning($"Callback error: {e.ToString()}");
 747             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 748          }
 749                               return _ret_var;
 750       } else {
 751          return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
 752       }
 753    }
 754    private static efl_pack_before_delegate efl_pack_before_static_delegate;
 755
 756
 757     [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);
 758
 759
 760     [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);
 761     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");
 762     private static bool pack_after(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
 763    {
 764       Eina.Log.Debug("function efl_pack_after was called");
 765       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 766       if(wrapper != null) {
 767                                                       bool _ret_var = default(bool);
 768          try {
 769             _ret_var = ((LayoutPartBox)wrapper).PackAfter( subobj,  existing);
 770          } catch (Exception e) {
 771             Eina.Log.Warning($"Callback error: {e.ToString()}");
 772             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 773          }
 774                               return _ret_var;
 775       } else {
 776          return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
 777       }
 778    }
 779    private static efl_pack_after_delegate efl_pack_after_static_delegate;
 780
 781
 782     [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);
 783
 784
 785     [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);
 786     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");
 787     private static bool pack_at(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,   int index)
 788    {
 789       Eina.Log.Debug("function efl_pack_at was called");
 790       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 791       if(wrapper != null) {
 792                                                       bool _ret_var = default(bool);
 793          try {
 794             _ret_var = ((LayoutPartBox)wrapper).PackAt( subobj,  index);
 795          } catch (Exception e) {
 796             Eina.Log.Warning($"Callback error: {e.ToString()}");
 797             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 798          }
 799                               return _ret_var;
 800       } else {
 801          return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  index);
 802       }
 803    }
 804    private static efl_pack_at_delegate efl_pack_at_static_delegate;
 805
 806
 807    [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);
 808
 809
 810    [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);
 811     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");
 812     private static Efl.Gfx.Entity pack_content_get(System.IntPtr obj, System.IntPtr pd,   int index)
 813    {
 814       Eina.Log.Debug("function efl_pack_content_get was called");
 815       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 816       if(wrapper != null) {
 817                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
 818          try {
 819             _ret_var = ((LayoutPartBox)wrapper).GetPackContent( index);
 820          } catch (Exception e) {
 821             Eina.Log.Warning($"Callback error: {e.ToString()}");
 822             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 823          }
 824                   return _ret_var;
 825       } else {
 826          return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
 827       }
 828    }
 829    private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
 830
 831
 832     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);
 833
 834
 835     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);
 836     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");
 837     private static  int pack_index_get(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 838    {
 839       Eina.Log.Debug("function efl_pack_index_get was called");
 840       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 841       if(wrapper != null) {
 842                                      int _ret_var = default( int);
 843          try {
 844             _ret_var = ((LayoutPartBox)wrapper).GetPackIndex( subobj);
 845          } catch (Exception e) {
 846             Eina.Log.Warning($"Callback error: {e.ToString()}");
 847             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 848          }
 849                   return _ret_var;
 850       } else {
 851          return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 852       }
 853    }
 854    private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
 855
 856
 857    [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);
 858
 859
 860    [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);
 861     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");
 862     private static Efl.Gfx.Entity pack_unpack_at(System.IntPtr obj, System.IntPtr pd,   int index)
 863    {
 864       Eina.Log.Debug("function efl_pack_unpack_at was called");
 865       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 866       if(wrapper != null) {
 867                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
 868          try {
 869             _ret_var = ((LayoutPartBox)wrapper).PackUnpackAt( index);
 870          } catch (Exception e) {
 871             Eina.Log.Warning($"Callback error: {e.ToString()}");
 872             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 873          }
 874                   return _ret_var;
 875       } else {
 876          return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
 877       }
 878    }
 879    private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
 880
 881
 882     private delegate Efl.Ui.Dir efl_ui_direction_get_delegate(System.IntPtr obj, System.IntPtr pd);
 883
 884
 885     public delegate Efl.Ui.Dir efl_ui_direction_get_api_delegate(System.IntPtr obj);
 886     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");
 887     private static Efl.Ui.Dir direction_get(System.IntPtr obj, System.IntPtr pd)
 888    {
 889       Eina.Log.Debug("function efl_ui_direction_get was called");
 890       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 891       if(wrapper != null) {
 892                   Efl.Ui.Dir _ret_var = default(Efl.Ui.Dir);
 893          try {
 894             _ret_var = ((LayoutPartBox)wrapper).GetDirection();
 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_ui_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 902       }
 903    }
 904    private static efl_ui_direction_get_delegate efl_ui_direction_get_static_delegate;
 905
 906
 907     private delegate  void efl_ui_direction_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Dir dir);
 908
 909
 910     public delegate  void efl_ui_direction_set_api_delegate(System.IntPtr obj,   Efl.Ui.Dir dir);
 911     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");
 912     private static  void direction_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Dir dir)
 913    {
 914       Eina.Log.Debug("function efl_ui_direction_set was called");
 915       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 916       if(wrapper != null) {
 917
 918          try {
 919             ((LayoutPartBox)wrapper).SetDirection( dir);
 920          } catch (Exception e) {
 921             Eina.Log.Warning($"Callback error: {e.ToString()}");
 922             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 923          }
 924                         } else {
 925          efl_ui_direction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir);
 926       }
 927    }
 928    private static efl_ui_direction_set_delegate efl_ui_direction_set_static_delegate;
 929 }
 930 } }