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 [Efl.Eo.BindingEntity]
15 public interface IImageLoadController :
16 Efl.Eo.IWrapper, IDisposable
18 /// <summary>Returns the requested load size.</summary>
19 /// <returns>The image load size.</returns>
20 Eina.Size2D GetLoadSize();
21 /// <summary>Requests the canvas to load the image at the given size.
22 /// EFL will try to load an image of the requested size but does not guarantee an exact match between the request and the loaded image dimensions.</summary>
23 /// <param name="size">The image load size.</param>
24 void SetLoadSize(Eina.Size2D size);
25 /// <summary>Get the DPI resolution of a loaded image object in the canvas.
26 /// This function returns the DPI resolution of the given canvas image.</summary>
27 /// <returns>The DPI resolution.</returns>
29 /// <summary>Set the DPI resolution of an image object's source image.
30 /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
31 /// <param name="dpi">The DPI resolution.</param>
32 void SetLoadDpi(double dpi);
33 /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
34 /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
35 bool GetLoadRegionSupport();
36 /// <summary>Retrieve the coordinates of a given image object's selective (source image) load region.</summary>
37 /// <returns>A region of the image.</returns>
38 Eina.Rect GetLoadRegion();
39 /// <summary>Inform a given image object to load a selective region of its source image.
40 /// This function is useful when one is not showing all of an image's area on its image object.
42 /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
43 /// <param name="region">A region of the image.</param>
44 void SetLoadRegion(Eina.Rect region);
45 /// <summary>Defines whether the orientation information in the image file should be honored.
46 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
47 /// <returns><c>true</c> means that it should honor the orientation information.</returns>
48 bool GetLoadOrientation();
49 /// <summary>Defines whether the orientation information in the image file should be honored.
50 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
51 /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
52 void SetLoadOrientation(bool enable);
53 /// <summary>The scale down factor is a divider on the original image size.
54 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
56 /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
58 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
59 /// <returns>The scale down dividing factor.</returns>
60 int GetLoadScaleDown();
61 /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
62 /// <param name="div">The scale down dividing factor.</param>
63 void SetLoadScaleDown(int div);
64 /// <summary>Initial load should skip header check and leave it all to data load
65 /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
66 /// <returns>Will be true if header is to be skipped.</returns>
67 bool GetLoadSkipHeader();
68 /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
69 /// <param name="skip">Will be true if header is to be skipped.</param>
70 void SetLoadSkipHeader(bool skip);
71 /// <summary>Begin preloading an image object's image data in the background.
72 /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
73 void LoadAsyncStart();
74 /// <summary>Cancel preloading an image object's image data in the background.
75 /// The object should be left in a state where it has no image data. If cancel is called too late, the image will be kept in memory.</summary>
76 void LoadAsyncCancel();
77 /// <summary>Called when he image was loaded</summary>
78 event EventHandler LoadDoneEvt;
79 /// <summary>Called when an error happened during image loading</summary>
80 event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt;
81 /// <summary>The load size of an image.
82 /// The image will be loaded into memory as if it was the specified size instead of its original size. This can save a lot of memory and is important for scalable types like svg.
84 /// By default, the load size is not specified, so it is 0x0.</summary>
85 /// <value>The image load size.</value>
86 Eina.Size2D LoadSize {
90 /// <summary>Get the DPI resolution of a loaded image object in the canvas.
91 /// This function returns the DPI resolution of the given canvas image.</summary>
92 /// <value>The DPI resolution.</value>
97 /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
98 /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
99 bool LoadRegionSupport {
102 /// <summary>Retrieve the coordinates of a given image object's selective (source image) load region.</summary>
103 /// <value>A region of the image.</value>
104 Eina.Rect LoadRegion {
108 /// <summary>Defines whether the orientation information in the image file should be honored.
109 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
110 /// <value><c>true</c> means that it should honor the orientation information.</value>
111 bool LoadOrientation {
115 /// <summary>The scale down factor is a divider on the original image size.
116 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
118 /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
120 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
121 /// <value>The scale down dividing factor.</value>
126 /// <summary>Initial load should skip header check and leave it all to data load
127 /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
128 /// <value>Will be true if header is to be skipped.</value>
129 bool LoadSkipHeader {
134 ///<summary>Event argument wrapper for event <see cref="Efl.Gfx.IImageLoadController.LoadErrorEvt"/>.</summary>
135 [Efl.Eo.BindingEntity]
136 public class IImageLoadControllerLoadErrorEvt_Args : EventArgs {
137 ///<summary>Actual event payload.</summary>
138 public Eina.Error arg { get; set; }
140 /// <summary>Common APIs for all loadable 2D images.</summary>
141 sealed public class IImageLoadControllerConcrete :
143 , IImageLoadController
146 ///<summary>Pointer to the native class description.</summary>
147 public override System.IntPtr NativeClass
151 if (((object)this).GetType() == typeof(IImageLoadControllerConcrete))
153 return GetEflClassStatic();
157 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
162 /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
163 /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
164 private IImageLoadControllerConcrete(ConstructingHandle ch) : base(ch)
168 [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
169 efl_gfx_image_load_controller_interface_get();
170 /// <summary>Initializes a new instance of the <see cref="IImageLoadController"/> class.
171 /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
172 /// <param name="wh">The native pointer to be wrapped.</param>
173 private IImageLoadControllerConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
177 /// <summary>Called when he image was loaded</summary>
178 public event EventHandler LoadDoneEvt
182 lock (eflBindingEventLock)
184 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
186 var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
189 EventArgs args = EventArgs.Empty;
192 value?.Invoke(obj, args);
196 Eina.Log.Error(e.ToString());
197 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
202 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
203 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
209 lock (eflBindingEventLock)
211 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
212 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
216 ///<summary>Method to raise event LoadDoneEvt.</summary>
217 public void OnLoadDoneEvt(EventArgs e)
219 var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
220 IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
221 if (desc == IntPtr.Zero)
223 Eina.Log.Error($"Failed to get native event {key}");
227 Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
229 /// <summary>Called when an error happened during image loading</summary>
230 public event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt
234 lock (eflBindingEventLock)
236 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
238 var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
241 Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args args = new Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args();
242 args.arg = (Eina.Error)Marshal.PtrToStructure(evt.Info, typeof(Eina.Error));
245 value?.Invoke(obj, args);
249 Eina.Log.Error(e.ToString());
250 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
255 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
256 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
262 lock (eflBindingEventLock)
264 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
265 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
269 ///<summary>Method to raise event LoadErrorEvt.</summary>
270 public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
272 var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
273 IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
274 if (desc == IntPtr.Zero)
276 Eina.Log.Error($"Failed to get native event {key}");
280 IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc((int)e.arg);
283 Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
287 Marshal.FreeHGlobal(info);
290 /// <summary>Returns the requested load size.</summary>
291 /// <returns>The image load size.</returns>
292 public Eina.Size2D GetLoadSize() {
293 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate(this.NativeHandle);
294 Eina.Error.RaiseIfUnhandledException();
297 /// <summary>Requests the canvas to load the image at the given size.
298 /// EFL will try to load an image of the requested size but does not guarantee an exact match between the request and the loaded image dimensions.</summary>
299 /// <param name="size">The image load size.</param>
300 public void SetLoadSize(Eina.Size2D size) {
301 Eina.Size2D.NativeStruct _in_size = size;
302 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate(this.NativeHandle,_in_size);
303 Eina.Error.RaiseIfUnhandledException();
305 /// <summary>Get the DPI resolution of a loaded image object in the canvas.
306 /// This function returns the DPI resolution of the given canvas image.</summary>
307 /// <returns>The DPI resolution.</returns>
308 public double GetLoadDpi() {
309 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate(this.NativeHandle);
310 Eina.Error.RaiseIfUnhandledException();
313 /// <summary>Set the DPI resolution of an image object's source image.
314 /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
315 /// <param name="dpi">The DPI resolution.</param>
316 public void SetLoadDpi(double dpi) {
317 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate(this.NativeHandle,dpi);
318 Eina.Error.RaiseIfUnhandledException();
320 /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
321 /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
322 public bool GetLoadRegionSupport() {
323 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate(this.NativeHandle);
324 Eina.Error.RaiseIfUnhandledException();
327 /// <summary>Retrieve the coordinates of a given image object's selective (source image) load region.</summary>
328 /// <returns>A region of the image.</returns>
329 public Eina.Rect GetLoadRegion() {
330 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate(this.NativeHandle);
331 Eina.Error.RaiseIfUnhandledException();
334 /// <summary>Inform a given image object to load a selective region of its source image.
335 /// This function is useful when one is not showing all of an image's area on its image object.
337 /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
338 /// <param name="region">A region of the image.</param>
339 public void SetLoadRegion(Eina.Rect region) {
340 Eina.Rect.NativeStruct _in_region = region;
341 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate(this.NativeHandle,_in_region);
342 Eina.Error.RaiseIfUnhandledException();
344 /// <summary>Defines whether the orientation information in the image file should be honored.
345 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
346 /// <returns><c>true</c> means that it should honor the orientation information.</returns>
347 public bool GetLoadOrientation() {
348 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate(this.NativeHandle);
349 Eina.Error.RaiseIfUnhandledException();
352 /// <summary>Defines whether the orientation information in the image file should be honored.
353 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
354 /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
355 public void SetLoadOrientation(bool enable) {
356 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate(this.NativeHandle,enable);
357 Eina.Error.RaiseIfUnhandledException();
359 /// <summary>The scale down factor is a divider on the original image size.
360 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
362 /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
364 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
365 /// <returns>The scale down dividing factor.</returns>
366 public int GetLoadScaleDown() {
367 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate(this.NativeHandle);
368 Eina.Error.RaiseIfUnhandledException();
371 /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
372 /// <param name="div">The scale down dividing factor.</param>
373 public void SetLoadScaleDown(int div) {
374 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate(this.NativeHandle,div);
375 Eina.Error.RaiseIfUnhandledException();
377 /// <summary>Initial load should skip header check and leave it all to data load
378 /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
379 /// <returns>Will be true if header is to be skipped.</returns>
380 public bool GetLoadSkipHeader() {
381 var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate(this.NativeHandle);
382 Eina.Error.RaiseIfUnhandledException();
385 /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
386 /// <param name="skip">Will be true if header is to be skipped.</param>
387 public void SetLoadSkipHeader(bool skip) {
388 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate(this.NativeHandle,skip);
389 Eina.Error.RaiseIfUnhandledException();
391 /// <summary>Begin preloading an image object's image data in the background.
392 /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
393 public void LoadAsyncStart() {
394 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(this.NativeHandle);
395 Eina.Error.RaiseIfUnhandledException();
397 /// <summary>Cancel preloading an image object's image data in the background.
398 /// The object should be left in a state where it has no image data. If cancel is called too late, the image will be kept in memory.</summary>
399 public void LoadAsyncCancel() {
400 Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(this.NativeHandle);
401 Eina.Error.RaiseIfUnhandledException();
403 /// <summary>The load size of an image.
404 /// The image will be loaded into memory as if it was the specified size instead of its original size. This can save a lot of memory and is important for scalable types like svg.
406 /// By default, the load size is not specified, so it is 0x0.</summary>
407 /// <value>The image load size.</value>
408 public Eina.Size2D LoadSize {
409 get { return GetLoadSize(); }
410 set { SetLoadSize(value); }
412 /// <summary>Get the DPI resolution of a loaded image object in the canvas.
413 /// This function returns the DPI resolution of the given canvas image.</summary>
414 /// <value>The DPI resolution.</value>
415 public double LoadDpi {
416 get { return GetLoadDpi(); }
417 set { SetLoadDpi(value); }
419 /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
420 /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
421 public bool LoadRegionSupport {
422 get { return GetLoadRegionSupport(); }
424 /// <summary>Retrieve the coordinates of a given image object's selective (source image) load region.</summary>
425 /// <value>A region of the image.</value>
426 public Eina.Rect LoadRegion {
427 get { return GetLoadRegion(); }
428 set { SetLoadRegion(value); }
430 /// <summary>Defines whether the orientation information in the image file should be honored.
431 /// The orientation can for instance be set in the EXIF tags of a JPEG image. If this flag is <c>false</c>, then the orientation will be ignored at load time, otherwise the image will be loaded with the proper orientation.</summary>
432 /// <value><c>true</c> means that it should honor the orientation information.</value>
433 public bool LoadOrientation {
434 get { return GetLoadOrientation(); }
435 set { SetLoadOrientation(value); }
437 /// <summary>The scale down factor is a divider on the original image size.
438 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
440 /// This function sets the scale down factor of a given canvas image. Most useful for the SVG image loader but also applies to JPEG, PNG and BMP.
442 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
443 /// <value>The scale down dividing factor.</value>
444 public int LoadScaleDown {
445 get { return GetLoadScaleDown(); }
446 set { SetLoadScaleDown(value); }
448 /// <summary>Initial load should skip header check and leave it all to data load
449 /// If this is true, then future loads of images will defer header loading to a preload stage and/or data load later on rather than at the start when the load begins (e.g. when file is set).</summary>
450 /// <value>Will be true if header is to be skipped.</value>
451 public bool LoadSkipHeader {
452 get { return GetLoadSkipHeader(); }
453 set { SetLoadSkipHeader(value); }
455 private static IntPtr GetEflClassStatic()
457 return Efl.Gfx.IImageLoadControllerConcrete.efl_gfx_image_load_controller_interface_get();
459 /// <summary>Wrapper for native methods and virtual method delegates.
460 /// For internal use by generated code only.</summary>
461 public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
463 private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule( efl.Libs.Efl);
464 /// <summary>Gets the list of Eo operations to override.</summary>
465 /// <returns>The list of Eo operations to be overload.</returns>
466 public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
468 var descs = new System.Collections.Generic.List<Efl_Op_Description>();
469 var methods = Efl.Eo.Globals.GetUserMethods(type);
471 if (efl_gfx_image_load_controller_load_size_get_static_delegate == null)
473 efl_gfx_image_load_controller_load_size_get_static_delegate = new efl_gfx_image_load_controller_load_size_get_delegate(load_size_get);
476 if (methods.FirstOrDefault(m => m.Name == "GetLoadSize") != null)
478 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_size_get_static_delegate) });
481 if (efl_gfx_image_load_controller_load_size_set_static_delegate == null)
483 efl_gfx_image_load_controller_load_size_set_static_delegate = new efl_gfx_image_load_controller_load_size_set_delegate(load_size_set);
486 if (methods.FirstOrDefault(m => m.Name == "SetLoadSize") != null)
488 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_size_set_static_delegate) });
491 if (efl_gfx_image_load_controller_load_dpi_get_static_delegate == null)
493 efl_gfx_image_load_controller_load_dpi_get_static_delegate = new efl_gfx_image_load_controller_load_dpi_get_delegate(load_dpi_get);
496 if (methods.FirstOrDefault(m => m.Name == "GetLoadDpi") != null)
498 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_dpi_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_dpi_get_static_delegate) });
501 if (efl_gfx_image_load_controller_load_dpi_set_static_delegate == null)
503 efl_gfx_image_load_controller_load_dpi_set_static_delegate = new efl_gfx_image_load_controller_load_dpi_set_delegate(load_dpi_set);
506 if (methods.FirstOrDefault(m => m.Name == "SetLoadDpi") != null)
508 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_dpi_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_dpi_set_static_delegate) });
511 if (efl_gfx_image_load_controller_load_region_support_get_static_delegate == null)
513 efl_gfx_image_load_controller_load_region_support_get_static_delegate = new efl_gfx_image_load_controller_load_region_support_get_delegate(load_region_support_get);
516 if (methods.FirstOrDefault(m => m.Name == "GetLoadRegionSupport") != null)
518 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_support_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_support_get_static_delegate) });
521 if (efl_gfx_image_load_controller_load_region_get_static_delegate == null)
523 efl_gfx_image_load_controller_load_region_get_static_delegate = new efl_gfx_image_load_controller_load_region_get_delegate(load_region_get);
526 if (methods.FirstOrDefault(m => m.Name == "GetLoadRegion") != null)
528 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_get_static_delegate) });
531 if (efl_gfx_image_load_controller_load_region_set_static_delegate == null)
533 efl_gfx_image_load_controller_load_region_set_static_delegate = new efl_gfx_image_load_controller_load_region_set_delegate(load_region_set);
536 if (methods.FirstOrDefault(m => m.Name == "SetLoadRegion") != null)
538 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_region_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_region_set_static_delegate) });
541 if (efl_gfx_image_load_controller_load_orientation_get_static_delegate == null)
543 efl_gfx_image_load_controller_load_orientation_get_static_delegate = new efl_gfx_image_load_controller_load_orientation_get_delegate(load_orientation_get);
546 if (methods.FirstOrDefault(m => m.Name == "GetLoadOrientation") != null)
548 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_orientation_get_static_delegate) });
551 if (efl_gfx_image_load_controller_load_orientation_set_static_delegate == null)
553 efl_gfx_image_load_controller_load_orientation_set_static_delegate = new efl_gfx_image_load_controller_load_orientation_set_delegate(load_orientation_set);
556 if (methods.FirstOrDefault(m => m.Name == "SetLoadOrientation") != null)
558 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_orientation_set_static_delegate) });
561 if (efl_gfx_image_load_controller_load_scale_down_get_static_delegate == null)
563 efl_gfx_image_load_controller_load_scale_down_get_static_delegate = new efl_gfx_image_load_controller_load_scale_down_get_delegate(load_scale_down_get);
566 if (methods.FirstOrDefault(m => m.Name == "GetLoadScaleDown") != null)
568 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_scale_down_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_scale_down_get_static_delegate) });
571 if (efl_gfx_image_load_controller_load_scale_down_set_static_delegate == null)
573 efl_gfx_image_load_controller_load_scale_down_set_static_delegate = new efl_gfx_image_load_controller_load_scale_down_set_delegate(load_scale_down_set);
576 if (methods.FirstOrDefault(m => m.Name == "SetLoadScaleDown") != null)
578 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_scale_down_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_scale_down_set_static_delegate) });
581 if (efl_gfx_image_load_controller_load_skip_header_get_static_delegate == null)
583 efl_gfx_image_load_controller_load_skip_header_get_static_delegate = new efl_gfx_image_load_controller_load_skip_header_get_delegate(load_skip_header_get);
586 if (methods.FirstOrDefault(m => m.Name == "GetLoadSkipHeader") != null)
588 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_skip_header_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_skip_header_get_static_delegate) });
591 if (efl_gfx_image_load_controller_load_skip_header_set_static_delegate == null)
593 efl_gfx_image_load_controller_load_skip_header_set_static_delegate = new efl_gfx_image_load_controller_load_skip_header_set_delegate(load_skip_header_set);
596 if (methods.FirstOrDefault(m => m.Name == "SetLoadSkipHeader") != null)
598 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_skip_header_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_skip_header_set_static_delegate) });
601 if (efl_gfx_image_load_controller_load_async_start_static_delegate == null)
603 efl_gfx_image_load_controller_load_async_start_static_delegate = new efl_gfx_image_load_controller_load_async_start_delegate(load_async_start);
606 if (methods.FirstOrDefault(m => m.Name == "LoadAsyncStart") != null)
608 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_async_start"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_async_start_static_delegate) });
611 if (efl_gfx_image_load_controller_load_async_cancel_static_delegate == null)
613 efl_gfx_image_load_controller_load_async_cancel_static_delegate = new efl_gfx_image_load_controller_load_async_cancel_delegate(load_async_cancel);
616 if (methods.FirstOrDefault(m => m.Name == "LoadAsyncCancel") != null)
618 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_controller_load_async_cancel"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_controller_load_async_cancel_static_delegate) });
623 /// <summary>Returns the Eo class for the native methods of this class.</summary>
624 /// <returns>The native class pointer.</returns>
625 public override IntPtr GetEflClass()
627 return Efl.Gfx.IImageLoadControllerConcrete.efl_gfx_image_load_controller_interface_get();
630 #pragma warning disable CA1707, CS1591, SA1300, SA1600
633 private delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
636 public delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_api_delegate(System.IntPtr obj);
638 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_get_api_delegate> efl_gfx_image_load_controller_load_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_size_get");
640 private static Eina.Size2D.NativeStruct load_size_get(System.IntPtr obj, System.IntPtr pd)
642 Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_get was called");
643 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
646 Eina.Size2D _ret_var = default(Eina.Size2D);
649 _ret_var = ((IImageLoadController)ws.Target).GetLoadSize();
653 Eina.Log.Warning($"Callback error: {e.ToString()}");
654 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
662 return efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
666 private static efl_gfx_image_load_controller_load_size_get_delegate efl_gfx_image_load_controller_load_size_get_static_delegate;
669 private delegate void efl_gfx_image_load_controller_load_size_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size);
672 public delegate void efl_gfx_image_load_controller_load_size_set_api_delegate(System.IntPtr obj, Eina.Size2D.NativeStruct size);
674 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_set_api_delegate> efl_gfx_image_load_controller_load_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_size_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_size_set");
676 private static void load_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
678 Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_set was called");
679 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
682 Eina.Size2D _in_size = size;
686 ((IImageLoadController)ws.Target).SetLoadSize(_in_size);
690 Eina.Log.Warning($"Callback error: {e.ToString()}");
691 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
698 efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
702 private static efl_gfx_image_load_controller_load_size_set_delegate efl_gfx_image_load_controller_load_size_set_static_delegate;
705 private delegate double efl_gfx_image_load_controller_load_dpi_get_delegate(System.IntPtr obj, System.IntPtr pd);
708 public delegate double efl_gfx_image_load_controller_load_dpi_get_api_delegate(System.IntPtr obj);
710 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_get_api_delegate> efl_gfx_image_load_controller_load_dpi_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_dpi_get");
712 private static double load_dpi_get(System.IntPtr obj, System.IntPtr pd)
714 Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_get was called");
715 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
718 double _ret_var = default(double);
721 _ret_var = ((IImageLoadController)ws.Target).GetLoadDpi();
725 Eina.Log.Warning($"Callback error: {e.ToString()}");
726 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
734 return efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
738 private static efl_gfx_image_load_controller_load_dpi_get_delegate efl_gfx_image_load_controller_load_dpi_get_static_delegate;
741 private delegate void efl_gfx_image_load_controller_load_dpi_set_delegate(System.IntPtr obj, System.IntPtr pd, double dpi);
744 public delegate void efl_gfx_image_load_controller_load_dpi_set_api_delegate(System.IntPtr obj, double dpi);
746 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_set_api_delegate> efl_gfx_image_load_controller_load_dpi_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_dpi_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_dpi_set");
748 private static void load_dpi_set(System.IntPtr obj, System.IntPtr pd, double dpi)
750 Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_set was called");
751 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
757 ((IImageLoadController)ws.Target).SetLoadDpi(dpi);
761 Eina.Log.Warning($"Callback error: {e.ToString()}");
762 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
769 efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dpi);
773 private static efl_gfx_image_load_controller_load_dpi_set_delegate efl_gfx_image_load_controller_load_dpi_set_static_delegate;
775 [return: MarshalAs(UnmanagedType.U1)]
776 private delegate bool efl_gfx_image_load_controller_load_region_support_get_delegate(System.IntPtr obj, System.IntPtr pd);
778 [return: MarshalAs(UnmanagedType.U1)]
779 public delegate bool efl_gfx_image_load_controller_load_region_support_get_api_delegate(System.IntPtr obj);
781 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_support_get_api_delegate> efl_gfx_image_load_controller_load_region_support_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_support_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_support_get");
783 private static bool load_region_support_get(System.IntPtr obj, System.IntPtr pd)
785 Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_support_get was called");
786 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
789 bool _ret_var = default(bool);
792 _ret_var = ((IImageLoadController)ws.Target).GetLoadRegionSupport();
796 Eina.Log.Warning($"Callback error: {e.ToString()}");
797 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
805 return efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
809 private static efl_gfx_image_load_controller_load_region_support_get_delegate efl_gfx_image_load_controller_load_region_support_get_static_delegate;
812 private delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
815 public delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_api_delegate(System.IntPtr obj);
817 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_get_api_delegate> efl_gfx_image_load_controller_load_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_get");
819 private static Eina.Rect.NativeStruct load_region_get(System.IntPtr obj, System.IntPtr pd)
821 Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_get was called");
822 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
825 Eina.Rect _ret_var = default(Eina.Rect);
828 _ret_var = ((IImageLoadController)ws.Target).GetLoadRegion();
832 Eina.Log.Warning($"Callback error: {e.ToString()}");
833 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
841 return efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
845 private static efl_gfx_image_load_controller_load_region_get_delegate efl_gfx_image_load_controller_load_region_get_static_delegate;
848 private delegate void efl_gfx_image_load_controller_load_region_set_delegate(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct region);
851 public delegate void efl_gfx_image_load_controller_load_region_set_api_delegate(System.IntPtr obj, Eina.Rect.NativeStruct region);
853 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_set_api_delegate> efl_gfx_image_load_controller_load_region_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_region_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_region_set");
855 private static void load_region_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct region)
857 Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_set was called");
858 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
861 Eina.Rect _in_region = region;
865 ((IImageLoadController)ws.Target).SetLoadRegion(_in_region);
869 Eina.Log.Warning($"Callback error: {e.ToString()}");
870 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
877 efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), region);
881 private static efl_gfx_image_load_controller_load_region_set_delegate efl_gfx_image_load_controller_load_region_set_static_delegate;
883 [return: MarshalAs(UnmanagedType.U1)]
884 private delegate bool efl_gfx_image_load_controller_load_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
886 [return: MarshalAs(UnmanagedType.U1)]
887 public delegate bool efl_gfx_image_load_controller_load_orientation_get_api_delegate(System.IntPtr obj);
889 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_get_api_delegate> efl_gfx_image_load_controller_load_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_orientation_get");
891 private static bool load_orientation_get(System.IntPtr obj, System.IntPtr pd)
893 Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_get was called");
894 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
897 bool _ret_var = default(bool);
900 _ret_var = ((IImageLoadController)ws.Target).GetLoadOrientation();
904 Eina.Log.Warning($"Callback error: {e.ToString()}");
905 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
913 return efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
917 private static efl_gfx_image_load_controller_load_orientation_get_delegate efl_gfx_image_load_controller_load_orientation_get_static_delegate;
920 private delegate void efl_gfx_image_load_controller_load_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enable);
923 public delegate void efl_gfx_image_load_controller_load_orientation_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enable);
925 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_set_api_delegate> efl_gfx_image_load_controller_load_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_orientation_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_orientation_set");
927 private static void load_orientation_set(System.IntPtr obj, System.IntPtr pd, bool enable)
929 Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_set was called");
930 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
936 ((IImageLoadController)ws.Target).SetLoadOrientation(enable);
940 Eina.Log.Warning($"Callback error: {e.ToString()}");
941 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
948 efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), enable);
952 private static efl_gfx_image_load_controller_load_orientation_set_delegate efl_gfx_image_load_controller_load_orientation_set_static_delegate;
955 private delegate int efl_gfx_image_load_controller_load_scale_down_get_delegate(System.IntPtr obj, System.IntPtr pd);
958 public delegate int efl_gfx_image_load_controller_load_scale_down_get_api_delegate(System.IntPtr obj);
960 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_get_api_delegate> efl_gfx_image_load_controller_load_scale_down_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_scale_down_get");
962 private static int load_scale_down_get(System.IntPtr obj, System.IntPtr pd)
964 Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_get was called");
965 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
968 int _ret_var = default(int);
971 _ret_var = ((IImageLoadController)ws.Target).GetLoadScaleDown();
975 Eina.Log.Warning($"Callback error: {e.ToString()}");
976 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
984 return efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
988 private static efl_gfx_image_load_controller_load_scale_down_get_delegate efl_gfx_image_load_controller_load_scale_down_get_static_delegate;
991 private delegate void efl_gfx_image_load_controller_load_scale_down_set_delegate(System.IntPtr obj, System.IntPtr pd, int div);
994 public delegate void efl_gfx_image_load_controller_load_scale_down_set_api_delegate(System.IntPtr obj, int div);
996 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_set_api_delegate> efl_gfx_image_load_controller_load_scale_down_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_scale_down_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_scale_down_set");
998 private static void load_scale_down_set(System.IntPtr obj, System.IntPtr pd, int div)
1000 Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_set was called");
1001 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1007 ((IImageLoadController)ws.Target).SetLoadScaleDown(div);
1011 Eina.Log.Warning($"Callback error: {e.ToString()}");
1012 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1019 efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), div);
1023 private static efl_gfx_image_load_controller_load_scale_down_set_delegate efl_gfx_image_load_controller_load_scale_down_set_static_delegate;
1025 [return: MarshalAs(UnmanagedType.U1)]
1026 private delegate bool efl_gfx_image_load_controller_load_skip_header_get_delegate(System.IntPtr obj, System.IntPtr pd);
1028 [return: MarshalAs(UnmanagedType.U1)]
1029 public delegate bool efl_gfx_image_load_controller_load_skip_header_get_api_delegate(System.IntPtr obj);
1031 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_get_api_delegate> efl_gfx_image_load_controller_load_skip_header_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_get_api_delegate>(Module, "efl_gfx_image_load_controller_load_skip_header_get");
1033 private static bool load_skip_header_get(System.IntPtr obj, System.IntPtr pd)
1035 Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_get was called");
1036 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1039 bool _ret_var = default(bool);
1042 _ret_var = ((IImageLoadController)ws.Target).GetLoadSkipHeader();
1046 Eina.Log.Warning($"Callback error: {e.ToString()}");
1047 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1055 return efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1059 private static efl_gfx_image_load_controller_load_skip_header_get_delegate efl_gfx_image_load_controller_load_skip_header_get_static_delegate;
1062 private delegate void efl_gfx_image_load_controller_load_skip_header_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool skip);
1065 public delegate void efl_gfx_image_load_controller_load_skip_header_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool skip);
1067 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_set_api_delegate> efl_gfx_image_load_controller_load_skip_header_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_skip_header_set_api_delegate>(Module, "efl_gfx_image_load_controller_load_skip_header_set");
1069 private static void load_skip_header_set(System.IntPtr obj, System.IntPtr pd, bool skip)
1071 Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_set was called");
1072 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1078 ((IImageLoadController)ws.Target).SetLoadSkipHeader(skip);
1082 Eina.Log.Warning($"Callback error: {e.ToString()}");
1083 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1090 efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), skip);
1094 private static efl_gfx_image_load_controller_load_skip_header_set_delegate efl_gfx_image_load_controller_load_skip_header_set_static_delegate;
1097 private delegate void efl_gfx_image_load_controller_load_async_start_delegate(System.IntPtr obj, System.IntPtr pd);
1100 public delegate void efl_gfx_image_load_controller_load_async_start_api_delegate(System.IntPtr obj);
1102 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_start_api_delegate> efl_gfx_image_load_controller_load_async_start_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_start_api_delegate>(Module, "efl_gfx_image_load_controller_load_async_start");
1104 private static void load_async_start(System.IntPtr obj, System.IntPtr pd)
1106 Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_start was called");
1107 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1113 ((IImageLoadController)ws.Target).LoadAsyncStart();
1117 Eina.Log.Warning($"Callback error: {e.ToString()}");
1118 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1125 efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1129 private static efl_gfx_image_load_controller_load_async_start_delegate efl_gfx_image_load_controller_load_async_start_static_delegate;
1132 private delegate void efl_gfx_image_load_controller_load_async_cancel_delegate(System.IntPtr obj, System.IntPtr pd);
1135 public delegate void efl_gfx_image_load_controller_load_async_cancel_api_delegate(System.IntPtr obj);
1137 public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_cancel_api_delegate> efl_gfx_image_load_controller_load_async_cancel_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_controller_load_async_cancel_api_delegate>(Module, "efl_gfx_image_load_controller_load_async_cancel");
1139 private static void load_async_cancel(System.IntPtr obj, System.IntPtr pd)
1141 Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_cancel was called");
1142 var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1148 ((IImageLoadController)ws.Target).LoadAsyncCancel();
1152 Eina.Log.Warning($"Callback error: {e.ToString()}");
1153 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1160 efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1164 private static efl_gfx_image_load_controller_load_async_cancel_delegate efl_gfx_image_load_controller_load_async_cancel_static_delegate;
1166 #pragma warning restore CA1707, CS1591, SA1300, SA1600