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

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