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

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