1 #pragma warning disable CS1591
3 using System.Runtime.InteropServices;
4 using System.Collections.Generic;
6 using System.Threading;
7 using System.ComponentModel;
12 /// <summary>Common APIs for all loadable 2D images.</summary>
13 [Efl.Gfx.IImageLoadControllerConcrete.NativeMethods]
14 public interface IImageLoadController :
15 Efl.Eo.IWrapper, IDisposable
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>
28 /// <summary>Set the DPI resolution of an image object'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'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's area on its image object.
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.
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.
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'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'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.
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 {
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>
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 {
101 /// <summary>Retrieve the coordinates of a given image object's selective (source image) load region.</summary>
102 /// <value>A region of the image.</value>
103 Eina.Rect LoadRegion {
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 {
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.
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.
119 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
120 /// <value>The scale down dividing factor.</value>
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 {
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; }
138 /// <summary>Common APIs for all loadable 2D images.</summary>
139 sealed public class IImageLoadControllerConcrete :
141 , IImageLoadController
144 ///<summary>Pointer to the native class description.</summary>
145 public override System.IntPtr NativeClass
149 if (((object)this).GetType() == typeof(IImageLoadControllerConcrete))
151 return GetEflClassStatic();
155 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
160 [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
161 efl_gfx_image_load_controller_interface_get();
162 /// <summary>Initializes a new instance of the <see cref="IImageLoadController"/> class.
163 /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
164 private IImageLoadControllerConcrete(System.IntPtr raw) : base(raw)
168 /// <summary>Called when he image was loaded</summary>
169 public event EventHandler LoadDoneEvt
175 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
177 var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
180 EventArgs args = EventArgs.Empty;
183 value?.Invoke(obj, args);
187 Eina.Log.Error(e.ToString());
188 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
193 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
194 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
202 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
203 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
207 ///<summary>Method to raise event LoadDoneEvt.</summary>
208 public void OnLoadDoneEvt(EventArgs e)
210 var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
211 IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
212 if (desc == IntPtr.Zero)
214 Eina.Log.Error($"Failed to get native event {key}");
218 Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
220 /// <summary>Called when an error happened during image loading</summary>
221 public event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt
227 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
229 var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
232 Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args args = new Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args();
233 args.arg = (Eina.Error)Marshal.PtrToStructure(evt.Info, typeof(Eina.Error));
236 value?.Invoke(obj, args);
240 Eina.Log.Error(e.ToString());
241 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
246 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
247 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
255 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
256 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
260 ///<summary>Method to raise event LoadErrorEvt.</summary>
261 public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
263 var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
264 IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
265 if (desc == IntPtr.Zero)
267 Eina.Log.Error($"Failed to get native event {key}");
271 IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc((int)e.arg);
274 Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
278 Marshal.FreeHGlobal(info);
281 /// <summary>Returns the requested load size.</summary>
282 /// <returns>The image load size.</returns>
283 public Eina.Size2D GetLoadSize() {
284 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate(this.NativeHandle);
285 Eina.Error.RaiseIfUnhandledException();
288 /// <summary>Requests the canvas to load the image at the given size.
289 /// EFL will try to load an image of the requested size but does not guarantee an exact match between the request and the loaded image dimensions.</summary>
290 /// <param name="size">The image load size.</param>
291 public void SetLoadSize(Eina.Size2D size) {
292 Eina.Size2D.NativeStruct _in_size = size;
293 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate(this.NativeHandle,_in_size);
294 Eina.Error.RaiseIfUnhandledException();
296 /// <summary>Get the DPI resolution of a loaded image object in the canvas.
297 /// This function returns the DPI resolution of the given canvas image.</summary>
298 /// <returns>The DPI resolution.</returns>
299 public double GetLoadDpi() {
300 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate(this.NativeHandle);
301 Eina.Error.RaiseIfUnhandledException();
304 /// <summary>Set the DPI resolution of an image object's source image.
305 /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
306 /// <param name="dpi">The DPI resolution.</param>
307 public void SetLoadDpi(double dpi) {
308 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate(this.NativeHandle,dpi);
309 Eina.Error.RaiseIfUnhandledException();
311 /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
312 /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
313 public bool GetLoadRegionSupport() {
314 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate(this.NativeHandle);
315 Eina.Error.RaiseIfUnhandledException();
318 /// <summary>Retrieve the coordinates of a given image object's selective (source image) load region.</summary>
319 /// <returns>A region of the image.</returns>
320 public Eina.Rect GetLoadRegion() {
321 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate(this.NativeHandle);
322 Eina.Error.RaiseIfUnhandledException();
325 /// <summary>Inform a given image object to load a selective region of its source image.
326 /// This function is useful when one is not showing all of an image's area on its image object.
328 /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
329 /// <param name="region">A region of the image.</param>
330 public void SetLoadRegion(Eina.Rect region) {
331 Eina.Rect.NativeStruct _in_region = region;
332 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate(this.NativeHandle,_in_region);
333 Eina.Error.RaiseIfUnhandledException();
335 /// <summary>Defines whether the orientation information in the image file should be honored.
336 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
337 /// <returns><c>true</c> means that it should honor the orientation information.</returns>
338 public bool GetLoadOrientation() {
339 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate(this.NativeHandle);
340 Eina.Error.RaiseIfUnhandledException();
343 /// <summary>Defines whether the orientation information in the image file should be honored.
344 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
345 /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
346 public void SetLoadOrientation(bool enable) {
347 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate(this.NativeHandle,enable);
348 Eina.Error.RaiseIfUnhandledException();
350 /// <summary>The scale down factor is a divider on the original image size.
351 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
353 /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
355 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
356 /// <returns>The scale down dividing factor.</returns>
357 public int GetLoadScaleDown() {
358 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate(this.NativeHandle);
359 Eina.Error.RaiseIfUnhandledException();
362 /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
363 /// <param name="div">The scale down dividing factor.</param>
364 public void SetLoadScaleDown(int div) {
365 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate(this.NativeHandle,div);
366 Eina.Error.RaiseIfUnhandledException();
368 /// <summary>Initial load should skip header check and leave it all to data load
369 /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
370 /// <returns>Will be true if header is to be skipped.</returns>
371 public bool GetLoadSkipHeader() {
372 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate(this.NativeHandle);
373 Eina.Error.RaiseIfUnhandledException();
376 /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
377 /// <param name="skip">Will be true if header is to be skipped.</param>
378 public void SetLoadSkipHeader(bool skip) {
379 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate(this.NativeHandle,skip);
380 Eina.Error.RaiseIfUnhandledException();
382 /// <summary>Begin preloading an image object's image data in the background.
383 /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
384 public void LoadAsyncStart() {
385 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(this.NativeHandle);
386 Eina.Error.RaiseIfUnhandledException();
388 /// <summary>Cancel preloading an image object's image data in the background.
389 /// The object should be left in a state where it has no image data. If cancel is called too late, the image will be kept in memory.</summary>
390 public void LoadAsyncCancel() {
391 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(this.NativeHandle);
392 Eina.Error.RaiseIfUnhandledException();
394 /// <summary>The load size of an image.
395 /// The image will be loaded into memory as if it was the specified size instead of its original size. This can save a lot of memory and is important for scalable types like svg.
397 /// By default, the load size is not specified, so it is 0x0.</summary>
398 /// <value>The image load size.</value>
399 public Eina.Size2D LoadSize {
400 get { return GetLoadSize(); }
401 set { SetLoadSize(value); }
403 /// <summary>Get the DPI resolution of a loaded image object in the canvas.
404 /// This function returns the DPI resolution of the given canvas image.</summary>
405 /// <value>The DPI resolution.</value>
406 public double LoadDpi {
407 get { return GetLoadDpi(); }
408 set { SetLoadDpi(value); }
410 /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
411 /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
412 public bool LoadRegionSupport {
413 get { return GetLoadRegionSupport(); }
415 /// <summary>Retrieve the coordinates of a given image object's selective (source image) load region.</summary>
416 /// <value>A region of the image.</value>
417 public Eina.Rect LoadRegion {
418 get { return GetLoadRegion(); }
419 set { SetLoadRegion(value); }
421 /// <summary>Defines whether the orientation information in the image file should be honored.
422 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
423 /// <value><c>true</c> means that it should honor the orientation information.</value>
424 public bool LoadOrientation {
425 get { return GetLoadOrientation(); }
426 set { SetLoadOrientation(value); }
428 /// <summary>The scale down factor is a divider on the original image size.
429 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
431 /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
433 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
434 /// <value>The scale down dividing factor.</value>
435 public int LoadScaleDown {
436 get { return GetLoadScaleDown(); }
437 set { SetLoadScaleDown(value); }
439 /// <summary>Initial load should skip header check and leave it all to data load
440 /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
441 /// <value>Will be true if header is to be skipped.</value>
442 public bool LoadSkipHeader {
443 get { return GetLoadSkipHeader(); }
444 set { SetLoadSkipHeader(value); }
446 private static IntPtr GetEflClassStatic()
448 return Efl.Gfx.IImageLoadControllerConcrete.efl_gfx_image_load_controller_interface_get();
450 /// <summary>Wrapper for native methods and virtual method delegates.
451 /// For internal use by generated code only.</summary>
452 public class NativeMethods : Efl.Eo.NativeClass
454 private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Efl);
455 /// <summary>Gets the list of Eo operations to override.</summary>
456 /// <returns>The list of Eo operations to be overload.</returns>
457 public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
459 var descs = new System.Collections.Generic.List<Efl_Op_Description>();
460 var methods = Efl.Eo.Globals.GetUserMethods(type);
462 if (efl_gfx_image_load_controller_load_size_get_static_delegate == null)
464 efl_gfx_image_load_controller_load_size_get_static_delegate = new efl_gfx_image_load_controller_load_size_get_delegate(load_size_get);
467 if (methods.FirstOrDefault(m => m.Name == "GetLoadSize") != null)
469 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_size_get_static_delegate) });
472 if (efl_gfx_image_load_controller_load_size_set_static_delegate == null)
474 efl_gfx_image_load_controller_load_size_set_static_delegate = new efl_gfx_image_load_controller_load_size_set_delegate(load_size_set);
477 if (methods.FirstOrDefault(m => m.Name == "SetLoadSize") != null)
479 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_size_set_static_delegate) });
482 if (efl_gfx_image_load_controller_load_dpi_get_static_delegate == null)
484 efl_gfx_image_load_controller_load_dpi_get_static_delegate = new efl_gfx_image_load_controller_load_dpi_get_delegate(load_dpi_get);
487 if (methods.FirstOrDefault(m => m.Name == "GetLoadDpi") != null)
489 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_dpi_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_dpi_get_static_delegate) });
492 if (efl_gfx_image_load_controller_load_dpi_set_static_delegate == null)
494 efl_gfx_image_load_controller_load_dpi_set_static_delegate = new efl_gfx_image_load_controller_load_dpi_set_delegate(load_dpi_set);
497 if (methods.FirstOrDefault(m => m.Name == "SetLoadDpi") != null)
499 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_dpi_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_dpi_set_static_delegate) });
502 if (efl_gfx_image_load_controller_load_region_support_get_static_delegate == null)
504 efl_gfx_image_load_controller_load_region_support_get_static_delegate = new efl_gfx_image_load_controller_load_region_support_get_delegate(load_region_support_get);
507 if (methods.FirstOrDefault(m => m.Name == "GetLoadRegionSupport") != null)
509 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_support_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_support_get_static_delegate) });
512 if (efl_gfx_image_load_controller_load_region_get_static_delegate == null)
514 efl_gfx_image_load_controller_load_region_get_static_delegate = new efl_gfx_image_load_controller_load_region_get_delegate(load_region_get);
517 if (methods.FirstOrDefault(m => m.Name == "GetLoadRegion") != null)
519 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_get_static_delegate) });
522 if (efl_gfx_image_load_controller_load_region_set_static_delegate == null)
524 efl_gfx_image_load_controller_load_region_set_static_delegate = new efl_gfx_image_load_controller_load_region_set_delegate(load_region_set);
527 if (methods.FirstOrDefault(m => m.Name == "SetLoadRegion") != null)
529 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_set_static_delegate) });
532 if (efl_gfx_image_load_controller_load_orientation_get_static_delegate == null)
534 efl_gfx_image_load_controller_load_orientation_get_static_delegate = new efl_gfx_image_load_controller_load_orientation_get_delegate(load_orientation_get);
537 if (methods.FirstOrDefault(m => m.Name == "GetLoadOrientation") != null)
539 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_orientation_get_static_delegate) });
542 if (efl_gfx_image_load_controller_load_orientation_set_static_delegate == null)
544 efl_gfx_image_load_controller_load_orientation_set_static_delegate = new efl_gfx_image_load_controller_load_orientation_set_delegate(load_orientation_set);
547 if (methods.FirstOrDefault(m => m.Name == "SetLoadOrientation") != null)
549 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_orientation_set_static_delegate) });
552 if (efl_gfx_image_load_controller_load_scale_down_get_static_delegate == null)
554 efl_gfx_image_load_controller_load_scale_down_get_static_delegate = new efl_gfx_image_load_controller_load_scale_down_get_delegate(load_scale_down_get);
557 if (methods.FirstOrDefault(m => m.Name == "GetLoadScaleDown") != null)
559 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_scale_down_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_scale_down_get_static_delegate) });
562 if (efl_gfx_image_load_controller_load_scale_down_set_static_delegate == null)
564 efl_gfx_image_load_controller_load_scale_down_set_static_delegate = new efl_gfx_image_load_controller_load_scale_down_set_delegate(load_scale_down_set);
567 if (methods.FirstOrDefault(m => m.Name == "SetLoadScaleDown") != null)
569 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_scale_down_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_scale_down_set_static_delegate) });
572 if (efl_gfx_image_load_controller_load_skip_header_get_static_delegate == null)
574 efl_gfx_image_load_controller_load_skip_header_get_static_delegate = new efl_gfx_image_load_controller_load_skip_header_get_delegate(load_skip_header_get);
577 if (methods.FirstOrDefault(m => m.Name == "GetLoadSkipHeader") != null)
579 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_skip_header_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_skip_header_get_static_delegate) });
582 if (efl_gfx_image_load_controller_load_skip_header_set_static_delegate == null)
584 efl_gfx_image_load_controller_load_skip_header_set_static_delegate = new efl_gfx_image_load_controller_load_skip_header_set_delegate(load_skip_header_set);
587 if (methods.FirstOrDefault(m => m.Name == "SetLoadSkipHeader") != null)
589 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_skip_header_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_skip_header_set_static_delegate) });
592 if (efl_gfx_image_load_controller_load_async_start_static_delegate == null)
594 efl_gfx_image_load_controller_load_async_start_static_delegate = new efl_gfx_image_load_controller_load_async_start_delegate(load_async_start);
597 if (methods.FirstOrDefault(m => m.Name == "LoadAsyncStart") != null)
599 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_async_start"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_async_start_static_delegate) });
602 if (efl_gfx_image_load_controller_load_async_cancel_static_delegate == null)
604 efl_gfx_image_load_controller_load_async_cancel_static_delegate = new efl_gfx_image_load_controller_load_async_cancel_delegate(load_async_cancel);
607 if (methods.FirstOrDefault(m => m.Name == "LoadAsyncCancel") != null)
609 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_async_cancel"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_async_cancel_static_delegate) });
614 /// <summary>Returns the Eo class for the native methods of this class.</summary>
615 /// <returns>The native class pointer.</returns>
616 public override IntPtr GetEflClass()
618 return Efl.Gfx.IImageLoadControllerConcrete.efl_gfx_image_load_controller_interface_get();
621 #pragma warning disable CA1707, CS1591, SA1300, SA1600
624 private delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
627 public delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_api_delegate(System.IntPtr obj);
629 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_get_api_delegate> efl_gfx_image_load_controller_load_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_size_get");
631 private static Eina.Size2D.NativeStruct load_size_get(System.IntPtr obj, System.IntPtr pd)
633 Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_get was called");
634 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
637 Eina.Size2D _ret_var = default(Eina.Size2D);
640 _ret_var = ((IImageLoadController)ws.Target).GetLoadSize();
644 Eina.Log.Warning($"Callback error: {e.ToString()}");
645 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
653 return efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
657 private static efl_gfx_image_load_controller_load_size_get_delegate efl_gfx_image_load_controller_load_size_get_static_delegate;
660 private delegate void efl_gfx_image_load_controller_load_size_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size);
663 public delegate void efl_gfx_image_load_controller_load_size_set_api_delegate(System.IntPtr obj, Eina.Size2D.NativeStruct size);
665 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_set_api_delegate> efl_gfx_image_load_controller_load_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_size_set");
667 private static void load_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
669 Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_set was called");
670 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
673 Eina.Size2D _in_size = size;
677 ((IImageLoadController)ws.Target).SetLoadSize(_in_size);
681 Eina.Log.Warning($"Callback error: {e.ToString()}");
682 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
689 efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
693 private static efl_gfx_image_load_controller_load_size_set_delegate efl_gfx_image_load_controller_load_size_set_static_delegate;
696 private delegate double efl_gfx_image_load_controller_load_dpi_get_delegate(System.IntPtr obj, System.IntPtr pd);
699 public delegate double efl_gfx_image_load_controller_load_dpi_get_api_delegate(System.IntPtr obj);
701 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_get_api_delegate> efl_gfx_image_load_controller_load_dpi_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_dpi_get");
703 private static double load_dpi_get(System.IntPtr obj, System.IntPtr pd)
705 Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_get was called");
706 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
709 double _ret_var = default(double);
712 _ret_var = ((IImageLoadController)ws.Target).GetLoadDpi();
716 Eina.Log.Warning($"Callback error: {e.ToString()}");
717 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
725 return efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
729 private static efl_gfx_image_load_controller_load_dpi_get_delegate efl_gfx_image_load_controller_load_dpi_get_static_delegate;
732 private delegate void efl_gfx_image_load_controller_load_dpi_set_delegate(System.IntPtr obj, System.IntPtr pd, double dpi);
735 public delegate void efl_gfx_image_load_controller_load_dpi_set_api_delegate(System.IntPtr obj, double dpi);
737 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_set_api_delegate> efl_gfx_image_load_controller_load_dpi_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_dpi_set");
739 private static void load_dpi_set(System.IntPtr obj, System.IntPtr pd, double dpi)
741 Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_set was called");
742 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
748 ((IImageLoadController)ws.Target).SetLoadDpi(dpi);
752 Eina.Log.Warning($"Callback error: {e.ToString()}");
753 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
760 efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dpi);
764 private static efl_gfx_image_load_controller_load_dpi_set_delegate efl_gfx_image_load_controller_load_dpi_set_static_delegate;
766 [return: MarshalAs(UnmanagedType.U1)]
767 private delegate bool efl_gfx_image_load_controller_load_region_support_get_delegate(System.IntPtr obj, System.IntPtr pd);
769 [return: MarshalAs(UnmanagedType.U1)]
770 public delegate bool efl_gfx_image_load_controller_load_region_support_get_api_delegate(System.IntPtr obj);
772 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_support_get_api_delegate> efl_gfx_image_load_controller_load_region_support_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_support_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_support_get");
774 private static bool load_region_support_get(System.IntPtr obj, System.IntPtr pd)
776 Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_support_get was called");
777 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
780 bool _ret_var = default(bool);
783 _ret_var = ((IImageLoadController)ws.Target).GetLoadRegionSupport();
787 Eina.Log.Warning($"Callback error: {e.ToString()}");
788 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
796 return efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
800 private static efl_gfx_image_load_controller_load_region_support_get_delegate efl_gfx_image_load_controller_load_region_support_get_static_delegate;
803 private delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
806 public delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_api_delegate(System.IntPtr obj);
808 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_get_api_delegate> efl_gfx_image_load_controller_load_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_get");
810 private static Eina.Rect.NativeStruct load_region_get(System.IntPtr obj, System.IntPtr pd)
812 Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_get was called");
813 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
816 Eina.Rect _ret_var = default(Eina.Rect);
819 _ret_var = ((IImageLoadController)ws.Target).GetLoadRegion();
823 Eina.Log.Warning($"Callback error: {e.ToString()}");
824 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
832 return efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
836 private static efl_gfx_image_load_controller_load_region_get_delegate efl_gfx_image_load_controller_load_region_get_static_delegate;
839 private delegate void efl_gfx_image_load_controller_load_region_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct region);
842 public delegate void efl_gfx_image_load_controller_load_region_set_api_delegate(System.IntPtr obj, Eina.Rect.NativeStruct region);
844 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_set_api_delegate> efl_gfx_image_load_controller_load_region_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_set");
846 private static void load_region_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct region)
848 Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_set was called");
849 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
852 Eina.Rect _in_region = region;
856 ((IImageLoadController)ws.Target).SetLoadRegion(_in_region);
860 Eina.Log.Warning($"Callback error: {e.ToString()}");
861 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
868 efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), region);
872 private static efl_gfx_image_load_controller_load_region_set_delegate efl_gfx_image_load_controller_load_region_set_static_delegate;
874 [return: MarshalAs(UnmanagedType.U1)]
875 private delegate bool efl_gfx_image_load_controller_load_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
877 [return: MarshalAs(UnmanagedType.U1)]
878 public delegate bool efl_gfx_image_load_controller_load_orientation_get_api_delegate(System.IntPtr obj);
880 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_get_api_delegate> efl_gfx_image_load_controller_load_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_orientation_get");
882 private static bool load_orientation_get(System.IntPtr obj, System.IntPtr pd)
884 Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_get was called");
885 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
888 bool _ret_var = default(bool);
891 _ret_var = ((IImageLoadController)ws.Target).GetLoadOrientation();
895 Eina.Log.Warning($"Callback error: {e.ToString()}");
896 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
904 return efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
908 private static efl_gfx_image_load_controller_load_orientation_get_delegate efl_gfx_image_load_controller_load_orientation_get_static_delegate;
911 private delegate void efl_gfx_image_load_controller_load_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enable);
914 public delegate void efl_gfx_image_load_controller_load_orientation_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enable);
916 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_set_api_delegate> efl_gfx_image_load_controller_load_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_orientation_set");
918 private static void load_orientation_set(System.IntPtr obj, System.IntPtr pd, bool enable)
920 Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_set was called");
921 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
927 ((IImageLoadController)ws.Target).SetLoadOrientation(enable);
931 Eina.Log.Warning($"Callback error: {e.ToString()}");
932 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
939 efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enable);
943 private static efl_gfx_image_load_controller_load_orientation_set_delegate efl_gfx_image_load_controller_load_orientation_set_static_delegate;
946 private delegate int efl_gfx_image_load_controller_load_scale_down_get_delegate(System.IntPtr obj, System.IntPtr pd);
949 public delegate int efl_gfx_image_load_controller_load_scale_down_get_api_delegate(System.IntPtr obj);
951 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_get_api_delegate> efl_gfx_image_load_controller_load_scale_down_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_scale_down_get");
953 private static int load_scale_down_get(System.IntPtr obj, System.IntPtr pd)
955 Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_get was called");
956 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
959 int _ret_var = default(int);
962 _ret_var = ((IImageLoadController)ws.Target).GetLoadScaleDown();
966 Eina.Log.Warning($"Callback error: {e.ToString()}");
967 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
975 return efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
979 private static efl_gfx_image_load_controller_load_scale_down_get_delegate efl_gfx_image_load_controller_load_scale_down_get_static_delegate;
982 private delegate void efl_gfx_image_load_controller_load_scale_down_set_delegate(System.IntPtr obj, System.IntPtr pd, int div);
985 public delegate void efl_gfx_image_load_controller_load_scale_down_set_api_delegate(System.IntPtr obj, int div);
987 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_set_api_delegate> efl_gfx_image_load_controller_load_scale_down_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_scale_down_set");
989 private static void load_scale_down_set(System.IntPtr obj, System.IntPtr pd, int div)
991 Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_set was called");
992 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
998 ((IImageLoadController)ws.Target).SetLoadScaleDown(div);
1002 Eina.Log.Warning($"Callback error: {e.ToString()}");
1003 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1010 efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), div);
1014 private static efl_gfx_image_load_controller_load_scale_down_set_delegate efl_gfx_image_load_controller_load_scale_down_set_static_delegate;
1016 [return: MarshalAs(UnmanagedType.U1)]
1017 private delegate bool efl_gfx_image_load_controller_load_skip_header_get_delegate(System.IntPtr obj, System.IntPtr pd);
1019 [return: MarshalAs(UnmanagedType.U1)]
1020 public delegate bool efl_gfx_image_load_controller_load_skip_header_get_api_delegate(System.IntPtr obj);
1022 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_get_api_delegate> efl_gfx_image_load_controller_load_skip_header_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_skip_header_get");
1024 private static bool load_skip_header_get(System.IntPtr obj, System.IntPtr pd)
1026 Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_get was called");
1027 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1030 bool _ret_var = default(bool);
1033 _ret_var = ((IImageLoadController)ws.Target).GetLoadSkipHeader();
1037 Eina.Log.Warning($"Callback error: {e.ToString()}");
1038 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1046 return efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1050 private static efl_gfx_image_load_controller_load_skip_header_get_delegate efl_gfx_image_load_controller_load_skip_header_get_static_delegate;
1053 private delegate void efl_gfx_image_load_controller_load_skip_header_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool skip);
1056 public delegate void efl_gfx_image_load_controller_load_skip_header_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool skip);
1058 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_set_api_delegate> efl_gfx_image_load_controller_load_skip_header_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_skip_header_set");
1060 private static void load_skip_header_set(System.IntPtr obj, System.IntPtr pd, bool skip)
1062 Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_set was called");
1063 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1069 ((IImageLoadController)ws.Target).SetLoadSkipHeader(skip);
1073 Eina.Log.Warning($"Callback error: {e.ToString()}");
1074 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1081 efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), skip);
1085 private static efl_gfx_image_load_controller_load_skip_header_set_delegate efl_gfx_image_load_controller_load_skip_header_set_static_delegate;
1088 private delegate void efl_gfx_image_load_controller_load_async_start_delegate(System.IntPtr obj, System.IntPtr pd);
1091 public delegate void efl_gfx_image_load_controller_load_async_start_api_delegate(System.IntPtr obj);
1093 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_start_api_delegate> efl_gfx_image_load_controller_load_async_start_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_start_api_delegate>(Module, "efl_gfx_image_load_controller_load_async_start");
1095 private static void load_async_start(System.IntPtr obj, System.IntPtr pd)
1097 Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_start was called");
1098 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1104 ((IImageLoadController)ws.Target).LoadAsyncStart();
1108 Eina.Log.Warning($"Callback error: {e.ToString()}");
1109 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1116 efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1120 private static efl_gfx_image_load_controller_load_async_start_delegate efl_gfx_image_load_controller_load_async_start_static_delegate;
1123 private delegate void efl_gfx_image_load_controller_load_async_cancel_delegate(System.IntPtr obj, System.IntPtr pd);
1126 public delegate void efl_gfx_image_load_controller_load_async_cancel_api_delegate(System.IntPtr obj);
1128 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_cancel_api_delegate> efl_gfx_image_load_controller_load_async_cancel_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_cancel_api_delegate>(Module, "efl_gfx_image_load_controller_load_async_cancel");
1130 private static void load_async_cancel(System.IntPtr obj, System.IntPtr pd)
1132 Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_cancel was called");
1133 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1139 ((IImageLoadController)ws.Target).LoadAsyncCancel();
1143 Eina.Log.Warning($"Callback error: {e.ToString()}");
1144 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1151 efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1155 private static efl_gfx_image_load_controller_load_async_cancel_delegate efl_gfx_image_load_controller_load_async_cancel_static_delegate;
1157 #pragma warning restore CA1707, CS1591, SA1300, SA1600