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