internals/src/EflSharp/EflSharp/efl_ui_grid.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>Simple grid widget with Pack interface.</summary>
   9 [GridNativeInherit]
  10 public class Grid : Efl.Ui.LayoutBase, Efl.Eo.IWrapper,Efl.Pack,Efl.PackLayout,Efl.PackLinear,Efl.Ui.Clickable,Efl.Ui.Direction,Efl.Ui.MultiSelectable,Efl.Ui.Scrollable,Efl.Ui.ScrollableInteractive,Efl.Ui.Scrollbar,Efl.Ui.Selectable
  11 {
  12    public new static System.IntPtr klass = System.IntPtr.Zero;
  13    public new static Efl.Ui.GridNativeInherit nativeInherit = new Efl.Ui.GridNativeInherit();
  14    ///<summary>Pointer to the native class description.</summary>
  15    public override System.IntPtr NativeClass {
  16       get {
  17          if (((object)this).GetType() == typeof (Grid))
  18             return Efl.Ui.GridNativeInherit.GetEflClassStatic();
  19          else
  20             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  21       }
  22    }
  23    [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  24       efl_ui_grid_class_get();
  25    ///<summary>Creates a new instance.</summary>
  26    ///<param name="parent">Parent instance.</param>
  27    ///<param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  28    public Grid(Efl.Object parent
  29          ,  System.String style = null) :
  30       base(efl_ui_grid_class_get(), typeof(Grid), parent)
  31    {
  32       if (Efl.Eo.Globals.ParamHelperCheck(style))
  33          SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  34       FinishInstantiation();
  35    }
  36    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  37    public Grid(System.IntPtr raw) : base(raw)
  38    {
  39             register_event_proxies();
  40    }
  41    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  42    protected Grid(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  43    ///<summary>Casts obj into an instance of this type.</summary>
  44    public new static Grid static_cast(Efl.Object obj)
  45    {
  46       if (obj == null)
  47          throw new System.ArgumentNullException("obj");
  48       return new Grid(obj.NativeHandle);
  49    }
  50    ///<summary>Verifies if the given object is equal to this one.</summary>
  51    public override bool Equals(object obj)
  52    {
  53       var other = obj as Efl.Object;
  54       if (other == null)
  55          return false;
  56       return this.NativeHandle == other.NativeHandle;
  57    }
  58    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  59    public override int GetHashCode()
  60    {
  61       return this.NativeHandle.ToInt32();
  62    }
  63    ///<summary>Turns the native pointer into a string representation.</summary>
  64    public override String ToString()
  65    {
  66       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  67    }
  68 private static object LayoutUpdatedEvtKey = new object();
  69    /// <summary>Sent after the layout was updated.</summary>
  70    public event EventHandler LayoutUpdatedEvt
  71    {
  72       add {
  73          lock (eventLock) {
  74             string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
  75             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_LayoutUpdatedEvt_delegate)) {
  76                eventHandlers.AddHandler(LayoutUpdatedEvtKey , value);
  77             } else
  78                Eina.Log.Error($"Error adding proxy for event {key}");
  79          }
  80       }
  81       remove {
  82          lock (eventLock) {
  83             string key = "_EFL_PACK_EVENT_LAYOUT_UPDATED";
  84             if (remove_cpp_event_handler(key, this.evt_LayoutUpdatedEvt_delegate)) {
  85                eventHandlers.RemoveHandler(LayoutUpdatedEvtKey , value);
  86             } else
  87                Eina.Log.Error($"Error removing proxy for event {key}");
  88          }
  89       }
  90    }
  91    ///<summary>Method to raise event LayoutUpdatedEvt.</summary>
  92    public void On_LayoutUpdatedEvt(EventArgs e)
  93    {
  94       EventHandler evt;
  95       lock (eventLock) {
  96       evt = (EventHandler)eventHandlers[LayoutUpdatedEvtKey];
  97       }
  98       evt?.Invoke(this, e);
  99    }
 100    Efl.EventCb evt_LayoutUpdatedEvt_delegate;
 101    private void on_LayoutUpdatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 102    {
 103       EventArgs args = EventArgs.Empty;
 104       try {
 105          On_LayoutUpdatedEvt(args);
 106       } catch (Exception e) {
 107          Eina.Log.Error(e.ToString());
 108          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 109       }
 110    }
 111
 112 private static object ClickedEvtKey = new object();
 113    /// <summary>Called when object is clicked</summary>
 114    public event EventHandler ClickedEvt
 115    {
 116       add {
 117          lock (eventLock) {
 118             string key = "_EFL_UI_EVENT_CLICKED";
 119             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedEvt_delegate)) {
 120                eventHandlers.AddHandler(ClickedEvtKey , value);
 121             } else
 122                Eina.Log.Error($"Error adding proxy for event {key}");
 123          }
 124       }
 125       remove {
 126          lock (eventLock) {
 127             string key = "_EFL_UI_EVENT_CLICKED";
 128             if (remove_cpp_event_handler(key, this.evt_ClickedEvt_delegate)) {
 129                eventHandlers.RemoveHandler(ClickedEvtKey , value);
 130             } else
 131                Eina.Log.Error($"Error removing proxy for event {key}");
 132          }
 133       }
 134    }
 135    ///<summary>Method to raise event ClickedEvt.</summary>
 136    public void On_ClickedEvt(EventArgs e)
 137    {
 138       EventHandler evt;
 139       lock (eventLock) {
 140       evt = (EventHandler)eventHandlers[ClickedEvtKey];
 141       }
 142       evt?.Invoke(this, e);
 143    }
 144    Efl.EventCb evt_ClickedEvt_delegate;
 145    private void on_ClickedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 146    {
 147       EventArgs args = EventArgs.Empty;
 148       try {
 149          On_ClickedEvt(args);
 150       } catch (Exception e) {
 151          Eina.Log.Error(e.ToString());
 152          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 153       }
 154    }
 155
 156 private static object ClickedDoubleEvtKey = new object();
 157    /// <summary>Called when object receives a double click</summary>
 158    public event EventHandler ClickedDoubleEvt
 159    {
 160       add {
 161          lock (eventLock) {
 162             string key = "_EFL_UI_EVENT_CLICKED_DOUBLE";
 163             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedDoubleEvt_delegate)) {
 164                eventHandlers.AddHandler(ClickedDoubleEvtKey , value);
 165             } else
 166                Eina.Log.Error($"Error adding proxy for event {key}");
 167          }
 168       }
 169       remove {
 170          lock (eventLock) {
 171             string key = "_EFL_UI_EVENT_CLICKED_DOUBLE";
 172             if (remove_cpp_event_handler(key, this.evt_ClickedDoubleEvt_delegate)) {
 173                eventHandlers.RemoveHandler(ClickedDoubleEvtKey , value);
 174             } else
 175                Eina.Log.Error($"Error removing proxy for event {key}");
 176          }
 177       }
 178    }
 179    ///<summary>Method to raise event ClickedDoubleEvt.</summary>
 180    public void On_ClickedDoubleEvt(EventArgs e)
 181    {
 182       EventHandler evt;
 183       lock (eventLock) {
 184       evt = (EventHandler)eventHandlers[ClickedDoubleEvtKey];
 185       }
 186       evt?.Invoke(this, e);
 187    }
 188    Efl.EventCb evt_ClickedDoubleEvt_delegate;
 189    private void on_ClickedDoubleEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 190    {
 191       EventArgs args = EventArgs.Empty;
 192       try {
 193          On_ClickedDoubleEvt(args);
 194       } catch (Exception e) {
 195          Eina.Log.Error(e.ToString());
 196          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 197       }
 198    }
 199
 200 private static object ClickedTripleEvtKey = new object();
 201    /// <summary>Called when object receives a triple click</summary>
 202    public event EventHandler ClickedTripleEvt
 203    {
 204       add {
 205          lock (eventLock) {
 206             string key = "_EFL_UI_EVENT_CLICKED_TRIPLE";
 207             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedTripleEvt_delegate)) {
 208                eventHandlers.AddHandler(ClickedTripleEvtKey , value);
 209             } else
 210                Eina.Log.Error($"Error adding proxy for event {key}");
 211          }
 212       }
 213       remove {
 214          lock (eventLock) {
 215             string key = "_EFL_UI_EVENT_CLICKED_TRIPLE";
 216             if (remove_cpp_event_handler(key, this.evt_ClickedTripleEvt_delegate)) {
 217                eventHandlers.RemoveHandler(ClickedTripleEvtKey , value);
 218             } else
 219                Eina.Log.Error($"Error removing proxy for event {key}");
 220          }
 221       }
 222    }
 223    ///<summary>Method to raise event ClickedTripleEvt.</summary>
 224    public void On_ClickedTripleEvt(EventArgs e)
 225    {
 226       EventHandler evt;
 227       lock (eventLock) {
 228       evt = (EventHandler)eventHandlers[ClickedTripleEvtKey];
 229       }
 230       evt?.Invoke(this, e);
 231    }
 232    Efl.EventCb evt_ClickedTripleEvt_delegate;
 233    private void on_ClickedTripleEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 234    {
 235       EventArgs args = EventArgs.Empty;
 236       try {
 237          On_ClickedTripleEvt(args);
 238       } catch (Exception e) {
 239          Eina.Log.Error(e.ToString());
 240          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 241       }
 242    }
 243
 244 private static object ClickedRightEvtKey = new object();
 245    /// <summary>Called when object receives a right click</summary>
 246    public event EventHandler<Efl.Ui.ClickableClickedRightEvt_Args> ClickedRightEvt
 247    {
 248       add {
 249          lock (eventLock) {
 250             string key = "_EFL_UI_EVENT_CLICKED_RIGHT";
 251             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClickedRightEvt_delegate)) {
 252                eventHandlers.AddHandler(ClickedRightEvtKey , value);
 253             } else
 254                Eina.Log.Error($"Error adding proxy for event {key}");
 255          }
 256       }
 257       remove {
 258          lock (eventLock) {
 259             string key = "_EFL_UI_EVENT_CLICKED_RIGHT";
 260             if (remove_cpp_event_handler(key, this.evt_ClickedRightEvt_delegate)) {
 261                eventHandlers.RemoveHandler(ClickedRightEvtKey , value);
 262             } else
 263                Eina.Log.Error($"Error removing proxy for event {key}");
 264          }
 265       }
 266    }
 267    ///<summary>Method to raise event ClickedRightEvt.</summary>
 268    public void On_ClickedRightEvt(Efl.Ui.ClickableClickedRightEvt_Args e)
 269    {
 270       EventHandler<Efl.Ui.ClickableClickedRightEvt_Args> evt;
 271       lock (eventLock) {
 272       evt = (EventHandler<Efl.Ui.ClickableClickedRightEvt_Args>)eventHandlers[ClickedRightEvtKey];
 273       }
 274       evt?.Invoke(this, e);
 275    }
 276    Efl.EventCb evt_ClickedRightEvt_delegate;
 277    private void on_ClickedRightEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 278    {
 279       Efl.Ui.ClickableClickedRightEvt_Args args = new Efl.Ui.ClickableClickedRightEvt_Args();
 280       args.arg = new Efl.Object(evt.Info);
 281       try {
 282          On_ClickedRightEvt(args);
 283       } catch (Exception e) {
 284          Eina.Log.Error(e.ToString());
 285          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 286       }
 287    }
 288
 289 private static object PressedEvtKey = new object();
 290    /// <summary>Called when the object is pressed</summary>
 291    public event EventHandler<Efl.Ui.ClickablePressedEvt_Args> PressedEvt
 292    {
 293       add {
 294          lock (eventLock) {
 295             string key = "_EFL_UI_EVENT_PRESSED";
 296             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_PressedEvt_delegate)) {
 297                eventHandlers.AddHandler(PressedEvtKey , value);
 298             } else
 299                Eina.Log.Error($"Error adding proxy for event {key}");
 300          }
 301       }
 302       remove {
 303          lock (eventLock) {
 304             string key = "_EFL_UI_EVENT_PRESSED";
 305             if (remove_cpp_event_handler(key, this.evt_PressedEvt_delegate)) {
 306                eventHandlers.RemoveHandler(PressedEvtKey , value);
 307             } else
 308                Eina.Log.Error($"Error removing proxy for event {key}");
 309          }
 310       }
 311    }
 312    ///<summary>Method to raise event PressedEvt.</summary>
 313    public void On_PressedEvt(Efl.Ui.ClickablePressedEvt_Args e)
 314    {
 315       EventHandler<Efl.Ui.ClickablePressedEvt_Args> evt;
 316       lock (eventLock) {
 317       evt = (EventHandler<Efl.Ui.ClickablePressedEvt_Args>)eventHandlers[PressedEvtKey];
 318       }
 319       evt?.Invoke(this, e);
 320    }
 321    Efl.EventCb evt_PressedEvt_delegate;
 322    private void on_PressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 323    {
 324       Efl.Ui.ClickablePressedEvt_Args args = new Efl.Ui.ClickablePressedEvt_Args();
 325       args.arg = new Efl.Object(evt.Info);
 326       try {
 327          On_PressedEvt(args);
 328       } catch (Exception e) {
 329          Eina.Log.Error(e.ToString());
 330          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 331       }
 332    }
 333
 334 private static object UnpressedEvtKey = new object();
 335    /// <summary>Called when the object is no longer pressed</summary>
 336    public event EventHandler<Efl.Ui.ClickableUnpressedEvt_Args> UnpressedEvt
 337    {
 338       add {
 339          lock (eventLock) {
 340             string key = "_EFL_UI_EVENT_UNPRESSED";
 341             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_UnpressedEvt_delegate)) {
 342                eventHandlers.AddHandler(UnpressedEvtKey , value);
 343             } else
 344                Eina.Log.Error($"Error adding proxy for event {key}");
 345          }
 346       }
 347       remove {
 348          lock (eventLock) {
 349             string key = "_EFL_UI_EVENT_UNPRESSED";
 350             if (remove_cpp_event_handler(key, this.evt_UnpressedEvt_delegate)) {
 351                eventHandlers.RemoveHandler(UnpressedEvtKey , value);
 352             } else
 353                Eina.Log.Error($"Error removing proxy for event {key}");
 354          }
 355       }
 356    }
 357    ///<summary>Method to raise event UnpressedEvt.</summary>
 358    public void On_UnpressedEvt(Efl.Ui.ClickableUnpressedEvt_Args e)
 359    {
 360       EventHandler<Efl.Ui.ClickableUnpressedEvt_Args> evt;
 361       lock (eventLock) {
 362       evt = (EventHandler<Efl.Ui.ClickableUnpressedEvt_Args>)eventHandlers[UnpressedEvtKey];
 363       }
 364       evt?.Invoke(this, e);
 365    }
 366    Efl.EventCb evt_UnpressedEvt_delegate;
 367    private void on_UnpressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 368    {
 369       Efl.Ui.ClickableUnpressedEvt_Args args = new Efl.Ui.ClickableUnpressedEvt_Args();
 370       args.arg = new Efl.Object(evt.Info);
 371       try {
 372          On_UnpressedEvt(args);
 373       } catch (Exception e) {
 374          Eina.Log.Error(e.ToString());
 375          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 376       }
 377    }
 378
 379 private static object LongpressedEvtKey = new object();
 380    /// <summary>Called when the object receives a long press</summary>
 381    public event EventHandler<Efl.Ui.ClickableLongpressedEvt_Args> LongpressedEvt
 382    {
 383       add {
 384          lock (eventLock) {
 385             string key = "_EFL_UI_EVENT_LONGPRESSED";
 386             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_LongpressedEvt_delegate)) {
 387                eventHandlers.AddHandler(LongpressedEvtKey , value);
 388             } else
 389                Eina.Log.Error($"Error adding proxy for event {key}");
 390          }
 391       }
 392       remove {
 393          lock (eventLock) {
 394             string key = "_EFL_UI_EVENT_LONGPRESSED";
 395             if (remove_cpp_event_handler(key, this.evt_LongpressedEvt_delegate)) {
 396                eventHandlers.RemoveHandler(LongpressedEvtKey , value);
 397             } else
 398                Eina.Log.Error($"Error removing proxy for event {key}");
 399          }
 400       }
 401    }
 402    ///<summary>Method to raise event LongpressedEvt.</summary>
 403    public void On_LongpressedEvt(Efl.Ui.ClickableLongpressedEvt_Args e)
 404    {
 405       EventHandler<Efl.Ui.ClickableLongpressedEvt_Args> evt;
 406       lock (eventLock) {
 407       evt = (EventHandler<Efl.Ui.ClickableLongpressedEvt_Args>)eventHandlers[LongpressedEvtKey];
 408       }
 409       evt?.Invoke(this, e);
 410    }
 411    Efl.EventCb evt_LongpressedEvt_delegate;
 412    private void on_LongpressedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 413    {
 414       Efl.Ui.ClickableLongpressedEvt_Args args = new Efl.Ui.ClickableLongpressedEvt_Args();
 415       args.arg = new Efl.Object(evt.Info);
 416       try {
 417          On_LongpressedEvt(args);
 418       } catch (Exception e) {
 419          Eina.Log.Error(e.ToString());
 420          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 421       }
 422    }
 423
 424 private static object RepeatedEvtKey = new object();
 425    /// <summary>Called when the object receives repeated presses/clicks</summary>
 426    public event EventHandler RepeatedEvt
 427    {
 428       add {
 429          lock (eventLock) {
 430             string key = "_EFL_UI_EVENT_REPEATED";
 431             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_RepeatedEvt_delegate)) {
 432                eventHandlers.AddHandler(RepeatedEvtKey , value);
 433             } else
 434                Eina.Log.Error($"Error adding proxy for event {key}");
 435          }
 436       }
 437       remove {
 438          lock (eventLock) {
 439             string key = "_EFL_UI_EVENT_REPEATED";
 440             if (remove_cpp_event_handler(key, this.evt_RepeatedEvt_delegate)) {
 441                eventHandlers.RemoveHandler(RepeatedEvtKey , value);
 442             } else
 443                Eina.Log.Error($"Error removing proxy for event {key}");
 444          }
 445       }
 446    }
 447    ///<summary>Method to raise event RepeatedEvt.</summary>
 448    public void On_RepeatedEvt(EventArgs e)
 449    {
 450       EventHandler evt;
 451       lock (eventLock) {
 452       evt = (EventHandler)eventHandlers[RepeatedEvtKey];
 453       }
 454       evt?.Invoke(this, e);
 455    }
 456    Efl.EventCb evt_RepeatedEvt_delegate;
 457    private void on_RepeatedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 458    {
 459       EventArgs args = EventArgs.Empty;
 460       try {
 461          On_RepeatedEvt(args);
 462       } catch (Exception e) {
 463          Eina.Log.Error(e.ToString());
 464          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 465       }
 466    }
 467
 468 private static object ScrollStartEvtKey = new object();
 469    /// <summary>Called when scroll operation starts</summary>
 470    public event EventHandler ScrollStartEvt
 471    {
 472       add {
 473          lock (eventLock) {
 474             string key = "_EFL_UI_EVENT_SCROLL_START";
 475             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollStartEvt_delegate)) {
 476                eventHandlers.AddHandler(ScrollStartEvtKey , value);
 477             } else
 478                Eina.Log.Error($"Error adding proxy for event {key}");
 479          }
 480       }
 481       remove {
 482          lock (eventLock) {
 483             string key = "_EFL_UI_EVENT_SCROLL_START";
 484             if (remove_cpp_event_handler(key, this.evt_ScrollStartEvt_delegate)) {
 485                eventHandlers.RemoveHandler(ScrollStartEvtKey , value);
 486             } else
 487                Eina.Log.Error($"Error removing proxy for event {key}");
 488          }
 489       }
 490    }
 491    ///<summary>Method to raise event ScrollStartEvt.</summary>
 492    public void On_ScrollStartEvt(EventArgs e)
 493    {
 494       EventHandler evt;
 495       lock (eventLock) {
 496       evt = (EventHandler)eventHandlers[ScrollStartEvtKey];
 497       }
 498       evt?.Invoke(this, e);
 499    }
 500    Efl.EventCb evt_ScrollStartEvt_delegate;
 501    private void on_ScrollStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 502    {
 503       EventArgs args = EventArgs.Empty;
 504       try {
 505          On_ScrollStartEvt(args);
 506       } catch (Exception e) {
 507          Eina.Log.Error(e.ToString());
 508          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 509       }
 510    }
 511
 512 private static object ScrollEvtKey = new object();
 513    /// <summary>Called when scrolling</summary>
 514    public event EventHandler ScrollEvt
 515    {
 516       add {
 517          lock (eventLock) {
 518             string key = "_EFL_UI_EVENT_SCROLL";
 519             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollEvt_delegate)) {
 520                eventHandlers.AddHandler(ScrollEvtKey , value);
 521             } else
 522                Eina.Log.Error($"Error adding proxy for event {key}");
 523          }
 524       }
 525       remove {
 526          lock (eventLock) {
 527             string key = "_EFL_UI_EVENT_SCROLL";
 528             if (remove_cpp_event_handler(key, this.evt_ScrollEvt_delegate)) {
 529                eventHandlers.RemoveHandler(ScrollEvtKey , value);
 530             } else
 531                Eina.Log.Error($"Error removing proxy for event {key}");
 532          }
 533       }
 534    }
 535    ///<summary>Method to raise event ScrollEvt.</summary>
 536    public void On_ScrollEvt(EventArgs e)
 537    {
 538       EventHandler evt;
 539       lock (eventLock) {
 540       evt = (EventHandler)eventHandlers[ScrollEvtKey];
 541       }
 542       evt?.Invoke(this, e);
 543    }
 544    Efl.EventCb evt_ScrollEvt_delegate;
 545    private void on_ScrollEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 546    {
 547       EventArgs args = EventArgs.Empty;
 548       try {
 549          On_ScrollEvt(args);
 550       } catch (Exception e) {
 551          Eina.Log.Error(e.ToString());
 552          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 553       }
 554    }
 555
 556 private static object ScrollStopEvtKey = new object();
 557    /// <summary>Called when scroll operation stops</summary>
 558    public event EventHandler ScrollStopEvt
 559    {
 560       add {
 561          lock (eventLock) {
 562             string key = "_EFL_UI_EVENT_SCROLL_STOP";
 563             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollStopEvt_delegate)) {
 564                eventHandlers.AddHandler(ScrollStopEvtKey , value);
 565             } else
 566                Eina.Log.Error($"Error adding proxy for event {key}");
 567          }
 568       }
 569       remove {
 570          lock (eventLock) {
 571             string key = "_EFL_UI_EVENT_SCROLL_STOP";
 572             if (remove_cpp_event_handler(key, this.evt_ScrollStopEvt_delegate)) {
 573                eventHandlers.RemoveHandler(ScrollStopEvtKey , value);
 574             } else
 575                Eina.Log.Error($"Error removing proxy for event {key}");
 576          }
 577       }
 578    }
 579    ///<summary>Method to raise event ScrollStopEvt.</summary>
 580    public void On_ScrollStopEvt(EventArgs e)
 581    {
 582       EventHandler evt;
 583       lock (eventLock) {
 584       evt = (EventHandler)eventHandlers[ScrollStopEvtKey];
 585       }
 586       evt?.Invoke(this, e);
 587    }
 588    Efl.EventCb evt_ScrollStopEvt_delegate;
 589    private void on_ScrollStopEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 590    {
 591       EventArgs args = EventArgs.Empty;
 592       try {
 593          On_ScrollStopEvt(args);
 594       } catch (Exception e) {
 595          Eina.Log.Error(e.ToString());
 596          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 597       }
 598    }
 599
 600 private static object ScrollUpEvtKey = new object();
 601    /// <summary>Called when scrolling upwards</summary>
 602    public event EventHandler ScrollUpEvt
 603    {
 604       add {
 605          lock (eventLock) {
 606             string key = "_EFL_UI_EVENT_SCROLL_UP";
 607             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollUpEvt_delegate)) {
 608                eventHandlers.AddHandler(ScrollUpEvtKey , value);
 609             } else
 610                Eina.Log.Error($"Error adding proxy for event {key}");
 611          }
 612       }
 613       remove {
 614          lock (eventLock) {
 615             string key = "_EFL_UI_EVENT_SCROLL_UP";
 616             if (remove_cpp_event_handler(key, this.evt_ScrollUpEvt_delegate)) {
 617                eventHandlers.RemoveHandler(ScrollUpEvtKey , value);
 618             } else
 619                Eina.Log.Error($"Error removing proxy for event {key}");
 620          }
 621       }
 622    }
 623    ///<summary>Method to raise event ScrollUpEvt.</summary>
 624    public void On_ScrollUpEvt(EventArgs e)
 625    {
 626       EventHandler evt;
 627       lock (eventLock) {
 628       evt = (EventHandler)eventHandlers[ScrollUpEvtKey];
 629       }
 630       evt?.Invoke(this, e);
 631    }
 632    Efl.EventCb evt_ScrollUpEvt_delegate;
 633    private void on_ScrollUpEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 634    {
 635       EventArgs args = EventArgs.Empty;
 636       try {
 637          On_ScrollUpEvt(args);
 638       } catch (Exception e) {
 639          Eina.Log.Error(e.ToString());
 640          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 641       }
 642    }
 643
 644 private static object ScrollDownEvtKey = new object();
 645    /// <summary>Called when scrolling downwards</summary>
 646    public event EventHandler ScrollDownEvt
 647    {
 648       add {
 649          lock (eventLock) {
 650             string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 651             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollDownEvt_delegate)) {
 652                eventHandlers.AddHandler(ScrollDownEvtKey , value);
 653             } else
 654                Eina.Log.Error($"Error adding proxy for event {key}");
 655          }
 656       }
 657       remove {
 658          lock (eventLock) {
 659             string key = "_EFL_UI_EVENT_SCROLL_DOWN";
 660             if (remove_cpp_event_handler(key, this.evt_ScrollDownEvt_delegate)) {
 661                eventHandlers.RemoveHandler(ScrollDownEvtKey , value);
 662             } else
 663                Eina.Log.Error($"Error removing proxy for event {key}");
 664          }
 665       }
 666    }
 667    ///<summary>Method to raise event ScrollDownEvt.</summary>
 668    public void On_ScrollDownEvt(EventArgs e)
 669    {
 670       EventHandler evt;
 671       lock (eventLock) {
 672       evt = (EventHandler)eventHandlers[ScrollDownEvtKey];
 673       }
 674       evt?.Invoke(this, e);
 675    }
 676    Efl.EventCb evt_ScrollDownEvt_delegate;
 677    private void on_ScrollDownEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 678    {
 679       EventArgs args = EventArgs.Empty;
 680       try {
 681          On_ScrollDownEvt(args);
 682       } catch (Exception e) {
 683          Eina.Log.Error(e.ToString());
 684          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 685       }
 686    }
 687
 688 private static object ScrollLeftEvtKey = new object();
 689    /// <summary>Called when scrolling left</summary>
 690    public event EventHandler ScrollLeftEvt
 691    {
 692       add {
 693          lock (eventLock) {
 694             string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 695             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollLeftEvt_delegate)) {
 696                eventHandlers.AddHandler(ScrollLeftEvtKey , value);
 697             } else
 698                Eina.Log.Error($"Error adding proxy for event {key}");
 699          }
 700       }
 701       remove {
 702          lock (eventLock) {
 703             string key = "_EFL_UI_EVENT_SCROLL_LEFT";
 704             if (remove_cpp_event_handler(key, this.evt_ScrollLeftEvt_delegate)) {
 705                eventHandlers.RemoveHandler(ScrollLeftEvtKey , value);
 706             } else
 707                Eina.Log.Error($"Error removing proxy for event {key}");
 708          }
 709       }
 710    }
 711    ///<summary>Method to raise event ScrollLeftEvt.</summary>
 712    public void On_ScrollLeftEvt(EventArgs e)
 713    {
 714       EventHandler evt;
 715       lock (eventLock) {
 716       evt = (EventHandler)eventHandlers[ScrollLeftEvtKey];
 717       }
 718       evt?.Invoke(this, e);
 719    }
 720    Efl.EventCb evt_ScrollLeftEvt_delegate;
 721    private void on_ScrollLeftEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 722    {
 723       EventArgs args = EventArgs.Empty;
 724       try {
 725          On_ScrollLeftEvt(args);
 726       } catch (Exception e) {
 727          Eina.Log.Error(e.ToString());
 728          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 729       }
 730    }
 731
 732 private static object ScrollRightEvtKey = new object();
 733    /// <summary>Called when scrolling right</summary>
 734    public event EventHandler ScrollRightEvt
 735    {
 736       add {
 737          lock (eventLock) {
 738             string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 739             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollRightEvt_delegate)) {
 740                eventHandlers.AddHandler(ScrollRightEvtKey , value);
 741             } else
 742                Eina.Log.Error($"Error adding proxy for event {key}");
 743          }
 744       }
 745       remove {
 746          lock (eventLock) {
 747             string key = "_EFL_UI_EVENT_SCROLL_RIGHT";
 748             if (remove_cpp_event_handler(key, this.evt_ScrollRightEvt_delegate)) {
 749                eventHandlers.RemoveHandler(ScrollRightEvtKey , value);
 750             } else
 751                Eina.Log.Error($"Error removing proxy for event {key}");
 752          }
 753       }
 754    }
 755    ///<summary>Method to raise event ScrollRightEvt.</summary>
 756    public void On_ScrollRightEvt(EventArgs e)
 757    {
 758       EventHandler evt;
 759       lock (eventLock) {
 760       evt = (EventHandler)eventHandlers[ScrollRightEvtKey];
 761       }
 762       evt?.Invoke(this, e);
 763    }
 764    Efl.EventCb evt_ScrollRightEvt_delegate;
 765    private void on_ScrollRightEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 766    {
 767       EventArgs args = EventArgs.Empty;
 768       try {
 769          On_ScrollRightEvt(args);
 770       } catch (Exception e) {
 771          Eina.Log.Error(e.ToString());
 772          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 773       }
 774    }
 775
 776 private static object EdgeUpEvtKey = new object();
 777    /// <summary>Called when hitting the top edge</summary>
 778    public event EventHandler EdgeUpEvt
 779    {
 780       add {
 781          lock (eventLock) {
 782             string key = "_EFL_UI_EVENT_EDGE_UP";
 783             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeUpEvt_delegate)) {
 784                eventHandlers.AddHandler(EdgeUpEvtKey , value);
 785             } else
 786                Eina.Log.Error($"Error adding proxy for event {key}");
 787          }
 788       }
 789       remove {
 790          lock (eventLock) {
 791             string key = "_EFL_UI_EVENT_EDGE_UP";
 792             if (remove_cpp_event_handler(key, this.evt_EdgeUpEvt_delegate)) {
 793                eventHandlers.RemoveHandler(EdgeUpEvtKey , value);
 794             } else
 795                Eina.Log.Error($"Error removing proxy for event {key}");
 796          }
 797       }
 798    }
 799    ///<summary>Method to raise event EdgeUpEvt.</summary>
 800    public void On_EdgeUpEvt(EventArgs e)
 801    {
 802       EventHandler evt;
 803       lock (eventLock) {
 804       evt = (EventHandler)eventHandlers[EdgeUpEvtKey];
 805       }
 806       evt?.Invoke(this, e);
 807    }
 808    Efl.EventCb evt_EdgeUpEvt_delegate;
 809    private void on_EdgeUpEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 810    {
 811       EventArgs args = EventArgs.Empty;
 812       try {
 813          On_EdgeUpEvt(args);
 814       } catch (Exception e) {
 815          Eina.Log.Error(e.ToString());
 816          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 817       }
 818    }
 819
 820 private static object EdgeDownEvtKey = new object();
 821    /// <summary>Called when hitting the bottom edge</summary>
 822    public event EventHandler EdgeDownEvt
 823    {
 824       add {
 825          lock (eventLock) {
 826             string key = "_EFL_UI_EVENT_EDGE_DOWN";
 827             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeDownEvt_delegate)) {
 828                eventHandlers.AddHandler(EdgeDownEvtKey , value);
 829             } else
 830                Eina.Log.Error($"Error adding proxy for event {key}");
 831          }
 832       }
 833       remove {
 834          lock (eventLock) {
 835             string key = "_EFL_UI_EVENT_EDGE_DOWN";
 836             if (remove_cpp_event_handler(key, this.evt_EdgeDownEvt_delegate)) {
 837                eventHandlers.RemoveHandler(EdgeDownEvtKey , value);
 838             } else
 839                Eina.Log.Error($"Error removing proxy for event {key}");
 840          }
 841       }
 842    }
 843    ///<summary>Method to raise event EdgeDownEvt.</summary>
 844    public void On_EdgeDownEvt(EventArgs e)
 845    {
 846       EventHandler evt;
 847       lock (eventLock) {
 848       evt = (EventHandler)eventHandlers[EdgeDownEvtKey];
 849       }
 850       evt?.Invoke(this, e);
 851    }
 852    Efl.EventCb evt_EdgeDownEvt_delegate;
 853    private void on_EdgeDownEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 854    {
 855       EventArgs args = EventArgs.Empty;
 856       try {
 857          On_EdgeDownEvt(args);
 858       } catch (Exception e) {
 859          Eina.Log.Error(e.ToString());
 860          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 861       }
 862    }
 863
 864 private static object EdgeLeftEvtKey = new object();
 865    /// <summary>Called when hitting the left edge</summary>
 866    public event EventHandler EdgeLeftEvt
 867    {
 868       add {
 869          lock (eventLock) {
 870             string key = "_EFL_UI_EVENT_EDGE_LEFT";
 871             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeLeftEvt_delegate)) {
 872                eventHandlers.AddHandler(EdgeLeftEvtKey , value);
 873             } else
 874                Eina.Log.Error($"Error adding proxy for event {key}");
 875          }
 876       }
 877       remove {
 878          lock (eventLock) {
 879             string key = "_EFL_UI_EVENT_EDGE_LEFT";
 880             if (remove_cpp_event_handler(key, this.evt_EdgeLeftEvt_delegate)) {
 881                eventHandlers.RemoveHandler(EdgeLeftEvtKey , value);
 882             } else
 883                Eina.Log.Error($"Error removing proxy for event {key}");
 884          }
 885       }
 886    }
 887    ///<summary>Method to raise event EdgeLeftEvt.</summary>
 888    public void On_EdgeLeftEvt(EventArgs e)
 889    {
 890       EventHandler evt;
 891       lock (eventLock) {
 892       evt = (EventHandler)eventHandlers[EdgeLeftEvtKey];
 893       }
 894       evt?.Invoke(this, e);
 895    }
 896    Efl.EventCb evt_EdgeLeftEvt_delegate;
 897    private void on_EdgeLeftEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 898    {
 899       EventArgs args = EventArgs.Empty;
 900       try {
 901          On_EdgeLeftEvt(args);
 902       } catch (Exception e) {
 903          Eina.Log.Error(e.ToString());
 904          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 905       }
 906    }
 907
 908 private static object EdgeRightEvtKey = new object();
 909    /// <summary>Called when hitting the right edge</summary>
 910    public event EventHandler EdgeRightEvt
 911    {
 912       add {
 913          lock (eventLock) {
 914             string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 915             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EdgeRightEvt_delegate)) {
 916                eventHandlers.AddHandler(EdgeRightEvtKey , value);
 917             } else
 918                Eina.Log.Error($"Error adding proxy for event {key}");
 919          }
 920       }
 921       remove {
 922          lock (eventLock) {
 923             string key = "_EFL_UI_EVENT_EDGE_RIGHT";
 924             if (remove_cpp_event_handler(key, this.evt_EdgeRightEvt_delegate)) {
 925                eventHandlers.RemoveHandler(EdgeRightEvtKey , value);
 926             } else
 927                Eina.Log.Error($"Error removing proxy for event {key}");
 928          }
 929       }
 930    }
 931    ///<summary>Method to raise event EdgeRightEvt.</summary>
 932    public void On_EdgeRightEvt(EventArgs e)
 933    {
 934       EventHandler evt;
 935       lock (eventLock) {
 936       evt = (EventHandler)eventHandlers[EdgeRightEvtKey];
 937       }
 938       evt?.Invoke(this, e);
 939    }
 940    Efl.EventCb evt_EdgeRightEvt_delegate;
 941    private void on_EdgeRightEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 942    {
 943       EventArgs args = EventArgs.Empty;
 944       try {
 945          On_EdgeRightEvt(args);
 946       } catch (Exception e) {
 947          Eina.Log.Error(e.ToString());
 948          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 949       }
 950    }
 951
 952 private static object ScrollAnimStartEvtKey = new object();
 953    /// <summary>Called when scroll animation starts</summary>
 954    public event EventHandler ScrollAnimStartEvt
 955    {
 956       add {
 957          lock (eventLock) {
 958             string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 959             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollAnimStartEvt_delegate)) {
 960                eventHandlers.AddHandler(ScrollAnimStartEvtKey , value);
 961             } else
 962                Eina.Log.Error($"Error adding proxy for event {key}");
 963          }
 964       }
 965       remove {
 966          lock (eventLock) {
 967             string key = "_EFL_UI_EVENT_SCROLL_ANIM_START";
 968             if (remove_cpp_event_handler(key, this.evt_ScrollAnimStartEvt_delegate)) {
 969                eventHandlers.RemoveHandler(ScrollAnimStartEvtKey , value);
 970             } else
 971                Eina.Log.Error($"Error removing proxy for event {key}");
 972          }
 973       }
 974    }
 975    ///<summary>Method to raise event ScrollAnimStartEvt.</summary>
 976    public void On_ScrollAnimStartEvt(EventArgs e)
 977    {
 978       EventHandler evt;
 979       lock (eventLock) {
 980       evt = (EventHandler)eventHandlers[ScrollAnimStartEvtKey];
 981       }
 982       evt?.Invoke(this, e);
 983    }
 984    Efl.EventCb evt_ScrollAnimStartEvt_delegate;
 985    private void on_ScrollAnimStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 986    {
 987       EventArgs args = EventArgs.Empty;
 988       try {
 989          On_ScrollAnimStartEvt(args);
 990       } catch (Exception e) {
 991          Eina.Log.Error(e.ToString());
 992          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 993       }
 994    }
 995
 996 private static object ScrollAnimStopEvtKey = new object();
 997    /// <summary>Called when scroll animation stopps</summary>
 998    public event EventHandler ScrollAnimStopEvt
 999    {
1000       add {
1001          lock (eventLock) {
1002             string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
1003             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollAnimStopEvt_delegate)) {
1004                eventHandlers.AddHandler(ScrollAnimStopEvtKey , value);
1005             } else
1006                Eina.Log.Error($"Error adding proxy for event {key}");
1007          }
1008       }
1009       remove {
1010          lock (eventLock) {
1011             string key = "_EFL_UI_EVENT_SCROLL_ANIM_STOP";
1012             if (remove_cpp_event_handler(key, this.evt_ScrollAnimStopEvt_delegate)) {
1013                eventHandlers.RemoveHandler(ScrollAnimStopEvtKey , value);
1014             } else
1015                Eina.Log.Error($"Error removing proxy for event {key}");
1016          }
1017       }
1018    }
1019    ///<summary>Method to raise event ScrollAnimStopEvt.</summary>
1020    public void On_ScrollAnimStopEvt(EventArgs e)
1021    {
1022       EventHandler evt;
1023       lock (eventLock) {
1024       evt = (EventHandler)eventHandlers[ScrollAnimStopEvtKey];
1025       }
1026       evt?.Invoke(this, e);
1027    }
1028    Efl.EventCb evt_ScrollAnimStopEvt_delegate;
1029    private void on_ScrollAnimStopEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1030    {
1031       EventArgs args = EventArgs.Empty;
1032       try {
1033          On_ScrollAnimStopEvt(args);
1034       } catch (Exception e) {
1035          Eina.Log.Error(e.ToString());
1036          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1037       }
1038    }
1039
1040 private static object ScrollDragStartEvtKey = new object();
1041    /// <summary>Called when scroll drag starts</summary>
1042    public event EventHandler ScrollDragStartEvt
1043    {
1044       add {
1045          lock (eventLock) {
1046             string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
1047             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollDragStartEvt_delegate)) {
1048                eventHandlers.AddHandler(ScrollDragStartEvtKey , value);
1049             } else
1050                Eina.Log.Error($"Error adding proxy for event {key}");
1051          }
1052       }
1053       remove {
1054          lock (eventLock) {
1055             string key = "_EFL_UI_EVENT_SCROLL_DRAG_START";
1056             if (remove_cpp_event_handler(key, this.evt_ScrollDragStartEvt_delegate)) {
1057                eventHandlers.RemoveHandler(ScrollDragStartEvtKey , value);
1058             } else
1059                Eina.Log.Error($"Error removing proxy for event {key}");
1060          }
1061       }
1062    }
1063    ///<summary>Method to raise event ScrollDragStartEvt.</summary>
1064    public void On_ScrollDragStartEvt(EventArgs e)
1065    {
1066       EventHandler evt;
1067       lock (eventLock) {
1068       evt = (EventHandler)eventHandlers[ScrollDragStartEvtKey];
1069       }
1070       evt?.Invoke(this, e);
1071    }
1072    Efl.EventCb evt_ScrollDragStartEvt_delegate;
1073    private void on_ScrollDragStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1074    {
1075       EventArgs args = EventArgs.Empty;
1076       try {
1077          On_ScrollDragStartEvt(args);
1078       } catch (Exception e) {
1079          Eina.Log.Error(e.ToString());
1080          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1081       }
1082    }
1083
1084 private static object ScrollDragStopEvtKey = new object();
1085    /// <summary>Called when scroll drag stops</summary>
1086    public event EventHandler ScrollDragStopEvt
1087    {
1088       add {
1089          lock (eventLock) {
1090             string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
1091             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ScrollDragStopEvt_delegate)) {
1092                eventHandlers.AddHandler(ScrollDragStopEvtKey , value);
1093             } else
1094                Eina.Log.Error($"Error adding proxy for event {key}");
1095          }
1096       }
1097       remove {
1098          lock (eventLock) {
1099             string key = "_EFL_UI_EVENT_SCROLL_DRAG_STOP";
1100             if (remove_cpp_event_handler(key, this.evt_ScrollDragStopEvt_delegate)) {
1101                eventHandlers.RemoveHandler(ScrollDragStopEvtKey , value);
1102             } else
1103                Eina.Log.Error($"Error removing proxy for event {key}");
1104          }
1105       }
1106    }
1107    ///<summary>Method to raise event ScrollDragStopEvt.</summary>
1108    public void On_ScrollDragStopEvt(EventArgs e)
1109    {
1110       EventHandler evt;
1111       lock (eventLock) {
1112       evt = (EventHandler)eventHandlers[ScrollDragStopEvtKey];
1113       }
1114       evt?.Invoke(this, e);
1115    }
1116    Efl.EventCb evt_ScrollDragStopEvt_delegate;
1117    private void on_ScrollDragStopEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1118    {
1119       EventArgs args = EventArgs.Empty;
1120       try {
1121          On_ScrollDragStopEvt(args);
1122       } catch (Exception e) {
1123          Eina.Log.Error(e.ToString());
1124          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1125       }
1126    }
1127
1128 private static object BarPressEvtKey = new object();
1129    /// <summary>Called when bar is pressed</summary>
1130    public event EventHandler<Efl.Ui.ScrollbarBarPressEvt_Args> BarPressEvt
1131    {
1132       add {
1133          lock (eventLock) {
1134             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
1135             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarPressEvt_delegate)) {
1136                eventHandlers.AddHandler(BarPressEvtKey , value);
1137             } else
1138                Eina.Log.Error($"Error adding proxy for event {key}");
1139          }
1140       }
1141       remove {
1142          lock (eventLock) {
1143             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_PRESS";
1144             if (remove_cpp_event_handler(key, this.evt_BarPressEvt_delegate)) {
1145                eventHandlers.RemoveHandler(BarPressEvtKey , value);
1146             } else
1147                Eina.Log.Error($"Error removing proxy for event {key}");
1148          }
1149       }
1150    }
1151    ///<summary>Method to raise event BarPressEvt.</summary>
1152    public void On_BarPressEvt(Efl.Ui.ScrollbarBarPressEvt_Args e)
1153    {
1154       EventHandler<Efl.Ui.ScrollbarBarPressEvt_Args> evt;
1155       lock (eventLock) {
1156       evt = (EventHandler<Efl.Ui.ScrollbarBarPressEvt_Args>)eventHandlers[BarPressEvtKey];
1157       }
1158       evt?.Invoke(this, e);
1159    }
1160    Efl.EventCb evt_BarPressEvt_delegate;
1161    private void on_BarPressEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1162    {
1163       Efl.Ui.ScrollbarBarPressEvt_Args args = new Efl.Ui.ScrollbarBarPressEvt_Args();
1164       args.arg = default(Efl.Ui.ScrollbarDirection);
1165       try {
1166          On_BarPressEvt(args);
1167       } catch (Exception e) {
1168          Eina.Log.Error(e.ToString());
1169          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1170       }
1171    }
1172
1173 private static object BarUnpressEvtKey = new object();
1174    /// <summary>Called when bar is unpressed</summary>
1175    public event EventHandler<Efl.Ui.ScrollbarBarUnpressEvt_Args> BarUnpressEvt
1176    {
1177       add {
1178          lock (eventLock) {
1179             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
1180             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarUnpressEvt_delegate)) {
1181                eventHandlers.AddHandler(BarUnpressEvtKey , value);
1182             } else
1183                Eina.Log.Error($"Error adding proxy for event {key}");
1184          }
1185       }
1186       remove {
1187          lock (eventLock) {
1188             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS";
1189             if (remove_cpp_event_handler(key, this.evt_BarUnpressEvt_delegate)) {
1190                eventHandlers.RemoveHandler(BarUnpressEvtKey , value);
1191             } else
1192                Eina.Log.Error($"Error removing proxy for event {key}");
1193          }
1194       }
1195    }
1196    ///<summary>Method to raise event BarUnpressEvt.</summary>
1197    public void On_BarUnpressEvt(Efl.Ui.ScrollbarBarUnpressEvt_Args e)
1198    {
1199       EventHandler<Efl.Ui.ScrollbarBarUnpressEvt_Args> evt;
1200       lock (eventLock) {
1201       evt = (EventHandler<Efl.Ui.ScrollbarBarUnpressEvt_Args>)eventHandlers[BarUnpressEvtKey];
1202       }
1203       evt?.Invoke(this, e);
1204    }
1205    Efl.EventCb evt_BarUnpressEvt_delegate;
1206    private void on_BarUnpressEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1207    {
1208       Efl.Ui.ScrollbarBarUnpressEvt_Args args = new Efl.Ui.ScrollbarBarUnpressEvt_Args();
1209       args.arg = default(Efl.Ui.ScrollbarDirection);
1210       try {
1211          On_BarUnpressEvt(args);
1212       } catch (Exception e) {
1213          Eina.Log.Error(e.ToString());
1214          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1215       }
1216    }
1217
1218 private static object BarDragEvtKey = new object();
1219    /// <summary>Called when bar is dragged</summary>
1220    public event EventHandler<Efl.Ui.ScrollbarBarDragEvt_Args> BarDragEvt
1221    {
1222       add {
1223          lock (eventLock) {
1224             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1225             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarDragEvt_delegate)) {
1226                eventHandlers.AddHandler(BarDragEvtKey , value);
1227             } else
1228                Eina.Log.Error($"Error adding proxy for event {key}");
1229          }
1230       }
1231       remove {
1232          lock (eventLock) {
1233             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_DRAG";
1234             if (remove_cpp_event_handler(key, this.evt_BarDragEvt_delegate)) {
1235                eventHandlers.RemoveHandler(BarDragEvtKey , value);
1236             } else
1237                Eina.Log.Error($"Error removing proxy for event {key}");
1238          }
1239       }
1240    }
1241    ///<summary>Method to raise event BarDragEvt.</summary>
1242    public void On_BarDragEvt(Efl.Ui.ScrollbarBarDragEvt_Args e)
1243    {
1244       EventHandler<Efl.Ui.ScrollbarBarDragEvt_Args> evt;
1245       lock (eventLock) {
1246       evt = (EventHandler<Efl.Ui.ScrollbarBarDragEvt_Args>)eventHandlers[BarDragEvtKey];
1247       }
1248       evt?.Invoke(this, e);
1249    }
1250    Efl.EventCb evt_BarDragEvt_delegate;
1251    private void on_BarDragEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1252    {
1253       Efl.Ui.ScrollbarBarDragEvt_Args args = new Efl.Ui.ScrollbarBarDragEvt_Args();
1254       args.arg = default(Efl.Ui.ScrollbarDirection);
1255       try {
1256          On_BarDragEvt(args);
1257       } catch (Exception e) {
1258          Eina.Log.Error(e.ToString());
1259          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1260       }
1261    }
1262
1263 private static object BarSizeChangedEvtKey = new object();
1264    /// <summary>Called when bar size is changed</summary>
1265    public event EventHandler BarSizeChangedEvt
1266    {
1267       add {
1268          lock (eventLock) {
1269             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1270             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarSizeChangedEvt_delegate)) {
1271                eventHandlers.AddHandler(BarSizeChangedEvtKey , value);
1272             } else
1273                Eina.Log.Error($"Error adding proxy for event {key}");
1274          }
1275       }
1276       remove {
1277          lock (eventLock) {
1278             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED";
1279             if (remove_cpp_event_handler(key, this.evt_BarSizeChangedEvt_delegate)) {
1280                eventHandlers.RemoveHandler(BarSizeChangedEvtKey , value);
1281             } else
1282                Eina.Log.Error($"Error removing proxy for event {key}");
1283          }
1284       }
1285    }
1286    ///<summary>Method to raise event BarSizeChangedEvt.</summary>
1287    public void On_BarSizeChangedEvt(EventArgs e)
1288    {
1289       EventHandler evt;
1290       lock (eventLock) {
1291       evt = (EventHandler)eventHandlers[BarSizeChangedEvtKey];
1292       }
1293       evt?.Invoke(this, e);
1294    }
1295    Efl.EventCb evt_BarSizeChangedEvt_delegate;
1296    private void on_BarSizeChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1297    {
1298       EventArgs args = EventArgs.Empty;
1299       try {
1300          On_BarSizeChangedEvt(args);
1301       } catch (Exception e) {
1302          Eina.Log.Error(e.ToString());
1303          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1304       }
1305    }
1306
1307 private static object BarPosChangedEvtKey = new object();
1308    /// <summary>Called when bar position is changed</summary>
1309    public event EventHandler BarPosChangedEvt
1310    {
1311       add {
1312          lock (eventLock) {
1313             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1314             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarPosChangedEvt_delegate)) {
1315                eventHandlers.AddHandler(BarPosChangedEvtKey , value);
1316             } else
1317                Eina.Log.Error($"Error adding proxy for event {key}");
1318          }
1319       }
1320       remove {
1321          lock (eventLock) {
1322             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_POS_CHANGED";
1323             if (remove_cpp_event_handler(key, this.evt_BarPosChangedEvt_delegate)) {
1324                eventHandlers.RemoveHandler(BarPosChangedEvtKey , value);
1325             } else
1326                Eina.Log.Error($"Error removing proxy for event {key}");
1327          }
1328       }
1329    }
1330    ///<summary>Method to raise event BarPosChangedEvt.</summary>
1331    public void On_BarPosChangedEvt(EventArgs e)
1332    {
1333       EventHandler evt;
1334       lock (eventLock) {
1335       evt = (EventHandler)eventHandlers[BarPosChangedEvtKey];
1336       }
1337       evt?.Invoke(this, e);
1338    }
1339    Efl.EventCb evt_BarPosChangedEvt_delegate;
1340    private void on_BarPosChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1341    {
1342       EventArgs args = EventArgs.Empty;
1343       try {
1344          On_BarPosChangedEvt(args);
1345       } catch (Exception e) {
1346          Eina.Log.Error(e.ToString());
1347          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1348       }
1349    }
1350
1351 private static object BarShowEvtKey = new object();
1352    /// <summary>Callend when bar is shown</summary>
1353    public event EventHandler<Efl.Ui.ScrollbarBarShowEvt_Args> BarShowEvt
1354    {
1355       add {
1356          lock (eventLock) {
1357             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1358             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarShowEvt_delegate)) {
1359                eventHandlers.AddHandler(BarShowEvtKey , value);
1360             } else
1361                Eina.Log.Error($"Error adding proxy for event {key}");
1362          }
1363       }
1364       remove {
1365          lock (eventLock) {
1366             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_SHOW";
1367             if (remove_cpp_event_handler(key, this.evt_BarShowEvt_delegate)) {
1368                eventHandlers.RemoveHandler(BarShowEvtKey , value);
1369             } else
1370                Eina.Log.Error($"Error removing proxy for event {key}");
1371          }
1372       }
1373    }
1374    ///<summary>Method to raise event BarShowEvt.</summary>
1375    public void On_BarShowEvt(Efl.Ui.ScrollbarBarShowEvt_Args e)
1376    {
1377       EventHandler<Efl.Ui.ScrollbarBarShowEvt_Args> evt;
1378       lock (eventLock) {
1379       evt = (EventHandler<Efl.Ui.ScrollbarBarShowEvt_Args>)eventHandlers[BarShowEvtKey];
1380       }
1381       evt?.Invoke(this, e);
1382    }
1383    Efl.EventCb evt_BarShowEvt_delegate;
1384    private void on_BarShowEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1385    {
1386       Efl.Ui.ScrollbarBarShowEvt_Args args = new Efl.Ui.ScrollbarBarShowEvt_Args();
1387       args.arg = default(Efl.Ui.ScrollbarDirection);
1388       try {
1389          On_BarShowEvt(args);
1390       } catch (Exception e) {
1391          Eina.Log.Error(e.ToString());
1392          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1393       }
1394    }
1395
1396 private static object BarHideEvtKey = new object();
1397    /// <summary>Called when bar is hidden</summary>
1398    public event EventHandler<Efl.Ui.ScrollbarBarHideEvt_Args> BarHideEvt
1399    {
1400       add {
1401          lock (eventLock) {
1402             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1403             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_BarHideEvt_delegate)) {
1404                eventHandlers.AddHandler(BarHideEvtKey , value);
1405             } else
1406                Eina.Log.Error($"Error adding proxy for event {key}");
1407          }
1408       }
1409       remove {
1410          lock (eventLock) {
1411             string key = "_EFL_UI_SCROLLBAR_EVENT_BAR_HIDE";
1412             if (remove_cpp_event_handler(key, this.evt_BarHideEvt_delegate)) {
1413                eventHandlers.RemoveHandler(BarHideEvtKey , value);
1414             } else
1415                Eina.Log.Error($"Error removing proxy for event {key}");
1416          }
1417       }
1418    }
1419    ///<summary>Method to raise event BarHideEvt.</summary>
1420    public void On_BarHideEvt(Efl.Ui.ScrollbarBarHideEvt_Args e)
1421    {
1422       EventHandler<Efl.Ui.ScrollbarBarHideEvt_Args> evt;
1423       lock (eventLock) {
1424       evt = (EventHandler<Efl.Ui.ScrollbarBarHideEvt_Args>)eventHandlers[BarHideEvtKey];
1425       }
1426       evt?.Invoke(this, e);
1427    }
1428    Efl.EventCb evt_BarHideEvt_delegate;
1429    private void on_BarHideEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1430    {
1431       Efl.Ui.ScrollbarBarHideEvt_Args args = new Efl.Ui.ScrollbarBarHideEvt_Args();
1432       args.arg = default(Efl.Ui.ScrollbarDirection);
1433       try {
1434          On_BarHideEvt(args);
1435       } catch (Exception e) {
1436          Eina.Log.Error(e.ToString());
1437          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1438       }
1439    }
1440
1441 private static object SelectedEvtKey = new object();
1442    /// <summary>Called when selected</summary>
1443    public event EventHandler SelectedEvt
1444    {
1445       add {
1446          lock (eventLock) {
1447             string key = "_EFL_UI_EVENT_SELECTED";
1448             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectedEvt_delegate)) {
1449                eventHandlers.AddHandler(SelectedEvtKey , value);
1450             } else
1451                Eina.Log.Error($"Error adding proxy for event {key}");
1452          }
1453       }
1454       remove {
1455          lock (eventLock) {
1456             string key = "_EFL_UI_EVENT_SELECTED";
1457             if (remove_cpp_event_handler(key, this.evt_SelectedEvt_delegate)) {
1458                eventHandlers.RemoveHandler(SelectedEvtKey , value);
1459             } else
1460                Eina.Log.Error($"Error removing proxy for event {key}");
1461          }
1462       }
1463    }
1464    ///<summary>Method to raise event SelectedEvt.</summary>
1465    public void On_SelectedEvt(EventArgs e)
1466    {
1467       EventHandler evt;
1468       lock (eventLock) {
1469       evt = (EventHandler)eventHandlers[SelectedEvtKey];
1470       }
1471       evt?.Invoke(this, e);
1472    }
1473    Efl.EventCb evt_SelectedEvt_delegate;
1474    private void on_SelectedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1475    {
1476       EventArgs args = EventArgs.Empty;
1477       try {
1478          On_SelectedEvt(args);
1479       } catch (Exception e) {
1480          Eina.Log.Error(e.ToString());
1481          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1482       }
1483    }
1484
1485 private static object UnselectedEvtKey = new object();
1486    /// <summary>Called when no longer selected</summary>
1487    public event EventHandler UnselectedEvt
1488    {
1489       add {
1490          lock (eventLock) {
1491             string key = "_EFL_UI_EVENT_UNSELECTED";
1492             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_UnselectedEvt_delegate)) {
1493                eventHandlers.AddHandler(UnselectedEvtKey , value);
1494             } else
1495                Eina.Log.Error($"Error adding proxy for event {key}");
1496          }
1497       }
1498       remove {
1499          lock (eventLock) {
1500             string key = "_EFL_UI_EVENT_UNSELECTED";
1501             if (remove_cpp_event_handler(key, this.evt_UnselectedEvt_delegate)) {
1502                eventHandlers.RemoveHandler(UnselectedEvtKey , value);
1503             } else
1504                Eina.Log.Error($"Error removing proxy for event {key}");
1505          }
1506       }
1507    }
1508    ///<summary>Method to raise event UnselectedEvt.</summary>
1509    public void On_UnselectedEvt(EventArgs e)
1510    {
1511       EventHandler evt;
1512       lock (eventLock) {
1513       evt = (EventHandler)eventHandlers[UnselectedEvtKey];
1514       }
1515       evt?.Invoke(this, e);
1516    }
1517    Efl.EventCb evt_UnselectedEvt_delegate;
1518    private void on_UnselectedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1519    {
1520       EventArgs args = EventArgs.Empty;
1521       try {
1522          On_UnselectedEvt(args);
1523       } catch (Exception e) {
1524          Eina.Log.Error(e.ToString());
1525          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1526       }
1527    }
1528
1529 private static object SelectionPasteEvtKey = new object();
1530    /// <summary>Called when selection is pasted</summary>
1531    public event EventHandler SelectionPasteEvt
1532    {
1533       add {
1534          lock (eventLock) {
1535             string key = "_EFL_UI_EVENT_SELECTION_PASTE";
1536             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionPasteEvt_delegate)) {
1537                eventHandlers.AddHandler(SelectionPasteEvtKey , value);
1538             } else
1539                Eina.Log.Error($"Error adding proxy for event {key}");
1540          }
1541       }
1542       remove {
1543          lock (eventLock) {
1544             string key = "_EFL_UI_EVENT_SELECTION_PASTE";
1545             if (remove_cpp_event_handler(key, this.evt_SelectionPasteEvt_delegate)) {
1546                eventHandlers.RemoveHandler(SelectionPasteEvtKey , value);
1547             } else
1548                Eina.Log.Error($"Error removing proxy for event {key}");
1549          }
1550       }
1551    }
1552    ///<summary>Method to raise event SelectionPasteEvt.</summary>
1553    public void On_SelectionPasteEvt(EventArgs e)
1554    {
1555       EventHandler evt;
1556       lock (eventLock) {
1557       evt = (EventHandler)eventHandlers[SelectionPasteEvtKey];
1558       }
1559       evt?.Invoke(this, e);
1560    }
1561    Efl.EventCb evt_SelectionPasteEvt_delegate;
1562    private void on_SelectionPasteEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1563    {
1564       EventArgs args = EventArgs.Empty;
1565       try {
1566          On_SelectionPasteEvt(args);
1567       } catch (Exception e) {
1568          Eina.Log.Error(e.ToString());
1569          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1570       }
1571    }
1572
1573 private static object SelectionCopyEvtKey = new object();
1574    /// <summary>Called when selection is copied</summary>
1575    public event EventHandler SelectionCopyEvt
1576    {
1577       add {
1578          lock (eventLock) {
1579             string key = "_EFL_UI_EVENT_SELECTION_COPY";
1580             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionCopyEvt_delegate)) {
1581                eventHandlers.AddHandler(SelectionCopyEvtKey , value);
1582             } else
1583                Eina.Log.Error($"Error adding proxy for event {key}");
1584          }
1585       }
1586       remove {
1587          lock (eventLock) {
1588             string key = "_EFL_UI_EVENT_SELECTION_COPY";
1589             if (remove_cpp_event_handler(key, this.evt_SelectionCopyEvt_delegate)) {
1590                eventHandlers.RemoveHandler(SelectionCopyEvtKey , value);
1591             } else
1592                Eina.Log.Error($"Error removing proxy for event {key}");
1593          }
1594       }
1595    }
1596    ///<summary>Method to raise event SelectionCopyEvt.</summary>
1597    public void On_SelectionCopyEvt(EventArgs e)
1598    {
1599       EventHandler evt;
1600       lock (eventLock) {
1601       evt = (EventHandler)eventHandlers[SelectionCopyEvtKey];
1602       }
1603       evt?.Invoke(this, e);
1604    }
1605    Efl.EventCb evt_SelectionCopyEvt_delegate;
1606    private void on_SelectionCopyEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1607    {
1608       EventArgs args = EventArgs.Empty;
1609       try {
1610          On_SelectionCopyEvt(args);
1611       } catch (Exception e) {
1612          Eina.Log.Error(e.ToString());
1613          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1614       }
1615    }
1616
1617 private static object SelectionCutEvtKey = new object();
1618    /// <summary>Called when selection is cut</summary>
1619    public event EventHandler SelectionCutEvt
1620    {
1621       add {
1622          lock (eventLock) {
1623             string key = "_EFL_UI_EVENT_SELECTION_CUT";
1624             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionCutEvt_delegate)) {
1625                eventHandlers.AddHandler(SelectionCutEvtKey , value);
1626             } else
1627                Eina.Log.Error($"Error adding proxy for event {key}");
1628          }
1629       }
1630       remove {
1631          lock (eventLock) {
1632             string key = "_EFL_UI_EVENT_SELECTION_CUT";
1633             if (remove_cpp_event_handler(key, this.evt_SelectionCutEvt_delegate)) {
1634                eventHandlers.RemoveHandler(SelectionCutEvtKey , value);
1635             } else
1636                Eina.Log.Error($"Error removing proxy for event {key}");
1637          }
1638       }
1639    }
1640    ///<summary>Method to raise event SelectionCutEvt.</summary>
1641    public void On_SelectionCutEvt(EventArgs e)
1642    {
1643       EventHandler evt;
1644       lock (eventLock) {
1645       evt = (EventHandler)eventHandlers[SelectionCutEvtKey];
1646       }
1647       evt?.Invoke(this, e);
1648    }
1649    Efl.EventCb evt_SelectionCutEvt_delegate;
1650    private void on_SelectionCutEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1651    {
1652       EventArgs args = EventArgs.Empty;
1653       try {
1654          On_SelectionCutEvt(args);
1655       } catch (Exception e) {
1656          Eina.Log.Error(e.ToString());
1657          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1658       }
1659    }
1660
1661 private static object SelectionStartEvtKey = new object();
1662    /// <summary>Called at selection start</summary>
1663    public event EventHandler SelectionStartEvt
1664    {
1665       add {
1666          lock (eventLock) {
1667             string key = "_EFL_UI_EVENT_SELECTION_START";
1668             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionStartEvt_delegate)) {
1669                eventHandlers.AddHandler(SelectionStartEvtKey , value);
1670             } else
1671                Eina.Log.Error($"Error adding proxy for event {key}");
1672          }
1673       }
1674       remove {
1675          lock (eventLock) {
1676             string key = "_EFL_UI_EVENT_SELECTION_START";
1677             if (remove_cpp_event_handler(key, this.evt_SelectionStartEvt_delegate)) {
1678                eventHandlers.RemoveHandler(SelectionStartEvtKey , value);
1679             } else
1680                Eina.Log.Error($"Error removing proxy for event {key}");
1681          }
1682       }
1683    }
1684    ///<summary>Method to raise event SelectionStartEvt.</summary>
1685    public void On_SelectionStartEvt(EventArgs e)
1686    {
1687       EventHandler evt;
1688       lock (eventLock) {
1689       evt = (EventHandler)eventHandlers[SelectionStartEvtKey];
1690       }
1691       evt?.Invoke(this, e);
1692    }
1693    Efl.EventCb evt_SelectionStartEvt_delegate;
1694    private void on_SelectionStartEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1695    {
1696       EventArgs args = EventArgs.Empty;
1697       try {
1698          On_SelectionStartEvt(args);
1699       } catch (Exception e) {
1700          Eina.Log.Error(e.ToString());
1701          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1702       }
1703    }
1704
1705 private static object Efl_Ui_Selectable_SelectionChangedEvtKey = new object();
1706    /// <summary>Called when selection is changed</summary>
1707     event EventHandler Efl.Ui.Selectable.SelectionChangedEvt
1708    {
1709       add {
1710          lock (eventLock) {
1711             string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
1712             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate)) {
1713                eventHandlers.AddHandler(Efl_Ui_Selectable_SelectionChangedEvtKey , value);
1714             } else
1715                Eina.Log.Error($"Error adding proxy for event {key}");
1716          }
1717       }
1718       remove {
1719          lock (eventLock) {
1720             string key = "_EFL_UI_EVENT_SELECTION_CHANGED";
1721             if (remove_cpp_event_handler(key, this.evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate)) {
1722                eventHandlers.RemoveHandler(Efl_Ui_Selectable_SelectionChangedEvtKey , value);
1723             } else
1724                Eina.Log.Error($"Error removing proxy for event {key}");
1725          }
1726       }
1727    }
1728    ///<summary>Method to raise event Efl_Ui_Selectable_SelectionChangedEvt.</summary>
1729    public void On_Efl_Ui_Selectable_SelectionChangedEvt(EventArgs e)
1730    {
1731       EventHandler evt;
1732       lock (eventLock) {
1733       evt = (EventHandler)eventHandlers[Efl_Ui_Selectable_SelectionChangedEvtKey];
1734       }
1735       evt?.Invoke(this, e);
1736    }
1737    Efl.EventCb evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate;
1738    private void on_Efl_Ui_Selectable_SelectionChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1739    {
1740       EventArgs args = EventArgs.Empty;
1741       try {
1742          On_Efl_Ui_Selectable_SelectionChangedEvt(args);
1743       } catch (Exception e) {
1744          Eina.Log.Error(e.ToString());
1745          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1746       }
1747    }
1748
1749 private static object SelectionClearedEvtKey = new object();
1750    /// <summary>Called when selection is cleared</summary>
1751    public event EventHandler SelectionClearedEvt
1752    {
1753       add {
1754          lock (eventLock) {
1755             string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
1756             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_SelectionClearedEvt_delegate)) {
1757                eventHandlers.AddHandler(SelectionClearedEvtKey , value);
1758             } else
1759                Eina.Log.Error($"Error adding proxy for event {key}");
1760          }
1761       }
1762       remove {
1763          lock (eventLock) {
1764             string key = "_EFL_UI_EVENT_SELECTION_CLEARED";
1765             if (remove_cpp_event_handler(key, this.evt_SelectionClearedEvt_delegate)) {
1766                eventHandlers.RemoveHandler(SelectionClearedEvtKey , value);
1767             } else
1768                Eina.Log.Error($"Error removing proxy for event {key}");
1769          }
1770       }
1771    }
1772    ///<summary>Method to raise event SelectionClearedEvt.</summary>
1773    public void On_SelectionClearedEvt(EventArgs e)
1774    {
1775       EventHandler evt;
1776       lock (eventLock) {
1777       evt = (EventHandler)eventHandlers[SelectionClearedEvtKey];
1778       }
1779       evt?.Invoke(this, e);
1780    }
1781    Efl.EventCb evt_SelectionClearedEvt_delegate;
1782    private void on_SelectionClearedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
1783    {
1784       EventArgs args = EventArgs.Empty;
1785       try {
1786          On_SelectionClearedEvt(args);
1787       } catch (Exception e) {
1788          Eina.Log.Error(e.ToString());
1789          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1790       }
1791    }
1792
1793    protected override void register_event_proxies()
1794    {
1795       base.register_event_proxies();
1796       evt_LayoutUpdatedEvt_delegate = new Efl.EventCb(on_LayoutUpdatedEvt_NativeCallback);
1797       evt_ClickedEvt_delegate = new Efl.EventCb(on_ClickedEvt_NativeCallback);
1798       evt_ClickedDoubleEvt_delegate = new Efl.EventCb(on_ClickedDoubleEvt_NativeCallback);
1799       evt_ClickedTripleEvt_delegate = new Efl.EventCb(on_ClickedTripleEvt_NativeCallback);
1800       evt_ClickedRightEvt_delegate = new Efl.EventCb(on_ClickedRightEvt_NativeCallback);
1801       evt_PressedEvt_delegate = new Efl.EventCb(on_PressedEvt_NativeCallback);
1802       evt_UnpressedEvt_delegate = new Efl.EventCb(on_UnpressedEvt_NativeCallback);
1803       evt_LongpressedEvt_delegate = new Efl.EventCb(on_LongpressedEvt_NativeCallback);
1804       evt_RepeatedEvt_delegate = new Efl.EventCb(on_RepeatedEvt_NativeCallback);
1805       evt_ScrollStartEvt_delegate = new Efl.EventCb(on_ScrollStartEvt_NativeCallback);
1806       evt_ScrollEvt_delegate = new Efl.EventCb(on_ScrollEvt_NativeCallback);
1807       evt_ScrollStopEvt_delegate = new Efl.EventCb(on_ScrollStopEvt_NativeCallback);
1808       evt_ScrollUpEvt_delegate = new Efl.EventCb(on_ScrollUpEvt_NativeCallback);
1809       evt_ScrollDownEvt_delegate = new Efl.EventCb(on_ScrollDownEvt_NativeCallback);
1810       evt_ScrollLeftEvt_delegate = new Efl.EventCb(on_ScrollLeftEvt_NativeCallback);
1811       evt_ScrollRightEvt_delegate = new Efl.EventCb(on_ScrollRightEvt_NativeCallback);
1812       evt_EdgeUpEvt_delegate = new Efl.EventCb(on_EdgeUpEvt_NativeCallback);
1813       evt_EdgeDownEvt_delegate = new Efl.EventCb(on_EdgeDownEvt_NativeCallback);
1814       evt_EdgeLeftEvt_delegate = new Efl.EventCb(on_EdgeLeftEvt_NativeCallback);
1815       evt_EdgeRightEvt_delegate = new Efl.EventCb(on_EdgeRightEvt_NativeCallback);
1816       evt_ScrollAnimStartEvt_delegate = new Efl.EventCb(on_ScrollAnimStartEvt_NativeCallback);
1817       evt_ScrollAnimStopEvt_delegate = new Efl.EventCb(on_ScrollAnimStopEvt_NativeCallback);
1818       evt_ScrollDragStartEvt_delegate = new Efl.EventCb(on_ScrollDragStartEvt_NativeCallback);
1819       evt_ScrollDragStopEvt_delegate = new Efl.EventCb(on_ScrollDragStopEvt_NativeCallback);
1820       evt_BarPressEvt_delegate = new Efl.EventCb(on_BarPressEvt_NativeCallback);
1821       evt_BarUnpressEvt_delegate = new Efl.EventCb(on_BarUnpressEvt_NativeCallback);
1822       evt_BarDragEvt_delegate = new Efl.EventCb(on_BarDragEvt_NativeCallback);
1823       evt_BarSizeChangedEvt_delegate = new Efl.EventCb(on_BarSizeChangedEvt_NativeCallback);
1824       evt_BarPosChangedEvt_delegate = new Efl.EventCb(on_BarPosChangedEvt_NativeCallback);
1825       evt_BarShowEvt_delegate = new Efl.EventCb(on_BarShowEvt_NativeCallback);
1826       evt_BarHideEvt_delegate = new Efl.EventCb(on_BarHideEvt_NativeCallback);
1827       evt_SelectedEvt_delegate = new Efl.EventCb(on_SelectedEvt_NativeCallback);
1828       evt_UnselectedEvt_delegate = new Efl.EventCb(on_UnselectedEvt_NativeCallback);
1829       evt_SelectionPasteEvt_delegate = new Efl.EventCb(on_SelectionPasteEvt_NativeCallback);
1830       evt_SelectionCopyEvt_delegate = new Efl.EventCb(on_SelectionCopyEvt_NativeCallback);
1831       evt_SelectionCutEvt_delegate = new Efl.EventCb(on_SelectionCutEvt_NativeCallback);
1832       evt_SelectionStartEvt_delegate = new Efl.EventCb(on_SelectionStartEvt_NativeCallback);
1833       evt_Efl_Ui_Selectable_SelectionChangedEvt_delegate = new Efl.EventCb(on_Efl_Ui_Selectable_SelectionChangedEvt_NativeCallback);
1834       evt_SelectionClearedEvt_delegate = new Efl.EventCb(on_SelectionClearedEvt_NativeCallback);
1835    }
1836    /// <summary>Property data of item size.</summary>
1837    /// <returns>last selected item of grid.</returns>
1838    virtual public Eina.Size2D GetItemSize() {
1839        var _ret_var = Efl.Ui.GridNativeInherit.efl_ui_grid_item_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1840       Eina.Error.RaiseIfUnhandledException();
1841       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
1842  }
1843    /// <summary>Property data of item size.</summary>
1844    /// <param name="size">last selected item of grid.</param>
1845    /// <returns></returns>
1846    virtual public  void SetItemSize( Eina.Size2D size) {
1847        var _in_size = Eina.Size2D_StructConversion.ToInternal(size);
1848                   Efl.Ui.GridNativeInherit.efl_ui_grid_item_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_size);
1849       Eina.Error.RaiseIfUnhandledException();
1850                    }
1851    /// <summary>Property data of last selected item.</summary>
1852    /// <returns>last selected item of grid.</returns>
1853    virtual public Efl.Ui.GridItem GetLastSelectedItem() {
1854        var _ret_var = Efl.Ui.GridNativeInherit.efl_ui_grid_last_selected_item_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1855       Eina.Error.RaiseIfUnhandledException();
1856       return _ret_var;
1857  }
1858    /// <summary>scroll move the item to show in the viewport.</summary>
1859    /// <param name="item">Target item.</param>
1860    /// <param name="animation">Boolean value for animation of scroll move.</param>
1861    /// <returns></returns>
1862    virtual public  void ItemScroll( Efl.Ui.GridItem item,  bool animation) {
1863                                            Efl.Ui.GridNativeInherit.efl_ui_grid_item_scroll_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), item,  animation);
1864       Eina.Error.RaiseIfUnhandledException();
1865                                }
1866    /// <summary>scroll move the item to show at the align position of the viewport.</summary>
1867    /// <param name="item">Target item.</param>
1868    /// <param name="align">align value in Viewport.</param>
1869    /// <param name="animation">Boolean value for animation of scroll move.</param>
1870    /// <returns></returns>
1871    virtual public  void ItemScrollAlign( Efl.Ui.GridItem item,  double align,  bool animation) {
1872                                                              Efl.Ui.GridNativeInherit.efl_ui_grid_item_scroll_align_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), item,  align,  animation);
1873       Eina.Error.RaiseIfUnhandledException();
1874                                            }
1875    /// <summary>Get the selected items iterator. The iterator sequence will be decided by selection.</summary>
1876    /// <returns>Iterator covered by selected items list. user have to free the iterator after used.</returns>
1877    virtual public Eina.Iterator<Efl.Ui.GridItem> GetSelectedItems() {
1878        var _ret_var = Efl.Ui.GridNativeInherit.efl_ui_grid_selected_items_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1879       Eina.Error.RaiseIfUnhandledException();
1880       return new Eina.Iterator<Efl.Ui.GridItem>(_ret_var, true, false);
1881  }
1882    /// <summary>Alignment of the container within its bounds</summary>
1883    /// <param name="align_horiz">Horizontal alignment</param>
1884    /// <param name="align_vert">Vertical alignment</param>
1885    /// <returns></returns>
1886    virtual public  void GetPackAlign( out double align_horiz,  out double align_vert) {
1887                                            Efl.PackNativeInherit.efl_pack_align_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out align_horiz,  out align_vert);
1888       Eina.Error.RaiseIfUnhandledException();
1889                                }
1890    /// <summary>Alignment of the container within its bounds</summary>
1891    /// <param name="align_horiz">Horizontal alignment</param>
1892    /// <param name="align_vert">Vertical alignment</param>
1893    /// <returns></returns>
1894    virtual public  void SetPackAlign( double align_horiz,  double align_vert) {
1895                                            Efl.PackNativeInherit.efl_pack_align_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), align_horiz,  align_vert);
1896       Eina.Error.RaiseIfUnhandledException();
1897                                }
1898    /// <summary>Padding between items contained in this object.</summary>
1899    /// <param name="pad_horiz">Horizontal padding</param>
1900    /// <param name="pad_vert">Vertical padding</param>
1901    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
1902    /// <returns></returns>
1903    virtual public  void GetPackPadding( out double pad_horiz,  out double pad_vert,  out bool scalable) {
1904                                                              Efl.PackNativeInherit.efl_pack_padding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out pad_horiz,  out pad_vert,  out scalable);
1905       Eina.Error.RaiseIfUnhandledException();
1906                                            }
1907    /// <summary>Padding between items contained in this object.</summary>
1908    /// <param name="pad_horiz">Horizontal padding</param>
1909    /// <param name="pad_vert">Vertical padding</param>
1910    /// <param name="scalable"><c>true</c> if scalable, <c>false</c> otherwise</param>
1911    /// <returns></returns>
1912    virtual public  void SetPackPadding( double pad_horiz,  double pad_vert,  bool scalable) {
1913                                                              Efl.PackNativeInherit.efl_pack_padding_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), pad_horiz,  pad_vert,  scalable);
1914       Eina.Error.RaiseIfUnhandledException();
1915                                            }
1916    /// <summary>Removes all packed contents, and unreferences them.</summary>
1917    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1918    virtual public bool ClearPack() {
1919        var _ret_var = Efl.PackNativeInherit.efl_pack_clear_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1920       Eina.Error.RaiseIfUnhandledException();
1921       return _ret_var;
1922  }
1923    /// <summary>Removes all packed contents, without unreferencing them.
1924    /// Use with caution.</summary>
1925    /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
1926    virtual public bool UnpackAll() {
1927        var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_all_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1928       Eina.Error.RaiseIfUnhandledException();
1929       return _ret_var;
1930  }
1931    /// <summary>Removes an existing item from the container, without deleting it.</summary>
1932    /// <param name="subobj">The unpacked object.</param>
1933    /// <returns><c>false</c> if <c>subobj</c> wasn&apos;t a child or can&apos;t be removed</returns>
1934    virtual public bool Unpack( Efl.Gfx.Entity subobj) {
1935                          var _ret_var = Efl.PackNativeInherit.efl_pack_unpack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
1936       Eina.Error.RaiseIfUnhandledException();
1937                   return _ret_var;
1938  }
1939    /// <summary>Adds an item to this container.
1940    /// Depending on the container this will either fill in the default spot, replacing any already existing element or append to the end of the container if there is no default part.
1941    ///
1942    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
1943    /// <param name="subobj">An object to pack.</param>
1944    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
1945    virtual public bool DoPack( Efl.Gfx.Entity subobj) {
1946                          var _ret_var = Efl.PackNativeInherit.efl_pack_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
1947       Eina.Error.RaiseIfUnhandledException();
1948                   return _ret_var;
1949  }
1950    /// <summary>Requests EFL to call the <see cref="Efl.PackLayout.UpdateLayout"/> method on this object.
1951    /// This <see cref="Efl.PackLayout.UpdateLayout"/> may be called asynchronously.</summary>
1952    /// <returns></returns>
1953    virtual public  void LayoutRequest() {
1954        Efl.PackLayoutNativeInherit.efl_pack_layout_request_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1955       Eina.Error.RaiseIfUnhandledException();
1956        }
1957    /// <summary>Implementation of this container&apos;s layout algorithm.
1958    /// EFL will call this function whenever the contents of this container need to be re-layed out on the canvas.
1959    ///
1960    /// This can be overriden to implement custom layout behaviours.</summary>
1961    /// <returns></returns>
1962    virtual public  void UpdateLayout() {
1963        Efl.PackLayoutNativeInherit.efl_pack_layout_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
1964       Eina.Error.RaiseIfUnhandledException();
1965        }
1966    /// <summary>Prepend an object at the beginning of this container.
1967    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, 0).
1968    ///
1969    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
1970    /// <param name="subobj">Item to pack.</param>
1971    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
1972    virtual public bool PackBegin( Efl.Gfx.Entity subobj) {
1973                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_begin_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
1974       Eina.Error.RaiseIfUnhandledException();
1975                   return _ret_var;
1976  }
1977    /// <summary>Append object at the end of this container.
1978    /// This is the same as <see cref="Efl.PackLinear.PackAt"/>(<c>subobj</c>, -1).
1979    ///
1980    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
1981    /// <param name="subobj">Item to pack at the end.</param>
1982    /// <returns><c>false</c> if <c>subobj</c> could not be packed</returns>
1983    virtual public bool PackEnd( Efl.Gfx.Entity subobj) {
1984                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
1985       Eina.Error.RaiseIfUnhandledException();
1986                   return _ret_var;
1987  }
1988    /// <summary>Prepend item before other sub object.
1989    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
1990    /// <param name="subobj">Item to pack before <c>existing</c>.</param>
1991    /// <param name="existing">Item to refer to.</param>
1992    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
1993    virtual public bool PackBefore( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
1994                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_before_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  existing);
1995       Eina.Error.RaiseIfUnhandledException();
1996                               return _ret_var;
1997  }
1998    /// <summary>Append item after other sub object.
1999    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
2000    /// <param name="subobj">Item to pack after <c>existing</c>.</param>
2001    /// <param name="existing">Item to refer to.</param>
2002    /// <returns><c>false</c> if <c>existing</c> could not be found or <c>subobj</c> could not be packed.</returns>
2003    virtual public bool PackAfter( Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing) {
2004                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_after_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  existing);
2005       Eina.Error.RaiseIfUnhandledException();
2006                               return _ret_var;
2007  }
2008    /// <summary>Inserts <c>subobj</c> at the specified <c>index</c>.
2009    /// Valid range: -<c>count</c> to +<c>count</c>. -1 refers to the last element. Out of range indices will trigger an append.
2010    ///
2011    /// When this container is deleted, it will request deletion of the given <c>subobj</c>. Use <see cref="Efl.Pack.Unpack"/> to remove <c>subobj</c> from this container without deleting it.</summary>
2012    /// <param name="subobj">Item to pack at given index.</param>
2013    /// <param name="index">A position.</param>
2014    /// <returns><c>false</c> if <c>subobj</c> could not be packed.</returns>
2015    virtual public bool PackAt( Efl.Gfx.Entity subobj,   int index) {
2016                                            var _ret_var = Efl.PackLinearNativeInherit.efl_pack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj,  index);
2017       Eina.Error.RaiseIfUnhandledException();
2018                               return _ret_var;
2019  }
2020    /// <summary>Content at a given index in this container.
2021    /// Index -1 refers to the last item. The valid range is -(count - 1) to (count - 1).</summary>
2022    /// <param name="index">Index number</param>
2023    /// <returns>The object contained at the given <c>index</c>.</returns>
2024    virtual public Efl.Gfx.Entity GetPackContent(  int index) {
2025                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_content_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), index);
2026       Eina.Error.RaiseIfUnhandledException();
2027                   return _ret_var;
2028  }
2029    /// <summary>Get the index of a child in this container.</summary>
2030    /// <param name="subobj">An object contained in this pack.</param>
2031    /// <returns>-1 in case of failure, or the index of this item.</returns>
2032    virtual public  int GetPackIndex( Efl.Gfx.Entity subobj) {
2033                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_index_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), subobj);
2034       Eina.Error.RaiseIfUnhandledException();
2035                   return _ret_var;
2036  }
2037    /// <summary>Pop out item at specified <c>index</c>.
2038    /// Equivalent to unpack(content_at(<c>index</c>)).</summary>
2039    /// <param name="index">Index number</param>
2040    /// <returns>The child item if it could be removed.</returns>
2041    virtual public Efl.Gfx.Entity PackUnpackAt(  int index) {
2042                          var _ret_var = Efl.PackLinearNativeInherit.efl_pack_unpack_at_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), index);
2043       Eina.Error.RaiseIfUnhandledException();
2044                   return _ret_var;
2045  }
2046    /// <summary>Control the direction of a given widget.
2047    /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
2048    ///
2049    /// Mirroring as defined in <see cref="Efl.Ui.I18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
2050    /// <returns>Direction of the widget.</returns>
2051    virtual public Efl.Ui.Dir GetDirection() {
2052        var _ret_var = Efl.Ui.DirectionNativeInherit.efl_ui_direction_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2053       Eina.Error.RaiseIfUnhandledException();
2054       return _ret_var;
2055  }
2056    /// <summary>Control the direction of a given widget.
2057    /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
2058    ///
2059    /// Mirroring as defined in <see cref="Efl.Ui.I18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
2060    /// <param name="dir">Direction of the widget.</param>
2061    /// <returns></returns>
2062    virtual public  void SetDirection( Efl.Ui.Dir dir) {
2063                          Efl.Ui.DirectionNativeInherit.efl_ui_direction_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir);
2064       Eina.Error.RaiseIfUnhandledException();
2065                    }
2066    /// <summary>The mode type for children selection.</summary>
2067    /// <returns>Type of selection of children</returns>
2068    virtual public Efl.Ui.SelectMode GetSelectMode() {
2069        var _ret_var = Efl.Ui.MultiSelectableNativeInherit.efl_ui_select_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2070       Eina.Error.RaiseIfUnhandledException();
2071       return _ret_var;
2072  }
2073    /// <summary>The mode type for children selection.</summary>
2074    /// <param name="mode">Type of selection of children</param>
2075    /// <returns></returns>
2076    virtual public  void SetSelectMode( Efl.Ui.SelectMode mode) {
2077                          Efl.Ui.MultiSelectableNativeInherit.efl_ui_select_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), mode);
2078       Eina.Error.RaiseIfUnhandledException();
2079                    }
2080    /// <summary>The content position</summary>
2081    /// <returns>The position is virtual value, (0, 0) starting at the top-left.</returns>
2082    virtual public Eina.Position2D GetContentPos() {
2083        var _ret_var = Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_content_pos_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2084       Eina.Error.RaiseIfUnhandledException();
2085       return Eina.Position2D_StructConversion.ToManaged(_ret_var);
2086  }
2087    /// <summary>The content position</summary>
2088    /// <param name="pos">The position is virtual value, (0, 0) starting at the top-left.</param>
2089    /// <returns></returns>
2090    virtual public  void SetContentPos( Eina.Position2D pos) {
2091        var _in_pos = Eina.Position2D_StructConversion.ToInternal(pos);
2092                   Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_content_pos_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_pos);
2093       Eina.Error.RaiseIfUnhandledException();
2094                    }
2095    /// <summary>The content size</summary>
2096    /// <returns>The content size in pixels.</returns>
2097    virtual public Eina.Size2D GetContentSize() {
2098        var _ret_var = Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_content_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2099       Eina.Error.RaiseIfUnhandledException();
2100       return Eina.Size2D_StructConversion.ToManaged(_ret_var);
2101  }
2102    /// <summary>The viewport geometry</summary>
2103    /// <returns>It is absolute geometry.</returns>
2104    virtual public Eina.Rect GetViewportGeometry() {
2105        var _ret_var = Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_viewport_geometry_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2106       Eina.Error.RaiseIfUnhandledException();
2107       return Eina.Rect_StructConversion.ToManaged(_ret_var);
2108  }
2109    /// <summary>Bouncing behavior
2110    /// 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>
2111    /// <param name="horiz">Horizontal bounce policy.</param>
2112    /// <param name="vert">Vertical bounce policy.</param>
2113    /// <returns></returns>
2114    virtual public  void GetBounceEnabled( out bool horiz,  out bool vert) {
2115                                            Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_bounce_enabled_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out horiz,  out vert);
2116       Eina.Error.RaiseIfUnhandledException();
2117                                }
2118    /// <summary>Bouncing behavior
2119    /// 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>
2120    /// <param name="horiz">Horizontal bounce policy.</param>
2121    /// <param name="vert">Vertical bounce policy.</param>
2122    /// <returns></returns>
2123    virtual public  void SetBounceEnabled( bool horiz,  bool vert) {
2124                                            Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_bounce_enabled_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), horiz,  vert);
2125       Eina.Error.RaiseIfUnhandledException();
2126                                }
2127    /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.ScrollableInteractive.SetMovementBlock"/>.</summary>
2128    /// <returns><c>true</c> if freeze, <c>false</c> otherwise</returns>
2129    virtual public bool GetScrollFreeze() {
2130        var _ret_var = Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_scroll_freeze_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2131       Eina.Error.RaiseIfUnhandledException();
2132       return _ret_var;
2133  }
2134    /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.ScrollableInteractive.SetMovementBlock"/>.</summary>
2135    /// <param name="freeze"><c>true</c> if freeze, <c>false</c> otherwise</param>
2136    /// <returns></returns>
2137    virtual public  void SetScrollFreeze( bool freeze) {
2138                          Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_scroll_freeze_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), freeze);
2139       Eina.Error.RaiseIfUnhandledException();
2140                    }
2141    /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
2142    /// <returns><c>true</c> if hold, <c>false</c> otherwise</returns>
2143    virtual public bool GetScrollHold() {
2144        var _ret_var = Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_scroll_hold_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2145       Eina.Error.RaiseIfUnhandledException();
2146       return _ret_var;
2147  }
2148    /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
2149    /// <param name="hold"><c>true</c> if hold, <c>false</c> otherwise</param>
2150    /// <returns></returns>
2151    virtual public  void SetScrollHold( bool hold) {
2152                          Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_scroll_hold_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), hold);
2153       Eina.Error.RaiseIfUnhandledException();
2154                    }
2155    /// <summary>Controls an infinite loop for a scroller.</summary>
2156    /// <param name="loop_h">The scrolling horizontal loop</param>
2157    /// <param name="loop_v">The Scrolling vertical loop</param>
2158    /// <returns></returns>
2159    virtual public  void GetLooping( out bool loop_h,  out bool loop_v) {
2160                                            Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_looping_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out loop_h,  out loop_v);
2161       Eina.Error.RaiseIfUnhandledException();
2162                                }
2163    /// <summary>Controls an infinite loop for a scroller.</summary>
2164    /// <param name="loop_h">The scrolling horizontal loop</param>
2165    /// <param name="loop_v">The Scrolling vertical loop</param>
2166    /// <returns></returns>
2167    virtual public  void SetLooping( bool loop_h,  bool loop_v) {
2168                                            Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_looping_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), loop_h,  loop_v);
2169       Eina.Error.RaiseIfUnhandledException();
2170                                }
2171    /// <summary>Blocking of scrolling (per axis)
2172    /// 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>
2173    /// <returns>Which axis (or axes) to block</returns>
2174    virtual public Efl.Ui.ScrollBlock GetMovementBlock() {
2175        var _ret_var = Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_movement_block_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2176       Eina.Error.RaiseIfUnhandledException();
2177       return _ret_var;
2178  }
2179    /// <summary>Blocking of scrolling (per axis)
2180    /// 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>
2181    /// <param name="block">Which axis (or axes) to block</param>
2182    /// <returns></returns>
2183    virtual public  void SetMovementBlock( Efl.Ui.ScrollBlock block) {
2184                          Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_movement_block_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), block);
2185       Eina.Error.RaiseIfUnhandledException();
2186                    }
2187    /// <summary>Control scrolling gravity on the scrollable
2188    /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
2189    ///
2190    /// The scroller will adjust the view to glue itself as follows.
2191    ///
2192    /// 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
2193    ///
2194    /// Default values for x and y are 0.0</summary>
2195    /// <param name="x">Horizontal scrolling gravity</param>
2196    /// <param name="y">Vertical scrolling gravity</param>
2197    /// <returns></returns>
2198    virtual public  void GetGravity( out double x,  out double y) {
2199                                            Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_gravity_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out x,  out y);
2200       Eina.Error.RaiseIfUnhandledException();
2201                                }
2202    /// <summary>Control scrolling gravity on the scrollable
2203    /// The gravity defines how the scroller will adjust its view when the size of the scroller contents increases.
2204    ///
2205    /// The scroller will adjust the view to glue itself as follows.
2206    ///
2207    /// 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
2208    ///
2209    /// Default values for x and y are 0.0</summary>
2210    /// <param name="x">Horizontal scrolling gravity</param>
2211    /// <param name="y">Vertical scrolling gravity</param>
2212    /// <returns></returns>
2213    virtual public  void SetGravity( double x,  double y) {
2214                                            Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_gravity_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), x,  y);
2215       Eina.Error.RaiseIfUnhandledException();
2216                                }
2217    /// <summary>Prevent the scrollable from being smaller than the minimum size of the content.
2218    /// 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>
2219    /// <param name="w">Whether to limit the minimum horizontal size</param>
2220    /// <param name="h">Whether to limit the minimum vertical size</param>
2221    /// <returns></returns>
2222    virtual public  void SetMatchContent( bool w,  bool h) {
2223                                            Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_match_content_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), w,  h);
2224       Eina.Error.RaiseIfUnhandledException();
2225                                }
2226    /// <summary>Control the step size
2227    /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
2228    /// <returns>The step size in pixels</returns>
2229    virtual public Eina.Position2D GetStepSize() {
2230        var _ret_var = Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_step_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2231       Eina.Error.RaiseIfUnhandledException();
2232       return Eina.Position2D_StructConversion.ToManaged(_ret_var);
2233  }
2234    /// <summary>Control the step size
2235    /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
2236    /// <param name="step">The step size in pixels</param>
2237    /// <returns></returns>
2238    virtual public  void SetStepSize( Eina.Position2D step) {
2239        var _in_step = Eina.Position2D_StructConversion.ToInternal(step);
2240                   Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_step_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_step);
2241       Eina.Error.RaiseIfUnhandledException();
2242                    }
2243    /// <summary>Show a specific virtual region within the scroller content object.
2244    /// 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>
2245    /// <param name="rect">The position where to scroll. and The size user want to see</param>
2246    /// <param name="animation">Whether to scroll with animation or not</param>
2247    /// <returns></returns>
2248    virtual public  void Scroll( Eina.Rect rect,  bool animation) {
2249        var _in_rect = Eina.Rect_StructConversion.ToInternal(rect);
2250                                     Efl.Ui.ScrollableInteractiveNativeInherit.efl_ui_scrollable_scroll_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_rect,  animation);
2251       Eina.Error.RaiseIfUnhandledException();
2252                                }
2253    /// <summary>Scrollbar visibility policy</summary>
2254    /// <param name="hbar">Horizontal scrollbar</param>
2255    /// <param name="vbar">Vertical scrollbar</param>
2256    /// <returns></returns>
2257    virtual public  void GetBarMode( out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar) {
2258                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_mode_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out hbar,  out vbar);
2259       Eina.Error.RaiseIfUnhandledException();
2260                                }
2261    /// <summary>Scrollbar visibility policy</summary>
2262    /// <param name="hbar">Horizontal scrollbar</param>
2263    /// <param name="vbar">Vertical scrollbar</param>
2264    /// <returns></returns>
2265    virtual public  void SetBarMode( Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar) {
2266                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_mode_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), hbar,  vbar);
2267       Eina.Error.RaiseIfUnhandledException();
2268                                }
2269    /// <summary>Scrollbar size. It is calculated based on viewport size-content sizes.</summary>
2270    /// <param name="width">Value between 0.0 and 1.0</param>
2271    /// <param name="height">Value between 0.0 and 1.0</param>
2272    /// <returns></returns>
2273    virtual public  void GetBarSize( out double width,  out double height) {
2274                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out width,  out height);
2275       Eina.Error.RaiseIfUnhandledException();
2276                                }
2277    /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
2278    /// <param name="posx">Value between 0.0 and 1.0</param>
2279    /// <param name="posy">Value between 0.0 and 1.0</param>
2280    /// <returns></returns>
2281    virtual public  void GetBarPosition( out double posx,  out double posy) {
2282                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out posx,  out posy);
2283       Eina.Error.RaiseIfUnhandledException();
2284                                }
2285    /// <summary>Scrollbar position. It is calculated based on current position-maximum positions.</summary>
2286    /// <param name="posx">Value between 0.0 and 1.0</param>
2287    /// <param name="posy">Value between 0.0 and 1.0</param>
2288    /// <returns></returns>
2289    virtual public  void SetBarPosition( double posx,  double posy) {
2290                                            Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), posx,  posy);
2291       Eina.Error.RaiseIfUnhandledException();
2292                                }
2293    /// <summary>Update bar visibility.
2294    /// The object will call this function whenever the bar need to be shown or hidden.</summary>
2295    /// <returns></returns>
2296    virtual public  void UpdateBarVisibility() {
2297        Efl.Ui.ScrollbarNativeInherit.efl_ui_scrollbar_bar_visibility_update_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
2298       Eina.Error.RaiseIfUnhandledException();
2299        }
2300    /// <summary>Property data of item size.</summary>
2301 /// <value>last selected item of grid.</value>
2302    public Eina.Size2D ItemSize {
2303       get { return GetItemSize(); }
2304       set { SetItemSize( value); }
2305    }
2306    /// <summary>Property data of last selected item.</summary>
2307 /// <value>last selected item of grid.</value>
2308    public Efl.Ui.GridItem LastSelectedItem {
2309       get { return GetLastSelectedItem(); }
2310    }
2311    /// <summary>Control the direction of a given widget.
2312 /// Use this function to change how your widget is to be disposed: vertically or horizontally or inverted vertically or inverted horizontally.
2313 ///
2314 /// Mirroring as defined in <see cref="Efl.Ui.I18n"/> can invert the <c>horizontal</c> direction: it is <c>ltr</c> by default, but becomes <c>rtl</c> if the object is mirrored.</summary>
2315 /// <value>Direction of the widget.</value>
2316    public Efl.Ui.Dir Direction {
2317       get { return GetDirection(); }
2318       set { SetDirection( value); }
2319    }
2320    /// <summary>The mode type for children selection.</summary>
2321 /// <value>Type of selection of children</value>
2322    public Efl.Ui.SelectMode SelectMode {
2323       get { return GetSelectMode(); }
2324       set { SetSelectMode( value); }
2325    }
2326    /// <summary>The content position</summary>
2327 /// <value>The position is virtual value, (0, 0) starting at the top-left.</value>
2328    public Eina.Position2D ContentPos {
2329       get { return GetContentPos(); }
2330       set { SetContentPos( value); }
2331    }
2332    /// <summary>The content size</summary>
2333 /// <value>The content size in pixels.</value>
2334    public Eina.Size2D ContentSize {
2335       get { return GetContentSize(); }
2336    }
2337    /// <summary>The viewport geometry</summary>
2338 /// <value>It is absolute geometry.</value>
2339    public Eina.Rect ViewportGeometry {
2340       get { return GetViewportGeometry(); }
2341    }
2342    /// <summary>Freeze property This function will freeze scrolling movement (by input of a user). Unlike efl_ui_scrollable_movement_block_set, this function freezes bidirectionally. If you want to freeze in only one direction, See <see cref="Efl.Ui.ScrollableInteractive.SetMovementBlock"/>.</summary>
2343 /// <value><c>true</c> if freeze, <c>false</c> otherwise</value>
2344    public bool ScrollFreeze {
2345       get { return GetScrollFreeze(); }
2346       set { SetScrollFreeze( value); }
2347    }
2348    /// <summary>Hold property When hold turns on, it only scrolls by holding action.</summary>
2349 /// <value><c>true</c> if hold, <c>false</c> otherwise</value>
2350    public bool ScrollHold {
2351       get { return GetScrollHold(); }
2352       set { SetScrollHold( value); }
2353    }
2354    /// <summary>Blocking of scrolling (per axis)
2355 /// 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>
2356 /// <value>Which axis (or axes) to block</value>
2357    public Efl.Ui.ScrollBlock MovementBlock {
2358       get { return GetMovementBlock(); }
2359       set { SetMovementBlock( value); }
2360    }
2361    /// <summary>Control the step size
2362 /// Use this call to set step size. This value is used when scroller scroll by arrow key event.</summary>
2363 /// <value>The step size in pixels</value>
2364    public Eina.Position2D StepSize {
2365       get { return GetStepSize(); }
2366       set { SetStepSize( value); }
2367    }
2368    private static new  IntPtr GetEflClassStatic()
2369    {
2370       return Efl.Ui.Grid.efl_ui_grid_class_get();
2371    }
2372 }
2373 public class GridNativeInherit : Efl.Ui.LayoutBaseNativeInherit{
2374    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Elementary);
2375    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
2376    {
2377       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
2378       if (efl_ui_grid_item_size_get_static_delegate == null)
2379       efl_ui_grid_item_size_get_static_delegate = new efl_ui_grid_item_size_get_delegate(item_size_get);
2380       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_grid_item_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_grid_item_size_get_static_delegate)});
2381       if (efl_ui_grid_item_size_set_static_delegate == null)
2382       efl_ui_grid_item_size_set_static_delegate = new efl_ui_grid_item_size_set_delegate(item_size_set);
2383       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_grid_item_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_grid_item_size_set_static_delegate)});
2384       if (efl_ui_grid_last_selected_item_get_static_delegate == null)
2385       efl_ui_grid_last_selected_item_get_static_delegate = new efl_ui_grid_last_selected_item_get_delegate(last_selected_item_get);
2386       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_grid_last_selected_item_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_grid_last_selected_item_get_static_delegate)});
2387       if (efl_ui_grid_item_scroll_static_delegate == null)
2388       efl_ui_grid_item_scroll_static_delegate = new efl_ui_grid_item_scroll_delegate(item_scroll);
2389       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_grid_item_scroll"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_grid_item_scroll_static_delegate)});
2390       if (efl_ui_grid_item_scroll_align_static_delegate == null)
2391       efl_ui_grid_item_scroll_align_static_delegate = new efl_ui_grid_item_scroll_align_delegate(item_scroll_align);
2392       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_grid_item_scroll_align"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_grid_item_scroll_align_static_delegate)});
2393       if (efl_ui_grid_selected_items_get_static_delegate == null)
2394       efl_ui_grid_selected_items_get_static_delegate = new efl_ui_grid_selected_items_get_delegate(selected_items_get);
2395       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_grid_selected_items_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_grid_selected_items_get_static_delegate)});
2396       if (efl_pack_align_get_static_delegate == null)
2397       efl_pack_align_get_static_delegate = new efl_pack_align_get_delegate(pack_align_get);
2398       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_align_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_align_get_static_delegate)});
2399       if (efl_pack_align_set_static_delegate == null)
2400       efl_pack_align_set_static_delegate = new efl_pack_align_set_delegate(pack_align_set);
2401       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_align_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_align_set_static_delegate)});
2402       if (efl_pack_padding_get_static_delegate == null)
2403       efl_pack_padding_get_static_delegate = new efl_pack_padding_get_delegate(pack_padding_get);
2404       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_padding_get_static_delegate)});
2405       if (efl_pack_padding_set_static_delegate == null)
2406       efl_pack_padding_set_static_delegate = new efl_pack_padding_set_delegate(pack_padding_set);
2407       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_padding_set"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_padding_set_static_delegate)});
2408       if (efl_pack_clear_static_delegate == null)
2409       efl_pack_clear_static_delegate = new efl_pack_clear_delegate(pack_clear);
2410       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_clear"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_clear_static_delegate)});
2411       if (efl_pack_unpack_all_static_delegate == null)
2412       efl_pack_unpack_all_static_delegate = new efl_pack_unpack_all_delegate(unpack_all);
2413       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_unpack_all"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_all_static_delegate)});
2414       if (efl_pack_unpack_static_delegate == null)
2415       efl_pack_unpack_static_delegate = new efl_pack_unpack_delegate(unpack);
2416       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_unpack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_static_delegate)});
2417       if (efl_pack_static_delegate == null)
2418       efl_pack_static_delegate = new efl_pack_delegate(pack);
2419       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_static_delegate)});
2420       if (efl_pack_layout_request_static_delegate == null)
2421       efl_pack_layout_request_static_delegate = new efl_pack_layout_request_delegate(layout_request);
2422       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_layout_request"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_layout_request_static_delegate)});
2423       if (efl_pack_layout_update_static_delegate == null)
2424       efl_pack_layout_update_static_delegate = new efl_pack_layout_update_delegate(layout_update);
2425       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_layout_update"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_layout_update_static_delegate)});
2426       if (efl_pack_begin_static_delegate == null)
2427       efl_pack_begin_static_delegate = new efl_pack_begin_delegate(pack_begin);
2428       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_begin"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_begin_static_delegate)});
2429       if (efl_pack_end_static_delegate == null)
2430       efl_pack_end_static_delegate = new efl_pack_end_delegate(pack_end);
2431       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_end"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_end_static_delegate)});
2432       if (efl_pack_before_static_delegate == null)
2433       efl_pack_before_static_delegate = new efl_pack_before_delegate(pack_before);
2434       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_before"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_before_static_delegate)});
2435       if (efl_pack_after_static_delegate == null)
2436       efl_pack_after_static_delegate = new efl_pack_after_delegate(pack_after);
2437       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_after"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_after_static_delegate)});
2438       if (efl_pack_at_static_delegate == null)
2439       efl_pack_at_static_delegate = new efl_pack_at_delegate(pack_at);
2440       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_at_static_delegate)});
2441       if (efl_pack_content_get_static_delegate == null)
2442       efl_pack_content_get_static_delegate = new efl_pack_content_get_delegate(pack_content_get);
2443       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_content_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_content_get_static_delegate)});
2444       if (efl_pack_index_get_static_delegate == null)
2445       efl_pack_index_get_static_delegate = new efl_pack_index_get_delegate(pack_index_get);
2446       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_index_get"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_index_get_static_delegate)});
2447       if (efl_pack_unpack_at_static_delegate == null)
2448       efl_pack_unpack_at_static_delegate = new efl_pack_unpack_at_delegate(pack_unpack_at);
2449       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_pack_unpack_at"), func = Marshal.GetFunctionPointerForDelegate(efl_pack_unpack_at_static_delegate)});
2450       if (efl_ui_direction_get_static_delegate == null)
2451       efl_ui_direction_get_static_delegate = new efl_ui_direction_get_delegate(direction_get);
2452       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_direction_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_direction_get_static_delegate)});
2453       if (efl_ui_direction_set_static_delegate == null)
2454       efl_ui_direction_set_static_delegate = new efl_ui_direction_set_delegate(direction_set);
2455       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_direction_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_direction_set_static_delegate)});
2456       if (efl_ui_select_mode_get_static_delegate == null)
2457       efl_ui_select_mode_get_static_delegate = new efl_ui_select_mode_get_delegate(select_mode_get);
2458       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_select_mode_get"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_select_mode_get_static_delegate)});
2459       if (efl_ui_select_mode_set_static_delegate == null)
2460       efl_ui_select_mode_set_static_delegate = new efl_ui_select_mode_set_delegate(select_mode_set);
2461       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_ui_select_mode_set"), func = Marshal.GetFunctionPointerForDelegate(efl_ui_select_mode_set_static_delegate)});
2462       if (efl_ui_scrollable_content_pos_get_static_delegate == null)
2463       efl_ui_scrollable_content_pos_get_static_delegate = new efl_ui_scrollable_content_pos_get_delegate(content_pos_get);
2464       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)});
2465       if (efl_ui_scrollable_content_pos_set_static_delegate == null)
2466       efl_ui_scrollable_content_pos_set_static_delegate = new efl_ui_scrollable_content_pos_set_delegate(content_pos_set);
2467       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)});
2468       if (efl_ui_scrollable_content_size_get_static_delegate == null)
2469       efl_ui_scrollable_content_size_get_static_delegate = new efl_ui_scrollable_content_size_get_delegate(content_size_get);
2470       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)});
2471       if (efl_ui_scrollable_viewport_geometry_get_static_delegate == null)
2472       efl_ui_scrollable_viewport_geometry_get_static_delegate = new efl_ui_scrollable_viewport_geometry_get_delegate(viewport_geometry_get);
2473       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)});
2474       if (efl_ui_scrollable_bounce_enabled_get_static_delegate == null)
2475       efl_ui_scrollable_bounce_enabled_get_static_delegate = new efl_ui_scrollable_bounce_enabled_get_delegate(bounce_enabled_get);
2476       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)});
2477       if (efl_ui_scrollable_bounce_enabled_set_static_delegate == null)
2478       efl_ui_scrollable_bounce_enabled_set_static_delegate = new efl_ui_scrollable_bounce_enabled_set_delegate(bounce_enabled_set);
2479       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)});
2480       if (efl_ui_scrollable_scroll_freeze_get_static_delegate == null)
2481       efl_ui_scrollable_scroll_freeze_get_static_delegate = new efl_ui_scrollable_scroll_freeze_get_delegate(scroll_freeze_get);
2482       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)});
2483       if (efl_ui_scrollable_scroll_freeze_set_static_delegate == null)
2484       efl_ui_scrollable_scroll_freeze_set_static_delegate = new efl_ui_scrollable_scroll_freeze_set_delegate(scroll_freeze_set);
2485       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)});
2486       if (efl_ui_scrollable_scroll_hold_get_static_delegate == null)
2487       efl_ui_scrollable_scroll_hold_get_static_delegate = new efl_ui_scrollable_scroll_hold_get_delegate(scroll_hold_get);
2488       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)});
2489       if (efl_ui_scrollable_scroll_hold_set_static_delegate == null)
2490       efl_ui_scrollable_scroll_hold_set_static_delegate = new efl_ui_scrollable_scroll_hold_set_delegate(scroll_hold_set);
2491       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)});
2492       if (efl_ui_scrollable_looping_get_static_delegate == null)
2493       efl_ui_scrollable_looping_get_static_delegate = new efl_ui_scrollable_looping_get_delegate(looping_get);
2494       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)});
2495       if (efl_ui_scrollable_looping_set_static_delegate == null)
2496       efl_ui_scrollable_looping_set_static_delegate = new efl_ui_scrollable_looping_set_delegate(looping_set);
2497       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)});
2498       if (efl_ui_scrollable_movement_block_get_static_delegate == null)
2499       efl_ui_scrollable_movement_block_get_static_delegate = new efl_ui_scrollable_movement_block_get_delegate(movement_block_get);
2500       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)});
2501       if (efl_ui_scrollable_movement_block_set_static_delegate == null)
2502       efl_ui_scrollable_movement_block_set_static_delegate = new efl_ui_scrollable_movement_block_set_delegate(movement_block_set);
2503       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)});
2504       if (efl_ui_scrollable_gravity_get_static_delegate == null)
2505       efl_ui_scrollable_gravity_get_static_delegate = new efl_ui_scrollable_gravity_get_delegate(gravity_get);
2506       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)});
2507       if (efl_ui_scrollable_gravity_set_static_delegate == null)
2508       efl_ui_scrollable_gravity_set_static_delegate = new efl_ui_scrollable_gravity_set_delegate(gravity_set);
2509       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)});
2510       if (efl_ui_scrollable_match_content_set_static_delegate == null)
2511       efl_ui_scrollable_match_content_set_static_delegate = new efl_ui_scrollable_match_content_set_delegate(match_content_set);
2512       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)});
2513       if (efl_ui_scrollable_step_size_get_static_delegate == null)
2514       efl_ui_scrollable_step_size_get_static_delegate = new efl_ui_scrollable_step_size_get_delegate(step_size_get);
2515       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)});
2516       if (efl_ui_scrollable_step_size_set_static_delegate == null)
2517       efl_ui_scrollable_step_size_set_static_delegate = new efl_ui_scrollable_step_size_set_delegate(step_size_set);
2518       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)});
2519       if (efl_ui_scrollable_scroll_static_delegate == null)
2520       efl_ui_scrollable_scroll_static_delegate = new efl_ui_scrollable_scroll_delegate(scroll);
2521       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)});
2522       if (efl_ui_scrollbar_bar_mode_get_static_delegate == null)
2523       efl_ui_scrollbar_bar_mode_get_static_delegate = new efl_ui_scrollbar_bar_mode_get_delegate(bar_mode_get);
2524       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)});
2525       if (efl_ui_scrollbar_bar_mode_set_static_delegate == null)
2526       efl_ui_scrollbar_bar_mode_set_static_delegate = new efl_ui_scrollbar_bar_mode_set_delegate(bar_mode_set);
2527       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)});
2528       if (efl_ui_scrollbar_bar_size_get_static_delegate == null)
2529       efl_ui_scrollbar_bar_size_get_static_delegate = new efl_ui_scrollbar_bar_size_get_delegate(bar_size_get);
2530       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)});
2531       if (efl_ui_scrollbar_bar_position_get_static_delegate == null)
2532       efl_ui_scrollbar_bar_position_get_static_delegate = new efl_ui_scrollbar_bar_position_get_delegate(bar_position_get);
2533       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)});
2534       if (efl_ui_scrollbar_bar_position_set_static_delegate == null)
2535       efl_ui_scrollbar_bar_position_set_static_delegate = new efl_ui_scrollbar_bar_position_set_delegate(bar_position_set);
2536       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)});
2537       if (efl_ui_scrollbar_bar_visibility_update_static_delegate == null)
2538       efl_ui_scrollbar_bar_visibility_update_static_delegate = new efl_ui_scrollbar_bar_visibility_update_delegate(bar_visibility_update);
2539       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)});
2540       descs.AddRange(base.GetEoOps(type));
2541       return descs;
2542    }
2543    public override IntPtr GetEflClass()
2544    {
2545       return Efl.Ui.Grid.efl_ui_grid_class_get();
2546    }
2547    public static new  IntPtr GetEflClassStatic()
2548    {
2549       return Efl.Ui.Grid.efl_ui_grid_class_get();
2550    }
2551
2552
2553     private delegate Eina.Size2D_StructInternal efl_ui_grid_item_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2554
2555
2556     public delegate Eina.Size2D_StructInternal efl_ui_grid_item_size_get_api_delegate(System.IntPtr obj);
2557     public static Efl.Eo.FunctionWrapper<efl_ui_grid_item_size_get_api_delegate> efl_ui_grid_item_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_grid_item_size_get_api_delegate>(_Module, "efl_ui_grid_item_size_get");
2558     private static Eina.Size2D_StructInternal item_size_get(System.IntPtr obj, System.IntPtr pd)
2559    {
2560       Eina.Log.Debug("function efl_ui_grid_item_size_get was called");
2561       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2562       if(wrapper != null) {
2563                   Eina.Size2D _ret_var = default(Eina.Size2D);
2564          try {
2565             _ret_var = ((Grid)wrapper).GetItemSize();
2566          } catch (Exception e) {
2567             Eina.Log.Warning($"Callback error: {e.ToString()}");
2568             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2569          }
2570       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
2571       } else {
2572          return efl_ui_grid_item_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2573       }
2574    }
2575    private static efl_ui_grid_item_size_get_delegate efl_ui_grid_item_size_get_static_delegate;
2576
2577
2578     private delegate  void efl_ui_grid_item_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D_StructInternal size);
2579
2580
2581     public delegate  void efl_ui_grid_item_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D_StructInternal size);
2582     public static Efl.Eo.FunctionWrapper<efl_ui_grid_item_size_set_api_delegate> efl_ui_grid_item_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_grid_item_size_set_api_delegate>(_Module, "efl_ui_grid_item_size_set");
2583     private static  void item_size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D_StructInternal size)
2584    {
2585       Eina.Log.Debug("function efl_ui_grid_item_size_set was called");
2586       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2587       if(wrapper != null) {
2588                var _in_size = Eina.Size2D_StructConversion.ToManaged(size);
2589
2590          try {
2591             ((Grid)wrapper).SetItemSize( _in_size);
2592          } catch (Exception e) {
2593             Eina.Log.Warning($"Callback error: {e.ToString()}");
2594             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2595          }
2596                         } else {
2597          efl_ui_grid_item_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size);
2598       }
2599    }
2600    private static efl_ui_grid_item_size_set_delegate efl_ui_grid_item_size_set_static_delegate;
2601
2602
2603    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.GridItem, Efl.Eo.NonOwnTag>))] private delegate Efl.Ui.GridItem efl_ui_grid_last_selected_item_get_delegate(System.IntPtr obj, System.IntPtr pd);
2604
2605
2606    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.GridItem, Efl.Eo.NonOwnTag>))] public delegate Efl.Ui.GridItem efl_ui_grid_last_selected_item_get_api_delegate(System.IntPtr obj);
2607     public static Efl.Eo.FunctionWrapper<efl_ui_grid_last_selected_item_get_api_delegate> efl_ui_grid_last_selected_item_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_grid_last_selected_item_get_api_delegate>(_Module, "efl_ui_grid_last_selected_item_get");
2608     private static Efl.Ui.GridItem last_selected_item_get(System.IntPtr obj, System.IntPtr pd)
2609    {
2610       Eina.Log.Debug("function efl_ui_grid_last_selected_item_get was called");
2611       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2612       if(wrapper != null) {
2613                   Efl.Ui.GridItem _ret_var = default(Efl.Ui.GridItem);
2614          try {
2615             _ret_var = ((Grid)wrapper).GetLastSelectedItem();
2616          } catch (Exception e) {
2617             Eina.Log.Warning($"Callback error: {e.ToString()}");
2618             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2619          }
2620       return _ret_var;
2621       } else {
2622          return efl_ui_grid_last_selected_item_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2623       }
2624    }
2625    private static efl_ui_grid_last_selected_item_get_delegate efl_ui_grid_last_selected_item_get_static_delegate;
2626
2627
2628     private delegate  void efl_ui_grid_item_scroll_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.GridItem, Efl.Eo.NonOwnTag>))]  Efl.Ui.GridItem item,  [MarshalAs(UnmanagedType.U1)]  bool animation);
2629
2630
2631     public delegate  void efl_ui_grid_item_scroll_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.GridItem, Efl.Eo.NonOwnTag>))]  Efl.Ui.GridItem item,  [MarshalAs(UnmanagedType.U1)]  bool animation);
2632     public static Efl.Eo.FunctionWrapper<efl_ui_grid_item_scroll_api_delegate> efl_ui_grid_item_scroll_ptr = new Efl.Eo.FunctionWrapper<efl_ui_grid_item_scroll_api_delegate>(_Module, "efl_ui_grid_item_scroll");
2633     private static  void item_scroll(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.GridItem item,  bool animation)
2634    {
2635       Eina.Log.Debug("function efl_ui_grid_item_scroll was called");
2636       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2637       if(wrapper != null) {
2638
2639          try {
2640             ((Grid)wrapper).ItemScroll( item,  animation);
2641          } catch (Exception e) {
2642             Eina.Log.Warning($"Callback error: {e.ToString()}");
2643             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2644          }
2645                                     } else {
2646          efl_ui_grid_item_scroll_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  item,  animation);
2647       }
2648    }
2649    private static efl_ui_grid_item_scroll_delegate efl_ui_grid_item_scroll_static_delegate;
2650
2651
2652     private delegate  void efl_ui_grid_item_scroll_align_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.GridItem, Efl.Eo.NonOwnTag>))]  Efl.Ui.GridItem item,   double align,  [MarshalAs(UnmanagedType.U1)]  bool animation);
2653
2654
2655     public delegate  void efl_ui_grid_item_scroll_align_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Ui.GridItem, Efl.Eo.NonOwnTag>))]  Efl.Ui.GridItem item,   double align,  [MarshalAs(UnmanagedType.U1)]  bool animation);
2656     public static Efl.Eo.FunctionWrapper<efl_ui_grid_item_scroll_align_api_delegate> efl_ui_grid_item_scroll_align_ptr = new Efl.Eo.FunctionWrapper<efl_ui_grid_item_scroll_align_api_delegate>(_Module, "efl_ui_grid_item_scroll_align");
2657     private static  void item_scroll_align(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.GridItem item,  double align,  bool animation)
2658    {
2659       Eina.Log.Debug("function efl_ui_grid_item_scroll_align was called");
2660       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2661       if(wrapper != null) {
2662
2663          try {
2664             ((Grid)wrapper).ItemScrollAlign( item,  align,  animation);
2665          } catch (Exception e) {
2666             Eina.Log.Warning($"Callback error: {e.ToString()}");
2667             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2668          }
2669                                                 } else {
2670          efl_ui_grid_item_scroll_align_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  item,  align,  animation);
2671       }
2672    }
2673    private static efl_ui_grid_item_scroll_align_delegate efl_ui_grid_item_scroll_align_static_delegate;
2674
2675
2676     private delegate  System.IntPtr efl_ui_grid_selected_items_get_delegate(System.IntPtr obj, System.IntPtr pd);
2677
2678
2679     public delegate  System.IntPtr efl_ui_grid_selected_items_get_api_delegate(System.IntPtr obj);
2680     public static Efl.Eo.FunctionWrapper<efl_ui_grid_selected_items_get_api_delegate> efl_ui_grid_selected_items_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_grid_selected_items_get_api_delegate>(_Module, "efl_ui_grid_selected_items_get");
2681     private static  System.IntPtr selected_items_get(System.IntPtr obj, System.IntPtr pd)
2682    {
2683       Eina.Log.Debug("function efl_ui_grid_selected_items_get was called");
2684       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2685       if(wrapper != null) {
2686                   Eina.Iterator<Efl.Ui.GridItem> _ret_var = default(Eina.Iterator<Efl.Ui.GridItem>);
2687          try {
2688             _ret_var = ((Grid)wrapper).GetSelectedItems();
2689          } catch (Exception e) {
2690             Eina.Log.Warning($"Callback error: {e.ToString()}");
2691             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2692          }
2693       _ret_var.Own = false; return _ret_var.Handle;
2694       } else {
2695          return efl_ui_grid_selected_items_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2696       }
2697    }
2698    private static efl_ui_grid_selected_items_get_delegate efl_ui_grid_selected_items_get_static_delegate;
2699
2700
2701     private delegate  void efl_pack_align_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double align_horiz,   out double align_vert);
2702
2703
2704     public delegate  void efl_pack_align_get_api_delegate(System.IntPtr obj,   out double align_horiz,   out double align_vert);
2705     public static Efl.Eo.FunctionWrapper<efl_pack_align_get_api_delegate> efl_pack_align_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_align_get_api_delegate>(_Module, "efl_pack_align_get");
2706     private static  void pack_align_get(System.IntPtr obj, System.IntPtr pd,  out double align_horiz,  out double align_vert)
2707    {
2708       Eina.Log.Debug("function efl_pack_align_get was called");
2709       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2710       if(wrapper != null) {
2711                            align_horiz = default(double);      align_vert = default(double);
2712          try {
2713             ((Grid)wrapper).GetPackAlign( out align_horiz,  out align_vert);
2714          } catch (Exception e) {
2715             Eina.Log.Warning($"Callback error: {e.ToString()}");
2716             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2717          }
2718                                     } else {
2719          efl_pack_align_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out align_horiz,  out align_vert);
2720       }
2721    }
2722    private static efl_pack_align_get_delegate efl_pack_align_get_static_delegate;
2723
2724
2725     private delegate  void efl_pack_align_set_delegate(System.IntPtr obj, System.IntPtr pd,   double align_horiz,   double align_vert);
2726
2727
2728     public delegate  void efl_pack_align_set_api_delegate(System.IntPtr obj,   double align_horiz,   double align_vert);
2729     public static Efl.Eo.FunctionWrapper<efl_pack_align_set_api_delegate> efl_pack_align_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_align_set_api_delegate>(_Module, "efl_pack_align_set");
2730     private static  void pack_align_set(System.IntPtr obj, System.IntPtr pd,  double align_horiz,  double align_vert)
2731    {
2732       Eina.Log.Debug("function efl_pack_align_set was called");
2733       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2734       if(wrapper != null) {
2735
2736          try {
2737             ((Grid)wrapper).SetPackAlign( align_horiz,  align_vert);
2738          } catch (Exception e) {
2739             Eina.Log.Warning($"Callback error: {e.ToString()}");
2740             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2741          }
2742                                     } else {
2743          efl_pack_align_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  align_horiz,  align_vert);
2744       }
2745    }
2746    private static efl_pack_align_set_delegate efl_pack_align_set_static_delegate;
2747
2748
2749     private delegate  void efl_pack_padding_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double pad_horiz,   out double pad_vert,  [MarshalAs(UnmanagedType.U1)]  out bool scalable);
2750
2751
2752     public delegate  void efl_pack_padding_get_api_delegate(System.IntPtr obj,   out double pad_horiz,   out double pad_vert,  [MarshalAs(UnmanagedType.U1)]  out bool scalable);
2753     public static Efl.Eo.FunctionWrapper<efl_pack_padding_get_api_delegate> efl_pack_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_padding_get_api_delegate>(_Module, "efl_pack_padding_get");
2754     private static  void pack_padding_get(System.IntPtr obj, System.IntPtr pd,  out double pad_horiz,  out double pad_vert,  out bool scalable)
2755    {
2756       Eina.Log.Debug("function efl_pack_padding_get was called");
2757       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2758       if(wrapper != null) {
2759                                  pad_horiz = default(double);      pad_vert = default(double);      scalable = default(bool);
2760          try {
2761             ((Grid)wrapper).GetPackPadding( out pad_horiz,  out pad_vert,  out scalable);
2762          } catch (Exception e) {
2763             Eina.Log.Warning($"Callback error: {e.ToString()}");
2764             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2765          }
2766                                                 } else {
2767          efl_pack_padding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out pad_horiz,  out pad_vert,  out scalable);
2768       }
2769    }
2770    private static efl_pack_padding_get_delegate efl_pack_padding_get_static_delegate;
2771
2772
2773     private delegate  void efl_pack_padding_set_delegate(System.IntPtr obj, System.IntPtr pd,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
2774
2775
2776     public delegate  void efl_pack_padding_set_api_delegate(System.IntPtr obj,   double pad_horiz,   double pad_vert,  [MarshalAs(UnmanagedType.U1)]  bool scalable);
2777     public static Efl.Eo.FunctionWrapper<efl_pack_padding_set_api_delegate> efl_pack_padding_set_ptr = new Efl.Eo.FunctionWrapper<efl_pack_padding_set_api_delegate>(_Module, "efl_pack_padding_set");
2778     private static  void pack_padding_set(System.IntPtr obj, System.IntPtr pd,  double pad_horiz,  double pad_vert,  bool scalable)
2779    {
2780       Eina.Log.Debug("function efl_pack_padding_set was called");
2781       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2782       if(wrapper != null) {
2783
2784          try {
2785             ((Grid)wrapper).SetPackPadding( pad_horiz,  pad_vert,  scalable);
2786          } catch (Exception e) {
2787             Eina.Log.Warning($"Callback error: {e.ToString()}");
2788             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2789          }
2790                                                 } else {
2791          efl_pack_padding_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  pad_horiz,  pad_vert,  scalable);
2792       }
2793    }
2794    private static efl_pack_padding_set_delegate efl_pack_padding_set_static_delegate;
2795
2796
2797     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_clear_delegate(System.IntPtr obj, System.IntPtr pd);
2798
2799
2800     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_clear_api_delegate(System.IntPtr obj);
2801     public static Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate> efl_pack_clear_ptr = new Efl.Eo.FunctionWrapper<efl_pack_clear_api_delegate>(_Module, "efl_pack_clear");
2802     private static bool pack_clear(System.IntPtr obj, System.IntPtr pd)
2803    {
2804       Eina.Log.Debug("function efl_pack_clear was called");
2805       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2806       if(wrapper != null) {
2807                   bool _ret_var = default(bool);
2808          try {
2809             _ret_var = ((Grid)wrapper).ClearPack();
2810          } catch (Exception e) {
2811             Eina.Log.Warning($"Callback error: {e.ToString()}");
2812             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2813          }
2814       return _ret_var;
2815       } else {
2816          return efl_pack_clear_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2817       }
2818    }
2819    private static efl_pack_clear_delegate efl_pack_clear_static_delegate;
2820
2821
2822     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_all_delegate(System.IntPtr obj, System.IntPtr pd);
2823
2824
2825     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_all_api_delegate(System.IntPtr obj);
2826     public static Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate> efl_pack_unpack_all_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_all_api_delegate>(_Module, "efl_pack_unpack_all");
2827     private static bool unpack_all(System.IntPtr obj, System.IntPtr pd)
2828    {
2829       Eina.Log.Debug("function efl_pack_unpack_all was called");
2830       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2831       if(wrapper != null) {
2832                   bool _ret_var = default(bool);
2833          try {
2834             _ret_var = ((Grid)wrapper).UnpackAll();
2835          } catch (Exception e) {
2836             Eina.Log.Warning($"Callback error: {e.ToString()}");
2837             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2838          }
2839       return _ret_var;
2840       } else {
2841          return efl_pack_unpack_all_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2842       }
2843    }
2844    private static efl_pack_unpack_all_delegate efl_pack_unpack_all_static_delegate;
2845
2846
2847     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_unpack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2848
2849
2850     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_unpack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2851     public static Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate> efl_pack_unpack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_api_delegate>(_Module, "efl_pack_unpack");
2852     private static bool unpack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
2853    {
2854       Eina.Log.Debug("function efl_pack_unpack was called");
2855       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2856       if(wrapper != null) {
2857                                     bool _ret_var = default(bool);
2858          try {
2859             _ret_var = ((Grid)wrapper).Unpack( subobj);
2860          } catch (Exception e) {
2861             Eina.Log.Warning($"Callback error: {e.ToString()}");
2862             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2863          }
2864                   return _ret_var;
2865       } else {
2866          return efl_pack_unpack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
2867       }
2868    }
2869    private static efl_pack_unpack_delegate efl_pack_unpack_static_delegate;
2870
2871
2872     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2873
2874
2875     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2876     public static Efl.Eo.FunctionWrapper<efl_pack_api_delegate> efl_pack_ptr = new Efl.Eo.FunctionWrapper<efl_pack_api_delegate>(_Module, "efl_pack");
2877     private static bool pack(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
2878    {
2879       Eina.Log.Debug("function efl_pack was called");
2880       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2881       if(wrapper != null) {
2882                                     bool _ret_var = default(bool);
2883          try {
2884             _ret_var = ((Grid)wrapper).DoPack( subobj);
2885          } catch (Exception e) {
2886             Eina.Log.Warning($"Callback error: {e.ToString()}");
2887             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2888          }
2889                   return _ret_var;
2890       } else {
2891          return efl_pack_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
2892       }
2893    }
2894    private static efl_pack_delegate efl_pack_static_delegate;
2895
2896
2897     private delegate  void efl_pack_layout_request_delegate(System.IntPtr obj, System.IntPtr pd);
2898
2899
2900     public delegate  void efl_pack_layout_request_api_delegate(System.IntPtr obj);
2901     public static Efl.Eo.FunctionWrapper<efl_pack_layout_request_api_delegate> efl_pack_layout_request_ptr = new Efl.Eo.FunctionWrapper<efl_pack_layout_request_api_delegate>(_Module, "efl_pack_layout_request");
2902     private static  void layout_request(System.IntPtr obj, System.IntPtr pd)
2903    {
2904       Eina.Log.Debug("function efl_pack_layout_request was called");
2905       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2906       if(wrapper != null) {
2907
2908          try {
2909             ((Grid)wrapper).LayoutRequest();
2910          } catch (Exception e) {
2911             Eina.Log.Warning($"Callback error: {e.ToString()}");
2912             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2913          }
2914             } else {
2915          efl_pack_layout_request_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2916       }
2917    }
2918    private static efl_pack_layout_request_delegate efl_pack_layout_request_static_delegate;
2919
2920
2921     private delegate  void efl_pack_layout_update_delegate(System.IntPtr obj, System.IntPtr pd);
2922
2923
2924     public delegate  void efl_pack_layout_update_api_delegate(System.IntPtr obj);
2925     public static Efl.Eo.FunctionWrapper<efl_pack_layout_update_api_delegate> efl_pack_layout_update_ptr = new Efl.Eo.FunctionWrapper<efl_pack_layout_update_api_delegate>(_Module, "efl_pack_layout_update");
2926     private static  void layout_update(System.IntPtr obj, System.IntPtr pd)
2927    {
2928       Eina.Log.Debug("function efl_pack_layout_update was called");
2929       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2930       if(wrapper != null) {
2931
2932          try {
2933             ((Grid)wrapper).UpdateLayout();
2934          } catch (Exception e) {
2935             Eina.Log.Warning($"Callback error: {e.ToString()}");
2936             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2937          }
2938             } else {
2939          efl_pack_layout_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2940       }
2941    }
2942    private static efl_pack_layout_update_delegate efl_pack_layout_update_static_delegate;
2943
2944
2945     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_begin_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2946
2947
2948     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_begin_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2949     public static Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate> efl_pack_begin_ptr = new Efl.Eo.FunctionWrapper<efl_pack_begin_api_delegate>(_Module, "efl_pack_begin");
2950     private static bool pack_begin(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
2951    {
2952       Eina.Log.Debug("function efl_pack_begin was called");
2953       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2954       if(wrapper != null) {
2955                                     bool _ret_var = default(bool);
2956          try {
2957             _ret_var = ((Grid)wrapper).PackBegin( subobj);
2958          } catch (Exception e) {
2959             Eina.Log.Warning($"Callback error: {e.ToString()}");
2960             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2961          }
2962                   return _ret_var;
2963       } else {
2964          return efl_pack_begin_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
2965       }
2966    }
2967    private static efl_pack_begin_delegate efl_pack_begin_static_delegate;
2968
2969
2970     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_end_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2971
2972
2973     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_end_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
2974     public static Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate> efl_pack_end_ptr = new Efl.Eo.FunctionWrapper<efl_pack_end_api_delegate>(_Module, "efl_pack_end");
2975     private static bool pack_end(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
2976    {
2977       Eina.Log.Debug("function efl_pack_end was called");
2978       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
2979       if(wrapper != null) {
2980                                     bool _ret_var = default(bool);
2981          try {
2982             _ret_var = ((Grid)wrapper).PackEnd( subobj);
2983          } catch (Exception e) {
2984             Eina.Log.Warning($"Callback error: {e.ToString()}");
2985             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2986          }
2987                   return _ret_var;
2988       } else {
2989          return efl_pack_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
2990       }
2991    }
2992    private static efl_pack_end_delegate efl_pack_end_static_delegate;
2993
2994
2995     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_before_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
2996
2997
2998     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_before_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
2999     public static Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate> efl_pack_before_ptr = new Efl.Eo.FunctionWrapper<efl_pack_before_api_delegate>(_Module, "efl_pack_before");
3000     private static bool pack_before(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
3001    {
3002       Eina.Log.Debug("function efl_pack_before was called");
3003       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3004       if(wrapper != null) {
3005                                                       bool _ret_var = default(bool);
3006          try {
3007             _ret_var = ((Grid)wrapper).PackBefore( subobj,  existing);
3008          } catch (Exception e) {
3009             Eina.Log.Warning($"Callback error: {e.ToString()}");
3010             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3011          }
3012                               return _ret_var;
3013       } else {
3014          return efl_pack_before_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
3015       }
3016    }
3017    private static efl_pack_before_delegate efl_pack_before_static_delegate;
3018
3019
3020     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_after_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
3021
3022
3023     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_after_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity existing);
3024     public static Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate> efl_pack_after_ptr = new Efl.Eo.FunctionWrapper<efl_pack_after_api_delegate>(_Module, "efl_pack_after");
3025     private static bool pack_after(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,  Efl.Gfx.Entity existing)
3026    {
3027       Eina.Log.Debug("function efl_pack_after was called");
3028       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3029       if(wrapper != null) {
3030                                                       bool _ret_var = default(bool);
3031          try {
3032             _ret_var = ((Grid)wrapper).PackAfter( subobj,  existing);
3033          } catch (Exception e) {
3034             Eina.Log.Warning($"Callback error: {e.ToString()}");
3035             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3036          }
3037                               return _ret_var;
3038       } else {
3039          return efl_pack_after_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  existing);
3040       }
3041    }
3042    private static efl_pack_after_delegate efl_pack_after_static_delegate;
3043
3044
3045     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_pack_at_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj,    int index);
3046
3047
3048     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_pack_at_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj,    int index);
3049     public static Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate> efl_pack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_at_api_delegate>(_Module, "efl_pack_at");
3050     private static bool pack_at(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj,   int index)
3051    {
3052       Eina.Log.Debug("function efl_pack_at was called");
3053       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3054       if(wrapper != null) {
3055                                                       bool _ret_var = default(bool);
3056          try {
3057             _ret_var = ((Grid)wrapper).PackAt( subobj,  index);
3058          } catch (Exception e) {
3059             Eina.Log.Warning($"Callback error: {e.ToString()}");
3060             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3061          }
3062                               return _ret_var;
3063       } else {
3064          return efl_pack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj,  index);
3065       }
3066    }
3067    private static efl_pack_at_delegate efl_pack_at_static_delegate;
3068
3069
3070    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_pack_content_get_delegate(System.IntPtr obj, System.IntPtr pd,    int index);
3071
3072
3073    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_pack_content_get_api_delegate(System.IntPtr obj,    int index);
3074     public static Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate> efl_pack_content_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_content_get_api_delegate>(_Module, "efl_pack_content_get");
3075     private static Efl.Gfx.Entity pack_content_get(System.IntPtr obj, System.IntPtr pd,   int index)
3076    {
3077       Eina.Log.Debug("function efl_pack_content_get was called");
3078       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3079       if(wrapper != null) {
3080                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
3081          try {
3082             _ret_var = ((Grid)wrapper).GetPackContent( index);
3083          } catch (Exception e) {
3084             Eina.Log.Warning($"Callback error: {e.ToString()}");
3085             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3086          }
3087                   return _ret_var;
3088       } else {
3089          return efl_pack_content_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
3090       }
3091    }
3092    private static efl_pack_content_get_delegate efl_pack_content_get_static_delegate;
3093
3094
3095     private delegate  int efl_pack_index_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
3096
3097
3098     public delegate  int efl_pack_index_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.Entity subobj);
3099     public static Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate> efl_pack_index_get_ptr = new Efl.Eo.FunctionWrapper<efl_pack_index_get_api_delegate>(_Module, "efl_pack_index_get");
3100     private static  int pack_index_get(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Entity subobj)
3101    {
3102       Eina.Log.Debug("function efl_pack_index_get was called");
3103       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3104       if(wrapper != null) {
3105                                      int _ret_var = default( int);
3106          try {
3107             _ret_var = ((Grid)wrapper).GetPackIndex( subobj);
3108          } catch (Exception e) {
3109             Eina.Log.Warning($"Callback error: {e.ToString()}");
3110             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3111          }
3112                   return _ret_var;
3113       } else {
3114          return efl_pack_index_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  subobj);
3115       }
3116    }
3117    private static efl_pack_index_get_delegate efl_pack_index_get_static_delegate;
3118
3119
3120    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] private delegate Efl.Gfx.Entity efl_pack_unpack_at_delegate(System.IntPtr obj, System.IntPtr pd,    int index);
3121
3122
3123    [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.EntityConcrete, Efl.Eo.NonOwnTag>))] public delegate Efl.Gfx.Entity efl_pack_unpack_at_api_delegate(System.IntPtr obj,    int index);
3124     public static Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate> efl_pack_unpack_at_ptr = new Efl.Eo.FunctionWrapper<efl_pack_unpack_at_api_delegate>(_Module, "efl_pack_unpack_at");
3125     private static Efl.Gfx.Entity pack_unpack_at(System.IntPtr obj, System.IntPtr pd,   int index)
3126    {
3127       Eina.Log.Debug("function efl_pack_unpack_at was called");
3128       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3129       if(wrapper != null) {
3130                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
3131          try {
3132             _ret_var = ((Grid)wrapper).PackUnpackAt( index);
3133          } catch (Exception e) {
3134             Eina.Log.Warning($"Callback error: {e.ToString()}");
3135             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3136          }
3137                   return _ret_var;
3138       } else {
3139          return efl_pack_unpack_at_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  index);
3140       }
3141    }
3142    private static efl_pack_unpack_at_delegate efl_pack_unpack_at_static_delegate;
3143
3144
3145     private delegate Efl.Ui.Dir efl_ui_direction_get_delegate(System.IntPtr obj, System.IntPtr pd);
3146
3147
3148     public delegate Efl.Ui.Dir efl_ui_direction_get_api_delegate(System.IntPtr obj);
3149     public static Efl.Eo.FunctionWrapper<efl_ui_direction_get_api_delegate> efl_ui_direction_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_direction_get_api_delegate>(_Module, "efl_ui_direction_get");
3150     private static Efl.Ui.Dir direction_get(System.IntPtr obj, System.IntPtr pd)
3151    {
3152       Eina.Log.Debug("function efl_ui_direction_get was called");
3153       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3154       if(wrapper != null) {
3155                   Efl.Ui.Dir _ret_var = default(Efl.Ui.Dir);
3156          try {
3157             _ret_var = ((Grid)wrapper).GetDirection();
3158          } catch (Exception e) {
3159             Eina.Log.Warning($"Callback error: {e.ToString()}");
3160             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3161          }
3162       return _ret_var;
3163       } else {
3164          return efl_ui_direction_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3165       }
3166    }
3167    private static efl_ui_direction_get_delegate efl_ui_direction_get_static_delegate;
3168
3169
3170     private delegate  void efl_ui_direction_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.Dir dir);
3171
3172
3173     public delegate  void efl_ui_direction_set_api_delegate(System.IntPtr obj,   Efl.Ui.Dir dir);
3174     public static Efl.Eo.FunctionWrapper<efl_ui_direction_set_api_delegate> efl_ui_direction_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_direction_set_api_delegate>(_Module, "efl_ui_direction_set");
3175     private static  void direction_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.Dir dir)
3176    {
3177       Eina.Log.Debug("function efl_ui_direction_set was called");
3178       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3179       if(wrapper != null) {
3180
3181          try {
3182             ((Grid)wrapper).SetDirection( dir);
3183          } catch (Exception e) {
3184             Eina.Log.Warning($"Callback error: {e.ToString()}");
3185             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3186          }
3187                         } else {
3188          efl_ui_direction_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir);
3189       }
3190    }
3191    private static efl_ui_direction_set_delegate efl_ui_direction_set_static_delegate;
3192
3193
3194     private delegate Efl.Ui.SelectMode efl_ui_select_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
3195
3196
3197     public delegate Efl.Ui.SelectMode efl_ui_select_mode_get_api_delegate(System.IntPtr obj);
3198     public static Efl.Eo.FunctionWrapper<efl_ui_select_mode_get_api_delegate> efl_ui_select_mode_get_ptr = new Efl.Eo.FunctionWrapper<efl_ui_select_mode_get_api_delegate>(_Module, "efl_ui_select_mode_get");
3199     private static Efl.Ui.SelectMode select_mode_get(System.IntPtr obj, System.IntPtr pd)
3200    {
3201       Eina.Log.Debug("function efl_ui_select_mode_get was called");
3202       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3203       if(wrapper != null) {
3204                   Efl.Ui.SelectMode _ret_var = default(Efl.Ui.SelectMode);
3205          try {
3206             _ret_var = ((Grid)wrapper).GetSelectMode();
3207          } catch (Exception e) {
3208             Eina.Log.Warning($"Callback error: {e.ToString()}");
3209             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3210          }
3211       return _ret_var;
3212       } else {
3213          return efl_ui_select_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3214       }
3215    }
3216    private static efl_ui_select_mode_get_delegate efl_ui_select_mode_get_static_delegate;
3217
3218
3219     private delegate  void efl_ui_select_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.SelectMode mode);
3220
3221
3222     public delegate  void efl_ui_select_mode_set_api_delegate(System.IntPtr obj,   Efl.Ui.SelectMode mode);
3223     public static Efl.Eo.FunctionWrapper<efl_ui_select_mode_set_api_delegate> efl_ui_select_mode_set_ptr = new Efl.Eo.FunctionWrapper<efl_ui_select_mode_set_api_delegate>(_Module, "efl_ui_select_mode_set");
3224     private static  void select_mode_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.SelectMode mode)
3225    {
3226       Eina.Log.Debug("function efl_ui_select_mode_set was called");
3227       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3228       if(wrapper != null) {
3229
3230          try {
3231             ((Grid)wrapper).SetSelectMode( mode);
3232          } catch (Exception e) {
3233             Eina.Log.Warning($"Callback error: {e.ToString()}");
3234             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3235          }
3236                         } else {
3237          efl_ui_select_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  mode);
3238       }
3239    }
3240    private static efl_ui_select_mode_set_delegate efl_ui_select_mode_set_static_delegate;
3241
3242
3243     private delegate Eina.Position2D_StructInternal efl_ui_scrollable_content_pos_get_delegate(System.IntPtr obj, System.IntPtr pd);
3244
3245
3246     public delegate Eina.Position2D_StructInternal efl_ui_scrollable_content_pos_get_api_delegate(System.IntPtr obj);
3247     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");
3248     private static Eina.Position2D_StructInternal content_pos_get(System.IntPtr obj, System.IntPtr pd)
3249    {
3250       Eina.Log.Debug("function efl_ui_scrollable_content_pos_get was called");
3251       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3252       if(wrapper != null) {
3253                   Eina.Position2D _ret_var = default(Eina.Position2D);
3254          try {
3255             _ret_var = ((Grid)wrapper).GetContentPos();
3256          } catch (Exception e) {
3257             Eina.Log.Warning($"Callback error: {e.ToString()}");
3258             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3259          }
3260       return Eina.Position2D_StructConversion.ToInternal(_ret_var);
3261       } else {
3262          return efl_ui_scrollable_content_pos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3263       }
3264    }
3265    private static efl_ui_scrollable_content_pos_get_delegate efl_ui_scrollable_content_pos_get_static_delegate;
3266
3267
3268     private delegate  void efl_ui_scrollable_content_pos_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Position2D_StructInternal pos);
3269
3270
3271     public delegate  void efl_ui_scrollable_content_pos_set_api_delegate(System.IntPtr obj,   Eina.Position2D_StructInternal pos);
3272     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");
3273     private static  void content_pos_set(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D_StructInternal pos)
3274    {
3275       Eina.Log.Debug("function efl_ui_scrollable_content_pos_set was called");
3276       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3277       if(wrapper != null) {
3278                var _in_pos = Eina.Position2D_StructConversion.ToManaged(pos);
3279
3280          try {
3281             ((Grid)wrapper).SetContentPos( _in_pos);
3282          } catch (Exception e) {
3283             Eina.Log.Warning($"Callback error: {e.ToString()}");
3284             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3285          }
3286                         } else {
3287          efl_ui_scrollable_content_pos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  pos);
3288       }
3289    }
3290    private static efl_ui_scrollable_content_pos_set_delegate efl_ui_scrollable_content_pos_set_static_delegate;
3291
3292
3293     private delegate Eina.Size2D_StructInternal efl_ui_scrollable_content_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
3294
3295
3296     public delegate Eina.Size2D_StructInternal efl_ui_scrollable_content_size_get_api_delegate(System.IntPtr obj);
3297     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");
3298     private static Eina.Size2D_StructInternal content_size_get(System.IntPtr obj, System.IntPtr pd)
3299    {
3300       Eina.Log.Debug("function efl_ui_scrollable_content_size_get was called");
3301       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3302       if(wrapper != null) {
3303                   Eina.Size2D _ret_var = default(Eina.Size2D);
3304          try {
3305             _ret_var = ((Grid)wrapper).GetContentSize();
3306          } catch (Exception e) {
3307             Eina.Log.Warning($"Callback error: {e.ToString()}");
3308             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3309          }
3310       return Eina.Size2D_StructConversion.ToInternal(_ret_var);
3311       } else {
3312          return efl_ui_scrollable_content_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3313       }
3314    }
3315    private static efl_ui_scrollable_content_size_get_delegate efl_ui_scrollable_content_size_get_static_delegate;
3316
3317
3318     private delegate Eina.Rect_StructInternal efl_ui_scrollable_viewport_geometry_get_delegate(System.IntPtr obj, System.IntPtr pd);
3319
3320
3321     public delegate Eina.Rect_StructInternal efl_ui_scrollable_viewport_geometry_get_api_delegate(System.IntPtr obj);
3322     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");
3323     private static Eina.Rect_StructInternal viewport_geometry_get(System.IntPtr obj, System.IntPtr pd)
3324    {
3325       Eina.Log.Debug("function efl_ui_scrollable_viewport_geometry_get was called");
3326       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3327       if(wrapper != null) {
3328                   Eina.Rect _ret_var = default(Eina.Rect);
3329          try {
3330             _ret_var = ((Grid)wrapper).GetViewportGeometry();
3331          } catch (Exception e) {
3332             Eina.Log.Warning($"Callback error: {e.ToString()}");
3333             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3334          }
3335       return Eina.Rect_StructConversion.ToInternal(_ret_var);
3336       } else {
3337          return efl_ui_scrollable_viewport_geometry_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3338       }
3339    }
3340    private static efl_ui_scrollable_viewport_geometry_get_delegate efl_ui_scrollable_viewport_geometry_get_static_delegate;
3341
3342
3343     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);
3344
3345
3346     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);
3347     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");
3348     private static  void bounce_enabled_get(System.IntPtr obj, System.IntPtr pd,  out bool horiz,  out bool vert)
3349    {
3350       Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_get was called");
3351       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3352       if(wrapper != null) {
3353                            horiz = default(bool);      vert = default(bool);
3354          try {
3355             ((Grid)wrapper).GetBounceEnabled( out horiz,  out vert);
3356          } catch (Exception e) {
3357             Eina.Log.Warning($"Callback error: {e.ToString()}");
3358             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3359          }
3360                                     } else {
3361          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);
3362       }
3363    }
3364    private static efl_ui_scrollable_bounce_enabled_get_delegate efl_ui_scrollable_bounce_enabled_get_static_delegate;
3365
3366
3367     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);
3368
3369
3370     public delegate  void efl_ui_scrollable_bounce_enabled_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool horiz,  [MarshalAs(UnmanagedType.U1)]  bool vert);
3371     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");
3372     private static  void bounce_enabled_set(System.IntPtr obj, System.IntPtr pd,  bool horiz,  bool vert)
3373    {
3374       Eina.Log.Debug("function efl_ui_scrollable_bounce_enabled_set was called");
3375       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3376       if(wrapper != null) {
3377
3378          try {
3379             ((Grid)wrapper).SetBounceEnabled( horiz,  vert);
3380          } catch (Exception e) {
3381             Eina.Log.Warning($"Callback error: {e.ToString()}");
3382             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3383          }
3384                                     } else {
3385          efl_ui_scrollable_bounce_enabled_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  horiz,  vert);
3386       }
3387    }
3388    private static efl_ui_scrollable_bounce_enabled_set_delegate efl_ui_scrollable_bounce_enabled_set_static_delegate;
3389
3390
3391     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_scrollable_scroll_freeze_get_delegate(System.IntPtr obj, System.IntPtr pd);
3392
3393
3394     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_scrollable_scroll_freeze_get_api_delegate(System.IntPtr obj);
3395     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");
3396     private static bool scroll_freeze_get(System.IntPtr obj, System.IntPtr pd)
3397    {
3398       Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_get was called");
3399       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3400       if(wrapper != null) {
3401                   bool _ret_var = default(bool);
3402          try {
3403             _ret_var = ((Grid)wrapper).GetScrollFreeze();
3404          } catch (Exception e) {
3405             Eina.Log.Warning($"Callback error: {e.ToString()}");
3406             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3407          }
3408       return _ret_var;
3409       } else {
3410          return efl_ui_scrollable_scroll_freeze_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3411       }
3412    }
3413    private static efl_ui_scrollable_scroll_freeze_get_delegate efl_ui_scrollable_scroll_freeze_get_static_delegate;
3414
3415
3416     private delegate  void efl_ui_scrollable_scroll_freeze_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool freeze);
3417
3418
3419     public delegate  void efl_ui_scrollable_scroll_freeze_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool freeze);
3420     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");
3421     private static  void scroll_freeze_set(System.IntPtr obj, System.IntPtr pd,  bool freeze)
3422    {
3423       Eina.Log.Debug("function efl_ui_scrollable_scroll_freeze_set was called");
3424       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3425       if(wrapper != null) {
3426
3427          try {
3428             ((Grid)wrapper).SetScrollFreeze( freeze);
3429          } catch (Exception e) {
3430             Eina.Log.Warning($"Callback error: {e.ToString()}");
3431             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3432          }
3433                         } else {
3434          efl_ui_scrollable_scroll_freeze_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  freeze);
3435       }
3436    }
3437    private static efl_ui_scrollable_scroll_freeze_set_delegate efl_ui_scrollable_scroll_freeze_set_static_delegate;
3438
3439
3440     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_ui_scrollable_scroll_hold_get_delegate(System.IntPtr obj, System.IntPtr pd);
3441
3442
3443     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_ui_scrollable_scroll_hold_get_api_delegate(System.IntPtr obj);
3444     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");
3445     private static bool scroll_hold_get(System.IntPtr obj, System.IntPtr pd)
3446    {
3447       Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_get was called");
3448       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3449       if(wrapper != null) {
3450                   bool _ret_var = default(bool);
3451          try {
3452             _ret_var = ((Grid)wrapper).GetScrollHold();
3453          } catch (Exception e) {
3454             Eina.Log.Warning($"Callback error: {e.ToString()}");
3455             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3456          }
3457       return _ret_var;
3458       } else {
3459          return efl_ui_scrollable_scroll_hold_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3460       }
3461    }
3462    private static efl_ui_scrollable_scroll_hold_get_delegate efl_ui_scrollable_scroll_hold_get_static_delegate;
3463
3464
3465     private delegate  void efl_ui_scrollable_scroll_hold_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool hold);
3466
3467
3468     public delegate  void efl_ui_scrollable_scroll_hold_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool hold);
3469     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");
3470     private static  void scroll_hold_set(System.IntPtr obj, System.IntPtr pd,  bool hold)
3471    {
3472       Eina.Log.Debug("function efl_ui_scrollable_scroll_hold_set was called");
3473       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3474       if(wrapper != null) {
3475
3476          try {
3477             ((Grid)wrapper).SetScrollHold( hold);
3478          } catch (Exception e) {
3479             Eina.Log.Warning($"Callback error: {e.ToString()}");
3480             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3481          }
3482                         } else {
3483          efl_ui_scrollable_scroll_hold_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  hold);
3484       }
3485    }
3486    private static efl_ui_scrollable_scroll_hold_set_delegate efl_ui_scrollable_scroll_hold_set_static_delegate;
3487
3488
3489     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);
3490
3491
3492     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);
3493     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");
3494     private static  void looping_get(System.IntPtr obj, System.IntPtr pd,  out bool loop_h,  out bool loop_v)
3495    {
3496       Eina.Log.Debug("function efl_ui_scrollable_looping_get was called");
3497       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3498       if(wrapper != null) {
3499                            loop_h = default(bool);      loop_v = default(bool);
3500          try {
3501             ((Grid)wrapper).GetLooping( out loop_h,  out loop_v);
3502          } catch (Exception e) {
3503             Eina.Log.Warning($"Callback error: {e.ToString()}");
3504             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3505          }
3506                                     } else {
3507          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);
3508       }
3509    }
3510    private static efl_ui_scrollable_looping_get_delegate efl_ui_scrollable_looping_get_static_delegate;
3511
3512
3513     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);
3514
3515
3516     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);
3517     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");
3518     private static  void looping_set(System.IntPtr obj, System.IntPtr pd,  bool loop_h,  bool loop_v)
3519    {
3520       Eina.Log.Debug("function efl_ui_scrollable_looping_set was called");
3521       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3522       if(wrapper != null) {
3523
3524          try {
3525             ((Grid)wrapper).SetLooping( loop_h,  loop_v);
3526          } catch (Exception e) {
3527             Eina.Log.Warning($"Callback error: {e.ToString()}");
3528             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3529          }
3530                                     } else {
3531          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);
3532       }
3533    }
3534    private static efl_ui_scrollable_looping_set_delegate efl_ui_scrollable_looping_set_static_delegate;
3535
3536
3537     private delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_delegate(System.IntPtr obj, System.IntPtr pd);
3538
3539
3540     public delegate Efl.Ui.ScrollBlock efl_ui_scrollable_movement_block_get_api_delegate(System.IntPtr obj);
3541     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");
3542     private static Efl.Ui.ScrollBlock movement_block_get(System.IntPtr obj, System.IntPtr pd)
3543    {
3544       Eina.Log.Debug("function efl_ui_scrollable_movement_block_get was called");
3545       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3546       if(wrapper != null) {
3547                   Efl.Ui.ScrollBlock _ret_var = default(Efl.Ui.ScrollBlock);
3548          try {
3549             _ret_var = ((Grid)wrapper).GetMovementBlock();
3550          } catch (Exception e) {
3551             Eina.Log.Warning($"Callback error: {e.ToString()}");
3552             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3553          }
3554       return _ret_var;
3555       } else {
3556          return efl_ui_scrollable_movement_block_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3557       }
3558    }
3559    private static efl_ui_scrollable_movement_block_get_delegate efl_ui_scrollable_movement_block_get_static_delegate;
3560
3561
3562     private delegate  void efl_ui_scrollable_movement_block_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.ScrollBlock block);
3563
3564
3565     public delegate  void efl_ui_scrollable_movement_block_set_api_delegate(System.IntPtr obj,   Efl.Ui.ScrollBlock block);
3566     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");
3567     private static  void movement_block_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollBlock block)
3568    {
3569       Eina.Log.Debug("function efl_ui_scrollable_movement_block_set was called");
3570       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3571       if(wrapper != null) {
3572
3573          try {
3574             ((Grid)wrapper).SetMovementBlock( block);
3575          } catch (Exception e) {
3576             Eina.Log.Warning($"Callback error: {e.ToString()}");
3577             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3578          }
3579                         } else {
3580          efl_ui_scrollable_movement_block_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  block);
3581       }
3582    }
3583    private static efl_ui_scrollable_movement_block_set_delegate efl_ui_scrollable_movement_block_set_static_delegate;
3584
3585
3586     private delegate  void efl_ui_scrollable_gravity_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
3587
3588
3589     public delegate  void efl_ui_scrollable_gravity_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
3590     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");
3591     private static  void gravity_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
3592    {
3593       Eina.Log.Debug("function efl_ui_scrollable_gravity_get was called");
3594       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3595       if(wrapper != null) {
3596                            x = default(double);      y = default(double);
3597          try {
3598             ((Grid)wrapper).GetGravity( out x,  out y);
3599          } catch (Exception e) {
3600             Eina.Log.Warning($"Callback error: {e.ToString()}");
3601             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3602          }
3603                                     } else {
3604          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);
3605       }
3606    }
3607    private static efl_ui_scrollable_gravity_get_delegate efl_ui_scrollable_gravity_get_static_delegate;
3608
3609
3610     private delegate  void efl_ui_scrollable_gravity_set_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
3611
3612
3613     public delegate  void efl_ui_scrollable_gravity_set_api_delegate(System.IntPtr obj,   double x,   double y);
3614     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");
3615     private static  void gravity_set(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
3616    {
3617       Eina.Log.Debug("function efl_ui_scrollable_gravity_set was called");
3618       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3619       if(wrapper != null) {
3620
3621          try {
3622             ((Grid)wrapper).SetGravity( x,  y);
3623          } catch (Exception e) {
3624             Eina.Log.Warning($"Callback error: {e.ToString()}");
3625             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3626          }
3627                                     } else {
3628          efl_ui_scrollable_gravity_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
3629       }
3630    }
3631    private static efl_ui_scrollable_gravity_set_delegate efl_ui_scrollable_gravity_set_static_delegate;
3632
3633
3634     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);
3635
3636
3637     public delegate  void efl_ui_scrollable_match_content_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool w,  [MarshalAs(UnmanagedType.U1)]  bool h);
3638     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");
3639     private static  void match_content_set(System.IntPtr obj, System.IntPtr pd,  bool w,  bool h)
3640    {
3641       Eina.Log.Debug("function efl_ui_scrollable_match_content_set was called");
3642       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3643       if(wrapper != null) {
3644
3645          try {
3646             ((Grid)wrapper).SetMatchContent( w,  h);
3647          } catch (Exception e) {
3648             Eina.Log.Warning($"Callback error: {e.ToString()}");
3649             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3650          }
3651                                     } else {
3652          efl_ui_scrollable_match_content_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  w,  h);
3653       }
3654    }
3655    private static efl_ui_scrollable_match_content_set_delegate efl_ui_scrollable_match_content_set_static_delegate;
3656
3657
3658     private delegate Eina.Position2D_StructInternal efl_ui_scrollable_step_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
3659
3660
3661     public delegate Eina.Position2D_StructInternal efl_ui_scrollable_step_size_get_api_delegate(System.IntPtr obj);
3662     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");
3663     private static Eina.Position2D_StructInternal step_size_get(System.IntPtr obj, System.IntPtr pd)
3664    {
3665       Eina.Log.Debug("function efl_ui_scrollable_step_size_get was called");
3666       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3667       if(wrapper != null) {
3668                   Eina.Position2D _ret_var = default(Eina.Position2D);
3669          try {
3670             _ret_var = ((Grid)wrapper).GetStepSize();
3671          } catch (Exception e) {
3672             Eina.Log.Warning($"Callback error: {e.ToString()}");
3673             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3674          }
3675       return Eina.Position2D_StructConversion.ToInternal(_ret_var);
3676       } else {
3677          return efl_ui_scrollable_step_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3678       }
3679    }
3680    private static efl_ui_scrollable_step_size_get_delegate efl_ui_scrollable_step_size_get_static_delegate;
3681
3682
3683     private delegate  void efl_ui_scrollable_step_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Position2D_StructInternal step);
3684
3685
3686     public delegate  void efl_ui_scrollable_step_size_set_api_delegate(System.IntPtr obj,   Eina.Position2D_StructInternal step);
3687     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");
3688     private static  void step_size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Position2D_StructInternal step)
3689    {
3690       Eina.Log.Debug("function efl_ui_scrollable_step_size_set was called");
3691       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3692       if(wrapper != null) {
3693                var _in_step = Eina.Position2D_StructConversion.ToManaged(step);
3694
3695          try {
3696             ((Grid)wrapper).SetStepSize( _in_step);
3697          } catch (Exception e) {
3698             Eina.Log.Warning($"Callback error: {e.ToString()}");
3699             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3700          }
3701                         } else {
3702          efl_ui_scrollable_step_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  step);
3703       }
3704    }
3705    private static efl_ui_scrollable_step_size_set_delegate efl_ui_scrollable_step_size_set_static_delegate;
3706
3707
3708     private delegate  void efl_ui_scrollable_scroll_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Rect_StructInternal rect,  [MarshalAs(UnmanagedType.U1)]  bool animation);
3709
3710
3711     public delegate  void efl_ui_scrollable_scroll_api_delegate(System.IntPtr obj,   Eina.Rect_StructInternal rect,  [MarshalAs(UnmanagedType.U1)]  bool animation);
3712     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");
3713     private static  void scroll(System.IntPtr obj, System.IntPtr pd,  Eina.Rect_StructInternal rect,  bool animation)
3714    {
3715       Eina.Log.Debug("function efl_ui_scrollable_scroll was called");
3716       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3717       if(wrapper != null) {
3718                var _in_rect = Eina.Rect_StructConversion.ToManaged(rect);
3719
3720          try {
3721             ((Grid)wrapper).Scroll( _in_rect,  animation);
3722          } catch (Exception e) {
3723             Eina.Log.Warning($"Callback error: {e.ToString()}");
3724             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3725          }
3726                                     } else {
3727          efl_ui_scrollable_scroll_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  rect,  animation);
3728       }
3729    }
3730    private static efl_ui_scrollable_scroll_delegate efl_ui_scrollable_scroll_static_delegate;
3731
3732
3733     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);
3734
3735
3736     public delegate  void efl_ui_scrollbar_bar_mode_get_api_delegate(System.IntPtr obj,   out Efl.Ui.ScrollbarMode hbar,   out Efl.Ui.ScrollbarMode vbar);
3737     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");
3738     private static  void bar_mode_get(System.IntPtr obj, System.IntPtr pd,  out Efl.Ui.ScrollbarMode hbar,  out Efl.Ui.ScrollbarMode vbar)
3739    {
3740       Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_get was called");
3741       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3742       if(wrapper != null) {
3743                            hbar = default(Efl.Ui.ScrollbarMode);      vbar = default(Efl.Ui.ScrollbarMode);
3744          try {
3745             ((Grid)wrapper).GetBarMode( out hbar,  out vbar);
3746          } catch (Exception e) {
3747             Eina.Log.Warning($"Callback error: {e.ToString()}");
3748             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3749          }
3750                                     } else {
3751          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);
3752       }
3753    }
3754    private static efl_ui_scrollbar_bar_mode_get_delegate efl_ui_scrollbar_bar_mode_get_static_delegate;
3755
3756
3757     private delegate  void efl_ui_scrollbar_bar_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Ui.ScrollbarMode hbar,   Efl.Ui.ScrollbarMode vbar);
3758
3759
3760     public delegate  void efl_ui_scrollbar_bar_mode_set_api_delegate(System.IntPtr obj,   Efl.Ui.ScrollbarMode hbar,   Efl.Ui.ScrollbarMode vbar);
3761     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");
3762     private static  void bar_mode_set(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ScrollbarMode hbar,  Efl.Ui.ScrollbarMode vbar)
3763    {
3764       Eina.Log.Debug("function efl_ui_scrollbar_bar_mode_set was called");
3765       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3766       if(wrapper != null) {
3767
3768          try {
3769             ((Grid)wrapper).SetBarMode( hbar,  vbar);
3770          } catch (Exception e) {
3771             Eina.Log.Warning($"Callback error: {e.ToString()}");
3772             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3773          }
3774                                     } else {
3775          efl_ui_scrollbar_bar_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  hbar,  vbar);
3776       }
3777    }
3778    private static efl_ui_scrollbar_bar_mode_set_delegate efl_ui_scrollbar_bar_mode_set_static_delegate;
3779
3780
3781     private delegate  void efl_ui_scrollbar_bar_size_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double width,   out double height);
3782
3783
3784     public delegate  void efl_ui_scrollbar_bar_size_get_api_delegate(System.IntPtr obj,   out double width,   out double height);
3785     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");
3786     private static  void bar_size_get(System.IntPtr obj, System.IntPtr pd,  out double width,  out double height)
3787    {
3788       Eina.Log.Debug("function efl_ui_scrollbar_bar_size_get was called");
3789       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3790       if(wrapper != null) {
3791                            width = default(double);      height = default(double);
3792          try {
3793             ((Grid)wrapper).GetBarSize( out width,  out height);
3794          } catch (Exception e) {
3795             Eina.Log.Warning($"Callback error: {e.ToString()}");
3796             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3797          }
3798                                     } else {
3799          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);
3800       }
3801    }
3802    private static efl_ui_scrollbar_bar_size_get_delegate efl_ui_scrollbar_bar_size_get_static_delegate;
3803
3804
3805     private delegate  void efl_ui_scrollbar_bar_position_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double posx,   out double posy);
3806
3807
3808     public delegate  void efl_ui_scrollbar_bar_position_get_api_delegate(System.IntPtr obj,   out double posx,   out double posy);
3809     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");
3810     private static  void bar_position_get(System.IntPtr obj, System.IntPtr pd,  out double posx,  out double posy)
3811    {
3812       Eina.Log.Debug("function efl_ui_scrollbar_bar_position_get was called");
3813       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3814       if(wrapper != null) {
3815                            posx = default(double);      posy = default(double);
3816          try {
3817             ((Grid)wrapper).GetBarPosition( out posx,  out posy);
3818          } catch (Exception e) {
3819             Eina.Log.Warning($"Callback error: {e.ToString()}");
3820             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3821          }
3822                                     } else {
3823          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);
3824       }
3825    }
3826    private static efl_ui_scrollbar_bar_position_get_delegate efl_ui_scrollbar_bar_position_get_static_delegate;
3827
3828
3829     private delegate  void efl_ui_scrollbar_bar_position_set_delegate(System.IntPtr obj, System.IntPtr pd,   double posx,   double posy);
3830
3831
3832     public delegate  void efl_ui_scrollbar_bar_position_set_api_delegate(System.IntPtr obj,   double posx,   double posy);
3833     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");
3834     private static  void bar_position_set(System.IntPtr obj, System.IntPtr pd,  double posx,  double posy)
3835    {
3836       Eina.Log.Debug("function efl_ui_scrollbar_bar_position_set was called");
3837       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3838       if(wrapper != null) {
3839
3840          try {
3841             ((Grid)wrapper).SetBarPosition( posx,  posy);
3842          } catch (Exception e) {
3843             Eina.Log.Warning($"Callback error: {e.ToString()}");
3844             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3845          }
3846                                     } else {
3847          efl_ui_scrollbar_bar_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  posx,  posy);
3848       }
3849    }
3850    private static efl_ui_scrollbar_bar_position_set_delegate efl_ui_scrollbar_bar_position_set_static_delegate;
3851
3852
3853     private delegate  void efl_ui_scrollbar_bar_visibility_update_delegate(System.IntPtr obj, System.IntPtr pd);
3854
3855
3856     public delegate  void efl_ui_scrollbar_bar_visibility_update_api_delegate(System.IntPtr obj);
3857     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");
3858     private static  void bar_visibility_update(System.IntPtr obj, System.IntPtr pd)
3859    {
3860       Eina.Log.Debug("function efl_ui_scrollbar_bar_visibility_update was called");
3861       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
3862       if(wrapper != null) {
3863
3864          try {
3865             ((Grid)wrapper).UpdateBarVisibility();
3866          } catch (Exception e) {
3867             Eina.Log.Warning($"Callback error: {e.ToString()}");
3868             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3869          }
3870             } else {
3871          efl_ui_scrollbar_bar_visibility_update_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3872       }
3873    }
3874    private static efl_ui_scrollbar_bar_visibility_update_delegate efl_ui_scrollbar_bar_visibility_update_static_delegate;
3875 }
3876 } }