internals/src/EflSharp/EflSharp/efl_ui_pager.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.ComponentModel;
   7 namespace Efl { namespace Ui {
   8 /// <summary>Pager widget
   9 /// A pager contains many pages in a linear fashion and allows users to scroll through pages. Each page is numbered according to linear order and one of the pages is marked as &apos;current page&apos; and displayed in the middle. The way each page is displayed is defined by <see cref="Efl.Page.Transition"/> object, allowing users to adopt different types of transition. The most common use case of this widget is the home screen of mobile devices.</summary>
  10 [PagerNativeInherit]
  11 public class Pager : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.Pack,Efl.PackLinear
  12 {
  13    public new static System.IntPtr klass = System.IntPtr.Zero;
  14    public new static Efl.Ui.PagerNativeInherit nativeInherit = new Efl.Ui.PagerNativeInherit();
  15    ///<summary>Pointer to the native class description.</summary>
  16    public override System.IntPtr NativeClass {
  17       get {
  18          if (((object)this).GetType() == typeof (Pager))
  19             return Efl.Ui.PagerNativeInherit.GetEflClassStatic();
  20          else
  21             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  22       }
  23    }
  24    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  25       efl_ui_pager_class_get();
  26    ///<summary>Creates a new instance.</summary>
  27    ///<param name="parent">Parent instance.</param>
  28    ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  29    public Pager(Efl.Object parent
  30          ,  System.String style = null) :
  31       base(efl_ui_pager_class_get(), typeof(Pager), parent)
  32    {
  33       if (Efl.Eo.Globals.ParamHelperCheck(style))
  34          SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  35       FinishInstantiation();
  36    }
  37    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  38    public Pager(System.IntPtr raw) : base(raw)
  39    {
  40             register_event_proxies();
  41    }
  42    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  43    protected Pager(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  44    ///<summary>Casts obj into an instance of this type.</summary>
  45    public new static Pager static_cast(Efl.Object obj)
  46    {
  47       if (obj == null)
  48          throw new System.ArgumentNullException("obj");
  49       return new Pager(obj.NativeHandle);
  50    }
  51    ///<summary>Verifies if the given object is equal to this one.</summary>
  52    public override bool Equals(object obj)
  53    {
  54       var other = obj as Efl.Object;
  55       if (other == null)
  56          return false;
  57       return this.NativeHandle == other.NativeHandle;
  58    }
  59    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  60    public override int GetHashCode()
  61    {
  62       return this.NativeHandle.ToInt32();
  63    }
  64    ///<summary>Turns the native pointer into a string representation.</summary>
  65    public override String ToString()
  66    {
  67       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  68    }
  69    protected override void register_event_proxies()
  70    {
  71       base.register_event_proxies();
  72    }
  73    /// <summary>Set a page transition effect</summary>
  74    /// <param name="transition">transition effect</param>
  75    /// <returns></returns>
  76    virtual public  void SetTransition( Efl.Page.Transition transition) {
  77                          Efl.Ui.PagerNativeInherit.efl_ui_pager_transition_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), transition);
  78       Eina.Error.RaiseIfUnhandledException();
  79                    }
  80    /// <summary>Set a page indicator</summary>
  81    /// <param name="indicator">indicator class</param>
  82    /// <returns></returns>
  83    virtual public  void SetIndicator( Efl.Page.Indicator indicator) {
  84                          Efl.Ui.PagerNativeInherit.efl_ui_pager_indicator_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), indicator);
  85       Eina.Error.RaiseIfUnhandledException();
  86                    }
  87    /// <summary>Get the current page</summary>
  88    /// <returns></returns>
  89    virtual public  int GetCurrentPage() {
  90        var _ret_var = Efl.Ui.PagerNativeInherit.efl_ui_pager_current_page_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  91       Eina.Error.RaiseIfUnhandledException();
  92       return _ret_var;
  93  }
  94    /// <summary>Set one page as current page</summary>
  95    /// <param name="index"></param>
  96    /// <returns></returns>
  97    virtual public  void SetCurrentPage(  int index) {
  98                          Efl.Ui.PagerNativeInherit.efl_ui_pager_current_page_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), index);
  99       Eina.Error.RaiseIfUnhandledException();
 100                    }
 101    /// <summary>Pages can be scrolled back and forth by default. This property allows limiting the direction of scrolling, or blocking scroll gesture at all.</summary>
 102    /// <param name="prev"></param>
 103    /// <param name="next"></param>
 104    /// <returns></returns>
 105    virtual public  void GetScrollBlock( out bool prev,  out bool next) {
 106                                            Efl.Ui.PagerNativeInherit.efl_ui_pager_scroll_block_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out prev,  out next);
 107       Eina.Error.RaiseIfUnhandledException();
 108                                }
 109    /// <summary>Pages can be scrolled back and forth by default. This property allows limiting the direction of scrolling, or blocking scroll gesture at all.</summary>
 110    /// <param name="prev"></param>
 111    /// <param name="next"></param>
 112    /// <returns></returns>
 113    virtual public  void SetScrollBlock( bool prev,  bool next) {
 114                                            Efl.Ui.PagerNativeInherit.efl_ui_pager_scroll_block_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), prev,  next);
 115       Eina.Error.RaiseIfUnhandledException();
 116                                }
 117    /// <summary>Pager is not scrolled after it&apos;s scrolled to the end by default. This property gives the option to make a loop through pages.</summary>
 118    /// <returns></returns>
 119    virtual public Efl.Ui.PagerLoop GetLoopMode() {
 120        var _ret_var = Efl.Ui.PagerNativeInherit.efl_ui_pager_loop_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 121       Eina.Error.RaiseIfUnhandledException();
 122       return _ret_var;
 123  }
 124    /// <summary>Pager is not scrolled after it&apos;s scrolled to the end by default. This property gives the option to make a loop through pages.</summary>
 125    /// <param name="loop"></param>
 126    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 127    virtual public bool SetLoopMode( Efl.Ui.PagerLoop loop) {
 128                          var _ret_var = Efl.Ui.PagerNativeInherit.efl_ui_pager_loop_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), loop);
 129       Eina.Error.RaiseIfUnhandledException();
 130                   return _ret_var;
 131  }
 132    /// <summary></summary>
 133    /// <returns></returns>
 134    virtual public Eina.Size2D GetPageSize() {
 135        var _ret_var = Efl.Ui.PagerNativeInherit.efl_ui_pager_page_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 136       Eina.Error.RaiseIfUnhandledException();
 137       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
 138  }
 139    /// <summary></summary>
 140    /// <param name="size"></param>
 141    /// <returns></returns>
 142    virtual public  void SetPageSize( Eina.Size2D size) {
 143        var _in_size = Eina.Size2D_StructConversion.ToInternal(size);
 144                   Efl.Ui.PagerNativeInherit.efl_ui_pager_page_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_size);
 145       Eina.Error.RaiseIfUnhandledException();
 146                    }
 147    /// <summary></summary>
 148    /// <returns></returns>
 149    virtual public  int GetPadding() {
 150        var _ret_var = Efl.Ui.PagerNativeInherit.efl_ui_pager_padding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 151       Eina.Error.RaiseIfUnhandledException();
 152       return _ret_var;
 153  }
 154    /// <summary></summary>
 155    /// <param name="padding"></param>
 156    /// <returns></returns>
 157    virtual public  void SetPadding(  int padding) {
 158                          Efl.Ui.PagerNativeInherit.efl_ui_pager_padding_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), padding);
 159       Eina.Error.RaiseIfUnhandledException();
 160                    }
 161    /// <summary>Alignment of the container within its bounds</summary>
 162    /// <param name="align_horiz">Horizontal alignment</param>
 163    /// <param name="align_vert">Vertical alignment</param>
 164    /// <returns></returns>
 165    virtual public  void GetPackAlign( out double align_horiz,  out double align_vert) {
 166                                            Efl.PackNativeInherit.efl_pack_align_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out align_horiz,  out align_vert);
 167       Eina.Error.RaiseIfUnhandledException();
 168                                }
 169    /// <summary>Alignment of the container within its bounds</summary>
 170    /// <param name="align_horiz">Horizontal alignment</param>
 171    /// <param name="align_vert">Vertical alignment</param>
 172    /// <returns></returns>
 173    virtual public  void SetPackAlign( double align_horiz,  double align_vert) {
 174                                            Efl.PackNativeInherit.efl_pack_align_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), align_horiz,  align_vert);
 175       Eina.Error.RaiseIfUnhandledException();
 176                                }
 177    /// <summary>Padding between items contained in this object.</summary>
 178    /// <param name="pad_horiz">Horizontal padding</param>
 179    /// <param name="pad_vert">Vertical padding</param>
 180    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 181    /// <returns></returns>
 182    virtual public  void GetPackPadding( out double pad_horiz,  out double pad_vert,  out bool scalable) {
 183                                                              Efl.PackNativeInherit.efl_pack_padding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out pad_horiz,  out pad_vert,  out scalable);
 184       Eina.Error.RaiseIfUnhandledException();
 185                                            }
 186    /// <summary>Padding between items contained in this object.</summary>
 187    /// <param name="pad_horiz">Horizontal padding</param>
 188    /// <param name="pad_vert">Vertical padding</param>
 189    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
 190    /// <returns></returns>
 191    virtual public  void SetPackPadding( double pad_horiz,  double pad_vert,  bool scalable) {
 192                                                              Efl.PackNativeInherit.efl_pack_padding_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), pad_horiz,  pad_vert,  scalable);
 193       Eina.Error.RaiseIfUnhandledException();
 194                                            }
 195    /// <summary>Removes all packed contents, and unreferences them.</summary>
 196    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 197    virtual public bool ClearPack() {
 198        var _ret_var = Efl.PackNativeInherit.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 199       Eina.Error.RaiseIfUnhandledException();
 200       return _ret_var;
 201  }
 202    /// <summary>Removes all packed contents, without unreferencing them.
 203    /// Use with caution.</summary>
 204    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 205    virtual public bool UnpackAll() {
 206        var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 207       Eina.Error.RaiseIfUnhandledException();
 208       return _ret_var;
 209  }
 210    /// <summary>Removes an existing item from the container, without deleting it.</summary>
 211    /// <param name="subobj">The unpacked object.</param>
 212    /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t a child or can&apos;t be removed</returns>
 213    virtual public bool Unpack( Efl.Gfx.Entity subobj) {
 214                          var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 215       Eina.Error.RaiseIfUnhandledException();
 216                   return _ret_var;
 217  }
 218    /// <summary>Adds an item to this container.
 219    /// 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.
 220    ///
 221    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 222    /// <param name="subobj">An object to pack.</param>
 223    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 224    virtual public bool DoPack( Efl.Gfx.Entity subobj) {
 225                          var _ret_var = Efl.PackNativeInherit.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 226       Eina.Error.RaiseIfUnhandledException();
 227                   return _ret_var;
 228  }
 229    /// <summary>Prepend an object at the beginning of this container.
 230    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, 0).
 231    ///
 232    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 233    /// <param name="subobj">Item to pack.</param>
 234    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
 235    virtual public bool PackBegin( Efl.Gfx.Entity subobj) {
 236                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_begin_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 237       Eina.Error.RaiseIfUnhandledException();
 238                   return _ret_var;
 239  }
 240    /// <summary>Append object at the end of this container.
 241    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, -1).
 242    ///
 243    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 244    /// <param name="subobj">Item to pack at the end.</param>
 245    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
 246    virtual public bool PackEnd( Efl.Gfx.Entity subobj) {
 247                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 248       Eina.Error.RaiseIfUnhandledException();
 249                   return _ret_var;
 250  }
 251    /// <summary>Prepend item before other sub object.
 252    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 253    /// <param name="subobj">Item to pack before <c>existing</c>.</param>
 254    /// <param name="existing">Item to refer to.</param>
 255    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 256    virtual public bool PackBefore( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
 257                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_before_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  existing);
 258       Eina.Error.RaiseIfUnhandledException();
 259                               return _ret_var;
 260  }
 261    /// <summary>Append item after other sub object.
 262    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 263    /// <param name="subobj">Item to pack after <c>existing</c>.</param>
 264    /// <param name="existing">Item to refer to.</param>
 265    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
 266    virtual public bool PackAfter( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
 267                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_after_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  existing);
 268       Eina.Error.RaiseIfUnhandledException();
 269                               return _ret_var;
 270  }
 271    /// <summary>Inserts <c>subobj</c> at the specified <c>index</c>.
 272    /// Valid range: -<c>count</c> to +<c>count</c>. -1 refers to the last element. Out of range indices will trigger an append.
 273    ///
 274    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
 275    /// <param name="subobj">Item to pack at given index.</param>
 276    /// <param name="index">A position.</param>
 277    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
 278    virtual public bool PackAt( Efl.Gfx.Entity subobj,   int index) {
 279                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  index);
 280       Eina.Error.RaiseIfUnhandledException();
 281                               return _ret_var;
 282  }
 283    /// <summary>Content at a given index in this container.
 284    /// Index -1 refers to the last item. The valid range is -(count - 1) to (count - 1).</summary>
 285    /// <param name="index">Index number</param>
 286    /// <returns>The object contained at the given <c>index</c>.</returns>
 287    virtual public Efl.Gfx.Entity GetPackContent(  int index) {
 288                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), index);
 289       Eina.Error.RaiseIfUnhandledException();
 290                   return _ret_var;
 291  }
 292    /// <summary>Get the index of a child in this container.</summary>
 293    /// <param name="subobj">An object contained in this pack.</param>
 294    /// <returns>-1 in case of failure, or the index of this item.</returns>
 295    virtual public  int GetPackIndex( Efl.Gfx.Entity subobj) {
 296                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
 297       Eina.Error.RaiseIfUnhandledException();
 298                   return _ret_var;
 299  }
 300    /// <summary>Pop out item at specified <c>index</c>.
 301    /// Equivalent to unpack(content_at(<c>index</c>)).</summary>
 302    /// <param name="index">Index number</param>
 303    /// <returns>The child item if it could be removed.</returns>
 304    virtual public Efl.Gfx.Entity PackUnpackAt(  int index) {
 305                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_unpack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), index);
 306       Eina.Error.RaiseIfUnhandledException();
 307                   return _ret_var;
 308  }
 309    /// <summary>Page transition effect
 310 /// Page transition is in charge of displaying pages in a specific way and invoked every time page layout needs to be updated.</summary>
 311 /// <value>transition effect</value>
 312    public Efl.Page.Transition Transition {
 313       set { SetTransition( value); }
 314    }
 315    /// <summary>Page indicator
 316 /// Page indicator, located on the top layer of pager widget, helps users to know the number of pages and the current page&apos;s index without scrolling.</summary>
 317 /// <value>indicator class</value>
 318    public Efl.Page.Indicator Indicator {
 319       set { SetIndicator( value); }
 320    }
 321    /// <summary>One page is selected as the current page and mainly displayed.</summary>
 322 /// <value></value>
 323    public  int CurrentPage {
 324       get { return GetCurrentPage(); }
 325       set { SetCurrentPage( value); }
 326    }
 327    /// <summary>Pager is not scrolled after it&apos;s scrolled to the end by default. This property gives the option to make a loop through pages.</summary>
 328 /// <value></value>
 329    public Efl.Ui.PagerLoop LoopMode {
 330       get { return GetLoopMode(); }
 331       set { SetLoopMode( value); }
 332    }
 333    /// <summary></summary>
 334 /// <value></value>
 335    public Eina.Size2D PageSize {
 336       get { return GetPageSize(); }
 337       set { SetPageSize( value); }
 338    }
 339    /// <summary></summary>
 340 /// <value></value>
 341    public  int Padding {
 342       get { return GetPadding(); }
 343       set { SetPadding( value); }
 344    }
 345    private static new  IntPtr GetEflClassStatic()
 346    {
 347       return Efl.Ui.Pager.efl_ui_pager_class_get();
 348    }
 349 }
 350 public class PagerNativeInherit : Efl.Ui.LayoutBaseNativeInherit{
 351    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
 352    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 353    {
 354       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 355       if (efl_ui_pager_transition_set_static_delegate == null)
 356       efl_ui_pager_transition_set_static_delegate = new efl_ui_pager_transition_set_delegate(transition_set);
 357       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_transition_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_transition_set_static_delegate)});
 358       if (efl_ui_pager_indicator_set_static_delegate == null)
 359       efl_ui_pager_indicator_set_static_delegate = new efl_ui_pager_indicator_set_delegate(indicator_set);
 360       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_indicator_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_indicator_set_static_delegate)});
 361       if (efl_ui_pager_current_page_get_static_delegate == null)
 362       efl_ui_pager_current_page_get_static_delegate = new efl_ui_pager_current_page_get_delegate(current_page_get);
 363       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_current_page_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_current_page_get_static_delegate)});
 364       if (efl_ui_pager_current_page_set_static_delegate == null)
 365       efl_ui_pager_current_page_set_static_delegate = new efl_ui_pager_current_page_set_delegate(current_page_set);
 366       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_current_page_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_current_page_set_static_delegate)});
 367       if (efl_ui_pager_scroll_block_get_static_delegate == null)
 368       efl_ui_pager_scroll_block_get_static_delegate = new efl_ui_pager_scroll_block_get_delegate(scroll_block_get);
 369       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_scroll_block_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_scroll_block_get_static_delegate)});
 370       if (efl_ui_pager_scroll_block_set_static_delegate == null)
 371       efl_ui_pager_scroll_block_set_static_delegate = new efl_ui_pager_scroll_block_set_delegate(scroll_block_set);
 372       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_scroll_block_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_scroll_block_set_static_delegate)});
 373       if (efl_ui_pager_loop_mode_get_static_delegate == null)
 374       efl_ui_pager_loop_mode_get_static_delegate = new efl_ui_pager_loop_mode_get_delegate(loop_mode_get);
 375       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_loop_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_loop_mode_get_static_delegate)});
 376       if (efl_ui_pager_loop_mode_set_static_delegate == null)
 377       efl_ui_pager_loop_mode_set_static_delegate = new efl_ui_pager_loop_mode_set_delegate(loop_mode_set);
 378       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_loop_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_loop_mode_set_static_delegate)});
 379       if (efl_ui_pager_page_size_get_static_delegate == null)
 380       efl_ui_pager_page_size_get_static_delegate = new efl_ui_pager_page_size_get_delegate(page_size_get);
 381       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_page_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_page_size_get_static_delegate)});
 382       if (efl_ui_pager_page_size_set_static_delegate == null)
 383       efl_ui_pager_page_size_set_static_delegate = new efl_ui_pager_page_size_set_delegate(page_size_set);
 384       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_page_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_page_size_set_static_delegate)});
 385       if (efl_ui_pager_padding_get_static_delegate == null)
 386       efl_ui_pager_padding_get_static_delegate = new efl_ui_pager_padding_get_delegate(padding_get);
 387       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_padding_get_static_delegate)});
 388       if (efl_ui_pager_padding_set_static_delegate == null)
 389       efl_ui_pager_padding_set_static_delegate = new efl_ui_pager_padding_set_delegate(padding_set);
 390       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_pager_padding_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_pager_padding_set_static_delegate)});
 391       if (efl_pack_align_get_static_delegate == null)
 392       efl_pack_align_get_static_delegate = new efl_pack_align_get_delegate(pack_align_get);
 393       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_align_get_static_delegate)});
 394       if (efl_pack_align_set_static_delegate == null)
 395       efl_pack_align_set_static_delegate = new efl_pack_align_set_delegate(pack_align_set);
 396       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_align_set_static_delegate)});
 397       if (efl_pack_padding_get_static_delegate == null)
 398       efl_pack_padding_get_static_delegate = new efl_pack_padding_get_delegate(pack_padding_get);
 399       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_padding_get_static_delegate)});
 400       if (efl_pack_padding_set_static_delegate == null)
 401       efl_pack_padding_set_static_delegate = new efl_pack_padding_set_delegate(pack_padding_set);
 402       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_padding_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_padding_set_static_delegate)});
 403       if (efl_pack_clear_static_delegate == null)
 404       efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
 405       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)});
 406       if (efl_pack_unpack_all_static_delegate == null)
 407       efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
 408       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)});
 409       if (efl_pack_unpack_static_delegate == null)
 410       efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
 411       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)});
 412       if (efl_pack_static_delegate == null)
 413       efl_pack_static_delegate = new efl_pack_delegate(pack);
 414       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate)});
 415       if (efl_pack_begin_static_delegate == null)
 416       efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
 417       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)});
 418       if (efl_pack_end_static_delegate == null)
 419       efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
 420       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)});
 421       if (efl_pack_before_static_delegate == null)
 422       efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
 423       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)});
 424       if (efl_pack_after_static_delegate == null)
 425       efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
 426       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)});
 427       if (efl_pack_at_static_delegate == null)
 428       efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
 429       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)});
 430       if (efl_pack_content_get_static_delegate == null)
 431       efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
 432       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)});
 433       if (efl_pack_index_get_static_delegate == null)
 434       efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
 435       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)});
 436       if (efl_pack_unpack_at_static_delegate == null)
 437       efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
 438       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)});
 439       descs.AddRange(base.GetEoOps(type));
 440       return descs;
 441    }
 442    public override IntPtr GetEflClass()
 443    {
 444       return Efl.Ui.Pager.efl_ui_pager_class_get();
 445    }
 446    public static new  IntPtr GetEflClassStatic()
 447    {
 448       return Efl.Ui.Pager.efl_ui_pager_class_get();
 449    }
 450
 451
 452     private delegate  void efl_ui_pager_transition_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Page.Transition, Efl.Eo.NonOwnTag>))]  Efl.Page.Transition transition);
 453
 454
 455     public delegate  void efl_ui_pager_transition_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Page.Transition, Efl.Eo.NonOwnTag>))]  Efl.Page.Transition transition);
 456     public static Efl.Eo.FunctionWrapper<efl_ui_pager_transition_set_api_delegate> efl_ui_pager_transition_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_transition_set_api_delegate>(_Module, "efl_ui_pager_transition_set");
 457     private static  void transition_set(System.IntPtr obj, System.IntPtr pd,  Efl.Page.Transition transition)
 458    {
 459       Eina.Log.Debug("function efl_ui_pager_transition_set was called");
 460       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 461       if(wrapper != null) {
 462
 463          try {
 464             ((Pager)wrapper).SetTransition( transition);
 465          } catch (Exception e) {
 466             Eina.Log.Warning($"Callback error: {e.ToString()}");
 467             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 468          }
 469                         } else {
 470          efl_ui_pager_transition_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  transition);
 471       }
 472    }
 473    private static efl_ui_pager_transition_set_delegate efl_ui_pager_transition_set_static_delegate;
 474
 475
 476     private delegate  void efl_ui_pager_indicator_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Page.Indicator, Efl.Eo.NonOwnTag>))]  Efl.Page.Indicator indicator);
 477
 478
 479     public delegate  void efl_ui_pager_indicator_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Page.Indicator, Efl.Eo.NonOwnTag>))]  Efl.Page.Indicator indicator);
 480     public static Efl.Eo.FunctionWrapper<efl_ui_pager_indicator_set_api_delegate> efl_ui_pager_indicator_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_indicator_set_api_delegate>(_Module, "efl_ui_pager_indicator_set");
 481     private static  void indicator_set(System.IntPtr obj, System.IntPtr pd,  Efl.Page.Indicator indicator)
 482    {
 483       Eina.Log.Debug("function efl_ui_pager_indicator_set was called");
 484       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 485       if(wrapper != null) {
 486
 487          try {
 488             ((Pager)wrapper).SetIndicator( indicator);
 489          } catch (Exception e) {
 490             Eina.Log.Warning($"Callback error: {e.ToString()}");
 491             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 492          }
 493                         } else {
 494          efl_ui_pager_indicator_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  indicator);
 495       }
 496    }
 497    private static efl_ui_pager_indicator_set_delegate efl_ui_pager_indicator_set_static_delegate;
 498
 499
 500     private delegate  int efl_ui_pager_current_page_get_delegate(System.IntPtr obj, System.IntPtr pd);
 501
 502
 503     public delegate  int efl_ui_pager_current_page_get_api_delegate(System.IntPtr obj);
 504     public static Efl.Eo.FunctionWrapper<efl_ui_pager_current_page_get_api_delegate> efl_ui_pager_current_page_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_current_page_get_api_delegate>(_Module, "efl_ui_pager_current_page_get");
 505     private static  int current_page_get(System.IntPtr obj, System.IntPtr pd)
 506    {
 507       Eina.Log.Debug("function efl_ui_pager_current_page_get was called");
 508       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 509       if(wrapper != null) {
 510                    int _ret_var = default( int);
 511          try {
 512             _ret_var = ((Pager)wrapper).GetCurrentPage();
 513          } catch (Exception e) {
 514             Eina.Log.Warning($"Callback error: {e.ToString()}");
 515             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 516          }
 517       return _ret_var;
 518       } else {
 519          return efl_ui_pager_current_page_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 520       }
 521    }
 522    private static efl_ui_pager_current_page_get_delegate efl_ui_pager_current_page_get_static_delegate;
 523
 524
 525     private delegate  void efl_ui_pager_current_page_set_delegate(System.IntPtr obj, System.IntPtr pd,    int index);
 526
 527
 528     public delegate  void efl_ui_pager_current_page_set_api_delegate(System.IntPtr obj,    int index);
 529     public static Efl.Eo.FunctionWrapper<efl_ui_pager_current_page_set_api_delegate> efl_ui_pager_current_page_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_current_page_set_api_delegate>(_Module, "efl_ui_pager_current_page_set");
 530     private static  void current_page_set(System.IntPtr obj, System.IntPtr pd,   int index)
 531    {
 532       Eina.Log.Debug("function efl_ui_pager_current_page_set was called");
 533       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 534       if(wrapper != null) {
 535
 536          try {
 537             ((Pager)wrapper).SetCurrentPage( index);
 538          } catch (Exception e) {
 539             Eina.Log.Warning($"Callback error: {e.ToString()}");
 540             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 541          }
 542                         } else {
 543          efl_ui_pager_current_page_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
 544       }
 545    }
 546    private static efl_ui_pager_current_page_set_delegate efl_ui_pager_current_page_set_static_delegate;
 547
 548
 549     private delegate  void efl_ui_pager_scroll_block_get_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  out bool prev,  [MarshalAs(UnmanagedType.U1)]  out bool next);
 550
 551
 552     public delegate  void efl_ui_pager_scroll_block_get_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  out bool prev,  [MarshalAs(UnmanagedType.U1)]  out bool next);
 553     public static Efl.Eo.FunctionWrapper<efl_ui_pager_scroll_block_get_api_delegate> efl_ui_pager_scroll_block_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_scroll_block_get_api_delegate>(_Module, "efl_ui_pager_scroll_block_get");
 554     private static  void scroll_block_get(System.IntPtr obj, System.IntPtr pd,  out bool prev,  out bool next)
 555    {
 556       Eina.Log.Debug("function efl_ui_pager_scroll_block_get was called");
 557       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 558       if(wrapper != null) {
 559                            prev = default(bool);      next = default(bool);
 560          try {
 561             ((Pager)wrapper).GetScrollBlock( out prev,  out next);
 562          } catch (Exception e) {
 563             Eina.Log.Warning($"Callback error: {e.ToString()}");
 564             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 565          }
 566                                     } else {
 567          efl_ui_pager_scroll_block_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out prev,  out next);
 568       }
 569    }
 570    private static efl_ui_pager_scroll_block_get_delegate efl_ui_pager_scroll_block_get_static_delegate;
 571
 572
 573     private delegate  void efl_ui_pager_scroll_block_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool prev,  [MarshalAs(UnmanagedType.U1)]  bool next);
 574
 575
 576     public delegate  void efl_ui_pager_scroll_block_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool prev,  [MarshalAs(UnmanagedType.U1)]  bool next);
 577     public static Efl.Eo.FunctionWrapper<efl_ui_pager_scroll_block_set_api_delegate> efl_ui_pager_scroll_block_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_scroll_block_set_api_delegate>(_Module, "efl_ui_pager_scroll_block_set");
 578     private static  void scroll_block_set(System.IntPtr obj, System.IntPtr pd,  bool prev,  bool next)
 579    {
 580       Eina.Log.Debug("function efl_ui_pager_scroll_block_set was called");
 581       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 582       if(wrapper != null) {
 583
 584          try {
 585             ((Pager)wrapper).SetScrollBlock( prev,  next);
 586          } catch (Exception e) {
 587             Eina.Log.Warning($"Callback error: {e.ToString()}");
 588             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 589          }
 590                                     } else {
 591          efl_ui_pager_scroll_block_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  prev,  next);
 592       }
 593    }
 594    private static efl_ui_pager_scroll_block_set_delegate efl_ui_pager_scroll_block_set_static_delegate;
 595
 596
 597     private delegate Efl.Ui.PagerLoop efl_ui_pager_loop_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 598
 599
 600     public delegate Efl.Ui.PagerLoop efl_ui_pager_loop_mode_get_api_delegate(System.IntPtr obj);
 601     public static Efl.Eo.FunctionWrapper<efl_ui_pager_loop_mode_get_api_delegate> efl_ui_pager_loop_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_loop_mode_get_api_delegate>(_Module, "efl_ui_pager_loop_mode_get");
 602     private static Efl.Ui.PagerLoop loop_mode_get(System.IntPtr obj, System.IntPtr pd)
 603    {
 604       Eina.Log.Debug("function efl_ui_pager_loop_mode_get was called");
 605       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 606       if(wrapper != null) {
 607                   Efl.Ui.PagerLoop _ret_var = default(Efl.Ui.PagerLoop);
 608          try {
 609             _ret_var = ((Pager)wrapper).GetLoopMode();
 610          } catch (Exception e) {
 611             Eina.Log.Warning($"Callback error: {e.ToString()}");
 612             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 613          }
 614       return _ret_var;
 615       } else {
 616          return efl_ui_pager_loop_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 617       }
 618    }
 619    private static efl_ui_pager_loop_mode_get_delegate efl_ui_pager_loop_mode_get_static_delegate;
 620
 621
 622     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_pager_loop_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.PagerLoop loop);
 623
 624
 625     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_pager_loop_mode_set_api_delegate(System.IntPtr obj,   Efl.Ui.PagerLoop loop);
 626     public static Efl.Eo.FunctionWrapper<efl_ui_pager_loop_mode_set_api_delegate> efl_ui_pager_loop_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_loop_mode_set_api_delegate>(_Module, "efl_ui_pager_loop_mode_set");
 627     private static bool loop_mode_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.PagerLoop loop)
 628    {
 629       Eina.Log.Debug("function efl_ui_pager_loop_mode_set was called");
 630       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 631       if(wrapper != null) {
 632                                     bool _ret_var = default(bool);
 633          try {
 634             _ret_var = ((Pager)wrapper).SetLoopMode( loop);
 635          } catch (Exception e) {
 636             Eina.Log.Warning($"Callback error: {e.ToString()}");
 637             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 638          }
 639                   return _ret_var;
 640       } else {
 641          return efl_ui_pager_loop_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  loop);
 642       }
 643    }
 644    private static efl_ui_pager_loop_mode_set_delegate efl_ui_pager_loop_mode_set_static_delegate;
 645
 646
 647     private delegate Eina.Size2D_StructInternal efl_ui_pager_page_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 648
 649
 650     public delegate Eina.Size2D_StructInternal efl_ui_pager_page_size_get_api_delegate(System.IntPtr obj);
 651     public static Efl.Eo.FunctionWrapper<efl_ui_pager_page_size_get_api_delegate> efl_ui_pager_page_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_page_size_get_api_delegate>(_Module, "efl_ui_pager_page_size_get");
 652     private static Eina.Size2D_StructInternal page_size_get(System.IntPtr obj, System.IntPtr pd)
 653    {
 654       Eina.Log.Debug("function efl_ui_pager_page_size_get was called");
 655       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 656       if(wrapper != null) {
 657                   Eina.Size2D _ret_var = default(Eina.Size2D);
 658          try {
 659             _ret_var = ((Pager)wrapper).GetPageSize();
 660          } catch (Exception e) {
 661             Eina.Log.Warning($"Callback error: {e.ToString()}");
 662             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 663          }
 664       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
 665       } else {
 666          return efl_ui_pager_page_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 667       }
 668    }
 669    private static efl_ui_pager_page_size_get_delegate efl_ui_pager_page_size_get_static_delegate;
 670
 671
 672     private delegate  void efl_ui_pager_page_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal size);
 673
 674
 675     public delegate  void efl_ui_pager_page_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal size);
 676     public static Efl.Eo.FunctionWrapper<efl_ui_pager_page_size_set_api_delegate> efl_ui_pager_page_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_page_size_set_api_delegate>(_Module, "efl_ui_pager_page_size_set");
 677     private static  void page_size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal size)
 678    {
 679       Eina.Log.Debug("function efl_ui_pager_page_size_set was called");
 680       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 681       if(wrapper != null) {
 682                var _in_size = Eina.Size2D_StructConversion.ToManaged(size);
 683
 684          try {
 685             ((Pager)wrapper).SetPageSize( _in_size);
 686          } catch (Exception e) {
 687             Eina.Log.Warning($"Callback error: {e.ToString()}");
 688             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 689          }
 690                         } else {
 691          efl_ui_pager_page_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size);
 692       }
 693    }
 694    private static efl_ui_pager_page_size_set_delegate efl_ui_pager_page_size_set_static_delegate;
 695
 696
 697     private delegate  int efl_ui_pager_padding_get_delegate(System.IntPtr obj, System.IntPtr pd);
 698
 699
 700     public delegate  int efl_ui_pager_padding_get_api_delegate(System.IntPtr obj);
 701     public static Efl.Eo.FunctionWrapper<efl_ui_pager_padding_get_api_delegate> efl_ui_pager_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_padding_get_api_delegate>(_Module, "efl_ui_pager_padding_get");
 702     private static  int padding_get(System.IntPtr obj, System.IntPtr pd)
 703    {
 704       Eina.Log.Debug("function efl_ui_pager_padding_get was called");
 705       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 706       if(wrapper != null) {
 707                    int _ret_var = default( int);
 708          try {
 709             _ret_var = ((Pager)wrapper).GetPadding();
 710          } catch (Exception e) {
 711             Eina.Log.Warning($"Callback error: {e.ToString()}");
 712             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 713          }
 714       return _ret_var;
 715       } else {
 716          return efl_ui_pager_padding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 717       }
 718    }
 719    private static efl_ui_pager_padding_get_delegate efl_ui_pager_padding_get_static_delegate;
 720
 721
 722     private delegate  void efl_ui_pager_padding_set_delegate(System.IntPtr obj, System.IntPtr pd,    int padding);
 723
 724
 725     public delegate  void efl_ui_pager_padding_set_api_delegate(System.IntPtr obj,    int padding);
 726     public static Efl.Eo.FunctionWrapper<efl_ui_pager_padding_set_api_delegate> efl_ui_pager_padding_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_pager_padding_set_api_delegate>(_Module, "efl_ui_pager_padding_set");
 727     private static  void padding_set(System.IntPtr obj, System.IntPtr pd,   int padding)
 728    {
 729       Eina.Log.Debug("function efl_ui_pager_padding_set was called");
 730       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 731       if(wrapper != null) {
 732
 733          try {
 734             ((Pager)wrapper).SetPadding( padding);
 735          } catch (Exception e) {
 736             Eina.Log.Warning($"Callback error: {e.ToString()}");
 737             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 738          }
 739                         } else {
 740          efl_ui_pager_padding_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  padding);
 741       }
 742    }
 743    private static efl_ui_pager_padding_set_delegate efl_ui_pager_padding_set_static_delegate;
 744
 745
 746     private delegate  void efl_pack_align_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double align_horiz,   out double align_vert);
 747
 748
 749     public delegate  void efl_pack_align_get_api_delegate(System.IntPtr obj,   out double align_horiz,   out double align_vert);
 750     public static Efl.Eo.FunctionWrapper<efl_pack_align_get_api_delegate> efl_pack_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_align_get_api_delegate>(_Module, "efl_pack_align_get");
 751     private static  void pack_align_get(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert)
 752    {
 753       Eina.Log.Debug("function efl_pack_align_get was called");
 754       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 755       if(wrapper != null) {
 756                            align_horiz = default(double);      align_vert = default(double);
 757          try {
 758             ((Pager)wrapper).GetPackAlign( out align_horiz,  out align_vert);
 759          } catch (Exception e) {
 760             Eina.Log.Warning($"Callback error: {e.ToString()}");
 761             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 762          }
 763                                     } else {
 764          efl_pack_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out align_horiz,  out align_vert);
 765       }
 766    }
 767    private static efl_pack_align_get_delegate efl_pack_align_get_static_delegate;
 768
 769
 770     private delegate  void efl_pack_align_set_delegate(System.IntPtr obj, System.IntPtr pd,   double align_horiz,   double align_vert);
 771
 772
 773     public delegate  void efl_pack_align_set_api_delegate(System.IntPtr obj,   double align_horiz,   double align_vert);
 774     public static Efl.Eo.FunctionWrapper<efl_pack_align_set_api_delegate> efl_pack_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_align_set_api_delegate>(_Module, "efl_pack_align_set");
 775     private static  void pack_align_set(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert)
 776    {
 777       Eina.Log.Debug("function efl_pack_align_set was called");
 778       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 779       if(wrapper != null) {
 780
 781          try {
 782             ((Pager)wrapper).SetPackAlign( align_horiz,  align_vert);
 783          } catch (Exception e) {
 784             Eina.Log.Warning($"Callback error: {e.ToString()}");
 785             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 786          }
 787                                     } else {
 788          efl_pack_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  align_horiz,  align_vert);
 789       }
 790    }
 791    private static efl_pack_align_set_delegate efl_pack_align_set_static_delegate;
 792
 793
 794     private delegate  void efl_pack_padding_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double pad_horiz,   out double pad_vert,  [MarshalAs(UnmanagedType.U1)]  out bool scalable);
 795
 796
 797     public delegate  void efl_pack_padding_get_api_delegate(System.IntPtr obj,   out double pad_horiz,   out double pad_vert,  [MarshalAs(UnmanagedType.U1)]  out bool scalable);
 798     public static Efl.Eo.FunctionWrapper<efl_pack_padding_get_api_delegate> efl_pack_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_padding_get_api_delegate>(_Module, "efl_pack_padding_get");
 799     private static  void pack_padding_get(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert,  out bool scalable)
 800    {
 801       Eina.Log.Debug("function efl_pack_padding_get was called");
 802       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 803       if(wrapper != null) {
 804                                  pad_horiz = default(double);      pad_vert = default(double);      scalable = default(bool);
 805          try {
 806             ((Pager)wrapper).GetPackPadding( out pad_horiz,  out pad_vert,  out scalable);
 807          } catch (Exception e) {
 808             Eina.Log.Warning($"Callback error: {e.ToString()}");
 809             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 810          }
 811                                                 } else {
 812          efl_pack_padding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out pad_horiz,  out pad_vert,  out scalable);
 813       }
 814    }
 815    private static efl_pack_padding_get_delegate efl_pack_padding_get_static_delegate;
 816
 817
 818     private delegate  void efl_pack_padding_set_delegate(System.IntPtr obj, System.IntPtr pd,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
 819
 820
 821     public delegate  void efl_pack_padding_set_api_delegate(System.IntPtr obj,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
 822     public static Efl.Eo.FunctionWrapper<efl_pack_padding_set_api_delegate> efl_pack_padding_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_padding_set_api_delegate>(_Module, "efl_pack_padding_set");
 823     private static  void pack_padding_set(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert,  bool scalable)
 824    {
 825       Eina.Log.Debug("function efl_pack_padding_set was called");
 826       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 827       if(wrapper != null) {
 828
 829          try {
 830             ((Pager)wrapper).SetPackPadding( pad_horiz,  pad_vert,  scalable);
 831          } catch (Exception e) {
 832             Eina.Log.Warning($"Callback error: {e.ToString()}");
 833             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 834          }
 835                                                 } else {
 836          efl_pack_padding_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  pad_horiz,  pad_vert,  scalable);
 837       }
 838    }
 839    private static efl_pack_padding_set_delegate efl_pack_padding_set_static_delegate;
 840
 841
 842     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
 843
 844
 845     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
 846     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");
 847     private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
 848    {
 849       Eina.Log.Debug("function efl_pack_clear was called");
 850       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 851       if(wrapper != null) {
 852                   bool _ret_var = default(bool);
 853          try {
 854             _ret_var = ((Pager)wrapper).ClearPack();
 855          } catch (Exception e) {
 856             Eina.Log.Warning($"Callback error: {e.ToString()}");
 857             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 858          }
 859       return _ret_var;
 860       } else {
 861          return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 862       }
 863    }
 864    private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
 865
 866
 867     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
 868
 869
 870     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
 871     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");
 872     private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
 873    {
 874       Eina.Log.Debug("function efl_pack_unpack_all was called");
 875       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 876       if(wrapper != null) {
 877                   bool _ret_var = default(bool);
 878          try {
 879             _ret_var = ((Pager)wrapper).UnpackAll();
 880          } catch (Exception e) {
 881             Eina.Log.Warning($"Callback error: {e.ToString()}");
 882             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 883          }
 884       return _ret_var;
 885       } else {
 886          return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 887       }
 888    }
 889    private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
 890
 891
 892     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 893
 894
 895     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 896     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");
 897     private static bool unpack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 898    {
 899       Eina.Log.Debug("function efl_pack_unpack was called");
 900       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 901       if(wrapper != null) {
 902                                     bool _ret_var = default(bool);
 903          try {
 904             _ret_var = ((Pager)wrapper).Unpack( subobj);
 905          } catch (Exception e) {
 906             Eina.Log.Warning($"Callback error: {e.ToString()}");
 907             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 908          }
 909                   return _ret_var;
 910       } else {
 911          return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 912       }
 913    }
 914    private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
 915
 916
 917     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 918
 919
 920     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 921     public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(_Module, "efl_pack");
 922     private static bool pack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 923    {
 924       Eina.Log.Debug("function efl_pack was called");
 925       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 926       if(wrapper != null) {
 927                                     bool _ret_var = default(bool);
 928          try {
 929             _ret_var = ((Pager)wrapper).DoPack( subobj);
 930          } catch (Exception e) {
 931             Eina.Log.Warning($"Callback error: {e.ToString()}");
 932             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 933          }
 934                   return _ret_var;
 935       } else {
 936          return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 937       }
 938    }
 939    private static efl_pack_delegate efl_pack_static_delegate;
 940
 941
 942     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 943
 944
 945     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 946     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");
 947     private static bool pack_begin(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 948    {
 949       Eina.Log.Debug("function efl_pack_begin was called");
 950       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 951       if(wrapper != null) {
 952                                     bool _ret_var = default(bool);
 953          try {
 954             _ret_var = ((Pager)wrapper).PackBegin( subobj);
 955          } catch (Exception e) {
 956             Eina.Log.Warning($"Callback error: {e.ToString()}");
 957             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 958          }
 959                   return _ret_var;
 960       } else {
 961          return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 962       }
 963    }
 964    private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
 965
 966
 967     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 968
 969
 970     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
 971     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");
 972     private static bool pack_end(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
 973    {
 974       Eina.Log.Debug("function efl_pack_end was called");
 975       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 976       if(wrapper != null) {
 977                                     bool _ret_var = default(bool);
 978          try {
 979             _ret_var = ((Pager)wrapper).PackEnd( subobj);
 980          } catch (Exception e) {
 981             Eina.Log.Warning($"Callback error: {e.ToString()}");
 982             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 983          }
 984                   return _ret_var;
 985       } else {
 986          return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
 987       }
 988    }
 989    private static efl_pack_end_delegate efl_pack_end_static_delegate;
 990
 991
 992     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
 993
 994
 995     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
 996     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");
 997     private static bool pack_before(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
 998    {
 999       Eina.Log.Debug("function efl_pack_before was called");
1000       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1001       if(wrapper != null) {
1002                                                       bool _ret_var = default(bool);
1003          try {
1004             _ret_var = ((Pager)wrapper).PackBefore( subobj,  existing);
1005          } catch (Exception e) {
1006             Eina.Log.Warning($"Callback error: {e.ToString()}");
1007             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1008          }
1009                               return _ret_var;
1010       } else {
1011          return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
1012       }
1013    }
1014    private static efl_pack_before_delegate efl_pack_before_static_delegate;
1015
1016
1017     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
1018
1019
1020     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
1021     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");
1022     private static bool pack_after(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
1023    {
1024       Eina.Log.Debug("function efl_pack_after was called");
1025       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1026       if(wrapper != null) {
1027                                                       bool _ret_var = default(bool);
1028          try {
1029             _ret_var = ((Pager)wrapper).PackAfter( subobj,  existing);
1030          } catch (Exception e) {
1031             Eina.Log.Warning($"Callback error: {e.ToString()}");
1032             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1033          }
1034                               return _ret_var;
1035       } else {
1036          return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
1037       }
1038    }
1039    private static efl_pack_after_delegate efl_pack_after_static_delegate;
1040
1041
1042     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj,    int index);
1043
1044
1045     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj,    int index);
1046     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");
1047     private static bool pack_at(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,   int index)
1048    {
1049       Eina.Log.Debug("function efl_pack_at was called");
1050       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1051       if(wrapper != null) {
1052                                                       bool _ret_var = default(bool);
1053          try {
1054             _ret_var = ((Pager)wrapper).PackAt( subobj,  index);
1055          } catch (Exception e) {
1056             Eina.Log.Warning($"Callback error: {e.ToString()}");
1057             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1058          }
1059                               return _ret_var;
1060       } else {
1061          return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  index);
1062       }
1063    }
1064    private static efl_pack_at_delegate efl_pack_at_static_delegate;
1065
1066
1067    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,    int index);
1068
1069
1070    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_pack_content_get_api_delegate(System.IntPtr obj,    int index);
1071     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");
1072     private static Efl.Gfx.Entity pack_content_get(System.IntPtr obj, System.IntPtr pd,   int index)
1073    {
1074       Eina.Log.Debug("function efl_pack_content_get was called");
1075       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1076       if(wrapper != null) {
1077                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
1078          try {
1079             _ret_var = ((Pager)wrapper).GetPackContent( index);
1080          } catch (Exception e) {
1081             Eina.Log.Warning($"Callback error: {e.ToString()}");
1082             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1083          }
1084                   return _ret_var;
1085       } else {
1086          return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
1087       }
1088    }
1089    private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
1090
1091
1092     private delegate  int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
1093
1094
1095     public delegate  int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
1096     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");
1097     private static  int pack_index_get(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
1098    {
1099       Eina.Log.Debug("function efl_pack_index_get was called");
1100       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1101       if(wrapper != null) {
1102                                      int _ret_var = default( int);
1103          try {
1104             _ret_var = ((Pager)wrapper).GetPackIndex( subobj);
1105          } catch (Exception e) {
1106             Eina.Log.Warning($"Callback error: {e.ToString()}");
1107             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1108          }
1109                   return _ret_var;
1110       } else {
1111          return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
1112       }
1113    }
1114    private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
1115
1116
1117    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,    int index);
1118
1119
1120    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_pack_unpack_at_api_delegate(System.IntPtr obj,    int index);
1121     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");
1122     private static Efl.Gfx.Entity pack_unpack_at(System.IntPtr obj, System.IntPtr pd,   int index)
1123    {
1124       Eina.Log.Debug("function efl_pack_unpack_at was called");
1125       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1126       if(wrapper != null) {
1127                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
1128          try {
1129             _ret_var = ((Pager)wrapper).PackUnpackAt( index);
1130          } catch (Exception e) {
1131             Eina.Log.Warning($"Callback error: {e.ToString()}");
1132             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1133          }
1134                   return _ret_var;
1135       } else {
1136          return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
1137       }
1138    }
1139    private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
1140 }
1141 } }
1142 namespace Efl { namespace Ui {
1143 /// <summary>Efl ui pager loop mode</summary>
1144 public enum PagerLoop
1145 {
1146 /// <summary></summary>
1147 Disabled = 0,
1148 /// <summary></summary>
1149 Enabled = 1,
1150 }
1151 } }