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