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

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