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