internals/src/EflSharp/EflSharp/efl/efl_gfx_image.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 Gfx {
  11
  12 /// <summary>Common APIs for all 2D images that can be rendered on the canvas.</summary>
  13 [Efl.Gfx.IImageConcrete.NativeMethods]
  14 public interface IImage :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Whether to use high-quality image scaling algorithm for this image.
  18 /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
  19 ///
  20 /// <c>true</c> by default</summary>
  21 /// <returns>Whether to use smooth scale or not.</returns>
  22 bool GetSmoothScale();
  23     /// <summary>Whether to use high-quality image scaling algorithm for this image.
  24 /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
  25 ///
  26 /// <c>true</c> by default</summary>
  27 /// <param name="smooth_scale">Whether to use smooth scale or not.</param>
  28 void SetSmoothScale(bool smooth_scale);
  29     /// <summary>Control how the image is scaled.</summary>
  30 /// <returns>Image scale type</returns>
  31 Efl.Gfx.ImageScaleType GetScaleType();
  32     /// <summary>Control how the image is scaled.</summary>
  33 /// <param name="scale_type">Image scale type</param>
  34 void SetScaleType(Efl.Gfx.ImageScaleType scale_type);
  35     /// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
  36 /// <returns>The image&apos;s ratio.</returns>
  37 double GetRatio();
  38     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
  39 /// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
  40 ///
  41 /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
  42 ///
  43 /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
  44 ///
  45 /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
  46 ///
  47 /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
  48 /// <param name="l">The border&apos;s left width.</param>
  49 /// <param name="r">The border&apos;s right width.</param>
  50 /// <param name="t">The border&apos;s top height.</param>
  51 /// <param name="b">The border&apos;s bottom height.</param>
  52 void GetBorder(out int l, out int r, out int t, out int b);
  53     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
  54 /// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
  55 ///
  56 /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
  57 ///
  58 /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
  59 ///
  60 /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
  61 ///
  62 /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
  63 /// <param name="l">The border&apos;s left width.</param>
  64 /// <param name="r">The border&apos;s right width.</param>
  65 /// <param name="t">The border&apos;s top height.</param>
  66 /// <param name="b">The border&apos;s bottom height.</param>
  67 void SetBorder(int l, int r, int t, int b);
  68     /// <summary>Scaling factor applied to the image borders.
  69 /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
  70 ///
  71 /// Default value is 1.0 (no scaling).</summary>
  72 /// <returns>The scale factor.</returns>
  73 double GetBorderScale();
  74     /// <summary>Scaling factor applied to the image borders.
  75 /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
  76 ///
  77 /// Default value is 1.0 (no scaling).</summary>
  78 /// <param name="scale">The scale factor.</param>
  79 void SetBorderScale(double scale);
  80     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
  81 /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
  82 ///
  83 /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
  84 /// <returns>Fill mode of the center region.</returns>
  85 Efl.Gfx.BorderFillMode GetBorderCenterFill();
  86     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
  87 /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
  88 ///
  89 /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
  90 /// <param name="fill">Fill mode of the center region.</param>
  91 void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill);
  92     /// <summary>This represents the size of the original image in pixels.
  93 /// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
  94 ///
  95 /// This is a read-only property, and may return 0x0.</summary>
  96 /// <returns>The size in pixels.</returns>
  97 Eina.Size2D GetImageSize();
  98     /// <summary>Get the content hint setting of a given image object of the canvas.
  99 /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 100 /// <returns>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></returns>
 101 Efl.Gfx.ImageContentHint GetContentHint();
 102     /// <summary>Set the content hint setting of a given image object of the canvas.
 103 /// This function sets the content hint value of the given image of the canvas. For example, if you&apos;re on the GL engine and your driver implementation supports it, setting this hint to #EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies at texture upload time, which is an &quot;expensive&quot; operation.</summary>
 104 /// <param name="hint">Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></param>
 105 void SetContentHint(Efl.Gfx.ImageContentHint hint);
 106     /// <summary>Get the scale hint of a given image of the canvas.
 107 /// This function returns the scale hint value of the given image object of the canvas.</summary>
 108 /// <returns>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></returns>
 109 Efl.Gfx.ImageScaleHint GetScaleHint();
 110     /// <summary>Set the scale hint of a given image of the canvas.
 111 /// This function sets the scale hint value of the given image object in the canvas, which will affect how Evas is to cache scaled versions of its original source image.</summary>
 112 /// <param name="hint">Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></param>
 113 void SetScaleHint(Efl.Gfx.ImageScaleHint hint);
 114     /// <summary>Gets the (last) file loading error for a given object.</summary>
 115 /// <returns>The load error code.</returns>
 116 Eina.Error GetImageLoadError();
 117                                                                         /// <summary>Image data has been preloaded.</summary>
 118     event EventHandler ImagePreloadEvt;
 119     /// <summary>Image was resized (its pixel data).</summary>
 120     event EventHandler ImageResizeEvt;
 121     /// <summary>Image data has been unloaded (by some mechanism in EFL that threw out the original image data).</summary>
 122     event EventHandler ImageUnloadEvt;
 123     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 124     /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 125     ///
 126     /// <c>true</c> by default</summary>
 127     /// <value>Whether to use smooth scale or not.</value>
 128     bool SmoothScale {
 129         get ;
 130         set ;
 131     }
 132     /// <summary>Control how the image is scaled.</summary>
 133     /// <value>Image scale type</value>
 134     Efl.Gfx.ImageScaleType ScaleType {
 135         get ;
 136         set ;
 137     }
 138     /// <summary>The native width/height ratio of the image.</summary>
 139     /// <value>The image&apos;s ratio.</value>
 140     double Ratio {
 141         get ;
 142     }
 143     /// <summary>Scaling factor applied to the image borders.
 144     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 145     ///
 146     /// Default value is 1.0 (no scaling).</summary>
 147     /// <value>The scale factor.</value>
 148     double BorderScale {
 149         get ;
 150         set ;
 151     }
 152     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 153     /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
 154     ///
 155     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 156     /// <value>Fill mode of the center region.</value>
 157     Efl.Gfx.BorderFillMode BorderCenterFill {
 158         get ;
 159         set ;
 160     }
 161     /// <summary>This represents the size of the original image in pixels.
 162     /// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
 163     ///
 164     /// This is a read-only property, and may return 0x0.</summary>
 165     /// <value>The size in pixels.</value>
 166     Eina.Size2D ImageSize {
 167         get ;
 168     }
 169     /// <summary>Get the content hint setting of a given image object of the canvas.
 170     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 171     /// <value>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></value>
 172     Efl.Gfx.ImageContentHint ContentHint {
 173         get ;
 174         set ;
 175     }
 176     /// <summary>Get the scale hint of a given image of the canvas.
 177     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 178     /// <value>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></value>
 179     Efl.Gfx.ImageScaleHint ScaleHint {
 180         get ;
 181         set ;
 182     }
 183     /// <summary>Gets the (last) file loading error for a given object.</summary>
 184     /// <value>The load error code.</value>
 185     Eina.Error ImageLoadError {
 186         get ;
 187     }
 188 }
 189 /// <summary>Common APIs for all 2D images that can be rendered on the canvas.</summary>
 190 sealed public class IImageConcrete :
 191     Efl.Eo.EoWrapper
 192     , IImage
 193
 194 {
 195     ///<summary>Pointer to the native class description.</summary>
 196     public override System.IntPtr NativeClass
 197     {
 198         get
 199         {
 200             if (((object)this).GetType() == typeof(IImageConcrete))
 201             {
 202                 return GetEflClassStatic();
 203             }
 204             else
 205             {
 206                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 207             }
 208         }
 209     }
 210
 211     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 212         efl_gfx_image_interface_get();
 213     /// <summary>Initializes a new instance of the <see cref="IImage"/> class.
 214     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 215     private IImageConcrete(System.IntPtr raw) : base(raw)
 216     {
 217     }
 218
 219     /// <summary>Image data has been preloaded.</summary>
 220     public event EventHandler ImagePreloadEvt
 221     {
 222         add
 223         {
 224             lock (eventLock)
 225             {
 226                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 227                 {
 228                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 229                     if (obj != null)
 230                     {
 231                         EventArgs args = EventArgs.Empty;
 232                         try
 233                         {
 234                             value?.Invoke(obj, args);
 235                         }
 236                         catch (Exception e)
 237                         {
 238                             Eina.Log.Error(e.ToString());
 239                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 240                         }
 241                     }
 242                 };
 243
 244                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 245                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 246             }
 247         }
 248
 249         remove
 250         {
 251             lock (eventLock)
 252             {
 253                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 254                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 255             }
 256         }
 257     }
 258     ///<summary>Method to raise event ImagePreloadEvt.</summary>
 259     public void OnImagePreloadEvt(EventArgs e)
 260     {
 261         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 262         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 263         if (desc == IntPtr.Zero)
 264         {
 265             Eina.Log.Error($"Failed to get native event {key}");
 266             return;
 267         }
 268
 269         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 270     }
 271     /// <summary>Image was resized (its pixel data).</summary>
 272     public event EventHandler ImageResizeEvt
 273     {
 274         add
 275         {
 276             lock (eventLock)
 277             {
 278                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 279                 {
 280                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 281                     if (obj != null)
 282                     {
 283                         EventArgs args = EventArgs.Empty;
 284                         try
 285                         {
 286                             value?.Invoke(obj, args);
 287                         }
 288                         catch (Exception e)
 289                         {
 290                             Eina.Log.Error(e.ToString());
 291                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 292                         }
 293                     }
 294                 };
 295
 296                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 297                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 298             }
 299         }
 300
 301         remove
 302         {
 303             lock (eventLock)
 304             {
 305                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 306                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 307             }
 308         }
 309     }
 310     ///<summary>Method to raise event ImageResizeEvt.</summary>
 311     public void OnImageResizeEvt(EventArgs e)
 312     {
 313         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 314         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 315         if (desc == IntPtr.Zero)
 316         {
 317             Eina.Log.Error($"Failed to get native event {key}");
 318             return;
 319         }
 320
 321         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 322     }
 323     /// <summary>Image data has been unloaded (by some mechanism in EFL that threw out the original image data).</summary>
 324     public event EventHandler ImageUnloadEvt
 325     {
 326         add
 327         {
 328             lock (eventLock)
 329             {
 330                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 331                 {
 332                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 333                     if (obj != null)
 334                     {
 335                         EventArgs args = EventArgs.Empty;
 336                         try
 337                         {
 338                             value?.Invoke(obj, args);
 339                         }
 340                         catch (Exception e)
 341                         {
 342                             Eina.Log.Error(e.ToString());
 343                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 344                         }
 345                     }
 346                 };
 347
 348                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 349                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 350             }
 351         }
 352
 353         remove
 354         {
 355             lock (eventLock)
 356             {
 357                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 358                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 359             }
 360         }
 361     }
 362     ///<summary>Method to raise event ImageUnloadEvt.</summary>
 363     public void OnImageUnloadEvt(EventArgs e)
 364     {
 365         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 366         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 367         if (desc == IntPtr.Zero)
 368         {
 369             Eina.Log.Error($"Failed to get native event {key}");
 370             return;
 371         }
 372
 373         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 374     }
 375     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 376     /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 377     ///
 378     /// <c>true</c> by default</summary>
 379     /// <returns>Whether to use smooth scale or not.</returns>
 380     public bool GetSmoothScale() {
 381          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(this.NativeHandle);
 382         Eina.Error.RaiseIfUnhandledException();
 383         return _ret_var;
 384  }
 385     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 386     /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 387     ///
 388     /// <c>true</c> by default</summary>
 389     /// <param name="smooth_scale">Whether to use smooth scale or not.</param>
 390     public void SetSmoothScale(bool smooth_scale) {
 391                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(this.NativeHandle,smooth_scale);
 392         Eina.Error.RaiseIfUnhandledException();
 393                          }
 394     /// <summary>Control how the image is scaled.</summary>
 395     /// <returns>Image scale type</returns>
 396     public Efl.Gfx.ImageScaleType GetScaleType() {
 397          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_get_ptr.Value.Delegate(this.NativeHandle);
 398         Eina.Error.RaiseIfUnhandledException();
 399         return _ret_var;
 400  }
 401     /// <summary>Control how the image is scaled.</summary>
 402     /// <param name="scale_type">Image scale type</param>
 403     public void SetScaleType(Efl.Gfx.ImageScaleType scale_type) {
 404                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_set_ptr.Value.Delegate(this.NativeHandle,scale_type);
 405         Eina.Error.RaiseIfUnhandledException();
 406                          }
 407     /// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
 408     /// <returns>The image&apos;s ratio.</returns>
 409     public double GetRatio() {
 410          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_ratio_get_ptr.Value.Delegate(this.NativeHandle);
 411         Eina.Error.RaiseIfUnhandledException();
 412         return _ret_var;
 413  }
 414     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 415     /// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
 416     ///
 417     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 418     ///
 419     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 420     ///
 421     /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
 422     ///
 423     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 424     /// <param name="l">The border&apos;s left width.</param>
 425     /// <param name="r">The border&apos;s right width.</param>
 426     /// <param name="t">The border&apos;s top height.</param>
 427     /// <param name="b">The border&apos;s bottom height.</param>
 428     public void GetBorder(out int l, out int r, out int t, out int b) {
 429                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_get_ptr.Value.Delegate(this.NativeHandle,out l, out r, out t, out b);
 430         Eina.Error.RaiseIfUnhandledException();
 431                                                                          }
 432     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 433     /// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
 434     ///
 435     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 436     ///
 437     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 438     ///
 439     /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
 440     ///
 441     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 442     /// <param name="l">The border&apos;s left width.</param>
 443     /// <param name="r">The border&apos;s right width.</param>
 444     /// <param name="t">The border&apos;s top height.</param>
 445     /// <param name="b">The border&apos;s bottom height.</param>
 446     public void SetBorder(int l, int r, int t, int b) {
 447                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_set_ptr.Value.Delegate(this.NativeHandle,l, r, t, b);
 448         Eina.Error.RaiseIfUnhandledException();
 449                                                                          }
 450     /// <summary>Scaling factor applied to the image borders.
 451     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 452     ///
 453     /// Default value is 1.0 (no scaling).</summary>
 454     /// <returns>The scale factor.</returns>
 455     public double GetBorderScale() {
 456          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_get_ptr.Value.Delegate(this.NativeHandle);
 457         Eina.Error.RaiseIfUnhandledException();
 458         return _ret_var;
 459  }
 460     /// <summary>Scaling factor applied to the image borders.
 461     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 462     ///
 463     /// Default value is 1.0 (no scaling).</summary>
 464     /// <param name="scale">The scale factor.</param>
 465     public void SetBorderScale(double scale) {
 466                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_set_ptr.Value.Delegate(this.NativeHandle,scale);
 467         Eina.Error.RaiseIfUnhandledException();
 468                          }
 469     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 470     /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
 471     ///
 472     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 473     /// <returns>Fill mode of the center region.</returns>
 474     public Efl.Gfx.BorderFillMode GetBorderCenterFill() {
 475          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(this.NativeHandle);
 476         Eina.Error.RaiseIfUnhandledException();
 477         return _ret_var;
 478  }
 479     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 480     /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
 481     ///
 482     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 483     /// <param name="fill">Fill mode of the center region.</param>
 484     public void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill) {
 485                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(this.NativeHandle,fill);
 486         Eina.Error.RaiseIfUnhandledException();
 487                          }
 488     /// <summary>This represents the size of the original image in pixels.
 489     /// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
 490     ///
 491     /// This is a read-only property, and may return 0x0.</summary>
 492     /// <returns>The size in pixels.</returns>
 493     public Eina.Size2D GetImageSize() {
 494          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_size_get_ptr.Value.Delegate(this.NativeHandle);
 495         Eina.Error.RaiseIfUnhandledException();
 496         return _ret_var;
 497  }
 498     /// <summary>Get the content hint setting of a given image object of the canvas.
 499     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 500     /// <returns>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></returns>
 501     public Efl.Gfx.ImageContentHint GetContentHint() {
 502          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_get_ptr.Value.Delegate(this.NativeHandle);
 503         Eina.Error.RaiseIfUnhandledException();
 504         return _ret_var;
 505  }
 506     /// <summary>Set the content hint setting of a given image object of the canvas.
 507     /// This function sets the content hint value of the given image of the canvas. For example, if you&apos;re on the GL engine and your driver implementation supports it, setting this hint to #EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies at texture upload time, which is an &quot;expensive&quot; operation.</summary>
 508     /// <param name="hint">Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></param>
 509     public void SetContentHint(Efl.Gfx.ImageContentHint hint) {
 510                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_set_ptr.Value.Delegate(this.NativeHandle,hint);
 511         Eina.Error.RaiseIfUnhandledException();
 512                          }
 513     /// <summary>Get the scale hint of a given image of the canvas.
 514     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 515     /// <returns>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></returns>
 516     public Efl.Gfx.ImageScaleHint GetScaleHint() {
 517          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_get_ptr.Value.Delegate(this.NativeHandle);
 518         Eina.Error.RaiseIfUnhandledException();
 519         return _ret_var;
 520  }
 521     /// <summary>Set the scale hint of a given image of the canvas.
 522     /// This function sets the scale hint value of the given image object in the canvas, which will affect how Evas is to cache scaled versions of its original source image.</summary>
 523     /// <param name="hint">Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></param>
 524     public void SetScaleHint(Efl.Gfx.ImageScaleHint hint) {
 525                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_set_ptr.Value.Delegate(this.NativeHandle,hint);
 526         Eina.Error.RaiseIfUnhandledException();
 527                          }
 528     /// <summary>Gets the (last) file loading error for a given object.</summary>
 529     /// <returns>The load error code.</returns>
 530     public Eina.Error GetImageLoadError() {
 531          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_load_error_get_ptr.Value.Delegate(this.NativeHandle);
 532         Eina.Error.RaiseIfUnhandledException();
 533         return _ret_var;
 534  }
 535     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 536     /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 537     ///
 538     /// <c>true</c> by default</summary>
 539     /// <value>Whether to use smooth scale or not.</value>
 540     public bool SmoothScale {
 541         get { return GetSmoothScale(); }
 542         set { SetSmoothScale(value); }
 543     }
 544     /// <summary>Control how the image is scaled.</summary>
 545     /// <value>Image scale type</value>
 546     public Efl.Gfx.ImageScaleType ScaleType {
 547         get { return GetScaleType(); }
 548         set { SetScaleType(value); }
 549     }
 550     /// <summary>The native width/height ratio of the image.</summary>
 551     /// <value>The image&apos;s ratio.</value>
 552     public double Ratio {
 553         get { return GetRatio(); }
 554     }
 555     /// <summary>Scaling factor applied to the image borders.
 556     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 557     ///
 558     /// Default value is 1.0 (no scaling).</summary>
 559     /// <value>The scale factor.</value>
 560     public double BorderScale {
 561         get { return GetBorderScale(); }
 562         set { SetBorderScale(value); }
 563     }
 564     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 565     /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
 566     ///
 567     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 568     /// <value>Fill mode of the center region.</value>
 569     public Efl.Gfx.BorderFillMode BorderCenterFill {
 570         get { return GetBorderCenterFill(); }
 571         set { SetBorderCenterFill(value); }
 572     }
 573     /// <summary>This represents the size of the original image in pixels.
 574     /// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
 575     ///
 576     /// This is a read-only property, and may return 0x0.</summary>
 577     /// <value>The size in pixels.</value>
 578     public Eina.Size2D ImageSize {
 579         get { return GetImageSize(); }
 580     }
 581     /// <summary>Get the content hint setting of a given image object of the canvas.
 582     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 583     /// <value>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></value>
 584     public Efl.Gfx.ImageContentHint ContentHint {
 585         get { return GetContentHint(); }
 586         set { SetContentHint(value); }
 587     }
 588     /// <summary>Get the scale hint of a given image of the canvas.
 589     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 590     /// <value>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></value>
 591     public Efl.Gfx.ImageScaleHint ScaleHint {
 592         get { return GetScaleHint(); }
 593         set { SetScaleHint(value); }
 594     }
 595     /// <summary>Gets the (last) file loading error for a given object.</summary>
 596     /// <value>The load error code.</value>
 597     public Eina.Error ImageLoadError {
 598         get { return GetImageLoadError(); }
 599     }
 600     private static IntPtr GetEflClassStatic()
 601     {
 602         return Efl.Gfx.IImageConcrete.efl_gfx_image_interface_get();
 603     }
 604     /// <summary>Wrapper for native methods and virtual method delegates.
 605     /// For internal use by generated code only.</summary>
 606     public class NativeMethods  : Efl.Eo.NativeClass
 607     {
 608         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 609         /// <summary>Gets the list of Eo operations to override.</summary>
 610         /// <returns>The list of Eo operations to be overload.</returns>
 611         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 612         {
 613             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 614             var methods = Efl.Eo.Globals.GetUserMethods(type);
 615
 616             if (efl_gfx_image_smooth_scale_get_static_delegate == null)
 617             {
 618                 efl_gfx_image_smooth_scale_get_static_delegate = new efl_gfx_image_smooth_scale_get_delegate(smooth_scale_get);
 619             }
 620
 621             if (methods.FirstOrDefault(m => m.Name == "GetSmoothScale") != null)
 622             {
 623                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_smooth_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_smooth_scale_get_static_delegate) });
 624             }
 625
 626             if (efl_gfx_image_smooth_scale_set_static_delegate == null)
 627             {
 628                 efl_gfx_image_smooth_scale_set_static_delegate = new efl_gfx_image_smooth_scale_set_delegate(smooth_scale_set);
 629             }
 630
 631             if (methods.FirstOrDefault(m => m.Name == "SetSmoothScale") != null)
 632             {
 633                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_smooth_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_smooth_scale_set_static_delegate) });
 634             }
 635
 636             if (efl_gfx_image_scale_type_get_static_delegate == null)
 637             {
 638                 efl_gfx_image_scale_type_get_static_delegate = new efl_gfx_image_scale_type_get_delegate(scale_type_get);
 639             }
 640
 641             if (methods.FirstOrDefault(m => m.Name == "GetScaleType") != null)
 642             {
 643                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_type_get_static_delegate) });
 644             }
 645
 646             if (efl_gfx_image_scale_type_set_static_delegate == null)
 647             {
 648                 efl_gfx_image_scale_type_set_static_delegate = new efl_gfx_image_scale_type_set_delegate(scale_type_set);
 649             }
 650
 651             if (methods.FirstOrDefault(m => m.Name == "SetScaleType") != null)
 652             {
 653                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_type_set_static_delegate) });
 654             }
 655
 656             if (efl_gfx_image_ratio_get_static_delegate == null)
 657             {
 658                 efl_gfx_image_ratio_get_static_delegate = new efl_gfx_image_ratio_get_delegate(ratio_get);
 659             }
 660
 661             if (methods.FirstOrDefault(m => m.Name == "GetRatio") != null)
 662             {
 663                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_ratio_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_ratio_get_static_delegate) });
 664             }
 665
 666             if (efl_gfx_image_border_get_static_delegate == null)
 667             {
 668                 efl_gfx_image_border_get_static_delegate = new efl_gfx_image_border_get_delegate(border_get);
 669             }
 670
 671             if (methods.FirstOrDefault(m => m.Name == "GetBorder") != null)
 672             {
 673                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_get_static_delegate) });
 674             }
 675
 676             if (efl_gfx_image_border_set_static_delegate == null)
 677             {
 678                 efl_gfx_image_border_set_static_delegate = new efl_gfx_image_border_set_delegate(border_set);
 679             }
 680
 681             if (methods.FirstOrDefault(m => m.Name == "SetBorder") != null)
 682             {
 683                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_set_static_delegate) });
 684             }
 685
 686             if (efl_gfx_image_border_scale_get_static_delegate == null)
 687             {
 688                 efl_gfx_image_border_scale_get_static_delegate = new efl_gfx_image_border_scale_get_delegate(border_scale_get);
 689             }
 690
 691             if (methods.FirstOrDefault(m => m.Name == "GetBorderScale") != null)
 692             {
 693                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_scale_get_static_delegate) });
 694             }
 695
 696             if (efl_gfx_image_border_scale_set_static_delegate == null)
 697             {
 698                 efl_gfx_image_border_scale_set_static_delegate = new efl_gfx_image_border_scale_set_delegate(border_scale_set);
 699             }
 700
 701             if (methods.FirstOrDefault(m => m.Name == "SetBorderScale") != null)
 702             {
 703                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_scale_set_static_delegate) });
 704             }
 705
 706             if (efl_gfx_image_border_center_fill_get_static_delegate == null)
 707             {
 708                 efl_gfx_image_border_center_fill_get_static_delegate = new efl_gfx_image_border_center_fill_get_delegate(border_center_fill_get);
 709             }
 710
 711             if (methods.FirstOrDefault(m => m.Name == "GetBorderCenterFill") != null)
 712             {
 713                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_center_fill_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_center_fill_get_static_delegate) });
 714             }
 715
 716             if (efl_gfx_image_border_center_fill_set_static_delegate == null)
 717             {
 718                 efl_gfx_image_border_center_fill_set_static_delegate = new efl_gfx_image_border_center_fill_set_delegate(border_center_fill_set);
 719             }
 720
 721             if (methods.FirstOrDefault(m => m.Name == "SetBorderCenterFill") != null)
 722             {
 723                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_center_fill_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_center_fill_set_static_delegate) });
 724             }
 725
 726             if (efl_gfx_image_size_get_static_delegate == null)
 727             {
 728                 efl_gfx_image_size_get_static_delegate = new efl_gfx_image_size_get_delegate(image_size_get);
 729             }
 730
 731             if (methods.FirstOrDefault(m => m.Name == "GetImageSize") != null)
 732             {
 733                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_size_get_static_delegate) });
 734             }
 735
 736             if (efl_gfx_image_content_hint_get_static_delegate == null)
 737             {
 738                 efl_gfx_image_content_hint_get_static_delegate = new efl_gfx_image_content_hint_get_delegate(content_hint_get);
 739             }
 740
 741             if (methods.FirstOrDefault(m => m.Name == "GetContentHint") != null)
 742             {
 743                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_hint_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_hint_get_static_delegate) });
 744             }
 745
 746             if (efl_gfx_image_content_hint_set_static_delegate == null)
 747             {
 748                 efl_gfx_image_content_hint_set_static_delegate = new efl_gfx_image_content_hint_set_delegate(content_hint_set);
 749             }
 750
 751             if (methods.FirstOrDefault(m => m.Name == "SetContentHint") != null)
 752             {
 753                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_hint_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_hint_set_static_delegate) });
 754             }
 755
 756             if (efl_gfx_image_scale_hint_get_static_delegate == null)
 757             {
 758                 efl_gfx_image_scale_hint_get_static_delegate = new efl_gfx_image_scale_hint_get_delegate(scale_hint_get);
 759             }
 760
 761             if (methods.FirstOrDefault(m => m.Name == "GetScaleHint") != null)
 762             {
 763                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_hint_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_hint_get_static_delegate) });
 764             }
 765
 766             if (efl_gfx_image_scale_hint_set_static_delegate == null)
 767             {
 768                 efl_gfx_image_scale_hint_set_static_delegate = new efl_gfx_image_scale_hint_set_delegate(scale_hint_set);
 769             }
 770
 771             if (methods.FirstOrDefault(m => m.Name == "SetScaleHint") != null)
 772             {
 773                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_hint_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_hint_set_static_delegate) });
 774             }
 775
 776             if (efl_gfx_image_load_error_get_static_delegate == null)
 777             {
 778                 efl_gfx_image_load_error_get_static_delegate = new efl_gfx_image_load_error_get_delegate(image_load_error_get);
 779             }
 780
 781             if (methods.FirstOrDefault(m => m.Name == "GetImageLoadError") != null)
 782             {
 783                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_error_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_error_get_static_delegate) });
 784             }
 785
 786             return descs;
 787         }
 788         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 789         /// <returns>The native class pointer.</returns>
 790         public override IntPtr GetEflClass()
 791         {
 792             return Efl.Gfx.IImageConcrete.efl_gfx_image_interface_get();
 793         }
 794
 795         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 796
 797         [return: MarshalAs(UnmanagedType.U1)]
 798         private delegate bool efl_gfx_image_smooth_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
 799
 800         [return: MarshalAs(UnmanagedType.U1)]
 801         public delegate bool efl_gfx_image_smooth_scale_get_api_delegate(System.IntPtr obj);
 802
 803         public static Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_get_api_delegate> efl_gfx_image_smooth_scale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_get_api_delegate>(Module, "efl_gfx_image_smooth_scale_get");
 804
 805         private static bool smooth_scale_get(System.IntPtr obj, System.IntPtr pd)
 806         {
 807             Eina.Log.Debug("function efl_gfx_image_smooth_scale_get was called");
 808             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 809             if (ws != null)
 810             {
 811             bool _ret_var = default(bool);
 812                 try
 813                 {
 814                     _ret_var = ((IImage)ws.Target).GetSmoothScale();
 815                 }
 816                 catch (Exception e)
 817                 {
 818                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 819                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 820                 }
 821
 822         return _ret_var;
 823
 824             }
 825             else
 826             {
 827                 return efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 828             }
 829         }
 830
 831         private static efl_gfx_image_smooth_scale_get_delegate efl_gfx_image_smooth_scale_get_static_delegate;
 832
 833
 834         private delegate void efl_gfx_image_smooth_scale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
 835
 836
 837         public delegate void efl_gfx_image_smooth_scale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
 838
 839         public static Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_set_api_delegate> efl_gfx_image_smooth_scale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_set_api_delegate>(Module, "efl_gfx_image_smooth_scale_set");
 840
 841         private static void smooth_scale_set(System.IntPtr obj, System.IntPtr pd, bool smooth_scale)
 842         {
 843             Eina.Log.Debug("function efl_gfx_image_smooth_scale_set was called");
 844             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 845             if (ws != null)
 846             {
 847
 848                 try
 849                 {
 850                     ((IImage)ws.Target).SetSmoothScale(smooth_scale);
 851                 }
 852                 catch (Exception e)
 853                 {
 854                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 855                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 856                 }
 857
 858
 859             }
 860             else
 861             {
 862                 efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth_scale);
 863             }
 864         }
 865
 866         private static efl_gfx_image_smooth_scale_set_delegate efl_gfx_image_smooth_scale_set_static_delegate;
 867
 868
 869         private delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
 870
 871
 872         public delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_api_delegate(System.IntPtr obj);
 873
 874         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_get_api_delegate> efl_gfx_image_scale_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_get_api_delegate>(Module, "efl_gfx_image_scale_type_get");
 875
 876         private static Efl.Gfx.ImageScaleType scale_type_get(System.IntPtr obj, System.IntPtr pd)
 877         {
 878             Eina.Log.Debug("function efl_gfx_image_scale_type_get was called");
 879             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 880             if (ws != null)
 881             {
 882             Efl.Gfx.ImageScaleType _ret_var = default(Efl.Gfx.ImageScaleType);
 883                 try
 884                 {
 885                     _ret_var = ((IImage)ws.Target).GetScaleType();
 886                 }
 887                 catch (Exception e)
 888                 {
 889                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 890                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 891                 }
 892
 893         return _ret_var;
 894
 895             }
 896             else
 897             {
 898                 return efl_gfx_image_scale_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 899             }
 900         }
 901
 902         private static efl_gfx_image_scale_type_get_delegate efl_gfx_image_scale_type_get_static_delegate;
 903
 904
 905         private delegate void efl_gfx_image_scale_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleType scale_type);
 906
 907
 908         public delegate void efl_gfx_image_scale_type_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleType scale_type);
 909
 910         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_set_api_delegate> efl_gfx_image_scale_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_set_api_delegate>(Module, "efl_gfx_image_scale_type_set");
 911
 912         private static void scale_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleType scale_type)
 913         {
 914             Eina.Log.Debug("function efl_gfx_image_scale_type_set was called");
 915             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 916             if (ws != null)
 917             {
 918
 919                 try
 920                 {
 921                     ((IImage)ws.Target).SetScaleType(scale_type);
 922                 }
 923                 catch (Exception e)
 924                 {
 925                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 926                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 927                 }
 928
 929
 930             }
 931             else
 932             {
 933                 efl_gfx_image_scale_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale_type);
 934             }
 935         }
 936
 937         private static efl_gfx_image_scale_type_set_delegate efl_gfx_image_scale_type_set_static_delegate;
 938
 939
 940         private delegate double efl_gfx_image_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
 941
 942
 943         public delegate double efl_gfx_image_ratio_get_api_delegate(System.IntPtr obj);
 944
 945         public static Efl.Eo.FunctionWrapper<efl_gfx_image_ratio_get_api_delegate> efl_gfx_image_ratio_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_ratio_get_api_delegate>(Module, "efl_gfx_image_ratio_get");
 946
 947         private static double ratio_get(System.IntPtr obj, System.IntPtr pd)
 948         {
 949             Eina.Log.Debug("function efl_gfx_image_ratio_get was called");
 950             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 951             if (ws != null)
 952             {
 953             double _ret_var = default(double);
 954                 try
 955                 {
 956                     _ret_var = ((IImage)ws.Target).GetRatio();
 957                 }
 958                 catch (Exception e)
 959                 {
 960                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 961                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 962                 }
 963
 964         return _ret_var;
 965
 966             }
 967             else
 968             {
 969                 return efl_gfx_image_ratio_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 970             }
 971         }
 972
 973         private static efl_gfx_image_ratio_get_delegate efl_gfx_image_ratio_get_static_delegate;
 974
 975
 976         private delegate void efl_gfx_image_border_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int l,  out int r,  out int t,  out int b);
 977
 978
 979         public delegate void efl_gfx_image_border_get_api_delegate(System.IntPtr obj,  out int l,  out int r,  out int t,  out int b);
 980
 981         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_get_api_delegate> efl_gfx_image_border_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_get_api_delegate>(Module, "efl_gfx_image_border_get");
 982
 983         private static void border_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
 984         {
 985             Eina.Log.Debug("function efl_gfx_image_border_get was called");
 986             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 987             if (ws != null)
 988             {
 989                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
 990                 try
 991                 {
 992                     ((IImage)ws.Target).GetBorder(out l, out r, out t, out b);
 993                 }
 994                 catch (Exception e)
 995                 {
 996                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 997                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 998                 }
 999
1000
1001             }
1002             else
1003             {
1004                 efl_gfx_image_border_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out l, out r, out t, out b);
1005             }
1006         }
1007
1008         private static efl_gfx_image_border_get_delegate efl_gfx_image_border_get_static_delegate;
1009
1010
1011         private delegate void efl_gfx_image_border_set_delegate(System.IntPtr obj, System.IntPtr pd,  int l,  int r,  int t,  int b);
1012
1013
1014         public delegate void efl_gfx_image_border_set_api_delegate(System.IntPtr obj,  int l,  int r,  int t,  int b);
1015
1016         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_set_api_delegate> efl_gfx_image_border_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_set_api_delegate>(Module, "efl_gfx_image_border_set");
1017
1018         private static void border_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
1019         {
1020             Eina.Log.Debug("function efl_gfx_image_border_set was called");
1021             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1022             if (ws != null)
1023             {
1024
1025                 try
1026                 {
1027                     ((IImage)ws.Target).SetBorder(l, r, t, b);
1028                 }
1029                 catch (Exception e)
1030                 {
1031                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1032                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1033                 }
1034
1035
1036             }
1037             else
1038             {
1039                 efl_gfx_image_border_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), l, r, t, b);
1040             }
1041         }
1042
1043         private static efl_gfx_image_border_set_delegate efl_gfx_image_border_set_static_delegate;
1044
1045
1046         private delegate double efl_gfx_image_border_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1047
1048
1049         public delegate double efl_gfx_image_border_scale_get_api_delegate(System.IntPtr obj);
1050
1051         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_get_api_delegate> efl_gfx_image_border_scale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_get_api_delegate>(Module, "efl_gfx_image_border_scale_get");
1052
1053         private static double border_scale_get(System.IntPtr obj, System.IntPtr pd)
1054         {
1055             Eina.Log.Debug("function efl_gfx_image_border_scale_get was called");
1056             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1057             if (ws != null)
1058             {
1059             double _ret_var = default(double);
1060                 try
1061                 {
1062                     _ret_var = ((IImage)ws.Target).GetBorderScale();
1063                 }
1064                 catch (Exception e)
1065                 {
1066                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1067                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1068                 }
1069
1070         return _ret_var;
1071
1072             }
1073             else
1074             {
1075                 return efl_gfx_image_border_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1076             }
1077         }
1078
1079         private static efl_gfx_image_border_scale_get_delegate efl_gfx_image_border_scale_get_static_delegate;
1080
1081
1082         private delegate void efl_gfx_image_border_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double scale);
1083
1084
1085         public delegate void efl_gfx_image_border_scale_set_api_delegate(System.IntPtr obj,  double scale);
1086
1087         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_set_api_delegate> efl_gfx_image_border_scale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_set_api_delegate>(Module, "efl_gfx_image_border_scale_set");
1088
1089         private static void border_scale_set(System.IntPtr obj, System.IntPtr pd, double scale)
1090         {
1091             Eina.Log.Debug("function efl_gfx_image_border_scale_set was called");
1092             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1093             if (ws != null)
1094             {
1095
1096                 try
1097                 {
1098                     ((IImage)ws.Target).SetBorderScale(scale);
1099                 }
1100                 catch (Exception e)
1101                 {
1102                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1103                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1104                 }
1105
1106
1107             }
1108             else
1109             {
1110                 efl_gfx_image_border_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale);
1111             }
1112         }
1113
1114         private static efl_gfx_image_border_scale_set_delegate efl_gfx_image_border_scale_set_static_delegate;
1115
1116
1117         private delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
1118
1119
1120         public delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_api_delegate(System.IntPtr obj);
1121
1122         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_get_api_delegate> efl_gfx_image_border_center_fill_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_get_api_delegate>(Module, "efl_gfx_image_border_center_fill_get");
1123
1124         private static Efl.Gfx.BorderFillMode border_center_fill_get(System.IntPtr obj, System.IntPtr pd)
1125         {
1126             Eina.Log.Debug("function efl_gfx_image_border_center_fill_get was called");
1127             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1128             if (ws != null)
1129             {
1130             Efl.Gfx.BorderFillMode _ret_var = default(Efl.Gfx.BorderFillMode);
1131                 try
1132                 {
1133                     _ret_var = ((IImage)ws.Target).GetBorderCenterFill();
1134                 }
1135                 catch (Exception e)
1136                 {
1137                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1138                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1139                 }
1140
1141         return _ret_var;
1142
1143             }
1144             else
1145             {
1146                 return efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1147             }
1148         }
1149
1150         private static efl_gfx_image_border_center_fill_get_delegate efl_gfx_image_border_center_fill_get_static_delegate;
1151
1152
1153         private delegate void efl_gfx_image_border_center_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.BorderFillMode fill);
1154
1155
1156         public delegate void efl_gfx_image_border_center_fill_set_api_delegate(System.IntPtr obj,  Efl.Gfx.BorderFillMode fill);
1157
1158         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_set_api_delegate> efl_gfx_image_border_center_fill_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_set_api_delegate>(Module, "efl_gfx_image_border_center_fill_set");
1159
1160         private static void border_center_fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BorderFillMode fill)
1161         {
1162             Eina.Log.Debug("function efl_gfx_image_border_center_fill_set was called");
1163             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1164             if (ws != null)
1165             {
1166
1167                 try
1168                 {
1169                     ((IImage)ws.Target).SetBorderCenterFill(fill);
1170                 }
1171                 catch (Exception e)
1172                 {
1173                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1174                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1175                 }
1176
1177
1178             }
1179             else
1180             {
1181                 efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill);
1182             }
1183         }
1184
1185         private static efl_gfx_image_border_center_fill_set_delegate efl_gfx_image_border_center_fill_set_static_delegate;
1186
1187
1188         private delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1189
1190
1191         public delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_api_delegate(System.IntPtr obj);
1192
1193         public static Efl.Eo.FunctionWrapper<efl_gfx_image_size_get_api_delegate> efl_gfx_image_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_size_get_api_delegate>(Module, "efl_gfx_image_size_get");
1194
1195         private static Eina.Size2D.NativeStruct image_size_get(System.IntPtr obj, System.IntPtr pd)
1196         {
1197             Eina.Log.Debug("function efl_gfx_image_size_get was called");
1198             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1199             if (ws != null)
1200             {
1201             Eina.Size2D _ret_var = default(Eina.Size2D);
1202                 try
1203                 {
1204                     _ret_var = ((IImage)ws.Target).GetImageSize();
1205                 }
1206                 catch (Exception e)
1207                 {
1208                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1209                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1210                 }
1211
1212         return _ret_var;
1213
1214             }
1215             else
1216             {
1217                 return efl_gfx_image_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1218             }
1219         }
1220
1221         private static efl_gfx_image_size_get_delegate efl_gfx_image_size_get_static_delegate;
1222
1223
1224         private delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
1225
1226
1227         public delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_api_delegate(System.IntPtr obj);
1228
1229         public static Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_get_api_delegate> efl_gfx_image_content_hint_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_get_api_delegate>(Module, "efl_gfx_image_content_hint_get");
1230
1231         private static Efl.Gfx.ImageContentHint content_hint_get(System.IntPtr obj, System.IntPtr pd)
1232         {
1233             Eina.Log.Debug("function efl_gfx_image_content_hint_get was called");
1234             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1235             if (ws != null)
1236             {
1237             Efl.Gfx.ImageContentHint _ret_var = default(Efl.Gfx.ImageContentHint);
1238                 try
1239                 {
1240                     _ret_var = ((IImage)ws.Target).GetContentHint();
1241                 }
1242                 catch (Exception e)
1243                 {
1244                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1245                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1246                 }
1247
1248         return _ret_var;
1249
1250             }
1251             else
1252             {
1253                 return efl_gfx_image_content_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1254             }
1255         }
1256
1257         private static efl_gfx_image_content_hint_get_delegate efl_gfx_image_content_hint_get_static_delegate;
1258
1259
1260         private delegate void efl_gfx_image_content_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageContentHint hint);
1261
1262
1263         public delegate void efl_gfx_image_content_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageContentHint hint);
1264
1265         public static Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_set_api_delegate> efl_gfx_image_content_hint_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_set_api_delegate>(Module, "efl_gfx_image_content_hint_set");
1266
1267         private static void content_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageContentHint hint)
1268         {
1269             Eina.Log.Debug("function efl_gfx_image_content_hint_set was called");
1270             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1271             if (ws != null)
1272             {
1273
1274                 try
1275                 {
1276                     ((IImage)ws.Target).SetContentHint(hint);
1277                 }
1278                 catch (Exception e)
1279                 {
1280                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1281                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1282                 }
1283
1284
1285             }
1286             else
1287             {
1288                 efl_gfx_image_content_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
1289             }
1290         }
1291
1292         private static efl_gfx_image_content_hint_set_delegate efl_gfx_image_content_hint_set_static_delegate;
1293
1294
1295         private delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
1296
1297
1298         public delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_api_delegate(System.IntPtr obj);
1299
1300         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_get_api_delegate> efl_gfx_image_scale_hint_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_get_api_delegate>(Module, "efl_gfx_image_scale_hint_get");
1301
1302         private static Efl.Gfx.ImageScaleHint scale_hint_get(System.IntPtr obj, System.IntPtr pd)
1303         {
1304             Eina.Log.Debug("function efl_gfx_image_scale_hint_get was called");
1305             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1306             if (ws != null)
1307             {
1308             Efl.Gfx.ImageScaleHint _ret_var = default(Efl.Gfx.ImageScaleHint);
1309                 try
1310                 {
1311                     _ret_var = ((IImage)ws.Target).GetScaleHint();
1312                 }
1313                 catch (Exception e)
1314                 {
1315                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1316                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1317                 }
1318
1319         return _ret_var;
1320
1321             }
1322             else
1323             {
1324                 return efl_gfx_image_scale_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1325             }
1326         }
1327
1328         private static efl_gfx_image_scale_hint_get_delegate efl_gfx_image_scale_hint_get_static_delegate;
1329
1330
1331         private delegate void efl_gfx_image_scale_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleHint hint);
1332
1333
1334         public delegate void efl_gfx_image_scale_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleHint hint);
1335
1336         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_set_api_delegate> efl_gfx_image_scale_hint_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_set_api_delegate>(Module, "efl_gfx_image_scale_hint_set");
1337
1338         private static void scale_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleHint hint)
1339         {
1340             Eina.Log.Debug("function efl_gfx_image_scale_hint_set was called");
1341             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1342             if (ws != null)
1343             {
1344
1345                 try
1346                 {
1347                     ((IImage)ws.Target).SetScaleHint(hint);
1348                 }
1349                 catch (Exception e)
1350                 {
1351                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1352                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1353                 }
1354
1355
1356             }
1357             else
1358             {
1359                 efl_gfx_image_scale_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
1360             }
1361         }
1362
1363         private static efl_gfx_image_scale_hint_set_delegate efl_gfx_image_scale_hint_set_static_delegate;
1364
1365
1366         private delegate Eina.Error efl_gfx_image_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
1367
1368
1369         public delegate Eina.Error efl_gfx_image_load_error_get_api_delegate(System.IntPtr obj);
1370
1371         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_error_get_api_delegate> efl_gfx_image_load_error_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_error_get_api_delegate>(Module, "efl_gfx_image_load_error_get");
1372
1373         private static Eina.Error image_load_error_get(System.IntPtr obj, System.IntPtr pd)
1374         {
1375             Eina.Log.Debug("function efl_gfx_image_load_error_get was called");
1376             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1377             if (ws != null)
1378             {
1379             Eina.Error _ret_var = default(Eina.Error);
1380                 try
1381                 {
1382                     _ret_var = ((IImage)ws.Target).GetImageLoadError();
1383                 }
1384                 catch (Exception e)
1385                 {
1386                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1387                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1388                 }
1389
1390         return _ret_var;
1391
1392             }
1393             else
1394             {
1395                 return efl_gfx_image_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1396             }
1397         }
1398
1399         private static efl_gfx_image_load_error_get_delegate efl_gfx_image_load_error_get_static_delegate;
1400
1401         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1402
1403 }
1404 }
1405 }
1406
1407 }
1408
1409 namespace Efl {
1410
1411 namespace Gfx {
1412
1413 /// <summary>How an image&apos;s data is to be treated by EFL, for optimization.</summary>
1414 public enum ImageContentHint
1415 {
1416 /// <summary>No hint on the content (default).</summary>
1417 None = 0,
1418 /// <summary>The content will change over time.</summary>
1419 Dynamic = 1,
1420 /// <summary>The content won&apos;t change over time.</summary>
1421 Static = 2,
1422 }
1423
1424 }
1425
1426 }
1427
1428 namespace Efl {
1429
1430 namespace Gfx {
1431
1432 /// <summary>How an image&apos;s data is to be treated by EFL, with regard to scaling cache.</summary>
1433 public enum ImageScaleHint
1434 {
1435 /// <summary>No hint on the scaling (default).</summary>
1436 None = 0,
1437 /// <summary>Image will be re-scaled over time, thus turning scaling cache OFF for its data.</summary>
1438 Dynamic = 1,
1439 /// <summary>Image will not be re-scaled over time, thus turning scaling cache ON for its data.</summary>
1440 Static = 2,
1441 }
1442
1443 }
1444
1445 }
1446
1447 namespace Efl {
1448
1449 namespace Gfx {
1450
1451 /// <summary>Enumeration that defines scale types of an image.</summary>
1452 public enum ImageScaleType
1453 {
1454 /// <summary>Scale the image so that it matches the object&apos;s area exactly. The image&apos;s aspect ratio might be changed.</summary>
1455 Fill = 0,
1456 /// <summary>Scale the image so that it fits inside the object&apos;s area while maintaining the aspect ratio. At least one of the dimensions of the image should be equal to the corresponding dimension of the object.</summary>
1457 FitInside = 1,
1458 /// <summary>Scale the image so that it covers the entire object area while maintaining the aspect ratio. At least one of the dimensions of the image should be equal to the corresponding dimension of the object.</summary>
1459 FitOutside = 2,
1460 /// <summary>Tile image at its original size.</summary>
1461 Tile = 3,
1462 /// <summary>Not scale the image</summary>
1463 None = 4,
1464 }
1465
1466 }
1467
1468 }
1469