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