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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 namespace ActiveView {
  13
  14 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.ActiveView.Container.TransitionStartEvt"/>.</summary>
  15 public class ContainerTransitionStartEvt_Args : EventArgs {
  16     ///<summary>Actual event payload.</summary>
  17     public Efl.Ui.ActiveView.TransitionEvent arg { get; set; }
  18 }
  19 ///<summary>Event argument wrapper for event <see cref="Efl.Ui.ActiveView.Container.TransitionEndEvt"/>.</summary>
  20 public class ContainerTransitionEndEvt_Args : EventArgs {
  21     ///<summary>Actual event payload.</summary>
  22     public Efl.Ui.ActiveView.TransitionEvent arg { get; set; }
  23 }
  24 /// <summary>The Active View widget is a container for other sub-widgets (views), where only one sub-widget is active at any given time.
  25 /// Views are added using the <see cref="Efl.IPackLinear"/> interface and the active view is selected using <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/>.
  26 ///
  27 /// The way the different views are rendered can be customized through the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> object. For example, only the active view might be shown, or it might be shown in a central position whereas the other views are displayed on the sides, or grayed-out. All views are displayed with the same size, selected with <see cref="Efl.Ui.ActiveView.Container.ActiveViewSize"/>.
  28 ///
  29 /// Additionally, the transition from one view to another can be animated. This animation is also controlled by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> object.
  30 ///
  31 /// Also, an indicator widget can be used to show a visual cue of how many views are there and which one is the active one.
  32 ///
  33 /// This class can be used to create other widgets like Pagers, Tabbed pagers or Stacks, where each view represents a &quot;page&quot; full of other widgets. All these cases can be implemented with a different <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> and use the same <see cref="Efl.Ui.ActiveView.Container"/>.</summary>
  34 [Efl.Ui.ActiveView.Container.NativeMethods]
  35 public class Container : Efl.Ui.LayoutBase, Efl.IPack, Efl.IPackLinear
  36 {
  37     ///<summary>Pointer to the native class description.</summary>
  38     public override System.IntPtr NativeClass
  39     {
  40         get
  41         {
  42             if (((object)this).GetType() == typeof(Container))
  43             {
  44                 return GetEflClassStatic();
  45             }
  46             else
  47             {
  48                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  49             }
  50         }
  51     }
  52
  53     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  54         efl_ui_active_view_container_class_get();
  55     /// <summary>Initializes a new instance of the <see cref="Container"/> class.</summary>
  56     /// <param name="parent">Parent instance.</param>
  57     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  58     public Container(Efl.Object parent
  59             , System.String style = null) : base(efl_ui_active_view_container_class_get(), typeof(Container), parent)
  60     {
  61         if (Efl.Eo.Globals.ParamHelperCheck(style))
  62         {
  63             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  64         }
  65
  66         FinishInstantiation();
  67     }
  68
  69     /// <summary>Initializes a new instance of the <see cref="Container"/> class.
  70     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  71     /// <param name="raw">The native pointer to be wrapped.</param>
  72     protected Container(System.IntPtr raw) : base(raw)
  73     {
  74     }
  75
  76     /// <summary>Initializes a new instance of the <see cref="Container"/> class.
  77     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  78     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  79     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  80     /// <param name="parent">The Efl.Object parent of this instance.</param>
  81     protected Container(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  82     {
  83     }
  84
  85     /// <summary>A transition animation has started.</summary>
  86     public event EventHandler<Efl.Ui.ActiveView.ContainerTransitionStartEvt_Args> TransitionStartEvt
  87     {
  88         add
  89         {
  90             lock (eventLock)
  91             {
  92                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  93                 {
  94                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  95                     if (obj != null)
  96                     {
  97                         Efl.Ui.ActiveView.ContainerTransitionStartEvt_Args args = new Efl.Ui.ActiveView.ContainerTransitionStartEvt_Args();
  98                         args.arg =  evt.Info;
  99                         try
 100                         {
 101                             value?.Invoke(obj, args);
 102                         }
 103                         catch (Exception e)
 104                         {
 105                             Eina.Log.Error(e.ToString());
 106                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 107                         }
 108                     }
 109                 };
 110
 111                 string key = "_EFL_UI_ACTIVE_VIEW_EVENT_TRANSITION_START";
 112                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 113             }
 114         }
 115
 116         remove
 117         {
 118             lock (eventLock)
 119             {
 120                 string key = "_EFL_UI_ACTIVE_VIEW_EVENT_TRANSITION_START";
 121                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 122             }
 123         }
 124     }
 125     ///<summary>Method to raise event TransitionStartEvt.</summary>
 126     public void OnTransitionStartEvt(Efl.Ui.ActiveView.ContainerTransitionStartEvt_Args e)
 127     {
 128         var key = "_EFL_UI_ACTIVE_VIEW_EVENT_TRANSITION_START";
 129         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 130         if (desc == IntPtr.Zero)
 131         {
 132             Eina.Log.Error($"Failed to get native event {key}");
 133             return;
 134         }
 135
 136         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 137         try
 138         {
 139             Marshal.StructureToPtr(e.arg, info, false);
 140             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 141         }
 142         finally
 143         {
 144             Marshal.FreeHGlobal(info);
 145         }
 146     }
 147     /// <summary>A transition animation has ended.</summary>
 148     public event EventHandler<Efl.Ui.ActiveView.ContainerTransitionEndEvt_Args> TransitionEndEvt
 149     {
 150         add
 151         {
 152             lock (eventLock)
 153             {
 154                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 155                 {
 156                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 157                     if (obj != null)
 158                     {
 159                         Efl.Ui.ActiveView.ContainerTransitionEndEvt_Args args = new Efl.Ui.ActiveView.ContainerTransitionEndEvt_Args();
 160                         args.arg =  evt.Info;
 161                         try
 162                         {
 163                             value?.Invoke(obj, args);
 164                         }
 165                         catch (Exception e)
 166                         {
 167                             Eina.Log.Error(e.ToString());
 168                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 169                         }
 170                     }
 171                 };
 172
 173                 string key = "_EFL_UI_ACTIVE_VIEW_EVENT_TRANSITION_END";
 174                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 175             }
 176         }
 177
 178         remove
 179         {
 180             lock (eventLock)
 181             {
 182                 string key = "_EFL_UI_ACTIVE_VIEW_EVENT_TRANSITION_END";
 183                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 184             }
 185         }
 186     }
 187     ///<summary>Method to raise event TransitionEndEvt.</summary>
 188     public void OnTransitionEndEvt(Efl.Ui.ActiveView.ContainerTransitionEndEvt_Args e)
 189     {
 190         var key = "_EFL_UI_ACTIVE_VIEW_EVENT_TRANSITION_END";
 191         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 192         if (desc == IntPtr.Zero)
 193         {
 194             Eina.Log.Error($"Failed to get native event {key}");
 195             return;
 196         }
 197
 198         IntPtr info = Marshal.AllocHGlobal(Marshal.SizeOf(e.arg));
 199         try
 200         {
 201             Marshal.StructureToPtr(e.arg, info, false);
 202             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 203         }
 204         finally
 205         {
 206             Marshal.FreeHGlobal(info);
 207         }
 208     }
 209     /// <summary>This object defines how views are rendered and animated. If it is not set, only the active view is shown and transitions are instantaneous (not animated).</summary>
 210     /// <returns>The View Manager object or <c>NULL</c>.</returns>
 211     virtual public Efl.Ui.ActiveView.ViewManager GetViewManager() {
 212          var _ret_var = Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_manager_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 213         Eina.Error.RaiseIfUnhandledException();
 214         return _ret_var;
 215  }
 216     /// <summary>This object defines how views are rendered and animated. If it is not set, only the active view is shown and transitions are instantaneous (not animated).</summary>
 217     /// <param name="view_manager">The View Manager object or <c>NULL</c>.</param>
 218     virtual public void SetViewManager(Efl.Ui.ActiveView.ViewManager view_manager) {
 219                                  Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_manager_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),view_manager);
 220         Eina.Error.RaiseIfUnhandledException();
 221                          }
 222     /// <summary>An indicator object to use, which will display the current state of the Active View (number of views and active one). When this object is set, it is immediately updated to reflect the current state of the widget. Its location inside the container is controlled by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/>.</summary>
 223     /// <returns>The Indicator object or <c>NULL</c>.</returns>
 224     virtual public Efl.Ui.ActiveView.Indicator GetIndicator() {
 225          var _ret_var = Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_indicator_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 226         Eina.Error.RaiseIfUnhandledException();
 227         return _ret_var;
 228  }
 229     /// <summary>An indicator object to use, which will display the current state of the Active View (number of views and active one). When this object is set, it is immediately updated to reflect the current state of the widget. Its location inside the container is controlled by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/>.</summary>
 230     /// <param name="indicator">The Indicator object or <c>NULL</c>.</param>
 231     virtual public void SetIndicator(Efl.Ui.ActiveView.Indicator indicator) {
 232                                  Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_indicator_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),indicator);
 233         Eina.Error.RaiseIfUnhandledException();
 234                          }
 235     /// <summary>Currently active view among all the views added to this widget.
 236     /// Changing this value might trigger an animation.</summary>
 237     /// <returns>Index of the active view, from 0 to the number of views - 1 (<see cref="Efl.IContainer.ContentCount"/> - 1).</returns>
 238     virtual public int GetActiveIndex() {
 239          var _ret_var = Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_active_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 240         Eina.Error.RaiseIfUnhandledException();
 241         return _ret_var;
 242  }
 243     /// <summary>Currently active view among all the views added to this widget.
 244     /// Changing this value might trigger an animation.</summary>
 245     /// <param name="index">Index of the active view, from 0 to the number of views - 1 (<see cref="Efl.IContainer.ContentCount"/> - 1).</param>
 246     virtual public void SetActiveIndex(int index) {
 247                                  Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_active_index_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
 248         Eina.Error.RaiseIfUnhandledException();
 249                          }
 250     /// <summary>When a new view is added to this widget, the indices for the previous views might change (for example, when adding a view at the beginning of the list with <see cref="Efl.IPackLinear.PackBegin"/> all previous view&apos;s indices are increased by one).
 251     /// This property controls whether the Active View should remain the same view as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>) or if the Active View should be moved to the one with the same index as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/>).
 252     ///
 253     /// For example, <see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/> can be used to build a Stack, where <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> is always 0 and new views are pushed onto the stack with <see cref="Efl.IPackLinear.PackBegin"/> and popped from the stack with <see cref="Efl.IPackLinear.PackUnpackAt"/> 0.</summary>
 254     /// <returns>Active View behavior when adding new views. Default is <see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>.</returns>
 255     virtual public Efl.Ui.ActiveView.ContainerGravity GetActiveViewGravity() {
 256          var _ret_var = Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_gravity_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 257         Eina.Error.RaiseIfUnhandledException();
 258         return _ret_var;
 259  }
 260     /// <summary>When a new view is added to this widget, the indices for the previous views might change (for example, when adding a view at the beginning of the list with <see cref="Efl.IPackLinear.PackBegin"/> all previous view&apos;s indices are increased by one).
 261     /// This property controls whether the Active View should remain the same view as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>) or if the Active View should be moved to the one with the same index as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/>).
 262     ///
 263     /// For example, <see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/> can be used to build a Stack, where <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> is always 0 and new views are pushed onto the stack with <see cref="Efl.IPackLinear.PackBegin"/> and popped from the stack with <see cref="Efl.IPackLinear.PackUnpackAt"/> 0.</summary>
 264     /// <param name="gravity">Active View behavior when adding new views. Default is <see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>.</param>
 265     virtual public void SetActiveViewGravity(Efl.Ui.ActiveView.ContainerGravity gravity) {
 266                                  Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_gravity_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),gravity);
 267         Eina.Error.RaiseIfUnhandledException();
 268                          }
 269     /// <summary>The size to use when displaying the Active View. This is used by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> to perform the rendering. Views other than the Active one may or may not use this size.</summary>
 270     /// <returns>Render size for the Active View. (-1, -1) means that all available space inside the container is used.</returns>
 271     virtual public Eina.Size2D GetActiveViewSize() {
 272          var _ret_var = Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 273         Eina.Error.RaiseIfUnhandledException();
 274         return _ret_var;
 275  }
 276     /// <summary>The size to use when displaying the Active View. This is used by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> to perform the rendering. Views other than the Active one may or may not use this size.</summary>
 277     /// <param name="size">Render size for the Active View. (-1, -1) means that all available space inside the container is used.</param>
 278     virtual public void SetActiveViewSize(Eina.Size2D size) {
 279          Eina.Size2D.NativeStruct _in_size = size;
 280                         Efl.Ui.ActiveView.Container.NativeMethods.efl_ui_active_view_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_size);
 281         Eina.Error.RaiseIfUnhandledException();
 282                          }
 283     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
 284     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 285     virtual public bool ClearPack() {
 286          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 287         Eina.Error.RaiseIfUnhandledException();
 288         return _ret_var;
 289  }
 290     /// <summary>Removes all packed sub-objects without unreferencing them.
 291     /// Use with caution.</summary>
 292     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 293     virtual public bool UnpackAll() {
 294          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 295         Eina.Error.RaiseIfUnhandledException();
 296         return _ret_var;
 297  }
 298     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
 299     /// <param name="subobj">The sub-object to unpack.</param>
 300     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
 301     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
 302                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 303         Eina.Error.RaiseIfUnhandledException();
 304                         return _ret_var;
 305  }
 306     /// <summary>Adds a sub-object to this container.
 307     /// 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.
 308     ///
 309     /// 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>
 310     /// <param name="subobj">The object to pack.</param>
 311     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 312     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 313                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 314         Eina.Error.RaiseIfUnhandledException();
 315                         return _ret_var;
 316  }
 317     /// <summary>Prepend an object at the beginning of this container.
 318     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
 319     ///
 320     /// 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>
 321     /// <param name="subobj">Object to pack at the beginning.</param>
 322     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 323     virtual public bool PackBegin(Efl.Gfx.IEntity subobj) {
 324                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_begin_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 325         Eina.Error.RaiseIfUnhandledException();
 326                         return _ret_var;
 327  }
 328     /// <summary>Append object at the end of this container.
 329     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
 330     ///
 331     /// 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>
 332     /// <param name="subobj">Object to pack at the end.</param>
 333     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 334     virtual public bool PackEnd(Efl.Gfx.IEntity subobj) {
 335                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 336         Eina.Error.RaiseIfUnhandledException();
 337                         return _ret_var;
 338  }
 339     /// <summary>Prepend an object before an existing sub-object.
 340     /// 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>
 341     /// <param name="subobj">Object to pack before <c>existing</c>.</param>
 342     /// <param name="existing">Existing reference sub-object.</param>
 343     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 344     virtual public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 345                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_before_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, existing);
 346         Eina.Error.RaiseIfUnhandledException();
 347                                         return _ret_var;
 348  }
 349     /// <summary>Append an object after an existing sub-object.
 350     /// 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>
 351     /// <param name="subobj">Object to pack after <c>existing</c>.</param>
 352     /// <param name="existing">Existing reference sub-object.</param>
 353     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 354     virtual public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 355                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_after_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, existing);
 356         Eina.Error.RaiseIfUnhandledException();
 357                                         return _ret_var;
 358  }
 359     /// <summary>Inserts <c>subobj</c> BEFORE the sub-object at position <c>index</c>.
 360     /// <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"/>.
 361     ///
 362     /// 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>).
 363     ///
 364     /// 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>
 365     /// <param name="subobj">Object to pack.</param>
 366     /// <param name="index">Index of existing sub-object to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 367     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 368     virtual public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
 369                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj, index);
 370         Eina.Error.RaiseIfUnhandledException();
 371                                         return _ret_var;
 372  }
 373     /// <summary>Sub-object at a given <c>index</c> in this container.
 374     /// <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"/>.
 375     ///
 376     /// 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>
 377     /// <param name="index">Index of the existing sub-object to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 378     /// <returns>The sub-object contained at the given <c>index</c>.</returns>
 379     virtual public Efl.Gfx.IEntity GetPackContent(int index) {
 380                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
 381         Eina.Error.RaiseIfUnhandledException();
 382                         return _ret_var;
 383  }
 384     /// <summary>Get the index of a sub-object in this container.</summary>
 385     /// <param name="subobj">An existing sub-object in this container.</param>
 386     /// <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>
 387     virtual public int GetPackIndex(Efl.Gfx.IEntity subobj) {
 388                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),subobj);
 389         Eina.Error.RaiseIfUnhandledException();
 390                         return _ret_var;
 391  }
 392     /// <summary>Pop out (remove) the sub-object at the specified <c>index</c>.
 393     /// <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"/>.
 394     ///
 395     /// 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>
 396     /// <param name="index">Index of the sub-object to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 397     /// <returns>The sub-object if it could be removed.</returns>
 398     virtual public Efl.Gfx.IEntity PackUnpackAt(int index) {
 399                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_unpack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),index);
 400         Eina.Error.RaiseIfUnhandledException();
 401                         return _ret_var;
 402  }
 403     /// <summary>This object defines how views are rendered and animated. If it is not set, only the active view is shown and transitions are instantaneous (not animated).</summary>
 404     /// <value>The View Manager object or <c>NULL</c>.</value>
 405     public Efl.Ui.ActiveView.ViewManager ViewManager {
 406         get { return GetViewManager(); }
 407         set { SetViewManager(value); }
 408     }
 409     /// <summary>An indicator object to use, which will display the current state of the Active View (number of views and active one). When this object is set, it is immediately updated to reflect the current state of the widget. Its location inside the container is controlled by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/>.</summary>
 410     /// <value>The Indicator object or <c>NULL</c>.</value>
 411     public Efl.Ui.ActiveView.Indicator Indicator {
 412         get { return GetIndicator(); }
 413         set { SetIndicator(value); }
 414     }
 415     /// <summary>Currently active view among all the views added to this widget.
 416     /// Changing this value might trigger an animation.</summary>
 417     /// <value>Index of the active view, from 0 to the number of views - 1 (<see cref="Efl.IContainer.ContentCount"/> - 1).</value>
 418     public int ActiveIndex {
 419         get { return GetActiveIndex(); }
 420         set { SetActiveIndex(value); }
 421     }
 422     /// <summary>When a new view is added to this widget, the indices for the previous views might change (for example, when adding a view at the beginning of the list with <see cref="Efl.IPackLinear.PackBegin"/> all previous view&apos;s indices are increased by one).
 423     /// This property controls whether the Active View should remain the same view as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>) or if the Active View should be moved to the one with the same index as before (<see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/>).
 424     ///
 425     /// For example, <see cref="Efl.Ui.ActiveView.ContainerGravity.Index"/> can be used to build a Stack, where <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> is always 0 and new views are pushed onto the stack with <see cref="Efl.IPackLinear.PackBegin"/> and popped from the stack with <see cref="Efl.IPackLinear.PackUnpackAt"/> 0.</summary>
 426     /// <value>Active View behavior when adding new views. Default is <see cref="Efl.Ui.ActiveView.ContainerGravity.Content"/>.</value>
 427     public Efl.Ui.ActiveView.ContainerGravity ActiveViewGravity {
 428         get { return GetActiveViewGravity(); }
 429         set { SetActiveViewGravity(value); }
 430     }
 431     /// <summary>The size to use when displaying the Active View. This is used by the <see cref="Efl.Ui.ActiveView.Container.ViewManager"/> to perform the rendering. Views other than the Active one may or may not use this size.</summary>
 432     /// <value>Render size for the Active View. (-1, -1) means that all available space inside the container is used.</value>
 433     public Eina.Size2D ActiveViewSize {
 434         get { return GetActiveViewSize(); }
 435         set { SetActiveViewSize(value); }
 436     }
 437     private static IntPtr GetEflClassStatic()
 438     {
 439         return Efl.Ui.ActiveView.Container.efl_ui_active_view_container_class_get();
 440     }
 441     /// <summary>Wrapper for native methods and virtual method delegates.
 442     /// For internal use by generated code only.</summary>
 443     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 444     {
 445         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 446         /// <summary>Gets the list of Eo operations to override.</summary>
 447         /// <returns>The list of Eo operations to be overload.</returns>
 448         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 449         {
 450             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 451             var methods = Efl.Eo.Globals.GetUserMethods(type);
 452
 453             if (efl_ui_active_view_manager_get_static_delegate == null)
 454             {
 455                 efl_ui_active_view_manager_get_static_delegate = new efl_ui_active_view_manager_get_delegate(view_manager_get);
 456             }
 457
 458             if (methods.FirstOrDefault(m => m.Name == "GetViewManager") != null)
 459             {
 460                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_manager_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_manager_get_static_delegate) });
 461             }
 462
 463             if (efl_ui_active_view_manager_set_static_delegate == null)
 464             {
 465                 efl_ui_active_view_manager_set_static_delegate = new efl_ui_active_view_manager_set_delegate(view_manager_set);
 466             }
 467
 468             if (methods.FirstOrDefault(m => m.Name == "SetViewManager") != null)
 469             {
 470                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_manager_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_manager_set_static_delegate) });
 471             }
 472
 473             if (efl_ui_active_view_indicator_get_static_delegate == null)
 474             {
 475                 efl_ui_active_view_indicator_get_static_delegate = new efl_ui_active_view_indicator_get_delegate(indicator_get);
 476             }
 477
 478             if (methods.FirstOrDefault(m => m.Name == "GetIndicator") != null)
 479             {
 480                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_indicator_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_indicator_get_static_delegate) });
 481             }
 482
 483             if (efl_ui_active_view_indicator_set_static_delegate == null)
 484             {
 485                 efl_ui_active_view_indicator_set_static_delegate = new efl_ui_active_view_indicator_set_delegate(indicator_set);
 486             }
 487
 488             if (methods.FirstOrDefault(m => m.Name == "SetIndicator") != null)
 489             {
 490                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_indicator_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_indicator_set_static_delegate) });
 491             }
 492
 493             if (efl_ui_active_view_active_index_get_static_delegate == null)
 494             {
 495                 efl_ui_active_view_active_index_get_static_delegate = new efl_ui_active_view_active_index_get_delegate(active_index_get);
 496             }
 497
 498             if (methods.FirstOrDefault(m => m.Name == "GetActiveIndex") != null)
 499             {
 500                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_active_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_active_index_get_static_delegate) });
 501             }
 502
 503             if (efl_ui_active_view_active_index_set_static_delegate == null)
 504             {
 505                 efl_ui_active_view_active_index_set_static_delegate = new efl_ui_active_view_active_index_set_delegate(active_index_set);
 506             }
 507
 508             if (methods.FirstOrDefault(m => m.Name == "SetActiveIndex") != null)
 509             {
 510                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_active_index_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_active_index_set_static_delegate) });
 511             }
 512
 513             if (efl_ui_active_view_gravity_get_static_delegate == null)
 514             {
 515                 efl_ui_active_view_gravity_get_static_delegate = new efl_ui_active_view_gravity_get_delegate(active_view_gravity_get);
 516             }
 517
 518             if (methods.FirstOrDefault(m => m.Name == "GetActiveViewGravity") != null)
 519             {
 520                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_gravity_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_gravity_get_static_delegate) });
 521             }
 522
 523             if (efl_ui_active_view_gravity_set_static_delegate == null)
 524             {
 525                 efl_ui_active_view_gravity_set_static_delegate = new efl_ui_active_view_gravity_set_delegate(active_view_gravity_set);
 526             }
 527
 528             if (methods.FirstOrDefault(m => m.Name == "SetActiveViewGravity") != null)
 529             {
 530                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_gravity_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_gravity_set_static_delegate) });
 531             }
 532
 533             if (efl_ui_active_view_size_get_static_delegate == null)
 534             {
 535                 efl_ui_active_view_size_get_static_delegate = new efl_ui_active_view_size_get_delegate(active_view_size_get);
 536             }
 537
 538             if (methods.FirstOrDefault(m => m.Name == "GetActiveViewSize") != null)
 539             {
 540                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_size_get_static_delegate) });
 541             }
 542
 543             if (efl_ui_active_view_size_set_static_delegate == null)
 544             {
 545                 efl_ui_active_view_size_set_static_delegate = new efl_ui_active_view_size_set_delegate(active_view_size_set);
 546             }
 547
 548             if (methods.FirstOrDefault(m => m.Name == "SetActiveViewSize") != null)
 549             {
 550                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_active_view_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_active_view_size_set_static_delegate) });
 551             }
 552
 553             if (efl_pack_clear_static_delegate == null)
 554             {
 555                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 556             }
 557
 558             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 559             {
 560                 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) });
 561             }
 562
 563             if (efl_pack_unpack_all_static_delegate == null)
 564             {
 565                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 566             }
 567
 568             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 569             {
 570                 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) });
 571             }
 572
 573             if (efl_pack_unpack_static_delegate == null)
 574             {
 575                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 576             }
 577
 578             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 579             {
 580                 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) });
 581             }
 582
 583             if (efl_pack_static_delegate == null)
 584             {
 585                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 586             }
 587
 588             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 589             {
 590                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 591             }
 592
 593             if (efl_pack_begin_static_delegate == null)
 594             {
 595                 efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 596             }
 597
 598             if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
 599             {
 600                 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) });
 601             }
 602
 603             if (efl_pack_end_static_delegate == null)
 604             {
 605                 efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 606             }
 607
 608             if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
 609             {
 610                 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) });
 611             }
 612
 613             if (efl_pack_before_static_delegate == null)
 614             {
 615                 efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 616             }
 617
 618             if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
 619             {
 620                 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) });
 621             }
 622
 623             if (efl_pack_after_static_delegate == null)
 624             {
 625                 efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 626             }
 627
 628             if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
 629             {
 630                 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) });
 631             }
 632
 633             if (efl_pack_at_static_delegate == null)
 634             {
 635                 efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 636             }
 637
 638             if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
 639             {
 640                 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) });
 641             }
 642
 643             if (efl_pack_content_get_static_delegate == null)
 644             {
 645                 efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 646             }
 647
 648             if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
 649             {
 650                 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) });
 651             }
 652
 653             if (efl_pack_index_get_static_delegate == null)
 654             {
 655                 efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 656             }
 657
 658             if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
 659             {
 660                 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) });
 661             }
 662
 663             if (efl_pack_unpack_at_static_delegate == null)
 664             {
 665                 efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 666             }
 667
 668             if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
 669             {
 670                 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) });
 671             }
 672
 673             descs.AddRange(base.GetEoOps(type));
 674             return descs;
 675         }
 676         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 677         /// <returns>The native class pointer.</returns>
 678         public override IntPtr GetEflClass()
 679         {
 680             return Efl.Ui.ActiveView.Container.efl_ui_active_view_container_class_get();
 681         }
 682
 683         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 684
 685         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
 686         private delegate Efl.Ui.ActiveView.ViewManager efl_ui_active_view_manager_get_delegate(System.IntPtr obj, System.IntPtr pd);
 687
 688         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
 689         public delegate Efl.Ui.ActiveView.ViewManager efl_ui_active_view_manager_get_api_delegate(System.IntPtr obj);
 690
 691         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_manager_get_api_delegate> efl_ui_active_view_manager_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_manager_get_api_delegate>(Module, "efl_ui_active_view_manager_get");
 692
 693         private static Efl.Ui.ActiveView.ViewManager view_manager_get(System.IntPtr obj, System.IntPtr pd)
 694         {
 695             Eina.Log.Debug("function efl_ui_active_view_manager_get was called");
 696             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 697             if (ws != null)
 698             {
 699             Efl.Ui.ActiveView.ViewManager _ret_var = default(Efl.Ui.ActiveView.ViewManager);
 700                 try
 701                 {
 702                     _ret_var = ((Container)ws.Target).GetViewManager();
 703                 }
 704                 catch (Exception e)
 705                 {
 706                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 707                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 708                 }
 709
 710         return _ret_var;
 711
 712             }
 713             else
 714             {
 715                 return efl_ui_active_view_manager_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 716             }
 717         }
 718
 719         private static efl_ui_active_view_manager_get_delegate efl_ui_active_view_manager_get_static_delegate;
 720
 721
 722         private delegate void efl_ui_active_view_manager_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))] Efl.Ui.ActiveView.ViewManager view_manager);
 723
 724
 725         public delegate void efl_ui_active_view_manager_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))] Efl.Ui.ActiveView.ViewManager view_manager);
 726
 727         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_manager_set_api_delegate> efl_ui_active_view_manager_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_manager_set_api_delegate>(Module, "efl_ui_active_view_manager_set");
 728
 729         private static void view_manager_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ActiveView.ViewManager view_manager)
 730         {
 731             Eina.Log.Debug("function efl_ui_active_view_manager_set was called");
 732             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 733             if (ws != null)
 734             {
 735
 736                 try
 737                 {
 738                     ((Container)ws.Target).SetViewManager(view_manager);
 739                 }
 740                 catch (Exception e)
 741                 {
 742                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 743                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 744                 }
 745
 746
 747             }
 748             else
 749             {
 750                 efl_ui_active_view_manager_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), view_manager);
 751             }
 752         }
 753
 754         private static efl_ui_active_view_manager_set_delegate efl_ui_active_view_manager_set_static_delegate;
 755
 756         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
 757         private delegate Efl.Ui.ActiveView.Indicator efl_ui_active_view_indicator_get_delegate(System.IntPtr obj, System.IntPtr pd);
 758
 759         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))]
 760         public delegate Efl.Ui.ActiveView.Indicator efl_ui_active_view_indicator_get_api_delegate(System.IntPtr obj);
 761
 762         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_indicator_get_api_delegate> efl_ui_active_view_indicator_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_indicator_get_api_delegate>(Module, "efl_ui_active_view_indicator_get");
 763
 764         private static Efl.Ui.ActiveView.Indicator indicator_get(System.IntPtr obj, System.IntPtr pd)
 765         {
 766             Eina.Log.Debug("function efl_ui_active_view_indicator_get was called");
 767             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 768             if (ws != null)
 769             {
 770             Efl.Ui.ActiveView.Indicator _ret_var = default(Efl.Ui.ActiveView.Indicator);
 771                 try
 772                 {
 773                     _ret_var = ((Container)ws.Target).GetIndicator();
 774                 }
 775                 catch (Exception e)
 776                 {
 777                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 778                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 779                 }
 780
 781         return _ret_var;
 782
 783             }
 784             else
 785             {
 786                 return efl_ui_active_view_indicator_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 787             }
 788         }
 789
 790         private static efl_ui_active_view_indicator_get_delegate efl_ui_active_view_indicator_get_static_delegate;
 791
 792
 793         private delegate void efl_ui_active_view_indicator_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))] Efl.Ui.ActiveView.Indicator indicator);
 794
 795
 796         public delegate void efl_ui_active_view_indicator_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.OwnTag>))] Efl.Ui.ActiveView.Indicator indicator);
 797
 798         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_indicator_set_api_delegate> efl_ui_active_view_indicator_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_indicator_set_api_delegate>(Module, "efl_ui_active_view_indicator_set");
 799
 800         private static void indicator_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ActiveView.Indicator indicator)
 801         {
 802             Eina.Log.Debug("function efl_ui_active_view_indicator_set was called");
 803             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 804             if (ws != null)
 805             {
 806
 807                 try
 808                 {
 809                     ((Container)ws.Target).SetIndicator(indicator);
 810                 }
 811                 catch (Exception e)
 812                 {
 813                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 814                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 815                 }
 816
 817
 818             }
 819             else
 820             {
 821                 efl_ui_active_view_indicator_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), indicator);
 822             }
 823         }
 824
 825         private static efl_ui_active_view_indicator_set_delegate efl_ui_active_view_indicator_set_static_delegate;
 826
 827
 828         private delegate int efl_ui_active_view_active_index_get_delegate(System.IntPtr obj, System.IntPtr pd);
 829
 830
 831         public delegate int efl_ui_active_view_active_index_get_api_delegate(System.IntPtr obj);
 832
 833         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_active_index_get_api_delegate> efl_ui_active_view_active_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_active_index_get_api_delegate>(Module, "efl_ui_active_view_active_index_get");
 834
 835         private static int active_index_get(System.IntPtr obj, System.IntPtr pd)
 836         {
 837             Eina.Log.Debug("function efl_ui_active_view_active_index_get was called");
 838             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 839             if (ws != null)
 840             {
 841             int _ret_var = default(int);
 842                 try
 843                 {
 844                     _ret_var = ((Container)ws.Target).GetActiveIndex();
 845                 }
 846                 catch (Exception e)
 847                 {
 848                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 849                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 850                 }
 851
 852         return _ret_var;
 853
 854             }
 855             else
 856             {
 857                 return efl_ui_active_view_active_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 858             }
 859         }
 860
 861         private static efl_ui_active_view_active_index_get_delegate efl_ui_active_view_active_index_get_static_delegate;
 862
 863
 864         private delegate void efl_ui_active_view_active_index_set_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
 865
 866
 867         public delegate void efl_ui_active_view_active_index_set_api_delegate(System.IntPtr obj,  int index);
 868
 869         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_active_index_set_api_delegate> efl_ui_active_view_active_index_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_active_index_set_api_delegate>(Module, "efl_ui_active_view_active_index_set");
 870
 871         private static void active_index_set(System.IntPtr obj, System.IntPtr pd, int index)
 872         {
 873             Eina.Log.Debug("function efl_ui_active_view_active_index_set was called");
 874             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 875             if (ws != null)
 876             {
 877
 878                 try
 879                 {
 880                     ((Container)ws.Target).SetActiveIndex(index);
 881                 }
 882                 catch (Exception e)
 883                 {
 884                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 885                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 886                 }
 887
 888
 889             }
 890             else
 891             {
 892                 efl_ui_active_view_active_index_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
 893             }
 894         }
 895
 896         private static efl_ui_active_view_active_index_set_delegate efl_ui_active_view_active_index_set_static_delegate;
 897
 898
 899         private delegate Efl.Ui.ActiveView.ContainerGravity efl_ui_active_view_gravity_get_delegate(System.IntPtr obj, System.IntPtr pd);
 900
 901
 902         public delegate Efl.Ui.ActiveView.ContainerGravity efl_ui_active_view_gravity_get_api_delegate(System.IntPtr obj);
 903
 904         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_get_api_delegate> efl_ui_active_view_gravity_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_get_api_delegate>(Module, "efl_ui_active_view_gravity_get");
 905
 906         private static Efl.Ui.ActiveView.ContainerGravity active_view_gravity_get(System.IntPtr obj, System.IntPtr pd)
 907         {
 908             Eina.Log.Debug("function efl_ui_active_view_gravity_get was called");
 909             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 910             if (ws != null)
 911             {
 912             Efl.Ui.ActiveView.ContainerGravity _ret_var = default(Efl.Ui.ActiveView.ContainerGravity);
 913                 try
 914                 {
 915                     _ret_var = ((Container)ws.Target).GetActiveViewGravity();
 916                 }
 917                 catch (Exception e)
 918                 {
 919                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 920                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 921                 }
 922
 923         return _ret_var;
 924
 925             }
 926             else
 927             {
 928                 return efl_ui_active_view_gravity_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 929             }
 930         }
 931
 932         private static efl_ui_active_view_gravity_get_delegate efl_ui_active_view_gravity_get_static_delegate;
 933
 934
 935         private delegate void efl_ui_active_view_gravity_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ActiveView.ContainerGravity gravity);
 936
 937
 938         public delegate void efl_ui_active_view_gravity_set_api_delegate(System.IntPtr obj,  Efl.Ui.ActiveView.ContainerGravity gravity);
 939
 940         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_set_api_delegate> efl_ui_active_view_gravity_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_gravity_set_api_delegate>(Module, "efl_ui_active_view_gravity_set");
 941
 942         private static void active_view_gravity_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ActiveView.ContainerGravity gravity)
 943         {
 944             Eina.Log.Debug("function efl_ui_active_view_gravity_set was called");
 945             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 946             if (ws != null)
 947             {
 948
 949                 try
 950                 {
 951                     ((Container)ws.Target).SetActiveViewGravity(gravity);
 952                 }
 953                 catch (Exception e)
 954                 {
 955                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 956                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 957                 }
 958
 959
 960             }
 961             else
 962             {
 963                 efl_ui_active_view_gravity_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), gravity);
 964             }
 965         }
 966
 967         private static efl_ui_active_view_gravity_set_delegate efl_ui_active_view_gravity_set_static_delegate;
 968
 969
 970         private delegate Eina.Size2D.NativeStruct efl_ui_active_view_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 971
 972
 973         public delegate Eina.Size2D.NativeStruct efl_ui_active_view_size_get_api_delegate(System.IntPtr obj);
 974
 975         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_size_get_api_delegate> efl_ui_active_view_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_size_get_api_delegate>(Module, "efl_ui_active_view_size_get");
 976
 977         private static Eina.Size2D.NativeStruct active_view_size_get(System.IntPtr obj, System.IntPtr pd)
 978         {
 979             Eina.Log.Debug("function efl_ui_active_view_size_get was called");
 980             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 981             if (ws != null)
 982             {
 983             Eina.Size2D _ret_var = default(Eina.Size2D);
 984                 try
 985                 {
 986                     _ret_var = ((Container)ws.Target).GetActiveViewSize();
 987                 }
 988                 catch (Exception e)
 989                 {
 990                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 991                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 992                 }
 993
 994         return _ret_var;
 995
 996             }
 997             else
 998             {
 999                 return efl_ui_active_view_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1000             }
1001         }
1002
1003         private static efl_ui_active_view_size_get_delegate efl_ui_active_view_size_get_static_delegate;
1004
1005
1006         private delegate void efl_ui_active_view_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size);
1007
1008
1009         public delegate void efl_ui_active_view_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct size);
1010
1011         public static Efl.Eo.FunctionWrapper<efl_ui_active_view_size_set_api_delegate> efl_ui_active_view_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_active_view_size_set_api_delegate>(Module, "efl_ui_active_view_size_set");
1012
1013         private static void active_view_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
1014         {
1015             Eina.Log.Debug("function efl_ui_active_view_size_set was called");
1016             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1017             if (ws != null)
1018             {
1019         Eina.Size2D _in_size = size;
1020
1021                 try
1022                 {
1023                     ((Container)ws.Target).SetActiveViewSize(_in_size);
1024                 }
1025                 catch (Exception e)
1026                 {
1027                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1028                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1029                 }
1030
1031
1032             }
1033             else
1034             {
1035                 efl_ui_active_view_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
1036             }
1037         }
1038
1039         private static efl_ui_active_view_size_set_delegate efl_ui_active_view_size_set_static_delegate;
1040
1041         [return: MarshalAs(UnmanagedType.U1)]
1042         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
1043
1044         [return: MarshalAs(UnmanagedType.U1)]
1045         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
1046
1047         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");
1048
1049         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
1050         {
1051             Eina.Log.Debug("function efl_pack_clear was called");
1052             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1053             if (ws != null)
1054             {
1055             bool _ret_var = default(bool);
1056                 try
1057                 {
1058                     _ret_var = ((Container)ws.Target).ClearPack();
1059                 }
1060                 catch (Exception e)
1061                 {
1062                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1063                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1064                 }
1065
1066         return _ret_var;
1067
1068             }
1069             else
1070             {
1071                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1072             }
1073         }
1074
1075         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
1076
1077         [return: MarshalAs(UnmanagedType.U1)]
1078         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
1079
1080         [return: MarshalAs(UnmanagedType.U1)]
1081         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
1082
1083         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");
1084
1085         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
1086         {
1087             Eina.Log.Debug("function efl_pack_unpack_all was called");
1088             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1089             if (ws != null)
1090             {
1091             bool _ret_var = default(bool);
1092                 try
1093                 {
1094                     _ret_var = ((Container)ws.Target).UnpackAll();
1095                 }
1096                 catch (Exception e)
1097                 {
1098                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1099                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1100                 }
1101
1102         return _ret_var;
1103
1104             }
1105             else
1106             {
1107                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1108             }
1109         }
1110
1111         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
1112
1113         [return: MarshalAs(UnmanagedType.U1)]
1114         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);
1115
1116         [return: MarshalAs(UnmanagedType.U1)]
1117         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);
1118
1119         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");
1120
1121         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1122         {
1123             Eina.Log.Debug("function efl_pack_unpack was called");
1124             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1125             if (ws != null)
1126             {
1127                                     bool _ret_var = default(bool);
1128                 try
1129                 {
1130                     _ret_var = ((Container)ws.Target).Unpack(subobj);
1131                 }
1132                 catch (Exception e)
1133                 {
1134                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1135                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1136                 }
1137
1138                         return _ret_var;
1139
1140             }
1141             else
1142             {
1143                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1144             }
1145         }
1146
1147         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
1148
1149         [return: MarshalAs(UnmanagedType.U1)]
1150         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);
1151
1152         [return: MarshalAs(UnmanagedType.U1)]
1153         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);
1154
1155         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
1156
1157         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1158         {
1159             Eina.Log.Debug("function efl_pack was called");
1160             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1161             if (ws != null)
1162             {
1163                                     bool _ret_var = default(bool);
1164                 try
1165                 {
1166                     _ret_var = ((Container)ws.Target).Pack(subobj);
1167                 }
1168                 catch (Exception e)
1169                 {
1170                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1171                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1172                 }
1173
1174                         return _ret_var;
1175
1176             }
1177             else
1178             {
1179                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1180             }
1181         }
1182
1183         private static efl_pack_delegate efl_pack_static_delegate;
1184
1185         [return: MarshalAs(UnmanagedType.U1)]
1186         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);
1187
1188         [return: MarshalAs(UnmanagedType.U1)]
1189         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);
1190
1191         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");
1192
1193         private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1194         {
1195             Eina.Log.Debug("function efl_pack_begin was called");
1196             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1197             if (ws != null)
1198             {
1199                                     bool _ret_var = default(bool);
1200                 try
1201                 {
1202                     _ret_var = ((Container)ws.Target).PackBegin(subobj);
1203                 }
1204                 catch (Exception e)
1205                 {
1206                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1207                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1208                 }
1209
1210                         return _ret_var;
1211
1212             }
1213             else
1214             {
1215                 return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1216             }
1217         }
1218
1219         private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
1220
1221         [return: MarshalAs(UnmanagedType.U1)]
1222         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);
1223
1224         [return: MarshalAs(UnmanagedType.U1)]
1225         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);
1226
1227         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");
1228
1229         private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1230         {
1231             Eina.Log.Debug("function efl_pack_end was called");
1232             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1233             if (ws != null)
1234             {
1235                                     bool _ret_var = default(bool);
1236                 try
1237                 {
1238                     _ret_var = ((Container)ws.Target).PackEnd(subobj);
1239                 }
1240                 catch (Exception e)
1241                 {
1242                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1243                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1244                 }
1245
1246                         return _ret_var;
1247
1248             }
1249             else
1250             {
1251                 return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1252             }
1253         }
1254
1255         private static efl_pack_end_delegate efl_pack_end_static_delegate;
1256
1257         [return: MarshalAs(UnmanagedType.U1)]
1258         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);
1259
1260         [return: MarshalAs(UnmanagedType.U1)]
1261         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);
1262
1263         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");
1264
1265         private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1266         {
1267             Eina.Log.Debug("function efl_pack_before was called");
1268             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1269             if (ws != null)
1270             {
1271                                                             bool _ret_var = default(bool);
1272                 try
1273                 {
1274                     _ret_var = ((Container)ws.Target).PackBefore(subobj, existing);
1275                 }
1276                 catch (Exception e)
1277                 {
1278                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1279                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1280                 }
1281
1282                                         return _ret_var;
1283
1284             }
1285             else
1286             {
1287                 return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1288             }
1289         }
1290
1291         private static efl_pack_before_delegate efl_pack_before_static_delegate;
1292
1293         [return: MarshalAs(UnmanagedType.U1)]
1294         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);
1295
1296         [return: MarshalAs(UnmanagedType.U1)]
1297         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);
1298
1299         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");
1300
1301         private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1302         {
1303             Eina.Log.Debug("function efl_pack_after was called");
1304             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1305             if (ws != null)
1306             {
1307                                                             bool _ret_var = default(bool);
1308                 try
1309                 {
1310                     _ret_var = ((Container)ws.Target).PackAfter(subobj, existing);
1311                 }
1312                 catch (Exception e)
1313                 {
1314                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1315                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1316                 }
1317
1318                                         return _ret_var;
1319
1320             }
1321             else
1322             {
1323                 return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1324             }
1325         }
1326
1327         private static efl_pack_after_delegate efl_pack_after_static_delegate;
1328
1329         [return: MarshalAs(UnmanagedType.U1)]
1330         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);
1331
1332         [return: MarshalAs(UnmanagedType.U1)]
1333         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);
1334
1335         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");
1336
1337         private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
1338         {
1339             Eina.Log.Debug("function efl_pack_at was called");
1340             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1341             if (ws != null)
1342             {
1343                                                             bool _ret_var = default(bool);
1344                 try
1345                 {
1346                     _ret_var = ((Container)ws.Target).PackAt(subobj, index);
1347                 }
1348                 catch (Exception e)
1349                 {
1350                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1351                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1352                 }
1353
1354                                         return _ret_var;
1355
1356             }
1357             else
1358             {
1359                 return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
1360             }
1361         }
1362
1363         private static efl_pack_at_delegate efl_pack_at_static_delegate;
1364
1365         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1366         private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
1367
1368         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1369         public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj,  int index);
1370
1371         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");
1372
1373         private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
1374         {
1375             Eina.Log.Debug("function efl_pack_content_get was called");
1376             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1377             if (ws != null)
1378             {
1379                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1380                 try
1381                 {
1382                     _ret_var = ((Container)ws.Target).GetPackContent(index);
1383                 }
1384                 catch (Exception e)
1385                 {
1386                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1387                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1388                 }
1389
1390                         return _ret_var;
1391
1392             }
1393             else
1394             {
1395                 return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1396             }
1397         }
1398
1399         private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
1400
1401
1402         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);
1403
1404
1405         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);
1406
1407         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");
1408
1409         private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1410         {
1411             Eina.Log.Debug("function efl_pack_index_get was called");
1412             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1413             if (ws != null)
1414             {
1415                                     int _ret_var = default(int);
1416                 try
1417                 {
1418                     _ret_var = ((Container)ws.Target).GetPackIndex(subobj);
1419                 }
1420                 catch (Exception e)
1421                 {
1422                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1423                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1424                 }
1425
1426                         return _ret_var;
1427
1428             }
1429             else
1430             {
1431                 return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1432             }
1433         }
1434
1435         private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
1436
1437         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1438         private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
1439
1440         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1441         public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj,  int index);
1442
1443         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");
1444
1445         private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
1446         {
1447             Eina.Log.Debug("function efl_pack_unpack_at was called");
1448             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1449             if (ws != null)
1450             {
1451                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1452                 try
1453                 {
1454                     _ret_var = ((Container)ws.Target).PackUnpackAt(index);
1455                 }
1456                 catch (Exception e)
1457                 {
1458                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1459                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1460                 }
1461
1462                         return _ret_var;
1463
1464             }
1465             else
1466             {
1467                 return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1468             }
1469         }
1470
1471         private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
1472
1473         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1474
1475 }
1476 }
1477 }
1478
1479 }
1480
1481 }
1482
1483 namespace Efl {
1484
1485 namespace Ui {
1486
1487 namespace ActiveView {
1488
1489 /// <summary>This enum controls the behavior of <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> when indices are shifted due to object addition or removal.</summary>
1490 public enum ContainerGravity
1491 {
1492 /// <summary>When a view is added or removed from the container, the <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> will be adjusted as necessary so it points to the same view as before.</summary>
1493 Content = 0,
1494 /// <summary>When a view is added or removed from the container, the <see cref="Efl.Ui.ActiveView.Container.ActiveIndex"/> will remain the same, possibly pointing to a different view.</summary>
1495 Index = 1,
1496 }
1497
1498 }
1499
1500 }
1501
1502 }
1503
1504 namespace Efl {
1505
1506 namespace Ui {
1507
1508 namespace ActiveView {
1509
1510 /// <summary>Information regarding transition events.</summary>
1511 [StructLayout(LayoutKind.Sequential)]
1512 public struct TransitionEvent
1513 {
1514     /// <summary>The view index from where the transition started, -1 if not known.</summary>
1515     public int From;
1516     /// <summary>The view index to where the transition is headed, -1 if not known.</summary>
1517     public int To;
1518     ///<summary>Constructor for TransitionEvent.</summary>
1519     public TransitionEvent(
1520         int From = default(int),
1521         int To = default(int)    )
1522     {
1523         this.From = From;
1524         this.To = To;
1525     }
1526
1527     ///<summary>Implicit conversion to the managed representation from a native pointer.</summary>
1528     ///<param name="ptr">Native pointer to be converted.</param>
1529     public static implicit operator TransitionEvent(IntPtr ptr)
1530     {
1531         var tmp = (TransitionEvent.NativeStruct)Marshal.PtrToStructure(ptr, typeof(TransitionEvent.NativeStruct));
1532         return tmp;
1533     }
1534
1535     #pragma warning disable CS1591
1536
1537     ///<summary>Internal wrapper for struct TransitionEvent.</summary>
1538     [StructLayout(LayoutKind.Sequential)]
1539     public struct NativeStruct
1540     {
1541
1542         public int From;
1543
1544         public int To;
1545         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
1546         public static implicit operator TransitionEvent.NativeStruct(TransitionEvent _external_struct)
1547         {
1548             var _internal_struct = new TransitionEvent.NativeStruct();
1549             _internal_struct.From = _external_struct.From;
1550             _internal_struct.To = _external_struct.To;
1551             return _internal_struct;
1552         }
1553
1554         ///<summary>Implicit conversion to the managed representation.</summary>
1555         public static implicit operator TransitionEvent(TransitionEvent.NativeStruct _internal_struct)
1556         {
1557             var _external_struct = new TransitionEvent();
1558             _external_struct.From = _internal_struct.From;
1559             _external_struct.To = _internal_struct.To;
1560             return _external_struct;
1561         }
1562
1563     }
1564
1565     #pragma warning restore CS1591
1566
1567 }
1568
1569 }
1570
1571 }
1572
1573 }
1574