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