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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Ui {
  12
  13 namespace Scroll {
  14
  15 /// <summary>Efl ui scroll manager class</summary>
  16 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  17 [Efl.Ui.Scroll.Manager.NativeMethods]
  18 [Efl.Eo.BindingEntity]
  19 public class Manager : Efl.Object, Efl.Ui.II18n, Efl.Ui.IScrollable, Efl.Ui.IScrollableInteractive, Efl.Ui.IScrollbar
  20 {
  21     /// <summary>Pointer to the native class description.</summary>
  22     public override System.IntPtr NativeClass
  23     {
  24         get
  25         {
  26             if (((object)this).GetType() == typeof(Manager))
  27             {
  28                 return GetEflClassStatic();
  29             }
  30             else
  31             {
  32                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  33             }
  34         }
  35     }
  36
  37     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  38         efl_ui_scroll_manager_class_get();
  39     /// <summary>Initializes a new instance of the <see cref="Manager"/> class.</summary>
  40     /// <param name="parent">Parent instance.</param>
  41     public Manager(Efl.Object parent= null
  42             ) : base(efl_ui_scroll_manager_class_get(), parent)
  43     {
  44         FinishInstantiation();
  45     }
  46
  47     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  48     /// Do not call this constructor directly.</summary>
  49     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  50     protected Manager(ConstructingHandle ch) : base(ch)
  51     {
  52     }
  53
  54     /// <summary>Initializes a new instance of the <see cref="Manager"/> class.
  55     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  56     /// <param name="wh">The native pointer to be wrapped.</param>
  57     protected Manager(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  58     {
  59     }
  60
  61     /// <summary>Initializes a new instance of the <see cref="Manager"/> class.
  62     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  63     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  64     /// <param name="parent">The Efl.Object parent of this instance.</param>
  65     protected Manager(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  66     {
  67     }
  68
  69     /// <summary>Called when scroll operation starts</summary>
  70     public event EventHandler ScrollStartEvt
  71     {
  72         add
  73         {
  74             lock (eflBindingEventLock)
  75             {
  76                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  77                 {
  78                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  79                     if (obj != null)
  80                     {
  81                         EventArgs args = EventArgs.Empty;
  82                         try
  83                         {
  84                             value?.Invoke(obj, args);
  85                         }
  86                         catch (Exception e)
  87                         {
  88                             Eina.Log.Error(e.ToString());
  89                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  90                         }
  91                     }
  92                 };
  93
  94                 string key = "_EFL_UI_EVENT_SCROLL_START";
  95                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  96             }
  97         }
  98
  99         remove
 100         {
 101             lock (eflBindingEventLock)
 102             {
 103                 string key = "_EFL_UI_EVENT_SCROLL_START";
 104                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 105             }
 106         }
 107     }
 108     /// <summary>Method to raise event ScrollStartEvt.</summary>
 109     public void OnScrollStartEvt(EventArgs e)
 110     {
 111         var key = "_EFL_UI_EVENT_SCROLL_START";
 112         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 113         if (desc == IntPtr.Zero)
 114         {
 115             Eina.Log.Error($"Failed to get native event {key}");
 116             return;
 117         }
 118
 119         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 120     }
 121     /// <summary>Called when scrolling</summary>
 122     public event EventHandler ScrollEvt
 123     {
 124         add
 125         {
 126             lock (eflBindingEventLock)
 127             {
 128                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 129                 {
 130                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 131                     if (obj != null)
 132                     {
 133                         EventArgs args = EventArgs.Empty;
 134                         try
 135                         {
 136                             value?.Invoke(obj, args);
 137                         }
 138                         catch (Exception e)
 139                         {
 140                             Eina.Log.Error(e.ToString());
 141                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 142                         }
 143                     }
 144                 };
 145
 146                 string key = "_EFL_UI_EVENT_SCROLL";
 147                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 148             }
 149         }
 150
 151         remove
 152         {
 153             lock (eflBindingEventLock)
 154             {
 155                 string key = "_EFL_UI_EVENT_SCROLL";
 156                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 157             }
 158         }
 159     }
 160     /// <summary>Method to raise event ScrollEvt.</summary>
 161     public void OnScrollEvt(EventArgs e)
 162     {
 163         var key = "_EFL_UI_EVENT_SCROLL";
 164         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 165         if (desc == IntPtr.Zero)
 166         {
 167             Eina.Log.Error($"Failed to get native event {key}");
 168             return;
 169         }
 170
 171         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 172     }
 173     /// <summary>Called when scroll operation stops</summary>
 174     public event EventHandler ScrollStopEvt
 175     {
 176         add
 177         {
 178             lock (eflBindingEventLock)
 179             {
 180                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 181                 {
 182                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 183                     if (obj != null)
 184                     {
 185                         EventArgs args = EventArgs.Empty;
 186                         try
 187                         {
 188                             value?.Invoke(obj, args);
 189                         }
 190                         catch (Exception e)
 191                         {
 192                             Eina.Log.Error(e.ToString());
 193                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 194                         }
 195                     }
 196                 };
 197
 198                 string key = "_EFL_UI_EVENT_SCROLL_STOP";
 199                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 200             }
 201         }
 202
 203         remove
 204         {
 205             lock (eflBindingEventLock)
 206             {
 207                 string key = "_EFL_UI_EVENT_SCROLL_STOP";
 208                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 209             }
 210         }
 211     }
 212     /// <summary>Method to raise event ScrollStopEvt.</summary>
 213     public void OnScrollStopEvt(EventArgs e)
 214     {
 215         var key = "_EFL_UI_EVENT_SCROLL_STOP";
 216         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 217         if (desc == IntPtr.Zero)
 218         {
 219             Eina.Log.Error($"Failed to get native event {key}");
 220             return;
 221         }
 222
 223         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 224     }
 225     /// <summary>Called when scrolling upwards</summary>
 226     public event EventHandler ScrollUpEvt
 227     {
 228         add
 229         {
 230             lock (eflBindingEventLock)
 231             {
 232                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 233                 {
 234                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 235                     if (obj != null)
 236                     {
 237                         EventArgs args = EventArgs.Empty;
 238                         try
 239                         {
 240                             value?.Invoke(obj, args);
 241                         }
 242                         catch (Exception e)
 243                         {
 244                             Eina.Log.Error(e.ToString());
 245                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 246                         }
 247                     }
 248                 };
 249
 250                 string key = "_EFL_UI_EVENT_SCROLL_UP";
 251                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 252             }
 253         }
 254
 255         remove
 256         {
 257             lock (eflBindingEventLock)
 258             {
 259                 string key = "_EFL_UI_EVENT_SCROLL_UP";
 260                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 261             }
 262         }
 263     }
 264     /// <summary>Method to raise event ScrollUpEvt.</summary>
 265     public void OnScrollUpEvt(EventArgs e)
 266     {
 267         var key = "_EFL_UI_EVENT_SCROLL_UP";
 268         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 269         if (desc == IntPtr.Zero)
 270         {
 271             Eina.Log.Error($"Failed to get native event {key}");
 272             return;
 273         }
 274
 275         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 276     }
 277     /// <summary>Called when scrolling downwards</summary>
 278     public event EventHandler ScrollDownEvt
 279     {
 280         add
 281         {
 282             lock (eflBindingEventLock)
 283             {
 284                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 285                 {
 286                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 287                     if (obj != null)
 288                     {
 289                         EventArgs args = EventArgs.Empty;
 290                         try
 291                         {
 292                             value?.Invoke(obj, args);
 293                         }
 294                         catch (Exception e)
 295                         {
 296                             Eina.Log.Error(e.ToString());
 297                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 298                         }
 299                     }
 300                 };
 301
 302                 string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 303                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 304             }
 305         }
 306
 307         remove
 308         {
 309             lock (eflBindingEventLock)
 310             {
 311                 string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 312                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 313             }
 314         }
 315     }
 316     /// <summary>Method to raise event ScrollDownEvt.</summary>
 317     public void OnScrollDownEvt(EventArgs e)
 318     {
 319         var key = "_EFL_UI_EVENT_SCROLL_DOWN";
 320         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 321         if (desc == IntPtr.Zero)
 322         {
 323             Eina.Log.Error($"Failed to get native event {key}");
 324             return;
 325         }
 326
 327         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 328     }
 329     /// <summary>Called when scrolling left</summary>
 330     public event EventHandler ScrollLeftEvt
 331     {
 332         add
 333         {
 334             lock (eflBindingEventLock)
 335             {
 336                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 337                 {
 338                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 339                     if (obj != null)
 340                     {
 341                         EventArgs args = EventArgs.Empty;
 342                         try
 343                         {
 344                             value?.Invoke(obj, args);
 345                         }
 346                         catch (Exception e)
 347                         {
 348                             Eina.Log.Error(e.ToString());
 349                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 350                         }
 351                     }
 352                 };
 353
 354                 string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 355                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 356             }
 357         }
 358
 359         remove
 360         {
 361             lock (eflBindingEventLock)
 362             {
 363                 string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 364                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 365             }
 366         }
 367     }
 368     /// <summary>Method to raise event ScrollLeftEvt.</summary>
 369     public void OnScrollLeftEvt(EventArgs e)
 370     {
 371         var key = "_EFL_UI_EVENT_SCROLL_LEFT";
 372         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 373         if (desc == IntPtr.Zero)
 374         {
 375             Eina.Log.Error($"Failed to get native event {key}");
 376             return;
 377         }
 378
 379         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 380     }
 381     /// <summary>Called when scrolling right</summary>
 382     public event EventHandler ScrollRightEvt
 383     {
 384         add
 385         {
 386             lock (eflBindingEventLock)
 387             {
 388                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 389                 {
 390                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 391                     if (obj != null)
 392                     {
 393                         EventArgs args = EventArgs.Empty;
 394                         try
 395                         {
 396                             value?.Invoke(obj, args);
 397                         }
 398                         catch (Exception e)
 399                         {
 400                             Eina.Log.Error(e.ToString());
 401                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 402                         }
 403                     }
 404                 };
 405
 406                 string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 407                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 408             }
 409         }
 410
 411         remove
 412         {
 413             lock (eflBindingEventLock)
 414             {
 415                 string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 416                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 417             }
 418         }
 419     }
 420     /// <summary>Method to raise event ScrollRightEvt.</summary>
 421     public void OnScrollRightEvt(EventArgs e)
 422     {
 423         var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 424         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 425         if (desc == IntPtr.Zero)
 426         {
 427             Eina.Log.Error($"Failed to get native event {key}");
 428             return;
 429         }
 430
 431         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 432     }
 433     /// <summary>Called when hitting the top edge</summary>
 434     public event EventHandler EdgeUpEvt
 435     {
 436         add
 437         {
 438             lock (eflBindingEventLock)
 439             {
 440                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 441                 {
 442                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 443                     if (obj != null)
 444                     {
 445                         EventArgs args = EventArgs.Empty;
 446                         try
 447                         {
 448                             value?.Invoke(obj, args);
 449                         }
 450                         catch (Exception e)
 451                         {
 452                             Eina.Log.Error(e.ToString());
 453                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 454                         }
 455                     }
 456                 };
 457
 458                 string key = "_EFL_UI_EVENT_EDGE_UP";
 459                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 460             }
 461         }
 462
 463         remove
 464         {
 465             lock (eflBindingEventLock)
 466             {
 467                 string key = "_EFL_UI_EVENT_EDGE_UP";
 468                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 469             }
 470         }
 471     }
 472     /// <summary>Method to raise event EdgeUpEvt.</summary>
 473     public void OnEdgeUpEvt(EventArgs e)
 474     {
 475         var key = "_EFL_UI_EVENT_EDGE_UP";
 476         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 477         if (desc == IntPtr.Zero)
 478         {
 479             Eina.Log.Error($"Failed to get native event {key}");
 480             return;
 481         }
 482
 483         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 484     }
 485     /// <summary>Called when hitting the bottom edge</summary>
 486     public event EventHandler EdgeDownEvt
 487     {
 488         add
 489         {
 490             lock (eflBindingEventLock)
 491             {
 492                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 493                 {
 494                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 495                     if (obj != null)
 496                     {
 497                         EventArgs args = EventArgs.Empty;
 498                         try
 499                         {
 500                             value?.Invoke(obj, args);
 501                         }
 502                         catch (Exception e)
 503                         {
 504                             Eina.Log.Error(e.ToString());
 505                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 506                         }
 507                     }
 508                 };
 509
 510                 string key = "_EFL_UI_EVENT_EDGE_DOWN";
 511                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 512             }
 513         }
 514
 515         remove
 516         {
 517             lock (eflBindingEventLock)
 518             {
 519                 string key = "_EFL_UI_EVENT_EDGE_DOWN";
 520                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 521             }
 522         }
 523     }
 524     /// <summary>Method to raise event EdgeDownEvt.</summary>
 525     public void OnEdgeDownEvt(EventArgs e)
 526     {
 527         var key = "_EFL_UI_EVENT_EDGE_DOWN";
 528         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 529         if (desc == IntPtr.Zero)
 530         {
 531             Eina.Log.Error($"Failed to get native event {key}");
 532             return;
 533         }
 534
 535         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 536     }
 537     /// <summary>Called when hitting the left edge</summary>
 538     public event EventHandler EdgeLeftEvt
 539     {
 540         add
 541         {
 542             lock (eflBindingEventLock)
 543             {
 544                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 545                 {
 546                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 547                     if (obj != null)
 548                     {
 549                         EventArgs args = EventArgs.Empty;
 550                         try
 551                         {
 552                             value?.Invoke(obj, args);
 553                         }
 554                         catch (Exception e)
 555                         {
 556                             Eina.Log.Error(e.ToString());
 557                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 558                         }
 559                     }
 560                 };
 561
 562                 string key = "_EFL_UI_EVENT_EDGE_LEFT";
 563                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 564             }
 565         }
 566
 567         remove
 568         {
 569             lock (eflBindingEventLock)
 570             {
 571                 string key = "_EFL_UI_EVENT_EDGE_LEFT";
 572                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 573             }
 574         }
 575     }
 576     /// <summary>Method to raise event EdgeLeftEvt.</summary>
 577     public void OnEdgeLeftEvt(EventArgs e)
 578     {
 579         var key = "_EFL_UI_EVENT_EDGE_LEFT";
 580         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 581         if (desc == IntPtr.Zero)
 582         {
 583             Eina.Log.Error($"Failed to get native event {key}");
 584             return;
 585         }
 586
 587         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 588     }
 589     /// <summary>Called when hitting the right edge</summary>
 590     public event EventHandler EdgeRightEvt
 591     {
 592         add
 593         {
 594             lock (eflBindingEventLock)
 595             {
 596                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 597                 {
 598                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 599                     if (obj != null)
 600                     {
 601                         EventArgs args = EventArgs.Empty;
 602                         try
 603                         {
 604                             value?.Invoke(obj, args);
 605                         }
 606                         catch (Exception e)
 607                         {
 608                             Eina.Log.Error(e.ToString());
 609                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 610                         }
 611                     }
 612                 };
 613
 614                 string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 615                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 616             }
 617         }
 618
 619         remove
 620         {
 621             lock (eflBindingEventLock)
 622             {
 623                 string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 624                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 625             }
 626         }
 627     }
 628     /// <summary>Method to raise event EdgeRightEvt.</summary>
 629     public void OnEdgeRightEvt(EventArgs e)
 630     {
 631         var key = "_EFL_UI_EVENT_EDGE_RIGHT";
 632         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 633         if (desc == IntPtr.Zero)
 634         {
 635             Eina.Log.Error($"Failed to get native event {key}");
 636             return;
 637         }
 638
 639         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 640     }
 641     /// <summary>Called when scroll animation starts</summary>
 642     public event EventHandler ScrollAnimStartEvt
 643     {
 644         add
 645         {
 646             lock (eflBindingEventLock)
 647             {
 648                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 649                 {
 650                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 651                     if (obj != null)
 652                     {
 653                         EventArgs args = EventArgs.Empty;
 654                         try
 655                         {
 656                             value?.Invoke(obj, args);
 657                         }
 658                         catch (Exception e)
 659                         {
 660                             Eina.Log.Error(e.ToString());
 661                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 662                         }
 663                     }
 664                 };
 665
 666                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 667                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 668             }
 669         }
 670
 671         remove
 672         {
 673             lock (eflBindingEventLock)
 674             {
 675                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 676                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 677             }
 678         }
 679     }
 680     /// <summary>Method to raise event ScrollAnimStartEvt.</summary>
 681     public void OnScrollAnimStartEvt(EventArgs e)
 682     {
 683         var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 684         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 685         if (desc == IntPtr.Zero)
 686         {
 687             Eina.Log.Error($"Failed to get native event {key}");
 688             return;
 689         }
 690
 691         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 692     }
 693     /// <summary>Called when scroll animation stopps</summary>
 694     public event EventHandler ScrollAnimStopEvt
 695     {
 696         add
 697         {
 698             lock (eflBindingEventLock)
 699             {
 700                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 701                 {
 702                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 703                     if (obj != null)
 704                     {
 705                         EventArgs args = EventArgs.Empty;
 706                         try
 707                         {
 708                             value?.Invoke(obj, args);
 709                         }
 710                         catch (Exception e)
 711                         {
 712                             Eina.Log.Error(e.ToString());
 713                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 714                         }
 715                     }
 716                 };
 717
 718                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 719                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 720             }
 721         }
 722
 723         remove
 724         {
 725             lock (eflBindingEventLock)
 726             {
 727                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 728                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 729             }
 730         }
 731     }
 732     /// <summary>Method to raise event ScrollAnimStopEvt.</summary>
 733     public void OnScrollAnimStopEvt(EventArgs e)
 734     {
 735         var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 736         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 737         if (desc == IntPtr.Zero)
 738         {
 739             Eina.Log.Error($"Failed to get native event {key}");
 740             return;
 741         }
 742
 743         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 744     }
 745     /// <summary>Called when scroll drag starts</summary>
 746     public event EventHandler ScrollDragStartEvt
 747     {
 748         add
 749         {
 750             lock (eflBindingEventLock)
 751             {
 752                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 753                 {
 754                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 755                     if (obj != null)
 756                     {
 757                         EventArgs args = EventArgs.Empty;
 758                         try
 759                         {
 760                             value?.Invoke(obj, args);
 761                         }
 762                         catch (Exception e)
 763                         {
 764                             Eina.Log.Error(e.ToString());
 765                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 766                         }
 767                     }
 768                 };
 769
 770                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 771                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 772             }
 773         }
 774
 775         remove
 776         {
 777             lock (eflBindingEventLock)
 778             {
 779                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 780                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 781             }
 782         }
 783     }
 784     /// <summary>Method to raise event ScrollDragStartEvt.</summary>
 785     public void OnScrollDragStartEvt(EventArgs e)
 786     {
 787         var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 788         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 789         if (desc == IntPtr.Zero)
 790         {
 791             Eina.Log.Error($"Failed to get native event {key}");
 792             return;
 793         }
 794
 795         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 796     }
 797     /// <summary>Called when scroll drag stops</summary>
 798     public event EventHandler ScrollDragStopEvt
 799     {
 800         add
 801         {
 802             lock (eflBindingEventLock)
 803             {
 804                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 805                 {
 806                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 807                     if (obj != null)
 808                     {
 809                         EventArgs args = EventArgs.Empty;
 810                         try
 811                         {
 812                             value?.Invoke(obj, args);
 813                         }
 814                         catch (Exception e)
 815                         {
 816                             Eina.Log.Error(e.ToString());
 817                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 818                         }
 819                     }
 820                 };
 821
 822                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 823                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 824             }
 825         }
 826
 827         remove
 828         {
 829             lock (eflBindingEventLock)
 830             {
 831                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 832                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 833             }
 834         }
 835     }
 836     /// <summary>Method to raise event ScrollDragStopEvt.</summary>
 837     public void OnScrollDragStopEvt(EventArgs e)
 838     {
 839         var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 840         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 841         if (desc == IntPtr.Zero)
 842         {
 843             Eina.Log.Error($"Failed to get native event {key}");
 844             return;
 845         }
 846
 847         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 848     }
 849     /// <summary>Called when bar is pressed.</summary>
 850     /// <value><see cref="Efl.Ui.IScrollbarBarPressEvt_Args"/></value>
 851     public event EventHandler<Efl.Ui.IScrollbarBarPressEvt_Args> BarPressEvt
 852     {
 853         add
 854         {
 855             lock (eflBindingEventLock)
 856             {
 857                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 858                 {
 859                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 860                     if (obj != null)
 861                     {
 862                         Efl.Ui.IScrollbarBarPressEvt_Args args = new Efl.Ui.IScrollbarBarPressEvt_Args();
 863                         args.arg =  (Efl.Ui.LayoutOrientation)evt.Info;
 864                         try
 865                         {
 866                             value?.Invoke(obj, args);
 867                         }
 868                         catch (Exception e)
 869                         {
 870                             Eina.Log.Error(e.ToString());
 871                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 872                         }
 873                     }
 874                 };
 875
 876                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
 877                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 878             }
 879         }
 880
 881         remove
 882         {
 883             lock (eflBindingEventLock)
 884             {
 885                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
 886                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 887             }
 888         }
 889     }
 890     /// <summary>Method to raise event BarPressEvt.</summary>
 891     public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
 892     {
 893         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
 894         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 895         if (desc == IntPtr.Zero)
 896         {
 897             Eina.Log.Error($"Failed to get native event {key}");
 898             return;
 899         }
 900
 901         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 902         try
 903         {
 904             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 905         }
 906         finally
 907         {
 908             Marshal.FreeHGlobal(info);
 909         }
 910     }
 911     /// <summary>Called when bar is unpressed.</summary>
 912     /// <value><see cref="Efl.Ui.IScrollbarBarUnpressEvt_Args"/></value>
 913     public event EventHandler<Efl.Ui.IScrollbarBarUnpressEvt_Args> BarUnpressEvt
 914     {
 915         add
 916         {
 917             lock (eflBindingEventLock)
 918             {
 919                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 920                 {
 921                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 922                     if (obj != null)
 923                     {
 924                         Efl.Ui.IScrollbarBarUnpressEvt_Args args = new Efl.Ui.IScrollbarBarUnpressEvt_Args();
 925                         args.arg =  (Efl.Ui.LayoutOrientation)evt.Info;
 926                         try
 927                         {
 928                             value?.Invoke(obj, args);
 929                         }
 930                         catch (Exception e)
 931                         {
 932                             Eina.Log.Error(e.ToString());
 933                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 934                         }
 935                     }
 936                 };
 937
 938                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
 939                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 940             }
 941         }
 942
 943         remove
 944         {
 945             lock (eflBindingEventLock)
 946             {
 947                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
 948                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 949             }
 950         }
 951     }
 952     /// <summary>Method to raise event BarUnpressEvt.</summary>
 953     public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
 954     {
 955         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
 956         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 957         if (desc == IntPtr.Zero)
 958         {
 959             Eina.Log.Error($"Failed to get native event {key}");
 960             return;
 961         }
 962
 963         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 964         try
 965         {
 966             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 967         }
 968         finally
 969         {
 970             Marshal.FreeHGlobal(info);
 971         }
 972     }
 973     /// <summary>Called when bar is dragged.</summary>
 974     /// <value><see cref="Efl.Ui.IScrollbarBarDragEvt_Args"/></value>
 975     public event EventHandler<Efl.Ui.IScrollbarBarDragEvt_Args> BarDragEvt
 976     {
 977         add
 978         {
 979             lock (eflBindingEventLock)
 980             {
 981                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 982                 {
 983                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 984                     if (obj != null)
 985                     {
 986                         Efl.Ui.IScrollbarBarDragEvt_Args args = new Efl.Ui.IScrollbarBarDragEvt_Args();
 987                         args.arg =  (Efl.Ui.LayoutOrientation)evt.Info;
 988                         try
 989                         {
 990                             value?.Invoke(obj, args);
 991                         }
 992                         catch (Exception e)
 993                         {
 994                             Eina.Log.Error(e.ToString());
 995                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 996                         }
 997                     }
 998                 };
 999
1000                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1001                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1002             }
1003         }
1004
1005         remove
1006         {
1007             lock (eflBindingEventLock)
1008             {
1009                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1010                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1011             }
1012         }
1013     }
1014     /// <summary>Method to raise event BarDragEvt.</summary>
1015     public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
1016     {
1017         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1018         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1019         if (desc == IntPtr.Zero)
1020         {
1021             Eina.Log.Error($"Failed to get native event {key}");
1022             return;
1023         }
1024
1025         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
1026         try
1027         {
1028             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1029         }
1030         finally
1031         {
1032             Marshal.FreeHGlobal(info);
1033         }
1034     }
1035     /// <summary>Called when bar size is changed.</summary>
1036     public event EventHandler BarSizeChangedEvt
1037     {
1038         add
1039         {
1040             lock (eflBindingEventLock)
1041             {
1042                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1043                 {
1044                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
1045                     if (obj != null)
1046                     {
1047                         EventArgs args = EventArgs.Empty;
1048                         try
1049                         {
1050                             value?.Invoke(obj, args);
1051                         }
1052                         catch (Exception e)
1053                         {
1054                             Eina.Log.Error(e.ToString());
1055                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1056                         }
1057                     }
1058                 };
1059
1060                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1061                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1062             }
1063         }
1064
1065         remove
1066         {
1067             lock (eflBindingEventLock)
1068             {
1069                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1070                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1071             }
1072         }
1073     }
1074     /// <summary>Method to raise event BarSizeChangedEvt.</summary>
1075     public void OnBarSizeChangedEvt(EventArgs e)
1076     {
1077         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1078         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1079         if (desc == IntPtr.Zero)
1080         {
1081             Eina.Log.Error($"Failed to get native event {key}");
1082             return;
1083         }
1084
1085         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
1086     }
1087     /// <summary>Called when bar position is changed.</summary>
1088     public event EventHandler BarPosChangedEvt
1089     {
1090         add
1091         {
1092             lock (eflBindingEventLock)
1093             {
1094                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1095                 {
1096                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
1097                     if (obj != null)
1098                     {
1099                         EventArgs args = EventArgs.Empty;
1100                         try
1101                         {
1102                             value?.Invoke(obj, args);
1103                         }
1104                         catch (Exception e)
1105                         {
1106                             Eina.Log.Error(e.ToString());
1107                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1108                         }
1109                     }
1110                 };
1111
1112                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1113                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1114             }
1115         }
1116
1117         remove
1118         {
1119             lock (eflBindingEventLock)
1120             {
1121                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1122                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1123             }
1124         }
1125     }
1126     /// <summary>Method to raise event BarPosChangedEvt.</summary>
1127     public void OnBarPosChangedEvt(EventArgs e)
1128     {
1129         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1130         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1131         if (desc == IntPtr.Zero)
1132         {
1133             Eina.Log.Error($"Failed to get native event {key}");
1134             return;
1135         }
1136
1137         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
1138     }
1139     /// <summary>Callend when bar is shown.</summary>
1140     /// <value><see cref="Efl.Ui.IScrollbarBarShowEvt_Args"/></value>
1141     public event EventHandler<Efl.Ui.IScrollbarBarShowEvt_Args> BarShowEvt
1142     {
1143         add
1144         {
1145             lock (eflBindingEventLock)
1146             {
1147                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1148                 {
1149                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
1150                     if (obj != null)
1151                     {
1152                         Efl.Ui.IScrollbarBarShowEvt_Args args = new Efl.Ui.IScrollbarBarShowEvt_Args();
1153                         args.arg =  (Efl.Ui.LayoutOrientation)evt.Info;
1154                         try
1155                         {
1156                             value?.Invoke(obj, args);
1157                         }
1158                         catch (Exception e)
1159                         {
1160                             Eina.Log.Error(e.ToString());
1161                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1162                         }
1163                     }
1164                 };
1165
1166                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1167                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1168             }
1169         }
1170
1171         remove
1172         {
1173             lock (eflBindingEventLock)
1174             {
1175                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1176                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1177             }
1178         }
1179     }
1180     /// <summary>Method to raise event BarShowEvt.</summary>
1181     public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
1182     {
1183         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1184         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1185         if (desc == IntPtr.Zero)
1186         {
1187             Eina.Log.Error($"Failed to get native event {key}");
1188             return;
1189         }
1190
1191         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
1192         try
1193         {
1194             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1195         }
1196         finally
1197         {
1198             Marshal.FreeHGlobal(info);
1199         }
1200     }
1201     /// <summary>Called when bar is hidden.</summary>
1202     /// <value><see cref="Efl.Ui.IScrollbarBarHideEvt_Args"/></value>
1203     public event EventHandler<Efl.Ui.IScrollbarBarHideEvt_Args> BarHideEvt
1204     {
1205         add
1206         {
1207             lock (eflBindingEventLock)
1208             {
1209                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1210                 {
1211                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
1212                     if (obj != null)
1213                     {
1214                         Efl.Ui.IScrollbarBarHideEvt_Args args = new Efl.Ui.IScrollbarBarHideEvt_Args();
1215                         args.arg =  (Efl.Ui.LayoutOrientation)evt.Info;
1216                         try
1217                         {
1218                             value?.Invoke(obj, args);
1219                         }
1220                         catch (Exception e)
1221                         {
1222                             Eina.Log.Error(e.ToString());
1223                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1224                         }
1225                     }
1226                 };
1227
1228                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1229                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1230             }
1231         }
1232
1233         remove
1234         {
1235             lock (eflBindingEventLock)
1236             {
1237                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1238                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1239             }
1240         }
1241     }
1242     /// <summary>Method to raise event BarHideEvt.</summary>
1243     public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
1244     {
1245         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1246         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1247         if (desc == IntPtr.Zero)
1248         {
1249             Eina.Log.Error($"Failed to get native event {key}");
1250             return;
1251         }
1252
1253         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
1254         try
1255         {
1256             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1257         }
1258         finally
1259         {
1260             Marshal.FreeHGlobal(info);
1261         }
1262     }
1263     /// <summary>This is the internal pan object managed by scroll manager.
1264     /// This property is protected as it is meant for scrollable object implementations only, to set and access the internal pan object. If pan is set to NULL, scrolling does not work.</summary>
1265     /// <param name="pan">Pan object</param>
1266     virtual protected void SetPan(Efl.Ui.Pan pan) {
1267                                  Efl.Ui.Scroll.Manager.NativeMethods.efl_ui_scroll_manager_pan_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),pan);
1268         Eina.Error.RaiseIfUnhandledException();
1269                          }
1270     /// <summary>Whether this object should be mirrored.
1271     /// If mirrored, an object is in RTL (right to left) mode instead of LTR (left to right).</summary>
1272     /// <returns><c>true</c> for RTL, <c>false</c> for LTR (default).</returns>
1273     virtual public bool GetMirrored() {
1274          var _ret_var = Efl.Ui.II18nConcrete.NativeMethods.efl_ui_mirrored_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1275         Eina.Error.RaiseIfUnhandledException();
1276         return _ret_var;
1277  }
1278     /// <summary>Whether this object should be mirrored.
1279     /// If mirrored, an object is in RTL (right to left) mode instead of LTR (left to right).</summary>
1280     /// <param name="rtl"><c>true</c> for RTL, <c>false</c> for LTR (default).</param>
1281     virtual public void SetMirrored(bool rtl) {
1282                                  Efl.Ui.II18nConcrete.NativeMethods.efl_ui_mirrored_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),rtl);
1283         Eina.Error.RaiseIfUnhandledException();
1284                          }
1285     /// <summary>Whether the property <see cref="Efl.Ui.II18n.Mirrored"/> should be set automatically.
1286     /// If enabled, the system or application configuration will be used to set the value of <see cref="Efl.Ui.II18n.Mirrored"/>.
1287     ///
1288     /// This property may be implemented by high-level widgets (in Efl.Ui) but not by low-level widgets (in <see cref="Efl.Canvas.IScene"/>) as the configuration should affect only high-level widgets.</summary>
1289     /// <returns>Whether the widget uses automatic mirroring</returns>
1290     virtual public bool GetMirroredAutomatic() {
1291          var _ret_var = Efl.Ui.II18nConcrete.NativeMethods.efl_ui_mirrored_automatic_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1292         Eina.Error.RaiseIfUnhandledException();
1293         return _ret_var;
1294  }
1295     /// <summary>Whether the property <see cref="Efl.Ui.II18n.Mirrored"/> should be set automatically.
1296     /// If enabled, the system or application configuration will be used to set the value of <see cref="Efl.Ui.II18n.Mirrored"/>.
1297     ///
1298     /// This property may be implemented by high-level widgets (in Efl.Ui) but not by low-level widgets (in <see cref="Efl.Canvas.IScene"/>) as the configuration should affect only high-level widgets.</summary>
1299     /// <param name="automatic">Whether the widget uses automatic mirroring</param>
1300     virtual public void SetMirroredAutomatic(bool automatic) {
1301                                  Efl.Ui.II18nConcrete.NativeMethods.efl_ui_mirrored_automatic_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),automatic);
1302         Eina.Error.RaiseIfUnhandledException();
1303                          }
1304     /// <summary>Gets the language for this object.</summary>
1305     /// <returns>The current language.</returns>
1306     virtual public System.String GetLanguage() {
1307          var _ret_var = Efl.Ui.II18nConcrete.NativeMethods.efl_ui_language_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1308         Eina.Error.RaiseIfUnhandledException();
1309         return _ret_var;
1310  }
1311     /// <summary>Sets the language for this object.</summary>
1312     /// <param name="language">The current language.</param>
1313     virtual public void SetLanguage(System.String language) {
1314                                  Efl.Ui.II18nConcrete.NativeMethods.efl_ui_language_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),language);
1315         Eina.Error.RaiseIfUnhandledException();
1316                          }
1317     /// <summary>The content position</summary>
1318     /// <returns>The position is virtual value, (0, 0) starting at the top-left.</returns>
1319     virtual public Eina.Position2D GetContentPos() {
1320          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_content_pos_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1321         Eina.Error.RaiseIfUnhandledException();
1322         return _ret_var;
1323  }
1324     /// <summary>The content position</summary>
1325     /// <param name="pos">The position is virtual value, (0, 0) starting at the top-left.</param>
1326     virtual public void SetContentPos(Eina.Position2D pos) {
1327          Eina.Position2D.NativeStruct _in_pos = pos;
1328                         Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_content_pos_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_pos);
1329         Eina.Error.RaiseIfUnhandledException();
1330                          }
1331     /// <summary>The content size</summary>
1332     /// <returns>The content size in pixels.</returns>
1333     virtual public Eina.Size2D GetContentSize() {
1334          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_content_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1335         Eina.Error.RaiseIfUnhandledException();
1336         return _ret_var;
1337  }
1338     /// <summary>The viewport geometry</summary>
1339     /// <returns>It is absolute geometry.</returns>
1340     virtual public Eina.Rect GetViewportGeometry() {
1341          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_viewport_geometry_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1342         Eina.Error.RaiseIfUnhandledException();
1343         return _ret_var;
1344  }
1345     /// <summary>Bouncing behavior
1346     /// 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>
1347     /// <param name="horiz">Horizontal bounce policy.</param>
1348     /// <param name="vert">Vertical bounce policy.</param>
1349     virtual public void GetBounceEnabled(out bool horiz, out bool vert) {
1350                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_bounce_enabled_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out horiz, out vert);
1351         Eina.Error.RaiseIfUnhandledException();
1352                                          }
1353     /// <summary>Bouncing behavior
1354     /// 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>
1355     /// <param name="horiz">Horizontal bounce policy.</param>
1356     /// <param name="vert">Vertical bounce policy.</param>
1357     virtual public void SetBounceEnabled(bool horiz, bool vert) {
1358                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_bounce_enabled_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),horiz, vert);
1359         Eina.Error.RaiseIfUnhandledException();
1360                                          }
1361     /// <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>
1362     /// <returns><c>true</c> if freeze, <c>false</c> otherwise</returns>
1363     virtual public bool GetScrollFreeze() {
1364          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_freeze_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1365         Eina.Error.RaiseIfUnhandledException();
1366         return _ret_var;
1367  }
1368     /// <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>
1369     /// <param name="freeze"><c>true</c> if freeze, <c>false</c> otherwise</param>
1370     virtual public void SetScrollFreeze(bool freeze) {
1371                                  Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_freeze_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),freeze);
1372         Eina.Error.RaiseIfUnhandledException();
1373                          }
1374     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1375     /// <returns><c>true</c> if hold, <c>false</c> otherwise</returns>
1376     virtual public bool GetScrollHold() {
1377          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_hold_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1378         Eina.Error.RaiseIfUnhandledException();
1379         return _ret_var;
1380  }
1381     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1382     /// <param name="hold"><c>true</c> if hold, <c>false</c> otherwise</param>
1383     virtual public void SetScrollHold(bool hold) {
1384                                  Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_hold_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),hold);
1385         Eina.Error.RaiseIfUnhandledException();
1386                          }
1387     /// <summary>Controls an infinite loop for a scroller.</summary>
1388     /// <param name="loop_h">The scrolling horizontal loop</param>
1389     /// <param name="loop_v">The Scrolling vertical loop</param>
1390     virtual public void GetLooping(out bool loop_h, out bool loop_v) {
1391                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_looping_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out loop_h, out loop_v);
1392         Eina.Error.RaiseIfUnhandledException();
1393                                          }
1394     /// <summary>Controls an infinite loop for a scroller.</summary>
1395     /// <param name="loop_h">The scrolling horizontal loop</param>
1396     /// <param name="loop_v">The Scrolling vertical loop</param>
1397     virtual public void SetLooping(bool loop_h, bool loop_v) {
1398                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_looping_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),loop_h, loop_v);
1399         Eina.Error.RaiseIfUnhandledException();
1400                                          }
1401     /// <summary>Blocking of scrolling (per axis)
1402     /// 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>
1403     /// <returns>Which axis (or axes) to block</returns>
1404     virtual public Efl.Ui.ScrollBlock GetMovementBlock() {
1405          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_movement_block_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1406         Eina.Error.RaiseIfUnhandledException();
1407         return _ret_var;
1408  }
1409     /// <summary>Blocking of scrolling (per axis)
1410     /// 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>
1411     /// <param name="block">Which axis (or axes) to block</param>
1412     virtual public void SetMovementBlock(Efl.Ui.ScrollBlock block) {
1413                                  Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_movement_block_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),block);
1414         Eina.Error.RaiseIfUnhandledException();
1415                          }
1416     /// <summary>Control scrolling gravity on the scrollable
1417     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1418     ///
1419     /// The scroller will adjust the view to glue itself as follows.
1420     ///
1421     /// 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
1422     ///
1423     /// Default values for x and y are 0.0</summary>
1424     /// <param name="x">Horizontal scrolling gravity</param>
1425     /// <param name="y">Vertical scrolling gravity</param>
1426     virtual public void GetGravity(out double x, out double y) {
1427                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_gravity_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out x, out y);
1428         Eina.Error.RaiseIfUnhandledException();
1429                                          }
1430     /// <summary>Control scrolling gravity on the scrollable
1431     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1432     ///
1433     /// The scroller will adjust the view to glue itself as follows.
1434     ///
1435     /// 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
1436     ///
1437     /// Default values for x and y are 0.0</summary>
1438     /// <param name="x">Horizontal scrolling gravity</param>
1439     /// <param name="y">Vertical scrolling gravity</param>
1440     virtual public void SetGravity(double x, double y) {
1441                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_gravity_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),x, y);
1442         Eina.Error.RaiseIfUnhandledException();
1443                                          }
1444     /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
1445     /// 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>
1446     /// <param name="w">Whether to limit the minimum horizontal size</param>
1447     /// <param name="h">Whether to limit the minimum vertical size</param>
1448     virtual public void SetMatchContent(bool w, bool h) {
1449                                                          Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_match_content_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),w, h);
1450         Eina.Error.RaiseIfUnhandledException();
1451                                          }
1452     /// <summary>Control the step size
1453     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1454     /// <returns>The step size in pixels</returns>
1455     virtual public Eina.Position2D GetStepSize() {
1456          var _ret_var = Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_step_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1457         Eina.Error.RaiseIfUnhandledException();
1458         return _ret_var;
1459  }
1460     /// <summary>Control the step size
1461     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1462     /// <param name="step">The step size in pixels</param>
1463     virtual public void SetStepSize(Eina.Position2D step) {
1464          Eina.Position2D.NativeStruct _in_step = step;
1465                         Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_step_size_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_step);
1466         Eina.Error.RaiseIfUnhandledException();
1467                          }
1468     /// <summary>Show a specific virtual region within the scroller content object.
1469     /// 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>
1470     /// <param name="rect">The position where to scroll. and The size user want to see</param>
1471     /// <param name="animation">Whether to scroll with animation or not</param>
1472     virtual public void Scroll(Eina.Rect rect, bool animation) {
1473          Eina.Rect.NativeStruct _in_rect = rect;
1474                                                 Efl.Ui.IScrollableInteractiveConcrete.NativeMethods.efl_ui_scrollable_scroll_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_rect, animation);
1475         Eina.Error.RaiseIfUnhandledException();
1476                                          }
1477     /// <summary>Scrollbar visibility policy</summary>
1478     /// <param name="hbar">Horizontal scrollbar.</param>
1479     /// <param name="vbar">Vertical scrollbar.</param>
1480     virtual public void GetBarMode(out Efl.Ui.ScrollbarMode hbar, out Efl.Ui.ScrollbarMode vbar) {
1481                                                          Efl.Ui.IScrollbarConcrete.NativeMethods.efl_ui_scrollbar_bar_mode_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out hbar, out vbar);
1482         Eina.Error.RaiseIfUnhandledException();
1483                                          }
1484     /// <summary>Scrollbar visibility policy</summary>
1485     /// <param name="hbar">Horizontal scrollbar.</param>
1486     /// <param name="vbar">Vertical scrollbar.</param>
1487     virtual public void SetBarMode(Efl.Ui.ScrollbarMode hbar, Efl.Ui.ScrollbarMode vbar) {
1488                                                          Efl.Ui.IScrollbarConcrete.NativeMethods.efl_ui_scrollbar_bar_mode_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),hbar, vbar);
1489         Eina.Error.RaiseIfUnhandledException();
1490                                          }
1491     /// <summary>Scrollbar size. It is calculated based on viewport size-content sizes.</summary>
1492     /// <param name="width">Value between 0.0 and 1.0.</param>
1493     /// <param name="height">Value between 0.0 and 1.0.</param>
1494     virtual public void GetBarSize(out double width, out double height) {
1495                                                          Efl.Ui.IScrollbarConcrete.NativeMethods.efl_ui_scrollbar_bar_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out width, out height);
1496         Eina.Error.RaiseIfUnhandledException();
1497                                          }
1498     /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
1499     /// <param name="posx">Value between 0.0 and 1.0.</param>
1500     /// <param name="posy">Value between 0.0 and 1.0.</param>
1501     virtual public void GetBarPosition(out double posx, out double posy) {
1502                                                          Efl.Ui.IScrollbarConcrete.NativeMethods.efl_ui_scrollbar_bar_position_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out posx, out posy);
1503         Eina.Error.RaiseIfUnhandledException();
1504                                          }
1505     /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
1506     /// <param name="posx">Value between 0.0 and 1.0.</param>
1507     /// <param name="posy">Value between 0.0 and 1.0.</param>
1508     virtual public void SetBarPosition(double posx, double posy) {
1509                                                          Efl.Ui.IScrollbarConcrete.NativeMethods.efl_ui_scrollbar_bar_position_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),posx, posy);
1510         Eina.Error.RaiseIfUnhandledException();
1511                                          }
1512     /// <summary>Update bar visibility.
1513     /// The object will call this function whenever the bar needs to be shown or hidden.</summary>
1514     virtual public void UpdateBarVisibility() {
1515          Efl.Ui.IScrollbarConcrete.NativeMethods.efl_ui_scrollbar_bar_visibility_update_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
1516         Eina.Error.RaiseIfUnhandledException();
1517          }
1518     /// <summary>This is the internal pan object managed by scroll manager.
1519     /// This property is protected as it is meant for scrollable object implementations only, to set and access the internal pan object. If pan is set to NULL, scrolling does not work.</summary>
1520     /// <value>Pan object</value>
1521     protected Efl.Ui.Pan Pan {
1522         set { SetPan(value); }
1523     }
1524     /// <summary>Whether this object should be mirrored.
1525     /// If mirrored, an object is in RTL (right to left) mode instead of LTR (left to right).</summary>
1526     /// <value><c>true</c> for RTL, <c>false</c> for LTR (default).</value>
1527     public bool Mirrored {
1528         get { return GetMirrored(); }
1529         set { SetMirrored(value); }
1530     }
1531     /// <summary>Whether the property <see cref="Efl.Ui.II18n.Mirrored"/> should be set automatically.
1532     /// If enabled, the system or application configuration will be used to set the value of <see cref="Efl.Ui.II18n.Mirrored"/>.
1533     ///
1534     /// This property may be implemented by high-level widgets (in Efl.Ui) but not by low-level widgets (in <see cref="Efl.Canvas.IScene"/>) as the configuration should affect only high-level widgets.</summary>
1535     /// <value>Whether the widget uses automatic mirroring</value>
1536     public bool MirroredAutomatic {
1537         get { return GetMirroredAutomatic(); }
1538         set { SetMirroredAutomatic(value); }
1539     }
1540     /// <summary>The (human) language for this object.</summary>
1541     /// <value>The current language.</value>
1542     public System.String Language {
1543         get { return GetLanguage(); }
1544         set { SetLanguage(value); }
1545     }
1546     /// <summary>The content position</summary>
1547     /// <value>The position is virtual value, (0, 0) starting at the top-left.</value>
1548     public Eina.Position2D ContentPos {
1549         get { return GetContentPos(); }
1550         set { SetContentPos(value); }
1551     }
1552     /// <summary>The content size</summary>
1553     /// <value>The content size in pixels.</value>
1554     public Eina.Size2D ContentSize {
1555         get { return GetContentSize(); }
1556     }
1557     /// <summary>The viewport geometry</summary>
1558     /// <value>It is absolute geometry.</value>
1559     public Eina.Rect ViewportGeometry {
1560         get { return GetViewportGeometry(); }
1561     }
1562     /// <summary>Bouncing behavior
1563     /// 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>
1564     /// <value>Horizontal bounce policy.</value>
1565     public (bool, bool) BounceEnabled {
1566         get {
1567             bool _out_horiz = default(bool);
1568             bool _out_vert = default(bool);
1569             GetBounceEnabled(out _out_horiz,out _out_vert);
1570             return (_out_horiz,_out_vert);
1571         }
1572         set { SetBounceEnabled( value.Item1,  value.Item2); }
1573     }
1574     /// <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>
1575     /// <value><c>true</c> if freeze, <c>false</c> otherwise</value>
1576     public bool ScrollFreeze {
1577         get { return GetScrollFreeze(); }
1578         set { SetScrollFreeze(value); }
1579     }
1580     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1581     /// <value><c>true</c> if hold, <c>false</c> otherwise</value>
1582     public bool ScrollHold {
1583         get { return GetScrollHold(); }
1584         set { SetScrollHold(value); }
1585     }
1586     /// <summary>Controls an infinite loop for a scroller.</summary>
1587     /// <value>The scrolling horizontal loop</value>
1588     public (bool, bool) Looping {
1589         get {
1590             bool _out_loop_h = default(bool);
1591             bool _out_loop_v = default(bool);
1592             GetLooping(out _out_loop_h,out _out_loop_v);
1593             return (_out_loop_h,_out_loop_v);
1594         }
1595         set { SetLooping( value.Item1,  value.Item2); }
1596     }
1597     /// <summary>Blocking of scrolling (per axis)
1598     /// 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>
1599     /// <value>Which axis (or axes) to block</value>
1600     public Efl.Ui.ScrollBlock MovementBlock {
1601         get { return GetMovementBlock(); }
1602         set { SetMovementBlock(value); }
1603     }
1604     /// <summary>Control scrolling gravity on the scrollable
1605     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1606     ///
1607     /// The scroller will adjust the view to glue itself as follows.
1608     ///
1609     /// 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
1610     ///
1611     /// Default values for x and y are 0.0</summary>
1612     /// <value>Horizontal scrolling gravity</value>
1613     public (double, double) Gravity {
1614         get {
1615             double _out_x = default(double);
1616             double _out_y = default(double);
1617             GetGravity(out _out_x,out _out_y);
1618             return (_out_x,_out_y);
1619         }
1620         set { SetGravity( value.Item1,  value.Item2); }
1621     }
1622     /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
1623     /// 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>
1624     /// <value>Whether to limit the minimum horizontal size</value>
1625     public (bool, bool) MatchContent {
1626         set { SetMatchContent( value.Item1,  value.Item2); }
1627     }
1628     /// <summary>Control the step size
1629     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1630     /// <value>The step size in pixels</value>
1631     public Eina.Position2D StepSize {
1632         get { return GetStepSize(); }
1633         set { SetStepSize(value); }
1634     }
1635     /// <summary>Scrollbar visibility policy</summary>
1636     /// <value>Horizontal scrollbar.</value>
1637     public (Efl.Ui.ScrollbarMode, Efl.Ui.ScrollbarMode) BarMode {
1638         get {
1639             Efl.Ui.ScrollbarMode _out_hbar = default(Efl.Ui.ScrollbarMode);
1640             Efl.Ui.ScrollbarMode _out_vbar = default(Efl.Ui.ScrollbarMode);
1641             GetBarMode(out _out_hbar,out _out_vbar);
1642             return (_out_hbar,_out_vbar);
1643         }
1644         set { SetBarMode( value.Item1,  value.Item2); }
1645     }
1646     /// <summary>Scrollbar size. It is calculated based on viewport size-content sizes.</summary>
1647     public (double, double) BarSize {
1648         get {
1649             double _out_width = default(double);
1650             double _out_height = default(double);
1651             GetBarSize(out _out_width,out _out_height);
1652             return (_out_width,_out_height);
1653         }
1654     }
1655     /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
1656     /// <value>Value between 0.0 and 1.0.</value>
1657     public (double, double) BarPosition {
1658         get {
1659             double _out_posx = default(double);
1660             double _out_posy = default(double);
1661             GetBarPosition(out _out_posx,out _out_posy);
1662             return (_out_posx,_out_posy);
1663         }
1664         set { SetBarPosition( value.Item1,  value.Item2); }
1665     }
1666     private static IntPtr GetEflClassStatic()
1667     {
1668         return Efl.Ui.Scroll.Manager.efl_ui_scroll_manager_class_get();
1669     }
1670     /// <summary>Wrapper for native methods and virtual method delegates.
1671     /// For internal use by generated code only.</summary>
1672     public new class NativeMethods : Efl.Object.NativeMethods
1673     {
1674         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
1675         /// <summary>Gets the list of Eo operations to override.</summary>
1676         /// <returns>The list of Eo operations to be overload.</returns>
1677         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
1678         {
1679             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
1680             var methods = Efl.Eo.Globals.GetUserMethods(type);
1681
1682             if (efl_ui_scroll_manager_pan_set_static_delegate == null)
1683             {
1684                 efl_ui_scroll_manager_pan_set_static_delegate = new efl_ui_scroll_manager_pan_set_delegate(pan_set);
1685             }
1686
1687             if (methods.FirstOrDefault(m => m.Name == "SetPan") != null)
1688             {
1689                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scroll_manager_pan_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scroll_manager_pan_set_static_delegate) });
1690             }
1691
1692             if (efl_ui_mirrored_get_static_delegate == null)
1693             {
1694                 efl_ui_mirrored_get_static_delegate = new efl_ui_mirrored_get_delegate(mirrored_get);
1695             }
1696
1697             if (methods.FirstOrDefault(m => m.Name == "GetMirrored") != null)
1698             {
1699                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_mirrored_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_mirrored_get_static_delegate) });
1700             }
1701
1702             if (efl_ui_mirrored_set_static_delegate == null)
1703             {
1704                 efl_ui_mirrored_set_static_delegate = new efl_ui_mirrored_set_delegate(mirrored_set);
1705             }
1706
1707             if (methods.FirstOrDefault(m => m.Name == "SetMirrored") != null)
1708             {
1709                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_mirrored_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_mirrored_set_static_delegate) });
1710             }
1711
1712             if (efl_ui_mirrored_automatic_get_static_delegate == null)
1713             {
1714                 efl_ui_mirrored_automatic_get_static_delegate = new efl_ui_mirrored_automatic_get_delegate(mirrored_automatic_get);
1715             }
1716
1717             if (methods.FirstOrDefault(m => m.Name == "GetMirroredAutomatic") != null)
1718             {
1719                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_mirrored_automatic_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_mirrored_automatic_get_static_delegate) });
1720             }
1721
1722             if (efl_ui_mirrored_automatic_set_static_delegate == null)
1723             {
1724                 efl_ui_mirrored_automatic_set_static_delegate = new efl_ui_mirrored_automatic_set_delegate(mirrored_automatic_set);
1725             }
1726
1727             if (methods.FirstOrDefault(m => m.Name == "SetMirroredAutomatic") != null)
1728             {
1729                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_mirrored_automatic_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_mirrored_automatic_set_static_delegate) });
1730             }
1731
1732             if (efl_ui_language_get_static_delegate == null)
1733             {
1734                 efl_ui_language_get_static_delegate = new efl_ui_language_get_delegate(language_get);
1735             }
1736
1737             if (methods.FirstOrDefault(m => m.Name == "GetLanguage") != null)
1738             {
1739                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_language_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_language_get_static_delegate) });
1740             }
1741
1742             if (efl_ui_language_set_static_delegate == null)
1743             {
1744                 efl_ui_language_set_static_delegate = new efl_ui_language_set_delegate(language_set);
1745             }
1746
1747             if (methods.FirstOrDefault(m => m.Name == "SetLanguage") != null)
1748             {
1749                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_language_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_language_set_static_delegate) });
1750             }
1751
1752             if (efl_ui_scrollable_content_pos_get_static_delegate == null)
1753             {
1754                 efl_ui_scrollable_content_pos_get_static_delegate = new efl_ui_scrollable_content_pos_get_delegate(content_pos_get);
1755             }
1756
1757             if (methods.FirstOrDefault(m => m.Name == "GetContentPos") != null)
1758             {
1759                 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) });
1760             }
1761
1762             if (efl_ui_scrollable_content_pos_set_static_delegate == null)
1763             {
1764                 efl_ui_scrollable_content_pos_set_static_delegate = new efl_ui_scrollable_content_pos_set_delegate(content_pos_set);
1765             }
1766
1767             if (methods.FirstOrDefault(m => m.Name == "SetContentPos") != null)
1768             {
1769                 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) });
1770             }
1771
1772             if (efl_ui_scrollable_content_size_get_static_delegate == null)
1773             {
1774                 efl_ui_scrollable_content_size_get_static_delegate = new efl_ui_scrollable_content_size_get_delegate(content_size_get);
1775             }
1776
1777             if (methods.FirstOrDefault(m => m.Name == "GetContentSize") != null)
1778             {
1779                 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) });
1780             }
1781
1782             if (efl_ui_scrollable_viewport_geometry_get_static_delegate == null)
1783             {
1784                 efl_ui_scrollable_viewport_geometry_get_static_delegate = new efl_ui_scrollable_viewport_geometry_get_delegate(viewport_geometry_get);
1785             }
1786
1787             if (methods.FirstOrDefault(m => m.Name == "GetViewportGeometry") != null)
1788             {
1789                 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) });
1790             }
1791
1792             if (efl_ui_scrollable_bounce_enabled_get_static_delegate == null)
1793             {
1794                 efl_ui_scrollable_bounce_enabled_get_static_delegate = new efl_ui_scrollable_bounce_enabled_get_delegate(bounce_enabled_get);
1795             }
1796
1797             if (methods.FirstOrDefault(m => m.Name == "GetBounceEnabled") != null)
1798             {
1799                 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) });
1800             }
1801
1802             if (efl_ui_scrollable_bounce_enabled_set_static_delegate == null)
1803             {
1804                 efl_ui_scrollable_bounce_enabled_set_static_delegate = new efl_ui_scrollable_bounce_enabled_set_delegate(bounce_enabled_set);
1805             }
1806
1807             if (methods.FirstOrDefault(m => m.Name == "SetBounceEnabled") != null)
1808             {
1809                 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) });
1810             }
1811
1812             if (efl_ui_scrollable_scroll_freeze_get_static_delegate == null)
1813             {
1814                 efl_ui_scrollable_scroll_freeze_get_static_delegate = new efl_ui_scrollable_scroll_freeze_get_delegate(scroll_freeze_get);
1815             }
1816
1817             if (methods.FirstOrDefault(m => m.Name == "GetScrollFreeze") != null)
1818             {
1819                 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) });
1820             }
1821
1822             if (efl_ui_scrollable_scroll_freeze_set_static_delegate == null)
1823             {
1824                 efl_ui_scrollable_scroll_freeze_set_static_delegate = new efl_ui_scrollable_scroll_freeze_set_delegate(scroll_freeze_set);
1825             }
1826
1827             if (methods.FirstOrDefault(m => m.Name == "SetScrollFreeze") != null)
1828             {
1829                 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) });
1830             }
1831
1832             if (efl_ui_scrollable_scroll_hold_get_static_delegate == null)
1833             {
1834                 efl_ui_scrollable_scroll_hold_get_static_delegate = new efl_ui_scrollable_scroll_hold_get_delegate(scroll_hold_get);
1835             }
1836
1837             if (methods.FirstOrDefault(m => m.Name == "GetScrollHold") != null)
1838             {
1839                 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) });
1840             }
1841
1842             if (efl_ui_scrollable_scroll_hold_set_static_delegate == null)
1843             {
1844                 efl_ui_scrollable_scroll_hold_set_static_delegate = new efl_ui_scrollable_scroll_hold_set_delegate(scroll_hold_set);
1845             }
1846
1847             if (methods.FirstOrDefault(m => m.Name == "SetScrollHold") != null)
1848             {
1849                 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) });
1850             }
1851
1852             if (efl_ui_scrollable_looping_get_static_delegate == null)
1853             {
1854                 efl_ui_scrollable_looping_get_static_delegate = new efl_ui_scrollable_looping_get_delegate(looping_get);
1855             }
1856
1857             if (methods.FirstOrDefault(m => m.Name == "GetLooping") != null)
1858             {
1859                 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) });
1860             }
1861
1862             if (efl_ui_scrollable_looping_set_static_delegate == null)
1863             {
1864                 efl_ui_scrollable_looping_set_static_delegate = new efl_ui_scrollable_looping_set_delegate(looping_set);
1865             }
1866
1867             if (methods.FirstOrDefault(m => m.Name == "SetLooping") != null)
1868             {
1869                 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) });
1870             }
1871
1872             if (efl_ui_scrollable_movement_block_get_static_delegate == null)
1873             {
1874                 efl_ui_scrollable_movement_block_get_static_delegate = new efl_ui_scrollable_movement_block_get_delegate(movement_block_get);
1875             }
1876
1877             if (methods.FirstOrDefault(m => m.Name == "GetMovementBlock") != null)
1878             {
1879                 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) });
1880             }
1881
1882             if (efl_ui_scrollable_movement_block_set_static_delegate == null)
1883             {
1884                 efl_ui_scrollable_movement_block_set_static_delegate = new efl_ui_scrollable_movement_block_set_delegate(movement_block_set);
1885             }
1886
1887             if (methods.FirstOrDefault(m => m.Name == "SetMovementBlock") != null)
1888             {
1889                 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) });
1890             }
1891
1892             if (efl_ui_scrollable_gravity_get_static_delegate == null)
1893             {
1894                 efl_ui_scrollable_gravity_get_static_delegate = new efl_ui_scrollable_gravity_get_delegate(gravity_get);
1895             }
1896
1897             if (methods.FirstOrDefault(m => m.Name == "GetGravity") != null)
1898             {
1899                 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) });
1900             }
1901
1902             if (efl_ui_scrollable_gravity_set_static_delegate == null)
1903             {
1904                 efl_ui_scrollable_gravity_set_static_delegate = new efl_ui_scrollable_gravity_set_delegate(gravity_set);
1905             }
1906
1907             if (methods.FirstOrDefault(m => m.Name == "SetGravity") != null)
1908             {
1909                 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) });
1910             }
1911
1912             if (efl_ui_scrollable_match_content_set_static_delegate == null)
1913             {
1914                 efl_ui_scrollable_match_content_set_static_delegate = new efl_ui_scrollable_match_content_set_delegate(match_content_set);
1915             }
1916
1917             if (methods.FirstOrDefault(m => m.Name == "SetMatchContent") != null)
1918             {
1919                 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) });
1920             }
1921
1922             if (efl_ui_scrollable_step_size_get_static_delegate == null)
1923             {
1924                 efl_ui_scrollable_step_size_get_static_delegate = new efl_ui_scrollable_step_size_get_delegate(step_size_get);
1925             }
1926
1927             if (methods.FirstOrDefault(m => m.Name == "GetStepSize") != null)
1928             {
1929                 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) });
1930             }
1931
1932             if (efl_ui_scrollable_step_size_set_static_delegate == null)
1933             {
1934                 efl_ui_scrollable_step_size_set_static_delegate = new efl_ui_scrollable_step_size_set_delegate(step_size_set);
1935             }
1936
1937             if (methods.FirstOrDefault(m => m.Name == "SetStepSize") != null)
1938             {
1939                 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) });
1940             }
1941
1942             if (efl_ui_scrollable_scroll_static_delegate == null)
1943             {
1944                 efl_ui_scrollable_scroll_static_delegate = new efl_ui_scrollable_scroll_delegate(scroll);
1945             }
1946
1947             if (methods.FirstOrDefault(m => m.Name == "Scroll") != null)
1948             {
1949                 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) });
1950             }
1951
1952             if (efl_ui_scrollbar_bar_mode_get_static_delegate == null)
1953             {
1954                 efl_ui_scrollbar_bar_mode_get_static_delegate = new efl_ui_scrollbar_bar_mode_get_delegate(bar_mode_get);
1955             }
1956
1957             if (methods.FirstOrDefault(m => m.Name == "GetBarMode") != null)
1958             {
1959                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollbar_bar_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_mode_get_static_delegate) });
1960             }
1961
1962             if (efl_ui_scrollbar_bar_mode_set_static_delegate == null)
1963             {
1964                 efl_ui_scrollbar_bar_mode_set_static_delegate = new efl_ui_scrollbar_bar_mode_set_delegate(bar_mode_set);
1965             }
1966
1967             if (methods.FirstOrDefault(m => m.Name == "SetBarMode") != null)
1968             {
1969                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollbar_bar_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_mode_set_static_delegate) });
1970             }
1971
1972             if (efl_ui_scrollbar_bar_size_get_static_delegate == null)
1973             {
1974                 efl_ui_scrollbar_bar_size_get_static_delegate = new efl_ui_scrollbar_bar_size_get_delegate(bar_size_get);
1975             }
1976
1977             if (methods.FirstOrDefault(m => m.Name == "GetBarSize") != null)
1978             {
1979                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollbar_bar_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_size_get_static_delegate) });
1980             }
1981
1982             if (efl_ui_scrollbar_bar_position_get_static_delegate == null)
1983             {
1984                 efl_ui_scrollbar_bar_position_get_static_delegate = new efl_ui_scrollbar_bar_position_get_delegate(bar_position_get);
1985             }
1986
1987             if (methods.FirstOrDefault(m => m.Name == "GetBarPosition") != null)
1988             {
1989                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollbar_bar_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_position_get_static_delegate) });
1990             }
1991
1992             if (efl_ui_scrollbar_bar_position_set_static_delegate == null)
1993             {
1994                 efl_ui_scrollbar_bar_position_set_static_delegate = new efl_ui_scrollbar_bar_position_set_delegate(bar_position_set);
1995             }
1996
1997             if (methods.FirstOrDefault(m => m.Name == "SetBarPosition") != null)
1998             {
1999                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollbar_bar_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_position_set_static_delegate) });
2000             }
2001
2002             if (efl_ui_scrollbar_bar_visibility_update_static_delegate == null)
2003             {
2004                 efl_ui_scrollbar_bar_visibility_update_static_delegate = new efl_ui_scrollbar_bar_visibility_update_delegate(bar_visibility_update);
2005             }
2006
2007             if (methods.FirstOrDefault(m => m.Name == "UpdateBarVisibility") != null)
2008             {
2009                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_scrollbar_bar_visibility_update"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_scrollbar_bar_visibility_update_static_delegate) });
2010             }
2011
2012             descs.AddRange(base.GetEoOps(type));
2013             return descs;
2014         }
2015         /// <summary>Returns the Eo class for the native methods of this class.</summary>
2016         /// <returns>The native class pointer.</returns>
2017         public override IntPtr GetEflClass()
2018         {
2019             return Efl.Ui.Scroll.Manager.efl_ui_scroll_manager_class_get();
2020         }
2021
2022         #pragma warning disable CA1707, CS1591, SA1300, SA1600
2023
2024
2025         private delegate void efl_ui_scroll_manager_pan_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Pan pan);
2026
2027
2028         public delegate void efl_ui_scroll_manager_pan_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Pan pan);
2029
2030         public static Efl.Eo.FunctionWrapper<efl_ui_scroll_manager_pan_set_api_delegate> efl_ui_scroll_manager_pan_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scroll_manager_pan_set_api_delegate>(Module, "efl_ui_scroll_manager_pan_set");
2031
2032         private static void pan_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Pan pan)
2033         {
2034             Eina.Log.Debug("function efl_ui_scroll_manager_pan_set was called");
2035             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2036             if (ws != null)
2037             {
2038
2039                 try
2040                 {
2041                     ((Manager)ws.Target).SetPan(pan);
2042                 }
2043                 catch (Exception e)
2044                 {
2045                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2046                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2047                 }
2048
2049
2050             }
2051             else
2052             {
2053                 efl_ui_scroll_manager_pan_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pan);
2054             }
2055         }
2056
2057         private static efl_ui_scroll_manager_pan_set_delegate efl_ui_scroll_manager_pan_set_static_delegate;
2058
2059         [return: MarshalAs(UnmanagedType.U1)]
2060         private delegate bool efl_ui_mirrored_get_delegate(System.IntPtr obj, System.IntPtr pd);
2061
2062         [return: MarshalAs(UnmanagedType.U1)]
2063         public delegate bool efl_ui_mirrored_get_api_delegate(System.IntPtr obj);
2064
2065         public static Efl.Eo.FunctionWrapper<efl_ui_mirrored_get_api_delegate> efl_ui_mirrored_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_mirrored_get_api_delegate>(Module, "efl_ui_mirrored_get");
2066
2067         private static bool mirrored_get(System.IntPtr obj, System.IntPtr pd)
2068         {
2069             Eina.Log.Debug("function efl_ui_mirrored_get was called");
2070             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2071             if (ws != null)
2072             {
2073             bool _ret_var = default(bool);
2074                 try
2075                 {
2076                     _ret_var = ((Manager)ws.Target).GetMirrored();
2077                 }
2078                 catch (Exception e)
2079                 {
2080                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2081                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2082                 }
2083
2084         return _ret_var;
2085
2086             }
2087             else
2088             {
2089                 return efl_ui_mirrored_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2090             }
2091         }
2092
2093         private static efl_ui_mirrored_get_delegate efl_ui_mirrored_get_static_delegate;
2094
2095
2096         private delegate void efl_ui_mirrored_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool rtl);
2097
2098
2099         public delegate void efl_ui_mirrored_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool rtl);
2100
2101         public static Efl.Eo.FunctionWrapper<efl_ui_mirrored_set_api_delegate> efl_ui_mirrored_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_mirrored_set_api_delegate>(Module, "efl_ui_mirrored_set");
2102
2103         private static void mirrored_set(System.IntPtr obj, System.IntPtr pd, bool rtl)
2104         {
2105             Eina.Log.Debug("function efl_ui_mirrored_set was called");
2106             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2107             if (ws != null)
2108             {
2109
2110                 try
2111                 {
2112                     ((Manager)ws.Target).SetMirrored(rtl);
2113                 }
2114                 catch (Exception e)
2115                 {
2116                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2117                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2118                 }
2119
2120
2121             }
2122             else
2123             {
2124                 efl_ui_mirrored_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rtl);
2125             }
2126         }
2127
2128         private static efl_ui_mirrored_set_delegate efl_ui_mirrored_set_static_delegate;
2129
2130         [return: MarshalAs(UnmanagedType.U1)]
2131         private delegate bool efl_ui_mirrored_automatic_get_delegate(System.IntPtr obj, System.IntPtr pd);
2132
2133         [return: MarshalAs(UnmanagedType.U1)]
2134         public delegate bool efl_ui_mirrored_automatic_get_api_delegate(System.IntPtr obj);
2135
2136         public static Efl.Eo.FunctionWrapper<efl_ui_mirrored_automatic_get_api_delegate> efl_ui_mirrored_automatic_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_mirrored_automatic_get_api_delegate>(Module, "efl_ui_mirrored_automatic_get");
2137
2138         private static bool mirrored_automatic_get(System.IntPtr obj, System.IntPtr pd)
2139         {
2140             Eina.Log.Debug("function efl_ui_mirrored_automatic_get was called");
2141             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2142             if (ws != null)
2143             {
2144             bool _ret_var = default(bool);
2145                 try
2146                 {
2147                     _ret_var = ((Manager)ws.Target).GetMirroredAutomatic();
2148                 }
2149                 catch (Exception e)
2150                 {
2151                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2152                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2153                 }
2154
2155         return _ret_var;
2156
2157             }
2158             else
2159             {
2160                 return efl_ui_mirrored_automatic_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2161             }
2162         }
2163
2164         private static efl_ui_mirrored_automatic_get_delegate efl_ui_mirrored_automatic_get_static_delegate;
2165
2166
2167         private delegate void efl_ui_mirrored_automatic_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool automatic);
2168
2169
2170         public delegate void efl_ui_mirrored_automatic_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool automatic);
2171
2172         public static Efl.Eo.FunctionWrapper<efl_ui_mirrored_automatic_set_api_delegate> efl_ui_mirrored_automatic_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_mirrored_automatic_set_api_delegate>(Module, "efl_ui_mirrored_automatic_set");
2173
2174         private static void mirrored_automatic_set(System.IntPtr obj, System.IntPtr pd, bool automatic)
2175         {
2176             Eina.Log.Debug("function efl_ui_mirrored_automatic_set was called");
2177             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2178             if (ws != null)
2179             {
2180
2181                 try
2182                 {
2183                     ((Manager)ws.Target).SetMirroredAutomatic(automatic);
2184                 }
2185                 catch (Exception e)
2186                 {
2187                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2188                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2189                 }
2190
2191
2192             }
2193             else
2194             {
2195                 efl_ui_mirrored_automatic_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), automatic);
2196             }
2197         }
2198
2199         private static efl_ui_mirrored_automatic_set_delegate efl_ui_mirrored_automatic_set_static_delegate;
2200
2201         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2202         private delegate System.String efl_ui_language_get_delegate(System.IntPtr obj, System.IntPtr pd);
2203
2204         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
2205         public delegate System.String efl_ui_language_get_api_delegate(System.IntPtr obj);
2206
2207         public static Efl.Eo.FunctionWrapper<efl_ui_language_get_api_delegate> efl_ui_language_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_language_get_api_delegate>(Module, "efl_ui_language_get");
2208
2209         private static System.String language_get(System.IntPtr obj, System.IntPtr pd)
2210         {
2211             Eina.Log.Debug("function efl_ui_language_get was called");
2212             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2213             if (ws != null)
2214             {
2215             System.String _ret_var = default(System.String);
2216                 try
2217                 {
2218                     _ret_var = ((Manager)ws.Target).GetLanguage();
2219                 }
2220                 catch (Exception e)
2221                 {
2222                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2223                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2224                 }
2225
2226         return _ret_var;
2227
2228             }
2229             else
2230             {
2231                 return efl_ui_language_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2232             }
2233         }
2234
2235         private static efl_ui_language_get_delegate efl_ui_language_get_static_delegate;
2236
2237
2238         private delegate void efl_ui_language_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String language);
2239
2240
2241         public delegate void efl_ui_language_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String language);
2242
2243         public static Efl.Eo.FunctionWrapper<efl_ui_language_set_api_delegate> efl_ui_language_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_language_set_api_delegate>(Module, "efl_ui_language_set");
2244
2245         private static void language_set(System.IntPtr obj, System.IntPtr pd, System.String language)
2246         {
2247             Eina.Log.Debug("function efl_ui_language_set was called");
2248             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2249             if (ws != null)
2250             {
2251
2252                 try
2253                 {
2254                     ((Manager)ws.Target).SetLanguage(language);
2255                 }
2256                 catch (Exception e)
2257                 {
2258                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2259                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2260                 }
2261
2262
2263             }
2264             else
2265             {
2266                 efl_ui_language_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), language);
2267             }
2268         }
2269
2270         private static efl_ui_language_set_delegate efl_ui_language_set_static_delegate;
2271
2272
2273         private delegate Eina.Position2D.NativeStruct efl_ui_scrollable_content_pos_get_delegate(System.IntPtr obj, System.IntPtr pd);
2274
2275
2276         public delegate Eina.Position2D.NativeStruct efl_ui_scrollable_content_pos_get_api_delegate(System.IntPtr obj);
2277
2278         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");
2279
2280         private static Eina.Position2D.NativeStruct content_pos_get(System.IntPtr obj, System.IntPtr pd)
2281         {
2282             Eina.Log.Debug("function efl_ui_scrollable_content_pos_get was called");
2283             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2284             if (ws != null)
2285             {
2286             Eina.Position2D _ret_var = default(Eina.Position2D);
2287                 try
2288                 {
2289                     _ret_var = ((Manager)ws.Target).GetContentPos();
2290                 }
2291                 catch (Exception e)
2292                 {
2293                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2294                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2295                 }
2296
2297         return _ret_var;
2298
2299             }
2300             else
2301             {
2302                 return efl_ui_scrollable_content_pos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2303             }
2304         }
2305
2306         private static efl_ui_scrollable_content_pos_get_delegate efl_ui_scrollable_content_pos_get_static_delegate;
2307
2308
2309         private delegate void efl_ui_scrollable_content_pos_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos);
2310
2311
2312         public delegate void efl_ui_scrollable_content_pos_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos);
2313
2314         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");
2315
2316         private static void content_pos_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos)
2317         {
2318             Eina.Log.Debug("function efl_ui_scrollable_content_pos_set was called");
2319             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2320             if (ws != null)
2321             {
2322         Eina.Position2D _in_pos = pos;
2323
2324                 try
2325                 {
2326                     ((Manager)ws.Target).SetContentPos(_in_pos);
2327                 }
2328                 catch (Exception e)
2329                 {
2330                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2331                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2332                 }
2333
2334
2335             }
2336             else
2337             {
2338                 efl_ui_scrollable_content_pos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos);
2339             }
2340         }
2341
2342         private static efl_ui_scrollable_content_pos_set_delegate efl_ui_scrollable_content_pos_set_static_delegate;
2343
2344
2345         private delegate Eina.Size2D.NativeStruct efl_ui_scrollable_content_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2346
2347
2348         public delegate Eina.Size2D.NativeStruct efl_ui_scrollable_content_size_get_api_delegate(System.IntPtr obj);
2349
2350         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");
2351
2352         private static Eina.Size2D.NativeStruct content_size_get(System.IntPtr obj, System.IntPtr pd)
2353         {
2354             Eina.Log.Debug("function efl_ui_scrollable_content_size_get was called");
2355             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2356             if (ws != null)
2357             {
2358             Eina.Size2D _ret_var = default(Eina.Size2D);
2359                 try
2360                 {
2361                     _ret_var = ((Manager)ws.Target).GetContentSize();
2362                 }
2363                 catch (Exception e)
2364                 {
2365                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2366                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2367                 }
2368
2369         return _ret_var;
2370
2371             }
2372             else
2373             {
2374                 return efl_ui_scrollable_content_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2375             }
2376         }
2377
2378         private static efl_ui_scrollable_content_size_get_delegate efl_ui_scrollable_content_size_get_static_delegate;
2379
2380
2381         private delegate Eina.Rect.NativeStruct efl_ui_scrollable_viewport_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
2382
2383
2384         public delegate Eina.Rect.NativeStruct efl_ui_scrollable_viewport_geometry_get_api_delegate(System.IntPtr obj);
2385
2386         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");
2387
2388         private static Eina.Rect.NativeStruct viewport_geometry_get(System.IntPtr obj, System.IntPtr pd)
2389         {
2390             Eina.Log.Debug("function efl_ui_scrollable_viewport_geometry_get was called");
2391             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2392             if (ws != null)
2393             {
2394             Eina.Rect _ret_var = default(Eina.Rect);
2395                 try
2396                 {
2397                     _ret_var = ((Manager)ws.Target).GetViewportGeometry();
2398                 }
2399                 catch (Exception e)
2400                 {
2401                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2402                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2403                 }
2404
2405         return _ret_var;
2406
2407             }
2408             else
2409             {
2410                 return efl_ui_scrollable_viewport_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2411             }
2412         }
2413
2414         private static efl_ui_scrollable_viewport_geometry_get_delegate efl_ui_scrollable_viewport_geometry_get_static_delegate;
2415
2416
2417         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);
2418
2419
2420         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);
2421
2422         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");
2423
2424         private static void bounce_enabled_get(System.IntPtr obj, System.IntPtr pd, out bool horiz, out bool vert)
2425         {
2426             Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_get was called");
2427             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2428             if (ws != null)
2429             {
2430                         horiz = default(bool);        vert = default(bool);
2431                 try
2432                 {
2433                     ((Manager)ws.Target).GetBounceEnabled(out horiz, out vert);
2434                 }
2435                 catch (Exception e)
2436                 {
2437                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2438                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2439                 }
2440
2441
2442             }
2443             else
2444             {
2445                 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);
2446             }
2447         }
2448
2449         private static efl_ui_scrollable_bounce_enabled_get_delegate efl_ui_scrollable_bounce_enabled_get_static_delegate;
2450
2451
2452         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);
2453
2454
2455         public delegate void efl_ui_scrollable_bounce_enabled_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool horiz, [MarshalAs(UnmanagedType.U1)] bool vert);
2456
2457         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");
2458
2459         private static void bounce_enabled_set(System.IntPtr obj, System.IntPtr pd, bool horiz, bool vert)
2460         {
2461             Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_set was called");
2462             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2463             if (ws != null)
2464             {
2465
2466                 try
2467                 {
2468                     ((Manager)ws.Target).SetBounceEnabled(horiz, vert);
2469                 }
2470                 catch (Exception e)
2471                 {
2472                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2473                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2474                 }
2475
2476
2477             }
2478             else
2479             {
2480                 efl_ui_scrollable_bounce_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), horiz, vert);
2481             }
2482         }
2483
2484         private static efl_ui_scrollable_bounce_enabled_set_delegate efl_ui_scrollable_bounce_enabled_set_static_delegate;
2485
2486         [return: MarshalAs(UnmanagedType.U1)]
2487         private delegate bool efl_ui_scrollable_scroll_freeze_get_delegate(System.IntPtr obj, System.IntPtr pd);
2488
2489         [return: MarshalAs(UnmanagedType.U1)]
2490         public delegate bool efl_ui_scrollable_scroll_freeze_get_api_delegate(System.IntPtr obj);
2491
2492         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");
2493
2494         private static bool scroll_freeze_get(System.IntPtr obj, System.IntPtr pd)
2495         {
2496             Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_get was called");
2497             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2498             if (ws != null)
2499             {
2500             bool _ret_var = default(bool);
2501                 try
2502                 {
2503                     _ret_var = ((Manager)ws.Target).GetScrollFreeze();
2504                 }
2505                 catch (Exception e)
2506                 {
2507                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2508                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2509                 }
2510
2511         return _ret_var;
2512
2513             }
2514             else
2515             {
2516                 return efl_ui_scrollable_scroll_freeze_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2517             }
2518         }
2519
2520         private static efl_ui_scrollable_scroll_freeze_get_delegate efl_ui_scrollable_scroll_freeze_get_static_delegate;
2521
2522
2523         private delegate void efl_ui_scrollable_scroll_freeze_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool freeze);
2524
2525
2526         public delegate void efl_ui_scrollable_scroll_freeze_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool freeze);
2527
2528         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");
2529
2530         private static void scroll_freeze_set(System.IntPtr obj, System.IntPtr pd, bool freeze)
2531         {
2532             Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_set was called");
2533             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2534             if (ws != null)
2535             {
2536
2537                 try
2538                 {
2539                     ((Manager)ws.Target).SetScrollFreeze(freeze);
2540                 }
2541                 catch (Exception e)
2542                 {
2543                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2544                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2545                 }
2546
2547
2548             }
2549             else
2550             {
2551                 efl_ui_scrollable_scroll_freeze_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), freeze);
2552             }
2553         }
2554
2555         private static efl_ui_scrollable_scroll_freeze_set_delegate efl_ui_scrollable_scroll_freeze_set_static_delegate;
2556
2557         [return: MarshalAs(UnmanagedType.U1)]
2558         private delegate bool efl_ui_scrollable_scroll_hold_get_delegate(System.IntPtr obj, System.IntPtr pd);
2559
2560         [return: MarshalAs(UnmanagedType.U1)]
2561         public delegate bool efl_ui_scrollable_scroll_hold_get_api_delegate(System.IntPtr obj);
2562
2563         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");
2564
2565         private static bool scroll_hold_get(System.IntPtr obj, System.IntPtr pd)
2566         {
2567             Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_get was called");
2568             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2569             if (ws != null)
2570             {
2571             bool _ret_var = default(bool);
2572                 try
2573                 {
2574                     _ret_var = ((Manager)ws.Target).GetScrollHold();
2575                 }
2576                 catch (Exception e)
2577                 {
2578                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2579                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2580                 }
2581
2582         return _ret_var;
2583
2584             }
2585             else
2586             {
2587                 return efl_ui_scrollable_scroll_hold_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2588             }
2589         }
2590
2591         private static efl_ui_scrollable_scroll_hold_get_delegate efl_ui_scrollable_scroll_hold_get_static_delegate;
2592
2593
2594         private delegate void efl_ui_scrollable_scroll_hold_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool hold);
2595
2596
2597         public delegate void efl_ui_scrollable_scroll_hold_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool hold);
2598
2599         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");
2600
2601         private static void scroll_hold_set(System.IntPtr obj, System.IntPtr pd, bool hold)
2602         {
2603             Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_set was called");
2604             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2605             if (ws != null)
2606             {
2607
2608                 try
2609                 {
2610                     ((Manager)ws.Target).SetScrollHold(hold);
2611                 }
2612                 catch (Exception e)
2613                 {
2614                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2615                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2616                 }
2617
2618
2619             }
2620             else
2621             {
2622                 efl_ui_scrollable_scroll_hold_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hold);
2623             }
2624         }
2625
2626         private static efl_ui_scrollable_scroll_hold_set_delegate efl_ui_scrollable_scroll_hold_set_static_delegate;
2627
2628
2629         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);
2630
2631
2632         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);
2633
2634         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");
2635
2636         private static void looping_get(System.IntPtr obj, System.IntPtr pd, out bool loop_h, out bool loop_v)
2637         {
2638             Eina.Log.Debug("function efl_ui_scrollable_looping_get was called");
2639             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2640             if (ws != null)
2641             {
2642                         loop_h = default(bool);        loop_v = default(bool);
2643                 try
2644                 {
2645                     ((Manager)ws.Target).GetLooping(out loop_h, out loop_v);
2646                 }
2647                 catch (Exception e)
2648                 {
2649                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2650                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2651                 }
2652
2653
2654             }
2655             else
2656             {
2657                 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);
2658             }
2659         }
2660
2661         private static efl_ui_scrollable_looping_get_delegate efl_ui_scrollable_looping_get_static_delegate;
2662
2663
2664         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);
2665
2666
2667         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);
2668
2669         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");
2670
2671         private static void looping_set(System.IntPtr obj, System.IntPtr pd, bool loop_h, bool loop_v)
2672         {
2673             Eina.Log.Debug("function efl_ui_scrollable_looping_set was called");
2674             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2675             if (ws != null)
2676             {
2677
2678                 try
2679                 {
2680                     ((Manager)ws.Target).SetLooping(loop_h, loop_v);
2681                 }
2682                 catch (Exception e)
2683                 {
2684                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2685                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2686                 }
2687
2688
2689             }
2690             else
2691             {
2692                 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);
2693             }
2694         }
2695
2696         private static efl_ui_scrollable_looping_set_delegate efl_ui_scrollable_looping_set_static_delegate;
2697
2698
2699         private delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_delegate(System.IntPtr obj, System.IntPtr pd);
2700
2701
2702         public delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_api_delegate(System.IntPtr obj);
2703
2704         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");
2705
2706         private static Efl.Ui.ScrollBlock movement_block_get(System.IntPtr obj, System.IntPtr pd)
2707         {
2708             Eina.Log.Debug("function efl_ui_scrollable_movement_block_get was called");
2709             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2710             if (ws != null)
2711             {
2712             Efl.Ui.ScrollBlock _ret_var = default(Efl.Ui.ScrollBlock);
2713                 try
2714                 {
2715                     _ret_var = ((Manager)ws.Target).GetMovementBlock();
2716                 }
2717                 catch (Exception e)
2718                 {
2719                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2720                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2721                 }
2722
2723         return _ret_var;
2724
2725             }
2726             else
2727             {
2728                 return efl_ui_scrollable_movement_block_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2729             }
2730         }
2731
2732         private static efl_ui_scrollable_movement_block_get_delegate efl_ui_scrollable_movement_block_get_static_delegate;
2733
2734
2735         private delegate void efl_ui_scrollable_movement_block_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollBlock block);
2736
2737
2738         public delegate void efl_ui_scrollable_movement_block_set_api_delegate(System.IntPtr obj,  Efl.Ui.ScrollBlock block);
2739
2740         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");
2741
2742         private static void movement_block_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ScrollBlock block)
2743         {
2744             Eina.Log.Debug("function efl_ui_scrollable_movement_block_set was called");
2745             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2746             if (ws != null)
2747             {
2748
2749                 try
2750                 {
2751                     ((Manager)ws.Target).SetMovementBlock(block);
2752                 }
2753                 catch (Exception e)
2754                 {
2755                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2756                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2757                 }
2758
2759
2760             }
2761             else
2762             {
2763                 efl_ui_scrollable_movement_block_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), block);
2764             }
2765         }
2766
2767         private static efl_ui_scrollable_movement_block_set_delegate efl_ui_scrollable_movement_block_set_static_delegate;
2768
2769
2770         private delegate void efl_ui_scrollable_gravity_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
2771
2772
2773         public delegate void efl_ui_scrollable_gravity_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
2774
2775         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");
2776
2777         private static void gravity_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
2778         {
2779             Eina.Log.Debug("function efl_ui_scrollable_gravity_get was called");
2780             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2781             if (ws != null)
2782             {
2783                         x = default(double);        y = default(double);
2784                 try
2785                 {
2786                     ((Manager)ws.Target).GetGravity(out x, out y);
2787                 }
2788                 catch (Exception e)
2789                 {
2790                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2791                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2792                 }
2793
2794
2795             }
2796             else
2797             {
2798                 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);
2799             }
2800         }
2801
2802         private static efl_ui_scrollable_gravity_get_delegate efl_ui_scrollable_gravity_get_static_delegate;
2803
2804
2805         private delegate void efl_ui_scrollable_gravity_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
2806
2807
2808         public delegate void efl_ui_scrollable_gravity_set_api_delegate(System.IntPtr obj,  double x,  double y);
2809
2810         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");
2811
2812         private static void gravity_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
2813         {
2814             Eina.Log.Debug("function efl_ui_scrollable_gravity_set was called");
2815             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2816             if (ws != null)
2817             {
2818
2819                 try
2820                 {
2821                     ((Manager)ws.Target).SetGravity(x, y);
2822                 }
2823                 catch (Exception e)
2824                 {
2825                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2826                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2827                 }
2828
2829
2830             }
2831             else
2832             {
2833                 efl_ui_scrollable_gravity_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
2834             }
2835         }
2836
2837         private static efl_ui_scrollable_gravity_set_delegate efl_ui_scrollable_gravity_set_static_delegate;
2838
2839
2840         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);
2841
2842
2843         public delegate void efl_ui_scrollable_match_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool w, [MarshalAs(UnmanagedType.U1)] bool h);
2844
2845         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");
2846
2847         private static void match_content_set(System.IntPtr obj, System.IntPtr pd, bool w, bool h)
2848         {
2849             Eina.Log.Debug("function efl_ui_scrollable_match_content_set was called");
2850             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2851             if (ws != null)
2852             {
2853
2854                 try
2855                 {
2856                     ((Manager)ws.Target).SetMatchContent(w, h);
2857                 }
2858                 catch (Exception e)
2859                 {
2860                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2861                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2862                 }
2863
2864
2865             }
2866             else
2867             {
2868                 efl_ui_scrollable_match_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), w, h);
2869             }
2870         }
2871
2872         private static efl_ui_scrollable_match_content_set_delegate efl_ui_scrollable_match_content_set_static_delegate;
2873
2874
2875         private delegate Eina.Position2D.NativeStruct efl_ui_scrollable_step_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2876
2877
2878         public delegate Eina.Position2D.NativeStruct efl_ui_scrollable_step_size_get_api_delegate(System.IntPtr obj);
2879
2880         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");
2881
2882         private static Eina.Position2D.NativeStruct step_size_get(System.IntPtr obj, System.IntPtr pd)
2883         {
2884             Eina.Log.Debug("function efl_ui_scrollable_step_size_get was called");
2885             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2886             if (ws != null)
2887             {
2888             Eina.Position2D _ret_var = default(Eina.Position2D);
2889                 try
2890                 {
2891                     _ret_var = ((Manager)ws.Target).GetStepSize();
2892                 }
2893                 catch (Exception e)
2894                 {
2895                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2896                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2897                 }
2898
2899         return _ret_var;
2900
2901             }
2902             else
2903             {
2904                 return efl_ui_scrollable_step_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2905             }
2906         }
2907
2908         private static efl_ui_scrollable_step_size_get_delegate efl_ui_scrollable_step_size_get_static_delegate;
2909
2910
2911         private delegate void efl_ui_scrollable_step_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct step);
2912
2913
2914         public delegate void efl_ui_scrollable_step_size_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct step);
2915
2916         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");
2917
2918         private static void step_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct step)
2919         {
2920             Eina.Log.Debug("function efl_ui_scrollable_step_size_set was called");
2921             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2922             if (ws != null)
2923             {
2924         Eina.Position2D _in_step = step;
2925
2926                 try
2927                 {
2928                     ((Manager)ws.Target).SetStepSize(_in_step);
2929                 }
2930                 catch (Exception e)
2931                 {
2932                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2933                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2934                 }
2935
2936
2937             }
2938             else
2939             {
2940                 efl_ui_scrollable_step_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), step);
2941             }
2942         }
2943
2944         private static efl_ui_scrollable_step_size_set_delegate efl_ui_scrollable_step_size_set_static_delegate;
2945
2946
2947         private delegate void efl_ui_scrollable_scroll_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool animation);
2948
2949
2950         public delegate void efl_ui_scrollable_scroll_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool animation);
2951
2952         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");
2953
2954         private static void scroll(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct rect, bool animation)
2955         {
2956             Eina.Log.Debug("function efl_ui_scrollable_scroll was called");
2957             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2958             if (ws != null)
2959             {
2960         Eina.Rect _in_rect = rect;
2961
2962                 try
2963                 {
2964                     ((Manager)ws.Target).Scroll(_in_rect, animation);
2965                 }
2966                 catch (Exception e)
2967                 {
2968                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2969                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2970                 }
2971
2972
2973             }
2974             else
2975             {
2976                 efl_ui_scrollable_scroll_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rect, animation);
2977             }
2978         }
2979
2980         private static efl_ui_scrollable_scroll_delegate efl_ui_scrollable_scroll_static_delegate;
2981
2982
2983         private delegate void efl_ui_scrollbar_bar_mode_get_delegate(System.IntPtr obj, System.IntPtr pd,  out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar);
2984
2985
2986         public delegate void efl_ui_scrollbar_bar_mode_get_api_delegate(System.IntPtr obj,  out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar);
2987
2988         public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_get_api_delegate> efl_ui_scrollbar_bar_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_get_api_delegate>(Module, "efl_ui_scrollbar_bar_mode_get");
2989
2990         private static void bar_mode_get(System.IntPtr obj, System.IntPtr pd, out Efl.Ui.ScrollbarMode hbar, out Efl.Ui.ScrollbarMode vbar)
2991         {
2992             Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_get was called");
2993             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2994             if (ws != null)
2995             {
2996                         hbar = default(Efl.Ui.ScrollbarMode);        vbar = default(Efl.Ui.ScrollbarMode);
2997                 try
2998                 {
2999                     ((Manager)ws.Target).GetBarMode(out hbar, out vbar);
3000                 }
3001                 catch (Exception e)
3002                 {
3003                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3004                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3005                 }
3006
3007
3008             }
3009             else
3010             {
3011                 efl_ui_scrollbar_bar_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out hbar, out vbar);
3012             }
3013         }
3014
3015         private static efl_ui_scrollbar_bar_mode_get_delegate efl_ui_scrollbar_bar_mode_get_static_delegate;
3016
3017
3018         private delegate void efl_ui_scrollbar_bar_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar);
3019
3020
3021         public delegate void efl_ui_scrollbar_bar_mode_set_api_delegate(System.IntPtr obj,  Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar);
3022
3023         public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_set_api_delegate> efl_ui_scrollbar_bar_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_mode_set_api_delegate>(Module, "efl_ui_scrollbar_bar_mode_set");
3024
3025         private static void bar_mode_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ScrollbarMode hbar, Efl.Ui.ScrollbarMode vbar)
3026         {
3027             Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_set was called");
3028             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3029             if (ws != null)
3030             {
3031
3032                 try
3033                 {
3034                     ((Manager)ws.Target).SetBarMode(hbar, vbar);
3035                 }
3036                 catch (Exception e)
3037                 {
3038                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3039                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3040                 }
3041
3042
3043             }
3044             else
3045             {
3046                 efl_ui_scrollbar_bar_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hbar, vbar);
3047             }
3048         }
3049
3050         private static efl_ui_scrollbar_bar_mode_set_delegate efl_ui_scrollbar_bar_mode_set_static_delegate;
3051
3052
3053         private delegate void efl_ui_scrollbar_bar_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double width,  out double height);
3054
3055
3056         public delegate void efl_ui_scrollbar_bar_size_get_api_delegate(System.IntPtr obj,  out double width,  out double height);
3057
3058         public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_size_get_api_delegate> efl_ui_scrollbar_bar_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_size_get_api_delegate>(Module, "efl_ui_scrollbar_bar_size_get");
3059
3060         private static void bar_size_get(System.IntPtr obj, System.IntPtr pd, out double width, out double height)
3061         {
3062             Eina.Log.Debug("function efl_ui_scrollbar_bar_size_get was called");
3063             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3064             if (ws != null)
3065             {
3066                         width = default(double);        height = default(double);
3067                 try
3068                 {
3069                     ((Manager)ws.Target).GetBarSize(out width, out height);
3070                 }
3071                 catch (Exception e)
3072                 {
3073                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3074                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3075                 }
3076
3077
3078             }
3079             else
3080             {
3081                 efl_ui_scrollbar_bar_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out width, out height);
3082             }
3083         }
3084
3085         private static efl_ui_scrollbar_bar_size_get_delegate efl_ui_scrollbar_bar_size_get_static_delegate;
3086
3087
3088         private delegate void efl_ui_scrollbar_bar_position_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double posx,  out double posy);
3089
3090
3091         public delegate void efl_ui_scrollbar_bar_position_get_api_delegate(System.IntPtr obj,  out double posx,  out double posy);
3092
3093         public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_get_api_delegate> efl_ui_scrollbar_bar_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_get_api_delegate>(Module, "efl_ui_scrollbar_bar_position_get");
3094
3095         private static void bar_position_get(System.IntPtr obj, System.IntPtr pd, out double posx, out double posy)
3096         {
3097             Eina.Log.Debug("function efl_ui_scrollbar_bar_position_get was called");
3098             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3099             if (ws != null)
3100             {
3101                         posx = default(double);        posy = default(double);
3102                 try
3103                 {
3104                     ((Manager)ws.Target).GetBarPosition(out posx, out posy);
3105                 }
3106                 catch (Exception e)
3107                 {
3108                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3109                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3110                 }
3111
3112
3113             }
3114             else
3115             {
3116                 efl_ui_scrollbar_bar_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out posx, out posy);
3117             }
3118         }
3119
3120         private static efl_ui_scrollbar_bar_position_get_delegate efl_ui_scrollbar_bar_position_get_static_delegate;
3121
3122
3123         private delegate void efl_ui_scrollbar_bar_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  double posx,  double posy);
3124
3125
3126         public delegate void efl_ui_scrollbar_bar_position_set_api_delegate(System.IntPtr obj,  double posx,  double posy);
3127
3128         public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_set_api_delegate> efl_ui_scrollbar_bar_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_position_set_api_delegate>(Module, "efl_ui_scrollbar_bar_position_set");
3129
3130         private static void bar_position_set(System.IntPtr obj, System.IntPtr pd, double posx, double posy)
3131         {
3132             Eina.Log.Debug("function efl_ui_scrollbar_bar_position_set was called");
3133             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3134             if (ws != null)
3135             {
3136
3137                 try
3138                 {
3139                     ((Manager)ws.Target).SetBarPosition(posx, posy);
3140                 }
3141                 catch (Exception e)
3142                 {
3143                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3144                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3145                 }
3146
3147
3148             }
3149             else
3150             {
3151                 efl_ui_scrollbar_bar_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), posx, posy);
3152             }
3153         }
3154
3155         private static efl_ui_scrollbar_bar_position_set_delegate efl_ui_scrollbar_bar_position_set_static_delegate;
3156
3157
3158         private delegate void efl_ui_scrollbar_bar_visibility_update_delegate(System.IntPtr obj, System.IntPtr pd);
3159
3160
3161         public delegate void efl_ui_scrollbar_bar_visibility_update_api_delegate(System.IntPtr obj);
3162
3163         public static Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_visibility_update_api_delegate> efl_ui_scrollbar_bar_visibility_update_ptr = new Efl.Eo.FunctionWrapper<efl_ui_scrollbar_bar_visibility_update_api_delegate>(Module, "efl_ui_scrollbar_bar_visibility_update");
3164
3165         private static void bar_visibility_update(System.IntPtr obj, System.IntPtr pd)
3166         {
3167             Eina.Log.Debug("function efl_ui_scrollbar_bar_visibility_update was called");
3168             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3169             if (ws != null)
3170             {
3171
3172                 try
3173                 {
3174                     ((Manager)ws.Target).UpdateBarVisibility();
3175                 }
3176                 catch (Exception e)
3177                 {
3178                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3179                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3180                 }
3181
3182
3183             }
3184             else
3185             {
3186                 efl_ui_scrollbar_bar_visibility_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3187             }
3188         }
3189
3190         private static efl_ui_scrollbar_bar_visibility_update_delegate efl_ui_scrollbar_bar_visibility_update_static_delegate;
3191
3192         #pragma warning restore CA1707, CS1591, SA1300, SA1600
3193
3194 }
3195 }
3196 }
3197
3198 }
3199
3200 }
3201
3202 #if EFL_BETA
3203 #pragma warning disable CS1591
3204 public static class Efl_Ui_ScrollManager_ExtensionMethods {
3205     public static Efl.BindableProperty<Efl.Ui.Pan> Pan<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3206         return new Efl.BindableProperty<Efl.Ui.Pan>("pan", fac);
3207     }
3208
3209     public static Efl.BindableProperty<bool> Mirrored<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3210         return new Efl.BindableProperty<bool>("mirrored", fac);
3211     }
3212
3213     public static Efl.BindableProperty<bool> MirroredAutomatic<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3214         return new Efl.BindableProperty<bool>("mirrored_automatic", fac);
3215     }
3216
3217     public static Efl.BindableProperty<System.String> Language<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3218         return new Efl.BindableProperty<System.String>("language", fac);
3219     }
3220
3221     public static Efl.BindableProperty<Eina.Position2D> ContentPos<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3222         return new Efl.BindableProperty<Eina.Position2D>("content_pos", fac);
3223     }
3224
3225
3226
3227
3228     public static Efl.BindableProperty<bool> ScrollFreeze<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3229         return new Efl.BindableProperty<bool>("scroll_freeze", fac);
3230     }
3231
3232     public static Efl.BindableProperty<bool> ScrollHold<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3233         return new Efl.BindableProperty<bool>("scroll_hold", fac);
3234     }
3235
3236
3237     public static Efl.BindableProperty<Efl.Ui.ScrollBlock> MovementBlock<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3238         return new Efl.BindableProperty<Efl.Ui.ScrollBlock>("movement_block", fac);
3239     }
3240
3241
3242
3243     public static Efl.BindableProperty<Eina.Position2D> StepSize<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.Scroll.Manager, T>magic = null) where T : Efl.Ui.Scroll.Manager {
3244         return new Efl.BindableProperty<Eina.Position2D>("step_size", fac);
3245     }
3246
3247
3248
3249
3250 }
3251 #pragma warning restore CS1591
3252 #endif