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

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