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

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