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