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.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>Sent after a new sub-object was added.
  60     /// (Since EFL 1.22)</summary>
  61     public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
  62     {
  63         add
  64         {
  65             lock (eventLock)
  66             {
  67                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  68                 {
  69                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  70                     if (obj != null)
  71                     {
  72                         Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
  73                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
  74                         try
  75                         {
  76                             value?.Invoke(obj, args);
  77                         }
  78                         catch (Exception e)
  79                         {
  80                             Eina.Log.Error(e.ToString());
  81                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  82                         }
  83                     }
  84                 };
  85
  86                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  87                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
  88             }
  89         }
  90
  91         remove
  92         {
  93             lock (eventLock)
  94             {
  95                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  96                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
  97             }
  98         }
  99     }
 100     ///<summary>Method to raise event ContentAddedEvt.</summary>
 101     public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
 102     {
 103         var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 104         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 105         if (desc == IntPtr.Zero)
 106         {
 107             Eina.Log.Error($"Failed to get native event {key}");
 108             return;
 109         }
 110
 111         IntPtr info = e.arg.NativeHandle;
 112         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 113     }
 114     /// <summary>Sent after a sub-object was removed, before unref.
 115     /// (Since EFL 1.22)</summary>
 116     public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
 117     {
 118         add
 119         {
 120             lock (eventLock)
 121             {
 122                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 123                 {
 124                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 125                     if (obj != null)
 126                     {
 127                         Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
 128                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 129                         try
 130                         {
 131                             value?.Invoke(obj, args);
 132                         }
 133                         catch (Exception e)
 134                         {
 135                             Eina.Log.Error(e.ToString());
 136                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 137                         }
 138                     }
 139                 };
 140
 141                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 142                 AddNativeEventHandler(efl.Libs.Edje, key, callerCb, value);
 143             }
 144         }
 145
 146         remove
 147         {
 148             lock (eventLock)
 149             {
 150                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 151                 RemoveNativeEventHandler(efl.Libs.Edje, key, value);
 152             }
 153         }
 154     }
 155     ///<summary>Method to raise event ContentRemovedEvt.</summary>
 156     public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
 157     {
 158         var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 159         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Edje, key);
 160         if (desc == IntPtr.Zero)
 161         {
 162             Eina.Log.Error($"Failed to get native event {key}");
 163             return;
 164         }
 165
 166         IntPtr info = e.arg.NativeHandle;
 167         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 168     }
 169     /// <summary>Begin iterating over this object&apos;s contents.
 170     /// (Since EFL 1.22)</summary>
 171     /// <returns>Iterator on object&apos;s content.</returns>
 172     virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 173          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 174         Eina.Error.RaiseIfUnhandledException();
 175         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 176  }
 177     /// <summary>Returns the number of contained sub-objects.
 178     /// (Since EFL 1.22)</summary>
 179     /// <returns>Number of sub-objects.</returns>
 180     virtual public int ContentCount() {
 181          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 182         Eina.Error.RaiseIfUnhandledException();
 183         return _ret_var;
 184  }
 185     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
 186     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 187     virtual public bool ClearPack() {
 188          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 189         Eina.Error.RaiseIfUnhandledException();
 190         return _ret_var;
 191  }
 192     /// <summary>Removes all packed sub-objects without unreferencing them.
 193     /// Use with caution.</summary>
 194     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 195     virtual public bool UnpackAll() {
 196          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));
 197         Eina.Error.RaiseIfUnhandledException();
 198         return _ret_var;
 199  }
 200     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
 201     /// <param name="subobj">The sub-object to unpack.</param>
 202     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
 203     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
 204                                  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);
 205         Eina.Error.RaiseIfUnhandledException();
 206                         return _ret_var;
 207  }
 208     /// <summary>Adds a sub-object to this container.
 209     /// 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.
 210     ///
 211     /// 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>
 212     /// <param name="subobj">The object to pack.</param>
 213     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 214     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 215                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 216         Eina.Error.RaiseIfUnhandledException();
 217                         return _ret_var;
 218  }
 219     /// <summary>Position and span of the <c>subobj</c> in this container, may be modified to move the <c>subobj</c></summary>
 220     /// <param name="subobj">Child object</param>
 221     /// <param name="col">Column number</param>
 222     /// <param name="row">Row number</param>
 223     /// <param name="colspan">Column span</param>
 224     /// <param name="rowspan">Row span</param>
 225     /// <returns>Returns false if item is not a child</returns>
 226     virtual public bool GetTablePosition(Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan) {
 227                                                                                                                                  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);
 228         Eina.Error.RaiseIfUnhandledException();
 229                                                                                         return _ret_var;
 230  }
 231     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 232     /// <param name="cols">Number of columns</param>
 233     /// <param name="rows">Number of rows</param>
 234     virtual public void GetTableSize(out int cols, out int rows) {
 235                                                          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);
 236         Eina.Error.RaiseIfUnhandledException();
 237                                          }
 238     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 239     /// <param name="cols">Number of columns</param>
 240     /// <param name="rows">Number of rows</param>
 241     virtual public void SetTableSize(int cols, int rows) {
 242                                                          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);
 243         Eina.Error.RaiseIfUnhandledException();
 244                                          }
 245     /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
 246     /// <returns>Amount of columns.</returns>
 247     virtual public int GetTableColumns() {
 248          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));
 249         Eina.Error.RaiseIfUnhandledException();
 250         return _ret_var;
 251  }
 252     /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
 253     /// <param name="cols">Amount of columns.</param>
 254     virtual public void SetTableColumns(int cols) {
 255                                  Efl.IPackTableConcrete.NativeMethods.efl_pack_table_columns_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cols);
 256         Eina.Error.RaiseIfUnhandledException();
 257                          }
 258     /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
 259     /// <returns>Amount of rows.</returns>
 260     virtual public int GetTableRows() {
 261          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));
 262         Eina.Error.RaiseIfUnhandledException();
 263         return _ret_var;
 264  }
 265     /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
 266     /// <param name="rows">Amount of rows.</param>
 267     virtual public void SetTableRows(int rows) {
 268                                  Efl.IPackTableConcrete.NativeMethods.efl_pack_table_rows_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),rows);
 269         Eina.Error.RaiseIfUnhandledException();
 270                          }
 271     /// <summary>Pack object at a given location in the table.
 272     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 273     /// <param name="subobj">A child object to pack in this table.</param>
 274     /// <param name="col">Column number</param>
 275     /// <param name="row">Row number</param>
 276     /// <param name="colspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableColumns"/></param>
 277     /// <param name="rowspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableRows"/></param>
 278     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 279     virtual public bool PackTable(Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan) {
 280                                                                                                                                  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);
 281         Eina.Error.RaiseIfUnhandledException();
 282                                                                                         return _ret_var;
 283  }
 284     /// <summary>Returns all objects at a given position in this table.</summary>
 285     /// <param name="col">Column number</param>
 286     /// <param name="row">Row number</param>
 287     /// <param name="below">If <c>true</c> get objects spanning over this cell.</param>
 288     /// <returns>Iterator to table contents</returns>
 289     virtual public Eina.Iterator<Efl.Gfx.IEntity> GetTableContents(int col, int row, bool below) {
 290                                                                                  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);
 291         Eina.Error.RaiseIfUnhandledException();
 292                                                         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 293  }
 294     /// <summary>Returns a child at a given position, see <see cref="Efl.IPackTable.GetTableContents"/>.</summary>
 295     /// <param name="col">Column number</param>
 296     /// <param name="row">Row number</param>
 297     /// <returns>Child object</returns>
 298     virtual public Efl.Gfx.IEntity GetTableContent(int col, int row) {
 299                                                          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);
 300         Eina.Error.RaiseIfUnhandledException();
 301                                         return _ret_var;
 302  }
 303     /// <summary>Specifies the amount of columns the table will have when the fill direction is horizontal. If it is vertical, the amount of columns depends on the amount of cells added and <see cref="Efl.IPackTable.TableRows"/>.</summary>
 304     /// <value>Amount of columns.</value>
 305     public int TableColumns {
 306         get { return GetTableColumns(); }
 307         set { SetTableColumns(value); }
 308     }
 309     /// <summary>Specifies the amount of rows the table will have when the fill direction is vertical. If it is horizontal, the amount of rows depends on the amount of cells added and <see cref="Efl.IPackTable.TableColumns"/>.</summary>
 310     /// <value>Amount of rows.</value>
 311     public int TableRows {
 312         get { return GetTableRows(); }
 313         set { SetTableRows(value); }
 314     }
 315     private static IntPtr GetEflClassStatic()
 316     {
 317         return Efl.Canvas.LayoutPartTable.efl_canvas_layout_part_table_class_get();
 318     }
 319     /// <summary>Wrapper for native methods and virtual method delegates.
 320     /// For internal use by generated code only.</summary>
 321     public new class NativeMethods : Efl.Canvas.LayoutPart.NativeMethods
 322     {
 323         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Edje);
 324         /// <summary>Gets the list of Eo operations to override.</summary>
 325         /// <returns>The list of Eo operations to be overload.</returns>
 326         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 327         {
 328             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 329             var methods = Efl.Eo.Globals.GetUserMethods(type);
 330
 331             if (efl_content_iterate_static_delegate == null)
 332             {
 333                 efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 334             }
 335
 336             if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 337             {
 338                 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) });
 339             }
 340
 341             if (efl_content_count_static_delegate == null)
 342             {
 343                 efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 344             }
 345
 346             if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 347             {
 348                 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) });
 349             }
 350
 351             if (efl_pack_clear_static_delegate == null)
 352             {
 353                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 354             }
 355
 356             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 357             {
 358                 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) });
 359             }
 360
 361             if (efl_pack_unpack_all_static_delegate == null)
 362             {
 363                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 364             }
 365
 366             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 367             {
 368                 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) });
 369             }
 370
 371             if (efl_pack_unpack_static_delegate == null)
 372             {
 373                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 374             }
 375
 376             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 377             {
 378                 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) });
 379             }
 380
 381             if (efl_pack_static_delegate == null)
 382             {
 383                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 384             }
 385
 386             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 387             {
 388                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 389             }
 390
 391             if (efl_pack_table_position_get_static_delegate == null)
 392             {
 393                 efl_pack_table_position_get_static_delegate = new efl_pack_table_position_get_delegate(table_position_get);
 394             }
 395
 396             if (methods.FirstOrDefault(m => m.Name == "GetTablePosition") != null)
 397             {
 398                 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) });
 399             }
 400
 401             if (efl_pack_table_size_get_static_delegate == null)
 402             {
 403                 efl_pack_table_size_get_static_delegate = new efl_pack_table_size_get_delegate(table_size_get);
 404             }
 405
 406             if (methods.FirstOrDefault(m => m.Name == "GetTableSize") != null)
 407             {
 408                 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) });
 409             }
 410
 411             if (efl_pack_table_size_set_static_delegate == null)
 412             {
 413                 efl_pack_table_size_set_static_delegate = new efl_pack_table_size_set_delegate(table_size_set);
 414             }
 415
 416             if (methods.FirstOrDefault(m => m.Name == "SetTableSize") != null)
 417             {
 418                 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) });
 419             }
 420
 421             if (efl_pack_table_columns_get_static_delegate == null)
 422             {
 423                 efl_pack_table_columns_get_static_delegate = new efl_pack_table_columns_get_delegate(table_columns_get);
 424             }
 425
 426             if (methods.FirstOrDefault(m => m.Name == "GetTableColumns") != null)
 427             {
 428                 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) });
 429             }
 430
 431             if (efl_pack_table_columns_set_static_delegate == null)
 432             {
 433                 efl_pack_table_columns_set_static_delegate = new efl_pack_table_columns_set_delegate(table_columns_set);
 434             }
 435
 436             if (methods.FirstOrDefault(m => m.Name == "SetTableColumns") != null)
 437             {
 438                 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) });
 439             }
 440
 441             if (efl_pack_table_rows_get_static_delegate == null)
 442             {
 443                 efl_pack_table_rows_get_static_delegate = new efl_pack_table_rows_get_delegate(table_rows_get);
 444             }
 445
 446             if (methods.FirstOrDefault(m => m.Name == "GetTableRows") != null)
 447             {
 448                 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) });
 449             }
 450
 451             if (efl_pack_table_rows_set_static_delegate == null)
 452             {
 453                 efl_pack_table_rows_set_static_delegate = new efl_pack_table_rows_set_delegate(table_rows_set);
 454             }
 455
 456             if (methods.FirstOrDefault(m => m.Name == "SetTableRows") != null)
 457             {
 458                 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) });
 459             }
 460
 461             if (efl_pack_table_static_delegate == null)
 462             {
 463                 efl_pack_table_static_delegate = new efl_pack_table_delegate(pack_table);
 464             }
 465
 466             if (methods.FirstOrDefault(m => m.Name == "PackTable") != null)
 467             {
 468                 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) });
 469             }
 470
 471             if (efl_pack_table_contents_get_static_delegate == null)
 472             {
 473                 efl_pack_table_contents_get_static_delegate = new efl_pack_table_contents_get_delegate(table_contents_get);
 474             }
 475
 476             if (methods.FirstOrDefault(m => m.Name == "GetTableContents") != null)
 477             {
 478                 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) });
 479             }
 480
 481             if (efl_pack_table_content_get_static_delegate == null)
 482             {
 483                 efl_pack_table_content_get_static_delegate = new efl_pack_table_content_get_delegate(table_content_get);
 484             }
 485
 486             if (methods.FirstOrDefault(m => m.Name == "GetTableContent") != null)
 487             {
 488                 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) });
 489             }
 490
 491             descs.AddRange(base.GetEoOps(type));
 492             return descs;
 493         }
 494         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 495         /// <returns>The native class pointer.</returns>
 496         public override IntPtr GetEflClass()
 497         {
 498             return Efl.Canvas.LayoutPartTable.efl_canvas_layout_part_table_class_get();
 499         }
 500
 501         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 502
 503
 504         private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 505
 506
 507         public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
 508
 509         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");
 510
 511         private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
 512         {
 513             Eina.Log.Debug("function efl_content_iterate was called");
 514             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 515             if (ws != null)
 516             {
 517             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
 518                 try
 519                 {
 520                     _ret_var = ((LayoutPartTable)ws.Target).ContentIterate();
 521                 }
 522                 catch (Exception e)
 523                 {
 524                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 525                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 526                 }
 527
 528         _ret_var.Own = false; return _ret_var.Handle;
 529
 530             }
 531             else
 532             {
 533                 return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 534             }
 535         }
 536
 537         private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
 538
 539
 540         private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
 541
 542
 543         public delegate int efl_content_count_api_delegate(System.IntPtr obj);
 544
 545         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");
 546
 547         private static int content_count(System.IntPtr obj, System.IntPtr pd)
 548         {
 549             Eina.Log.Debug("function efl_content_count was called");
 550             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 551             if (ws != null)
 552             {
 553             int _ret_var = default(int);
 554                 try
 555                 {
 556                     _ret_var = ((LayoutPartTable)ws.Target).ContentCount();
 557                 }
 558                 catch (Exception e)
 559                 {
 560                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 561                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 562                 }
 563
 564         return _ret_var;
 565
 566             }
 567             else
 568             {
 569                 return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 570             }
 571         }
 572
 573         private static efl_content_count_delegate efl_content_count_static_delegate;
 574
 575         [return: MarshalAs(UnmanagedType.U1)]
 576         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 577
 578         [return: MarshalAs(UnmanagedType.U1)]
 579         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 580
 581         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");
 582
 583         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 584         {
 585             Eina.Log.Debug("function efl_pack_clear was called");
 586             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 587             if (ws != null)
 588             {
 589             bool _ret_var = default(bool);
 590                 try
 591                 {
 592                     _ret_var = ((LayoutPartTable)ws.Target).ClearPack();
 593                 }
 594                 catch (Exception e)
 595                 {
 596                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 597                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 598                 }
 599
 600         return _ret_var;
 601
 602             }
 603             else
 604             {
 605                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 606             }
 607         }
 608
 609         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 610
 611         [return: MarshalAs(UnmanagedType.U1)]
 612         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 613
 614         [return: MarshalAs(UnmanagedType.U1)]
 615         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 616
 617         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");
 618
 619         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 620         {
 621             Eina.Log.Debug("function efl_pack_unpack_all was called");
 622             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 623             if (ws != null)
 624             {
 625             bool _ret_var = default(bool);
 626                 try
 627                 {
 628                     _ret_var = ((LayoutPartTable)ws.Target).UnpackAll();
 629                 }
 630                 catch (Exception e)
 631                 {
 632                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 633                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 634                 }
 635
 636         return _ret_var;
 637
 638             }
 639             else
 640             {
 641                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 642             }
 643         }
 644
 645         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 646
 647         [return: MarshalAs(UnmanagedType.U1)]
 648         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);
 649
 650         [return: MarshalAs(UnmanagedType.U1)]
 651         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);
 652
 653         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");
 654
 655         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 656         {
 657             Eina.Log.Debug("function efl_pack_unpack was called");
 658             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 659             if (ws != null)
 660             {
 661                                     bool _ret_var = default(bool);
 662                 try
 663                 {
 664                     _ret_var = ((LayoutPartTable)ws.Target).Unpack(subobj);
 665                 }
 666                 catch (Exception e)
 667                 {
 668                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 669                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 670                 }
 671
 672                         return _ret_var;
 673
 674             }
 675             else
 676             {
 677                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 678             }
 679         }
 680
 681         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 682
 683         [return: MarshalAs(UnmanagedType.U1)]
 684         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);
 685
 686         [return: MarshalAs(UnmanagedType.U1)]
 687         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);
 688
 689         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
 690
 691         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 692         {
 693             Eina.Log.Debug("function efl_pack was called");
 694             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 695             if (ws != null)
 696             {
 697                                     bool _ret_var = default(bool);
 698                 try
 699                 {
 700                     _ret_var = ((LayoutPartTable)ws.Target).Pack(subobj);
 701                 }
 702                 catch (Exception e)
 703                 {
 704                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 705                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 706                 }
 707
 708                         return _ret_var;
 709
 710             }
 711             else
 712             {
 713                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 714             }
 715         }
 716
 717         private static efl_pack_delegate efl_pack_static_delegate;
 718
 719         [return: MarshalAs(UnmanagedType.U1)]
 720         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);
 721
 722         [return: MarshalAs(UnmanagedType.U1)]
 723         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);
 724
 725         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");
 726
 727         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)
 728         {
 729             Eina.Log.Debug("function efl_pack_table_position_get was called");
 730             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 731             if (ws != null)
 732             {
 733                                                         col = default(int);        row = default(int);        colspan = default(int);        rowspan = default(int);                                                    bool _ret_var = default(bool);
 734                 try
 735                 {
 736                     _ret_var = ((LayoutPartTable)ws.Target).GetTablePosition(subobj, out col, out row, out colspan, out rowspan);
 737                 }
 738                 catch (Exception e)
 739                 {
 740                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 741                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 742                 }
 743
 744                                                                                         return _ret_var;
 745
 746             }
 747             else
 748             {
 749                 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);
 750             }
 751         }
 752
 753         private static efl_pack_table_position_get_delegate efl_pack_table_position_get_static_delegate;
 754
 755
 756         private delegate void efl_pack_table_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int cols,  out int rows);
 757
 758
 759         public delegate void efl_pack_table_size_get_api_delegate(System.IntPtr obj,  out int cols,  out int rows);
 760
 761         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");
 762
 763         private static void table_size_get(System.IntPtr obj, System.IntPtr pd, out int cols, out int rows)
 764         {
 765             Eina.Log.Debug("function efl_pack_table_size_get was called");
 766             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 767             if (ws != null)
 768             {
 769                         cols = default(int);        rows = default(int);
 770                 try
 771                 {
 772                     ((LayoutPartTable)ws.Target).GetTableSize(out cols, out rows);
 773                 }
 774                 catch (Exception e)
 775                 {
 776                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 777                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 778                 }
 779
 780
 781             }
 782             else
 783             {
 784                 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);
 785             }
 786         }
 787
 788         private static efl_pack_table_size_get_delegate efl_pack_table_size_get_static_delegate;
 789
 790
 791         private delegate void efl_pack_table_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  int cols,  int rows);
 792
 793
 794         public delegate void efl_pack_table_size_set_api_delegate(System.IntPtr obj,  int cols,  int rows);
 795
 796         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");
 797
 798         private static void table_size_set(System.IntPtr obj, System.IntPtr pd, int cols, int rows)
 799         {
 800             Eina.Log.Debug("function efl_pack_table_size_set was called");
 801             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 802             if (ws != null)
 803             {
 804
 805                 try
 806                 {
 807                     ((LayoutPartTable)ws.Target).SetTableSize(cols, rows);
 808                 }
 809                 catch (Exception e)
 810                 {
 811                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 812                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 813                 }
 814
 815
 816             }
 817             else
 818             {
 819                 efl_pack_table_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols, rows);
 820             }
 821         }
 822
 823         private static efl_pack_table_size_set_delegate efl_pack_table_size_set_static_delegate;
 824
 825
 826         private delegate int efl_pack_table_columns_get_delegate(System.IntPtr obj, System.IntPtr pd);
 827
 828
 829         public delegate int efl_pack_table_columns_get_api_delegate(System.IntPtr obj);
 830
 831         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");
 832
 833         private static int table_columns_get(System.IntPtr obj, System.IntPtr pd)
 834         {
 835             Eina.Log.Debug("function efl_pack_table_columns_get was called");
 836             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 837             if (ws != null)
 838             {
 839             int _ret_var = default(int);
 840                 try
 841                 {
 842                     _ret_var = ((LayoutPartTable)ws.Target).GetTableColumns();
 843                 }
 844                 catch (Exception e)
 845                 {
 846                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 847                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 848                 }
 849
 850         return _ret_var;
 851
 852             }
 853             else
 854             {
 855                 return efl_pack_table_columns_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 856             }
 857         }
 858
 859         private static efl_pack_table_columns_get_delegate efl_pack_table_columns_get_static_delegate;
 860
 861
 862         private delegate void efl_pack_table_columns_set_delegate(System.IntPtr obj, System.IntPtr pd,  int cols);
 863
 864
 865         public delegate void efl_pack_table_columns_set_api_delegate(System.IntPtr obj,  int cols);
 866
 867         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");
 868
 869         private static void table_columns_set(System.IntPtr obj, System.IntPtr pd, int cols)
 870         {
 871             Eina.Log.Debug("function efl_pack_table_columns_set was called");
 872             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 873             if (ws != null)
 874             {
 875
 876                 try
 877                 {
 878                     ((LayoutPartTable)ws.Target).SetTableColumns(cols);
 879                 }
 880                 catch (Exception e)
 881                 {
 882                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 883                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 884                 }
 885
 886
 887             }
 888             else
 889             {
 890                 efl_pack_table_columns_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols);
 891             }
 892         }
 893
 894         private static efl_pack_table_columns_set_delegate efl_pack_table_columns_set_static_delegate;
 895
 896
 897         private delegate int efl_pack_table_rows_get_delegate(System.IntPtr obj, System.IntPtr pd);
 898
 899
 900         public delegate int efl_pack_table_rows_get_api_delegate(System.IntPtr obj);
 901
 902         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");
 903
 904         private static int table_rows_get(System.IntPtr obj, System.IntPtr pd)
 905         {
 906             Eina.Log.Debug("function efl_pack_table_rows_get was called");
 907             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 908             if (ws != null)
 909             {
 910             int _ret_var = default(int);
 911                 try
 912                 {
 913                     _ret_var = ((LayoutPartTable)ws.Target).GetTableRows();
 914                 }
 915                 catch (Exception e)
 916                 {
 917                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 918                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 919                 }
 920
 921         return _ret_var;
 922
 923             }
 924             else
 925             {
 926                 return efl_pack_table_rows_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 927             }
 928         }
 929
 930         private static efl_pack_table_rows_get_delegate efl_pack_table_rows_get_static_delegate;
 931
 932
 933         private delegate void efl_pack_table_rows_set_delegate(System.IntPtr obj, System.IntPtr pd,  int rows);
 934
 935
 936         public delegate void efl_pack_table_rows_set_api_delegate(System.IntPtr obj,  int rows);
 937
 938         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");
 939
 940         private static void table_rows_set(System.IntPtr obj, System.IntPtr pd, int rows)
 941         {
 942             Eina.Log.Debug("function efl_pack_table_rows_set was called");
 943             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 944             if (ws != null)
 945             {
 946
 947                 try
 948                 {
 949                     ((LayoutPartTable)ws.Target).SetTableRows(rows);
 950                 }
 951                 catch (Exception e)
 952                 {
 953                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 954                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 955                 }
 956
 957
 958             }
 959             else
 960             {
 961                 efl_pack_table_rows_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rows);
 962             }
 963         }
 964
 965         private static efl_pack_table_rows_set_delegate efl_pack_table_rows_set_static_delegate;
 966
 967         [return: MarshalAs(UnmanagedType.U1)]
 968         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);
 969
 970         [return: MarshalAs(UnmanagedType.U1)]
 971         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);
 972
 973         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");
 974
 975         private static bool pack_table(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan)
 976         {
 977             Eina.Log.Debug("function efl_pack_table was called");
 978             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 979             if (ws != null)
 980             {
 981                                                                                                                                     bool _ret_var = default(bool);
 982                 try
 983                 {
 984                     _ret_var = ((LayoutPartTable)ws.Target).PackTable(subobj, col, row, colspan, rowspan);
 985                 }
 986                 catch (Exception e)
 987                 {
 988                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 989                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 990                 }
 991
 992                                                                                         return _ret_var;
 993
 994             }
 995             else
 996             {
 997                 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);
 998             }
 999         }
1000
1001         private static efl_pack_table_delegate efl_pack_table_static_delegate;
1002
1003
1004         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);
1005
1006
1007         public delegate System.IntPtr efl_pack_table_contents_get_api_delegate(System.IntPtr obj,  int col,  int row, [MarshalAs(UnmanagedType.U1)] bool below);
1008
1009         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");
1010
1011         private static System.IntPtr table_contents_get(System.IntPtr obj, System.IntPtr pd, int col, int row, bool below)
1012         {
1013             Eina.Log.Debug("function efl_pack_table_contents_get was called");
1014             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1015             if (ws != null)
1016             {
1017                                                                                     Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
1018                 try
1019                 {
1020                     _ret_var = ((LayoutPartTable)ws.Target).GetTableContents(col, row, below);
1021                 }
1022                 catch (Exception e)
1023                 {
1024                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1025                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1026                 }
1027
1028                                                         _ret_var.Own = false; return _ret_var.Handle;
1029
1030             }
1031             else
1032             {
1033                 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);
1034             }
1035         }
1036
1037         private static efl_pack_table_contents_get_delegate efl_pack_table_contents_get_static_delegate;
1038
1039         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1040         private delegate Efl.Gfx.IEntity efl_pack_table_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int col,  int row);
1041
1042         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1043         public delegate Efl.Gfx.IEntity efl_pack_table_content_get_api_delegate(System.IntPtr obj,  int col,  int row);
1044
1045         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");
1046
1047         private static Efl.Gfx.IEntity table_content_get(System.IntPtr obj, System.IntPtr pd, int col, int row)
1048         {
1049             Eina.Log.Debug("function efl_pack_table_content_get was called");
1050             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1051             if (ws != null)
1052             {
1053                                                             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1054                 try
1055                 {
1056                     _ret_var = ((LayoutPartTable)ws.Target).GetTableContent(col, row);
1057                 }
1058                 catch (Exception e)
1059                 {
1060                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1061                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1062                 }
1063
1064                                         return _ret_var;
1065
1066             }
1067             else
1068             {
1069                 return efl_pack_table_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), col, row);
1070             }
1071         }
1072
1073         private static efl_pack_table_content_get_delegate efl_pack_table_content_get_static_delegate;
1074
1075         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1076
1077 }
1078 }
1079 }
1080
1081 }
1082