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

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