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

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