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

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