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