internals/src/EflSharp/EflSharp/efl/efl_canvas_image_internal.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>Efl canvas internal image class</summary>
  13 [Efl.Canvas.ImageInternal.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public abstract class ImageInternal : Efl.Canvas.Object, Efl.IFileSave, Efl.Canvas.Filter.IInternal, Efl.Gfx.IBuffer, Efl.Gfx.IFill, Efl.Gfx.IFilter, Efl.Gfx.IImage, Efl.Gfx.IImageOrientable, Efl.Gfx.IView
  16 {
  17     ///<summary>Pointer to the native class description.</summary>
  18     public override System.IntPtr NativeClass
  19     {
  20         get
  21         {
  22             if (((object)this).GetType() == typeof(ImageInternal))
  23             {
  24                 return GetEflClassStatic();
  25             }
  26             else
  27             {
  28                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  29             }
  30         }
  31     }
  32
  33     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  34         efl_canvas_image_internal_class_get();
  35     /// <summary>Initializes a new instance of the <see cref="ImageInternal"/> class.</summary>
  36     /// <param name="parent">Parent instance.</param>
  37     public ImageInternal(Efl.Object parent= null
  38             ) : base(efl_canvas_image_internal_class_get(), parent)
  39     {
  40         FinishInstantiation();
  41     }
  42
  43     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  44     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  45     protected ImageInternal(ConstructingHandle ch) : base(ch)
  46     {
  47     }
  48
  49     /// <summary>Initializes a new instance of the <see cref="ImageInternal"/> class.
  50     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  51     /// <param name="wh">The native pointer to be wrapped.</param>
  52     protected ImageInternal(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  53     {
  54     }
  55
  56     [Efl.Eo.PrivateNativeClass]
  57     private class ImageInternalRealized : ImageInternal
  58     {
  59         private ImageInternalRealized(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  60         {
  61         }
  62     }
  63     /// <summary>Initializes a new instance of the <see cref="ImageInternal"/> class.
  64     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  65     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  66     /// <param name="parent">The Efl.Object parent of this instance.</param>
  67     protected ImageInternal(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  68     {
  69     }
  70
  71     /// <summary>Image data has been preloaded.</summary>
  72     public event EventHandler ImagePreloadEvt
  73     {
  74         add
  75         {
  76             lock (eflBindingEventLock)
  77             {
  78                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  79                 {
  80                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  81                     if (obj != null)
  82                     {
  83                         EventArgs args = EventArgs.Empty;
  84                         try
  85                         {
  86                             value?.Invoke(obj, args);
  87                         }
  88                         catch (Exception e)
  89                         {
  90                             Eina.Log.Error(e.ToString());
  91                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  92                         }
  93                     }
  94                 };
  95
  96                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  97                 AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
  98             }
  99         }
 100
 101         remove
 102         {
 103             lock (eflBindingEventLock)
 104             {
 105                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 106                 RemoveNativeEventHandler(efl.Libs.Evas, key, value);
 107             }
 108         }
 109     }
 110     ///<summary>Method to raise event ImagePreloadEvt.</summary>
 111     public void OnImagePreloadEvt(EventArgs e)
 112     {
 113         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
 114         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
 115         if (desc == IntPtr.Zero)
 116         {
 117             Eina.Log.Error($"Failed to get native event {key}");
 118             return;
 119         }
 120
 121         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 122     }
 123     /// <summary>Image was resized (its pixel data).</summary>
 124     public event EventHandler ImageResizeEvt
 125     {
 126         add
 127         {
 128             lock (eflBindingEventLock)
 129             {
 130                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 131                 {
 132                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 133                     if (obj != null)
 134                     {
 135                         EventArgs args = EventArgs.Empty;
 136                         try
 137                         {
 138                             value?.Invoke(obj, args);
 139                         }
 140                         catch (Exception e)
 141                         {
 142                             Eina.Log.Error(e.ToString());
 143                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 144                         }
 145                     }
 146                 };
 147
 148                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 149                 AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
 150             }
 151         }
 152
 153         remove
 154         {
 155             lock (eflBindingEventLock)
 156             {
 157                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 158                 RemoveNativeEventHandler(efl.Libs.Evas, key, value);
 159             }
 160         }
 161     }
 162     ///<summary>Method to raise event ImageResizeEvt.</summary>
 163     public void OnImageResizeEvt(EventArgs e)
 164     {
 165         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 166         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
 167         if (desc == IntPtr.Zero)
 168         {
 169             Eina.Log.Error($"Failed to get native event {key}");
 170             return;
 171         }
 172
 173         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 174     }
 175     /// <summary>Image data has been unloaded (by some mechanism in EFL that threw out the original image data).</summary>
 176     public event EventHandler ImageUnloadEvt
 177     {
 178         add
 179         {
 180             lock (eflBindingEventLock)
 181             {
 182                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 183                 {
 184                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 185                     if (obj != null)
 186                     {
 187                         EventArgs args = EventArgs.Empty;
 188                         try
 189                         {
 190                             value?.Invoke(obj, args);
 191                         }
 192                         catch (Exception e)
 193                         {
 194                             Eina.Log.Error(e.ToString());
 195                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 196                         }
 197                     }
 198                 };
 199
 200                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 201                 AddNativeEventHandler(efl.Libs.Evas, key, callerCb, value);
 202             }
 203         }
 204
 205         remove
 206         {
 207             lock (eflBindingEventLock)
 208             {
 209                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 210                 RemoveNativeEventHandler(efl.Libs.Evas, key, value);
 211             }
 212         }
 213     }
 214     ///<summary>Method to raise event ImageUnloadEvt.</summary>
 215     public void OnImageUnloadEvt(EventArgs e)
 216     {
 217         var key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 218         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Evas, key);
 219         if (desc == IntPtr.Zero)
 220         {
 221             Eina.Log.Error($"Failed to get native event {key}");
 222             return;
 223         }
 224
 225         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 226     }
 227     /// <summary>Save the given image object&apos;s contents to an (image) file.
 228     /// The extension suffix on <c>file</c> will determine which saver module Evas is to use when saving, thus the final file&apos;s format. If the file supports multiple data stored in it (Eet ones), you can specify the key to be used as the index of the image in it.
 229     ///
 230     /// You can specify some flags when saving the image.  Currently acceptable flags are <c>quality</c> and <c>compress</c>. Eg.: &quot;quality=100 compress=9&quot;.
 231     /// (Since EFL 1.22)</summary>
 232     /// <param name="file">The filename to be used to save the image (extension obligatory).</param>
 233     /// <param name="key">The image key in the file (if an Eet one), or <c>null</c>, otherwise.</param>
 234     /// <param name="info">The flags to be used (<c>null</c> for defaults).</param>
 235     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 236     virtual public bool Save(System.String file, System.String key, ref Efl.FileSaveInfo info) {
 237                          Efl.FileSaveInfo.NativeStruct _in_info = info;
 238                                                         var _ret_var = Efl.IFileSaveConcrete.NativeMethods.efl_file_save_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),file, key, ref _in_info);
 239         Eina.Error.RaiseIfUnhandledException();
 240                                                 info = _in_info;
 241         return _ret_var;
 242  }
 243     /// <summary>Marks this filter as changed.</summary>
 244     /// <param name="val"><c>true</c> if filter changed, <c>false</c> otherwise</param>
 245     virtual public void SetFilterChanged(bool val) {
 246                                  Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_changed_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 247         Eina.Error.RaiseIfUnhandledException();
 248                          }
 249     /// <summary>Marks this filter as invalid.</summary>
 250     /// <param name="val"><c>true</c> if filter is invalid, <c>false</c> otherwise</param>
 251     virtual public void SetFilterInvalid(bool val) {
 252                                  Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_invalid_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),val);
 253         Eina.Error.RaiseIfUnhandledException();
 254                          }
 255     /// <summary>Retrieve cached output buffer, if any.
 256     /// Does not increment the reference count.</summary>
 257     /// <returns>Output buffer</returns>
 258     virtual public System.IntPtr GetFilterOutputBuffer() {
 259          var _ret_var = Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_output_buffer_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 260         Eina.Error.RaiseIfUnhandledException();
 261         return _ret_var;
 262  }
 263     /// <summary>Called by Efl.Canvas.Filter.Internal to determine whether the input is alpha or rgba.</summary>
 264     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 265     virtual public bool FilterInputAlpha() {
 266          var _ret_var = Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_input_alpha_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>Called by Efl.Canvas.Filter.Internal to request the parent class for state information (color, etc...).</summary>
 271     /// <param name="state">State info to fill in</param>
 272     /// <param name="data">Private data for the class</param>
 273     virtual public void FilterStatePrepare(out Efl.Canvas.Filter.State state, System.IntPtr data) {
 274                          var _out_state = new Efl.Canvas.Filter.State.NativeStruct();
 275                                 Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_state_prepare_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out _out_state, data);
 276         Eina.Error.RaiseIfUnhandledException();
 277         state = _out_state;
 278                                  }
 279     /// <summary>Called by Efl.Canvas.Filter.Internal when the parent class must render the input.</summary>
 280     /// <param name="filter">Current filter context</param>
 281     /// <param name="engine">Engine context</param>
 282     /// <param name="output">Output context</param>
 283     /// <param name="drawctx">Draw context (for evas engine)</param>
 284     /// <param name="data">Private data used by textblock</param>
 285     /// <param name="l">Left</param>
 286     /// <param name="r">Right</param>
 287     /// <param name="t">Top</param>
 288     /// <param name="b">Bottom</param>
 289     /// <param name="x">X offset</param>
 290     /// <param name="y">Y offset</param>
 291     /// <param name="do_async"><c>true</c> when the operation should be done asynchronously, <c>false</c> otherwise</param>
 292     /// <returns>Indicates success from the object render function.</returns>
 293     virtual public bool FilterInputRender(System.IntPtr filter, System.IntPtr engine, System.IntPtr output, System.IntPtr drawctx, System.IntPtr data, int l, int r, int t, int b, int x, int y, bool do_async) {
 294                                                                                                                                                                                                                                                                                                          var _ret_var = Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_input_render_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),filter, engine, output, drawctx, data, l, r, t, b, x, y, do_async);
 295         Eina.Error.RaiseIfUnhandledException();
 296                                                                                                                                                                                                         return _ret_var;
 297  }
 298     /// <summary>Called when filter changes must trigger a redraw of the object.
 299     /// Virtual, to be implemented in the parent class.</summary>
 300     virtual public void FilterDirty() {
 301          Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_dirty_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 302         Eina.Error.RaiseIfUnhandledException();
 303          }
 304     /// <summary>Rectangular size of the pixel buffer as allocated in memory.</summary>
 305     /// <returns>Size of the buffer in pixels.</returns>
 306     virtual public Eina.Size2D GetBufferSize() {
 307          var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 308         Eina.Error.RaiseIfUnhandledException();
 309         return _ret_var;
 310  }
 311     /// <summary>Potentially not implemented, <see cref="Efl.Gfx.IBuffer.BufferSize"/> may be read-only.</summary>
 312     /// <param name="sz">Size of the buffer in pixels.</param>
 313     virtual public void SetBufferSize(Eina.Size2D sz) {
 314          Eina.Size2D.NativeStruct _in_sz = sz;
 315                         Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_size_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_sz);
 316         Eina.Error.RaiseIfUnhandledException();
 317                          }
 318     /// <summary>Returns the current encoding of this buffer&apos;s pixels.
 319     /// See <see cref="Efl.Gfx.Colorspace"/> for more information on the supported formats.</summary>
 320     /// <returns>Colorspace</returns>
 321     virtual public Efl.Gfx.Colorspace GetColorspace() {
 322          var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_colorspace_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 323         Eina.Error.RaiseIfUnhandledException();
 324         return _ret_var;
 325  }
 326     /// <summary>Retrieve whether alpha channel data is used on this object.</summary>
 327     /// <returns>Whether to use alpha channel (<c>true</c>) data or not (<c>false</c>).</returns>
 328     virtual public bool GetAlpha() {
 329          var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_alpha_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 330         Eina.Error.RaiseIfUnhandledException();
 331         return _ret_var;
 332  }
 333     /// <summary>Change alpha channel usage for this object.
 334     /// This function sets a flag on an image object indicating whether or not to use alpha channel data. A value of <c>true</c> makes it use alpha channel data, and <c>false</c> makes it ignore that data. Note that this has nothing to do with an object&apos;s color as manipulated by <see cref="Efl.Gfx.IColor.GetColor"/>.</summary>
 335     /// <param name="alpha">Whether to use alpha channel (<c>true</c>) data or not (<c>false</c>).</param>
 336     virtual public void SetAlpha(bool alpha) {
 337                                  Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_alpha_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),alpha);
 338         Eina.Error.RaiseIfUnhandledException();
 339                          }
 340     /// <summary>Length in bytes of one row of pixels in memory.
 341     /// Usually this will be equal to width * 4, with a plain BGRA image. This may return 0 if the stride is not applicable.
 342     ///
 343     /// When applicable, this will include the <see cref="Efl.Gfx.IBuffer.GetBufferBorders"/> as well as potential extra padding.</summary>
 344     /// <returns>Stride</returns>
 345     virtual public int GetStride() {
 346          var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_stride_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 347         Eina.Error.RaiseIfUnhandledException();
 348         return _ret_var;
 349  }
 350     /// <summary>Duplicated pixel borders inside this buffer.
 351     /// Internally, EFL may require an image to have its border pixels duplicated, in particular for GL textures. This property exposes the internal duplicated borders to allow calling <see cref="Efl.Gfx.IBuffer.BufferMap"/> with the entire pixel data, including those edge pixels.</summary>
 352     /// <param name="l">Left border pixels, usually 0 or 1</param>
 353     /// <param name="r">Right border pixels, usually 0 or 1</param>
 354     /// <param name="t">Top border pixels, usually 0 or 1</param>
 355     /// <param name="b">Bottom border pixels, usually 0 or 1</param>
 356     virtual public void GetBufferBorders(out uint l, out uint r, out uint t, out uint b) {
 357                                                                                                          Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_borders_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out l, out r, out t, out b);
 358         Eina.Error.RaiseIfUnhandledException();
 359                                                                          }
 360     /// <summary>Mark a sub-region of the given image object to be redrawn.
 361     /// This function schedules a particular rectangular region of an image object to be updated (redrawn) at the next rendering cycle.</summary>
 362     /// <param name="region">The updated region.</param>
 363     virtual public void AddBufferUpdate(ref Eina.Rect region) {
 364          Eina.Rect.NativeStruct _in_region = region;
 365                         Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_update_add_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),ref _in_region);
 366         Eina.Error.RaiseIfUnhandledException();
 367                 region = _in_region;
 368          }
 369     /// <summary>Map a region of this buffer for read or write access by the CPU.
 370     /// Fetches data from the GPU if needed. This operation may be slow if cpu_readable_fast or cpu_writeable_fast are not true, or if the required colorspace is different from the internal one.
 371     ///
 372     /// Note that if the buffer has <see cref="Efl.Gfx.IBuffer.GetBufferBorders"/>, then <c>x</c> and <c>y</c> may be negative.</summary>
 373     /// <param name="mode">Specifies whether to map for read-only, write-only or read-write access (OR combination of flags).</param>
 374     /// <param name="region">The region to map.</param>
 375     /// <param name="cspace">Requested colorspace. If different from the internal cspace, map should try to convert the data into a new buffer. argb8888 by default.</param>
 376     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 377     /// <param name="stride">Returns the length in bytes of a mapped line</param>
 378     /// <returns>The data slice. In case of failure, the memory pointer will be <c>null</c>.</returns>
 379     virtual public Eina.RwSlice BufferMap(Efl.Gfx.BufferAccessMode mode, ref Eina.Rect region, Efl.Gfx.Colorspace cspace, int plane, out int stride) {
 380                  Eina.Rect.NativeStruct _in_region = region;
 381                                                                                                                 var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_map_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),mode, ref _in_region, cspace, plane, out stride);
 382         Eina.Error.RaiseIfUnhandledException();
 383                                                         region = _in_region;
 384                                 return _ret_var;
 385  }
 386     /// <summary>Unmap a region of this buffer, and update the internal data if needed.
 387     /// EFL will update the internal image if the map had write access.
 388     ///
 389     /// Note: The <c>slice</c> struct does not need to be the one returned by <see cref="Efl.Gfx.IBuffer.BufferMap"/>, only its contents (<c>mem</c> and <c>len</c>) must match. But after a call to <see cref="Efl.Gfx.IBuffer.BufferUnmap"/> the original <c>slice</c> structure is not valid anymore.</summary>
 390     /// <param name="slice">Data slice returned by a previous call to map.</param>
 391     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 392     virtual public bool BufferUnmap(Eina.RwSlice slice) {
 393                                  var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_unmap_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),slice);
 394         Eina.Error.RaiseIfUnhandledException();
 395                         return _ret_var;
 396  }
 397     /// <summary>Set the pixels for this buffer by copying them, or allocate a new memory region.
 398     /// This will allocate a new buffer in memory and copy the input <c>pixels</c> to it. The internal colorspace is not guaranteed to be preserved, and colorspace conversion may happen internally.
 399     ///
 400     /// If <c>pixels</c> is <c>null</c>, then a new empty buffer will be allocated. If the buffer already had pixel data, the previous image data will be dropped. This is the same as <see cref="Efl.Gfx.IBuffer.SetBufferManaged"/>.
 401     ///
 402     /// The memory buffer <c>pixels</c> must be large enough to hold <c>width</c> x <c>height</c> pixels encoded in the colorspace <c>cspace</c>.
 403     ///
 404     /// <c>slice</c> should not be the return value of <see cref="Efl.Gfx.IBuffer.GetBufferManaged"/>.</summary>
 405     /// <param name="slice">If <c>null</c>, allocates an empty buffer</param>
 406     /// <param name="size">The size in pixels.</param>
 407     /// <param name="stride">If 0, automatically guessed from the <c>width</c>.</param>
 408     /// <param name="cspace">argb8888 by default.</param>
 409     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 410     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 411     virtual public bool SetBufferCopy(Eina.Slice slice, Eina.Size2D size, int stride, Efl.Gfx.Colorspace cspace, int plane) {
 412          var _in_slice = Eina.PrimitiveConversion.ManagedToPointerAlloc(slice);
 413         Eina.Size2D.NativeStruct _in_size = size;
 414                                                                                                                 var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_copy_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_slice, _in_size, stride, cspace, plane);
 415         Eina.Error.RaiseIfUnhandledException();
 416                                                                                         return _ret_var;
 417  }
 418     /// <summary>Set the pixels for this buffer, managed externally by the client.
 419     /// EFL will use the pixel data directly, and update the GPU-side texture if required. This will mark the image as dirty. If <c>slice</c> is <c>null</c>, this will detach the pixel data.
 420     ///
 421     /// If the buffer already had pixel data, the previous image data will be dropped. This is the same as <see cref="Efl.Gfx.IBuffer.SetBufferCopy"/>.
 422     ///
 423     /// The memory buffer <c>pixels</c> must be large enough to hold <c>width</c> x <c>height</c> pixels encoded in the colorspace <c>cspace</c>.
 424     ///
 425     /// See also <see cref="Efl.Gfx.IBuffer.SetBufferCopy"/> if you want EFL to copy the input buffer internally.</summary>
 426     /// <param name="slice">If <c>null</c>, detaches the previous buffer.</param>
 427     /// <param name="size">The size in pixels.</param>
 428     /// <param name="stride">If 0, automatically guessed from the <c>width</c>.</param>
 429     /// <param name="cspace">argb8888 by default.</param>
 430     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 431     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 432     virtual public bool SetBufferManaged(Eina.Slice slice, Eina.Size2D size, int stride, Efl.Gfx.Colorspace cspace, int plane) {
 433          var _in_slice = Eina.PrimitiveConversion.ManagedToPointerAlloc(slice);
 434         Eina.Size2D.NativeStruct _in_size = size;
 435                                                                                                                 var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_managed_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_slice, _in_size, stride, cspace, plane);
 436         Eina.Error.RaiseIfUnhandledException();
 437                                                                                         return _ret_var;
 438  }
 439     /// <summary>Get a direct pointer to the internal pixel data, if available.
 440     /// This will return <c>null</c> unless <see cref="Efl.Gfx.IBuffer.SetBufferManaged"/> was used to pass in an external data pointer.</summary>
 441     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 442     /// <returns>The data slice. The memory pointer will be <c>null</c> in case of failure.</returns>
 443     virtual public Eina.Slice GetBufferManaged(int plane) {
 444                                  var _ret_var = Efl.Gfx.IBufferConcrete.NativeMethods.efl_gfx_buffer_managed_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),plane);
 445         Eina.Error.RaiseIfUnhandledException();
 446                         return _ret_var;
 447  }
 448     /// <summary>Binds the object&apos;s <see cref="Efl.Gfx.IFill.Fill"/> property to its actual geometry.
 449     /// If <c>true</c>, then every time the object is resized, it will automatically trigger a call to <see cref="Efl.Gfx.IFill.SetFill"/> with the new size (and 0, 0 as source image&apos;s origin), so the image will cover the whole object&apos;s area.
 450     ///
 451     /// This property takes precedence over <see cref="Efl.Gfx.IFill.Fill"/>. If set to <c>false</c>, then <see cref="Efl.Gfx.IFill.Fill"/> should be set.
 452     ///
 453     /// This flag is <c>true</c> by default (used to be <c>false</c> with the old APIs, and was known as &quot;filled&quot;).</summary>
 454     /// <returns><c>true</c> to make the fill property follow object size or <c>false</c> otherwise.</returns>
 455     virtual public bool GetFillAuto() {
 456          var _ret_var = Efl.Gfx.IFillConcrete.NativeMethods.efl_gfx_fill_auto_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 457         Eina.Error.RaiseIfUnhandledException();
 458         return _ret_var;
 459  }
 460     /// <summary>Binds the object&apos;s <see cref="Efl.Gfx.IFill.Fill"/> property to its actual geometry.
 461     /// If <c>true</c>, then every time the object is resized, it will automatically trigger a call to <see cref="Efl.Gfx.IFill.SetFill"/> with the new size (and 0, 0 as source image&apos;s origin), so the image will cover the whole object&apos;s area.
 462     ///
 463     /// This property takes precedence over <see cref="Efl.Gfx.IFill.Fill"/>. If set to <c>false</c>, then <see cref="Efl.Gfx.IFill.Fill"/> should be set.
 464     ///
 465     /// This flag is <c>true</c> by default (used to be <c>false</c> with the old APIs, and was known as &quot;filled&quot;).</summary>
 466     /// <param name="filled"><c>true</c> to make the fill property follow object size or <c>false</c> otherwise.</param>
 467     virtual public void SetFillAuto(bool filled) {
 468                                  Efl.Gfx.IFillConcrete.NativeMethods.efl_gfx_fill_auto_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),filled);
 469         Eina.Error.RaiseIfUnhandledException();
 470                          }
 471     /// <summary>Specifies how to tile an image to fill its rectangle geometry.
 472     /// Note that if <c>w</c> or <c>h</c> are smaller than the dimensions of the object, the displayed image will be tiled around the object&apos;s area. To have only one copy of the bound image drawn, <c>x</c> and <c>y</c> must be 0 and <c>w</c> and <c>h</c> need to be the exact width and height of the image object itself, respectively.
 473     ///
 474     /// Setting this property will reset the <see cref="Efl.Gfx.IFill.FillAuto"/> to <c>false</c>.</summary>
 475     /// <returns>The top-left corner to start drawing from as well as the size at which the bound image will be displayed.</returns>
 476     virtual public Eina.Rect GetFill() {
 477          var _ret_var = Efl.Gfx.IFillConcrete.NativeMethods.efl_gfx_fill_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 478         Eina.Error.RaiseIfUnhandledException();
 479         return _ret_var;
 480  }
 481     /// <summary>Specifies how to tile an image to fill its rectangle geometry.
 482     /// Note that if <c>w</c> or <c>h</c> are smaller than the dimensions of the object, the displayed image will be tiled around the object&apos;s area. To have only one copy of the bound image drawn, <c>x</c> and <c>y</c> must be 0 and <c>w</c> and <c>h</c> need to be the exact width and height of the image object itself, respectively.
 483     ///
 484     /// Setting this property will reset the <see cref="Efl.Gfx.IFill.FillAuto"/> to <c>false</c>.</summary>
 485     /// <param name="fill">The top-left corner to start drawing from as well as the size at which the bound image will be displayed.</param>
 486     virtual public void SetFill(Eina.Rect fill) {
 487          Eina.Rect.NativeStruct _in_fill = fill;
 488                         Efl.Gfx.IFillConcrete.NativeMethods.efl_gfx_fill_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_fill);
 489         Eina.Error.RaiseIfUnhandledException();
 490                          }
 491     /// <summary>Gets the code of the filter program set on this object. May be <c>null</c>.</summary>
 492     /// <param name="code">The Lua program source code.</param>
 493     /// <param name="name">An optional name for this filter.</param>
 494     virtual public void GetFilterProgram(out System.String code, out System.String name) {
 495                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_program_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out code, out name);
 496         Eina.Error.RaiseIfUnhandledException();
 497                                          }
 498     /// <summary>Set a graphical filter program on this object.
 499     /// Valid for Text and Image objects at the moment.
 500     ///
 501     /// The argument passed to this function is a string containing a valid Lua program based on the filters API as described in the &quot;EFL Graphics Filters&quot; reference page.
 502     ///
 503     /// Set to <c>null</c> to disable filtering.</summary>
 504     /// <param name="code">The Lua program source code.</param>
 505     /// <param name="name">An optional name for this filter.</param>
 506     virtual public void SetFilterProgram(System.String code, System.String name) {
 507                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_program_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),code, name);
 508         Eina.Error.RaiseIfUnhandledException();
 509                                          }
 510     /// <summary>Set the current state of the filter.
 511     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 512     ///
 513     /// A full state is defined by two states (name + value): origin state and target state of an ongoing animation, as well as the <c>pos</c> progress (from 0 to 1) of that animation timeline. The second state can be omitted if there is no ongoing animation.</summary>
 514     /// <param name="cur_state">Current state of the filter</param>
 515     /// <param name="cur_val">Current value</param>
 516     /// <param name="next_state">Next filter state, optional</param>
 517     /// <param name="next_val">Next value, optional</param>
 518     /// <param name="pos">Position, optional</param>
 519     virtual public void GetFilterState(out System.String cur_state, out double cur_val, out System.String next_state, out double next_val, out double pos) {
 520                                                                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_state_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out cur_state, out cur_val, out next_state, out next_val, out pos);
 521         Eina.Error.RaiseIfUnhandledException();
 522                                                                                          }
 523     /// <summary>Set the current state of the filter.
 524     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 525     ///
 526     /// A full state is defined by two states (name + value): origin state and target state of an ongoing animation, as well as the <c>pos</c> progress (from 0 to 1) of that animation timeline. The second state can be omitted if there is no ongoing animation.</summary>
 527     /// <param name="cur_state">Current state of the filter</param>
 528     /// <param name="cur_val">Current value</param>
 529     /// <param name="next_state">Next filter state, optional</param>
 530     /// <param name="next_val">Next value, optional</param>
 531     /// <param name="pos">Position, optional</param>
 532     virtual public void SetFilterState(System.String cur_state, double cur_val, System.String next_state, double next_val, double pos) {
 533                                                                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_state_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),cur_state, cur_val, next_state, next_val, pos);
 534         Eina.Error.RaiseIfUnhandledException();
 535                                                                                          }
 536     /// <summary>Gets the padding required to apply this filter.</summary>
 537     /// <param name="l">Padding on the left</param>
 538     /// <param name="r">Padding on the right</param>
 539     /// <param name="t">Padding on the top</param>
 540     /// <param name="b">Padding on the bottom</param>
 541     virtual public void GetFilterPadding(out int l, out int r, out int t, out int b) {
 542                                                                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_padding_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out l, out r, out t, out b);
 543         Eina.Error.RaiseIfUnhandledException();
 544                                                                          }
 545     /// <summary>Bind an object to use as a mask or texture in a filter program.
 546     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 547     /// <param name="name">Buffer name as used in the program.</param>
 548     /// <returns>Object to use as a source of pixels.</returns>
 549     virtual public Efl.Gfx.IEntity GetFilterSource(System.String name) {
 550                                  var _ret_var = Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_source_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name);
 551         Eina.Error.RaiseIfUnhandledException();
 552                         return _ret_var;
 553  }
 554     /// <summary>Bind an object to use as a mask or texture in a filter program.
 555     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 556     /// <param name="name">Buffer name as used in the program.</param>
 557     /// <param name="source">Object to use as a source of pixels.</param>
 558     virtual public void SetFilterSource(System.String name, Efl.Gfx.IEntity source) {
 559                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_source_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name, source);
 560         Eina.Error.RaiseIfUnhandledException();
 561                                          }
 562     /// <summary>Extra data used by the filter program.
 563     /// Each data element is a string (<c>value</c>) stored as a global variable <c>name</c>. The program is then responsible for conversion to numbers, tables, etc...
 564     ///
 565     /// If the <c>execute</c> flag is set, then the <c>value</c> can be complex and run, as if the original Lua program contained a line &apos;name = value&apos;. This can be used to pass in tables.</summary>
 566     /// <param name="name">Name of the global variable</param>
 567     /// <param name="value">String value to use as data</param>
 568     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 569     virtual public void GetFilterData(System.String name, out System.String value, out bool execute) {
 570                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_data_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name, out value, out execute);
 571         Eina.Error.RaiseIfUnhandledException();
 572                                                          }
 573     /// <summary>Extra data used by the filter program.
 574     /// Each data element is a string (<c>value</c>) stored as a global variable <c>name</c>. The program is then responsible for conversion to numbers, tables, etc...
 575     ///
 576     /// If the <c>execute</c> flag is set, then the <c>value</c> can be complex and run, as if the original Lua program contained a line &apos;name = value&apos;. This can be used to pass in tables.</summary>
 577     /// <param name="name">Name of the global variable</param>
 578     /// <param name="value">String value to use as data</param>
 579     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 580     virtual public void SetFilterData(System.String name, System.String value, bool execute) {
 581                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_data_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name, value, execute);
 582         Eina.Error.RaiseIfUnhandledException();
 583                                                          }
 584     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 585     /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 586     ///
 587     /// <c>true</c> by default</summary>
 588     /// <returns>Whether to use smooth scale or not.</returns>
 589     virtual public bool GetSmoothScale() {
 590          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 591         Eina.Error.RaiseIfUnhandledException();
 592         return _ret_var;
 593  }
 594     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 595     /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 596     ///
 597     /// <c>true</c> by default</summary>
 598     /// <param name="smooth_scale">Whether to use smooth scale or not.</param>
 599     virtual public void SetSmoothScale(bool smooth_scale) {
 600                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_smooth_scale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),smooth_scale);
 601         Eina.Error.RaiseIfUnhandledException();
 602                          }
 603     /// <summary>Control how the image is scaled.</summary>
 604     /// <returns>Image scale type</returns>
 605     virtual public Efl.Gfx.ImageScaleType GetScaleType() {
 606          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 607         Eina.Error.RaiseIfUnhandledException();
 608         return _ret_var;
 609  }
 610     /// <summary>Control how the image is scaled.</summary>
 611     /// <param name="scale_type">Image scale type</param>
 612     virtual public void SetScaleType(Efl.Gfx.ImageScaleType scale_type) {
 613                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_type_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),scale_type);
 614         Eina.Error.RaiseIfUnhandledException();
 615                          }
 616     /// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
 617     /// <returns>The image&apos;s ratio.</returns>
 618     virtual public double GetRatio() {
 619          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_ratio_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 620         Eina.Error.RaiseIfUnhandledException();
 621         return _ret_var;
 622  }
 623     /// <summary>Return the relative area enclosed inside the image where content is expected.
 624     /// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
 625     ///
 626     /// The geometry of the area is expressed relative to the geometry of the object.</summary>
 627     /// <returns>A rectangle inside the object boundary that where content is expected.</returns>
 628     virtual public Eina.Rect GetContentRegion() {
 629          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_region_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 630         Eina.Error.RaiseIfUnhandledException();
 631         return _ret_var;
 632  }
 633     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 634     /// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
 635     ///
 636     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 637     ///
 638     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 639     ///
 640     /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
 641     ///
 642     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 643     /// <param name="l">The border&apos;s left width.</param>
 644     /// <param name="r">The border&apos;s right width.</param>
 645     /// <param name="t">The border&apos;s top height.</param>
 646     /// <param name="b">The border&apos;s bottom height.</param>
 647     virtual public void GetBorder(out int l, out int r, out int t, out int b) {
 648                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out l, out r, out t, out b);
 649         Eina.Error.RaiseIfUnhandledException();
 650                                                                          }
 651     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 652     /// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
 653     ///
 654     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 655     ///
 656     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 657     ///
 658     /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
 659     ///
 660     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 661     /// <param name="l">The border&apos;s left width.</param>
 662     /// <param name="r">The border&apos;s right width.</param>
 663     /// <param name="t">The border&apos;s top height.</param>
 664     /// <param name="b">The border&apos;s bottom height.</param>
 665     virtual public void SetBorder(int l, int r, int t, int b) {
 666                                                                                                          Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),l, r, t, b);
 667         Eina.Error.RaiseIfUnhandledException();
 668                                                                          }
 669     /// <summary>Scaling factor applied to the image borders.
 670     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 671     ///
 672     /// Default value is 1.0 (no scaling).</summary>
 673     /// <returns>The scale factor.</returns>
 674     virtual public double GetBorderScale() {
 675          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 676         Eina.Error.RaiseIfUnhandledException();
 677         return _ret_var;
 678  }
 679     /// <summary>Scaling factor applied to the image borders.
 680     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 681     ///
 682     /// Default value is 1.0 (no scaling).</summary>
 683     /// <param name="scale">The scale factor.</param>
 684     virtual public void SetBorderScale(double scale) {
 685                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_scale_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),scale);
 686         Eina.Error.RaiseIfUnhandledException();
 687                          }
 688     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 689     /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
 690     ///
 691     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 692     /// <returns>Fill mode of the center region.</returns>
 693     virtual public Efl.Gfx.BorderFillMode GetBorderCenterFill() {
 694          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 695         Eina.Error.RaiseIfUnhandledException();
 696         return _ret_var;
 697  }
 698     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 699     /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
 700     ///
 701     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 702     /// <param name="fill">Fill mode of the center region.</param>
 703     virtual public void SetBorderCenterFill(Efl.Gfx.BorderFillMode fill) {
 704                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_border_center_fill_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),fill);
 705         Eina.Error.RaiseIfUnhandledException();
 706                          }
 707     /// <summary>This property defines the stretchable pixels region of an image.
 708     /// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
 709     /// <param name="horizontal">Representation of area that are stretchable in the image horizontal space.</param>
 710     /// <param name="vertical">Representation of area that are stretchable in the image vertical space.</param>
 711     virtual public void GetStretchRegion(out Eina.Iterator<Efl.Gfx.Image.StretchRegion> horizontal, out Eina.Iterator<Efl.Gfx.Image.StretchRegion> vertical) {
 712                          System.IntPtr _out_horizontal = System.IntPtr.Zero;
 713         System.IntPtr _out_vertical = System.IntPtr.Zero;
 714                         Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_stretch_region_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out _out_horizontal, out _out_vertical);
 715         Eina.Error.RaiseIfUnhandledException();
 716         horizontal = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(_out_horizontal, false);
 717         vertical = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(_out_vertical, false);
 718                          }
 719     /// <summary>This property defines the stretchable pixels region of an image.
 720     /// When the regions are set by the user, the method will walk the iterators once and then destroy them. When the regions are retrieved by the user, it is his responsibility to destroy the iterators.. It will remember the information for the lifetime of the object. It will ignore all value of <see cref="Efl.Gfx.IImage.GetBorder"/>, <see cref="Efl.Gfx.IImage.BorderScale"/> and <see cref="Efl.Gfx.IImage.BorderCenterFill"/> . To reset the object you can just pass <c>null</c> to both horizontal and vertical at the same time.</summary>
 721     /// <param name="horizontal">Representation of area that are stretchable in the image horizontal space.</param>
 722     /// <param name="vertical">Representation of area that are stretchable in the image vertical space.</param>
 723     /// <returns>return an error code if the stretch_region provided are incorrect.</returns>
 724     virtual public Eina.Error SetStretchRegion(Eina.Iterator<Efl.Gfx.Image.StretchRegion> horizontal, Eina.Iterator<Efl.Gfx.Image.StretchRegion> vertical) {
 725          var _in_horizontal = horizontal.Handle;
 726         var _in_vertical = vertical.Handle;
 727                                         var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_stretch_region_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_horizontal, _in_vertical);
 728         Eina.Error.RaiseIfUnhandledException();
 729                                         return _ret_var;
 730  }
 731     /// <summary>This represents the size of the original image in pixels.
 732     /// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
 733     ///
 734     /// This is a read-only property, and may return 0x0.</summary>
 735     /// <returns>The size in pixels.</returns>
 736     virtual public Eina.Size2D GetImageSize() {
 737          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 738         Eina.Error.RaiseIfUnhandledException();
 739         return _ret_var;
 740  }
 741     /// <summary>Get the content hint setting of a given image object of the canvas.
 742     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 743     /// <returns>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></returns>
 744     virtual public Efl.Gfx.ImageContentHint GetContentHint() {
 745          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 746         Eina.Error.RaiseIfUnhandledException();
 747         return _ret_var;
 748  }
 749     /// <summary>Set the content hint setting of a given image object of the canvas.
 750     /// This function sets the content hint value of the given image of the canvas. For example, if you&apos;re on the GL engine and your driver implementation supports it, setting this hint to #EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies at texture upload time, which is an &quot;expensive&quot; operation.</summary>
 751     /// <param name="hint">Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></param>
 752     virtual public void SetContentHint(Efl.Gfx.ImageContentHint hint) {
 753                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_content_hint_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),hint);
 754         Eina.Error.RaiseIfUnhandledException();
 755                          }
 756     /// <summary>Get the scale hint of a given image of the canvas.
 757     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 758     /// <returns>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></returns>
 759     virtual public Efl.Gfx.ImageScaleHint GetScaleHint() {
 760          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 761         Eina.Error.RaiseIfUnhandledException();
 762         return _ret_var;
 763  }
 764     /// <summary>Set the scale hint of a given image of the canvas.
 765     /// This function sets the scale hint value of the given image object in the canvas, which will affect how Evas is to cache scaled versions of its original source image.</summary>
 766     /// <param name="hint">Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></param>
 767     virtual public void SetScaleHint(Efl.Gfx.ImageScaleHint hint) {
 768                                  Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_scale_hint_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),hint);
 769         Eina.Error.RaiseIfUnhandledException();
 770                          }
 771     /// <summary>Gets the (last) file loading error for a given object.</summary>
 772     /// <returns>The load error code.</returns>
 773     virtual public Eina.Error GetImageLoadError() {
 774          var _ret_var = Efl.Gfx.IImageConcrete.NativeMethods.efl_gfx_image_load_error_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 775         Eina.Error.RaiseIfUnhandledException();
 776         return _ret_var;
 777  }
 778     /// <summary>Control the orientation (rotation and flipping) of a visual object.
 779     /// This can be used to set the rotation on an image or a window, for instance.</summary>
 780     /// <returns>The final orientation of the object.</returns>
 781     virtual public Efl.Gfx.ImageOrientation GetImageOrientation() {
 782          var _ret_var = Efl.Gfx.IImageOrientableConcrete.NativeMethods.efl_gfx_image_orientation_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 783         Eina.Error.RaiseIfUnhandledException();
 784         return _ret_var;
 785  }
 786     /// <summary>Control the orientation (rotation and flipping) of a visual object.
 787     /// This can be used to set the rotation on an image or a window, for instance.</summary>
 788     /// <param name="dir">The final orientation of the object.</param>
 789     virtual public void SetImageOrientation(Efl.Gfx.ImageOrientation dir) {
 790                                  Efl.Gfx.IImageOrientableConcrete.NativeMethods.efl_gfx_image_orientation_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),dir);
 791         Eina.Error.RaiseIfUnhandledException();
 792                          }
 793     /// <summary>The dimensions of this object&apos;s viewport.
 794     /// This property represents the size of an image (file on disk, vector graphics, GL or 3D scene, ...) view: this is the logical size of a view, not the number of pixels in the buffer, nor its visible size on the window.
 795     ///
 796     /// For scalable scenes (vector graphics, 3D or GL), this means scaling the contents of the scene and drawing more pixels as a result; For pixmaps this means zooming and stretching up or down the backing buffer to fit this view.
 797     ///
 798     /// In most cases the view should have the same dimensions as the object on the canvas, for best quality.
 799     ///
 800     /// <see cref="Efl.Gfx.IView.SetViewSize"/> may not be implemented. If it is, it might trigger a complete recalculation of the scene, or reload of the pixel data.
 801     ///
 802     /// Refer to each implementing class specific documentation for more details.</summary>
 803     /// <returns>Size of the view.</returns>
 804     virtual public Eina.Size2D GetViewSize() {
 805          var _ret_var = Efl.Gfx.IViewConcrete.NativeMethods.efl_gfx_view_size_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 806         Eina.Error.RaiseIfUnhandledException();
 807         return _ret_var;
 808  }
 809     /// <summary>The dimensions of this object&apos;s viewport.
 810     /// This property represents the size of an image (file on disk, vector graphics, GL or 3D scene, ...) view: this is the logical size of a view, not the number of pixels in the buffer, nor its visible size on the window.
 811     ///
 812     /// For scalable scenes (vector graphics, 3D or GL), this means scaling the contents of the scene and drawing more pixels as a result; For pixmaps this means zooming and stretching up or down the backing buffer to fit this view.
 813     ///
 814     /// In most cases the view should have the same dimensions as the object on the canvas, for best quality.
 815     ///
 816     /// <see cref="Efl.Gfx.IView.SetViewSize"/> may not be implemented. If it is, it might trigger a complete recalculation of the scene, or reload of the pixel data.
 817     ///
 818     /// Refer to each implementing class specific documentation for more details.</summary>
 819     /// <param name="size">Size of the view.</param>
 820     virtual public void SetViewSize(Eina.Size2D size) {
 821          Eina.Size2D.NativeStruct _in_size = size;
 822                         Efl.Gfx.IViewConcrete.NativeMethods.efl_gfx_view_size_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_size);
 823         Eina.Error.RaiseIfUnhandledException();
 824                          }
 825     /// <summary>Marks this filter as changed.</summary>
 826     /// <value><c>true</c> if filter changed, <c>false</c> otherwise</value>
 827     public bool FilterChanged {
 828         set { SetFilterChanged(value); }
 829     }
 830     /// <summary>Marks this filter as invalid.</summary>
 831     /// <value><c>true</c> if filter is invalid, <c>false</c> otherwise</value>
 832     public bool FilterInvalid {
 833         set { SetFilterInvalid(value); }
 834     }
 835     /// <summary>Retrieve cached output buffer, if any.
 836     /// Does not increment the reference count.</summary>
 837     /// <value>Output buffer</value>
 838     public System.IntPtr FilterOutputBuffer {
 839         get { return GetFilterOutputBuffer(); }
 840     }
 841     /// <summary>Rectangular size of the pixel buffer as allocated in memory.</summary>
 842     /// <value>Size of the buffer in pixels.</value>
 843     public Eina.Size2D BufferSize {
 844         get { return GetBufferSize(); }
 845         set { SetBufferSize(value); }
 846     }
 847     /// <summary>The colorspace defines how pixels are encoded in the image in memory.
 848     /// By default, images are encoded in 32-bit BGRA, ie. each pixel takes 4 bytes in memory, with each channel B,G,R,A encoding the color with values from 0 to 255.
 849     ///
 850     /// All images used in EFL use alpha-premultipied BGRA values, which means that for each pixel, B &lt;= A, G &lt;= A and R &lt;= A.</summary>
 851     /// <value>Colorspace</value>
 852     public Efl.Gfx.Colorspace Colorspace {
 853         get { return GetColorspace(); }
 854     }
 855     /// <summary>Indicates whether the alpha channel should be used.
 856     /// This does not indicate whether the image source file contains an alpha channel, only whether to respect it or discard it.</summary>
 857     /// <value>Whether to use alpha channel (<c>true</c>) data or not (<c>false</c>).</value>
 858     public bool Alpha {
 859         get { return GetAlpha(); }
 860         set { SetAlpha(value); }
 861     }
 862     /// <summary>Length in bytes of one row of pixels in memory.
 863     /// Usually this will be equal to width * 4, with a plain BGRA image. This may return 0 if the stride is not applicable.
 864     ///
 865     /// When applicable, this will include the <see cref="Efl.Gfx.IBuffer.GetBufferBorders"/> as well as potential extra padding.</summary>
 866     /// <value>Stride</value>
 867     public int Stride {
 868         get { return GetStride(); }
 869     }
 870     /// <summary>Binds the object&apos;s <see cref="Efl.Gfx.IFill.Fill"/> property to its actual geometry.
 871     /// If <c>true</c>, then every time the object is resized, it will automatically trigger a call to <see cref="Efl.Gfx.IFill.SetFill"/> with the new size (and 0, 0 as source image&apos;s origin), so the image will cover the whole object&apos;s area.
 872     ///
 873     /// This property takes precedence over <see cref="Efl.Gfx.IFill.Fill"/>. If set to <c>false</c>, then <see cref="Efl.Gfx.IFill.Fill"/> should be set.
 874     ///
 875     /// This flag is <c>true</c> by default (used to be <c>false</c> with the old APIs, and was known as &quot;filled&quot;).</summary>
 876     /// <value><c>true</c> to make the fill property follow object size or <c>false</c> otherwise.</value>
 877     public bool FillAuto {
 878         get { return GetFillAuto(); }
 879         set { SetFillAuto(value); }
 880     }
 881     /// <summary>Specifies how to tile an image to fill its rectangle geometry.
 882     /// Note that if <c>w</c> or <c>h</c> are smaller than the dimensions of the object, the displayed image will be tiled around the object&apos;s area. To have only one copy of the bound image drawn, <c>x</c> and <c>y</c> must be 0 and <c>w</c> and <c>h</c> need to be the exact width and height of the image object itself, respectively.
 883     ///
 884     /// Setting this property will reset the <see cref="Efl.Gfx.IFill.FillAuto"/> to <c>false</c>.</summary>
 885     /// <value>The top-left corner to start drawing from as well as the size at which the bound image will be displayed.</value>
 886     public Eina.Rect Fill {
 887         get { return GetFill(); }
 888         set { SetFill(value); }
 889     }
 890     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 891     /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 892     ///
 893     /// <c>true</c> by default</summary>
 894     /// <value>Whether to use smooth scale or not.</value>
 895     public bool SmoothScale {
 896         get { return GetSmoothScale(); }
 897         set { SetSmoothScale(value); }
 898     }
 899     /// <summary>Control how the image is scaled.</summary>
 900     /// <value>Image scale type</value>
 901     public Efl.Gfx.ImageScaleType ScaleType {
 902         get { return GetScaleType(); }
 903         set { SetScaleType(value); }
 904     }
 905     /// <summary>The native width/height ratio of the image.</summary>
 906     /// <value>The image&apos;s ratio.</value>
 907     public double Ratio {
 908         get { return GetRatio(); }
 909     }
 910     /// <summary>Return the relative area enclosed inside the image where content is expected.
 911     /// We do expect content to be inside the limit defined by the border or inside the stretch region. If a stretch region is provided, the content region will encompass the non strechable area that are surrounded by stretchable area. If no border and no stretch region is set, they are assumed to be zero and the full object geometry is where content can be layout on top. The area size change with the object size.
 912     ///
 913     /// The geometry of the area is expressed relative to the geometry of the object.</summary>
 914     /// <value>A rectangle inside the object boundary that where content is expected.</value>
 915     public Eina.Rect ContentRegion {
 916         get { return GetContentRegion(); }
 917     }
 918     /// <summary>Scaling factor applied to the image borders.
 919     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 920     ///
 921     /// Default value is 1.0 (no scaling).</summary>
 922     /// <value>The scale factor.</value>
 923     public double BorderScale {
 924         get { return GetBorderScale(); }
 925         set { SetBorderScale(value); }
 926     }
 927     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 928     /// This function sets how the center part of the image object&apos;s source image is to be drawn, which must be one of the values in <see cref="Efl.Gfx.BorderFillMode"/>. By center we mean the complementary part of that defined by <see cref="Efl.Gfx.IImage.GetBorder"/>. This is very useful for making frames and decorations. You would most probably also be using a filled image (as in <see cref="Efl.Gfx.IFill.FillAuto"/>) to use as a frame.
 929     ///
 930     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 931     /// <value>Fill mode of the center region.</value>
 932     public Efl.Gfx.BorderFillMode BorderCenterFill {
 933         get { return GetBorderCenterFill(); }
 934         set { SetBorderCenterFill(value); }
 935     }
 936     /// <summary>This represents the size of the original image in pixels.
 937     /// This may be different from the actual geometry on screen or even the size of the loaded pixel buffer. This is the size of the image as stored in the original file.
 938     ///
 939     /// This is a read-only property, and may return 0x0.</summary>
 940     /// <value>The size in pixels.</value>
 941     public Eina.Size2D ImageSize {
 942         get { return GetImageSize(); }
 943     }
 944     /// <summary>Get the content hint setting of a given image object of the canvas.
 945     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 946     /// <value>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></value>
 947     public Efl.Gfx.ImageContentHint ContentHint {
 948         get { return GetContentHint(); }
 949         set { SetContentHint(value); }
 950     }
 951     /// <summary>Get the scale hint of a given image of the canvas.
 952     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 953     /// <value>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></value>
 954     public Efl.Gfx.ImageScaleHint ScaleHint {
 955         get { return GetScaleHint(); }
 956         set { SetScaleHint(value); }
 957     }
 958     /// <summary>Gets the (last) file loading error for a given object.</summary>
 959     /// <value>The load error code.</value>
 960     public Eina.Error ImageLoadError {
 961         get { return GetImageLoadError(); }
 962     }
 963     /// <summary>Control the orientation (rotation and flipping) of a visual object.
 964     /// This can be used to set the rotation on an image or a window, for instance.</summary>
 965     /// <value>The final orientation of the object.</value>
 966     public Efl.Gfx.ImageOrientation ImageOrientation {
 967         get { return GetImageOrientation(); }
 968         set { SetImageOrientation(value); }
 969     }
 970     /// <summary>The dimensions of this object&apos;s viewport.
 971     /// This property represents the size of an image (file on disk, vector graphics, GL or 3D scene, ...) view: this is the logical size of a view, not the number of pixels in the buffer, nor its visible size on the window.
 972     ///
 973     /// For scalable scenes (vector graphics, 3D or GL), this means scaling the contents of the scene and drawing more pixels as a result; For pixmaps this means zooming and stretching up or down the backing buffer to fit this view.
 974     ///
 975     /// In most cases the view should have the same dimensions as the object on the canvas, for best quality.
 976     ///
 977     /// <see cref="Efl.Gfx.IView.SetViewSize"/> may not be implemented. If it is, it might trigger a complete recalculation of the scene, or reload of the pixel data.
 978     ///
 979     /// Refer to each implementing class specific documentation for more details.</summary>
 980     /// <value>Size of the view.</value>
 981     public Eina.Size2D ViewSize {
 982         get { return GetViewSize(); }
 983         set { SetViewSize(value); }
 984     }
 985     private static IntPtr GetEflClassStatic()
 986     {
 987         return Efl.Canvas.ImageInternal.efl_canvas_image_internal_class_get();
 988     }
 989     /// <summary>Wrapper for native methods and virtual method delegates.
 990     /// For internal use by generated code only.</summary>
 991     public new class NativeMethods : Efl.Canvas.Object.NativeMethods
 992     {
 993         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 994         /// <summary>Gets the list of Eo operations to override.</summary>
 995         /// <returns>The list of Eo operations to be overload.</returns>
 996         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 997         {
 998             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 999             var methods = Efl.Eo.Globals.GetUserMethods(type);
1000
1001             if (efl_file_save_static_delegate == null)
1002             {
1003                 efl_file_save_static_delegate = new efl_file_save_delegate(save);
1004             }
1005
1006             if (methods.FirstOrDefault(m => m.Name == "Save") != null)
1007             {
1008                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_save"), func = Marshal.GetFunctionPointerForDelegate(efl_file_save_static_delegate) });
1009             }
1010
1011             if (evas_filter_changed_set_static_delegate == null)
1012             {
1013                 evas_filter_changed_set_static_delegate = new evas_filter_changed_set_delegate(filter_changed_set);
1014             }
1015
1016             if (methods.FirstOrDefault(m => m.Name == "SetFilterChanged") != null)
1017             {
1018                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "evas_filter_changed_set"), func = Marshal.GetFunctionPointerForDelegate(evas_filter_changed_set_static_delegate) });
1019             }
1020
1021             if (evas_filter_invalid_set_static_delegate == null)
1022             {
1023                 evas_filter_invalid_set_static_delegate = new evas_filter_invalid_set_delegate(filter_invalid_set);
1024             }
1025
1026             if (methods.FirstOrDefault(m => m.Name == "SetFilterInvalid") != null)
1027             {
1028                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "evas_filter_invalid_set"), func = Marshal.GetFunctionPointerForDelegate(evas_filter_invalid_set_static_delegate) });
1029             }
1030
1031             if (evas_filter_output_buffer_get_static_delegate == null)
1032             {
1033                 evas_filter_output_buffer_get_static_delegate = new evas_filter_output_buffer_get_delegate(filter_output_buffer_get);
1034             }
1035
1036             if (methods.FirstOrDefault(m => m.Name == "GetFilterOutputBuffer") != null)
1037             {
1038                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "evas_filter_output_buffer_get"), func = Marshal.GetFunctionPointerForDelegate(evas_filter_output_buffer_get_static_delegate) });
1039             }
1040
1041             if (evas_filter_input_alpha_static_delegate == null)
1042             {
1043                 evas_filter_input_alpha_static_delegate = new evas_filter_input_alpha_delegate(filter_input_alpha);
1044             }
1045
1046             if (methods.FirstOrDefault(m => m.Name == "FilterInputAlpha") != null)
1047             {
1048                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "evas_filter_input_alpha"), func = Marshal.GetFunctionPointerForDelegate(evas_filter_input_alpha_static_delegate) });
1049             }
1050
1051             if (evas_filter_state_prepare_static_delegate == null)
1052             {
1053                 evas_filter_state_prepare_static_delegate = new evas_filter_state_prepare_delegate(filter_state_prepare);
1054             }
1055
1056             if (methods.FirstOrDefault(m => m.Name == "FilterStatePrepare") != null)
1057             {
1058                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "evas_filter_state_prepare"), func = Marshal.GetFunctionPointerForDelegate(evas_filter_state_prepare_static_delegate) });
1059             }
1060
1061             if (evas_filter_input_render_static_delegate == null)
1062             {
1063                 evas_filter_input_render_static_delegate = new evas_filter_input_render_delegate(filter_input_render);
1064             }
1065
1066             if (methods.FirstOrDefault(m => m.Name == "FilterInputRender") != null)
1067             {
1068                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "evas_filter_input_render"), func = Marshal.GetFunctionPointerForDelegate(evas_filter_input_render_static_delegate) });
1069             }
1070
1071             if (evas_filter_dirty_static_delegate == null)
1072             {
1073                 evas_filter_dirty_static_delegate = new evas_filter_dirty_delegate(filter_dirty);
1074             }
1075
1076             if (methods.FirstOrDefault(m => m.Name == "FilterDirty") != null)
1077             {
1078                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "evas_filter_dirty"), func = Marshal.GetFunctionPointerForDelegate(evas_filter_dirty_static_delegate) });
1079             }
1080
1081             if (efl_gfx_buffer_size_get_static_delegate == null)
1082             {
1083                 efl_gfx_buffer_size_get_static_delegate = new efl_gfx_buffer_size_get_delegate(buffer_size_get);
1084             }
1085
1086             if (methods.FirstOrDefault(m => m.Name == "GetBufferSize") != null)
1087             {
1088                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_size_get_static_delegate) });
1089             }
1090
1091             if (efl_gfx_buffer_size_set_static_delegate == null)
1092             {
1093                 efl_gfx_buffer_size_set_static_delegate = new efl_gfx_buffer_size_set_delegate(buffer_size_set);
1094             }
1095
1096             if (methods.FirstOrDefault(m => m.Name == "SetBufferSize") != null)
1097             {
1098                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_size_set_static_delegate) });
1099             }
1100
1101             if (efl_gfx_buffer_colorspace_get_static_delegate == null)
1102             {
1103                 efl_gfx_buffer_colorspace_get_static_delegate = new efl_gfx_buffer_colorspace_get_delegate(colorspace_get);
1104             }
1105
1106             if (methods.FirstOrDefault(m => m.Name == "GetColorspace") != null)
1107             {
1108                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_colorspace_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_colorspace_get_static_delegate) });
1109             }
1110
1111             if (efl_gfx_buffer_alpha_get_static_delegate == null)
1112             {
1113                 efl_gfx_buffer_alpha_get_static_delegate = new efl_gfx_buffer_alpha_get_delegate(alpha_get);
1114             }
1115
1116             if (methods.FirstOrDefault(m => m.Name == "GetAlpha") != null)
1117             {
1118                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_alpha_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_alpha_get_static_delegate) });
1119             }
1120
1121             if (efl_gfx_buffer_alpha_set_static_delegate == null)
1122             {
1123                 efl_gfx_buffer_alpha_set_static_delegate = new efl_gfx_buffer_alpha_set_delegate(alpha_set);
1124             }
1125
1126             if (methods.FirstOrDefault(m => m.Name == "SetAlpha") != null)
1127             {
1128                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_alpha_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_alpha_set_static_delegate) });
1129             }
1130
1131             if (efl_gfx_buffer_stride_get_static_delegate == null)
1132             {
1133                 efl_gfx_buffer_stride_get_static_delegate = new efl_gfx_buffer_stride_get_delegate(stride_get);
1134             }
1135
1136             if (methods.FirstOrDefault(m => m.Name == "GetStride") != null)
1137             {
1138                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_stride_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_stride_get_static_delegate) });
1139             }
1140
1141             if (efl_gfx_buffer_borders_get_static_delegate == null)
1142             {
1143                 efl_gfx_buffer_borders_get_static_delegate = new efl_gfx_buffer_borders_get_delegate(buffer_borders_get);
1144             }
1145
1146             if (methods.FirstOrDefault(m => m.Name == "GetBufferBorders") != null)
1147             {
1148                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_borders_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_borders_get_static_delegate) });
1149             }
1150
1151             if (efl_gfx_buffer_update_add_static_delegate == null)
1152             {
1153                 efl_gfx_buffer_update_add_static_delegate = new efl_gfx_buffer_update_add_delegate(buffer_update_add);
1154             }
1155
1156             if (methods.FirstOrDefault(m => m.Name == "AddBufferUpdate") != null)
1157             {
1158                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_update_add"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_update_add_static_delegate) });
1159             }
1160
1161             if (efl_gfx_buffer_map_static_delegate == null)
1162             {
1163                 efl_gfx_buffer_map_static_delegate = new efl_gfx_buffer_map_delegate(buffer_map);
1164             }
1165
1166             if (methods.FirstOrDefault(m => m.Name == "BufferMap") != null)
1167             {
1168                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_map"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_map_static_delegate) });
1169             }
1170
1171             if (efl_gfx_buffer_unmap_static_delegate == null)
1172             {
1173                 efl_gfx_buffer_unmap_static_delegate = new efl_gfx_buffer_unmap_delegate(buffer_unmap);
1174             }
1175
1176             if (methods.FirstOrDefault(m => m.Name == "BufferUnmap") != null)
1177             {
1178                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_unmap"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_unmap_static_delegate) });
1179             }
1180
1181             if (efl_gfx_buffer_copy_set_static_delegate == null)
1182             {
1183                 efl_gfx_buffer_copy_set_static_delegate = new efl_gfx_buffer_copy_set_delegate(buffer_copy_set);
1184             }
1185
1186             if (methods.FirstOrDefault(m => m.Name == "SetBufferCopy") != null)
1187             {
1188                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_copy_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_copy_set_static_delegate) });
1189             }
1190
1191             if (efl_gfx_buffer_managed_set_static_delegate == null)
1192             {
1193                 efl_gfx_buffer_managed_set_static_delegate = new efl_gfx_buffer_managed_set_delegate(buffer_managed_set);
1194             }
1195
1196             if (methods.FirstOrDefault(m => m.Name == "SetBufferManaged") != null)
1197             {
1198                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_managed_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_managed_set_static_delegate) });
1199             }
1200
1201             if (efl_gfx_buffer_managed_get_static_delegate == null)
1202             {
1203                 efl_gfx_buffer_managed_get_static_delegate = new efl_gfx_buffer_managed_get_delegate(buffer_managed_get);
1204             }
1205
1206             if (methods.FirstOrDefault(m => m.Name == "GetBufferManaged") != null)
1207             {
1208                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_buffer_managed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_buffer_managed_get_static_delegate) });
1209             }
1210
1211             if (efl_gfx_fill_auto_get_static_delegate == null)
1212             {
1213                 efl_gfx_fill_auto_get_static_delegate = new efl_gfx_fill_auto_get_delegate(fill_auto_get);
1214             }
1215
1216             if (methods.FirstOrDefault(m => m.Name == "GetFillAuto") != null)
1217             {
1218                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_fill_auto_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_fill_auto_get_static_delegate) });
1219             }
1220
1221             if (efl_gfx_fill_auto_set_static_delegate == null)
1222             {
1223                 efl_gfx_fill_auto_set_static_delegate = new efl_gfx_fill_auto_set_delegate(fill_auto_set);
1224             }
1225
1226             if (methods.FirstOrDefault(m => m.Name == "SetFillAuto") != null)
1227             {
1228                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_fill_auto_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_fill_auto_set_static_delegate) });
1229             }
1230
1231             if (efl_gfx_fill_get_static_delegate == null)
1232             {
1233                 efl_gfx_fill_get_static_delegate = new efl_gfx_fill_get_delegate(fill_get);
1234             }
1235
1236             if (methods.FirstOrDefault(m => m.Name == "GetFill") != null)
1237             {
1238                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_fill_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_fill_get_static_delegate) });
1239             }
1240
1241             if (efl_gfx_fill_set_static_delegate == null)
1242             {
1243                 efl_gfx_fill_set_static_delegate = new efl_gfx_fill_set_delegate(fill_set);
1244             }
1245
1246             if (methods.FirstOrDefault(m => m.Name == "SetFill") != null)
1247             {
1248                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_fill_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_fill_set_static_delegate) });
1249             }
1250
1251             if (efl_gfx_filter_program_get_static_delegate == null)
1252             {
1253                 efl_gfx_filter_program_get_static_delegate = new efl_gfx_filter_program_get_delegate(filter_program_get);
1254             }
1255
1256             if (methods.FirstOrDefault(m => m.Name == "GetFilterProgram") != null)
1257             {
1258                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_program_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_program_get_static_delegate) });
1259             }
1260
1261             if (efl_gfx_filter_program_set_static_delegate == null)
1262             {
1263                 efl_gfx_filter_program_set_static_delegate = new efl_gfx_filter_program_set_delegate(filter_program_set);
1264             }
1265
1266             if (methods.FirstOrDefault(m => m.Name == "SetFilterProgram") != null)
1267             {
1268                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_program_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_program_set_static_delegate) });
1269             }
1270
1271             if (efl_gfx_filter_state_get_static_delegate == null)
1272             {
1273                 efl_gfx_filter_state_get_static_delegate = new efl_gfx_filter_state_get_delegate(filter_state_get);
1274             }
1275
1276             if (methods.FirstOrDefault(m => m.Name == "GetFilterState") != null)
1277             {
1278                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_state_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_state_get_static_delegate) });
1279             }
1280
1281             if (efl_gfx_filter_state_set_static_delegate == null)
1282             {
1283                 efl_gfx_filter_state_set_static_delegate = new efl_gfx_filter_state_set_delegate(filter_state_set);
1284             }
1285
1286             if (methods.FirstOrDefault(m => m.Name == "SetFilterState") != null)
1287             {
1288                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_state_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_state_set_static_delegate) });
1289             }
1290
1291             if (efl_gfx_filter_padding_get_static_delegate == null)
1292             {
1293                 efl_gfx_filter_padding_get_static_delegate = new efl_gfx_filter_padding_get_delegate(filter_padding_get);
1294             }
1295
1296             if (methods.FirstOrDefault(m => m.Name == "GetFilterPadding") != null)
1297             {
1298                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_padding_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_padding_get_static_delegate) });
1299             }
1300
1301             if (efl_gfx_filter_source_get_static_delegate == null)
1302             {
1303                 efl_gfx_filter_source_get_static_delegate = new efl_gfx_filter_source_get_delegate(filter_source_get);
1304             }
1305
1306             if (methods.FirstOrDefault(m => m.Name == "GetFilterSource") != null)
1307             {
1308                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_source_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_source_get_static_delegate) });
1309             }
1310
1311             if (efl_gfx_filter_source_set_static_delegate == null)
1312             {
1313                 efl_gfx_filter_source_set_static_delegate = new efl_gfx_filter_source_set_delegate(filter_source_set);
1314             }
1315
1316             if (methods.FirstOrDefault(m => m.Name == "SetFilterSource") != null)
1317             {
1318                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_source_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_source_set_static_delegate) });
1319             }
1320
1321             if (efl_gfx_filter_data_get_static_delegate == null)
1322             {
1323                 efl_gfx_filter_data_get_static_delegate = new efl_gfx_filter_data_get_delegate(filter_data_get);
1324             }
1325
1326             if (methods.FirstOrDefault(m => m.Name == "GetFilterData") != null)
1327             {
1328                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_data_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_data_get_static_delegate) });
1329             }
1330
1331             if (efl_gfx_filter_data_set_static_delegate == null)
1332             {
1333                 efl_gfx_filter_data_set_static_delegate = new efl_gfx_filter_data_set_delegate(filter_data_set);
1334             }
1335
1336             if (methods.FirstOrDefault(m => m.Name == "SetFilterData") != null)
1337             {
1338                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_filter_data_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_filter_data_set_static_delegate) });
1339             }
1340
1341             if (efl_gfx_image_smooth_scale_get_static_delegate == null)
1342             {
1343                 efl_gfx_image_smooth_scale_get_static_delegate = new efl_gfx_image_smooth_scale_get_delegate(smooth_scale_get);
1344             }
1345
1346             if (methods.FirstOrDefault(m => m.Name == "GetSmoothScale") != null)
1347             {
1348                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_smooth_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_smooth_scale_get_static_delegate) });
1349             }
1350
1351             if (efl_gfx_image_smooth_scale_set_static_delegate == null)
1352             {
1353                 efl_gfx_image_smooth_scale_set_static_delegate = new efl_gfx_image_smooth_scale_set_delegate(smooth_scale_set);
1354             }
1355
1356             if (methods.FirstOrDefault(m => m.Name == "SetSmoothScale") != null)
1357             {
1358                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_smooth_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_smooth_scale_set_static_delegate) });
1359             }
1360
1361             if (efl_gfx_image_scale_type_get_static_delegate == null)
1362             {
1363                 efl_gfx_image_scale_type_get_static_delegate = new efl_gfx_image_scale_type_get_delegate(scale_type_get);
1364             }
1365
1366             if (methods.FirstOrDefault(m => m.Name == "GetScaleType") != null)
1367             {
1368                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_type_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_type_get_static_delegate) });
1369             }
1370
1371             if (efl_gfx_image_scale_type_set_static_delegate == null)
1372             {
1373                 efl_gfx_image_scale_type_set_static_delegate = new efl_gfx_image_scale_type_set_delegate(scale_type_set);
1374             }
1375
1376             if (methods.FirstOrDefault(m => m.Name == "SetScaleType") != null)
1377             {
1378                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_type_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_type_set_static_delegate) });
1379             }
1380
1381             if (efl_gfx_image_ratio_get_static_delegate == null)
1382             {
1383                 efl_gfx_image_ratio_get_static_delegate = new efl_gfx_image_ratio_get_delegate(ratio_get);
1384             }
1385
1386             if (methods.FirstOrDefault(m => m.Name == "GetRatio") != null)
1387             {
1388                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_ratio_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_ratio_get_static_delegate) });
1389             }
1390
1391             if (efl_gfx_image_content_region_get_static_delegate == null)
1392             {
1393                 efl_gfx_image_content_region_get_static_delegate = new efl_gfx_image_content_region_get_delegate(content_region_get);
1394             }
1395
1396             if (methods.FirstOrDefault(m => m.Name == "GetContentRegion") != null)
1397             {
1398                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_region_get_static_delegate) });
1399             }
1400
1401             if (efl_gfx_image_border_get_static_delegate == null)
1402             {
1403                 efl_gfx_image_border_get_static_delegate = new efl_gfx_image_border_get_delegate(border_get);
1404             }
1405
1406             if (methods.FirstOrDefault(m => m.Name == "GetBorder") != null)
1407             {
1408                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_get_static_delegate) });
1409             }
1410
1411             if (efl_gfx_image_border_set_static_delegate == null)
1412             {
1413                 efl_gfx_image_border_set_static_delegate = new efl_gfx_image_border_set_delegate(border_set);
1414             }
1415
1416             if (methods.FirstOrDefault(m => m.Name == "SetBorder") != null)
1417             {
1418                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_set_static_delegate) });
1419             }
1420
1421             if (efl_gfx_image_border_scale_get_static_delegate == null)
1422             {
1423                 efl_gfx_image_border_scale_get_static_delegate = new efl_gfx_image_border_scale_get_delegate(border_scale_get);
1424             }
1425
1426             if (methods.FirstOrDefault(m => m.Name == "GetBorderScale") != null)
1427             {
1428                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_scale_get_static_delegate) });
1429             }
1430
1431             if (efl_gfx_image_border_scale_set_static_delegate == null)
1432             {
1433                 efl_gfx_image_border_scale_set_static_delegate = new efl_gfx_image_border_scale_set_delegate(border_scale_set);
1434             }
1435
1436             if (methods.FirstOrDefault(m => m.Name == "SetBorderScale") != null)
1437             {
1438                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_scale_set_static_delegate) });
1439             }
1440
1441             if (efl_gfx_image_border_center_fill_get_static_delegate == null)
1442             {
1443                 efl_gfx_image_border_center_fill_get_static_delegate = new efl_gfx_image_border_center_fill_get_delegate(border_center_fill_get);
1444             }
1445
1446             if (methods.FirstOrDefault(m => m.Name == "GetBorderCenterFill") != null)
1447             {
1448                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_center_fill_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_center_fill_get_static_delegate) });
1449             }
1450
1451             if (efl_gfx_image_border_center_fill_set_static_delegate == null)
1452             {
1453                 efl_gfx_image_border_center_fill_set_static_delegate = new efl_gfx_image_border_center_fill_set_delegate(border_center_fill_set);
1454             }
1455
1456             if (methods.FirstOrDefault(m => m.Name == "SetBorderCenterFill") != null)
1457             {
1458                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_border_center_fill_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_border_center_fill_set_static_delegate) });
1459             }
1460
1461             if (efl_gfx_image_stretch_region_get_static_delegate == null)
1462             {
1463                 efl_gfx_image_stretch_region_get_static_delegate = new efl_gfx_image_stretch_region_get_delegate(stretch_region_get);
1464             }
1465
1466             if (methods.FirstOrDefault(m => m.Name == "GetStretchRegion") != null)
1467             {
1468                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_stretch_region_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_stretch_region_get_static_delegate) });
1469             }
1470
1471             if (efl_gfx_image_stretch_region_set_static_delegate == null)
1472             {
1473                 efl_gfx_image_stretch_region_set_static_delegate = new efl_gfx_image_stretch_region_set_delegate(stretch_region_set);
1474             }
1475
1476             if (methods.FirstOrDefault(m => m.Name == "SetStretchRegion") != null)
1477             {
1478                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_stretch_region_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_stretch_region_set_static_delegate) });
1479             }
1480
1481             if (efl_gfx_image_size_get_static_delegate == null)
1482             {
1483                 efl_gfx_image_size_get_static_delegate = new efl_gfx_image_size_get_delegate(image_size_get);
1484             }
1485
1486             if (methods.FirstOrDefault(m => m.Name == "GetImageSize") != null)
1487             {
1488                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_size_get_static_delegate) });
1489             }
1490
1491             if (efl_gfx_image_content_hint_get_static_delegate == null)
1492             {
1493                 efl_gfx_image_content_hint_get_static_delegate = new efl_gfx_image_content_hint_get_delegate(content_hint_get);
1494             }
1495
1496             if (methods.FirstOrDefault(m => m.Name == "GetContentHint") != null)
1497             {
1498                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_hint_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_hint_get_static_delegate) });
1499             }
1500
1501             if (efl_gfx_image_content_hint_set_static_delegate == null)
1502             {
1503                 efl_gfx_image_content_hint_set_static_delegate = new efl_gfx_image_content_hint_set_delegate(content_hint_set);
1504             }
1505
1506             if (methods.FirstOrDefault(m => m.Name == "SetContentHint") != null)
1507             {
1508                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_content_hint_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_content_hint_set_static_delegate) });
1509             }
1510
1511             if (efl_gfx_image_scale_hint_get_static_delegate == null)
1512             {
1513                 efl_gfx_image_scale_hint_get_static_delegate = new efl_gfx_image_scale_hint_get_delegate(scale_hint_get);
1514             }
1515
1516             if (methods.FirstOrDefault(m => m.Name == "GetScaleHint") != null)
1517             {
1518                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_hint_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_hint_get_static_delegate) });
1519             }
1520
1521             if (efl_gfx_image_scale_hint_set_static_delegate == null)
1522             {
1523                 efl_gfx_image_scale_hint_set_static_delegate = new efl_gfx_image_scale_hint_set_delegate(scale_hint_set);
1524             }
1525
1526             if (methods.FirstOrDefault(m => m.Name == "SetScaleHint") != null)
1527             {
1528                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_scale_hint_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_scale_hint_set_static_delegate) });
1529             }
1530
1531             if (efl_gfx_image_load_error_get_static_delegate == null)
1532             {
1533                 efl_gfx_image_load_error_get_static_delegate = new efl_gfx_image_load_error_get_delegate(image_load_error_get);
1534             }
1535
1536             if (methods.FirstOrDefault(m => m.Name == "GetImageLoadError") != null)
1537             {
1538                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_load_error_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_load_error_get_static_delegate) });
1539             }
1540
1541             if (efl_gfx_image_orientation_get_static_delegate == null)
1542             {
1543                 efl_gfx_image_orientation_get_static_delegate = new efl_gfx_image_orientation_get_delegate(image_orientation_get);
1544             }
1545
1546             if (methods.FirstOrDefault(m => m.Name == "GetImageOrientation") != null)
1547             {
1548                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_orientation_get_static_delegate) });
1549             }
1550
1551             if (efl_gfx_image_orientation_set_static_delegate == null)
1552             {
1553                 efl_gfx_image_orientation_set_static_delegate = new efl_gfx_image_orientation_set_delegate(image_orientation_set);
1554             }
1555
1556             if (methods.FirstOrDefault(m => m.Name == "SetImageOrientation") != null)
1557             {
1558                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_image_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_image_orientation_set_static_delegate) });
1559             }
1560
1561             if (efl_gfx_view_size_get_static_delegate == null)
1562             {
1563                 efl_gfx_view_size_get_static_delegate = new efl_gfx_view_size_get_delegate(view_size_get);
1564             }
1565
1566             if (methods.FirstOrDefault(m => m.Name == "GetViewSize") != null)
1567             {
1568                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_view_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_view_size_get_static_delegate) });
1569             }
1570
1571             if (efl_gfx_view_size_set_static_delegate == null)
1572             {
1573                 efl_gfx_view_size_set_static_delegate = new efl_gfx_view_size_set_delegate(view_size_set);
1574             }
1575
1576             if (methods.FirstOrDefault(m => m.Name == "SetViewSize") != null)
1577             {
1578                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_view_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_view_size_set_static_delegate) });
1579             }
1580
1581             descs.AddRange(base.GetEoOps(type));
1582             return descs;
1583         }
1584         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1585         /// <returns>The native class pointer.</returns>
1586         public override IntPtr GetEflClass()
1587         {
1588             return Efl.Canvas.ImageInternal.efl_canvas_image_internal_class_get();
1589         }
1590
1591         #pragma warning disable CA1707, CS1591, SA1300, SA1600
1592
1593         [return: MarshalAs(UnmanagedType.U1)]
1594         private delegate bool efl_file_save_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key,  ref Efl.FileSaveInfo.NativeStruct info);
1595
1596         [return: MarshalAs(UnmanagedType.U1)]
1597         public delegate bool efl_file_save_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key,  ref Efl.FileSaveInfo.NativeStruct info);
1598
1599         public static Efl.Eo.FunctionWrapper<efl_file_save_api_delegate> efl_file_save_ptr = new Efl.Eo.FunctionWrapper<efl_file_save_api_delegate>(Module, "efl_file_save");
1600
1601         private static bool save(System.IntPtr obj, System.IntPtr pd, System.String file, System.String key, ref Efl.FileSaveInfo.NativeStruct info)
1602         {
1603             Eina.Log.Debug("function efl_file_save was called");
1604             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1605             if (ws != null)
1606             {
1607                         Efl.FileSaveInfo _in_info = info;
1608                                                             bool _ret_var = default(bool);
1609                 try
1610                 {
1611                     _ret_var = ((ImageInternal)ws.Target).Save(file, key, ref _in_info);
1612                 }
1613                 catch (Exception e)
1614                 {
1615                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1616                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1617                 }
1618
1619                                                 info = _in_info;
1620         return _ret_var;
1621
1622             }
1623             else
1624             {
1625                 return efl_file_save_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file, key, ref info);
1626             }
1627         }
1628
1629         private static efl_file_save_delegate efl_file_save_static_delegate;
1630
1631
1632         private delegate void evas_filter_changed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
1633
1634
1635         public delegate void evas_filter_changed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
1636
1637         public static Efl.Eo.FunctionWrapper<evas_filter_changed_set_api_delegate> evas_filter_changed_set_ptr = new Efl.Eo.FunctionWrapper<evas_filter_changed_set_api_delegate>(Module, "evas_filter_changed_set");
1638
1639         private static void filter_changed_set(System.IntPtr obj, System.IntPtr pd, bool val)
1640         {
1641             Eina.Log.Debug("function evas_filter_changed_set was called");
1642             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1643             if (ws != null)
1644             {
1645
1646                 try
1647                 {
1648                     ((ImageInternal)ws.Target).SetFilterChanged(val);
1649                 }
1650                 catch (Exception e)
1651                 {
1652                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1653                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1654                 }
1655
1656
1657             }
1658             else
1659             {
1660                 evas_filter_changed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1661             }
1662         }
1663
1664         private static evas_filter_changed_set_delegate evas_filter_changed_set_static_delegate;
1665
1666
1667         private delegate void evas_filter_invalid_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
1668
1669
1670         public delegate void evas_filter_invalid_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
1671
1672         public static Efl.Eo.FunctionWrapper<evas_filter_invalid_set_api_delegate> evas_filter_invalid_set_ptr = new Efl.Eo.FunctionWrapper<evas_filter_invalid_set_api_delegate>(Module, "evas_filter_invalid_set");
1673
1674         private static void filter_invalid_set(System.IntPtr obj, System.IntPtr pd, bool val)
1675         {
1676             Eina.Log.Debug("function evas_filter_invalid_set was called");
1677             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1678             if (ws != null)
1679             {
1680
1681                 try
1682                 {
1683                     ((ImageInternal)ws.Target).SetFilterInvalid(val);
1684                 }
1685                 catch (Exception e)
1686                 {
1687                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1688                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1689                 }
1690
1691
1692             }
1693             else
1694             {
1695                 evas_filter_invalid_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
1696             }
1697         }
1698
1699         private static evas_filter_invalid_set_delegate evas_filter_invalid_set_static_delegate;
1700
1701
1702         private delegate System.IntPtr evas_filter_output_buffer_get_delegate(System.IntPtr obj, System.IntPtr pd);
1703
1704
1705         public delegate System.IntPtr evas_filter_output_buffer_get_api_delegate(System.IntPtr obj);
1706
1707         public static Efl.Eo.FunctionWrapper<evas_filter_output_buffer_get_api_delegate> evas_filter_output_buffer_get_ptr = new Efl.Eo.FunctionWrapper<evas_filter_output_buffer_get_api_delegate>(Module, "evas_filter_output_buffer_get");
1708
1709         private static System.IntPtr filter_output_buffer_get(System.IntPtr obj, System.IntPtr pd)
1710         {
1711             Eina.Log.Debug("function evas_filter_output_buffer_get was called");
1712             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1713             if (ws != null)
1714             {
1715             System.IntPtr _ret_var = default(System.IntPtr);
1716                 try
1717                 {
1718                     _ret_var = ((ImageInternal)ws.Target).GetFilterOutputBuffer();
1719                 }
1720                 catch (Exception e)
1721                 {
1722                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1723                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1724                 }
1725
1726         return _ret_var;
1727
1728             }
1729             else
1730             {
1731                 return evas_filter_output_buffer_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1732             }
1733         }
1734
1735         private static evas_filter_output_buffer_get_delegate evas_filter_output_buffer_get_static_delegate;
1736
1737         [return: MarshalAs(UnmanagedType.U1)]
1738         private delegate bool evas_filter_input_alpha_delegate(System.IntPtr obj, System.IntPtr pd);
1739
1740         [return: MarshalAs(UnmanagedType.U1)]
1741         public delegate bool evas_filter_input_alpha_api_delegate(System.IntPtr obj);
1742
1743         public static Efl.Eo.FunctionWrapper<evas_filter_input_alpha_api_delegate> evas_filter_input_alpha_ptr = new Efl.Eo.FunctionWrapper<evas_filter_input_alpha_api_delegate>(Module, "evas_filter_input_alpha");
1744
1745         private static bool filter_input_alpha(System.IntPtr obj, System.IntPtr pd)
1746         {
1747             Eina.Log.Debug("function evas_filter_input_alpha was called");
1748             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1749             if (ws != null)
1750             {
1751             bool _ret_var = default(bool);
1752                 try
1753                 {
1754                     _ret_var = ((ImageInternal)ws.Target).FilterInputAlpha();
1755                 }
1756                 catch (Exception e)
1757                 {
1758                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1759                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1760                 }
1761
1762         return _ret_var;
1763
1764             }
1765             else
1766             {
1767                 return evas_filter_input_alpha_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1768             }
1769         }
1770
1771         private static evas_filter_input_alpha_delegate evas_filter_input_alpha_static_delegate;
1772
1773
1774         private delegate void evas_filter_state_prepare_delegate(System.IntPtr obj, System.IntPtr pd,  out Efl.Canvas.Filter.State.NativeStruct state,  System.IntPtr data);
1775
1776
1777         public delegate void evas_filter_state_prepare_api_delegate(System.IntPtr obj,  out Efl.Canvas.Filter.State.NativeStruct state,  System.IntPtr data);
1778
1779         public static Efl.Eo.FunctionWrapper<evas_filter_state_prepare_api_delegate> evas_filter_state_prepare_ptr = new Efl.Eo.FunctionWrapper<evas_filter_state_prepare_api_delegate>(Module, "evas_filter_state_prepare");
1780
1781         private static void filter_state_prepare(System.IntPtr obj, System.IntPtr pd, out Efl.Canvas.Filter.State.NativeStruct state, System.IntPtr data)
1782         {
1783             Eina.Log.Debug("function evas_filter_state_prepare was called");
1784             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1785             if (ws != null)
1786             {
1787                         Efl.Canvas.Filter.State _out_state = default(Efl.Canvas.Filter.State);
1788
1789                 try
1790                 {
1791                     ((ImageInternal)ws.Target).FilterStatePrepare(out _out_state, data);
1792                 }
1793                 catch (Exception e)
1794                 {
1795                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1796                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1797                 }
1798
1799         state = _out_state;
1800
1801             }
1802             else
1803             {
1804                 evas_filter_state_prepare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out state, data);
1805             }
1806         }
1807
1808         private static evas_filter_state_prepare_delegate evas_filter_state_prepare_static_delegate;
1809
1810         [return: MarshalAs(UnmanagedType.U1)]
1811         private delegate bool evas_filter_input_render_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr filter,  System.IntPtr engine,  System.IntPtr output,  System.IntPtr drawctx,  System.IntPtr data,  int l,  int r,  int t,  int b,  int x,  int y, [MarshalAs(UnmanagedType.U1)] bool do_async);
1812
1813         [return: MarshalAs(UnmanagedType.U1)]
1814         public delegate bool evas_filter_input_render_api_delegate(System.IntPtr obj,  System.IntPtr filter,  System.IntPtr engine,  System.IntPtr output,  System.IntPtr drawctx,  System.IntPtr data,  int l,  int r,  int t,  int b,  int x,  int y, [MarshalAs(UnmanagedType.U1)] bool do_async);
1815
1816         public static Efl.Eo.FunctionWrapper<evas_filter_input_render_api_delegate> evas_filter_input_render_ptr = new Efl.Eo.FunctionWrapper<evas_filter_input_render_api_delegate>(Module, "evas_filter_input_render");
1817
1818         private static bool filter_input_render(System.IntPtr obj, System.IntPtr pd, System.IntPtr filter, System.IntPtr engine, System.IntPtr output, System.IntPtr drawctx, System.IntPtr data, int l, int r, int t, int b, int x, int y, bool do_async)
1819         {
1820             Eina.Log.Debug("function evas_filter_input_render was called");
1821             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1822             if (ws != null)
1823             {
1824                                                                                                                                                                                                                                                                                                             bool _ret_var = default(bool);
1825                 try
1826                 {
1827                     _ret_var = ((ImageInternal)ws.Target).FilterInputRender(filter, engine, output, drawctx, data, l, r, t, b, x, y, do_async);
1828                 }
1829                 catch (Exception e)
1830                 {
1831                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1832                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1833                 }
1834
1835                                                                                                                                                                                                         return _ret_var;
1836
1837             }
1838             else
1839             {
1840                 return evas_filter_input_render_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), filter, engine, output, drawctx, data, l, r, t, b, x, y, do_async);
1841             }
1842         }
1843
1844         private static evas_filter_input_render_delegate evas_filter_input_render_static_delegate;
1845
1846
1847         private delegate void evas_filter_dirty_delegate(System.IntPtr obj, System.IntPtr pd);
1848
1849
1850         public delegate void evas_filter_dirty_api_delegate(System.IntPtr obj);
1851
1852         public static Efl.Eo.FunctionWrapper<evas_filter_dirty_api_delegate> evas_filter_dirty_ptr = new Efl.Eo.FunctionWrapper<evas_filter_dirty_api_delegate>(Module, "evas_filter_dirty");
1853
1854         private static void filter_dirty(System.IntPtr obj, System.IntPtr pd)
1855         {
1856             Eina.Log.Debug("function evas_filter_dirty was called");
1857             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1858             if (ws != null)
1859             {
1860
1861                 try
1862                 {
1863                     ((ImageInternal)ws.Target).FilterDirty();
1864                 }
1865                 catch (Exception e)
1866                 {
1867                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1868                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1869                 }
1870
1871
1872             }
1873             else
1874             {
1875                 evas_filter_dirty_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1876             }
1877         }
1878
1879         private static evas_filter_dirty_delegate evas_filter_dirty_static_delegate;
1880
1881
1882         private delegate Eina.Size2D.NativeStruct efl_gfx_buffer_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1883
1884
1885         public delegate Eina.Size2D.NativeStruct efl_gfx_buffer_size_get_api_delegate(System.IntPtr obj);
1886
1887         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_size_get_api_delegate> efl_gfx_buffer_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_size_get_api_delegate>(Module, "efl_gfx_buffer_size_get");
1888
1889         private static Eina.Size2D.NativeStruct buffer_size_get(System.IntPtr obj, System.IntPtr pd)
1890         {
1891             Eina.Log.Debug("function efl_gfx_buffer_size_get was called");
1892             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1893             if (ws != null)
1894             {
1895             Eina.Size2D _ret_var = default(Eina.Size2D);
1896                 try
1897                 {
1898                     _ret_var = ((ImageInternal)ws.Target).GetBufferSize();
1899                 }
1900                 catch (Exception e)
1901                 {
1902                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1903                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1904                 }
1905
1906         return _ret_var;
1907
1908             }
1909             else
1910             {
1911                 return efl_gfx_buffer_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1912             }
1913         }
1914
1915         private static efl_gfx_buffer_size_get_delegate efl_gfx_buffer_size_get_static_delegate;
1916
1917
1918         private delegate void efl_gfx_buffer_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct sz);
1919
1920
1921         public delegate void efl_gfx_buffer_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct sz);
1922
1923         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_size_set_api_delegate> efl_gfx_buffer_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_size_set_api_delegate>(Module, "efl_gfx_buffer_size_set");
1924
1925         private static void buffer_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct sz)
1926         {
1927             Eina.Log.Debug("function efl_gfx_buffer_size_set was called");
1928             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1929             if (ws != null)
1930             {
1931         Eina.Size2D _in_sz = sz;
1932
1933                 try
1934                 {
1935                     ((ImageInternal)ws.Target).SetBufferSize(_in_sz);
1936                 }
1937                 catch (Exception e)
1938                 {
1939                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1940                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1941                 }
1942
1943
1944             }
1945             else
1946             {
1947                 efl_gfx_buffer_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), sz);
1948             }
1949         }
1950
1951         private static efl_gfx_buffer_size_set_delegate efl_gfx_buffer_size_set_static_delegate;
1952
1953
1954         private delegate Efl.Gfx.Colorspace efl_gfx_buffer_colorspace_get_delegate(System.IntPtr obj, System.IntPtr pd);
1955
1956
1957         public delegate Efl.Gfx.Colorspace efl_gfx_buffer_colorspace_get_api_delegate(System.IntPtr obj);
1958
1959         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_colorspace_get_api_delegate> efl_gfx_buffer_colorspace_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_colorspace_get_api_delegate>(Module, "efl_gfx_buffer_colorspace_get");
1960
1961         private static Efl.Gfx.Colorspace colorspace_get(System.IntPtr obj, System.IntPtr pd)
1962         {
1963             Eina.Log.Debug("function efl_gfx_buffer_colorspace_get was called");
1964             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1965             if (ws != null)
1966             {
1967             Efl.Gfx.Colorspace _ret_var = default(Efl.Gfx.Colorspace);
1968                 try
1969                 {
1970                     _ret_var = ((ImageInternal)ws.Target).GetColorspace();
1971                 }
1972                 catch (Exception e)
1973                 {
1974                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1975                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1976                 }
1977
1978         return _ret_var;
1979
1980             }
1981             else
1982             {
1983                 return efl_gfx_buffer_colorspace_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1984             }
1985         }
1986
1987         private static efl_gfx_buffer_colorspace_get_delegate efl_gfx_buffer_colorspace_get_static_delegate;
1988
1989         [return: MarshalAs(UnmanagedType.U1)]
1990         private delegate bool efl_gfx_buffer_alpha_get_delegate(System.IntPtr obj, System.IntPtr pd);
1991
1992         [return: MarshalAs(UnmanagedType.U1)]
1993         public delegate bool efl_gfx_buffer_alpha_get_api_delegate(System.IntPtr obj);
1994
1995         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_alpha_get_api_delegate> efl_gfx_buffer_alpha_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_alpha_get_api_delegate>(Module, "efl_gfx_buffer_alpha_get");
1996
1997         private static bool alpha_get(System.IntPtr obj, System.IntPtr pd)
1998         {
1999             Eina.Log.Debug("function efl_gfx_buffer_alpha_get was called");
2000             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2001             if (ws != null)
2002             {
2003             bool _ret_var = default(bool);
2004                 try
2005                 {
2006                     _ret_var = ((ImageInternal)ws.Target).GetAlpha();
2007                 }
2008                 catch (Exception e)
2009                 {
2010                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2011                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2012                 }
2013
2014         return _ret_var;
2015
2016             }
2017             else
2018             {
2019                 return efl_gfx_buffer_alpha_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2020             }
2021         }
2022
2023         private static efl_gfx_buffer_alpha_get_delegate efl_gfx_buffer_alpha_get_static_delegate;
2024
2025
2026         private delegate void efl_gfx_buffer_alpha_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool alpha);
2027
2028
2029         public delegate void efl_gfx_buffer_alpha_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool alpha);
2030
2031         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_alpha_set_api_delegate> efl_gfx_buffer_alpha_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_alpha_set_api_delegate>(Module, "efl_gfx_buffer_alpha_set");
2032
2033         private static void alpha_set(System.IntPtr obj, System.IntPtr pd, bool alpha)
2034         {
2035             Eina.Log.Debug("function efl_gfx_buffer_alpha_set was called");
2036             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2037             if (ws != null)
2038             {
2039
2040                 try
2041                 {
2042                     ((ImageInternal)ws.Target).SetAlpha(alpha);
2043                 }
2044                 catch (Exception e)
2045                 {
2046                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2047                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2048                 }
2049
2050
2051             }
2052             else
2053             {
2054                 efl_gfx_buffer_alpha_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), alpha);
2055             }
2056         }
2057
2058         private static efl_gfx_buffer_alpha_set_delegate efl_gfx_buffer_alpha_set_static_delegate;
2059
2060
2061         private delegate int efl_gfx_buffer_stride_get_delegate(System.IntPtr obj, System.IntPtr pd);
2062
2063
2064         public delegate int efl_gfx_buffer_stride_get_api_delegate(System.IntPtr obj);
2065
2066         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_stride_get_api_delegate> efl_gfx_buffer_stride_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_stride_get_api_delegate>(Module, "efl_gfx_buffer_stride_get");
2067
2068         private static int stride_get(System.IntPtr obj, System.IntPtr pd)
2069         {
2070             Eina.Log.Debug("function efl_gfx_buffer_stride_get was called");
2071             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2072             if (ws != null)
2073             {
2074             int _ret_var = default(int);
2075                 try
2076                 {
2077                     _ret_var = ((ImageInternal)ws.Target).GetStride();
2078                 }
2079                 catch (Exception e)
2080                 {
2081                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2082                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2083                 }
2084
2085         return _ret_var;
2086
2087             }
2088             else
2089             {
2090                 return efl_gfx_buffer_stride_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2091             }
2092         }
2093
2094         private static efl_gfx_buffer_stride_get_delegate efl_gfx_buffer_stride_get_static_delegate;
2095
2096
2097         private delegate void efl_gfx_buffer_borders_get_delegate(System.IntPtr obj, System.IntPtr pd,  out uint l,  out uint r,  out uint t,  out uint b);
2098
2099
2100         public delegate void efl_gfx_buffer_borders_get_api_delegate(System.IntPtr obj,  out uint l,  out uint r,  out uint t,  out uint b);
2101
2102         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_borders_get_api_delegate> efl_gfx_buffer_borders_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_borders_get_api_delegate>(Module, "efl_gfx_buffer_borders_get");
2103
2104         private static void buffer_borders_get(System.IntPtr obj, System.IntPtr pd, out uint l, out uint r, out uint t, out uint b)
2105         {
2106             Eina.Log.Debug("function efl_gfx_buffer_borders_get was called");
2107             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2108             if (ws != null)
2109             {
2110                                         l = default(uint);        r = default(uint);        t = default(uint);        b = default(uint);
2111                 try
2112                 {
2113                     ((ImageInternal)ws.Target).GetBufferBorders(out l, out r, out t, out b);
2114                 }
2115                 catch (Exception e)
2116                 {
2117                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2118                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2119                 }
2120
2121
2122             }
2123             else
2124             {
2125                 efl_gfx_buffer_borders_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out l, out r, out t, out b);
2126             }
2127         }
2128
2129         private static efl_gfx_buffer_borders_get_delegate efl_gfx_buffer_borders_get_static_delegate;
2130
2131
2132         private delegate void efl_gfx_buffer_update_add_delegate(System.IntPtr obj, System.IntPtr pd,  ref Eina.Rect.NativeStruct region);
2133
2134
2135         public delegate void efl_gfx_buffer_update_add_api_delegate(System.IntPtr obj,  ref Eina.Rect.NativeStruct region);
2136
2137         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_update_add_api_delegate> efl_gfx_buffer_update_add_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_update_add_api_delegate>(Module, "efl_gfx_buffer_update_add");
2138
2139         private static void buffer_update_add(System.IntPtr obj, System.IntPtr pd, ref Eina.Rect.NativeStruct region)
2140         {
2141             Eina.Log.Debug("function efl_gfx_buffer_update_add was called");
2142             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2143             if (ws != null)
2144             {
2145         Eina.Rect _in_region = region;
2146
2147                 try
2148                 {
2149                     ((ImageInternal)ws.Target).AddBufferUpdate(ref _in_region);
2150                 }
2151                 catch (Exception e)
2152                 {
2153                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2154                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2155                 }
2156
2157                 region = _in_region;
2158
2159             }
2160             else
2161             {
2162                 efl_gfx_buffer_update_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref region);
2163             }
2164         }
2165
2166         private static efl_gfx_buffer_update_add_delegate efl_gfx_buffer_update_add_static_delegate;
2167
2168
2169         private delegate Eina.RwSlice efl_gfx_buffer_map_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.BufferAccessMode mode,  ref Eina.Rect.NativeStruct region,  Efl.Gfx.Colorspace cspace,  int plane,  out int stride);
2170
2171
2172         public delegate Eina.RwSlice efl_gfx_buffer_map_api_delegate(System.IntPtr obj,  Efl.Gfx.BufferAccessMode mode,  ref Eina.Rect.NativeStruct region,  Efl.Gfx.Colorspace cspace,  int plane,  out int stride);
2173
2174         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_map_api_delegate> efl_gfx_buffer_map_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_map_api_delegate>(Module, "efl_gfx_buffer_map");
2175
2176         private static Eina.RwSlice buffer_map(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BufferAccessMode mode, ref Eina.Rect.NativeStruct region, Efl.Gfx.Colorspace cspace, int plane, out int stride)
2177         {
2178             Eina.Log.Debug("function efl_gfx_buffer_map was called");
2179             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2180             if (ws != null)
2181             {
2182                 Eina.Rect _in_region = region;
2183                                                                 stride = default(int);                                                    Eina.RwSlice _ret_var = default(Eina.RwSlice);
2184                 try
2185                 {
2186                     _ret_var = ((ImageInternal)ws.Target).BufferMap(mode, ref _in_region, cspace, plane, out stride);
2187                 }
2188                 catch (Exception e)
2189                 {
2190                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2191                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2192                 }
2193
2194                                                         region = _in_region;
2195                                 return _ret_var;
2196
2197             }
2198             else
2199             {
2200                 return efl_gfx_buffer_map_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), mode, ref region, cspace, plane, out stride);
2201             }
2202         }
2203
2204         private static efl_gfx_buffer_map_delegate efl_gfx_buffer_map_static_delegate;
2205
2206         [return: MarshalAs(UnmanagedType.U1)]
2207         private delegate bool efl_gfx_buffer_unmap_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.RwSlice slice);
2208
2209         [return: MarshalAs(UnmanagedType.U1)]
2210         public delegate bool efl_gfx_buffer_unmap_api_delegate(System.IntPtr obj,  Eina.RwSlice slice);
2211
2212         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_unmap_api_delegate> efl_gfx_buffer_unmap_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_unmap_api_delegate>(Module, "efl_gfx_buffer_unmap");
2213
2214         private static bool buffer_unmap(System.IntPtr obj, System.IntPtr pd, Eina.RwSlice slice)
2215         {
2216             Eina.Log.Debug("function efl_gfx_buffer_unmap was called");
2217             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2218             if (ws != null)
2219             {
2220                                     bool _ret_var = default(bool);
2221                 try
2222                 {
2223                     _ret_var = ((ImageInternal)ws.Target).BufferUnmap(slice);
2224                 }
2225                 catch (Exception e)
2226                 {
2227                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2228                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2229                 }
2230
2231                         return _ret_var;
2232
2233             }
2234             else
2235             {
2236                 return efl_gfx_buffer_unmap_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), slice);
2237             }
2238         }
2239
2240         private static efl_gfx_buffer_unmap_delegate efl_gfx_buffer_unmap_static_delegate;
2241
2242         [return: MarshalAs(UnmanagedType.U1)]
2243         private delegate bool efl_gfx_buffer_copy_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr slice,  Eina.Size2D.NativeStruct size,  int stride,  Efl.Gfx.Colorspace cspace,  int plane);
2244
2245         [return: MarshalAs(UnmanagedType.U1)]
2246         public delegate bool efl_gfx_buffer_copy_set_api_delegate(System.IntPtr obj,  System.IntPtr slice,  Eina.Size2D.NativeStruct size,  int stride,  Efl.Gfx.Colorspace cspace,  int plane);
2247
2248         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_copy_set_api_delegate> efl_gfx_buffer_copy_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_copy_set_api_delegate>(Module, "efl_gfx_buffer_copy_set");
2249
2250         private static bool buffer_copy_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr slice, Eina.Size2D.NativeStruct size, int stride, Efl.Gfx.Colorspace cspace, int plane)
2251         {
2252             Eina.Log.Debug("function efl_gfx_buffer_copy_set was called");
2253             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2254             if (ws != null)
2255             {
2256         var _in_slice = Eina.PrimitiveConversion.PointerToManaged<Eina.Slice>(slice);
2257         Eina.Size2D _in_size = size;
2258                                                                                                                     bool _ret_var = default(bool);
2259                 try
2260                 {
2261                     _ret_var = ((ImageInternal)ws.Target).SetBufferCopy(_in_slice, _in_size, stride, cspace, plane);
2262                 }
2263                 catch (Exception e)
2264                 {
2265                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2266                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2267                 }
2268
2269                                                                                         return _ret_var;
2270
2271             }
2272             else
2273             {
2274                 return efl_gfx_buffer_copy_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), slice, size, stride, cspace, plane);
2275             }
2276         }
2277
2278         private static efl_gfx_buffer_copy_set_delegate efl_gfx_buffer_copy_set_static_delegate;
2279
2280         [return: MarshalAs(UnmanagedType.U1)]
2281         private delegate bool efl_gfx_buffer_managed_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr slice,  Eina.Size2D.NativeStruct size,  int stride,  Efl.Gfx.Colorspace cspace,  int plane);
2282
2283         [return: MarshalAs(UnmanagedType.U1)]
2284         public delegate bool efl_gfx_buffer_managed_set_api_delegate(System.IntPtr obj,  System.IntPtr slice,  Eina.Size2D.NativeStruct size,  int stride,  Efl.Gfx.Colorspace cspace,  int plane);
2285
2286         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_managed_set_api_delegate> efl_gfx_buffer_managed_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_managed_set_api_delegate>(Module, "efl_gfx_buffer_managed_set");
2287
2288         private static bool buffer_managed_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr slice, Eina.Size2D.NativeStruct size, int stride, Efl.Gfx.Colorspace cspace, int plane)
2289         {
2290             Eina.Log.Debug("function efl_gfx_buffer_managed_set was called");
2291             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2292             if (ws != null)
2293             {
2294         var _in_slice = Eina.PrimitiveConversion.PointerToManaged<Eina.Slice>(slice);
2295         Eina.Size2D _in_size = size;
2296                                                                                                                     bool _ret_var = default(bool);
2297                 try
2298                 {
2299                     _ret_var = ((ImageInternal)ws.Target).SetBufferManaged(_in_slice, _in_size, stride, cspace, plane);
2300                 }
2301                 catch (Exception e)
2302                 {
2303                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2304                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2305                 }
2306
2307                                                                                         return _ret_var;
2308
2309             }
2310             else
2311             {
2312                 return efl_gfx_buffer_managed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), slice, size, stride, cspace, plane);
2313             }
2314         }
2315
2316         private static efl_gfx_buffer_managed_set_delegate efl_gfx_buffer_managed_set_static_delegate;
2317
2318
2319         private delegate Eina.Slice efl_gfx_buffer_managed_get_delegate(System.IntPtr obj, System.IntPtr pd,  int plane);
2320
2321
2322         public delegate Eina.Slice efl_gfx_buffer_managed_get_api_delegate(System.IntPtr obj,  int plane);
2323
2324         public static Efl.Eo.FunctionWrapper<efl_gfx_buffer_managed_get_api_delegate> efl_gfx_buffer_managed_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_buffer_managed_get_api_delegate>(Module, "efl_gfx_buffer_managed_get");
2325
2326         private static Eina.Slice buffer_managed_get(System.IntPtr obj, System.IntPtr pd, int plane)
2327         {
2328             Eina.Log.Debug("function efl_gfx_buffer_managed_get was called");
2329             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2330             if (ws != null)
2331             {
2332                                     Eina.Slice _ret_var = default(Eina.Slice);
2333                 try
2334                 {
2335                     _ret_var = ((ImageInternal)ws.Target).GetBufferManaged(plane);
2336                 }
2337                 catch (Exception e)
2338                 {
2339                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2340                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2341                 }
2342
2343                         return _ret_var;
2344
2345             }
2346             else
2347             {
2348                 return efl_gfx_buffer_managed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), plane);
2349             }
2350         }
2351
2352         private static efl_gfx_buffer_managed_get_delegate efl_gfx_buffer_managed_get_static_delegate;
2353
2354         [return: MarshalAs(UnmanagedType.U1)]
2355         private delegate bool efl_gfx_fill_auto_get_delegate(System.IntPtr obj, System.IntPtr pd);
2356
2357         [return: MarshalAs(UnmanagedType.U1)]
2358         public delegate bool efl_gfx_fill_auto_get_api_delegate(System.IntPtr obj);
2359
2360         public static Efl.Eo.FunctionWrapper<efl_gfx_fill_auto_get_api_delegate> efl_gfx_fill_auto_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_fill_auto_get_api_delegate>(Module, "efl_gfx_fill_auto_get");
2361
2362         private static bool fill_auto_get(System.IntPtr obj, System.IntPtr pd)
2363         {
2364             Eina.Log.Debug("function efl_gfx_fill_auto_get was called");
2365             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2366             if (ws != null)
2367             {
2368             bool _ret_var = default(bool);
2369                 try
2370                 {
2371                     _ret_var = ((ImageInternal)ws.Target).GetFillAuto();
2372                 }
2373                 catch (Exception e)
2374                 {
2375                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2376                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2377                 }
2378
2379         return _ret_var;
2380
2381             }
2382             else
2383             {
2384                 return efl_gfx_fill_auto_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2385             }
2386         }
2387
2388         private static efl_gfx_fill_auto_get_delegate efl_gfx_fill_auto_get_static_delegate;
2389
2390
2391         private delegate void efl_gfx_fill_auto_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool filled);
2392
2393
2394         public delegate void efl_gfx_fill_auto_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool filled);
2395
2396         public static Efl.Eo.FunctionWrapper<efl_gfx_fill_auto_set_api_delegate> efl_gfx_fill_auto_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_fill_auto_set_api_delegate>(Module, "efl_gfx_fill_auto_set");
2397
2398         private static void fill_auto_set(System.IntPtr obj, System.IntPtr pd, bool filled)
2399         {
2400             Eina.Log.Debug("function efl_gfx_fill_auto_set was called");
2401             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2402             if (ws != null)
2403             {
2404
2405                 try
2406                 {
2407                     ((ImageInternal)ws.Target).SetFillAuto(filled);
2408                 }
2409                 catch (Exception e)
2410                 {
2411                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2412                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2413                 }
2414
2415
2416             }
2417             else
2418             {
2419                 efl_gfx_fill_auto_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), filled);
2420             }
2421         }
2422
2423         private static efl_gfx_fill_auto_set_delegate efl_gfx_fill_auto_set_static_delegate;
2424
2425
2426         private delegate Eina.Rect.NativeStruct efl_gfx_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
2427
2428
2429         public delegate Eina.Rect.NativeStruct efl_gfx_fill_get_api_delegate(System.IntPtr obj);
2430
2431         public static Efl.Eo.FunctionWrapper<efl_gfx_fill_get_api_delegate> efl_gfx_fill_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_fill_get_api_delegate>(Module, "efl_gfx_fill_get");
2432
2433         private static Eina.Rect.NativeStruct fill_get(System.IntPtr obj, System.IntPtr pd)
2434         {
2435             Eina.Log.Debug("function efl_gfx_fill_get was called");
2436             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2437             if (ws != null)
2438             {
2439             Eina.Rect _ret_var = default(Eina.Rect);
2440                 try
2441                 {
2442                     _ret_var = ((ImageInternal)ws.Target).GetFill();
2443                 }
2444                 catch (Exception e)
2445                 {
2446                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2447                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2448                 }
2449
2450         return _ret_var;
2451
2452             }
2453             else
2454             {
2455                 return efl_gfx_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2456             }
2457         }
2458
2459         private static efl_gfx_fill_get_delegate efl_gfx_fill_get_static_delegate;
2460
2461
2462         private delegate void efl_gfx_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct fill);
2463
2464
2465         public delegate void efl_gfx_fill_set_api_delegate(System.IntPtr obj,  Eina.Rect.NativeStruct fill);
2466
2467         public static Efl.Eo.FunctionWrapper<efl_gfx_fill_set_api_delegate> efl_gfx_fill_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_fill_set_api_delegate>(Module, "efl_gfx_fill_set");
2468
2469         private static void fill_set(System.IntPtr obj, System.IntPtr pd, Eina.Rect.NativeStruct fill)
2470         {
2471             Eina.Log.Debug("function efl_gfx_fill_set was called");
2472             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2473             if (ws != null)
2474             {
2475         Eina.Rect _in_fill = fill;
2476
2477                 try
2478                 {
2479                     ((ImageInternal)ws.Target).SetFill(_in_fill);
2480                 }
2481                 catch (Exception e)
2482                 {
2483                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2484                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2485                 }
2486
2487
2488             }
2489             else
2490             {
2491                 efl_gfx_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill);
2492             }
2493         }
2494
2495         private static efl_gfx_fill_set_delegate efl_gfx_fill_set_static_delegate;
2496
2497
2498         private delegate void efl_gfx_filter_program_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String code, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String name);
2499
2500
2501         public delegate void efl_gfx_filter_program_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String code, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String name);
2502
2503         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_program_get_api_delegate> efl_gfx_filter_program_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_program_get_api_delegate>(Module, "efl_gfx_filter_program_get");
2504
2505         private static void filter_program_get(System.IntPtr obj, System.IntPtr pd, out System.String code, out System.String name)
2506         {
2507             Eina.Log.Debug("function efl_gfx_filter_program_get was called");
2508             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2509             if (ws != null)
2510             {
2511                         System.String _out_code = default(System.String);
2512         System.String _out_name = default(System.String);
2513
2514                 try
2515                 {
2516                     ((ImageInternal)ws.Target).GetFilterProgram(out _out_code, out _out_name);
2517                 }
2518                 catch (Exception e)
2519                 {
2520                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2521                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2522                 }
2523
2524         code = _out_code;
2525         name = _out_name;
2526
2527             }
2528             else
2529             {
2530                 efl_gfx_filter_program_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out code, out name);
2531             }
2532         }
2533
2534         private static efl_gfx_filter_program_get_delegate efl_gfx_filter_program_get_static_delegate;
2535
2536
2537         private delegate void efl_gfx_filter_program_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String code, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
2538
2539
2540         public delegate void efl_gfx_filter_program_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String code, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
2541
2542         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_program_set_api_delegate> efl_gfx_filter_program_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_program_set_api_delegate>(Module, "efl_gfx_filter_program_set");
2543
2544         private static void filter_program_set(System.IntPtr obj, System.IntPtr pd, System.String code, System.String name)
2545         {
2546             Eina.Log.Debug("function efl_gfx_filter_program_set was called");
2547             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2548             if (ws != null)
2549             {
2550
2551                 try
2552                 {
2553                     ((ImageInternal)ws.Target).SetFilterProgram(code, name);
2554                 }
2555                 catch (Exception e)
2556                 {
2557                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2558                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2559                 }
2560
2561
2562             }
2563             else
2564             {
2565                 efl_gfx_filter_program_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), code, name);
2566             }
2567         }
2568
2569         private static efl_gfx_filter_program_set_delegate efl_gfx_filter_program_set_static_delegate;
2570
2571
2572         private delegate void efl_gfx_filter_state_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String cur_state,  out double cur_val, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String next_state,  out double next_val,  out double pos);
2573
2574
2575         public delegate void efl_gfx_filter_state_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String cur_state,  out double cur_val, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String next_state,  out double next_val,  out double pos);
2576
2577         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_state_get_api_delegate> efl_gfx_filter_state_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_state_get_api_delegate>(Module, "efl_gfx_filter_state_get");
2578
2579         private static void filter_state_get(System.IntPtr obj, System.IntPtr pd, out System.String cur_state, out double cur_val, out System.String next_state, out double next_val, out double pos)
2580         {
2581             Eina.Log.Debug("function efl_gfx_filter_state_get was called");
2582             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2583             if (ws != null)
2584             {
2585                                                 System.String _out_cur_state = default(System.String);
2586         cur_val = default(double);        System.String _out_next_state = default(System.String);
2587         next_val = default(double);        pos = default(double);
2588                 try
2589                 {
2590                     ((ImageInternal)ws.Target).GetFilterState(out _out_cur_state, out cur_val, out _out_next_state, out next_val, out pos);
2591                 }
2592                 catch (Exception e)
2593                 {
2594                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2595                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2596                 }
2597
2598         cur_state = _out_cur_state;
2599                 next_state = _out_next_state;
2600
2601             }
2602             else
2603             {
2604                 efl_gfx_filter_state_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out cur_state, out cur_val, out next_state, out next_val, out pos);
2605             }
2606         }
2607
2608         private static efl_gfx_filter_state_get_delegate efl_gfx_filter_state_get_static_delegate;
2609
2610
2611         private delegate void efl_gfx_filter_state_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String cur_state,  double cur_val, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String next_state,  double next_val,  double pos);
2612
2613
2614         public delegate void efl_gfx_filter_state_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String cur_state,  double cur_val, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String next_state,  double next_val,  double pos);
2615
2616         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_state_set_api_delegate> efl_gfx_filter_state_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_state_set_api_delegate>(Module, "efl_gfx_filter_state_set");
2617
2618         private static void filter_state_set(System.IntPtr obj, System.IntPtr pd, System.String cur_state, double cur_val, System.String next_state, double next_val, double pos)
2619         {
2620             Eina.Log.Debug("function efl_gfx_filter_state_set was called");
2621             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2622             if (ws != null)
2623             {
2624
2625                 try
2626                 {
2627                     ((ImageInternal)ws.Target).SetFilterState(cur_state, cur_val, next_state, next_val, pos);
2628                 }
2629                 catch (Exception e)
2630                 {
2631                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2632                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2633                 }
2634
2635
2636             }
2637             else
2638             {
2639                 efl_gfx_filter_state_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cur_state, cur_val, next_state, next_val, pos);
2640             }
2641         }
2642
2643         private static efl_gfx_filter_state_set_delegate efl_gfx_filter_state_set_static_delegate;
2644
2645
2646         private delegate void efl_gfx_filter_padding_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int l,  out int r,  out int t,  out int b);
2647
2648
2649         public delegate void efl_gfx_filter_padding_get_api_delegate(System.IntPtr obj,  out int l,  out int r,  out int t,  out int b);
2650
2651         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_padding_get_api_delegate> efl_gfx_filter_padding_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_padding_get_api_delegate>(Module, "efl_gfx_filter_padding_get");
2652
2653         private static void filter_padding_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
2654         {
2655             Eina.Log.Debug("function efl_gfx_filter_padding_get was called");
2656             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2657             if (ws != null)
2658             {
2659                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
2660                 try
2661                 {
2662                     ((ImageInternal)ws.Target).GetFilterPadding(out l, out r, out t, out b);
2663                 }
2664                 catch (Exception e)
2665                 {
2666                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2667                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2668                 }
2669
2670
2671             }
2672             else
2673             {
2674                 efl_gfx_filter_padding_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out l, out r, out t, out b);
2675             }
2676         }
2677
2678         private static efl_gfx_filter_padding_get_delegate efl_gfx_filter_padding_get_static_delegate;
2679
2680         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2681         private delegate Efl.Gfx.IEntity efl_gfx_filter_source_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
2682
2683         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
2684         public delegate Efl.Gfx.IEntity efl_gfx_filter_source_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
2685
2686         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_source_get_api_delegate> efl_gfx_filter_source_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_source_get_api_delegate>(Module, "efl_gfx_filter_source_get");
2687
2688         private static Efl.Gfx.IEntity filter_source_get(System.IntPtr obj, System.IntPtr pd, System.String name)
2689         {
2690             Eina.Log.Debug("function efl_gfx_filter_source_get was called");
2691             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2692             if (ws != null)
2693             {
2694                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
2695                 try
2696                 {
2697                     _ret_var = ((ImageInternal)ws.Target).GetFilterSource(name);
2698                 }
2699                 catch (Exception e)
2700                 {
2701                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2702                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2703                 }
2704
2705                         return _ret_var;
2706
2707             }
2708             else
2709             {
2710                 return efl_gfx_filter_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name);
2711             }
2712         }
2713
2714         private static efl_gfx_filter_source_get_delegate efl_gfx_filter_source_get_static_delegate;
2715
2716
2717         private delegate void efl_gfx_filter_source_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity source);
2718
2719
2720         public delegate void efl_gfx_filter_source_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity source);
2721
2722         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_source_set_api_delegate> efl_gfx_filter_source_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_source_set_api_delegate>(Module, "efl_gfx_filter_source_set");
2723
2724         private static void filter_source_set(System.IntPtr obj, System.IntPtr pd, System.String name, Efl.Gfx.IEntity source)
2725         {
2726             Eina.Log.Debug("function efl_gfx_filter_source_set was called");
2727             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2728             if (ws != null)
2729             {
2730
2731                 try
2732                 {
2733                     ((ImageInternal)ws.Target).SetFilterSource(name, source);
2734                 }
2735                 catch (Exception e)
2736                 {
2737                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2738                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2739                 }
2740
2741
2742             }
2743             else
2744             {
2745                 efl_gfx_filter_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, source);
2746             }
2747         }
2748
2749         private static efl_gfx_filter_source_set_delegate efl_gfx_filter_source_set_static_delegate;
2750
2751
2752         private delegate void efl_gfx_filter_data_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String value, [MarshalAs(UnmanagedType.U1)] out bool execute);
2753
2754
2755         public delegate void efl_gfx_filter_data_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] out System.String value, [MarshalAs(UnmanagedType.U1)] out bool execute);
2756
2757         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_data_get_api_delegate> efl_gfx_filter_data_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_data_get_api_delegate>(Module, "efl_gfx_filter_data_get");
2758
2759         private static void filter_data_get(System.IntPtr obj, System.IntPtr pd, System.String name, out System.String value, out bool execute)
2760         {
2761             Eina.Log.Debug("function efl_gfx_filter_data_get was called");
2762             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2763             if (ws != null)
2764             {
2765                                         System.String _out_value = default(System.String);
2766         execute = default(bool);
2767                 try
2768                 {
2769                     ((ImageInternal)ws.Target).GetFilterData(name, out _out_value, out execute);
2770                 }
2771                 catch (Exception e)
2772                 {
2773                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2774                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2775                 }
2776
2777                 value = _out_value;
2778
2779             }
2780             else
2781             {
2782                 efl_gfx_filter_data_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, out value, out execute);
2783             }
2784         }
2785
2786         private static efl_gfx_filter_data_get_delegate efl_gfx_filter_data_get_static_delegate;
2787
2788
2789         private delegate void efl_gfx_filter_data_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String value, [MarshalAs(UnmanagedType.U1)] bool execute);
2790
2791
2792         public delegate void efl_gfx_filter_data_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String value, [MarshalAs(UnmanagedType.U1)] bool execute);
2793
2794         public static Efl.Eo.FunctionWrapper<efl_gfx_filter_data_set_api_delegate> efl_gfx_filter_data_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_filter_data_set_api_delegate>(Module, "efl_gfx_filter_data_set");
2795
2796         private static void filter_data_set(System.IntPtr obj, System.IntPtr pd, System.String name, System.String value, bool execute)
2797         {
2798             Eina.Log.Debug("function efl_gfx_filter_data_set was called");
2799             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2800             if (ws != null)
2801             {
2802
2803                 try
2804                 {
2805                     ((ImageInternal)ws.Target).SetFilterData(name, value, execute);
2806                 }
2807                 catch (Exception e)
2808                 {
2809                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2810                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2811                 }
2812
2813
2814             }
2815             else
2816             {
2817                 efl_gfx_filter_data_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, value, execute);
2818             }
2819         }
2820
2821         private static efl_gfx_filter_data_set_delegate efl_gfx_filter_data_set_static_delegate;
2822
2823         [return: MarshalAs(UnmanagedType.U1)]
2824         private delegate bool efl_gfx_image_smooth_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
2825
2826         [return: MarshalAs(UnmanagedType.U1)]
2827         public delegate bool efl_gfx_image_smooth_scale_get_api_delegate(System.IntPtr obj);
2828
2829         public static Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_get_api_delegate> efl_gfx_image_smooth_scale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_get_api_delegate>(Module, "efl_gfx_image_smooth_scale_get");
2830
2831         private static bool smooth_scale_get(System.IntPtr obj, System.IntPtr pd)
2832         {
2833             Eina.Log.Debug("function efl_gfx_image_smooth_scale_get was called");
2834             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2835             if (ws != null)
2836             {
2837             bool _ret_var = default(bool);
2838                 try
2839                 {
2840                     _ret_var = ((ImageInternal)ws.Target).GetSmoothScale();
2841                 }
2842                 catch (Exception e)
2843                 {
2844                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2845                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2846                 }
2847
2848         return _ret_var;
2849
2850             }
2851             else
2852             {
2853                 return efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2854             }
2855         }
2856
2857         private static efl_gfx_image_smooth_scale_get_delegate efl_gfx_image_smooth_scale_get_static_delegate;
2858
2859
2860         private delegate void efl_gfx_image_smooth_scale_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
2861
2862
2863         public delegate void efl_gfx_image_smooth_scale_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool smooth_scale);
2864
2865         public static Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_set_api_delegate> efl_gfx_image_smooth_scale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_smooth_scale_set_api_delegate>(Module, "efl_gfx_image_smooth_scale_set");
2866
2867         private static void smooth_scale_set(System.IntPtr obj, System.IntPtr pd, bool smooth_scale)
2868         {
2869             Eina.Log.Debug("function efl_gfx_image_smooth_scale_set was called");
2870             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2871             if (ws != null)
2872             {
2873
2874                 try
2875                 {
2876                     ((ImageInternal)ws.Target).SetSmoothScale(smooth_scale);
2877                 }
2878                 catch (Exception e)
2879                 {
2880                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2881                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2882                 }
2883
2884
2885             }
2886             else
2887             {
2888                 efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), smooth_scale);
2889             }
2890         }
2891
2892         private static efl_gfx_image_smooth_scale_set_delegate efl_gfx_image_smooth_scale_set_static_delegate;
2893
2894
2895         private delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
2896
2897
2898         public delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_api_delegate(System.IntPtr obj);
2899
2900         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_get_api_delegate> efl_gfx_image_scale_type_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_get_api_delegate>(Module, "efl_gfx_image_scale_type_get");
2901
2902         private static Efl.Gfx.ImageScaleType scale_type_get(System.IntPtr obj, System.IntPtr pd)
2903         {
2904             Eina.Log.Debug("function efl_gfx_image_scale_type_get was called");
2905             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2906             if (ws != null)
2907             {
2908             Efl.Gfx.ImageScaleType _ret_var = default(Efl.Gfx.ImageScaleType);
2909                 try
2910                 {
2911                     _ret_var = ((ImageInternal)ws.Target).GetScaleType();
2912                 }
2913                 catch (Exception e)
2914                 {
2915                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2916                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2917                 }
2918
2919         return _ret_var;
2920
2921             }
2922             else
2923             {
2924                 return efl_gfx_image_scale_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2925             }
2926         }
2927
2928         private static efl_gfx_image_scale_type_get_delegate efl_gfx_image_scale_type_get_static_delegate;
2929
2930
2931         private delegate void efl_gfx_image_scale_type_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleType scale_type);
2932
2933
2934         public delegate void efl_gfx_image_scale_type_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleType scale_type);
2935
2936         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_set_api_delegate> efl_gfx_image_scale_type_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_type_set_api_delegate>(Module, "efl_gfx_image_scale_type_set");
2937
2938         private static void scale_type_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleType scale_type)
2939         {
2940             Eina.Log.Debug("function efl_gfx_image_scale_type_set was called");
2941             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2942             if (ws != null)
2943             {
2944
2945                 try
2946                 {
2947                     ((ImageInternal)ws.Target).SetScaleType(scale_type);
2948                 }
2949                 catch (Exception e)
2950                 {
2951                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2952                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2953                 }
2954
2955
2956             }
2957             else
2958             {
2959                 efl_gfx_image_scale_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale_type);
2960             }
2961         }
2962
2963         private static efl_gfx_image_scale_type_set_delegate efl_gfx_image_scale_type_set_static_delegate;
2964
2965
2966         private delegate double efl_gfx_image_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
2967
2968
2969         public delegate double efl_gfx_image_ratio_get_api_delegate(System.IntPtr obj);
2970
2971         public static Efl.Eo.FunctionWrapper<efl_gfx_image_ratio_get_api_delegate> efl_gfx_image_ratio_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_ratio_get_api_delegate>(Module, "efl_gfx_image_ratio_get");
2972
2973         private static double ratio_get(System.IntPtr obj, System.IntPtr pd)
2974         {
2975             Eina.Log.Debug("function efl_gfx_image_ratio_get was called");
2976             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2977             if (ws != null)
2978             {
2979             double _ret_var = default(double);
2980                 try
2981                 {
2982                     _ret_var = ((ImageInternal)ws.Target).GetRatio();
2983                 }
2984                 catch (Exception e)
2985                 {
2986                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2987                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2988                 }
2989
2990         return _ret_var;
2991
2992             }
2993             else
2994             {
2995                 return efl_gfx_image_ratio_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2996             }
2997         }
2998
2999         private static efl_gfx_image_ratio_get_delegate efl_gfx_image_ratio_get_static_delegate;
3000
3001
3002         private delegate Eina.Rect.NativeStruct efl_gfx_image_content_region_get_delegate(System.IntPtr obj, System.IntPtr pd);
3003
3004
3005         public delegate Eina.Rect.NativeStruct efl_gfx_image_content_region_get_api_delegate(System.IntPtr obj);
3006
3007         public static Efl.Eo.FunctionWrapper<efl_gfx_image_content_region_get_api_delegate> efl_gfx_image_content_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_content_region_get_api_delegate>(Module, "efl_gfx_image_content_region_get");
3008
3009         private static Eina.Rect.NativeStruct content_region_get(System.IntPtr obj, System.IntPtr pd)
3010         {
3011             Eina.Log.Debug("function efl_gfx_image_content_region_get was called");
3012             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3013             if (ws != null)
3014             {
3015             Eina.Rect _ret_var = default(Eina.Rect);
3016                 try
3017                 {
3018                     _ret_var = ((ImageInternal)ws.Target).GetContentRegion();
3019                 }
3020                 catch (Exception e)
3021                 {
3022                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3023                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3024                 }
3025
3026         return _ret_var;
3027
3028             }
3029             else
3030             {
3031                 return efl_gfx_image_content_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3032             }
3033         }
3034
3035         private static efl_gfx_image_content_region_get_delegate efl_gfx_image_content_region_get_static_delegate;
3036
3037
3038         private delegate void efl_gfx_image_border_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int l,  out int r,  out int t,  out int b);
3039
3040
3041         public delegate void efl_gfx_image_border_get_api_delegate(System.IntPtr obj,  out int l,  out int r,  out int t,  out int b);
3042
3043         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_get_api_delegate> efl_gfx_image_border_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_get_api_delegate>(Module, "efl_gfx_image_border_get");
3044
3045         private static void border_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
3046         {
3047             Eina.Log.Debug("function efl_gfx_image_border_get was called");
3048             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3049             if (ws != null)
3050             {
3051                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
3052                 try
3053                 {
3054                     ((ImageInternal)ws.Target).GetBorder(out l, out r, out t, out b);
3055                 }
3056                 catch (Exception e)
3057                 {
3058                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3059                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3060                 }
3061
3062
3063             }
3064             else
3065             {
3066                 efl_gfx_image_border_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out l, out r, out t, out b);
3067             }
3068         }
3069
3070         private static efl_gfx_image_border_get_delegate efl_gfx_image_border_get_static_delegate;
3071
3072
3073         private delegate void efl_gfx_image_border_set_delegate(System.IntPtr obj, System.IntPtr pd,  int l,  int r,  int t,  int b);
3074
3075
3076         public delegate void efl_gfx_image_border_set_api_delegate(System.IntPtr obj,  int l,  int r,  int t,  int b);
3077
3078         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_set_api_delegate> efl_gfx_image_border_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_set_api_delegate>(Module, "efl_gfx_image_border_set");
3079
3080         private static void border_set(System.IntPtr obj, System.IntPtr pd, int l, int r, int t, int b)
3081         {
3082             Eina.Log.Debug("function efl_gfx_image_border_set was called");
3083             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3084             if (ws != null)
3085             {
3086
3087                 try
3088                 {
3089                     ((ImageInternal)ws.Target).SetBorder(l, r, t, b);
3090                 }
3091                 catch (Exception e)
3092                 {
3093                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3094                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3095                 }
3096
3097
3098             }
3099             else
3100             {
3101                 efl_gfx_image_border_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), l, r, t, b);
3102             }
3103         }
3104
3105         private static efl_gfx_image_border_set_delegate efl_gfx_image_border_set_static_delegate;
3106
3107
3108         private delegate double efl_gfx_image_border_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
3109
3110
3111         public delegate double efl_gfx_image_border_scale_get_api_delegate(System.IntPtr obj);
3112
3113         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_get_api_delegate> efl_gfx_image_border_scale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_get_api_delegate>(Module, "efl_gfx_image_border_scale_get");
3114
3115         private static double border_scale_get(System.IntPtr obj, System.IntPtr pd)
3116         {
3117             Eina.Log.Debug("function efl_gfx_image_border_scale_get was called");
3118             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3119             if (ws != null)
3120             {
3121             double _ret_var = default(double);
3122                 try
3123                 {
3124                     _ret_var = ((ImageInternal)ws.Target).GetBorderScale();
3125                 }
3126                 catch (Exception e)
3127                 {
3128                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3129                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3130                 }
3131
3132         return _ret_var;
3133
3134             }
3135             else
3136             {
3137                 return efl_gfx_image_border_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3138             }
3139         }
3140
3141         private static efl_gfx_image_border_scale_get_delegate efl_gfx_image_border_scale_get_static_delegate;
3142
3143
3144         private delegate void efl_gfx_image_border_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double scale);
3145
3146
3147         public delegate void efl_gfx_image_border_scale_set_api_delegate(System.IntPtr obj,  double scale);
3148
3149         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_set_api_delegate> efl_gfx_image_border_scale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_scale_set_api_delegate>(Module, "efl_gfx_image_border_scale_set");
3150
3151         private static void border_scale_set(System.IntPtr obj, System.IntPtr pd, double scale)
3152         {
3153             Eina.Log.Debug("function efl_gfx_image_border_scale_set was called");
3154             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3155             if (ws != null)
3156             {
3157
3158                 try
3159                 {
3160                     ((ImageInternal)ws.Target).SetBorderScale(scale);
3161                 }
3162                 catch (Exception e)
3163                 {
3164                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3165                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3166                 }
3167
3168
3169             }
3170             else
3171             {
3172                 efl_gfx_image_border_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), scale);
3173             }
3174         }
3175
3176         private static efl_gfx_image_border_scale_set_delegate efl_gfx_image_border_scale_set_static_delegate;
3177
3178
3179         private delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
3180
3181
3182         public delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_api_delegate(System.IntPtr obj);
3183
3184         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_get_api_delegate> efl_gfx_image_border_center_fill_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_get_api_delegate>(Module, "efl_gfx_image_border_center_fill_get");
3185
3186         private static Efl.Gfx.BorderFillMode border_center_fill_get(System.IntPtr obj, System.IntPtr pd)
3187         {
3188             Eina.Log.Debug("function efl_gfx_image_border_center_fill_get was called");
3189             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3190             if (ws != null)
3191             {
3192             Efl.Gfx.BorderFillMode _ret_var = default(Efl.Gfx.BorderFillMode);
3193                 try
3194                 {
3195                     _ret_var = ((ImageInternal)ws.Target).GetBorderCenterFill();
3196                 }
3197                 catch (Exception e)
3198                 {
3199                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3200                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3201                 }
3202
3203         return _ret_var;
3204
3205             }
3206             else
3207             {
3208                 return efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3209             }
3210         }
3211
3212         private static efl_gfx_image_border_center_fill_get_delegate efl_gfx_image_border_center_fill_get_static_delegate;
3213
3214
3215         private delegate void efl_gfx_image_border_center_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.BorderFillMode fill);
3216
3217
3218         public delegate void efl_gfx_image_border_center_fill_set_api_delegate(System.IntPtr obj,  Efl.Gfx.BorderFillMode fill);
3219
3220         public static Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_set_api_delegate> efl_gfx_image_border_center_fill_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_border_center_fill_set_api_delegate>(Module, "efl_gfx_image_border_center_fill_set");
3221
3222         private static void border_center_fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.BorderFillMode fill)
3223         {
3224             Eina.Log.Debug("function efl_gfx_image_border_center_fill_set was called");
3225             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3226             if (ws != null)
3227             {
3228
3229                 try
3230                 {
3231                     ((ImageInternal)ws.Target).SetBorderCenterFill(fill);
3232                 }
3233                 catch (Exception e)
3234                 {
3235                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3236                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3237                 }
3238
3239
3240             }
3241             else
3242             {
3243                 efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill);
3244             }
3245         }
3246
3247         private static efl_gfx_image_border_center_fill_set_delegate efl_gfx_image_border_center_fill_set_static_delegate;
3248
3249
3250         private delegate void efl_gfx_image_stretch_region_get_delegate(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr horizontal,  out System.IntPtr vertical);
3251
3252
3253         public delegate void efl_gfx_image_stretch_region_get_api_delegate(System.IntPtr obj,  out System.IntPtr horizontal,  out System.IntPtr vertical);
3254
3255         public static Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_get_api_delegate> efl_gfx_image_stretch_region_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_get_api_delegate>(Module, "efl_gfx_image_stretch_region_get");
3256
3257         private static void stretch_region_get(System.IntPtr obj, System.IntPtr pd, out System.IntPtr horizontal, out System.IntPtr vertical)
3258         {
3259             Eina.Log.Debug("function efl_gfx_image_stretch_region_get was called");
3260             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3261             if (ws != null)
3262             {
3263                         Eina.Iterator<Efl.Gfx.Image.StretchRegion> _out_horizontal = default(Eina.Iterator<Efl.Gfx.Image.StretchRegion>);
3264         Eina.Iterator<Efl.Gfx.Image.StretchRegion> _out_vertical = default(Eina.Iterator<Efl.Gfx.Image.StretchRegion>);
3265
3266                 try
3267                 {
3268                     ((ImageInternal)ws.Target).GetStretchRegion(out _out_horizontal, out _out_vertical);
3269                 }
3270                 catch (Exception e)
3271                 {
3272                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3273                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3274                 }
3275
3276         horizontal = _out_horizontal.Handle;
3277         vertical = _out_vertical.Handle;
3278
3279             }
3280             else
3281             {
3282                 efl_gfx_image_stretch_region_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out horizontal, out vertical);
3283             }
3284         }
3285
3286         private static efl_gfx_image_stretch_region_get_delegate efl_gfx_image_stretch_region_get_static_delegate;
3287
3288
3289         private delegate Eina.Error efl_gfx_image_stretch_region_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr horizontal,  System.IntPtr vertical);
3290
3291
3292         public delegate Eina.Error efl_gfx_image_stretch_region_set_api_delegate(System.IntPtr obj,  System.IntPtr horizontal,  System.IntPtr vertical);
3293
3294         public static Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_set_api_delegate> efl_gfx_image_stretch_region_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_stretch_region_set_api_delegate>(Module, "efl_gfx_image_stretch_region_set");
3295
3296         private static Eina.Error stretch_region_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr horizontal, System.IntPtr vertical)
3297         {
3298             Eina.Log.Debug("function efl_gfx_image_stretch_region_set was called");
3299             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3300             if (ws != null)
3301             {
3302         var _in_horizontal = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(horizontal, false);
3303         var _in_vertical = new Eina.Iterator<Efl.Gfx.Image.StretchRegion>(vertical, false);
3304                                             Eina.Error _ret_var = default(Eina.Error);
3305                 try
3306                 {
3307                     _ret_var = ((ImageInternal)ws.Target).SetStretchRegion(_in_horizontal, _in_vertical);
3308                 }
3309                 catch (Exception e)
3310                 {
3311                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3312                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3313                 }
3314
3315                                         return _ret_var;
3316
3317             }
3318             else
3319             {
3320                 return efl_gfx_image_stretch_region_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), horizontal, vertical);
3321             }
3322         }
3323
3324         private static efl_gfx_image_stretch_region_set_delegate efl_gfx_image_stretch_region_set_static_delegate;
3325
3326
3327         private delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
3328
3329
3330         public delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_api_delegate(System.IntPtr obj);
3331
3332         public static Efl.Eo.FunctionWrapper<efl_gfx_image_size_get_api_delegate> efl_gfx_image_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_size_get_api_delegate>(Module, "efl_gfx_image_size_get");
3333
3334         private static Eina.Size2D.NativeStruct image_size_get(System.IntPtr obj, System.IntPtr pd)
3335         {
3336             Eina.Log.Debug("function efl_gfx_image_size_get was called");
3337             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3338             if (ws != null)
3339             {
3340             Eina.Size2D _ret_var = default(Eina.Size2D);
3341                 try
3342                 {
3343                     _ret_var = ((ImageInternal)ws.Target).GetImageSize();
3344                 }
3345                 catch (Exception e)
3346                 {
3347                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3348                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3349                 }
3350
3351         return _ret_var;
3352
3353             }
3354             else
3355             {
3356                 return efl_gfx_image_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3357             }
3358         }
3359
3360         private static efl_gfx_image_size_get_delegate efl_gfx_image_size_get_static_delegate;
3361
3362
3363         private delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
3364
3365
3366         public delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_api_delegate(System.IntPtr obj);
3367
3368         public static Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_get_api_delegate> efl_gfx_image_content_hint_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_get_api_delegate>(Module, "efl_gfx_image_content_hint_get");
3369
3370         private static Efl.Gfx.ImageContentHint content_hint_get(System.IntPtr obj, System.IntPtr pd)
3371         {
3372             Eina.Log.Debug("function efl_gfx_image_content_hint_get was called");
3373             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3374             if (ws != null)
3375             {
3376             Efl.Gfx.ImageContentHint _ret_var = default(Efl.Gfx.ImageContentHint);
3377                 try
3378                 {
3379                     _ret_var = ((ImageInternal)ws.Target).GetContentHint();
3380                 }
3381                 catch (Exception e)
3382                 {
3383                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3384                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3385                 }
3386
3387         return _ret_var;
3388
3389             }
3390             else
3391             {
3392                 return efl_gfx_image_content_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3393             }
3394         }
3395
3396         private static efl_gfx_image_content_hint_get_delegate efl_gfx_image_content_hint_get_static_delegate;
3397
3398
3399         private delegate void efl_gfx_image_content_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageContentHint hint);
3400
3401
3402         public delegate void efl_gfx_image_content_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageContentHint hint);
3403
3404         public static Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_set_api_delegate> efl_gfx_image_content_hint_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_content_hint_set_api_delegate>(Module, "efl_gfx_image_content_hint_set");
3405
3406         private static void content_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageContentHint hint)
3407         {
3408             Eina.Log.Debug("function efl_gfx_image_content_hint_set was called");
3409             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3410             if (ws != null)
3411             {
3412
3413                 try
3414                 {
3415                     ((ImageInternal)ws.Target).SetContentHint(hint);
3416                 }
3417                 catch (Exception e)
3418                 {
3419                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3420                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3421                 }
3422
3423
3424             }
3425             else
3426             {
3427                 efl_gfx_image_content_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
3428             }
3429         }
3430
3431         private static efl_gfx_image_content_hint_set_delegate efl_gfx_image_content_hint_set_static_delegate;
3432
3433
3434         private delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
3435
3436
3437         public delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_api_delegate(System.IntPtr obj);
3438
3439         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_get_api_delegate> efl_gfx_image_scale_hint_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_get_api_delegate>(Module, "efl_gfx_image_scale_hint_get");
3440
3441         private static Efl.Gfx.ImageScaleHint scale_hint_get(System.IntPtr obj, System.IntPtr pd)
3442         {
3443             Eina.Log.Debug("function efl_gfx_image_scale_hint_get was called");
3444             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3445             if (ws != null)
3446             {
3447             Efl.Gfx.ImageScaleHint _ret_var = default(Efl.Gfx.ImageScaleHint);
3448                 try
3449                 {
3450                     _ret_var = ((ImageInternal)ws.Target).GetScaleHint();
3451                 }
3452                 catch (Exception e)
3453                 {
3454                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3455                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3456                 }
3457
3458         return _ret_var;
3459
3460             }
3461             else
3462             {
3463                 return efl_gfx_image_scale_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3464             }
3465         }
3466
3467         private static efl_gfx_image_scale_hint_get_delegate efl_gfx_image_scale_hint_get_static_delegate;
3468
3469
3470         private delegate void efl_gfx_image_scale_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleHint hint);
3471
3472
3473         public delegate void efl_gfx_image_scale_hint_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageScaleHint hint);
3474
3475         public static Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_set_api_delegate> efl_gfx_image_scale_hint_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_scale_hint_set_api_delegate>(Module, "efl_gfx_image_scale_hint_set");
3476
3477         private static void scale_hint_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageScaleHint hint)
3478         {
3479             Eina.Log.Debug("function efl_gfx_image_scale_hint_set was called");
3480             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3481             if (ws != null)
3482             {
3483
3484                 try
3485                 {
3486                     ((ImageInternal)ws.Target).SetScaleHint(hint);
3487                 }
3488                 catch (Exception e)
3489                 {
3490                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3491                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3492                 }
3493
3494
3495             }
3496             else
3497             {
3498                 efl_gfx_image_scale_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), hint);
3499             }
3500         }
3501
3502         private static efl_gfx_image_scale_hint_set_delegate efl_gfx_image_scale_hint_set_static_delegate;
3503
3504
3505         private delegate Eina.Error efl_gfx_image_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
3506
3507
3508         public delegate Eina.Error efl_gfx_image_load_error_get_api_delegate(System.IntPtr obj);
3509
3510         public static Efl.Eo.FunctionWrapper<efl_gfx_image_load_error_get_api_delegate> efl_gfx_image_load_error_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_load_error_get_api_delegate>(Module, "efl_gfx_image_load_error_get");
3511
3512         private static Eina.Error image_load_error_get(System.IntPtr obj, System.IntPtr pd)
3513         {
3514             Eina.Log.Debug("function efl_gfx_image_load_error_get was called");
3515             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3516             if (ws != null)
3517             {
3518             Eina.Error _ret_var = default(Eina.Error);
3519                 try
3520                 {
3521                     _ret_var = ((ImageInternal)ws.Target).GetImageLoadError();
3522                 }
3523                 catch (Exception e)
3524                 {
3525                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3526                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3527                 }
3528
3529         return _ret_var;
3530
3531             }
3532             else
3533             {
3534                 return efl_gfx_image_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3535             }
3536         }
3537
3538         private static efl_gfx_image_load_error_get_delegate efl_gfx_image_load_error_get_static_delegate;
3539
3540
3541         private delegate Efl.Gfx.ImageOrientation efl_gfx_image_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
3542
3543
3544         public delegate Efl.Gfx.ImageOrientation efl_gfx_image_orientation_get_api_delegate(System.IntPtr obj);
3545
3546         public static Efl.Eo.FunctionWrapper<efl_gfx_image_orientation_get_api_delegate> efl_gfx_image_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_orientation_get_api_delegate>(Module, "efl_gfx_image_orientation_get");
3547
3548         private static Efl.Gfx.ImageOrientation image_orientation_get(System.IntPtr obj, System.IntPtr pd)
3549         {
3550             Eina.Log.Debug("function efl_gfx_image_orientation_get was called");
3551             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3552             if (ws != null)
3553             {
3554             Efl.Gfx.ImageOrientation _ret_var = default(Efl.Gfx.ImageOrientation);
3555                 try
3556                 {
3557                     _ret_var = ((ImageInternal)ws.Target).GetImageOrientation();
3558                 }
3559                 catch (Exception e)
3560                 {
3561                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3562                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3563                 }
3564
3565         return _ret_var;
3566
3567             }
3568             else
3569             {
3570                 return efl_gfx_image_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3571             }
3572         }
3573
3574         private static efl_gfx_image_orientation_get_delegate efl_gfx_image_orientation_get_static_delegate;
3575
3576
3577         private delegate void efl_gfx_image_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageOrientation dir);
3578
3579
3580         public delegate void efl_gfx_image_orientation_set_api_delegate(System.IntPtr obj,  Efl.Gfx.ImageOrientation dir);
3581
3582         public static Efl.Eo.FunctionWrapper<efl_gfx_image_orientation_set_api_delegate> efl_gfx_image_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_image_orientation_set_api_delegate>(Module, "efl_gfx_image_orientation_set");
3583
3584         private static void image_orientation_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.ImageOrientation dir)
3585         {
3586             Eina.Log.Debug("function efl_gfx_image_orientation_set was called");
3587             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3588             if (ws != null)
3589             {
3590
3591                 try
3592                 {
3593                     ((ImageInternal)ws.Target).SetImageOrientation(dir);
3594                 }
3595                 catch (Exception e)
3596                 {
3597                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3598                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3599                 }
3600
3601
3602             }
3603             else
3604             {
3605                 efl_gfx_image_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dir);
3606             }
3607         }
3608
3609         private static efl_gfx_image_orientation_set_delegate efl_gfx_image_orientation_set_static_delegate;
3610
3611
3612         private delegate Eina.Size2D.NativeStruct efl_gfx_view_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
3613
3614
3615         public delegate Eina.Size2D.NativeStruct efl_gfx_view_size_get_api_delegate(System.IntPtr obj);
3616
3617         public static Efl.Eo.FunctionWrapper<efl_gfx_view_size_get_api_delegate> efl_gfx_view_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_view_size_get_api_delegate>(Module, "efl_gfx_view_size_get");
3618
3619         private static Eina.Size2D.NativeStruct view_size_get(System.IntPtr obj, System.IntPtr pd)
3620         {
3621             Eina.Log.Debug("function efl_gfx_view_size_get was called");
3622             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3623             if (ws != null)
3624             {
3625             Eina.Size2D _ret_var = default(Eina.Size2D);
3626                 try
3627                 {
3628                     _ret_var = ((ImageInternal)ws.Target).GetViewSize();
3629                 }
3630                 catch (Exception e)
3631                 {
3632                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3633                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3634                 }
3635
3636         return _ret_var;
3637
3638             }
3639             else
3640             {
3641                 return efl_gfx_view_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
3642             }
3643         }
3644
3645         private static efl_gfx_view_size_get_delegate efl_gfx_view_size_get_static_delegate;
3646
3647
3648         private delegate void efl_gfx_view_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size);
3649
3650
3651         public delegate void efl_gfx_view_size_set_api_delegate(System.IntPtr obj,  Eina.Size2D.NativeStruct size);
3652
3653         public static Efl.Eo.FunctionWrapper<efl_gfx_view_size_set_api_delegate> efl_gfx_view_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_view_size_set_api_delegate>(Module, "efl_gfx_view_size_set");
3654
3655         private static void view_size_set(System.IntPtr obj, System.IntPtr pd, Eina.Size2D.NativeStruct size)
3656         {
3657             Eina.Log.Debug("function efl_gfx_view_size_set was called");
3658             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
3659             if (ws != null)
3660             {
3661         Eina.Size2D _in_size = size;
3662
3663                 try
3664                 {
3665                     ((ImageInternal)ws.Target).SetViewSize(_in_size);
3666                 }
3667                 catch (Exception e)
3668                 {
3669                     Eina.Log.Warning($"Callback error: {e.ToString()}");
3670                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
3671                 }
3672
3673
3674             }
3675             else
3676             {
3677                 efl_gfx_view_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
3678             }
3679         }
3680
3681         private static efl_gfx_view_size_set_delegate efl_gfx_view_size_set_static_delegate;
3682
3683         #pragma warning restore CA1707, CS1591, SA1300, SA1600
3684
3685 }
3686 }
3687 }
3688
3689 }
3690