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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Efl UI zoom interface</summary>
  13 [Efl.Ui.IZoomConcrete.NativeMethods]
  14 public interface IZoom :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <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>
  18 /// <returns>The paused state.</returns>
  19 bool GetZoomAnimation();
  20     /// <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>
  21 /// <param name="paused">The paused state.</param>
  22 void SetZoomAnimation(bool paused);
  23     /// <summary>Get the zoom level of the photo
  24 /// 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>
  25 /// <returns>The zoom level to set</returns>
  26 double GetZoomLevel();
  27     /// <summary>Set the zoom level of the photo
  28 /// 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>
  29 /// <param name="zoom">The zoom level to set</param>
  30 void SetZoomLevel(double zoom);
  31     /// <summary>Get the zoom mode
  32 /// This gets the current zoom mode of the zoomable object.</summary>
  33 /// <returns>The zoom mode.</returns>
  34 Efl.Ui.ZoomMode GetZoomMode();
  35     /// <summary>Set the zoom mode
  36 /// 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.
  37 ///
  38 /// #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>
  39 /// <param name="mode">The zoom mode.</param>
  40 void SetZoomMode(Efl.Ui.ZoomMode mode);
  41                             /// <summary>Called when zooming started</summary>
  42     event EventHandler ZoomStartEvt;
  43     /// <summary>Called when zooming stopped</summary>
  44     event EventHandler ZoomStopEvt;
  45     /// <summary>Called when zooming changed</summary>
  46     event EventHandler ZoomChangeEvt;
  47     /// <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>
  48     /// <value>The paused state.</value>
  49     bool ZoomAnimation {
  50         get ;
  51         set ;
  52     }
  53     /// <summary>Get the zoom level of the photo
  54     /// 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>
  55     /// <value>The zoom level to set</value>
  56     double ZoomLevel {
  57         get ;
  58         set ;
  59     }
  60     /// <summary>Get the zoom mode
  61     /// This gets the current zoom mode of the zoomable object.</summary>
  62     /// <value>The zoom mode.</value>
  63     Efl.Ui.ZoomMode ZoomMode {
  64         get ;
  65         set ;
  66     }
  67 }
  68 /// <summary>Efl UI zoom interface</summary>
  69 sealed public class IZoomConcrete :
  70     Efl.Eo.EoWrapper
  71     , IZoom
  72
  73 {
  74     ///<summary>Pointer to the native class description.</summary>
  75     public override System.IntPtr NativeClass
  76     {
  77         get
  78         {
  79             if (((object)this).GetType() == typeof(IZoomConcrete))
  80             {
  81                 return GetEflClassStatic();
  82             }
  83             else
  84             {
  85                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  86             }
  87         }
  88     }
  89
  90     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
  91         efl_ui_zoom_interface_get();
  92     /// <summary>Initializes a new instance of the <see cref="IZoom"/> class.
  93     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  94     private IZoomConcrete(System.IntPtr raw) : base(raw)
  95     {
  96     }
  97
  98     /// <summary>Called when zooming started</summary>
  99     public event EventHandler ZoomStartEvt
 100     {
 101         add
 102         {
 103             lock (eventLock)
 104             {
 105                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 106                 {
 107                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 108                     if (obj != null)
 109                     {
 110                         EventArgs args = EventArgs.Empty;
 111                         try
 112                         {
 113                             value?.Invoke(obj, args);
 114                         }
 115                         catch (Exception e)
 116                         {
 117                             Eina.Log.Error(e.ToString());
 118                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 119                         }
 120                     }
 121                 };
 122
 123                 string key = "_EFL_UI_EVENT_ZOOM_START";
 124                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 125             }
 126         }
 127
 128         remove
 129         {
 130             lock (eventLock)
 131             {
 132                 string key = "_EFL_UI_EVENT_ZOOM_START";
 133                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 134             }
 135         }
 136     }
 137     ///<summary>Method to raise event ZoomStartEvt.</summary>
 138     public void OnZoomStartEvt(EventArgs e)
 139     {
 140         var key = "_EFL_UI_EVENT_ZOOM_START";
 141         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 142         if (desc == IntPtr.Zero)
 143         {
 144             Eina.Log.Error($"Failed to get native event {key}");
 145             return;
 146         }
 147
 148         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 149     }
 150     /// <summary>Called when zooming stopped</summary>
 151     public event EventHandler ZoomStopEvt
 152     {
 153         add
 154         {
 155             lock (eventLock)
 156             {
 157                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 158                 {
 159                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 160                     if (obj != null)
 161                     {
 162                         EventArgs args = EventArgs.Empty;
 163                         try
 164                         {
 165                             value?.Invoke(obj, args);
 166                         }
 167                         catch (Exception e)
 168                         {
 169                             Eina.Log.Error(e.ToString());
 170                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 171                         }
 172                     }
 173                 };
 174
 175                 string key = "_EFL_UI_EVENT_ZOOM_STOP";
 176                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 177             }
 178         }
 179
 180         remove
 181         {
 182             lock (eventLock)
 183             {
 184                 string key = "_EFL_UI_EVENT_ZOOM_STOP";
 185                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 186             }
 187         }
 188     }
 189     ///<summary>Method to raise event ZoomStopEvt.</summary>
 190     public void OnZoomStopEvt(EventArgs e)
 191     {
 192         var key = "_EFL_UI_EVENT_ZOOM_STOP";
 193         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 194         if (desc == IntPtr.Zero)
 195         {
 196             Eina.Log.Error($"Failed to get native event {key}");
 197             return;
 198         }
 199
 200         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 201     }
 202     /// <summary>Called when zooming changed</summary>
 203     public event EventHandler ZoomChangeEvt
 204     {
 205         add
 206         {
 207             lock (eventLock)
 208             {
 209                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 210                 {
 211                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 212                     if (obj != null)
 213                     {
 214                         EventArgs args = EventArgs.Empty;
 215                         try
 216                         {
 217                             value?.Invoke(obj, args);
 218                         }
 219                         catch (Exception e)
 220                         {
 221                             Eina.Log.Error(e.ToString());
 222                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 223                         }
 224                     }
 225                 };
 226
 227                 string key = "_EFL_UI_EVENT_ZOOM_CHANGE";
 228                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 229             }
 230         }
 231
 232         remove
 233         {
 234             lock (eventLock)
 235             {
 236                 string key = "_EFL_UI_EVENT_ZOOM_CHANGE";
 237                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 238             }
 239         }
 240     }
 241     ///<summary>Method to raise event ZoomChangeEvt.</summary>
 242     public void OnZoomChangeEvt(EventArgs e)
 243     {
 244         var key = "_EFL_UI_EVENT_ZOOM_CHANGE";
 245         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 246         if (desc == IntPtr.Zero)
 247         {
 248             Eina.Log.Error($"Failed to get native event {key}");
 249             return;
 250         }
 251
 252         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 253     }
 254     /// <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>
 255     /// <returns>The paused state.</returns>
 256     public bool GetZoomAnimation() {
 257          var _ret_var = Efl.Ui.IZoomConcrete.NativeMethods.efl_ui_zoom_animation_get_ptr.Value.Delegate(this.NativeHandle);
 258         Eina.Error.RaiseIfUnhandledException();
 259         return _ret_var;
 260  }
 261     /// <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>
 262     /// <param name="paused">The paused state.</param>
 263     public void SetZoomAnimation(bool paused) {
 264                                  Efl.Ui.IZoomConcrete.NativeMethods.efl_ui_zoom_animation_set_ptr.Value.Delegate(this.NativeHandle,paused);
 265         Eina.Error.RaiseIfUnhandledException();
 266                          }
 267     /// <summary>Get the zoom level of the photo
 268     /// 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>
 269     /// <returns>The zoom level to set</returns>
 270     public double GetZoomLevel() {
 271          var _ret_var = Efl.Ui.IZoomConcrete.NativeMethods.efl_ui_zoom_level_get_ptr.Value.Delegate(this.NativeHandle);
 272         Eina.Error.RaiseIfUnhandledException();
 273         return _ret_var;
 274  }
 275     /// <summary>Set the zoom level of the photo
 276     /// 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>
 277     /// <param name="zoom">The zoom level to set</param>
 278     public void SetZoomLevel(double zoom) {
 279                                  Efl.Ui.IZoomConcrete.NativeMethods.efl_ui_zoom_level_set_ptr.Value.Delegate(this.NativeHandle,zoom);
 280         Eina.Error.RaiseIfUnhandledException();
 281                          }
 282     /// <summary>Get the zoom mode
 283     /// This gets the current zoom mode of the zoomable object.</summary>
 284     /// <returns>The zoom mode.</returns>
 285     public Efl.Ui.ZoomMode GetZoomMode() {
 286          var _ret_var = Efl.Ui.IZoomConcrete.NativeMethods.efl_ui_zoom_mode_get_ptr.Value.Delegate(this.NativeHandle);
 287         Eina.Error.RaiseIfUnhandledException();
 288         return _ret_var;
 289  }
 290     /// <summary>Set the zoom mode
 291     /// 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.
 292     ///
 293     /// #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>
 294     /// <param name="mode">The zoom mode.</param>
 295     public void SetZoomMode(Efl.Ui.ZoomMode mode) {
 296                                  Efl.Ui.IZoomConcrete.NativeMethods.efl_ui_zoom_mode_set_ptr.Value.Delegate(this.NativeHandle,mode);
 297         Eina.Error.RaiseIfUnhandledException();
 298                          }
 299     /// <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>
 300     /// <value>The paused state.</value>
 301     public bool ZoomAnimation {
 302         get { return GetZoomAnimation(); }
 303         set { SetZoomAnimation(value); }
 304     }
 305     /// <summary>Get the zoom level of the photo
 306     /// 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>
 307     /// <value>The zoom level to set</value>
 308     public double ZoomLevel {
 309         get { return GetZoomLevel(); }
 310         set { SetZoomLevel(value); }
 311     }
 312     /// <summary>Get the zoom mode
 313     /// This gets the current zoom mode of the zoomable object.</summary>
 314     /// <value>The zoom mode.</value>
 315     public Efl.Ui.ZoomMode ZoomMode {
 316         get { return GetZoomMode(); }
 317         set { SetZoomMode(value); }
 318     }
 319     private static IntPtr GetEflClassStatic()
 320     {
 321         return Efl.Ui.IZoomConcrete.efl_ui_zoom_interface_get();
 322     }
 323     /// <summary>Wrapper for native methods and virtual method delegates.
 324     /// For internal use by generated code only.</summary>
 325     public class NativeMethods  : Efl.Eo.NativeClass
 326     {
 327         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 328         /// <summary>Gets the list of Eo operations to override.</summary>
 329         /// <returns>The list of Eo operations to be overload.</returns>
 330         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 331         {
 332             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 333             var methods = Efl.Eo.Globals.GetUserMethods(type);
 334
 335             if (efl_ui_zoom_animation_get_static_delegate == null)
 336             {
 337                 efl_ui_zoom_animation_get_static_delegate = new efl_ui_zoom_animation_get_delegate(zoom_animation_get);
 338             }
 339
 340             if (methods.FirstOrDefault(m => m.Name == "GetZoomAnimation") != null)
 341             {
 342                 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) });
 343             }
 344
 345             if (efl_ui_zoom_animation_set_static_delegate == null)
 346             {
 347                 efl_ui_zoom_animation_set_static_delegate = new efl_ui_zoom_animation_set_delegate(zoom_animation_set);
 348             }
 349
 350             if (methods.FirstOrDefault(m => m.Name == "SetZoomAnimation") != null)
 351             {
 352                 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) });
 353             }
 354
 355             if (efl_ui_zoom_level_get_static_delegate == null)
 356             {
 357                 efl_ui_zoom_level_get_static_delegate = new efl_ui_zoom_level_get_delegate(zoom_level_get);
 358             }
 359
 360             if (methods.FirstOrDefault(m => m.Name == "GetZoomLevel") != null)
 361             {
 362                 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) });
 363             }
 364
 365             if (efl_ui_zoom_level_set_static_delegate == null)
 366             {
 367                 efl_ui_zoom_level_set_static_delegate = new efl_ui_zoom_level_set_delegate(zoom_level_set);
 368             }
 369
 370             if (methods.FirstOrDefault(m => m.Name == "SetZoomLevel") != null)
 371             {
 372                 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) });
 373             }
 374
 375             if (efl_ui_zoom_mode_get_static_delegate == null)
 376             {
 377                 efl_ui_zoom_mode_get_static_delegate = new efl_ui_zoom_mode_get_delegate(zoom_mode_get);
 378             }
 379
 380             if (methods.FirstOrDefault(m => m.Name == "GetZoomMode") != null)
 381             {
 382                 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) });
 383             }
 384
 385             if (efl_ui_zoom_mode_set_static_delegate == null)
 386             {
 387                 efl_ui_zoom_mode_set_static_delegate = new efl_ui_zoom_mode_set_delegate(zoom_mode_set);
 388             }
 389
 390             if (methods.FirstOrDefault(m => m.Name == "SetZoomMode") != null)
 391             {
 392                 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) });
 393             }
 394
 395             return descs;
 396         }
 397         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 398         /// <returns>The native class pointer.</returns>
 399         public override IntPtr GetEflClass()
 400         {
 401             return Efl.Ui.IZoomConcrete.efl_ui_zoom_interface_get();
 402         }
 403
 404         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 405
 406         [return: MarshalAs(UnmanagedType.U1)]
 407         private delegate bool efl_ui_zoom_animation_get_delegate(System.IntPtr obj, System.IntPtr pd);
 408
 409         [return: MarshalAs(UnmanagedType.U1)]
 410         public delegate bool efl_ui_zoom_animation_get_api_delegate(System.IntPtr obj);
 411
 412         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");
 413
 414         private static bool zoom_animation_get(System.IntPtr obj, System.IntPtr pd)
 415         {
 416             Eina.Log.Debug("function efl_ui_zoom_animation_get was called");
 417             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 418             if (ws != null)
 419             {
 420             bool _ret_var = default(bool);
 421                 try
 422                 {
 423                     _ret_var = ((IZoom)ws.Target).GetZoomAnimation();
 424                 }
 425                 catch (Exception e)
 426                 {
 427                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 428                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 429                 }
 430
 431         return _ret_var;
 432
 433             }
 434             else
 435             {
 436                 return efl_ui_zoom_animation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 437             }
 438         }
 439
 440         private static efl_ui_zoom_animation_get_delegate efl_ui_zoom_animation_get_static_delegate;
 441
 442
 443         private delegate void efl_ui_zoom_animation_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool paused);
 444
 445
 446         public delegate void efl_ui_zoom_animation_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool paused);
 447
 448         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");
 449
 450         private static void zoom_animation_set(System.IntPtr obj, System.IntPtr pd, bool paused)
 451         {
 452             Eina.Log.Debug("function efl_ui_zoom_animation_set was called");
 453             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 454             if (ws != null)
 455             {
 456
 457                 try
 458                 {
 459                     ((IZoom)ws.Target).SetZoomAnimation(paused);
 460                 }
 461                 catch (Exception e)
 462                 {
 463                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 464                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 465                 }
 466
 467
 468             }
 469             else
 470             {
 471                 efl_ui_zoom_animation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), paused);
 472             }
 473         }
 474
 475         private static efl_ui_zoom_animation_set_delegate efl_ui_zoom_animation_set_static_delegate;
 476
 477
 478         private delegate double efl_ui_zoom_level_get_delegate(System.IntPtr obj, System.IntPtr pd);
 479
 480
 481         public delegate double efl_ui_zoom_level_get_api_delegate(System.IntPtr obj);
 482
 483         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");
 484
 485         private static double zoom_level_get(System.IntPtr obj, System.IntPtr pd)
 486         {
 487             Eina.Log.Debug("function efl_ui_zoom_level_get was called");
 488             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 489             if (ws != null)
 490             {
 491             double _ret_var = default(double);
 492                 try
 493                 {
 494                     _ret_var = ((IZoom)ws.Target).GetZoomLevel();
 495                 }
 496                 catch (Exception e)
 497                 {
 498                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 499                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 500                 }
 501
 502         return _ret_var;
 503
 504             }
 505             else
 506             {
 507                 return efl_ui_zoom_level_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 508             }
 509         }
 510
 511         private static efl_ui_zoom_level_get_delegate efl_ui_zoom_level_get_static_delegate;
 512
 513
 514         private delegate void efl_ui_zoom_level_set_delegate(System.IntPtr obj, System.IntPtr pd,  double zoom);
 515
 516
 517         public delegate void efl_ui_zoom_level_set_api_delegate(System.IntPtr obj,  double zoom);
 518
 519         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");
 520
 521         private static void zoom_level_set(System.IntPtr obj, System.IntPtr pd, double zoom)
 522         {
 523             Eina.Log.Debug("function efl_ui_zoom_level_set was called");
 524             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 525             if (ws != null)
 526             {
 527
 528                 try
 529                 {
 530                     ((IZoom)ws.Target).SetZoomLevel(zoom);
 531                 }
 532                 catch (Exception e)
 533                 {
 534                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 535                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 536                 }
 537
 538
 539             }
 540             else
 541             {
 542                 efl_ui_zoom_level_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), zoom);
 543             }
 544         }
 545
 546         private static efl_ui_zoom_level_set_delegate efl_ui_zoom_level_set_static_delegate;
 547
 548
 549         private delegate Efl.Ui.ZoomMode efl_ui_zoom_mode_get_delegate(System.IntPtr obj, System.IntPtr pd);
 550
 551
 552         public delegate Efl.Ui.ZoomMode efl_ui_zoom_mode_get_api_delegate(System.IntPtr obj);
 553
 554         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");
 555
 556         private static Efl.Ui.ZoomMode zoom_mode_get(System.IntPtr obj, System.IntPtr pd)
 557         {
 558             Eina.Log.Debug("function efl_ui_zoom_mode_get was called");
 559             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 560             if (ws != null)
 561             {
 562             Efl.Ui.ZoomMode _ret_var = default(Efl.Ui.ZoomMode);
 563                 try
 564                 {
 565                     _ret_var = ((IZoom)ws.Target).GetZoomMode();
 566                 }
 567                 catch (Exception e)
 568                 {
 569                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 570                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 571                 }
 572
 573         return _ret_var;
 574
 575             }
 576             else
 577             {
 578                 return efl_ui_zoom_mode_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 579             }
 580         }
 581
 582         private static efl_ui_zoom_mode_get_delegate efl_ui_zoom_mode_get_static_delegate;
 583
 584
 585         private delegate void efl_ui_zoom_mode_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Ui.ZoomMode mode);
 586
 587
 588         public delegate void efl_ui_zoom_mode_set_api_delegate(System.IntPtr obj,  Efl.Ui.ZoomMode mode);
 589
 590         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");
 591
 592         private static void zoom_mode_set(System.IntPtr obj, System.IntPtr pd, Efl.Ui.ZoomMode mode)
 593         {
 594             Eina.Log.Debug("function efl_ui_zoom_mode_set was called");
 595             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 596             if (ws != null)
 597             {
 598
 599                 try
 600                 {
 601                     ((IZoom)ws.Target).SetZoomMode(mode);
 602                 }
 603                 catch (Exception e)
 604                 {
 605                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 606                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 607                 }
 608
 609
 610             }
 611             else
 612             {
 613                 efl_ui_zoom_mode_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode);
 614             }
 615         }
 616
 617         private static efl_ui_zoom_mode_set_delegate efl_ui_zoom_mode_set_static_delegate;
 618
 619         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 620
 621 }
 622 }
 623 }
 624
 625 }
 626
 627 namespace Efl {
 628
 629 namespace Ui {
 630
 631 /// <summary>Types of zoom available.</summary>
 632 public enum ZoomMode
 633 {
 634 /// <summary>Zoom controlled normally by efl_ui_zoom_set</summary>
 635 Manual = 0,
 636 /// <summary>Zoom until photo fits in zoomable object</summary>
 637 AutoFit = 1,
 638 /// <summary>Zoom until photo fills zoomable object</summary>
 639 AutoFill = 2,
 640 /// <summary>Zoom in until photo fits in zoomable object</summary>
 641 AutoFitIn = 3,
 642 /// <summary>Sentinel value to indicate last enum field during iteration</summary>
 643 Last = 4,
 644 }
 645
 646 }
 647
 648 }
 649