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