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

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