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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Efl UI flip class</summary>
  13 [Efl.Ui.Flip.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public class Flip : Efl.Ui.Widget, Efl.IContainer, Efl.IPack, Efl.IPackLinear
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(Flip))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  34         efl_ui_flip_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="Flip"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle" /></param>
  38     public Flip(Efl.Object parent
  39             , System.String style = null) : base(efl_ui_flip_class_get(), parent)
  40     {
  41         if (Efl.Eo.Globals.ParamHelperCheck(style))
  42         {
  43             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  44         }
  45
  46         FinishInstantiation();
  47     }
  48
  49     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  50     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  51     protected Flip(ConstructingHandle ch) : base(ch)
  52     {
  53     }
  54
  55     /// <summary>Initializes a new instance of the <see cref="Flip"/> class.
  56     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  57     /// <param name="wh">The native pointer to be wrapped.</param>
  58     protected Flip(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  59     {
  60     }
  61
  62     /// <summary>Initializes a new instance of the <see cref="Flip"/> class.
  63     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  64     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  65     /// <param name="parent">The Efl.Object parent of this instance.</param>
  66     protected Flip(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  67     {
  68     }
  69
  70     /// <summary>Called when flip animation begins</summary>
  71     public event EventHandler AnimateBeginEvt
  72     {
  73         add
  74         {
  75             lock (eflBindingEventLock)
  76             {
  77                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  78                 {
  79                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  80                     if (obj != null)
  81                     {
  82                         EventArgs args = EventArgs.Empty;
  83                         try
  84                         {
  85                             value?.Invoke(obj, args);
  86                         }
  87                         catch (Exception e)
  88                         {
  89                             Eina.Log.Error(e.ToString());
  90                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  91                         }
  92                     }
  93                 };
  94
  95                 string key = "_EFL_UI_FLIP_EVENT_ANIMATE_BEGIN";
  96                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  97             }
  98         }
  99
 100         remove
 101         {
 102             lock (eflBindingEventLock)
 103             {
 104                 string key = "_EFL_UI_FLIP_EVENT_ANIMATE_BEGIN";
 105                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 106             }
 107         }
 108     }
 109     ///<summary>Method to raise event AnimateBeginEvt.</summary>
 110     public void OnAnimateBeginEvt(EventArgs e)
 111     {
 112         var key = "_EFL_UI_FLIP_EVENT_ANIMATE_BEGIN";
 113         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 114         if (desc == IntPtr.Zero)
 115         {
 116             Eina.Log.Error($"Failed to get native event {key}");
 117             return;
 118         }
 119
 120         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 121     }
 122     /// <summary>Called when flip animation is done</summary>
 123     public event EventHandler AnimateDoneEvt
 124     {
 125         add
 126         {
 127             lock (eflBindingEventLock)
 128             {
 129                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 130                 {
 131                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 132                     if (obj != null)
 133                     {
 134                         EventArgs args = EventArgs.Empty;
 135                         try
 136                         {
 137                             value?.Invoke(obj, args);
 138                         }
 139                         catch (Exception e)
 140                         {
 141                             Eina.Log.Error(e.ToString());
 142                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 143                         }
 144                     }
 145                 };
 146
 147                 string key = "_EFL_UI_FLIP_EVENT_ANIMATE_DONE";
 148                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 149             }
 150         }
 151
 152         remove
 153         {
 154             lock (eflBindingEventLock)
 155             {
 156                 string key = "_EFL_UI_FLIP_EVENT_ANIMATE_DONE";
 157                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 158             }
 159         }
 160     }
 161     ///<summary>Method to raise event AnimateDoneEvt.</summary>
 162     public void OnAnimateDoneEvt(EventArgs e)
 163     {
 164         var key = "_EFL_UI_FLIP_EVENT_ANIMATE_DONE";
 165         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 166         if (desc == IntPtr.Zero)
 167         {
 168             Eina.Log.Error($"Failed to get native event {key}");
 169             return;
 170         }
 171
 172         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 173     }
 174     /// <summary>Sent after a new sub-object was added.
 175     /// (Since EFL 1.22)</summary>
 176     public event EventHandler<Efl.IContainerContentAddedEvt_Args> ContentAddedEvt
 177     {
 178         add
 179         {
 180             lock (eflBindingEventLock)
 181             {
 182                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 183                 {
 184                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 185                     if (obj != null)
 186                     {
 187                         Efl.IContainerContentAddedEvt_Args args = new Efl.IContainerContentAddedEvt_Args();
 188                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 189                         try
 190                         {
 191                             value?.Invoke(obj, args);
 192                         }
 193                         catch (Exception e)
 194                         {
 195                             Eina.Log.Error(e.ToString());
 196                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 197                         }
 198                     }
 199                 };
 200
 201                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 202                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 203             }
 204         }
 205
 206         remove
 207         {
 208             lock (eflBindingEventLock)
 209             {
 210                 string key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 211                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 212             }
 213         }
 214     }
 215     ///<summary>Method to raise event ContentAddedEvt.</summary>
 216     public void OnContentAddedEvt(Efl.IContainerContentAddedEvt_Args e)
 217     {
 218         var key = "_EFL_CONTAINER_EVENT_CONTENT_ADDED";
 219         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 220         if (desc == IntPtr.Zero)
 221         {
 222             Eina.Log.Error($"Failed to get native event {key}");
 223             return;
 224         }
 225
 226         IntPtr info = e.arg.NativeHandle;
 227         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 228     }
 229     /// <summary>Sent after a sub-object was removed, before unref.
 230     /// (Since EFL 1.22)</summary>
 231     public event EventHandler<Efl.IContainerContentRemovedEvt_Args> ContentRemovedEvt
 232     {
 233         add
 234         {
 235             lock (eflBindingEventLock)
 236             {
 237                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 238                 {
 239                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 240                     if (obj != null)
 241                     {
 242                         Efl.IContainerContentRemovedEvt_Args args = new Efl.IContainerContentRemovedEvt_Args();
 243                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 244                         try
 245                         {
 246                             value?.Invoke(obj, args);
 247                         }
 248                         catch (Exception e)
 249                         {
 250                             Eina.Log.Error(e.ToString());
 251                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 252                         }
 253                     }
 254                 };
 255
 256                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 257                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 258             }
 259         }
 260
 261         remove
 262         {
 263             lock (eflBindingEventLock)
 264             {
 265                 string key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 266                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 267             }
 268         }
 269     }
 270     ///<summary>Method to raise event ContentRemovedEvt.</summary>
 271     public void OnContentRemovedEvt(Efl.IContainerContentRemovedEvt_Args e)
 272     {
 273         var key = "_EFL_CONTAINER_EVENT_CONTENT_REMOVED";
 274         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 275         if (desc == IntPtr.Zero)
 276         {
 277             Eina.Log.Error($"Failed to get native event {key}");
 278             return;
 279         }
 280
 281         IntPtr info = e.arg.NativeHandle;
 282         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 283     }
 284     /// <summary>Get the interactive flip mode.</summary>
 285     /// <returns>The interactive flip mode to use.</returns>
 286     virtual public Efl.Ui.FlipInteraction GetInteraction() {
 287          var _ret_var = Efl.Ui.Flip.NativeMethods.efl_ui_flip_interaction_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 288         Eina.Error.RaiseIfUnhandledException();
 289         return _ret_var;
 290  }
 291     /// <summary>Set the interactive flip mode.
 292     /// This sets if the flip should be interactive (allow user to click and drag a side of the flip to reveal the back page and cause it to flip). By default a flip is not interactive. You may also need to set which sides of the flip are &quot;active&quot; for flipping and how much space they use (a minimum of a finger size) with <see cref="Efl.Ui.Flip.SetInteractionDirectionEnabled"/> and <see cref="Efl.Ui.Flip.SetInteractionDirectionHitsize"/>.
 293     ///
 294     /// The four available mode of interaction are #ELM_FLIP_INTERACTION_NONE, #ELM_FLIP_INTERACTION_ROTATE, #ELM_FLIP_INTERACTION_CUBE and  #ELM_FLIP_INTERACTION_PAGE.
 295     ///
 296     /// Note: #ELM_FLIP_INTERACTION_ROTATE won&apos;t cause #ELM_FLIP_ROTATE_XZ_CENTER_AXIS or #ELM_FLIP_ROTATE_YZ_CENTER_AXIS to happen, those can only be achieved with <see cref="Efl.Ui.Flip.Go"/>.</summary>
 297     /// <param name="mode">The interactive flip mode to use.</param>
 298     virtual public void SetInteraction(Efl.Ui.FlipInteraction mode) {
 299                                  Efl.Ui.Flip.NativeMethods.efl_ui_flip_interaction_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),mode);
 300         Eina.Error.RaiseIfUnhandledException();
 301                          }
 302     /// <summary>Get flip front visibility state.</summary>
 303     /// <returns><c>true</c> if front front is showing, <c>false</c> if the back is showing.</returns>
 304     virtual public bool GetFrontVisible() {
 305          var _ret_var = Efl.Ui.Flip.NativeMethods.efl_ui_flip_front_visible_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 306         Eina.Error.RaiseIfUnhandledException();
 307         return _ret_var;
 308  }
 309     /// <summary>Set the amount of the flip that is sensitive to interactive flip.
 310     /// Set the amount of the flip that is sensitive to interactive flip, with 0 representing no area in the flip and 1 representing the entire flip. There is however a consideration to be made in that the area will never be smaller than the finger size set (as set in your Elementary configuration), and dragging must always start from the opposite half of the flip (eg. right half of the flip when dragging to the left).
 311     ///
 312     /// Note: The <c>dir</c> parameter is not actually related to the direction of the drag, it only refers to the area in the flip where interaction can occur (top, bottom, left, right).
 313     ///
 314     /// Negative values of <c>hitsize</c> will disable this hit area.
 315     ///
 316     /// See also <see cref="Efl.Ui.Flip.SetInteraction"/>.</summary>
 317     /// <param name="dir">The hit area to set.</param>
 318     /// <param name="hitsize">The amount of that dimension (0.0 to 1.0) to use.</param>
 319     virtual public void SetInteractionDirectionHitsize(Efl.Ui.LayoutOrientation dir, double hitsize) {
 320                                                          Efl.Ui.Flip.NativeMethods.efl_ui_flip_interaction_direction_hitsize_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir, hitsize);
 321         Eina.Error.RaiseIfUnhandledException();
 322                                          }
 323     /// <summary>Get the amount of the flip that is sensitive to interactive flip.</summary>
 324     /// <param name="dir">The direction to check.</param>
 325     /// <returns>The size set for that direction.</returns>
 326     virtual public double GetInteractionDirectionHitsize(Efl.Ui.LayoutOrientation dir) {
 327                                  var _ret_var = Efl.Ui.Flip.NativeMethods.efl_ui_flip_interaction_direction_hitsize_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir);
 328         Eina.Error.RaiseIfUnhandledException();
 329                         return _ret_var;
 330  }
 331     /// <summary>Set which directions of the flip respond to interactive flip
 332     /// By default all directions are disabled, so you may want to enable the desired directions for flipping if you need interactive flipping. You must call this function once for each direction that&apos;s enabled.
 333     ///
 334     /// You can also set the appropriate hit area size by calling <see cref="Efl.Ui.Flip.SetInteractionDirectionHitsize"/>. By default, a minimum hit area will be created on the opposite edge of the flip.</summary>
 335     /// <param name="dir">The direction to change.</param>
 336     /// <param name="enabled">If that direction is enabled or not.</param>
 337     virtual public void SetInteractionDirectionEnabled(Efl.Ui.LayoutOrientation dir, bool enabled) {
 338                                                          Efl.Ui.Flip.NativeMethods.efl_ui_flip_interaction_direction_enabled_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir, enabled);
 339         Eina.Error.RaiseIfUnhandledException();
 340                                          }
 341     /// <summary>Get the enabled state of that flip direction.</summary>
 342     /// <param name="dir">The direction to check.</param>
 343     /// <returns>If that direction is enabled or not.</returns>
 344     virtual public bool GetInteractionDirectionEnabled(Efl.Ui.LayoutOrientation dir) {
 345                                  var _ret_var = Efl.Ui.Flip.NativeMethods.efl_ui_flip_interaction_direction_enabled_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir);
 346         Eina.Error.RaiseIfUnhandledException();
 347                         return _ret_var;
 348  }
 349     /// <summary>Runs the flip animation.
 350     /// Flips the front and back contents using the <c>mode</c> animation. This effectively hides the currently visible content and shows the hidden one.
 351     ///
 352     /// There a number of possible animations to use for flipping, namely #ELM_FLIP_ROTATE_X_CENTER_AXIS (rotate the currently visible content around a horizontal axis in the middle of its height, the other content is shown as the other side of the flip), #ELM_FLIP_ROTATE_Y_CENTER_AXIS (rotate the currently visible content around a vertical axis in the middle of its width, the other content is shown as the other side of the flip), #ELM_FLIP_ROTATE_XZ_CENTER_AXIS (rotate the currently visible content around a diagonal axis in the middle of its width, the other content is shown as the other side of the flip), #ELM_FLIP_ROTATE_YZ_CENTER_AXIS (rotate the currently visible content around a diagonal axis in the middle of its height, the other content is shown as the other side of the flip). #ELM_FLIP_CUBE_LEFT (rotate the currently visible content to the left as if the flip was a cube, the other content is shown as the right face of the cube), #ELM_FLIP_CUBE_RIGHT (rotate the currently visible content to the right as if the flip was a cube, the other content is shown as the left face of the cube), #ELM_FLIP_CUBE_UP (rotate the currently visible content up as if the flip was a cube, the other content is shown as the bottom face of the cube), #ELM_FLIP_CUBE_DOWN (rotate the currently visible content down as if the flip was a cube, the other content is shown as the upper face of the cube), #ELM_FLIP_PAGE_LEFT (move the currently visible content to the left as if the flip was a book, the other content is shown as the page below that), #ELM_FLIP_PAGE_RIGHT (move the currently visible content to the right as if the flip was a book, the other content is shown as the page below it), #ELM_FLIP_PAGE_UP (move the currently visible content up as if the flip was a book, the other content is shown as the page below it), #ELM_FLIP_PAGE_DOWN (move the currently visible content down as if the flip was a book, the other content is shown as the page below that) and #ELM_FLIP_CROSS_FADE (fade out the currently visible content, while fading in the invisible content).</summary>
 353     /// <param name="mode">The mode type.</param>
 354     virtual public void Go(Efl.Ui.FlipMode mode) {
 355                                  Efl.Ui.Flip.NativeMethods.efl_ui_flip_go_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),mode);
 356         Eina.Error.RaiseIfUnhandledException();
 357                          }
 358     /// <summary>Runs the flip animation to front or back.
 359     /// Flips the front and back contents using the <c>mode</c> animation. This effectively hides the currently visible content and shows he hidden one.
 360     ///
 361     /// There a number of possible animations to use for flipping, namely #ELM_FLIP_ROTATE_X_CENTER_AXIS (rotate the currently visible content around a horizontal axis in the middle of its height, the other content is shown as the other side of the flip), #ELM_FLIP_ROTATE_Y_CENTER_AXIS (rotate the currently visible content around a vertical axis in the middle of its width, the other content is shown as the other side of the flip), #ELM_FLIP_ROTATE_XZ_CENTER_AXIS (rotate the currently visible content around a diagonal axis in the middle of its width, the other content is shown as the other side of the flip), #ELM_FLIP_ROTATE_YZ_CENTER_AXIS (rotate the currently visible content around a diagonal axis in the middle of its height, the other content is shown as the other side of the flip). #ELM_FLIP_CUBE_LEFT (rotate the currently visible content to the left as if the flip was a cube, the other content is show as the right face of the cube), #ELM_FLIP_CUBE_RIGHT (rotate the currently visible content to the right as if the flip was a cube, the other content is show as the left face of the cube), #ELM_FLIP_CUBE_UP (rotate the currently visible content up as if the flip was a cube, the other content is shown as the bottom face of the cube), #ELM_FLIP_CUBE_DOWN (rotate the currently visible content down as if the flip was a cube, the other content is shown as the upper face of the cube), #ELM_FLIP_PAGE_LEFT (move the currently visible content to the left as if the flip was a book, the other content is shown as the page below that), #ELM_FLIP_PAGE_RIGHT (move the currently visible content to the right as if the flip was a book, the other content is shown as the page below it), #ELM_FLIP_PAGE_UP (move the currently visible content up as if the flip was a book, the other content is shown as the page below it) and #ELM_FLIP_PAGE_DOWN (move the currently visible content down as if the flip was a book, the other content is shown as the page below that).</summary>
 362     /// <param name="front">If <c>true</c>, makes front visible, otherwise makes back.</param>
 363     /// <param name="mode">The mode type.</param>
 364     virtual public void GoTo(bool front, Efl.Ui.FlipMode mode) {
 365                                                          Efl.Ui.Flip.NativeMethods.efl_ui_flip_go_to_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),front, mode);
 366         Eina.Error.RaiseIfUnhandledException();
 367                                          }
 368     /// <summary>Begin iterating over this object&apos;s contents.
 369     /// (Since EFL 1.22)</summary>
 370     /// <returns>Iterator on object&apos;s content.</returns>
 371     virtual public Eina.Iterator<Efl.Gfx.IEntity> ContentIterate() {
 372          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_iterate_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 373         Eina.Error.RaiseIfUnhandledException();
 374         return new Eina.Iterator<Efl.Gfx.IEntity>(_ret_var, true);
 375  }
 376     /// <summary>Returns the number of contained sub-objects.
 377     /// (Since EFL 1.22)</summary>
 378     /// <returns>Number of sub-objects.</returns>
 379     virtual public int ContentCount() {
 380          var _ret_var = Efl.IContainerConcrete.NativeMethods.efl_content_count_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 381         Eina.Error.RaiseIfUnhandledException();
 382         return _ret_var;
 383  }
 384     /// <summary>Removes all packed sub-objects and unreferences them.</summary>
 385     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 386     virtual public bool ClearPack() {
 387          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_clear_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 388         Eina.Error.RaiseIfUnhandledException();
 389         return _ret_var;
 390  }
 391     /// <summary>Removes all packed sub-objects without unreferencing them.
 392     /// Use with caution.</summary>
 393     /// <returns><c>true</c> on success, <c>false</c> otherwise.</returns>
 394     virtual public bool UnpackAll() {
 395          var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_all_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 396         Eina.Error.RaiseIfUnhandledException();
 397         return _ret_var;
 398  }
 399     /// <summary>Removes an existing sub-object from the container without deleting it.</summary>
 400     /// <param name="subobj">The sub-object to unpack.</param>
 401     /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t in the container or couldn&apos;t be removed.</returns>
 402     virtual public bool Unpack(Efl.Gfx.IEntity subobj) {
 403                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_unpack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 404         Eina.Error.RaiseIfUnhandledException();
 405                         return _ret_var;
 406  }
 407     /// <summary>Adds a sub-object to this container.
 408     /// 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.
 409     ///
 410     /// 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>
 411     /// <param name="subobj">The object to pack.</param>
 412     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 413     virtual public bool Pack(Efl.Gfx.IEntity subobj) {
 414                                  var _ret_var = Efl.IPackConcrete.NativeMethods.efl_pack_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 415         Eina.Error.RaiseIfUnhandledException();
 416                         return _ret_var;
 417  }
 418     /// <summary>Prepend an object at the beginning of this container.
 419     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, 0).
 420     ///
 421     /// 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>
 422     /// <param name="subobj">Object to pack at the beginning.</param>
 423     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 424     virtual public bool PackBegin(Efl.Gfx.IEntity subobj) {
 425                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_begin_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 426         Eina.Error.RaiseIfUnhandledException();
 427                         return _ret_var;
 428  }
 429     /// <summary>Append object at the end of this container.
 430     /// This is the same as <see cref="Efl.IPackLinear.PackAt"/>(<c>subobj</c>, -1).
 431     ///
 432     /// 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>
 433     /// <param name="subobj">Object to pack at the end.</param>
 434     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 435     virtual public bool PackEnd(Efl.Gfx.IEntity subobj) {
 436                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_end_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 437         Eina.Error.RaiseIfUnhandledException();
 438                         return _ret_var;
 439  }
 440     /// <summary>Prepend an object before an existing sub-object.
 441     /// 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>
 442     /// <param name="subobj">Object to pack before <c>existing</c>.</param>
 443     /// <param name="existing">Existing reference sub-object.</param>
 444     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 445     virtual public bool PackBefore(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 446                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_before_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, existing);
 447         Eina.Error.RaiseIfUnhandledException();
 448                                         return _ret_var;
 449  }
 450     /// <summary>Append an object after an existing sub-object.
 451     /// 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>
 452     /// <param name="subobj">Object to pack after <c>existing</c>.</param>
 453     /// <param name="existing">Existing reference sub-object.</param>
 454     /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 455     virtual public bool PackAfter(Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing) {
 456                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_after_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, existing);
 457         Eina.Error.RaiseIfUnhandledException();
 458                                         return _ret_var;
 459  }
 460     /// <summary>Inserts <c>subobj</c> BEFORE the sub-object at position <c>index</c>.
 461     /// <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"/>.
 462     ///
 463     /// 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>).
 464     ///
 465     /// 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>
 466     /// <param name="subobj">Object to pack.</param>
 467     /// <param name="index">Index of existing sub-object to insert BEFORE. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 468     /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 469     virtual public bool PackAt(Efl.Gfx.IEntity subobj, int index) {
 470                                                          var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_at_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj, index);
 471         Eina.Error.RaiseIfUnhandledException();
 472                                         return _ret_var;
 473  }
 474     /// <summary>Sub-object at a given <c>index</c> in this container.
 475     /// <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"/>.
 476     ///
 477     /// 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>
 478     /// <param name="index">Index of the existing sub-object to retrieve. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 479     /// <returns>The sub-object contained at the given <c>index</c>.</returns>
 480     virtual public Efl.Gfx.IEntity GetPackContent(int index) {
 481                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_content_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),index);
 482         Eina.Error.RaiseIfUnhandledException();
 483                         return _ret_var;
 484  }
 485     /// <summary>Get the index of a sub-object in this container.</summary>
 486     /// <param name="subobj">An existing sub-object in this container.</param>
 487     /// <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>
 488     virtual public int GetPackIndex(Efl.Gfx.IEntity subobj) {
 489                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_index_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),subobj);
 490         Eina.Error.RaiseIfUnhandledException();
 491                         return _ret_var;
 492  }
 493     /// <summary>Pop out (remove) the sub-object at the specified <c>index</c>.
 494     /// <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"/>.
 495     ///
 496     /// 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>
 497     /// <param name="index">Index of the sub-object to remove. Valid range is -<c>count</c> to (<c>count</c>-1).</param>
 498     /// <returns>The sub-object if it could be removed.</returns>
 499     virtual public Efl.Gfx.IEntity PackUnpackAt(int index) {
 500                                  var _ret_var = Efl.IPackLinearConcrete.NativeMethods.efl_pack_unpack_at_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),index);
 501         Eina.Error.RaiseIfUnhandledException();
 502                         return _ret_var;
 503  }
 504     /// <summary>Get the interactive flip mode.</summary>
 505     /// <value>The interactive flip mode to use.</value>
 506     public Efl.Ui.FlipInteraction Interaction {
 507         get { return GetInteraction(); }
 508         set { SetInteraction(value); }
 509     }
 510     /// <summary>Get flip front visibility state.</summary>
 511     /// <value><c>true</c> if front front is showing, <c>false</c> if the back is showing.</value>
 512     public bool FrontVisible {
 513         get { return GetFrontVisible(); }
 514     }
 515     private static IntPtr GetEflClassStatic()
 516     {
 517         return Efl.Ui.Flip.efl_ui_flip_class_get();
 518     }
 519     /// <summary>Wrapper for native methods and virtual method delegates.
 520     /// For internal use by generated code only.</summary>
 521     public new class NativeMethods : Efl.Ui.Widget.NativeMethods
 522     {
 523         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 524         /// <summary>Gets the list of Eo operations to override.</summary>
 525         /// <returns>The list of Eo operations to be overload.</returns>
 526         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 527         {
 528             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 529             var methods = Efl.Eo.Globals.GetUserMethods(type);
 530
 531             if (efl_ui_flip_interaction_get_static_delegate == null)
 532             {
 533                 efl_ui_flip_interaction_get_static_delegate = new efl_ui_flip_interaction_get_delegate(interaction_get);
 534             }
 535
 536             if (methods.FirstOrDefault(m => m.Name == "GetInteraction") != null)
 537             {
 538                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_interaction_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_interaction_get_static_delegate) });
 539             }
 540
 541             if (efl_ui_flip_interaction_set_static_delegate == null)
 542             {
 543                 efl_ui_flip_interaction_set_static_delegate = new efl_ui_flip_interaction_set_delegate(interaction_set);
 544             }
 545
 546             if (methods.FirstOrDefault(m => m.Name == "SetInteraction") != null)
 547             {
 548                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_interaction_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_interaction_set_static_delegate) });
 549             }
 550
 551             if (efl_ui_flip_front_visible_get_static_delegate == null)
 552             {
 553                 efl_ui_flip_front_visible_get_static_delegate = new efl_ui_flip_front_visible_get_delegate(front_visible_get);
 554             }
 555
 556             if (methods.FirstOrDefault(m => m.Name == "GetFrontVisible") != null)
 557             {
 558                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_front_visible_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_front_visible_get_static_delegate) });
 559             }
 560
 561             if (efl_ui_flip_interaction_direction_hitsize_set_static_delegate == null)
 562             {
 563                 efl_ui_flip_interaction_direction_hitsize_set_static_delegate = new efl_ui_flip_interaction_direction_hitsize_set_delegate(interaction_direction_hitsize_set);
 564             }
 565
 566             if (methods.FirstOrDefault(m => m.Name == "SetInteractionDirectionHitsize") != null)
 567             {
 568                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_interaction_direction_hitsize_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_interaction_direction_hitsize_set_static_delegate) });
 569             }
 570
 571             if (efl_ui_flip_interaction_direction_hitsize_get_static_delegate == null)
 572             {
 573                 efl_ui_flip_interaction_direction_hitsize_get_static_delegate = new efl_ui_flip_interaction_direction_hitsize_get_delegate(interaction_direction_hitsize_get);
 574             }
 575
 576             if (methods.FirstOrDefault(m => m.Name == "GetInteractionDirectionHitsize") != null)
 577             {
 578                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_interaction_direction_hitsize_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_interaction_direction_hitsize_get_static_delegate) });
 579             }
 580
 581             if (efl_ui_flip_interaction_direction_enabled_set_static_delegate == null)
 582             {
 583                 efl_ui_flip_interaction_direction_enabled_set_static_delegate = new efl_ui_flip_interaction_direction_enabled_set_delegate(interaction_direction_enabled_set);
 584             }
 585
 586             if (methods.FirstOrDefault(m => m.Name == "SetInteractionDirectionEnabled") != null)
 587             {
 588                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_interaction_direction_enabled_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_interaction_direction_enabled_set_static_delegate) });
 589             }
 590
 591             if (efl_ui_flip_interaction_direction_enabled_get_static_delegate == null)
 592             {
 593                 efl_ui_flip_interaction_direction_enabled_get_static_delegate = new efl_ui_flip_interaction_direction_enabled_get_delegate(interaction_direction_enabled_get);
 594             }
 595
 596             if (methods.FirstOrDefault(m => m.Name == "GetInteractionDirectionEnabled") != null)
 597             {
 598                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_interaction_direction_enabled_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_interaction_direction_enabled_get_static_delegate) });
 599             }
 600
 601             if (efl_ui_flip_go_static_delegate == null)
 602             {
 603                 efl_ui_flip_go_static_delegate = new efl_ui_flip_go_delegate(go);
 604             }
 605
 606             if (methods.FirstOrDefault(m => m.Name == "Go") != null)
 607             {
 608                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_go"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_go_static_delegate) });
 609             }
 610
 611             if (efl_ui_flip_go_to_static_delegate == null)
 612             {
 613                 efl_ui_flip_go_to_static_delegate = new efl_ui_flip_go_to_delegate(go_to);
 614             }
 615
 616             if (methods.FirstOrDefault(m => m.Name == "GoTo") != null)
 617             {
 618                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_flip_go_to"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_flip_go_to_static_delegate) });
 619             }
 620
 621             if (efl_content_iterate_static_delegate == null)
 622             {
 623                 efl_content_iterate_static_delegate = new efl_content_iterate_delegate(content_iterate);
 624             }
 625
 626             if (methods.FirstOrDefault(m => m.Name == "ContentIterate") != null)
 627             {
 628                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_iterate"), func = Marshal.GetFunctionPointerForDelegate(efl_content_iterate_static_delegate) });
 629             }
 630
 631             if (efl_content_count_static_delegate == null)
 632             {
 633                 efl_content_count_static_delegate = new efl_content_count_delegate(content_count);
 634             }
 635
 636             if (methods.FirstOrDefault(m => m.Name == "ContentCount") != null)
 637             {
 638                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_count"), func = Marshal.GetFunctionPointerForDelegate(efl_content_count_static_delegate) });
 639             }
 640
 641             if (efl_pack_clear_static_delegate == null)
 642             {
 643                 efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 644             }
 645
 646             if (methods.FirstOrDefault(m => m.Name == "ClearPack") != null)
 647             {
 648                 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) });
 649             }
 650
 651             if (efl_pack_unpack_all_static_delegate == null)
 652             {
 653                 efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 654             }
 655
 656             if (methods.FirstOrDefault(m => m.Name == "UnpackAll") != null)
 657             {
 658                 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) });
 659             }
 660
 661             if (efl_pack_unpack_static_delegate == null)
 662             {
 663                 efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 664             }
 665
 666             if (methods.FirstOrDefault(m => m.Name == "Unpack") != null)
 667             {
 668                 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) });
 669             }
 670
 671             if (efl_pack_static_delegate == null)
 672             {
 673                 efl_pack_static_delegate = new efl_pack_delegate(pack);
 674             }
 675
 676             if (methods.FirstOrDefault(m => m.Name == "Pack") != null)
 677             {
 678                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate) });
 679             }
 680
 681             if (efl_pack_begin_static_delegate == null)
 682             {
 683                 efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 684             }
 685
 686             if (methods.FirstOrDefault(m => m.Name == "PackBegin") != null)
 687             {
 688                 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) });
 689             }
 690
 691             if (efl_pack_end_static_delegate == null)
 692             {
 693                 efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 694             }
 695
 696             if (methods.FirstOrDefault(m => m.Name == "PackEnd") != null)
 697             {
 698                 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) });
 699             }
 700
 701             if (efl_pack_before_static_delegate == null)
 702             {
 703                 efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 704             }
 705
 706             if (methods.FirstOrDefault(m => m.Name == "PackBefore") != null)
 707             {
 708                 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) });
 709             }
 710
 711             if (efl_pack_after_static_delegate == null)
 712             {
 713                 efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 714             }
 715
 716             if (methods.FirstOrDefault(m => m.Name == "PackAfter") != null)
 717             {
 718                 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) });
 719             }
 720
 721             if (efl_pack_at_static_delegate == null)
 722             {
 723                 efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 724             }
 725
 726             if (methods.FirstOrDefault(m => m.Name == "PackAt") != null)
 727             {
 728                 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) });
 729             }
 730
 731             if (efl_pack_content_get_static_delegate == null)
 732             {
 733                 efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 734             }
 735
 736             if (methods.FirstOrDefault(m => m.Name == "GetPackContent") != null)
 737             {
 738                 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) });
 739             }
 740
 741             if (efl_pack_index_get_static_delegate == null)
 742             {
 743                 efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 744             }
 745
 746             if (methods.FirstOrDefault(m => m.Name == "GetPackIndex") != null)
 747             {
 748                 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) });
 749             }
 750
 751             if (efl_pack_unpack_at_static_delegate == null)
 752             {
 753                 efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 754             }
 755
 756             if (methods.FirstOrDefault(m => m.Name == "PackUnpackAt") != null)
 757             {
 758                 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) });
 759             }
 760
 761             descs.AddRange(base.GetEoOps(type));
 762             return descs;
 763         }
 764         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 765         /// <returns>The native class pointer.</returns>
 766         public override IntPtr GetEflClass()
 767         {
 768             return Efl.Ui.Flip.efl_ui_flip_class_get();
 769         }
 770
 771         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 772
 773
 774         private delegate Efl.Ui.FlipInteraction efl_ui_flip_interaction_get_delegate(System.IntPtr obj, System.IntPtr pd);
 775
 776
 777         public delegate Efl.Ui.FlipInteraction efl_ui_flip_interaction_get_api_delegate(System.IntPtr obj);
 778
 779         public static Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_get_api_delegate> efl_ui_flip_interaction_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_get_api_delegate>(Module, "efl_ui_flip_interaction_get");
 780
 781         private static Efl.Ui.FlipInteraction interaction_get(System.IntPtr obj, System.IntPtr pd)
 782         {
 783             Eina.Log.Debug("function efl_ui_flip_interaction_get was called");
 784             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 785             if (ws != null)
 786             {
 787             Efl.Ui.FlipInteraction _ret_var = default(Efl.Ui.FlipInteraction);
 788                 try
 789                 {
 790                     _ret_var = ((Flip)ws.Target).GetInteraction();
 791                 }
 792                 catch (Exception e)
 793                 {
 794                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 795                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 796                 }
 797
 798         return _ret_var;
 799
 800             }
 801             else
 802             {
 803                 return efl_ui_flip_interaction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 804             }
 805         }
 806
 807         private static efl_ui_flip_interaction_get_delegate efl_ui_flip_interaction_get_static_delegate;
 808
 809
 810         private delegate void efl_ui_flip_interaction_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.FlipInteraction mode);
 811
 812
 813         public delegate void efl_ui_flip_interaction_set_api_delegate(System.IntPtr obj,  Efl.Ui.FlipInteraction mode);
 814
 815         public static Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_set_api_delegate> efl_ui_flip_interaction_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_set_api_delegate>(Module, "efl_ui_flip_interaction_set");
 816
 817         private static void interaction_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.FlipInteraction mode)
 818         {
 819             Eina.Log.Debug("function efl_ui_flip_interaction_set was called");
 820             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 821             if (ws != null)
 822             {
 823
 824                 try
 825                 {
 826                     ((Flip)ws.Target).SetInteraction(mode);
 827                 }
 828                 catch (Exception e)
 829                 {
 830                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 831                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 832                 }
 833
 834
 835             }
 836             else
 837             {
 838                 efl_ui_flip_interaction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode);
 839             }
 840         }
 841
 842         private static efl_ui_flip_interaction_set_delegate efl_ui_flip_interaction_set_static_delegate;
 843
 844         [return: MarshalAs(UnmanagedType.U1)]
 845         private delegate bool efl_ui_flip_front_visible_get_delegate(System.IntPtr obj, System.IntPtr pd);
 846
 847         [return: MarshalAs(UnmanagedType.U1)]
 848         public delegate bool efl_ui_flip_front_visible_get_api_delegate(System.IntPtr obj);
 849
 850         public static Efl.Eo.FunctionWrapper<efl_ui_flip_front_visible_get_api_delegate> efl_ui_flip_front_visible_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_front_visible_get_api_delegate>(Module, "efl_ui_flip_front_visible_get");
 851
 852         private static bool front_visible_get(System.IntPtr obj, System.IntPtr pd)
 853         {
 854             Eina.Log.Debug("function efl_ui_flip_front_visible_get was called");
 855             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 856             if (ws != null)
 857             {
 858             bool _ret_var = default(bool);
 859                 try
 860                 {
 861                     _ret_var = ((Flip)ws.Target).GetFrontVisible();
 862                 }
 863                 catch (Exception e)
 864                 {
 865                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 866                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 867                 }
 868
 869         return _ret_var;
 870
 871             }
 872             else
 873             {
 874                 return efl_ui_flip_front_visible_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 875             }
 876         }
 877
 878         private static efl_ui_flip_front_visible_get_delegate efl_ui_flip_front_visible_get_static_delegate;
 879
 880
 881         private delegate void efl_ui_flip_interaction_direction_hitsize_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir,  double hitsize);
 882
 883
 884         public delegate void efl_ui_flip_interaction_direction_hitsize_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir,  double hitsize);
 885
 886         public static Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_hitsize_set_api_delegate> efl_ui_flip_interaction_direction_hitsize_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_hitsize_set_api_delegate>(Module, "efl_ui_flip_interaction_direction_hitsize_set");
 887
 888         private static void interaction_direction_hitsize_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir, double hitsize)
 889         {
 890             Eina.Log.Debug("function efl_ui_flip_interaction_direction_hitsize_set was called");
 891             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 892             if (ws != null)
 893             {
 894
 895                 try
 896                 {
 897                     ((Flip)ws.Target).SetInteractionDirectionHitsize(dir, hitsize);
 898                 }
 899                 catch (Exception e)
 900                 {
 901                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 902                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 903                 }
 904
 905
 906             }
 907             else
 908             {
 909                 efl_ui_flip_interaction_direction_hitsize_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir, hitsize);
 910             }
 911         }
 912
 913         private static efl_ui_flip_interaction_direction_hitsize_set_delegate efl_ui_flip_interaction_direction_hitsize_set_static_delegate;
 914
 915
 916         private delegate double efl_ui_flip_interaction_direction_hitsize_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
 917
 918
 919         public delegate double efl_ui_flip_interaction_direction_hitsize_get_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
 920
 921         public static Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_hitsize_get_api_delegate> efl_ui_flip_interaction_direction_hitsize_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_hitsize_get_api_delegate>(Module, "efl_ui_flip_interaction_direction_hitsize_get");
 922
 923         private static double interaction_direction_hitsize_get(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
 924         {
 925             Eina.Log.Debug("function efl_ui_flip_interaction_direction_hitsize_get was called");
 926             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 927             if (ws != null)
 928             {
 929                                     double _ret_var = default(double);
 930                 try
 931                 {
 932                     _ret_var = ((Flip)ws.Target).GetInteractionDirectionHitsize(dir);
 933                 }
 934                 catch (Exception e)
 935                 {
 936                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 937                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 938                 }
 939
 940                         return _ret_var;
 941
 942             }
 943             else
 944             {
 945                 return efl_ui_flip_interaction_direction_hitsize_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
 946             }
 947         }
 948
 949         private static efl_ui_flip_interaction_direction_hitsize_get_delegate efl_ui_flip_interaction_direction_hitsize_get_static_delegate;
 950
 951
 952         private delegate void efl_ui_flip_interaction_direction_enabled_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir, [MarshalAs(UnmanagedType.U1)] bool enabled);
 953
 954
 955         public delegate void efl_ui_flip_interaction_direction_enabled_set_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir, [MarshalAs(UnmanagedType.U1)] bool enabled);
 956
 957         public static Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_enabled_set_api_delegate> efl_ui_flip_interaction_direction_enabled_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_enabled_set_api_delegate>(Module, "efl_ui_flip_interaction_direction_enabled_set");
 958
 959         private static void interaction_direction_enabled_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir, bool enabled)
 960         {
 961             Eina.Log.Debug("function efl_ui_flip_interaction_direction_enabled_set was called");
 962             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 963             if (ws != null)
 964             {
 965
 966                 try
 967                 {
 968                     ((Flip)ws.Target).SetInteractionDirectionEnabled(dir, enabled);
 969                 }
 970                 catch (Exception e)
 971                 {
 972                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 973                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 974                 }
 975
 976
 977             }
 978             else
 979             {
 980                 efl_ui_flip_interaction_direction_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir, enabled);
 981             }
 982         }
 983
 984         private static efl_ui_flip_interaction_direction_enabled_set_delegate efl_ui_flip_interaction_direction_enabled_set_static_delegate;
 985
 986         [return: MarshalAs(UnmanagedType.U1)]
 987         private delegate bool efl_ui_flip_interaction_direction_enabled_get_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.LayoutOrientation dir);
 988
 989         [return: MarshalAs(UnmanagedType.U1)]
 990         public delegate bool efl_ui_flip_interaction_direction_enabled_get_api_delegate(System.IntPtr obj,  Efl.Ui.LayoutOrientation dir);
 991
 992         public static Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_enabled_get_api_delegate> efl_ui_flip_interaction_direction_enabled_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_interaction_direction_enabled_get_api_delegate>(Module, "efl_ui_flip_interaction_direction_enabled_get");
 993
 994         private static bool interaction_direction_enabled_get(System.IntPtr obj, System.IntPtr pd, Efl.Ui.LayoutOrientation dir)
 995         {
 996             Eina.Log.Debug("function efl_ui_flip_interaction_direction_enabled_get was called");
 997             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 998             if (ws != null)
 999             {
1000                                     bool _ret_var = default(bool);
1001                 try
1002                 {
1003                     _ret_var = ((Flip)ws.Target).GetInteractionDirectionEnabled(dir);
1004                 }
1005                 catch (Exception e)
1006                 {
1007                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1008                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1009                 }
1010
1011                         return _ret_var;
1012
1013             }
1014             else
1015             {
1016                 return efl_ui_flip_interaction_direction_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
1017             }
1018         }
1019
1020         private static efl_ui_flip_interaction_direction_enabled_get_delegate efl_ui_flip_interaction_direction_enabled_get_static_delegate;
1021
1022
1023         private delegate void efl_ui_flip_go_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.FlipMode mode);
1024
1025
1026         public delegate void efl_ui_flip_go_api_delegate(System.IntPtr obj,  Efl.Ui.FlipMode mode);
1027
1028         public static Efl.Eo.FunctionWrapper<efl_ui_flip_go_api_delegate> efl_ui_flip_go_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_go_api_delegate>(Module, "efl_ui_flip_go");
1029
1030         private static void go(System.IntPtr obj, System.IntPtr pd, Efl.Ui.FlipMode mode)
1031         {
1032             Eina.Log.Debug("function efl_ui_flip_go was called");
1033             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1034             if (ws != null)
1035             {
1036
1037                 try
1038                 {
1039                     ((Flip)ws.Target).Go(mode);
1040                 }
1041                 catch (Exception e)
1042                 {
1043                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1044                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1045                 }
1046
1047
1048             }
1049             else
1050             {
1051                 efl_ui_flip_go_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode);
1052             }
1053         }
1054
1055         private static efl_ui_flip_go_delegate efl_ui_flip_go_static_delegate;
1056
1057
1058         private delegate void efl_ui_flip_go_to_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool front,  Efl.Ui.FlipMode mode);
1059
1060
1061         public delegate void efl_ui_flip_go_to_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool front,  Efl.Ui.FlipMode mode);
1062
1063         public static Efl.Eo.FunctionWrapper<efl_ui_flip_go_to_api_delegate> efl_ui_flip_go_to_ptr = new Efl.Eo.FunctionWrapper<efl_ui_flip_go_to_api_delegate>(Module, "efl_ui_flip_go_to");
1064
1065         private static void go_to(System.IntPtr obj, System.IntPtr pd, bool front, Efl.Ui.FlipMode mode)
1066         {
1067             Eina.Log.Debug("function efl_ui_flip_go_to was called");
1068             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1069             if (ws != null)
1070             {
1071
1072                 try
1073                 {
1074                     ((Flip)ws.Target).GoTo(front, mode);
1075                 }
1076                 catch (Exception e)
1077                 {
1078                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1079                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1080                 }
1081
1082
1083             }
1084             else
1085             {
1086                 efl_ui_flip_go_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), front, mode);
1087             }
1088         }
1089
1090         private static efl_ui_flip_go_to_delegate efl_ui_flip_go_to_static_delegate;
1091
1092
1093         private delegate System.IntPtr efl_content_iterate_delegate(System.IntPtr obj, System.IntPtr pd);
1094
1095
1096         public delegate System.IntPtr efl_content_iterate_api_delegate(System.IntPtr obj);
1097
1098         public static Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate> efl_content_iterate_ptr = new Efl.Eo.FunctionWrapper<efl_content_iterate_api_delegate>(Module, "efl_content_iterate");
1099
1100         private static System.IntPtr content_iterate(System.IntPtr obj, System.IntPtr pd)
1101         {
1102             Eina.Log.Debug("function efl_content_iterate was called");
1103             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1104             if (ws != null)
1105             {
1106             Eina.Iterator<Efl.Gfx.IEntity> _ret_var = default(Eina.Iterator<Efl.Gfx.IEntity>);
1107                 try
1108                 {
1109                     _ret_var = ((Flip)ws.Target).ContentIterate();
1110                 }
1111                 catch (Exception e)
1112                 {
1113                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1114                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1115                 }
1116
1117         _ret_var.Own = false; return _ret_var.Handle;
1118
1119             }
1120             else
1121             {
1122                 return efl_content_iterate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1123             }
1124         }
1125
1126         private static efl_content_iterate_delegate efl_content_iterate_static_delegate;
1127
1128
1129         private delegate int efl_content_count_delegate(System.IntPtr obj, System.IntPtr pd);
1130
1131
1132         public delegate int efl_content_count_api_delegate(System.IntPtr obj);
1133
1134         public static Efl.Eo.FunctionWrapper<efl_content_count_api_delegate> efl_content_count_ptr = new Efl.Eo.FunctionWrapper<efl_content_count_api_delegate>(Module, "efl_content_count");
1135
1136         private static int content_count(System.IntPtr obj, System.IntPtr pd)
1137         {
1138             Eina.Log.Debug("function efl_content_count was called");
1139             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1140             if (ws != null)
1141             {
1142             int _ret_var = default(int);
1143                 try
1144                 {
1145                     _ret_var = ((Flip)ws.Target).ContentCount();
1146                 }
1147                 catch (Exception e)
1148                 {
1149                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1150                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1151                 }
1152
1153         return _ret_var;
1154
1155             }
1156             else
1157             {
1158                 return efl_content_count_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1159             }
1160         }
1161
1162         private static efl_content_count_delegate efl_content_count_static_delegate;
1163
1164         [return: MarshalAs(UnmanagedType.U1)]
1165         private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
1166
1167         [return: MarshalAs(UnmanagedType.U1)]
1168         public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
1169
1170         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");
1171
1172         private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
1173         {
1174             Eina.Log.Debug("function efl_pack_clear was called");
1175             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1176             if (ws != null)
1177             {
1178             bool _ret_var = default(bool);
1179                 try
1180                 {
1181                     _ret_var = ((Flip)ws.Target).ClearPack();
1182                 }
1183                 catch (Exception e)
1184                 {
1185                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1186                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1187                 }
1188
1189         return _ret_var;
1190
1191             }
1192             else
1193             {
1194                 return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1195             }
1196         }
1197
1198         private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
1199
1200         [return: MarshalAs(UnmanagedType.U1)]
1201         private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
1202
1203         [return: MarshalAs(UnmanagedType.U1)]
1204         public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
1205
1206         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");
1207
1208         private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
1209         {
1210             Eina.Log.Debug("function efl_pack_unpack_all was called");
1211             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1212             if (ws != null)
1213             {
1214             bool _ret_var = default(bool);
1215                 try
1216                 {
1217                     _ret_var = ((Flip)ws.Target).UnpackAll();
1218                 }
1219                 catch (Exception e)
1220                 {
1221                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1222                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1223                 }
1224
1225         return _ret_var;
1226
1227             }
1228             else
1229             {
1230                 return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1231             }
1232         }
1233
1234         private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
1235
1236         [return: MarshalAs(UnmanagedType.U1)]
1237         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);
1238
1239         [return: MarshalAs(UnmanagedType.U1)]
1240         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);
1241
1242         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");
1243
1244         private static bool unpack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1245         {
1246             Eina.Log.Debug("function efl_pack_unpack was called");
1247             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1248             if (ws != null)
1249             {
1250                                     bool _ret_var = default(bool);
1251                 try
1252                 {
1253                     _ret_var = ((Flip)ws.Target).Unpack(subobj);
1254                 }
1255                 catch (Exception e)
1256                 {
1257                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1258                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1259                 }
1260
1261                         return _ret_var;
1262
1263             }
1264             else
1265             {
1266                 return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1267             }
1268         }
1269
1270         private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
1271
1272         [return: MarshalAs(UnmanagedType.U1)]
1273         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);
1274
1275         [return: MarshalAs(UnmanagedType.U1)]
1276         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);
1277
1278         public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(Module, "efl_pack");
1279
1280         private static bool pack(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1281         {
1282             Eina.Log.Debug("function efl_pack was called");
1283             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1284             if (ws != null)
1285             {
1286                                     bool _ret_var = default(bool);
1287                 try
1288                 {
1289                     _ret_var = ((Flip)ws.Target).Pack(subobj);
1290                 }
1291                 catch (Exception e)
1292                 {
1293                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1294                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1295                 }
1296
1297                         return _ret_var;
1298
1299             }
1300             else
1301             {
1302                 return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1303             }
1304         }
1305
1306         private static efl_pack_delegate efl_pack_static_delegate;
1307
1308         [return: MarshalAs(UnmanagedType.U1)]
1309         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);
1310
1311         [return: MarshalAs(UnmanagedType.U1)]
1312         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);
1313
1314         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");
1315
1316         private static bool pack_begin(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1317         {
1318             Eina.Log.Debug("function efl_pack_begin was called");
1319             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1320             if (ws != null)
1321             {
1322                                     bool _ret_var = default(bool);
1323                 try
1324                 {
1325                     _ret_var = ((Flip)ws.Target).PackBegin(subobj);
1326                 }
1327                 catch (Exception e)
1328                 {
1329                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1330                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1331                 }
1332
1333                         return _ret_var;
1334
1335             }
1336             else
1337             {
1338                 return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1339             }
1340         }
1341
1342         private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
1343
1344         [return: MarshalAs(UnmanagedType.U1)]
1345         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);
1346
1347         [return: MarshalAs(UnmanagedType.U1)]
1348         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);
1349
1350         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");
1351
1352         private static bool pack_end(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1353         {
1354             Eina.Log.Debug("function efl_pack_end was called");
1355             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1356             if (ws != null)
1357             {
1358                                     bool _ret_var = default(bool);
1359                 try
1360                 {
1361                     _ret_var = ((Flip)ws.Target).PackEnd(subobj);
1362                 }
1363                 catch (Exception e)
1364                 {
1365                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1366                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1367                 }
1368
1369                         return _ret_var;
1370
1371             }
1372             else
1373             {
1374                 return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1375             }
1376         }
1377
1378         private static efl_pack_end_delegate efl_pack_end_static_delegate;
1379
1380         [return: MarshalAs(UnmanagedType.U1)]
1381         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);
1382
1383         [return: MarshalAs(UnmanagedType.U1)]
1384         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);
1385
1386         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");
1387
1388         private static bool pack_before(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1389         {
1390             Eina.Log.Debug("function efl_pack_before was called");
1391             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1392             if (ws != null)
1393             {
1394                                                             bool _ret_var = default(bool);
1395                 try
1396                 {
1397                     _ret_var = ((Flip)ws.Target).PackBefore(subobj, existing);
1398                 }
1399                 catch (Exception e)
1400                 {
1401                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1402                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1403                 }
1404
1405                                         return _ret_var;
1406
1407             }
1408             else
1409             {
1410                 return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1411             }
1412         }
1413
1414         private static efl_pack_before_delegate efl_pack_before_static_delegate;
1415
1416         [return: MarshalAs(UnmanagedType.U1)]
1417         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);
1418
1419         [return: MarshalAs(UnmanagedType.U1)]
1420         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);
1421
1422         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");
1423
1424         private static bool pack_after(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, Efl.Gfx.IEntity existing)
1425         {
1426             Eina.Log.Debug("function efl_pack_after was called");
1427             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1428             if (ws != null)
1429             {
1430                                                             bool _ret_var = default(bool);
1431                 try
1432                 {
1433                     _ret_var = ((Flip)ws.Target).PackAfter(subobj, existing);
1434                 }
1435                 catch (Exception e)
1436                 {
1437                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1438                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1439                 }
1440
1441                                         return _ret_var;
1442
1443             }
1444             else
1445             {
1446                 return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, existing);
1447             }
1448         }
1449
1450         private static efl_pack_after_delegate efl_pack_after_static_delegate;
1451
1452         [return: MarshalAs(UnmanagedType.U1)]
1453         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);
1454
1455         [return: MarshalAs(UnmanagedType.U1)]
1456         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);
1457
1458         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");
1459
1460         private static bool pack_at(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj, int index)
1461         {
1462             Eina.Log.Debug("function efl_pack_at was called");
1463             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1464             if (ws != null)
1465             {
1466                                                             bool _ret_var = default(bool);
1467                 try
1468                 {
1469                     _ret_var = ((Flip)ws.Target).PackAt(subobj, index);
1470                 }
1471                 catch (Exception e)
1472                 {
1473                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1474                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1475                 }
1476
1477                                         return _ret_var;
1478
1479             }
1480             else
1481             {
1482                 return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj, index);
1483             }
1484         }
1485
1486         private static efl_pack_at_delegate efl_pack_at_static_delegate;
1487
1488         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1489         private delegate Efl.Gfx.IEntity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
1490
1491         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1492         public delegate Efl.Gfx.IEntity efl_pack_content_get_api_delegate(System.IntPtr obj,  int index);
1493
1494         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");
1495
1496         private static Efl.Gfx.IEntity pack_content_get(System.IntPtr obj, System.IntPtr pd, int index)
1497         {
1498             Eina.Log.Debug("function efl_pack_content_get was called");
1499             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1500             if (ws != null)
1501             {
1502                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1503                 try
1504                 {
1505                     _ret_var = ((Flip)ws.Target).GetPackContent(index);
1506                 }
1507                 catch (Exception e)
1508                 {
1509                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1510                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1511                 }
1512
1513                         return _ret_var;
1514
1515             }
1516             else
1517             {
1518                 return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1519             }
1520         }
1521
1522         private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
1523
1524
1525         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);
1526
1527
1528         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);
1529
1530         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");
1531
1532         private static int pack_index_get(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity subobj)
1533         {
1534             Eina.Log.Debug("function efl_pack_index_get was called");
1535             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1536             if (ws != null)
1537             {
1538                                     int _ret_var = default(int);
1539                 try
1540                 {
1541                     _ret_var = ((Flip)ws.Target).GetPackIndex(subobj);
1542                 }
1543                 catch (Exception e)
1544                 {
1545                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1546                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1547                 }
1548
1549                         return _ret_var;
1550
1551             }
1552             else
1553             {
1554                 return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), subobj);
1555             }
1556         }
1557
1558         private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
1559
1560         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1561         private delegate Efl.Gfx.IEntity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,  int index);
1562
1563         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1564         public delegate Efl.Gfx.IEntity efl_pack_unpack_at_api_delegate(System.IntPtr obj,  int index);
1565
1566         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");
1567
1568         private static Efl.Gfx.IEntity pack_unpack_at(System.IntPtr obj, System.IntPtr pd, int index)
1569         {
1570             Eina.Log.Debug("function efl_pack_unpack_at was called");
1571             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1572             if (ws != null)
1573             {
1574                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1575                 try
1576                 {
1577                     _ret_var = ((Flip)ws.Target).PackUnpackAt(index);
1578                 }
1579                 catch (Exception e)
1580                 {
1581                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1582                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1583                 }
1584
1585                         return _ret_var;
1586
1587             }
1588             else
1589             {
1590                 return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), index);
1591             }
1592         }
1593
1594         private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
1595
1596         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1597
1598 }
1599 }
1600 }
1601
1602 }
1603
1604 namespace Efl {
1605
1606 namespace Ui {
1607
1608 /// <summary>Efl UI flip mode</summary>
1609 [Efl.Eo.BindingEntity]
1610 public enum FlipMode
1611 {
1612 /// <summary>Rotate Y center axis flip mode</summary>
1613 RotateYCenterAxis = 0,
1614 /// <summary>Rotate X center axis flip mode</summary>
1615 RotateXCenterAxis = 1,
1616 /// <summary>Rotate XZ center axis flip mode</summary>
1617 RotateXzCenterAxis = 2,
1618 /// <summary>Rotate YZ center axis flip mode</summary>
1619 RotateYzCenterAxis = 3,
1620 /// <summary>Cube left flip mode</summary>
1621 CubeLeft = 4,
1622 /// <summary>Cube right flip mode</summary>
1623 CubeRight = 5,
1624 /// <summary>Cube up flip mode</summary>
1625 CubeUp = 6,
1626 /// <summary>Cube down flip mode</summary>
1627 CubeDown = 7,
1628 /// <summary>Page left flip mode</summary>
1629 PageLeft = 8,
1630 /// <summary>Page right flip mode</summary>
1631 PageRight = 9,
1632 /// <summary>Page up flip mode</summary>
1633 PageUp = 10,
1634 /// <summary>Page down flip mode</summary>
1635 PageDown = 11,
1636 /// <summary>Cross fade flip mode</summary>
1637 CrossFade = 12,
1638 }
1639
1640 }
1641
1642 }
1643
1644 namespace Efl {
1645
1646 namespace Ui {
1647
1648 /// <summary>Efl UI flip interaction</summary>
1649 [Efl.Eo.BindingEntity]
1650 public enum FlipInteraction
1651 {
1652 /// <summary>No interaction</summary>
1653 None = 0,
1654 /// <summary>Rotate interaction</summary>
1655 Rotate = 1,
1656 /// <summary>Cube interaction</summary>
1657 Cube = 2,
1658 /// <summary>Page interaction</summary>
1659 Page = 3,
1660 }
1661
1662 }
1663
1664 }
1665