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