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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Ui {
  12
  13 /// <summary>Elementary widget internal part background class</summary>
  14 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  15 [Efl.Ui.WidgetPartBg.NativeMethods]
  16 [Efl.Eo.BindingEntity]
  17 public class WidgetPartBg : Efl.Ui.WidgetPart, Efl.IFile, Efl.Gfx.IColor, Efl.Gfx.IImage
  18 {
  19     /// <summary>Pointer to the native class description.</summary>
  20     public override System.IntPtr NativeClass
  21     {
  22         get
  23         {
  24             if (((object)this).GetType() == typeof(WidgetPartBg))
  25             {
  26                 return GetEflClassStatic();
  27             }
  28             else
  29             {
  30                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  31             }
  32         }
  33     }
  34
  35     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  36         efl_ui_widget_part_bg_class_get();
  37     /// <summary>Initializes a new instance of the <see cref="WidgetPartBg"/> class.</summary>
  38     /// <param name="parent">Parent instance.</param>
  39     public WidgetPartBg(Efl.Object parent= null
  40             ) : base(efl_ui_widget_part_bg_class_get(), parent)
  41     {
  42         FinishInstantiation();
  43     }
  44
  45     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  46     /// Do not call this constructor directly.</summary>
  47     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  48     protected WidgetPartBg(ConstructingHandle ch) : base(ch)
  49     {
  50     }
  51
  52     /// <summary>Initializes a new instance of the <see cref="WidgetPartBg"/> class.
  53     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  54     /// <param name="wh">The native pointer to be wrapped.</param>
  55     protected WidgetPartBg(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  56     {
  57     }
  58
  59     /// <summary>Initializes a new instance of the <see cref="WidgetPartBg"/> class.
  60     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  61     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  62     /// <param name="parent">The Efl.Object parent of this instance.</param>
  63     protected WidgetPartBg(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  64     {
  65     }
  66
  67     /// <summary>Image data has been preloaded.</summary>
  68     public event EventHandler ImagePreloadEvt
  69     {
  70         add
  71         {
  72             lock (eflBindingEventLock)
  73             {
  74                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  75                 {
  76                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  77                     if (obj != null)
  78                     {
  79                         EventArgs args = EventArgs.Empty;
  80                         try
  81                         {
  82                             value?.Invoke(obj, args);
  83                         }
  84                         catch (Exception e)
  85                         {
  86                             Eina.Log.Error(e.ToString());
  87                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  88                         }
  89                     }
  90                 };
  91
  92                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  93                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  94             }
  95         }
  96
  97         remove
  98         {
  99             lock (eflBindingEventLock)
 100             {
 101                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 102                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 103             }
 104         }
 105     }
 106     /// <summary>Method to raise event ImagePreloadEvt.</summary>
 107     public void OnImagePreloadEvt(EventArgs e)
 108     {
 109         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 110         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 111         if (desc == IntPtr.Zero)
 112         {
 113             Eina.Log.Error($"Failed to get native event {key}");
 114             return;
 115         }
 116
 117         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 118     }
 119     /// <summary>Image was resized (its pixel data).</summary>
 120     public event EventHandler ImageResizeEvt
 121     {
 122         add
 123         {
 124             lock (eflBindingEventLock)
 125             {
 126                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 127                 {
 128                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 129                     if (obj != null)
 130                     {
 131                         EventArgs args = EventArgs.Empty;
 132                         try
 133                         {
 134                             value?.Invoke(obj, args);
 135                         }
 136                         catch (Exception e)
 137                         {
 138                             Eina.Log.Error(e.ToString());
 139                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 140                         }
 141                     }
 142                 };
 143
 144                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 145                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 146             }
 147         }
 148
 149         remove
 150         {
 151             lock (eflBindingEventLock)
 152             {
 153                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 154                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 155             }
 156         }
 157     }
 158     /// <summary>Method to raise event ImageResizeEvt.</summary>
 159     public void OnImageResizeEvt(EventArgs e)
 160     {
 161         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 162         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 163         if (desc == IntPtr.Zero)
 164         {
 165             Eina.Log.Error($"Failed to get native event {key}");
 166             return;
 167         }
 168
 169         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 170     }
 171     /// <summary>Image data has been unloaded (by some mechanism in EFL that threw out the original image data).</summary>
 172     public event EventHandler ImageUnloadEvt
 173     {
 174         add
 175         {
 176             lock (eflBindingEventLock)
 177             {
 178                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 179                 {
 180                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 181                     if (obj != null)
 182                     {
 183                         EventArgs args = EventArgs.Empty;
 184                         try
 185                         {
 186                             value?.Invoke(obj, args);
 187                         }
 188                         catch (Exception e)
 189                         {
 190                             Eina.Log.Error(e.ToString());
 191                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 192                         }
 193                     }
 194                 };
 195
 196                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 197                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 198             }
 199         }
 200
 201         remove
 202         {
 203             lock (eflBindingEventLock)
 204             {
 205                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 206                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 207             }
 208         }
 209     }
 210     /// <summary>Method to raise event ImageUnloadEvt.</summary>
 211     public void OnImageUnloadEvt(EventArgs e)
 212     {
 213         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 214         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 215         if (desc == IntPtr.Zero)
 216         {
 217             Eina.Log.Error($"Failed to get native event {key}");
 218             return;
 219         }
 220
 221         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 222     }
 223     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 224     /// (Since EFL 1.22)</summary>
 225     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 226     virtual public Eina.File GetMmap() {
 227          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 228         Eina.Error.RaiseIfUnhandledException();
 229         return _ret_var;
 230  }
 231     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 232     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 233     /// (Since EFL 1.22)</summary>
 234     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 235     /// <returns>0 on success, error code otherwise</returns>
 236     virtual public Eina.Error SetMmap(Eina.File f) {
 237                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),f);
 238         Eina.Error.RaiseIfUnhandledException();
 239                         return _ret_var;
 240  }
 241     /// <summary>Retrieve the file path from where an object is to fetch the data.
 242     /// You must not modify the strings on the returned pointers.
 243     /// (Since EFL 1.22)</summary>
 244     /// <returns>The file path.</returns>
 245     virtual public System.String GetFile() {
 246          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 247         Eina.Error.RaiseIfUnhandledException();
 248         return _ret_var;
 249  }
 250     /// <summary>Set the file path from where an object will fetch the data.
 251     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 252     /// (Since EFL 1.22)</summary>
 253     /// <param name="file">The file path.</param>
 254     /// <returns>0 on success, error code otherwise</returns>
 255     virtual public Eina.Error SetFile(System.String file) {
 256                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),file);
 257         Eina.Error.RaiseIfUnhandledException();
 258                         return _ret_var;
 259  }
 260     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 261     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 262     ///
 263     /// You must not modify the strings on the returned pointers.
 264     /// (Since EFL 1.22)</summary>
 265     /// <returns>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</returns>
 266     virtual public System.String GetKey() {
 267          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_key_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 268         Eina.Error.RaiseIfUnhandledException();
 269         return _ret_var;
 270  }
 271     /// <summary>Set the key which corresponds to the target data within a file.
 272     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 273     /// (Since EFL 1.22)</summary>
 274     /// <param name="key">The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</param>
 275     virtual public void SetKey(System.String key) {
 276                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),key);
 277         Eina.Error.RaiseIfUnhandledException();
 278                          }
 279     /// <summary>Get the load state of the object.
 280     /// (Since EFL 1.22)</summary>
 281     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 282     virtual public bool GetLoaded() {
 283          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_loaded_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 284         Eina.Error.RaiseIfUnhandledException();
 285         return _ret_var;
 286  }
 287     /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.IFile.File"/> (or <see cref="Efl.IFile.Mmap"/>) and <see cref="Efl.IFile.Key"/> properties.
 288     /// In the case where <see cref="Efl.IFile.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.IFile.SetMmap"/> on the object using the opened file handle.
 289     ///
 290     /// Calling <see cref="Efl.IFile.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.
 291     /// (Since EFL 1.22)</summary>
 292     /// <returns>0 on success, error code otherwise</returns>
 293     virtual public Eina.Error Load() {
 294          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 295         Eina.Error.RaiseIfUnhandledException();
 296         return _ret_var;
 297  }
 298     /// <summary>Perform all necessary operations to unload file data from the object.
 299     /// In the case where <see cref="Efl.IFile.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
 300     ///
 301     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 302     /// (Since EFL 1.22)</summary>
 303     virtual public void Unload() {
 304          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 305         Eina.Error.RaiseIfUnhandledException();
 306          }
 307     /// <summary>Retrieves the general/main color of the given Evas object.
 308     /// Retrieves the main color&apos;s RGB component (and alpha channel) values, which range from 0 to 255. For the alpha channel, which defines the object&apos;s transparency level, 0 means totally transparent, while 255 means opaque. These color values are premultiplied by the alpha value.
 309     ///
 310     /// Usually youll use this attribute for text and rectangle objects, where the main color is their unique one. If set for objects which themselves have colors, like the images one, those colors get modulated by this one.
 311     ///
 312     /// All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
 313     ///
 314     /// Use null pointers on the components you&apos;re not interested in: they&apos;ll be ignored by the function.
 315     /// (Since EFL 1.22)</summary>
 316     virtual public void GetColor(out int r, out int g, out int b, out int a) {
 317                                                                                                          Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out r, out g, out b, out a);
 318         Eina.Error.RaiseIfUnhandledException();
 319                                                                          }
 320     /// <summary>Sets the general/main color of the given Evas object to the given one.
 321     /// See also <see cref="Efl.Gfx.IColor.GetColor"/> (for an example)
 322     ///
 323     /// These color values are expected to be premultiplied by alpha.
 324     /// (Since EFL 1.22)</summary>
 325     virtual public void SetColor(int r, int g, int b, int a) {
 326                                                                                                          Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),r, g, b, a);
 327         Eina.Error.RaiseIfUnhandledException();
 328                                                                          }
 329     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 330     /// (Since EFL 1.22)</summary>
 331     /// <returns>the hex color code.</returns>
 332     virtual public System.String GetColorCode() {
 333          var _ret_var = Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_code_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 334         Eina.Error.RaiseIfUnhandledException();
 335         return _ret_var;
 336  }
 337     /// <summary>Set the color of given Evas object to the given hex color code(#RRGGBBAA). e.g. efl_gfx_color_code_set(obj, &quot;#FFCCAACC&quot;);
 338     /// (Since EFL 1.22)</summary>
 339     /// <param name="colorcode">the hex color code.</param>
 340     virtual public void SetColorCode(System.String colorcode) {
 341                                  Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_code_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),colorcode);
 342         Eina.Error.RaiseIfUnhandledException();
 343                          }
 344     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 345     /// 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.
 346     ///
 347     /// <c>true</c> by default</summary>
 348     /// <returns>Whether to use smooth scale or not.</returns>
 349     virtual public bool GetSmoothScale() {
 350          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 351         Eina.Error.RaiseIfUnhandledException();
 352         return _ret_var;
 353  }
 354     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 355     /// 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.
 356     ///
 357     /// <c>true</c> by default</summary>
 358     /// <param name="smooth_scale">Whether to use smooth scale or not.</param>
 359     virtual public void SetSmoothScale(bool smooth_scale) {
 360                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),smooth_scale);
 361         Eina.Error.RaiseIfUnhandledException();
 362                          }
 363     /// <summary>Control how the image is scaled.</summary>
 364     /// <returns>Image scale type</returns>
 365     virtual public Efl.Gfx.ImageScaleType GetScaleType() {
 366          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 367         Eina.Error.RaiseIfUnhandledException();
 368         return _ret_var;
 369  }
 370     /// <summary>Control how the image is scaled.</summary>
 371     /// <param name="scale_type">Image scale type</param>
 372     virtual public void SetScaleType(Efl.Gfx.ImageScaleType scale_type) {
 373                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),scale_type);
 374         Eina.Error.RaiseIfUnhandledException();
 375                          }
 376     /// <summary>If <c>true</c>, the image may be scaled to a larger size. If <c>false</c>, the image will never be resized larger than its native size. This is set to <c>true</c> by default.</summary>
 377     /// <returns>Allow image upscaling</returns>
 378     virtual public bool GetCanUpscale() {
 379          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_upscale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 380         Eina.Error.RaiseIfUnhandledException();
 381         return _ret_var;
 382  }
 383     /// <summary>If <c>true</c>, the image may be scaled to a larger size. If <c>false</c>, the image will never be resized larger than its native size. This is set to <c>true</c> by default.</summary>
 384     /// <param name="upscale">Allow image upscaling</param>
 385     virtual public void SetCanUpscale(bool upscale) {
 386                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_upscale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),upscale);
 387         Eina.Error.RaiseIfUnhandledException();
 388                          }
 389     /// <summary>If <c>true</c>, the image may be scaled to a smaller size. If <c>false</c>, the image will never be resized smaller than its native size. This is set to <c>true</c> by default.</summary>
 390     /// <returns>Allow image downscaling</returns>
 391     virtual public bool GetCanDownscale() {
 392          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_downscale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 393         Eina.Error.RaiseIfUnhandledException();
 394         return _ret_var;
 395  }
 396     /// <summary>If <c>true</c>, the image may be scaled to a smaller size. If <c>false</c>, the image will never be resized smaller than its native size. This is set to <c>true</c> by default.</summary>
 397     /// <param name="downscale">Allow image downscaling</param>
 398     virtual public void SetCanDownscale(bool downscale) {
 399                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_can_downscale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),downscale);
 400         Eina.Error.RaiseIfUnhandledException();
 401                          }
 402     /// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
 403     /// <returns>The image&apos;s ratio.</returns>
 404     virtual public double GetRatio() {
 405          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_ratio_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 406         Eina.Error.RaiseIfUnhandledException();
 407         return _ret_var;
 408  }
 409     /// <summary>Return the relative area enclosed inside the image where content is expected.
 410     /// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
 411     ///
 412     /// The geometry of the area is expressed relative to the geometry of the object.</summary>
 413     /// <returns>A rectangle inside the object boundary that where content is expected.</returns>
 414     virtual public Eina.Rect GetContentRegion() {
 415          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_region_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 416         Eina.Error.RaiseIfUnhandledException();
 417         return _ret_var;
 418  }
 419     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 420     /// 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.
 421     ///
 422     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 423     ///
 424     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 425     ///
 426     /// 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.
 427     ///
 428     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 429     /// <param name="l">The border&apos;s left width.</param>
 430     /// <param name="r">The border&apos;s right width.</param>
 431     /// <param name="t">The border&apos;s top height.</param>
 432     /// <param name="b">The border&apos;s bottom height.</param>
 433     virtual public void GetBorder(out int l, out int r, out int t, out int b) {
 434                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out l, out r, out t, out b);
 435         Eina.Error.RaiseIfUnhandledException();
 436                                                                          }
 437     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 438     /// 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.
 439     ///
 440     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 441     ///
 442     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 443     ///
 444     /// 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.
 445     ///
 446     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 447     /// <param name="l">The border&apos;s left width.</param>
 448     /// <param name="r">The border&apos;s right width.</param>
 449     /// <param name="t">The border&apos;s top height.</param>
 450     /// <param name="b">The border&apos;s bottom height.</param>
 451     virtual public void SetBorder(int l, int r, int t, int b) {
 452                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),l, r, t, b);
 453         Eina.Error.RaiseIfUnhandledException();
 454                                                                          }
 455     /// <summary>Scaling factor applied to the image borders.
 456     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 457     ///
 458     /// Default value is 1.0 (no scaling).</summary>
 459     /// <returns>The scale factor.</returns>
 460     virtual public double GetBorderScale() {
 461          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 462         Eina.Error.RaiseIfUnhandledException();
 463         return _ret_var;
 464  }
 465     /// <summary>Scaling factor applied to the image borders.
 466     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 467     ///
 468     /// Default value is 1.0 (no scaling).</summary>
 469     /// <param name="scale">The scale factor.</param>
 470     virtual public void SetBorderScale(double scale) {
 471                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),scale);
 472         Eina.Error.RaiseIfUnhandledException();
 473                          }
 474     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 475     /// 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.
 476     ///
 477     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 478     /// <returns>Fill mode of the center region.</returns>
 479     virtual public Efl.Gfx.BorderFillMode GetBorderCenterFill() {
 480          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 481         Eina.Error.RaiseIfUnhandledException();
 482         return _ret_var;
 483  }
 484     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 485     /// 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.
 486     ///
 487     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 488     /// <param name="fill">Fill mode of the center region.</param>
 489     virtual public void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill) {
 490                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),fill);
 491         Eina.Error.RaiseIfUnhandledException();
 492                          }
 493     /// <summary>This property defines the stretchable pixels region of an image.
 494     /// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
 495     /// <param name="horizontal">Representation of area that are stretchable in the image horizontal space.</param>
 496     /// <param name="vertical">Representation of area that are stretchable in the image vertical space.</param>
 497     virtual public void GetStretchRegion(out Eina.Iterator<Efl.Gfx.ImageStretchRegion> horizontal, out Eina.Iterator<Efl.Gfx.ImageStretchRegion> vertical) {
 498                          System.IntPtr _out_horizontal = System.IntPtr.Zero;
 499         System.IntPtr _out_vertical = System.IntPtr.Zero;
 500                         Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_stretch_region_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out _out_horizontal, out _out_vertical);
 501         Eina.Error.RaiseIfUnhandledException();
 502         horizontal = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(_out_horizontal, false);
 503         vertical = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(_out_vertical, false);
 504                          }
 505     /// <summary>This property defines the stretchable pixels region of an image.
 506     /// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
 507     /// <param name="horizontal">Representation of area that are stretchable in the image horizontal space.</param>
 508     /// <param name="vertical">Representation of area that are stretchable in the image vertical space.</param>
 509     /// <returns>return an error code if the stretch_region provided are incorrect.</returns>
 510     virtual public Eina.Error SetStretchRegion(Eina.Iterator<Efl.Gfx.ImageStretchRegion> horizontal, Eina.Iterator<Efl.Gfx.ImageStretchRegion> vertical) {
 511          var _in_horizontal = horizontal.Handle;
 512         var _in_vertical = vertical.Handle;
 513                                         var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_stretch_region_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_horizontal, _in_vertical);
 514         Eina.Error.RaiseIfUnhandledException();
 515                                         return _ret_var;
 516  }
 517     /// <summary>This represents the size of the original image in pixels.
 518     /// 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.
 519     ///
 520     /// This is a read-only property, and may return 0x0.</summary>
 521     /// <returns>The size in pixels.</returns>
 522     virtual public Eina.Size2D GetImageSize() {
 523          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 524         Eina.Error.RaiseIfUnhandledException();
 525         return _ret_var;
 526  }
 527     /// <summary>Get the content hint setting of a given image object of the canvas.
 528     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 529     /// <returns>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></returns>
 530     virtual public Efl.Gfx.ImageContentHint GetContentHint() {
 531          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 532         Eina.Error.RaiseIfUnhandledException();
 533         return _ret_var;
 534  }
 535     /// <summary>Set the content hint setting of a given image object of the canvas.
 536     /// 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>
 537     /// <param name="hint">Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></param>
 538     virtual public void SetContentHint(Efl.Gfx.ImageContentHint hint) {
 539                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),hint);
 540         Eina.Error.RaiseIfUnhandledException();
 541                          }
 542     /// <summary>Get the scale hint of a given image of the canvas.
 543     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 544     /// <returns>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></returns>
 545     virtual public Efl.Gfx.ImageScaleHint GetScaleHint() {
 546          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 547         Eina.Error.RaiseIfUnhandledException();
 548         return _ret_var;
 549  }
 550     /// <summary>Set the scale hint of a given image of the canvas.
 551     /// 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>
 552     /// <param name="hint">Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></param>
 553     virtual public void SetScaleHint(Efl.Gfx.ImageScaleHint hint) {
 554                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),hint);
 555         Eina.Error.RaiseIfUnhandledException();
 556                          }
 557     /// <summary>Gets the (last) file loading error for a given object.</summary>
 558     /// <returns>The load error code.</returns>
 559     virtual public Eina.Error GetImageLoadError() {
 560          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_load_error_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 561         Eina.Error.RaiseIfUnhandledException();
 562         return _ret_var;
 563  }
 564     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 565     /// (Since EFL 1.22)</summary>
 566     /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 567     public Eina.File Mmap {
 568         get { return GetMmap(); }
 569         set { SetMmap(value); }
 570     }
 571     /// <summary>Retrieve the file path from where an object is to fetch the data.
 572     /// You must not modify the strings on the returned pointers.
 573     /// (Since EFL 1.22)</summary>
 574     /// <value>The file path.</value>
 575     public System.String File {
 576         get { return GetFile(); }
 577         set { SetFile(value); }
 578     }
 579     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 580     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 581     ///
 582     /// You must not modify the strings on the returned pointers.
 583     /// (Since EFL 1.22)</summary>
 584     /// <value>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</value>
 585     public System.String Key {
 586         get { return GetKey(); }
 587         set { SetKey(value); }
 588     }
 589     /// <summary>Get the load state of the object.
 590     /// (Since EFL 1.22)</summary>
 591     /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 592     public bool Loaded {
 593         get { return GetLoaded(); }
 594     }
 595     /// <summary>Retrieves the general/main color of the given Evas object.
 596     /// Retrieves the main color&apos;s RGB component (and alpha channel) values, which range from 0 to 255. For the alpha channel, which defines the object&apos;s transparency level, 0 means totally transparent, while 255 means opaque. These color values are premultiplied by the alpha value.
 597     ///
 598     /// Usually youll use this attribute for text and rectangle objects, where the main color is their unique one. If set for objects which themselves have colors, like the images one, those colors get modulated by this one.
 599     ///
 600     /// All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
 601     ///
 602     /// Use null pointers on the components you&apos;re not interested in: they&apos;ll be ignored by the function.
 603     /// (Since EFL 1.22)</summary>
 604     public (int, int, int, int) Color {
 605         get {
 606             int _out_r = default(int);
 607             int _out_g = default(int);
 608             int _out_b = default(int);
 609             int _out_a = default(int);
 610             GetColor(out _out_r,out _out_g,out _out_b,out _out_a);
 611             return (_out_r,_out_g,_out_b,_out_a);
 612         }
 613         set { SetColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 614     }
 615     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 616     /// (Since EFL 1.22)</summary>
 617     /// <value>the hex color code.</value>
 618     public System.String ColorCode {
 619         get { return GetColorCode(); }
 620         set { SetColorCode(value); }
 621     }
 622     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 623     /// 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.
 624     ///
 625     /// <c>true</c> by default</summary>
 626     /// <value>Whether to use smooth scale or not.</value>
 627     public bool SmoothScale {
 628         get { return GetSmoothScale(); }
 629         set { SetSmoothScale(value); }
 630     }
 631     /// <summary>Control how the image is scaled.</summary>
 632     /// <value>Image scale type</value>
 633     public Efl.Gfx.ImageScaleType ScaleType {
 634         get { return GetScaleType(); }
 635         set { SetScaleType(value); }
 636     }
 637     /// <summary>If <c>true</c>, the image may be scaled to a larger size. If <c>false</c>, the image will never be resized larger than its native size. This is set to <c>true</c> by default.</summary>
 638     /// <value>Allow image upscaling</value>
 639     public bool CanUpscale {
 640         get { return GetCanUpscale(); }
 641         set { SetCanUpscale(value); }
 642     }
 643     /// <summary>If <c>true</c>, the image may be scaled to a smaller size. If <c>false</c>, the image will never be resized smaller than its native size. This is set to <c>true</c> by default.</summary>
 644     /// <value>Allow image downscaling</value>
 645     public bool CanDownscale {
 646         get { return GetCanDownscale(); }
 647         set { SetCanDownscale(value); }
 648     }
 649     /// <summary>The native width/height ratio of the image.</summary>
 650     /// <value>The image&apos;s ratio.</value>
 651     public double Ratio {
 652         get { return GetRatio(); }
 653     }
 654     /// <summary>Return the relative area enclosed inside the image where content is expected.
 655     /// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
 656     ///
 657     /// The geometry of the area is expressed relative to the geometry of the object.</summary>
 658     /// <value>A rectangle inside the object boundary that where content is expected.</value>
 659     public Eina.Rect ContentRegion {
 660         get { return GetContentRegion(); }
 661     }
 662     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 663     /// 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.
 664     ///
 665     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 666     ///
 667     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 668     ///
 669     /// 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.
 670     ///
 671     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 672     /// <value>The border&apos;s left width.</value>
 673     public (int, int, int, int) Border {
 674         get {
 675             int _out_l = default(int);
 676             int _out_r = default(int);
 677             int _out_t = default(int);
 678             int _out_b = default(int);
 679             GetBorder(out _out_l,out _out_r,out _out_t,out _out_b);
 680             return (_out_l,_out_r,_out_t,_out_b);
 681         }
 682         set { SetBorder( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 683     }
 684     /// <summary>Scaling factor applied to the image borders.
 685     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 686     ///
 687     /// Default value is 1.0 (no scaling).</summary>
 688     /// <value>The scale factor.</value>
 689     public double BorderScale {
 690         get { return GetBorderScale(); }
 691         set { SetBorderScale(value); }
 692     }
 693     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 694     /// 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.
 695     ///
 696     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 697     /// <value>Fill mode of the center region.</value>
 698     public Efl.Gfx.BorderFillMode BorderCenterFill {
 699         get { return GetBorderCenterFill(); }
 700         set { SetBorderCenterFill(value); }
 701     }
 702     /// <summary>This property defines the stretchable pixels region of an image.
 703     /// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
 704     /// <value>Representation of area that are stretchable in the image horizontal space.</value>
 705     public (Eina.Iterator<Efl.Gfx.ImageStretchRegion>, Eina.Iterator<Efl.Gfx.ImageStretchRegion>) StretchRegion {
 706         get {
 707             Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_horizontal = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
 708             Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_vertical = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
 709             GetStretchRegion(out _out_horizontal,out _out_vertical);
 710             return (_out_horizontal,_out_vertical);
 711         }
 712         set { SetStretchRegion( value.Item1,  value.Item2); }
 713     }
 714     /// <summary>This represents the size of the original image in pixels.
 715     /// 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.
 716     ///
 717     /// This is a read-only property, and may return 0x0.</summary>
 718     /// <value>The size in pixels.</value>
 719     public Eina.Size2D ImageSize {
 720         get { return GetImageSize(); }
 721     }
 722     /// <summary>Get the content hint setting of a given image object of the canvas.
 723     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 724     /// <value>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></value>
 725     public Efl.Gfx.ImageContentHint ContentHint {
 726         get { return GetContentHint(); }
 727         set { SetContentHint(value); }
 728     }
 729     /// <summary>Get the scale hint of a given image of the canvas.
 730     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 731     /// <value>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></value>
 732     public Efl.Gfx.ImageScaleHint ScaleHint {
 733         get { return GetScaleHint(); }
 734         set { SetScaleHint(value); }
 735     }
 736     /// <summary>Gets the (last) file loading error for a given object.</summary>
 737     /// <value>The load error code.</value>
 738     public Eina.Error ImageLoadError {
 739         get { return GetImageLoadError(); }
 740     }
 741     private static IntPtr GetEflClassStatic()
 742     {
 743         return Efl.Ui.WidgetPartBg.efl_ui_widget_part_bg_class_get();
 744     }
 745     /// <summary>Wrapper for native methods and virtual method delegates.
 746     /// For internal use by generated code only.</summary>
 747     public new class NativeMethods : Efl.Ui.WidgetPart.NativeMethods
 748     {
 749         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 750         /// <summary>Gets the list of Eo operations to override.</summary>
 751         /// <returns>The list of Eo operations to be overload.</returns>
 752         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 753         {
 754             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 755             var methods = Efl.Eo.Globals.GetUserMethods(type);
 756
 757             if (efl_file_mmap_get_static_delegate == null)
 758             {
 759                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 760             }
 761
 762             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 763             {
 764                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_get_static_delegate) });
 765             }
 766
 767             if (efl_file_mmap_set_static_delegate == null)
 768             {
 769                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 770             }
 771
 772             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 773             {
 774                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_set_static_delegate) });
 775             }
 776
 777             if (efl_file_get_static_delegate == null)
 778             {
 779                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 780             }
 781
 782             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 783             {
 784                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_get_static_delegate) });
 785             }
 786
 787             if (efl_file_set_static_delegate == null)
 788             {
 789                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 790             }
 791
 792             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 793             {
 794                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_set_static_delegate) });
 795             }
 796
 797             if (efl_file_key_get_static_delegate == null)
 798             {
 799                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 800             }
 801
 802             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 803             {
 804                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_get_static_delegate) });
 805             }
 806
 807             if (efl_file_key_set_static_delegate == null)
 808             {
 809                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 810             }
 811
 812             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 813             {
 814                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_set_static_delegate) });
 815             }
 816
 817             if (efl_file_loaded_get_static_delegate == null)
 818             {
 819                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 820             }
 821
 822             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 823             {
 824                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_loaded_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_loaded_get_static_delegate) });
 825             }
 826
 827             if (efl_file_load_static_delegate == null)
 828             {
 829                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 830             }
 831
 832             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 833             {
 834                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_load"), func = Marshal.GetFunctionPointerForDelegate(efl_file_load_static_delegate) });
 835             }
 836
 837             if (efl_file_unload_static_delegate == null)
 838             {
 839                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 840             }
 841
 842             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 843             {
 844                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_unload"), func = Marshal.GetFunctionPointerForDelegate(efl_file_unload_static_delegate) });
 845             }
 846
 847             if (efl_gfx_color_get_static_delegate == null)
 848             {
 849                 efl_gfx_color_get_static_delegate = new efl_gfx_color_get_delegate(color_get);
 850             }
 851
 852             if (methods.FirstOrDefault(m => m.Name == "GetColor") != null)
 853             {
 854                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_get_static_delegate) });
 855             }
 856
 857             if (efl_gfx_color_set_static_delegate == null)
 858             {
 859                 efl_gfx_color_set_static_delegate = new efl_gfx_color_set_delegate(color_set);
 860             }
 861
 862             if (methods.FirstOrDefault(m => m.Name == "SetColor") != null)
 863             {
 864                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_set_static_delegate) });
 865             }
 866
 867             if (efl_gfx_color_code_get_static_delegate == null)
 868             {
 869                 efl_gfx_color_code_get_static_delegate = new efl_gfx_color_code_get_delegate(color_code_get);
 870             }
 871
 872             if (methods.FirstOrDefault(m => m.Name == "GetColorCode") != null)
 873             {
 874                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_code_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_code_get_static_delegate) });
 875             }
 876
 877             if (efl_gfx_color_code_set_static_delegate == null)
 878             {
 879                 efl_gfx_color_code_set_static_delegate = new efl_gfx_color_code_set_delegate(color_code_set);
 880             }
 881
 882             if (methods.FirstOrDefault(m => m.Name == "SetColorCode") != null)
 883             {
 884                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_code_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_code_set_static_delegate) });
 885             }
 886
 887             if (efl_gfx_image_smooth_scale_get_static_delegate == null)
 888             {
 889                 efl_gfx_image_smooth_scale_get_static_delegate = new efl_gfx_image_smooth_scale_get_delegate(smooth_scale_get);
 890             }
 891
 892             if (methods.FirstOrDefault(m => m.Name == "GetSmoothScale") != null)
 893             {
 894                 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) });
 895             }
 896
 897             if (efl_gfx_image_smooth_scale_set_static_delegate == null)
 898             {
 899                 efl_gfx_image_smooth_scale_set_static_delegate = new efl_gfx_image_smooth_scale_set_delegate(smooth_scale_set);
 900             }
 901
 902             if (methods.FirstOrDefault(m => m.Name == "SetSmoothScale") != null)
 903             {
 904                 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) });
 905             }
 906
 907             if (efl_gfx_image_scale_type_get_static_delegate == null)
 908             {
 909                 efl_gfx_image_scale_type_get_static_delegate = new efl_gfx_image_scale_type_get_delegate(scale_type_get);
 910             }
 911
 912             if (methods.FirstOrDefault(m => m.Name == "GetScaleType") != null)
 913             {
 914                 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) });
 915             }
 916
 917             if (efl_gfx_image_scale_type_set_static_delegate == null)
 918             {
 919                 efl_gfx_image_scale_type_set_static_delegate = new efl_gfx_image_scale_type_set_delegate(scale_type_set);
 920             }
 921
 922             if (methods.FirstOrDefault(m => m.Name == "SetScaleType") != null)
 923             {
 924                 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) });
 925             }
 926
 927             if (efl_gfx_image_can_upscale_get_static_delegate == null)
 928             {
 929                 efl_gfx_image_can_upscale_get_static_delegate = new efl_gfx_image_can_upscale_get_delegate(can_upscale_get);
 930             }
 931
 932             if (methods.FirstOrDefault(m => m.Name == "GetCanUpscale") != null)
 933             {
 934                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_upscale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_upscale_get_static_delegate) });
 935             }
 936
 937             if (efl_gfx_image_can_upscale_set_static_delegate == null)
 938             {
 939                 efl_gfx_image_can_upscale_set_static_delegate = new efl_gfx_image_can_upscale_set_delegate(can_upscale_set);
 940             }
 941
 942             if (methods.FirstOrDefault(m => m.Name == "SetCanUpscale") != null)
 943             {
 944                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_upscale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_upscale_set_static_delegate) });
 945             }
 946
 947             if (efl_gfx_image_can_downscale_get_static_delegate == null)
 948             {
 949                 efl_gfx_image_can_downscale_get_static_delegate = new efl_gfx_image_can_downscale_get_delegate(can_downscale_get);
 950             }
 951
 952             if (methods.FirstOrDefault(m => m.Name == "GetCanDownscale") != null)
 953             {
 954                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_downscale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_downscale_get_static_delegate) });
 955             }
 956
 957             if (efl_gfx_image_can_downscale_set_static_delegate == null)
 958             {
 959                 efl_gfx_image_can_downscale_set_static_delegate = new efl_gfx_image_can_downscale_set_delegate(can_downscale_set);
 960             }
 961
 962             if (methods.FirstOrDefault(m => m.Name == "SetCanDownscale") != null)
 963             {
 964                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_can_downscale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_can_downscale_set_static_delegate) });
 965             }
 966
 967             if (efl_gfx_image_ratio_get_static_delegate == null)
 968             {
 969                 efl_gfx_image_ratio_get_static_delegate = new efl_gfx_image_ratio_get_delegate(ratio_get);
 970             }
 971
 972             if (methods.FirstOrDefault(m => m.Name == "GetRatio") != null)
 973             {
 974                 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) });
 975             }
 976
 977             if (efl_gfx_image_content_region_get_static_delegate == null)
 978             {
 979                 efl_gfx_image_content_region_get_static_delegate = new efl_gfx_image_content_region_get_delegate(content_region_get);
 980             }
 981
 982             if (methods.FirstOrDefault(m => m.Name == "GetContentRegion") != null)
 983             {
 984                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_region_get_static_delegate) });
 985             }
 986
 987             if (efl_gfx_image_border_get_static_delegate == null)
 988             {
 989                 efl_gfx_image_border_get_static_delegate = new efl_gfx_image_border_get_delegate(border_get);
 990             }
 991
 992             if (methods.FirstOrDefault(m => m.Name == "GetBorder") != null)
 993             {
 994                 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) });
 995             }
 996
 997             if (efl_gfx_image_border_set_static_delegate == null)
 998             {
 999                 efl_gfx_image_border_set_static_delegate = new efl_gfx_image_border_set_delegate(border_set);
1000             }
1001
1002             if (methods.FirstOrDefault(m => m.Name == "SetBorder") != null)
1003             {
1004                 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) });
1005             }
1006
1007             if (efl_gfx_image_border_scale_get_static_delegate == null)
1008             {
1009                 efl_gfx_image_border_scale_get_static_delegate = new efl_gfx_image_border_scale_get_delegate(border_scale_get);
1010             }
1011
1012             if (methods.FirstOrDefault(m => m.Name == "GetBorderScale") != null)
1013             {
1014                 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) });
1015             }
1016
1017             if (efl_gfx_image_border_scale_set_static_delegate == null)
1018             {
1019                 efl_gfx_image_border_scale_set_static_delegate = new efl_gfx_image_border_scale_set_delegate(border_scale_set);
1020             }
1021
1022             if (methods.FirstOrDefault(m => m.Name == "SetBorderScale") != null)
1023             {
1024                 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) });
1025             }
1026
1027             if (efl_gfx_image_border_center_fill_get_static_delegate == null)
1028             {
1029                 efl_gfx_image_border_center_fill_get_static_delegate = new efl_gfx_image_border_center_fill_get_delegate(border_center_fill_get);
1030             }
1031
1032             if (methods.FirstOrDefault(m => m.Name == "GetBorderCenterFill") != null)
1033             {
1034                 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) });
1035             }
1036
1037             if (efl_gfx_image_border_center_fill_set_static_delegate == null)
1038             {
1039                 efl_gfx_image_border_center_fill_set_static_delegate = new efl_gfx_image_border_center_fill_set_delegate(border_center_fill_set);
1040             }
1041
1042             if (methods.FirstOrDefault(m => m.Name == "SetBorderCenterFill") != null)
1043             {
1044                 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) });
1045             }
1046
1047             if (efl_gfx_image_stretch_region_get_static_delegate == null)
1048             {
1049                 efl_gfx_image_stretch_region_get_static_delegate = new efl_gfx_image_stretch_region_get_delegate(stretch_region_get);
1050             }
1051
1052             if (methods.FirstOrDefault(m => m.Name == "GetStretchRegion") != null)
1053             {
1054                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_stretch_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_stretch_region_get_static_delegate) });
1055             }
1056
1057             if (efl_gfx_image_stretch_region_set_static_delegate == null)
1058             {
1059                 efl_gfx_image_stretch_region_set_static_delegate = new efl_gfx_image_stretch_region_set_delegate(stretch_region_set);
1060             }
1061
1062             if (methods.FirstOrDefault(m => m.Name == "SetStretchRegion") != null)
1063             {
1064                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_stretch_region_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_stretch_region_set_static_delegate) });
1065             }
1066
1067             if (efl_gfx_image_size_get_static_delegate == null)
1068             {
1069                 efl_gfx_image_size_get_static_delegate = new efl_gfx_image_size_get_delegate(image_size_get);
1070             }
1071
1072             if (methods.FirstOrDefault(m => m.Name == "GetImageSize") != null)
1073             {
1074                 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) });
1075             }
1076
1077             if (efl_gfx_image_content_hint_get_static_delegate == null)
1078             {
1079                 efl_gfx_image_content_hint_get_static_delegate = new efl_gfx_image_content_hint_get_delegate(content_hint_get);
1080             }
1081
1082             if (methods.FirstOrDefault(m => m.Name == "GetContentHint") != null)
1083             {
1084                 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) });
1085             }
1086
1087             if (efl_gfx_image_content_hint_set_static_delegate == null)
1088             {
1089                 efl_gfx_image_content_hint_set_static_delegate = new efl_gfx_image_content_hint_set_delegate(content_hint_set);
1090             }
1091
1092             if (methods.FirstOrDefault(m => m.Name == "SetContentHint") != null)
1093             {
1094                 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) });
1095             }
1096
1097             if (efl_gfx_image_scale_hint_get_static_delegate == null)
1098             {
1099                 efl_gfx_image_scale_hint_get_static_delegate = new efl_gfx_image_scale_hint_get_delegate(scale_hint_get);
1100             }
1101
1102             if (methods.FirstOrDefault(m => m.Name == "GetScaleHint") != null)
1103             {
1104                 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) });
1105             }
1106
1107             if (efl_gfx_image_scale_hint_set_static_delegate == null)
1108             {
1109                 efl_gfx_image_scale_hint_set_static_delegate = new efl_gfx_image_scale_hint_set_delegate(scale_hint_set);
1110             }
1111
1112             if (methods.FirstOrDefault(m => m.Name == "SetScaleHint") != null)
1113             {
1114                 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) });
1115             }
1116
1117             if (efl_gfx_image_load_error_get_static_delegate == null)
1118             {
1119                 efl_gfx_image_load_error_get_static_delegate = new efl_gfx_image_load_error_get_delegate(image_load_error_get);
1120             }
1121
1122             if (methods.FirstOrDefault(m => m.Name == "GetImageLoadError") != null)
1123             {
1124                 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) });
1125             }
1126
1127             descs.AddRange(base.GetEoOps(type));
1128             return descs;
1129         }
1130         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1131         /// <returns>The native class pointer.</returns>
1132         public override IntPtr GetEflClass()
1133         {
1134             return Efl.Ui.WidgetPartBg.efl_ui_widget_part_bg_class_get();
1135         }
1136
1137         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1138
1139
1140         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1141
1142
1143         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
1144
1145         public static Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate> efl_file_mmap_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate>(Module, "efl_file_mmap_get");
1146
1147         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
1148         {
1149             Eina.Log.Debug("function efl_file_mmap_get was called");
1150             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1151             if (ws != null)
1152             {
1153             Eina.File _ret_var = default(Eina.File);
1154                 try
1155                 {
1156                     _ret_var = ((WidgetPartBg)ws.Target).GetMmap();
1157                 }
1158                 catch (Exception e)
1159                 {
1160                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1161                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1162                 }
1163
1164         return _ret_var;
1165
1166             }
1167             else
1168             {
1169                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1170             }
1171         }
1172
1173         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
1174
1175
1176         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
1177
1178
1179         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
1180
1181         public static Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate> efl_file_mmap_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate>(Module, "efl_file_mmap_set");
1182
1183         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
1184         {
1185             Eina.Log.Debug("function efl_file_mmap_set was called");
1186             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1187             if (ws != null)
1188             {
1189                                     Eina.Error _ret_var = default(Eina.Error);
1190                 try
1191                 {
1192                     _ret_var = ((WidgetPartBg)ws.Target).SetMmap(f);
1193                 }
1194                 catch (Exception e)
1195                 {
1196                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1197                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1198                 }
1199
1200                         return _ret_var;
1201
1202             }
1203             else
1204             {
1205                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
1206             }
1207         }
1208
1209         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
1210
1211         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1212         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
1213
1214         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1215         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
1216
1217         public static Efl.Eo.FunctionWrapper<efl_file_get_api_delegate> efl_file_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_get_api_delegate>(Module, "efl_file_get");
1218
1219         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
1220         {
1221             Eina.Log.Debug("function efl_file_get was called");
1222             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1223             if (ws != null)
1224             {
1225             System.String _ret_var = default(System.String);
1226                 try
1227                 {
1228                     _ret_var = ((WidgetPartBg)ws.Target).GetFile();
1229                 }
1230                 catch (Exception e)
1231                 {
1232                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1233                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1234                 }
1235
1236         return _ret_var;
1237
1238             }
1239             else
1240             {
1241                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1242             }
1243         }
1244
1245         private static efl_file_get_delegate efl_file_get_static_delegate;
1246
1247
1248         private delegate Eina.Error efl_file_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1249
1250
1251         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1252
1253         public static Efl.Eo.FunctionWrapper<efl_file_set_api_delegate> efl_file_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_set_api_delegate>(Module, "efl_file_set");
1254
1255         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
1256         {
1257             Eina.Log.Debug("function efl_file_set was called");
1258             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1259             if (ws != null)
1260             {
1261                                     Eina.Error _ret_var = default(Eina.Error);
1262                 try
1263                 {
1264                     _ret_var = ((WidgetPartBg)ws.Target).SetFile(file);
1265                 }
1266                 catch (Exception e)
1267                 {
1268                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1269                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1270                 }
1271
1272                         return _ret_var;
1273
1274             }
1275             else
1276             {
1277                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
1278             }
1279         }
1280
1281         private static efl_file_set_delegate efl_file_set_static_delegate;
1282
1283         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1284         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
1285
1286         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1287         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
1288
1289         public static Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate> efl_file_key_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate>(Module, "efl_file_key_get");
1290
1291         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
1292         {
1293             Eina.Log.Debug("function efl_file_key_get was called");
1294             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1295             if (ws != null)
1296             {
1297             System.String _ret_var = default(System.String);
1298                 try
1299                 {
1300                     _ret_var = ((WidgetPartBg)ws.Target).GetKey();
1301                 }
1302                 catch (Exception e)
1303                 {
1304                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1305                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1306                 }
1307
1308         return _ret_var;
1309
1310             }
1311             else
1312             {
1313                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1314             }
1315         }
1316
1317         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
1318
1319
1320         private delegate void efl_file_key_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1321
1322
1323         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1324
1325         public static Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate> efl_file_key_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate>(Module, "efl_file_key_set");
1326
1327         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
1328         {
1329             Eina.Log.Debug("function efl_file_key_set was called");
1330             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1331             if (ws != null)
1332             {
1333
1334                 try
1335                 {
1336                     ((WidgetPartBg)ws.Target).SetKey(key);
1337                 }
1338                 catch (Exception e)
1339                 {
1340                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1341                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1342                 }
1343
1344
1345             }
1346             else
1347             {
1348                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1349             }
1350         }
1351
1352         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
1353
1354         [return: MarshalAs(UnmanagedType.U1)]
1355         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
1356
1357         [return: MarshalAs(UnmanagedType.U1)]
1358         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
1359
1360         public static Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate> efl_file_loaded_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate>(Module, "efl_file_loaded_get");
1361
1362         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
1363         {
1364             Eina.Log.Debug("function efl_file_loaded_get was called");
1365             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1366             if (ws != null)
1367             {
1368             bool _ret_var = default(bool);
1369                 try
1370                 {
1371                     _ret_var = ((WidgetPartBg)ws.Target).GetLoaded();
1372                 }
1373                 catch (Exception e)
1374                 {
1375                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1376                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1377                 }
1378
1379         return _ret_var;
1380
1381             }
1382             else
1383             {
1384                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1385             }
1386         }
1387
1388         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
1389
1390
1391         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
1392
1393
1394         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
1395
1396         public static Efl.Eo.FunctionWrapper<efl_file_load_api_delegate> efl_file_load_ptr = new Efl.Eo.FunctionWrapper<efl_file_load_api_delegate>(Module, "efl_file_load");
1397
1398         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
1399         {
1400             Eina.Log.Debug("function efl_file_load was called");
1401             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1402             if (ws != null)
1403             {
1404             Eina.Error _ret_var = default(Eina.Error);
1405                 try
1406                 {
1407                     _ret_var = ((WidgetPartBg)ws.Target).Load();
1408                 }
1409                 catch (Exception e)
1410                 {
1411                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1412                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1413                 }
1414
1415         return _ret_var;
1416
1417             }
1418             else
1419             {
1420                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1421             }
1422         }
1423
1424         private static efl_file_load_delegate efl_file_load_static_delegate;
1425
1426
1427         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
1428
1429
1430         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
1431
1432         public static Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate> efl_file_unload_ptr = new Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate>(Module, "efl_file_unload");
1433
1434         private static void unload(System.IntPtr obj, System.IntPtr pd)
1435         {
1436             Eina.Log.Debug("function efl_file_unload was called");
1437             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1438             if (ws != null)
1439             {
1440
1441                 try
1442                 {
1443                     ((WidgetPartBg)ws.Target).Unload();
1444                 }
1445                 catch (Exception e)
1446                 {
1447                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1448                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1449                 }
1450
1451
1452             }
1453             else
1454             {
1455                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1456             }
1457         }
1458
1459         private static efl_file_unload_delegate efl_file_unload_static_delegate;
1460
1461
1462         private delegate void efl_gfx_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int r,  out int g,  out int b,  out int a);
1463
1464
1465         public delegate void efl_gfx_color_get_api_delegate(System.IntPtr obj,  out int r,  out int g,  out int b,  out int a);
1466
1467         public static Efl.Eo.FunctionWrapper<efl_gfx_color_get_api_delegate> efl_gfx_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_get_api_delegate>(Module, "efl_gfx_color_get");
1468
1469         private static void color_get(System.IntPtr obj, System.IntPtr pd, out int r, out int g, out int b, out int a)
1470         {
1471             Eina.Log.Debug("function efl_gfx_color_get was called");
1472             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1473             if (ws != null)
1474             {
1475                                         r = default(int);        g = default(int);        b = default(int);        a = default(int);
1476                 try
1477                 {
1478                     ((WidgetPartBg)ws.Target).GetColor(out r, out g, out b, out a);
1479                 }
1480                 catch (Exception e)
1481                 {
1482                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1483                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1484                 }
1485
1486
1487             }
1488             else
1489             {
1490                 efl_gfx_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
1491             }
1492         }
1493
1494         private static efl_gfx_color_get_delegate efl_gfx_color_get_static_delegate;
1495
1496
1497         private delegate void efl_gfx_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  int r,  int g,  int b,  int a);
1498
1499
1500         public delegate void efl_gfx_color_set_api_delegate(System.IntPtr obj,  int r,  int g,  int b,  int a);
1501
1502         public static Efl.Eo.FunctionWrapper<efl_gfx_color_set_api_delegate> efl_gfx_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_set_api_delegate>(Module, "efl_gfx_color_set");
1503
1504         private static void color_set(System.IntPtr obj, System.IntPtr pd, int r, int g, int b, int a)
1505         {
1506             Eina.Log.Debug("function efl_gfx_color_set was called");
1507             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1508             if (ws != null)
1509             {
1510
1511                 try
1512                 {
1513                     ((WidgetPartBg)ws.Target).SetColor(r, g, b, a);
1514                 }
1515                 catch (Exception e)
1516                 {
1517                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1518                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1519                 }
1520
1521
1522             }
1523             else
1524             {
1525                 efl_gfx_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
1526             }
1527         }
1528
1529         private static efl_gfx_color_set_delegate efl_gfx_color_set_static_delegate;
1530
1531         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1532         private delegate System.String efl_gfx_color_code_get_delegate(System.IntPtr obj, System.IntPtr pd);
1533
1534         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1535         public delegate System.String efl_gfx_color_code_get_api_delegate(System.IntPtr obj);
1536
1537         public static Efl.Eo.FunctionWrapper<efl_gfx_color_code_get_api_delegate> efl_gfx_color_code_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_code_get_api_delegate>(Module, "efl_gfx_color_code_get");
1538
1539         private static System.String color_code_get(System.IntPtr obj, System.IntPtr pd)
1540         {
1541             Eina.Log.Debug("function efl_gfx_color_code_get was called");
1542             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1543             if (ws != null)
1544             {
1545             System.String _ret_var = default(System.String);
1546                 try
1547                 {
1548                     _ret_var = ((WidgetPartBg)ws.Target).GetColorCode();
1549                 }
1550                 catch (Exception e)
1551                 {
1552                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1553                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1554                 }
1555
1556         return _ret_var;
1557
1558             }
1559             else
1560             {
1561                 return efl_gfx_color_code_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1562             }
1563         }
1564
1565         private static efl_gfx_color_code_get_delegate efl_gfx_color_code_get_static_delegate;
1566
1567
1568         private delegate void efl_gfx_color_code_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String colorcode);
1569
1570
1571         public delegate void efl_gfx_color_code_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String colorcode);
1572
1573         public static Efl.Eo.FunctionWrapper<efl_gfx_color_code_set_api_delegate> efl_gfx_color_code_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_code_set_api_delegate>(Module, "efl_gfx_color_code_set");
1574
1575         private static void color_code_set(System.IntPtr obj, System.IntPtr pd, System.String colorcode)
1576         {
1577             Eina.Log.Debug("function efl_gfx_color_code_set was called");
1578             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1579             if (ws != null)
1580             {
1581
1582                 try
1583                 {
1584                     ((WidgetPartBg)ws.Target).SetColorCode(colorcode);
1585                 }
1586                 catch (Exception e)
1587                 {
1588                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1589                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1590                 }
1591
1592
1593             }
1594             else
1595             {
1596                 efl_gfx_color_code_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), colorcode);
1597             }
1598         }
1599
1600         private static efl_gfx_color_code_set_delegate efl_gfx_color_code_set_static_delegate;
1601
1602         [return: MarshalAs(UnmanagedType.U1)]
1603         private delegate bool efl_gfx_image_smooth_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1604
1605         [return: MarshalAs(UnmanagedType.U1)]
1606         public delegate bool efl_gfx_image_smooth_scale_get_api_delegate(System.IntPtr obj);
1607
1608         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");
1609
1610         private static bool smooth_scale_get(System.IntPtr obj, System.IntPtr pd)
1611         {
1612             Eina.Log.Debug("function efl_gfx_image_smooth_scale_get was called");
1613             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1614             if (ws != null)
1615             {
1616             bool _ret_var = default(bool);
1617                 try
1618                 {
1619                     _ret_var = ((WidgetPartBg)ws.Target).GetSmoothScale();
1620                 }
1621                 catch (Exception e)
1622                 {
1623                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1624                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1625                 }
1626
1627         return _ret_var;
1628
1629             }
1630             else
1631             {
1632                 return efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1633             }
1634         }
1635
1636         private static efl_gfx_image_smooth_scale_get_delegate efl_gfx_image_smooth_scale_get_static_delegate;
1637
1638
1639         private delegate void efl_gfx_image_smooth_scale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
1640
1641
1642         public delegate void efl_gfx_image_smooth_scale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
1643
1644         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");
1645
1646         private static void smooth_scale_set(System.IntPtr obj, System.IntPtr pd, bool smooth_scale)
1647         {
1648             Eina.Log.Debug("function efl_gfx_image_smooth_scale_set was called");
1649             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1650             if (ws != null)
1651             {
1652
1653                 try
1654                 {
1655                     ((WidgetPartBg)ws.Target).SetSmoothScale(smooth_scale);
1656                 }
1657                 catch (Exception e)
1658                 {
1659                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1660                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1661                 }
1662
1663
1664             }
1665             else
1666             {
1667                 efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth_scale);
1668             }
1669         }
1670
1671         private static efl_gfx_image_smooth_scale_set_delegate efl_gfx_image_smooth_scale_set_static_delegate;
1672
1673
1674         private delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1675
1676
1677         public delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_api_delegate(System.IntPtr obj);
1678
1679         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");
1680
1681         private static Efl.Gfx.ImageScaleType scale_type_get(System.IntPtr obj, System.IntPtr pd)
1682         {
1683             Eina.Log.Debug("function efl_gfx_image_scale_type_get was called");
1684             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1685             if (ws != null)
1686             {
1687             Efl.Gfx.ImageScaleType _ret_var = default(Efl.Gfx.ImageScaleType);
1688                 try
1689                 {
1690                     _ret_var = ((WidgetPartBg)ws.Target).GetScaleType();
1691                 }
1692                 catch (Exception e)
1693                 {
1694                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1695                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1696                 }
1697
1698         return _ret_var;
1699
1700             }
1701             else
1702             {
1703                 return efl_gfx_image_scale_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1704             }
1705         }
1706
1707         private static efl_gfx_image_scale_type_get_delegate efl_gfx_image_scale_type_get_static_delegate;
1708
1709
1710         private delegate void efl_gfx_image_scale_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleType scale_type);
1711
1712
1713         public delegate void efl_gfx_image_scale_type_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleType scale_type);
1714
1715         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");
1716
1717         private static void scale_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleType scale_type)
1718         {
1719             Eina.Log.Debug("function efl_gfx_image_scale_type_set was called");
1720             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1721             if (ws != null)
1722             {
1723
1724                 try
1725                 {
1726                     ((WidgetPartBg)ws.Target).SetScaleType(scale_type);
1727                 }
1728                 catch (Exception e)
1729                 {
1730                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1731                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1732                 }
1733
1734
1735             }
1736             else
1737             {
1738                 efl_gfx_image_scale_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale_type);
1739             }
1740         }
1741
1742         private static efl_gfx_image_scale_type_set_delegate efl_gfx_image_scale_type_set_static_delegate;
1743
1744         [return: MarshalAs(UnmanagedType.U1)]
1745         private delegate bool efl_gfx_image_can_upscale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1746
1747         [return: MarshalAs(UnmanagedType.U1)]
1748         public delegate bool efl_gfx_image_can_upscale_get_api_delegate(System.IntPtr obj);
1749
1750         public static Efl.Eo.FunctionWrapper<efl_gfx_image_can_upscale_get_api_delegate> efl_gfx_image_can_upscale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_upscale_get_api_delegate>(Module, "efl_gfx_image_can_upscale_get");
1751
1752         private static bool can_upscale_get(System.IntPtr obj, System.IntPtr pd)
1753         {
1754             Eina.Log.Debug("function efl_gfx_image_can_upscale_get was called");
1755             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1756             if (ws != null)
1757             {
1758             bool _ret_var = default(bool);
1759                 try
1760                 {
1761                     _ret_var = ((WidgetPartBg)ws.Target).GetCanUpscale();
1762                 }
1763                 catch (Exception e)
1764                 {
1765                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1766                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1767                 }
1768
1769         return _ret_var;
1770
1771             }
1772             else
1773             {
1774                 return efl_gfx_image_can_upscale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1775             }
1776         }
1777
1778         private static efl_gfx_image_can_upscale_get_delegate efl_gfx_image_can_upscale_get_static_delegate;
1779
1780
1781         private delegate void efl_gfx_image_can_upscale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool upscale);
1782
1783
1784         public delegate void efl_gfx_image_can_upscale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool upscale);
1785
1786         public static Efl.Eo.FunctionWrapper<efl_gfx_image_can_upscale_set_api_delegate> efl_gfx_image_can_upscale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_upscale_set_api_delegate>(Module, "efl_gfx_image_can_upscale_set");
1787
1788         private static void can_upscale_set(System.IntPtr obj, System.IntPtr pd, bool upscale)
1789         {
1790             Eina.Log.Debug("function efl_gfx_image_can_upscale_set was called");
1791             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1792             if (ws != null)
1793             {
1794
1795                 try
1796                 {
1797                     ((WidgetPartBg)ws.Target).SetCanUpscale(upscale);
1798                 }
1799                 catch (Exception e)
1800                 {
1801                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1802                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1803                 }
1804
1805
1806             }
1807             else
1808             {
1809                 efl_gfx_image_can_upscale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), upscale);
1810             }
1811         }
1812
1813         private static efl_gfx_image_can_upscale_set_delegate efl_gfx_image_can_upscale_set_static_delegate;
1814
1815         [return: MarshalAs(UnmanagedType.U1)]
1816         private delegate bool efl_gfx_image_can_downscale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1817
1818         [return: MarshalAs(UnmanagedType.U1)]
1819         public delegate bool efl_gfx_image_can_downscale_get_api_delegate(System.IntPtr obj);
1820
1821         public static Efl.Eo.FunctionWrapper<efl_gfx_image_can_downscale_get_api_delegate> efl_gfx_image_can_downscale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_downscale_get_api_delegate>(Module, "efl_gfx_image_can_downscale_get");
1822
1823         private static bool can_downscale_get(System.IntPtr obj, System.IntPtr pd)
1824         {
1825             Eina.Log.Debug("function efl_gfx_image_can_downscale_get was called");
1826             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1827             if (ws != null)
1828             {
1829             bool _ret_var = default(bool);
1830                 try
1831                 {
1832                     _ret_var = ((WidgetPartBg)ws.Target).GetCanDownscale();
1833                 }
1834                 catch (Exception e)
1835                 {
1836                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1837                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1838                 }
1839
1840         return _ret_var;
1841
1842             }
1843             else
1844             {
1845                 return efl_gfx_image_can_downscale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1846             }
1847         }
1848
1849         private static efl_gfx_image_can_downscale_get_delegate efl_gfx_image_can_downscale_get_static_delegate;
1850
1851
1852         private delegate void efl_gfx_image_can_downscale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool downscale);
1853
1854
1855         public delegate void efl_gfx_image_can_downscale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool downscale);
1856
1857         public static Efl.Eo.FunctionWrapper<efl_gfx_image_can_downscale_set_api_delegate> efl_gfx_image_can_downscale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_can_downscale_set_api_delegate>(Module, "efl_gfx_image_can_downscale_set");
1858
1859         private static void can_downscale_set(System.IntPtr obj, System.IntPtr pd, bool downscale)
1860         {
1861             Eina.Log.Debug("function efl_gfx_image_can_downscale_set was called");
1862             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1863             if (ws != null)
1864             {
1865
1866                 try
1867                 {
1868                     ((WidgetPartBg)ws.Target).SetCanDownscale(downscale);
1869                 }
1870                 catch (Exception e)
1871                 {
1872                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1873                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1874                 }
1875
1876
1877             }
1878             else
1879             {
1880                 efl_gfx_image_can_downscale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), downscale);
1881             }
1882         }
1883
1884         private static efl_gfx_image_can_downscale_set_delegate efl_gfx_image_can_downscale_set_static_delegate;
1885
1886
1887         private delegate double efl_gfx_image_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
1888
1889
1890         public delegate double efl_gfx_image_ratio_get_api_delegate(System.IntPtr obj);
1891
1892         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");
1893
1894         private static double ratio_get(System.IntPtr obj, System.IntPtr pd)
1895         {
1896             Eina.Log.Debug("function efl_gfx_image_ratio_get was called");
1897             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1898             if (ws != null)
1899             {
1900             double _ret_var = default(double);
1901                 try
1902                 {
1903                     _ret_var = ((WidgetPartBg)ws.Target).GetRatio();
1904                 }
1905                 catch (Exception e)
1906                 {
1907                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1908                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1909                 }
1910
1911         return _ret_var;
1912
1913             }
1914             else
1915             {
1916                 return efl_gfx_image_ratio_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1917             }
1918         }
1919
1920         private static efl_gfx_image_ratio_get_delegate efl_gfx_image_ratio_get_static_delegate;
1921
1922
1923         private delegate Eina.Rect.NativeStruct efl_gfx_image_content_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
1924
1925
1926         public delegate Eina.Rect.NativeStruct efl_gfx_image_content_region_get_api_delegate(System.IntPtr obj);
1927
1928         public static Efl.Eo.FunctionWrapper<efl_gfx_image_content_region_get_api_delegate> efl_gfx_image_content_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_content_region_get_api_delegate>(Module, "efl_gfx_image_content_region_get");
1929
1930         private static Eina.Rect.NativeStruct content_region_get(System.IntPtr obj, System.IntPtr pd)
1931         {
1932             Eina.Log.Debug("function efl_gfx_image_content_region_get was called");
1933             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1934             if (ws != null)
1935             {
1936             Eina.Rect _ret_var = default(Eina.Rect);
1937                 try
1938                 {
1939                     _ret_var = ((WidgetPartBg)ws.Target).GetContentRegion();
1940                 }
1941                 catch (Exception e)
1942                 {
1943                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1944                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1945                 }
1946
1947         return _ret_var;
1948
1949             }
1950             else
1951             {
1952                 return efl_gfx_image_content_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1953             }
1954         }
1955
1956         private static efl_gfx_image_content_region_get_delegate efl_gfx_image_content_region_get_static_delegate;
1957
1958
1959         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);
1960
1961
1962         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);
1963
1964         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");
1965
1966         private static void border_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
1967         {
1968             Eina.Log.Debug("function efl_gfx_image_border_get was called");
1969             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1970             if (ws != null)
1971             {
1972                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
1973                 try
1974                 {
1975                     ((WidgetPartBg)ws.Target).GetBorder(out l, out r, out t, out b);
1976                 }
1977                 catch (Exception e)
1978                 {
1979                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1980                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1981                 }
1982
1983
1984             }
1985             else
1986             {
1987                 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);
1988             }
1989         }
1990
1991         private static efl_gfx_image_border_get_delegate efl_gfx_image_border_get_static_delegate;
1992
1993
1994         private delegate void efl_gfx_image_border_set_delegate(System.IntPtr obj, System.IntPtr pd,  int l,  int r,  int t,  int b);
1995
1996
1997         public delegate void efl_gfx_image_border_set_api_delegate(System.IntPtr obj,  int l,  int r,  int t,  int b);
1998
1999         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");
2000
2001         private static void border_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
2002         {
2003             Eina.Log.Debug("function efl_gfx_image_border_set was called");
2004             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2005             if (ws != null)
2006             {
2007
2008                 try
2009                 {
2010                     ((WidgetPartBg)ws.Target).SetBorder(l, r, t, b);
2011                 }
2012                 catch (Exception e)
2013                 {
2014                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2015                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2016                 }
2017
2018
2019             }
2020             else
2021             {
2022                 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);
2023             }
2024         }
2025
2026         private static efl_gfx_image_border_set_delegate efl_gfx_image_border_set_static_delegate;
2027
2028
2029         private delegate double efl_gfx_image_border_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
2030
2031
2032         public delegate double efl_gfx_image_border_scale_get_api_delegate(System.IntPtr obj);
2033
2034         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");
2035
2036         private static double border_scale_get(System.IntPtr obj, System.IntPtr pd)
2037         {
2038             Eina.Log.Debug("function efl_gfx_image_border_scale_get was called");
2039             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2040             if (ws != null)
2041             {
2042             double _ret_var = default(double);
2043                 try
2044                 {
2045                     _ret_var = ((WidgetPartBg)ws.Target).GetBorderScale();
2046                 }
2047                 catch (Exception e)
2048                 {
2049                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2050                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2051                 }
2052
2053         return _ret_var;
2054
2055             }
2056             else
2057             {
2058                 return efl_gfx_image_border_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2059             }
2060         }
2061
2062         private static efl_gfx_image_border_scale_get_delegate efl_gfx_image_border_scale_get_static_delegate;
2063
2064
2065         private delegate void efl_gfx_image_border_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double scale);
2066
2067
2068         public delegate void efl_gfx_image_border_scale_set_api_delegate(System.IntPtr obj,  double scale);
2069
2070         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");
2071
2072         private static void border_scale_set(System.IntPtr obj, System.IntPtr pd, double scale)
2073         {
2074             Eina.Log.Debug("function efl_gfx_image_border_scale_set was called");
2075             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2076             if (ws != null)
2077             {
2078
2079                 try
2080                 {
2081                     ((WidgetPartBg)ws.Target).SetBorderScale(scale);
2082                 }
2083                 catch (Exception e)
2084                 {
2085                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2086                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2087                 }
2088
2089
2090             }
2091             else
2092             {
2093                 efl_gfx_image_border_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale);
2094             }
2095         }
2096
2097         private static efl_gfx_image_border_scale_set_delegate efl_gfx_image_border_scale_set_static_delegate;
2098
2099
2100         private delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
2101
2102
2103         public delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_api_delegate(System.IntPtr obj);
2104
2105         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");
2106
2107         private static Efl.Gfx.BorderFillMode border_center_fill_get(System.IntPtr obj, System.IntPtr pd)
2108         {
2109             Eina.Log.Debug("function efl_gfx_image_border_center_fill_get was called");
2110             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2111             if (ws != null)
2112             {
2113             Efl.Gfx.BorderFillMode _ret_var = default(Efl.Gfx.BorderFillMode);
2114                 try
2115                 {
2116                     _ret_var = ((WidgetPartBg)ws.Target).GetBorderCenterFill();
2117                 }
2118                 catch (Exception e)
2119                 {
2120                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2121                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2122                 }
2123
2124         return _ret_var;
2125
2126             }
2127             else
2128             {
2129                 return efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2130             }
2131         }
2132
2133         private static efl_gfx_image_border_center_fill_get_delegate efl_gfx_image_border_center_fill_get_static_delegate;
2134
2135
2136         private delegate void efl_gfx_image_border_center_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.BorderFillMode fill);
2137
2138
2139         public delegate void efl_gfx_image_border_center_fill_set_api_delegate(System.IntPtr obj,  Efl.Gfx.BorderFillMode fill);
2140
2141         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");
2142
2143         private static void border_center_fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BorderFillMode fill)
2144         {
2145             Eina.Log.Debug("function efl_gfx_image_border_center_fill_set was called");
2146             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2147             if (ws != null)
2148             {
2149
2150                 try
2151                 {
2152                     ((WidgetPartBg)ws.Target).SetBorderCenterFill(fill);
2153                 }
2154                 catch (Exception e)
2155                 {
2156                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2157                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2158                 }
2159
2160
2161             }
2162             else
2163             {
2164                 efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill);
2165             }
2166         }
2167
2168         private static efl_gfx_image_border_center_fill_set_delegate efl_gfx_image_border_center_fill_set_static_delegate;
2169
2170
2171         private delegate void efl_gfx_image_stretch_region_get_delegate(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr horizontal,  out System.IntPtr vertical);
2172
2173
2174         public delegate void efl_gfx_image_stretch_region_get_api_delegate(System.IntPtr obj,  out System.IntPtr horizontal,  out System.IntPtr vertical);
2175
2176         public static Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_get_api_delegate> efl_gfx_image_stretch_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_get_api_delegate>(Module, "efl_gfx_image_stretch_region_get");
2177
2178         private static void stretch_region_get(System.IntPtr obj, System.IntPtr pd, out System.IntPtr horizontal, out System.IntPtr vertical)
2179         {
2180             Eina.Log.Debug("function efl_gfx_image_stretch_region_get was called");
2181             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2182             if (ws != null)
2183             {
2184                         Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_horizontal = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
2185         Eina.Iterator<Efl.Gfx.ImageStretchRegion> _out_vertical = default(Eina.Iterator<Efl.Gfx.ImageStretchRegion>);
2186
2187                 try
2188                 {
2189                     ((WidgetPartBg)ws.Target).GetStretchRegion(out _out_horizontal, out _out_vertical);
2190                 }
2191                 catch (Exception e)
2192                 {
2193                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2194                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2195                 }
2196
2197         horizontal = _out_horizontal.Handle;
2198         vertical = _out_vertical.Handle;
2199
2200             }
2201             else
2202             {
2203                 efl_gfx_image_stretch_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out horizontal, out vertical);
2204             }
2205         }
2206
2207         private static efl_gfx_image_stretch_region_get_delegate efl_gfx_image_stretch_region_get_static_delegate;
2208
2209
2210         private delegate Eina.Error efl_gfx_image_stretch_region_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr horizontal,  System.IntPtr vertical);
2211
2212
2213         public delegate Eina.Error efl_gfx_image_stretch_region_set_api_delegate(System.IntPtr obj,  System.IntPtr horizontal,  System.IntPtr vertical);
2214
2215         public static Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_set_api_delegate> efl_gfx_image_stretch_region_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_set_api_delegate>(Module, "efl_gfx_image_stretch_region_set");
2216
2217         private static Eina.Error stretch_region_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr horizontal, System.IntPtr vertical)
2218         {
2219             Eina.Log.Debug("function efl_gfx_image_stretch_region_set was called");
2220             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2221             if (ws != null)
2222             {
2223         var _in_horizontal = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(horizontal, false);
2224         var _in_vertical = new Eina.Iterator<Efl.Gfx.ImageStretchRegion>(vertical, false);
2225                                             Eina.Error _ret_var = default(Eina.Error);
2226                 try
2227                 {
2228                     _ret_var = ((WidgetPartBg)ws.Target).SetStretchRegion(_in_horizontal, _in_vertical);
2229                 }
2230                 catch (Exception e)
2231                 {
2232                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2233                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2234                 }
2235
2236                                         return _ret_var;
2237
2238             }
2239             else
2240             {
2241                 return efl_gfx_image_stretch_region_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), horizontal, vertical);
2242             }
2243         }
2244
2245         private static efl_gfx_image_stretch_region_set_delegate efl_gfx_image_stretch_region_set_static_delegate;
2246
2247
2248         private delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2249
2250
2251         public delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_api_delegate(System.IntPtr obj);
2252
2253         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");
2254
2255         private static Eina.Size2D.NativeStruct image_size_get(System.IntPtr obj, System.IntPtr pd)
2256         {
2257             Eina.Log.Debug("function efl_gfx_image_size_get was called");
2258             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2259             if (ws != null)
2260             {
2261             Eina.Size2D _ret_var = default(Eina.Size2D);
2262                 try
2263                 {
2264                     _ret_var = ((WidgetPartBg)ws.Target).GetImageSize();
2265                 }
2266                 catch (Exception e)
2267                 {
2268                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2269                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2270                 }
2271
2272         return _ret_var;
2273
2274             }
2275             else
2276             {
2277                 return efl_gfx_image_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2278             }
2279         }
2280
2281         private static efl_gfx_image_size_get_delegate efl_gfx_image_size_get_static_delegate;
2282
2283
2284         private delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
2285
2286
2287         public delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_api_delegate(System.IntPtr obj);
2288
2289         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");
2290
2291         private static Efl.Gfx.ImageContentHint content_hint_get(System.IntPtr obj, System.IntPtr pd)
2292         {
2293             Eina.Log.Debug("function efl_gfx_image_content_hint_get was called");
2294             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2295             if (ws != null)
2296             {
2297             Efl.Gfx.ImageContentHint _ret_var = default(Efl.Gfx.ImageContentHint);
2298                 try
2299                 {
2300                     _ret_var = ((WidgetPartBg)ws.Target).GetContentHint();
2301                 }
2302                 catch (Exception e)
2303                 {
2304                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2305                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2306                 }
2307
2308         return _ret_var;
2309
2310             }
2311             else
2312             {
2313                 return efl_gfx_image_content_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2314             }
2315         }
2316
2317         private static efl_gfx_image_content_hint_get_delegate efl_gfx_image_content_hint_get_static_delegate;
2318
2319
2320         private delegate void efl_gfx_image_content_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageContentHint hint);
2321
2322
2323         public delegate void efl_gfx_image_content_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageContentHint hint);
2324
2325         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");
2326
2327         private static void content_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageContentHint hint)
2328         {
2329             Eina.Log.Debug("function efl_gfx_image_content_hint_set was called");
2330             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2331             if (ws != null)
2332             {
2333
2334                 try
2335                 {
2336                     ((WidgetPartBg)ws.Target).SetContentHint(hint);
2337                 }
2338                 catch (Exception e)
2339                 {
2340                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2341                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2342                 }
2343
2344
2345             }
2346             else
2347             {
2348                 efl_gfx_image_content_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
2349             }
2350         }
2351
2352         private static efl_gfx_image_content_hint_set_delegate efl_gfx_image_content_hint_set_static_delegate;
2353
2354
2355         private delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
2356
2357
2358         public delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_api_delegate(System.IntPtr obj);
2359
2360         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");
2361
2362         private static Efl.Gfx.ImageScaleHint scale_hint_get(System.IntPtr obj, System.IntPtr pd)
2363         {
2364             Eina.Log.Debug("function efl_gfx_image_scale_hint_get was called");
2365             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2366             if (ws != null)
2367             {
2368             Efl.Gfx.ImageScaleHint _ret_var = default(Efl.Gfx.ImageScaleHint);
2369                 try
2370                 {
2371                     _ret_var = ((WidgetPartBg)ws.Target).GetScaleHint();
2372                 }
2373                 catch (Exception e)
2374                 {
2375                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2376                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2377                 }
2378
2379         return _ret_var;
2380
2381             }
2382             else
2383             {
2384                 return efl_gfx_image_scale_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2385             }
2386         }
2387
2388         private static efl_gfx_image_scale_hint_get_delegate efl_gfx_image_scale_hint_get_static_delegate;
2389
2390
2391         private delegate void efl_gfx_image_scale_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleHint hint);
2392
2393
2394         public delegate void efl_gfx_image_scale_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleHint hint);
2395
2396         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");
2397
2398         private static void scale_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleHint hint)
2399         {
2400             Eina.Log.Debug("function efl_gfx_image_scale_hint_set was called");
2401             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2402             if (ws != null)
2403             {
2404
2405                 try
2406                 {
2407                     ((WidgetPartBg)ws.Target).SetScaleHint(hint);
2408                 }
2409                 catch (Exception e)
2410                 {
2411                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2412                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2413                 }
2414
2415
2416             }
2417             else
2418             {
2419                 efl_gfx_image_scale_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
2420             }
2421         }
2422
2423         private static efl_gfx_image_scale_hint_set_delegate efl_gfx_image_scale_hint_set_static_delegate;
2424
2425
2426         private delegate Eina.Error efl_gfx_image_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
2427
2428
2429         public delegate Eina.Error efl_gfx_image_load_error_get_api_delegate(System.IntPtr obj);
2430
2431         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");
2432
2433         private static Eina.Error image_load_error_get(System.IntPtr obj, System.IntPtr pd)
2434         {
2435             Eina.Log.Debug("function efl_gfx_image_load_error_get was called");
2436             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2437             if (ws != null)
2438             {
2439             Eina.Error _ret_var = default(Eina.Error);
2440                 try
2441                 {
2442                     _ret_var = ((WidgetPartBg)ws.Target).GetImageLoadError();
2443                 }
2444                 catch (Exception e)
2445                 {
2446                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2447                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2448                 }
2449
2450         return _ret_var;
2451
2452             }
2453             else
2454             {
2455                 return efl_gfx_image_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2456             }
2457         }
2458
2459         private static efl_gfx_image_load_error_get_delegate efl_gfx_image_load_error_get_static_delegate;
2460
2461         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2462
2463 }
2464 }
2465 }
2466
2467 }
2468
2469 #if EFL_BETA
2470 #pragma warning disable CS1591
2471 public static class Efl_UiWidgetPartBg_ExtensionMethods {
2472     public static Efl.BindableProperty<Eina.File> Mmap<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2473         return new Efl.BindableProperty<Eina.File>("mmap", fac);
2474     }
2475
2476     public static Efl.BindableProperty<System.String> File<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2477         return new Efl.BindableProperty<System.String>("file", fac);
2478     }
2479
2480     public static Efl.BindableProperty<System.String> Key<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2481         return new Efl.BindableProperty<System.String>("key", fac);
2482     }
2483
2484
2485
2486     public static Efl.BindableProperty<System.String> ColorCode<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2487         return new Efl.BindableProperty<System.String>("color_code", fac);
2488     }
2489
2490     public static Efl.BindableProperty<bool> SmoothScale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2491         return new Efl.BindableProperty<bool>("smooth_scale", fac);
2492     }
2493
2494     public static Efl.BindableProperty<Efl.Gfx.ImageScaleType> ScaleType<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2495         return new Efl.BindableProperty<Efl.Gfx.ImageScaleType>("scale_type", fac);
2496     }
2497
2498     public static Efl.BindableProperty<bool> CanUpscale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2499         return new Efl.BindableProperty<bool>("can_upscale", fac);
2500     }
2501
2502     public static Efl.BindableProperty<bool> CanDownscale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2503         return new Efl.BindableProperty<bool>("can_downscale", fac);
2504     }
2505
2506
2507
2508
2509     public static Efl.BindableProperty<double> BorderScale<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2510         return new Efl.BindableProperty<double>("border_scale", fac);
2511     }
2512
2513     public static Efl.BindableProperty<Efl.Gfx.BorderFillMode> BorderCenterFill<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2514         return new Efl.BindableProperty<Efl.Gfx.BorderFillMode>("border_center_fill", fac);
2515     }
2516
2517
2518
2519     public static Efl.BindableProperty<Efl.Gfx.ImageContentHint> ContentHint<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2520         return new Efl.BindableProperty<Efl.Gfx.ImageContentHint>("content_hint", fac);
2521     }
2522
2523     public static Efl.BindableProperty<Efl.Gfx.ImageScaleHint> ScaleHint<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartBg, T>magic = null) where T : Efl.Ui.WidgetPartBg {
2524         return new Efl.BindableProperty<Efl.Gfx.ImageScaleHint>("scale_hint", fac);
2525     }
2526
2527
2528 }
2529 #pragma warning restore CS1591
2530 #endif