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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Gfx {
  11
  12 /// <summary>Common APIs for all loadable 2D images.</summary>
  13 [Efl.Gfx.IImageLoadControllerConcrete.NativeMethods]
  14 public interface IImageLoadController :
  15     Efl.Eo.IWrapper, IDisposable
  16 {
  17     /// <summary>Returns the requested load size.</summary>
  18 /// <returns>The image load size.</returns>
  19 Eina.Size2D GetLoadSize();
  20     /// <summary>Requests the canvas to load the image at the given size.
  21 /// 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>
  22 /// <param name="size">The image load size.</param>
  23 void SetLoadSize(Eina.Size2D size);
  24     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
  25 /// This function returns the DPI resolution of the given canvas image.</summary>
  26 /// <returns>The DPI resolution.</returns>
  27 double GetLoadDpi();
  28     /// <summary>Set the DPI resolution of an image object&apos;s source image.
  29 /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
  30 /// <param name="dpi">The DPI resolution.</param>
  31 void SetLoadDpi(double dpi);
  32     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
  33 /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
  34 bool GetLoadRegionSupport();
  35     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
  36 /// <returns>A region of the image.</returns>
  37 Eina.Rect GetLoadRegion();
  38     /// <summary>Inform a given image object to load a selective region of its source image.
  39 /// This function is useful when one is not showing all of an image&apos;s area on its image object.
  40 ///
  41 /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
  42 /// <param name="region">A region of the image.</param>
  43 void SetLoadRegion(Eina.Rect region);
  44     /// <summary>Defines whether the orientation information in the image file should be honored.
  45 /// 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>
  46 /// <returns><c>true</c> means that it should honor the orientation information.</returns>
  47 bool GetLoadOrientation();
  48     /// <summary>Defines whether the orientation information in the image file should be honored.
  49 /// 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>
  50 /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
  51 void SetLoadOrientation(bool enable);
  52     /// <summary>The scale down factor is a divider on the original image size.
  53 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
  54 ///
  55 /// 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.
  56 ///
  57 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
  58 /// <returns>The scale down dividing factor.</returns>
  59 int GetLoadScaleDown();
  60     /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
  61 /// <param name="div">The scale down dividing factor.</param>
  62 void SetLoadScaleDown(int div);
  63     /// <summary>Initial load should skip header check and leave it all to data load
  64 /// 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>
  65 /// <returns>Will be true if header is to be skipped.</returns>
  66 bool GetLoadSkipHeader();
  67     /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
  68 /// <param name="skip">Will be true if header is to be skipped.</param>
  69 void SetLoadSkipHeader(bool skip);
  70     /// <summary>Begin preloading an image object&apos;s image data in the background.
  71 /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
  72 void LoadAsyncStart();
  73     /// <summary>Cancel preloading an image object&apos;s image data in the background.
  74 /// 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>
  75 void LoadAsyncCancel();
  76                                                                 /// <summary>Called when he image was loaded</summary>
  77     event EventHandler LoadDoneEvt;
  78     /// <summary>Called when an error happened during image loading</summary>
  79     event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt;
  80     /// <summary>The load size of an image.
  81     /// 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.
  82     ///
  83     /// By default, the load size is not specified, so it is 0x0.</summary>
  84     /// <value>The image load size.</value>
  85     Eina.Size2D LoadSize {
  86         get ;
  87         set ;
  88     }
  89     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
  90     /// This function returns the DPI resolution of the given canvas image.</summary>
  91     /// <value>The DPI resolution.</value>
  92     double LoadDpi {
  93         get ;
  94         set ;
  95     }
  96     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
  97     /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
  98     bool LoadRegionSupport {
  99         get ;
 100     }
 101     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 102     /// <value>A region of the image.</value>
 103     Eina.Rect LoadRegion {
 104         get ;
 105         set ;
 106     }
 107     /// <summary>Defines whether the orientation information in the image file should be honored.
 108     /// 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>
 109     /// <value><c>true</c> means that it should honor the orientation information.</value>
 110     bool LoadOrientation {
 111         get ;
 112         set ;
 113     }
 114     /// <summary>The scale down factor is a divider on the original image size.
 115     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 116     ///
 117     /// 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.
 118     ///
 119     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 120     /// <value>The scale down dividing factor.</value>
 121     int LoadScaleDown {
 122         get ;
 123         set ;
 124     }
 125     /// <summary>Initial load should skip header check and leave it all to data load
 126     /// 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>
 127     /// <value>Will be true if header is to be skipped.</value>
 128     bool LoadSkipHeader {
 129         get ;
 130         set ;
 131     }
 132 }
 133 ///<summary>Event argument wrapper for event <see cref="Efl.Gfx.IImageLoadController.LoadErrorEvt"/>.</summary>
 134 public class IImageLoadControllerLoadErrorEvt_Args : EventArgs {
 135     ///<summary>Actual event payload.</summary>
 136     public Eina.Error arg { get; set; }
 137 }
 138 /// <summary>Common APIs for all loadable 2D images.</summary>
 139 sealed public class IImageLoadControllerConcrete :
 140     Efl.Eo.EoWrapper
 141     , IImageLoadController
 142
 143 {
 144     ///<summary>Pointer to the native class description.</summary>
 145     public override System.IntPtr NativeClass
 146     {
 147         get
 148         {
 149             if (((object)this).GetType() == typeof(IImageLoadControllerConcrete))
 150             {
 151                 return GetEflClassStatic();
 152             }
 153             else
 154             {
 155                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 156             }
 157         }
 158     }
 159
 160     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 161         efl_gfx_image_load_controller_interface_get();
 162     /// <summary>Initializes a new instance of the <see cref="IImageLoadController"/> class.
 163     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 164     private IImageLoadControllerConcrete(System.IntPtr raw) : base(raw)
 165     {
 166     }
 167
 168     /// <summary>Called when he image was loaded</summary>
 169     public event EventHandler LoadDoneEvt
 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_LOAD_CONTROLLER_EVENT_LOAD_DONE";
 194                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 195             }
 196         }
 197
 198         remove
 199         {
 200             lock (eventLock)
 201             {
 202                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
 203                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 204             }
 205         }
 206     }
 207     ///<summary>Method to raise event LoadDoneEvt.</summary>
 208     public void OnLoadDoneEvt(EventArgs e)
 209     {
 210         var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
 211         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, 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 an error happened during image loading</summary>
 221     public event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt
 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                         Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args args = new Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args();
 233                         args.arg = (Eina.Error)Marshal.PtrToStructure(evt.Info, typeof(Eina.Error));
 234                         try
 235                         {
 236                             value?.Invoke(obj, args);
 237                         }
 238                         catch (Exception e)
 239                         {
 240                             Eina.Log.Error(e.ToString());
 241                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 242                         }
 243                     }
 244                 };
 245
 246                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 247                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 248             }
 249         }
 250
 251         remove
 252         {
 253             lock (eventLock)
 254             {
 255                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 256                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 257             }
 258         }
 259     }
 260     ///<summary>Method to raise event LoadErrorEvt.</summary>
 261     public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
 262     {
 263         var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 264         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 265         if (desc == IntPtr.Zero)
 266         {
 267             Eina.Log.Error($"Failed to get native event {key}");
 268             return;
 269         }
 270
 271         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc((int)e.arg);
 272         try
 273         {
 274             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 275         }
 276         finally
 277         {
 278             Marshal.FreeHGlobal(info);
 279         }
 280     }
 281     /// <summary>Returns the requested load size.</summary>
 282     /// <returns>The image load size.</returns>
 283     public Eina.Size2D GetLoadSize() {
 284          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate(this.NativeHandle);
 285         Eina.Error.RaiseIfUnhandledException();
 286         return _ret_var;
 287  }
 288     /// <summary>Requests the canvas to load the image at the given size.
 289     /// 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>
 290     /// <param name="size">The image load size.</param>
 291     public void SetLoadSize(Eina.Size2D size) {
 292          Eina.Size2D.NativeStruct _in_size = size;
 293                         Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate(this.NativeHandle,_in_size);
 294         Eina.Error.RaiseIfUnhandledException();
 295                          }
 296     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 297     /// This function returns the DPI resolution of the given canvas image.</summary>
 298     /// <returns>The DPI resolution.</returns>
 299     public double GetLoadDpi() {
 300          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate(this.NativeHandle);
 301         Eina.Error.RaiseIfUnhandledException();
 302         return _ret_var;
 303  }
 304     /// <summary>Set the DPI resolution of an image object&apos;s source image.
 305     /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
 306     /// <param name="dpi">The DPI resolution.</param>
 307     public void SetLoadDpi(double dpi) {
 308                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate(this.NativeHandle,dpi);
 309         Eina.Error.RaiseIfUnhandledException();
 310                          }
 311     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 312     /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
 313     public bool GetLoadRegionSupport() {
 314          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate(this.NativeHandle);
 315         Eina.Error.RaiseIfUnhandledException();
 316         return _ret_var;
 317  }
 318     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 319     /// <returns>A region of the image.</returns>
 320     public Eina.Rect GetLoadRegion() {
 321          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate(this.NativeHandle);
 322         Eina.Error.RaiseIfUnhandledException();
 323         return _ret_var;
 324  }
 325     /// <summary>Inform a given image object to load a selective region of its source image.
 326     /// This function is useful when one is not showing all of an image&apos;s area on its image object.
 327     ///
 328     /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
 329     /// <param name="region">A region of the image.</param>
 330     public void SetLoadRegion(Eina.Rect region) {
 331          Eina.Rect.NativeStruct _in_region = region;
 332                         Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate(this.NativeHandle,_in_region);
 333         Eina.Error.RaiseIfUnhandledException();
 334                          }
 335     /// <summary>Defines whether the orientation information in the image file should be honored.
 336     /// 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>
 337     /// <returns><c>true</c> means that it should honor the orientation information.</returns>
 338     public bool GetLoadOrientation() {
 339          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate(this.NativeHandle);
 340         Eina.Error.RaiseIfUnhandledException();
 341         return _ret_var;
 342  }
 343     /// <summary>Defines whether the orientation information in the image file should be honored.
 344     /// 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>
 345     /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
 346     public void SetLoadOrientation(bool enable) {
 347                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate(this.NativeHandle,enable);
 348         Eina.Error.RaiseIfUnhandledException();
 349                          }
 350     /// <summary>The scale down factor is a divider on the original image size.
 351     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 352     ///
 353     /// 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.
 354     ///
 355     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 356     /// <returns>The scale down dividing factor.</returns>
 357     public int GetLoadScaleDown() {
 358          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate(this.NativeHandle);
 359         Eina.Error.RaiseIfUnhandledException();
 360         return _ret_var;
 361  }
 362     /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
 363     /// <param name="div">The scale down dividing factor.</param>
 364     public void SetLoadScaleDown(int div) {
 365                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate(this.NativeHandle,div);
 366         Eina.Error.RaiseIfUnhandledException();
 367                          }
 368     /// <summary>Initial load should skip header check and leave it all to data load
 369     /// 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>
 370     /// <returns>Will be true if header is to be skipped.</returns>
 371     public bool GetLoadSkipHeader() {
 372          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate(this.NativeHandle);
 373         Eina.Error.RaiseIfUnhandledException();
 374         return _ret_var;
 375  }
 376     /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
 377     /// <param name="skip">Will be true if header is to be skipped.</param>
 378     public void SetLoadSkipHeader(bool skip) {
 379                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate(this.NativeHandle,skip);
 380         Eina.Error.RaiseIfUnhandledException();
 381                          }
 382     /// <summary>Begin preloading an image object&apos;s image data in the background.
 383     /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
 384     public void LoadAsyncStart() {
 385          Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(this.NativeHandle);
 386         Eina.Error.RaiseIfUnhandledException();
 387          }
 388     /// <summary>Cancel preloading an image object&apos;s image data in the background.
 389     /// 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>
 390     public void LoadAsyncCancel() {
 391          Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(this.NativeHandle);
 392         Eina.Error.RaiseIfUnhandledException();
 393          }
 394     /// <summary>The load size of an image.
 395     /// 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.
 396     ///
 397     /// By default, the load size is not specified, so it is 0x0.</summary>
 398     /// <value>The image load size.</value>
 399     public Eina.Size2D LoadSize {
 400         get { return GetLoadSize(); }
 401         set { SetLoadSize(value); }
 402     }
 403     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 404     /// This function returns the DPI resolution of the given canvas image.</summary>
 405     /// <value>The DPI resolution.</value>
 406     public double LoadDpi {
 407         get { return GetLoadDpi(); }
 408         set { SetLoadDpi(value); }
 409     }
 410     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 411     /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
 412     public bool LoadRegionSupport {
 413         get { return GetLoadRegionSupport(); }
 414     }
 415     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 416     /// <value>A region of the image.</value>
 417     public Eina.Rect LoadRegion {
 418         get { return GetLoadRegion(); }
 419         set { SetLoadRegion(value); }
 420     }
 421     /// <summary>Defines whether the orientation information in the image file should be honored.
 422     /// 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>
 423     /// <value><c>true</c> means that it should honor the orientation information.</value>
 424     public bool LoadOrientation {
 425         get { return GetLoadOrientation(); }
 426         set { SetLoadOrientation(value); }
 427     }
 428     /// <summary>The scale down factor is a divider on the original image size.
 429     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 430     ///
 431     /// 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.
 432     ///
 433     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 434     /// <value>The scale down dividing factor.</value>
 435     public int LoadScaleDown {
 436         get { return GetLoadScaleDown(); }
 437         set { SetLoadScaleDown(value); }
 438     }
 439     /// <summary>Initial load should skip header check and leave it all to data load
 440     /// 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>
 441     /// <value>Will be true if header is to be skipped.</value>
 442     public bool LoadSkipHeader {
 443         get { return GetLoadSkipHeader(); }
 444         set { SetLoadSkipHeader(value); }
 445     }
 446     private static IntPtr GetEflClassStatic()
 447     {
 448         return Efl.Gfx.IImageLoadControllerConcrete.efl_gfx_image_load_controller_interface_get();
 449     }
 450     /// <summary>Wrapper for native methods and virtual method delegates.
 451     /// For internal use by generated code only.</summary>
 452     public class NativeMethods  : Efl.Eo.NativeClass
 453     {
 454         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 455         /// <summary>Gets the list of Eo operations to override.</summary>
 456         /// <returns>The list of Eo operations to be overload.</returns>
 457         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 458         {
 459             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 460             var methods = Efl.Eo.Globals.GetUserMethods(type);
 461
 462             if (efl_gfx_image_load_controller_load_size_get_static_delegate == null)
 463             {
 464                 efl_gfx_image_load_controller_load_size_get_static_delegate = new efl_gfx_image_load_controller_load_size_get_delegate(load_size_get);
 465             }
 466
 467             if (methods.FirstOrDefault(m => m.Name == "GetLoadSize") != null)
 468             {
 469                 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) });
 470             }
 471
 472             if (efl_gfx_image_load_controller_load_size_set_static_delegate == null)
 473             {
 474                 efl_gfx_image_load_controller_load_size_set_static_delegate = new efl_gfx_image_load_controller_load_size_set_delegate(load_size_set);
 475             }
 476
 477             if (methods.FirstOrDefault(m => m.Name == "SetLoadSize") != null)
 478             {
 479                 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) });
 480             }
 481
 482             if (efl_gfx_image_load_controller_load_dpi_get_static_delegate == null)
 483             {
 484                 efl_gfx_image_load_controller_load_dpi_get_static_delegate = new efl_gfx_image_load_controller_load_dpi_get_delegate(load_dpi_get);
 485             }
 486
 487             if (methods.FirstOrDefault(m => m.Name == "GetLoadDpi") != null)
 488             {
 489                 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) });
 490             }
 491
 492             if (efl_gfx_image_load_controller_load_dpi_set_static_delegate == null)
 493             {
 494                 efl_gfx_image_load_controller_load_dpi_set_static_delegate = new efl_gfx_image_load_controller_load_dpi_set_delegate(load_dpi_set);
 495             }
 496
 497             if (methods.FirstOrDefault(m => m.Name == "SetLoadDpi") != null)
 498             {
 499                 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) });
 500             }
 501
 502             if (efl_gfx_image_load_controller_load_region_support_get_static_delegate == null)
 503             {
 504                 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);
 505             }
 506
 507             if (methods.FirstOrDefault(m => m.Name == "GetLoadRegionSupport") != null)
 508             {
 509                 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) });
 510             }
 511
 512             if (efl_gfx_image_load_controller_load_region_get_static_delegate == null)
 513             {
 514                 efl_gfx_image_load_controller_load_region_get_static_delegate = new efl_gfx_image_load_controller_load_region_get_delegate(load_region_get);
 515             }
 516
 517             if (methods.FirstOrDefault(m => m.Name == "GetLoadRegion") != null)
 518             {
 519                 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) });
 520             }
 521
 522             if (efl_gfx_image_load_controller_load_region_set_static_delegate == null)
 523             {
 524                 efl_gfx_image_load_controller_load_region_set_static_delegate = new efl_gfx_image_load_controller_load_region_set_delegate(load_region_set);
 525             }
 526
 527             if (methods.FirstOrDefault(m => m.Name == "SetLoadRegion") != null)
 528             {
 529                 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) });
 530             }
 531
 532             if (efl_gfx_image_load_controller_load_orientation_get_static_delegate == null)
 533             {
 534                 efl_gfx_image_load_controller_load_orientation_get_static_delegate = new efl_gfx_image_load_controller_load_orientation_get_delegate(load_orientation_get);
 535             }
 536
 537             if (methods.FirstOrDefault(m => m.Name == "GetLoadOrientation") != null)
 538             {
 539                 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) });
 540             }
 541
 542             if (efl_gfx_image_load_controller_load_orientation_set_static_delegate == null)
 543             {
 544                 efl_gfx_image_load_controller_load_orientation_set_static_delegate = new efl_gfx_image_load_controller_load_orientation_set_delegate(load_orientation_set);
 545             }
 546
 547             if (methods.FirstOrDefault(m => m.Name == "SetLoadOrientation") != null)
 548             {
 549                 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) });
 550             }
 551
 552             if (efl_gfx_image_load_controller_load_scale_down_get_static_delegate == null)
 553             {
 554                 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);
 555             }
 556
 557             if (methods.FirstOrDefault(m => m.Name == "GetLoadScaleDown") != null)
 558             {
 559                 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) });
 560             }
 561
 562             if (efl_gfx_image_load_controller_load_scale_down_set_static_delegate == null)
 563             {
 564                 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);
 565             }
 566
 567             if (methods.FirstOrDefault(m => m.Name == "SetLoadScaleDown") != null)
 568             {
 569                 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) });
 570             }
 571
 572             if (efl_gfx_image_load_controller_load_skip_header_get_static_delegate == null)
 573             {
 574                 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);
 575             }
 576
 577             if (methods.FirstOrDefault(m => m.Name == "GetLoadSkipHeader") != null)
 578             {
 579                 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) });
 580             }
 581
 582             if (efl_gfx_image_load_controller_load_skip_header_set_static_delegate == null)
 583             {
 584                 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);
 585             }
 586
 587             if (methods.FirstOrDefault(m => m.Name == "SetLoadSkipHeader") != null)
 588             {
 589                 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) });
 590             }
 591
 592             if (efl_gfx_image_load_controller_load_async_start_static_delegate == null)
 593             {
 594                 efl_gfx_image_load_controller_load_async_start_static_delegate = new efl_gfx_image_load_controller_load_async_start_delegate(load_async_start);
 595             }
 596
 597             if (methods.FirstOrDefault(m => m.Name == "LoadAsyncStart") != null)
 598             {
 599                 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) });
 600             }
 601
 602             if (efl_gfx_image_load_controller_load_async_cancel_static_delegate == null)
 603             {
 604                 efl_gfx_image_load_controller_load_async_cancel_static_delegate = new efl_gfx_image_load_controller_load_async_cancel_delegate(load_async_cancel);
 605             }
 606
 607             if (methods.FirstOrDefault(m => m.Name == "LoadAsyncCancel") != null)
 608             {
 609                 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) });
 610             }
 611
 612             return descs;
 613         }
 614         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 615         /// <returns>The native class pointer.</returns>
 616         public override IntPtr GetEflClass()
 617         {
 618             return Efl.Gfx.IImageLoadControllerConcrete.efl_gfx_image_load_controller_interface_get();
 619         }
 620
 621         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 622
 623
 624         private delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
 625
 626
 627         public delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_api_delegate(System.IntPtr obj);
 628
 629         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");
 630
 631         private static Eina.Size2D.NativeStruct load_size_get(System.IntPtr obj, System.IntPtr pd)
 632         {
 633             Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_get was called");
 634             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 635             if (ws != null)
 636             {
 637             Eina.Size2D _ret_var = default(Eina.Size2D);
 638                 try
 639                 {
 640                     _ret_var = ((IImageLoadController)ws.Target).GetLoadSize();
 641                 }
 642                 catch (Exception e)
 643                 {
 644                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 645                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 646                 }
 647
 648         return _ret_var;
 649
 650             }
 651             else
 652             {
 653                 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)));
 654             }
 655         }
 656
 657         private static efl_gfx_image_load_controller_load_size_get_delegate efl_gfx_image_load_controller_load_size_get_static_delegate;
 658
 659
 660         private delegate void efl_gfx_image_load_controller_load_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size);
 661
 662
 663         public delegate void efl_gfx_image_load_controller_load_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct size);
 664
 665         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");
 666
 667         private static void load_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
 668         {
 669             Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_set was called");
 670             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 671             if (ws != null)
 672             {
 673         Eina.Size2D _in_size = size;
 674
 675                 try
 676                 {
 677                     ((IImageLoadController)ws.Target).SetLoadSize(_in_size);
 678                 }
 679                 catch (Exception e)
 680                 {
 681                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 682                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 683                 }
 684
 685
 686             }
 687             else
 688             {
 689                 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);
 690             }
 691         }
 692
 693         private static efl_gfx_image_load_controller_load_size_set_delegate efl_gfx_image_load_controller_load_size_set_static_delegate;
 694
 695
 696         private delegate double efl_gfx_image_load_controller_load_dpi_get_delegate(System.IntPtr obj, System.IntPtr pd);
 697
 698
 699         public delegate double efl_gfx_image_load_controller_load_dpi_get_api_delegate(System.IntPtr obj);
 700
 701         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");
 702
 703         private static double load_dpi_get(System.IntPtr obj, System.IntPtr pd)
 704         {
 705             Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_get was called");
 706             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 707             if (ws != null)
 708             {
 709             double _ret_var = default(double);
 710                 try
 711                 {
 712                     _ret_var = ((IImageLoadController)ws.Target).GetLoadDpi();
 713                 }
 714                 catch (Exception e)
 715                 {
 716                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 717                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 718                 }
 719
 720         return _ret_var;
 721
 722             }
 723             else
 724             {
 725                 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)));
 726             }
 727         }
 728
 729         private static efl_gfx_image_load_controller_load_dpi_get_delegate efl_gfx_image_load_controller_load_dpi_get_static_delegate;
 730
 731
 732         private delegate void efl_gfx_image_load_controller_load_dpi_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dpi);
 733
 734
 735         public delegate void efl_gfx_image_load_controller_load_dpi_set_api_delegate(System.IntPtr obj,  double dpi);
 736
 737         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");
 738
 739         private static void load_dpi_set(System.IntPtr obj, System.IntPtr pd, double dpi)
 740         {
 741             Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_set was called");
 742             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 743             if (ws != null)
 744             {
 745
 746                 try
 747                 {
 748                     ((IImageLoadController)ws.Target).SetLoadDpi(dpi);
 749                 }
 750                 catch (Exception e)
 751                 {
 752                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 753                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 754                 }
 755
 756
 757             }
 758             else
 759             {
 760                 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);
 761             }
 762         }
 763
 764         private static efl_gfx_image_load_controller_load_dpi_set_delegate efl_gfx_image_load_controller_load_dpi_set_static_delegate;
 765
 766         [return: MarshalAs(UnmanagedType.U1)]
 767         private delegate bool efl_gfx_image_load_controller_load_region_support_get_delegate(System.IntPtr obj, System.IntPtr pd);
 768
 769         [return: MarshalAs(UnmanagedType.U1)]
 770         public delegate bool efl_gfx_image_load_controller_load_region_support_get_api_delegate(System.IntPtr obj);
 771
 772         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");
 773
 774         private static bool load_region_support_get(System.IntPtr obj, System.IntPtr pd)
 775         {
 776             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_support_get was called");
 777             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 778             if (ws != null)
 779             {
 780             bool _ret_var = default(bool);
 781                 try
 782                 {
 783                     _ret_var = ((IImageLoadController)ws.Target).GetLoadRegionSupport();
 784                 }
 785                 catch (Exception e)
 786                 {
 787                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 788                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 789                 }
 790
 791         return _ret_var;
 792
 793             }
 794             else
 795             {
 796                 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)));
 797             }
 798         }
 799
 800         private static efl_gfx_image_load_controller_load_region_support_get_delegate efl_gfx_image_load_controller_load_region_support_get_static_delegate;
 801
 802
 803         private delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
 804
 805
 806         public delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_api_delegate(System.IntPtr obj);
 807
 808         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");
 809
 810         private static Eina.Rect.NativeStruct load_region_get(System.IntPtr obj, System.IntPtr pd)
 811         {
 812             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_get was called");
 813             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 814             if (ws != null)
 815             {
 816             Eina.Rect _ret_var = default(Eina.Rect);
 817                 try
 818                 {
 819                     _ret_var = ((IImageLoadController)ws.Target).GetLoadRegion();
 820                 }
 821                 catch (Exception e)
 822                 {
 823                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 824                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 825                 }
 826
 827         return _ret_var;
 828
 829             }
 830             else
 831             {
 832                 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)));
 833             }
 834         }
 835
 836         private static efl_gfx_image_load_controller_load_region_get_delegate efl_gfx_image_load_controller_load_region_get_static_delegate;
 837
 838
 839         private delegate void efl_gfx_image_load_controller_load_region_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct region);
 840
 841
 842         public delegate void efl_gfx_image_load_controller_load_region_set_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct region);
 843
 844         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");
 845
 846         private static void load_region_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct region)
 847         {
 848             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_set was called");
 849             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 850             if (ws != null)
 851             {
 852         Eina.Rect _in_region = region;
 853
 854                 try
 855                 {
 856                     ((IImageLoadController)ws.Target).SetLoadRegion(_in_region);
 857                 }
 858                 catch (Exception e)
 859                 {
 860                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 861                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 862                 }
 863
 864
 865             }
 866             else
 867             {
 868                 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);
 869             }
 870         }
 871
 872         private static efl_gfx_image_load_controller_load_region_set_delegate efl_gfx_image_load_controller_load_region_set_static_delegate;
 873
 874         [return: MarshalAs(UnmanagedType.U1)]
 875         private delegate bool efl_gfx_image_load_controller_load_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
 876
 877         [return: MarshalAs(UnmanagedType.U1)]
 878         public delegate bool efl_gfx_image_load_controller_load_orientation_get_api_delegate(System.IntPtr obj);
 879
 880         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");
 881
 882         private static bool load_orientation_get(System.IntPtr obj, System.IntPtr pd)
 883         {
 884             Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_get was called");
 885             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 886             if (ws != null)
 887             {
 888             bool _ret_var = default(bool);
 889                 try
 890                 {
 891                     _ret_var = ((IImageLoadController)ws.Target).GetLoadOrientation();
 892                 }
 893                 catch (Exception e)
 894                 {
 895                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 896                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 897                 }
 898
 899         return _ret_var;
 900
 901             }
 902             else
 903             {
 904                 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)));
 905             }
 906         }
 907
 908         private static efl_gfx_image_load_controller_load_orientation_get_delegate efl_gfx_image_load_controller_load_orientation_get_static_delegate;
 909
 910
 911         private delegate void efl_gfx_image_load_controller_load_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enable);
 912
 913
 914         public delegate void efl_gfx_image_load_controller_load_orientation_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enable);
 915
 916         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");
 917
 918         private static void load_orientation_set(System.IntPtr obj, System.IntPtr pd, bool enable)
 919         {
 920             Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_set was called");
 921             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 922             if (ws != null)
 923             {
 924
 925                 try
 926                 {
 927                     ((IImageLoadController)ws.Target).SetLoadOrientation(enable);
 928                 }
 929                 catch (Exception e)
 930                 {
 931                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 932                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 933                 }
 934
 935
 936             }
 937             else
 938             {
 939                 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);
 940             }
 941         }
 942
 943         private static efl_gfx_image_load_controller_load_orientation_set_delegate efl_gfx_image_load_controller_load_orientation_set_static_delegate;
 944
 945
 946         private delegate int efl_gfx_image_load_controller_load_scale_down_get_delegate(System.IntPtr obj, System.IntPtr pd);
 947
 948
 949         public delegate int efl_gfx_image_load_controller_load_scale_down_get_api_delegate(System.IntPtr obj);
 950
 951         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");
 952
 953         private static int load_scale_down_get(System.IntPtr obj, System.IntPtr pd)
 954         {
 955             Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_get was called");
 956             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 957             if (ws != null)
 958             {
 959             int _ret_var = default(int);
 960                 try
 961                 {
 962                     _ret_var = ((IImageLoadController)ws.Target).GetLoadScaleDown();
 963                 }
 964                 catch (Exception e)
 965                 {
 966                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 967                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 968                 }
 969
 970         return _ret_var;
 971
 972             }
 973             else
 974             {
 975                 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)));
 976             }
 977         }
 978
 979         private static efl_gfx_image_load_controller_load_scale_down_get_delegate efl_gfx_image_load_controller_load_scale_down_get_static_delegate;
 980
 981
 982         private delegate void efl_gfx_image_load_controller_load_scale_down_set_delegate(System.IntPtr obj, System.IntPtr pd,  int div);
 983
 984
 985         public delegate void efl_gfx_image_load_controller_load_scale_down_set_api_delegate(System.IntPtr obj,  int div);
 986
 987         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");
 988
 989         private static void load_scale_down_set(System.IntPtr obj, System.IntPtr pd, int div)
 990         {
 991             Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_set was called");
 992             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 993             if (ws != null)
 994             {
 995
 996                 try
 997                 {
 998                     ((IImageLoadController)ws.Target).SetLoadScaleDown(div);
 999                 }
1000                 catch (Exception e)
1001                 {
1002                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1003                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1004                 }
1005
1006
1007             }
1008             else
1009             {
1010                 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);
1011             }
1012         }
1013
1014         private static efl_gfx_image_load_controller_load_scale_down_set_delegate efl_gfx_image_load_controller_load_scale_down_set_static_delegate;
1015
1016         [return: MarshalAs(UnmanagedType.U1)]
1017         private delegate bool efl_gfx_image_load_controller_load_skip_header_get_delegate(System.IntPtr obj, System.IntPtr pd);
1018
1019         [return: MarshalAs(UnmanagedType.U1)]
1020         public delegate bool efl_gfx_image_load_controller_load_skip_header_get_api_delegate(System.IntPtr obj);
1021
1022         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");
1023
1024         private static bool load_skip_header_get(System.IntPtr obj, System.IntPtr pd)
1025         {
1026             Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_get was called");
1027             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1028             if (ws != null)
1029             {
1030             bool _ret_var = default(bool);
1031                 try
1032                 {
1033                     _ret_var = ((IImageLoadController)ws.Target).GetLoadSkipHeader();
1034                 }
1035                 catch (Exception e)
1036                 {
1037                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1038                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1039                 }
1040
1041         return _ret_var;
1042
1043             }
1044             else
1045             {
1046                 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)));
1047             }
1048         }
1049
1050         private static efl_gfx_image_load_controller_load_skip_header_get_delegate efl_gfx_image_load_controller_load_skip_header_get_static_delegate;
1051
1052
1053         private delegate void efl_gfx_image_load_controller_load_skip_header_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool skip);
1054
1055
1056         public delegate void efl_gfx_image_load_controller_load_skip_header_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool skip);
1057
1058         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");
1059
1060         private static void load_skip_header_set(System.IntPtr obj, System.IntPtr pd, bool skip)
1061         {
1062             Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_set was called");
1063             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1064             if (ws != null)
1065             {
1066
1067                 try
1068                 {
1069                     ((IImageLoadController)ws.Target).SetLoadSkipHeader(skip);
1070                 }
1071                 catch (Exception e)
1072                 {
1073                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1074                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1075                 }
1076
1077
1078             }
1079             else
1080             {
1081                 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);
1082             }
1083         }
1084
1085         private static efl_gfx_image_load_controller_load_skip_header_set_delegate efl_gfx_image_load_controller_load_skip_header_set_static_delegate;
1086
1087
1088         private delegate void efl_gfx_image_load_controller_load_async_start_delegate(System.IntPtr obj, System.IntPtr pd);
1089
1090
1091         public delegate void efl_gfx_image_load_controller_load_async_start_api_delegate(System.IntPtr obj);
1092
1093         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");
1094
1095         private static void load_async_start(System.IntPtr obj, System.IntPtr pd)
1096         {
1097             Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_start was called");
1098             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1099             if (ws != null)
1100             {
1101
1102                 try
1103                 {
1104                     ((IImageLoadController)ws.Target).LoadAsyncStart();
1105                 }
1106                 catch (Exception e)
1107                 {
1108                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1109                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1110                 }
1111
1112
1113             }
1114             else
1115             {
1116                 efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1117             }
1118         }
1119
1120         private static efl_gfx_image_load_controller_load_async_start_delegate efl_gfx_image_load_controller_load_async_start_static_delegate;
1121
1122
1123         private delegate void efl_gfx_image_load_controller_load_async_cancel_delegate(System.IntPtr obj, System.IntPtr pd);
1124
1125
1126         public delegate void efl_gfx_image_load_controller_load_async_cancel_api_delegate(System.IntPtr obj);
1127
1128         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");
1129
1130         private static void load_async_cancel(System.IntPtr obj, System.IntPtr pd)
1131         {
1132             Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_cancel was called");
1133             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1134             if (ws != null)
1135             {
1136
1137                 try
1138                 {
1139                     ((IImageLoadController)ws.Target).LoadAsyncCancel();
1140                 }
1141                 catch (Exception e)
1142                 {
1143                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1144                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1145                 }
1146
1147
1148             }
1149             else
1150             {
1151                 efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1152             }
1153         }
1154
1155         private static efl_gfx_image_load_controller_load_async_cancel_delegate efl_gfx_image_load_controller_load_async_cancel_static_delegate;
1156
1157         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1158
1159 }
1160 }
1161 }
1162
1163 }
1164