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