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

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