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.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 /// <summary>API for containers</summary>
  11 [Efl.IPackLinearConcrete.NativeMethods]
  12 public interface IPackLinear :
  13     Efl.IPack ,
  14     Efl.Eo.IWrapper, IDisposable
  15 {
  16     /// <summary>Prepend an object at the beginning of this container.
  17 /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
  18 ///
  19 /// 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>
  20 /// <param name="subobj">Item to pack at the beginning.</param>
  21 /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
  22 bool PackBegin(Efl.Gfx.IEntity subobj);
  23     /// <summary>Append item at the end of this container.
  24 /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
  25 ///
  26 /// 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>
  27 /// <param name="subobj">Item to pack at the end.</param>
  28 /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
  29 bool PackEnd(Efl.Gfx.IEntity subobj);
  30     /// <summary>Prepend item before other sub object.
  31 /// 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>
  32 /// <param name="subobj">Item to pack before <c>existing</c>.</param>
  33 /// <param name="existing">Item to refer to.</param>
  34 /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
  35 bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing);
  36     /// <summary>Append item after other sub object.
  37 /// 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>
  38 /// <param name="subobj">Item to pack after <c>existing</c>.</param>
  39 /// <param name="existing">Item to refer to.</param>
  40 /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
  41 bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing);
  42     /// <summary>Inserts <c>subobj</c> BEFORE the item at position <c>index</c>.
  43 /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first item (0) to last item (<c>count</c>-1), and negative numbers go from last item (-1) to first item (-<c>count</c>). Where <c>count</c> is the number of items currently in the container.
  44 ///
  45 /// If <c>index</c> is less than -<c>count</c>, it will trigger <see cref="Efl.IPackLinear.PackBegin"/>(<c>subobj</c>) whereas <c>index</c> greater than <c>count</c>-1 will trigger <see cref="Efl.IPackLinear.PackEnd"/>(<c>subobj</c>).
  46 ///
  47 /// 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>
  48 /// <param name="subobj">Item to pack.</param>
  49 /// <param name="index">Index of item to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
  50 /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
  51 bool PackAt(Efl.Gfx.IEntity subobj, int index);
  52     /// <summary>Content at a given <c>index</c> in this container.
  53 /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first item (0) to last item (<c>count</c>-1), and negative numbers go from last item (-1) to first item (-<c>count</c>). Where <c>count</c> is the number of items currently in the container.
  54 ///
  55 /// If <c>index</c> is less than -<c>count</c>, it will return the first item whereas <c>index</c> greater than <c>count</c>-1 will return the last item.</summary>
  56 /// <param name="index">Index of the item to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
  57 /// <returns>The object contained at the given <c>index</c>.</returns>
  58 Efl.Gfx.IEntity GetPackContent(int index);
  59     /// <summary>Get the index of a child in this container.</summary>
  60 /// <param name="subobj">An object contained in this pack.</param>
  61 /// <returns>-1 in case <c>subobj</c> is not a child of this object, or the index of this item in the range 0 to (<c>count</c>-1).</returns>
  62 int GetPackIndex(Efl.Gfx.IEntity subobj);
  63     /// <summary>Pop out (remove) the item at the specified <c>index</c>.
  64 /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first item (0) to last item (<c>count</c>-1), and negative numbers go from last item (-1) to first item (-<c>count</c>). Where <c>count</c> is the number of items currently in the container.
  65 ///
  66 /// If <c>index</c> is less than -<c>count</c>, it will remove the first item whereas <c>index</c> greater than <c>count</c>-1 will remove the last item.
  67 ///
  68 /// Equivalent to <see cref="Efl.IPack.Unpack"/>(<see cref="Efl.IPackLinear.GetPackContent"/>(<c>index</c>)).</summary>
  69 /// <param name="index">Index of item to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
  70 /// <returns>The child item if it could be removed.</returns>
  71 Efl.Gfx.IEntity PackUnpackAt(int index);
  72                                 }
  73 /// <summary>API for containers</summary>
  74 sealed public class IPackLinearConcrete :
  75
  76 IPackLinear
  77     , Efl.IContainer, Efl.IPack
  78 {
  79     ///<summary>Pointer to the native class description.</summary>
  80     public System.IntPtr NativeClass
  81     {
  82         get
  83         {
  84             if (((object)this).GetType() == typeof(IPackLinearConcrete))
  85             {
  86                 return GetEflClassStatic();
  87             }
  88             else
  89             {
  90                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  91             }
  92         }
  93     }
  94
  95     private Dictionary<(IntPtr desc, object evtDelegate), (IntPtr evtCallerPtr, Efl.EventCb evtCaller)> eoEvents = new Dictionary<(IntPtr desc, object evtDelegate), (IntPtr evtCallerPtr, Efl.EventCb evtCaller)>();
  96     private readonly object eventLock = new object();
  97     private  System.IntPtr handle;
  98     ///<summary>Pointer to the native instance.</summary>
  99     public System.IntPtr NativeHandle
 100     {
 101         get { return handle; }
 102     }
 103
 104     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 105         efl_pack_linear_interface_get();
 106     /// <summary>Initializes a new instance of the <see cref="IPackLinear"/> class.
 107     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 108     private IPackLinearConcrete(System.IntPtr raw)
 109     {
 110         handle = raw;
 111     }
 112     ///<summary>Destructor.</summary>
 113     ~IPackLinearConcrete()
 114     {
 115         Dispose(false);
 116     }
 117
 118     ///<summary>Releases the underlying native instance.</summary>
 119     private void Dispose(bool disposing)
 120     {
 121         if (handle != System.IntPtr.Zero)
 122         {
 123             IntPtr h = handle;
 124             handle = IntPtr.Zero;
 125
 126             IntPtr gcHandlePtr = IntPtr.Zero;
 127             if (eoEvents.Count != 0)
 128             {
 129                 GCHandle gcHandle = GCHandle.Alloc(eoEvents);
 130                 gcHandlePtr = GCHandle.ToIntPtr(gcHandle);
 131             }
 132
 133             if (disposing)
 134             {
 135                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 136             }
 137             else
 138             {
 139                 Monitor.Enter(Efl.All.InitLock);
 140                 if (Efl.All.MainLoopInitialized)
 141                 {
 142                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 143                 }
 144
 145                 Monitor.Exit(Efl.All.InitLock);
 146             }
 147         }
 148
 149     }
 150
 151     ///<summary>Releases the underlying native instance.</summary>
 152     public void Dispose()
 153     {
 154         Dispose(true);
 155         GC.SuppressFinalize(this);
 156     }
 157
 158     /// <summary>Verifies if the given object is equal to this one.</summary>
 159     /// <param name="instance">The object to compare to.</param>
 160     /// <returns>True if both objects point to the same native object.</returns>
 161     public override bool Equals(object instance)
 162     {
 163         var other = instance as Efl.Object;
 164         if (other == null)
 165         {
 166             return false;
 167         }
 168         return this.NativeHandle == other.NativeHandle;
 169     }
 170
 171     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 172     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 173     public override int GetHashCode()
 174     {
 175         return this.NativeHandle.ToInt32();
 176     }
 177
 178     /// <summary>Turns the native pointer into a string representation.</summary>
 179     /// <returns>A string with the type and the native pointer for this object.</returns>
 180     public override String ToString()
 181     {
 182         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 183     }
 184
 185     ///<summary>Adds a new event handler, registering it to the native event. For internal use only.</summary>
 186     ///<param name="lib">The name of the native library definining the event.</param>
 187     ///<param name="key">The name of the native event.</param>
 188     ///<param name="evtCaller">Delegate to be called by native code on event raising.</param>
 189     ///<param name="evtDelegate">Managed delegate that will be called by evtCaller on event raising.</param>
 190     private void AddNativeEventHandler(string lib, string key, Efl.EventCb evtCaller, object evtDelegate)
 191     {
 192         IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 193         if (desc == IntPtr.Zero)
 194         {
 195             Eina.Log.Error($"Failed to get native event {key}");
 196         }
 197
 198         if (eoEvents.ContainsKey((desc, evtDelegate)))
 199         {
 200             Eina.Log.Warning($"Event proxy for event {key} already registered!");
 201             return;
 202         }
 203
 204         IntPtr evtCallerPtr = Marshal.GetFunctionPointerForDelegate(evtCaller);
 205         if (!Efl.Eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evtCallerPtr, IntPtr.Zero))
 206         {
 207             Eina.Log.Error($"Failed to add event proxy for event {key}");
 208             return;
 209         }
 210
 211         eoEvents[(desc, evtDelegate)] = (evtCallerPtr, evtCaller);
 212         Eina.Error.RaiseIfUnhandledException();
 213     }
 214
 215     ///<summary>Removes the given event handler for the given event. For internal use only.</summary>
 216     ///<param name="lib">The name of the native library definining the event.</param>
 217     ///<param name="key">The name of the native event.</param>
 218     ///<param name="evtDelegate">The delegate to be removed.</param>
 219     private void RemoveNativeEventHandler(string lib, string key, object evtDelegate)
 220     {
 221         IntPtr desc = Efl.EventDescription.GetNative(lib, key);
 222         if (desc == IntPtr.Zero)
 223         {
 224             Eina.Log.Error($"Failed to get native event {key}");
 225             return;
 226         }
 227
 228         var evtPair = (desc, evtDelegate);
 229         if (eoEvents.TryGetValue(evtPair, out var caller))
 230         {
 231             if (!Efl.Eo.Globals.efl_event_callback_del(handle, desc, caller.evtCallerPtr, IntPtr.Zero))
 232             {
 233                 Eina.Log.Error($"Failed to remove event proxy for event {key}");
 234                 return;
 235             }
 236
 237             eoEvents.Remove(evtPair);
 238             Eina.Error.RaiseIfUnhandledException();
 239         }
 240         else
 241         {
 242             Eina.Log.Error($"Trying to remove proxy for event {key} when it is nothing registered.");
 243         }
 244     }
 245
 246     /// <summary>Sent after a new item was added.
 247     /// (Since EFL 1.22)</summary>
 248     public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
 249     {
 250         add
 251         {
 252             lock (eventLock)
 253             {
 254                 var wRef = new WeakReference(this);
 255                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 256                 {
 257                     var obj = wRef.Target as Efl.Eo.IWrapper;
 258                     if (obj != null)
 259                     {
 260                                                 Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
 261                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 262                         try
 263                         {
 264                             value?.Invoke(obj, args);
 265                         }
 266                         catch (Exception e)
 267                         {
 268                             Eina.Log.Error(e.ToString());
 269                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 270                         }
 271                     }
 272                 };
 273
 274                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 275                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 276             }
 277         }
 278
 279         remove
 280         {
 281             lock (eventLock)
 282             {
 283                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 284                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 285             }
 286         }
 287     }
 288     ///<summary>Method to raise event ContentAddedEvt.</summary>
 289     public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
 290     {
 291         var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 292         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 293         if (desc == IntPtr.Zero)
 294         {
 295             Eina.Log.Error($"Failed to get native event {key}");
 296             return;
 297         }
 298
 299         IntPtr info = e.arg.NativeHandle;
 300         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 301     }
 302     /// <summary>Sent after an item was removed, before unref.
 303     /// (Since EFL 1.22)</summary>
 304     public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
 305     {
 306         add
 307         {
 308             lock (eventLock)
 309             {
 310                 var wRef = new WeakReference(this);
 311                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 312                 {
 313                     var obj = wRef.Target as Efl.Eo.IWrapper;
 314                     if (obj != null)
 315                     {
 316                                                 Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
 317                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 318                         try
 319                         {
 320                             value?.Invoke(obj, args);
 321                         }
 322                         catch (Exception e)
 323                         {
 324                             Eina.Log.Error(e.ToString());
 325                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 326                         }
 327                     }
 328                 };
 329
 330                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 331                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 332             }
 333         }
 334
 335         remove
 336         {
 337             lock (eventLock)
 338             {
 339                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 340                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 341             }
 342         }
 343     }
 344     ///<summary>Method to raise event ContentRemovedEvt.</summary>
 345     public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
 346     {
 347         var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 348         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 349         if (desc == IntPtr.Zero)
 350         {
 351             Eina.Log.Error($"Failed to get native event {key}");
 352             return;
 353         }
 354
 355         IntPtr info = e.arg.NativeHandle;
 356         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 357     }
 358     /// <summary>Prepend an object at the beginning of this container.
 359     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
 360     ///
 361     /// 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>
 362     /// <param name="subobj">Item to pack at the beginning.</param>
 363     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 364     public bool PackBegin(Efl.Gfx.IEntity subobj) {
 365                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_begin_ptr.Value.Delegate(this.NativeHandle,subobj);
 366         Eina.Error.RaiseIfUnhandledException();
 367                         return _ret_var;
 368  }
 369     /// <summary>Append item at the end of this container.
 370     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
 371     ///
 372     /// 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>
 373     /// <param name="subobj">Item to pack at the end.</param>
 374     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 375     public bool PackEnd(Efl.Gfx.IEntity subobj) {
 376                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_end_ptr.Value.Delegate(this.NativeHandle,subobj);
 377         Eina.Error.RaiseIfUnhandledException();
 378                         return _ret_var;
 379  }
 380     /// <summary>Prepend item before other sub object.
 381     /// 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>
 382     /// <param name="subobj">Item to pack before <c>existing</c>.</param>
 383     /// <param name="existing">Item to refer to.</param>
 384     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 385     public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 386                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_before_ptr.Value.Delegate(this.NativeHandle,subobj, existing);
 387         Eina.Error.RaiseIfUnhandledException();
 388                                         return _ret_var;
 389  }
 390     /// <summary>Append item after other sub object.
 391     /// 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>
 392     /// <param name="subobj">Item to pack after <c>existing</c>.</param>
 393     /// <param name="existing">Item to refer to.</param>
 394     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 395     public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 396                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_after_ptr.Value.Delegate(this.NativeHandle,subobj, existing);
 397         Eina.Error.RaiseIfUnhandledException();
 398                                         return _ret_var;
 399  }
 400     /// <summary>Inserts <c>subobj</c> BEFORE the item at position <c>index</c>.
 401     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first item (0) to last item (<c>count</c>-1), and negative numbers go from last item (-1) to first item (-<c>count</c>). Where <c>count</c> is the number of items currently in the container.
 402     ///
 403     /// If <c>index</c> is less than -<c>count</c>, it will trigger <see cref="Efl.IPackLinear.PackBegin"/>(<c>subobj</c>) whereas <c>index</c> greater than <c>count</c>-1 will trigger <see cref="Efl.IPackLinear.PackEnd"/>(<c>subobj</c>).
 404     ///
 405     /// 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>
 406     /// <param name="subobj">Item to pack.</param>
 407     /// <param name="index">Index of item to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 408     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 409     public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
 410                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_at_ptr.Value.Delegate(this.NativeHandle,subobj, index);
 411         Eina.Error.RaiseIfUnhandledException();
 412                                         return _ret_var;
 413  }
 414     /// <summary>Content at a given <c>index</c> in this container.
 415     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first item (0) to last item (<c>count</c>-1), and negative numbers go from last item (-1) to first item (-<c>count</c>). Where <c>count</c> is the number of items currently in the container.
 416     ///
 417     /// If <c>index</c> is less than -<c>count</c>, it will return the first item whereas <c>index</c> greater than <c>count</c>-1 will return the last item.</summary>
 418     /// <param name="index">Index of the item to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 419     /// <returns>The object contained at the given <c>index</c>.</returns>
 420     public Efl.Gfx.IEntity GetPackContent(int index) {
 421                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_content_get_ptr.Value.Delegate(this.NativeHandle,index);
 422         Eina.Error.RaiseIfUnhandledException();
 423                         return _ret_var;
 424  }
 425     /// <summary>Get the index of a child in this container.</summary>
 426     /// <param name="subobj">An object contained in this pack.</param>
 427     /// <returns>-1 in case <c>subobj</c> is not a child of this object, or the index of this item in the range 0 to (<c>count</c>-1).</returns>
 428     public int GetPackIndex(Efl.Gfx.IEntity subobj) {
 429                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_index_get_ptr.Value.Delegate(this.NativeHandle,subobj);
 430         Eina.Error.RaiseIfUnhandledException();
 431                         return _ret_var;
 432  }
 433     /// <summary>Pop out (remove) the item at the specified <c>index</c>.
 434     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first item (0) to last item (<c>count</c>-1), and negative numbers go from last item (-1) to first item (-<c>count</c>). Where <c>count</c> is the number of items currently in the container.
 435     ///
 436     /// If <c>index</c> is less than -<c>count</c>, it will remove the first item whereas <c>index</c> greater than <c>count</c>-1 will remove the last item.
 437     ///
 438     /// Equivalent to <see cref="Efl.IPack.Unpack"/>(<see cref="Efl.IPackLinear.GetPackContent"/>(<c>index</c>)).</summary>
 439     /// <param name="index">Index of item to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 440     /// <returns>The child item if it could be removed.</returns>
 441     public Efl.Gfx.IEntity PackUnpackAt(int index) {
 442                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_unpack_at_ptr.Value.Delegate(this.NativeHandle,index);
 443         Eina.Error.RaiseIfUnhandledException();
 444                         return _ret_var;
 445  }
 446     /// <summary>Begin iterating over this object&apos;s contents.
 447     /// (Since EFL 1.22)</summary>
 448     /// <returns>Iterator to object content</returns>
 449     public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 450          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate(this.NativeHandle);
 451         Eina.Error.RaiseIfUnhandledException();
 452         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 453  }
 454     /// <summary>Returns the number of UI elements packed in this container.
 455     /// (Since EFL 1.22)</summary>
 456     /// <returns>Number of packed UI elements</returns>
 457     public int ContentCount() {
 458          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate(this.NativeHandle);
 459         Eina.Error.RaiseIfUnhandledException();
 460         return _ret_var;
 461  }
 462     /// <summary>Alignment of the container within its bounds</summary>
 463     /// <param name="align_horiz">Horizontal alignment</param>
 464     /// <param name="align_vert">Vertical alignment</param>
 465     public void GetPackAlign(out double align_horiz, out double align_vert) {
 466                                                          Efl.IPackConcrete.NativeMethods.efl_pack_align_get_ptr.Value.Delegate(this.NativeHandle,out align_horiz, out align_vert);
 467         Eina.Error.RaiseIfUnhandledException();
 468                                          }
 469     /// <summary>Alignment of the container within its bounds</summary>
 470     /// <param name="align_horiz">Horizontal alignment</param>
 471     /// <param name="align_vert">Vertical alignment</param>
 472     public void SetPackAlign(double align_horiz, double align_vert) {
 473                                                          Efl.IPackConcrete.NativeMethods.efl_pack_align_set_ptr.Value.Delegate(this.NativeHandle,align_horiz, align_vert);
 474         Eina.Error.RaiseIfUnhandledException();
 475                                          }
 476     /// <summary>Padding between items contained in this object.</summary>
 477     /// <param name="pad_horiz">Horizontal padding</param>
 478     /// <param name="pad_vert">Vertical padding</param>
 479     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 480     public void GetPackPadding(out double pad_horiz, out double pad_vert, out bool scalable) {
 481                                                                                  Efl.IPackConcrete.NativeMethods.efl_pack_padding_get_ptr.Value.Delegate(this.NativeHandle,out pad_horiz, out pad_vert, out scalable);
 482         Eina.Error.RaiseIfUnhandledException();
 483                                                          }
 484     /// <summary>Padding between items contained in this object.</summary>
 485     /// <param name="pad_horiz">Horizontal padding</param>
 486     /// <param name="pad_vert">Vertical padding</param>
 487     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 488     public void SetPackPadding(double pad_horiz, double pad_vert, bool scalable) {
 489                                                                                  Efl.IPackConcrete.NativeMethods.efl_pack_padding_set_ptr.Value.Delegate(this.NativeHandle,pad_horiz, pad_vert, scalable);
 490         Eina.Error.RaiseIfUnhandledException();
 491                                                          }
 492     /// <summary>Removes all packed contents, and unreferences them.</summary>
 493     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 494     public bool ClearPack() {
 495          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate(this.NativeHandle);
 496         Eina.Error.RaiseIfUnhandledException();
 497         return _ret_var;
 498  }
 499     /// <summary>Removes all packed contents, without unreferencing them.
 500     /// Use with caution.</summary>
 501     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 502     public bool UnpackAll() {
 503          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_all_ptr.Value.Delegate(this.NativeHandle);
 504         Eina.Error.RaiseIfUnhandledException();
 505         return _ret_var;
 506  }
 507     /// <summary>Removes an existing item from the container, without deleting it.</summary>
 508     /// <param name="subobj">The unpacked object.</param>
 509     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t a child or can&apos;t be removed</returns>
 510     public bool Unpack(Efl.Gfx.IEntity subobj) {
 511                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_ptr.Value.Delegate(this.NativeHandle,subobj);
 512         Eina.Error.RaiseIfUnhandledException();
 513                         return _ret_var;
 514  }
 515     /// <summary>Adds an item to this container.
 516     /// 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.
 517     ///
 518     /// 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>
 519     /// <param name="subobj">An object to pack.</param>
 520     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 521     public bool Pack(Efl.Gfx.IEntity subobj) {
 522                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate(this.NativeHandle,subobj);
 523         Eina.Error.RaiseIfUnhandledException();
 524                         return _ret_var;
 525  }
 526     private static IntPtr GetEflClassStatic()
 527     {
 528         return Efl.IPackLinearConcrete.efl_pack_linear_interface_get();
 529     }
 530     /// <summary>Wrapper for native methods and virtual method delegates.
 531     /// For internal use by generated code only.</summary>
 532     public class NativeMethods  : Efl.Eo.NativeClass
 533     {
 534         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 535         /// <summary>Gets the list of Eo operations to override.</summary>
 536         /// <returns>The list of Eo operations to be overload.</returns>
 537         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 538         {
 539             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 540             var methods = Efl.Eo.Globals.GetUserMethods(type);
 541
 542             if (efl_pack_begin_static_delegate == null)
 543             {
 544                 efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 545             }
 546
 547             if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
 548             {
 549                 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) });
 550             }
 551
 552             if (efl_pack_end_static_delegate == null)
 553             {
 554                 efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 555             }
 556
 557             if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
 558             {
 559                 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) });
 560             }
 561
 562             if (efl_pack_before_static_delegate == null)
 563             {
 564                 efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 565             }
 566
 567             if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
 568             {
 569                 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) });
 570             }
 571
 572             if (efl_pack_after_static_delegate == null)
 573             {
 574                 efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 575             }
 576
 577             if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
 578             {
 579                 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) });
 580             }
 581
 582             if (efl_pack_at_static_delegate == null)
 583             {
 584                 efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 585             }
 586
 587             if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
 588             {
 589                 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) });
 590             }
 591
 592             if (efl_pack_content_get_static_delegate == null)
 593             {
 594                 efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 595             }
 596
 597             if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
 598             {
 599                 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) });
 600             }
 601
 602             if (efl_pack_index_get_static_delegate == null)
 603             {
 604                 efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 605             }
 606
 607             if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
 608             {
 609                 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) });
 610             }
 611
 612             if (efl_pack_unpack_at_static_delegate == null)
 613             {
 614                 efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 615             }
 616
 617             if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
 618             {
 619                 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) });
 620             }
 621
 622             if (efl_content_iterate_static_delegate == null)
 623             {
 624                 efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 625             }
 626
 627             if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 628             {
 629                 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) });
 630             }
 631
 632             if (efl_content_count_static_delegate == null)
 633             {
 634                 efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 635             }
 636
 637             if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 638             {
 639                 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) });
 640             }
 641
 642             if (efl_pack_align_get_static_delegate == null)
 643             {
 644                 efl_pack_align_get_static_delegate = new efl_pack_align_get_delegate(pack_align_get);
 645             }
 646
 647             if (methods.FirstOrDefault(m => m.Name == "GetPackAlign") != null)
 648             {
 649                 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) });
 650             }
 651
 652             if (efl_pack_align_set_static_delegate == null)
 653             {
 654                 efl_pack_align_set_static_delegate = new efl_pack_align_set_delegate(pack_align_set);
 655             }
 656
 657             if (methods.FirstOrDefault(m => m.Name == "SetPackAlign") != null)
 658             {
 659                 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) });
 660             }
 661
 662             if (efl_pack_padding_get_static_delegate == null)
 663             {
 664                 efl_pack_padding_get_static_delegate = new efl_pack_padding_get_delegate(pack_padding_get);
 665             }
 666
 667             if (methods.FirstOrDefault(m => m.Name == "GetPackPadding") != null)
 668             {
 669                 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) });
 670             }
 671
 672             if (efl_pack_padding_set_static_delegate == null)
 673             {
 674                 efl_pack_padding_set_static_delegate = new efl_pack_padding_set_delegate(pack_padding_set);
 675             }
 676
 677             if (methods.FirstOrDefault(m => m.Name == "SetPackPadding") != null)
 678             {
 679                 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) });
 680             }
 681
 682             if (efl_pack_clear_static_delegate == null)
 683             {
 684                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 685             }
 686
 687             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 688             {
 689                 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) });
 690             }
 691
 692             if (efl_pack_unpack_all_static_delegate == null)
 693             {
 694                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 695             }
 696
 697             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 698             {
 699                 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) });
 700             }
 701
 702             if (efl_pack_unpack_static_delegate == null)
 703             {
 704                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 705             }
 706
 707             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 708             {
 709                 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) });
 710             }
 711
 712             if (efl_pack_static_delegate == null)
 713             {
 714                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 715             }
 716
 717             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 718             {
 719                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 720             }
 721
 722             return descs;
 723         }
 724         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 725         /// <returns>The native class pointer.</returns>
 726         public override IntPtr GetEflClass()
 727         {
 728             return Efl.IPackLinearConcrete.efl_pack_linear_interface_get();
 729         }
 730
 731         #pragma warning disable CA1707, SA1300, SA1600
 732
 733         [return: MarshalAs(UnmanagedType.U1)]
 734         private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 735
 736         [return: MarshalAs(UnmanagedType.U1)]
 737         public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 738
 739         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");
 740
 741         private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 742         {
 743             Eina.Log.Debug("function efl_pack_begin was called");
 744             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 745             if (wrapper != null)
 746             {
 747                                     bool _ret_var = default(bool);
 748                 try
 749                 {
 750                     _ret_var = ((IPackLinear)wrapper).PackBegin(subobj);
 751                 }
 752                 catch (Exception e)
 753                 {
 754                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 755                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 756                 }
 757
 758                         return _ret_var;
 759
 760             }
 761             else
 762             {
 763                 return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 764             }
 765         }
 766
 767         private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
 768
 769         [return: MarshalAs(UnmanagedType.U1)]
 770         private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 771
 772         [return: MarshalAs(UnmanagedType.U1)]
 773         public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 774
 775         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");
 776
 777         private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 778         {
 779             Eina.Log.Debug("function efl_pack_end was called");
 780             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 781             if (wrapper != null)
 782             {
 783                                     bool _ret_var = default(bool);
 784                 try
 785                 {
 786                     _ret_var = ((IPackLinear)wrapper).PackEnd(subobj);
 787                 }
 788                 catch (Exception e)
 789                 {
 790                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 791                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 792                 }
 793
 794                         return _ret_var;
 795
 796             }
 797             else
 798             {
 799                 return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 800             }
 801         }
 802
 803         private static efl_pack_end_delegate efl_pack_end_static_delegate;
 804
 805         [return: MarshalAs(UnmanagedType.U1)]
 806         private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 807
 808         [return: MarshalAs(UnmanagedType.U1)]
 809         public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 810
 811         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");
 812
 813         private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
 814         {
 815             Eina.Log.Debug("function efl_pack_before was called");
 816             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 817             if (wrapper != null)
 818             {
 819                                                             bool _ret_var = default(bool);
 820                 try
 821                 {
 822                     _ret_var = ((IPackLinear)wrapper).PackBefore(subobj, existing);
 823                 }
 824                 catch (Exception e)
 825                 {
 826                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 827                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 828                 }
 829
 830                                         return _ret_var;
 831
 832             }
 833             else
 834             {
 835                 return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
 836             }
 837         }
 838
 839         private static efl_pack_before_delegate efl_pack_before_static_delegate;
 840
 841         [return: MarshalAs(UnmanagedType.U1)]
 842         private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 843
 844         [return: MarshalAs(UnmanagedType.U1)]
 845         public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 846
 847         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");
 848
 849         private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
 850         {
 851             Eina.Log.Debug("function efl_pack_after was called");
 852             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 853             if (wrapper != null)
 854             {
 855                                                             bool _ret_var = default(bool);
 856                 try
 857                 {
 858                     _ret_var = ((IPackLinear)wrapper).PackAfter(subobj, existing);
 859                 }
 860                 catch (Exception e)
 861                 {
 862                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 863                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 864                 }
 865
 866                                         return _ret_var;
 867
 868             }
 869             else
 870             {
 871                 return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
 872             }
 873         }
 874
 875         private static efl_pack_after_delegate efl_pack_after_static_delegate;
 876
 877         [return: MarshalAs(UnmanagedType.U1)]
 878         private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
 879
 880         [return: MarshalAs(UnmanagedType.U1)]
 881         public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
 882
 883         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");
 884
 885         private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
 886         {
 887             Eina.Log.Debug("function efl_pack_at was called");
 888             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 889             if (wrapper != null)
 890             {
 891                                                             bool _ret_var = default(bool);
 892                 try
 893                 {
 894                     _ret_var = ((IPackLinear)wrapper).PackAt(subobj, index);
 895                 }
 896                 catch (Exception e)
 897                 {
 898                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 899                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 900                 }
 901
 902                                         return _ret_var;
 903
 904             }
 905             else
 906             {
 907                 return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
 908             }
 909         }
 910
 911         private static efl_pack_at_delegate efl_pack_at_static_delegate;
 912
 913         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 914         private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
 915
 916         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 917         public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj,  int index);
 918
 919         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");
 920
 921         private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
 922         {
 923             Eina.Log.Debug("function efl_pack_content_get was called");
 924             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 925             if (wrapper != null)
 926             {
 927                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 928                 try
 929                 {
 930                     _ret_var = ((IPackLinear)wrapper).GetPackContent(index);
 931                 }
 932                 catch (Exception e)
 933                 {
 934                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 935                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 936                 }
 937
 938                         return _ret_var;
 939
 940             }
 941             else
 942             {
 943                 return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
 944             }
 945         }
 946
 947         private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
 948
 949
 950         private delegate int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 951
 952
 953         public delegate int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 954
 955         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");
 956
 957         private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 958         {
 959             Eina.Log.Debug("function efl_pack_index_get was called");
 960             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 961             if (wrapper != null)
 962             {
 963                                     int _ret_var = default(int);
 964                 try
 965                 {
 966                     _ret_var = ((IPackLinear)wrapper).GetPackIndex(subobj);
 967                 }
 968                 catch (Exception e)
 969                 {
 970                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 971                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 972                 }
 973
 974                         return _ret_var;
 975
 976             }
 977             else
 978             {
 979                 return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 980             }
 981         }
 982
 983         private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
 984
 985         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 986         private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
 987
 988         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 989         public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj,  int index);
 990
 991         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");
 992
 993         private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
 994         {
 995             Eina.Log.Debug("function efl_pack_unpack_at was called");
 996             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 997             if (wrapper != null)
 998             {
 999                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1000                 try
1001                 {
1002                     _ret_var = ((IPackLinear)wrapper).PackUnpackAt(index);
1003                 }
1004                 catch (Exception e)
1005                 {
1006                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1007                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1008                 }
1009
1010                         return _ret_var;
1011
1012             }
1013             else
1014             {
1015                 return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1016             }
1017         }
1018
1019         private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
1020
1021
1022         private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
1023
1024
1025         public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
1026
1027         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");
1028
1029         private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
1030         {
1031             Eina.Log.Debug("function efl_content_iterate was called");
1032             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1033             if (wrapper != null)
1034             {
1035             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
1036                 try
1037                 {
1038                     _ret_var = ((IPackLinear)wrapper).ContentIterate();
1039                 }
1040                 catch (Exception e)
1041                 {
1042                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1043                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1044                 }
1045
1046         _ret_var.Own = false; return _ret_var.Handle;
1047
1048             }
1049             else
1050             {
1051                 return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1052             }
1053         }
1054
1055         private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
1056
1057
1058         private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
1059
1060
1061         public delegate int efl_content_count_api_delegate(System.IntPtr obj);
1062
1063         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");
1064
1065         private static int content_count(System.IntPtr obj, System.IntPtr pd)
1066         {
1067             Eina.Log.Debug("function efl_content_count was called");
1068             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1069             if (wrapper != null)
1070             {
1071             int _ret_var = default(int);
1072                 try
1073                 {
1074                     _ret_var = ((IPackLinear)wrapper).ContentCount();
1075                 }
1076                 catch (Exception e)
1077                 {
1078                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1079                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1080                 }
1081
1082         return _ret_var;
1083
1084             }
1085             else
1086             {
1087                 return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1088             }
1089         }
1090
1091         private static efl_content_count_delegate efl_content_count_static_delegate;
1092
1093
1094         private delegate void efl_pack_align_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert);
1095
1096
1097         public delegate void efl_pack_align_get_api_delegate(System.IntPtr obj,  out double align_horiz,  out double align_vert);
1098
1099         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");
1100
1101         private static void pack_align_get(System.IntPtr obj, System.IntPtr pd, out double align_horiz, out double align_vert)
1102         {
1103             Eina.Log.Debug("function efl_pack_align_get was called");
1104             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1105             if (wrapper != null)
1106             {
1107                         align_horiz = default(double);        align_vert = default(double);
1108                 try
1109                 {
1110                     ((IPackLinear)wrapper).GetPackAlign(out align_horiz, out align_vert);
1111                 }
1112                 catch (Exception e)
1113                 {
1114                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1115                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1116                 }
1117
1118
1119             }
1120             else
1121             {
1122                 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);
1123             }
1124         }
1125
1126         private static efl_pack_align_get_delegate efl_pack_align_get_static_delegate;
1127
1128
1129         private delegate void efl_pack_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert);
1130
1131
1132         public delegate void efl_pack_align_set_api_delegate(System.IntPtr obj,  double align_horiz,  double align_vert);
1133
1134         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");
1135
1136         private static void pack_align_set(System.IntPtr obj, System.IntPtr pd, double align_horiz, double align_vert)
1137         {
1138             Eina.Log.Debug("function efl_pack_align_set was called");
1139             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1140             if (wrapper != null)
1141             {
1142
1143                 try
1144                 {
1145                     ((IPackLinear)wrapper).SetPackAlign(align_horiz, align_vert);
1146                 }
1147                 catch (Exception e)
1148                 {
1149                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1150                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1151                 }
1152
1153
1154             }
1155             else
1156             {
1157                 efl_pack_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), align_horiz, align_vert);
1158             }
1159         }
1160
1161         private static efl_pack_align_set_delegate efl_pack_align_set_static_delegate;
1162
1163
1164         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);
1165
1166
1167         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);
1168
1169         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");
1170
1171         private static void pack_padding_get(System.IntPtr obj, System.IntPtr pd, out double pad_horiz, out double pad_vert, out bool scalable)
1172         {
1173             Eina.Log.Debug("function efl_pack_padding_get was called");
1174             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1175             if (wrapper != null)
1176             {
1177                                 pad_horiz = default(double);        pad_vert = default(double);        scalable = default(bool);
1178                 try
1179                 {
1180                     ((IPackLinear)wrapper).GetPackPadding(out pad_horiz, out pad_vert, out scalable);
1181                 }
1182                 catch (Exception e)
1183                 {
1184                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1185                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1186                 }
1187
1188
1189             }
1190             else
1191             {
1192                 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);
1193             }
1194         }
1195
1196         private static efl_pack_padding_get_delegate efl_pack_padding_get_static_delegate;
1197
1198
1199         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);
1200
1201
1202         public delegate void efl_pack_padding_set_api_delegate(System.IntPtr obj,  double pad_horiz,  double pad_vert, [MarshalAs(UnmanagedType.U1)] bool scalable);
1203
1204         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");
1205
1206         private static void pack_padding_set(System.IntPtr obj, System.IntPtr pd, double pad_horiz, double pad_vert, bool scalable)
1207         {
1208             Eina.Log.Debug("function efl_pack_padding_set was called");
1209             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1210             if (wrapper != null)
1211             {
1212
1213                 try
1214                 {
1215                     ((IPackLinear)wrapper).SetPackPadding(pad_horiz, pad_vert, scalable);
1216                 }
1217                 catch (Exception e)
1218                 {
1219                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1220                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1221                 }
1222
1223
1224             }
1225             else
1226             {
1227                 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);
1228             }
1229         }
1230
1231         private static efl_pack_padding_set_delegate efl_pack_padding_set_static_delegate;
1232
1233         [return: MarshalAs(UnmanagedType.U1)]
1234         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
1235
1236         [return: MarshalAs(UnmanagedType.U1)]
1237         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
1238
1239         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");
1240
1241         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
1242         {
1243             Eina.Log.Debug("function efl_pack_clear was called");
1244             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1245             if (wrapper != null)
1246             {
1247             bool _ret_var = default(bool);
1248                 try
1249                 {
1250                     _ret_var = ((IPackLinear)wrapper).ClearPack();
1251                 }
1252                 catch (Exception e)
1253                 {
1254                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1255                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1256                 }
1257
1258         return _ret_var;
1259
1260             }
1261             else
1262             {
1263                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1264             }
1265         }
1266
1267         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
1268
1269         [return: MarshalAs(UnmanagedType.U1)]
1270         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
1271
1272         [return: MarshalAs(UnmanagedType.U1)]
1273         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
1274
1275         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");
1276
1277         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
1278         {
1279             Eina.Log.Debug("function efl_pack_unpack_all was called");
1280             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1281             if (wrapper != null)
1282             {
1283             bool _ret_var = default(bool);
1284                 try
1285                 {
1286                     _ret_var = ((IPackLinear)wrapper).UnpackAll();
1287                 }
1288                 catch (Exception e)
1289                 {
1290                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1291                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1292                 }
1293
1294         return _ret_var;
1295
1296             }
1297             else
1298             {
1299                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1300             }
1301         }
1302
1303         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
1304
1305         [return: MarshalAs(UnmanagedType.U1)]
1306         private delegate bool efl_pack_unpack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1307
1308         [return: MarshalAs(UnmanagedType.U1)]
1309         public delegate bool efl_pack_unpack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1310
1311         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");
1312
1313         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1314         {
1315             Eina.Log.Debug("function efl_pack_unpack was called");
1316             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1317             if (wrapper != null)
1318             {
1319                                     bool _ret_var = default(bool);
1320                 try
1321                 {
1322                     _ret_var = ((IPackLinear)wrapper).Unpack(subobj);
1323                 }
1324                 catch (Exception e)
1325                 {
1326                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1327                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1328                 }
1329
1330                         return _ret_var;
1331
1332             }
1333             else
1334             {
1335                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1336             }
1337         }
1338
1339         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
1340
1341         [return: MarshalAs(UnmanagedType.U1)]
1342         private delegate bool efl_pack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1343
1344         [return: MarshalAs(UnmanagedType.U1)]
1345         public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
1346
1347         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
1348
1349         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1350         {
1351             Eina.Log.Debug("function efl_pack was called");
1352             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1353             if (wrapper != null)
1354             {
1355                                     bool _ret_var = default(bool);
1356                 try
1357                 {
1358                     _ret_var = ((IPackLinear)wrapper).Pack(subobj);
1359                 }
1360                 catch (Exception e)
1361                 {
1362                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1363                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1364                 }
1365
1366                         return _ret_var;
1367
1368             }
1369             else
1370             {
1371                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1372             }
1373         }
1374
1375         private static efl_pack_delegate efl_pack_static_delegate;
1376
1377         #pragma warning restore CA1707, SA1300, SA1600
1378
1379 }
1380 }
1381 }
1382