internals/src/EflSharp/EflSharp/efl/efl_ui_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>The bg (background) widget is used for setting (solid) background decorations for a window (unless it has transparency enabled) or for any container object. It works just like an image, but has some properties useful for backgrounds, such as setting it to tiled, centered, scaled or stretched.</summary>
  13 [Efl.Ui.Bg.NativeMethods]
  14 public class Bg : Efl.Ui.LayoutBase, Efl.IFile, Efl.Gfx.IImage, Efl.Gfx.IImageLoadController
  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(Bg))
  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_bg_class_get();
  34     /// <summary>Initializes a new instance of the <see cref="Bg"/> class.</summary>
  35     /// <param name="parent">Parent instance.</param>
  36     /// <param name="style">The widget style to use. See <see cref="Efl.Ui.Widget.SetStyle"/></param>
  37     public Bg(Efl.Object parent
  38             , System.String style = null) : base(efl_ui_bg_class_get(), typeof(Bg), parent)
  39     {
  40         if (Efl.Eo.Globals.ParamHelperCheck(style))
  41         {
  42             SetStyle(Efl.Eo.Globals.GetParamHelper(style));
  43         }
  44
  45         FinishInstantiation();
  46     }
  47
  48     /// <summary>Initializes a new instance of the <see cref="Bg"/> class.
  49     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  50     /// <param name="raw">The native pointer to be wrapped.</param>
  51     protected Bg(System.IntPtr raw) : base(raw)
  52     {
  53     }
  54
  55     /// <summary>Initializes a new instance of the <see cref="Bg"/> class.
  56     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  57     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  58     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  59     /// <param name="parent">The Efl.Object parent of this instance.</param>
  60     protected Bg(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  61     {
  62     }
  63
  64     /// <summary>Image data has been preloaded.</summary>
  65     public event EventHandler ImagePreloadEvt
  66     {
  67         add
  68         {
  69             lock (eventLock)
  70             {
  71                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  72                 {
  73                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  74                     if (obj != null)
  75                     {
  76                         EventArgs args = EventArgs.Empty;
  77                         try
  78                         {
  79                             value?.Invoke(obj, args);
  80                         }
  81                         catch (Exception e)
  82                         {
  83                             Eina.Log.Error(e.ToString());
  84                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  85                         }
  86                     }
  87                 };
  88
  89                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  90                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
  91             }
  92         }
  93
  94         remove
  95         {
  96             lock (eventLock)
  97             {
  98                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  99                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 100             }
 101         }
 102     }
 103     ///<summary>Method to raise event ImagePreloadEvt.</summary>
 104     public void OnImagePreloadEvt(EventArgs e)
 105     {
 106         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 107         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 108         if (desc == IntPtr.Zero)
 109         {
 110             Eina.Log.Error($"Failed to get native event {key}");
 111             return;
 112         }
 113
 114         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 115     }
 116     /// <summary>Image was resized (its pixel data).</summary>
 117     public event EventHandler ImageResizeEvt
 118     {
 119         add
 120         {
 121             lock (eventLock)
 122             {
 123                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 124                 {
 125                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 126                     if (obj != null)
 127                     {
 128                         EventArgs args = EventArgs.Empty;
 129                         try
 130                         {
 131                             value?.Invoke(obj, args);
 132                         }
 133                         catch (Exception e)
 134                         {
 135                             Eina.Log.Error(e.ToString());
 136                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 137                         }
 138                     }
 139                 };
 140
 141                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 142                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 143             }
 144         }
 145
 146         remove
 147         {
 148             lock (eventLock)
 149             {
 150                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 151                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 152             }
 153         }
 154     }
 155     ///<summary>Method to raise event ImageResizeEvt.</summary>
 156     public void OnImageResizeEvt(EventArgs e)
 157     {
 158         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 159         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 160         if (desc == IntPtr.Zero)
 161         {
 162             Eina.Log.Error($"Failed to get native event {key}");
 163             return;
 164         }
 165
 166         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 167     }
 168     /// <summary>Image data has been unloaded (by some mechanism in EFL that threw out the original image data).</summary>
 169     public event EventHandler ImageUnloadEvt
 170     {
 171         add
 172         {
 173             lock (eventLock)
 174             {
 175                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 176                 {
 177                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 178                     if (obj != null)
 179                     {
 180                         EventArgs args = EventArgs.Empty;
 181                         try
 182                         {
 183                             value?.Invoke(obj, args);
 184                         }
 185                         catch (Exception e)
 186                         {
 187                             Eina.Log.Error(e.ToString());
 188                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 189                         }
 190                     }
 191                 };
 192
 193                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 194                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 195             }
 196         }
 197
 198         remove
 199         {
 200             lock (eventLock)
 201             {
 202                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 203                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 204             }
 205         }
 206     }
 207     ///<summary>Method to raise event ImageUnloadEvt.</summary>
 208     public void OnImageUnloadEvt(EventArgs e)
 209     {
 210         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 211         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 212         if (desc == IntPtr.Zero)
 213         {
 214             Eina.Log.Error($"Failed to get native event {key}");
 215             return;
 216         }
 217
 218         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 219     }
 220     /// <summary>Called when he image was loaded</summary>
 221     public event EventHandler LoadDoneEvt
 222     {
 223         add
 224         {
 225             lock (eventLock)
 226             {
 227                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 228                 {
 229                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 230                     if (obj != null)
 231                     {
 232                         EventArgs args = EventArgs.Empty;
 233                         try
 234                         {
 235                             value?.Invoke(obj, args);
 236                         }
 237                         catch (Exception e)
 238                         {
 239                             Eina.Log.Error(e.ToString());
 240                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 241                         }
 242                     }
 243                 };
 244
 245                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
 246                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 247             }
 248         }
 249
 250         remove
 251         {
 252             lock (eventLock)
 253             {
 254                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
 255                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 256             }
 257         }
 258     }
 259     ///<summary>Method to raise event LoadDoneEvt.</summary>
 260     public void OnLoadDoneEvt(EventArgs e)
 261     {
 262         var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
 263         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 264         if (desc == IntPtr.Zero)
 265         {
 266             Eina.Log.Error($"Failed to get native event {key}");
 267             return;
 268         }
 269
 270         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 271     }
 272     /// <summary>Called when an error happened during image loading</summary>
 273     public event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt
 274     {
 275         add
 276         {
 277             lock (eventLock)
 278             {
 279                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 280                 {
 281                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 282                     if (obj != null)
 283                     {
 284                         Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args args = new Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args();
 285                         args.arg = (Eina.Error)Marshal.PtrToStructure(evt.Info, typeof(Eina.Error));
 286                         try
 287                         {
 288                             value?.Invoke(obj, args);
 289                         }
 290                         catch (Exception e)
 291                         {
 292                             Eina.Log.Error(e.ToString());
 293                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 294                         }
 295                     }
 296                 };
 297
 298                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 299                 AddNativeEventHandler(efl.Libs.Elementary, key, callerCb, value);
 300             }
 301         }
 302
 303         remove
 304         {
 305             lock (eventLock)
 306             {
 307                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 308                 RemoveNativeEventHandler(efl.Libs.Elementary, key, value);
 309             }
 310         }
 311     }
 312     ///<summary>Method to raise event LoadErrorEvt.</summary>
 313     public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
 314     {
 315         var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 316         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Elementary, key);
 317         if (desc == IntPtr.Zero)
 318         {
 319             Eina.Log.Error($"Failed to get native event {key}");
 320             return;
 321         }
 322
 323         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc((int)e.arg);
 324         try
 325         {
 326             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 327         }
 328         finally
 329         {
 330             Marshal.FreeHGlobal(info);
 331         }
 332     }
 333     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 334     /// (Since EFL 1.22)</summary>
 335     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 336     virtual public Eina.File GetMmap() {
 337          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));
 338         Eina.Error.RaiseIfUnhandledException();
 339         return _ret_var;
 340  }
 341     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 342     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 343     /// (Since EFL 1.22)</summary>
 344     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 345     /// <returns>0 on success, error code otherwise</returns>
 346     virtual public Eina.Error SetMmap(Eina.File f) {
 347                                  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);
 348         Eina.Error.RaiseIfUnhandledException();
 349                         return _ret_var;
 350  }
 351     /// <summary>Retrieve the file path from where an object is to fetch the data.
 352     /// You must not modify the strings on the returned pointers.
 353     /// (Since EFL 1.22)</summary>
 354     /// <returns>The file path.</returns>
 355     virtual public System.String GetFile() {
 356          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 357         Eina.Error.RaiseIfUnhandledException();
 358         return _ret_var;
 359  }
 360     /// <summary>Set the file path from where an object will fetch the data.
 361     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 362     /// (Since EFL 1.22)</summary>
 363     /// <param name="file">The file path.</param>
 364     /// <returns>0 on success, error code otherwise</returns>
 365     virtual public Eina.Error SetFile(System.String file) {
 366                                  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);
 367         Eina.Error.RaiseIfUnhandledException();
 368                         return _ret_var;
 369  }
 370     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 371     /// 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"/>).
 372     ///
 373     /// You must not modify the strings on the returned pointers.
 374     /// (Since EFL 1.22)</summary>
 375     /// <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>
 376     virtual public System.String GetKey() {
 377          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));
 378         Eina.Error.RaiseIfUnhandledException();
 379         return _ret_var;
 380  }
 381     /// <summary>Set the key which corresponds to the target data within a file.
 382     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 383     /// (Since EFL 1.22)</summary>
 384     /// <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>
 385     virtual public void SetKey(System.String key) {
 386                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),key);
 387         Eina.Error.RaiseIfUnhandledException();
 388                          }
 389     /// <summary>Get the load state of the object.
 390     /// (Since EFL 1.22)</summary>
 391     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 392     virtual public bool GetLoaded() {
 393          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));
 394         Eina.Error.RaiseIfUnhandledException();
 395         return _ret_var;
 396  }
 397     /// <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.
 398     /// 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.
 399     ///
 400     /// 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.
 401     /// (Since EFL 1.22)</summary>
 402     /// <returns>0 on success, error code otherwise</returns>
 403     virtual public Eina.Error Load() {
 404          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 405         Eina.Error.RaiseIfUnhandledException();
 406         return _ret_var;
 407  }
 408     /// <summary>Perform all necessary operations to unload file data from the object.
 409     /// 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.
 410     ///
 411     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 412     /// (Since EFL 1.22)</summary>
 413     virtual public void Unload() {
 414          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 415         Eina.Error.RaiseIfUnhandledException();
 416          }
 417     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 418     /// 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.
 419     ///
 420     /// <c>true</c> by default</summary>
 421     /// <returns>Whether to use smooth scale or not.</returns>
 422     virtual public bool GetSmoothScale() {
 423          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));
 424         Eina.Error.RaiseIfUnhandledException();
 425         return _ret_var;
 426  }
 427     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 428     /// 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.
 429     ///
 430     /// <c>true</c> by default</summary>
 431     /// <param name="smooth_scale">Whether to use smooth scale or not.</param>
 432     virtual public void SetSmoothScale(bool smooth_scale) {
 433                                  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);
 434         Eina.Error.RaiseIfUnhandledException();
 435                          }
 436     /// <summary>Control how the image is scaled.</summary>
 437     /// <returns>Image scale type</returns>
 438     virtual public Efl.Gfx.ImageScaleType GetScaleType() {
 439          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));
 440         Eina.Error.RaiseIfUnhandledException();
 441         return _ret_var;
 442  }
 443     /// <summary>Control how the image is scaled.</summary>
 444     /// <param name="scale_type">Image scale type</param>
 445     virtual public void SetScaleType(Efl.Gfx.ImageScaleType scale_type) {
 446                                  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);
 447         Eina.Error.RaiseIfUnhandledException();
 448                          }
 449     /// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
 450     /// <returns>The image&apos;s ratio.</returns>
 451     virtual public double GetRatio() {
 452          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));
 453         Eina.Error.RaiseIfUnhandledException();
 454         return _ret_var;
 455  }
 456     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 457     /// 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.
 458     ///
 459     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 460     ///
 461     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 462     ///
 463     /// 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.
 464     ///
 465     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 466     /// <param name="l">The border&apos;s left width.</param>
 467     /// <param name="r">The border&apos;s right width.</param>
 468     /// <param name="t">The border&apos;s top height.</param>
 469     /// <param name="b">The border&apos;s bottom height.</param>
 470     virtual public void GetBorder(out int l, out int r, out int t, out int b) {
 471                                                                                                          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);
 472         Eina.Error.RaiseIfUnhandledException();
 473                                                                          }
 474     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 475     /// 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.
 476     ///
 477     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 478     ///
 479     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 480     ///
 481     /// 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.
 482     ///
 483     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 484     /// <param name="l">The border&apos;s left width.</param>
 485     /// <param name="r">The border&apos;s right width.</param>
 486     /// <param name="t">The border&apos;s top height.</param>
 487     /// <param name="b">The border&apos;s bottom height.</param>
 488     virtual public void SetBorder(int l, int r, int t, int b) {
 489                                                                                                          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);
 490         Eina.Error.RaiseIfUnhandledException();
 491                                                                          }
 492     /// <summary>Scaling factor applied to the image borders.
 493     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 494     ///
 495     /// Default value is 1.0 (no scaling).</summary>
 496     /// <returns>The scale factor.</returns>
 497     virtual public double GetBorderScale() {
 498          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));
 499         Eina.Error.RaiseIfUnhandledException();
 500         return _ret_var;
 501  }
 502     /// <summary>Scaling factor applied to the image borders.
 503     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 504     ///
 505     /// Default value is 1.0 (no scaling).</summary>
 506     /// <param name="scale">The scale factor.</param>
 507     virtual public void SetBorderScale(double scale) {
 508                                  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);
 509         Eina.Error.RaiseIfUnhandledException();
 510                          }
 511     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 512     /// 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.
 513     ///
 514     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 515     /// <returns>Fill mode of the center region.</returns>
 516     virtual public Efl.Gfx.BorderFillMode GetBorderCenterFill() {
 517          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));
 518         Eina.Error.RaiseIfUnhandledException();
 519         return _ret_var;
 520  }
 521     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 522     /// 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.
 523     ///
 524     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 525     /// <param name="fill">Fill mode of the center region.</param>
 526     virtual public void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill) {
 527                                  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);
 528         Eina.Error.RaiseIfUnhandledException();
 529                          }
 530     /// <summary>This represents the size of the original image in pixels.
 531     /// 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.
 532     ///
 533     /// This is a read-only property, and may return 0x0.</summary>
 534     /// <returns>The size in pixels.</returns>
 535     virtual public Eina.Size2D GetImageSize() {
 536          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));
 537         Eina.Error.RaiseIfUnhandledException();
 538         return _ret_var;
 539  }
 540     /// <summary>Get the content hint setting of a given image object of the canvas.
 541     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 542     /// <returns>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></returns>
 543     virtual public Efl.Gfx.ImageContentHint GetContentHint() {
 544          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));
 545         Eina.Error.RaiseIfUnhandledException();
 546         return _ret_var;
 547  }
 548     /// <summary>Set the content hint setting of a given image object of the canvas.
 549     /// 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>
 550     /// <param name="hint">Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></param>
 551     virtual public void SetContentHint(Efl.Gfx.ImageContentHint hint) {
 552                                  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);
 553         Eina.Error.RaiseIfUnhandledException();
 554                          }
 555     /// <summary>Get the scale hint of a given image of the canvas.
 556     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 557     /// <returns>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></returns>
 558     virtual public Efl.Gfx.ImageScaleHint GetScaleHint() {
 559          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));
 560         Eina.Error.RaiseIfUnhandledException();
 561         return _ret_var;
 562  }
 563     /// <summary>Set the scale hint of a given image of the canvas.
 564     /// 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>
 565     /// <param name="hint">Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></param>
 566     virtual public void SetScaleHint(Efl.Gfx.ImageScaleHint hint) {
 567                                  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);
 568         Eina.Error.RaiseIfUnhandledException();
 569                          }
 570     /// <summary>Gets the (last) file loading error for a given object.</summary>
 571     /// <returns>The load error code.</returns>
 572     virtual public Eina.Error GetImageLoadError() {
 573          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));
 574         Eina.Error.RaiseIfUnhandledException();
 575         return _ret_var;
 576  }
 577     /// <summary>Returns the requested load size.</summary>
 578     /// <returns>The image load size.</returns>
 579     virtual public Eina.Size2D GetLoadSize() {
 580          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 581         Eina.Error.RaiseIfUnhandledException();
 582         return _ret_var;
 583  }
 584     /// <summary>Requests the canvas to load the image at the given size.
 585     /// EFL will try to load an image of the requested size but does not guarantee an exact match between the request and the loaded image dimensions.</summary>
 586     /// <param name="size">The image load size.</param>
 587     virtual public void SetLoadSize(Eina.Size2D size) {
 588          Eina.Size2D.NativeStruct _in_size = size;
 589                         Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_size);
 590         Eina.Error.RaiseIfUnhandledException();
 591                          }
 592     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 593     /// This function returns the DPI resolution of the given canvas image.</summary>
 594     /// <returns>The DPI resolution.</returns>
 595     virtual public double GetLoadDpi() {
 596          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 597         Eina.Error.RaiseIfUnhandledException();
 598         return _ret_var;
 599  }
 600     /// <summary>Set the DPI resolution of an image object&apos;s source image.
 601     /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
 602     /// <param name="dpi">The DPI resolution.</param>
 603     virtual public void SetLoadDpi(double dpi) {
 604                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dpi);
 605         Eina.Error.RaiseIfUnhandledException();
 606                          }
 607     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 608     /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
 609     virtual public bool GetLoadRegionSupport() {
 610          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 611         Eina.Error.RaiseIfUnhandledException();
 612         return _ret_var;
 613  }
 614     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 615     /// <returns>A region of the image.</returns>
 616     virtual public Eina.Rect GetLoadRegion() {
 617          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 618         Eina.Error.RaiseIfUnhandledException();
 619         return _ret_var;
 620  }
 621     /// <summary>Inform a given image object to load a selective region of its source image.
 622     /// This function is useful when one is not showing all of an image&apos;s area on its image object.
 623     ///
 624     /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
 625     /// <param name="region">A region of the image.</param>
 626     virtual public void SetLoadRegion(Eina.Rect region) {
 627          Eina.Rect.NativeStruct _in_region = region;
 628                         Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_region);
 629         Eina.Error.RaiseIfUnhandledException();
 630                          }
 631     /// <summary>Defines whether the orientation information in the image file should be honored.
 632     /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
 633     /// <returns><c>true</c> means that it should honor the orientation information.</returns>
 634     virtual public bool GetLoadOrientation() {
 635          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 636         Eina.Error.RaiseIfUnhandledException();
 637         return _ret_var;
 638  }
 639     /// <summary>Defines whether the orientation information in the image file should be honored.
 640     /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
 641     /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
 642     virtual public void SetLoadOrientation(bool enable) {
 643                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),enable);
 644         Eina.Error.RaiseIfUnhandledException();
 645                          }
 646     /// <summary>The scale down factor is a divider on the original image size.
 647     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 648     ///
 649     /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
 650     ///
 651     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 652     /// <returns>The scale down dividing factor.</returns>
 653     virtual public int GetLoadScaleDown() {
 654          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 655         Eina.Error.RaiseIfUnhandledException();
 656         return _ret_var;
 657  }
 658     /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
 659     /// <param name="div">The scale down dividing factor.</param>
 660     virtual public void SetLoadScaleDown(int div) {
 661                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),div);
 662         Eina.Error.RaiseIfUnhandledException();
 663                          }
 664     /// <summary>Initial load should skip header check and leave it all to data load
 665     /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
 666     /// <returns>Will be true if header is to be skipped.</returns>
 667     virtual public bool GetLoadSkipHeader() {
 668          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 669         Eina.Error.RaiseIfUnhandledException();
 670         return _ret_var;
 671  }
 672     /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
 673     /// <param name="skip">Will be true if header is to be skipped.</param>
 674     virtual public void SetLoadSkipHeader(bool skip) {
 675                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),skip);
 676         Eina.Error.RaiseIfUnhandledException();
 677                          }
 678     /// <summary>Begin preloading an image object&apos;s image data in the background.
 679     /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
 680     virtual public void LoadAsyncStart() {
 681          Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 682         Eina.Error.RaiseIfUnhandledException();
 683          }
 684     /// <summary>Cancel preloading an image object&apos;s image data in the background.
 685     /// The object should be left in a state where it has no image data. If cancel is called too late, the image will be kept in memory.</summary>
 686     virtual public void LoadAsyncCancel() {
 687          Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 688         Eina.Error.RaiseIfUnhandledException();
 689          }
 690     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 691     /// (Since EFL 1.22)</summary>
 692     /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 693     public Eina.File Mmap {
 694         get { return GetMmap(); }
 695         set { SetMmap(value); }
 696     }
 697     /// <summary>Retrieve the file path from where an object is to fetch the data.
 698     /// You must not modify the strings on the returned pointers.
 699     /// (Since EFL 1.22)</summary>
 700     /// <value>The file path.</value>
 701     public System.String File {
 702         get { return GetFile(); }
 703         set { SetFile(value); }
 704     }
 705     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 706     /// 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"/>).
 707     ///
 708     /// You must not modify the strings on the returned pointers.
 709     /// (Since EFL 1.22)</summary>
 710     /// <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>
 711     public System.String Key {
 712         get { return GetKey(); }
 713         set { SetKey(value); }
 714     }
 715     /// <summary>Get the load state of the object.
 716     /// (Since EFL 1.22)</summary>
 717     /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 718     public bool Loaded {
 719         get { return GetLoaded(); }
 720     }
 721     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 722     /// 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.
 723     ///
 724     /// <c>true</c> by default</summary>
 725     /// <value>Whether to use smooth scale or not.</value>
 726     public bool SmoothScale {
 727         get { return GetSmoothScale(); }
 728         set { SetSmoothScale(value); }
 729     }
 730     /// <summary>Control how the image is scaled.</summary>
 731     /// <value>Image scale type</value>
 732     public Efl.Gfx.ImageScaleType ScaleType {
 733         get { return GetScaleType(); }
 734         set { SetScaleType(value); }
 735     }
 736     /// <summary>The native width/height ratio of the image.</summary>
 737     /// <value>The image&apos;s ratio.</value>
 738     public double Ratio {
 739         get { return GetRatio(); }
 740     }
 741     /// <summary>Scaling factor applied to the image borders.
 742     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 743     ///
 744     /// Default value is 1.0 (no scaling).</summary>
 745     /// <value>The scale factor.</value>
 746     public double BorderScale {
 747         get { return GetBorderScale(); }
 748         set { SetBorderScale(value); }
 749     }
 750     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 751     /// 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.
 752     ///
 753     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 754     /// <value>Fill mode of the center region.</value>
 755     public Efl.Gfx.BorderFillMode BorderCenterFill {
 756         get { return GetBorderCenterFill(); }
 757         set { SetBorderCenterFill(value); }
 758     }
 759     /// <summary>This represents the size of the original image in pixels.
 760     /// 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.
 761     ///
 762     /// This is a read-only property, and may return 0x0.</summary>
 763     /// <value>The size in pixels.</value>
 764     public Eina.Size2D ImageSize {
 765         get { return GetImageSize(); }
 766     }
 767     /// <summary>Get the content hint setting of a given image object of the canvas.
 768     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 769     /// <value>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></value>
 770     public Efl.Gfx.ImageContentHint ContentHint {
 771         get { return GetContentHint(); }
 772         set { SetContentHint(value); }
 773     }
 774     /// <summary>Get the scale hint of a given image of the canvas.
 775     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 776     /// <value>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></value>
 777     public Efl.Gfx.ImageScaleHint ScaleHint {
 778         get { return GetScaleHint(); }
 779         set { SetScaleHint(value); }
 780     }
 781     /// <summary>Gets the (last) file loading error for a given object.</summary>
 782     /// <value>The load error code.</value>
 783     public Eina.Error ImageLoadError {
 784         get { return GetImageLoadError(); }
 785     }
 786     /// <summary>The load size of an image.
 787     /// The image will be loaded into memory as if it was the specified size instead of its original size. This can save a lot of memory and is important for scalable types like svg.
 788     ///
 789     /// By default, the load size is not specified, so it is 0x0.</summary>
 790     /// <value>The image load size.</value>
 791     public Eina.Size2D LoadSize {
 792         get { return GetLoadSize(); }
 793         set { SetLoadSize(value); }
 794     }
 795     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 796     /// This function returns the DPI resolution of the given canvas image.</summary>
 797     /// <value>The DPI resolution.</value>
 798     public double LoadDpi {
 799         get { return GetLoadDpi(); }
 800         set { SetLoadDpi(value); }
 801     }
 802     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 803     /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
 804     public bool LoadRegionSupport {
 805         get { return GetLoadRegionSupport(); }
 806     }
 807     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 808     /// <value>A region of the image.</value>
 809     public Eina.Rect LoadRegion {
 810         get { return GetLoadRegion(); }
 811         set { SetLoadRegion(value); }
 812     }
 813     /// <summary>Defines whether the orientation information in the image file should be honored.
 814     /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
 815     /// <value><c>true</c> means that it should honor the orientation information.</value>
 816     public bool LoadOrientation {
 817         get { return GetLoadOrientation(); }
 818         set { SetLoadOrientation(value); }
 819     }
 820     /// <summary>The scale down factor is a divider on the original image size.
 821     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 822     ///
 823     /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
 824     ///
 825     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 826     /// <value>The scale down dividing factor.</value>
 827     public int LoadScaleDown {
 828         get { return GetLoadScaleDown(); }
 829         set { SetLoadScaleDown(value); }
 830     }
 831     /// <summary>Initial load should skip header check and leave it all to data load
 832     /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
 833     /// <value>Will be true if header is to be skipped.</value>
 834     public bool LoadSkipHeader {
 835         get { return GetLoadSkipHeader(); }
 836         set { SetLoadSkipHeader(value); }
 837     }
 838     private static IntPtr GetEflClassStatic()
 839     {
 840         return Efl.Ui.Bg.efl_ui_bg_class_get();
 841     }
 842     /// <summary>Wrapper for native methods and virtual method delegates.
 843     /// For internal use by generated code only.</summary>
 844     public new class NativeMethods : Efl.Ui.LayoutBase.NativeMethods
 845     {
 846         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 847         /// <summary>Gets the list of Eo operations to override.</summary>
 848         /// <returns>The list of Eo operations to be overload.</returns>
 849         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 850         {
 851             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 852             var methods = Efl.Eo.Globals.GetUserMethods(type);
 853
 854             if (efl_file_mmap_get_static_delegate == null)
 855             {
 856                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 857             }
 858
 859             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 860             {
 861                 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) });
 862             }
 863
 864             if (efl_file_mmap_set_static_delegate == null)
 865             {
 866                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 867             }
 868
 869             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 870             {
 871                 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) });
 872             }
 873
 874             if (efl_file_get_static_delegate == null)
 875             {
 876                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 877             }
 878
 879             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 880             {
 881                 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) });
 882             }
 883
 884             if (efl_file_set_static_delegate == null)
 885             {
 886                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 887             }
 888
 889             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 890             {
 891                 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) });
 892             }
 893
 894             if (efl_file_key_get_static_delegate == null)
 895             {
 896                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 897             }
 898
 899             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 900             {
 901                 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) });
 902             }
 903
 904             if (efl_file_key_set_static_delegate == null)
 905             {
 906                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 907             }
 908
 909             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 910             {
 911                 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) });
 912             }
 913
 914             if (efl_file_loaded_get_static_delegate == null)
 915             {
 916                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 917             }
 918
 919             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 920             {
 921                 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) });
 922             }
 923
 924             if (efl_file_load_static_delegate == null)
 925             {
 926                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 927             }
 928
 929             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 930             {
 931                 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) });
 932             }
 933
 934             if (efl_file_unload_static_delegate == null)
 935             {
 936                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 937             }
 938
 939             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 940             {
 941                 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) });
 942             }
 943
 944             if (efl_gfx_image_smooth_scale_get_static_delegate == null)
 945             {
 946                 efl_gfx_image_smooth_scale_get_static_delegate = new efl_gfx_image_smooth_scale_get_delegate(smooth_scale_get);
 947             }
 948
 949             if (methods.FirstOrDefault(m => m.Name == "GetSmoothScale") != null)
 950             {
 951                 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) });
 952             }
 953
 954             if (efl_gfx_image_smooth_scale_set_static_delegate == null)
 955             {
 956                 efl_gfx_image_smooth_scale_set_static_delegate = new efl_gfx_image_smooth_scale_set_delegate(smooth_scale_set);
 957             }
 958
 959             if (methods.FirstOrDefault(m => m.Name == "SetSmoothScale") != null)
 960             {
 961                 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) });
 962             }
 963
 964             if (efl_gfx_image_scale_type_get_static_delegate == null)
 965             {
 966                 efl_gfx_image_scale_type_get_static_delegate = new efl_gfx_image_scale_type_get_delegate(scale_type_get);
 967             }
 968
 969             if (methods.FirstOrDefault(m => m.Name == "GetScaleType") != null)
 970             {
 971                 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) });
 972             }
 973
 974             if (efl_gfx_image_scale_type_set_static_delegate == null)
 975             {
 976                 efl_gfx_image_scale_type_set_static_delegate = new efl_gfx_image_scale_type_set_delegate(scale_type_set);
 977             }
 978
 979             if (methods.FirstOrDefault(m => m.Name == "SetScaleType") != null)
 980             {
 981                 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) });
 982             }
 983
 984             if (efl_gfx_image_ratio_get_static_delegate == null)
 985             {
 986                 efl_gfx_image_ratio_get_static_delegate = new efl_gfx_image_ratio_get_delegate(ratio_get);
 987             }
 988
 989             if (methods.FirstOrDefault(m => m.Name == "GetRatio") != null)
 990             {
 991                 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) });
 992             }
 993
 994             if (efl_gfx_image_border_get_static_delegate == null)
 995             {
 996                 efl_gfx_image_border_get_static_delegate = new efl_gfx_image_border_get_delegate(border_get);
 997             }
 998
 999             if (methods.FirstOrDefault(m => m.Name == "GetBorder") != null)
1000             {
1001                 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) });
1002             }
1003
1004             if (efl_gfx_image_border_set_static_delegate == null)
1005             {
1006                 efl_gfx_image_border_set_static_delegate = new efl_gfx_image_border_set_delegate(border_set);
1007             }
1008
1009             if (methods.FirstOrDefault(m => m.Name == "SetBorder") != null)
1010             {
1011                 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) });
1012             }
1013
1014             if (efl_gfx_image_border_scale_get_static_delegate == null)
1015             {
1016                 efl_gfx_image_border_scale_get_static_delegate = new efl_gfx_image_border_scale_get_delegate(border_scale_get);
1017             }
1018
1019             if (methods.FirstOrDefault(m => m.Name == "GetBorderScale") != null)
1020             {
1021                 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) });
1022             }
1023
1024             if (efl_gfx_image_border_scale_set_static_delegate == null)
1025             {
1026                 efl_gfx_image_border_scale_set_static_delegate = new efl_gfx_image_border_scale_set_delegate(border_scale_set);
1027             }
1028
1029             if (methods.FirstOrDefault(m => m.Name == "SetBorderScale") != null)
1030             {
1031                 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) });
1032             }
1033
1034             if (efl_gfx_image_border_center_fill_get_static_delegate == null)
1035             {
1036                 efl_gfx_image_border_center_fill_get_static_delegate = new efl_gfx_image_border_center_fill_get_delegate(border_center_fill_get);
1037             }
1038
1039             if (methods.FirstOrDefault(m => m.Name == "GetBorderCenterFill") != null)
1040             {
1041                 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) });
1042             }
1043
1044             if (efl_gfx_image_border_center_fill_set_static_delegate == null)
1045             {
1046                 efl_gfx_image_border_center_fill_set_static_delegate = new efl_gfx_image_border_center_fill_set_delegate(border_center_fill_set);
1047             }
1048
1049             if (methods.FirstOrDefault(m => m.Name == "SetBorderCenterFill") != null)
1050             {
1051                 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) });
1052             }
1053
1054             if (efl_gfx_image_size_get_static_delegate == null)
1055             {
1056                 efl_gfx_image_size_get_static_delegate = new efl_gfx_image_size_get_delegate(image_size_get);
1057             }
1058
1059             if (methods.FirstOrDefault(m => m.Name == "GetImageSize") != null)
1060             {
1061                 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) });
1062             }
1063
1064             if (efl_gfx_image_content_hint_get_static_delegate == null)
1065             {
1066                 efl_gfx_image_content_hint_get_static_delegate = new efl_gfx_image_content_hint_get_delegate(content_hint_get);
1067             }
1068
1069             if (methods.FirstOrDefault(m => m.Name == "GetContentHint") != null)
1070             {
1071                 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) });
1072             }
1073
1074             if (efl_gfx_image_content_hint_set_static_delegate == null)
1075             {
1076                 efl_gfx_image_content_hint_set_static_delegate = new efl_gfx_image_content_hint_set_delegate(content_hint_set);
1077             }
1078
1079             if (methods.FirstOrDefault(m => m.Name == "SetContentHint") != null)
1080             {
1081                 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) });
1082             }
1083
1084             if (efl_gfx_image_scale_hint_get_static_delegate == null)
1085             {
1086                 efl_gfx_image_scale_hint_get_static_delegate = new efl_gfx_image_scale_hint_get_delegate(scale_hint_get);
1087             }
1088
1089             if (methods.FirstOrDefault(m => m.Name == "GetScaleHint") != null)
1090             {
1091                 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) });
1092             }
1093
1094             if (efl_gfx_image_scale_hint_set_static_delegate == null)
1095             {
1096                 efl_gfx_image_scale_hint_set_static_delegate = new efl_gfx_image_scale_hint_set_delegate(scale_hint_set);
1097             }
1098
1099             if (methods.FirstOrDefault(m => m.Name == "SetScaleHint") != null)
1100             {
1101                 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) });
1102             }
1103
1104             if (efl_gfx_image_load_error_get_static_delegate == null)
1105             {
1106                 efl_gfx_image_load_error_get_static_delegate = new efl_gfx_image_load_error_get_delegate(image_load_error_get);
1107             }
1108
1109             if (methods.FirstOrDefault(m => m.Name == "GetImageLoadError") != null)
1110             {
1111                 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) });
1112             }
1113
1114             if (efl_gfx_image_load_controller_load_size_get_static_delegate == null)
1115             {
1116                 efl_gfx_image_load_controller_load_size_get_static_delegate = new efl_gfx_image_load_controller_load_size_get_delegate(load_size_get);
1117             }
1118
1119             if (methods.FirstOrDefault(m => m.Name == "GetLoadSize") != null)
1120             {
1121                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_size_get_static_delegate) });
1122             }
1123
1124             if (efl_gfx_image_load_controller_load_size_set_static_delegate == null)
1125             {
1126                 efl_gfx_image_load_controller_load_size_set_static_delegate = new efl_gfx_image_load_controller_load_size_set_delegate(load_size_set);
1127             }
1128
1129             if (methods.FirstOrDefault(m => m.Name == "SetLoadSize") != null)
1130             {
1131                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_size_set_static_delegate) });
1132             }
1133
1134             if (efl_gfx_image_load_controller_load_dpi_get_static_delegate == null)
1135             {
1136                 efl_gfx_image_load_controller_load_dpi_get_static_delegate = new efl_gfx_image_load_controller_load_dpi_get_delegate(load_dpi_get);
1137             }
1138
1139             if (methods.FirstOrDefault(m => m.Name == "GetLoadDpi") != null)
1140             {
1141                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_dpi_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_dpi_get_static_delegate) });
1142             }
1143
1144             if (efl_gfx_image_load_controller_load_dpi_set_static_delegate == null)
1145             {
1146                 efl_gfx_image_load_controller_load_dpi_set_static_delegate = new efl_gfx_image_load_controller_load_dpi_set_delegate(load_dpi_set);
1147             }
1148
1149             if (methods.FirstOrDefault(m => m.Name == "SetLoadDpi") != null)
1150             {
1151                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_dpi_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_dpi_set_static_delegate) });
1152             }
1153
1154             if (efl_gfx_image_load_controller_load_region_support_get_static_delegate == null)
1155             {
1156                 efl_gfx_image_load_controller_load_region_support_get_static_delegate = new efl_gfx_image_load_controller_load_region_support_get_delegate(load_region_support_get);
1157             }
1158
1159             if (methods.FirstOrDefault(m => m.Name == "GetLoadRegionSupport") != null)
1160             {
1161                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_support_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_support_get_static_delegate) });
1162             }
1163
1164             if (efl_gfx_image_load_controller_load_region_get_static_delegate == null)
1165             {
1166                 efl_gfx_image_load_controller_load_region_get_static_delegate = new efl_gfx_image_load_controller_load_region_get_delegate(load_region_get);
1167             }
1168
1169             if (methods.FirstOrDefault(m => m.Name == "GetLoadRegion") != null)
1170             {
1171                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_get_static_delegate) });
1172             }
1173
1174             if (efl_gfx_image_load_controller_load_region_set_static_delegate == null)
1175             {
1176                 efl_gfx_image_load_controller_load_region_set_static_delegate = new efl_gfx_image_load_controller_load_region_set_delegate(load_region_set);
1177             }
1178
1179             if (methods.FirstOrDefault(m => m.Name == "SetLoadRegion") != null)
1180             {
1181                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_set_static_delegate) });
1182             }
1183
1184             if (efl_gfx_image_load_controller_load_orientation_get_static_delegate == null)
1185             {
1186                 efl_gfx_image_load_controller_load_orientation_get_static_delegate = new efl_gfx_image_load_controller_load_orientation_get_delegate(load_orientation_get);
1187             }
1188
1189             if (methods.FirstOrDefault(m => m.Name == "GetLoadOrientation") != null)
1190             {
1191                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_orientation_get_static_delegate) });
1192             }
1193
1194             if (efl_gfx_image_load_controller_load_orientation_set_static_delegate == null)
1195             {
1196                 efl_gfx_image_load_controller_load_orientation_set_static_delegate = new efl_gfx_image_load_controller_load_orientation_set_delegate(load_orientation_set);
1197             }
1198
1199             if (methods.FirstOrDefault(m => m.Name == "SetLoadOrientation") != null)
1200             {
1201                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_orientation_set_static_delegate) });
1202             }
1203
1204             if (efl_gfx_image_load_controller_load_scale_down_get_static_delegate == null)
1205             {
1206                 efl_gfx_image_load_controller_load_scale_down_get_static_delegate = new efl_gfx_image_load_controller_load_scale_down_get_delegate(load_scale_down_get);
1207             }
1208
1209             if (methods.FirstOrDefault(m => m.Name == "GetLoadScaleDown") != null)
1210             {
1211                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_scale_down_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_scale_down_get_static_delegate) });
1212             }
1213
1214             if (efl_gfx_image_load_controller_load_scale_down_set_static_delegate == null)
1215             {
1216                 efl_gfx_image_load_controller_load_scale_down_set_static_delegate = new efl_gfx_image_load_controller_load_scale_down_set_delegate(load_scale_down_set);
1217             }
1218
1219             if (methods.FirstOrDefault(m => m.Name == "SetLoadScaleDown") != null)
1220             {
1221                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_scale_down_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_scale_down_set_static_delegate) });
1222             }
1223
1224             if (efl_gfx_image_load_controller_load_skip_header_get_static_delegate == null)
1225             {
1226                 efl_gfx_image_load_controller_load_skip_header_get_static_delegate = new efl_gfx_image_load_controller_load_skip_header_get_delegate(load_skip_header_get);
1227             }
1228
1229             if (methods.FirstOrDefault(m => m.Name == "GetLoadSkipHeader") != null)
1230             {
1231                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_skip_header_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_skip_header_get_static_delegate) });
1232             }
1233
1234             if (efl_gfx_image_load_controller_load_skip_header_set_static_delegate == null)
1235             {
1236                 efl_gfx_image_load_controller_load_skip_header_set_static_delegate = new efl_gfx_image_load_controller_load_skip_header_set_delegate(load_skip_header_set);
1237             }
1238
1239             if (methods.FirstOrDefault(m => m.Name == "SetLoadSkipHeader") != null)
1240             {
1241                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_skip_header_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_skip_header_set_static_delegate) });
1242             }
1243
1244             if (efl_gfx_image_load_controller_load_async_start_static_delegate == null)
1245             {
1246                 efl_gfx_image_load_controller_load_async_start_static_delegate = new efl_gfx_image_load_controller_load_async_start_delegate(load_async_start);
1247             }
1248
1249             if (methods.FirstOrDefault(m => m.Name == "LoadAsyncStart") != null)
1250             {
1251                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_async_start"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_async_start_static_delegate) });
1252             }
1253
1254             if (efl_gfx_image_load_controller_load_async_cancel_static_delegate == null)
1255             {
1256                 efl_gfx_image_load_controller_load_async_cancel_static_delegate = new efl_gfx_image_load_controller_load_async_cancel_delegate(load_async_cancel);
1257             }
1258
1259             if (methods.FirstOrDefault(m => m.Name == "LoadAsyncCancel") != null)
1260             {
1261                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_async_cancel"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_async_cancel_static_delegate) });
1262             }
1263
1264             descs.AddRange(base.GetEoOps(type));
1265             return descs;
1266         }
1267         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1268         /// <returns>The native class pointer.</returns>
1269         public override IntPtr GetEflClass()
1270         {
1271             return Efl.Ui.Bg.efl_ui_bg_class_get();
1272         }
1273
1274         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1275
1276
1277         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1278
1279
1280         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
1281
1282         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");
1283
1284         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
1285         {
1286             Eina.Log.Debug("function efl_file_mmap_get was called");
1287             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1288             if (ws != null)
1289             {
1290             Eina.File _ret_var = default(Eina.File);
1291                 try
1292                 {
1293                     _ret_var = ((Bg)ws.Target).GetMmap();
1294                 }
1295                 catch (Exception e)
1296                 {
1297                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1298                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1299                 }
1300
1301         return _ret_var;
1302
1303             }
1304             else
1305             {
1306                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1307             }
1308         }
1309
1310         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
1311
1312
1313         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
1314
1315
1316         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
1317
1318         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");
1319
1320         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
1321         {
1322             Eina.Log.Debug("function efl_file_mmap_set was called");
1323             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1324             if (ws != null)
1325             {
1326                                     Eina.Error _ret_var = default(Eina.Error);
1327                 try
1328                 {
1329                     _ret_var = ((Bg)ws.Target).SetMmap(f);
1330                 }
1331                 catch (Exception e)
1332                 {
1333                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1334                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1335                 }
1336
1337                         return _ret_var;
1338
1339             }
1340             else
1341             {
1342                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
1343             }
1344         }
1345
1346         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
1347
1348         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1349         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
1350
1351         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1352         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
1353
1354         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");
1355
1356         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
1357         {
1358             Eina.Log.Debug("function efl_file_get was called");
1359             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1360             if (ws != null)
1361             {
1362             System.String _ret_var = default(System.String);
1363                 try
1364                 {
1365                     _ret_var = ((Bg)ws.Target).GetFile();
1366                 }
1367                 catch (Exception e)
1368                 {
1369                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1370                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1371                 }
1372
1373         return _ret_var;
1374
1375             }
1376             else
1377             {
1378                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1379             }
1380         }
1381
1382         private static efl_file_get_delegate efl_file_get_static_delegate;
1383
1384
1385         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);
1386
1387
1388         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1389
1390         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");
1391
1392         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
1393         {
1394             Eina.Log.Debug("function efl_file_set was called");
1395             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1396             if (ws != null)
1397             {
1398                                     Eina.Error _ret_var = default(Eina.Error);
1399                 try
1400                 {
1401                     _ret_var = ((Bg)ws.Target).SetFile(file);
1402                 }
1403                 catch (Exception e)
1404                 {
1405                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1406                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1407                 }
1408
1409                         return _ret_var;
1410
1411             }
1412             else
1413             {
1414                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
1415             }
1416         }
1417
1418         private static efl_file_set_delegate efl_file_set_static_delegate;
1419
1420         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1421         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
1422
1423         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1424         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
1425
1426         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");
1427
1428         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
1429         {
1430             Eina.Log.Debug("function efl_file_key_get was called");
1431             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1432             if (ws != null)
1433             {
1434             System.String _ret_var = default(System.String);
1435                 try
1436                 {
1437                     _ret_var = ((Bg)ws.Target).GetKey();
1438                 }
1439                 catch (Exception e)
1440                 {
1441                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1442                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1443                 }
1444
1445         return _ret_var;
1446
1447             }
1448             else
1449             {
1450                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1451             }
1452         }
1453
1454         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
1455
1456
1457         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);
1458
1459
1460         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1461
1462         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");
1463
1464         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
1465         {
1466             Eina.Log.Debug("function efl_file_key_set was called");
1467             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1468             if (ws != null)
1469             {
1470
1471                 try
1472                 {
1473                     ((Bg)ws.Target).SetKey(key);
1474                 }
1475                 catch (Exception e)
1476                 {
1477                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1478                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1479                 }
1480
1481
1482             }
1483             else
1484             {
1485                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1486             }
1487         }
1488
1489         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
1490
1491         [return: MarshalAs(UnmanagedType.U1)]
1492         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
1493
1494         [return: MarshalAs(UnmanagedType.U1)]
1495         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
1496
1497         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");
1498
1499         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
1500         {
1501             Eina.Log.Debug("function efl_file_loaded_get was called");
1502             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1503             if (ws != null)
1504             {
1505             bool _ret_var = default(bool);
1506                 try
1507                 {
1508                     _ret_var = ((Bg)ws.Target).GetLoaded();
1509                 }
1510                 catch (Exception e)
1511                 {
1512                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1513                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1514                 }
1515
1516         return _ret_var;
1517
1518             }
1519             else
1520             {
1521                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1522             }
1523         }
1524
1525         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
1526
1527
1528         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
1529
1530
1531         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
1532
1533         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");
1534
1535         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
1536         {
1537             Eina.Log.Debug("function efl_file_load was called");
1538             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1539             if (ws != null)
1540             {
1541             Eina.Error _ret_var = default(Eina.Error);
1542                 try
1543                 {
1544                     _ret_var = ((Bg)ws.Target).Load();
1545                 }
1546                 catch (Exception e)
1547                 {
1548                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1549                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1550                 }
1551
1552         return _ret_var;
1553
1554             }
1555             else
1556             {
1557                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1558             }
1559         }
1560
1561         private static efl_file_load_delegate efl_file_load_static_delegate;
1562
1563
1564         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
1565
1566
1567         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
1568
1569         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");
1570
1571         private static void unload(System.IntPtr obj, System.IntPtr pd)
1572         {
1573             Eina.Log.Debug("function efl_file_unload was called");
1574             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1575             if (ws != null)
1576             {
1577
1578                 try
1579                 {
1580                     ((Bg)ws.Target).Unload();
1581                 }
1582                 catch (Exception e)
1583                 {
1584                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1585                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1586                 }
1587
1588
1589             }
1590             else
1591             {
1592                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1593             }
1594         }
1595
1596         private static efl_file_unload_delegate efl_file_unload_static_delegate;
1597
1598         [return: MarshalAs(UnmanagedType.U1)]
1599         private delegate bool efl_gfx_image_smooth_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1600
1601         [return: MarshalAs(UnmanagedType.U1)]
1602         public delegate bool efl_gfx_image_smooth_scale_get_api_delegate(System.IntPtr obj);
1603
1604         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");
1605
1606         private static bool smooth_scale_get(System.IntPtr obj, System.IntPtr pd)
1607         {
1608             Eina.Log.Debug("function efl_gfx_image_smooth_scale_get was called");
1609             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1610             if (ws != null)
1611             {
1612             bool _ret_var = default(bool);
1613                 try
1614                 {
1615                     _ret_var = ((Bg)ws.Target).GetSmoothScale();
1616                 }
1617                 catch (Exception e)
1618                 {
1619                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1620                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1621                 }
1622
1623         return _ret_var;
1624
1625             }
1626             else
1627             {
1628                 return efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1629             }
1630         }
1631
1632         private static efl_gfx_image_smooth_scale_get_delegate efl_gfx_image_smooth_scale_get_static_delegate;
1633
1634
1635         private delegate void efl_gfx_image_smooth_scale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
1636
1637
1638         public delegate void efl_gfx_image_smooth_scale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
1639
1640         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");
1641
1642         private static void smooth_scale_set(System.IntPtr obj, System.IntPtr pd, bool smooth_scale)
1643         {
1644             Eina.Log.Debug("function efl_gfx_image_smooth_scale_set was called");
1645             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1646             if (ws != null)
1647             {
1648
1649                 try
1650                 {
1651                     ((Bg)ws.Target).SetSmoothScale(smooth_scale);
1652                 }
1653                 catch (Exception e)
1654                 {
1655                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1656                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1657                 }
1658
1659
1660             }
1661             else
1662             {
1663                 efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth_scale);
1664             }
1665         }
1666
1667         private static efl_gfx_image_smooth_scale_set_delegate efl_gfx_image_smooth_scale_set_static_delegate;
1668
1669
1670         private delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1671
1672
1673         public delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_api_delegate(System.IntPtr obj);
1674
1675         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");
1676
1677         private static Efl.Gfx.ImageScaleType scale_type_get(System.IntPtr obj, System.IntPtr pd)
1678         {
1679             Eina.Log.Debug("function efl_gfx_image_scale_type_get was called");
1680             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1681             if (ws != null)
1682             {
1683             Efl.Gfx.ImageScaleType _ret_var = default(Efl.Gfx.ImageScaleType);
1684                 try
1685                 {
1686                     _ret_var = ((Bg)ws.Target).GetScaleType();
1687                 }
1688                 catch (Exception e)
1689                 {
1690                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1691                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1692                 }
1693
1694         return _ret_var;
1695
1696             }
1697             else
1698             {
1699                 return efl_gfx_image_scale_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1700             }
1701         }
1702
1703         private static efl_gfx_image_scale_type_get_delegate efl_gfx_image_scale_type_get_static_delegate;
1704
1705
1706         private delegate void efl_gfx_image_scale_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleType scale_type);
1707
1708
1709         public delegate void efl_gfx_image_scale_type_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleType scale_type);
1710
1711         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");
1712
1713         private static void scale_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleType scale_type)
1714         {
1715             Eina.Log.Debug("function efl_gfx_image_scale_type_set was called");
1716             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1717             if (ws != null)
1718             {
1719
1720                 try
1721                 {
1722                     ((Bg)ws.Target).SetScaleType(scale_type);
1723                 }
1724                 catch (Exception e)
1725                 {
1726                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1727                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1728                 }
1729
1730
1731             }
1732             else
1733             {
1734                 efl_gfx_image_scale_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale_type);
1735             }
1736         }
1737
1738         private static efl_gfx_image_scale_type_set_delegate efl_gfx_image_scale_type_set_static_delegate;
1739
1740
1741         private delegate double efl_gfx_image_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
1742
1743
1744         public delegate double efl_gfx_image_ratio_get_api_delegate(System.IntPtr obj);
1745
1746         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");
1747
1748         private static double ratio_get(System.IntPtr obj, System.IntPtr pd)
1749         {
1750             Eina.Log.Debug("function efl_gfx_image_ratio_get was called");
1751             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1752             if (ws != null)
1753             {
1754             double _ret_var = default(double);
1755                 try
1756                 {
1757                     _ret_var = ((Bg)ws.Target).GetRatio();
1758                 }
1759                 catch (Exception e)
1760                 {
1761                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1762                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1763                 }
1764
1765         return _ret_var;
1766
1767             }
1768             else
1769             {
1770                 return efl_gfx_image_ratio_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1771             }
1772         }
1773
1774         private static efl_gfx_image_ratio_get_delegate efl_gfx_image_ratio_get_static_delegate;
1775
1776
1777         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);
1778
1779
1780         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);
1781
1782         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");
1783
1784         private static void border_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
1785         {
1786             Eina.Log.Debug("function efl_gfx_image_border_get was called");
1787             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1788             if (ws != null)
1789             {
1790                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
1791                 try
1792                 {
1793                     ((Bg)ws.Target).GetBorder(out l, out r, out t, out b);
1794                 }
1795                 catch (Exception e)
1796                 {
1797                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1798                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1799                 }
1800
1801
1802             }
1803             else
1804             {
1805                 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);
1806             }
1807         }
1808
1809         private static efl_gfx_image_border_get_delegate efl_gfx_image_border_get_static_delegate;
1810
1811
1812         private delegate void efl_gfx_image_border_set_delegate(System.IntPtr obj, System.IntPtr pd,  int l,  int r,  int t,  int b);
1813
1814
1815         public delegate void efl_gfx_image_border_set_api_delegate(System.IntPtr obj,  int l,  int r,  int t,  int b);
1816
1817         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");
1818
1819         private static void border_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
1820         {
1821             Eina.Log.Debug("function efl_gfx_image_border_set was called");
1822             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1823             if (ws != null)
1824             {
1825
1826                 try
1827                 {
1828                     ((Bg)ws.Target).SetBorder(l, r, t, b);
1829                 }
1830                 catch (Exception e)
1831                 {
1832                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1833                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1834                 }
1835
1836
1837             }
1838             else
1839             {
1840                 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);
1841             }
1842         }
1843
1844         private static efl_gfx_image_border_set_delegate efl_gfx_image_border_set_static_delegate;
1845
1846
1847         private delegate double efl_gfx_image_border_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
1848
1849
1850         public delegate double efl_gfx_image_border_scale_get_api_delegate(System.IntPtr obj);
1851
1852         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");
1853
1854         private static double border_scale_get(System.IntPtr obj, System.IntPtr pd)
1855         {
1856             Eina.Log.Debug("function efl_gfx_image_border_scale_get was called");
1857             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1858             if (ws != null)
1859             {
1860             double _ret_var = default(double);
1861                 try
1862                 {
1863                     _ret_var = ((Bg)ws.Target).GetBorderScale();
1864                 }
1865                 catch (Exception e)
1866                 {
1867                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1868                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1869                 }
1870
1871         return _ret_var;
1872
1873             }
1874             else
1875             {
1876                 return efl_gfx_image_border_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1877             }
1878         }
1879
1880         private static efl_gfx_image_border_scale_get_delegate efl_gfx_image_border_scale_get_static_delegate;
1881
1882
1883         private delegate void efl_gfx_image_border_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double scale);
1884
1885
1886         public delegate void efl_gfx_image_border_scale_set_api_delegate(System.IntPtr obj,  double scale);
1887
1888         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");
1889
1890         private static void border_scale_set(System.IntPtr obj, System.IntPtr pd, double scale)
1891         {
1892             Eina.Log.Debug("function efl_gfx_image_border_scale_set was called");
1893             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1894             if (ws != null)
1895             {
1896
1897                 try
1898                 {
1899                     ((Bg)ws.Target).SetBorderScale(scale);
1900                 }
1901                 catch (Exception e)
1902                 {
1903                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1904                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1905                 }
1906
1907
1908             }
1909             else
1910             {
1911                 efl_gfx_image_border_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale);
1912             }
1913         }
1914
1915         private static efl_gfx_image_border_scale_set_delegate efl_gfx_image_border_scale_set_static_delegate;
1916
1917
1918         private delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
1919
1920
1921         public delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_api_delegate(System.IntPtr obj);
1922
1923         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");
1924
1925         private static Efl.Gfx.BorderFillMode border_center_fill_get(System.IntPtr obj, System.IntPtr pd)
1926         {
1927             Eina.Log.Debug("function efl_gfx_image_border_center_fill_get was called");
1928             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1929             if (ws != null)
1930             {
1931             Efl.Gfx.BorderFillMode _ret_var = default(Efl.Gfx.BorderFillMode);
1932                 try
1933                 {
1934                     _ret_var = ((Bg)ws.Target).GetBorderCenterFill();
1935                 }
1936                 catch (Exception e)
1937                 {
1938                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1939                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1940                 }
1941
1942         return _ret_var;
1943
1944             }
1945             else
1946             {
1947                 return efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1948             }
1949         }
1950
1951         private static efl_gfx_image_border_center_fill_get_delegate efl_gfx_image_border_center_fill_get_static_delegate;
1952
1953
1954         private delegate void efl_gfx_image_border_center_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.BorderFillMode fill);
1955
1956
1957         public delegate void efl_gfx_image_border_center_fill_set_api_delegate(System.IntPtr obj,  Efl.Gfx.BorderFillMode fill);
1958
1959         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");
1960
1961         private static void border_center_fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BorderFillMode fill)
1962         {
1963             Eina.Log.Debug("function efl_gfx_image_border_center_fill_set was called");
1964             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1965             if (ws != null)
1966             {
1967
1968                 try
1969                 {
1970                     ((Bg)ws.Target).SetBorderCenterFill(fill);
1971                 }
1972                 catch (Exception e)
1973                 {
1974                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1975                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1976                 }
1977
1978
1979             }
1980             else
1981             {
1982                 efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill);
1983             }
1984         }
1985
1986         private static efl_gfx_image_border_center_fill_set_delegate efl_gfx_image_border_center_fill_set_static_delegate;
1987
1988
1989         private delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1990
1991
1992         public delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_api_delegate(System.IntPtr obj);
1993
1994         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");
1995
1996         private static Eina.Size2D.NativeStruct image_size_get(System.IntPtr obj, System.IntPtr pd)
1997         {
1998             Eina.Log.Debug("function efl_gfx_image_size_get was called");
1999             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2000             if (ws != null)
2001             {
2002             Eina.Size2D _ret_var = default(Eina.Size2D);
2003                 try
2004                 {
2005                     _ret_var = ((Bg)ws.Target).GetImageSize();
2006                 }
2007                 catch (Exception e)
2008                 {
2009                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2010                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2011                 }
2012
2013         return _ret_var;
2014
2015             }
2016             else
2017             {
2018                 return efl_gfx_image_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2019             }
2020         }
2021
2022         private static efl_gfx_image_size_get_delegate efl_gfx_image_size_get_static_delegate;
2023
2024
2025         private delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
2026
2027
2028         public delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_api_delegate(System.IntPtr obj);
2029
2030         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");
2031
2032         private static Efl.Gfx.ImageContentHint content_hint_get(System.IntPtr obj, System.IntPtr pd)
2033         {
2034             Eina.Log.Debug("function efl_gfx_image_content_hint_get was called");
2035             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2036             if (ws != null)
2037             {
2038             Efl.Gfx.ImageContentHint _ret_var = default(Efl.Gfx.ImageContentHint);
2039                 try
2040                 {
2041                     _ret_var = ((Bg)ws.Target).GetContentHint();
2042                 }
2043                 catch (Exception e)
2044                 {
2045                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2046                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2047                 }
2048
2049         return _ret_var;
2050
2051             }
2052             else
2053             {
2054                 return efl_gfx_image_content_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2055             }
2056         }
2057
2058         private static efl_gfx_image_content_hint_get_delegate efl_gfx_image_content_hint_get_static_delegate;
2059
2060
2061         private delegate void efl_gfx_image_content_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageContentHint hint);
2062
2063
2064         public delegate void efl_gfx_image_content_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageContentHint hint);
2065
2066         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");
2067
2068         private static void content_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageContentHint hint)
2069         {
2070             Eina.Log.Debug("function efl_gfx_image_content_hint_set was called");
2071             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2072             if (ws != null)
2073             {
2074
2075                 try
2076                 {
2077                     ((Bg)ws.Target).SetContentHint(hint);
2078                 }
2079                 catch (Exception e)
2080                 {
2081                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2082                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2083                 }
2084
2085
2086             }
2087             else
2088             {
2089                 efl_gfx_image_content_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
2090             }
2091         }
2092
2093         private static efl_gfx_image_content_hint_set_delegate efl_gfx_image_content_hint_set_static_delegate;
2094
2095
2096         private delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
2097
2098
2099         public delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_api_delegate(System.IntPtr obj);
2100
2101         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");
2102
2103         private static Efl.Gfx.ImageScaleHint scale_hint_get(System.IntPtr obj, System.IntPtr pd)
2104         {
2105             Eina.Log.Debug("function efl_gfx_image_scale_hint_get was called");
2106             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2107             if (ws != null)
2108             {
2109             Efl.Gfx.ImageScaleHint _ret_var = default(Efl.Gfx.ImageScaleHint);
2110                 try
2111                 {
2112                     _ret_var = ((Bg)ws.Target).GetScaleHint();
2113                 }
2114                 catch (Exception e)
2115                 {
2116                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2117                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2118                 }
2119
2120         return _ret_var;
2121
2122             }
2123             else
2124             {
2125                 return efl_gfx_image_scale_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2126             }
2127         }
2128
2129         private static efl_gfx_image_scale_hint_get_delegate efl_gfx_image_scale_hint_get_static_delegate;
2130
2131
2132         private delegate void efl_gfx_image_scale_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleHint hint);
2133
2134
2135         public delegate void efl_gfx_image_scale_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleHint hint);
2136
2137         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");
2138
2139         private static void scale_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleHint hint)
2140         {
2141             Eina.Log.Debug("function efl_gfx_image_scale_hint_set was called");
2142             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2143             if (ws != null)
2144             {
2145
2146                 try
2147                 {
2148                     ((Bg)ws.Target).SetScaleHint(hint);
2149                 }
2150                 catch (Exception e)
2151                 {
2152                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2153                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2154                 }
2155
2156
2157             }
2158             else
2159             {
2160                 efl_gfx_image_scale_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
2161             }
2162         }
2163
2164         private static efl_gfx_image_scale_hint_set_delegate efl_gfx_image_scale_hint_set_static_delegate;
2165
2166
2167         private delegate Eina.Error efl_gfx_image_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
2168
2169
2170         public delegate Eina.Error efl_gfx_image_load_error_get_api_delegate(System.IntPtr obj);
2171
2172         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");
2173
2174         private static Eina.Error image_load_error_get(System.IntPtr obj, System.IntPtr pd)
2175         {
2176             Eina.Log.Debug("function efl_gfx_image_load_error_get was called");
2177             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2178             if (ws != null)
2179             {
2180             Eina.Error _ret_var = default(Eina.Error);
2181                 try
2182                 {
2183                     _ret_var = ((Bg)ws.Target).GetImageLoadError();
2184                 }
2185                 catch (Exception e)
2186                 {
2187                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2188                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2189                 }
2190
2191         return _ret_var;
2192
2193             }
2194             else
2195             {
2196                 return efl_gfx_image_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2197             }
2198         }
2199
2200         private static efl_gfx_image_load_error_get_delegate efl_gfx_image_load_error_get_static_delegate;
2201
2202
2203         private delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2204
2205
2206         public delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_api_delegate(System.IntPtr obj);
2207
2208         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_get_api_delegate> efl_gfx_image_load_controller_load_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_size_get");
2209
2210         private static Eina.Size2D.NativeStruct load_size_get(System.IntPtr obj, System.IntPtr pd)
2211         {
2212             Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_get was called");
2213             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2214             if (ws != null)
2215             {
2216             Eina.Size2D _ret_var = default(Eina.Size2D);
2217                 try
2218                 {
2219                     _ret_var = ((Bg)ws.Target).GetLoadSize();
2220                 }
2221                 catch (Exception e)
2222                 {
2223                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2224                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2225                 }
2226
2227         return _ret_var;
2228
2229             }
2230             else
2231             {
2232                 return efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2233             }
2234         }
2235
2236         private static efl_gfx_image_load_controller_load_size_get_delegate efl_gfx_image_load_controller_load_size_get_static_delegate;
2237
2238
2239         private delegate void efl_gfx_image_load_controller_load_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size);
2240
2241
2242         public delegate void efl_gfx_image_load_controller_load_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct size);
2243
2244         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_set_api_delegate> efl_gfx_image_load_controller_load_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_size_set");
2245
2246         private static void load_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
2247         {
2248             Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_set was called");
2249             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2250             if (ws != null)
2251             {
2252         Eina.Size2D _in_size = size;
2253
2254                 try
2255                 {
2256                     ((Bg)ws.Target).SetLoadSize(_in_size);
2257                 }
2258                 catch (Exception e)
2259                 {
2260                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2261                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2262                 }
2263
2264
2265             }
2266             else
2267             {
2268                 efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
2269             }
2270         }
2271
2272         private static efl_gfx_image_load_controller_load_size_set_delegate efl_gfx_image_load_controller_load_size_set_static_delegate;
2273
2274
2275         private delegate double efl_gfx_image_load_controller_load_dpi_get_delegate(System.IntPtr obj, System.IntPtr pd);
2276
2277
2278         public delegate double efl_gfx_image_load_controller_load_dpi_get_api_delegate(System.IntPtr obj);
2279
2280         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_get_api_delegate> efl_gfx_image_load_controller_load_dpi_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_dpi_get");
2281
2282         private static double load_dpi_get(System.IntPtr obj, System.IntPtr pd)
2283         {
2284             Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_get was called");
2285             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2286             if (ws != null)
2287             {
2288             double _ret_var = default(double);
2289                 try
2290                 {
2291                     _ret_var = ((Bg)ws.Target).GetLoadDpi();
2292                 }
2293                 catch (Exception e)
2294                 {
2295                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2296                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2297                 }
2298
2299         return _ret_var;
2300
2301             }
2302             else
2303             {
2304                 return efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2305             }
2306         }
2307
2308         private static efl_gfx_image_load_controller_load_dpi_get_delegate efl_gfx_image_load_controller_load_dpi_get_static_delegate;
2309
2310
2311         private delegate void efl_gfx_image_load_controller_load_dpi_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dpi);
2312
2313
2314         public delegate void efl_gfx_image_load_controller_load_dpi_set_api_delegate(System.IntPtr obj,  double dpi);
2315
2316         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_set_api_delegate> efl_gfx_image_load_controller_load_dpi_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_dpi_set");
2317
2318         private static void load_dpi_set(System.IntPtr obj, System.IntPtr pd, double dpi)
2319         {
2320             Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_set was called");
2321             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2322             if (ws != null)
2323             {
2324
2325                 try
2326                 {
2327                     ((Bg)ws.Target).SetLoadDpi(dpi);
2328                 }
2329                 catch (Exception e)
2330                 {
2331                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2332                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2333                 }
2334
2335
2336             }
2337             else
2338             {
2339                 efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dpi);
2340             }
2341         }
2342
2343         private static efl_gfx_image_load_controller_load_dpi_set_delegate efl_gfx_image_load_controller_load_dpi_set_static_delegate;
2344
2345         [return: MarshalAs(UnmanagedType.U1)]
2346         private delegate bool efl_gfx_image_load_controller_load_region_support_get_delegate(System.IntPtr obj, System.IntPtr pd);
2347
2348         [return: MarshalAs(UnmanagedType.U1)]
2349         public delegate bool efl_gfx_image_load_controller_load_region_support_get_api_delegate(System.IntPtr obj);
2350
2351         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_support_get_api_delegate> efl_gfx_image_load_controller_load_region_support_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_support_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_support_get");
2352
2353         private static bool load_region_support_get(System.IntPtr obj, System.IntPtr pd)
2354         {
2355             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_support_get was called");
2356             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2357             if (ws != null)
2358             {
2359             bool _ret_var = default(bool);
2360                 try
2361                 {
2362                     _ret_var = ((Bg)ws.Target).GetLoadRegionSupport();
2363                 }
2364                 catch (Exception e)
2365                 {
2366                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2367                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2368                 }
2369
2370         return _ret_var;
2371
2372             }
2373             else
2374             {
2375                 return efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2376             }
2377         }
2378
2379         private static efl_gfx_image_load_controller_load_region_support_get_delegate efl_gfx_image_load_controller_load_region_support_get_static_delegate;
2380
2381
2382         private delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
2383
2384
2385         public delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_api_delegate(System.IntPtr obj);
2386
2387         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_get_api_delegate> efl_gfx_image_load_controller_load_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_get");
2388
2389         private static Eina.Rect.NativeStruct load_region_get(System.IntPtr obj, System.IntPtr pd)
2390         {
2391             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_get was called");
2392             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2393             if (ws != null)
2394             {
2395             Eina.Rect _ret_var = default(Eina.Rect);
2396                 try
2397                 {
2398                     _ret_var = ((Bg)ws.Target).GetLoadRegion();
2399                 }
2400                 catch (Exception e)
2401                 {
2402                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2403                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2404                 }
2405
2406         return _ret_var;
2407
2408             }
2409             else
2410             {
2411                 return efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2412             }
2413         }
2414
2415         private static efl_gfx_image_load_controller_load_region_get_delegate efl_gfx_image_load_controller_load_region_get_static_delegate;
2416
2417
2418         private delegate void efl_gfx_image_load_controller_load_region_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct region);
2419
2420
2421         public delegate void efl_gfx_image_load_controller_load_region_set_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct region);
2422
2423         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_set_api_delegate> efl_gfx_image_load_controller_load_region_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_set");
2424
2425         private static void load_region_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct region)
2426         {
2427             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_set was called");
2428             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2429             if (ws != null)
2430             {
2431         Eina.Rect _in_region = region;
2432
2433                 try
2434                 {
2435                     ((Bg)ws.Target).SetLoadRegion(_in_region);
2436                 }
2437                 catch (Exception e)
2438                 {
2439                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2440                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2441                 }
2442
2443
2444             }
2445             else
2446             {
2447                 efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), region);
2448             }
2449         }
2450
2451         private static efl_gfx_image_load_controller_load_region_set_delegate efl_gfx_image_load_controller_load_region_set_static_delegate;
2452
2453         [return: MarshalAs(UnmanagedType.U1)]
2454         private delegate bool efl_gfx_image_load_controller_load_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
2455
2456         [return: MarshalAs(UnmanagedType.U1)]
2457         public delegate bool efl_gfx_image_load_controller_load_orientation_get_api_delegate(System.IntPtr obj);
2458
2459         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_get_api_delegate> efl_gfx_image_load_controller_load_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_orientation_get");
2460
2461         private static bool load_orientation_get(System.IntPtr obj, System.IntPtr pd)
2462         {
2463             Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_get was called");
2464             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2465             if (ws != null)
2466             {
2467             bool _ret_var = default(bool);
2468                 try
2469                 {
2470                     _ret_var = ((Bg)ws.Target).GetLoadOrientation();
2471                 }
2472                 catch (Exception e)
2473                 {
2474                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2475                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2476                 }
2477
2478         return _ret_var;
2479
2480             }
2481             else
2482             {
2483                 return efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2484             }
2485         }
2486
2487         private static efl_gfx_image_load_controller_load_orientation_get_delegate efl_gfx_image_load_controller_load_orientation_get_static_delegate;
2488
2489
2490         private delegate void efl_gfx_image_load_controller_load_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enable);
2491
2492
2493         public delegate void efl_gfx_image_load_controller_load_orientation_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enable);
2494
2495         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_set_api_delegate> efl_gfx_image_load_controller_load_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_orientation_set");
2496
2497         private static void load_orientation_set(System.IntPtr obj, System.IntPtr pd, bool enable)
2498         {
2499             Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_set was called");
2500             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2501             if (ws != null)
2502             {
2503
2504                 try
2505                 {
2506                     ((Bg)ws.Target).SetLoadOrientation(enable);
2507                 }
2508                 catch (Exception e)
2509                 {
2510                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2511                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2512                 }
2513
2514
2515             }
2516             else
2517             {
2518                 efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enable);
2519             }
2520         }
2521
2522         private static efl_gfx_image_load_controller_load_orientation_set_delegate efl_gfx_image_load_controller_load_orientation_set_static_delegate;
2523
2524
2525         private delegate int efl_gfx_image_load_controller_load_scale_down_get_delegate(System.IntPtr obj, System.IntPtr pd);
2526
2527
2528         public delegate int efl_gfx_image_load_controller_load_scale_down_get_api_delegate(System.IntPtr obj);
2529
2530         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_get_api_delegate> efl_gfx_image_load_controller_load_scale_down_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_scale_down_get");
2531
2532         private static int load_scale_down_get(System.IntPtr obj, System.IntPtr pd)
2533         {
2534             Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_get was called");
2535             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2536             if (ws != null)
2537             {
2538             int _ret_var = default(int);
2539                 try
2540                 {
2541                     _ret_var = ((Bg)ws.Target).GetLoadScaleDown();
2542                 }
2543                 catch (Exception e)
2544                 {
2545                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2546                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2547                 }
2548
2549         return _ret_var;
2550
2551             }
2552             else
2553             {
2554                 return efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2555             }
2556         }
2557
2558         private static efl_gfx_image_load_controller_load_scale_down_get_delegate efl_gfx_image_load_controller_load_scale_down_get_static_delegate;
2559
2560
2561         private delegate void efl_gfx_image_load_controller_load_scale_down_set_delegate(System.IntPtr obj, System.IntPtr pd,  int div);
2562
2563
2564         public delegate void efl_gfx_image_load_controller_load_scale_down_set_api_delegate(System.IntPtr obj,  int div);
2565
2566         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_set_api_delegate> efl_gfx_image_load_controller_load_scale_down_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_scale_down_set");
2567
2568         private static void load_scale_down_set(System.IntPtr obj, System.IntPtr pd, int div)
2569         {
2570             Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_set was called");
2571             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2572             if (ws != null)
2573             {
2574
2575                 try
2576                 {
2577                     ((Bg)ws.Target).SetLoadScaleDown(div);
2578                 }
2579                 catch (Exception e)
2580                 {
2581                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2582                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2583                 }
2584
2585
2586             }
2587             else
2588             {
2589                 efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), div);
2590             }
2591         }
2592
2593         private static efl_gfx_image_load_controller_load_scale_down_set_delegate efl_gfx_image_load_controller_load_scale_down_set_static_delegate;
2594
2595         [return: MarshalAs(UnmanagedType.U1)]
2596         private delegate bool efl_gfx_image_load_controller_load_skip_header_get_delegate(System.IntPtr obj, System.IntPtr pd);
2597
2598         [return: MarshalAs(UnmanagedType.U1)]
2599         public delegate bool efl_gfx_image_load_controller_load_skip_header_get_api_delegate(System.IntPtr obj);
2600
2601         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_get_api_delegate> efl_gfx_image_load_controller_load_skip_header_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_skip_header_get");
2602
2603         private static bool load_skip_header_get(System.IntPtr obj, System.IntPtr pd)
2604         {
2605             Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_get was called");
2606             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2607             if (ws != null)
2608             {
2609             bool _ret_var = default(bool);
2610                 try
2611                 {
2612                     _ret_var = ((Bg)ws.Target).GetLoadSkipHeader();
2613                 }
2614                 catch (Exception e)
2615                 {
2616                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2617                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2618                 }
2619
2620         return _ret_var;
2621
2622             }
2623             else
2624             {
2625                 return efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2626             }
2627         }
2628
2629         private static efl_gfx_image_load_controller_load_skip_header_get_delegate efl_gfx_image_load_controller_load_skip_header_get_static_delegate;
2630
2631
2632         private delegate void efl_gfx_image_load_controller_load_skip_header_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool skip);
2633
2634
2635         public delegate void efl_gfx_image_load_controller_load_skip_header_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool skip);
2636
2637         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_set_api_delegate> efl_gfx_image_load_controller_load_skip_header_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_skip_header_set");
2638
2639         private static void load_skip_header_set(System.IntPtr obj, System.IntPtr pd, bool skip)
2640         {
2641             Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_set was called");
2642             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2643             if (ws != null)
2644             {
2645
2646                 try
2647                 {
2648                     ((Bg)ws.Target).SetLoadSkipHeader(skip);
2649                 }
2650                 catch (Exception e)
2651                 {
2652                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2653                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2654                 }
2655
2656
2657             }
2658             else
2659             {
2660                 efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), skip);
2661             }
2662         }
2663
2664         private static efl_gfx_image_load_controller_load_skip_header_set_delegate efl_gfx_image_load_controller_load_skip_header_set_static_delegate;
2665
2666
2667         private delegate void efl_gfx_image_load_controller_load_async_start_delegate(System.IntPtr obj, System.IntPtr pd);
2668
2669
2670         public delegate void efl_gfx_image_load_controller_load_async_start_api_delegate(System.IntPtr obj);
2671
2672         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_start_api_delegate> efl_gfx_image_load_controller_load_async_start_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_start_api_delegate>(Module, "efl_gfx_image_load_controller_load_async_start");
2673
2674         private static void load_async_start(System.IntPtr obj, System.IntPtr pd)
2675         {
2676             Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_start was called");
2677             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2678             if (ws != null)
2679             {
2680
2681                 try
2682                 {
2683                     ((Bg)ws.Target).LoadAsyncStart();
2684                 }
2685                 catch (Exception e)
2686                 {
2687                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2688                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2689                 }
2690
2691
2692             }
2693             else
2694             {
2695                 efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2696             }
2697         }
2698
2699         private static efl_gfx_image_load_controller_load_async_start_delegate efl_gfx_image_load_controller_load_async_start_static_delegate;
2700
2701
2702         private delegate void efl_gfx_image_load_controller_load_async_cancel_delegate(System.IntPtr obj, System.IntPtr pd);
2703
2704
2705         public delegate void efl_gfx_image_load_controller_load_async_cancel_api_delegate(System.IntPtr obj);
2706
2707         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_cancel_api_delegate> efl_gfx_image_load_controller_load_async_cancel_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_cancel_api_delegate>(Module, "efl_gfx_image_load_controller_load_async_cancel");
2708
2709         private static void load_async_cancel(System.IntPtr obj, System.IntPtr pd)
2710         {
2711             Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_cancel was called");
2712             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2713             if (ws != null)
2714             {
2715
2716                 try
2717                 {
2718                     ((Bg)ws.Target).LoadAsyncCancel();
2719                 }
2720                 catch (Exception e)
2721                 {
2722                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2723                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2724                 }
2725
2726
2727             }
2728             else
2729             {
2730                 efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2731             }
2732         }
2733
2734         private static efl_gfx_image_load_controller_load_async_cancel_delegate efl_gfx_image_load_controller_load_async_cancel_static_delegate;
2735
2736         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2737
2738 }
2739 }
2740 }
2741
2742 }
2743