internals/src/EflSharp/EflSharp/efl/efl_canvas_layout_part_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 { namespace Canvas {
   8 /// <summary>Represents a Table created as part of a layout.
   9 /// Can not be deleted, this is only a representation of an internal object of an EFL layout.</summary>
  10 [LayoutPartTableNativeInherit]
  11 public class LayoutPartTable : Efl.Canvas.LayoutPart, Efl.Eo.IWrapper,Efl.IContainer,Efl.IPack,Efl.IPackTable
  12 {
  13     ///<summary>Pointer to the native class description.</summary>
  14     public override System.IntPtr NativeClass {
  15         get {
  16             if (((object)this).GetType() == typeof (LayoutPartTable))
  17                 return Efl.Canvas.LayoutPartTableNativeInherit.GetEflClassStatic();
  18             else
  19                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  20         }
  21     }
  22     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  23         efl_canvas_layout_part_table_class_get();
  24     ///<summary>Creates a new instance.</summary>
  25     ///<param name="parent">Parent instance.</param>
  26     public LayoutPartTable(Efl.Object parent= null
  27             ) :
  28         base(efl_canvas_layout_part_table_class_get(), typeof(LayoutPartTable), parent)
  29     {
  30         FinishInstantiation();
  31     }
  32     ///<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>
  33     protected LayoutPartTable(System.IntPtr raw) : base(raw)
  34     {
  35                 RegisterEventProxies();
  36     }
  37     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  38     protected LayoutPartTable(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  39     ///<summary>Verifies if the given object is equal to this one.</summary>
  40     public override bool Equals(object obj)
  41     {
  42         var other = obj as Efl.Object;
  43         if (other == null)
  44             return false;
  45         return this.NativeHandle == other.NativeHandle;
  46     }
  47     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  48     public override int GetHashCode()
  49     {
  50         return this.NativeHandle.ToInt32();
  51     }
  52     ///<summary>Turns the native pointer into a string representation.</summary>
  53     public override String ToString()
  54     {
  55         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  56     }
  57 private static object ContentAddedEvtKey = new object();
  58     /// <summary>Sent after a new item was added.
  59     /// (Since EFL 1.22)</summary>
  60     public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
  61     {
  62         add {
  63             lock (eventLock) {
  64                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  65                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_ContentAddedEvt_delegate)) {
  66                     eventHandlers.AddHandler(ContentAddedEvtKey , value);
  67                 } else
  68                     Eina.Log.Error($"Error adding proxy for event {key}");
  69             }
  70         }
  71         remove {
  72             lock (eventLock) {
  73                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  74                 if (RemoveNativeEventHandler(key, this.evt_ContentAddedEvt_delegate)) {
  75                     eventHandlers.RemoveHandler(ContentAddedEvtKey , value);
  76                 } else
  77                     Eina.Log.Error($"Error removing proxy for event {key}");
  78             }
  79         }
  80     }
  81     ///<summary>Method to raise event ContentAddedEvt.</summary>
  82     public void On_ContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
  83     {
  84         EventHandler<Efl.IContainerContentAddedEvt_Args> evt;
  85         lock (eventLock) {
  86         evt = (EventHandler<Efl.IContainerContentAddedEvt_Args>)eventHandlers[ContentAddedEvtKey];
  87         }
  88         evt?.Invoke(this, e);
  89     }
  90     Efl.EventCb evt_ContentAddedEvt_delegate;
  91     private void on_ContentAddedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
  92     {
  93         Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
  94       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
  95         try {
  96             On_ContentAddedEvt(args);
  97         } catch (Exception e) {
  98             Eina.Log.Error(e.ToString());
  99             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 100         }
 101     }
 102
 103 private static object ContentRemovedEvtKey = new object();
 104     /// <summary>Sent after an item was removed, before unref.
 105     /// (Since EFL 1.22)</summary>
 106     public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
 107     {
 108         add {
 109             lock (eventLock) {
 110                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 111                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_ContentRemovedEvt_delegate)) {
 112                     eventHandlers.AddHandler(ContentRemovedEvtKey , value);
 113                 } else
 114                     Eina.Log.Error($"Error adding proxy for event {key}");
 115             }
 116         }
 117         remove {
 118             lock (eventLock) {
 119                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 120                 if (RemoveNativeEventHandler(key, this.evt_ContentRemovedEvt_delegate)) {
 121                     eventHandlers.RemoveHandler(ContentRemovedEvtKey , value);
 122                 } else
 123                     Eina.Log.Error($"Error removing proxy for event {key}");
 124             }
 125         }
 126     }
 127     ///<summary>Method to raise event ContentRemovedEvt.</summary>
 128     public void On_ContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
 129     {
 130         EventHandler<Efl.IContainerContentRemovedEvt_Args> evt;
 131         lock (eventLock) {
 132         evt = (EventHandler<Efl.IContainerContentRemovedEvt_Args>)eventHandlers[ContentRemovedEvtKey];
 133         }
 134         evt?.Invoke(this, e);
 135     }
 136     Efl.EventCb evt_ContentRemovedEvt_delegate;
 137     private void on_ContentRemovedEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 138     {
 139         Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
 140       args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 141         try {
 142             On_ContentRemovedEvt(args);
 143         } catch (Exception e) {
 144             Eina.Log.Error(e.ToString());
 145             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 146         }
 147     }
 148
 149     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 150     protected override void RegisterEventProxies()
 151     {
 152         base.RegisterEventProxies();
 153         evt_ContentAddedEvt_delegate = new Efl.EventCb(on_ContentAddedEvt_NativeCallback);
 154         evt_ContentRemovedEvt_delegate = new Efl.EventCb(on_ContentRemovedEvt_NativeCallback);
 155     }
 156     /// <summary>Begin iterating over this object&apos;s contents.
 157     /// (Since EFL 1.22)</summary>
 158     /// <returns>Iterator to object content</returns>
 159     virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 160          var _ret_var = Efl.IContainerNativeInherit.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 161         Eina.Error.RaiseIfUnhandledException();
 162         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 163  }
 164     /// <summary>Returns the number of UI elements packed in this container.
 165     /// (Since EFL 1.22)</summary>
 166     /// <returns>Number of packed UI elements</returns>
 167     virtual public int ContentCount() {
 168          var _ret_var = Efl.IContainerNativeInherit.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 169         Eina.Error.RaiseIfUnhandledException();
 170         return _ret_var;
 171  }
 172     /// <summary>Alignment of the container within its bounds</summary>
 173     /// <param name="align_horiz">Horizontal alignment</param>
 174     /// <param name="align_vert">Vertical alignment</param>
 175     /// <returns></returns>
 176     virtual public void GetPackAlign( out double align_horiz,  out double align_vert) {
 177                                                          Efl.IPackNativeInherit.efl_pack_align_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out align_horiz,  out align_vert);
 178         Eina.Error.RaiseIfUnhandledException();
 179                                          }
 180     /// <summary>Alignment of the container within its bounds</summary>
 181     /// <param name="align_horiz">Horizontal alignment</param>
 182     /// <param name="align_vert">Vertical alignment</param>
 183     /// <returns></returns>
 184     virtual public void SetPackAlign( double align_horiz,  double align_vert) {
 185                                                          Efl.IPackNativeInherit.efl_pack_align_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), align_horiz,  align_vert);
 186         Eina.Error.RaiseIfUnhandledException();
 187                                          }
 188     /// <summary>Padding between items contained in this object.</summary>
 189     /// <param name="pad_horiz">Horizontal padding</param>
 190     /// <param name="pad_vert">Vertical padding</param>
 191     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 192     /// <returns></returns>
 193     virtual public void GetPackPadding( out double pad_horiz,  out double pad_vert,  out bool scalable) {
 194                                                                                  Efl.IPackNativeInherit.efl_pack_padding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out pad_horiz,  out pad_vert,  out scalable);
 195         Eina.Error.RaiseIfUnhandledException();
 196                                                          }
 197     /// <summary>Padding between items contained in this object.</summary>
 198     /// <param name="pad_horiz">Horizontal padding</param>
 199     /// <param name="pad_vert">Vertical padding</param>
 200     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 201     /// <returns></returns>
 202     virtual public void SetPackPadding( double pad_horiz,  double pad_vert,  bool scalable) {
 203                                                                                  Efl.IPackNativeInherit.efl_pack_padding_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), pad_horiz,  pad_vert,  scalable);
 204         Eina.Error.RaiseIfUnhandledException();
 205                                                          }
 206     /// <summary>Removes all packed contents, and unreferences them.</summary>
 207     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 208     virtual public bool ClearPack() {
 209          var _ret_var = Efl.IPackNativeInherit.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 210         Eina.Error.RaiseIfUnhandledException();
 211         return _ret_var;
 212  }
 213     /// <summary>Removes all packed contents, without unreferencing them.
 214     /// Use with caution.</summary>
 215     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 216     virtual public bool UnpackAll() {
 217          var _ret_var = Efl.IPackNativeInherit.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 218         Eina.Error.RaiseIfUnhandledException();
 219         return _ret_var;
 220  }
 221     /// <summary>Removes an existing item from the container, without deleting it.</summary>
 222     /// <param name="subobj">The unpacked object.</param>
 223     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t a child or can&apos;t be removed</returns>
 224     virtual public bool Unpack( Efl.Gfx.IEntity subobj) {
 225                                  var _ret_var = Efl.IPackNativeInherit.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 226         Eina.Error.RaiseIfUnhandledException();
 227                         return _ret_var;
 228  }
 229     /// <summary>Adds an item to this container.
 230     /// 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.
 231     ///
 232     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 233     /// <param name="subobj">An object to pack.</param>
 234     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 235     virtual public bool DoPack( Efl.Gfx.IEntity subobj) {
 236                                  var _ret_var = Efl.IPackNativeInherit.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 237         Eina.Error.RaiseIfUnhandledException();
 238                         return _ret_var;
 239  }
 240     /// <summary>Position and span of the <c>subobj</c> in this container, may be modified to move the <c>subobj</c></summary>
 241     /// <param name="subobj">Child object</param>
 242     /// <param name="col">Column number</param>
 243     /// <param name="row">Row number</param>
 244     /// <param name="colspan">Column span</param>
 245     /// <param name="rowspan">Row span</param>
 246     /// <returns>Returns false if item is not a child</returns>
 247     virtual public bool GetTablePosition( Efl.Gfx.IEntity subobj,  out int col,  out int row,  out int colspan,  out int rowspan) {
 248                                                                                                                                  var _ret_var = Efl.IPackTableNativeInherit.efl_pack_table_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  out col,  out row,  out colspan,  out rowspan);
 249         Eina.Error.RaiseIfUnhandledException();
 250                                                                                         return _ret_var;
 251  }
 252     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 253     /// <param name="cols">Number of columns</param>
 254     /// <param name="rows">Number of rows</param>
 255     /// <returns></returns>
 256     virtual public void GetTableSize( out int cols,  out int rows) {
 257                                                          Efl.IPackTableNativeInherit.efl_pack_table_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out cols,  out rows);
 258         Eina.Error.RaiseIfUnhandledException();
 259                                          }
 260     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 261     /// <param name="cols">Number of columns</param>
 262     /// <param name="rows">Number of rows</param>
 263     /// <returns></returns>
 264     virtual public void SetTableSize( int cols,  int rows) {
 265                                                          Efl.IPackTableNativeInherit.efl_pack_table_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), cols,  rows);
 266         Eina.Error.RaiseIfUnhandledException();
 267                                          }
 268     /// <summary>Gird columns property</summary>
 269     /// <returns>Number of columns</returns>
 270     virtual public int GetTableColumns() {
 271          var _ret_var = Efl.IPackTableNativeInherit.efl_pack_table_columns_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 272         Eina.Error.RaiseIfUnhandledException();
 273         return _ret_var;
 274  }
 275     /// <summary>Specifies limit for linear adds - if direction is horizontal</summary>
 276     /// <param name="cols">Number of columns</param>
 277     /// <returns></returns>
 278     virtual public void SetTableColumns( int cols) {
 279                                  Efl.IPackTableNativeInherit.efl_pack_table_columns_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), cols);
 280         Eina.Error.RaiseIfUnhandledException();
 281                          }
 282     /// <summary>Table rows property</summary>
 283     /// <returns>Number of rows</returns>
 284     virtual public int GetTableRows() {
 285          var _ret_var = Efl.IPackTableNativeInherit.efl_pack_table_rows_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 286         Eina.Error.RaiseIfUnhandledException();
 287         return _ret_var;
 288  }
 289     /// <summary>Specifies limit for linear adds - if direction is vertical</summary>
 290     /// <param name="rows">Number of rows</param>
 291     /// <returns></returns>
 292     virtual public void SetTableRows( int rows) {
 293                                  Efl.IPackTableNativeInherit.efl_pack_table_rows_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), rows);
 294         Eina.Error.RaiseIfUnhandledException();
 295                          }
 296     /// <summary>Primary and secondary up/left/right/down directions for linear apis.
 297     /// Default is horizontal and vertical. This overrides <see cref="Efl.Ui.IDirection.Direction"/>.</summary>
 298     /// <param name="primary">Primary direction</param>
 299     /// <param name="secondary">Secondary direction</param>
 300     /// <returns></returns>
 301     virtual public void GetTableDirection( out Efl.Ui.Dir primary,  out Efl.Ui.Dir secondary) {
 302                                                          Efl.IPackTableNativeInherit.efl_pack_table_direction_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out primary,  out secondary);
 303         Eina.Error.RaiseIfUnhandledException();
 304                                          }
 305     /// <summary>Primary and secondary up/left/right/down directions for linear apis.
 306     /// Default is horizontal and vertical. This overrides <see cref="Efl.Ui.IDirection.Direction"/>.</summary>
 307     /// <param name="primary">Primary direction</param>
 308     /// <param name="secondary">Secondary direction</param>
 309     /// <returns></returns>
 310     virtual public void SetTableDirection( Efl.Ui.Dir primary,  Efl.Ui.Dir secondary) {
 311                                                          Efl.IPackTableNativeInherit.efl_pack_table_direction_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), primary,  secondary);
 312         Eina.Error.RaiseIfUnhandledException();
 313                                          }
 314     /// <summary>Pack object at a given location in the table.
 315     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 316     /// <param name="subobj">A child object to pack in this table.</param>
 317     /// <param name="col">Column number</param>
 318     /// <param name="row">Row number</param>
 319     /// <param name="colspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableColumns"/></param>
 320     /// <param name="rowspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableRows"/></param>
 321     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 322     virtual public bool PackTable( Efl.Gfx.IEntity subobj,  int col,  int row,  int colspan,  int rowspan) {
 323                                                                                                                                  var _ret_var = Efl.IPackTableNativeInherit.efl_pack_table_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  col,  row,  colspan,  rowspan);
 324         Eina.Error.RaiseIfUnhandledException();
 325                                                                                         return _ret_var;
 326  }
 327     /// <summary>Returns all objects at a given position in this table.</summary>
 328     /// <param name="col">Column number</param>
 329     /// <param name="row">Row number</param>
 330     /// <param name="below">If <c>true</c> get objects spanning over this cell.</param>
 331     /// <returns>Iterator to table contents</returns>
 332     virtual public Eina.Iterator<Efl.Gfx.IEntity> GetTableContents( int col,  int row,  bool below) {
 333                                                                                  var _ret_var = Efl.IPackTableNativeInherit.efl_pack_table_contents_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), col,  row,  below);
 334         Eina.Error.RaiseIfUnhandledException();
 335                                                         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 336  }
 337     /// <summary>Returns a child at a given position, see <see cref="Efl.IPackTable.GetTableContents"/>.</summary>
 338     /// <param name="col">Column number</param>
 339     /// <param name="row">Row number</param>
 340     /// <returns>Child object</returns>
 341     virtual public Efl.Gfx.IEntity GetTableContent( int col,  int row) {
 342                                                          var _ret_var = Efl.IPackTableNativeInherit.efl_pack_table_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), col,  row);
 343         Eina.Error.RaiseIfUnhandledException();
 344                                         return _ret_var;
 345  }
 346     /// <summary>Gird columns property</summary>
 347 /// <value>Number of columns</value>
 348     public int TableColumns {
 349         get { return GetTableColumns(); }
 350         set { SetTableColumns( value); }
 351     }
 352     /// <summary>Table rows property</summary>
 353 /// <value>Number of rows</value>
 354     public int TableRows {
 355         get { return GetTableRows(); }
 356         set { SetTableRows( value); }
 357     }
 358     private static IntPtr GetEflClassStatic()
 359     {
 360         return Efl.Canvas.LayoutPartTable.efl_canvas_layout_part_table_class_get();
 361     }
 362 }
 363 public class LayoutPartTableNativeInherit : Efl.Canvas.LayoutPartNativeInherit{
 364     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Edje);
 365     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 366     {
 367         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 368         var methods = Efl.Eo.Globals.GetUserMethods(type);
 369         if (efl_content_iterate_static_delegate == null)
 370             efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 371         if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 372             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)});
 373         if (efl_content_count_static_delegate == null)
 374             efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 375         if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 376             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)});
 377         if (efl_pack_align_get_static_delegate == null)
 378             efl_pack_align_get_static_delegate = new efl_pack_align_get_delegate(pack_align_get);
 379         if (methods.FirstOrDefault(m => m.Name == "GetPackAlign") != null)
 380             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)});
 381         if (efl_pack_align_set_static_delegate == null)
 382             efl_pack_align_set_static_delegate = new efl_pack_align_set_delegate(pack_align_set);
 383         if (methods.FirstOrDefault(m => m.Name == "SetPackAlign") != null)
 384             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)});
 385         if (efl_pack_padding_get_static_delegate == null)
 386             efl_pack_padding_get_static_delegate = new efl_pack_padding_get_delegate(pack_padding_get);
 387         if (methods.FirstOrDefault(m => m.Name == "GetPackPadding") != null)
 388             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)});
 389         if (efl_pack_padding_set_static_delegate == null)
 390             efl_pack_padding_set_static_delegate = new efl_pack_padding_set_delegate(pack_padding_set);
 391         if (methods.FirstOrDefault(m => m.Name == "SetPackPadding") != null)
 392             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)});
 393         if (efl_pack_clear_static_delegate == null)
 394             efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 395         if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 396             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)});
 397         if (efl_pack_unpack_all_static_delegate == null)
 398             efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 399         if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 400             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)});
 401         if (efl_pack_unpack_static_delegate == null)
 402             efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 403         if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 404             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)});
 405         if (efl_pack_static_delegate == null)
 406             efl_pack_static_delegate = new efl_pack_delegate(pack);
 407         if (methods.FirstOrDefault(m => m.Name == "DoPack") != null)
 408             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate)});
 409         if (efl_pack_table_position_get_static_delegate == null)
 410             efl_pack_table_position_get_static_delegate = new efl_pack_table_position_get_delegate(table_position_get);
 411         if (methods.FirstOrDefault(m => m.Name == "GetTablePosition") != null)
 412             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)});
 413         if (efl_pack_table_size_get_static_delegate == null)
 414             efl_pack_table_size_get_static_delegate = new efl_pack_table_size_get_delegate(table_size_get);
 415         if (methods.FirstOrDefault(m => m.Name == "GetTableSize") != null)
 416             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)});
 417         if (efl_pack_table_size_set_static_delegate == null)
 418             efl_pack_table_size_set_static_delegate = new efl_pack_table_size_set_delegate(table_size_set);
 419         if (methods.FirstOrDefault(m => m.Name == "SetTableSize") != null)
 420             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)});
 421         if (efl_pack_table_columns_get_static_delegate == null)
 422             efl_pack_table_columns_get_static_delegate = new efl_pack_table_columns_get_delegate(table_columns_get);
 423         if (methods.FirstOrDefault(m => m.Name == "GetTableColumns") != null)
 424             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)});
 425         if (efl_pack_table_columns_set_static_delegate == null)
 426             efl_pack_table_columns_set_static_delegate = new efl_pack_table_columns_set_delegate(table_columns_set);
 427         if (methods.FirstOrDefault(m => m.Name == "SetTableColumns") != null)
 428             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)});
 429         if (efl_pack_table_rows_get_static_delegate == null)
 430             efl_pack_table_rows_get_static_delegate = new efl_pack_table_rows_get_delegate(table_rows_get);
 431         if (methods.FirstOrDefault(m => m.Name == "GetTableRows") != null)
 432             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)});
 433         if (efl_pack_table_rows_set_static_delegate == null)
 434             efl_pack_table_rows_set_static_delegate = new efl_pack_table_rows_set_delegate(table_rows_set);
 435         if (methods.FirstOrDefault(m => m.Name == "SetTableRows") != null)
 436             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)});
 437         if (efl_pack_table_direction_get_static_delegate == null)
 438             efl_pack_table_direction_get_static_delegate = new efl_pack_table_direction_get_delegate(table_direction_get);
 439         if (methods.FirstOrDefault(m => m.Name == "GetTableDirection") != null)
 440             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)});
 441         if (efl_pack_table_direction_set_static_delegate == null)
 442             efl_pack_table_direction_set_static_delegate = new efl_pack_table_direction_set_delegate(table_direction_set);
 443         if (methods.FirstOrDefault(m => m.Name == "SetTableDirection") != null)
 444             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)});
 445         if (efl_pack_table_static_delegate == null)
 446             efl_pack_table_static_delegate = new efl_pack_table_delegate(pack_table);
 447         if (methods.FirstOrDefault(m => m.Name == "PackTable") != null)
 448             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)});
 449         if (efl_pack_table_contents_get_static_delegate == null)
 450             efl_pack_table_contents_get_static_delegate = new efl_pack_table_contents_get_delegate(table_contents_get);
 451         if (methods.FirstOrDefault(m => m.Name == "GetTableContents") != null)
 452             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)});
 453         if (efl_pack_table_content_get_static_delegate == null)
 454             efl_pack_table_content_get_static_delegate = new efl_pack_table_content_get_delegate(table_content_get);
 455         if (methods.FirstOrDefault(m => m.Name == "GetTableContent") != null)
 456             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)});
 457         descs.AddRange(base.GetEoOps(type));
 458         return descs;
 459     }
 460     public override IntPtr GetEflClass()
 461     {
 462         return Efl.Canvas.LayoutPartTable.efl_canvas_layout_part_table_class_get();
 463     }
 464     public static new  IntPtr GetEflClassStatic()
 465     {
 466         return Efl.Canvas.LayoutPartTable.efl_canvas_layout_part_table_class_get();
 467     }
 468
 469
 470      private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 471
 472
 473      public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
 474      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");
 475      private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
 476     {
 477         Eina.Log.Debug("function efl_content_iterate was called");
 478         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 479         if(wrapper != null) {
 480                         Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
 481             try {
 482                 _ret_var = ((LayoutPartTable)wrapper).ContentIterate();
 483             } catch (Exception e) {
 484                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 485                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 486             }
 487         _ret_var.Own = false; return _ret_var.Handle;
 488         } else {
 489             return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 490         }
 491     }
 492     private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
 493
 494
 495      private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
 496
 497
 498      public delegate int efl_content_count_api_delegate(System.IntPtr obj);
 499      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");
 500      private static int content_count(System.IntPtr obj, System.IntPtr pd)
 501     {
 502         Eina.Log.Debug("function efl_content_count was called");
 503         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 504         if(wrapper != null) {
 505                         int _ret_var = default(int);
 506             try {
 507                 _ret_var = ((LayoutPartTable)wrapper).ContentCount();
 508             } catch (Exception e) {
 509                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 510                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 511             }
 512         return _ret_var;
 513         } else {
 514             return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 515         }
 516     }
 517     private static efl_content_count_delegate efl_content_count_static_delegate;
 518
 519
 520      private delegate void efl_pack_align_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double align_horiz,   out double align_vert);
 521
 522
 523      public delegate void efl_pack_align_get_api_delegate(System.IntPtr obj,   out double align_horiz,   out double align_vert);
 524      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");
 525      private static void pack_align_get(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert)
 526     {
 527         Eina.Log.Debug("function efl_pack_align_get was called");
 528         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 529         if(wrapper != null) {
 530                                     align_horiz = default(double);        align_vert = default(double);
 531             try {
 532                 ((LayoutPartTable)wrapper).GetPackAlign( out align_horiz,  out align_vert);
 533             } catch (Exception e) {
 534                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 535                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 536             }
 537                                                 } else {
 538             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);
 539         }
 540     }
 541     private static efl_pack_align_get_delegate efl_pack_align_get_static_delegate;
 542
 543
 544      private delegate void efl_pack_align_set_delegate(System.IntPtr obj, System.IntPtr pd,   double align_horiz,   double align_vert);
 545
 546
 547      public delegate void efl_pack_align_set_api_delegate(System.IntPtr obj,   double align_horiz,   double align_vert);
 548      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");
 549      private static void pack_align_set(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert)
 550     {
 551         Eina.Log.Debug("function efl_pack_align_set was called");
 552         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 553         if(wrapper != null) {
 554
 555             try {
 556                 ((LayoutPartTable)wrapper).SetPackAlign( align_horiz,  align_vert);
 557             } catch (Exception e) {
 558                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 559                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 560             }
 561                                                 } else {
 562             efl_pack_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  align_horiz,  align_vert);
 563         }
 564     }
 565     private static efl_pack_align_set_delegate efl_pack_align_set_static_delegate;
 566
 567
 568      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);
 569
 570
 571      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);
 572      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");
 573      private static void pack_padding_get(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert,  out bool scalable)
 574     {
 575         Eina.Log.Debug("function efl_pack_padding_get was called");
 576         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 577         if(wrapper != null) {
 578                                             pad_horiz = default(double);        pad_vert = default(double);        scalable = default(bool);
 579             try {
 580                 ((LayoutPartTable)wrapper).GetPackPadding( out pad_horiz,  out pad_vert,  out scalable);
 581             } catch (Exception e) {
 582                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 583                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 584             }
 585                                                                 } else {
 586             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);
 587         }
 588     }
 589     private static efl_pack_padding_get_delegate efl_pack_padding_get_static_delegate;
 590
 591
 592      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);
 593
 594
 595      public delegate void efl_pack_padding_set_api_delegate(System.IntPtr obj,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
 596      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");
 597      private static void pack_padding_set(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert,  bool scalable)
 598     {
 599         Eina.Log.Debug("function efl_pack_padding_set was called");
 600         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 601         if(wrapper != null) {
 602
 603             try {
 604                 ((LayoutPartTable)wrapper).SetPackPadding( pad_horiz,  pad_vert,  scalable);
 605             } catch (Exception e) {
 606                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 607                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 608             }
 609                                                                 } else {
 610             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);
 611         }
 612     }
 613     private static efl_pack_padding_set_delegate efl_pack_padding_set_static_delegate;
 614
 615
 616      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 617
 618
 619      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 620      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");
 621      private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 622     {
 623         Eina.Log.Debug("function efl_pack_clear was called");
 624         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 625         if(wrapper != null) {
 626                         bool _ret_var = default(bool);
 627             try {
 628                 _ret_var = ((LayoutPartTable)wrapper).ClearPack();
 629             } catch (Exception e) {
 630                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 631                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 632             }
 633         return _ret_var;
 634         } else {
 635             return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 636         }
 637     }
 638     private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 639
 640
 641      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 642
 643
 644      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 645      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");
 646      private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 647     {
 648         Eina.Log.Debug("function efl_pack_unpack_all was called");
 649         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 650         if(wrapper != null) {
 651                         bool _ret_var = default(bool);
 652             try {
 653                 _ret_var = ((LayoutPartTable)wrapper).UnpackAll();
 654             } catch (Exception e) {
 655                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 656                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 657             }
 658         return _ret_var;
 659         } else {
 660             return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 661         }
 662     }
 663     private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 664
 665
 666      [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.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj);
 667
 668
 669      [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.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj);
 670      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");
 671      private static bool unpack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.IEntity subobj)
 672     {
 673         Eina.Log.Debug("function efl_pack_unpack was called");
 674         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 675         if(wrapper != null) {
 676                                                 bool _ret_var = default(bool);
 677             try {
 678                 _ret_var = ((LayoutPartTable)wrapper).Unpack( subobj);
 679             } catch (Exception e) {
 680                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 681                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 682             }
 683                         return _ret_var;
 684         } else {
 685             return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 686         }
 687     }
 688     private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 689
 690
 691      [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.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj);
 692
 693
 694      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj);
 695      public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(_Module, "efl_pack");
 696      private static bool pack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.IEntity subobj)
 697     {
 698         Eina.Log.Debug("function efl_pack was called");
 699         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 700         if(wrapper != null) {
 701                                                 bool _ret_var = default(bool);
 702             try {
 703                 _ret_var = ((LayoutPartTable)wrapper).DoPack( subobj);
 704             } catch (Exception e) {
 705                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 706                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 707             }
 708                         return _ret_var;
 709         } else {
 710             return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 711         }
 712     }
 713     private static efl_pack_delegate efl_pack_static_delegate;
 714
 715
 716      [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.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj,   out int col,   out int row,   out int colspan,   out int rowspan);
 717
 718
 719      [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.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj,   out int col,   out int row,   out int colspan,   out int rowspan);
 720      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");
 721      private static bool table_position_get(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.IEntity subobj,  out int col,  out int row,  out int colspan,  out int rowspan)
 722     {
 723         Eina.Log.Debug("function efl_pack_table_position_get was called");
 724         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 725         if(wrapper != null) {
 726                                                                     col = default(int);        row = default(int);        colspan = default(int);        rowspan = default(int);                                                    bool _ret_var = default(bool);
 727             try {
 728                 _ret_var = ((LayoutPartTable)wrapper).GetTablePosition( subobj,  out col,  out row,  out colspan,  out rowspan);
 729             } catch (Exception e) {
 730                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 731                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 732             }
 733                                                                                         return _ret_var;
 734         } else {
 735             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);
 736         }
 737     }
 738     private static efl_pack_table_position_get_delegate efl_pack_table_position_get_static_delegate;
 739
 740
 741      private delegate void efl_pack_table_size_get_delegate(System.IntPtr obj, System.IntPtr pd,   out int cols,   out int rows);
 742
 743
 744      public delegate void efl_pack_table_size_get_api_delegate(System.IntPtr obj,   out int cols,   out int rows);
 745      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");
 746      private static void table_size_get(System.IntPtr obj, System.IntPtr pd,  out int cols,  out int rows)
 747     {
 748         Eina.Log.Debug("function efl_pack_table_size_get was called");
 749         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 750         if(wrapper != null) {
 751                                     cols = default(int);        rows = default(int);
 752             try {
 753                 ((LayoutPartTable)wrapper).GetTableSize( out cols,  out 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_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out cols,  out rows);
 760         }
 761     }
 762     private static efl_pack_table_size_get_delegate efl_pack_table_size_get_static_delegate;
 763
 764
 765      private delegate void efl_pack_table_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   int cols,   int rows);
 766
 767
 768      public delegate void efl_pack_table_size_set_api_delegate(System.IntPtr obj,   int cols,   int rows);
 769      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");
 770      private static void table_size_set(System.IntPtr obj, System.IntPtr pd,  int cols,  int rows)
 771     {
 772         Eina.Log.Debug("function efl_pack_table_size_set was called");
 773         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 774         if(wrapper != null) {
 775
 776             try {
 777                 ((LayoutPartTable)wrapper).SetTableSize( cols,  rows);
 778             } catch (Exception e) {
 779                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 780                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 781             }
 782                                                 } else {
 783             efl_pack_table_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cols,  rows);
 784         }
 785     }
 786     private static efl_pack_table_size_set_delegate efl_pack_table_size_set_static_delegate;
 787
 788
 789      private delegate int efl_pack_table_columns_get_delegate(System.IntPtr obj, System.IntPtr pd);
 790
 791
 792      public delegate int efl_pack_table_columns_get_api_delegate(System.IntPtr obj);
 793      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");
 794      private static int table_columns_get(System.IntPtr obj, System.IntPtr pd)
 795     {
 796         Eina.Log.Debug("function efl_pack_table_columns_get was called");
 797         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 798         if(wrapper != null) {
 799                         int _ret_var = default(int);
 800             try {
 801                 _ret_var = ((LayoutPartTable)wrapper).GetTableColumns();
 802             } catch (Exception e) {
 803                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 804                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 805             }
 806         return _ret_var;
 807         } else {
 808             return efl_pack_table_columns_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 809         }
 810     }
 811     private static efl_pack_table_columns_get_delegate efl_pack_table_columns_get_static_delegate;
 812
 813
 814      private delegate void efl_pack_table_columns_set_delegate(System.IntPtr obj, System.IntPtr pd,   int cols);
 815
 816
 817      public delegate void efl_pack_table_columns_set_api_delegate(System.IntPtr obj,   int cols);
 818      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");
 819      private static void table_columns_set(System.IntPtr obj, System.IntPtr pd,  int cols)
 820     {
 821         Eina.Log.Debug("function efl_pack_table_columns_set was called");
 822         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 823         if(wrapper != null) {
 824
 825             try {
 826                 ((LayoutPartTable)wrapper).SetTableColumns( cols);
 827             } catch (Exception e) {
 828                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 829                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 830             }
 831                                 } else {
 832             efl_pack_table_columns_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  cols);
 833         }
 834     }
 835     private static efl_pack_table_columns_set_delegate efl_pack_table_columns_set_static_delegate;
 836
 837
 838      private delegate int efl_pack_table_rows_get_delegate(System.IntPtr obj, System.IntPtr pd);
 839
 840
 841      public delegate int efl_pack_table_rows_get_api_delegate(System.IntPtr obj);
 842      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");
 843      private static int table_rows_get(System.IntPtr obj, System.IntPtr pd)
 844     {
 845         Eina.Log.Debug("function efl_pack_table_rows_get was called");
 846         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 847         if(wrapper != null) {
 848                         int _ret_var = default(int);
 849             try {
 850                 _ret_var = ((LayoutPartTable)wrapper).GetTableRows();
 851             } catch (Exception e) {
 852                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 853                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 854             }
 855         return _ret_var;
 856         } else {
 857             return efl_pack_table_rows_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 858         }
 859     }
 860     private static efl_pack_table_rows_get_delegate efl_pack_table_rows_get_static_delegate;
 861
 862
 863      private delegate void efl_pack_table_rows_set_delegate(System.IntPtr obj, System.IntPtr pd,   int rows);
 864
 865
 866      public delegate void efl_pack_table_rows_set_api_delegate(System.IntPtr obj,   int rows);
 867      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");
 868      private static void table_rows_set(System.IntPtr obj, System.IntPtr pd,  int rows)
 869     {
 870         Eina.Log.Debug("function efl_pack_table_rows_set was called");
 871         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 872         if(wrapper != null) {
 873
 874             try {
 875                 ((LayoutPartTable)wrapper).SetTableRows( rows);
 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_rows_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  rows);
 882         }
 883     }
 884     private static efl_pack_table_rows_set_delegate efl_pack_table_rows_set_static_delegate;
 885
 886
 887      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);
 888
 889
 890      public delegate void efl_pack_table_direction_get_api_delegate(System.IntPtr obj,   out Efl.Ui.Dir primary,   out Efl.Ui.Dir secondary);
 891      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");
 892      private static void table_direction_get(System.IntPtr obj, System.IntPtr pd,  out Efl.Ui.Dir primary,  out Efl.Ui.Dir secondary)
 893     {
 894         Eina.Log.Debug("function efl_pack_table_direction_get was called");
 895         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 896         if(wrapper != null) {
 897                                     primary = default(Efl.Ui.Dir);        secondary = default(Efl.Ui.Dir);
 898             try {
 899                 ((LayoutPartTable)wrapper).GetTableDirection( out primary,  out 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_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out primary,  out secondary);
 906         }
 907     }
 908     private static efl_pack_table_direction_get_delegate efl_pack_table_direction_get_static_delegate;
 909
 910
 911      private delegate void efl_pack_table_direction_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Dir primary,   Efl.Ui.Dir secondary);
 912
 913
 914      public delegate void efl_pack_table_direction_set_api_delegate(System.IntPtr obj,   Efl.Ui.Dir primary,   Efl.Ui.Dir secondary);
 915      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");
 916      private static void table_direction_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Dir primary,  Efl.Ui.Dir secondary)
 917     {
 918         Eina.Log.Debug("function efl_pack_table_direction_set was called");
 919         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 920         if(wrapper != null) {
 921
 922             try {
 923                 ((LayoutPartTable)wrapper).SetTableDirection( primary,  secondary);
 924             } catch (Exception e) {
 925                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 926                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 927             }
 928                                                 } else {
 929             efl_pack_table_direction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  primary,  secondary);
 930         }
 931     }
 932     private static efl_pack_table_direction_set_delegate efl_pack_table_direction_set_static_delegate;
 933
 934
 935      [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.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj,   int col,   int row,   int colspan,   int rowspan);
 936
 937
 938      [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.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity subobj,   int col,   int row,   int colspan,   int rowspan);
 939      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");
 940      private static bool pack_table(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.IEntity subobj,  int col,  int row,  int colspan,  int rowspan)
 941     {
 942         Eina.Log.Debug("function efl_pack_table was called");
 943         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 944         if(wrapper != null) {
 945                                                                                                                                                 bool _ret_var = default(bool);
 946             try {
 947                 _ret_var = ((LayoutPartTable)wrapper).PackTable( subobj,  col,  row,  colspan,  rowspan);
 948             } catch (Exception e) {
 949                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 950                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 951             }
 952                                                                                         return _ret_var;
 953         } else {
 954             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);
 955         }
 956     }
 957     private static efl_pack_table_delegate efl_pack_table_static_delegate;
 958
 959
 960      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);
 961
 962
 963      public delegate System.IntPtr efl_pack_table_contents_get_api_delegate(System.IntPtr obj,   int col,   int row,  [MarshalAs(UnmanagedType.U1)]  bool below);
 964      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");
 965      private static System.IntPtr table_contents_get(System.IntPtr obj, System.IntPtr pd,  int col,  int row,  bool below)
 966     {
 967         Eina.Log.Debug("function efl_pack_table_contents_get was called");
 968         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 969         if(wrapper != null) {
 970                                                                                                 Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
 971             try {
 972                 _ret_var = ((LayoutPartTable)wrapper).GetTableContents( col,  row,  below);
 973             } catch (Exception e) {
 974                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 975                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 976             }
 977                                                         _ret_var.Own = false; return _ret_var.Handle;
 978         } else {
 979             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);
 980         }
 981     }
 982     private static efl_pack_table_contents_get_delegate efl_pack_table_contents_get_static_delegate;
 983
 984
 985     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.IEntity efl_pack_table_content_get_delegate(System.IntPtr obj, System.IntPtr pd,   int col,   int row);
 986
 987
 988     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.IEntity efl_pack_table_content_get_api_delegate(System.IntPtr obj,   int col,   int row);
 989      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");
 990      private static Efl.Gfx.IEntity table_content_get(System.IntPtr obj, System.IntPtr pd,  int col,  int row)
 991     {
 992         Eina.Log.Debug("function efl_pack_table_content_get was called");
 993         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 994         if(wrapper != null) {
 995                                                                         Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 996             try {
 997                 _ret_var = ((LayoutPartTable)wrapper).GetTableContent( col,  row);
 998             } catch (Exception e) {
 999                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1000                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1001             }
1002                                         return _ret_var;
1003         } else {
1004             return efl_pack_table_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  col,  row);
1005         }
1006     }
1007     private static efl_pack_table_content_get_delegate efl_pack_table_content_get_static_delegate;
1008 }
1009 } }