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.ComponentModel;
   7 namespace Efl { namespace Canvas {
   8 /// <summary>Low-level Image object.
   9 /// 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>
  10 [ImageNativeInherit]
  11 public class Image : Efl.Canvas.ImageInternal, Efl.Eo.IWrapper,Efl.IFile,Efl.Gfx.IFrameController,Efl.Gfx.IImageLoadController
  12 {
  13     ///<summary>Pointer to the native class description.</summary>
  14     public override System.IntPtr NativeClass {
  15         get {
  16             if (((object)this).GetType() == typeof (Image))
  17                 return Efl.Canvas.ImageNativeInherit.GetEflClassStatic();
  18             else
  19                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  20         }
  21     }
  22     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  23         efl_canvas_image_class_get();
  24     ///<summary>Creates a new instance.</summary>
  25     ///<param name="parent">Parent instance.</param>
  26     public Image(Efl.Object parent= null
  27             ) :
  28         base(efl_canvas_image_class_get(), typeof(Image), parent)
  29     {
  30         FinishInstantiation();
  31     }
  32     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  33     protected Image(System.IntPtr raw) : base(raw)
  34     {
  35                 RegisterEventProxies();
  36     }
  37     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  38     protected Image(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  39     ///<summary>Verifies if the given object is equal to this one.</summary>
  40     public override bool Equals(object obj)
  41     {
  42         var other = obj as Efl.Object;
  43         if (other == null)
  44             return false;
  45         return this.NativeHandle == other.NativeHandle;
  46     }
  47     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  48     public override int GetHashCode()
  49     {
  50         return this.NativeHandle.ToInt32();
  51     }
  52     ///<summary>Turns the native pointer into a string representation.</summary>
  53     public override String ToString()
  54     {
  55         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  56     }
  57 private static object LoadDoneEvtKey = new object();
  58     /// <summary>Called when he image was loaded</summary>
  59     public event EventHandler LoadDoneEvt
  60     {
  61         add {
  62             lock (eventLock) {
  63                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
  64                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_LoadDoneEvt_delegate)) {
  65                     eventHandlers.AddHandler(LoadDoneEvtKey , value);
  66                 } else
  67                     Eina.Log.Error($"Error adding proxy for event {key}");
  68             }
  69         }
  70         remove {
  71             lock (eventLock) {
  72                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_DONE";
  73                 if (RemoveNativeEventHandler(key, this.evt_LoadDoneEvt_delegate)) {
  74                     eventHandlers.RemoveHandler(LoadDoneEvtKey , value);
  75                 } else
  76                     Eina.Log.Error($"Error removing proxy for event {key}");
  77             }
  78         }
  79     }
  80     ///<summary>Method to raise event LoadDoneEvt.</summary>
  81     public void On_LoadDoneEvt(EventArgs e)
  82     {
  83         EventHandler evt;
  84         lock (eventLock) {
  85         evt = (EventHandler)eventHandlers[LoadDoneEvtKey];
  86         }
  87         evt?.Invoke(this, e);
  88     }
  89     Efl.EventCb evt_LoadDoneEvt_delegate;
  90     private void on_LoadDoneEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
  91     {
  92         EventArgs args = EventArgs.Empty;
  93         try {
  94             On_LoadDoneEvt(args);
  95         } catch (Exception e) {
  96             Eina.Log.Error(e.ToString());
  97             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  98         }
  99     }
 100
 101 private static object LoadErrorEvtKey = new object();
 102     /// <summary>Called when an error happened during image loading</summary>
 103     public event EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> LoadErrorEvt
 104     {
 105         add {
 106             lock (eventLock) {
 107                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 108                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_LoadErrorEvt_delegate)) {
 109                     eventHandlers.AddHandler(LoadErrorEvtKey , value);
 110                 } else
 111                     Eina.Log.Error($"Error adding proxy for event {key}");
 112             }
 113         }
 114         remove {
 115             lock (eventLock) {
 116                 string key = "_EFL_GFX_IMAGE_LOAD_CONTROLLER_EVENT_LOAD_ERROR";
 117                 if (RemoveNativeEventHandler(key, this.evt_LoadErrorEvt_delegate)) {
 118                     eventHandlers.RemoveHandler(LoadErrorEvtKey , value);
 119                 } else
 120                     Eina.Log.Error($"Error removing proxy for event {key}");
 121             }
 122         }
 123     }
 124     ///<summary>Method to raise event LoadErrorEvt.</summary>
 125     public void On_LoadErrorEvt(Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args e)
 126     {
 127         EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args> evt;
 128         lock (eventLock) {
 129         evt = (EventHandler<Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args>)eventHandlers[LoadErrorEvtKey];
 130         }
 131         evt?.Invoke(this, e);
 132     }
 133     Efl.EventCb evt_LoadErrorEvt_delegate;
 134     private void on_LoadErrorEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 135     {
 136         Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args args = new Efl.Gfx.IImageLoadControllerLoadErrorEvt_Args();
 137       args.arg = (Eina.Error)Marshal.PtrToStructure(evt.Info, typeof(Eina.Error));
 138         try {
 139             On_LoadErrorEvt(args);
 140         } catch (Exception e) {
 141             Eina.Log.Error(e.ToString());
 142             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 143         }
 144     }
 145
 146     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 147     protected override void RegisterEventProxies()
 148     {
 149         base.RegisterEventProxies();
 150         evt_LoadDoneEvt_delegate = new Efl.EventCb(on_LoadDoneEvt_NativeCallback);
 151         evt_LoadErrorEvt_delegate = new Efl.EventCb(on_LoadErrorEvt_NativeCallback);
 152     }
 153     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 154     /// (Since EFL 1.22)</summary>
 155     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 156     virtual public Eina.File GetMmap() {
 157          var _ret_var = Efl.IFileNativeInherit.efl_file_mmap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 158         Eina.Error.RaiseIfUnhandledException();
 159         return _ret_var;
 160  }
 161     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 162     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 163     /// (Since EFL 1.22)</summary>
 164     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 165     /// <returns>0 on success, error code otherwise</returns>
 166     virtual public Eina.Error SetMmap( Eina.File f) {
 167                                  var _ret_var = Efl.IFileNativeInherit.efl_file_mmap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), f);
 168         Eina.Error.RaiseIfUnhandledException();
 169                         return _ret_var;
 170  }
 171     /// <summary>Retrieve the file path from where an object is to fetch the data.
 172     /// You must not modify the strings on the returned pointers.
 173     /// (Since EFL 1.22)</summary>
 174     /// <returns>The file path.</returns>
 175     virtual public System.String GetFile() {
 176          var _ret_var = Efl.IFileNativeInherit.efl_file_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 177         Eina.Error.RaiseIfUnhandledException();
 178         return _ret_var;
 179  }
 180     /// <summary>Set the file path from where an object will fetch the data.
 181     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 182     /// (Since EFL 1.22)</summary>
 183     /// <param name="file">The file path.</param>
 184     /// <returns>0 on success, error code otherwise</returns>
 185     virtual public Eina.Error SetFile( System.String file) {
 186                                  var _ret_var = Efl.IFileNativeInherit.efl_file_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), file);
 187         Eina.Error.RaiseIfUnhandledException();
 188                         return _ret_var;
 189  }
 190     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 191     /// 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"/>).
 192     ///
 193     /// You must not modify the strings on the returned pointers.
 194     /// (Since EFL 1.22)</summary>
 195     /// <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>
 196     virtual public System.String GetKey() {
 197          var _ret_var = Efl.IFileNativeInherit.efl_file_key_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 198         Eina.Error.RaiseIfUnhandledException();
 199         return _ret_var;
 200  }
 201     /// <summary>Set the key which corresponds to the target data within a file.
 202     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 203     /// (Since EFL 1.22)</summary>
 204     /// <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>
 205     /// <returns></returns>
 206     virtual public void SetKey( System.String key) {
 207                                  Efl.IFileNativeInherit.efl_file_key_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), key);
 208         Eina.Error.RaiseIfUnhandledException();
 209                          }
 210     /// <summary>Get the load state of the object.
 211     /// (Since EFL 1.22)</summary>
 212     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 213     virtual public bool GetLoaded() {
 214          var _ret_var = Efl.IFileNativeInherit.efl_file_loaded_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 215         Eina.Error.RaiseIfUnhandledException();
 216         return _ret_var;
 217  }
 218     /// <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.
 219     /// 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.
 220     ///
 221     /// 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.
 222     /// (Since EFL 1.22)</summary>
 223     /// <returns>0 on success, error code otherwise</returns>
 224     virtual public Eina.Error Load() {
 225          var _ret_var = Efl.IFileNativeInherit.efl_file_load_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 226         Eina.Error.RaiseIfUnhandledException();
 227         return _ret_var;
 228  }
 229     /// <summary>Perform all necessary operations to unload file data from the object.
 230     /// 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.
 231     ///
 232     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 233     /// (Since EFL 1.22)</summary>
 234     /// <returns></returns>
 235     virtual public void Unload() {
 236          Efl.IFileNativeInherit.efl_file_unload_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 237         Eina.Error.RaiseIfUnhandledException();
 238          }
 239     /// <summary>Check if an object can be animated (has multiple frames).
 240     /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 241     /// <returns><c>true</c> if the object is animated</returns>
 242     virtual public bool GetAnimated() {
 243          var _ret_var = Efl.Gfx.IFrameControllerNativeInherit.efl_gfx_frame_controller_animated_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 244         Eina.Error.RaiseIfUnhandledException();
 245         return _ret_var;
 246  }
 247     /// <summary>Index of the current frame of an animated object.
 248     /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 249     /// <returns>The index of current frame.</returns>
 250     virtual public int GetFrame() {
 251          var _ret_var = Efl.Gfx.IFrameControllerNativeInherit.efl_gfx_frame_controller_frame_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 252         Eina.Error.RaiseIfUnhandledException();
 253         return _ret_var;
 254  }
 255     /// <summary>Set the frame to current frame of an animated object.</summary>
 256     /// <param name="frame_index">The index of current frame.</param>
 257     /// <returns>Returns <c>true</c> if the frame index is valid.</returns>
 258     virtual public bool SetFrame( int frame_index) {
 259                                  var _ret_var = Efl.Gfx.IFrameControllerNativeInherit.efl_gfx_frame_controller_frame_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), frame_index);
 260         Eina.Error.RaiseIfUnhandledException();
 261                         return _ret_var;
 262  }
 263     /// <summary>Get the total number of frames of the object, if animated.
 264     /// Returns -1 if not animated.</summary>
 265     /// <returns>The number of frames in the animated object.</returns>
 266     virtual public int GetFrameCount() {
 267          var _ret_var = Efl.Gfx.IFrameControllerNativeInherit.efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 268         Eina.Error.RaiseIfUnhandledException();
 269         return _ret_var;
 270  }
 271     /// <summary>Get the kind of looping the animated object does.
 272     /// This returns the kind of looping the animated object wants to do.
 273     ///
 274     /// 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...
 275     ///
 276     /// 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...
 277     ///
 278     /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 279     /// <returns>Loop type of the animated object.</returns>
 280     virtual public Efl.Gfx.FrameControllerLoopHint GetLoopType() {
 281          var _ret_var = Efl.Gfx.IFrameControllerNativeInherit.efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 282         Eina.Error.RaiseIfUnhandledException();
 283         return _ret_var;
 284  }
 285     /// <summary>Get the number times the animation of the object loops.
 286     /// 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).
 287     ///
 288     /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 289     /// <returns>The number of loop of an animated object.</returns>
 290     virtual public int GetLoopCount() {
 291          var _ret_var = Efl.Gfx.IFrameControllerNativeInherit.efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 292         Eina.Error.RaiseIfUnhandledException();
 293         return _ret_var;
 294  }
 295     /// <summary>Get the duration of a sequence of frames.
 296     /// This returns total duration in seconds that the specified sequence of frames should take.
 297     ///
 298     /// 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>
 299     /// <param name="start_frame">The first frame, rangers from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>.</param>
 300     /// <param name="frame_num">Number of frames in the sequence, starts from 0.</param>
 301     /// <returns>Duration in seconds</returns>
 302     virtual public double GetFrameDuration( int start_frame,  int frame_num) {
 303                                                          var _ret_var = Efl.Gfx.IFrameControllerNativeInherit.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);
 304         Eina.Error.RaiseIfUnhandledException();
 305                                         return _ret_var;
 306  }
 307     /// <summary>Returns the requested load size.</summary>
 308     /// <returns>The image load size.</returns>
 309     virtual public Eina.Size2D GetLoadSize() {
 310          var _ret_var = Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 311         Eina.Error.RaiseIfUnhandledException();
 312         return _ret_var;
 313  }
 314     /// <summary>Requests the canvas to load the image at the given size.
 315     /// 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>
 316     /// <param name="size">The image load size.</param>
 317     /// <returns></returns>
 318     virtual public void SetLoadSize( Eina.Size2D size) {
 319          Eina.Size2D.NativeStruct _in_size = size;
 320                         Efl.Gfx.IImageLoadControllerNativeInherit.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);
 321         Eina.Error.RaiseIfUnhandledException();
 322                          }
 323     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 324     /// This function returns the DPI resolution of the given canvas image.</summary>
 325     /// <returns>The DPI resolution.</returns>
 326     virtual public double GetLoadDpi() {
 327          var _ret_var = Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_dpi_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>Set the DPI resolution of an image object&apos;s source image.
 332     /// This function sets the DPI resolution of a given loaded canvas image. Most useful for the SVG image loader.</summary>
 333     /// <param name="dpi">The DPI resolution.</param>
 334     /// <returns></returns>
 335     virtual public void SetLoadDpi( double dpi) {
 336                                  Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_dpi_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dpi);
 337         Eina.Error.RaiseIfUnhandledException();
 338                          }
 339     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 340     /// <returns><c>true</c> if region load of the image is supported, <c>false</c> otherwise</returns>
 341     virtual public bool GetLoadRegionSupport() {
 342          var _ret_var = Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_region_support_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 343         Eina.Error.RaiseIfUnhandledException();
 344         return _ret_var;
 345  }
 346     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 347     /// <returns>A region of the image.</returns>
 348     virtual public Eina.Rect GetLoadRegion() {
 349          var _ret_var = Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_region_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 350         Eina.Error.RaiseIfUnhandledException();
 351         return _ret_var;
 352  }
 353     /// <summary>Inform a given image object to load a selective region of its source image.
 354     /// This function is useful when one is not showing all of an image&apos;s area on its image object.
 355     ///
 356     /// Note: The image loader for the image format in question has to support selective region loading in order for this function to work.</summary>
 357     /// <param name="region">A region of the image.</param>
 358     /// <returns></returns>
 359     virtual public void SetLoadRegion( Eina.Rect region) {
 360          Eina.Rect.NativeStruct _in_region = region;
 361                         Efl.Gfx.IImageLoadControllerNativeInherit.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);
 362         Eina.Error.RaiseIfUnhandledException();
 363                          }
 364     /// <summary>Defines whether the orientation information in the image file should be honored.
 365     /// 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>
 366     /// <returns><c>true</c> means that it should honor the orientation information.</returns>
 367     virtual public bool GetLoadOrientation() {
 368          var _ret_var = Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 369         Eina.Error.RaiseIfUnhandledException();
 370         return _ret_var;
 371  }
 372     /// <summary>Defines whether the orientation information in the image file should be honored.
 373     /// 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>
 374     /// <param name="enable"><c>true</c> means that it should honor the orientation information.</param>
 375     /// <returns></returns>
 376     virtual public void SetLoadOrientation( bool enable) {
 377                                  Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), enable);
 378         Eina.Error.RaiseIfUnhandledException();
 379                          }
 380     /// <summary>The scale down factor is a divider on the original image size.
 381     /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 382     ///
 383     /// 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.
 384     ///
 385     /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 386     /// <returns>The scale down dividing factor.</returns>
 387     virtual public int GetLoadScaleDown() {
 388          var _ret_var = Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_scale_down_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 389         Eina.Error.RaiseIfUnhandledException();
 390         return _ret_var;
 391  }
 392     /// <summary>Requests the image loader to scale down by <c>div</c> times. Call this before starting the actual image load.</summary>
 393     /// <param name="div">The scale down dividing factor.</param>
 394     /// <returns></returns>
 395     virtual public void SetLoadScaleDown( int div) {
 396                                  Efl.Gfx.IImageLoadControllerNativeInherit.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);
 397         Eina.Error.RaiseIfUnhandledException();
 398                          }
 399     /// <summary>Initial load should skip header check and leave it all to data load
 400     /// 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>
 401     /// <returns>Will be true if header is to be skipped.</returns>
 402     virtual public bool GetLoadSkipHeader() {
 403          var _ret_var = Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_skip_header_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 404         Eina.Error.RaiseIfUnhandledException();
 405         return _ret_var;
 406  }
 407     /// <summary>Set the skip header state for susbsequent loads of a file.</summary>
 408     /// <param name="skip">Will be true if header is to be skipped.</param>
 409     /// <returns></returns>
 410     virtual public void SetLoadSkipHeader( bool skip) {
 411                                  Efl.Gfx.IImageLoadControllerNativeInherit.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);
 412         Eina.Error.RaiseIfUnhandledException();
 413                          }
 414     /// <summary>Begin preloading an image object&apos;s image data in the background.
 415     /// Once the background task is complete the event <c>load</c>,done will be emitted.</summary>
 416     /// <returns></returns>
 417     virtual public void LoadAsyncStart() {
 418          Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 419         Eina.Error.RaiseIfUnhandledException();
 420          }
 421     /// <summary>Cancel preloading an image object&apos;s image data in the background.
 422     /// 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>
 423     /// <returns></returns>
 424     virtual public void LoadAsyncCancel() {
 425          Efl.Gfx.IImageLoadControllerNativeInherit.efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 426         Eina.Error.RaiseIfUnhandledException();
 427          }
 428     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 429 /// (Since EFL 1.22)</summary>
 430 /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 431     public Eina.File Mmap {
 432         get { return GetMmap(); }
 433         set { SetMmap( value); }
 434     }
 435     /// <summary>Retrieve the file path from where an object is to fetch the data.
 436 /// You must not modify the strings on the returned pointers.
 437 /// (Since EFL 1.22)</summary>
 438 /// <value>The file path.</value>
 439     public System.String File {
 440         get { return GetFile(); }
 441         set { SetFile( value); }
 442     }
 443     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 444 /// 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"/>).
 445 ///
 446 /// You must not modify the strings on the returned pointers.
 447 /// (Since EFL 1.22)</summary>
 448 /// <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>
 449     public System.String Key {
 450         get { return GetKey(); }
 451         set { SetKey( value); }
 452     }
 453     /// <summary>Get the load state of the object.
 454 /// (Since EFL 1.22)</summary>
 455 /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 456     public bool Loaded {
 457         get { return GetLoaded(); }
 458     }
 459     /// <summary>Check if an object can be animated (has multiple frames).
 460 /// This will be <c>true</c> for animated object for instance but <c>false</c> for a single frame object.</summary>
 461 /// <value><c>true</c> if the object is animated</value>
 462     public bool Animated {
 463         get { return GetAnimated(); }
 464     }
 465     /// <summary>Index of the current frame of an animated object.
 466 /// Ranges from 1 to <see cref="Efl.Gfx.IFrameController.GetFrameCount"/>. Valid only if <see cref="Efl.Gfx.IFrameController.GetAnimated"/>.</summary>
 467 /// <value>The index of current frame.</value>
 468     public int Frame {
 469         get { return GetFrame(); }
 470         set { SetFrame( value); }
 471     }
 472     /// <summary>Get the total number of frames of the object, if animated.
 473 /// Returns -1 if not animated.</summary>
 474 /// <value>The number of frames in the animated object.</value>
 475     public int FrameCount {
 476         get { return GetFrameCount(); }
 477     }
 478     /// <summary>Get the kind of looping the animated object does.
 479 /// This returns the kind of looping the animated object wants to do.
 480 ///
 481 /// 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...
 482 ///
 483 /// 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...
 484 ///
 485 /// The default type is <see cref="Efl.Gfx.FrameControllerLoopHint.Loop"/>.</summary>
 486 /// <value>Loop type of the animated object.</value>
 487     public Efl.Gfx.FrameControllerLoopHint LoopType {
 488         get { return GetLoopType(); }
 489     }
 490     /// <summary>Get the number times the animation of the object loops.
 491 /// 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).
 492 ///
 493 /// If 0 is returned, then looping should happen indefinitely (no limit to the number of times it loops).</summary>
 494 /// <value>The number of loop of an animated object.</value>
 495     public int LoopCount {
 496         get { return GetLoopCount(); }
 497     }
 498     /// <summary>The load size of an image.
 499 /// 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.
 500 ///
 501 /// By default, the load size is not specified, so it is 0x0.</summary>
 502 /// <value>The image load size.</value>
 503     public Eina.Size2D LoadSize {
 504         get { return GetLoadSize(); }
 505         set { SetLoadSize( value); }
 506     }
 507     /// <summary>Get the DPI resolution of a loaded image object in the canvas.
 508 /// This function returns the DPI resolution of the given canvas image.</summary>
 509 /// <value>The DPI resolution.</value>
 510     public double LoadDpi {
 511         get { return GetLoadDpi(); }
 512         set { SetLoadDpi( value); }
 513     }
 514     /// <summary>Indicates whether the <see cref="Efl.Gfx.IImageLoadController.LoadRegion"/> property is supported for the current file.</summary>
 515 /// <value><c>true</c> if region load of the image is supported, <c>false</c> otherwise</value>
 516     public bool LoadRegionSupport {
 517         get { return GetLoadRegionSupport(); }
 518     }
 519     /// <summary>Retrieve the coordinates of a given image object&apos;s selective (source image) load region.</summary>
 520 /// <value>A region of the image.</value>
 521     public Eina.Rect LoadRegion {
 522         get { return GetLoadRegion(); }
 523         set { SetLoadRegion( value); }
 524     }
 525     /// <summary>Defines whether the orientation information in the image file should be honored.
 526 /// 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>
 527 /// <value><c>true</c> means that it should honor the orientation information.</value>
 528     public bool LoadOrientation {
 529         get { return GetLoadOrientation(); }
 530         set { SetLoadOrientation( value); }
 531     }
 532     /// <summary>The scale down factor is a divider on the original image size.
 533 /// Setting the scale down factor can reduce load time and memory usage at the cost of having a scaled down image in memory.
 534 ///
 535 /// 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.
 536 ///
 537 /// Powers of two (2, 4, 8) are best supported (especially with JPEG)</summary>
 538 /// <value>The scale down dividing factor.</value>
 539     public int LoadScaleDown {
 540         get { return GetLoadScaleDown(); }
 541         set { SetLoadScaleDown( value); }
 542     }
 543     /// <summary>Initial load should skip header check and leave it all to data load
 544 /// 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>
 545 /// <value>Will be true if header is to be skipped.</value>
 546     public bool LoadSkipHeader {
 547         get { return GetLoadSkipHeader(); }
 548         set { SetLoadSkipHeader( value); }
 549     }
 550     private static IntPtr GetEflClassStatic()
 551     {
 552         return Efl.Canvas.Image.efl_canvas_image_class_get();
 553     }
 554 }
 555 public class ImageNativeInherit : Efl.Canvas.ImageInternalNativeInherit{
 556     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Evas);
 557     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 558     {
 559         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 560         var methods = Efl.Eo.Globals.GetUserMethods(type);
 561         if (efl_file_mmap_get_static_delegate == null)
 562             efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 563         if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 564             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)});
 565         if (efl_file_mmap_set_static_delegate == null)
 566             efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 567         if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 568             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)});
 569         if (efl_file_get_static_delegate == null)
 570             efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 571         if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 572             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)});
 573         if (efl_file_set_static_delegate == null)
 574             efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 575         if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 576             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)});
 577         if (efl_file_key_get_static_delegate == null)
 578             efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 579         if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 580             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)});
 581         if (efl_file_key_set_static_delegate == null)
 582             efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 583         if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 584             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)});
 585         if (efl_file_loaded_get_static_delegate == null)
 586             efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 587         if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 588             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)});
 589         if (efl_file_load_static_delegate == null)
 590             efl_file_load_static_delegate = new efl_file_load_delegate(load);
 591         if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 592             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)});
 593         if (efl_file_unload_static_delegate == null)
 594             efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 595         if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 596             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)});
 597         if (efl_gfx_frame_controller_animated_get_static_delegate == null)
 598             efl_gfx_frame_controller_animated_get_static_delegate = new efl_gfx_frame_controller_animated_get_delegate(animated_get);
 599         if (methods.FirstOrDefault(m => m.Name == "GetAnimated") != null)
 600             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)});
 601         if (efl_gfx_frame_controller_frame_get_static_delegate == null)
 602             efl_gfx_frame_controller_frame_get_static_delegate = new efl_gfx_frame_controller_frame_get_delegate(frame_get);
 603         if (methods.FirstOrDefault(m => m.Name == "GetFrame") != null)
 604             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)});
 605         if (efl_gfx_frame_controller_frame_set_static_delegate == null)
 606             efl_gfx_frame_controller_frame_set_static_delegate = new efl_gfx_frame_controller_frame_set_delegate(frame_set);
 607         if (methods.FirstOrDefault(m => m.Name == "SetFrame") != null)
 608             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)});
 609         if (efl_gfx_frame_controller_frame_count_get_static_delegate == null)
 610             efl_gfx_frame_controller_frame_count_get_static_delegate = new efl_gfx_frame_controller_frame_count_get_delegate(frame_count_get);
 611         if (methods.FirstOrDefault(m => m.Name == "GetFrameCount") != null)
 612             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)});
 613         if (efl_gfx_frame_controller_loop_type_get_static_delegate == null)
 614             efl_gfx_frame_controller_loop_type_get_static_delegate = new efl_gfx_frame_controller_loop_type_get_delegate(loop_type_get);
 615         if (methods.FirstOrDefault(m => m.Name == "GetLoopType") != null)
 616             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)});
 617         if (efl_gfx_frame_controller_loop_count_get_static_delegate == null)
 618             efl_gfx_frame_controller_loop_count_get_static_delegate = new efl_gfx_frame_controller_loop_count_get_delegate(loop_count_get);
 619         if (methods.FirstOrDefault(m => m.Name == "GetLoopCount") != null)
 620             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)});
 621         if (efl_gfx_frame_controller_frame_duration_get_static_delegate == null)
 622             efl_gfx_frame_controller_frame_duration_get_static_delegate = new efl_gfx_frame_controller_frame_duration_get_delegate(frame_duration_get);
 623         if (methods.FirstOrDefault(m => m.Name == "GetFrameDuration") != null)
 624             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)});
 625         if (efl_gfx_image_load_controller_load_size_get_static_delegate == null)
 626             efl_gfx_image_load_controller_load_size_get_static_delegate = new efl_gfx_image_load_controller_load_size_get_delegate(load_size_get);
 627         if (methods.FirstOrDefault(m => m.Name == "GetLoadSize") != null)
 628             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)});
 629         if (efl_gfx_image_load_controller_load_size_set_static_delegate == null)
 630             efl_gfx_image_load_controller_load_size_set_static_delegate = new efl_gfx_image_load_controller_load_size_set_delegate(load_size_set);
 631         if (methods.FirstOrDefault(m => m.Name == "SetLoadSize") != null)
 632             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)});
 633         if (efl_gfx_image_load_controller_load_dpi_get_static_delegate == null)
 634             efl_gfx_image_load_controller_load_dpi_get_static_delegate = new efl_gfx_image_load_controller_load_dpi_get_delegate(load_dpi_get);
 635         if (methods.FirstOrDefault(m => m.Name == "GetLoadDpi") != null)
 636             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)});
 637         if (efl_gfx_image_load_controller_load_dpi_set_static_delegate == null)
 638             efl_gfx_image_load_controller_load_dpi_set_static_delegate = new efl_gfx_image_load_controller_load_dpi_set_delegate(load_dpi_set);
 639         if (methods.FirstOrDefault(m => m.Name == "SetLoadDpi") != null)
 640             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)});
 641         if (efl_gfx_image_load_controller_load_region_support_get_static_delegate == null)
 642             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);
 643         if (methods.FirstOrDefault(m => m.Name == "GetLoadRegionSupport") != null)
 644             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)});
 645         if (efl_gfx_image_load_controller_load_region_get_static_delegate == null)
 646             efl_gfx_image_load_controller_load_region_get_static_delegate = new efl_gfx_image_load_controller_load_region_get_delegate(load_region_get);
 647         if (methods.FirstOrDefault(m => m.Name == "GetLoadRegion") != null)
 648             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)});
 649         if (efl_gfx_image_load_controller_load_region_set_static_delegate == null)
 650             efl_gfx_image_load_controller_load_region_set_static_delegate = new efl_gfx_image_load_controller_load_region_set_delegate(load_region_set);
 651         if (methods.FirstOrDefault(m => m.Name == "SetLoadRegion") != null)
 652             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)});
 653         if (efl_gfx_image_load_controller_load_orientation_get_static_delegate == null)
 654             efl_gfx_image_load_controller_load_orientation_get_static_delegate = new efl_gfx_image_load_controller_load_orientation_get_delegate(load_orientation_get);
 655         if (methods.FirstOrDefault(m => m.Name == "GetLoadOrientation") != null)
 656             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)});
 657         if (efl_gfx_image_load_controller_load_orientation_set_static_delegate == null)
 658             efl_gfx_image_load_controller_load_orientation_set_static_delegate = new efl_gfx_image_load_controller_load_orientation_set_delegate(load_orientation_set);
 659         if (methods.FirstOrDefault(m => m.Name == "SetLoadOrientation") != null)
 660             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)});
 661         if (efl_gfx_image_load_controller_load_scale_down_get_static_delegate == null)
 662             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);
 663         if (methods.FirstOrDefault(m => m.Name == "GetLoadScaleDown") != null)
 664             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)});
 665         if (efl_gfx_image_load_controller_load_scale_down_set_static_delegate == null)
 666             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);
 667         if (methods.FirstOrDefault(m => m.Name == "SetLoadScaleDown") != null)
 668             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)});
 669         if (efl_gfx_image_load_controller_load_skip_header_get_static_delegate == null)
 670             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);
 671         if (methods.FirstOrDefault(m => m.Name == "GetLoadSkipHeader") != null)
 672             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)});
 673         if (efl_gfx_image_load_controller_load_skip_header_set_static_delegate == null)
 674             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);
 675         if (methods.FirstOrDefault(m => m.Name == "SetLoadSkipHeader") != null)
 676             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)});
 677         if (efl_gfx_image_load_controller_load_async_start_static_delegate == null)
 678             efl_gfx_image_load_controller_load_async_start_static_delegate = new efl_gfx_image_load_controller_load_async_start_delegate(load_async_start);
 679         if (methods.FirstOrDefault(m => m.Name == "LoadAsyncStart") != null)
 680             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)});
 681         if (efl_gfx_image_load_controller_load_async_cancel_static_delegate == null)
 682             efl_gfx_image_load_controller_load_async_cancel_static_delegate = new efl_gfx_image_load_controller_load_async_cancel_delegate(load_async_cancel);
 683         if (methods.FirstOrDefault(m => m.Name == "LoadAsyncCancel") != null)
 684             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)});
 685         descs.AddRange(base.GetEoOps(type));
 686         return descs;
 687     }
 688     public override IntPtr GetEflClass()
 689     {
 690         return Efl.Canvas.Image.efl_canvas_image_class_get();
 691     }
 692     public static new  IntPtr GetEflClassStatic()
 693     {
 694         return Efl.Canvas.Image.efl_canvas_image_class_get();
 695     }
 696
 697
 698      private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 699
 700
 701      public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
 702      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");
 703      private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
 704     {
 705         Eina.Log.Debug("function efl_file_mmap_get was called");
 706         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 707         if(wrapper != null) {
 708                         Eina.File _ret_var = default(Eina.File);
 709             try {
 710                 _ret_var = ((Image)wrapper).GetMmap();
 711             } catch (Exception e) {
 712                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 713                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 714             }
 715         return _ret_var;
 716         } else {
 717             return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 718         }
 719     }
 720     private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
 721
 722
 723      private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.File f);
 724
 725
 726      public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,   Eina.File f);
 727      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");
 728      private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd,  Eina.File f)
 729     {
 730         Eina.Log.Debug("function efl_file_mmap_set was called");
 731         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 732         if(wrapper != null) {
 733                                                 Eina.Error _ret_var = default(Eina.Error);
 734             try {
 735                 _ret_var = ((Image)wrapper).SetMmap( f);
 736             } catch (Exception e) {
 737                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 738                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 739             }
 740                         return _ret_var;
 741         } else {
 742             return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  f);
 743         }
 744     }
 745     private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
 746
 747
 748      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
 749
 750
 751      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
 752      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");
 753      private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
 754     {
 755         Eina.Log.Debug("function efl_file_get was called");
 756         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 757         if(wrapper != null) {
 758                         System.String _ret_var = default(System.String);
 759             try {
 760                 _ret_var = ((Image)wrapper).GetFile();
 761             } catch (Exception e) {
 762                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 763                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 764             }
 765         return _ret_var;
 766         } else {
 767             return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 768         }
 769     }
 770     private static efl_file_get_delegate efl_file_get_static_delegate;
 771
 772
 773      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);
 774
 775
 776      public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String file);
 777      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");
 778      private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd,  System.String file)
 779     {
 780         Eina.Log.Debug("function efl_file_set was called");
 781         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 782         if(wrapper != null) {
 783                                                 Eina.Error _ret_var = default(Eina.Error);
 784             try {
 785                 _ret_var = ((Image)wrapper).SetFile( file);
 786             } catch (Exception e) {
 787                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 788                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 789             }
 790                         return _ret_var;
 791         } else {
 792             return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  file);
 793         }
 794     }
 795     private static efl_file_set_delegate efl_file_set_static_delegate;
 796
 797
 798      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
 799
 800
 801      [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
 802      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");
 803      private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
 804     {
 805         Eina.Log.Debug("function efl_file_key_get was called");
 806         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 807         if(wrapper != null) {
 808                         System.String _ret_var = default(System.String);
 809             try {
 810                 _ret_var = ((Image)wrapper).GetKey();
 811             } catch (Exception e) {
 812                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 813                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 814             }
 815         return _ret_var;
 816         } else {
 817             return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 818         }
 819     }
 820     private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
 821
 822
 823      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);
 824
 825
 826      public delegate void efl_file_key_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]  System.String key);
 827      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");
 828      private static void key_set(System.IntPtr obj, System.IntPtr pd,  System.String key)
 829     {
 830         Eina.Log.Debug("function efl_file_key_set was called");
 831         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 832         if(wrapper != null) {
 833
 834             try {
 835                 ((Image)wrapper).SetKey( key);
 836             } catch (Exception e) {
 837                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 838                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 839             }
 840                                 } else {
 841             efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  key);
 842         }
 843     }
 844     private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
 845
 846
 847      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
 848
 849
 850      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
 851      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");
 852      private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
 853     {
 854         Eina.Log.Debug("function efl_file_loaded_get was called");
 855         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 856         if(wrapper != null) {
 857                         bool _ret_var = default(bool);
 858             try {
 859                 _ret_var = ((Image)wrapper).GetLoaded();
 860             } catch (Exception e) {
 861                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 862                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 863             }
 864         return _ret_var;
 865         } else {
 866             return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 867         }
 868     }
 869     private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
 870
 871
 872      private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
 873
 874
 875      public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
 876      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");
 877      private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
 878     {
 879         Eina.Log.Debug("function efl_file_load was called");
 880         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 881         if(wrapper != null) {
 882                         Eina.Error _ret_var = default(Eina.Error);
 883             try {
 884                 _ret_var = ((Image)wrapper).Load();
 885             } catch (Exception e) {
 886                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 887                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 888             }
 889         return _ret_var;
 890         } else {
 891             return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 892         }
 893     }
 894     private static efl_file_load_delegate efl_file_load_static_delegate;
 895
 896
 897      private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
 898
 899
 900      public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
 901      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");
 902      private static void unload(System.IntPtr obj, System.IntPtr pd)
 903     {
 904         Eina.Log.Debug("function efl_file_unload was called");
 905         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 906         if(wrapper != null) {
 907
 908             try {
 909                 ((Image)wrapper).Unload();
 910             } catch (Exception e) {
 911                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 912                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 913             }
 914                 } else {
 915             efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 916         }
 917     }
 918     private static efl_file_unload_delegate efl_file_unload_static_delegate;
 919
 920
 921      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_frame_controller_animated_get_delegate(System.IntPtr obj, System.IntPtr pd);
 922
 923
 924      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_frame_controller_animated_get_api_delegate(System.IntPtr obj);
 925      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");
 926      private static bool animated_get(System.IntPtr obj, System.IntPtr pd)
 927     {
 928         Eina.Log.Debug("function efl_gfx_frame_controller_animated_get was called");
 929         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 930         if(wrapper != null) {
 931                         bool _ret_var = default(bool);
 932             try {
 933                 _ret_var = ((Image)wrapper).GetAnimated();
 934             } catch (Exception e) {
 935                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 936                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 937             }
 938         return _ret_var;
 939         } else {
 940             return efl_gfx_frame_controller_animated_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 941         }
 942     }
 943     private static efl_gfx_frame_controller_animated_get_delegate efl_gfx_frame_controller_animated_get_static_delegate;
 944
 945
 946      private delegate int efl_gfx_frame_controller_frame_get_delegate(System.IntPtr obj, System.IntPtr pd);
 947
 948
 949      public delegate int efl_gfx_frame_controller_frame_get_api_delegate(System.IntPtr obj);
 950      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");
 951      private static int frame_get(System.IntPtr obj, System.IntPtr pd)
 952     {
 953         Eina.Log.Debug("function efl_gfx_frame_controller_frame_get was called");
 954         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 955         if(wrapper != null) {
 956                         int _ret_var = default(int);
 957             try {
 958                 _ret_var = ((Image)wrapper).GetFrame();
 959             } catch (Exception e) {
 960                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 961                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 962             }
 963         return _ret_var;
 964         } else {
 965             return efl_gfx_frame_controller_frame_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 966         }
 967     }
 968     private static efl_gfx_frame_controller_frame_get_delegate efl_gfx_frame_controller_frame_get_static_delegate;
 969
 970
 971      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_frame_controller_frame_set_delegate(System.IntPtr obj, System.IntPtr pd,   int frame_index);
 972
 973
 974      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_frame_controller_frame_set_api_delegate(System.IntPtr obj,   int frame_index);
 975      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");
 976      private static bool frame_set(System.IntPtr obj, System.IntPtr pd,  int frame_index)
 977     {
 978         Eina.Log.Debug("function efl_gfx_frame_controller_frame_set was called");
 979         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 980         if(wrapper != null) {
 981                                                 bool _ret_var = default(bool);
 982             try {
 983                 _ret_var = ((Image)wrapper).SetFrame( frame_index);
 984             } catch (Exception e) {
 985                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 986                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 987             }
 988                         return _ret_var;
 989         } else {
 990             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);
 991         }
 992     }
 993     private static efl_gfx_frame_controller_frame_set_delegate efl_gfx_frame_controller_frame_set_static_delegate;
 994
 995
 996      private delegate int efl_gfx_frame_controller_frame_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
 997
 998
 999      public delegate int efl_gfx_frame_controller_frame_count_get_api_delegate(System.IntPtr obj);
1000      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");
1001      private static int frame_count_get(System.IntPtr obj, System.IntPtr pd)
1002     {
1003         Eina.Log.Debug("function efl_gfx_frame_controller_frame_count_get was called");
1004         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1005         if(wrapper != null) {
1006                         int _ret_var = default(int);
1007             try {
1008                 _ret_var = ((Image)wrapper).GetFrameCount();
1009             } catch (Exception e) {
1010                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1011                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1012             }
1013         return _ret_var;
1014         } else {
1015             return efl_gfx_frame_controller_frame_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1016         }
1017     }
1018     private static efl_gfx_frame_controller_frame_count_get_delegate efl_gfx_frame_controller_frame_count_get_static_delegate;
1019
1020
1021      private delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
1022
1023
1024      public delegate Efl.Gfx.FrameControllerLoopHint efl_gfx_frame_controller_loop_type_get_api_delegate(System.IntPtr obj);
1025      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");
1026      private static Efl.Gfx.FrameControllerLoopHint loop_type_get(System.IntPtr obj, System.IntPtr pd)
1027     {
1028         Eina.Log.Debug("function efl_gfx_frame_controller_loop_type_get was called");
1029         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1030         if(wrapper != null) {
1031                         Efl.Gfx.FrameControllerLoopHint _ret_var = default(Efl.Gfx.FrameControllerLoopHint);
1032             try {
1033                 _ret_var = ((Image)wrapper).GetLoopType();
1034             } catch (Exception e) {
1035                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1036                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1037             }
1038         return _ret_var;
1039         } else {
1040             return efl_gfx_frame_controller_loop_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1041         }
1042     }
1043     private static efl_gfx_frame_controller_loop_type_get_delegate efl_gfx_frame_controller_loop_type_get_static_delegate;
1044
1045
1046      private delegate int efl_gfx_frame_controller_loop_count_get_delegate(System.IntPtr obj, System.IntPtr pd);
1047
1048
1049      public delegate int efl_gfx_frame_controller_loop_count_get_api_delegate(System.IntPtr obj);
1050      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");
1051      private static int loop_count_get(System.IntPtr obj, System.IntPtr pd)
1052     {
1053         Eina.Log.Debug("function efl_gfx_frame_controller_loop_count_get was called");
1054         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1055         if(wrapper != null) {
1056                         int _ret_var = default(int);
1057             try {
1058                 _ret_var = ((Image)wrapper).GetLoopCount();
1059             } catch (Exception e) {
1060                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1061                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1062             }
1063         return _ret_var;
1064         } else {
1065             return efl_gfx_frame_controller_loop_count_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1066         }
1067     }
1068     private static efl_gfx_frame_controller_loop_count_get_delegate efl_gfx_frame_controller_loop_count_get_static_delegate;
1069
1070
1071      private delegate double efl_gfx_frame_controller_frame_duration_get_delegate(System.IntPtr obj, System.IntPtr pd,   int start_frame,   int frame_num);
1072
1073
1074      public delegate double efl_gfx_frame_controller_frame_duration_get_api_delegate(System.IntPtr obj,   int start_frame,   int frame_num);
1075      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");
1076      private static double frame_duration_get(System.IntPtr obj, System.IntPtr pd,  int start_frame,  int frame_num)
1077     {
1078         Eina.Log.Debug("function efl_gfx_frame_controller_frame_duration_get was called");
1079         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1080         if(wrapper != null) {
1081                                                                         double _ret_var = default(double);
1082             try {
1083                 _ret_var = ((Image)wrapper).GetFrameDuration( start_frame,  frame_num);
1084             } catch (Exception e) {
1085                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1086                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1087             }
1088                                         return _ret_var;
1089         } else {
1090             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);
1091         }
1092     }
1093     private static efl_gfx_frame_controller_frame_duration_get_delegate efl_gfx_frame_controller_frame_duration_get_static_delegate;
1094
1095
1096      private delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1097
1098
1099      public delegate Eina.Size2D.NativeStruct efl_gfx_image_load_controller_load_size_get_api_delegate(System.IntPtr obj);
1100      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");
1101      private static Eina.Size2D.NativeStruct load_size_get(System.IntPtr obj, System.IntPtr pd)
1102     {
1103         Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_get was called");
1104         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1105         if(wrapper != null) {
1106                         Eina.Size2D _ret_var = default(Eina.Size2D);
1107             try {
1108                 _ret_var = ((Image)wrapper).GetLoadSize();
1109             } catch (Exception e) {
1110                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1111                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1112             }
1113         return _ret_var;
1114         } else {
1115             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)));
1116         }
1117     }
1118     private static efl_gfx_image_load_controller_load_size_get_delegate efl_gfx_image_load_controller_load_size_get_static_delegate;
1119
1120
1121      private delegate void efl_gfx_image_load_controller_load_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D.NativeStruct size);
1122
1123
1124      public delegate void efl_gfx_image_load_controller_load_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D.NativeStruct size);
1125      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");
1126      private static void load_size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size)
1127     {
1128         Eina.Log.Debug("function efl_gfx_image_load_controller_load_size_set was called");
1129         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1130         if(wrapper != null) {
1131                     Eina.Size2D _in_size = size;
1132
1133             try {
1134                 ((Image)wrapper).SetLoadSize( _in_size);
1135             } catch (Exception e) {
1136                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1137                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1138             }
1139                                 } else {
1140             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);
1141         }
1142     }
1143     private static efl_gfx_image_load_controller_load_size_set_delegate efl_gfx_image_load_controller_load_size_set_static_delegate;
1144
1145
1146      private delegate double efl_gfx_image_load_controller_load_dpi_get_delegate(System.IntPtr obj, System.IntPtr pd);
1147
1148
1149      public delegate double efl_gfx_image_load_controller_load_dpi_get_api_delegate(System.IntPtr obj);
1150      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");
1151      private static double load_dpi_get(System.IntPtr obj, System.IntPtr pd)
1152     {
1153         Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_get was called");
1154         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1155         if(wrapper != null) {
1156                         double _ret_var = default(double);
1157             try {
1158                 _ret_var = ((Image)wrapper).GetLoadDpi();
1159             } catch (Exception e) {
1160                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1161                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1162             }
1163         return _ret_var;
1164         } else {
1165             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)));
1166         }
1167     }
1168     private static efl_gfx_image_load_controller_load_dpi_get_delegate efl_gfx_image_load_controller_load_dpi_get_static_delegate;
1169
1170
1171      private delegate void efl_gfx_image_load_controller_load_dpi_set_delegate(System.IntPtr obj, System.IntPtr pd,   double dpi);
1172
1173
1174      public delegate void efl_gfx_image_load_controller_load_dpi_set_api_delegate(System.IntPtr obj,   double dpi);
1175      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");
1176      private static void load_dpi_set(System.IntPtr obj, System.IntPtr pd,  double dpi)
1177     {
1178         Eina.Log.Debug("function efl_gfx_image_load_controller_load_dpi_set was called");
1179         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1180         if(wrapper != null) {
1181
1182             try {
1183                 ((Image)wrapper).SetLoadDpi( dpi);
1184             } catch (Exception e) {
1185                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1186                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1187             }
1188                                 } else {
1189             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);
1190         }
1191     }
1192     private static efl_gfx_image_load_controller_load_dpi_set_delegate efl_gfx_image_load_controller_load_dpi_set_static_delegate;
1193
1194
1195      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_image_load_controller_load_region_support_get_delegate(System.IntPtr obj, System.IntPtr pd);
1196
1197
1198      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_image_load_controller_load_region_support_get_api_delegate(System.IntPtr obj);
1199      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");
1200      private static bool load_region_support_get(System.IntPtr obj, System.IntPtr pd)
1201     {
1202         Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_support_get was called");
1203         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1204         if(wrapper != null) {
1205                         bool _ret_var = default(bool);
1206             try {
1207                 _ret_var = ((Image)wrapper).GetLoadRegionSupport();
1208             } catch (Exception e) {
1209                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1210                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1211             }
1212         return _ret_var;
1213         } else {
1214             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)));
1215         }
1216     }
1217     private static efl_gfx_image_load_controller_load_region_support_get_delegate efl_gfx_image_load_controller_load_region_support_get_static_delegate;
1218
1219
1220      private delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
1221
1222
1223      public delegate Eina.Rect.NativeStruct efl_gfx_image_load_controller_load_region_get_api_delegate(System.IntPtr obj);
1224      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");
1225      private static Eina.Rect.NativeStruct load_region_get(System.IntPtr obj, System.IntPtr pd)
1226     {
1227         Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_get was called");
1228         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1229         if(wrapper != null) {
1230                         Eina.Rect _ret_var = default(Eina.Rect);
1231             try {
1232                 _ret_var = ((Image)wrapper).GetLoadRegion();
1233             } catch (Exception e) {
1234                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1235                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1236             }
1237         return _ret_var;
1238         } else {
1239             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)));
1240         }
1241     }
1242     private static efl_gfx_image_load_controller_load_region_get_delegate efl_gfx_image_load_controller_load_region_get_static_delegate;
1243
1244
1245      private delegate void efl_gfx_image_load_controller_load_region_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Rect.NativeStruct region);
1246
1247
1248      public delegate void efl_gfx_image_load_controller_load_region_set_api_delegate(System.IntPtr obj,   Eina.Rect.NativeStruct region);
1249      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");
1250      private static void load_region_set(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct region)
1251     {
1252         Eina.Log.Debug("function efl_gfx_image_load_controller_load_region_set was called");
1253         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1254         if(wrapper != null) {
1255                     Eina.Rect _in_region = region;
1256
1257             try {
1258                 ((Image)wrapper).SetLoadRegion( _in_region);
1259             } catch (Exception e) {
1260                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1261                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1262             }
1263                                 } else {
1264             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);
1265         }
1266     }
1267     private static efl_gfx_image_load_controller_load_region_set_delegate efl_gfx_image_load_controller_load_region_set_static_delegate;
1268
1269
1270      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_image_load_controller_load_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1271
1272
1273      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_image_load_controller_load_orientation_get_api_delegate(System.IntPtr obj);
1274      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");
1275      private static bool load_orientation_get(System.IntPtr obj, System.IntPtr pd)
1276     {
1277         Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_get was called");
1278         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1279         if(wrapper != null) {
1280                         bool _ret_var = default(bool);
1281             try {
1282                 _ret_var = ((Image)wrapper).GetLoadOrientation();
1283             } catch (Exception e) {
1284                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1285                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1286             }
1287         return _ret_var;
1288         } else {
1289             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)));
1290         }
1291     }
1292     private static efl_gfx_image_load_controller_load_orientation_get_delegate efl_gfx_image_load_controller_load_orientation_get_static_delegate;
1293
1294
1295      private delegate void efl_gfx_image_load_controller_load_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool enable);
1296
1297
1298      public delegate void efl_gfx_image_load_controller_load_orientation_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool enable);
1299      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");
1300      private static void load_orientation_set(System.IntPtr obj, System.IntPtr pd,  bool enable)
1301     {
1302         Eina.Log.Debug("function efl_gfx_image_load_controller_load_orientation_set was called");
1303         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1304         if(wrapper != null) {
1305
1306             try {
1307                 ((Image)wrapper).SetLoadOrientation( enable);
1308             } catch (Exception e) {
1309                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1310                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1311             }
1312                                 } else {
1313             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);
1314         }
1315     }
1316     private static efl_gfx_image_load_controller_load_orientation_set_delegate efl_gfx_image_load_controller_load_orientation_set_static_delegate;
1317
1318
1319      private delegate int efl_gfx_image_load_controller_load_scale_down_get_delegate(System.IntPtr obj, System.IntPtr pd);
1320
1321
1322      public delegate int efl_gfx_image_load_controller_load_scale_down_get_api_delegate(System.IntPtr obj);
1323      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");
1324      private static int load_scale_down_get(System.IntPtr obj, System.IntPtr pd)
1325     {
1326         Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_get was called");
1327         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1328         if(wrapper != null) {
1329                         int _ret_var = default(int);
1330             try {
1331                 _ret_var = ((Image)wrapper).GetLoadScaleDown();
1332             } catch (Exception e) {
1333                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1334                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1335             }
1336         return _ret_var;
1337         } else {
1338             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)));
1339         }
1340     }
1341     private static efl_gfx_image_load_controller_load_scale_down_get_delegate efl_gfx_image_load_controller_load_scale_down_get_static_delegate;
1342
1343
1344      private delegate void efl_gfx_image_load_controller_load_scale_down_set_delegate(System.IntPtr obj, System.IntPtr pd,   int div);
1345
1346
1347      public delegate void efl_gfx_image_load_controller_load_scale_down_set_api_delegate(System.IntPtr obj,   int div);
1348      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");
1349      private static void load_scale_down_set(System.IntPtr obj, System.IntPtr pd,  int div)
1350     {
1351         Eina.Log.Debug("function efl_gfx_image_load_controller_load_scale_down_set was called");
1352         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1353         if(wrapper != null) {
1354
1355             try {
1356                 ((Image)wrapper).SetLoadScaleDown( div);
1357             } catch (Exception e) {
1358                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1359                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1360             }
1361                                 } else {
1362             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);
1363         }
1364     }
1365     private static efl_gfx_image_load_controller_load_scale_down_set_delegate efl_gfx_image_load_controller_load_scale_down_set_static_delegate;
1366
1367
1368      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_image_load_controller_load_skip_header_get_delegate(System.IntPtr obj, System.IntPtr pd);
1369
1370
1371      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_image_load_controller_load_skip_header_get_api_delegate(System.IntPtr obj);
1372      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");
1373      private static bool load_skip_header_get(System.IntPtr obj, System.IntPtr pd)
1374     {
1375         Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_get was called");
1376         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1377         if(wrapper != null) {
1378                         bool _ret_var = default(bool);
1379             try {
1380                 _ret_var = ((Image)wrapper).GetLoadSkipHeader();
1381             } catch (Exception e) {
1382                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1383                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1384             }
1385         return _ret_var;
1386         } else {
1387             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)));
1388         }
1389     }
1390     private static efl_gfx_image_load_controller_load_skip_header_get_delegate efl_gfx_image_load_controller_load_skip_header_get_static_delegate;
1391
1392
1393      private delegate void efl_gfx_image_load_controller_load_skip_header_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool skip);
1394
1395
1396      public delegate void efl_gfx_image_load_controller_load_skip_header_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool skip);
1397      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");
1398      private static void load_skip_header_set(System.IntPtr obj, System.IntPtr pd,  bool skip)
1399     {
1400         Eina.Log.Debug("function efl_gfx_image_load_controller_load_skip_header_set was called");
1401         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1402         if(wrapper != null) {
1403
1404             try {
1405                 ((Image)wrapper).SetLoadSkipHeader( skip);
1406             } catch (Exception e) {
1407                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1408                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1409             }
1410                                 } else {
1411             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);
1412         }
1413     }
1414     private static efl_gfx_image_load_controller_load_skip_header_set_delegate efl_gfx_image_load_controller_load_skip_header_set_static_delegate;
1415
1416
1417      private delegate void efl_gfx_image_load_controller_load_async_start_delegate(System.IntPtr obj, System.IntPtr pd);
1418
1419
1420      public delegate void efl_gfx_image_load_controller_load_async_start_api_delegate(System.IntPtr obj);
1421      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");
1422      private static void load_async_start(System.IntPtr obj, System.IntPtr pd)
1423     {
1424         Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_start was called");
1425         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1426         if(wrapper != null) {
1427
1428             try {
1429                 ((Image)wrapper).LoadAsyncStart();
1430             } catch (Exception e) {
1431                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1432                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1433             }
1434                 } else {
1435             efl_gfx_image_load_controller_load_async_start_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1436         }
1437     }
1438     private static efl_gfx_image_load_controller_load_async_start_delegate efl_gfx_image_load_controller_load_async_start_static_delegate;
1439
1440
1441      private delegate void efl_gfx_image_load_controller_load_async_cancel_delegate(System.IntPtr obj, System.IntPtr pd);
1442
1443
1444      public delegate void efl_gfx_image_load_controller_load_async_cancel_api_delegate(System.IntPtr obj);
1445      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");
1446      private static void load_async_cancel(System.IntPtr obj, System.IntPtr pd)
1447     {
1448         Eina.Log.Debug("function efl_gfx_image_load_controller_load_async_cancel was called");
1449         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1450         if(wrapper != null) {
1451
1452             try {
1453                 ((Image)wrapper).LoadAsyncCancel();
1454             } catch (Exception e) {
1455                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1456                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1457             }
1458                 } else {
1459             efl_gfx_image_load_controller_load_async_cancel_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1460         }
1461     }
1462     private static efl_gfx_image_load_controller_load_async_cancel_delegate efl_gfx_image_load_controller_load_async_cancel_static_delegate;
1463 }
1464 } }