internals/src/EflSharp/EflSharp/efl/efl_ui_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>Widget container that arranges its elements in a grid.
  13 /// The amount of rows and columns can be controlled with <see cref="Efl.IPackTable.TableRows"/> and <see cref="Efl.IPackTable.TableColumns"/>, and elements can be manually positioned with <see cref="Efl.IPackTable.PackTable"/>. Additionally, a fill direction can be defined with <see cref="Efl.Ui.ILayoutOrientable.Orientation"/> and elements added with <see cref="Efl.IPack.Pack"/>. Elements are then added following this direction (horizontal or vertical) and when the amount of columns or rows has been reached, a step is taken in the orthogonal direction. In this second case there is no need to define both the amount of columns and rows, as the table will expand as needed. The default fill direction is <see cref="Efl.Ui.LayoutOrientation.Horizontal"/>.</summary>
  14 [Efl.Ui.Table.NativeMethods]
  15 public class Table : Efl.Ui.Widget, Efl.IContainer, Efl.IPack, Efl.IPackLayout, Efl.IPackTable, Efl.Gfx.IArrangement, Efl.Ui.ILayoutOrientable
  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(Table))
  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_table_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="Table"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  38     public Table(Efl.Object parent
  39             , System.String style = null) : base(efl_ui_table_class_get(), typeof(Table), parent)
  40     {
  41         if (Efl.Eo.Globals.ParamHelperCheck(style))
  42         {
  43             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  44         }
  45
  46         FinishInstantiation();
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="Table"/> class.
  50     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  51     /// <param name="raw">The native pointer to be wrapped.</param>
  52     protected Table(System.IntPtr raw) : base(raw)
  53     {
  54     }
  55
  56     /// <summary>Initializes a new instance of the <see cref="Table"/> class.
  57     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  58     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  59     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  60     /// <param name="parent">The Efl.Object parent of this instance.</param>
  61     protected Table(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  62     {
  63     }
  64
  65     /// <summary>Sent after a new sub-object was added.
  66     /// (Since EFL 1.22)</summary>
  67     public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
  68     {
  69         add
  70         {
  71             lock (eventLock)
  72             {
  73                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  74                 {
  75                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  76                     if (obj != null)
  77                     {
  78                         Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
  79                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
  80                         try
  81                         {
  82                             value?.Invoke(obj, args);
  83                         }
  84                         catch (Exception e)
  85                         {
  86                             Eina.Log.Error(e.ToString());
  87                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  88                         }
  89                     }
  90                 };
  91
  92                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
  93                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
  94             }
  95         }
  96
  97         remove
  98         {
  99             lock (eventLock)
 100             {
 101                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 102                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 103             }
 104         }
 105     }
 106     ///<summary>Method to raise event ContentAddedEvt.</summary>
 107     public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
 108     {
 109         var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 110         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 111         if (desc == IntPtr.Zero)
 112         {
 113             Eina.Log.Error($"Failed to get native event {key}");
 114             return;
 115         }
 116
 117         IntPtr info = e.arg.NativeHandle;
 118         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 119     }
 120     /// <summary>Sent after a sub-object was removed, before unref.
 121     /// (Since EFL 1.22)</summary>
 122     public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
 123     {
 124         add
 125         {
 126             lock (eventLock)
 127             {
 128                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 129                 {
 130                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 131                     if (obj != null)
 132                     {
 133                         Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
 134                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 135                         try
 136                         {
 137                             value?.Invoke(obj, args);
 138                         }
 139                         catch (Exception e)
 140                         {
 141                             Eina.Log.Error(e.ToString());
 142                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 143                         }
 144                     }
 145                 };
 146
 147                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 148                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 149             }
 150         }
 151
 152         remove
 153         {
 154             lock (eventLock)
 155             {
 156                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 157                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 158             }
 159         }
 160     }
 161     ///<summary>Method to raise event ContentRemovedEvt.</summary>
 162     public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
 163     {
 164         var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 165         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 166         if (desc == IntPtr.Zero)
 167         {
 168             Eina.Log.Error($"Failed to get native event {key}");
 169             return;
 170         }
 171
 172         IntPtr info = e.arg.NativeHandle;
 173         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 174     }
 175     /// <summary>Sent after the layout was updated.</summary>
 176     public event EventHandler LayoutUpdatedEvt
 177     {
 178         add
 179         {
 180             lock (eventLock)
 181             {
 182                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 183                 {
 184                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 185                     if (obj != null)
 186                     {
 187                         EventArgs args = EventArgs.Empty;
 188                         try
 189                         {
 190                             value?.Invoke(obj, args);
 191                         }
 192                         catch (Exception e)
 193                         {
 194                             Eina.Log.Error(e.ToString());
 195                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 196                         }
 197                     }
 198                 };
 199
 200                 string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 201                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 202             }
 203         }
 204
 205         remove
 206         {
 207             lock (eventLock)
 208             {
 209                 string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 210                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 211             }
 212         }
 213     }
 214     ///<summary>Method to raise event LayoutUpdatedEvt.</summary>
 215     public void OnLayoutUpdatedEvt(EventArgs e)
 216     {
 217         var key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
 218         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 219         if (desc == IntPtr.Zero)
 220         {
 221             Eina.Log.Error($"Failed to get native event {key}");
 222             return;
 223         }
 224
 225         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 226     }
 227     /// <summary>Control homogeneous mode.
 228     /// This will enable the homogeneous mode where cells are of the same weight and of the same min size which is determined by maximum min size of cells.</summary>
 229     /// <param name="homogeneoush"><c>true</c> if the box is homogeneous horizontally, <c>false</c> otherwise</param>
 230     /// <param name="homogeneousv"><c>true</c> if the box is homogeneous vertically, <c>false</c> otherwise</param>
 231     virtual public void GetHomogeneous(out bool homogeneoush, out bool homogeneousv) {
 232                                                          Efl.Ui.Table.NativeMethods.efl_ui_table_homogeneous_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out homogeneoush, out homogeneousv);
 233         Eina.Error.RaiseIfUnhandledException();
 234                                          }
 235     /// <summary>Control homogeneous mode.
 236     /// This will enable the homogeneous mode where cells are of the same weight and of the same min size which is determined by maximum min size of cells.</summary>
 237     /// <param name="homogeneoush"><c>true</c> if the box is homogeneous horizontally, <c>false</c> otherwise</param>
 238     /// <param name="homogeneousv"><c>true</c> if the box is homogeneous vertically, <c>false</c> otherwise</param>
 239     virtual public void SetHomogeneous(bool homogeneoush, bool homogeneousv) {
 240                                                          Efl.Ui.Table.NativeMethods.efl_ui_table_homogeneous_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),homogeneoush, homogeneousv);
 241         Eina.Error.RaiseIfUnhandledException();
 242                                          }
 243     /// <summary>Begin iterating over this object&apos;s contents.
 244     /// (Since EFL 1.22)</summary>
 245     /// <returns>Iterator on object&apos;s content.</returns>
 246     virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 247          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 248         Eina.Error.RaiseIfUnhandledException();
 249         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 250  }
 251     /// <summary>Returns the number of contained sub-objects.
 252     /// (Since EFL 1.22)</summary>
 253     /// <returns>Number of sub-objects.</returns>
 254     virtual public int ContentCount() {
 255          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 256         Eina.Error.RaiseIfUnhandledException();
 257         return _ret_var;
 258  }
 259     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
 260     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 261     virtual public bool ClearPack() {
 262          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 263         Eina.Error.RaiseIfUnhandledException();
 264         return _ret_var;
 265  }
 266     /// <summary>Removes all packed sub-objects without unreferencing them.
 267     /// Use with caution.</summary>
 268     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 269     virtual public bool UnpackAll() {
 270          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));
 271         Eina.Error.RaiseIfUnhandledException();
 272         return _ret_var;
 273  }
 274     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
 275     /// <param name="subobj">The sub-object to unpack.</param>
 276     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
 277     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
 278                                  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);
 279         Eina.Error.RaiseIfUnhandledException();
 280                         return _ret_var;
 281  }
 282     /// <summary>Adds a sub-object to this container.
 283     /// 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.
 284     ///
 285     /// 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>
 286     /// <param name="subobj">The object to pack.</param>
 287     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 288     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 289                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 290         Eina.Error.RaiseIfUnhandledException();
 291                         return _ret_var;
 292  }
 293     /// <summary>Requests EFL to call the <see cref="Efl.IPackLayout.UpdateLayout"/> method on this object.
 294     /// This <see cref="Efl.IPackLayout.UpdateLayout"/> may be called asynchronously.</summary>
 295     virtual public void LayoutRequest() {
 296          Efl.IPackLayoutConcrete.NativeMethods.efl_pack_layout_request_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 297         Eina.Error.RaiseIfUnhandledException();
 298          }
 299     /// <summary>Implementation of this container&apos;s layout algorithm.
 300     /// EFL will call this function whenever the contents of this container need to be re-laid out on the canvas.
 301     ///
 302     /// This can be overriden to implement custom layout behaviors.</summary>
 303     virtual public void UpdateLayout() {
 304          Efl.IPackLayoutConcrete.NativeMethods.efl_pack_layout_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 305         Eina.Error.RaiseIfUnhandledException();
 306          }
 307     /// <summary>Position and span of the <c>subobj</c> in this container, may be modified to move the <c>subobj</c></summary>
 308     /// <param name="subobj">Child object</param>
 309     /// <param name="col">Column number</param>
 310     /// <param name="row">Row number</param>
 311     /// <param name="colspan">Column span</param>
 312     /// <param name="rowspan">Row span</param>
 313     /// <returns>Returns false if item is not a child</returns>
 314     virtual public bool GetTablePosition(Efl.Gfx.IEntity subobj, out int col, out int row, out int colspan, out int rowspan) {
 315                                                                                                                                  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);
 316         Eina.Error.RaiseIfUnhandledException();
 317                                                                                         return _ret_var;
 318  }
 319     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 320     /// <param name="cols">Number of columns</param>
 321     /// <param name="rows">Number of rows</param>
 322     virtual public void GetTableSize(out int cols, out int rows) {
 323                                                          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);
 324         Eina.Error.RaiseIfUnhandledException();
 325                                          }
 326     /// <summary>Combines <see cref="Efl.IPackTable.TableColumns"/> and <see cref="Efl.IPackTable.TableRows"/></summary>
 327     /// <param name="cols">Number of columns</param>
 328     /// <param name="rows">Number of rows</param>
 329     virtual public void SetTableSize(int cols, int rows) {
 330                                                          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);
 331         Eina.Error.RaiseIfUnhandledException();
 332                                          }
 333     /// <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>
 334     /// <returns>Amount of columns.</returns>
 335     virtual public int GetTableColumns() {
 336          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));
 337         Eina.Error.RaiseIfUnhandledException();
 338         return _ret_var;
 339  }
 340     /// <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>
 341     /// <param name="cols">Amount of columns.</param>
 342     virtual public void SetTableColumns(int cols) {
 343                                  Efl.IPackTableConcrete.NativeMethods.efl_pack_table_columns_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),cols);
 344         Eina.Error.RaiseIfUnhandledException();
 345                          }
 346     /// <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>
 347     /// <returns>Amount of rows.</returns>
 348     virtual public int GetTableRows() {
 349          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));
 350         Eina.Error.RaiseIfUnhandledException();
 351         return _ret_var;
 352  }
 353     /// <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>
 354     /// <param name="rows">Amount of rows.</param>
 355     virtual public void SetTableRows(int rows) {
 356                                  Efl.IPackTableConcrete.NativeMethods.efl_pack_table_rows_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),rows);
 357         Eina.Error.RaiseIfUnhandledException();
 358                          }
 359     /// <summary>Pack object at a given location in the table.
 360     /// 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>
 361     /// <param name="subobj">A child object to pack in this table.</param>
 362     /// <param name="col">Column number</param>
 363     /// <param name="row">Row number</param>
 364     /// <param name="colspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableColumns"/></param>
 365     /// <param name="rowspan">0 means 1, -1 means <see cref="Efl.IPackTable.TableRows"/></param>
 366     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 367     virtual public bool PackTable(Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan) {
 368                                                                                                                                  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);
 369         Eina.Error.RaiseIfUnhandledException();
 370                                                                                         return _ret_var;
 371  }
 372     /// <summary>Returns all objects at a given position in this table.</summary>
 373     /// <param name="col">Column number</param>
 374     /// <param name="row">Row number</param>
 375     /// <param name="below">If <c>true</c> get objects spanning over this cell.</param>
 376     /// <returns>Iterator to table contents</returns>
 377     virtual public Eina.Iterator<Efl.Gfx.IEntity> GetTableContents(int col, int row, bool below) {
 378                                                                                  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);
 379         Eina.Error.RaiseIfUnhandledException();
 380                                                         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true, false);
 381  }
 382     /// <summary>Returns a child at a given position, see <see cref="Efl.IPackTable.GetTableContents"/>.</summary>
 383     /// <param name="col">Column number</param>
 384     /// <param name="row">Row number</param>
 385     /// <returns>Child object</returns>
 386     virtual public Efl.Gfx.IEntity GetTableContent(int col, int row) {
 387                                                          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);
 388         Eina.Error.RaiseIfUnhandledException();
 389                                         return _ret_var;
 390  }
 391     /// <summary>Alignment of the container within its bounds</summary>
 392     /// <param name="align_horiz">Horizontal alignment</param>
 393     /// <param name="align_vert">Vertical alignment</param>
 394     virtual public void GetContentAlign(out double align_horiz, out double align_vert) {
 395                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out align_horiz, out align_vert);
 396         Eina.Error.RaiseIfUnhandledException();
 397                                          }
 398     /// <summary>Alignment of the container within its bounds</summary>
 399     /// <param name="align_horiz">Horizontal alignment</param>
 400     /// <param name="align_vert">Vertical alignment</param>
 401     virtual public void SetContentAlign(double align_horiz, double align_vert) {
 402                                                          Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_align_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),align_horiz, align_vert);
 403         Eina.Error.RaiseIfUnhandledException();
 404                                          }
 405     /// <summary>Padding between items contained in this object.</summary>
 406     /// <param name="pad_horiz">Horizontal padding</param>
 407     /// <param name="pad_vert">Vertical padding</param>
 408     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 409     virtual public void GetContentPadding(out double pad_horiz, out double pad_vert, out bool scalable) {
 410                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out pad_horiz, out pad_vert, out scalable);
 411         Eina.Error.RaiseIfUnhandledException();
 412                                                          }
 413     /// <summary>Padding between items contained in this object.</summary>
 414     /// <param name="pad_horiz">Horizontal padding</param>
 415     /// <param name="pad_vert">Vertical padding</param>
 416     /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 417     virtual public void SetContentPadding(double pad_horiz, double pad_vert, bool scalable) {
 418                                                                                  Efl.Gfx.IArrangementConcrete.NativeMethods.efl_gfx_arrangement_content_padding_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),pad_horiz, pad_vert, scalable);
 419         Eina.Error.RaiseIfUnhandledException();
 420                                                          }
 421     /// <summary>Control the direction of a given widget.
 422     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 423     ///
 424     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 425     /// <returns>Direction of the widget.</returns>
 426     virtual public Efl.Ui.LayoutOrientation GetOrientation() {
 427          var _ret_var = Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 428         Eina.Error.RaiseIfUnhandledException();
 429         return _ret_var;
 430  }
 431     /// <summary>Control the direction of a given widget.
 432     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 433     ///
 434     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 435     /// <param name="dir">Direction of the widget.</param>
 436     virtual public void SetOrientation(Efl.Ui.LayoutOrientation dir) {
 437                                  Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dir);
 438         Eina.Error.RaiseIfUnhandledException();
 439                          }
 440     /// <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>
 441     /// <value>Amount of columns.</value>
 442     public int TableColumns {
 443         get { return GetTableColumns(); }
 444         set { SetTableColumns(value); }
 445     }
 446     /// <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>
 447     /// <value>Amount of rows.</value>
 448     public int TableRows {
 449         get { return GetTableRows(); }
 450         set { SetTableRows(value); }
 451     }
 452     /// <summary>Control the direction of a given widget.
 453     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 454     ///
 455     /// Mirroring as defined in <see cref="Efl.Ui.II18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
 456     /// <value>Direction of the widget.</value>
 457     public Efl.Ui.LayoutOrientation Orientation {
 458         get { return GetOrientation(); }
 459         set { SetOrientation(value); }
 460     }
 461     private static IntPtr GetEflClassStatic()
 462     {
 463         return Efl.Ui.Table.efl_ui_table_class_get();
 464     }
 465     /// <summary>Wrapper for native methods and virtual method delegates.
 466     /// For internal use by generated code only.</summary>
 467     public new class NativeMethods : Efl.Ui.Widget.NativeMethods
 468     {
 469         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 470         /// <summary>Gets the list of Eo operations to override.</summary>
 471         /// <returns>The list of Eo operations to be overload.</returns>
 472         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 473         {
 474             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 475             var methods = Efl.Eo.Globals.GetUserMethods(type);
 476
 477             if (efl_ui_table_homogeneous_get_static_delegate == null)
 478             {
 479                 efl_ui_table_homogeneous_get_static_delegate = new efl_ui_table_homogeneous_get_delegate(homogeneous_get);
 480             }
 481
 482             if (methods.FirstOrDefault(m => m.Name == "GetHomogeneous") != null)
 483             {
 484                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_table_homogeneous_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_table_homogeneous_get_static_delegate) });
 485             }
 486
 487             if (efl_ui_table_homogeneous_set_static_delegate == null)
 488             {
 489                 efl_ui_table_homogeneous_set_static_delegate = new efl_ui_table_homogeneous_set_delegate(homogeneous_set);
 490             }
 491
 492             if (methods.FirstOrDefault(m => m.Name == "SetHomogeneous") != null)
 493             {
 494                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_table_homogeneous_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_table_homogeneous_set_static_delegate) });
 495             }
 496
 497             if (efl_content_iterate_static_delegate == null)
 498             {
 499                 efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 500             }
 501
 502             if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 503             {
 504                 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) });
 505             }
 506
 507             if (efl_content_count_static_delegate == null)
 508             {
 509                 efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 510             }
 511
 512             if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 513             {
 514                 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) });
 515             }
 516
 517             if (efl_pack_clear_static_delegate == null)
 518             {
 519                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 520             }
 521
 522             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 523             {
 524                 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) });
 525             }
 526
 527             if (efl_pack_unpack_all_static_delegate == null)
 528             {
 529                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 530             }
 531
 532             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 533             {
 534                 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) });
 535             }
 536
 537             if (efl_pack_unpack_static_delegate == null)
 538             {
 539                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 540             }
 541
 542             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 543             {
 544                 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) });
 545             }
 546
 547             if (efl_pack_static_delegate == null)
 548             {
 549                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 550             }
 551
 552             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 553             {
 554                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 555             }
 556
 557             if (efl_pack_layout_request_static_delegate == null)
 558             {
 559                 efl_pack_layout_request_static_delegate = new efl_pack_layout_request_delegate(layout_request);
 560             }
 561
 562             if (methods.FirstOrDefault(m => m.Name == "LayoutRequest") != null)
 563             {
 564                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_layout_request"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_layout_request_static_delegate) });
 565             }
 566
 567             if (efl_pack_layout_update_static_delegate == null)
 568             {
 569                 efl_pack_layout_update_static_delegate = new efl_pack_layout_update_delegate(layout_update);
 570             }
 571
 572             if (methods.FirstOrDefault(m => m.Name == "UpdateLayout") != null)
 573             {
 574                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_layout_update"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_layout_update_static_delegate) });
 575             }
 576
 577             if (efl_pack_table_position_get_static_delegate == null)
 578             {
 579                 efl_pack_table_position_get_static_delegate = new efl_pack_table_position_get_delegate(table_position_get);
 580             }
 581
 582             if (methods.FirstOrDefault(m => m.Name == "GetTablePosition") != null)
 583             {
 584                 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) });
 585             }
 586
 587             if (efl_pack_table_size_get_static_delegate == null)
 588             {
 589                 efl_pack_table_size_get_static_delegate = new efl_pack_table_size_get_delegate(table_size_get);
 590             }
 591
 592             if (methods.FirstOrDefault(m => m.Name == "GetTableSize") != null)
 593             {
 594                 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) });
 595             }
 596
 597             if (efl_pack_table_size_set_static_delegate == null)
 598             {
 599                 efl_pack_table_size_set_static_delegate = new efl_pack_table_size_set_delegate(table_size_set);
 600             }
 601
 602             if (methods.FirstOrDefault(m => m.Name == "SetTableSize") != null)
 603             {
 604                 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) });
 605             }
 606
 607             if (efl_pack_table_columns_get_static_delegate == null)
 608             {
 609                 efl_pack_table_columns_get_static_delegate = new efl_pack_table_columns_get_delegate(table_columns_get);
 610             }
 611
 612             if (methods.FirstOrDefault(m => m.Name == "GetTableColumns") != null)
 613             {
 614                 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) });
 615             }
 616
 617             if (efl_pack_table_columns_set_static_delegate == null)
 618             {
 619                 efl_pack_table_columns_set_static_delegate = new efl_pack_table_columns_set_delegate(table_columns_set);
 620             }
 621
 622             if (methods.FirstOrDefault(m => m.Name == "SetTableColumns") != null)
 623             {
 624                 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) });
 625             }
 626
 627             if (efl_pack_table_rows_get_static_delegate == null)
 628             {
 629                 efl_pack_table_rows_get_static_delegate = new efl_pack_table_rows_get_delegate(table_rows_get);
 630             }
 631
 632             if (methods.FirstOrDefault(m => m.Name == "GetTableRows") != null)
 633             {
 634                 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) });
 635             }
 636
 637             if (efl_pack_table_rows_set_static_delegate == null)
 638             {
 639                 efl_pack_table_rows_set_static_delegate = new efl_pack_table_rows_set_delegate(table_rows_set);
 640             }
 641
 642             if (methods.FirstOrDefault(m => m.Name == "SetTableRows") != null)
 643             {
 644                 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) });
 645             }
 646
 647             if (efl_pack_table_static_delegate == null)
 648             {
 649                 efl_pack_table_static_delegate = new efl_pack_table_delegate(pack_table);
 650             }
 651
 652             if (methods.FirstOrDefault(m => m.Name == "PackTable") != null)
 653             {
 654                 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) });
 655             }
 656
 657             if (efl_pack_table_contents_get_static_delegate == null)
 658             {
 659                 efl_pack_table_contents_get_static_delegate = new efl_pack_table_contents_get_delegate(table_contents_get);
 660             }
 661
 662             if (methods.FirstOrDefault(m => m.Name == "GetTableContents") != null)
 663             {
 664                 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) });
 665             }
 666
 667             if (efl_pack_table_content_get_static_delegate == null)
 668             {
 669                 efl_pack_table_content_get_static_delegate = new efl_pack_table_content_get_delegate(table_content_get);
 670             }
 671
 672             if (methods.FirstOrDefault(m => m.Name == "GetTableContent") != null)
 673             {
 674                 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) });
 675             }
 676
 677             if (efl_gfx_arrangement_content_align_get_static_delegate == null)
 678             {
 679                 efl_gfx_arrangement_content_align_get_static_delegate = new efl_gfx_arrangement_content_align_get_delegate(content_align_get);
 680             }
 681
 682             if (methods.FirstOrDefault(m => m.Name == "GetContentAlign") != null)
 683             {
 684                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_align_get_static_delegate) });
 685             }
 686
 687             if (efl_gfx_arrangement_content_align_set_static_delegate == null)
 688             {
 689                 efl_gfx_arrangement_content_align_set_static_delegate = new efl_gfx_arrangement_content_align_set_delegate(content_align_set);
 690             }
 691
 692             if (methods.FirstOrDefault(m => m.Name == "SetContentAlign") != null)
 693             {
 694                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_align_set_static_delegate) });
 695             }
 696
 697             if (efl_gfx_arrangement_content_padding_get_static_delegate == null)
 698             {
 699                 efl_gfx_arrangement_content_padding_get_static_delegate = new efl_gfx_arrangement_content_padding_get_delegate(content_padding_get);
 700             }
 701
 702             if (methods.FirstOrDefault(m => m.Name == "GetContentPadding") != null)
 703             {
 704                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_padding_get_static_delegate) });
 705             }
 706
 707             if (efl_gfx_arrangement_content_padding_set_static_delegate == null)
 708             {
 709                 efl_gfx_arrangement_content_padding_set_static_delegate = new efl_gfx_arrangement_content_padding_set_delegate(content_padding_set);
 710             }
 711
 712             if (methods.FirstOrDefault(m => m.Name == "SetContentPadding") != null)
 713             {
 714                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_arrangement_content_padding_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_arrangement_content_padding_set_static_delegate) });
 715             }
 716
 717             if (efl_ui_layout_orientation_get_static_delegate == null)
 718             {
 719                 efl_ui_layout_orientation_get_static_delegate = new efl_ui_layout_orientation_get_delegate(orientation_get);
 720             }
 721
 722             if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
 723             {
 724                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_get_static_delegate) });
 725             }
 726
 727             if (efl_ui_layout_orientation_set_static_delegate == null)
 728             {
 729                 efl_ui_layout_orientation_set_static_delegate = new efl_ui_layout_orientation_set_delegate(orientation_set);
 730             }
 731
 732             if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
 733             {
 734                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_layout_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_layout_orientation_set_static_delegate) });
 735             }
 736
 737             descs.AddRange(base.GetEoOps(type));
 738             return descs;
 739         }
 740         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 741         /// <returns>The native class pointer.</returns>
 742         public override IntPtr GetEflClass()
 743         {
 744             return Efl.Ui.Table.efl_ui_table_class_get();
 745         }
 746
 747         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 748
 749
 750         private delegate void efl_ui_table_homogeneous_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] out bool homogeneoush, [MarshalAs(UnmanagedType.U1)] out bool homogeneousv);
 751
 752
 753         public delegate void efl_ui_table_homogeneous_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] out bool homogeneoush, [MarshalAs(UnmanagedType.U1)] out bool homogeneousv);
 754
 755         public static Efl.Eo.FunctionWrapper<efl_ui_table_homogeneous_get_api_delegate> efl_ui_table_homogeneous_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_table_homogeneous_get_api_delegate>(Module, "efl_ui_table_homogeneous_get");
 756
 757         private static void homogeneous_get(System.IntPtr obj, System.IntPtr pd, out bool homogeneoush, out bool homogeneousv)
 758         {
 759             Eina.Log.Debug("function efl_ui_table_homogeneous_get was called");
 760             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 761             if (ws != null)
 762             {
 763                         homogeneoush = default(bool);        homogeneousv = default(bool);
 764                 try
 765                 {
 766                     ((Table)ws.Target).GetHomogeneous(out homogeneoush, out homogeneousv);
 767                 }
 768                 catch (Exception e)
 769                 {
 770                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 771                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 772                 }
 773
 774
 775             }
 776             else
 777             {
 778                 efl_ui_table_homogeneous_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out homogeneoush, out homogeneousv);
 779             }
 780         }
 781
 782         private static efl_ui_table_homogeneous_get_delegate efl_ui_table_homogeneous_get_static_delegate;
 783
 784
 785         private delegate void efl_ui_table_homogeneous_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool homogeneoush, [MarshalAs(UnmanagedType.U1)] bool homogeneousv);
 786
 787
 788         public delegate void efl_ui_table_homogeneous_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool homogeneoush, [MarshalAs(UnmanagedType.U1)] bool homogeneousv);
 789
 790         public static Efl.Eo.FunctionWrapper<efl_ui_table_homogeneous_set_api_delegate> efl_ui_table_homogeneous_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_table_homogeneous_set_api_delegate>(Module, "efl_ui_table_homogeneous_set");
 791
 792         private static void homogeneous_set(System.IntPtr obj, System.IntPtr pd, bool homogeneoush, bool homogeneousv)
 793         {
 794             Eina.Log.Debug("function efl_ui_table_homogeneous_set was called");
 795             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 796             if (ws != null)
 797             {
 798
 799                 try
 800                 {
 801                     ((Table)ws.Target).SetHomogeneous(homogeneoush, homogeneousv);
 802                 }
 803                 catch (Exception e)
 804                 {
 805                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 806                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 807                 }
 808
 809
 810             }
 811             else
 812             {
 813                 efl_ui_table_homogeneous_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), homogeneoush, homogeneousv);
 814             }
 815         }
 816
 817         private static efl_ui_table_homogeneous_set_delegate efl_ui_table_homogeneous_set_static_delegate;
 818
 819
 820         private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 821
 822
 823         public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
 824
 825         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");
 826
 827         private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
 828         {
 829             Eina.Log.Debug("function efl_content_iterate was called");
 830             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 831             if (ws != null)
 832             {
 833             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
 834                 try
 835                 {
 836                     _ret_var = ((Table)ws.Target).ContentIterate();
 837                 }
 838                 catch (Exception e)
 839                 {
 840                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 841                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 842                 }
 843
 844         _ret_var.Own = false; return _ret_var.Handle;
 845
 846             }
 847             else
 848             {
 849                 return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 850             }
 851         }
 852
 853         private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
 854
 855
 856         private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
 857
 858
 859         public delegate int efl_content_count_api_delegate(System.IntPtr obj);
 860
 861         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");
 862
 863         private static int content_count(System.IntPtr obj, System.IntPtr pd)
 864         {
 865             Eina.Log.Debug("function efl_content_count was called");
 866             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 867             if (ws != null)
 868             {
 869             int _ret_var = default(int);
 870                 try
 871                 {
 872                     _ret_var = ((Table)ws.Target).ContentCount();
 873                 }
 874                 catch (Exception e)
 875                 {
 876                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 877                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 878                 }
 879
 880         return _ret_var;
 881
 882             }
 883             else
 884             {
 885                 return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 886             }
 887         }
 888
 889         private static efl_content_count_delegate efl_content_count_static_delegate;
 890
 891         [return: MarshalAs(UnmanagedType.U1)]
 892         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 893
 894         [return: MarshalAs(UnmanagedType.U1)]
 895         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 896
 897         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");
 898
 899         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 900         {
 901             Eina.Log.Debug("function efl_pack_clear was called");
 902             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 903             if (ws != null)
 904             {
 905             bool _ret_var = default(bool);
 906                 try
 907                 {
 908                     _ret_var = ((Table)ws.Target).ClearPack();
 909                 }
 910                 catch (Exception e)
 911                 {
 912                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 913                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 914                 }
 915
 916         return _ret_var;
 917
 918             }
 919             else
 920             {
 921                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 922             }
 923         }
 924
 925         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 926
 927         [return: MarshalAs(UnmanagedType.U1)]
 928         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 929
 930         [return: MarshalAs(UnmanagedType.U1)]
 931         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 932
 933         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");
 934
 935         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 936         {
 937             Eina.Log.Debug("function efl_pack_unpack_all was called");
 938             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 939             if (ws != null)
 940             {
 941             bool _ret_var = default(bool);
 942                 try
 943                 {
 944                     _ret_var = ((Table)ws.Target).UnpackAll();
 945                 }
 946                 catch (Exception e)
 947                 {
 948                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 949                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 950                 }
 951
 952         return _ret_var;
 953
 954             }
 955             else
 956             {
 957                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 958             }
 959         }
 960
 961         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 962
 963         [return: MarshalAs(UnmanagedType.U1)]
 964         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);
 965
 966         [return: MarshalAs(UnmanagedType.U1)]
 967         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);
 968
 969         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");
 970
 971         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 972         {
 973             Eina.Log.Debug("function efl_pack_unpack was called");
 974             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 975             if (ws != null)
 976             {
 977                                     bool _ret_var = default(bool);
 978                 try
 979                 {
 980                     _ret_var = ((Table)ws.Target).Unpack(subobj);
 981                 }
 982                 catch (Exception e)
 983                 {
 984                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 985                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 986                 }
 987
 988                         return _ret_var;
 989
 990             }
 991             else
 992             {
 993                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 994             }
 995         }
 996
 997         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 998
 999         [return: MarshalAs(UnmanagedType.U1)]
1000         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);
1001
1002         [return: MarshalAs(UnmanagedType.U1)]
1003         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);
1004
1005         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
1006
1007         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1008         {
1009             Eina.Log.Debug("function efl_pack was called");
1010             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1011             if (ws != null)
1012             {
1013                                     bool _ret_var = default(bool);
1014                 try
1015                 {
1016                     _ret_var = ((Table)ws.Target).Pack(subobj);
1017                 }
1018                 catch (Exception e)
1019                 {
1020                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1021                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1022                 }
1023
1024                         return _ret_var;
1025
1026             }
1027             else
1028             {
1029                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1030             }
1031         }
1032
1033         private static efl_pack_delegate efl_pack_static_delegate;
1034
1035
1036         private delegate void efl_pack_layout_request_delegate(System.IntPtr obj, System.IntPtr pd);
1037
1038
1039         public delegate void efl_pack_layout_request_api_delegate(System.IntPtr obj);
1040
1041         public static Efl.Eo.FunctionWrapper<efl_pack_layout_request_api_delegate> efl_pack_layout_request_ptr = new Efl.Eo.FunctionWrapper<efl_pack_layout_request_api_delegate>(Module, "efl_pack_layout_request");
1042
1043         private static void layout_request(System.IntPtr obj, System.IntPtr pd)
1044         {
1045             Eina.Log.Debug("function efl_pack_layout_request was called");
1046             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1047             if (ws != null)
1048             {
1049
1050                 try
1051                 {
1052                     ((Table)ws.Target).LayoutRequest();
1053                 }
1054                 catch (Exception e)
1055                 {
1056                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1057                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1058                 }
1059
1060
1061             }
1062             else
1063             {
1064                 efl_pack_layout_request_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1065             }
1066         }
1067
1068         private static efl_pack_layout_request_delegate efl_pack_layout_request_static_delegate;
1069
1070
1071         private delegate void efl_pack_layout_update_delegate(System.IntPtr obj, System.IntPtr pd);
1072
1073
1074         public delegate void efl_pack_layout_update_api_delegate(System.IntPtr obj);
1075
1076         public static Efl.Eo.FunctionWrapper<efl_pack_layout_update_api_delegate> efl_pack_layout_update_ptr = new Efl.Eo.FunctionWrapper<efl_pack_layout_update_api_delegate>(Module, "efl_pack_layout_update");
1077
1078         private static void layout_update(System.IntPtr obj, System.IntPtr pd)
1079         {
1080             Eina.Log.Debug("function efl_pack_layout_update was called");
1081             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1082             if (ws != null)
1083             {
1084
1085                 try
1086                 {
1087                     ((Table)ws.Target).UpdateLayout();
1088                 }
1089                 catch (Exception e)
1090                 {
1091                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1092                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1093                 }
1094
1095
1096             }
1097             else
1098             {
1099                 efl_pack_layout_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1100             }
1101         }
1102
1103         private static efl_pack_layout_update_delegate efl_pack_layout_update_static_delegate;
1104
1105         [return: MarshalAs(UnmanagedType.U1)]
1106         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);
1107
1108         [return: MarshalAs(UnmanagedType.U1)]
1109         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);
1110
1111         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");
1112
1113         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)
1114         {
1115             Eina.Log.Debug("function efl_pack_table_position_get was called");
1116             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1117             if (ws != null)
1118             {
1119                                                         col = default(int);        row = default(int);        colspan = default(int);        rowspan = default(int);                                                    bool _ret_var = default(bool);
1120                 try
1121                 {
1122                     _ret_var = ((Table)ws.Target).GetTablePosition(subobj, out col, out row, out colspan, out rowspan);
1123                 }
1124                 catch (Exception e)
1125                 {
1126                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1127                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1128                 }
1129
1130                                                                                         return _ret_var;
1131
1132             }
1133             else
1134             {
1135                 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);
1136             }
1137         }
1138
1139         private static efl_pack_table_position_get_delegate efl_pack_table_position_get_static_delegate;
1140
1141
1142         private delegate void efl_pack_table_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int cols,  out int rows);
1143
1144
1145         public delegate void efl_pack_table_size_get_api_delegate(System.IntPtr obj,  out int cols,  out int rows);
1146
1147         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");
1148
1149         private static void table_size_get(System.IntPtr obj, System.IntPtr pd, out int cols, out int rows)
1150         {
1151             Eina.Log.Debug("function efl_pack_table_size_get was called");
1152             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1153             if (ws != null)
1154             {
1155                         cols = default(int);        rows = default(int);
1156                 try
1157                 {
1158                     ((Table)ws.Target).GetTableSize(out cols, out rows);
1159                 }
1160                 catch (Exception e)
1161                 {
1162                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1163                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1164                 }
1165
1166
1167             }
1168             else
1169             {
1170                 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);
1171             }
1172         }
1173
1174         private static efl_pack_table_size_get_delegate efl_pack_table_size_get_static_delegate;
1175
1176
1177         private delegate void efl_pack_table_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  int cols,  int rows);
1178
1179
1180         public delegate void efl_pack_table_size_set_api_delegate(System.IntPtr obj,  int cols,  int rows);
1181
1182         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");
1183
1184         private static void table_size_set(System.IntPtr obj, System.IntPtr pd, int cols, int rows)
1185         {
1186             Eina.Log.Debug("function efl_pack_table_size_set was called");
1187             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1188             if (ws != null)
1189             {
1190
1191                 try
1192                 {
1193                     ((Table)ws.Target).SetTableSize(cols, rows);
1194                 }
1195                 catch (Exception e)
1196                 {
1197                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1198                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1199                 }
1200
1201
1202             }
1203             else
1204             {
1205                 efl_pack_table_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols, rows);
1206             }
1207         }
1208
1209         private static efl_pack_table_size_set_delegate efl_pack_table_size_set_static_delegate;
1210
1211
1212         private delegate int efl_pack_table_columns_get_delegate(System.IntPtr obj, System.IntPtr pd);
1213
1214
1215         public delegate int efl_pack_table_columns_get_api_delegate(System.IntPtr obj);
1216
1217         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");
1218
1219         private static int table_columns_get(System.IntPtr obj, System.IntPtr pd)
1220         {
1221             Eina.Log.Debug("function efl_pack_table_columns_get was called");
1222             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1223             if (ws != null)
1224             {
1225             int _ret_var = default(int);
1226                 try
1227                 {
1228                     _ret_var = ((Table)ws.Target).GetTableColumns();
1229                 }
1230                 catch (Exception e)
1231                 {
1232                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1233                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1234                 }
1235
1236         return _ret_var;
1237
1238             }
1239             else
1240             {
1241                 return efl_pack_table_columns_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1242             }
1243         }
1244
1245         private static efl_pack_table_columns_get_delegate efl_pack_table_columns_get_static_delegate;
1246
1247
1248         private delegate void efl_pack_table_columns_set_delegate(System.IntPtr obj, System.IntPtr pd,  int cols);
1249
1250
1251         public delegate void efl_pack_table_columns_set_api_delegate(System.IntPtr obj,  int cols);
1252
1253         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");
1254
1255         private static void table_columns_set(System.IntPtr obj, System.IntPtr pd, int cols)
1256         {
1257             Eina.Log.Debug("function efl_pack_table_columns_set was called");
1258             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1259             if (ws != null)
1260             {
1261
1262                 try
1263                 {
1264                     ((Table)ws.Target).SetTableColumns(cols);
1265                 }
1266                 catch (Exception e)
1267                 {
1268                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1269                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1270                 }
1271
1272
1273             }
1274             else
1275             {
1276                 efl_pack_table_columns_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cols);
1277             }
1278         }
1279
1280         private static efl_pack_table_columns_set_delegate efl_pack_table_columns_set_static_delegate;
1281
1282
1283         private delegate int efl_pack_table_rows_get_delegate(System.IntPtr obj, System.IntPtr pd);
1284
1285
1286         public delegate int efl_pack_table_rows_get_api_delegate(System.IntPtr obj);
1287
1288         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");
1289
1290         private static int table_rows_get(System.IntPtr obj, System.IntPtr pd)
1291         {
1292             Eina.Log.Debug("function efl_pack_table_rows_get was called");
1293             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1294             if (ws != null)
1295             {
1296             int _ret_var = default(int);
1297                 try
1298                 {
1299                     _ret_var = ((Table)ws.Target).GetTableRows();
1300                 }
1301                 catch (Exception e)
1302                 {
1303                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1304                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1305                 }
1306
1307         return _ret_var;
1308
1309             }
1310             else
1311             {
1312                 return efl_pack_table_rows_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1313             }
1314         }
1315
1316         private static efl_pack_table_rows_get_delegate efl_pack_table_rows_get_static_delegate;
1317
1318
1319         private delegate void efl_pack_table_rows_set_delegate(System.IntPtr obj, System.IntPtr pd,  int rows);
1320
1321
1322         public delegate void efl_pack_table_rows_set_api_delegate(System.IntPtr obj,  int rows);
1323
1324         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");
1325
1326         private static void table_rows_set(System.IntPtr obj, System.IntPtr pd, int rows)
1327         {
1328             Eina.Log.Debug("function efl_pack_table_rows_set was called");
1329             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1330             if (ws != null)
1331             {
1332
1333                 try
1334                 {
1335                     ((Table)ws.Target).SetTableRows(rows);
1336                 }
1337                 catch (Exception e)
1338                 {
1339                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1340                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1341                 }
1342
1343
1344             }
1345             else
1346             {
1347                 efl_pack_table_rows_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rows);
1348             }
1349         }
1350
1351         private static efl_pack_table_rows_set_delegate efl_pack_table_rows_set_static_delegate;
1352
1353         [return: MarshalAs(UnmanagedType.U1)]
1354         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);
1355
1356         [return: MarshalAs(UnmanagedType.U1)]
1357         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);
1358
1359         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");
1360
1361         private static bool pack_table(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int col, int row, int colspan, int rowspan)
1362         {
1363             Eina.Log.Debug("function efl_pack_table was called");
1364             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1365             if (ws != null)
1366             {
1367                                                                                                                                     bool _ret_var = default(bool);
1368                 try
1369                 {
1370                     _ret_var = ((Table)ws.Target).PackTable(subobj, col, row, colspan, rowspan);
1371                 }
1372                 catch (Exception e)
1373                 {
1374                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1375                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1376                 }
1377
1378                                                                                         return _ret_var;
1379
1380             }
1381             else
1382             {
1383                 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);
1384             }
1385         }
1386
1387         private static efl_pack_table_delegate efl_pack_table_static_delegate;
1388
1389
1390         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);
1391
1392
1393         public delegate System.IntPtr efl_pack_table_contents_get_api_delegate(System.IntPtr obj,  int col,  int row, [MarshalAs(UnmanagedType.U1)] bool below);
1394
1395         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");
1396
1397         private static System.IntPtr table_contents_get(System.IntPtr obj, System.IntPtr pd, int col, int row, bool below)
1398         {
1399             Eina.Log.Debug("function efl_pack_table_contents_get was called");
1400             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1401             if (ws != null)
1402             {
1403                                                                                     Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
1404                 try
1405                 {
1406                     _ret_var = ((Table)ws.Target).GetTableContents(col, row, below);
1407                 }
1408                 catch (Exception e)
1409                 {
1410                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1411                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1412                 }
1413
1414                                                         _ret_var.Own = false; return _ret_var.Handle;
1415
1416             }
1417             else
1418             {
1419                 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);
1420             }
1421         }
1422
1423         private static efl_pack_table_contents_get_delegate efl_pack_table_contents_get_static_delegate;
1424
1425         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1426         private delegate Efl.Gfx.IEntity efl_pack_table_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int col,  int row);
1427
1428         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1429         public delegate Efl.Gfx.IEntity efl_pack_table_content_get_api_delegate(System.IntPtr obj,  int col,  int row);
1430
1431         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");
1432
1433         private static Efl.Gfx.IEntity table_content_get(System.IntPtr obj, System.IntPtr pd, int col, int row)
1434         {
1435             Eina.Log.Debug("function efl_pack_table_content_get was called");
1436             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1437             if (ws != null)
1438             {
1439                                                             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1440                 try
1441                 {
1442                     _ret_var = ((Table)ws.Target).GetTableContent(col, row);
1443                 }
1444                 catch (Exception e)
1445                 {
1446                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1447                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1448                 }
1449
1450                                         return _ret_var;
1451
1452             }
1453             else
1454             {
1455                 return efl_pack_table_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), col, row);
1456             }
1457         }
1458
1459         private static efl_pack_table_content_get_delegate efl_pack_table_content_get_static_delegate;
1460
1461
1462         private delegate void efl_gfx_arrangement_content_align_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert);
1463
1464
1465         public delegate void efl_gfx_arrangement_content_align_get_api_delegate(System.IntPtr obj,  out double align_horiz,  out double align_vert);
1466
1467         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_get_api_delegate> efl_gfx_arrangement_content_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_get_api_delegate>(Module, "efl_gfx_arrangement_content_align_get");
1468
1469         private static void content_align_get(System.IntPtr obj, System.IntPtr pd, out double align_horiz, out double align_vert)
1470         {
1471             Eina.Log.Debug("function efl_gfx_arrangement_content_align_get was called");
1472             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1473             if (ws != null)
1474             {
1475                         align_horiz = default(double);        align_vert = default(double);
1476                 try
1477                 {
1478                     ((Table)ws.Target).GetContentAlign(out align_horiz, out align_vert);
1479                 }
1480                 catch (Exception e)
1481                 {
1482                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1483                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1484                 }
1485
1486
1487             }
1488             else
1489             {
1490                 efl_gfx_arrangement_content_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out align_horiz, out align_vert);
1491             }
1492         }
1493
1494         private static efl_gfx_arrangement_content_align_get_delegate efl_gfx_arrangement_content_align_get_static_delegate;
1495
1496
1497         private delegate void efl_gfx_arrangement_content_align_set_delegate(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert);
1498
1499
1500         public delegate void efl_gfx_arrangement_content_align_set_api_delegate(System.IntPtr obj,  double align_horiz,  double align_vert);
1501
1502         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_set_api_delegate> efl_gfx_arrangement_content_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_align_set_api_delegate>(Module, "efl_gfx_arrangement_content_align_set");
1503
1504         private static void content_align_set(System.IntPtr obj, System.IntPtr pd, double align_horiz, double align_vert)
1505         {
1506             Eina.Log.Debug("function efl_gfx_arrangement_content_align_set was called");
1507             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1508             if (ws != null)
1509             {
1510
1511                 try
1512                 {
1513                     ((Table)ws.Target).SetContentAlign(align_horiz, align_vert);
1514                 }
1515                 catch (Exception e)
1516                 {
1517                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1518                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1519                 }
1520
1521
1522             }
1523             else
1524             {
1525                 efl_gfx_arrangement_content_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), align_horiz, align_vert);
1526             }
1527         }
1528
1529         private static efl_gfx_arrangement_content_align_set_delegate efl_gfx_arrangement_content_align_set_static_delegate;
1530
1531
1532         private delegate void efl_gfx_arrangement_content_padding_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert, [MarshalAs(UnmanagedType.U1)] out bool scalable);
1533
1534
1535         public delegate void efl_gfx_arrangement_content_padding_get_api_delegate(System.IntPtr obj,  out double pad_horiz,  out double pad_vert, [MarshalAs(UnmanagedType.U1)] out bool scalable);
1536
1537         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_get_api_delegate> efl_gfx_arrangement_content_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_get_api_delegate>(Module, "efl_gfx_arrangement_content_padding_get");
1538
1539         private static void content_padding_get(System.IntPtr obj, System.IntPtr pd, out double pad_horiz, out double pad_vert, out bool scalable)
1540         {
1541             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_get was called");
1542             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1543             if (ws != null)
1544             {
1545                                 pad_horiz = default(double);        pad_vert = default(double);        scalable = default(bool);
1546                 try
1547                 {
1548                     ((Table)ws.Target).GetContentPadding(out pad_horiz, out pad_vert, out scalable);
1549                 }
1550                 catch (Exception e)
1551                 {
1552                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1553                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1554                 }
1555
1556
1557             }
1558             else
1559             {
1560                 efl_gfx_arrangement_content_padding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out pad_horiz, out pad_vert, out scalable);
1561             }
1562         }
1563
1564         private static efl_gfx_arrangement_content_padding_get_delegate efl_gfx_arrangement_content_padding_get_static_delegate;
1565
1566
1567         private delegate void efl_gfx_arrangement_content_padding_set_delegate(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert, [MarshalAs(UnmanagedType.U1)] bool scalable);
1568
1569
1570         public delegate void efl_gfx_arrangement_content_padding_set_api_delegate(System.IntPtr obj,  double pad_horiz,  double pad_vert, [MarshalAs(UnmanagedType.U1)] bool scalable);
1571
1572         public static Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_set_api_delegate> efl_gfx_arrangement_content_padding_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_arrangement_content_padding_set_api_delegate>(Module, "efl_gfx_arrangement_content_padding_set");
1573
1574         private static void content_padding_set(System.IntPtr obj, System.IntPtr pd, double pad_horiz, double pad_vert, bool scalable)
1575         {
1576             Eina.Log.Debug("function efl_gfx_arrangement_content_padding_set was called");
1577             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1578             if (ws != null)
1579             {
1580
1581                 try
1582                 {
1583                     ((Table)ws.Target).SetContentPadding(pad_horiz, pad_vert, scalable);
1584                 }
1585                 catch (Exception e)
1586                 {
1587                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1588                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1589                 }
1590
1591
1592             }
1593             else
1594             {
1595                 efl_gfx_arrangement_content_padding_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pad_horiz, pad_vert, scalable);
1596             }
1597         }
1598
1599         private static efl_gfx_arrangement_content_padding_set_delegate efl_gfx_arrangement_content_padding_set_static_delegate;
1600
1601
1602         private delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1603
1604
1605         public delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_api_delegate(System.IntPtr obj);
1606
1607         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate> efl_ui_layout_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_get_api_delegate>(Module, "efl_ui_layout_orientation_get");
1608
1609         private static Efl.Ui.LayoutOrientation orientation_get(System.IntPtr obj, System.IntPtr pd)
1610         {
1611             Eina.Log.Debug("function efl_ui_layout_orientation_get was called");
1612             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1613             if (ws != null)
1614             {
1615             Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
1616                 try
1617                 {
1618                     _ret_var = ((Table)ws.Target).GetOrientation();
1619                 }
1620                 catch (Exception e)
1621                 {
1622                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1623                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1624                 }
1625
1626         return _ret_var;
1627
1628             }
1629             else
1630             {
1631                 return efl_ui_layout_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1632             }
1633         }
1634
1635         private static efl_ui_layout_orientation_get_delegate efl_ui_layout_orientation_get_static_delegate;
1636
1637
1638         private delegate void efl_ui_layout_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
1639
1640
1641         public delegate void efl_ui_layout_orientation_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
1642
1643         public static Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate> efl_ui_layout_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_layout_orientation_set_api_delegate>(Module, "efl_ui_layout_orientation_set");
1644
1645         private static void orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
1646         {
1647             Eina.Log.Debug("function efl_ui_layout_orientation_set was called");
1648             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1649             if (ws != null)
1650             {
1651
1652                 try
1653                 {
1654                     ((Table)ws.Target).SetOrientation(dir);
1655                 }
1656                 catch (Exception e)
1657                 {
1658                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1659                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1660                 }
1661
1662
1663             }
1664             else
1665             {
1666                 efl_ui_layout_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
1667             }
1668         }
1669
1670         private static efl_ui_layout_orientation_set_delegate efl_ui_layout_orientation_set_static_delegate;
1671
1672         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1673
1674 }
1675 }
1676 }
1677
1678 }
1679