internals/src/EflSharp/EflSharp/efl/efl_ui_group_item.eo.cs

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Ui {
  12
  13 /// <summary>Group item for grids and lists</summary>
  14 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  15 [Efl.Ui.GroupItem.NativeMethods]
  16 [Efl.Eo.BindingEntity]
  17 public class GroupItem : Efl.Ui.DefaultItem, Efl.IPack, Efl.IPackLinear
  18 {
  19     /// <summary>Pointer to the native class description.</summary>
  20     public override System.IntPtr NativeClass
  21     {
  22         get
  23         {
  24             if (((object)this).GetType() == typeof(GroupItem))
  25             {
  26                 return GetEflClassStatic();
  27             }
  28             else
  29             {
  30                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  31             }
  32         }
  33     }
  34
  35     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  36         efl_ui_group_item_class_get();
  37     /// <summary>Initializes a new instance of the <see cref="GroupItem"/> class.</summary>
  38     /// <param name="parent">Parent instance.</param>
  39     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  40     public GroupItem(Efl.Object parent
  41             , System.String style = null) : base(efl_ui_group_item_class_get(), parent)
  42     {
  43         if (Efl.Eo.Globals.ParamHelperCheck(style))
  44         {
  45             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  46         }
  47
  48         FinishInstantiation();
  49     }
  50
  51     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  52     /// Do not call this constructor directly.</summary>
  53     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  54     protected GroupItem(ConstructingHandle ch) : base(ch)
  55     {
  56     }
  57
  58     /// <summary>Initializes a new instance of the <see cref="GroupItem"/> class.
  59     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  60     /// <param name="wh">The native pointer to be wrapped.</param>
  61     protected GroupItem(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  62     {
  63     }
  64
  65     /// <summary>Initializes a new instance of the <see cref="GroupItem"/> class.
  66     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  67     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  68     /// <param name="parent">The Efl.Object parent of this instance.</param>
  69     protected GroupItem(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  70     {
  71     }
  72
  73     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
  74     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
  75     virtual public bool ClearPack() {
  76          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  77         Eina.Error.RaiseIfUnhandledException();
  78         return _ret_var;
  79  }
  80     /// <summary>Removes all packed sub-objects without unreferencing them.
  81     /// Use with caution.</summary>
  82     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
  83     virtual public bool UnpackAll() {
  84          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_all_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  85         Eina.Error.RaiseIfUnhandledException();
  86         return _ret_var;
  87  }
  88     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
  89     /// <param name="subobj">The sub-object to unpack.</param>
  90     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
  91     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
  92                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
  93         Eina.Error.RaiseIfUnhandledException();
  94                         return _ret_var;
  95  }
  96     /// <summary>Adds a sub-object to this container.
  97     /// 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.
  98     ///
  99     /// 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>
 100     /// <param name="subobj">The object to pack.</param>
 101     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 102     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 103                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 104         Eina.Error.RaiseIfUnhandledException();
 105                         return _ret_var;
 106  }
 107     /// <summary>Prepend an object at the beginning of this container.
 108     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
 109     ///
 110     /// 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>
 111     /// <param name="subobj">Object to pack at the beginning.</param>
 112     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 113     virtual public bool PackBegin(Efl.Gfx.IEntity subobj) {
 114                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_begin_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 115         Eina.Error.RaiseIfUnhandledException();
 116                         return _ret_var;
 117  }
 118     /// <summary>Append object at the end of this container.
 119     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
 120     ///
 121     /// 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>
 122     /// <param name="subobj">Object to pack at the end.</param>
 123     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 124     virtual public bool PackEnd(Efl.Gfx.IEntity subobj) {
 125                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_end_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 126         Eina.Error.RaiseIfUnhandledException();
 127                         return _ret_var;
 128  }
 129     /// <summary>Prepend an object before an existing sub-object.
 130     /// 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>
 131     /// <param name="subobj">Object to pack before <c>existing</c>.</param>
 132     /// <param name="existing">Existing reference sub-object.</param>
 133     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 134     virtual public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 135                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_before_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, existing);
 136         Eina.Error.RaiseIfUnhandledException();
 137                                         return _ret_var;
 138  }
 139     /// <summary>Append an object after an existing sub-object.
 140     /// 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>
 141     /// <param name="subobj">Object to pack after <c>existing</c>.</param>
 142     /// <param name="existing">Existing reference sub-object.</param>
 143     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 144     virtual public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 145                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_after_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, existing);
 146         Eina.Error.RaiseIfUnhandledException();
 147                                         return _ret_var;
 148  }
 149     /// <summary>Inserts <c>subobj</c> BEFORE the sub-object at position <c>index</c>.
 150     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 151     ///
 152     /// If <c>index</c> is less than -<c>count</c>, it will trigger <see cref="Efl.IPackLinear.PackBegin"/>(<c>subobj</c>) whereas <c>index</c> greater than <c>count</c>-1 will trigger <see cref="Efl.IPackLinear.PackEnd"/>(<c>subobj</c>).
 153     ///
 154     /// 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>
 155     /// <param name="subobj">Object to pack.</param>
 156     /// <param name="index">Index of existing sub-object to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 157     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 158     virtual public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
 159                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_at_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, index);
 160         Eina.Error.RaiseIfUnhandledException();
 161                                         return _ret_var;
 162  }
 163     /// <summary>Sub-object at a given <c>index</c> in this container.
 164     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 165     ///
 166     /// If <c>index</c> is less than -<c>count</c>, it will return the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will return the last sub-object.</summary>
 167     /// <param name="index">Index of the existing sub-object to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 168     /// <returns>The sub-object contained at the given <c>index</c>.</returns>
 169     virtual public Efl.Gfx.IEntity GetPackContent(int index) {
 170                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_content_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),index);
 171         Eina.Error.RaiseIfUnhandledException();
 172                         return _ret_var;
 173  }
 174     /// <summary>Get the index of a sub-object in this container.</summary>
 175     /// <param name="subobj">An existing sub-object in this container.</param>
 176     /// <returns>-1 in case <c>subobj</c> is not found, or the index of <c>subobj</c> in the range 0 to (<c>count</c>-1).</returns>
 177     virtual public int GetPackIndex(Efl.Gfx.IEntity subobj) {
 178                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_index_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 179         Eina.Error.RaiseIfUnhandledException();
 180                         return _ret_var;
 181  }
 182     /// <summary>Pop out (remove) the sub-object at the specified <c>index</c>.
 183     /// <c>index</c> ranges from -<c>count</c> to <c>count</c>-1, where positive numbers go from first sub-object (0) to last (<c>count</c>-1), and negative numbers go from last sub-object (-1) to first (-<c>count</c>). <c>count</c> is the number of sub-objects currently in the container as returned by <see cref="Efl.IContainer.ContentCount"/>.
 184     ///
 185     /// If <c>index</c> is less than -<c>count</c>, it will remove the first sub-object whereas <c>index</c> greater than <c>count</c>-1 will remove the last sub-object.</summary>
 186     /// <param name="index">Index of the sub-object to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 187     /// <returns>The sub-object if it could be removed.</returns>
 188     virtual public Efl.Gfx.IEntity PackUnpackAt(int index) {
 189                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_unpack_at_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),index);
 190         Eina.Error.RaiseIfUnhandledException();
 191                         return _ret_var;
 192  }
 193     private static IntPtr GetEflClassStatic()
 194     {
 195         return Efl.Ui.GroupItem.efl_ui_group_item_class_get();
 196     }
 197     /// <summary>Wrapper for native methods and virtual method delegates.
 198     /// For internal use by generated code only.</summary>
 199     public new class NativeMethods : Efl.Ui.DefaultItem.NativeMethods
 200     {
 201         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 202         /// <summary>Gets the list of Eo operations to override.</summary>
 203         /// <returns>The list of Eo operations to be overload.</returns>
 204         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 205         {
 206             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 207             var methods = Efl.Eo.Globals.GetUserMethods(type);
 208
 209             if (efl_pack_clear_static_delegate == null)
 210             {
 211                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 212             }
 213
 214             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 215             {
 216                 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) });
 217             }
 218
 219             if (efl_pack_unpack_all_static_delegate == null)
 220             {
 221                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 222             }
 223
 224             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 225             {
 226                 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) });
 227             }
 228
 229             if (efl_pack_unpack_static_delegate == null)
 230             {
 231                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 232             }
 233
 234             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 235             {
 236                 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) });
 237             }
 238
 239             if (efl_pack_static_delegate == null)
 240             {
 241                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 242             }
 243
 244             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 245             {
 246                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 247             }
 248
 249             if (efl_pack_begin_static_delegate == null)
 250             {
 251                 efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 252             }
 253
 254             if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
 255             {
 256                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_begin"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_begin_static_delegate) });
 257             }
 258
 259             if (efl_pack_end_static_delegate == null)
 260             {
 261                 efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 262             }
 263
 264             if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
 265             {
 266                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_end"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_end_static_delegate) });
 267             }
 268
 269             if (efl_pack_before_static_delegate == null)
 270             {
 271                 efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 272             }
 273
 274             if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
 275             {
 276                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_before"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_before_static_delegate) });
 277             }
 278
 279             if (efl_pack_after_static_delegate == null)
 280             {
 281                 efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 282             }
 283
 284             if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
 285             {
 286                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_after"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_after_static_delegate) });
 287             }
 288
 289             if (efl_pack_at_static_delegate == null)
 290             {
 291                 efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 292             }
 293
 294             if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
 295             {
 296                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_at_static_delegate) });
 297             }
 298
 299             if (efl_pack_content_get_static_delegate == null)
 300             {
 301                 efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 302             }
 303
 304             if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
 305             {
 306                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_content_get_static_delegate) });
 307             }
 308
 309             if (efl_pack_index_get_static_delegate == null)
 310             {
 311                 efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 312             }
 313
 314             if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
 315             {
 316                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_index_get_static_delegate) });
 317             }
 318
 319             if (efl_pack_unpack_at_static_delegate == null)
 320             {
 321                 efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 322             }
 323
 324             if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
 325             {
 326                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack_unpack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_at_static_delegate) });
 327             }
 328
 329             descs.AddRange(base.GetEoOps(type));
 330             return descs;
 331         }
 332         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 333         /// <returns>The native class pointer.</returns>
 334         public override IntPtr GetEflClass()
 335         {
 336             return Efl.Ui.GroupItem.efl_ui_group_item_class_get();
 337         }
 338
 339         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 340
 341         [return: MarshalAs(UnmanagedType.U1)]
 342         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 343
 344         [return: MarshalAs(UnmanagedType.U1)]
 345         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 346
 347         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");
 348
 349         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 350         {
 351             Eina.Log.Debug("function efl_pack_clear was called");
 352             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 353             if (ws != null)
 354             {
 355             bool _ret_var = default(bool);
 356                 try
 357                 {
 358                     _ret_var = ((GroupItem)ws.Target).ClearPack();
 359                 }
 360                 catch (Exception e)
 361                 {
 362                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 363                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 364                 }
 365
 366         return _ret_var;
 367
 368             }
 369             else
 370             {
 371                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 372             }
 373         }
 374
 375         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 376
 377         [return: MarshalAs(UnmanagedType.U1)]
 378         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 379
 380         [return: MarshalAs(UnmanagedType.U1)]
 381         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 382
 383         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");
 384
 385         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 386         {
 387             Eina.Log.Debug("function efl_pack_unpack_all was called");
 388             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 389             if (ws != null)
 390             {
 391             bool _ret_var = default(bool);
 392                 try
 393                 {
 394                     _ret_var = ((GroupItem)ws.Target).UnpackAll();
 395                 }
 396                 catch (Exception e)
 397                 {
 398                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 399                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 400                 }
 401
 402         return _ret_var;
 403
 404             }
 405             else
 406             {
 407                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 408             }
 409         }
 410
 411         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 412
 413         [return: MarshalAs(UnmanagedType.U1)]
 414         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);
 415
 416         [return: MarshalAs(UnmanagedType.U1)]
 417         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);
 418
 419         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");
 420
 421         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 422         {
 423             Eina.Log.Debug("function efl_pack_unpack was called");
 424             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 425             if (ws != null)
 426             {
 427                                     bool _ret_var = default(bool);
 428                 try
 429                 {
 430                     _ret_var = ((GroupItem)ws.Target).Unpack(subobj);
 431                 }
 432                 catch (Exception e)
 433                 {
 434                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 435                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 436                 }
 437
 438                         return _ret_var;
 439
 440             }
 441             else
 442             {
 443                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 444             }
 445         }
 446
 447         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 448
 449         [return: MarshalAs(UnmanagedType.U1)]
 450         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);
 451
 452         [return: MarshalAs(UnmanagedType.U1)]
 453         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);
 454
 455         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
 456
 457         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 458         {
 459             Eina.Log.Debug("function efl_pack was called");
 460             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 461             if (ws != null)
 462             {
 463                                     bool _ret_var = default(bool);
 464                 try
 465                 {
 466                     _ret_var = ((GroupItem)ws.Target).Pack(subobj);
 467                 }
 468                 catch (Exception e)
 469                 {
 470                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 471                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 472                 }
 473
 474                         return _ret_var;
 475
 476             }
 477             else
 478             {
 479                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 480             }
 481         }
 482
 483         private static efl_pack_delegate efl_pack_static_delegate;
 484
 485         [return: MarshalAs(UnmanagedType.U1)]
 486         private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 487
 488         [return: MarshalAs(UnmanagedType.U1)]
 489         public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 490
 491         public static Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate> efl_pack_begin_ptr = new Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate>(Module, "efl_pack_begin");
 492
 493         private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 494         {
 495             Eina.Log.Debug("function efl_pack_begin was called");
 496             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 497             if (ws != null)
 498             {
 499                                     bool _ret_var = default(bool);
 500                 try
 501                 {
 502                     _ret_var = ((GroupItem)ws.Target).PackBegin(subobj);
 503                 }
 504                 catch (Exception e)
 505                 {
 506                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 507                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 508                 }
 509
 510                         return _ret_var;
 511
 512             }
 513             else
 514             {
 515                 return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 516             }
 517         }
 518
 519         private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
 520
 521         [return: MarshalAs(UnmanagedType.U1)]
 522         private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 523
 524         [return: MarshalAs(UnmanagedType.U1)]
 525         public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 526
 527         public static Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate> efl_pack_end_ptr = new Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate>(Module, "efl_pack_end");
 528
 529         private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 530         {
 531             Eina.Log.Debug("function efl_pack_end was called");
 532             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 533             if (ws != null)
 534             {
 535                                     bool _ret_var = default(bool);
 536                 try
 537                 {
 538                     _ret_var = ((GroupItem)ws.Target).PackEnd(subobj);
 539                 }
 540                 catch (Exception e)
 541                 {
 542                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 543                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 544                 }
 545
 546                         return _ret_var;
 547
 548             }
 549             else
 550             {
 551                 return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 552             }
 553         }
 554
 555         private static efl_pack_end_delegate efl_pack_end_static_delegate;
 556
 557         [return: MarshalAs(UnmanagedType.U1)]
 558         private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 559
 560         [return: MarshalAs(UnmanagedType.U1)]
 561         public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 562
 563         public static Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate> efl_pack_before_ptr = new Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate>(Module, "efl_pack_before");
 564
 565         private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
 566         {
 567             Eina.Log.Debug("function efl_pack_before was called");
 568             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 569             if (ws != null)
 570             {
 571                                                             bool _ret_var = default(bool);
 572                 try
 573                 {
 574                     _ret_var = ((GroupItem)ws.Target).PackBefore(subobj, existing);
 575                 }
 576                 catch (Exception e)
 577                 {
 578                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 579                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 580                 }
 581
 582                                         return _ret_var;
 583
 584             }
 585             else
 586             {
 587                 return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
 588             }
 589         }
 590
 591         private static efl_pack_before_delegate efl_pack_before_static_delegate;
 592
 593         [return: MarshalAs(UnmanagedType.U1)]
 594         private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 595
 596         [return: MarshalAs(UnmanagedType.U1)]
 597         public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity existing);
 598
 599         public static Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate> efl_pack_after_ptr = new Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate>(Module, "efl_pack_after");
 600
 601         private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
 602         {
 603             Eina.Log.Debug("function efl_pack_after was called");
 604             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 605             if (ws != null)
 606             {
 607                                                             bool _ret_var = default(bool);
 608                 try
 609                 {
 610                     _ret_var = ((GroupItem)ws.Target).PackAfter(subobj, existing);
 611                 }
 612                 catch (Exception e)
 613                 {
 614                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 615                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 616                 }
 617
 618                                         return _ret_var;
 619
 620             }
 621             else
 622             {
 623                 return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
 624             }
 625         }
 626
 627         private static efl_pack_after_delegate efl_pack_after_static_delegate;
 628
 629         [return: MarshalAs(UnmanagedType.U1)]
 630         private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
 631
 632         [return: MarshalAs(UnmanagedType.U1)]
 633         public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj,  int index);
 634
 635         public static Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate> efl_pack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate>(Module, "efl_pack_at");
 636
 637         private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
 638         {
 639             Eina.Log.Debug("function efl_pack_at was called");
 640             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 641             if (ws != null)
 642             {
 643                                                             bool _ret_var = default(bool);
 644                 try
 645                 {
 646                     _ret_var = ((GroupItem)ws.Target).PackAt(subobj, index);
 647                 }
 648                 catch (Exception e)
 649                 {
 650                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 651                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 652                 }
 653
 654                                         return _ret_var;
 655
 656             }
 657             else
 658             {
 659                 return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
 660             }
 661         }
 662
 663         private static efl_pack_at_delegate efl_pack_at_static_delegate;
 664
 665         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 666         private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
 667
 668         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 669         public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj,  int index);
 670
 671         public static Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate> efl_pack_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate>(Module, "efl_pack_content_get");
 672
 673         private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
 674         {
 675             Eina.Log.Debug("function efl_pack_content_get was called");
 676             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 677             if (ws != null)
 678             {
 679                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 680                 try
 681                 {
 682                     _ret_var = ((GroupItem)ws.Target).GetPackContent(index);
 683                 }
 684                 catch (Exception e)
 685                 {
 686                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 687                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 688                 }
 689
 690                         return _ret_var;
 691
 692             }
 693             else
 694             {
 695                 return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
 696             }
 697         }
 698
 699         private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
 700
 701
 702         private delegate int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 703
 704
 705         public delegate int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity subobj);
 706
 707         public static Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate> efl_pack_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate>(Module, "efl_pack_index_get");
 708
 709         private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 710         {
 711             Eina.Log.Debug("function efl_pack_index_get was called");
 712             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 713             if (ws != null)
 714             {
 715                                     int _ret_var = default(int);
 716                 try
 717                 {
 718                     _ret_var = ((GroupItem)ws.Target).GetPackIndex(subobj);
 719                 }
 720                 catch (Exception e)
 721                 {
 722                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 723                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 724                 }
 725
 726                         return _ret_var;
 727
 728             }
 729             else
 730             {
 731                 return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 732             }
 733         }
 734
 735         private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
 736
 737         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 738         private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
 739
 740         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 741         public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj,  int index);
 742
 743         public static Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate> efl_pack_unpack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate>(Module, "efl_pack_unpack_at");
 744
 745         private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
 746         {
 747             Eina.Log.Debug("function efl_pack_unpack_at was called");
 748             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 749             if (ws != null)
 750             {
 751                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 752                 try
 753                 {
 754                     _ret_var = ((GroupItem)ws.Target).PackUnpackAt(index);
 755                 }
 756                 catch (Exception e)
 757                 {
 758                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 759                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 760                 }
 761
 762                         return _ret_var;
 763
 764             }
 765             else
 766             {
 767                 return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
 768             }
 769         }
 770
 771         private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
 772
 773         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 774
 775 }
 776 }
 777 }
 778
 779 }
 780
 781 #if EFL_BETA
 782 #pragma warning disable CS1591
 783 public static class Efl_UiGroupItem_ExtensionMethods {
 784 }
 785 #pragma warning restore CS1591
 786 #endif