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

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