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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 /// <summary>Low-level Image object.
  13 /// This replaces the legacy Evas Object Image, with only image-related interfaces: file and data images only. This object does not implement any special features such as proxy, snapshot or GL.</summary>
  14 [Efl.Canvas.Image.NativeMethods]
  15 public class Image : Efl.Canvas.ImageInternal, Efl.IFile, Efl.Gfx.IFrameController, Efl.Gfx.IImageLoadController
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(Image))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  34         efl_canvas_image_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="Image"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     public Image(Efl.Object parent= null
  38             ) : base(efl_canvas_image_class_get(), typeof(Image), parent)
  39     {
  40         FinishInstantiation();
  41     }
  42
  43     /// <summary>Initializes a new instance of the <see cref="Image"/> class.
  44     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  45     /// <param name="raw">The native pointer to be wrapped.</param>
  46     protected Image(System.IntPtr raw) : base(raw)
  47     {
  48     }
  49
  50     /// <summary>Initializes a new instance of the <see cref="Image"/> class.
  51     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  52     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  53     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  54     /// <param name="parent">The Efl.Object parent of this instance.</param>
  55     protected Image(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  56     {
  57     }
  58
  59     /// <summary>Called when he image was loaded</summary>
  60     public event EventHandler LoadDoneEvt
  61     {
  62         add
  63         {
  64             lock (eventLock)
  65             {
  66                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  67                 {
  68                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  69                     if (obj != null)
  70                     {
  71                         EventArgs args = EventArgs.Empty;
  72                         try
  73                         {
  74                             value?.Invoke(obj, args);
  75                         }
  76                         catch (Exception e)
  77                         {
  78                             Eina.Log.Error(e.ToString());
  79                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  80                         }
  81                     }
  82                 };
  83
  84                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
  85                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
  86             }
  87         }
  88
  89         remove
  90         {
  91             lock (eventLock)
  92             {
  93                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
  94                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
  95             }
  96         }
  97     }
  98     ///<summary>Method to raise event LoadDoneEvt.</summary>
  99     public void OnLoadDoneEvt(EventArgs e)
 100     {
 101         var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
 102         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 103         if (desc == IntPtr.Zero)
 104         {
 105             Eina.Log.Error($"Failed to get native event {key}");
 106             return;
 107         }
 108
 109         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 110     }
 111     /// <summary>Called when an error happened during image loading</summary>
 112     public event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt
 113     {
 114         add
 115         {
 116             lock (eventLock)
 117             {
 118                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 119                 {
 120                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 121                     if (obj != null)
 122                     {
 123                         Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args args = new Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args();
 124                         args.arg = (Eina.Error)Marshal.PtrToStructure(evt.Info, typeof(Eina.Error));
 125                         try
 126                         {
 127                             value?.Invoke(obj, args);
 128                         }
 129                         catch (Exception e)
 130                         {
 131                             Eina.Log.Error(e.ToString());
 132                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 133                         }
 134                     }
 135                 };
 136
 137                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 138                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 139             }
 140         }
 141
 142         remove
 143         {
 144             lock (eventLock)
 145             {
 146                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 147                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 148             }
 149         }
 150     }
 151     ///<summary>Method to raise event LoadErrorEvt.</summary>
 152     public void OnLoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
 153     {
 154         var key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 155         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 156         if (desc == IntPtr.Zero)
 157         {
 158             Eina.Log.Error($"Failed to get native event {key}");
 159             return;
 160         }
 161
 162         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc((int)e.arg);
 163         try
 164         {
 165             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 166         }
 167         finally
 168         {
 169             Marshal.FreeHGlobal(info);
 170         }
 171     }
 172     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 173     /// (Since EFL 1.22)</summary>
 174     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 175     virtual public Eina.File GetMmap() {
 176          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 177         Eina.Error.RaiseIfUnhandledException();
 178         return _ret_var;
 179  }
 180     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 181     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 182     /// (Since EFL 1.22)</summary>
 183     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 184     /// <returns>0 on success, error code otherwise</returns>
 185     virtual public Eina.Error SetMmap(Eina.File f) {
 186                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),f);
 187         Eina.Error.RaiseIfUnhandledException();
 188                         return _ret_var;
 189  }
 190     /// <summary>Retrieve the file path from where an object is to fetch the data.
 191     /// You must not modify the strings on the returned pointers.
 192     /// (Since EFL 1.22)</summary>
 193     /// <returns>The file path.</returns>
 194     virtual public System.String GetFile() {
 195          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 196         Eina.Error.RaiseIfUnhandledException();
 197         return _ret_var;
 198  }
 199     /// <summary>Set the file path from where an object will fetch the data.
 200     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 201     /// (Since EFL 1.22)</summary>
 202     /// <param name="file">The file path.</param>
 203     /// <returns>0 on success, error code otherwise</returns>
 204     virtual public Eina.Error SetFile(System.String file) {
 205                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),file);
 206         Eina.Error.RaiseIfUnhandledException();
 207                         return _ret_var;
 208  }
 209     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 210     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 211     ///
 212     /// You must not modify the strings on the returned pointers.
 213     /// (Since EFL 1.22)</summary>
 214     /// <returns>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</returns>
 215     virtual public System.String GetKey() {
 216          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_key_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 217         Eina.Error.RaiseIfUnhandledException();
 218         return _ret_var;
 219  }
 220     /// <summary>Set the key which corresponds to the target data within a file.
 221     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 222     /// (Since EFL 1.22)</summary>
 223     /// <param name="key">The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</param>
 224     virtual public void SetKey(System.String key) {
 225                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),key);
 226         Eina.Error.RaiseIfUnhandledException();
 227                          }
 228     /// <summary>Get the load state of the object.
 229     /// (Since EFL 1.22)</summary>
 230     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 231     virtual public bool GetLoaded() {
 232          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_loaded_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 233         Eina.Error.RaiseIfUnhandledException();
 234         return _ret_var;
 235  }
 236     /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.IFile.File"/> (or <see cref="Efl.IFile.Mmap"/>) and <see cref="Efl.IFile.Key"/> properties.
 237     /// In the case where <see cref="Efl.IFile.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.IFile.SetMmap"/> on the object using the opened file handle.
 238     ///
 239     /// Calling <see cref="Efl.IFile.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.
 240     /// (Since EFL 1.22)</summary>
 241     /// <returns>0 on success, error code otherwise</returns>
 242     virtual public Eina.Error Load() {
 243          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 244         Eina.Error.RaiseIfUnhandledException();
 245         return _ret_var;
 246  }
 247     /// <summary>Perform all necessary operations to unload file data from the object.
 248     /// In the case where <see cref="Efl.IFile.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
 249     ///
 250     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 251     /// (Since EFL 1.22)</summary>
 252     virtual public void Unload() {
 253          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 254         Eina.Error.RaiseIfUnhandledException();
 255          }
 256     /// <summary>Check if an object can be animated (has multiple frames).
 257     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 258     /// <returns><c>true</c> if the object is animated</returns>
 259     virtual public bool GetAnimated() {
 260          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_animated_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 261         Eina.Error.RaiseIfUnhandledException();
 262         return _ret_var;
 263  }
 264     /// <summary>Index of the current frame of an animated object.
 265     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 266     /// <returns>The index of current frame.</returns>
 267     virtual public int GetFrame() {
 268          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 269         Eina.Error.RaiseIfUnhandledException();
 270         return _ret_var;
 271  }
 272     /// <summary>Set the frame to current frame of an animated object.</summary>
 273     /// <param name="frame_index">The index of current frame.</param>
 274     /// <returns>Returns <c>true</c> if the frame index is valid.</returns>
 275     virtual public bool SetFrame(int frame_index) {
 276                                  var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),frame_index);
 277         Eina.Error.RaiseIfUnhandledException();
 278                         return _ret_var;
 279  }
 280     /// <summary>Get the total number of frames of the object, if animated.
 281     /// Returns -1 if not animated.</summary>
 282     /// <returns>The number of frames in the animated object.</returns>
 283     virtual public int GetFrameCount() {
 284          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 285         Eina.Error.RaiseIfUnhandledException();
 286         return _ret_var;
 287  }
 288     /// <summary>Get the kind of looping the animated object does.
 289     /// This returns the kind of looping the animated object wants to do.
 290     ///
 291     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
 292     ///
 293     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
 294     ///
 295     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 296     /// <returns>Loop type of the animated object.</returns>
 297     virtual public Efl.Gfx.FrameControllerLoopHint GetLoopType() {
 298          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 299         Eina.Error.RaiseIfUnhandledException();
 300         return _ret_var;
 301  }
 302     /// <summary>Get the number times the animation of the object loops.
 303     /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
 304     ///
 305     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 306     /// <returns>The number of loop of an animated object.</returns>
 307     virtual public int GetLoopCount() {
 308          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 309         Eina.Error.RaiseIfUnhandledException();
 310         return _ret_var;
 311  }
 312     /// <summary>Get the duration of a sequence of frames.
 313     /// This returns total duration in seconds that the specified sequence of frames should take.
 314     ///
 315     /// If <c>start_frame</c> is 1 and <c>frame_num</c> is 0, this returns the duration of frame 1. If <c>start_frame</c> is 1 and <c>frame_num</c> is 1, this returns the total duration of frame 1 + frame 2.</summary>
 316     /// <param name="start_frame">The first frame, rangers from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>.</param>
 317     /// <param name="frame_num">Number of frames in the sequence, starts from 0.</param>
 318     /// <returns>Duration in seconds</returns>
 319     virtual public double GetFrameDuration(int start_frame, int frame_num) {
 320                                                          var _ret_var = Efl.Gfx.IFrameControllerConcrete.NativeMethods.efl_gfx_frame_controller_frame_duration_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),start_frame, frame_num);
 321         Eina.Error.RaiseIfUnhandledException();
 322                                         return _ret_var;
 323  }
 324     /// <summary>Returns the requested load size.</summary>
 325     /// <returns>The image load size.</returns>
 326     virtual public Eina.Size2D GetLoadSize() {
 327          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 328         Eina.Error.RaiseIfUnhandledException();
 329         return _ret_var;
 330  }
 331     /// <summary>Requests the canvas to load the image at the given size.
 332     /// 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>
 333     /// <param name="size">The image load size.</param>
 334     virtual public void SetLoadSize(Eina.Size2D size) {
 335          Eina.Size2D.NativeStruct _in_size = size;
 336                         Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_size);
 337         Eina.Error.RaiseIfUnhandledException();
 338                          }
 339     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 340     /// This function returns the DPI resolution of the given canvas image.</summary>
 341     /// <returns>The DPI resolution.</returns>
 342     virtual public double GetLoadDpi() {
 343          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 344         Eina.Error.RaiseIfUnhandledException();
 345         return _ret_var;
 346  }
 347     /// <summary>Set the DPI resolution of an image object&apos;s source image.
 348     /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
 349     /// <param name="dpi">The DPI resolution.</param>
 350     virtual public void SetLoadDpi(double dpi) {
 351                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),dpi);
 352         Eina.Error.RaiseIfUnhandledException();
 353                          }
 354     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 355     /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
 356     virtual public bool GetLoadRegionSupport() {
 357          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 358         Eina.Error.RaiseIfUnhandledException();
 359         return _ret_var;
 360  }
 361     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 362     /// <returns>A region of the image.</returns>
 363     virtual public Eina.Rect GetLoadRegion() {
 364          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 365         Eina.Error.RaiseIfUnhandledException();
 366         return _ret_var;
 367  }
 368     /// <summary>Inform a given image object to load a selective region of its source image.
 369     /// This function is useful when one is not showing all of an image&apos;s area on its image object.
 370     ///
 371     /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
 372     /// <param name="region">A region of the image.</param>
 373     virtual public void SetLoadRegion(Eina.Rect region) {
 374          Eina.Rect.NativeStruct _in_region = region;
 375                         Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_region_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),_in_region);
 376         Eina.Error.RaiseIfUnhandledException();
 377                          }
 378     /// <summary>Defines whether the orientation information in the image file should be honored.
 379     /// 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>
 380     /// <returns><c>true</c> means that it should honor the orientation information.</returns>
 381     virtual public bool GetLoadOrientation() {
 382          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 383         Eina.Error.RaiseIfUnhandledException();
 384         return _ret_var;
 385  }
 386     /// <summary>Defines whether the orientation information in the image file should be honored.
 387     /// 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>
 388     /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
 389     virtual public void SetLoadOrientation(bool enable) {
 390                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),enable);
 391         Eina.Error.RaiseIfUnhandledException();
 392                          }
 393     /// <summary>The scale down factor is a divider on the original image size.
 394     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 395     ///
 396     /// 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.
 397     ///
 398     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 399     /// <returns>The scale down dividing factor.</returns>
 400     virtual public int GetLoadScaleDown() {
 401          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 402         Eina.Error.RaiseIfUnhandledException();
 403         return _ret_var;
 404  }
 405     /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
 406     /// <param name="div">The scale down dividing factor.</param>
 407     virtual public void SetLoadScaleDown(int div) {
 408                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_scale_down_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),div);
 409         Eina.Error.RaiseIfUnhandledException();
 410                          }
 411     /// <summary>Initial load should skip header check and leave it all to data load
 412     /// 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>
 413     /// <returns>Will be true if header is to be skipped.</returns>
 414     virtual public bool GetLoadSkipHeader() {
 415          var _ret_var = Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 416         Eina.Error.RaiseIfUnhandledException();
 417         return _ret_var;
 418  }
 419     /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
 420     /// <param name="skip">Will be true if header is to be skipped.</param>
 421     virtual public void SetLoadSkipHeader(bool skip) {
 422                                  Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_skip_header_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),skip);
 423         Eina.Error.RaiseIfUnhandledException();
 424                          }
 425     /// <summary>Begin preloading an image object&apos;s image data in the background.
 426     /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
 427     virtual public void LoadAsyncStart() {
 428          Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 429         Eina.Error.RaiseIfUnhandledException();
 430          }
 431     /// <summary>Cancel preloading an image object&apos;s image data in the background.
 432     /// 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>
 433     virtual public void LoadAsyncCancel() {
 434          Efl.Gfx.IImageLoadControllerConcrete.NativeMethods.efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 435         Eina.Error.RaiseIfUnhandledException();
 436          }
 437     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 438     /// (Since EFL 1.22)</summary>
 439     /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 440     public Eina.File Mmap {
 441         get { return GetMmap(); }
 442         set { SetMmap(value); }
 443     }
 444     /// <summary>Retrieve the file path from where an object is to fetch the data.
 445     /// You must not modify the strings on the returned pointers.
 446     /// (Since EFL 1.22)</summary>
 447     /// <value>The file path.</value>
 448     public System.String File {
 449         get { return GetFile(); }
 450         set { SetFile(value); }
 451     }
 452     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 453     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 454     ///
 455     /// You must not modify the strings on the returned pointers.
 456     /// (Since EFL 1.22)</summary>
 457     /// <value>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</value>
 458     public System.String Key {
 459         get { return GetKey(); }
 460         set { SetKey(value); }
 461     }
 462     /// <summary>Get the load state of the object.
 463     /// (Since EFL 1.22)</summary>
 464     /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 465     public bool Loaded {
 466         get { return GetLoaded(); }
 467     }
 468     /// <summary>Check if an object can be animated (has multiple frames).
 469     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 470     /// <value><c>true</c> if the object is animated</value>
 471     public bool Animated {
 472         get { return GetAnimated(); }
 473     }
 474     /// <summary>Index of the current frame of an animated object.
 475     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 476     /// <value>The index of current frame.</value>
 477     public int Frame {
 478         get { return GetFrame(); }
 479         set { SetFrame(value); }
 480     }
 481     /// <summary>Get the total number of frames of the object, if animated.
 482     /// Returns -1 if not animated.</summary>
 483     /// <value>The number of frames in the animated object.</value>
 484     public int FrameCount {
 485         get { return GetFrameCount(); }
 486     }
 487     /// <summary>Get the kind of looping the animated object does.
 488     /// This returns the kind of looping the animated object wants to do.
 489     ///
 490     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>, you should display frames in a sequence like: 1-&gt;2-&gt;3-&gt;1-&gt;2-&gt;3-&gt;1...
 491     ///
 492     /// If it returns <see cref="Efl.Gfx.FrameControllerLoopHint.Pingpong"/>, it is better to display frames in a sequence like: 1-&gt;2-&gt;3-&gt;2-&gt;1-&gt;2-&gt;3-&gt;1...
 493     ///
 494     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 495     /// <value>Loop type of the animated object.</value>
 496     public Efl.Gfx.FrameControllerLoopHint LoopType {
 497         get { return GetLoopType(); }
 498     }
 499     /// <summary>Get the number times the animation of the object loops.
 500     /// This returns loop count of animated object. The loop count is the number of times the animation will play fully from first to last frame until the animation should stop (at the final frame).
 501     ///
 502     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 503     /// <value>The number of loop of an animated object.</value>
 504     public int LoopCount {
 505         get { return GetLoopCount(); }
 506     }
 507     /// <summary>The load size of an image.
 508     /// 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.
 509     ///
 510     /// By default, the load size is not specified, so it is 0x0.</summary>
 511     /// <value>The image load size.</value>
 512     public Eina.Size2D LoadSize {
 513         get { return GetLoadSize(); }
 514         set { SetLoadSize(value); }
 515     }
 516     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 517     /// This function returns the DPI resolution of the given canvas image.</summary>
 518     /// <value>The DPI resolution.</value>
 519     public double LoadDpi {
 520         get { return GetLoadDpi(); }
 521         set { SetLoadDpi(value); }
 522     }
 523     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 524     /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
 525     public bool LoadRegionSupport {
 526         get { return GetLoadRegionSupport(); }
 527     }
 528     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 529     /// <value>A region of the image.</value>
 530     public Eina.Rect LoadRegion {
 531         get { return GetLoadRegion(); }
 532         set { SetLoadRegion(value); }
 533     }
 534     /// <summary>Defines whether the orientation information in the image file should be honored.
 535     /// 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>
 536     /// <value><c>true</c> means that it should honor the orientation information.</value>
 537     public bool LoadOrientation {
 538         get { return GetLoadOrientation(); }
 539         set { SetLoadOrientation(value); }
 540     }
 541     /// <summary>The scale down factor is a divider on the original image size.
 542     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 543     ///
 544     /// 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.
 545     ///
 546     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 547     /// <value>The scale down dividing factor.</value>
 548     public int LoadScaleDown {
 549         get { return GetLoadScaleDown(); }
 550         set { SetLoadScaleDown(value); }
 551     }
 552     /// <summary>Initial load should skip header check and leave it all to data load
 553     /// 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>
 554     /// <value>Will be true if header is to be skipped.</value>
 555     public bool LoadSkipHeader {
 556         get { return GetLoadSkipHeader(); }
 557         set { SetLoadSkipHeader(value); }
 558     }
 559     private static IntPtr GetEflClassStatic()
 560     {
 561         return Efl.Canvas.Image.efl_canvas_image_class_get();
 562     }
 563     /// <summary>Wrapper for native methods and virtual method delegates.
 564     /// For internal use by generated code only.</summary>
 565     public new class NativeMethods : Efl.Canvas.ImageInternal.NativeMethods
 566     {
 567         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 568         /// <summary>Gets the list of Eo operations to override.</summary>
 569         /// <returns>The list of Eo operations to be overload.</returns>
 570         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 571         {
 572             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 573             var methods = Efl.Eo.Globals.GetUserMethods(type);
 574
 575             if (efl_file_mmap_get_static_delegate == null)
 576             {
 577                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 578             }
 579
 580             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 581             {
 582                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_get_static_delegate) });
 583             }
 584
 585             if (efl_file_mmap_set_static_delegate == null)
 586             {
 587                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 588             }
 589
 590             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 591             {
 592                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_set_static_delegate) });
 593             }
 594
 595             if (efl_file_get_static_delegate == null)
 596             {
 597                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 598             }
 599
 600             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 601             {
 602                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_get_static_delegate) });
 603             }
 604
 605             if (efl_file_set_static_delegate == null)
 606             {
 607                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 608             }
 609
 610             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 611             {
 612                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_set_static_delegate) });
 613             }
 614
 615             if (efl_file_key_get_static_delegate == null)
 616             {
 617                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 618             }
 619
 620             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 621             {
 622                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_get_static_delegate) });
 623             }
 624
 625             if (efl_file_key_set_static_delegate == null)
 626             {
 627                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 628             }
 629
 630             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 631             {
 632                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_set_static_delegate) });
 633             }
 634
 635             if (efl_file_loaded_get_static_delegate == null)
 636             {
 637                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 638             }
 639
 640             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 641             {
 642                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_loaded_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_loaded_get_static_delegate) });
 643             }
 644
 645             if (efl_file_load_static_delegate == null)
 646             {
 647                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 648             }
 649
 650             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 651             {
 652                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_load"), func = Marshal.GetFunctionPointerForDelegate(efl_file_load_static_delegate) });
 653             }
 654
 655             if (efl_file_unload_static_delegate == null)
 656             {
 657                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 658             }
 659
 660             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 661             {
 662                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_unload"), func = Marshal.GetFunctionPointerForDelegate(efl_file_unload_static_delegate) });
 663             }
 664
 665             if (efl_gfx_frame_controller_animated_get_static_delegate == null)
 666             {
 667                 efl_gfx_frame_controller_animated_get_static_delegate = new efl_gfx_frame_controller_animated_get_delegate(animated_get);
 668             }
 669
 670             if (methods.FirstOrDefault(m => m.Name == "GetAnimated") != null)
 671             {
 672                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_animated_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_animated_get_static_delegate) });
 673             }
 674
 675             if (efl_gfx_frame_controller_frame_get_static_delegate == null)
 676             {
 677                 efl_gfx_frame_controller_frame_get_static_delegate = new efl_gfx_frame_controller_frame_get_delegate(frame_get);
 678             }
 679
 680             if (methods.FirstOrDefault(m => m.Name == "GetFrame") != null)
 681             {
 682                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_get_static_delegate) });
 683             }
 684
 685             if (efl_gfx_frame_controller_frame_set_static_delegate == null)
 686             {
 687                 efl_gfx_frame_controller_frame_set_static_delegate = new efl_gfx_frame_controller_frame_set_delegate(frame_set);
 688             }
 689
 690             if (methods.FirstOrDefault(m => m.Name == "SetFrame") != null)
 691             {
 692                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_set_static_delegate) });
 693             }
 694
 695             if (efl_gfx_frame_controller_frame_count_get_static_delegate == null)
 696             {
 697                 efl_gfx_frame_controller_frame_count_get_static_delegate = new efl_gfx_frame_controller_frame_count_get_delegate(frame_count_get);
 698             }
 699
 700             if (methods.FirstOrDefault(m => m.Name == "GetFrameCount") != null)
 701             {
 702                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_count_get_static_delegate) });
 703             }
 704
 705             if (efl_gfx_frame_controller_loop_type_get_static_delegate == null)
 706             {
 707                 efl_gfx_frame_controller_loop_type_get_static_delegate = new efl_gfx_frame_controller_loop_type_get_delegate(loop_type_get);
 708             }
 709
 710             if (methods.FirstOrDefault(m => m.Name == "GetLoopType") != null)
 711             {
 712                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_loop_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_loop_type_get_static_delegate) });
 713             }
 714
 715             if (efl_gfx_frame_controller_loop_count_get_static_delegate == null)
 716             {
 717                 efl_gfx_frame_controller_loop_count_get_static_delegate = new efl_gfx_frame_controller_loop_count_get_delegate(loop_count_get);
 718             }
 719
 720             if (methods.FirstOrDefault(m => m.Name == "GetLoopCount") != null)
 721             {
 722                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_loop_count_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_loop_count_get_static_delegate) });
 723             }
 724
 725             if (efl_gfx_frame_controller_frame_duration_get_static_delegate == null)
 726             {
 727                 efl_gfx_frame_controller_frame_duration_get_static_delegate = new efl_gfx_frame_controller_frame_duration_get_delegate(frame_duration_get);
 728             }
 729
 730             if (methods.FirstOrDefault(m => m.Name == "GetFrameDuration") != null)
 731             {
 732                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_frame_controller_frame_duration_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_frame_controller_frame_duration_get_static_delegate) });
 733             }
 734
 735             if (efl_gfx_image_load_controller_load_size_get_static_delegate == null)
 736             {
 737                 efl_gfx_image_load_controller_load_size_get_static_delegate = new efl_gfx_image_load_controller_load_size_get_delegate(load_size_get);
 738             }
 739
 740             if (methods.FirstOrDefault(m => m.Name == "GetLoadSize") != null)
 741             {
 742                 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) });
 743             }
 744
 745             if (efl_gfx_image_load_controller_load_size_set_static_delegate == null)
 746             {
 747                 efl_gfx_image_load_controller_load_size_set_static_delegate = new efl_gfx_image_load_controller_load_size_set_delegate(load_size_set);
 748             }
 749
 750             if (methods.FirstOrDefault(m => m.Name == "SetLoadSize") != null)
 751             {
 752                 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) });
 753             }
 754
 755             if (efl_gfx_image_load_controller_load_dpi_get_static_delegate == null)
 756             {
 757                 efl_gfx_image_load_controller_load_dpi_get_static_delegate = new efl_gfx_image_load_controller_load_dpi_get_delegate(load_dpi_get);
 758             }
 759
 760             if (methods.FirstOrDefault(m => m.Name == "GetLoadDpi") != null)
 761             {
 762                 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) });
 763             }
 764
 765             if (efl_gfx_image_load_controller_load_dpi_set_static_delegate == null)
 766             {
 767                 efl_gfx_image_load_controller_load_dpi_set_static_delegate = new efl_gfx_image_load_controller_load_dpi_set_delegate(load_dpi_set);
 768             }
 769
 770             if (methods.FirstOrDefault(m => m.Name == "SetLoadDpi") != null)
 771             {
 772                 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) });
 773             }
 774
 775             if (efl_gfx_image_load_controller_load_region_support_get_static_delegate == null)
 776             {
 777                 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);
 778             }
 779
 780             if (methods.FirstOrDefault(m => m.Name == "GetLoadRegionSupport") != null)
 781             {
 782                 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) });
 783             }
 784
 785             if (efl_gfx_image_load_controller_load_region_get_static_delegate == null)
 786             {
 787                 efl_gfx_image_load_controller_load_region_get_static_delegate = new efl_gfx_image_load_controller_load_region_get_delegate(load_region_get);
 788             }
 789
 790             if (methods.FirstOrDefault(m => m.Name == "GetLoadRegion") != null)
 791             {
 792                 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) });
 793             }
 794
 795             if (efl_gfx_image_load_controller_load_region_set_static_delegate == null)
 796             {
 797                 efl_gfx_image_load_controller_load_region_set_static_delegate = new efl_gfx_image_load_controller_load_region_set_delegate(load_region_set);
 798             }
 799
 800             if (methods.FirstOrDefault(m => m.Name == "SetLoadRegion") != null)
 801             {
 802                 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) });
 803             }
 804
 805             if (efl_gfx_image_load_controller_load_orientation_get_static_delegate == null)
 806             {
 807                 efl_gfx_image_load_controller_load_orientation_get_static_delegate = new efl_gfx_image_load_controller_load_orientation_get_delegate(load_orientation_get);
 808             }
 809
 810             if (methods.FirstOrDefault(m => m.Name == "GetLoadOrientation") != null)
 811             {
 812                 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) });
 813             }
 814
 815             if (efl_gfx_image_load_controller_load_orientation_set_static_delegate == null)
 816             {
 817                 efl_gfx_image_load_controller_load_orientation_set_static_delegate = new efl_gfx_image_load_controller_load_orientation_set_delegate(load_orientation_set);
 818             }
 819
 820             if (methods.FirstOrDefault(m => m.Name == "SetLoadOrientation") != null)
 821             {
 822                 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) });
 823             }
 824
 825             if (efl_gfx_image_load_controller_load_scale_down_get_static_delegate == null)
 826             {
 827                 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);
 828             }
 829
 830             if (methods.FirstOrDefault(m => m.Name == "GetLoadScaleDown") != null)
 831             {
 832                 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) });
 833             }
 834
 835             if (efl_gfx_image_load_controller_load_scale_down_set_static_delegate == null)
 836             {
 837                 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);
 838             }
 839
 840             if (methods.FirstOrDefault(m => m.Name == "SetLoadScaleDown") != null)
 841             {
 842                 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) });
 843             }
 844
 845             if (efl_gfx_image_load_controller_load_skip_header_get_static_delegate == null)
 846             {
 847                 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);
 848             }
 849
 850             if (methods.FirstOrDefault(m => m.Name == "GetLoadSkipHeader") != null)
 851             {
 852                 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) });
 853             }
 854
 855             if (efl_gfx_image_load_controller_load_skip_header_set_static_delegate == null)
 856             {
 857                 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);
 858             }
 859
 860             if (methods.FirstOrDefault(m => m.Name == "SetLoadSkipHeader") != null)
 861             {
 862                 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) });
 863             }
 864
 865             if (efl_gfx_image_load_controller_load_async_start_static_delegate == null)
 866             {
 867                 efl_gfx_image_load_controller_load_async_start_static_delegate = new efl_gfx_image_load_controller_load_async_start_delegate(load_async_start);
 868             }
 869
 870             if (methods.FirstOrDefault(m => m.Name == "LoadAsyncStart") != null)
 871             {
 872                 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) });
 873             }
 874
 875             if (efl_gfx_image_load_controller_load_async_cancel_static_delegate == null)
 876             {
 877                 efl_gfx_image_load_controller_load_async_cancel_static_delegate = new efl_gfx_image_load_controller_load_async_cancel_delegate(load_async_cancel);
 878             }
 879
 880             if (methods.FirstOrDefault(m => m.Name == "LoadAsyncCancel") != null)
 881             {
 882                 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) });
 883             }
 884
 885             descs.AddRange(base.GetEoOps(type));
 886             return descs;
 887         }
 888         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 889         /// <returns>The native class pointer.</returns>
 890         public override IntPtr GetEflClass()
 891         {
 892             return Efl.Canvas.Image.efl_canvas_image_class_get();
 893         }
 894
 895         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 896
 897
 898         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 899
 900
 901         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
 902
 903         public static Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate> efl_file_mmap_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate>(Module, "efl_file_mmap_get");
 904
 905         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
 906         {
 907             Eina.Log.Debug("function efl_file_mmap_get was called");
 908             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 909             if (ws != null)
 910             {
 911             Eina.File _ret_var = default(Eina.File);
 912                 try
 913                 {
 914                     _ret_var = ((Image)ws.Target).GetMmap();
 915                 }
 916                 catch (Exception e)
 917                 {
 918                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 919                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 920                 }
 921
 922         return _ret_var;
 923
 924             }
 925             else
 926             {
 927                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 928             }
 929         }
 930
 931         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
 932
 933
 934         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
 935
 936
 937         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
 938
 939         public static Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate> efl_file_mmap_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate>(Module, "efl_file_mmap_set");
 940
 941         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
 942         {
 943             Eina.Log.Debug("function efl_file_mmap_set was called");
 944             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 945             if (ws != null)
 946             {
 947                                     Eina.Error _ret_var = default(Eina.Error);
 948                 try
 949                 {
 950                     _ret_var = ((Image)ws.Target).SetMmap(f);
 951                 }
 952                 catch (Exception e)
 953                 {
 954                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 955                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 956                 }
 957
 958                         return _ret_var;
 959
 960             }
 961             else
 962             {
 963                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
 964             }
 965         }
 966
 967         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
 968
 969         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 970         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
 971
 972         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 973         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
 974
 975         public static Efl.Eo.FunctionWrapper<efl_file_get_api_delegate> efl_file_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_get_api_delegate>(Module, "efl_file_get");
 976
 977         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
 978         {
 979             Eina.Log.Debug("function efl_file_get was called");
 980             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 981             if (ws != null)
 982             {
 983             System.String _ret_var = default(System.String);
 984                 try
 985                 {
 986                     _ret_var = ((Image)ws.Target).GetFile();
 987                 }
 988                 catch (Exception e)
 989                 {
 990                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 991                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 992                 }
 993
 994         return _ret_var;
 995
 996             }
 997             else
 998             {
 999                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1000             }
1001         }
1002
1003         private static efl_file_get_delegate efl_file_get_static_delegate;
1004
1005
1006         private delegate Eina.Error efl_file_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1007
1008
1009         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
1010
1011         public static Efl.Eo.FunctionWrapper<efl_file_set_api_delegate> efl_file_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_set_api_delegate>(Module, "efl_file_set");
1012
1013         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
1014         {
1015             Eina.Log.Debug("function efl_file_set was called");
1016             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1017             if (ws != null)
1018             {
1019                                     Eina.Error _ret_var = default(Eina.Error);
1020                 try
1021                 {
1022                     _ret_var = ((Image)ws.Target).SetFile(file);
1023                 }
1024                 catch (Exception e)
1025                 {
1026                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1027                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1028                 }
1029
1030                         return _ret_var;
1031
1032             }
1033             else
1034             {
1035                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
1036             }
1037         }
1038
1039         private static efl_file_set_delegate efl_file_set_static_delegate;
1040
1041         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1042         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
1043
1044         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1045         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
1046
1047         public static Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate> efl_file_key_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate>(Module, "efl_file_key_get");
1048
1049         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
1050         {
1051             Eina.Log.Debug("function efl_file_key_get was called");
1052             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1053             if (ws != null)
1054             {
1055             System.String _ret_var = default(System.String);
1056                 try
1057                 {
1058                     _ret_var = ((Image)ws.Target).GetKey();
1059                 }
1060                 catch (Exception e)
1061                 {
1062                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1063                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1064                 }
1065
1066         return _ret_var;
1067
1068             }
1069             else
1070             {
1071                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1072             }
1073         }
1074
1075         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
1076
1077
1078         private delegate void efl_file_key_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1079
1080
1081         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
1082
1083         public static Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate> efl_file_key_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate>(Module, "efl_file_key_set");
1084
1085         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
1086         {
1087             Eina.Log.Debug("function efl_file_key_set was called");
1088             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1089             if (ws != null)
1090             {
1091
1092                 try
1093                 {
1094                     ((Image)ws.Target).SetKey(key);
1095                 }
1096                 catch (Exception e)
1097                 {
1098                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1099                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1100                 }
1101
1102
1103             }
1104             else
1105             {
1106                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
1107             }
1108         }
1109
1110         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
1111
1112         [return: MarshalAs(UnmanagedType.U1)]
1113         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
1114
1115         [return: MarshalAs(UnmanagedType.U1)]
1116         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
1117
1118         public static Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate> efl_file_loaded_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate>(Module, "efl_file_loaded_get");
1119
1120         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
1121         {
1122             Eina.Log.Debug("function efl_file_loaded_get was called");
1123             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1124             if (ws != null)
1125             {
1126             bool _ret_var = default(bool);
1127                 try
1128                 {
1129                     _ret_var = ((Image)ws.Target).GetLoaded();
1130                 }
1131                 catch (Exception e)
1132                 {
1133                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1134                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1135                 }
1136
1137         return _ret_var;
1138
1139             }
1140             else
1141             {
1142                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1143             }
1144         }
1145
1146         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
1147
1148
1149         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
1150
1151
1152         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
1153
1154         public static Efl.Eo.FunctionWrapper<efl_file_load_api_delegate> efl_file_load_ptr = new Efl.Eo.FunctionWrapper<efl_file_load_api_delegate>(Module, "efl_file_load");
1155
1156         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
1157         {
1158             Eina.Log.Debug("function efl_file_load was called");
1159             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1160             if (ws != null)
1161             {
1162             Eina.Error _ret_var = default(Eina.Error);
1163                 try
1164                 {
1165                     _ret_var = ((Image)ws.Target).Load();
1166                 }
1167                 catch (Exception e)
1168                 {
1169                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1170                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1171                 }
1172
1173         return _ret_var;
1174
1175             }
1176             else
1177             {
1178                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1179             }
1180         }
1181
1182         private static efl_file_load_delegate efl_file_load_static_delegate;
1183
1184
1185         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
1186
1187
1188         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
1189
1190         public static Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate> efl_file_unload_ptr = new Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate>(Module, "efl_file_unload");
1191
1192         private static void unload(System.IntPtr obj, System.IntPtr pd)
1193         {
1194             Eina.Log.Debug("function efl_file_unload was called");
1195             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1196             if (ws != null)
1197             {
1198
1199                 try
1200                 {
1201                     ((Image)ws.Target).Unload();
1202                 }
1203                 catch (Exception e)
1204                 {
1205                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1206                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1207                 }
1208
1209
1210             }
1211             else
1212             {
1213                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1214             }
1215         }
1216
1217         private static efl_file_unload_delegate efl_file_unload_static_delegate;
1218
1219         [return: MarshalAs(UnmanagedType.U1)]
1220         private delegate bool efl_gfx_frame_controller_animated_get_delegate(System.IntPtr obj, System.IntPtr pd);
1221
1222         [return: MarshalAs(UnmanagedType.U1)]
1223         public delegate bool efl_gfx_frame_controller_animated_get_api_delegate(System.IntPtr obj);
1224
1225         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_animated_get_api_delegate> efl_gfx_frame_controller_animated_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_animated_get_api_delegate>(Module, "efl_gfx_frame_controller_animated_get");
1226
1227         private static bool animated_get(System.IntPtr obj, System.IntPtr pd)
1228         {
1229             Eina.Log.Debug("function efl_gfx_frame_controller_animated_get was called");
1230             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1231             if (ws != null)
1232             {
1233             bool _ret_var = default(bool);
1234                 try
1235                 {
1236                     _ret_var = ((Image)ws.Target).GetAnimated();
1237                 }
1238                 catch (Exception e)
1239                 {
1240                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1241                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1242                 }
1243
1244         return _ret_var;
1245
1246             }
1247             else
1248             {
1249                 return efl_gfx_frame_controller_animated_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1250             }
1251         }
1252
1253         private static efl_gfx_frame_controller_animated_get_delegate efl_gfx_frame_controller_animated_get_static_delegate;
1254
1255
1256         private delegate int efl_gfx_frame_controller_frame_get_delegate(System.IntPtr obj, System.IntPtr pd);
1257
1258
1259         public delegate int efl_gfx_frame_controller_frame_get_api_delegate(System.IntPtr obj);
1260
1261         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_get_api_delegate> efl_gfx_frame_controller_frame_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_get");
1262
1263         private static int frame_get(System.IntPtr obj, System.IntPtr pd)
1264         {
1265             Eina.Log.Debug("function efl_gfx_frame_controller_frame_get was called");
1266             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1267             if (ws != null)
1268             {
1269             int _ret_var = default(int);
1270                 try
1271                 {
1272                     _ret_var = ((Image)ws.Target).GetFrame();
1273                 }
1274                 catch (Exception e)
1275                 {
1276                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1277                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1278                 }
1279
1280         return _ret_var;
1281
1282             }
1283             else
1284             {
1285                 return efl_gfx_frame_controller_frame_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1286             }
1287         }
1288
1289         private static efl_gfx_frame_controller_frame_get_delegate efl_gfx_frame_controller_frame_get_static_delegate;
1290
1291         [return: MarshalAs(UnmanagedType.U1)]
1292         private delegate bool efl_gfx_frame_controller_frame_set_delegate(System.IntPtr obj, System.IntPtr pd,  int frame_index);
1293
1294         [return: MarshalAs(UnmanagedType.U1)]
1295         public delegate bool efl_gfx_frame_controller_frame_set_api_delegate(System.IntPtr obj,  int frame_index);
1296
1297         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_set_api_delegate> efl_gfx_frame_controller_frame_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_set_api_delegate>(Module, "efl_gfx_frame_controller_frame_set");
1298
1299         private static bool frame_set(System.IntPtr obj, System.IntPtr pd, int frame_index)
1300         {
1301             Eina.Log.Debug("function efl_gfx_frame_controller_frame_set was called");
1302             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1303             if (ws != null)
1304             {
1305                                     bool _ret_var = default(bool);
1306                 try
1307                 {
1308                     _ret_var = ((Image)ws.Target).SetFrame(frame_index);
1309                 }
1310                 catch (Exception e)
1311                 {
1312                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1313                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1314                 }
1315
1316                         return _ret_var;
1317
1318             }
1319             else
1320             {
1321                 return efl_gfx_frame_controller_frame_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), frame_index);
1322             }
1323         }
1324
1325         private static efl_gfx_frame_controller_frame_set_delegate efl_gfx_frame_controller_frame_set_static_delegate;
1326
1327
1328         private delegate int efl_gfx_frame_controller_frame_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1329
1330
1331         public delegate int efl_gfx_frame_controller_frame_count_get_api_delegate(System.IntPtr obj);
1332
1333         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_count_get_api_delegate> efl_gfx_frame_controller_frame_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_count_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_count_get");
1334
1335         private static int frame_count_get(System.IntPtr obj, System.IntPtr pd)
1336         {
1337             Eina.Log.Debug("function efl_gfx_frame_controller_frame_count_get was called");
1338             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1339             if (ws != null)
1340             {
1341             int _ret_var = default(int);
1342                 try
1343                 {
1344                     _ret_var = ((Image)ws.Target).GetFrameCount();
1345                 }
1346                 catch (Exception e)
1347                 {
1348                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1349                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1350                 }
1351
1352         return _ret_var;
1353
1354             }
1355             else
1356             {
1357                 return efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1358             }
1359         }
1360
1361         private static efl_gfx_frame_controller_frame_count_get_delegate efl_gfx_frame_controller_frame_count_get_static_delegate;
1362
1363
1364         private delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1365
1366
1367         public delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_api_delegate(System.IntPtr obj);
1368
1369         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_type_get_api_delegate> efl_gfx_frame_controller_loop_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_type_get_api_delegate>(Module, "efl_gfx_frame_controller_loop_type_get");
1370
1371         private static Efl.Gfx.FrameControllerLoopHint loop_type_get(System.IntPtr obj, System.IntPtr pd)
1372         {
1373             Eina.Log.Debug("function efl_gfx_frame_controller_loop_type_get was called");
1374             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1375             if (ws != null)
1376             {
1377             Efl.Gfx.FrameControllerLoopHint _ret_var = default(Efl.Gfx.FrameControllerLoopHint);
1378                 try
1379                 {
1380                     _ret_var = ((Image)ws.Target).GetLoopType();
1381                 }
1382                 catch (Exception e)
1383                 {
1384                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1385                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1386                 }
1387
1388         return _ret_var;
1389
1390             }
1391             else
1392             {
1393                 return efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1394             }
1395         }
1396
1397         private static efl_gfx_frame_controller_loop_type_get_delegate efl_gfx_frame_controller_loop_type_get_static_delegate;
1398
1399
1400         private delegate int efl_gfx_frame_controller_loop_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1401
1402
1403         public delegate int efl_gfx_frame_controller_loop_count_get_api_delegate(System.IntPtr obj);
1404
1405         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_count_get_api_delegate> efl_gfx_frame_controller_loop_count_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_loop_count_get_api_delegate>(Module, "efl_gfx_frame_controller_loop_count_get");
1406
1407         private static int loop_count_get(System.IntPtr obj, System.IntPtr pd)
1408         {
1409             Eina.Log.Debug("function efl_gfx_frame_controller_loop_count_get was called");
1410             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1411             if (ws != null)
1412             {
1413             int _ret_var = default(int);
1414                 try
1415                 {
1416                     _ret_var = ((Image)ws.Target).GetLoopCount();
1417                 }
1418                 catch (Exception e)
1419                 {
1420                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1421                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1422                 }
1423
1424         return _ret_var;
1425
1426             }
1427             else
1428             {
1429                 return efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1430             }
1431         }
1432
1433         private static efl_gfx_frame_controller_loop_count_get_delegate efl_gfx_frame_controller_loop_count_get_static_delegate;
1434
1435
1436         private delegate double efl_gfx_frame_controller_frame_duration_get_delegate(System.IntPtr obj, System.IntPtr pd,  int start_frame,  int frame_num);
1437
1438
1439         public delegate double efl_gfx_frame_controller_frame_duration_get_api_delegate(System.IntPtr obj,  int start_frame,  int frame_num);
1440
1441         public static Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_duration_get_api_delegate> efl_gfx_frame_controller_frame_duration_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_frame_controller_frame_duration_get_api_delegate>(Module, "efl_gfx_frame_controller_frame_duration_get");
1442
1443         private static double frame_duration_get(System.IntPtr obj, System.IntPtr pd, int start_frame, int frame_num)
1444         {
1445             Eina.Log.Debug("function efl_gfx_frame_controller_frame_duration_get was called");
1446             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1447             if (ws != null)
1448             {
1449                                                             double _ret_var = default(double);
1450                 try
1451                 {
1452                     _ret_var = ((Image)ws.Target).GetFrameDuration(start_frame, frame_num);
1453                 }
1454                 catch (Exception e)
1455                 {
1456                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1457                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1458                 }
1459
1460                                         return _ret_var;
1461
1462             }
1463             else
1464             {
1465                 return efl_gfx_frame_controller_frame_duration_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), start_frame, frame_num);
1466             }
1467         }
1468
1469         private static efl_gfx_frame_controller_frame_duration_get_delegate efl_gfx_frame_controller_frame_duration_get_static_delegate;
1470
1471
1472         private delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1473
1474
1475         public delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_api_delegate(System.IntPtr obj);
1476
1477         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");
1478
1479         private static Eina.Size2D.NativeStruct load_size_get(System.IntPtr obj, System.IntPtr pd)
1480         {
1481             Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_get was called");
1482             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1483             if (ws != null)
1484             {
1485             Eina.Size2D _ret_var = default(Eina.Size2D);
1486                 try
1487                 {
1488                     _ret_var = ((Image)ws.Target).GetLoadSize();
1489                 }
1490                 catch (Exception e)
1491                 {
1492                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1493                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1494                 }
1495
1496         return _ret_var;
1497
1498             }
1499             else
1500             {
1501                 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)));
1502             }
1503         }
1504
1505         private static efl_gfx_image_load_controller_load_size_get_delegate efl_gfx_image_load_controller_load_size_get_static_delegate;
1506
1507
1508         private delegate void efl_gfx_image_load_controller_load_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size);
1509
1510
1511         public delegate void efl_gfx_image_load_controller_load_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct size);
1512
1513         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");
1514
1515         private static void load_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
1516         {
1517             Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_set was called");
1518             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1519             if (ws != null)
1520             {
1521         Eina.Size2D _in_size = size;
1522
1523                 try
1524                 {
1525                     ((Image)ws.Target).SetLoadSize(_in_size);
1526                 }
1527                 catch (Exception e)
1528                 {
1529                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1530                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1531                 }
1532
1533
1534             }
1535             else
1536             {
1537                 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);
1538             }
1539         }
1540
1541         private static efl_gfx_image_load_controller_load_size_set_delegate efl_gfx_image_load_controller_load_size_set_static_delegate;
1542
1543
1544         private delegate double efl_gfx_image_load_controller_load_dpi_get_delegate(System.IntPtr obj, System.IntPtr pd);
1545
1546
1547         public delegate double efl_gfx_image_load_controller_load_dpi_get_api_delegate(System.IntPtr obj);
1548
1549         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");
1550
1551         private static double load_dpi_get(System.IntPtr obj, System.IntPtr pd)
1552         {
1553             Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_get was called");
1554             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1555             if (ws != null)
1556             {
1557             double _ret_var = default(double);
1558                 try
1559                 {
1560                     _ret_var = ((Image)ws.Target).GetLoadDpi();
1561                 }
1562                 catch (Exception e)
1563                 {
1564                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1565                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1566                 }
1567
1568         return _ret_var;
1569
1570             }
1571             else
1572             {
1573                 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)));
1574             }
1575         }
1576
1577         private static efl_gfx_image_load_controller_load_dpi_get_delegate efl_gfx_image_load_controller_load_dpi_get_static_delegate;
1578
1579
1580         private delegate void efl_gfx_image_load_controller_load_dpi_set_delegate(System.IntPtr obj, System.IntPtr pd,  double dpi);
1581
1582
1583         public delegate void efl_gfx_image_load_controller_load_dpi_set_api_delegate(System.IntPtr obj,  double dpi);
1584
1585         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");
1586
1587         private static void load_dpi_set(System.IntPtr obj, System.IntPtr pd, double dpi)
1588         {
1589             Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_set was called");
1590             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1591             if (ws != null)
1592             {
1593
1594                 try
1595                 {
1596                     ((Image)ws.Target).SetLoadDpi(dpi);
1597                 }
1598                 catch (Exception e)
1599                 {
1600                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1601                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1602                 }
1603
1604
1605             }
1606             else
1607             {
1608                 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);
1609             }
1610         }
1611
1612         private static efl_gfx_image_load_controller_load_dpi_set_delegate efl_gfx_image_load_controller_load_dpi_set_static_delegate;
1613
1614         [return: MarshalAs(UnmanagedType.U1)]
1615         private delegate bool efl_gfx_image_load_controller_load_region_support_get_delegate(System.IntPtr obj, System.IntPtr pd);
1616
1617         [return: MarshalAs(UnmanagedType.U1)]
1618         public delegate bool efl_gfx_image_load_controller_load_region_support_get_api_delegate(System.IntPtr obj);
1619
1620         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");
1621
1622         private static bool load_region_support_get(System.IntPtr obj, System.IntPtr pd)
1623         {
1624             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_support_get was called");
1625             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1626             if (ws != null)
1627             {
1628             bool _ret_var = default(bool);
1629                 try
1630                 {
1631                     _ret_var = ((Image)ws.Target).GetLoadRegionSupport();
1632                 }
1633                 catch (Exception e)
1634                 {
1635                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1636                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1637                 }
1638
1639         return _ret_var;
1640
1641             }
1642             else
1643             {
1644                 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)));
1645             }
1646         }
1647
1648         private static efl_gfx_image_load_controller_load_region_support_get_delegate efl_gfx_image_load_controller_load_region_support_get_static_delegate;
1649
1650
1651         private delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
1652
1653
1654         public delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_api_delegate(System.IntPtr obj);
1655
1656         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");
1657
1658         private static Eina.Rect.NativeStruct load_region_get(System.IntPtr obj, System.IntPtr pd)
1659         {
1660             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_get was called");
1661             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1662             if (ws != null)
1663             {
1664             Eina.Rect _ret_var = default(Eina.Rect);
1665                 try
1666                 {
1667                     _ret_var = ((Image)ws.Target).GetLoadRegion();
1668                 }
1669                 catch (Exception e)
1670                 {
1671                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1672                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1673                 }
1674
1675         return _ret_var;
1676
1677             }
1678             else
1679             {
1680                 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)));
1681             }
1682         }
1683
1684         private static efl_gfx_image_load_controller_load_region_get_delegate efl_gfx_image_load_controller_load_region_get_static_delegate;
1685
1686
1687         private delegate void efl_gfx_image_load_controller_load_region_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct region);
1688
1689
1690         public delegate void efl_gfx_image_load_controller_load_region_set_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct region);
1691
1692         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");
1693
1694         private static void load_region_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct region)
1695         {
1696             Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_set was called");
1697             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1698             if (ws != null)
1699             {
1700         Eina.Rect _in_region = region;
1701
1702                 try
1703                 {
1704                     ((Image)ws.Target).SetLoadRegion(_in_region);
1705                 }
1706                 catch (Exception e)
1707                 {
1708                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1709                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1710                 }
1711
1712
1713             }
1714             else
1715             {
1716                 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);
1717             }
1718         }
1719
1720         private static efl_gfx_image_load_controller_load_region_set_delegate efl_gfx_image_load_controller_load_region_set_static_delegate;
1721
1722         [return: MarshalAs(UnmanagedType.U1)]
1723         private delegate bool efl_gfx_image_load_controller_load_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1724
1725         [return: MarshalAs(UnmanagedType.U1)]
1726         public delegate bool efl_gfx_image_load_controller_load_orientation_get_api_delegate(System.IntPtr obj);
1727
1728         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");
1729
1730         private static bool load_orientation_get(System.IntPtr obj, System.IntPtr pd)
1731         {
1732             Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_get was called");
1733             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1734             if (ws != null)
1735             {
1736             bool _ret_var = default(bool);
1737                 try
1738                 {
1739                     _ret_var = ((Image)ws.Target).GetLoadOrientation();
1740                 }
1741                 catch (Exception e)
1742                 {
1743                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1744                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1745                 }
1746
1747         return _ret_var;
1748
1749             }
1750             else
1751             {
1752                 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)));
1753             }
1754         }
1755
1756         private static efl_gfx_image_load_controller_load_orientation_get_delegate efl_gfx_image_load_controller_load_orientation_get_static_delegate;
1757
1758
1759         private delegate void efl_gfx_image_load_controller_load_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool enable);
1760
1761
1762         public delegate void efl_gfx_image_load_controller_load_orientation_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool enable);
1763
1764         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");
1765
1766         private static void load_orientation_set(System.IntPtr obj, System.IntPtr pd, bool enable)
1767         {
1768             Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_set was called");
1769             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1770             if (ws != null)
1771             {
1772
1773                 try
1774                 {
1775                     ((Image)ws.Target).SetLoadOrientation(enable);
1776                 }
1777                 catch (Exception e)
1778                 {
1779                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1780                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1781                 }
1782
1783
1784             }
1785             else
1786             {
1787                 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);
1788             }
1789         }
1790
1791         private static efl_gfx_image_load_controller_load_orientation_set_delegate efl_gfx_image_load_controller_load_orientation_set_static_delegate;
1792
1793
1794         private delegate int efl_gfx_image_load_controller_load_scale_down_get_delegate(System.IntPtr obj, System.IntPtr pd);
1795
1796
1797         public delegate int efl_gfx_image_load_controller_load_scale_down_get_api_delegate(System.IntPtr obj);
1798
1799         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");
1800
1801         private static int load_scale_down_get(System.IntPtr obj, System.IntPtr pd)
1802         {
1803             Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_get was called");
1804             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1805             if (ws != null)
1806             {
1807             int _ret_var = default(int);
1808                 try
1809                 {
1810                     _ret_var = ((Image)ws.Target).GetLoadScaleDown();
1811                 }
1812                 catch (Exception e)
1813                 {
1814                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1815                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1816                 }
1817
1818         return _ret_var;
1819
1820             }
1821             else
1822             {
1823                 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)));
1824             }
1825         }
1826
1827         private static efl_gfx_image_load_controller_load_scale_down_get_delegate efl_gfx_image_load_controller_load_scale_down_get_static_delegate;
1828
1829
1830         private delegate void efl_gfx_image_load_controller_load_scale_down_set_delegate(System.IntPtr obj, System.IntPtr pd,  int div);
1831
1832
1833         public delegate void efl_gfx_image_load_controller_load_scale_down_set_api_delegate(System.IntPtr obj,  int div);
1834
1835         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");
1836
1837         private static void load_scale_down_set(System.IntPtr obj, System.IntPtr pd, int div)
1838         {
1839             Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_set was called");
1840             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1841             if (ws != null)
1842             {
1843
1844                 try
1845                 {
1846                     ((Image)ws.Target).SetLoadScaleDown(div);
1847                 }
1848                 catch (Exception e)
1849                 {
1850                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1851                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1852                 }
1853
1854
1855             }
1856             else
1857             {
1858                 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);
1859             }
1860         }
1861
1862         private static efl_gfx_image_load_controller_load_scale_down_set_delegate efl_gfx_image_load_controller_load_scale_down_set_static_delegate;
1863
1864         [return: MarshalAs(UnmanagedType.U1)]
1865         private delegate bool efl_gfx_image_load_controller_load_skip_header_get_delegate(System.IntPtr obj, System.IntPtr pd);
1866
1867         [return: MarshalAs(UnmanagedType.U1)]
1868         public delegate bool efl_gfx_image_load_controller_load_skip_header_get_api_delegate(System.IntPtr obj);
1869
1870         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");
1871
1872         private static bool load_skip_header_get(System.IntPtr obj, System.IntPtr pd)
1873         {
1874             Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_get was called");
1875             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1876             if (ws != null)
1877             {
1878             bool _ret_var = default(bool);
1879                 try
1880                 {
1881                     _ret_var = ((Image)ws.Target).GetLoadSkipHeader();
1882                 }
1883                 catch (Exception e)
1884                 {
1885                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1886                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1887                 }
1888
1889         return _ret_var;
1890
1891             }
1892             else
1893             {
1894                 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)));
1895             }
1896         }
1897
1898         private static efl_gfx_image_load_controller_load_skip_header_get_delegate efl_gfx_image_load_controller_load_skip_header_get_static_delegate;
1899
1900
1901         private delegate void efl_gfx_image_load_controller_load_skip_header_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool skip);
1902
1903
1904         public delegate void efl_gfx_image_load_controller_load_skip_header_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool skip);
1905
1906         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");
1907
1908         private static void load_skip_header_set(System.IntPtr obj, System.IntPtr pd, bool skip)
1909         {
1910             Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_set was called");
1911             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1912             if (ws != null)
1913             {
1914
1915                 try
1916                 {
1917                     ((Image)ws.Target).SetLoadSkipHeader(skip);
1918                 }
1919                 catch (Exception e)
1920                 {
1921                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1922                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1923                 }
1924
1925
1926             }
1927             else
1928             {
1929                 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);
1930             }
1931         }
1932
1933         private static efl_gfx_image_load_controller_load_skip_header_set_delegate efl_gfx_image_load_controller_load_skip_header_set_static_delegate;
1934
1935
1936         private delegate void efl_gfx_image_load_controller_load_async_start_delegate(System.IntPtr obj, System.IntPtr pd);
1937
1938
1939         public delegate void efl_gfx_image_load_controller_load_async_start_api_delegate(System.IntPtr obj);
1940
1941         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");
1942
1943         private static void load_async_start(System.IntPtr obj, System.IntPtr pd)
1944         {
1945             Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_start was called");
1946             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1947             if (ws != null)
1948             {
1949
1950                 try
1951                 {
1952                     ((Image)ws.Target).LoadAsyncStart();
1953                 }
1954                 catch (Exception e)
1955                 {
1956                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1957                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1958                 }
1959
1960
1961             }
1962             else
1963             {
1964                 efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1965             }
1966         }
1967
1968         private static efl_gfx_image_load_controller_load_async_start_delegate efl_gfx_image_load_controller_load_async_start_static_delegate;
1969
1970
1971         private delegate void efl_gfx_image_load_controller_load_async_cancel_delegate(System.IntPtr obj, System.IntPtr pd);
1972
1973
1974         public delegate void efl_gfx_image_load_controller_load_async_cancel_api_delegate(System.IntPtr obj);
1975
1976         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");
1977
1978         private static void load_async_cancel(System.IntPtr obj, System.IntPtr pd)
1979         {
1980             Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_cancel was called");
1981             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1982             if (ws != null)
1983             {
1984
1985                 try
1986                 {
1987                     ((Image)ws.Target).LoadAsyncCancel();
1988                 }
1989                 catch (Exception e)
1990                 {
1991                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1992                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1993                 }
1994
1995
1996             }
1997             else
1998             {
1999                 efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2000             }
2001         }
2002
2003         private static efl_gfx_image_load_controller_load_async_cancel_delegate efl_gfx_image_load_controller_load_async_cancel_static_delegate;
2004
2005         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2006
2007 }
2008 }
2009 }
2010
2011 }
2012