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

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