internals/src/EflSharp/EflSharp/efl/efl_ui_scroller.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 /// <summary>Efl ui scroller class</summary>
  13 [Efl.Ui.Scroller.NativeMethods]
  14 public class Scroller : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.IContent,Efl.Ui.IScrollable,Efl.Ui.IScrollableInteractive,Efl.Ui.IScrollbar,Efl.Ui.IWidgetFocusManager,Efl.Ui.Focus.IManager,Efl.Ui.Focus.IManagerSub
  15 {
  16     ///<summary>Pointer to the native class description.</summary>
  17     public override System.IntPtr NativeClass
  18     {
  19         get
  20         {
  21             if (((object)this).GetType() == typeof(Scroller))
  22             {
  23                 return GetEflClassStatic();
  24             }
  25             else
  26             {
  27                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  28             }
  29         }
  30     }
  31
  32     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  33         efl_ui_scroller_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Scroller"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  37     public Scroller(Efl.Object parent
  38             , System.String style = null) : base(efl_ui_scroller_class_get(), typeof(Scroller), parent)
  39     {
  40         if (Efl.Eo.Globals.ParamHelperCheck(style))
  41         {
  42             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  43         }
  44
  45         FinishInstantiation();
  46     }
  47
  48     /// <summary>Initializes a new instance of the <see cref="Scroller"/> class.
  49     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  50     /// <param name="raw">The native pointer to be wrapped.</param>
  51     protected Scroller(System.IntPtr raw) : base(raw)
  52     {
  53             }
  54
  55     /// <summary>Initializes a new instance of the <see cref="Scroller"/> class.
  56     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  57     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  58     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected Scroller(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  61     {
  62     }
  63
  64     /// <summary>Verifies if the given object is equal to this one.</summary>
  65     /// <param name="instance">The object to compare to.</param>
  66     /// <returns>True if both objects point to the same native object.</returns>
  67     public override bool Equals(object instance)
  68     {
  69         var other = instance as Efl.Object;
  70         if (other == null)
  71         {
  72             return false;
  73         }
  74         return this.NativeHandle == other.NativeHandle;
  75     }
  76
  77     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  78     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  79     public override int GetHashCode()
  80     {
  81         return this.NativeHandle.ToInt32();
  82     }
  83
  84     /// <summary>Turns the native pointer into a string representation.</summary>
  85     /// <returns>A string with the type and the native pointer for this object.</returns>
  86     public override String ToString()
  87     {
  88         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  89     }
  90
  91     /// <summary>Sent after the content is set or unset using the current content object.
  92     /// (Since EFL 1.22)</summary>
  93     public event EventHandler<Efl.IContentContentChangedEvt_Args> ContentChangedEvt
  94     {
  95         add
  96         {
  97             lock (eventLock)
  98             {
  99                 var wRef = new WeakReference(this);
 100                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 101                 {
 102                     var obj = wRef.Target as Efl.Eo.IWrapper;
 103                     if (obj != null)
 104                     {
 105                                                 Efl.IContentContentChangedEvt_Args args = new Efl.IContentContentChangedEvt_Args();
 106                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Gfx.IEntityConcrete);
 107                         try
 108                         {
 109                             value?.Invoke(obj, args);
 110                         }
 111                         catch (Exception e)
 112                         {
 113                             Eina.Log.Error(e.ToString());
 114                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 115                         }
 116                     }
 117                 };
 118
 119                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 120                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 121             }
 122         }
 123
 124         remove
 125         {
 126             lock (eventLock)
 127             {
 128                 string key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 129                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 130             }
 131         }
 132     }
 133     ///<summary>Method to raise event ContentChangedEvt.</summary>
 134     public void OnContentChangedEvt(Efl.IContentContentChangedEvt_Args e)
 135     {
 136         var key = "_EFL_CONTENT_EVENT_CONTENT_CHANGED";
 137         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 138         if (desc == IntPtr.Zero)
 139         {
 140             Eina.Log.Error($"Failed to get native event {key}");
 141             return;
 142         }
 143
 144         IntPtr info = e.arg.NativeHandle;
 145         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 146     }
 147     /// <summary>Called when scroll operation starts</summary>
 148     public event EventHandler ScrollStartEvt
 149     {
 150         add
 151         {
 152             lock (eventLock)
 153             {
 154                 var wRef = new WeakReference(this);
 155                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 156                 {
 157                     var obj = wRef.Target as Efl.Eo.IWrapper;
 158                     if (obj != null)
 159                     {
 160                         EventArgs args = EventArgs.Empty;
 161                         try
 162                         {
 163                             value?.Invoke(obj, args);
 164                         }
 165                         catch (Exception e)
 166                         {
 167                             Eina.Log.Error(e.ToString());
 168                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 169                         }
 170                     }
 171                 };
 172
 173                 string key = "_EFL_UI_EVENT_SCROLL_START";
 174                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 175             }
 176         }
 177
 178         remove
 179         {
 180             lock (eventLock)
 181             {
 182                 string key = "_EFL_UI_EVENT_SCROLL_START";
 183                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 184             }
 185         }
 186     }
 187     ///<summary>Method to raise event ScrollStartEvt.</summary>
 188     public void OnScrollStartEvt(EventArgs e)
 189     {
 190         var key = "_EFL_UI_EVENT_SCROLL_START";
 191         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 192         if (desc == IntPtr.Zero)
 193         {
 194             Eina.Log.Error($"Failed to get native event {key}");
 195             return;
 196         }
 197
 198         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 199     }
 200     /// <summary>Called when scrolling</summary>
 201     public event EventHandler ScrollEvt
 202     {
 203         add
 204         {
 205             lock (eventLock)
 206             {
 207                 var wRef = new WeakReference(this);
 208                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 209                 {
 210                     var obj = wRef.Target as Efl.Eo.IWrapper;
 211                     if (obj != null)
 212                     {
 213                         EventArgs args = EventArgs.Empty;
 214                         try
 215                         {
 216                             value?.Invoke(obj, args);
 217                         }
 218                         catch (Exception e)
 219                         {
 220                             Eina.Log.Error(e.ToString());
 221                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 222                         }
 223                     }
 224                 };
 225
 226                 string key = "_EFL_UI_EVENT_SCROLL";
 227                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 228             }
 229         }
 230
 231         remove
 232         {
 233             lock (eventLock)
 234             {
 235                 string key = "_EFL_UI_EVENT_SCROLL";
 236                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 237             }
 238         }
 239     }
 240     ///<summary>Method to raise event ScrollEvt.</summary>
 241     public void OnScrollEvt(EventArgs e)
 242     {
 243         var key = "_EFL_UI_EVENT_SCROLL";
 244         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 245         if (desc == IntPtr.Zero)
 246         {
 247             Eina.Log.Error($"Failed to get native event {key}");
 248             return;
 249         }
 250
 251         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 252     }
 253     /// <summary>Called when scroll operation stops</summary>
 254     public event EventHandler ScrollStopEvt
 255     {
 256         add
 257         {
 258             lock (eventLock)
 259             {
 260                 var wRef = new WeakReference(this);
 261                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 262                 {
 263                     var obj = wRef.Target as Efl.Eo.IWrapper;
 264                     if (obj != null)
 265                     {
 266                         EventArgs args = EventArgs.Empty;
 267                         try
 268                         {
 269                             value?.Invoke(obj, args);
 270                         }
 271                         catch (Exception e)
 272                         {
 273                             Eina.Log.Error(e.ToString());
 274                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 275                         }
 276                     }
 277                 };
 278
 279                 string key = "_EFL_UI_EVENT_SCROLL_STOP";
 280                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 281             }
 282         }
 283
 284         remove
 285         {
 286             lock (eventLock)
 287             {
 288                 string key = "_EFL_UI_EVENT_SCROLL_STOP";
 289                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 290             }
 291         }
 292     }
 293     ///<summary>Method to raise event ScrollStopEvt.</summary>
 294     public void OnScrollStopEvt(EventArgs e)
 295     {
 296         var key = "_EFL_UI_EVENT_SCROLL_STOP";
 297         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 298         if (desc == IntPtr.Zero)
 299         {
 300             Eina.Log.Error($"Failed to get native event {key}");
 301             return;
 302         }
 303
 304         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 305     }
 306     /// <summary>Called when scrolling upwards</summary>
 307     public event EventHandler ScrollUpEvt
 308     {
 309         add
 310         {
 311             lock (eventLock)
 312             {
 313                 var wRef = new WeakReference(this);
 314                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 315                 {
 316                     var obj = wRef.Target as Efl.Eo.IWrapper;
 317                     if (obj != null)
 318                     {
 319                         EventArgs args = EventArgs.Empty;
 320                         try
 321                         {
 322                             value?.Invoke(obj, args);
 323                         }
 324                         catch (Exception e)
 325                         {
 326                             Eina.Log.Error(e.ToString());
 327                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 328                         }
 329                     }
 330                 };
 331
 332                 string key = "_EFL_UI_EVENT_SCROLL_UP";
 333                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 334             }
 335         }
 336
 337         remove
 338         {
 339             lock (eventLock)
 340             {
 341                 string key = "_EFL_UI_EVENT_SCROLL_UP";
 342                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 343             }
 344         }
 345     }
 346     ///<summary>Method to raise event ScrollUpEvt.</summary>
 347     public void OnScrollUpEvt(EventArgs e)
 348     {
 349         var key = "_EFL_UI_EVENT_SCROLL_UP";
 350         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 351         if (desc == IntPtr.Zero)
 352         {
 353             Eina.Log.Error($"Failed to get native event {key}");
 354             return;
 355         }
 356
 357         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 358     }
 359     /// <summary>Called when scrolling downwards</summary>
 360     public event EventHandler ScrollDownEvt
 361     {
 362         add
 363         {
 364             lock (eventLock)
 365             {
 366                 var wRef = new WeakReference(this);
 367                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 368                 {
 369                     var obj = wRef.Target as Efl.Eo.IWrapper;
 370                     if (obj != null)
 371                     {
 372                         EventArgs args = EventArgs.Empty;
 373                         try
 374                         {
 375                             value?.Invoke(obj, args);
 376                         }
 377                         catch (Exception e)
 378                         {
 379                             Eina.Log.Error(e.ToString());
 380                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 381                         }
 382                     }
 383                 };
 384
 385                 string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 386                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 387             }
 388         }
 389
 390         remove
 391         {
 392             lock (eventLock)
 393             {
 394                 string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 395                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 396             }
 397         }
 398     }
 399     ///<summary>Method to raise event ScrollDownEvt.</summary>
 400     public void OnScrollDownEvt(EventArgs e)
 401     {
 402         var key = "_EFL_UI_EVENT_SCROLL_DOWN";
 403         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 404         if (desc == IntPtr.Zero)
 405         {
 406             Eina.Log.Error($"Failed to get native event {key}");
 407             return;
 408         }
 409
 410         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 411     }
 412     /// <summary>Called when scrolling left</summary>
 413     public event EventHandler ScrollLeftEvt
 414     {
 415         add
 416         {
 417             lock (eventLock)
 418             {
 419                 var wRef = new WeakReference(this);
 420                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 421                 {
 422                     var obj = wRef.Target as Efl.Eo.IWrapper;
 423                     if (obj != null)
 424                     {
 425                         EventArgs args = EventArgs.Empty;
 426                         try
 427                         {
 428                             value?.Invoke(obj, args);
 429                         }
 430                         catch (Exception e)
 431                         {
 432                             Eina.Log.Error(e.ToString());
 433                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 434                         }
 435                     }
 436                 };
 437
 438                 string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 439                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 440             }
 441         }
 442
 443         remove
 444         {
 445             lock (eventLock)
 446             {
 447                 string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 448                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 449             }
 450         }
 451     }
 452     ///<summary>Method to raise event ScrollLeftEvt.</summary>
 453     public void OnScrollLeftEvt(EventArgs e)
 454     {
 455         var key = "_EFL_UI_EVENT_SCROLL_LEFT";
 456         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 457         if (desc == IntPtr.Zero)
 458         {
 459             Eina.Log.Error($"Failed to get native event {key}");
 460             return;
 461         }
 462
 463         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 464     }
 465     /// <summary>Called when scrolling right</summary>
 466     public event EventHandler ScrollRightEvt
 467     {
 468         add
 469         {
 470             lock (eventLock)
 471             {
 472                 var wRef = new WeakReference(this);
 473                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 474                 {
 475                     var obj = wRef.Target as Efl.Eo.IWrapper;
 476                     if (obj != null)
 477                     {
 478                         EventArgs args = EventArgs.Empty;
 479                         try
 480                         {
 481                             value?.Invoke(obj, args);
 482                         }
 483                         catch (Exception e)
 484                         {
 485                             Eina.Log.Error(e.ToString());
 486                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 487                         }
 488                     }
 489                 };
 490
 491                 string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 492                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 493             }
 494         }
 495
 496         remove
 497         {
 498             lock (eventLock)
 499             {
 500                 string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 501                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 502             }
 503         }
 504     }
 505     ///<summary>Method to raise event ScrollRightEvt.</summary>
 506     public void OnScrollRightEvt(EventArgs e)
 507     {
 508         var key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 509         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 510         if (desc == IntPtr.Zero)
 511         {
 512             Eina.Log.Error($"Failed to get native event {key}");
 513             return;
 514         }
 515
 516         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 517     }
 518     /// <summary>Called when hitting the top edge</summary>
 519     public event EventHandler EdgeUpEvt
 520     {
 521         add
 522         {
 523             lock (eventLock)
 524             {
 525                 var wRef = new WeakReference(this);
 526                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 527                 {
 528                     var obj = wRef.Target as Efl.Eo.IWrapper;
 529                     if (obj != null)
 530                     {
 531                         EventArgs args = EventArgs.Empty;
 532                         try
 533                         {
 534                             value?.Invoke(obj, args);
 535                         }
 536                         catch (Exception e)
 537                         {
 538                             Eina.Log.Error(e.ToString());
 539                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 540                         }
 541                     }
 542                 };
 543
 544                 string key = "_EFL_UI_EVENT_EDGE_UP";
 545                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 546             }
 547         }
 548
 549         remove
 550         {
 551             lock (eventLock)
 552             {
 553                 string key = "_EFL_UI_EVENT_EDGE_UP";
 554                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 555             }
 556         }
 557     }
 558     ///<summary>Method to raise event EdgeUpEvt.</summary>
 559     public void OnEdgeUpEvt(EventArgs e)
 560     {
 561         var key = "_EFL_UI_EVENT_EDGE_UP";
 562         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 563         if (desc == IntPtr.Zero)
 564         {
 565             Eina.Log.Error($"Failed to get native event {key}");
 566             return;
 567         }
 568
 569         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 570     }
 571     /// <summary>Called when hitting the bottom edge</summary>
 572     public event EventHandler EdgeDownEvt
 573     {
 574         add
 575         {
 576             lock (eventLock)
 577             {
 578                 var wRef = new WeakReference(this);
 579                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 580                 {
 581                     var obj = wRef.Target as Efl.Eo.IWrapper;
 582                     if (obj != null)
 583                     {
 584                         EventArgs args = EventArgs.Empty;
 585                         try
 586                         {
 587                             value?.Invoke(obj, args);
 588                         }
 589                         catch (Exception e)
 590                         {
 591                             Eina.Log.Error(e.ToString());
 592                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 593                         }
 594                     }
 595                 };
 596
 597                 string key = "_EFL_UI_EVENT_EDGE_DOWN";
 598                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 599             }
 600         }
 601
 602         remove
 603         {
 604             lock (eventLock)
 605             {
 606                 string key = "_EFL_UI_EVENT_EDGE_DOWN";
 607                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 608             }
 609         }
 610     }
 611     ///<summary>Method to raise event EdgeDownEvt.</summary>
 612     public void OnEdgeDownEvt(EventArgs e)
 613     {
 614         var key = "_EFL_UI_EVENT_EDGE_DOWN";
 615         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 616         if (desc == IntPtr.Zero)
 617         {
 618             Eina.Log.Error($"Failed to get native event {key}");
 619             return;
 620         }
 621
 622         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 623     }
 624     /// <summary>Called when hitting the left edge</summary>
 625     public event EventHandler EdgeLeftEvt
 626     {
 627         add
 628         {
 629             lock (eventLock)
 630             {
 631                 var wRef = new WeakReference(this);
 632                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 633                 {
 634                     var obj = wRef.Target as Efl.Eo.IWrapper;
 635                     if (obj != null)
 636                     {
 637                         EventArgs args = EventArgs.Empty;
 638                         try
 639                         {
 640                             value?.Invoke(obj, args);
 641                         }
 642                         catch (Exception e)
 643                         {
 644                             Eina.Log.Error(e.ToString());
 645                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 646                         }
 647                     }
 648                 };
 649
 650                 string key = "_EFL_UI_EVENT_EDGE_LEFT";
 651                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 652             }
 653         }
 654
 655         remove
 656         {
 657             lock (eventLock)
 658             {
 659                 string key = "_EFL_UI_EVENT_EDGE_LEFT";
 660                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 661             }
 662         }
 663     }
 664     ///<summary>Method to raise event EdgeLeftEvt.</summary>
 665     public void OnEdgeLeftEvt(EventArgs e)
 666     {
 667         var key = "_EFL_UI_EVENT_EDGE_LEFT";
 668         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 669         if (desc == IntPtr.Zero)
 670         {
 671             Eina.Log.Error($"Failed to get native event {key}");
 672             return;
 673         }
 674
 675         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 676     }
 677     /// <summary>Called when hitting the right edge</summary>
 678     public event EventHandler EdgeRightEvt
 679     {
 680         add
 681         {
 682             lock (eventLock)
 683             {
 684                 var wRef = new WeakReference(this);
 685                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 686                 {
 687                     var obj = wRef.Target as Efl.Eo.IWrapper;
 688                     if (obj != null)
 689                     {
 690                         EventArgs args = EventArgs.Empty;
 691                         try
 692                         {
 693                             value?.Invoke(obj, args);
 694                         }
 695                         catch (Exception e)
 696                         {
 697                             Eina.Log.Error(e.ToString());
 698                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 699                         }
 700                     }
 701                 };
 702
 703                 string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 704                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 705             }
 706         }
 707
 708         remove
 709         {
 710             lock (eventLock)
 711             {
 712                 string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 713                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 714             }
 715         }
 716     }
 717     ///<summary>Method to raise event EdgeRightEvt.</summary>
 718     public void OnEdgeRightEvt(EventArgs e)
 719     {
 720         var key = "_EFL_UI_EVENT_EDGE_RIGHT";
 721         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 722         if (desc == IntPtr.Zero)
 723         {
 724             Eina.Log.Error($"Failed to get native event {key}");
 725             return;
 726         }
 727
 728         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 729     }
 730     /// <summary>Called when scroll animation starts</summary>
 731     public event EventHandler ScrollAnimStartEvt
 732     {
 733         add
 734         {
 735             lock (eventLock)
 736             {
 737                 var wRef = new WeakReference(this);
 738                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 739                 {
 740                     var obj = wRef.Target as Efl.Eo.IWrapper;
 741                     if (obj != null)
 742                     {
 743                         EventArgs args = EventArgs.Empty;
 744                         try
 745                         {
 746                             value?.Invoke(obj, args);
 747                         }
 748                         catch (Exception e)
 749                         {
 750                             Eina.Log.Error(e.ToString());
 751                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 752                         }
 753                     }
 754                 };
 755
 756                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 757                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 758             }
 759         }
 760
 761         remove
 762         {
 763             lock (eventLock)
 764             {
 765                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 766                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 767             }
 768         }
 769     }
 770     ///<summary>Method to raise event ScrollAnimStartEvt.</summary>
 771     public void OnScrollAnimStartEvt(EventArgs e)
 772     {
 773         var key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 774         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 775         if (desc == IntPtr.Zero)
 776         {
 777             Eina.Log.Error($"Failed to get native event {key}");
 778             return;
 779         }
 780
 781         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 782     }
 783     /// <summary>Called when scroll animation stopps</summary>
 784     public event EventHandler ScrollAnimStopEvt
 785     {
 786         add
 787         {
 788             lock (eventLock)
 789             {
 790                 var wRef = new WeakReference(this);
 791                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 792                 {
 793                     var obj = wRef.Target as Efl.Eo.IWrapper;
 794                     if (obj != null)
 795                     {
 796                         EventArgs args = EventArgs.Empty;
 797                         try
 798                         {
 799                             value?.Invoke(obj, args);
 800                         }
 801                         catch (Exception e)
 802                         {
 803                             Eina.Log.Error(e.ToString());
 804                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 805                         }
 806                     }
 807                 };
 808
 809                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 810                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 811             }
 812         }
 813
 814         remove
 815         {
 816             lock (eventLock)
 817             {
 818                 string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 819                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 820             }
 821         }
 822     }
 823     ///<summary>Method to raise event ScrollAnimStopEvt.</summary>
 824     public void OnScrollAnimStopEvt(EventArgs e)
 825     {
 826         var key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
 827         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 828         if (desc == IntPtr.Zero)
 829         {
 830             Eina.Log.Error($"Failed to get native event {key}");
 831             return;
 832         }
 833
 834         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 835     }
 836     /// <summary>Called when scroll drag starts</summary>
 837     public event EventHandler ScrollDragStartEvt
 838     {
 839         add
 840         {
 841             lock (eventLock)
 842             {
 843                 var wRef = new WeakReference(this);
 844                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 845                 {
 846                     var obj = wRef.Target as Efl.Eo.IWrapper;
 847                     if (obj != null)
 848                     {
 849                         EventArgs args = EventArgs.Empty;
 850                         try
 851                         {
 852                             value?.Invoke(obj, args);
 853                         }
 854                         catch (Exception e)
 855                         {
 856                             Eina.Log.Error(e.ToString());
 857                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 858                         }
 859                     }
 860                 };
 861
 862                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 863                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 864             }
 865         }
 866
 867         remove
 868         {
 869             lock (eventLock)
 870             {
 871                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 872                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 873             }
 874         }
 875     }
 876     ///<summary>Method to raise event ScrollDragStartEvt.</summary>
 877     public void OnScrollDragStartEvt(EventArgs e)
 878     {
 879         var key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
 880         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 881         if (desc == IntPtr.Zero)
 882         {
 883             Eina.Log.Error($"Failed to get native event {key}");
 884             return;
 885         }
 886
 887         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 888     }
 889     /// <summary>Called when scroll drag stops</summary>
 890     public event EventHandler ScrollDragStopEvt
 891     {
 892         add
 893         {
 894             lock (eventLock)
 895             {
 896                 var wRef = new WeakReference(this);
 897                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 898                 {
 899                     var obj = wRef.Target as Efl.Eo.IWrapper;
 900                     if (obj != null)
 901                     {
 902                         EventArgs args = EventArgs.Empty;
 903                         try
 904                         {
 905                             value?.Invoke(obj, args);
 906                         }
 907                         catch (Exception e)
 908                         {
 909                             Eina.Log.Error(e.ToString());
 910                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 911                         }
 912                     }
 913                 };
 914
 915                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 916                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 917             }
 918         }
 919
 920         remove
 921         {
 922             lock (eventLock)
 923             {
 924                 string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 925                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 926             }
 927         }
 928     }
 929     ///<summary>Method to raise event ScrollDragStopEvt.</summary>
 930     public void OnScrollDragStopEvt(EventArgs e)
 931     {
 932         var key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
 933         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 934         if (desc == IntPtr.Zero)
 935         {
 936             Eina.Log.Error($"Failed to get native event {key}");
 937             return;
 938         }
 939
 940         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 941     }
 942     /// <summary>Called when bar is pressed</summary>
 943     public event EventHandler<Efl.Ui.IScrollbarBarPressEvt_Args> BarPressEvt
 944     {
 945         add
 946         {
 947             lock (eventLock)
 948             {
 949                 var wRef = new WeakReference(this);
 950                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 951                 {
 952                     var obj = wRef.Target as Efl.Eo.IWrapper;
 953                     if (obj != null)
 954                     {
 955                                                 Efl.Ui.IScrollbarBarPressEvt_Args args = new Efl.Ui.IScrollbarBarPressEvt_Args();
 956                         args.arg = default(Efl.Ui.ScrollbarDirection);
 957                         try
 958                         {
 959                             value?.Invoke(obj, args);
 960                         }
 961                         catch (Exception e)
 962                         {
 963                             Eina.Log.Error(e.ToString());
 964                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 965                         }
 966                     }
 967                 };
 968
 969                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
 970                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 971             }
 972         }
 973
 974         remove
 975         {
 976             lock (eventLock)
 977             {
 978                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
 979                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 980             }
 981         }
 982     }
 983     ///<summary>Method to raise event BarPressEvt.</summary>
 984     public void OnBarPressEvt(Efl.Ui.IScrollbarBarPressEvt_Args e)
 985     {
 986         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
 987         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 988         if (desc == IntPtr.Zero)
 989         {
 990             Eina.Log.Error($"Failed to get native event {key}");
 991             return;
 992         }
 993
 994         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
 995         try
 996         {
 997             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 998         }
 999         finally
1000         {
1001             Marshal.FreeHGlobal(info);
1002         }
1003     }
1004     /// <summary>Called when bar is unpressed</summary>
1005     public event EventHandler<Efl.Ui.IScrollbarBarUnpressEvt_Args> BarUnpressEvt
1006     {
1007         add
1008         {
1009             lock (eventLock)
1010             {
1011                 var wRef = new WeakReference(this);
1012                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1013                 {
1014                     var obj = wRef.Target as Efl.Eo.IWrapper;
1015                     if (obj != null)
1016                     {
1017                                                 Efl.Ui.IScrollbarBarUnpressEvt_Args args = new Efl.Ui.IScrollbarBarUnpressEvt_Args();
1018                         args.arg = default(Efl.Ui.ScrollbarDirection);
1019                         try
1020                         {
1021                             value?.Invoke(obj, args);
1022                         }
1023                         catch (Exception e)
1024                         {
1025                             Eina.Log.Error(e.ToString());
1026                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1027                         }
1028                     }
1029                 };
1030
1031                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
1032                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
1033             }
1034         }
1035
1036         remove
1037         {
1038             lock (eventLock)
1039             {
1040                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
1041                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
1042             }
1043         }
1044     }
1045     ///<summary>Method to raise event BarUnpressEvt.</summary>
1046     public void OnBarUnpressEvt(Efl.Ui.IScrollbarBarUnpressEvt_Args e)
1047     {
1048         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
1049         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
1050         if (desc == IntPtr.Zero)
1051         {
1052             Eina.Log.Error($"Failed to get native event {key}");
1053             return;
1054         }
1055
1056         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
1057         try
1058         {
1059             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1060         }
1061         finally
1062         {
1063             Marshal.FreeHGlobal(info);
1064         }
1065     }
1066     /// <summary>Called when bar is dragged</summary>
1067     public event EventHandler<Efl.Ui.IScrollbarBarDragEvt_Args> BarDragEvt
1068     {
1069         add
1070         {
1071             lock (eventLock)
1072             {
1073                 var wRef = new WeakReference(this);
1074                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1075                 {
1076                     var obj = wRef.Target as Efl.Eo.IWrapper;
1077                     if (obj != null)
1078                     {
1079                                                 Efl.Ui.IScrollbarBarDragEvt_Args args = new Efl.Ui.IScrollbarBarDragEvt_Args();
1080                         args.arg = default(Efl.Ui.ScrollbarDirection);
1081                         try
1082                         {
1083                             value?.Invoke(obj, args);
1084                         }
1085                         catch (Exception e)
1086                         {
1087                             Eina.Log.Error(e.ToString());
1088                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1089                         }
1090                     }
1091                 };
1092
1093                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1094                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
1095             }
1096         }
1097
1098         remove
1099         {
1100             lock (eventLock)
1101             {
1102                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1103                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
1104             }
1105         }
1106     }
1107     ///<summary>Method to raise event BarDragEvt.</summary>
1108     public void OnBarDragEvt(Efl.Ui.IScrollbarBarDragEvt_Args e)
1109     {
1110         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1111         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
1112         if (desc == IntPtr.Zero)
1113         {
1114             Eina.Log.Error($"Failed to get native event {key}");
1115             return;
1116         }
1117
1118         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
1119         try
1120         {
1121             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1122         }
1123         finally
1124         {
1125             Marshal.FreeHGlobal(info);
1126         }
1127     }
1128     /// <summary>Called when bar size is changed</summary>
1129     public event EventHandler BarSizeChangedEvt
1130     {
1131         add
1132         {
1133             lock (eventLock)
1134             {
1135                 var wRef = new WeakReference(this);
1136                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1137                 {
1138                     var obj = wRef.Target as Efl.Eo.IWrapper;
1139                     if (obj != null)
1140                     {
1141                         EventArgs args = EventArgs.Empty;
1142                         try
1143                         {
1144                             value?.Invoke(obj, args);
1145                         }
1146                         catch (Exception e)
1147                         {
1148                             Eina.Log.Error(e.ToString());
1149                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1150                         }
1151                     }
1152                 };
1153
1154                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1155                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
1156             }
1157         }
1158
1159         remove
1160         {
1161             lock (eventLock)
1162             {
1163                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1164                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
1165             }
1166         }
1167     }
1168     ///<summary>Method to raise event BarSizeChangedEvt.</summary>
1169     public void OnBarSizeChangedEvt(EventArgs e)
1170     {
1171         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1172         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
1173         if (desc == IntPtr.Zero)
1174         {
1175             Eina.Log.Error($"Failed to get native event {key}");
1176             return;
1177         }
1178
1179         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
1180     }
1181     /// <summary>Called when bar position is changed</summary>
1182     public event EventHandler BarPosChangedEvt
1183     {
1184         add
1185         {
1186             lock (eventLock)
1187             {
1188                 var wRef = new WeakReference(this);
1189                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1190                 {
1191                     var obj = wRef.Target as Efl.Eo.IWrapper;
1192                     if (obj != null)
1193                     {
1194                         EventArgs args = EventArgs.Empty;
1195                         try
1196                         {
1197                             value?.Invoke(obj, args);
1198                         }
1199                         catch (Exception e)
1200                         {
1201                             Eina.Log.Error(e.ToString());
1202                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1203                         }
1204                     }
1205                 };
1206
1207                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1208                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
1209             }
1210         }
1211
1212         remove
1213         {
1214             lock (eventLock)
1215             {
1216                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1217                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
1218             }
1219         }
1220     }
1221     ///<summary>Method to raise event BarPosChangedEvt.</summary>
1222     public void OnBarPosChangedEvt(EventArgs e)
1223     {
1224         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1225         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
1226         if (desc == IntPtr.Zero)
1227         {
1228             Eina.Log.Error($"Failed to get native event {key}");
1229             return;
1230         }
1231
1232         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
1233     }
1234     /// <summary>Callend when bar is shown</summary>
1235     public event EventHandler<Efl.Ui.IScrollbarBarShowEvt_Args> BarShowEvt
1236     {
1237         add
1238         {
1239             lock (eventLock)
1240             {
1241                 var wRef = new WeakReference(this);
1242                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1243                 {
1244                     var obj = wRef.Target as Efl.Eo.IWrapper;
1245                     if (obj != null)
1246                     {
1247                                                 Efl.Ui.IScrollbarBarShowEvt_Args args = new Efl.Ui.IScrollbarBarShowEvt_Args();
1248                         args.arg = default(Efl.Ui.ScrollbarDirection);
1249                         try
1250                         {
1251                             value?.Invoke(obj, args);
1252                         }
1253                         catch (Exception e)
1254                         {
1255                             Eina.Log.Error(e.ToString());
1256                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1257                         }
1258                     }
1259                 };
1260
1261                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1262                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
1263             }
1264         }
1265
1266         remove
1267         {
1268             lock (eventLock)
1269             {
1270                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1271                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
1272             }
1273         }
1274     }
1275     ///<summary>Method to raise event BarShowEvt.</summary>
1276     public void OnBarShowEvt(Efl.Ui.IScrollbarBarShowEvt_Args e)
1277     {
1278         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1279         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
1280         if (desc == IntPtr.Zero)
1281         {
1282             Eina.Log.Error($"Failed to get native event {key}");
1283             return;
1284         }
1285
1286         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
1287         try
1288         {
1289             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1290         }
1291         finally
1292         {
1293             Marshal.FreeHGlobal(info);
1294         }
1295     }
1296     /// <summary>Called when bar is hidden</summary>
1297     public event EventHandler<Efl.Ui.IScrollbarBarHideEvt_Args> BarHideEvt
1298     {
1299         add
1300         {
1301             lock (eventLock)
1302             {
1303                 var wRef = new WeakReference(this);
1304                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1305                 {
1306                     var obj = wRef.Target as Efl.Eo.IWrapper;
1307                     if (obj != null)
1308                     {
1309                                                 Efl.Ui.IScrollbarBarHideEvt_Args args = new Efl.Ui.IScrollbarBarHideEvt_Args();
1310                         args.arg = default(Efl.Ui.ScrollbarDirection);
1311                         try
1312                         {
1313                             value?.Invoke(obj, args);
1314                         }
1315                         catch (Exception e)
1316                         {
1317                             Eina.Log.Error(e.ToString());
1318                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1319                         }
1320                     }
1321                 };
1322
1323                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1324                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
1325             }
1326         }
1327
1328         remove
1329         {
1330             lock (eventLock)
1331             {
1332                 string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1333                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
1334             }
1335         }
1336     }
1337     ///<summary>Method to raise event BarHideEvt.</summary>
1338     public void OnBarHideEvt(Efl.Ui.IScrollbarBarHideEvt_Args e)
1339     {
1340         var key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1341         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
1342         if (desc == IntPtr.Zero)
1343         {
1344             Eina.Log.Error($"Failed to get native event {key}");
1345             return;
1346         }
1347
1348         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg);
1349         try
1350         {
1351             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1352         }
1353         finally
1354         {
1355             Marshal.FreeHGlobal(info);
1356         }
1357     }
1358     /// <summary>Redirect object has changed, the old manager is passed as an event argument.
1359     /// (Since EFL 1.22)</summary>
1360     public event EventHandler<Efl.Ui.Focus.IManagerRedirectChangedEvt_Args> RedirectChangedEvt
1361     {
1362         add
1363         {
1364             lock (eventLock)
1365             {
1366                 var wRef = new WeakReference(this);
1367                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1368                 {
1369                     var obj = wRef.Target as Efl.Eo.IWrapper;
1370                     if (obj != null)
1371                     {
1372                                                 Efl.Ui.Focus.IManagerRedirectChangedEvt_Args args = new Efl.Ui.Focus.IManagerRedirectChangedEvt_Args();
1373                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IManagerConcrete);
1374                         try
1375                         {
1376                             value?.Invoke(obj, args);
1377                         }
1378                         catch (Exception e)
1379                         {
1380                             Eina.Log.Error(e.ToString());
1381                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1382                         }
1383                     }
1384                 };
1385
1386                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
1387                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1388             }
1389         }
1390
1391         remove
1392         {
1393             lock (eventLock)
1394             {
1395                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
1396                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1397             }
1398         }
1399     }
1400     ///<summary>Method to raise event RedirectChangedEvt.</summary>
1401     public void OnRedirectChangedEvt(Efl.Ui.Focus.IManagerRedirectChangedEvt_Args e)
1402     {
1403         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_REDIRECT_CHANGED";
1404         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1405         if (desc == IntPtr.Zero)
1406         {
1407             Eina.Log.Error($"Failed to get native event {key}");
1408             return;
1409         }
1410
1411         IntPtr info = e.arg.NativeHandle;
1412         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1413     }
1414     /// <summary>After this event, the manager object will calculate relations in the graph. Can be used to add / remove children in a lazy fashion.
1415     /// (Since EFL 1.22)</summary>
1416     public event EventHandler FlushPreEvt
1417     {
1418         add
1419         {
1420             lock (eventLock)
1421             {
1422                 var wRef = new WeakReference(this);
1423                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1424                 {
1425                     var obj = wRef.Target as Efl.Eo.IWrapper;
1426                     if (obj != null)
1427                     {
1428                         EventArgs args = EventArgs.Empty;
1429                         try
1430                         {
1431                             value?.Invoke(obj, args);
1432                         }
1433                         catch (Exception e)
1434                         {
1435                             Eina.Log.Error(e.ToString());
1436                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1437                         }
1438                     }
1439                 };
1440
1441                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
1442                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1443             }
1444         }
1445
1446         remove
1447         {
1448             lock (eventLock)
1449             {
1450                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
1451                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1452             }
1453         }
1454     }
1455     ///<summary>Method to raise event FlushPreEvt.</summary>
1456     public void OnFlushPreEvt(EventArgs e)
1457     {
1458         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_FLUSH_PRE";
1459         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1460         if (desc == IntPtr.Zero)
1461         {
1462             Eina.Log.Error($"Failed to get native event {key}");
1463             return;
1464         }
1465
1466         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
1467     }
1468     /// <summary>Cached relationship calculation results have been invalidated.
1469     /// (Since EFL 1.22)</summary>
1470     public event EventHandler CoordsDirtyEvt
1471     {
1472         add
1473         {
1474             lock (eventLock)
1475             {
1476                 var wRef = new WeakReference(this);
1477                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1478                 {
1479                     var obj = wRef.Target as Efl.Eo.IWrapper;
1480                     if (obj != null)
1481                     {
1482                         EventArgs args = EventArgs.Empty;
1483                         try
1484                         {
1485                             value?.Invoke(obj, args);
1486                         }
1487                         catch (Exception e)
1488                         {
1489                             Eina.Log.Error(e.ToString());
1490                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1491                         }
1492                     }
1493                 };
1494
1495                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
1496                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1497             }
1498         }
1499
1500         remove
1501         {
1502             lock (eventLock)
1503             {
1504                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
1505                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1506             }
1507         }
1508     }
1509     ///<summary>Method to raise event CoordsDirtyEvt.</summary>
1510     public void OnCoordsDirtyEvt(EventArgs e)
1511     {
1512         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_COORDS_DIRTY";
1513         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1514         if (desc == IntPtr.Zero)
1515         {
1516             Eina.Log.Error($"Failed to get native event {key}");
1517             return;
1518         }
1519
1520         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
1521     }
1522     /// <summary>The manager_focus property has changed. The previously focused object is passed as an event argument.
1523     /// (Since EFL 1.22)</summary>
1524     public event EventHandler<Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args> ManagerFocusChangedEvt
1525     {
1526         add
1527         {
1528             lock (eventLock)
1529             {
1530                 var wRef = new WeakReference(this);
1531                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1532                 {
1533                     var obj = wRef.Target as Efl.Eo.IWrapper;
1534                     if (obj != null)
1535                     {
1536                                                 Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args args = new Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args();
1537                         args.arg = (Efl.Eo.Globals.CreateWrapperFor(evt.Info) as Efl.Ui.Focus.IObjectConcrete);
1538                         try
1539                         {
1540                             value?.Invoke(obj, args);
1541                         }
1542                         catch (Exception e)
1543                         {
1544                             Eina.Log.Error(e.ToString());
1545                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1546                         }
1547                     }
1548                 };
1549
1550                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
1551                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1552             }
1553         }
1554
1555         remove
1556         {
1557             lock (eventLock)
1558             {
1559                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
1560                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1561             }
1562         }
1563     }
1564     ///<summary>Method to raise event ManagerFocusChangedEvt.</summary>
1565     public void OnManagerFocusChangedEvt(Efl.Ui.Focus.IManagerManagerFocusChangedEvt_Args e)
1566     {
1567         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_MANAGER_FOCUS_CHANGED";
1568         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1569         if (desc == IntPtr.Zero)
1570         {
1571             Eina.Log.Error($"Failed to get native event {key}");
1572             return;
1573         }
1574
1575         IntPtr info = e.arg.NativeHandle;
1576         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1577     }
1578     /// <summary>Called when this focus manager is frozen or thawed, even_info being <c>true</c> indicates that it is now frozen, <c>false</c> indicates that it is thawed.
1579     /// (Since EFL 1.22)</summary>
1580     public event EventHandler<Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args> DirtyLogicFreezeChangedEvt
1581     {
1582         add
1583         {
1584             lock (eventLock)
1585             {
1586                 var wRef = new WeakReference(this);
1587                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
1588                 {
1589                     var obj = wRef.Target as Efl.Eo.IWrapper;
1590                     if (obj != null)
1591                     {
1592                                                 Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args args = new Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args();
1593                         args.arg = evt.Info != IntPtr.Zero;
1594                         try
1595                         {
1596                             value?.Invoke(obj, args);
1597                         }
1598                         catch (Exception e)
1599                         {
1600                             Eina.Log.Error(e.ToString());
1601                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1602                         }
1603                     }
1604                 };
1605
1606                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
1607                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
1608             }
1609         }
1610
1611         remove
1612         {
1613             lock (eventLock)
1614             {
1615                 string key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
1616                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
1617             }
1618         }
1619     }
1620     ///<summary>Method to raise event DirtyLogicFreezeChangedEvt.</summary>
1621     public void OnDirtyLogicFreezeChangedEvt(Efl.Ui.Focus.IManagerDirtyLogicFreezeChangedEvt_Args e)
1622     {
1623         var key = "_EFL_UI_FOCUS_MANAGER_EVENT_DIRTY_LOGIC_FREEZE_CHANGED";
1624         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
1625         if (desc == IntPtr.Zero)
1626         {
1627             Eina.Log.Error($"Failed to get native event {key}");
1628             return;
1629         }
1630
1631         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
1632         try
1633         {
1634             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
1635         }
1636         finally
1637         {
1638             Marshal.FreeHGlobal(info);
1639         }
1640     }
1641     /// <summary>Sub-object currently set as this object&apos;s single content.
1642     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
1643     /// (Since EFL 1.22)</summary>
1644     /// <returns>The sub-object.</returns>
1645     virtual public Efl.Gfx.IEntity GetContent() {
1646          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1647         Eina.Error.RaiseIfUnhandledException();
1648         return _ret_var;
1649  }
1650     /// <summary>Sub-object currently set as this object&apos;s single content.
1651     /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
1652     /// (Since EFL 1.22)</summary>
1653     /// <param name="content">The sub-object.</param>
1654     /// <returns><c>true</c> if <c>content</c> was successfully swallowed.</returns>
1655     virtual public bool SetContent(Efl.Gfx.IEntity content) {
1656                                  var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),content);
1657         Eina.Error.RaiseIfUnhandledException();
1658                         return _ret_var;
1659  }
1660     /// <summary>Remove the sub-object currently set as content of this object and return it. This object becomes empty.
1661     /// (Since EFL 1.22)</summary>
1662     /// <returns>Unswallowed object</returns>
1663     virtual public Efl.Gfx.IEntity UnsetContent() {
1664          var _ret_var = Efl.IContentConcrete.NativeMethods.efl_content_unset_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1665         Eina.Error.RaiseIfUnhandledException();
1666         return _ret_var;
1667  }
1668     /// <summary>The content position</summary>
1669     /// <returns>The position is virtual value, (0, 0) starting at the top-left.</returns>
1670     virtual public Eina.Position2D GetContentPos() {
1671          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));
1672         Eina.Error.RaiseIfUnhandledException();
1673         return _ret_var;
1674  }
1675     /// <summary>The content position</summary>
1676     /// <param name="pos">The position is virtual value, (0, 0) starting at the top-left.</param>
1677     virtual public void SetContentPos(Eina.Position2D pos) {
1678          Eina.Position2D.NativeStruct _in_pos = pos;
1679                         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);
1680         Eina.Error.RaiseIfUnhandledException();
1681                          }
1682     /// <summary>The content size</summary>
1683     /// <returns>The content size in pixels.</returns>
1684     virtual public Eina.Size2D GetContentSize() {
1685          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));
1686         Eina.Error.RaiseIfUnhandledException();
1687         return _ret_var;
1688  }
1689     /// <summary>The viewport geometry</summary>
1690     /// <returns>It is absolute geometry.</returns>
1691     virtual public Eina.Rect GetViewportGeometry() {
1692          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));
1693         Eina.Error.RaiseIfUnhandledException();
1694         return _ret_var;
1695  }
1696     /// <summary>Bouncing behavior
1697     /// 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>
1698     /// <param name="horiz">Horizontal bounce policy.</param>
1699     /// <param name="vert">Vertical bounce policy.</param>
1700     virtual public void GetBounceEnabled(out bool horiz, out bool vert) {
1701                                                          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);
1702         Eina.Error.RaiseIfUnhandledException();
1703                                          }
1704     /// <summary>Bouncing behavior
1705     /// 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>
1706     /// <param name="horiz">Horizontal bounce policy.</param>
1707     /// <param name="vert">Vertical bounce policy.</param>
1708     virtual public void SetBounceEnabled(bool horiz, bool vert) {
1709                                                          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);
1710         Eina.Error.RaiseIfUnhandledException();
1711                                          }
1712     /// <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>
1713     /// <returns><c>true</c> if freeze, <c>false</c> otherwise</returns>
1714     virtual public bool GetScrollFreeze() {
1715          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));
1716         Eina.Error.RaiseIfUnhandledException();
1717         return _ret_var;
1718  }
1719     /// <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>
1720     /// <param name="freeze"><c>true</c> if freeze, <c>false</c> otherwise</param>
1721     virtual public void SetScrollFreeze(bool freeze) {
1722                                  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);
1723         Eina.Error.RaiseIfUnhandledException();
1724                          }
1725     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1726     /// <returns><c>true</c> if hold, <c>false</c> otherwise</returns>
1727     virtual public bool GetScrollHold() {
1728          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));
1729         Eina.Error.RaiseIfUnhandledException();
1730         return _ret_var;
1731  }
1732     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
1733     /// <param name="hold"><c>true</c> if hold, <c>false</c> otherwise</param>
1734     virtual public void SetScrollHold(bool hold) {
1735                                  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);
1736         Eina.Error.RaiseIfUnhandledException();
1737                          }
1738     /// <summary>Controls an infinite loop for a scroller.</summary>
1739     /// <param name="loop_h">The scrolling horizontal loop</param>
1740     /// <param name="loop_v">The Scrolling vertical loop</param>
1741     virtual public void GetLooping(out bool loop_h, out bool loop_v) {
1742                                                          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);
1743         Eina.Error.RaiseIfUnhandledException();
1744                                          }
1745     /// <summary>Controls an infinite loop for a scroller.</summary>
1746     /// <param name="loop_h">The scrolling horizontal loop</param>
1747     /// <param name="loop_v">The Scrolling vertical loop</param>
1748     virtual public void SetLooping(bool loop_h, bool loop_v) {
1749                                                          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);
1750         Eina.Error.RaiseIfUnhandledException();
1751                                          }
1752     /// <summary>Blocking of scrolling (per axis)
1753     /// 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>
1754     /// <returns>Which axis (or axes) to block</returns>
1755     virtual public Efl.Ui.ScrollBlock GetMovementBlock() {
1756          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));
1757         Eina.Error.RaiseIfUnhandledException();
1758         return _ret_var;
1759  }
1760     /// <summary>Blocking of scrolling (per axis)
1761     /// 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>
1762     /// <param name="block">Which axis (or axes) to block</param>
1763     virtual public void SetMovementBlock(Efl.Ui.ScrollBlock block) {
1764                                  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);
1765         Eina.Error.RaiseIfUnhandledException();
1766                          }
1767     /// <summary>Control scrolling gravity on the scrollable
1768     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1769     ///
1770     /// The scroller will adjust the view to glue itself as follows.
1771     ///
1772     /// 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
1773     ///
1774     /// Default values for x and y are 0.0</summary>
1775     /// <param name="x">Horizontal scrolling gravity</param>
1776     /// <param name="y">Vertical scrolling gravity</param>
1777     virtual public void GetGravity(out double x, out double y) {
1778                                                          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);
1779         Eina.Error.RaiseIfUnhandledException();
1780                                          }
1781     /// <summary>Control scrolling gravity on the scrollable
1782     /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
1783     ///
1784     /// The scroller will adjust the view to glue itself as follows.
1785     ///
1786     /// 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
1787     ///
1788     /// Default values for x and y are 0.0</summary>
1789     /// <param name="x">Horizontal scrolling gravity</param>
1790     /// <param name="y">Vertical scrolling gravity</param>
1791     virtual public void SetGravity(double x, double y) {
1792                                                          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);
1793         Eina.Error.RaiseIfUnhandledException();
1794                                          }
1795     /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
1796     /// 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>
1797     /// <param name="w">Whether to limit the minimum horizontal size</param>
1798     /// <param name="h">Whether to limit the minimum vertical size</param>
1799     virtual public void SetMatchContent(bool w, bool h) {
1800                                                          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);
1801         Eina.Error.RaiseIfUnhandledException();
1802                                          }
1803     /// <summary>Control the step size
1804     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1805     /// <returns>The step size in pixels</returns>
1806     virtual public Eina.Position2D GetStepSize() {
1807          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));
1808         Eina.Error.RaiseIfUnhandledException();
1809         return _ret_var;
1810  }
1811     /// <summary>Control the step size
1812     /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
1813     /// <param name="step">The step size in pixels</param>
1814     virtual public void SetStepSize(Eina.Position2D step) {
1815          Eina.Position2D.NativeStruct _in_step = step;
1816                         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);
1817         Eina.Error.RaiseIfUnhandledException();
1818                          }
1819     /// <summary>Show a specific virtual region within the scroller content object.
1820     /// 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>
1821     /// <param name="rect">The position where to scroll. and The size user want to see</param>
1822     /// <param name="animation">Whether to scroll with animation or not</param>
1823     virtual public void Scroll(Eina.Rect rect, bool animation) {
1824          Eina.Rect.NativeStruct _in_rect = rect;
1825                                                 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);
1826         Eina.Error.RaiseIfUnhandledException();
1827                                          }
1828     /// <summary>Scrollbar visibility policy</summary>
1829     /// <param name="hbar">Horizontal scrollbar</param>
1830     /// <param name="vbar">Vertical scrollbar</param>
1831     virtual public void GetBarMode(out Efl.Ui.ScrollbarMode hbar, out Efl.Ui.ScrollbarMode vbar) {
1832                                                          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);
1833         Eina.Error.RaiseIfUnhandledException();
1834                                          }
1835     /// <summary>Scrollbar visibility policy</summary>
1836     /// <param name="hbar">Horizontal scrollbar</param>
1837     /// <param name="vbar">Vertical scrollbar</param>
1838     virtual public void SetBarMode(Efl.Ui.ScrollbarMode hbar, Efl.Ui.ScrollbarMode vbar) {
1839                                                          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);
1840         Eina.Error.RaiseIfUnhandledException();
1841                                          }
1842     /// <summary>Scrollbar size. It is calculated based on viewport size-content sizes.</summary>
1843     /// <param name="width">Value between 0.0 and 1.0</param>
1844     /// <param name="height">Value between 0.0 and 1.0</param>
1845     virtual public void GetBarSize(out double width, out double height) {
1846                                                          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);
1847         Eina.Error.RaiseIfUnhandledException();
1848                                          }
1849     /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
1850     /// <param name="posx">Value between 0.0 and 1.0</param>
1851     /// <param name="posy">Value between 0.0 and 1.0</param>
1852     virtual public void GetBarPosition(out double posx, out double posy) {
1853                                                          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);
1854         Eina.Error.RaiseIfUnhandledException();
1855                                          }
1856     /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
1857     /// <param name="posx">Value between 0.0 and 1.0</param>
1858     /// <param name="posy">Value between 0.0 and 1.0</param>
1859     virtual public void SetBarPosition(double posx, double posy) {
1860                                                          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);
1861         Eina.Error.RaiseIfUnhandledException();
1862                                          }
1863     /// <summary>Update bar visibility.
1864     /// The object will call this function whenever the bar need to be shown or hidden.</summary>
1865     virtual public void UpdateBarVisibility() {
1866          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));
1867         Eina.Error.RaiseIfUnhandledException();
1868          }
1869     /// <summary>If the widget needs a focus manager, this function will be called.
1870     /// It can be used and overriden to inject your own manager or set custom options on the focus manager.
1871     /// (Since EFL 1.22)</summary>
1872     /// <param name="root">The logical root object for focus.</param>
1873     /// <returns>The focus manager.</returns>
1874     virtual public Efl.Ui.Focus.IManager FocusManagerCreate(Efl.Ui.Focus.IObject root) {
1875                                  var _ret_var = Efl.Ui.IWidgetFocusManagerConcrete.NativeMethods.efl_ui_widget_focus_manager_create_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),root);
1876         Eina.Error.RaiseIfUnhandledException();
1877                         return _ret_var;
1878  }
1879     /// <summary>The element which is currently focused by this manager
1880     /// Use this property to retrieve the object currently being focused, or to set the focus to a new one. When <c>focus</c> is a logical child (which cannot receive focus), the next non-logical object is selected instead. If there is no such object, focus does not change.
1881     /// (Since EFL 1.22)</summary>
1882     /// <returns>Currently focused element.</returns>
1883     virtual public Efl.Ui.Focus.IObject GetManagerFocus() {
1884          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_focus_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1885         Eina.Error.RaiseIfUnhandledException();
1886         return _ret_var;
1887  }
1888     /// <summary>The element which is currently focused by this manager
1889     /// Use this property to retrieve the object currently being focused, or to set the focus to a new one. When <c>focus</c> is a logical child (which cannot receive focus), the next non-logical object is selected instead. If there is no such object, focus does not change.
1890     /// (Since EFL 1.22)</summary>
1891     /// <param name="focus">Currently focused element.</param>
1892     virtual public void SetManagerFocus(Efl.Ui.Focus.IObject focus) {
1893                                  Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_focus_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),focus);
1894         Eina.Error.RaiseIfUnhandledException();
1895                          }
1896     /// <summary>Add another manager to serve the move requests.
1897     /// If this value is set, all move requests are redirected to this manager object. Set it to <c>null</c> once nothing should be redirected anymore.
1898     /// (Since EFL 1.22)</summary>
1899     /// <returns>The redirect manager.</returns>
1900     virtual public Efl.Ui.Focus.IManager GetRedirect() {
1901          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_redirect_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1902         Eina.Error.RaiseIfUnhandledException();
1903         return _ret_var;
1904  }
1905     /// <summary>Add another manager to serve the move requests.
1906     /// If this value is set, all move requests are redirected to this manager object. Set it to <c>null</c> once nothing should be redirected anymore.
1907     /// (Since EFL 1.22)</summary>
1908     /// <param name="redirect">The redirect manager.</param>
1909     virtual public void SetRedirect(Efl.Ui.Focus.IManager redirect) {
1910                                  Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_redirect_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),redirect);
1911         Eina.Error.RaiseIfUnhandledException();
1912                          }
1913     /// <summary>The list of elements which are at the border of the graph.
1914     /// This means one of the relations right,left or down,up are not set. This call flushes all changes. See <see cref="Efl.Ui.Focus.IManager.Move"/>
1915     /// (Since EFL 1.22)</summary>
1916     /// <returns>An iterator over the border objects.</returns>
1917     virtual public Eina.Iterator<Efl.Ui.Focus.IObject> GetBorderElements() {
1918          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1919         Eina.Error.RaiseIfUnhandledException();
1920         return new Eina.Iterator<Efl.Ui.Focus.IObject>(_ret_var, false, false);
1921  }
1922     /// <summary>Get all elements that are at the border of the viewport
1923     /// Every element returned by this is located inside the viewport rectangle, but has a right, left, down or up neighbor outside the viewport.
1924     /// (Since EFL 1.22)</summary>
1925     /// <param name="viewport">The rectangle defining the viewport.</param>
1926     /// <returns>The list of border objects.</returns>
1927     virtual public Eina.Iterator<Efl.Ui.Focus.IObject> GetViewportElements(Eina.Rect viewport) {
1928          Eina.Rect.NativeStruct _in_viewport = viewport;
1929                         var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_viewport_elements_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_viewport);
1930         Eina.Error.RaiseIfUnhandledException();
1931                         return new Eina.Iterator<Efl.Ui.Focus.IObject>(_ret_var, false, false);
1932  }
1933     /// <summary>Root node for all logical subtrees.
1934     /// This property can only be set once.
1935     /// (Since EFL 1.22)</summary>
1936     /// <returns>Will be registered into this manager object.</returns>
1937     virtual public Efl.Ui.Focus.IObject GetRoot() {
1938          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_root_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1939         Eina.Error.RaiseIfUnhandledException();
1940         return _ret_var;
1941  }
1942     /// <summary>Root node for all logical subtrees.
1943     /// This property can only be set once.
1944     /// (Since EFL 1.22)</summary>
1945     /// <param name="root">Will be registered into this manager object.</param>
1946     /// <returns>If <c>true</c>, this is the root node</returns>
1947     virtual public bool SetRoot(Efl.Ui.Focus.IObject root) {
1948                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_root_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),root);
1949         Eina.Error.RaiseIfUnhandledException();
1950                         return _ret_var;
1951  }
1952     /// <summary>Move the focus in the given direction.
1953     /// This call flushes all changes. This means all changes between the last flush and now are computed.
1954     /// (Since EFL 1.22)</summary>
1955     /// <param name="direction">The direction to move to.</param>
1956     /// <returns>The element which is now focused.</returns>
1957     virtual public Efl.Ui.Focus.IObject Move(Efl.Ui.Focus.Direction direction) {
1958                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),direction);
1959         Eina.Error.RaiseIfUnhandledException();
1960                         return _ret_var;
1961  }
1962     /// <summary>Return the object in the <c>direction</c> from <c>child</c>.
1963     /// (Since EFL 1.22)</summary>
1964     /// <param name="direction">Direction to move focus.</param>
1965     /// <param name="child">The child to move from. Pass <c>null</c> to indicate the currently focused child.</param>
1966     /// <param name="logical">Wether you want to have a logical node as result or a non-logical. Note, in a <see cref="Efl.Ui.Focus.IManager.Move"/> call no logical node will get focus.</param>
1967     /// <returns>Object that would receive focus if moved in the given direction.</returns>
1968     virtual public Efl.Ui.Focus.IObject MoveRequest(Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject child, bool logical) {
1969                                                                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_request_move_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),direction, child, logical);
1970         Eina.Error.RaiseIfUnhandledException();
1971                                                         return _ret_var;
1972  }
1973     /// <summary>Return the widget in the direction next.
1974     /// The returned widget is a child of <c>root</c>. It&apos;s guaranteed that child will not be prepared once again, so you can call this function inside a <see cref="Efl.Ui.Focus.IObject.SetupOrder"/> call.
1975     /// (Since EFL 1.22)</summary>
1976     /// <param name="root">Parent for returned child.</param>
1977     /// <returns>Child of passed parameter.</returns>
1978     virtual public Efl.Ui.Focus.IObject RequestSubchild(Efl.Ui.Focus.IObject root) {
1979                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_request_subchild_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),root);
1980         Eina.Error.RaiseIfUnhandledException();
1981                         return _ret_var;
1982  }
1983     /// <summary>This will fetch the data from a registered node.
1984     /// Be aware this function will trigger a computation of all dirty nodes.
1985     /// (Since EFL 1.22)</summary>
1986     /// <param name="child">The child object to inspect.</param>
1987     /// <returns>The list of relations starting from <c>child</c>.</returns>
1988     virtual public Efl.Ui.Focus.Relations Fetch(Efl.Ui.Focus.IObject child) {
1989                                  var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_fetch_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),child);
1990         Eina.Error.RaiseIfUnhandledException();
1991                         var __ret_tmp = Eina.PrimitiveConversion.PointerToManaged<Efl.Ui.Focus.Relations>(_ret_var);
1992         Marshal.FreeHGlobal(_ret_var);
1993         return __ret_tmp;
1994  }
1995     /// <summary>Return the last logical object.
1996     /// The returned object is the last object that would be returned if you start at the root and move the direction into next.
1997     /// (Since EFL 1.22)</summary>
1998     /// <returns>Last object.</returns>
1999     virtual public Efl.Ui.Focus.ManagerLogicalEndDetail LogicalEnd() {
2000          var _ret_var = Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_logical_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2001         Eina.Error.RaiseIfUnhandledException();
2002         return _ret_var;
2003  }
2004     /// <summary>Reset the history stack of this manager object. This means the uppermost element will be unfocused, and all other elements will be removed from the remembered list.
2005     /// You should focus another element immediately after calling this, in order to always have a focused object.
2006     /// (Since EFL 1.22)</summary>
2007     virtual public void ResetHistory() {
2008          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_reset_history_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2009         Eina.Error.RaiseIfUnhandledException();
2010          }
2011     /// <summary>Remove the uppermost history element, and focus the previous one.
2012     /// If there is an element that was focused before, it will be used. Otherwise, the best fitting element from the registered elements will be focused.
2013     /// (Since EFL 1.22)</summary>
2014     virtual public void PopHistoryStack() {
2015          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2016         Eina.Error.RaiseIfUnhandledException();
2017          }
2018     /// <summary>Called when this manager is set as redirect.
2019     /// In case that this is called as an result of a move call, <c>direction</c> and <c>entry</c> will be set to the direction of the move call, and the <c>entry</c> object will be set to the object that had this manager as redirect property.
2020     /// (Since EFL 1.22)</summary>
2021     /// <param name="direction">The direction in which this should be setup.</param>
2022     /// <param name="entry">The object that caused this manager to be redirect.</param>
2023     virtual public void SetupOnFirstTouch(Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject entry) {
2024                                                          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_setup_on_first_touch_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),direction, entry);
2025         Eina.Error.RaiseIfUnhandledException();
2026                                          }
2027     /// <summary>This disables the cache invalidation when an object is moved.
2028     /// Even if an object is moved, the focus manager will not recalculate its relations. This can be used when you know that the set of widgets in the focus manager is moved the same way, so the relations between the widets in the set do not change and the complex calculations can be avoided. Use <see cref="Efl.Ui.Focus.IManager.DirtyLogicUnfreeze"/> to re-enable relationship calculation.
2029     /// (Since EFL 1.22)</summary>
2030     virtual public void FreezeDirtyLogic() {
2031          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2032         Eina.Error.RaiseIfUnhandledException();
2033          }
2034     /// <summary>This enables the cache invalidation when an object is moved.
2035     /// This is the counterpart to <see cref="Efl.Ui.Focus.IManager.FreezeDirtyLogic"/>.
2036     /// (Since EFL 1.22)</summary>
2037     virtual public void DirtyLogicUnfreeze() {
2038          Efl.Ui.Focus.IManagerConcrete.NativeMethods.efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2039         Eina.Error.RaiseIfUnhandledException();
2040          }
2041     /// <summary>Sub-object currently set as this object&apos;s single content.
2042 /// If it is set multiple times, previous sub-objects are removed first. Therefore, if an invalid <c>content</c> is set the object will become empty (it will have no sub-object).
2043 /// (Since EFL 1.22)</summary>
2044 /// <value>The sub-object.</value>
2045     public Efl.Gfx.IEntity Content {
2046         get { return GetContent(); }
2047         set { SetContent(value); }
2048     }
2049     /// <summary>The content position</summary>
2050 /// <value>The position is virtual value, (0, 0) starting at the top-left.</value>
2051     public Eina.Position2D ContentPos {
2052         get { return GetContentPos(); }
2053         set { SetContentPos(value); }
2054     }
2055     /// <summary>The content size</summary>
2056 /// <value>The content size in pixels.</value>
2057     public Eina.Size2D ContentSize {
2058         get { return GetContentSize(); }
2059     }
2060     /// <summary>The viewport geometry</summary>
2061 /// <value>It is absolute geometry.</value>
2062     public Eina.Rect ViewportGeometry {
2063         get { return GetViewportGeometry(); }
2064     }
2065     /// <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>
2066 /// <value><c>true</c> if freeze, <c>false</c> otherwise</value>
2067     public bool ScrollFreeze {
2068         get { return GetScrollFreeze(); }
2069         set { SetScrollFreeze(value); }
2070     }
2071     /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
2072 /// <value><c>true</c> if hold, <c>false</c> otherwise</value>
2073     public bool ScrollHold {
2074         get { return GetScrollHold(); }
2075         set { SetScrollHold(value); }
2076     }
2077     /// <summary>Blocking of scrolling (per axis)
2078 /// 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>
2079 /// <value>Which axis (or axes) to block</value>
2080     public Efl.Ui.ScrollBlock MovementBlock {
2081         get { return GetMovementBlock(); }
2082         set { SetMovementBlock(value); }
2083     }
2084     /// <summary>Control the step size
2085 /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
2086 /// <value>The step size in pixels</value>
2087     public Eina.Position2D StepSize {
2088         get { return GetStepSize(); }
2089         set { SetStepSize(value); }
2090     }
2091     /// <summary>The element which is currently focused by this manager
2092 /// Use this property to retrieve the object currently being focused, or to set the focus to a new one. When <c>focus</c> is a logical child (which cannot receive focus), the next non-logical object is selected instead. If there is no such object, focus does not change.
2093 /// (Since EFL 1.22)</summary>
2094 /// <value>Currently focused element.</value>
2095     public Efl.Ui.Focus.IObject ManagerFocus {
2096         get { return GetManagerFocus(); }
2097         set { SetManagerFocus(value); }
2098     }
2099     /// <summary>Add another manager to serve the move requests.
2100 /// If this value is set, all move requests are redirected to this manager object. Set it to <c>null</c> once nothing should be redirected anymore.
2101 /// (Since EFL 1.22)</summary>
2102 /// <value>The redirect manager.</value>
2103     public Efl.Ui.Focus.IManager Redirect {
2104         get { return GetRedirect(); }
2105         set { SetRedirect(value); }
2106     }
2107     /// <summary>The list of elements which are at the border of the graph.
2108 /// This means one of the relations right,left or down,up are not set. This call flushes all changes. See <see cref="Efl.Ui.Focus.IManager.Move"/>
2109 /// (Since EFL 1.22)</summary>
2110 /// <value>An iterator over the border objects.</value>
2111     public Eina.Iterator<Efl.Ui.Focus.IObject> BorderElements {
2112         get { return GetBorderElements(); }
2113     }
2114     /// <summary>Root node for all logical subtrees.
2115 /// This property can only be set once.
2116 /// (Since EFL 1.22)</summary>
2117 /// <value>Will be registered into this manager object.</value>
2118     public Efl.Ui.Focus.IObject Root {
2119         get { return GetRoot(); }
2120         set { SetRoot(value); }
2121     }
2122     private static IntPtr GetEflClassStatic()
2123     {
2124         return Efl.Ui.Scroller.efl_ui_scroller_class_get();
2125     }
2126     /// <summary>Wrapper for native methods and virtual method delegates.
2127     /// For internal use by generated code only.</summary>
2128     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
2129     {
2130         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
2131         /// <summary>Gets the list of Eo operations to override.</summary>
2132         /// <returns>The list of Eo operations to be overload.</returns>
2133         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
2134         {
2135             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
2136             var methods = Efl.Eo.Globals.GetUserMethods(type);
2137
2138             if (efl_content_get_static_delegate == null)
2139             {
2140                 efl_content_get_static_delegate = new efl_content_get_delegate(content_get);
2141             }
2142
2143             if (methods.FirstOrDefault(m => m.Name == "GetContent") != null)
2144             {
2145                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_content_get_static_delegate) });
2146             }
2147
2148             if (efl_content_set_static_delegate == null)
2149             {
2150                 efl_content_set_static_delegate = new efl_content_set_delegate(content_set);
2151             }
2152
2153             if (methods.FirstOrDefault(m => m.Name == "SetContent") != null)
2154             {
2155                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_set"), func = Marshal.GetFunctionPointerForDelegate(efl_content_set_static_delegate) });
2156             }
2157
2158             if (efl_content_unset_static_delegate == null)
2159             {
2160                 efl_content_unset_static_delegate = new efl_content_unset_delegate(content_unset);
2161             }
2162
2163             if (methods.FirstOrDefault(m => m.Name == "UnsetContent") != null)
2164             {
2165                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_content_unset"), func = Marshal.GetFunctionPointerForDelegate(efl_content_unset_static_delegate) });
2166             }
2167
2168             if (efl_ui_scrollable_content_pos_get_static_delegate == null)
2169             {
2170                 efl_ui_scrollable_content_pos_get_static_delegate = new efl_ui_scrollable_content_pos_get_delegate(content_pos_get);
2171             }
2172
2173             if (methods.FirstOrDefault(m => m.Name == "GetContentPos") != null)
2174             {
2175                 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) });
2176             }
2177
2178             if (efl_ui_scrollable_content_pos_set_static_delegate == null)
2179             {
2180                 efl_ui_scrollable_content_pos_set_static_delegate = new efl_ui_scrollable_content_pos_set_delegate(content_pos_set);
2181             }
2182
2183             if (methods.FirstOrDefault(m => m.Name == "SetContentPos") != null)
2184             {
2185                 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) });
2186             }
2187
2188             if (efl_ui_scrollable_content_size_get_static_delegate == null)
2189             {
2190                 efl_ui_scrollable_content_size_get_static_delegate = new efl_ui_scrollable_content_size_get_delegate(content_size_get);
2191             }
2192
2193             if (methods.FirstOrDefault(m => m.Name == "GetContentSize") != null)
2194             {
2195                 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) });
2196             }
2197
2198             if (efl_ui_scrollable_viewport_geometry_get_static_delegate == null)
2199             {
2200                 efl_ui_scrollable_viewport_geometry_get_static_delegate = new efl_ui_scrollable_viewport_geometry_get_delegate(viewport_geometry_get);
2201             }
2202
2203             if (methods.FirstOrDefault(m => m.Name == "GetViewportGeometry") != null)
2204             {
2205                 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) });
2206             }
2207
2208             if (efl_ui_scrollable_bounce_enabled_get_static_delegate == null)
2209             {
2210                 efl_ui_scrollable_bounce_enabled_get_static_delegate = new efl_ui_scrollable_bounce_enabled_get_delegate(bounce_enabled_get);
2211             }
2212
2213             if (methods.FirstOrDefault(m => m.Name == "GetBounceEnabled") != null)
2214             {
2215                 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) });
2216             }
2217
2218             if (efl_ui_scrollable_bounce_enabled_set_static_delegate == null)
2219             {
2220                 efl_ui_scrollable_bounce_enabled_set_static_delegate = new efl_ui_scrollable_bounce_enabled_set_delegate(bounce_enabled_set);
2221             }
2222
2223             if (methods.FirstOrDefault(m => m.Name == "SetBounceEnabled") != null)
2224             {
2225                 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) });
2226             }
2227
2228             if (efl_ui_scrollable_scroll_freeze_get_static_delegate == null)
2229             {
2230                 efl_ui_scrollable_scroll_freeze_get_static_delegate = new efl_ui_scrollable_scroll_freeze_get_delegate(scroll_freeze_get);
2231             }
2232
2233             if (methods.FirstOrDefault(m => m.Name == "GetScrollFreeze") != null)
2234             {
2235                 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) });
2236             }
2237
2238             if (efl_ui_scrollable_scroll_freeze_set_static_delegate == null)
2239             {
2240                 efl_ui_scrollable_scroll_freeze_set_static_delegate = new efl_ui_scrollable_scroll_freeze_set_delegate(scroll_freeze_set);
2241             }
2242
2243             if (methods.FirstOrDefault(m => m.Name == "SetScrollFreeze") != null)
2244             {
2245                 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) });
2246             }
2247
2248             if (efl_ui_scrollable_scroll_hold_get_static_delegate == null)
2249             {
2250                 efl_ui_scrollable_scroll_hold_get_static_delegate = new efl_ui_scrollable_scroll_hold_get_delegate(scroll_hold_get);
2251             }
2252
2253             if (methods.FirstOrDefault(m => m.Name == "GetScrollHold") != null)
2254             {
2255                 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) });
2256             }
2257
2258             if (efl_ui_scrollable_scroll_hold_set_static_delegate == null)
2259             {
2260                 efl_ui_scrollable_scroll_hold_set_static_delegate = new efl_ui_scrollable_scroll_hold_set_delegate(scroll_hold_set);
2261             }
2262
2263             if (methods.FirstOrDefault(m => m.Name == "SetScrollHold") != null)
2264             {
2265                 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) });
2266             }
2267
2268             if (efl_ui_scrollable_looping_get_static_delegate == null)
2269             {
2270                 efl_ui_scrollable_looping_get_static_delegate = new efl_ui_scrollable_looping_get_delegate(looping_get);
2271             }
2272
2273             if (methods.FirstOrDefault(m => m.Name == "GetLooping") != null)
2274             {
2275                 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) });
2276             }
2277
2278             if (efl_ui_scrollable_looping_set_static_delegate == null)
2279             {
2280                 efl_ui_scrollable_looping_set_static_delegate = new efl_ui_scrollable_looping_set_delegate(looping_set);
2281             }
2282
2283             if (methods.FirstOrDefault(m => m.Name == "SetLooping") != null)
2284             {
2285                 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) });
2286             }
2287
2288             if (efl_ui_scrollable_movement_block_get_static_delegate == null)
2289             {
2290                 efl_ui_scrollable_movement_block_get_static_delegate = new efl_ui_scrollable_movement_block_get_delegate(movement_block_get);
2291             }
2292
2293             if (methods.FirstOrDefault(m => m.Name == "GetMovementBlock") != null)
2294             {
2295                 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) });
2296             }
2297
2298             if (efl_ui_scrollable_movement_block_set_static_delegate == null)
2299             {
2300                 efl_ui_scrollable_movement_block_set_static_delegate = new efl_ui_scrollable_movement_block_set_delegate(movement_block_set);
2301             }
2302
2303             if (methods.FirstOrDefault(m => m.Name == "SetMovementBlock") != null)
2304             {
2305                 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) });
2306             }
2307
2308             if (efl_ui_scrollable_gravity_get_static_delegate == null)
2309             {
2310                 efl_ui_scrollable_gravity_get_static_delegate = new efl_ui_scrollable_gravity_get_delegate(gravity_get);
2311             }
2312
2313             if (methods.FirstOrDefault(m => m.Name == "GetGravity") != null)
2314             {
2315                 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) });
2316             }
2317
2318             if (efl_ui_scrollable_gravity_set_static_delegate == null)
2319             {
2320                 efl_ui_scrollable_gravity_set_static_delegate = new efl_ui_scrollable_gravity_set_delegate(gravity_set);
2321             }
2322
2323             if (methods.FirstOrDefault(m => m.Name == "SetGravity") != null)
2324             {
2325                 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) });
2326             }
2327
2328             if (efl_ui_scrollable_match_content_set_static_delegate == null)
2329             {
2330                 efl_ui_scrollable_match_content_set_static_delegate = new efl_ui_scrollable_match_content_set_delegate(match_content_set);
2331             }
2332
2333             if (methods.FirstOrDefault(m => m.Name == "SetMatchContent") != null)
2334             {
2335                 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) });
2336             }
2337
2338             if (efl_ui_scrollable_step_size_get_static_delegate == null)
2339             {
2340                 efl_ui_scrollable_step_size_get_static_delegate = new efl_ui_scrollable_step_size_get_delegate(step_size_get);
2341             }
2342
2343             if (methods.FirstOrDefault(m => m.Name == "GetStepSize") != null)
2344             {
2345                 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) });
2346             }
2347
2348             if (efl_ui_scrollable_step_size_set_static_delegate == null)
2349             {
2350                 efl_ui_scrollable_step_size_set_static_delegate = new efl_ui_scrollable_step_size_set_delegate(step_size_set);
2351             }
2352
2353             if (methods.FirstOrDefault(m => m.Name == "SetStepSize") != null)
2354             {
2355                 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) });
2356             }
2357
2358             if (efl_ui_scrollable_scroll_static_delegate == null)
2359             {
2360                 efl_ui_scrollable_scroll_static_delegate = new efl_ui_scrollable_scroll_delegate(scroll);
2361             }
2362
2363             if (methods.FirstOrDefault(m => m.Name == "Scroll") != null)
2364             {
2365                 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) });
2366             }
2367
2368             if (efl_ui_scrollbar_bar_mode_get_static_delegate == null)
2369             {
2370                 efl_ui_scrollbar_bar_mode_get_static_delegate = new efl_ui_scrollbar_bar_mode_get_delegate(bar_mode_get);
2371             }
2372
2373             if (methods.FirstOrDefault(m => m.Name == "GetBarMode") != null)
2374             {
2375                 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) });
2376             }
2377
2378             if (efl_ui_scrollbar_bar_mode_set_static_delegate == null)
2379             {
2380                 efl_ui_scrollbar_bar_mode_set_static_delegate = new efl_ui_scrollbar_bar_mode_set_delegate(bar_mode_set);
2381             }
2382
2383             if (methods.FirstOrDefault(m => m.Name == "SetBarMode") != null)
2384             {
2385                 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) });
2386             }
2387
2388             if (efl_ui_scrollbar_bar_size_get_static_delegate == null)
2389             {
2390                 efl_ui_scrollbar_bar_size_get_static_delegate = new efl_ui_scrollbar_bar_size_get_delegate(bar_size_get);
2391             }
2392
2393             if (methods.FirstOrDefault(m => m.Name == "GetBarSize") != null)
2394             {
2395                 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) });
2396             }
2397
2398             if (efl_ui_scrollbar_bar_position_get_static_delegate == null)
2399             {
2400                 efl_ui_scrollbar_bar_position_get_static_delegate = new efl_ui_scrollbar_bar_position_get_delegate(bar_position_get);
2401             }
2402
2403             if (methods.FirstOrDefault(m => m.Name == "GetBarPosition") != null)
2404             {
2405                 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) });
2406             }
2407
2408             if (efl_ui_scrollbar_bar_position_set_static_delegate == null)
2409             {
2410                 efl_ui_scrollbar_bar_position_set_static_delegate = new efl_ui_scrollbar_bar_position_set_delegate(bar_position_set);
2411             }
2412
2413             if (methods.FirstOrDefault(m => m.Name == "SetBarPosition") != null)
2414             {
2415                 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) });
2416             }
2417
2418             if (efl_ui_scrollbar_bar_visibility_update_static_delegate == null)
2419             {
2420                 efl_ui_scrollbar_bar_visibility_update_static_delegate = new efl_ui_scrollbar_bar_visibility_update_delegate(bar_visibility_update);
2421             }
2422
2423             if (methods.FirstOrDefault(m => m.Name == "UpdateBarVisibility") != null)
2424             {
2425                 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) });
2426             }
2427
2428             if (efl_ui_widget_focus_manager_create_static_delegate == null)
2429             {
2430                 efl_ui_widget_focus_manager_create_static_delegate = new efl_ui_widget_focus_manager_create_delegate(focus_manager_create);
2431             }
2432
2433             if (methods.FirstOrDefault(m => m.Name == "FocusManagerCreate") != null)
2434             {
2435                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_widget_focus_manager_create"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_widget_focus_manager_create_static_delegate) });
2436             }
2437
2438             if (efl_ui_focus_manager_focus_get_static_delegate == null)
2439             {
2440                 efl_ui_focus_manager_focus_get_static_delegate = new efl_ui_focus_manager_focus_get_delegate(manager_focus_get);
2441             }
2442
2443             if (methods.FirstOrDefault(m => m.Name == "GetManagerFocus") != null)
2444             {
2445                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_focus_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_focus_get_static_delegate) });
2446             }
2447
2448             if (efl_ui_focus_manager_focus_set_static_delegate == null)
2449             {
2450                 efl_ui_focus_manager_focus_set_static_delegate = new efl_ui_focus_manager_focus_set_delegate(manager_focus_set);
2451             }
2452
2453             if (methods.FirstOrDefault(m => m.Name == "SetManagerFocus") != null)
2454             {
2455                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_focus_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_focus_set_static_delegate) });
2456             }
2457
2458             if (efl_ui_focus_manager_redirect_get_static_delegate == null)
2459             {
2460                 efl_ui_focus_manager_redirect_get_static_delegate = new efl_ui_focus_manager_redirect_get_delegate(redirect_get);
2461             }
2462
2463             if (methods.FirstOrDefault(m => m.Name == "GetRedirect") != null)
2464             {
2465                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_redirect_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_redirect_get_static_delegate) });
2466             }
2467
2468             if (efl_ui_focus_manager_redirect_set_static_delegate == null)
2469             {
2470                 efl_ui_focus_manager_redirect_set_static_delegate = new efl_ui_focus_manager_redirect_set_delegate(redirect_set);
2471             }
2472
2473             if (methods.FirstOrDefault(m => m.Name == "SetRedirect") != null)
2474             {
2475                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_redirect_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_redirect_set_static_delegate) });
2476             }
2477
2478             if (efl_ui_focus_manager_border_elements_get_static_delegate == null)
2479             {
2480                 efl_ui_focus_manager_border_elements_get_static_delegate = new efl_ui_focus_manager_border_elements_get_delegate(border_elements_get);
2481             }
2482
2483             if (methods.FirstOrDefault(m => m.Name == "GetBorderElements") != null)
2484             {
2485                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_border_elements_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_border_elements_get_static_delegate) });
2486             }
2487
2488             if (efl_ui_focus_manager_viewport_elements_get_static_delegate == null)
2489             {
2490                 efl_ui_focus_manager_viewport_elements_get_static_delegate = new efl_ui_focus_manager_viewport_elements_get_delegate(viewport_elements_get);
2491             }
2492
2493             if (methods.FirstOrDefault(m => m.Name == "GetViewportElements") != null)
2494             {
2495                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_viewport_elements_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_viewport_elements_get_static_delegate) });
2496             }
2497
2498             if (efl_ui_focus_manager_root_get_static_delegate == null)
2499             {
2500                 efl_ui_focus_manager_root_get_static_delegate = new efl_ui_focus_manager_root_get_delegate(root_get);
2501             }
2502
2503             if (methods.FirstOrDefault(m => m.Name == "GetRoot") != null)
2504             {
2505                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_root_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_root_get_static_delegate) });
2506             }
2507
2508             if (efl_ui_focus_manager_root_set_static_delegate == null)
2509             {
2510                 efl_ui_focus_manager_root_set_static_delegate = new efl_ui_focus_manager_root_set_delegate(root_set);
2511             }
2512
2513             if (methods.FirstOrDefault(m => m.Name == "SetRoot") != null)
2514             {
2515                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_root_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_root_set_static_delegate) });
2516             }
2517
2518             if (efl_ui_focus_manager_move_static_delegate == null)
2519             {
2520                 efl_ui_focus_manager_move_static_delegate = new efl_ui_focus_manager_move_delegate(move);
2521             }
2522
2523             if (methods.FirstOrDefault(m => m.Name == "Move") != null)
2524             {
2525                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_move_static_delegate) });
2526             }
2527
2528             if (efl_ui_focus_manager_request_move_static_delegate == null)
2529             {
2530                 efl_ui_focus_manager_request_move_static_delegate = new efl_ui_focus_manager_request_move_delegate(request_move);
2531             }
2532
2533             if (methods.FirstOrDefault(m => m.Name == "MoveRequest") != null)
2534             {
2535                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_request_move"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_request_move_static_delegate) });
2536             }
2537
2538             if (efl_ui_focus_manager_request_subchild_static_delegate == null)
2539             {
2540                 efl_ui_focus_manager_request_subchild_static_delegate = new efl_ui_focus_manager_request_subchild_delegate(request_subchild);
2541             }
2542
2543             if (methods.FirstOrDefault(m => m.Name == "RequestSubchild") != null)
2544             {
2545                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_request_subchild"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_request_subchild_static_delegate) });
2546             }
2547
2548             if (efl_ui_focus_manager_fetch_static_delegate == null)
2549             {
2550                 efl_ui_focus_manager_fetch_static_delegate = new efl_ui_focus_manager_fetch_delegate(fetch);
2551             }
2552
2553             if (methods.FirstOrDefault(m => m.Name == "Fetch") != null)
2554             {
2555                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_fetch"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_fetch_static_delegate) });
2556             }
2557
2558             if (efl_ui_focus_manager_logical_end_static_delegate == null)
2559             {
2560                 efl_ui_focus_manager_logical_end_static_delegate = new efl_ui_focus_manager_logical_end_delegate(logical_end);
2561             }
2562
2563             if (methods.FirstOrDefault(m => m.Name == "LogicalEnd") != null)
2564             {
2565                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_logical_end"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_logical_end_static_delegate) });
2566             }
2567
2568             if (efl_ui_focus_manager_reset_history_static_delegate == null)
2569             {
2570                 efl_ui_focus_manager_reset_history_static_delegate = new efl_ui_focus_manager_reset_history_delegate(reset_history);
2571             }
2572
2573             if (methods.FirstOrDefault(m => m.Name == "ResetHistory") != null)
2574             {
2575                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_reset_history"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_reset_history_static_delegate) });
2576             }
2577
2578             if (efl_ui_focus_manager_pop_history_stack_static_delegate == null)
2579             {
2580                 efl_ui_focus_manager_pop_history_stack_static_delegate = new efl_ui_focus_manager_pop_history_stack_delegate(pop_history_stack);
2581             }
2582
2583             if (methods.FirstOrDefault(m => m.Name == "PopHistoryStack") != null)
2584             {
2585                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_pop_history_stack"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_pop_history_stack_static_delegate) });
2586             }
2587
2588             if (efl_ui_focus_manager_setup_on_first_touch_static_delegate == null)
2589             {
2590                 efl_ui_focus_manager_setup_on_first_touch_static_delegate = new efl_ui_focus_manager_setup_on_first_touch_delegate(setup_on_first_touch);
2591             }
2592
2593             if (methods.FirstOrDefault(m => m.Name == "SetupOnFirstTouch") != null)
2594             {
2595                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_setup_on_first_touch"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_setup_on_first_touch_static_delegate) });
2596             }
2597
2598             if (efl_ui_focus_manager_dirty_logic_freeze_static_delegate == null)
2599             {
2600                 efl_ui_focus_manager_dirty_logic_freeze_static_delegate = new efl_ui_focus_manager_dirty_logic_freeze_delegate(dirty_logic_freeze);
2601             }
2602
2603             if (methods.FirstOrDefault(m => m.Name == "FreezeDirtyLogic") != null)
2604             {
2605                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_dirty_logic_freeze"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_dirty_logic_freeze_static_delegate) });
2606             }
2607
2608             if (efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate == null)
2609             {
2610                 efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate = new efl_ui_focus_manager_dirty_logic_unfreeze_delegate(dirty_logic_unfreeze);
2611             }
2612
2613             if (methods.FirstOrDefault(m => m.Name == "DirtyLogicUnfreeze") != null)
2614             {
2615                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_ui_focus_manager_dirty_logic_unfreeze"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate) });
2616             }
2617
2618             descs.AddRange(base.GetEoOps(type));
2619             return descs;
2620         }
2621         /// <summary>Returns the Eo class for the native methods of this class.</summary>
2622         /// <returns>The native class pointer.</returns>
2623         public override IntPtr GetEflClass()
2624         {
2625             return Efl.Ui.Scroller.efl_ui_scroller_class_get();
2626         }
2627
2628         #pragma warning disable CA1707, SA1300, SA1600
2629
2630         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2631         private delegate Efl.Gfx.IEntity efl_content_get_delegate(System.IntPtr obj, System.IntPtr pd);
2632
2633         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2634         public delegate Efl.Gfx.IEntity efl_content_get_api_delegate(System.IntPtr obj);
2635
2636         public static Efl.Eo.FunctionWrapper<efl_content_get_api_delegate> efl_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_content_get_api_delegate>(Module, "efl_content_get");
2637
2638         private static Efl.Gfx.IEntity content_get(System.IntPtr obj, System.IntPtr pd)
2639         {
2640             Eina.Log.Debug("function efl_content_get was called");
2641             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2642             if (wrapper != null)
2643             {
2644             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
2645                 try
2646                 {
2647                     _ret_var = ((Scroller)wrapper).GetContent();
2648                 }
2649                 catch (Exception e)
2650                 {
2651                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2652                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2653                 }
2654
2655         return _ret_var;
2656
2657             }
2658             else
2659             {
2660                 return efl_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2661             }
2662         }
2663
2664         private static efl_content_get_delegate efl_content_get_static_delegate;
2665
2666         [return: MarshalAs(UnmanagedType.U1)]
2667         private delegate bool efl_content_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
2668
2669         [return: MarshalAs(UnmanagedType.U1)]
2670         public delegate bool efl_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity content);
2671
2672         public static Efl.Eo.FunctionWrapper<efl_content_set_api_delegate> efl_content_set_ptr = new Efl.Eo.FunctionWrapper<efl_content_set_api_delegate>(Module, "efl_content_set");
2673
2674         private static bool content_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.IEntity content)
2675         {
2676             Eina.Log.Debug("function efl_content_set was called");
2677             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2678             if (wrapper != null)
2679             {
2680                                     bool _ret_var = default(bool);
2681                 try
2682                 {
2683                     _ret_var = ((Scroller)wrapper).SetContent(content);
2684                 }
2685                 catch (Exception e)
2686                 {
2687                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2688                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2689                 }
2690
2691                         return _ret_var;
2692
2693             }
2694             else
2695             {
2696                 return efl_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), content);
2697             }
2698         }
2699
2700         private static efl_content_set_delegate efl_content_set_static_delegate;
2701
2702         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2703         private delegate Efl.Gfx.IEntity efl_content_unset_delegate(System.IntPtr obj, System.IntPtr pd);
2704
2705         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2706         public delegate Efl.Gfx.IEntity efl_content_unset_api_delegate(System.IntPtr obj);
2707
2708         public static Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate> efl_content_unset_ptr = new Efl.Eo.FunctionWrapper<efl_content_unset_api_delegate>(Module, "efl_content_unset");
2709
2710         private static Efl.Gfx.IEntity content_unset(System.IntPtr obj, System.IntPtr pd)
2711         {
2712             Eina.Log.Debug("function efl_content_unset was called");
2713             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2714             if (wrapper != null)
2715             {
2716             Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
2717                 try
2718                 {
2719                     _ret_var = ((Scroller)wrapper).UnsetContent();
2720                 }
2721                 catch (Exception e)
2722                 {
2723                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2724                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2725                 }
2726
2727         return _ret_var;
2728
2729             }
2730             else
2731             {
2732                 return efl_content_unset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2733             }
2734         }
2735
2736         private static efl_content_unset_delegate efl_content_unset_static_delegate;
2737
2738
2739         private delegate Eina.Position2D.NativeStruct efl_ui_scrollable_content_pos_get_delegate(System.IntPtr obj, System.IntPtr pd);
2740
2741
2742         public delegate Eina.Position2D.NativeStruct efl_ui_scrollable_content_pos_get_api_delegate(System.IntPtr obj);
2743
2744         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");
2745
2746         private static Eina.Position2D.NativeStruct content_pos_get(System.IntPtr obj, System.IntPtr pd)
2747         {
2748             Eina.Log.Debug("function efl_ui_scrollable_content_pos_get was called");
2749             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2750             if (wrapper != null)
2751             {
2752             Eina.Position2D _ret_var = default(Eina.Position2D);
2753                 try
2754                 {
2755                     _ret_var = ((Scroller)wrapper).GetContentPos();
2756                 }
2757                 catch (Exception e)
2758                 {
2759                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2760                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2761                 }
2762
2763         return _ret_var;
2764
2765             }
2766             else
2767             {
2768                 return efl_ui_scrollable_content_pos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2769             }
2770         }
2771
2772         private static efl_ui_scrollable_content_pos_get_delegate efl_ui_scrollable_content_pos_get_static_delegate;
2773
2774
2775         private delegate void efl_ui_scrollable_content_pos_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct pos);
2776
2777
2778         public delegate void efl_ui_scrollable_content_pos_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct pos);
2779
2780         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");
2781
2782         private static void content_pos_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct pos)
2783         {
2784             Eina.Log.Debug("function efl_ui_scrollable_content_pos_set was called");
2785             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2786             if (wrapper != null)
2787             {
2788         Eina.Position2D _in_pos = pos;
2789
2790                 try
2791                 {
2792                     ((Scroller)wrapper).SetContentPos(_in_pos);
2793                 }
2794                 catch (Exception e)
2795                 {
2796                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2797                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2798                 }
2799
2800
2801             }
2802             else
2803             {
2804                 efl_ui_scrollable_content_pos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), pos);
2805             }
2806         }
2807
2808         private static efl_ui_scrollable_content_pos_set_delegate efl_ui_scrollable_content_pos_set_static_delegate;
2809
2810
2811         private delegate Eina.Size2D.NativeStruct efl_ui_scrollable_content_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2812
2813
2814         public delegate Eina.Size2D.NativeStruct efl_ui_scrollable_content_size_get_api_delegate(System.IntPtr obj);
2815
2816         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");
2817
2818         private static Eina.Size2D.NativeStruct content_size_get(System.IntPtr obj, System.IntPtr pd)
2819         {
2820             Eina.Log.Debug("function efl_ui_scrollable_content_size_get was called");
2821             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2822             if (wrapper != null)
2823             {
2824             Eina.Size2D _ret_var = default(Eina.Size2D);
2825                 try
2826                 {
2827                     _ret_var = ((Scroller)wrapper).GetContentSize();
2828                 }
2829                 catch (Exception e)
2830                 {
2831                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2832                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2833                 }
2834
2835         return _ret_var;
2836
2837             }
2838             else
2839             {
2840                 return efl_ui_scrollable_content_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2841             }
2842         }
2843
2844         private static efl_ui_scrollable_content_size_get_delegate efl_ui_scrollable_content_size_get_static_delegate;
2845
2846
2847         private delegate Eina.Rect.NativeStruct efl_ui_scrollable_viewport_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
2848
2849
2850         public delegate Eina.Rect.NativeStruct efl_ui_scrollable_viewport_geometry_get_api_delegate(System.IntPtr obj);
2851
2852         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");
2853
2854         private static Eina.Rect.NativeStruct viewport_geometry_get(System.IntPtr obj, System.IntPtr pd)
2855         {
2856             Eina.Log.Debug("function efl_ui_scrollable_viewport_geometry_get was called");
2857             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2858             if (wrapper != null)
2859             {
2860             Eina.Rect _ret_var = default(Eina.Rect);
2861                 try
2862                 {
2863                     _ret_var = ((Scroller)wrapper).GetViewportGeometry();
2864                 }
2865                 catch (Exception e)
2866                 {
2867                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2868                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2869                 }
2870
2871         return _ret_var;
2872
2873             }
2874             else
2875             {
2876                 return efl_ui_scrollable_viewport_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2877             }
2878         }
2879
2880         private static efl_ui_scrollable_viewport_geometry_get_delegate efl_ui_scrollable_viewport_geometry_get_static_delegate;
2881
2882
2883         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);
2884
2885
2886         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);
2887
2888         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");
2889
2890         private static void bounce_enabled_get(System.IntPtr obj, System.IntPtr pd, out bool horiz, out bool vert)
2891         {
2892             Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_get was called");
2893             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2894             if (wrapper != null)
2895             {
2896                         horiz = default(bool);        vert = default(bool);
2897                 try
2898                 {
2899                     ((Scroller)wrapper).GetBounceEnabled(out horiz, out vert);
2900                 }
2901                 catch (Exception e)
2902                 {
2903                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2904                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2905                 }
2906
2907
2908             }
2909             else
2910             {
2911                 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);
2912             }
2913         }
2914
2915         private static efl_ui_scrollable_bounce_enabled_get_delegate efl_ui_scrollable_bounce_enabled_get_static_delegate;
2916
2917
2918         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);
2919
2920
2921         public delegate void efl_ui_scrollable_bounce_enabled_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool horiz, [MarshalAs(UnmanagedType.U1)] bool vert);
2922
2923         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");
2924
2925         private static void bounce_enabled_set(System.IntPtr obj, System.IntPtr pd, bool horiz, bool vert)
2926         {
2927             Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_set was called");
2928             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2929             if (wrapper != null)
2930             {
2931
2932                 try
2933                 {
2934                     ((Scroller)wrapper).SetBounceEnabled(horiz, vert);
2935                 }
2936                 catch (Exception e)
2937                 {
2938                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2939                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2940                 }
2941
2942
2943             }
2944             else
2945             {
2946                 efl_ui_scrollable_bounce_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), horiz, vert);
2947             }
2948         }
2949
2950         private static efl_ui_scrollable_bounce_enabled_set_delegate efl_ui_scrollable_bounce_enabled_set_static_delegate;
2951
2952         [return: MarshalAs(UnmanagedType.U1)]
2953         private delegate bool efl_ui_scrollable_scroll_freeze_get_delegate(System.IntPtr obj, System.IntPtr pd);
2954
2955         [return: MarshalAs(UnmanagedType.U1)]
2956         public delegate bool efl_ui_scrollable_scroll_freeze_get_api_delegate(System.IntPtr obj);
2957
2958         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");
2959
2960         private static bool scroll_freeze_get(System.IntPtr obj, System.IntPtr pd)
2961         {
2962             Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_get was called");
2963             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2964             if (wrapper != null)
2965             {
2966             bool _ret_var = default(bool);
2967                 try
2968                 {
2969                     _ret_var = ((Scroller)wrapper).GetScrollFreeze();
2970                 }
2971                 catch (Exception e)
2972                 {
2973                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2974                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2975                 }
2976
2977         return _ret_var;
2978
2979             }
2980             else
2981             {
2982                 return efl_ui_scrollable_scroll_freeze_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2983             }
2984         }
2985
2986         private static efl_ui_scrollable_scroll_freeze_get_delegate efl_ui_scrollable_scroll_freeze_get_static_delegate;
2987
2988
2989         private delegate void efl_ui_scrollable_scroll_freeze_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool freeze);
2990
2991
2992         public delegate void efl_ui_scrollable_scroll_freeze_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool freeze);
2993
2994         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");
2995
2996         private static void scroll_freeze_set(System.IntPtr obj, System.IntPtr pd, bool freeze)
2997         {
2998             Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_set was called");
2999             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3000             if (wrapper != null)
3001             {
3002
3003                 try
3004                 {
3005                     ((Scroller)wrapper).SetScrollFreeze(freeze);
3006                 }
3007                 catch (Exception e)
3008                 {
3009                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3010                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3011                 }
3012
3013
3014             }
3015             else
3016             {
3017                 efl_ui_scrollable_scroll_freeze_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), freeze);
3018             }
3019         }
3020
3021         private static efl_ui_scrollable_scroll_freeze_set_delegate efl_ui_scrollable_scroll_freeze_set_static_delegate;
3022
3023         [return: MarshalAs(UnmanagedType.U1)]
3024         private delegate bool efl_ui_scrollable_scroll_hold_get_delegate(System.IntPtr obj, System.IntPtr pd);
3025
3026         [return: MarshalAs(UnmanagedType.U1)]
3027         public delegate bool efl_ui_scrollable_scroll_hold_get_api_delegate(System.IntPtr obj);
3028
3029         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");
3030
3031         private static bool scroll_hold_get(System.IntPtr obj, System.IntPtr pd)
3032         {
3033             Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_get was called");
3034             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3035             if (wrapper != null)
3036             {
3037             bool _ret_var = default(bool);
3038                 try
3039                 {
3040                     _ret_var = ((Scroller)wrapper).GetScrollHold();
3041                 }
3042                 catch (Exception e)
3043                 {
3044                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3045                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3046                 }
3047
3048         return _ret_var;
3049
3050             }
3051             else
3052             {
3053                 return efl_ui_scrollable_scroll_hold_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3054             }
3055         }
3056
3057         private static efl_ui_scrollable_scroll_hold_get_delegate efl_ui_scrollable_scroll_hold_get_static_delegate;
3058
3059
3060         private delegate void efl_ui_scrollable_scroll_hold_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool hold);
3061
3062
3063         public delegate void efl_ui_scrollable_scroll_hold_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool hold);
3064
3065         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");
3066
3067         private static void scroll_hold_set(System.IntPtr obj, System.IntPtr pd, bool hold)
3068         {
3069             Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_set was called");
3070             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3071             if (wrapper != null)
3072             {
3073
3074                 try
3075                 {
3076                     ((Scroller)wrapper).SetScrollHold(hold);
3077                 }
3078                 catch (Exception e)
3079                 {
3080                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3081                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3082                 }
3083
3084
3085             }
3086             else
3087             {
3088                 efl_ui_scrollable_scroll_hold_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hold);
3089             }
3090         }
3091
3092         private static efl_ui_scrollable_scroll_hold_set_delegate efl_ui_scrollable_scroll_hold_set_static_delegate;
3093
3094
3095         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);
3096
3097
3098         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);
3099
3100         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");
3101
3102         private static void looping_get(System.IntPtr obj, System.IntPtr pd, out bool loop_h, out bool loop_v)
3103         {
3104             Eina.Log.Debug("function efl_ui_scrollable_looping_get was called");
3105             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3106             if (wrapper != null)
3107             {
3108                         loop_h = default(bool);        loop_v = default(bool);
3109                 try
3110                 {
3111                     ((Scroller)wrapper).GetLooping(out loop_h, out loop_v);
3112                 }
3113                 catch (Exception e)
3114                 {
3115                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3116                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3117                 }
3118
3119
3120             }
3121             else
3122             {
3123                 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);
3124             }
3125         }
3126
3127         private static efl_ui_scrollable_looping_get_delegate efl_ui_scrollable_looping_get_static_delegate;
3128
3129
3130         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);
3131
3132
3133         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);
3134
3135         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");
3136
3137         private static void looping_set(System.IntPtr obj, System.IntPtr pd, bool loop_h, bool loop_v)
3138         {
3139             Eina.Log.Debug("function efl_ui_scrollable_looping_set was called");
3140             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3141             if (wrapper != null)
3142             {
3143
3144                 try
3145                 {
3146                     ((Scroller)wrapper).SetLooping(loop_h, loop_v);
3147                 }
3148                 catch (Exception e)
3149                 {
3150                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3151                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3152                 }
3153
3154
3155             }
3156             else
3157             {
3158                 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);
3159             }
3160         }
3161
3162         private static efl_ui_scrollable_looping_set_delegate efl_ui_scrollable_looping_set_static_delegate;
3163
3164
3165         private delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_delegate(System.IntPtr obj, System.IntPtr pd);
3166
3167
3168         public delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_api_delegate(System.IntPtr obj);
3169
3170         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");
3171
3172         private static Efl.Ui.ScrollBlock movement_block_get(System.IntPtr obj, System.IntPtr pd)
3173         {
3174             Eina.Log.Debug("function efl_ui_scrollable_movement_block_get was called");
3175             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3176             if (wrapper != null)
3177             {
3178             Efl.Ui.ScrollBlock _ret_var = default(Efl.Ui.ScrollBlock);
3179                 try
3180                 {
3181                     _ret_var = ((Scroller)wrapper).GetMovementBlock();
3182                 }
3183                 catch (Exception e)
3184                 {
3185                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3186                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3187                 }
3188
3189         return _ret_var;
3190
3191             }
3192             else
3193             {
3194                 return efl_ui_scrollable_movement_block_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3195             }
3196         }
3197
3198         private static efl_ui_scrollable_movement_block_get_delegate efl_ui_scrollable_movement_block_get_static_delegate;
3199
3200
3201         private delegate void efl_ui_scrollable_movement_block_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollBlock block);
3202
3203
3204         public delegate void efl_ui_scrollable_movement_block_set_api_delegate(System.IntPtr obj,  Efl.Ui.ScrollBlock block);
3205
3206         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");
3207
3208         private static void movement_block_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ScrollBlock block)
3209         {
3210             Eina.Log.Debug("function efl_ui_scrollable_movement_block_set was called");
3211             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3212             if (wrapper != null)
3213             {
3214
3215                 try
3216                 {
3217                     ((Scroller)wrapper).SetMovementBlock(block);
3218                 }
3219                 catch (Exception e)
3220                 {
3221                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3222                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3223                 }
3224
3225
3226             }
3227             else
3228             {
3229                 efl_ui_scrollable_movement_block_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), block);
3230             }
3231         }
3232
3233         private static efl_ui_scrollable_movement_block_set_delegate efl_ui_scrollable_movement_block_set_static_delegate;
3234
3235
3236         private delegate void efl_ui_scrollable_gravity_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
3237
3238
3239         public delegate void efl_ui_scrollable_gravity_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
3240
3241         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");
3242
3243         private static void gravity_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
3244         {
3245             Eina.Log.Debug("function efl_ui_scrollable_gravity_get was called");
3246             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3247             if (wrapper != null)
3248             {
3249                         x = default(double);        y = default(double);
3250                 try
3251                 {
3252                     ((Scroller)wrapper).GetGravity(out x, out y);
3253                 }
3254                 catch (Exception e)
3255                 {
3256                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3257                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3258                 }
3259
3260
3261             }
3262             else
3263             {
3264                 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);
3265             }
3266         }
3267
3268         private static efl_ui_scrollable_gravity_get_delegate efl_ui_scrollable_gravity_get_static_delegate;
3269
3270
3271         private delegate void efl_ui_scrollable_gravity_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
3272
3273
3274         public delegate void efl_ui_scrollable_gravity_set_api_delegate(System.IntPtr obj,  double x,  double y);
3275
3276         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");
3277
3278         private static void gravity_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
3279         {
3280             Eina.Log.Debug("function efl_ui_scrollable_gravity_set was called");
3281             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3282             if (wrapper != null)
3283             {
3284
3285                 try
3286                 {
3287                     ((Scroller)wrapper).SetGravity(x, y);
3288                 }
3289                 catch (Exception e)
3290                 {
3291                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3292                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3293                 }
3294
3295
3296             }
3297             else
3298             {
3299                 efl_ui_scrollable_gravity_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
3300             }
3301         }
3302
3303         private static efl_ui_scrollable_gravity_set_delegate efl_ui_scrollable_gravity_set_static_delegate;
3304
3305
3306         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);
3307
3308
3309         public delegate void efl_ui_scrollable_match_content_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool w, [MarshalAs(UnmanagedType.U1)] bool h);
3310
3311         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");
3312
3313         private static void match_content_set(System.IntPtr obj, System.IntPtr pd, bool w, bool h)
3314         {
3315             Eina.Log.Debug("function efl_ui_scrollable_match_content_set was called");
3316             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3317             if (wrapper != null)
3318             {
3319
3320                 try
3321                 {
3322                     ((Scroller)wrapper).SetMatchContent(w, h);
3323                 }
3324                 catch (Exception e)
3325                 {
3326                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3327                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3328                 }
3329
3330
3331             }
3332             else
3333             {
3334                 efl_ui_scrollable_match_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), w, h);
3335             }
3336         }
3337
3338         private static efl_ui_scrollable_match_content_set_delegate efl_ui_scrollable_match_content_set_static_delegate;
3339
3340
3341         private delegate Eina.Position2D.NativeStruct efl_ui_scrollable_step_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
3342
3343
3344         public delegate Eina.Position2D.NativeStruct efl_ui_scrollable_step_size_get_api_delegate(System.IntPtr obj);
3345
3346         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");
3347
3348         private static Eina.Position2D.NativeStruct step_size_get(System.IntPtr obj, System.IntPtr pd)
3349         {
3350             Eina.Log.Debug("function efl_ui_scrollable_step_size_get was called");
3351             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3352             if (wrapper != null)
3353             {
3354             Eina.Position2D _ret_var = default(Eina.Position2D);
3355                 try
3356                 {
3357                     _ret_var = ((Scroller)wrapper).GetStepSize();
3358                 }
3359                 catch (Exception e)
3360                 {
3361                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3362                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3363                 }
3364
3365         return _ret_var;
3366
3367             }
3368             else
3369             {
3370                 return efl_ui_scrollable_step_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3371             }
3372         }
3373
3374         private static efl_ui_scrollable_step_size_get_delegate efl_ui_scrollable_step_size_get_static_delegate;
3375
3376
3377         private delegate void efl_ui_scrollable_step_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D.NativeStruct step);
3378
3379
3380         public delegate void efl_ui_scrollable_step_size_set_api_delegate(System.IntPtr obj,  Eina.Position2D.NativeStruct step);
3381
3382         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");
3383
3384         private static void step_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Position2D.NativeStruct step)
3385         {
3386             Eina.Log.Debug("function efl_ui_scrollable_step_size_set was called");
3387             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3388             if (wrapper != null)
3389             {
3390         Eina.Position2D _in_step = step;
3391
3392                 try
3393                 {
3394                     ((Scroller)wrapper).SetStepSize(_in_step);
3395                 }
3396                 catch (Exception e)
3397                 {
3398                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3399                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3400                 }
3401
3402
3403             }
3404             else
3405             {
3406                 efl_ui_scrollable_step_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), step);
3407             }
3408         }
3409
3410         private static efl_ui_scrollable_step_size_set_delegate efl_ui_scrollable_step_size_set_static_delegate;
3411
3412
3413         private delegate void efl_ui_scrollable_scroll_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool animation);
3414
3415
3416         public delegate void efl_ui_scrollable_scroll_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct rect, [MarshalAs(UnmanagedType.U1)] bool animation);
3417
3418         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");
3419
3420         private static void scroll(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct rect, bool animation)
3421         {
3422             Eina.Log.Debug("function efl_ui_scrollable_scroll was called");
3423             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3424             if (wrapper != null)
3425             {
3426         Eina.Rect _in_rect = rect;
3427
3428                 try
3429                 {
3430                     ((Scroller)wrapper).Scroll(_in_rect, animation);
3431                 }
3432                 catch (Exception e)
3433                 {
3434                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3435                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3436                 }
3437
3438
3439             }
3440             else
3441             {
3442                 efl_ui_scrollable_scroll_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rect, animation);
3443             }
3444         }
3445
3446         private static efl_ui_scrollable_scroll_delegate efl_ui_scrollable_scroll_static_delegate;
3447
3448
3449         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);
3450
3451
3452         public delegate void efl_ui_scrollbar_bar_mode_get_api_delegate(System.IntPtr obj,  out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar);
3453
3454         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");
3455
3456         private static void bar_mode_get(System.IntPtr obj, System.IntPtr pd, out Efl.Ui.ScrollbarMode hbar, out Efl.Ui.ScrollbarMode vbar)
3457         {
3458             Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_get was called");
3459             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3460             if (wrapper != null)
3461             {
3462                         hbar = default(Efl.Ui.ScrollbarMode);        vbar = default(Efl.Ui.ScrollbarMode);
3463                 try
3464                 {
3465                     ((Scroller)wrapper).GetBarMode(out hbar, out vbar);
3466                 }
3467                 catch (Exception e)
3468                 {
3469                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3470                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3471                 }
3472
3473
3474             }
3475             else
3476             {
3477                 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);
3478             }
3479         }
3480
3481         private static efl_ui_scrollbar_bar_mode_get_delegate efl_ui_scrollbar_bar_mode_get_static_delegate;
3482
3483
3484         private delegate void efl_ui_scrollbar_bar_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar);
3485
3486
3487         public delegate void efl_ui_scrollbar_bar_mode_set_api_delegate(System.IntPtr obj,  Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar);
3488
3489         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");
3490
3491         private static void bar_mode_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ScrollbarMode hbar, Efl.Ui.ScrollbarMode vbar)
3492         {
3493             Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_set was called");
3494             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3495             if (wrapper != null)
3496             {
3497
3498                 try
3499                 {
3500                     ((Scroller)wrapper).SetBarMode(hbar, vbar);
3501                 }
3502                 catch (Exception e)
3503                 {
3504                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3505                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3506                 }
3507
3508
3509             }
3510             else
3511             {
3512                 efl_ui_scrollbar_bar_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hbar, vbar);
3513             }
3514         }
3515
3516         private static efl_ui_scrollbar_bar_mode_set_delegate efl_ui_scrollbar_bar_mode_set_static_delegate;
3517
3518
3519         private delegate void efl_ui_scrollbar_bar_size_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double width,  out double height);
3520
3521
3522         public delegate void efl_ui_scrollbar_bar_size_get_api_delegate(System.IntPtr obj,  out double width,  out double height);
3523
3524         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");
3525
3526         private static void bar_size_get(System.IntPtr obj, System.IntPtr pd, out double width, out double height)
3527         {
3528             Eina.Log.Debug("function efl_ui_scrollbar_bar_size_get was called");
3529             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3530             if (wrapper != null)
3531             {
3532                         width = default(double);        height = default(double);
3533                 try
3534                 {
3535                     ((Scroller)wrapper).GetBarSize(out width, out height);
3536                 }
3537                 catch (Exception e)
3538                 {
3539                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3540                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3541                 }
3542
3543
3544             }
3545             else
3546             {
3547                 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);
3548             }
3549         }
3550
3551         private static efl_ui_scrollbar_bar_size_get_delegate efl_ui_scrollbar_bar_size_get_static_delegate;
3552
3553
3554         private delegate void efl_ui_scrollbar_bar_position_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double posx,  out double posy);
3555
3556
3557         public delegate void efl_ui_scrollbar_bar_position_get_api_delegate(System.IntPtr obj,  out double posx,  out double posy);
3558
3559         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");
3560
3561         private static void bar_position_get(System.IntPtr obj, System.IntPtr pd, out double posx, out double posy)
3562         {
3563             Eina.Log.Debug("function efl_ui_scrollbar_bar_position_get was called");
3564             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3565             if (wrapper != null)
3566             {
3567                         posx = default(double);        posy = default(double);
3568                 try
3569                 {
3570                     ((Scroller)wrapper).GetBarPosition(out posx, out posy);
3571                 }
3572                 catch (Exception e)
3573                 {
3574                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3575                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3576                 }
3577
3578
3579             }
3580             else
3581             {
3582                 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);
3583             }
3584         }
3585
3586         private static efl_ui_scrollbar_bar_position_get_delegate efl_ui_scrollbar_bar_position_get_static_delegate;
3587
3588
3589         private delegate void efl_ui_scrollbar_bar_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  double posx,  double posy);
3590
3591
3592         public delegate void efl_ui_scrollbar_bar_position_set_api_delegate(System.IntPtr obj,  double posx,  double posy);
3593
3594         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");
3595
3596         private static void bar_position_set(System.IntPtr obj, System.IntPtr pd, double posx, double posy)
3597         {
3598             Eina.Log.Debug("function efl_ui_scrollbar_bar_position_set was called");
3599             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3600             if (wrapper != null)
3601             {
3602
3603                 try
3604                 {
3605                     ((Scroller)wrapper).SetBarPosition(posx, posy);
3606                 }
3607                 catch (Exception e)
3608                 {
3609                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3610                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3611                 }
3612
3613
3614             }
3615             else
3616             {
3617                 efl_ui_scrollbar_bar_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), posx, posy);
3618             }
3619         }
3620
3621         private static efl_ui_scrollbar_bar_position_set_delegate efl_ui_scrollbar_bar_position_set_static_delegate;
3622
3623
3624         private delegate void efl_ui_scrollbar_bar_visibility_update_delegate(System.IntPtr obj, System.IntPtr pd);
3625
3626
3627         public delegate void efl_ui_scrollbar_bar_visibility_update_api_delegate(System.IntPtr obj);
3628
3629         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");
3630
3631         private static void bar_visibility_update(System.IntPtr obj, System.IntPtr pd)
3632         {
3633             Eina.Log.Debug("function efl_ui_scrollbar_bar_visibility_update was called");
3634             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3635             if (wrapper != null)
3636             {
3637
3638                 try
3639                 {
3640                     ((Scroller)wrapper).UpdateBarVisibility();
3641                 }
3642                 catch (Exception e)
3643                 {
3644                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3645                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3646                 }
3647
3648
3649             }
3650             else
3651             {
3652                 efl_ui_scrollbar_bar_visibility_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3653             }
3654         }
3655
3656         private static efl_ui_scrollbar_bar_visibility_update_delegate efl_ui_scrollbar_bar_visibility_update_static_delegate;
3657
3658         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3659         private delegate Efl.Ui.Focus.IManager efl_ui_widget_focus_manager_create_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
3660
3661         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3662         public delegate Efl.Ui.Focus.IManager efl_ui_widget_focus_manager_create_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
3663
3664         public static Efl.Eo.FunctionWrapper<efl_ui_widget_focus_manager_create_api_delegate> efl_ui_widget_focus_manager_create_ptr = new Efl.Eo.FunctionWrapper<efl_ui_widget_focus_manager_create_api_delegate>(Module, "efl_ui_widget_focus_manager_create");
3665
3666         private static Efl.Ui.Focus.IManager focus_manager_create(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
3667         {
3668             Eina.Log.Debug("function efl_ui_widget_focus_manager_create was called");
3669             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3670             if (wrapper != null)
3671             {
3672                                     Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
3673                 try
3674                 {
3675                     _ret_var = ((Scroller)wrapper).FocusManagerCreate(root);
3676                 }
3677                 catch (Exception e)
3678                 {
3679                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3680                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3681                 }
3682
3683                         return _ret_var;
3684
3685             }
3686             else
3687             {
3688                 return efl_ui_widget_focus_manager_create_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
3689             }
3690         }
3691
3692         private static efl_ui_widget_focus_manager_create_delegate efl_ui_widget_focus_manager_create_static_delegate;
3693
3694         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3695         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_focus_get_delegate(System.IntPtr obj, System.IntPtr pd);
3696
3697         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3698         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_focus_get_api_delegate(System.IntPtr obj);
3699
3700         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_get_api_delegate> efl_ui_focus_manager_focus_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_get_api_delegate>(Module, "efl_ui_focus_manager_focus_get");
3701
3702         private static Efl.Ui.Focus.IObject manager_focus_get(System.IntPtr obj, System.IntPtr pd)
3703         {
3704             Eina.Log.Debug("function efl_ui_focus_manager_focus_get was called");
3705             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3706             if (wrapper != null)
3707             {
3708             Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
3709                 try
3710                 {
3711                     _ret_var = ((Scroller)wrapper).GetManagerFocus();
3712                 }
3713                 catch (Exception e)
3714                 {
3715                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3716                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3717                 }
3718
3719         return _ret_var;
3720
3721             }
3722             else
3723             {
3724                 return efl_ui_focus_manager_focus_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3725             }
3726         }
3727
3728         private static efl_ui_focus_manager_focus_get_delegate efl_ui_focus_manager_focus_get_static_delegate;
3729
3730
3731         private delegate void efl_ui_focus_manager_focus_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject focus);
3732
3733
3734         public delegate void efl_ui_focus_manager_focus_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject focus);
3735
3736         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_set_api_delegate> efl_ui_focus_manager_focus_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_focus_set_api_delegate>(Module, "efl_ui_focus_manager_focus_set");
3737
3738         private static void manager_focus_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject focus)
3739         {
3740             Eina.Log.Debug("function efl_ui_focus_manager_focus_set was called");
3741             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3742             if (wrapper != null)
3743             {
3744
3745                 try
3746                 {
3747                     ((Scroller)wrapper).SetManagerFocus(focus);
3748                 }
3749                 catch (Exception e)
3750                 {
3751                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3752                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3753                 }
3754
3755
3756             }
3757             else
3758             {
3759                 efl_ui_focus_manager_focus_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), focus);
3760             }
3761         }
3762
3763         private static efl_ui_focus_manager_focus_set_delegate efl_ui_focus_manager_focus_set_static_delegate;
3764
3765         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3766         private delegate Efl.Ui.Focus.IManager efl_ui_focus_manager_redirect_get_delegate(System.IntPtr obj, System.IntPtr pd);
3767
3768         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3769         public delegate Efl.Ui.Focus.IManager efl_ui_focus_manager_redirect_get_api_delegate(System.IntPtr obj);
3770
3771         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_get_api_delegate> efl_ui_focus_manager_redirect_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_get_api_delegate>(Module, "efl_ui_focus_manager_redirect_get");
3772
3773         private static Efl.Ui.Focus.IManager redirect_get(System.IntPtr obj, System.IntPtr pd)
3774         {
3775             Eina.Log.Debug("function efl_ui_focus_manager_redirect_get was called");
3776             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3777             if (wrapper != null)
3778             {
3779             Efl.Ui.Focus.IManager _ret_var = default(Efl.Ui.Focus.IManager);
3780                 try
3781                 {
3782                     _ret_var = ((Scroller)wrapper).GetRedirect();
3783                 }
3784                 catch (Exception e)
3785                 {
3786                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3787                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3788                 }
3789
3790         return _ret_var;
3791
3792             }
3793             else
3794             {
3795                 return efl_ui_focus_manager_redirect_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3796             }
3797         }
3798
3799         private static efl_ui_focus_manager_redirect_get_delegate efl_ui_focus_manager_redirect_get_static_delegate;
3800
3801
3802         private delegate void efl_ui_focus_manager_redirect_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
3803
3804
3805         public delegate void efl_ui_focus_manager_redirect_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IManager redirect);
3806
3807         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_set_api_delegate> efl_ui_focus_manager_redirect_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_redirect_set_api_delegate>(Module, "efl_ui_focus_manager_redirect_set");
3808
3809         private static void redirect_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IManager redirect)
3810         {
3811             Eina.Log.Debug("function efl_ui_focus_manager_redirect_set was called");
3812             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3813             if (wrapper != null)
3814             {
3815
3816                 try
3817                 {
3818                     ((Scroller)wrapper).SetRedirect(redirect);
3819                 }
3820                 catch (Exception e)
3821                 {
3822                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3823                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3824                 }
3825
3826
3827             }
3828             else
3829             {
3830                 efl_ui_focus_manager_redirect_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), redirect);
3831             }
3832         }
3833
3834         private static efl_ui_focus_manager_redirect_set_delegate efl_ui_focus_manager_redirect_set_static_delegate;
3835
3836
3837         private delegate System.IntPtr efl_ui_focus_manager_border_elements_get_delegate(System.IntPtr obj, System.IntPtr pd);
3838
3839
3840         public delegate System.IntPtr efl_ui_focus_manager_border_elements_get_api_delegate(System.IntPtr obj);
3841
3842         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_border_elements_get_api_delegate> efl_ui_focus_manager_border_elements_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_border_elements_get_api_delegate>(Module, "efl_ui_focus_manager_border_elements_get");
3843
3844         private static System.IntPtr border_elements_get(System.IntPtr obj, System.IntPtr pd)
3845         {
3846             Eina.Log.Debug("function efl_ui_focus_manager_border_elements_get was called");
3847             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3848             if (wrapper != null)
3849             {
3850             Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
3851                 try
3852                 {
3853                     _ret_var = ((Scroller)wrapper).GetBorderElements();
3854                 }
3855                 catch (Exception e)
3856                 {
3857                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3858                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3859                 }
3860
3861         return _ret_var.Handle;
3862
3863             }
3864             else
3865             {
3866                 return efl_ui_focus_manager_border_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3867             }
3868         }
3869
3870         private static efl_ui_focus_manager_border_elements_get_delegate efl_ui_focus_manager_border_elements_get_static_delegate;
3871
3872
3873         private delegate System.IntPtr efl_ui_focus_manager_viewport_elements_get_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct viewport);
3874
3875
3876         public delegate System.IntPtr efl_ui_focus_manager_viewport_elements_get_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct viewport);
3877
3878         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_viewport_elements_get_api_delegate> efl_ui_focus_manager_viewport_elements_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_viewport_elements_get_api_delegate>(Module, "efl_ui_focus_manager_viewport_elements_get");
3879
3880         private static System.IntPtr viewport_elements_get(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct viewport)
3881         {
3882             Eina.Log.Debug("function efl_ui_focus_manager_viewport_elements_get was called");
3883             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3884             if (wrapper != null)
3885             {
3886         Eina.Rect _in_viewport = viewport;
3887                             Eina.Iterator<Efl.Ui.Focus.IObject> _ret_var = default(Eina.Iterator<Efl.Ui.Focus.IObject>);
3888                 try
3889                 {
3890                     _ret_var = ((Scroller)wrapper).GetViewportElements(_in_viewport);
3891                 }
3892                 catch (Exception e)
3893                 {
3894                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3895                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3896                 }
3897
3898                         return _ret_var.Handle;
3899
3900             }
3901             else
3902             {
3903                 return efl_ui_focus_manager_viewport_elements_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), viewport);
3904             }
3905         }
3906
3907         private static efl_ui_focus_manager_viewport_elements_get_delegate efl_ui_focus_manager_viewport_elements_get_static_delegate;
3908
3909         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3910         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_root_get_delegate(System.IntPtr obj, System.IntPtr pd);
3911
3912         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3913         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_root_get_api_delegate(System.IntPtr obj);
3914
3915         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_get_api_delegate> efl_ui_focus_manager_root_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_get_api_delegate>(Module, "efl_ui_focus_manager_root_get");
3916
3917         private static Efl.Ui.Focus.IObject root_get(System.IntPtr obj, System.IntPtr pd)
3918         {
3919             Eina.Log.Debug("function efl_ui_focus_manager_root_get was called");
3920             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3921             if (wrapper != null)
3922             {
3923             Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
3924                 try
3925                 {
3926                     _ret_var = ((Scroller)wrapper).GetRoot();
3927                 }
3928                 catch (Exception e)
3929                 {
3930                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3931                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3932                 }
3933
3934         return _ret_var;
3935
3936             }
3937             else
3938             {
3939                 return efl_ui_focus_manager_root_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3940             }
3941         }
3942
3943         private static efl_ui_focus_manager_root_get_delegate efl_ui_focus_manager_root_get_static_delegate;
3944
3945         [return: MarshalAs(UnmanagedType.U1)]
3946         private delegate bool efl_ui_focus_manager_root_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
3947
3948         [return: MarshalAs(UnmanagedType.U1)]
3949         public delegate bool efl_ui_focus_manager_root_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
3950
3951         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_set_api_delegate> efl_ui_focus_manager_root_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_root_set_api_delegate>(Module, "efl_ui_focus_manager_root_set");
3952
3953         private static bool root_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
3954         {
3955             Eina.Log.Debug("function efl_ui_focus_manager_root_set was called");
3956             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3957             if (wrapper != null)
3958             {
3959                                     bool _ret_var = default(bool);
3960                 try
3961                 {
3962                     _ret_var = ((Scroller)wrapper).SetRoot(root);
3963                 }
3964                 catch (Exception e)
3965                 {
3966                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3967                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3968                 }
3969
3970                         return _ret_var;
3971
3972             }
3973             else
3974             {
3975                 return efl_ui_focus_manager_root_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
3976             }
3977         }
3978
3979         private static efl_ui_focus_manager_root_set_delegate efl_ui_focus_manager_root_set_static_delegate;
3980
3981         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3982         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_move_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction);
3983
3984         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
3985         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_move_api_delegate(System.IntPtr obj,  Efl.Ui.Focus.Direction direction);
3986
3987         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_move_api_delegate> efl_ui_focus_manager_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_move_api_delegate>(Module, "efl_ui_focus_manager_move");
3988
3989         private static Efl.Ui.Focus.IObject move(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.Direction direction)
3990         {
3991             Eina.Log.Debug("function efl_ui_focus_manager_move was called");
3992             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
3993             if (wrapper != null)
3994             {
3995                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
3996                 try
3997                 {
3998                     _ret_var = ((Scroller)wrapper).Move(direction);
3999                 }
4000                 catch (Exception e)
4001                 {
4002                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4003                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4004                 }
4005
4006                         return _ret_var;
4007
4008             }
4009             else
4010             {
4011                 return efl_ui_focus_manager_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), direction);
4012             }
4013         }
4014
4015         private static efl_ui_focus_manager_move_delegate efl_ui_focus_manager_move_static_delegate;
4016
4017         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
4018         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_request_move_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.U1)] bool logical);
4019
4020         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
4021         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_request_move_api_delegate(System.IntPtr obj,  Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child, [MarshalAs(UnmanagedType.U1)] bool logical);
4022
4023         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_move_api_delegate> efl_ui_focus_manager_request_move_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_move_api_delegate>(Module, "efl_ui_focus_manager_request_move");
4024
4025         private static Efl.Ui.Focus.IObject request_move(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject child, bool logical)
4026         {
4027             Eina.Log.Debug("function efl_ui_focus_manager_request_move was called");
4028             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4029             if (wrapper != null)
4030             {
4031                                                                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
4032                 try
4033                 {
4034                     _ret_var = ((Scroller)wrapper).MoveRequest(direction, child, logical);
4035                 }
4036                 catch (Exception e)
4037                 {
4038                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4039                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4040                 }
4041
4042                                                         return _ret_var;
4043
4044             }
4045             else
4046             {
4047                 return efl_ui_focus_manager_request_move_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), direction, child, logical);
4048             }
4049         }
4050
4051         private static efl_ui_focus_manager_request_move_delegate efl_ui_focus_manager_request_move_static_delegate;
4052
4053         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
4054         private delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_request_subchild_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
4055
4056         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
4057         public delegate Efl.Ui.Focus.IObject efl_ui_focus_manager_request_subchild_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject root);
4058
4059         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_subchild_api_delegate> efl_ui_focus_manager_request_subchild_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_request_subchild_api_delegate>(Module, "efl_ui_focus_manager_request_subchild");
4060
4061         private static Efl.Ui.Focus.IObject request_subchild(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject root)
4062         {
4063             Eina.Log.Debug("function efl_ui_focus_manager_request_subchild was called");
4064             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4065             if (wrapper != null)
4066             {
4067                                     Efl.Ui.Focus.IObject _ret_var = default(Efl.Ui.Focus.IObject);
4068                 try
4069                 {
4070                     _ret_var = ((Scroller)wrapper).RequestSubchild(root);
4071                 }
4072                 catch (Exception e)
4073                 {
4074                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4075                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4076                 }
4077
4078                         return _ret_var;
4079
4080             }
4081             else
4082             {
4083                 return efl_ui_focus_manager_request_subchild_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), root);
4084             }
4085         }
4086
4087         private static efl_ui_focus_manager_request_subchild_delegate efl_ui_focus_manager_request_subchild_static_delegate;
4088
4089
4090         private delegate System.IntPtr efl_ui_focus_manager_fetch_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child);
4091
4092
4093         public delegate System.IntPtr efl_ui_focus_manager_fetch_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject child);
4094
4095         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_fetch_api_delegate> efl_ui_focus_manager_fetch_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_fetch_api_delegate>(Module, "efl_ui_focus_manager_fetch");
4096
4097         private static System.IntPtr fetch(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.IObject child)
4098         {
4099             Eina.Log.Debug("function efl_ui_focus_manager_fetch was called");
4100             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4101             if (wrapper != null)
4102             {
4103                                     Efl.Ui.Focus.Relations _ret_var = default(Efl.Ui.Focus.Relations);
4104                 try
4105                 {
4106                     _ret_var = ((Scroller)wrapper).Fetch(child);
4107                 }
4108                 catch (Exception e)
4109                 {
4110                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4111                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4112                 }
4113
4114                         return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);
4115
4116             }
4117             else
4118             {
4119                 return efl_ui_focus_manager_fetch_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), child);
4120             }
4121         }
4122
4123         private static efl_ui_focus_manager_fetch_delegate efl_ui_focus_manager_fetch_static_delegate;
4124
4125
4126         private delegate Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct efl_ui_focus_manager_logical_end_delegate(System.IntPtr obj, System.IntPtr pd);
4127
4128
4129         public delegate Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct efl_ui_focus_manager_logical_end_api_delegate(System.IntPtr obj);
4130
4131         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_logical_end_api_delegate> efl_ui_focus_manager_logical_end_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_logical_end_api_delegate>(Module, "efl_ui_focus_manager_logical_end");
4132
4133         private static Efl.Ui.Focus.ManagerLogicalEndDetail.NativeStruct logical_end(System.IntPtr obj, System.IntPtr pd)
4134         {
4135             Eina.Log.Debug("function efl_ui_focus_manager_logical_end was called");
4136             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4137             if (wrapper != null)
4138             {
4139             Efl.Ui.Focus.ManagerLogicalEndDetail _ret_var = default(Efl.Ui.Focus.ManagerLogicalEndDetail);
4140                 try
4141                 {
4142                     _ret_var = ((Scroller)wrapper).LogicalEnd();
4143                 }
4144                 catch (Exception e)
4145                 {
4146                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4147                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4148                 }
4149
4150         return _ret_var;
4151
4152             }
4153             else
4154             {
4155                 return efl_ui_focus_manager_logical_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4156             }
4157         }
4158
4159         private static efl_ui_focus_manager_logical_end_delegate efl_ui_focus_manager_logical_end_static_delegate;
4160
4161
4162         private delegate void efl_ui_focus_manager_reset_history_delegate(System.IntPtr obj, System.IntPtr pd);
4163
4164
4165         public delegate void efl_ui_focus_manager_reset_history_api_delegate(System.IntPtr obj);
4166
4167         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_reset_history_api_delegate> efl_ui_focus_manager_reset_history_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_reset_history_api_delegate>(Module, "efl_ui_focus_manager_reset_history");
4168
4169         private static void reset_history(System.IntPtr obj, System.IntPtr pd)
4170         {
4171             Eina.Log.Debug("function efl_ui_focus_manager_reset_history was called");
4172             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4173             if (wrapper != null)
4174             {
4175
4176                 try
4177                 {
4178                     ((Scroller)wrapper).ResetHistory();
4179                 }
4180                 catch (Exception e)
4181                 {
4182                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4183                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4184                 }
4185
4186
4187             }
4188             else
4189             {
4190                 efl_ui_focus_manager_reset_history_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4191             }
4192         }
4193
4194         private static efl_ui_focus_manager_reset_history_delegate efl_ui_focus_manager_reset_history_static_delegate;
4195
4196
4197         private delegate void efl_ui_focus_manager_pop_history_stack_delegate(System.IntPtr obj, System.IntPtr pd);
4198
4199
4200         public delegate void efl_ui_focus_manager_pop_history_stack_api_delegate(System.IntPtr obj);
4201
4202         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_pop_history_stack_api_delegate> efl_ui_focus_manager_pop_history_stack_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_pop_history_stack_api_delegate>(Module, "efl_ui_focus_manager_pop_history_stack");
4203
4204         private static void pop_history_stack(System.IntPtr obj, System.IntPtr pd)
4205         {
4206             Eina.Log.Debug("function efl_ui_focus_manager_pop_history_stack was called");
4207             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4208             if (wrapper != null)
4209             {
4210
4211                 try
4212                 {
4213                     ((Scroller)wrapper).PopHistoryStack();
4214                 }
4215                 catch (Exception e)
4216                 {
4217                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4218                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4219                 }
4220
4221
4222             }
4223             else
4224             {
4225                 efl_ui_focus_manager_pop_history_stack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4226             }
4227         }
4228
4229         private static efl_ui_focus_manager_pop_history_stack_delegate efl_ui_focus_manager_pop_history_stack_static_delegate;
4230
4231
4232         private delegate void efl_ui_focus_manager_setup_on_first_touch_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject entry);
4233
4234
4235         public delegate void efl_ui_focus_manager_setup_on_first_touch_api_delegate(System.IntPtr obj,  Efl.Ui.Focus.Direction direction, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Ui.Focus.IObject entry);
4236
4237         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_setup_on_first_touch_api_delegate> efl_ui_focus_manager_setup_on_first_touch_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_setup_on_first_touch_api_delegate>(Module, "efl_ui_focus_manager_setup_on_first_touch");
4238
4239         private static void setup_on_first_touch(System.IntPtr obj, System.IntPtr pd, Efl.Ui.Focus.Direction direction, Efl.Ui.Focus.IObject entry)
4240         {
4241             Eina.Log.Debug("function efl_ui_focus_manager_setup_on_first_touch was called");
4242             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4243             if (wrapper != null)
4244             {
4245
4246                 try
4247                 {
4248                     ((Scroller)wrapper).SetupOnFirstTouch(direction, entry);
4249                 }
4250                 catch (Exception e)
4251                 {
4252                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4253                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4254                 }
4255
4256
4257             }
4258             else
4259             {
4260                 efl_ui_focus_manager_setup_on_first_touch_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), direction, entry);
4261             }
4262         }
4263
4264         private static efl_ui_focus_manager_setup_on_first_touch_delegate efl_ui_focus_manager_setup_on_first_touch_static_delegate;
4265
4266
4267         private delegate void efl_ui_focus_manager_dirty_logic_freeze_delegate(System.IntPtr obj, System.IntPtr pd);
4268
4269
4270         public delegate void efl_ui_focus_manager_dirty_logic_freeze_api_delegate(System.IntPtr obj);
4271
4272         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_freeze_api_delegate> efl_ui_focus_manager_dirty_logic_freeze_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_freeze_api_delegate>(Module, "efl_ui_focus_manager_dirty_logic_freeze");
4273
4274         private static void dirty_logic_freeze(System.IntPtr obj, System.IntPtr pd)
4275         {
4276             Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_freeze was called");
4277             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4278             if (wrapper != null)
4279             {
4280
4281                 try
4282                 {
4283                     ((Scroller)wrapper).FreezeDirtyLogic();
4284                 }
4285                 catch (Exception e)
4286                 {
4287                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4288                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4289                 }
4290
4291
4292             }
4293             else
4294             {
4295                 efl_ui_focus_manager_dirty_logic_freeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4296             }
4297         }
4298
4299         private static efl_ui_focus_manager_dirty_logic_freeze_delegate efl_ui_focus_manager_dirty_logic_freeze_static_delegate;
4300
4301
4302         private delegate void efl_ui_focus_manager_dirty_logic_unfreeze_delegate(System.IntPtr obj, System.IntPtr pd);
4303
4304
4305         public delegate void efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate(System.IntPtr obj);
4306
4307         public static Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate> efl_ui_focus_manager_dirty_logic_unfreeze_ptr = new Efl.Eo.FunctionWrapper<efl_ui_focus_manager_dirty_logic_unfreeze_api_delegate>(Module, "efl_ui_focus_manager_dirty_logic_unfreeze");
4308
4309         private static void dirty_logic_unfreeze(System.IntPtr obj, System.IntPtr pd)
4310         {
4311             Eina.Log.Debug("function efl_ui_focus_manager_dirty_logic_unfreeze was called");
4312             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
4313             if (wrapper != null)
4314             {
4315
4316                 try
4317                 {
4318                     ((Scroller)wrapper).DirtyLogicUnfreeze();
4319                 }
4320                 catch (Exception e)
4321                 {
4322                     Eina.Log.Warning($"Callback error: {e.ToString()}");
4323                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
4324                 }
4325
4326
4327             }
4328             else
4329             {
4330                 efl_ui_focus_manager_dirty_logic_unfreeze_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
4331             }
4332         }
4333
4334         private static efl_ui_focus_manager_dirty_logic_unfreeze_delegate efl_ui_focus_manager_dirty_logic_unfreeze_static_delegate;
4335
4336         #pragma warning restore CA1707, SA1300, SA1600
4337
4338 }
4339 }
4340 }
4341
4342 }
4343