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

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