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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 /// <summary>Represents a Box created as part of a layout.
  13 /// Its lifetime is limited to one function call only, unless an extra reference is explicitly held.</summary>
  14 [Efl.Canvas.LayoutPartBox.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public class LayoutPartBox : Efl.Canvas.LayoutPart, Efl.IContainer, Efl.IPack, Efl.IPackLinear, Efl.Ui.ILayoutOrientable, Efl.Ui.ILayoutOrientableReadonly
  17 {
  18     ///<summary>Pointer to the native class description.</summary>
  19     public override System.IntPtr NativeClass
  20     {
  21         get
  22         {
  23             if (((object)this).GetType() == typeof(LayoutPartBox))
  24             {
  25                 return GetEflClassStatic();
  26             }
  27             else
  28             {
  29                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  30             }
  31         }
  32     }
  33
  34     [System.Runtime.InteropServices.DllImport(efl.Libs.Edje)] internal static extern System.IntPtr
  35         efl_canvas_layout_part_box_class_get();
  36     /// <summary>Initializes a new instance of the <see cref="LayoutPartBox"/> class.</summary>
  37     /// <param name="parent">Parent instance.</param>
  38     public LayoutPartBox(Efl.Object parent= null
  39             ) : base(efl_canvas_layout_part_box_class_get(), parent)
  40     {
  41         FinishInstantiation();
  42     }
  43
  44     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  45     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  46     protected LayoutPartBox(ConstructingHandle ch) : base(ch)
  47     {
  48     }
  49
  50     /// <summary>Initializes a new instance of the <see cref="LayoutPartBox"/> class.
  51     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  52     /// <param name="wh">The native pointer to be wrapped.</param>
  53     protected LayoutPartBox(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  54     {
  55     }
  56
  57     /// <summary>Initializes a new instance of the <see cref="LayoutPartBox"/> class.
  58     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  59     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  60     /// <param name="parent">The Efl.Object parent of this instance.</param>
  61     protected LayoutPartBox(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, 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 (eflBindingEventLock)
  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.Edje, key, callerCb, value);
  94             }
  95         }
  96
  97         remove
  98         {
  99             lock (eflBindingEventLock)
 100             {
 101                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 102                 RemoveNativeEventHandler(efl.Libs.Edje, 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.Edje, 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 (eflBindingEventLock)
 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.Edje, key, callerCb, value);
 149             }
 150         }
 151
 152         remove
 153         {
 154             lock (eflBindingEventLock)
 155             {
 156                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 157                 RemoveNativeEventHandler(efl.Libs.Edje, 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.Edje, 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>Begin iterating over this object&apos;s contents.
 176     /// (Since EFL 1.22)</summary>
 177     /// <returns>Iterator on object&apos;s content.</returns>
 178     virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 179          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 180         Eina.Error.RaiseIfUnhandledException();
 181         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true);
 182  }
 183     /// <summary>Returns the number of contained sub-objects.
 184     /// (Since EFL 1.22)</summary>
 185     /// <returns>Number of sub-objects.</returns>
 186     virtual public int ContentCount() {
 187          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 188         Eina.Error.RaiseIfUnhandledException();
 189         return _ret_var;
 190  }
 191     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
 192     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 193     virtual public bool ClearPack() {
 194          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 195         Eina.Error.RaiseIfUnhandledException();
 196         return _ret_var;
 197  }
 198     /// <summary>Removes all packed sub-objects without unreferencing them.
 199     /// Use with caution.</summary>
 200     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 201     virtual public bool UnpackAll() {
 202          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)));
 203         Eina.Error.RaiseIfUnhandledException();
 204         return _ret_var;
 205  }
 206     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
 207     /// <param name="subobj">The sub-object to unpack.</param>
 208     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
 209     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
 210                                  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);
 211         Eina.Error.RaiseIfUnhandledException();
 212                         return _ret_var;
 213  }
 214     /// <summary>Adds a sub-object to this container.
 215     /// 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.
 216     ///
 217     /// 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>
 218     /// <param name="subobj">The object to pack.</param>
 219     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 220     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 221                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 222         Eina.Error.RaiseIfUnhandledException();
 223                         return _ret_var;
 224  }
 225     /// <summary>Prepend an object at the beginning of this container.
 226     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
 227     ///
 228     /// 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>
 229     /// <param name="subobj">Object to pack at the beginning.</param>
 230     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 231     virtual public bool PackBegin(Efl.Gfx.IEntity subobj) {
 232                                  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);
 233         Eina.Error.RaiseIfUnhandledException();
 234                         return _ret_var;
 235  }
 236     /// <summary>Append object at the end of this container.
 237     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
 238     ///
 239     /// 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>
 240     /// <param name="subobj">Object to pack at the end.</param>
 241     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 242     virtual public bool PackEnd(Efl.Gfx.IEntity subobj) {
 243                                  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);
 244         Eina.Error.RaiseIfUnhandledException();
 245                         return _ret_var;
 246  }
 247     /// <summary>Prepend an object before an existing sub-object.
 248     /// 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>
 249     /// <param name="subobj">Object to pack before <c>existing</c>.</param>
 250     /// <param name="existing">Existing reference sub-object.</param>
 251     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 252     virtual public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 253                                                          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);
 254         Eina.Error.RaiseIfUnhandledException();
 255                                         return _ret_var;
 256  }
 257     /// <summary>Append an object after an existing sub-object.
 258     /// 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>
 259     /// <param name="subobj">Object to pack after <c>existing</c>.</param>
 260     /// <param name="existing">Existing reference sub-object.</param>
 261     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 262     virtual public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 263                                                          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);
 264         Eina.Error.RaiseIfUnhandledException();
 265                                         return _ret_var;
 266  }
 267     /// <summary>Inserts <c>subobj</c> BEFORE the sub-object at position <c>index</c>.
 268     /// <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"/>.
 269     ///
 270     /// 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>).
 271     ///
 272     /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.IPack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 273     /// <param name="subobj">Object to pack.</param>
 274     /// <param name="index">Index of existing sub-object to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 275     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 276     virtual public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
 277                                                          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);
 278         Eina.Error.RaiseIfUnhandledException();
 279                                         return _ret_var;
 280  }
 281     /// <summary>Sub-object at a given <c>index</c> in this container.
 282     /// <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"/>.
 283     ///
 284     /// 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>
 285     /// <param name="index">Index of the existing sub-object to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 286     /// <returns>The sub-object contained at the given <c>index</c>.</returns>
 287     virtual public Efl.Gfx.IEntity GetPackContent(int index) {
 288                                  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);
 289         Eina.Error.RaiseIfUnhandledException();
 290                         return _ret_var;
 291  }
 292     /// <summary>Get the index of a sub-object in this container.</summary>
 293     /// <param name="subobj">An existing sub-object in this container.</param>
 294     /// <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>
 295     virtual public int GetPackIndex(Efl.Gfx.IEntity subobj) {
 296                                  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);
 297         Eina.Error.RaiseIfUnhandledException();
 298                         return _ret_var;
 299  }
 300     /// <summary>Pop out (remove) the sub-object at the specified <c>index</c>.
 301     /// <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"/>.
 302     ///
 303     /// 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>
 304     /// <param name="index">Index of the sub-object to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 305     /// <returns>The sub-object if it could be removed.</returns>
 306     virtual public Efl.Gfx.IEntity PackUnpackAt(int index) {
 307                                  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);
 308         Eina.Error.RaiseIfUnhandledException();
 309                         return _ret_var;
 310  }
 311     /// <summary>Control the direction of a given widget.
 312     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 313     ///
 314     /// 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>
 315     /// <returns>Direction of the widget.</returns>
 316     virtual public Efl.Ui.LayoutOrientation GetOrientation() {
 317          var _ret_var = Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 318         Eina.Error.RaiseIfUnhandledException();
 319         return _ret_var;
 320  }
 321     /// <summary>Control the direction of a given widget.
 322     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 323     ///
 324     /// 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>
 325     /// <param name="dir">Direction of the widget.</param>
 326     virtual public void SetOrientation(Efl.Ui.LayoutOrientation dir) {
 327                                  Efl.Ui.ILayoutOrientableConcrete.NativeMethods.efl_ui_layout_orientation_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir);
 328         Eina.Error.RaiseIfUnhandledException();
 329                          }
 330     /// <summary>Control the direction of a given widget.
 331     /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
 332     ///
 333     /// 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>
 334     /// <value>Direction of the widget.</value>
 335     public Efl.Ui.LayoutOrientation Orientation {
 336         get { return GetOrientation(); }
 337         set { SetOrientation(value); }
 338     }
 339     private static IntPtr GetEflClassStatic()
 340     {
 341         return Efl.Canvas.LayoutPartBox.efl_canvas_layout_part_box_class_get();
 342     }
 343     /// <summary>Wrapper for native methods and virtual method delegates.
 344     /// For internal use by generated code only.</summary>
 345     public new class NativeMethods : Efl.Canvas.LayoutPart.NativeMethods
 346     {
 347         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Edje);
 348         /// <summary>Gets the list of Eo operations to override.</summary>
 349         /// <returns>The list of Eo operations to be overload.</returns>
 350         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 351         {
 352             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 353             var methods = Efl.Eo.Globals.GetUserMethods(type);
 354
 355             if (efl_content_iterate_static_delegate == null)
 356             {
 357                 efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 358             }
 359
 360             if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 361             {
 362                 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) });
 363             }
 364
 365             if (efl_content_count_static_delegate == null)
 366             {
 367                 efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 368             }
 369
 370             if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 371             {
 372                 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) });
 373             }
 374
 375             if (efl_pack_clear_static_delegate == null)
 376             {
 377                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 378             }
 379
 380             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 381             {
 382                 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) });
 383             }
 384
 385             if (efl_pack_unpack_all_static_delegate == null)
 386             {
 387                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 388             }
 389
 390             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 391             {
 392                 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) });
 393             }
 394
 395             if (efl_pack_unpack_static_delegate == null)
 396             {
 397                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 398             }
 399
 400             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 401             {
 402                 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) });
 403             }
 404
 405             if (efl_pack_static_delegate == null)
 406             {
 407                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 408             }
 409
 410             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 411             {
 412                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 413             }
 414
 415             if (efl_pack_begin_static_delegate == null)
 416             {
 417                 efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 418             }
 419
 420             if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
 421             {
 422                 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) });
 423             }
 424
 425             if (efl_pack_end_static_delegate == null)
 426             {
 427                 efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 428             }
 429
 430             if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
 431             {
 432                 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) });
 433             }
 434
 435             if (efl_pack_before_static_delegate == null)
 436             {
 437                 efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 438             }
 439
 440             if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
 441             {
 442                 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) });
 443             }
 444
 445             if (efl_pack_after_static_delegate == null)
 446             {
 447                 efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 448             }
 449
 450             if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
 451             {
 452                 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) });
 453             }
 454
 455             if (efl_pack_at_static_delegate == null)
 456             {
 457                 efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 458             }
 459
 460             if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
 461             {
 462                 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) });
 463             }
 464
 465             if (efl_pack_content_get_static_delegate == null)
 466             {
 467                 efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 468             }
 469
 470             if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
 471             {
 472                 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) });
 473             }
 474
 475             if (efl_pack_index_get_static_delegate == null)
 476             {
 477                 efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 478             }
 479
 480             if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
 481             {
 482                 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) });
 483             }
 484
 485             if (efl_pack_unpack_at_static_delegate == null)
 486             {
 487                 efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 488             }
 489
 490             if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
 491             {
 492                 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) });
 493             }
 494
 495             if (efl_ui_layout_orientation_get_static_delegate == null)
 496             {
 497                 efl_ui_layout_orientation_get_static_delegate = new efl_ui_layout_orientation_get_delegate(orientation_get);
 498             }
 499
 500             if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
 501             {
 502                 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) });
 503             }
 504
 505             if (efl_ui_layout_orientation_set_static_delegate == null)
 506             {
 507                 efl_ui_layout_orientation_set_static_delegate = new efl_ui_layout_orientation_set_delegate(orientation_set);
 508             }
 509
 510             if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
 511             {
 512                 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) });
 513             }
 514
 515             descs.AddRange(base.GetEoOps(type));
 516             return descs;
 517         }
 518         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 519         /// <returns>The native class pointer.</returns>
 520         public override IntPtr GetEflClass()
 521         {
 522             return Efl.Canvas.LayoutPartBox.efl_canvas_layout_part_box_class_get();
 523         }
 524
 525         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 526
 527
 528         private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
 529
 530
 531         public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
 532
 533         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");
 534
 535         private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
 536         {
 537             Eina.Log.Debug("function efl_content_iterate was called");
 538             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 539             if (ws != null)
 540             {
 541             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
 542                 try
 543                 {
 544                     _ret_var = ((LayoutPartBox)ws.Target).ContentIterate();
 545                 }
 546                 catch (Exception e)
 547                 {
 548                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 549                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 550                 }
 551
 552         _ret_var.Own = false; return _ret_var.Handle;
 553
 554             }
 555             else
 556             {
 557                 return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 558             }
 559         }
 560
 561         private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
 562
 563
 564         private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
 565
 566
 567         public delegate int efl_content_count_api_delegate(System.IntPtr obj);
 568
 569         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");
 570
 571         private static int content_count(System.IntPtr obj, System.IntPtr pd)
 572         {
 573             Eina.Log.Debug("function efl_content_count was called");
 574             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 575             if (ws != null)
 576             {
 577             int _ret_var = default(int);
 578                 try
 579                 {
 580                     _ret_var = ((LayoutPartBox)ws.Target).ContentCount();
 581                 }
 582                 catch (Exception e)
 583                 {
 584                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 585                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 586                 }
 587
 588         return _ret_var;
 589
 590             }
 591             else
 592             {
 593                 return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 594             }
 595         }
 596
 597         private static efl_content_count_delegate efl_content_count_static_delegate;
 598
 599         [return: MarshalAs(UnmanagedType.U1)]
 600         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 601
 602         [return: MarshalAs(UnmanagedType.U1)]
 603         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 604
 605         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");
 606
 607         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 608         {
 609             Eina.Log.Debug("function efl_pack_clear was called");
 610             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 611             if (ws != null)
 612             {
 613             bool _ret_var = default(bool);
 614                 try
 615                 {
 616                     _ret_var = ((LayoutPartBox)ws.Target).ClearPack();
 617                 }
 618                 catch (Exception e)
 619                 {
 620                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 621                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 622                 }
 623
 624         return _ret_var;
 625
 626             }
 627             else
 628             {
 629                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 630             }
 631         }
 632
 633         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 634
 635         [return: MarshalAs(UnmanagedType.U1)]
 636         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 637
 638         [return: MarshalAs(UnmanagedType.U1)]
 639         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 640
 641         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");
 642
 643         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 644         {
 645             Eina.Log.Debug("function efl_pack_unpack_all was called");
 646             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 647             if (ws != null)
 648             {
 649             bool _ret_var = default(bool);
 650                 try
 651                 {
 652                     _ret_var = ((LayoutPartBox)ws.Target).UnpackAll();
 653                 }
 654                 catch (Exception e)
 655                 {
 656                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 657                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 658                 }
 659
 660         return _ret_var;
 661
 662             }
 663             else
 664             {
 665                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 666             }
 667         }
 668
 669         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 670
 671         [return: MarshalAs(UnmanagedType.U1)]
 672         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);
 673
 674         [return: MarshalAs(UnmanagedType.U1)]
 675         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);
 676
 677         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");
 678
 679         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 680         {
 681             Eina.Log.Debug("function efl_pack_unpack was called");
 682             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 683             if (ws != null)
 684             {
 685                                     bool _ret_var = default(bool);
 686                 try
 687                 {
 688                     _ret_var = ((LayoutPartBox)ws.Target).Unpack(subobj);
 689                 }
 690                 catch (Exception e)
 691                 {
 692                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 693                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 694                 }
 695
 696                         return _ret_var;
 697
 698             }
 699             else
 700             {
 701                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 702             }
 703         }
 704
 705         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 706
 707         [return: MarshalAs(UnmanagedType.U1)]
 708         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);
 709
 710         [return: MarshalAs(UnmanagedType.U1)]
 711         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);
 712
 713         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
 714
 715         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 716         {
 717             Eina.Log.Debug("function efl_pack was called");
 718             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 719             if (ws != null)
 720             {
 721                                     bool _ret_var = default(bool);
 722                 try
 723                 {
 724                     _ret_var = ((LayoutPartBox)ws.Target).Pack(subobj);
 725                 }
 726                 catch (Exception e)
 727                 {
 728                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 729                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 730                 }
 731
 732                         return _ret_var;
 733
 734             }
 735             else
 736             {
 737                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 738             }
 739         }
 740
 741         private static efl_pack_delegate efl_pack_static_delegate;
 742
 743         [return: MarshalAs(UnmanagedType.U1)]
 744         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);
 745
 746         [return: MarshalAs(UnmanagedType.U1)]
 747         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);
 748
 749         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");
 750
 751         private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 752         {
 753             Eina.Log.Debug("function efl_pack_begin was called");
 754             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 755             if (ws != null)
 756             {
 757                                     bool _ret_var = default(bool);
 758                 try
 759                 {
 760                     _ret_var = ((LayoutPartBox)ws.Target).PackBegin(subobj);
 761                 }
 762                 catch (Exception e)
 763                 {
 764                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 765                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 766                 }
 767
 768                         return _ret_var;
 769
 770             }
 771             else
 772             {
 773                 return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 774             }
 775         }
 776
 777         private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
 778
 779         [return: MarshalAs(UnmanagedType.U1)]
 780         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);
 781
 782         [return: MarshalAs(UnmanagedType.U1)]
 783         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);
 784
 785         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");
 786
 787         private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 788         {
 789             Eina.Log.Debug("function efl_pack_end was called");
 790             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 791             if (ws != null)
 792             {
 793                                     bool _ret_var = default(bool);
 794                 try
 795                 {
 796                     _ret_var = ((LayoutPartBox)ws.Target).PackEnd(subobj);
 797                 }
 798                 catch (Exception e)
 799                 {
 800                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 801                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 802                 }
 803
 804                         return _ret_var;
 805
 806             }
 807             else
 808             {
 809                 return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 810             }
 811         }
 812
 813         private static efl_pack_end_delegate efl_pack_end_static_delegate;
 814
 815         [return: MarshalAs(UnmanagedType.U1)]
 816         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);
 817
 818         [return: MarshalAs(UnmanagedType.U1)]
 819         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);
 820
 821         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");
 822
 823         private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
 824         {
 825             Eina.Log.Debug("function efl_pack_before was called");
 826             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 827             if (ws != null)
 828             {
 829                                                             bool _ret_var = default(bool);
 830                 try
 831                 {
 832                     _ret_var = ((LayoutPartBox)ws.Target).PackBefore(subobj, existing);
 833                 }
 834                 catch (Exception e)
 835                 {
 836                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 837                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 838                 }
 839
 840                                         return _ret_var;
 841
 842             }
 843             else
 844             {
 845                 return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
 846             }
 847         }
 848
 849         private static efl_pack_before_delegate efl_pack_before_static_delegate;
 850
 851         [return: MarshalAs(UnmanagedType.U1)]
 852         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);
 853
 854         [return: MarshalAs(UnmanagedType.U1)]
 855         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);
 856
 857         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");
 858
 859         private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
 860         {
 861             Eina.Log.Debug("function efl_pack_after was called");
 862             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 863             if (ws != null)
 864             {
 865                                                             bool _ret_var = default(bool);
 866                 try
 867                 {
 868                     _ret_var = ((LayoutPartBox)ws.Target).PackAfter(subobj, existing);
 869                 }
 870                 catch (Exception e)
 871                 {
 872                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 873                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 874                 }
 875
 876                                         return _ret_var;
 877
 878             }
 879             else
 880             {
 881                 return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
 882             }
 883         }
 884
 885         private static efl_pack_after_delegate efl_pack_after_static_delegate;
 886
 887         [return: MarshalAs(UnmanagedType.U1)]
 888         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);
 889
 890         [return: MarshalAs(UnmanagedType.U1)]
 891         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);
 892
 893         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");
 894
 895         private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
 896         {
 897             Eina.Log.Debug("function efl_pack_at was called");
 898             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 899             if (ws != null)
 900             {
 901                                                             bool _ret_var = default(bool);
 902                 try
 903                 {
 904                     _ret_var = ((LayoutPartBox)ws.Target).PackAt(subobj, index);
 905                 }
 906                 catch (Exception e)
 907                 {
 908                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 909                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 910                 }
 911
 912                                         return _ret_var;
 913
 914             }
 915             else
 916             {
 917                 return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
 918             }
 919         }
 920
 921         private static efl_pack_at_delegate efl_pack_at_static_delegate;
 922
 923         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 924         private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
 925
 926         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 927         public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj,  int index);
 928
 929         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");
 930
 931         private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
 932         {
 933             Eina.Log.Debug("function efl_pack_content_get was called");
 934             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 935             if (ws != null)
 936             {
 937                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 938                 try
 939                 {
 940                     _ret_var = ((LayoutPartBox)ws.Target).GetPackContent(index);
 941                 }
 942                 catch (Exception e)
 943                 {
 944                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 945                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 946                 }
 947
 948                         return _ret_var;
 949
 950             }
 951             else
 952             {
 953                 return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
 954             }
 955         }
 956
 957         private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
 958
 959
 960         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);
 961
 962
 963         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);
 964
 965         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");
 966
 967         private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
 968         {
 969             Eina.Log.Debug("function efl_pack_index_get was called");
 970             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 971             if (ws != null)
 972             {
 973                                     int _ret_var = default(int);
 974                 try
 975                 {
 976                     _ret_var = ((LayoutPartBox)ws.Target).GetPackIndex(subobj);
 977                 }
 978                 catch (Exception e)
 979                 {
 980                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 981                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 982                 }
 983
 984                         return _ret_var;
 985
 986             }
 987             else
 988             {
 989                 return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
 990             }
 991         }
 992
 993         private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
 994
 995         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 996         private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
 997
 998         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 999         public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj,  int index);
1000
1001         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");
1002
1003         private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
1004         {
1005             Eina.Log.Debug("function efl_pack_unpack_at was called");
1006             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1007             if (ws != null)
1008             {
1009                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1010                 try
1011                 {
1012                     _ret_var = ((LayoutPartBox)ws.Target).PackUnpackAt(index);
1013                 }
1014                 catch (Exception e)
1015                 {
1016                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1017                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1018                 }
1019
1020                         return _ret_var;
1021
1022             }
1023             else
1024             {
1025                 return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1026             }
1027         }
1028
1029         private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
1030
1031
1032         private delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1033
1034
1035         public delegate Efl.Ui.LayoutOrientation efl_ui_layout_orientation_get_api_delegate(System.IntPtr obj);
1036
1037         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");
1038
1039         private static Efl.Ui.LayoutOrientation orientation_get(System.IntPtr obj, System.IntPtr pd)
1040         {
1041             Eina.Log.Debug("function efl_ui_layout_orientation_get was called");
1042             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1043             if (ws != null)
1044             {
1045             Efl.Ui.LayoutOrientation _ret_var = default(Efl.Ui.LayoutOrientation);
1046                 try
1047                 {
1048                     _ret_var = ((LayoutPartBox)ws.Target).GetOrientation();
1049                 }
1050                 catch (Exception e)
1051                 {
1052                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1053                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1054                 }
1055
1056         return _ret_var;
1057
1058             }
1059             else
1060             {
1061                 return efl_ui_layout_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1062             }
1063         }
1064
1065         private static efl_ui_layout_orientation_get_delegate efl_ui_layout_orientation_get_static_delegate;
1066
1067
1068         private delegate void efl_ui_layout_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
1069
1070
1071         public delegate void efl_ui_layout_orientation_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
1072
1073         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");
1074
1075         private static void orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
1076         {
1077             Eina.Log.Debug("function efl_ui_layout_orientation_set was called");
1078             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1079             if (ws != null)
1080             {
1081
1082                 try
1083                 {
1084                     ((LayoutPartBox)ws.Target).SetOrientation(dir);
1085                 }
1086                 catch (Exception e)
1087                 {
1088                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1089                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1090                 }
1091
1092
1093             }
1094             else
1095             {
1096                 efl_ui_layout_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
1097             }
1098         }
1099
1100         private static efl_ui_layout_orientation_set_delegate efl_ui_layout_orientation_set_static_delegate;
1101
1102         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1103
1104 }
1105 }
1106 }
1107
1108 }
1109