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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Ui {
  12
  13 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  14 [Efl.Ui.IScrollableInteractiveConcrete.NativeMethods]
  15 [Efl.Eo.BindingEntity]
  16 public interface IScrollableInteractive :
  17     Efl.Ui.IScrollable ,
  18     Efl.Eo.IWrapper, IDisposable
  19 {
  20     /// <summary>The content position</summary>
  21 /// <returns>The position is virtual value, (0, 0) starting at the top-left.</returns>
  22 Eina.Position2D GetContentPos();
  23     /// <summary>The content position</summary>
  24 /// <param name="pos">The position is virtual value, (0, 0) starting at the top-left.</param>
  25 void SetContentPos(Eina.Position2D pos);
  26     /// <summary>The content size</summary>
  27 /// <returns>The content size in pixels.</returns>
  28 Eina.Size2D GetContentSize();
  29     /// <summary>The viewport geometry</summary>
  30 /// <returns>It is absolute geometry.</returns>
  31 Eina.Rect GetViewportGeometry();
  32     /// <summary>Bouncing behavior
  33 /// When scrolling, the scroller may &quot;bounce&quot; when reaching the edge of the content object. This is a visual way to indicate the end has been reached. This is enabled by default for both axes. This API will determine if it&apos;s enabled for the given axis with the boolean parameters for each one.</summary>
  34 /// <param name="horiz">Horizontal bounce policy.</param>
  35 /// <param name="vert">Vertical bounce policy.</param>
  36 void GetBounceEnabled(out bool horiz, out bool vert);
  37     /// <summary>Bouncing behavior
  38 /// When scrolling, the scroller may &quot;bounce&quot; when reaching the edge of the content object. This is a visual way to indicate the end has been reached. This is enabled by default for both axes. This API will determine if it&apos;s enabled for the given axis with the boolean parameters for each one.</summary>
  39 /// <param name="horiz">Horizontal bounce policy.</param>
  40 /// <param name="vert">Vertical bounce policy.</param>
  41 void SetBounceEnabled(bool horiz, bool vert);
  42     /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.IScrollableInteractive.SetMovementBlock"/>.</summary>
  43 /// <returns><c>true</c> if freeze, <c>false</c> otherwise</returns>
  44 bool GetScrollFreeze();
  45     /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.IScrollableInteractive.SetMovementBlock"/>.</summary>
  46 /// <param name="freeze"><c>true</c> if freeze, <c>false</c> otherwise</param>
  47 void SetScrollFreeze(bool freeze);
  48     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
  49 /// <returns><c>true</c> if hold, <c>false</c> otherwise</returns>
  50 bool GetScrollHold();
  51     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
  52 /// <param name="hold"><c>true</c> if hold, <c>false</c> otherwise</param>
  53 void SetScrollHold(bool hold);
  54     /// <summary>Controls an infinite loop for a scroller.</summary>
  55 /// <param name="loop_h">The scrolling horizontal loop</param>
  56 /// <param name="loop_v">The Scrolling vertical loop</param>
  57 void GetLooping(out bool loop_h, out bool loop_v);
  58     /// <summary>Controls an infinite loop for a scroller.</summary>
  59 /// <param name="loop_h">The scrolling horizontal loop</param>
  60 /// <param name="loop_v">The Scrolling vertical loop</param>
  61 void SetLooping(bool loop_h, bool loop_v);
  62     /// <summary>Blocking of scrolling (per axis)
  63 /// This function will block scrolling movement (by input of a user) in a given direction. You can disable movements in the X axis, the Y axis or both. The default value is <c>none</c>, where movements are allowed in both directions.</summary>
  64 /// <returns>Which axis (or axes) to block</returns>
  65 Efl.Ui.ScrollBlock GetMovementBlock();
  66     /// <summary>Blocking of scrolling (per axis)
  67 /// This function will block scrolling movement (by input of a user) in a given direction. You can disable movements in the X axis, the Y axis or both. The default value is <c>none</c>, where movements are allowed in both directions.</summary>
  68 /// <param name="block">Which axis (or axes) to block</param>
  69 void SetMovementBlock(Efl.Ui.ScrollBlock block);
  70     /// <summary>Control scrolling gravity on the scrollable
  71 /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
  72 ///
  73 /// The scroller will adjust the view to glue itself as follows.
  74 ///
  75 /// x=0.0, for staying where it is relative to the left edge of the content x=1.0, for staying where it is relative to the right edge of the content y=0.0, for staying where it is relative to the top edge of the content y=1.0, for staying where it is relative to the bottom edge of the content
  76 ///
  77 /// Default values for x and y are 0.0</summary>
  78 /// <param name="x">Horizontal scrolling gravity</param>
  79 /// <param name="y">Vertical scrolling gravity</param>
  80 void GetGravity(out double x, out double y);
  81     /// <summary>Control scrolling gravity on the scrollable
  82 /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
  83 ///
  84 /// The scroller will adjust the view to glue itself as follows.
  85 ///
  86 /// x=0.0, for staying where it is relative to the left edge of the content x=1.0, for staying where it is relative to the right edge of the content y=0.0, for staying where it is relative to the top edge of the content y=1.0, for staying where it is relative to the bottom edge of the content
  87 ///
  88 /// Default values for x and y are 0.0</summary>
  89 /// <param name="x">Horizontal scrolling gravity</param>
  90 /// <param name="y">Vertical scrolling gravity</param>
  91 void SetGravity(double x, double y);
  92     /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
  93 /// By default the scroller will be as small as its design allows, irrespective of its content. This will make the scroller minimum size the right size horizontally and/or vertically to perfectly fit its content in that direction.</summary>
  94 /// <param name="w">Whether to limit the minimum horizontal size</param>
  95 /// <param name="h">Whether to limit the minimum vertical size</param>
  96 void SetMatchContent(bool w, bool h);
  97     /// <summary>Control the step size
  98 /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
  99 /// <returns>The step size in pixels</returns>
 100 Eina.Position2D GetStepSize();
 101     /// <summary>Control the step size
 102 /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
 103 /// <param name="step">The step size in pixels</param>
 104 void SetStepSize(Eina.Position2D step);
 105     /// <summary>Show a specific virtual region within the scroller content object.
 106 /// This will ensure all (or part if it does not fit) of the designated region in the virtual content object (0, 0 starting at the top-left of the virtual content object) is shown within the scroller. This allows the scroller to &quot;smoothly slide&quot; to this location (if configuration in general calls for transitions). It may not jump immediately to the new location and make take a while and show other content along the way.</summary>
 107 /// <param name="rect">The position where to scroll. and The size user want to see</param>
 108 /// <param name="animation">Whether to scroll with animation or not</param>
 109 void Scroll(Eina.Rect rect, bool animation);
 110                                                                                     /// <summary>The content position</summary>
 111     /// <value>The position is virtual value, (0, 0) starting at the top-left.</value>
 112     Eina.Position2D ContentPos {
 113         get;
 114         set;
 115     }
 116     /// <summary>The content size</summary>
 117     /// <value>The content size in pixels.</value>
 118     Eina.Size2D ContentSize {
 119         get;
 120     }
 121     /// <summary>The viewport geometry</summary>
 122     /// <value>It is absolute geometry.</value>
 123     Eina.Rect ViewportGeometry {
 124         get;
 125     }
 126     /// <summary>Bouncing behavior
 127     /// When scrolling, the scroller may &quot;bounce&quot; when reaching the edge of the content object. This is a visual way to indicate the end has been reached. This is enabled by default for both axes. This API will determine if it&apos;s enabled for the given axis with the boolean parameters for each one.</summary>
 128     /// <value>Horizontal bounce policy.</value>
 129     (bool, bool) BounceEnabled {
 130         get;
 131         set;
 132     }
 133     /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.IScrollableInteractive.SetMovementBlock"/>.</summary>
 134     /// <value><c>true</c> if freeze, <c>false</c> otherwise</value>
 135     bool ScrollFreeze {
 136         get;
 137         set;
 138     }
 139     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
 140     /// <value><c>true</c> if hold, <c>false</c> otherwise</value>
 141     bool ScrollHold {
 142         get;
 143         set;
 144     }
 145     /// <summary>Controls an infinite loop for a scroller.</summary>
 146     /// <value>The scrolling horizontal loop</value>
 147     (bool, bool) Looping {
 148         get;
 149         set;
 150     }
 151     /// <summary>Blocking of scrolling (per axis)
 152     /// This function will block scrolling movement (by input of a user) in a given direction. You can disable movements in the X axis, the Y axis or both. The default value is <c>none</c>, where movements are allowed in both directions.</summary>
 153     /// <value>Which axis (or axes) to block</value>
 154     Efl.Ui.ScrollBlock MovementBlock {
 155         get;
 156         set;
 157     }
 158     /// <summary>Control scrolling gravity on the scrollable
 159     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
 160     ///
 161     /// The scroller will adjust the view to glue itself as follows.
 162     ///
 163     /// x=0.0, for staying where it is relative to the left edge of the content x=1.0, for staying where it is relative to the right edge of the content y=0.0, for staying where it is relative to the top edge of the content y=1.0, for staying where it is relative to the bottom edge of the content
 164     ///
 165     /// Default values for x and y are 0.0</summary>
 166     /// <value>Horizontal scrolling gravity</value>
 167     (double, double) Gravity {
 168         get;
 169         set;
 170     }
 171     /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
 172     /// By default the scroller will be as small as its design allows, irrespective of its content. This will make the scroller minimum size the right size horizontally and/or vertically to perfectly fit its content in that direction.</summary>
 173     /// <value>Whether to limit the minimum horizontal size</value>
 174     (bool, bool) MatchContent {
 175         set;
 176     }
 177     /// <summary>Control the step size
 178     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
 179     /// <value>The step size in pixels</value>
 180     Eina.Position2D StepSize {
 181         get;
 182         set;
 183     }
 184 }
 185 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
 186 sealed public  class IScrollableInteractiveConcrete :
 187     Efl.Eo.EoWrapper
 188     , IScrollableInteractive
 189     , Efl.Ui.IScrollable
 190 {
 191     /// <summary>Pointer to the native class description.</summary>
 192     public override System.IntPtr NativeClass
 193     {
 194         get
 195         {
 196             if (((object)this).GetType() == typeof(IScrollableInteractiveConcrete))
 197             {
 198                 return GetEflClassStatic();
 199             }
 200             else
 201             {
 202                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 203             }
 204         }
 205     }
 206
 207     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
 208     /// Do not call this constructor directly.</summary>
 209     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 210     private IScrollableInteractiveConcrete(ConstructingHandle ch) : base(ch)
 211     {
 212     }
 213
 214     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 215         efl_ui_scrollable_interactive_interface_get();
 216     /// <summary>Initializes a new instance of the <see cref="IScrollableInteractive"/> class.
 217     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 218     /// <param name="wh">The native pointer to be wrapped.</param>
 219     private IScrollableInteractiveConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 220     {
 221     }
 222
 223     /// <summary>Called when scroll operation starts</summary>
 224     public event EventHandler ScrollStartEvt
 225     {
 226         add
 227         {
 228             lock (eflBindingEventLock)
 229             {
 230                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 231                 {
 232                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 233                     if (obj != null)
 234                     {
 235                         EventArgs args = EventArgs.Empty;
 236                         try
 237                         {
 238                             value?.Invoke(obj, args);
 239                         }
 240                         catch (Exception e)
 241                         {
 242                             Eina.Log.Error(e.ToString());
 243                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 244                         }
 245                     }
 246                 };
 247
 248                 string key = "_EFL_UI_EVENT_SCROLL_START";
 249                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 250             }
 251         }
 252
 253         remove
 254         {
 255             lock (eflBindingEventLock)
 256             {
 257                 string key = "_EFL_UI_EVENT_SCROLL_START";
 258                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 259             }
 260         }
 261     }
 262     /// <summary>Method to raise event ScrollStartEvt.</summary>
 263     public void OnScrollStartEvt(EventArgs e)
 264     {
 265         var key = "_EFL_UI_EVENT_SCROLL_START";
 266         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 267         if (desc == IntPtr.Zero)
 268         {
 269             Eina.Log.Error($"Failed to get native event {key}");
 270             return;
 271         }
 272
 273         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 274     }
 275     /// <summary>Called when scrolling</summary>
 276     public event EventHandler ScrollEvt
 277     {
 278         add
 279         {
 280             lock (eflBindingEventLock)
 281             {
 282                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 283                 {
 284                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 285                     if (obj != null)
 286                     {
 287                         EventArgs args = EventArgs.Empty;
 288                         try
 289                         {
 290                             value?.Invoke(obj, args);
 291                         }
 292                         catch (Exception e)
 293                         {
 294                             Eina.Log.Error(e.ToString());
 295                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 296                         }
 297                     }
 298                 };
 299
 300                 string key = "_EFL_UI_EVENT_SCROLL";
 301                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 302             }
 303         }
 304
 305         remove
 306         {
 307             lock (eflBindingEventLock)
 308             {
 309                 string key = "_EFL_UI_EVENT_SCROLL";
 310                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 311             }
 312         }
 313     }
 314     /// <summary>Method to raise event ScrollEvt.</summary>
 315     public void OnScrollEvt(EventArgs e)
 316     {
 317         var key = "_EFL_UI_EVENT_SCROLL";
 318         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 319         if (desc == IntPtr.Zero)
 320         {
 321             Eina.Log.Error($"Failed to get native event {key}");
 322             return;
 323         }
 324
 325         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 326     }
 327     /// <summary>Called when scroll operation stops</summary>
 328     public event EventHandler ScrollStopEvt
 329     {
 330         add
 331         {
 332             lock (eflBindingEventLock)
 333             {
 334                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 335                 {
 336                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 337                     if (obj != null)
 338                     {
 339                         EventArgs args = EventArgs.Empty;
 340                         try
 341                         {
 342                             value?.Invoke(obj, args);
 343                         }
 344                         catch (Exception e)
 345                         {
 346                             Eina.Log.Error(e.ToString());
 347                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 348                         }
 349                     }
 350                 };
 351
 352                 string key = "_EFL_UI_EVENT_SCROLL_STOP";
 353                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 354             }
 355         }
 356
 357         remove
 358         {
 359             lock (eflBindingEventLock)
 360             {
 361                 string key = "_EFL_UI_EVENT_SCROLL_STOP";
 362                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 363             }
 364         }
 365     }
 366     /// <summary>Method to raise event ScrollStopEvt.</summary>
 367     public void OnScrollStopEvt(EventArgs e)
 368     {
 369         var key = "_EFL_UI_EVENT_SCROLL_STOP";
 370         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 371         if (desc == IntPtr.Zero)
 372         {
 373             Eina.Log.Error($"Failed to get native event {key}");
 374             return;
 375         }
 376
 377         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 378     }
 379     /// <summary>Called when scrolling upwards</summary>
 380     public event EventHandler ScrollUpEvt
 381     {
 382         add
 383         {
 384             lock (eflBindingEventLock)
 385             {
 386                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 387                 {
 388                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 389                     if (obj != null)
 390                     {
 391                         EventArgs args = EventArgs.Empty;
 392                         try
 393                         {
 394                             value?.Invoke(obj, args);
 395                         }
 396                         catch (Exception e)
 397                         {
 398                             Eina.Log.Error(e.ToString());
 399                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 400                         }
 401                     }
 402                 };
 403
 404                 string key = "_EFL_UI_EVENT_SCROLL_UP";
 405                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 406             }
 407         }
 408
 409         remove
 410         {
 411             lock (eflBindingEventLock)
 412             {
 413                 string key = "_EFL_UI_EVENT_SCROLL_UP";
 414                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 415             }
 416         }
 417     }
 418     /// <summary>Method to raise event ScrollUpEvt.</summary>
 419     public void OnScrollUpEvt(EventArgs e)
 420     {
 421         var key = "_EFL_UI_EVENT_SCROLL_UP";
 422         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 423         if (desc == IntPtr.Zero)
 424         {
 425             Eina.Log.Error($"Failed to get native event {key}");
 426             return;
 427         }
 428
 429         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 430     }
 431     /// <summary>Called when scrolling downwards</summary>
 432     public event EventHandler ScrollDownEvt
 433     {
 434         add
 435         {
 436             lock (eflBindingEventLock)
 437             {
 438                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 439                 {
 440                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 441                     if (obj != null)
 442                     {
 443                         EventArgs args = EventArgs.Empty;
 444                         try
 445                         {
 446                             value?.Invoke(obj, args);
 447                         }
 448                         catch (Exception e)
 449                         {
 450                             Eina.Log.Error(e.ToString());
 451                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 452                         }
 453                     }
 454                 };
 455
 456                 string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 457                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 458             }
 459         }
 460
 461         remove
 462         {
 463             lock (eflBindingEventLock)
 464             {
 465                 string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 466                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 467             }
 468         }
 469     }
 470     /// <summary>Method to raise event ScrollDownEvt.</summary>
 471     public void OnScrollDownEvt(EventArgs e)
 472     {
 473         var key = "_EFL_UI_EVENT_SCROLL_DOWN";
 474         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 475         if (desc == IntPtr.Zero)
 476         {
 477             Eina.Log.Error($"Failed to get native event {key}");
 478             return;
 479         }
 480
 481         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 482     }
 483     /// <summary>Called when scrolling left</summary>
 484     public event EventHandler ScrollLeftEvt
 485     {
 486         add
 487         {
 488             lock (eflBindingEventLock)
 489             {
 490                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 491                 {
 492                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 493                     if (obj != null)
 494                     {
 495                         EventArgs args = EventArgs.Empty;
 496                         try
 497                         {
 498                             value?.Invoke(obj, args);
 499                         }
 500                         catch (Exception e)
 501                         {
 502                             Eina.Log.Error(e.ToString());
 503                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 504                         }
 505                     }
 506                 };
 507
 508                 string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 509                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 510             }
 511         }
 512
 513         remove
 514         {
 515             lock (eflBindingEventLock)
 516             {
 517                 string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 518                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 519             }
 520         }
 521     }
 522     /// <summary>Method to raise event ScrollLeftEvt.</summary>
 523     public void OnScrollLeftEvt(EventArgs e)
 524     {
 525         var key = "_EFL_UI_EVENT_SCROLL_LEFT";
 526         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 527         if (desc == IntPtr.Zero)
 528         {
 529             Eina.Log.Error($"Failed to get native event {key}");
 530             return;
 531         }
 532
 533         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 534     }
 535     /// <summary>Called when scrolling right</summary>
 536     public event EventHandler ScrollRightEvt
 537     {
 538         add
 539         {
 540             lock (eflBindingEventLock)
 541             {
 542                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 543                 {
 544                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 545                     if (obj != null)
 546                     {
 547                         EventArgs args = EventArgs.Empty;
 548                         try
 549                         {
 550                             value?.Invoke(obj, args);
 551                         }
 552                         catch (Exception e)
 553                         {
 554                             Eina.Log.Error(e.ToString());
 555                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 556                         }
 557                     }
 558                 };
 559
 560                 string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 561                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 562             }
 563         }
 564
 565         remove
 566         {
 567             lock (eflBindingEventLock)
 568             {
 569                 string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 570                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 571             }
 572         }
 573     }
 574     /// <summary>Method to raise event ScrollRightEvt.</summary>
 575     public void OnScrollRightEvt(EventArgs e)
 576     {
 577         var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 578         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 579         if (desc == IntPtr.Zero)
 580         {
 581             Eina.Log.Error($"Failed to get native event {key}");
 582             return;
 583         }
 584
 585         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 586     }
 587     /// <summary>Called when hitting the top edge</summary>
 588     public event EventHandler EdgeUpEvt
 589     {
 590         add
 591         {
 592             lock (eflBindingEventLock)
 593             {
 594                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 595                 {
 596                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 597                     if (obj != null)
 598                     {
 599                         EventArgs args = EventArgs.Empty;
 600                         try
 601                         {
 602                             value?.Invoke(obj, args);
 603                         }
 604                         catch (Exception e)
 605                         {
 606                             Eina.Log.Error(e.ToString());
 607                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 608                         }
 609                     }
 610                 };
 611
 612                 string key = "_EFL_UI_EVENT_EDGE_UP";
 613                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 614             }
 615         }
 616
 617         remove
 618         {
 619             lock (eflBindingEventLock)
 620             {
 621                 string key = "_EFL_UI_EVENT_EDGE_UP";
 622                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 623             }
 624         }
 625     }
 626     /// <summary>Method to raise event EdgeUpEvt.</summary>
 627     public void OnEdgeUpEvt(EventArgs e)
 628     {
 629         var key = "_EFL_UI_EVENT_EDGE_UP";
 630         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 631         if (desc == IntPtr.Zero)
 632         {
 633             Eina.Log.Error($"Failed to get native event {key}");
 634             return;
 635         }
 636
 637         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 638     }
 639     /// <summary>Called when hitting the bottom edge</summary>
 640     public event EventHandler EdgeDownEvt
 641     {
 642         add
 643         {
 644             lock (eflBindingEventLock)
 645             {
 646                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 647                 {
 648                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 649                     if (obj != null)
 650                     {
 651                         EventArgs args = EventArgs.Empty;
 652                         try
 653                         {
 654                             value?.Invoke(obj, args);
 655                         }
 656                         catch (Exception e)
 657                         {
 658                             Eina.Log.Error(e.ToString());
 659                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 660                         }
 661                     }
 662                 };
 663
 664                 string key = "_EFL_UI_EVENT_EDGE_DOWN";
 665                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 666             }
 667         }
 668
 669         remove
 670         {
 671             lock (eflBindingEventLock)
 672             {
 673                 string key = "_EFL_UI_EVENT_EDGE_DOWN";
 674                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 675             }
 676         }
 677     }
 678     /// <summary>Method to raise event EdgeDownEvt.</summary>
 679     public void OnEdgeDownEvt(EventArgs e)
 680     {
 681         var key = "_EFL_UI_EVENT_EDGE_DOWN";
 682         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 683         if (desc == IntPtr.Zero)
 684         {
 685             Eina.Log.Error($"Failed to get native event {key}");
 686             return;
 687         }
 688
 689         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 690     }
 691     /// <summary>Called when hitting the left edge</summary>
 692     public event EventHandler EdgeLeftEvt
 693     {
 694         add
 695         {
 696             lock (eflBindingEventLock)
 697             {
 698                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 699                 {
 700                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 701                     if (obj != null)
 702                     {
 703                         EventArgs args = EventArgs.Empty;
 704                         try
 705                         {
 706                             value?.Invoke(obj, args);
 707                         }
 708                         catch (Exception e)
 709                         {
 710                             Eina.Log.Error(e.ToString());
 711                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 712                         }
 713                     }
 714                 };
 715
 716                 string key = "_EFL_UI_EVENT_EDGE_LEFT";
 717                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 718             }
 719         }
 720
 721         remove
 722         {
 723             lock (eflBindingEventLock)
 724             {
 725                 string key = "_EFL_UI_EVENT_EDGE_LEFT";
 726                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 727             }
 728         }
 729     }
 730     /// <summary>Method to raise event EdgeLeftEvt.</summary>
 731     public void OnEdgeLeftEvt(EventArgs e)
 732     {
 733         var key = "_EFL_UI_EVENT_EDGE_LEFT";
 734         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 735         if (desc == IntPtr.Zero)
 736         {
 737             Eina.Log.Error($"Failed to get native event {key}");
 738             return;
 739         }
 740
 741         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 742     }
 743     /// <summary>Called when hitting the right edge</summary>
 744     public event EventHandler EdgeRightEvt
 745     {
 746         add
 747         {
 748             lock (eflBindingEventLock)
 749             {
 750                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 751                 {
 752                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 753                     if (obj != null)
 754                     {
 755                         EventArgs args = EventArgs.Empty;
 756                         try
 757                         {
 758                             value?.Invoke(obj, args);
 759                         }
 760                         catch (Exception e)
 761                         {
 762                             Eina.Log.Error(e.ToString());
 763                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 764                         }
 765                     }
 766                 };
 767
 768                 string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 769                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 770             }
 771         }
 772
 773         remove
 774         {
 775             lock (eflBindingEventLock)
 776             {
 777                 string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 778                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 779             }
 780         }
 781     }
 782     /// <summary>Method to raise event EdgeRightEvt.</summary>
 783     public void OnEdgeRightEvt(EventArgs e)
 784     {
 785         var key = "_EFL_UI_EVENT_EDGE_RIGHT";
 786         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 787         if (desc == IntPtr.Zero)
 788         {
 789             Eina.Log.Error($"Failed to get native event {key}");
 790             return;
 791         }
 792
 793         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 794     }
 795     /// <summary>Called when scroll animation starts</summary>
 796     public event EventHandler ScrollAnimStartEvt
 797     {
 798         add
 799         {
 800             lock (eflBindingEventLock)
 801             {
 802                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 803                 {
 804                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 805                     if (obj != null)
 806                     {
 807                         EventArgs args = EventArgs.Empty;
 808                         try
 809                         {
 810                             value?.Invoke(obj, args);
 811                         }
 812                         catch (Exception e)
 813                         {
 814                             Eina.Log.Error(e.ToString());
 815                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 816                         }
 817                     }
 818                 };
 819
 820                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 821                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 822             }
 823         }
 824
 825         remove
 826         {
 827             lock (eflBindingEventLock)
 828             {
 829                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 830                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 831             }
 832         }
 833     }
 834     /// <summary>Method to raise event ScrollAnimStartEvt.</summary>
 835     public void OnScrollAnimStartEvt(EventArgs e)
 836     {
 837         var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 838         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 839         if (desc == IntPtr.Zero)
 840         {
 841             Eina.Log.Error($"Failed to get native event {key}");
 842             return;
 843         }
 844
 845         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 846     }
 847     /// <summary>Called when scroll animation stopps</summary>
 848     public event EventHandler ScrollAnimStopEvt
 849     {
 850         add
 851         {
 852             lock (eflBindingEventLock)
 853             {
 854                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 855                 {
 856                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 857                     if (obj != null)
 858                     {
 859                         EventArgs args = EventArgs.Empty;
 860                         try
 861                         {
 862                             value?.Invoke(obj, args);
 863                         }
 864                         catch (Exception e)
 865                         {
 866                             Eina.Log.Error(e.ToString());
 867                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 868                         }
 869                     }
 870                 };
 871
 872                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 873                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 874             }
 875         }
 876
 877         remove
 878         {
 879             lock (eflBindingEventLock)
 880             {
 881                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 882                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 883             }
 884         }
 885     }
 886     /// <summary>Method to raise event ScrollAnimStopEvt.</summary>
 887     public void OnScrollAnimStopEvt(EventArgs e)
 888     {
 889         var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 890         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 891         if (desc == IntPtr.Zero)
 892         {
 893             Eina.Log.Error($"Failed to get native event {key}");
 894             return;
 895         }
 896
 897         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 898     }
 899     /// <summary>Called when scroll drag starts</summary>
 900     public event EventHandler ScrollDragStartEvt
 901     {
 902         add
 903         {
 904             lock (eflBindingEventLock)
 905             {
 906                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 907                 {
 908                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 909                     if (obj != null)
 910                     {
 911                         EventArgs args = EventArgs.Empty;
 912                         try
 913                         {
 914                             value?.Invoke(obj, args);
 915                         }
 916                         catch (Exception e)
 917                         {
 918                             Eina.Log.Error(e.ToString());
 919                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 920                         }
 921                     }
 922                 };
 923
 924                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 925                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 926             }
 927         }
 928
 929         remove
 930         {
 931             lock (eflBindingEventLock)
 932             {
 933                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 934                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 935             }
 936         }
 937     }
 938     /// <summary>Method to raise event ScrollDragStartEvt.</summary>
 939     public void OnScrollDragStartEvt(EventArgs e)
 940     {
 941         var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 942         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 943         if (desc == IntPtr.Zero)
 944         {
 945             Eina.Log.Error($"Failed to get native event {key}");
 946             return;
 947         }
 948
 949         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 950     }
 951     /// <summary>Called when scroll drag stops</summary>
 952     public event EventHandler ScrollDragStopEvt
 953     {
 954         add
 955         {
 956             lock (eflBindingEventLock)
 957             {
 958                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 959                 {
 960                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 961                     if (obj != null)
 962                     {
 963                         EventArgs args = EventArgs.Empty;
 964                         try
 965                         {
 966                             value?.Invoke(obj, args);
 967                         }
 968                         catch (Exception e)
 969                         {
 970                             Eina.Log.Error(e.ToString());
 971                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 972                         }
 973                     }
 974                 };
 975
 976                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 977                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 978             }
 979         }
 980
 981         remove
 982         {
 983             lock (eflBindingEventLock)
 984             {
 985                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 986                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 987             }
 988         }
 989     }
 990     /// <summary>Method to raise event ScrollDragStopEvt.</summary>
 991     public void OnScrollDragStopEvt(EventArgs e)
 992     {
 993         var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 994         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 995         if (desc == IntPtr.Zero)
 996         {
 997             Eina.Log.Error($"Failed to get native event {key}");
 998             return;
 999         }
1000
1001         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
1002     }
1003     /// <summary>The content position</summary>
1004     /// <returns>The position is virtual value, (0, 0) starting at the top-left.</returns>
1005     public Eina.Position2D GetContentPos() {
1006          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_content_pos_get_ptr.Value.Delegate(this.NativeHandle);
1007         Eina.Error.RaiseIfUnhandledException();
1008         return _ret_var;
1009  }
1010     /// <summary>The content position</summary>
1011     /// <param name="pos">The position is virtual value, (0, 0) starting at the top-left.</param>
1012     public void SetContentPos(Eina.Position2D pos) {
1013          Eina.Position2D.NativeStruct _in_pos = pos;
1014                         Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_content_pos_set_ptr.Value.Delegate(this.NativeHandle,_in_pos);
1015         Eina.Error.RaiseIfUnhandledException();
1016                          }
1017     /// <summary>The content size</summary>
1018     /// <returns>The content size in pixels.</returns>
1019     public Eina.Size2D GetContentSize() {
1020          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_content_size_get_ptr.Value.Delegate(this.NativeHandle);
1021         Eina.Error.RaiseIfUnhandledException();
1022         return _ret_var;
1023  }
1024     /// <summary>The viewport geometry</summary>
1025     /// <returns>It is absolute geometry.</returns>
1026     public Eina.Rect GetViewportGeometry() {
1027          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_viewport_geometry_get_ptr.Value.Delegate(this.NativeHandle);
1028         Eina.Error.RaiseIfUnhandledException();
1029         return _ret_var;
1030  }
1031     /// <summary>Bouncing behavior
1032     /// When scrolling, the scroller may &quot;bounce&quot; when reaching the edge of the content object. This is a visual way to indicate the end has been reached. This is enabled by default for both axes. This API will determine if it&apos;s enabled for the given axis with the boolean parameters for each one.</summary>
1033     /// <param name="horiz">Horizontal bounce policy.</param>
1034     /// <param name="vert">Vertical bounce policy.</param>
1035     public void GetBounceEnabled(out bool horiz, out bool vert) {
1036                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_bounce_enabled_get_ptr.Value.Delegate(this.NativeHandle,out horiz, out vert);
1037         Eina.Error.RaiseIfUnhandledException();
1038                                          }
1039     /// <summary>Bouncing behavior
1040     /// When scrolling, the scroller may &quot;bounce&quot; when reaching the edge of the content object. This is a visual way to indicate the end has been reached. This is enabled by default for both axes. This API will determine if it&apos;s enabled for the given axis with the boolean parameters for each one.</summary>
1041     /// <param name="horiz">Horizontal bounce policy.</param>
1042     /// <param name="vert">Vertical bounce policy.</param>
1043     public void SetBounceEnabled(bool horiz, bool vert) {
1044                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_bounce_enabled_set_ptr.Value.Delegate(this.NativeHandle,horiz, vert);
1045         Eina.Error.RaiseIfUnhandledException();
1046                                          }
1047     /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.IScrollableInteractive.SetMovementBlock"/>.</summary>
1048     /// <returns><c>true</c> if freeze, <c>false</c> otherwise</returns>
1049     public bool GetScrollFreeze() {
1050          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_freeze_get_ptr.Value.Delegate(this.NativeHandle);
1051         Eina.Error.RaiseIfUnhandledException();
1052         return _ret_var;
1053  }
1054     /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.IScrollableInteractive.SetMovementBlock"/>.</summary>
1055     /// <param name="freeze"><c>true</c> if freeze, <c>false</c> otherwise</param>
1056     public void SetScrollFreeze(bool freeze) {
1057                                  Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_freeze_set_ptr.Value.Delegate(this.NativeHandle,freeze);
1058         Eina.Error.RaiseIfUnhandledException();
1059                          }
1060     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1061     /// <returns><c>true</c> if hold, <c>false</c> otherwise</returns>
1062     public bool GetScrollHold() {
1063          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_hold_get_ptr.Value.Delegate(this.NativeHandle);
1064         Eina.Error.RaiseIfUnhandledException();
1065         return _ret_var;
1066  }
1067     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1068     /// <param name="hold"><c>true</c> if hold, <c>false</c> otherwise</param>
1069     public void SetScrollHold(bool hold) {
1070                                  Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_hold_set_ptr.Value.Delegate(this.NativeHandle,hold);
1071         Eina.Error.RaiseIfUnhandledException();
1072                          }
1073     /// <summary>Controls an infinite loop for a scroller.</summary>
1074     /// <param name="loop_h">The scrolling horizontal loop</param>
1075     /// <param name="loop_v">The Scrolling vertical loop</param>
1076     public void GetLooping(out bool loop_h, out bool loop_v) {
1077                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_looping_get_ptr.Value.Delegate(this.NativeHandle,out loop_h, out loop_v);
1078         Eina.Error.RaiseIfUnhandledException();
1079                                          }
1080     /// <summary>Controls an infinite loop for a scroller.</summary>
1081     /// <param name="loop_h">The scrolling horizontal loop</param>
1082     /// <param name="loop_v">The Scrolling vertical loop</param>
1083     public void SetLooping(bool loop_h, bool loop_v) {
1084                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_looping_set_ptr.Value.Delegate(this.NativeHandle,loop_h, loop_v);
1085         Eina.Error.RaiseIfUnhandledException();
1086                                          }
1087     /// <summary>Blocking of scrolling (per axis)
1088     /// This function will block scrolling movement (by input of a user) in a given direction. You can disable movements in the X axis, the Y axis or both. The default value is <c>none</c>, where movements are allowed in both directions.</summary>
1089     /// <returns>Which axis (or axes) to block</returns>
1090     public Efl.Ui.ScrollBlock GetMovementBlock() {
1091          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_movement_block_get_ptr.Value.Delegate(this.NativeHandle);
1092         Eina.Error.RaiseIfUnhandledException();
1093         return _ret_var;
1094  }
1095     /// <summary>Blocking of scrolling (per axis)
1096     /// This function will block scrolling movement (by input of a user) in a given direction. You can disable movements in the X axis, the Y axis or both. The default value is <c>none</c>, where movements are allowed in both directions.</summary>
1097     /// <param name="block">Which axis (or axes) to block</param>
1098     public void SetMovementBlock(Efl.Ui.ScrollBlock block) {
1099                                  Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_movement_block_set_ptr.Value.Delegate(this.NativeHandle,block);
1100         Eina.Error.RaiseIfUnhandledException();
1101                          }
1102     /// <summary>Control scrolling gravity on the scrollable
1103     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1104     ///
1105     /// The scroller will adjust the view to glue itself as follows.
1106     ///
1107     /// x=0.0, for staying where it is relative to the left edge of the content x=1.0, for staying where it is relative to the right edge of the content y=0.0, for staying where it is relative to the top edge of the content y=1.0, for staying where it is relative to the bottom edge of the content
1108     ///
1109     /// Default values for x and y are 0.0</summary>
1110     /// <param name="x">Horizontal scrolling gravity</param>
1111     /// <param name="y">Vertical scrolling gravity</param>
1112     public void GetGravity(out double x, out double y) {
1113                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_gravity_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
1114         Eina.Error.RaiseIfUnhandledException();
1115                                          }
1116     /// <summary>Control scrolling gravity on the scrollable
1117     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1118     ///
1119     /// The scroller will adjust the view to glue itself as follows.
1120     ///
1121     /// x=0.0, for staying where it is relative to the left edge of the content x=1.0, for staying where it is relative to the right edge of the content y=0.0, for staying where it is relative to the top edge of the content y=1.0, for staying where it is relative to the bottom edge of the content
1122     ///
1123     /// Default values for x and y are 0.0</summary>
1124     /// <param name="x">Horizontal scrolling gravity</param>
1125     /// <param name="y">Vertical scrolling gravity</param>
1126     public void SetGravity(double x, double y) {
1127                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_gravity_set_ptr.Value.Delegate(this.NativeHandle,x, y);
1128         Eina.Error.RaiseIfUnhandledException();
1129                                          }
1130     /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
1131     /// By default the scroller will be as small as its design allows, irrespective of its content. This will make the scroller minimum size the right size horizontally and/or vertically to perfectly fit its content in that direction.</summary>
1132     /// <param name="w">Whether to limit the minimum horizontal size</param>
1133     /// <param name="h">Whether to limit the minimum vertical size</param>
1134     public void SetMatchContent(bool w, bool h) {
1135                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_match_content_set_ptr.Value.Delegate(this.NativeHandle,w, h);
1136         Eina.Error.RaiseIfUnhandledException();
1137                                          }
1138     /// <summary>Control the step size
1139     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1140     /// <returns>The step size in pixels</returns>
1141     public Eina.Position2D GetStepSize() {
1142          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_step_size_get_ptr.Value.Delegate(this.NativeHandle);
1143         Eina.Error.RaiseIfUnhandledException();
1144         return _ret_var;
1145  }
1146     /// <summary>Control the step size
1147     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1148     /// <param name="step">The step size in pixels</param>
1149     public void SetStepSize(Eina.Position2D step) {
1150          Eina.Position2D.NativeStruct _in_step = step;
1151                         Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_step_size_set_ptr.Value.Delegate(this.NativeHandle,_in_step);
1152         Eina.Error.RaiseIfUnhandledException();
1153                          }
1154     /// <summary>Show a specific virtual region within the scroller content object.
1155     /// This will ensure all (or part if it does not fit) of the designated region in the virtual content object (0, 0 starting at the top-left of the virtual content object) is shown within the scroller. This allows the scroller to &quot;smoothly slide&quot; to this location (if configuration in general calls for transitions). It may not jump immediately to the new location and make take a while and show other content along the way.</summary>
1156     /// <param name="rect">The position where to scroll. and The size user want to see</param>
1157     /// <param name="animation">Whether to scroll with animation or not</param>
1158     public void Scroll(Eina.Rect rect, bool animation) {
1159          Eina.Rect.NativeStruct _in_rect = rect;
1160                                                 Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_ptr.Value.Delegate(this.NativeHandle,_in_rect, animation);
1161         Eina.Error.RaiseIfUnhandledException();
1162                                          }
1163     /// <summary>The content position</summary>
1164     /// <value>The position is virtual value, (0, 0) starting at the top-left.</value>
1165     public Eina.Position2D ContentPos {
1166         get { return GetContentPos(); }
1167         set { SetContentPos(value); }
1168     }
1169     /// <summary>The content size</summary>
1170     /// <value>The content size in pixels.</value>
1171     public Eina.Size2D ContentSize {
1172         get { return GetContentSize(); }
1173     }
1174     /// <summary>The viewport geometry</summary>
1175     /// <value>It is absolute geometry.</value>
1176     public Eina.Rect ViewportGeometry {
1177         get { return GetViewportGeometry(); }
1178     }
1179     /// <summary>Bouncing behavior
1180     /// When scrolling, the scroller may &quot;bounce&quot; when reaching the edge of the content object. This is a visual way to indicate the end has been reached. This is enabled by default for both axes. This API will determine if it&apos;s enabled for the given axis with the boolean parameters for each one.</summary>
1181     /// <value>Horizontal bounce policy.</value>
1182     public (bool, bool) BounceEnabled {
1183         get {
1184             bool _out_horiz = default(bool);
1185             bool _out_vert = default(bool);
1186             GetBounceEnabled(out _out_horiz,out _out_vert);
1187             return (_out_horiz,_out_vert);
1188         }
1189         set { SetBounceEnabled( value.Item1,  value.Item2); }
1190     }
1191     /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.IScrollableInteractive.SetMovementBlock"/>.</summary>
1192     /// <value><c>true</c> if freeze, <c>false</c> otherwise</value>
1193     public bool ScrollFreeze {
1194         get { return GetScrollFreeze(); }
1195         set { SetScrollFreeze(value); }
1196     }
1197     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1198     /// <value><c>true</c> if hold, <c>false</c> otherwise</value>
1199     public bool ScrollHold {
1200         get { return GetScrollHold(); }
1201         set { SetScrollHold(value); }
1202     }
1203     /// <summary>Controls an infinite loop for a scroller.</summary>
1204     /// <value>The scrolling horizontal loop</value>
1205     public (bool, bool) Looping {
1206         get {
1207             bool _out_loop_h = default(bool);
1208             bool _out_loop_v = default(bool);
1209             GetLooping(out _out_loop_h,out _out_loop_v);
1210             return (_out_loop_h,_out_loop_v);
1211         }
1212         set { SetLooping( value.Item1,  value.Item2); }
1213     }
1214     /// <summary>Blocking of scrolling (per axis)
1215     /// This function will block scrolling movement (by input of a user) in a given direction. You can disable movements in the X axis, the Y axis or both. The default value is <c>none</c>, where movements are allowed in both directions.</summary>
1216     /// <value>Which axis (or axes) to block</value>
1217     public Efl.Ui.ScrollBlock MovementBlock {
1218         get { return GetMovementBlock(); }
1219         set { SetMovementBlock(value); }
1220     }
1221     /// <summary>Control scrolling gravity on the scrollable
1222     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1223     ///
1224     /// The scroller will adjust the view to glue itself as follows.
1225     ///
1226     /// x=0.0, for staying where it is relative to the left edge of the content x=1.0, for staying where it is relative to the right edge of the content y=0.0, for staying where it is relative to the top edge of the content y=1.0, for staying where it is relative to the bottom edge of the content
1227     ///
1228     /// Default values for x and y are 0.0</summary>
1229     /// <value>Horizontal scrolling gravity</value>
1230     public (double, double) Gravity {
1231         get {
1232             double _out_x = default(double);
1233             double _out_y = default(double);
1234             GetGravity(out _out_x,out _out_y);
1235             return (_out_x,_out_y);
1236         }
1237         set { SetGravity( value.Item1,  value.Item2); }
1238     }
1239     /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
1240     /// By default the scroller will be as small as its design allows, irrespective of its content. This will make the scroller minimum size the right size horizontally and/or vertically to perfectly fit its content in that direction.</summary>
1241     /// <value>Whether to limit the minimum horizontal size</value>
1242     public (bool, bool) MatchContent {
1243         set { SetMatchContent( value.Item1,  value.Item2); }
1244     }
1245     /// <summary>Control the step size
1246     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1247     /// <value>The step size in pixels</value>
1248     public Eina.Position2D StepSize {
1249         get { return GetStepSize(); }
1250         set { SetStepSize(value); }
1251     }
1252     private static IntPtr GetEflClassStatic()
1253     {
1254         return Efl.Ui.IScrollableInteractiveConcrete.efl_ui_scrollable_interactive_interface_get();
1255     }
1256     /// <summary>Wrapper for native methods and virtual method delegates.
1257     /// For internal use by generated code only.</summary>
1258     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
1259     {
1260         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
1261         /// <summary>Gets the list of Eo operations to override.</summary>
1262         /// <returns>The list of Eo operations to be overload.</returns>
1263         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
1264         {
1265             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
1266             var methods = Efl.Eo.Globals.GetUserMethods(type);
1267
1268             if (efl_ui_scrollable_content_pos_get_static_delegate == null)
1269             {
1270                 efl_ui_scrollable_content_pos_get_static_delegate = new efl_ui_scrollable_content_pos_get_delegate(content_pos_get);
1271             }
1272
1273             if (methods.FirstOrDefault(m => m.Name == "GetContentPos") != null)
1274             {
1275                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_content_pos_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_content_pos_get_static_delegate) });
1276             }
1277
1278             if (efl_ui_scrollable_content_pos_set_static_delegate == null)
1279             {
1280                 efl_ui_scrollable_content_pos_set_static_delegate = new efl_ui_scrollable_content_pos_set_delegate(content_pos_set);
1281             }
1282
1283             if (methods.FirstOrDefault(m => m.Name == "SetContentPos") != null)
1284             {
1285                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_content_pos_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_content_pos_set_static_delegate) });
1286             }
1287
1288             if (efl_ui_scrollable_content_size_get_static_delegate == null)
1289             {
1290                 efl_ui_scrollable_content_size_get_static_delegate = new efl_ui_scrollable_content_size_get_delegate(content_size_get);
1291             }
1292
1293             if (methods.FirstOrDefault(m => m.Name == "GetContentSize") != null)
1294             {
1295                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_content_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_content_size_get_static_delegate) });
1296             }
1297
1298             if (efl_ui_scrollable_viewport_geometry_get_static_delegate == null)
1299             {
1300                 efl_ui_scrollable_viewport_geometry_get_static_delegate = new efl_ui_scrollable_viewport_geometry_get_delegate(viewport_geometry_get);
1301             }
1302
1303             if (methods.FirstOrDefault(m => m.Name == "GetViewportGeometry") != null)
1304             {
1305                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_viewport_geometry_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_viewport_geometry_get_static_delegate) });
1306             }
1307
1308             if (efl_ui_scrollable_bounce_enabled_get_static_delegate == null)
1309             {
1310                 efl_ui_scrollable_bounce_enabled_get_static_delegate = new efl_ui_scrollable_bounce_enabled_get_delegate(bounce_enabled_get);
1311             }
1312
1313             if (methods.FirstOrDefault(m => m.Name == "GetBounceEnabled") != null)
1314             {
1315                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_bounce_enabled_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_bounce_enabled_get_static_delegate) });
1316             }
1317
1318             if (efl_ui_scrollable_bounce_enabled_set_static_delegate == null)
1319             {
1320                 efl_ui_scrollable_bounce_enabled_set_static_delegate = new efl_ui_scrollable_bounce_enabled_set_delegate(bounce_enabled_set);
1321             }
1322
1323             if (methods.FirstOrDefault(m => m.Name == "SetBounceEnabled") != null)
1324             {
1325                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_bounce_enabled_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_bounce_enabled_set_static_delegate) });
1326             }
1327
1328             if (efl_ui_scrollable_scroll_freeze_get_static_delegate == null)
1329             {
1330                 efl_ui_scrollable_scroll_freeze_get_static_delegate = new efl_ui_scrollable_scroll_freeze_get_delegate(scroll_freeze_get);
1331             }
1332
1333             if (methods.FirstOrDefault(m => m.Name == "GetScrollFreeze") != null)
1334             {
1335                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_scroll_freeze_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_scroll_freeze_get_static_delegate) });
1336             }
1337
1338             if (efl_ui_scrollable_scroll_freeze_set_static_delegate == null)
1339             {
1340                 efl_ui_scrollable_scroll_freeze_set_static_delegate = new efl_ui_scrollable_scroll_freeze_set_delegate(scroll_freeze_set);
1341             }
1342
1343             if (methods.FirstOrDefault(m => m.Name == "SetScrollFreeze") != null)
1344             {
1345                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_scroll_freeze_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_scroll_freeze_set_static_delegate) });
1346             }
1347
1348             if (efl_ui_scrollable_scroll_hold_get_static_delegate == null)
1349             {
1350                 efl_ui_scrollable_scroll_hold_get_static_delegate = new efl_ui_scrollable_scroll_hold_get_delegate(scroll_hold_get);
1351             }
1352
1353             if (methods.FirstOrDefault(m => m.Name == "GetScrollHold") != null)
1354             {
1355                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_scroll_hold_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_scroll_hold_get_static_delegate) });
1356             }
1357
1358             if (efl_ui_scrollable_scroll_hold_set_static_delegate == null)
1359             {
1360                 efl_ui_scrollable_scroll_hold_set_static_delegate = new efl_ui_scrollable_scroll_hold_set_delegate(scroll_hold_set);
1361             }
1362
1363             if (methods.FirstOrDefault(m => m.Name == "SetScrollHold") != null)
1364             {
1365                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_scroll_hold_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_scroll_hold_set_static_delegate) });
1366             }
1367
1368             if (efl_ui_scrollable_looping_get_static_delegate == null)
1369             {
1370                 efl_ui_scrollable_looping_get_static_delegate = new efl_ui_scrollable_looping_get_delegate(looping_get);
1371             }
1372
1373             if (methods.FirstOrDefault(m => m.Name == "GetLooping") != null)
1374             {
1375                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_looping_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_looping_get_static_delegate) });
1376             }
1377
1378             if (efl_ui_scrollable_looping_set_static_delegate == null)
1379             {
1380                 efl_ui_scrollable_looping_set_static_delegate = new efl_ui_scrollable_looping_set_delegate(looping_set);
1381             }
1382
1383             if (methods.FirstOrDefault(m => m.Name == "SetLooping") != null)
1384             {
1385                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_looping_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_looping_set_static_delegate) });
1386             }
1387
1388             if (efl_ui_scrollable_movement_block_get_static_delegate == null)
1389             {
1390                 efl_ui_scrollable_movement_block_get_static_delegate = new efl_ui_scrollable_movement_block_get_delegate(movement_block_get);
1391             }
1392
1393             if (methods.FirstOrDefault(m => m.Name == "GetMovementBlock") != null)
1394             {
1395                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_movement_block_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_movement_block_get_static_delegate) });
1396             }
1397
1398             if (efl_ui_scrollable_movement_block_set_static_delegate == null)
1399             {
1400                 efl_ui_scrollable_movement_block_set_static_delegate = new efl_ui_scrollable_movement_block_set_delegate(movement_block_set);
1401             }
1402
1403             if (methods.FirstOrDefault(m => m.Name == "SetMovementBlock") != null)
1404             {
1405                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_movement_block_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_movement_block_set_static_delegate) });
1406             }
1407
1408             if (efl_ui_scrollable_gravity_get_static_delegate == null)
1409             {
1410                 efl_ui_scrollable_gravity_get_static_delegate = new efl_ui_scrollable_gravity_get_delegate(gravity_get);
1411             }
1412
1413             if (methods.FirstOrDefault(m => m.Name == "GetGravity") != null)
1414             {
1415                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_gravity_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_gravity_get_static_delegate) });
1416             }
1417
1418             if (efl_ui_scrollable_gravity_set_static_delegate == null)
1419             {
1420                 efl_ui_scrollable_gravity_set_static_delegate = new efl_ui_scrollable_gravity_set_delegate(gravity_set);
1421             }
1422
1423             if (methods.FirstOrDefault(m => m.Name == "SetGravity") != null)
1424             {
1425                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_gravity_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_gravity_set_static_delegate) });
1426             }
1427
1428             if (efl_ui_scrollable_match_content_set_static_delegate == null)
1429             {
1430                 efl_ui_scrollable_match_content_set_static_delegate = new efl_ui_scrollable_match_content_set_delegate(match_content_set);
1431             }
1432
1433             if (methods.FirstOrDefault(m => m.Name == "SetMatchContent") != null)
1434             {
1435                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_match_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_match_content_set_static_delegate) });
1436             }
1437
1438             if (efl_ui_scrollable_step_size_get_static_delegate == null)
1439             {
1440                 efl_ui_scrollable_step_size_get_static_delegate = new efl_ui_scrollable_step_size_get_delegate(step_size_get);
1441             }
1442
1443             if (methods.FirstOrDefault(m => m.Name == "GetStepSize") != null)
1444             {
1445                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_step_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_step_size_get_static_delegate) });
1446             }
1447
1448             if (efl_ui_scrollable_step_size_set_static_delegate == null)
1449             {
1450                 efl_ui_scrollable_step_size_set_static_delegate = new efl_ui_scrollable_step_size_set_delegate(step_size_set);
1451             }
1452
1453             if (methods.FirstOrDefault(m => m.Name == "SetStepSize") != null)
1454             {
1455                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_step_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_step_size_set_static_delegate) });
1456             }
1457
1458             if (efl_ui_scrollable_scroll_static_delegate == null)
1459             {
1460                 efl_ui_scrollable_scroll_static_delegate = new efl_ui_scrollable_scroll_delegate(scroll);
1461             }
1462
1463             if (methods.FirstOrDefault(m => m.Name == "Scroll") != null)
1464             {
1465                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollable_scroll"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollable_scroll_static_delegate) });
1466             }
1467
1468             return descs;
1469         }
1470         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1471         /// <returns>The native class pointer.</returns>
1472         public override IntPtr GetEflClass()
1473         {
1474             return Efl.Ui.IScrollableInteractiveConcrete.efl_ui_scrollable_interactive_interface_get();
1475         }
1476
1477         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1478
1479
1480         private delegate Eina.Position2D.NativeStruct efl_ui_scrollable_content_pos_get_delegate(System.IntPtr obj, System.IntPtr pd);
1481
1482
1483         public delegate Eina.Position2D.NativeStruct efl_ui_scrollable_content_pos_get_api_delegate(System.IntPtr obj);
1484
1485         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_content_pos_get_api_delegate> efl_ui_scrollable_content_pos_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_content_pos_get_api_delegate>(Module, "efl_ui_scrollable_content_pos_get");
1486
1487         private static Eina.Position2D.NativeStruct content_pos_get(System.IntPtr obj, System.IntPtr pd)
1488         {
1489             Eina.Log.Debug("function efl_ui_scrollable_content_pos_get was called");
1490             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1491             if (ws != null)
1492             {
1493             Eina.Position2D _ret_var = default(Eina.Position2D);
1494                 try
1495                 {
1496                     _ret_var = ((IScrollableInteractive)ws.Target).GetContentPos();
1497                 }
1498                 catch (Exception e)
1499                 {
1500                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1501                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1502                 }
1503
1504         return _ret_var;
1505
1506             }
1507             else
1508             {
1509                 return efl_ui_scrollable_content_pos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1510             }
1511         }
1512
1513         private static efl_ui_scrollable_content_pos_get_delegate efl_ui_scrollable_content_pos_get_static_delegate;
1514
1515
1516         private delegate void efl_ui_scrollable_content_pos_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos);
1517
1518
1519         public delegate void efl_ui_scrollable_content_pos_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos);
1520
1521         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_content_pos_set_api_delegate> efl_ui_scrollable_content_pos_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_content_pos_set_api_delegate>(Module, "efl_ui_scrollable_content_pos_set");
1522
1523         private static void content_pos_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos)
1524         {
1525             Eina.Log.Debug("function efl_ui_scrollable_content_pos_set was called");
1526             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1527             if (ws != null)
1528             {
1529         Eina.Position2D _in_pos = pos;
1530
1531                 try
1532                 {
1533                     ((IScrollableInteractive)ws.Target).SetContentPos(_in_pos);
1534                 }
1535                 catch (Exception e)
1536                 {
1537                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1538                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1539                 }
1540
1541
1542             }
1543             else
1544             {
1545                 efl_ui_scrollable_content_pos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos);
1546             }
1547         }
1548
1549         private static efl_ui_scrollable_content_pos_set_delegate efl_ui_scrollable_content_pos_set_static_delegate;
1550
1551
1552         private delegate Eina.Size2D.NativeStruct efl_ui_scrollable_content_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1553
1554
1555         public delegate Eina.Size2D.NativeStruct efl_ui_scrollable_content_size_get_api_delegate(System.IntPtr obj);
1556
1557         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_content_size_get_api_delegate> efl_ui_scrollable_content_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_content_size_get_api_delegate>(Module, "efl_ui_scrollable_content_size_get");
1558
1559         private static Eina.Size2D.NativeStruct content_size_get(System.IntPtr obj, System.IntPtr pd)
1560         {
1561             Eina.Log.Debug("function efl_ui_scrollable_content_size_get was called");
1562             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1563             if (ws != null)
1564             {
1565             Eina.Size2D _ret_var = default(Eina.Size2D);
1566                 try
1567                 {
1568                     _ret_var = ((IScrollableInteractive)ws.Target).GetContentSize();
1569                 }
1570                 catch (Exception e)
1571                 {
1572                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1573                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1574                 }
1575
1576         return _ret_var;
1577
1578             }
1579             else
1580             {
1581                 return efl_ui_scrollable_content_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1582             }
1583         }
1584
1585         private static efl_ui_scrollable_content_size_get_delegate efl_ui_scrollable_content_size_get_static_delegate;
1586
1587
1588         private delegate Eina.Rect.NativeStruct efl_ui_scrollable_viewport_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
1589
1590
1591         public delegate Eina.Rect.NativeStruct efl_ui_scrollable_viewport_geometry_get_api_delegate(System.IntPtr obj);
1592
1593         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_viewport_geometry_get_api_delegate> efl_ui_scrollable_viewport_geometry_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_viewport_geometry_get_api_delegate>(Module, "efl_ui_scrollable_viewport_geometry_get");
1594
1595         private static Eina.Rect.NativeStruct viewport_geometry_get(System.IntPtr obj, System.IntPtr pd)
1596         {
1597             Eina.Log.Debug("function efl_ui_scrollable_viewport_geometry_get was called");
1598             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1599             if (ws != null)
1600             {
1601             Eina.Rect _ret_var = default(Eina.Rect);
1602                 try
1603                 {
1604                     _ret_var = ((IScrollableInteractive)ws.Target).GetViewportGeometry();
1605                 }
1606                 catch (Exception e)
1607                 {
1608                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1609                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1610                 }
1611
1612         return _ret_var;
1613
1614             }
1615             else
1616             {
1617                 return efl_ui_scrollable_viewport_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1618             }
1619         }
1620
1621         private static efl_ui_scrollable_viewport_geometry_get_delegate efl_ui_scrollable_viewport_geometry_get_static_delegate;
1622
1623
1624         private delegate void efl_ui_scrollable_bounce_enabled_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] out bool horiz, [MarshalAs(UnmanagedType.U1)] out bool vert);
1625
1626
1627         public delegate void efl_ui_scrollable_bounce_enabled_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] out bool horiz, [MarshalAs(UnmanagedType.U1)] out bool vert);
1628
1629         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_bounce_enabled_get_api_delegate> efl_ui_scrollable_bounce_enabled_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_bounce_enabled_get_api_delegate>(Module, "efl_ui_scrollable_bounce_enabled_get");
1630
1631         private static void bounce_enabled_get(System.IntPtr obj, System.IntPtr pd, out bool horiz, out bool vert)
1632         {
1633             Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_get was called");
1634             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1635             if (ws != null)
1636             {
1637                         horiz = default(bool);        vert = default(bool);
1638                 try
1639                 {
1640                     ((IScrollableInteractive)ws.Target).GetBounceEnabled(out horiz, out vert);
1641                 }
1642                 catch (Exception e)
1643                 {
1644                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1645                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1646                 }
1647
1648
1649             }
1650             else
1651             {
1652                 efl_ui_scrollable_bounce_enabled_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out horiz, out vert);
1653             }
1654         }
1655
1656         private static efl_ui_scrollable_bounce_enabled_get_delegate efl_ui_scrollable_bounce_enabled_get_static_delegate;
1657
1658
1659         private delegate void efl_ui_scrollable_bounce_enabled_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool horiz, [MarshalAs(UnmanagedType.U1)] bool vert);
1660
1661
1662         public delegate void efl_ui_scrollable_bounce_enabled_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool horiz, [MarshalAs(UnmanagedType.U1)] bool vert);
1663
1664         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_bounce_enabled_set_api_delegate> efl_ui_scrollable_bounce_enabled_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_bounce_enabled_set_api_delegate>(Module, "efl_ui_scrollable_bounce_enabled_set");
1665
1666         private static void bounce_enabled_set(System.IntPtr obj, System.IntPtr pd, bool horiz, bool vert)
1667         {
1668             Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_set was called");
1669             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1670             if (ws != null)
1671             {
1672
1673                 try
1674                 {
1675                     ((IScrollableInteractive)ws.Target).SetBounceEnabled(horiz, vert);
1676                 }
1677                 catch (Exception e)
1678                 {
1679                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1680                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1681                 }
1682
1683
1684             }
1685             else
1686             {
1687                 efl_ui_scrollable_bounce_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), horiz, vert);
1688             }
1689         }
1690
1691         private static efl_ui_scrollable_bounce_enabled_set_delegate efl_ui_scrollable_bounce_enabled_set_static_delegate;
1692
1693         [return: MarshalAs(UnmanagedType.U1)]
1694         private delegate bool efl_ui_scrollable_scroll_freeze_get_delegate(System.IntPtr obj, System.IntPtr pd);
1695
1696         [return: MarshalAs(UnmanagedType.U1)]
1697         public delegate bool efl_ui_scrollable_scroll_freeze_get_api_delegate(System.IntPtr obj);
1698
1699         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_freeze_get_api_delegate> efl_ui_scrollable_scroll_freeze_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_freeze_get_api_delegate>(Module, "efl_ui_scrollable_scroll_freeze_get");
1700
1701         private static bool scroll_freeze_get(System.IntPtr obj, System.IntPtr pd)
1702         {
1703             Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_get was called");
1704             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1705             if (ws != null)
1706             {
1707             bool _ret_var = default(bool);
1708                 try
1709                 {
1710                     _ret_var = ((IScrollableInteractive)ws.Target).GetScrollFreeze();
1711                 }
1712                 catch (Exception e)
1713                 {
1714                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1715                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1716                 }
1717
1718         return _ret_var;
1719
1720             }
1721             else
1722             {
1723                 return efl_ui_scrollable_scroll_freeze_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1724             }
1725         }
1726
1727         private static efl_ui_scrollable_scroll_freeze_get_delegate efl_ui_scrollable_scroll_freeze_get_static_delegate;
1728
1729
1730         private delegate void efl_ui_scrollable_scroll_freeze_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool freeze);
1731
1732
1733         public delegate void efl_ui_scrollable_scroll_freeze_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool freeze);
1734
1735         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_freeze_set_api_delegate> efl_ui_scrollable_scroll_freeze_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_freeze_set_api_delegate>(Module, "efl_ui_scrollable_scroll_freeze_set");
1736
1737         private static void scroll_freeze_set(System.IntPtr obj, System.IntPtr pd, bool freeze)
1738         {
1739             Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_set was called");
1740             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1741             if (ws != null)
1742             {
1743
1744                 try
1745                 {
1746                     ((IScrollableInteractive)ws.Target).SetScrollFreeze(freeze);
1747                 }
1748                 catch (Exception e)
1749                 {
1750                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1751                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1752                 }
1753
1754
1755             }
1756             else
1757             {
1758                 efl_ui_scrollable_scroll_freeze_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), freeze);
1759             }
1760         }
1761
1762         private static efl_ui_scrollable_scroll_freeze_set_delegate efl_ui_scrollable_scroll_freeze_set_static_delegate;
1763
1764         [return: MarshalAs(UnmanagedType.U1)]
1765         private delegate bool efl_ui_scrollable_scroll_hold_get_delegate(System.IntPtr obj, System.IntPtr pd);
1766
1767         [return: MarshalAs(UnmanagedType.U1)]
1768         public delegate bool efl_ui_scrollable_scroll_hold_get_api_delegate(System.IntPtr obj);
1769
1770         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_hold_get_api_delegate> efl_ui_scrollable_scroll_hold_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_hold_get_api_delegate>(Module, "efl_ui_scrollable_scroll_hold_get");
1771
1772         private static bool scroll_hold_get(System.IntPtr obj, System.IntPtr pd)
1773         {
1774             Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_get was called");
1775             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1776             if (ws != null)
1777             {
1778             bool _ret_var = default(bool);
1779                 try
1780                 {
1781                     _ret_var = ((IScrollableInteractive)ws.Target).GetScrollHold();
1782                 }
1783                 catch (Exception e)
1784                 {
1785                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1786                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1787                 }
1788
1789         return _ret_var;
1790
1791             }
1792             else
1793             {
1794                 return efl_ui_scrollable_scroll_hold_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1795             }
1796         }
1797
1798         private static efl_ui_scrollable_scroll_hold_get_delegate efl_ui_scrollable_scroll_hold_get_static_delegate;
1799
1800
1801         private delegate void efl_ui_scrollable_scroll_hold_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool hold);
1802
1803
1804         public delegate void efl_ui_scrollable_scroll_hold_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool hold);
1805
1806         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_hold_set_api_delegate> efl_ui_scrollable_scroll_hold_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_hold_set_api_delegate>(Module, "efl_ui_scrollable_scroll_hold_set");
1807
1808         private static void scroll_hold_set(System.IntPtr obj, System.IntPtr pd, bool hold)
1809         {
1810             Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_set was called");
1811             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1812             if (ws != null)
1813             {
1814
1815                 try
1816                 {
1817                     ((IScrollableInteractive)ws.Target).SetScrollHold(hold);
1818                 }
1819                 catch (Exception e)
1820                 {
1821                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1822                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1823                 }
1824
1825
1826             }
1827             else
1828             {
1829                 efl_ui_scrollable_scroll_hold_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hold);
1830             }
1831         }
1832
1833         private static efl_ui_scrollable_scroll_hold_set_delegate efl_ui_scrollable_scroll_hold_set_static_delegate;
1834
1835
1836         private delegate void efl_ui_scrollable_looping_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] out bool loop_h, [MarshalAs(UnmanagedType.U1)] out bool loop_v);
1837
1838
1839         public delegate void efl_ui_scrollable_looping_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] out bool loop_h, [MarshalAs(UnmanagedType.U1)] out bool loop_v);
1840
1841         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_looping_get_api_delegate> efl_ui_scrollable_looping_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_looping_get_api_delegate>(Module, "efl_ui_scrollable_looping_get");
1842
1843         private static void looping_get(System.IntPtr obj, System.IntPtr pd, out bool loop_h, out bool loop_v)
1844         {
1845             Eina.Log.Debug("function efl_ui_scrollable_looping_get was called");
1846             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1847             if (ws != null)
1848             {
1849                         loop_h = default(bool);        loop_v = default(bool);
1850                 try
1851                 {
1852                     ((IScrollableInteractive)ws.Target).GetLooping(out loop_h, out loop_v);
1853                 }
1854                 catch (Exception e)
1855                 {
1856                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1857                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1858                 }
1859
1860
1861             }
1862             else
1863             {
1864                 efl_ui_scrollable_looping_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out loop_h, out loop_v);
1865             }
1866         }
1867
1868         private static efl_ui_scrollable_looping_get_delegate efl_ui_scrollable_looping_get_static_delegate;
1869
1870
1871         private delegate void efl_ui_scrollable_looping_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool loop_h, [MarshalAs(UnmanagedType.U1)] bool loop_v);
1872
1873
1874         public delegate void efl_ui_scrollable_looping_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool loop_h, [MarshalAs(UnmanagedType.U1)] bool loop_v);
1875
1876         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_looping_set_api_delegate> efl_ui_scrollable_looping_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_looping_set_api_delegate>(Module, "efl_ui_scrollable_looping_set");
1877
1878         private static void looping_set(System.IntPtr obj, System.IntPtr pd, bool loop_h, bool loop_v)
1879         {
1880             Eina.Log.Debug("function efl_ui_scrollable_looping_set was called");
1881             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1882             if (ws != null)
1883             {
1884
1885                 try
1886                 {
1887                     ((IScrollableInteractive)ws.Target).SetLooping(loop_h, loop_v);
1888                 }
1889                 catch (Exception e)
1890                 {
1891                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1892                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1893                 }
1894
1895
1896             }
1897             else
1898             {
1899                 efl_ui_scrollable_looping_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), loop_h, loop_v);
1900             }
1901         }
1902
1903         private static efl_ui_scrollable_looping_set_delegate efl_ui_scrollable_looping_set_static_delegate;
1904
1905
1906         private delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_delegate(System.IntPtr obj, System.IntPtr pd);
1907
1908
1909         public delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_api_delegate(System.IntPtr obj);
1910
1911         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_movement_block_get_api_delegate> efl_ui_scrollable_movement_block_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_movement_block_get_api_delegate>(Module, "efl_ui_scrollable_movement_block_get");
1912
1913         private static Efl.Ui.ScrollBlock movement_block_get(System.IntPtr obj, System.IntPtr pd)
1914         {
1915             Eina.Log.Debug("function efl_ui_scrollable_movement_block_get was called");
1916             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1917             if (ws != null)
1918             {
1919             Efl.Ui.ScrollBlock _ret_var = default(Efl.Ui.ScrollBlock);
1920                 try
1921                 {
1922                     _ret_var = ((IScrollableInteractive)ws.Target).GetMovementBlock();
1923                 }
1924                 catch (Exception e)
1925                 {
1926                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1927                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1928                 }
1929
1930         return _ret_var;
1931
1932             }
1933             else
1934             {
1935                 return efl_ui_scrollable_movement_block_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1936             }
1937         }
1938
1939         private static efl_ui_scrollable_movement_block_get_delegate efl_ui_scrollable_movement_block_get_static_delegate;
1940
1941
1942         private delegate void efl_ui_scrollable_movement_block_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollBlock block);
1943
1944
1945         public delegate void efl_ui_scrollable_movement_block_set_api_delegate(System.IntPtr obj,  Efl.Ui.ScrollBlock block);
1946
1947         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_movement_block_set_api_delegate> efl_ui_scrollable_movement_block_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_movement_block_set_api_delegate>(Module, "efl_ui_scrollable_movement_block_set");
1948
1949         private static void movement_block_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ScrollBlock block)
1950         {
1951             Eina.Log.Debug("function efl_ui_scrollable_movement_block_set was called");
1952             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1953             if (ws != null)
1954             {
1955
1956                 try
1957                 {
1958                     ((IScrollableInteractive)ws.Target).SetMovementBlock(block);
1959                 }
1960                 catch (Exception e)
1961                 {
1962                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1963                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1964                 }
1965
1966
1967             }
1968             else
1969             {
1970                 efl_ui_scrollable_movement_block_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), block);
1971             }
1972         }
1973
1974         private static efl_ui_scrollable_movement_block_set_delegate efl_ui_scrollable_movement_block_set_static_delegate;
1975
1976
1977         private delegate void efl_ui_scrollable_gravity_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
1978
1979
1980         public delegate void efl_ui_scrollable_gravity_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
1981
1982         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_gravity_get_api_delegate> efl_ui_scrollable_gravity_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_gravity_get_api_delegate>(Module, "efl_ui_scrollable_gravity_get");
1983
1984         private static void gravity_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
1985         {
1986             Eina.Log.Debug("function efl_ui_scrollable_gravity_get was called");
1987             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1988             if (ws != null)
1989             {
1990                         x = default(double);        y = default(double);
1991                 try
1992                 {
1993                     ((IScrollableInteractive)ws.Target).GetGravity(out x, out y);
1994                 }
1995                 catch (Exception e)
1996                 {
1997                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1998                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1999                 }
2000
2001
2002             }
2003             else
2004             {
2005                 efl_ui_scrollable_gravity_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
2006             }
2007         }
2008
2009         private static efl_ui_scrollable_gravity_get_delegate efl_ui_scrollable_gravity_get_static_delegate;
2010
2011
2012         private delegate void efl_ui_scrollable_gravity_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
2013
2014
2015         public delegate void efl_ui_scrollable_gravity_set_api_delegate(System.IntPtr obj,  double x,  double y);
2016
2017         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_gravity_set_api_delegate> efl_ui_scrollable_gravity_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_gravity_set_api_delegate>(Module, "efl_ui_scrollable_gravity_set");
2018
2019         private static void gravity_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
2020         {
2021             Eina.Log.Debug("function efl_ui_scrollable_gravity_set was called");
2022             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2023             if (ws != null)
2024             {
2025
2026                 try
2027                 {
2028                     ((IScrollableInteractive)ws.Target).SetGravity(x, y);
2029                 }
2030                 catch (Exception e)
2031                 {
2032                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2033                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2034                 }
2035
2036
2037             }
2038             else
2039             {
2040                 efl_ui_scrollable_gravity_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
2041             }
2042         }
2043
2044         private static efl_ui_scrollable_gravity_set_delegate efl_ui_scrollable_gravity_set_static_delegate;
2045
2046
2047         private delegate void efl_ui_scrollable_match_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool w, [MarshalAs(UnmanagedType.U1)] bool h);
2048
2049
2050         public delegate void efl_ui_scrollable_match_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool w, [MarshalAs(UnmanagedType.U1)] bool h);
2051
2052         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_match_content_set_api_delegate> efl_ui_scrollable_match_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_match_content_set_api_delegate>(Module, "efl_ui_scrollable_match_content_set");
2053
2054         private static void match_content_set(System.IntPtr obj, System.IntPtr pd, bool w, bool h)
2055         {
2056             Eina.Log.Debug("function efl_ui_scrollable_match_content_set was called");
2057             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2058             if (ws != null)
2059             {
2060
2061                 try
2062                 {
2063                     ((IScrollableInteractive)ws.Target).SetMatchContent(w, h);
2064                 }
2065                 catch (Exception e)
2066                 {
2067                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2068                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2069                 }
2070
2071
2072             }
2073             else
2074             {
2075                 efl_ui_scrollable_match_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), w, h);
2076             }
2077         }
2078
2079         private static efl_ui_scrollable_match_content_set_delegate efl_ui_scrollable_match_content_set_static_delegate;
2080
2081
2082         private delegate Eina.Position2D.NativeStruct efl_ui_scrollable_step_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2083
2084
2085         public delegate Eina.Position2D.NativeStruct efl_ui_scrollable_step_size_get_api_delegate(System.IntPtr obj);
2086
2087         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_step_size_get_api_delegate> efl_ui_scrollable_step_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_step_size_get_api_delegate>(Module, "efl_ui_scrollable_step_size_get");
2088
2089         private static Eina.Position2D.NativeStruct step_size_get(System.IntPtr obj, System.IntPtr pd)
2090         {
2091             Eina.Log.Debug("function efl_ui_scrollable_step_size_get was called");
2092             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2093             if (ws != null)
2094             {
2095             Eina.Position2D _ret_var = default(Eina.Position2D);
2096                 try
2097                 {
2098                     _ret_var = ((IScrollableInteractive)ws.Target).GetStepSize();
2099                 }
2100                 catch (Exception e)
2101                 {
2102                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2103                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2104                 }
2105
2106         return _ret_var;
2107
2108             }
2109             else
2110             {
2111                 return efl_ui_scrollable_step_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2112             }
2113         }
2114
2115         private static efl_ui_scrollable_step_size_get_delegate efl_ui_scrollable_step_size_get_static_delegate;
2116
2117
2118         private delegate void efl_ui_scrollable_step_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct step);
2119
2120
2121         public delegate void efl_ui_scrollable_step_size_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct step);
2122
2123         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_step_size_set_api_delegate> efl_ui_scrollable_step_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_step_size_set_api_delegate>(Module, "efl_ui_scrollable_step_size_set");
2124
2125         private static void step_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct step)
2126         {
2127             Eina.Log.Debug("function efl_ui_scrollable_step_size_set was called");
2128             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2129             if (ws != null)
2130             {
2131         Eina.Position2D _in_step = step;
2132
2133                 try
2134                 {
2135                     ((IScrollableInteractive)ws.Target).SetStepSize(_in_step);
2136                 }
2137                 catch (Exception e)
2138                 {
2139                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2140                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2141                 }
2142
2143
2144             }
2145             else
2146             {
2147                 efl_ui_scrollable_step_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), step);
2148             }
2149         }
2150
2151         private static efl_ui_scrollable_step_size_set_delegate efl_ui_scrollable_step_size_set_static_delegate;
2152
2153
2154         private delegate void efl_ui_scrollable_scroll_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool animation);
2155
2156
2157         public delegate void efl_ui_scrollable_scroll_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool animation);
2158
2159         public static Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_api_delegate> efl_ui_scrollable_scroll_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollable_scroll_api_delegate>(Module, "efl_ui_scrollable_scroll");
2160
2161         private static void scroll(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct rect, bool animation)
2162         {
2163             Eina.Log.Debug("function efl_ui_scrollable_scroll was called");
2164             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2165             if (ws != null)
2166             {
2167         Eina.Rect _in_rect = rect;
2168
2169                 try
2170                 {
2171                     ((IScrollableInteractive)ws.Target).Scroll(_in_rect, animation);
2172                 }
2173                 catch (Exception e)
2174                 {
2175                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2176                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2177                 }
2178
2179
2180             }
2181             else
2182             {
2183                 efl_ui_scrollable_scroll_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rect, animation);
2184             }
2185         }
2186
2187         private static efl_ui_scrollable_scroll_delegate efl_ui_scrollable_scroll_static_delegate;
2188
2189         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2190
2191 }
2192 }
2193 }
2194
2195 }
2196
2197 #if EFL_BETA
2198 #pragma warning disable CS1591
2199 public static class Efl_UiIScrollableInteractiveConcrete_ExtensionMethods {
2200     public static Efl.BindableProperty<Eina.Position2D> ContentPos<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IScrollableInteractive, T>magic = null) where T : Efl.Ui.IScrollableInteractive {
2201         return new Efl.BindableProperty<Eina.Position2D>("content_pos", fac);
2202     }
2203
2204
2205
2206
2207     public static Efl.BindableProperty<bool> ScrollFreeze<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IScrollableInteractive, T>magic = null) where T : Efl.Ui.IScrollableInteractive {
2208         return new Efl.BindableProperty<bool>("scroll_freeze", fac);
2209     }
2210
2211     public static Efl.BindableProperty<bool> ScrollHold<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IScrollableInteractive, T>magic = null) where T : Efl.Ui.IScrollableInteractive {
2212         return new Efl.BindableProperty<bool>("scroll_hold", fac);
2213     }
2214
2215
2216     public static Efl.BindableProperty<Efl.Ui.ScrollBlock> MovementBlock<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IScrollableInteractive, T>magic = null) where T : Efl.Ui.IScrollableInteractive {
2217         return new Efl.BindableProperty<Efl.Ui.ScrollBlock>("movement_block", fac);
2218     }
2219
2220
2221
2222     public static Efl.BindableProperty<Eina.Position2D> StepSize<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.IScrollableInteractive, T>magic = null) where T : Efl.Ui.IScrollableInteractive {
2223         return new Efl.BindableProperty<Eina.Position2D>("step_size", fac);
2224     }
2225
2226 }
2227 #pragma warning restore CS1591
2228 #endif