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