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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Ui {
  11
  12 /// <summary>Elementary widget internal part background class</summary>
  13 [Efl.Ui.WidgetPartBg.NativeMethods]
  14 public class WidgetPartBg : Efl.Ui.WidgetPart, Efl.IFile, Efl.Gfx.IColor, Efl.Gfx.IImage
  15 {
  16     ///<summary>Pointer to the native class description.</summary>
  17     public override System.IntPtr NativeClass
  18     {
  19         get
  20         {
  21             if (((object)this).GetType() == typeof(WidgetPartBg))
  22             {
  23                 return GetEflClassStatic();
  24             }
  25             else
  26             {
  27                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  28             }
  29         }
  30     }
  31
  32     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  33         efl_ui_widget_part_bg_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="WidgetPartBg"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     public WidgetPartBg(Efl.Object parent= null
  37             ) : base(efl_ui_widget_part_bg_class_get(), typeof(WidgetPartBg), parent)
  38     {
  39         FinishInstantiation();
  40     }
  41
  42     /// <summary>Initializes a new instance of the <see cref="WidgetPartBg"/> class.
  43     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  44     /// <param name="raw">The native pointer to be wrapped.</param>
  45     protected WidgetPartBg(System.IntPtr raw) : base(raw)
  46     {
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="WidgetPartBg"/> class.
  50     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  51     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  52     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  53     /// <param name="parent">The Efl.Object parent of this instance.</param>
  54     protected WidgetPartBg(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  55     {
  56     }
  57
  58     /// <summary>Image data has been preloaded.</summary>
  59     public event EventHandler ImagePreloadEvt
  60     {
  61         add
  62         {
  63             lock (eventLock)
  64             {
  65                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  66                 {
  67                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  68                     if (obj != null)
  69                     {
  70                         EventArgs args = EventArgs.Empty;
  71                         try
  72                         {
  73                             value?.Invoke(obj, args);
  74                         }
  75                         catch (Exception e)
  76                         {
  77                             Eina.Log.Error(e.ToString());
  78                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  79                         }
  80                     }
  81                 };
  82
  83                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  84                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  85             }
  86         }
  87
  88         remove
  89         {
  90             lock (eventLock)
  91             {
  92                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  93                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
  94             }
  95         }
  96     }
  97     ///<summary>Method to raise event ImagePreloadEvt.</summary>
  98     public void OnImagePreloadEvt(EventArgs e)
  99     {
 100         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 101         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 102         if (desc == IntPtr.Zero)
 103         {
 104             Eina.Log.Error($"Failed to get native event {key}");
 105             return;
 106         }
 107
 108         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 109     }
 110     /// <summary>Image was resized (its pixel data).</summary>
 111     public event EventHandler ImageResizeEvt
 112     {
 113         add
 114         {
 115             lock (eventLock)
 116             {
 117                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 118                 {
 119                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 120                     if (obj != null)
 121                     {
 122                         EventArgs args = EventArgs.Empty;
 123                         try
 124                         {
 125                             value?.Invoke(obj, args);
 126                         }
 127                         catch (Exception e)
 128                         {
 129                             Eina.Log.Error(e.ToString());
 130                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 131                         }
 132                     }
 133                 };
 134
 135                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 136                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 137             }
 138         }
 139
 140         remove
 141         {
 142             lock (eventLock)
 143             {
 144                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 145                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 146             }
 147         }
 148     }
 149     ///<summary>Method to raise event ImageResizeEvt.</summary>
 150     public void OnImageResizeEvt(EventArgs e)
 151     {
 152         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 153         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 154         if (desc == IntPtr.Zero)
 155         {
 156             Eina.Log.Error($"Failed to get native event {key}");
 157             return;
 158         }
 159
 160         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 161     }
 162     /// <summary>Image data has been unloaded (by some mechanism in EFL that threw out the original image data).</summary>
 163     public event EventHandler ImageUnloadEvt
 164     {
 165         add
 166         {
 167             lock (eventLock)
 168             {
 169                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 170                 {
 171                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 172                     if (obj != null)
 173                     {
 174                         EventArgs args = EventArgs.Empty;
 175                         try
 176                         {
 177                             value?.Invoke(obj, args);
 178                         }
 179                         catch (Exception e)
 180                         {
 181                             Eina.Log.Error(e.ToString());
 182                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 183                         }
 184                     }
 185                 };
 186
 187                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 188                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 189             }
 190         }
 191
 192         remove
 193         {
 194             lock (eventLock)
 195             {
 196                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 197                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 198             }
 199         }
 200     }
 201     ///<summary>Method to raise event ImageUnloadEvt.</summary>
 202     public void OnImageUnloadEvt(EventArgs e)
 203     {
 204         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 205         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 206         if (desc == IntPtr.Zero)
 207         {
 208             Eina.Log.Error($"Failed to get native event {key}");
 209             return;
 210         }
 211
 212         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 213     }
 214     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 215     /// (Since EFL 1.22)</summary>
 216     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 217     virtual public Eina.File GetMmap() {
 218          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 219         Eina.Error.RaiseIfUnhandledException();
 220         return _ret_var;
 221  }
 222     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 223     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 224     /// (Since EFL 1.22)</summary>
 225     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 226     /// <returns>0 on success, error code otherwise</returns>
 227     virtual public Eina.Error SetMmap(Eina.File f) {
 228                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),f);
 229         Eina.Error.RaiseIfUnhandledException();
 230                         return _ret_var;
 231  }
 232     /// <summary>Retrieve the file path from where an object is to fetch the data.
 233     /// You must not modify the strings on the returned pointers.
 234     /// (Since EFL 1.22)</summary>
 235     /// <returns>The file path.</returns>
 236     virtual public System.String GetFile() {
 237          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 238         Eina.Error.RaiseIfUnhandledException();
 239         return _ret_var;
 240  }
 241     /// <summary>Set the file path from where an object will fetch the data.
 242     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 243     /// (Since EFL 1.22)</summary>
 244     /// <param name="file">The file path.</param>
 245     /// <returns>0 on success, error code otherwise</returns>
 246     virtual public Eina.Error SetFile(System.String file) {
 247                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),file);
 248         Eina.Error.RaiseIfUnhandledException();
 249                         return _ret_var;
 250  }
 251     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 252     /// 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"/>).
 253     ///
 254     /// You must not modify the strings on the returned pointers.
 255     /// (Since EFL 1.22)</summary>
 256     /// <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>
 257     virtual public System.String GetKey() {
 258          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_key_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 259         Eina.Error.RaiseIfUnhandledException();
 260         return _ret_var;
 261  }
 262     /// <summary>Set the key which corresponds to the target data within a file.
 263     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 264     /// (Since EFL 1.22)</summary>
 265     /// <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>
 266     virtual public void SetKey(System.String key) {
 267                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),key);
 268         Eina.Error.RaiseIfUnhandledException();
 269                          }
 270     /// <summary>Get the load state of the object.
 271     /// (Since EFL 1.22)</summary>
 272     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 273     virtual public bool GetLoaded() {
 274          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_loaded_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 275         Eina.Error.RaiseIfUnhandledException();
 276         return _ret_var;
 277  }
 278     /// <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.
 279     /// 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.
 280     ///
 281     /// 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.
 282     /// (Since EFL 1.22)</summary>
 283     /// <returns>0 on success, error code otherwise</returns>
 284     virtual public Eina.Error Load() {
 285          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 286         Eina.Error.RaiseIfUnhandledException();
 287         return _ret_var;
 288  }
 289     /// <summary>Perform all necessary operations to unload file data from the object.
 290     /// 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.
 291     ///
 292     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 293     /// (Since EFL 1.22)</summary>
 294     virtual public void Unload() {
 295          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 296         Eina.Error.RaiseIfUnhandledException();
 297          }
 298     /// <summary>Retrieves the general/main color of the given Evas object.
 299     /// 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.
 300     ///
 301     /// 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.
 302     ///
 303     /// All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
 304     ///
 305     /// Use null pointers on the components you&apos;re not interested in: they&apos;ll be ignored by the function.
 306     /// (Since EFL 1.22)</summary>
 307     virtual public void GetColor(out int r, out int g, out int b, out int a) {
 308                                                                                                          Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 309         Eina.Error.RaiseIfUnhandledException();
 310                                                                          }
 311     /// <summary>Sets the general/main color of the given Evas object to the given one.
 312     /// See also <see cref="Efl.Gfx.IColor.GetColor"/> (for an example)
 313     ///
 314     /// These color values are expected to be premultiplied by alpha.
 315     /// (Since EFL 1.22)</summary>
 316     virtual public void SetColor(int r, int g, int b, int a) {
 317                                                                                                          Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 318         Eina.Error.RaiseIfUnhandledException();
 319                                                                          }
 320     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 321     /// (Since EFL 1.22)</summary>
 322     /// <returns>the hex color code.</returns>
 323     virtual public System.String GetColorCode() {
 324          var _ret_var = Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_code_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 325         Eina.Error.RaiseIfUnhandledException();
 326         return _ret_var;
 327  }
 328     /// <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;);
 329     /// (Since EFL 1.22)</summary>
 330     /// <param name="colorcode">the hex color code.</param>
 331     virtual public void SetColorCode(System.String colorcode) {
 332                                  Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_code_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),colorcode);
 333         Eina.Error.RaiseIfUnhandledException();
 334                          }
 335     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 336     /// 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.
 337     ///
 338     /// <c>true</c> by default</summary>
 339     /// <returns>Whether to use smooth scale or not.</returns>
 340     virtual public bool GetSmoothScale() {
 341          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 342         Eina.Error.RaiseIfUnhandledException();
 343         return _ret_var;
 344  }
 345     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 346     /// 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.
 347     ///
 348     /// <c>true</c> by default</summary>
 349     /// <param name="smooth_scale">Whether to use smooth scale or not.</param>
 350     virtual public void SetSmoothScale(bool smooth_scale) {
 351                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),smooth_scale);
 352         Eina.Error.RaiseIfUnhandledException();
 353                          }
 354     /// <summary>Control how the image is scaled.</summary>
 355     /// <returns>Image scale type</returns>
 356     virtual public Efl.Gfx.ImageScaleType GetScaleType() {
 357          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 358         Eina.Error.RaiseIfUnhandledException();
 359         return _ret_var;
 360  }
 361     /// <summary>Control how the image is scaled.</summary>
 362     /// <param name="scale_type">Image scale type</param>
 363     virtual public void SetScaleType(Efl.Gfx.ImageScaleType scale_type) {
 364                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),scale_type);
 365         Eina.Error.RaiseIfUnhandledException();
 366                          }
 367     /// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
 368     /// <returns>The image&apos;s ratio.</returns>
 369     virtual public double GetRatio() {
 370          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_ratio_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 371         Eina.Error.RaiseIfUnhandledException();
 372         return _ret_var;
 373  }
 374     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 375     /// 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.
 376     ///
 377     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 378     ///
 379     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 380     ///
 381     /// 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.
 382     ///
 383     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 384     /// <param name="l">The border&apos;s left width.</param>
 385     /// <param name="r">The border&apos;s right width.</param>
 386     /// <param name="t">The border&apos;s top height.</param>
 387     /// <param name="b">The border&apos;s bottom height.</param>
 388     virtual public void GetBorder(out int l, out int r, out int t, out int b) {
 389                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out l, out r, out t, out b);
 390         Eina.Error.RaiseIfUnhandledException();
 391                                                                          }
 392     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 393     /// 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.
 394     ///
 395     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 396     ///
 397     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 398     ///
 399     /// 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.
 400     ///
 401     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 402     /// <param name="l">The border&apos;s left width.</param>
 403     /// <param name="r">The border&apos;s right width.</param>
 404     /// <param name="t">The border&apos;s top height.</param>
 405     /// <param name="b">The border&apos;s bottom height.</param>
 406     virtual public void SetBorder(int l, int r, int t, int b) {
 407                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),l, r, t, b);
 408         Eina.Error.RaiseIfUnhandledException();
 409                                                                          }
 410     /// <summary>Scaling factor applied to the image borders.
 411     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 412     ///
 413     /// Default value is 1.0 (no scaling).</summary>
 414     /// <returns>The scale factor.</returns>
 415     virtual public double GetBorderScale() {
 416          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 417         Eina.Error.RaiseIfUnhandledException();
 418         return _ret_var;
 419  }
 420     /// <summary>Scaling factor applied to the image borders.
 421     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 422     ///
 423     /// Default value is 1.0 (no scaling).</summary>
 424     /// <param name="scale">The scale factor.</param>
 425     virtual public void SetBorderScale(double scale) {
 426                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),scale);
 427         Eina.Error.RaiseIfUnhandledException();
 428                          }
 429     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 430     /// 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.
 431     ///
 432     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 433     /// <returns>Fill mode of the center region.</returns>
 434     virtual public Efl.Gfx.BorderFillMode GetBorderCenterFill() {
 435          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 436         Eina.Error.RaiseIfUnhandledException();
 437         return _ret_var;
 438  }
 439     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 440     /// 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.
 441     ///
 442     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 443     /// <param name="fill">Fill mode of the center region.</param>
 444     virtual public void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill) {
 445                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),fill);
 446         Eina.Error.RaiseIfUnhandledException();
 447                          }
 448     /// <summary>This represents the size of the original image in pixels.
 449     /// 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.
 450     ///
 451     /// This is a read-only property, and may return 0x0.</summary>
 452     /// <returns>The size in pixels.</returns>
 453     virtual public Eina.Size2D GetImageSize() {
 454          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 455         Eina.Error.RaiseIfUnhandledException();
 456         return _ret_var;
 457  }
 458     /// <summary>Get the content hint setting of a given image object of the canvas.
 459     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 460     /// <returns>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></returns>
 461     virtual public Efl.Gfx.ImageContentHint GetContentHint() {
 462          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 463         Eina.Error.RaiseIfUnhandledException();
 464         return _ret_var;
 465  }
 466     /// <summary>Set the content hint setting of a given image object of the canvas.
 467     /// 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>
 468     /// <param name="hint">Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></param>
 469     virtual public void SetContentHint(Efl.Gfx.ImageContentHint hint) {
 470                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),hint);
 471         Eina.Error.RaiseIfUnhandledException();
 472                          }
 473     /// <summary>Get the scale hint of a given image of the canvas.
 474     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 475     /// <returns>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></returns>
 476     virtual public Efl.Gfx.ImageScaleHint GetScaleHint() {
 477          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 478         Eina.Error.RaiseIfUnhandledException();
 479         return _ret_var;
 480  }
 481     /// <summary>Set the scale hint of a given image of the canvas.
 482     /// 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>
 483     /// <param name="hint">Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></param>
 484     virtual public void SetScaleHint(Efl.Gfx.ImageScaleHint hint) {
 485                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),hint);
 486         Eina.Error.RaiseIfUnhandledException();
 487                          }
 488     /// <summary>Gets the (last) file loading error for a given object.</summary>
 489     /// <returns>The load error code.</returns>
 490     virtual public Eina.Error GetImageLoadError() {
 491          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_load_error_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 492         Eina.Error.RaiseIfUnhandledException();
 493         return _ret_var;
 494  }
 495     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 496     /// (Since EFL 1.22)</summary>
 497     /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 498     public Eina.File Mmap {
 499         get { return GetMmap(); }
 500         set { SetMmap(value); }
 501     }
 502     /// <summary>Retrieve the file path from where an object is to fetch the data.
 503     /// You must not modify the strings on the returned pointers.
 504     /// (Since EFL 1.22)</summary>
 505     /// <value>The file path.</value>
 506     public System.String File {
 507         get { return GetFile(); }
 508         set { SetFile(value); }
 509     }
 510     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 511     /// 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"/>).
 512     ///
 513     /// You must not modify the strings on the returned pointers.
 514     /// (Since EFL 1.22)</summary>
 515     /// <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>
 516     public System.String Key {
 517         get { return GetKey(); }
 518         set { SetKey(value); }
 519     }
 520     /// <summary>Get the load state of the object.
 521     /// (Since EFL 1.22)</summary>
 522     /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 523     public bool Loaded {
 524         get { return GetLoaded(); }
 525     }
 526     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 527     /// (Since EFL 1.22)</summary>
 528     /// <value>the hex color code.</value>
 529     public System.String ColorCode {
 530         get { return GetColorCode(); }
 531         set { SetColorCode(value); }
 532     }
 533     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 534     /// 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.
 535     ///
 536     /// <c>true</c> by default</summary>
 537     /// <value>Whether to use smooth scale or not.</value>
 538     public bool SmoothScale {
 539         get { return GetSmoothScale(); }
 540         set { SetSmoothScale(value); }
 541     }
 542     /// <summary>Control how the image is scaled.</summary>
 543     /// <value>Image scale type</value>
 544     public Efl.Gfx.ImageScaleType ScaleType {
 545         get { return GetScaleType(); }
 546         set { SetScaleType(value); }
 547     }
 548     /// <summary>The native width/height ratio of the image.</summary>
 549     /// <value>The image&apos;s ratio.</value>
 550     public double Ratio {
 551         get { return GetRatio(); }
 552     }
 553     /// <summary>Scaling factor applied to the image borders.
 554     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 555     ///
 556     /// Default value is 1.0 (no scaling).</summary>
 557     /// <value>The scale factor.</value>
 558     public double BorderScale {
 559         get { return GetBorderScale(); }
 560         set { SetBorderScale(value); }
 561     }
 562     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 563     /// 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.
 564     ///
 565     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 566     /// <value>Fill mode of the center region.</value>
 567     public Efl.Gfx.BorderFillMode BorderCenterFill {
 568         get { return GetBorderCenterFill(); }
 569         set { SetBorderCenterFill(value); }
 570     }
 571     /// <summary>This represents the size of the original image in pixels.
 572     /// 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.
 573     ///
 574     /// This is a read-only property, and may return 0x0.</summary>
 575     /// <value>The size in pixels.</value>
 576     public Eina.Size2D ImageSize {
 577         get { return GetImageSize(); }
 578     }
 579     /// <summary>Get the content hint setting of a given image object of the canvas.
 580     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 581     /// <value>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></value>
 582     public Efl.Gfx.ImageContentHint ContentHint {
 583         get { return GetContentHint(); }
 584         set { SetContentHint(value); }
 585     }
 586     /// <summary>Get the scale hint of a given image of the canvas.
 587     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 588     /// <value>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></value>
 589     public Efl.Gfx.ImageScaleHint ScaleHint {
 590         get { return GetScaleHint(); }
 591         set { SetScaleHint(value); }
 592     }
 593     /// <summary>Gets the (last) file loading error for a given object.</summary>
 594     /// <value>The load error code.</value>
 595     public Eina.Error ImageLoadError {
 596         get { return GetImageLoadError(); }
 597     }
 598     private static IntPtr GetEflClassStatic()
 599     {
 600         return Efl.Ui.WidgetPartBg.efl_ui_widget_part_bg_class_get();
 601     }
 602     /// <summary>Wrapper for native methods and virtual method delegates.
 603     /// For internal use by generated code only.</summary>
 604     public new class NativeMethods : Efl.Ui.WidgetPart.NativeMethods
 605     {
 606         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 607         /// <summary>Gets the list of Eo operations to override.</summary>
 608         /// <returns>The list of Eo operations to be overload.</returns>
 609         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 610         {
 611             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 612             var methods = Efl.Eo.Globals.GetUserMethods(type);
 613
 614             if (efl_file_mmap_get_static_delegate == null)
 615             {
 616                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 617             }
 618
 619             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 620             {
 621                 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) });
 622             }
 623
 624             if (efl_file_mmap_set_static_delegate == null)
 625             {
 626                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 627             }
 628
 629             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 630             {
 631                 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) });
 632             }
 633
 634             if (efl_file_get_static_delegate == null)
 635             {
 636                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 637             }
 638
 639             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 640             {
 641                 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) });
 642             }
 643
 644             if (efl_file_set_static_delegate == null)
 645             {
 646                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 647             }
 648
 649             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 650             {
 651                 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) });
 652             }
 653
 654             if (efl_file_key_get_static_delegate == null)
 655             {
 656                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 657             }
 658
 659             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 660             {
 661                 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) });
 662             }
 663
 664             if (efl_file_key_set_static_delegate == null)
 665             {
 666                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 667             }
 668
 669             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 670             {
 671                 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) });
 672             }
 673
 674             if (efl_file_loaded_get_static_delegate == null)
 675             {
 676                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 677             }
 678
 679             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 680             {
 681                 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) });
 682             }
 683
 684             if (efl_file_load_static_delegate == null)
 685             {
 686                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 687             }
 688
 689             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 690             {
 691                 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) });
 692             }
 693
 694             if (efl_file_unload_static_delegate == null)
 695             {
 696                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 697             }
 698
 699             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 700             {
 701                 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) });
 702             }
 703
 704             if (efl_gfx_color_get_static_delegate == null)
 705             {
 706                 efl_gfx_color_get_static_delegate = new efl_gfx_color_get_delegate(color_get);
 707             }
 708
 709             if (methods.FirstOrDefault(m => m.Name == "GetColor") != null)
 710             {
 711                 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) });
 712             }
 713
 714             if (efl_gfx_color_set_static_delegate == null)
 715             {
 716                 efl_gfx_color_set_static_delegate = new efl_gfx_color_set_delegate(color_set);
 717             }
 718
 719             if (methods.FirstOrDefault(m => m.Name == "SetColor") != null)
 720             {
 721                 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) });
 722             }
 723
 724             if (efl_gfx_color_code_get_static_delegate == null)
 725             {
 726                 efl_gfx_color_code_get_static_delegate = new efl_gfx_color_code_get_delegate(color_code_get);
 727             }
 728
 729             if (methods.FirstOrDefault(m => m.Name == "GetColorCode") != null)
 730             {
 731                 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) });
 732             }
 733
 734             if (efl_gfx_color_code_set_static_delegate == null)
 735             {
 736                 efl_gfx_color_code_set_static_delegate = new efl_gfx_color_code_set_delegate(color_code_set);
 737             }
 738
 739             if (methods.FirstOrDefault(m => m.Name == "SetColorCode") != null)
 740             {
 741                 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) });
 742             }
 743
 744             if (efl_gfx_image_smooth_scale_get_static_delegate == null)
 745             {
 746                 efl_gfx_image_smooth_scale_get_static_delegate = new efl_gfx_image_smooth_scale_get_delegate(smooth_scale_get);
 747             }
 748
 749             if (methods.FirstOrDefault(m => m.Name == "GetSmoothScale") != null)
 750             {
 751                 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) });
 752             }
 753
 754             if (efl_gfx_image_smooth_scale_set_static_delegate == null)
 755             {
 756                 efl_gfx_image_smooth_scale_set_static_delegate = new efl_gfx_image_smooth_scale_set_delegate(smooth_scale_set);
 757             }
 758
 759             if (methods.FirstOrDefault(m => m.Name == "SetSmoothScale") != null)
 760             {
 761                 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) });
 762             }
 763
 764             if (efl_gfx_image_scale_type_get_static_delegate == null)
 765             {
 766                 efl_gfx_image_scale_type_get_static_delegate = new efl_gfx_image_scale_type_get_delegate(scale_type_get);
 767             }
 768
 769             if (methods.FirstOrDefault(m => m.Name == "GetScaleType") != null)
 770             {
 771                 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) });
 772             }
 773
 774             if (efl_gfx_image_scale_type_set_static_delegate == null)
 775             {
 776                 efl_gfx_image_scale_type_set_static_delegate = new efl_gfx_image_scale_type_set_delegate(scale_type_set);
 777             }
 778
 779             if (methods.FirstOrDefault(m => m.Name == "SetScaleType") != null)
 780             {
 781                 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) });
 782             }
 783
 784             if (efl_gfx_image_ratio_get_static_delegate == null)
 785             {
 786                 efl_gfx_image_ratio_get_static_delegate = new efl_gfx_image_ratio_get_delegate(ratio_get);
 787             }
 788
 789             if (methods.FirstOrDefault(m => m.Name == "GetRatio") != null)
 790             {
 791                 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) });
 792             }
 793
 794             if (efl_gfx_image_border_get_static_delegate == null)
 795             {
 796                 efl_gfx_image_border_get_static_delegate = new efl_gfx_image_border_get_delegate(border_get);
 797             }
 798
 799             if (methods.FirstOrDefault(m => m.Name == "GetBorder") != null)
 800             {
 801                 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) });
 802             }
 803
 804             if (efl_gfx_image_border_set_static_delegate == null)
 805             {
 806                 efl_gfx_image_border_set_static_delegate = new efl_gfx_image_border_set_delegate(border_set);
 807             }
 808
 809             if (methods.FirstOrDefault(m => m.Name == "SetBorder") != null)
 810             {
 811                 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) });
 812             }
 813
 814             if (efl_gfx_image_border_scale_get_static_delegate == null)
 815             {
 816                 efl_gfx_image_border_scale_get_static_delegate = new efl_gfx_image_border_scale_get_delegate(border_scale_get);
 817             }
 818
 819             if (methods.FirstOrDefault(m => m.Name == "GetBorderScale") != null)
 820             {
 821                 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) });
 822             }
 823
 824             if (efl_gfx_image_border_scale_set_static_delegate == null)
 825             {
 826                 efl_gfx_image_border_scale_set_static_delegate = new efl_gfx_image_border_scale_set_delegate(border_scale_set);
 827             }
 828
 829             if (methods.FirstOrDefault(m => m.Name == "SetBorderScale") != null)
 830             {
 831                 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) });
 832             }
 833
 834             if (efl_gfx_image_border_center_fill_get_static_delegate == null)
 835             {
 836                 efl_gfx_image_border_center_fill_get_static_delegate = new efl_gfx_image_border_center_fill_get_delegate(border_center_fill_get);
 837             }
 838
 839             if (methods.FirstOrDefault(m => m.Name == "GetBorderCenterFill") != null)
 840             {
 841                 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) });
 842             }
 843
 844             if (efl_gfx_image_border_center_fill_set_static_delegate == null)
 845             {
 846                 efl_gfx_image_border_center_fill_set_static_delegate = new efl_gfx_image_border_center_fill_set_delegate(border_center_fill_set);
 847             }
 848
 849             if (methods.FirstOrDefault(m => m.Name == "SetBorderCenterFill") != null)
 850             {
 851                 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) });
 852             }
 853
 854             if (efl_gfx_image_size_get_static_delegate == null)
 855             {
 856                 efl_gfx_image_size_get_static_delegate = new efl_gfx_image_size_get_delegate(image_size_get);
 857             }
 858
 859             if (methods.FirstOrDefault(m => m.Name == "GetImageSize") != null)
 860             {
 861                 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) });
 862             }
 863
 864             if (efl_gfx_image_content_hint_get_static_delegate == null)
 865             {
 866                 efl_gfx_image_content_hint_get_static_delegate = new efl_gfx_image_content_hint_get_delegate(content_hint_get);
 867             }
 868
 869             if (methods.FirstOrDefault(m => m.Name == "GetContentHint") != null)
 870             {
 871                 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) });
 872             }
 873
 874             if (efl_gfx_image_content_hint_set_static_delegate == null)
 875             {
 876                 efl_gfx_image_content_hint_set_static_delegate = new efl_gfx_image_content_hint_set_delegate(content_hint_set);
 877             }
 878
 879             if (methods.FirstOrDefault(m => m.Name == "SetContentHint") != null)
 880             {
 881                 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) });
 882             }
 883
 884             if (efl_gfx_image_scale_hint_get_static_delegate == null)
 885             {
 886                 efl_gfx_image_scale_hint_get_static_delegate = new efl_gfx_image_scale_hint_get_delegate(scale_hint_get);
 887             }
 888
 889             if (methods.FirstOrDefault(m => m.Name == "GetScaleHint") != null)
 890             {
 891                 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) });
 892             }
 893
 894             if (efl_gfx_image_scale_hint_set_static_delegate == null)
 895             {
 896                 efl_gfx_image_scale_hint_set_static_delegate = new efl_gfx_image_scale_hint_set_delegate(scale_hint_set);
 897             }
 898
 899             if (methods.FirstOrDefault(m => m.Name == "SetScaleHint") != null)
 900             {
 901                 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) });
 902             }
 903
 904             if (efl_gfx_image_load_error_get_static_delegate == null)
 905             {
 906                 efl_gfx_image_load_error_get_static_delegate = new efl_gfx_image_load_error_get_delegate(image_load_error_get);
 907             }
 908
 909             if (methods.FirstOrDefault(m => m.Name == "GetImageLoadError") != null)
 910             {
 911                 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) });
 912             }
 913
 914             descs.AddRange(base.GetEoOps(type));
 915             return descs;
 916         }
 917         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 918         /// <returns>The native class pointer.</returns>
 919         public override IntPtr GetEflClass()
 920         {
 921             return Efl.Ui.WidgetPartBg.efl_ui_widget_part_bg_class_get();
 922         }
 923
 924         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 925
 926
 927         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 928
 929
 930         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
 931
 932         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");
 933
 934         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
 935         {
 936             Eina.Log.Debug("function efl_file_mmap_get was called");
 937             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 938             if (ws != null)
 939             {
 940             Eina.File _ret_var = default(Eina.File);
 941                 try
 942                 {
 943                     _ret_var = ((WidgetPartBg)ws.Target).GetMmap();
 944                 }
 945                 catch (Exception e)
 946                 {
 947                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 948                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 949                 }
 950
 951         return _ret_var;
 952
 953             }
 954             else
 955             {
 956                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 957             }
 958         }
 959
 960         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
 961
 962
 963         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
 964
 965
 966         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
 967
 968         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");
 969
 970         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
 971         {
 972             Eina.Log.Debug("function efl_file_mmap_set was called");
 973             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 974             if (ws != null)
 975             {
 976                                     Eina.Error _ret_var = default(Eina.Error);
 977                 try
 978                 {
 979                     _ret_var = ((WidgetPartBg)ws.Target).SetMmap(f);
 980                 }
 981                 catch (Exception e)
 982                 {
 983                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 984                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 985                 }
 986
 987                         return _ret_var;
 988
 989             }
 990             else
 991             {
 992                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
 993             }
 994         }
 995
 996         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
 997
 998         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 999         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
1000
1001         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1002         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
1003
1004         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");
1005
1006         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
1007         {
1008             Eina.Log.Debug("function efl_file_get was called");
1009             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1010             if (ws != null)
1011             {
1012             System.String _ret_var = default(System.String);
1013                 try
1014                 {
1015                     _ret_var = ((WidgetPartBg)ws.Target).GetFile();
1016                 }
1017                 catch (Exception e)
1018                 {
1019                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1020                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1021                 }
1022
1023         return _ret_var;
1024
1025             }
1026             else
1027             {
1028                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1029             }
1030         }
1031
1032         private static efl_file_get_delegate efl_file_get_static_delegate;
1033
1034
1035         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);
1036
1037
1038         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1039
1040         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");
1041
1042         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
1043         {
1044             Eina.Log.Debug("function efl_file_set was called");
1045             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1046             if (ws != null)
1047             {
1048                                     Eina.Error _ret_var = default(Eina.Error);
1049                 try
1050                 {
1051                     _ret_var = ((WidgetPartBg)ws.Target).SetFile(file);
1052                 }
1053                 catch (Exception e)
1054                 {
1055                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1056                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1057                 }
1058
1059                         return _ret_var;
1060
1061             }
1062             else
1063             {
1064                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
1065             }
1066         }
1067
1068         private static efl_file_set_delegate efl_file_set_static_delegate;
1069
1070         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1071         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
1072
1073         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1074         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
1075
1076         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");
1077
1078         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
1079         {
1080             Eina.Log.Debug("function efl_file_key_get was called");
1081             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1082             if (ws != null)
1083             {
1084             System.String _ret_var = default(System.String);
1085                 try
1086                 {
1087                     _ret_var = ((WidgetPartBg)ws.Target).GetKey();
1088                 }
1089                 catch (Exception e)
1090                 {
1091                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1092                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1093                 }
1094
1095         return _ret_var;
1096
1097             }
1098             else
1099             {
1100                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1101             }
1102         }
1103
1104         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
1105
1106
1107         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);
1108
1109
1110         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1111
1112         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");
1113
1114         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
1115         {
1116             Eina.Log.Debug("function efl_file_key_set was called");
1117             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1118             if (ws != null)
1119             {
1120
1121                 try
1122                 {
1123                     ((WidgetPartBg)ws.Target).SetKey(key);
1124                 }
1125                 catch (Exception e)
1126                 {
1127                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1128                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1129                 }
1130
1131
1132             }
1133             else
1134             {
1135                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1136             }
1137         }
1138
1139         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
1140
1141         [return: MarshalAs(UnmanagedType.U1)]
1142         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
1143
1144         [return: MarshalAs(UnmanagedType.U1)]
1145         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
1146
1147         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");
1148
1149         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
1150         {
1151             Eina.Log.Debug("function efl_file_loaded_get was called");
1152             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1153             if (ws != null)
1154             {
1155             bool _ret_var = default(bool);
1156                 try
1157                 {
1158                     _ret_var = ((WidgetPartBg)ws.Target).GetLoaded();
1159                 }
1160                 catch (Exception e)
1161                 {
1162                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1163                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1164                 }
1165
1166         return _ret_var;
1167
1168             }
1169             else
1170             {
1171                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1172             }
1173         }
1174
1175         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
1176
1177
1178         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
1179
1180
1181         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
1182
1183         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");
1184
1185         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
1186         {
1187             Eina.Log.Debug("function efl_file_load was called");
1188             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1189             if (ws != null)
1190             {
1191             Eina.Error _ret_var = default(Eina.Error);
1192                 try
1193                 {
1194                     _ret_var = ((WidgetPartBg)ws.Target).Load();
1195                 }
1196                 catch (Exception e)
1197                 {
1198                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1199                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1200                 }
1201
1202         return _ret_var;
1203
1204             }
1205             else
1206             {
1207                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1208             }
1209         }
1210
1211         private static efl_file_load_delegate efl_file_load_static_delegate;
1212
1213
1214         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
1215
1216
1217         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
1218
1219         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");
1220
1221         private static void unload(System.IntPtr obj, System.IntPtr pd)
1222         {
1223             Eina.Log.Debug("function efl_file_unload was called");
1224             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1225             if (ws != null)
1226             {
1227
1228                 try
1229                 {
1230                     ((WidgetPartBg)ws.Target).Unload();
1231                 }
1232                 catch (Exception e)
1233                 {
1234                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1235                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1236                 }
1237
1238
1239             }
1240             else
1241             {
1242                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1243             }
1244         }
1245
1246         private static efl_file_unload_delegate efl_file_unload_static_delegate;
1247
1248
1249         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);
1250
1251
1252         public delegate void efl_gfx_color_get_api_delegate(System.IntPtr obj,  out int r,  out int g,  out int b,  out int a);
1253
1254         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");
1255
1256         private static void color_get(System.IntPtr obj, System.IntPtr pd, out int r, out int g, out int b, out int a)
1257         {
1258             Eina.Log.Debug("function efl_gfx_color_get was called");
1259             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1260             if (ws != null)
1261             {
1262                                         r = default(int);        g = default(int);        b = default(int);        a = default(int);
1263                 try
1264                 {
1265                     ((WidgetPartBg)ws.Target).GetColor(out r, out g, out b, out a);
1266                 }
1267                 catch (Exception e)
1268                 {
1269                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1270                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1271                 }
1272
1273
1274             }
1275             else
1276             {
1277                 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);
1278             }
1279         }
1280
1281         private static efl_gfx_color_get_delegate efl_gfx_color_get_static_delegate;
1282
1283
1284         private delegate void efl_gfx_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  int r,  int g,  int b,  int a);
1285
1286
1287         public delegate void efl_gfx_color_set_api_delegate(System.IntPtr obj,  int r,  int g,  int b,  int a);
1288
1289         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");
1290
1291         private static void color_set(System.IntPtr obj, System.IntPtr pd, int r, int g, int b, int a)
1292         {
1293             Eina.Log.Debug("function efl_gfx_color_set was called");
1294             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1295             if (ws != null)
1296             {
1297
1298                 try
1299                 {
1300                     ((WidgetPartBg)ws.Target).SetColor(r, g, b, a);
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
1309             }
1310             else
1311             {
1312                 efl_gfx_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
1313             }
1314         }
1315
1316         private static efl_gfx_color_set_delegate efl_gfx_color_set_static_delegate;
1317
1318         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1319         private delegate System.String efl_gfx_color_code_get_delegate(System.IntPtr obj, System.IntPtr pd);
1320
1321         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1322         public delegate System.String efl_gfx_color_code_get_api_delegate(System.IntPtr obj);
1323
1324         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");
1325
1326         private static System.String color_code_get(System.IntPtr obj, System.IntPtr pd)
1327         {
1328             Eina.Log.Debug("function efl_gfx_color_code_get was called");
1329             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1330             if (ws != null)
1331             {
1332             System.String _ret_var = default(System.String);
1333                 try
1334                 {
1335                     _ret_var = ((WidgetPartBg)ws.Target).GetColorCode();
1336                 }
1337                 catch (Exception e)
1338                 {
1339                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1340                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1341                 }
1342
1343         return _ret_var;
1344
1345             }
1346             else
1347             {
1348                 return efl_gfx_color_code_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1349             }
1350         }
1351
1352         private static efl_gfx_color_code_get_delegate efl_gfx_color_code_get_static_delegate;
1353
1354
1355         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);
1356
1357
1358         public delegate void efl_gfx_color_code_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String colorcode);
1359
1360         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");
1361
1362         private static void color_code_set(System.IntPtr obj, System.IntPtr pd, System.String colorcode)
1363         {
1364             Eina.Log.Debug("function efl_gfx_color_code_set was called");
1365             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1366             if (ws != null)
1367             {
1368
1369                 try
1370                 {
1371                     ((WidgetPartBg)ws.Target).SetColorCode(colorcode);
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
1380             }
1381             else
1382             {
1383                 efl_gfx_color_code_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), colorcode);
1384             }
1385         }
1386
1387         private static efl_gfx_color_code_set_delegate efl_gfx_color_code_set_static_delegate;
1388
1389         [return: MarshalAs(UnmanagedType.U1)]
1390         private delegate bool efl_gfx_image_smooth_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1391
1392         [return: MarshalAs(UnmanagedType.U1)]
1393         public delegate bool efl_gfx_image_smooth_scale_get_api_delegate(System.IntPtr obj);
1394
1395         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");
1396
1397         private static bool smooth_scale_get(System.IntPtr obj, System.IntPtr pd)
1398         {
1399             Eina.Log.Debug("function efl_gfx_image_smooth_scale_get was called");
1400             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1401             if (ws != null)
1402             {
1403             bool _ret_var = default(bool);
1404                 try
1405                 {
1406                     _ret_var = ((WidgetPartBg)ws.Target).GetSmoothScale();
1407                 }
1408                 catch (Exception e)
1409                 {
1410                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1411                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1412                 }
1413
1414         return _ret_var;
1415
1416             }
1417             else
1418             {
1419                 return efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1420             }
1421         }
1422
1423         private static efl_gfx_image_smooth_scale_get_delegate efl_gfx_image_smooth_scale_get_static_delegate;
1424
1425
1426         private delegate void efl_gfx_image_smooth_scale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
1427
1428
1429         public delegate void efl_gfx_image_smooth_scale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
1430
1431         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");
1432
1433         private static void smooth_scale_set(System.IntPtr obj, System.IntPtr pd, bool smooth_scale)
1434         {
1435             Eina.Log.Debug("function efl_gfx_image_smooth_scale_set was called");
1436             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1437             if (ws != null)
1438             {
1439
1440                 try
1441                 {
1442                     ((WidgetPartBg)ws.Target).SetSmoothScale(smooth_scale);
1443                 }
1444                 catch (Exception e)
1445                 {
1446                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1447                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1448                 }
1449
1450
1451             }
1452             else
1453             {
1454                 efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth_scale);
1455             }
1456         }
1457
1458         private static efl_gfx_image_smooth_scale_set_delegate efl_gfx_image_smooth_scale_set_static_delegate;
1459
1460
1461         private delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1462
1463
1464         public delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_api_delegate(System.IntPtr obj);
1465
1466         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");
1467
1468         private static Efl.Gfx.ImageScaleType scale_type_get(System.IntPtr obj, System.IntPtr pd)
1469         {
1470             Eina.Log.Debug("function efl_gfx_image_scale_type_get was called");
1471             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1472             if (ws != null)
1473             {
1474             Efl.Gfx.ImageScaleType _ret_var = default(Efl.Gfx.ImageScaleType);
1475                 try
1476                 {
1477                     _ret_var = ((WidgetPartBg)ws.Target).GetScaleType();
1478                 }
1479                 catch (Exception e)
1480                 {
1481                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1482                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1483                 }
1484
1485         return _ret_var;
1486
1487             }
1488             else
1489             {
1490                 return efl_gfx_image_scale_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1491             }
1492         }
1493
1494         private static efl_gfx_image_scale_type_get_delegate efl_gfx_image_scale_type_get_static_delegate;
1495
1496
1497         private delegate void efl_gfx_image_scale_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleType scale_type);
1498
1499
1500         public delegate void efl_gfx_image_scale_type_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleType scale_type);
1501
1502         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");
1503
1504         private static void scale_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleType scale_type)
1505         {
1506             Eina.Log.Debug("function efl_gfx_image_scale_type_set was called");
1507             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1508             if (ws != null)
1509             {
1510
1511                 try
1512                 {
1513                     ((WidgetPartBg)ws.Target).SetScaleType(scale_type);
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_image_scale_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale_type);
1526             }
1527         }
1528
1529         private static efl_gfx_image_scale_type_set_delegate efl_gfx_image_scale_type_set_static_delegate;
1530
1531
1532         private delegate double efl_gfx_image_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
1533
1534
1535         public delegate double efl_gfx_image_ratio_get_api_delegate(System.IntPtr obj);
1536
1537         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");
1538
1539         private static double ratio_get(System.IntPtr obj, System.IntPtr pd)
1540         {
1541             Eina.Log.Debug("function efl_gfx_image_ratio_get was called");
1542             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1543             if (ws != null)
1544             {
1545             double _ret_var = default(double);
1546                 try
1547                 {
1548                     _ret_var = ((WidgetPartBg)ws.Target).GetRatio();
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_image_ratio_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_image_ratio_get_delegate efl_gfx_image_ratio_get_static_delegate;
1566
1567
1568         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);
1569
1570
1571         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);
1572
1573         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");
1574
1575         private static void border_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
1576         {
1577             Eina.Log.Debug("function efl_gfx_image_border_get was called");
1578             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1579             if (ws != null)
1580             {
1581                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
1582                 try
1583                 {
1584                     ((WidgetPartBg)ws.Target).GetBorder(out l, out r, out t, out b);
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_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);
1597             }
1598         }
1599
1600         private static efl_gfx_image_border_get_delegate efl_gfx_image_border_get_static_delegate;
1601
1602
1603         private delegate void efl_gfx_image_border_set_delegate(System.IntPtr obj, System.IntPtr pd,  int l,  int r,  int t,  int b);
1604
1605
1606         public delegate void efl_gfx_image_border_set_api_delegate(System.IntPtr obj,  int l,  int r,  int t,  int b);
1607
1608         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");
1609
1610         private static void border_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
1611         {
1612             Eina.Log.Debug("function efl_gfx_image_border_set was called");
1613             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1614             if (ws != null)
1615             {
1616
1617                 try
1618                 {
1619                     ((WidgetPartBg)ws.Target).SetBorder(l, r, t, b);
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
1628             }
1629             else
1630             {
1631                 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);
1632             }
1633         }
1634
1635         private static efl_gfx_image_border_set_delegate efl_gfx_image_border_set_static_delegate;
1636
1637
1638         private delegate double efl_gfx_image_border_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1639
1640
1641         public delegate double efl_gfx_image_border_scale_get_api_delegate(System.IntPtr obj);
1642
1643         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");
1644
1645         private static double border_scale_get(System.IntPtr obj, System.IntPtr pd)
1646         {
1647             Eina.Log.Debug("function efl_gfx_image_border_scale_get was called");
1648             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1649             if (ws != null)
1650             {
1651             double _ret_var = default(double);
1652                 try
1653                 {
1654                     _ret_var = ((WidgetPartBg)ws.Target).GetBorderScale();
1655                 }
1656                 catch (Exception e)
1657                 {
1658                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1659                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1660                 }
1661
1662         return _ret_var;
1663
1664             }
1665             else
1666             {
1667                 return efl_gfx_image_border_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1668             }
1669         }
1670
1671         private static efl_gfx_image_border_scale_get_delegate efl_gfx_image_border_scale_get_static_delegate;
1672
1673
1674         private delegate void efl_gfx_image_border_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double scale);
1675
1676
1677         public delegate void efl_gfx_image_border_scale_set_api_delegate(System.IntPtr obj,  double scale);
1678
1679         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");
1680
1681         private static void border_scale_set(System.IntPtr obj, System.IntPtr pd, double scale)
1682         {
1683             Eina.Log.Debug("function efl_gfx_image_border_scale_set was called");
1684             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1685             if (ws != null)
1686             {
1687
1688                 try
1689                 {
1690                     ((WidgetPartBg)ws.Target).SetBorderScale(scale);
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
1699             }
1700             else
1701             {
1702                 efl_gfx_image_border_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale);
1703             }
1704         }
1705
1706         private static efl_gfx_image_border_scale_set_delegate efl_gfx_image_border_scale_set_static_delegate;
1707
1708
1709         private delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
1710
1711
1712         public delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_api_delegate(System.IntPtr obj);
1713
1714         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");
1715
1716         private static Efl.Gfx.BorderFillMode border_center_fill_get(System.IntPtr obj, System.IntPtr pd)
1717         {
1718             Eina.Log.Debug("function efl_gfx_image_border_center_fill_get was called");
1719             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1720             if (ws != null)
1721             {
1722             Efl.Gfx.BorderFillMode _ret_var = default(Efl.Gfx.BorderFillMode);
1723                 try
1724                 {
1725                     _ret_var = ((WidgetPartBg)ws.Target).GetBorderCenterFill();
1726                 }
1727                 catch (Exception e)
1728                 {
1729                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1730                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1731                 }
1732
1733         return _ret_var;
1734
1735             }
1736             else
1737             {
1738                 return efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1739             }
1740         }
1741
1742         private static efl_gfx_image_border_center_fill_get_delegate efl_gfx_image_border_center_fill_get_static_delegate;
1743
1744
1745         private delegate void efl_gfx_image_border_center_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.BorderFillMode fill);
1746
1747
1748         public delegate void efl_gfx_image_border_center_fill_set_api_delegate(System.IntPtr obj,  Efl.Gfx.BorderFillMode fill);
1749
1750         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");
1751
1752         private static void border_center_fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BorderFillMode fill)
1753         {
1754             Eina.Log.Debug("function efl_gfx_image_border_center_fill_set was called");
1755             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1756             if (ws != null)
1757             {
1758
1759                 try
1760                 {
1761                     ((WidgetPartBg)ws.Target).SetBorderCenterFill(fill);
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
1770             }
1771             else
1772             {
1773                 efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill);
1774             }
1775         }
1776
1777         private static efl_gfx_image_border_center_fill_set_delegate efl_gfx_image_border_center_fill_set_static_delegate;
1778
1779
1780         private delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1781
1782
1783         public delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_api_delegate(System.IntPtr obj);
1784
1785         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");
1786
1787         private static Eina.Size2D.NativeStruct image_size_get(System.IntPtr obj, System.IntPtr pd)
1788         {
1789             Eina.Log.Debug("function efl_gfx_image_size_get was called");
1790             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1791             if (ws != null)
1792             {
1793             Eina.Size2D _ret_var = default(Eina.Size2D);
1794                 try
1795                 {
1796                     _ret_var = ((WidgetPartBg)ws.Target).GetImageSize();
1797                 }
1798                 catch (Exception e)
1799                 {
1800                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1801                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1802                 }
1803
1804         return _ret_var;
1805
1806             }
1807             else
1808             {
1809                 return efl_gfx_image_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1810             }
1811         }
1812
1813         private static efl_gfx_image_size_get_delegate efl_gfx_image_size_get_static_delegate;
1814
1815
1816         private delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
1817
1818
1819         public delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_api_delegate(System.IntPtr obj);
1820
1821         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");
1822
1823         private static Efl.Gfx.ImageContentHint content_hint_get(System.IntPtr obj, System.IntPtr pd)
1824         {
1825             Eina.Log.Debug("function efl_gfx_image_content_hint_get was called");
1826             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1827             if (ws != null)
1828             {
1829             Efl.Gfx.ImageContentHint _ret_var = default(Efl.Gfx.ImageContentHint);
1830                 try
1831                 {
1832                     _ret_var = ((WidgetPartBg)ws.Target).GetContentHint();
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_content_hint_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_content_hint_get_delegate efl_gfx_image_content_hint_get_static_delegate;
1850
1851
1852         private delegate void efl_gfx_image_content_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageContentHint hint);
1853
1854
1855         public delegate void efl_gfx_image_content_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageContentHint hint);
1856
1857         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");
1858
1859         private static void content_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageContentHint hint)
1860         {
1861             Eina.Log.Debug("function efl_gfx_image_content_hint_set was called");
1862             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1863             if (ws != null)
1864             {
1865
1866                 try
1867                 {
1868                     ((WidgetPartBg)ws.Target).SetContentHint(hint);
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_content_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
1881             }
1882         }
1883
1884         private static efl_gfx_image_content_hint_set_delegate efl_gfx_image_content_hint_set_static_delegate;
1885
1886
1887         private delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
1888
1889
1890         public delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_api_delegate(System.IntPtr obj);
1891
1892         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");
1893
1894         private static Efl.Gfx.ImageScaleHint scale_hint_get(System.IntPtr obj, System.IntPtr pd)
1895         {
1896             Eina.Log.Debug("function efl_gfx_image_scale_hint_get was called");
1897             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1898             if (ws != null)
1899             {
1900             Efl.Gfx.ImageScaleHint _ret_var = default(Efl.Gfx.ImageScaleHint);
1901                 try
1902                 {
1903                     _ret_var = ((WidgetPartBg)ws.Target).GetScaleHint();
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_scale_hint_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_scale_hint_get_delegate efl_gfx_image_scale_hint_get_static_delegate;
1921
1922
1923         private delegate void efl_gfx_image_scale_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleHint hint);
1924
1925
1926         public delegate void efl_gfx_image_scale_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleHint hint);
1927
1928         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");
1929
1930         private static void scale_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleHint hint)
1931         {
1932             Eina.Log.Debug("function efl_gfx_image_scale_hint_set was called");
1933             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1934             if (ws != null)
1935             {
1936
1937                 try
1938                 {
1939                     ((WidgetPartBg)ws.Target).SetScaleHint(hint);
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
1948             }
1949             else
1950             {
1951                 efl_gfx_image_scale_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
1952             }
1953         }
1954
1955         private static efl_gfx_image_scale_hint_set_delegate efl_gfx_image_scale_hint_set_static_delegate;
1956
1957
1958         private delegate Eina.Error efl_gfx_image_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
1959
1960
1961         public delegate Eina.Error efl_gfx_image_load_error_get_api_delegate(System.IntPtr obj);
1962
1963         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");
1964
1965         private static Eina.Error image_load_error_get(System.IntPtr obj, System.IntPtr pd)
1966         {
1967             Eina.Log.Debug("function efl_gfx_image_load_error_get was called");
1968             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1969             if (ws != null)
1970             {
1971             Eina.Error _ret_var = default(Eina.Error);
1972                 try
1973                 {
1974                     _ret_var = ((WidgetPartBg)ws.Target).GetImageLoadError();
1975                 }
1976                 catch (Exception e)
1977                 {
1978                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1979                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1980                 }
1981
1982         return _ret_var;
1983
1984             }
1985             else
1986             {
1987                 return efl_gfx_image_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1988             }
1989         }
1990
1991         private static efl_gfx_image_load_error_get_delegate efl_gfx_image_load_error_get_static_delegate;
1992
1993         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1994
1995 }
1996 }
1997 }
1998
1999 }
2000