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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.ComponentModel;
   7 namespace Efl { namespace Canvas {
   8 /// <summary>Efl canvas internal image class</summary>
   9 [ImageInternalNativeInherit]
  10 public abstract class ImageInternal : Efl.Canvas.Object, Efl.Eo.IWrapper,Efl.IFileSave,Efl.IOrientation,Efl.Canvas.Filter.IInternal,Efl.Gfx.IBuffer,Efl.Gfx.IFill,Efl.Gfx.IFilter,Efl.Gfx.IImage,Efl.Gfx.IView
  11 {
  12     ///<summary>Pointer to the native class description.</summary>
  13     public override System.IntPtr NativeClass {
  14         get {
  15             if (((object)this).GetType() == typeof (ImageInternal))
  16                 return Efl.Canvas.ImageInternalNativeInherit.GetEflClassStatic();
  17             else
  18                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  19         }
  20     }
  21     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  22         efl_canvas_image_internal_class_get();
  23     ///<summary>Creates a new instance.</summary>
  24     ///<param name="parent">Parent instance.</param>
  25     public ImageInternal(Efl.Object parent= null
  26             ) :
  27         base(efl_canvas_image_internal_class_get(), typeof(ImageInternal), parent)
  28     {
  29         FinishInstantiation();
  30     }
  31     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  32     protected ImageInternal(System.IntPtr raw) : base(raw)
  33     {
  34                 RegisterEventProxies();
  35     }
  36     [Efl.Eo.PrivateNativeClass]
  37     private class ImageInternalRealized : ImageInternal
  38     {
  39         private ImageInternalRealized(IntPtr ptr) : base(ptr)
  40         {
  41         }
  42     }
  43     ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  44     protected ImageInternal(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  45     ///<summary>Verifies if the given object is equal to this one.</summary>
  46     public override bool Equals(object obj)
  47     {
  48         var other = obj as Efl.Object;
  49         if (other == null)
  50             return false;
  51         return this.NativeHandle == other.NativeHandle;
  52     }
  53     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  54     public override int GetHashCode()
  55     {
  56         return this.NativeHandle.ToInt32();
  57     }
  58     ///<summary>Turns the native pointer into a string representation.</summary>
  59     public override String ToString()
  60     {
  61         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  62     }
  63 private static object ImagePreloadEvtKey = new object();
  64     /// <summary>Image data has been preloaded.</summary>
  65     public event EventHandler ImagePreloadEvt
  66     {
  67         add {
  68             lock (eventLock) {
  69                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  70                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_ImagePreloadEvt_delegate)) {
  71                     eventHandlers.AddHandler(ImagePreloadEvtKey , value);
  72                 } else
  73                     Eina.Log.Error($"Error adding proxy for event {key}");
  74             }
  75         }
  76         remove {
  77             lock (eventLock) {
  78                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_PRELOAD";
  79                 if (RemoveNativeEventHandler(key, this.evt_ImagePreloadEvt_delegate)) {
  80                     eventHandlers.RemoveHandler(ImagePreloadEvtKey , value);
  81                 } else
  82                     Eina.Log.Error($"Error removing proxy for event {key}");
  83             }
  84         }
  85     }
  86     ///<summary>Method to raise event ImagePreloadEvt.</summary>
  87     public void On_ImagePreloadEvt(EventArgs e)
  88     {
  89         EventHandler evt;
  90         lock (eventLock) {
  91         evt = (EventHandler)eventHandlers[ImagePreloadEvtKey];
  92         }
  93         evt?.Invoke(this, e);
  94     }
  95     Efl.EventCb evt_ImagePreloadEvt_delegate;
  96     private void on_ImagePreloadEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
  97     {
  98         EventArgs args = EventArgs.Empty;
  99         try {
 100             On_ImagePreloadEvt(args);
 101         } catch (Exception e) {
 102             Eina.Log.Error(e.ToString());
 103             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 104         }
 105     }
 106
 107 private static object ImageResizeEvtKey = new object();
 108     /// <summary>Image was resized (its pixel data).</summary>
 109     public event EventHandler ImageResizeEvt
 110     {
 111         add {
 112             lock (eventLock) {
 113                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 114                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_ImageResizeEvt_delegate)) {
 115                     eventHandlers.AddHandler(ImageResizeEvtKey , value);
 116                 } else
 117                     Eina.Log.Error($"Error adding proxy for event {key}");
 118             }
 119         }
 120         remove {
 121             lock (eventLock) {
 122                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_RESIZE";
 123                 if (RemoveNativeEventHandler(key, this.evt_ImageResizeEvt_delegate)) {
 124                     eventHandlers.RemoveHandler(ImageResizeEvtKey , value);
 125                 } else
 126                     Eina.Log.Error($"Error removing proxy for event {key}");
 127             }
 128         }
 129     }
 130     ///<summary>Method to raise event ImageResizeEvt.</summary>
 131     public void On_ImageResizeEvt(EventArgs e)
 132     {
 133         EventHandler evt;
 134         lock (eventLock) {
 135         evt = (EventHandler)eventHandlers[ImageResizeEvtKey];
 136         }
 137         evt?.Invoke(this, e);
 138     }
 139     Efl.EventCb evt_ImageResizeEvt_delegate;
 140     private void on_ImageResizeEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 141     {
 142         EventArgs args = EventArgs.Empty;
 143         try {
 144             On_ImageResizeEvt(args);
 145         } catch (Exception e) {
 146             Eina.Log.Error(e.ToString());
 147             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 148         }
 149     }
 150
 151 private static object ImageUnloadEvtKey = new object();
 152     /// <summary>Image data has been unloaded (by some mechanism in EFL that threw out the original image data).</summary>
 153     public event EventHandler ImageUnloadEvt
 154     {
 155         add {
 156             lock (eventLock) {
 157                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 158                 if (AddNativeEventHandler(efl.Libs.Efl, key, this.evt_ImageUnloadEvt_delegate)) {
 159                     eventHandlers.AddHandler(ImageUnloadEvtKey , value);
 160                 } else
 161                     Eina.Log.Error($"Error adding proxy for event {key}");
 162             }
 163         }
 164         remove {
 165             lock (eventLock) {
 166                 string key = "_EFL_GFX_IMAGE_EVENT_IMAGE_UNLOAD";
 167                 if (RemoveNativeEventHandler(key, this.evt_ImageUnloadEvt_delegate)) {
 168                     eventHandlers.RemoveHandler(ImageUnloadEvtKey , value);
 169                 } else
 170                     Eina.Log.Error($"Error removing proxy for event {key}");
 171             }
 172         }
 173     }
 174     ///<summary>Method to raise event ImageUnloadEvt.</summary>
 175     public void On_ImageUnloadEvt(EventArgs e)
 176     {
 177         EventHandler evt;
 178         lock (eventLock) {
 179         evt = (EventHandler)eventHandlers[ImageUnloadEvtKey];
 180         }
 181         evt?.Invoke(this, e);
 182     }
 183     Efl.EventCb evt_ImageUnloadEvt_delegate;
 184     private void on_ImageUnloadEvt_NativeCallback(System.IntPtr data, ref Efl.Event.NativeStruct evt)
 185     {
 186         EventArgs args = EventArgs.Empty;
 187         try {
 188             On_ImageUnloadEvt(args);
 189         } catch (Exception e) {
 190             Eina.Log.Error(e.ToString());
 191             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 192         }
 193     }
 194
 195     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 196     protected override void RegisterEventProxies()
 197     {
 198         base.RegisterEventProxies();
 199         evt_ImagePreloadEvt_delegate = new Efl.EventCb(on_ImagePreloadEvt_NativeCallback);
 200         evt_ImageResizeEvt_delegate = new Efl.EventCb(on_ImageResizeEvt_NativeCallback);
 201         evt_ImageUnloadEvt_delegate = new Efl.EventCb(on_ImageUnloadEvt_NativeCallback);
 202     }
 203     /// <summary>Save the given image object&apos;s contents to an (image) file.
 204     /// 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.
 205     ///
 206     /// 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;.
 207     /// (Since EFL 1.22)</summary>
 208     /// <param name="file">The filename to be used to save the image (extension obligatory).</param>
 209     /// <param name="key">The image key in the file (if an Eet one), or <c>null</c>, otherwise.</param>
 210     /// <param name="info">The flags to be used (<c>null</c> for defaults).</param>
 211     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 212     virtual public bool Save( System.String file,  System.String key,  ref Efl.FileSaveInfo info) {
 213                          Efl.FileSaveInfo.NativeStruct _in_info = info;
 214                                                         var _ret_var = Efl.IFileSaveNativeInherit.efl_file_save_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), file,  key,  ref _in_info);
 215         Eina.Error.RaiseIfUnhandledException();
 216                                                 info = _in_info;
 217         return _ret_var;
 218  }
 219     /// <summary>Control the orientation of a given object.
 220     /// This can be used to set the rotation on an image or a window, for instance.</summary>
 221     /// <returns>The rotation angle (CCW), see <see cref="Efl.Orient"/>.</returns>
 222     virtual public Efl.Orient GetOrientation() {
 223          var _ret_var = Efl.IOrientationNativeInherit.efl_orientation_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 224         Eina.Error.RaiseIfUnhandledException();
 225         return _ret_var;
 226  }
 227     /// <summary>Control the orientation of a given object.
 228     /// This can be used to set the rotation on an image or a window, for instance.</summary>
 229     /// <param name="dir">The rotation angle (CCW), see <see cref="Efl.Orient"/>.</param>
 230     /// <returns></returns>
 231     virtual public void SetOrientation( Efl.Orient dir) {
 232                                  Efl.IOrientationNativeInherit.efl_orientation_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), dir);
 233         Eina.Error.RaiseIfUnhandledException();
 234                          }
 235     /// <summary>Control the flip of the given image
 236     /// Use this function to change how your image is to be flipped: vertically or horizontally or transpose or traverse.</summary>
 237     /// <returns>Flip method</returns>
 238     virtual public Efl.Flip GetFlip() {
 239          var _ret_var = Efl.IOrientationNativeInherit.efl_orientation_flip_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 240         Eina.Error.RaiseIfUnhandledException();
 241         return _ret_var;
 242  }
 243     /// <summary>Control the flip of the given image
 244     /// Use this function to change how your image is to be flipped: vertically or horizontally or transpose or traverse.</summary>
 245     /// <param name="flip">Flip method</param>
 246     /// <returns></returns>
 247     virtual public void SetFlip( Efl.Flip flip) {
 248                                  Efl.IOrientationNativeInherit.efl_orientation_flip_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), flip);
 249         Eina.Error.RaiseIfUnhandledException();
 250                          }
 251     /// <summary>Marks this filter as changed.</summary>
 252     /// <param name="val"><c>true</c> if filter changed, <c>false</c> otherwise</param>
 253     /// <returns></returns>
 254     virtual public void SetFilterChanged( bool val) {
 255                                  Efl.Canvas.Filter.IInternalNativeInherit.evas_filter_changed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), val);
 256         Eina.Error.RaiseIfUnhandledException();
 257                          }
 258     /// <summary>Marks this filter as invalid.</summary>
 259     /// <param name="val"><c>true</c> if filter is invalid, <c>false</c> otherwise</param>
 260     /// <returns></returns>
 261     virtual public void SetFilterInvalid( bool val) {
 262                                  Efl.Canvas.Filter.IInternalNativeInherit.evas_filter_invalid_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), val);
 263         Eina.Error.RaiseIfUnhandledException();
 264                          }
 265     /// <summary>Retrieve cached output buffer, if any.
 266     /// Does not increment the reference count.</summary>
 267     /// <returns>Output buffer</returns>
 268     virtual public System.IntPtr GetFilterOutputBuffer() {
 269          var _ret_var = Efl.Canvas.Filter.IInternalNativeInherit.evas_filter_output_buffer_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 270         Eina.Error.RaiseIfUnhandledException();
 271         return _ret_var;
 272  }
 273     /// <summary>Called by Efl.Canvas.Filter.Internal to determine whether the input is alpha or rgba.</summary>
 274     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 275     virtual public bool FilterInputAlpha() {
 276          var _ret_var = Efl.Canvas.Filter.IInternalNativeInherit.evas_filter_input_alpha_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 277         Eina.Error.RaiseIfUnhandledException();
 278         return _ret_var;
 279  }
 280     /// <summary>Called by Efl.Canvas.Filter.Internal to request the parent class for state information (color, etc...).</summary>
 281     /// <param name="state">State info to fill in</param>
 282     /// <param name="data">Private data for the class</param>
 283     /// <returns></returns>
 284     virtual public void FilterStatePrepare( out Efl.Canvas.Filter.State state,  System.IntPtr data) {
 285                          var _out_state = new Efl.Canvas.Filter.State.NativeStruct();
 286                                 Efl.Canvas.Filter.IInternalNativeInherit.evas_filter_state_prepare_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out _out_state,  data);
 287         Eina.Error.RaiseIfUnhandledException();
 288         state = _out_state;
 289                                  }
 290     /// <summary>Called by Efl.Canvas.Filter.Internal when the parent class must render the input.</summary>
 291     /// <param name="filter">Current filter context</param>
 292     /// <param name="engine">Engine context</param>
 293     /// <param name="output">Output context</param>
 294     /// <param name="drawctx">Draw context (for evas engine)</param>
 295     /// <param name="data">Private data used by textblock</param>
 296     /// <param name="l">Left</param>
 297     /// <param name="r">Right</param>
 298     /// <param name="t">Top</param>
 299     /// <param name="b">Bottom</param>
 300     /// <param name="x">X offset</param>
 301     /// <param name="y">Y offset</param>
 302     /// <param name="do_async"><c>true</c> when the operation should be done asynchronously, <c>false</c> otherwise</param>
 303     /// <returns>Indicates success from the object render function.</returns>
 304     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) {
 305                                                                                                                                                                                                                                                                                                          var _ret_var = Efl.Canvas.Filter.IInternalNativeInherit.evas_filter_input_render_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), filter,  engine,  output,  drawctx,  data,  l,  r,  t,  b,  x,  y,  do_async);
 306         Eina.Error.RaiseIfUnhandledException();
 307                                                                                                                                                                                                         return _ret_var;
 308  }
 309     /// <summary>Called when filter changes must trigger a redraw of the object.
 310     /// Virtual, to be implemented in the parent class.</summary>
 311     /// <returns></returns>
 312     virtual public void FilterDirty() {
 313          Efl.Canvas.Filter.IInternalNativeInherit.evas_filter_dirty_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 314         Eina.Error.RaiseIfUnhandledException();
 315          }
 316     /// <summary>Rectangular size of the pixel buffer as allocated in memory.</summary>
 317     /// <returns>Size of the buffer in pixels.</returns>
 318     virtual public Eina.Size2D GetBufferSize() {
 319          var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 320         Eina.Error.RaiseIfUnhandledException();
 321         return _ret_var;
 322  }
 323     /// <summary>Potentially not implemented, <see cref="Efl.Gfx.IBuffer.BufferSize"/> may be read-only.</summary>
 324     /// <param name="sz">Size of the buffer in pixels.</param>
 325     /// <returns></returns>
 326     virtual public void SetBufferSize( Eina.Size2D sz) {
 327          Eina.Size2D.NativeStruct _in_sz = sz;
 328                         Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_sz);
 329         Eina.Error.RaiseIfUnhandledException();
 330                          }
 331     /// <summary>Returns the current encoding of this buffer&apos;s pixels.
 332     /// See <see cref="Efl.Gfx.Colorspace"/> for more information on the supported formats.</summary>
 333     /// <returns>Colorspace</returns>
 334     virtual public Efl.Gfx.Colorspace GetColorspace() {
 335          var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_colorspace_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 336         Eina.Error.RaiseIfUnhandledException();
 337         return _ret_var;
 338  }
 339     /// <summary>Retrieve whether alpha channel data is used on this object.</summary>
 340     /// <returns>Whether to use alpha channel (<c>true</c>) data or not (<c>false</c>).</returns>
 341     virtual public bool GetAlpha() {
 342          var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_alpha_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 343         Eina.Error.RaiseIfUnhandledException();
 344         return _ret_var;
 345  }
 346     /// <summary>Change alpha channel usage for this object.
 347     /// 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>
 348     /// <param name="alpha">Whether to use alpha channel (<c>true</c>) data or not (<c>false</c>).</param>
 349     /// <returns></returns>
 350     virtual public void SetAlpha( bool alpha) {
 351                                  Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_alpha_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), alpha);
 352         Eina.Error.RaiseIfUnhandledException();
 353                          }
 354     /// <summary>Length in bytes of one row of pixels in memory.
 355     /// Usually this will be equal to width * 4, with a plain BGRA image. This may return 0 if the stride is not applicable.
 356     ///
 357     /// When applicable, this will include the <see cref="Efl.Gfx.IBuffer.GetBufferBorders"/> as well as potential extra padding.</summary>
 358     /// <returns>Stride</returns>
 359     virtual public int GetStride() {
 360          var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_stride_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 361         Eina.Error.RaiseIfUnhandledException();
 362         return _ret_var;
 363  }
 364     /// <summary>Duplicated pixel borders inside this buffer.
 365     /// 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>
 366     /// <param name="l">Left border pixels, usually 0 or 1</param>
 367     /// <param name="r">Right border pixels, usually 0 or 1</param>
 368     /// <param name="t">Top border pixels, usually 0 or 1</param>
 369     /// <param name="b">Bottom border pixels, usually 0 or 1</param>
 370     /// <returns></returns>
 371     virtual public void GetBufferBorders( out uint l,  out uint r,  out uint t,  out uint b) {
 372                                                                                                          Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_borders_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out l,  out r,  out t,  out b);
 373         Eina.Error.RaiseIfUnhandledException();
 374                                                                          }
 375     /// <summary>Mark a sub-region of the given image object to be redrawn.
 376     /// This function schedules a particular rectangular region of an image object to be updated (redrawn) at the next rendering cycle.</summary>
 377     /// <param name="region">The updated region.</param>
 378     /// <returns></returns>
 379     virtual public void AddBufferUpdate( ref Eina.Rect region) {
 380          Eina.Rect.NativeStruct _in_region = region;
 381                         Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_update_add_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), ref _in_region);
 382         Eina.Error.RaiseIfUnhandledException();
 383                 region = _in_region;
 384          }
 385     /// <summary>Map a region of this buffer for read or write access by the CPU.
 386     /// 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.
 387     ///
 388     /// Note that if the buffer has <see cref="Efl.Gfx.IBuffer.GetBufferBorders"/>, then <c>x</c> and <c>y</c> may be negative.</summary>
 389     /// <param name="mode">Specifies whether to map for read-only, write-only or read-write access (OR combination of flags).</param>
 390     /// <param name="region">The region to map.</param>
 391     /// <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>
 392     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 393     /// <param name="stride">Returns the length in bytes of a mapped line</param>
 394     /// <returns>The data slice. In case of failure, the memory pointer will be <c>null</c>.</returns>
 395     virtual public Eina.RwSlice BufferMap( Efl.Gfx.BufferAccessMode mode,  ref Eina.Rect region,  Efl.Gfx.Colorspace cspace,  int plane,  out int stride) {
 396                  Eina.Rect.NativeStruct _in_region = region;
 397                                                                                                                 var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_map_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), mode,  ref _in_region,  cspace,  plane,  out stride);
 398         Eina.Error.RaiseIfUnhandledException();
 399                                                         region = _in_region;
 400                                 return _ret_var;
 401  }
 402     /// <summary>Unmap a region of this buffer, and update the internal data if needed.
 403     /// EFL will update the internal image if the map had write access.
 404     ///
 405     /// 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>
 406     /// <param name="slice">Data slice returned by a previous call to map.</param>
 407     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 408     virtual public bool BufferUnmap( Eina.RwSlice slice) {
 409                                  var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_unmap_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), slice);
 410         Eina.Error.RaiseIfUnhandledException();
 411                         return _ret_var;
 412  }
 413     /// <summary>Set the pixels for this buffer by copying them, or allocate a new memory region.
 414     /// 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.
 415     ///
 416     /// 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"/>.
 417     ///
 418     /// 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>.
 419     ///
 420     /// <c>slice</c> should not be the return value of <see cref="Efl.Gfx.IBuffer.GetBufferManaged"/>.</summary>
 421     /// <param name="slice">If <c>null</c>, allocates an empty buffer</param>
 422     /// <param name="size">The size in pixels.</param>
 423     /// <param name="stride">If 0, automatically guessed from the <c>width</c>.</param>
 424     /// <param name="cspace">argb8888 by default.</param>
 425     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 426     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 427     virtual public bool SetBufferCopy( Eina.Slice slice,  Eina.Size2D size,  int stride,  Efl.Gfx.Colorspace cspace,  int plane) {
 428          var _in_slice = Eina.PrimitiveConversion.ManagedToPointerAlloc(slice);
 429         Eina.Size2D.NativeStruct _in_size = size;
 430                                                                                                                 var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_copy_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_slice,  _in_size,  stride,  cspace,  plane);
 431         Eina.Error.RaiseIfUnhandledException();
 432                                                                                         return _ret_var;
 433  }
 434     /// <summary>Set the pixels for this buffer, managed externally by the client.
 435     /// 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.
 436     ///
 437     /// 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"/>.
 438     ///
 439     /// 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>.
 440     ///
 441     /// See also <see cref="Efl.Gfx.IBuffer.SetBufferCopy"/> if you want EFL to copy the input buffer internally.</summary>
 442     /// <param name="slice">If <c>null</c>, detaches the previous buffer.</param>
 443     /// <param name="size">The size in pixels.</param>
 444     /// <param name="stride">If 0, automatically guessed from the <c>width</c>.</param>
 445     /// <param name="cspace">argb8888 by default.</param>
 446     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 447     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 448     virtual public bool SetBufferManaged( Eina.Slice slice,  Eina.Size2D size,  int stride,  Efl.Gfx.Colorspace cspace,  int plane) {
 449          var _in_slice = Eina.PrimitiveConversion.ManagedToPointerAlloc(slice);
 450         Eina.Size2D.NativeStruct _in_size = size;
 451                                                                                                                 var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_managed_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_slice,  _in_size,  stride,  cspace,  plane);
 452         Eina.Error.RaiseIfUnhandledException();
 453                                                                                         return _ret_var;
 454  }
 455     /// <summary>Get a direct pointer to the internal pixel data, if available.
 456     /// This will return <c>null</c> unless <see cref="Efl.Gfx.IBuffer.SetBufferManaged"/> was used to pass in an external data pointer.</summary>
 457     /// <param name="plane">Plane ID. 0 by default. Useful for planar formats only.</param>
 458     /// <returns>The data slice. The memory pointer will be <c>null</c> in case of failure.</returns>
 459     virtual public Eina.Slice GetBufferManaged( int plane) {
 460                                  var _ret_var = Efl.Gfx.IBufferNativeInherit.efl_gfx_buffer_managed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), plane);
 461         Eina.Error.RaiseIfUnhandledException();
 462                         return _ret_var;
 463  }
 464     /// <summary>Binds the object&apos;s <see cref="Efl.Gfx.IFill.Fill"/> property to its actual geometry.
 465     /// 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.
 466     ///
 467     /// 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.
 468     ///
 469     /// 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>
 470     /// <returns><c>true</c> to make the fill property follow object size or <c>false</c> otherwise.</returns>
 471     virtual public bool GetFillAuto() {
 472          var _ret_var = Efl.Gfx.IFillNativeInherit.efl_gfx_fill_auto_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 473         Eina.Error.RaiseIfUnhandledException();
 474         return _ret_var;
 475  }
 476     /// <summary>Binds the object&apos;s <see cref="Efl.Gfx.IFill.Fill"/> property to its actual geometry.
 477     /// 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.
 478     ///
 479     /// 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.
 480     ///
 481     /// 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>
 482     /// <param name="filled"><c>true</c> to make the fill property follow object size or <c>false</c> otherwise.</param>
 483     /// <returns></returns>
 484     virtual public void SetFillAuto( bool filled) {
 485                                  Efl.Gfx.IFillNativeInherit.efl_gfx_fill_auto_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), filled);
 486         Eina.Error.RaiseIfUnhandledException();
 487                          }
 488     /// <summary>Specifies how to tile an image to fill its rectangle geometry.
 489     /// 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.
 490     ///
 491     /// Setting this property will reset the <see cref="Efl.Gfx.IFill.FillAuto"/> to <c>false</c>.</summary>
 492     /// <returns>The top-left corner to start drawing from as well as the size at which the bound image will be displayed.</returns>
 493     virtual public Eina.Rect GetFill() {
 494          var _ret_var = Efl.Gfx.IFillNativeInherit.efl_gfx_fill_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 495         Eina.Error.RaiseIfUnhandledException();
 496         return _ret_var;
 497  }
 498     /// <summary>Specifies how to tile an image to fill its rectangle geometry.
 499     /// 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.
 500     ///
 501     /// Setting this property will reset the <see cref="Efl.Gfx.IFill.FillAuto"/> to <c>false</c>.</summary>
 502     /// <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>
 503     /// <returns></returns>
 504     virtual public void SetFill( Eina.Rect fill) {
 505          Eina.Rect.NativeStruct _in_fill = fill;
 506                         Efl.Gfx.IFillNativeInherit.efl_gfx_fill_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_fill);
 507         Eina.Error.RaiseIfUnhandledException();
 508                          }
 509     /// <summary>Gets the code of the filter program set on this object. May be <c>null</c>.</summary>
 510     /// <param name="code">The Lua program source code.</param>
 511     /// <param name="name">An optional name for this filter.</param>
 512     /// <returns></returns>
 513     virtual public void GetFilterProgram( out System.String code,  out System.String name) {
 514                                                          Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_program_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out code,  out name);
 515         Eina.Error.RaiseIfUnhandledException();
 516                                          }
 517     /// <summary>Set a graphical filter program on this object.
 518     /// Valid for Text and Image objects at the moment.
 519     ///
 520     /// 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.
 521     ///
 522     /// Set to <c>null</c> to disable filtering.</summary>
 523     /// <param name="code">The Lua program source code.</param>
 524     /// <param name="name">An optional name for this filter.</param>
 525     /// <returns></returns>
 526     virtual public void SetFilterProgram( System.String code,  System.String name) {
 527                                                          Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_program_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), code,  name);
 528         Eina.Error.RaiseIfUnhandledException();
 529                                          }
 530     /// <summary>Set the current state of the filter.
 531     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 532     ///
 533     /// 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>
 534     /// <param name="cur_state">Current state of the filter</param>
 535     /// <param name="cur_val">Current value</param>
 536     /// <param name="next_state">Next filter state, optional</param>
 537     /// <param name="next_val">Next value, optional</param>
 538     /// <param name="pos">Position, optional</param>
 539     /// <returns></returns>
 540     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) {
 541                                                                                                                                  Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_state_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out cur_state,  out cur_val,  out next_state,  out next_val,  out pos);
 542         Eina.Error.RaiseIfUnhandledException();
 543                                                                                          }
 544     /// <summary>Set the current state of the filter.
 545     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 546     ///
 547     /// 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>
 548     /// <param name="cur_state">Current state of the filter</param>
 549     /// <param name="cur_val">Current value</param>
 550     /// <param name="next_state">Next filter state, optional</param>
 551     /// <param name="next_val">Next value, optional</param>
 552     /// <param name="pos">Position, optional</param>
 553     /// <returns></returns>
 554     virtual public void SetFilterState( System.String cur_state,  double cur_val,  System.String next_state,  double next_val,  double pos) {
 555                                                                                                                                  Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_state_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), cur_state,  cur_val,  next_state,  next_val,  pos);
 556         Eina.Error.RaiseIfUnhandledException();
 557                                                                                          }
 558     /// <summary>Gets the padding required to apply this filter.</summary>
 559     /// <param name="l">Padding on the left</param>
 560     /// <param name="r">Padding on the right</param>
 561     /// <param name="t">Padding on the top</param>
 562     /// <param name="b">Padding on the bottom</param>
 563     /// <returns></returns>
 564     virtual public void GetFilterPadding( out int l,  out int r,  out int t,  out int b) {
 565                                                                                                          Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_padding_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out l,  out r,  out t,  out b);
 566         Eina.Error.RaiseIfUnhandledException();
 567                                                                          }
 568     /// <summary>Bind an object to use as a mask or texture in a filter program.
 569     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 570     /// <param name="name">Buffer name as used in the program.</param>
 571     /// <returns>Object to use as a source of pixels.</returns>
 572     virtual public Efl.Gfx.IEntity GetFilterSource( System.String name) {
 573                                  var _ret_var = Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_source_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name);
 574         Eina.Error.RaiseIfUnhandledException();
 575                         return _ret_var;
 576  }
 577     /// <summary>Bind an object to use as a mask or texture in a filter program.
 578     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 579     /// <param name="name">Buffer name as used in the program.</param>
 580     /// <param name="source">Object to use as a source of pixels.</param>
 581     /// <returns></returns>
 582     virtual public void SetFilterSource( System.String name,  Efl.Gfx.IEntity source) {
 583                                                          Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_source_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name,  source);
 584         Eina.Error.RaiseIfUnhandledException();
 585                                          }
 586     /// <summary>Extra data used by the filter program.
 587     /// 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...
 588     ///
 589     /// 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>
 590     /// <param name="name">Name of the global variable</param>
 591     /// <param name="value">String value to use as data</param>
 592     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 593     /// <returns></returns>
 594     virtual public void GetFilterData( System.String name,  out System.String value,  out bool execute) {
 595                                                                                  Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_data_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name,  out value,  out execute);
 596         Eina.Error.RaiseIfUnhandledException();
 597                                                          }
 598     /// <summary>Extra data used by the filter program.
 599     /// 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...
 600     ///
 601     /// 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>
 602     /// <param name="name">Name of the global variable</param>
 603     /// <param name="value">String value to use as data</param>
 604     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 605     /// <returns></returns>
 606     virtual public void SetFilterData( System.String name,  System.String value,  bool execute) {
 607                                                                                  Efl.Gfx.IFilterNativeInherit.efl_gfx_filter_data_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), name,  value,  execute);
 608         Eina.Error.RaiseIfUnhandledException();
 609                                                          }
 610     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 611     /// 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.
 612     ///
 613     /// <c>true</c> by default</summary>
 614     /// <returns>Whether to use smooth scale or not.</returns>
 615     virtual public bool GetSmoothScale() {
 616          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_smooth_scale_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 617         Eina.Error.RaiseIfUnhandledException();
 618         return _ret_var;
 619  }
 620     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 621     /// 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.
 622     ///
 623     /// <c>true</c> by default</summary>
 624     /// <param name="smooth_scale">Whether to use smooth scale or not.</param>
 625     /// <returns></returns>
 626     virtual public void SetSmoothScale( bool smooth_scale) {
 627                                  Efl.Gfx.IImageNativeInherit.efl_gfx_image_smooth_scale_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), smooth_scale);
 628         Eina.Error.RaiseIfUnhandledException();
 629                          }
 630     /// <summary>Control how the image is scaled.</summary>
 631     /// <returns>Image scale type</returns>
 632     virtual public Efl.Gfx.ImageScaleType GetScaleType() {
 633          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_scale_type_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 634         Eina.Error.RaiseIfUnhandledException();
 635         return _ret_var;
 636  }
 637     /// <summary>Control how the image is scaled.</summary>
 638     /// <param name="scale_type">Image scale type</param>
 639     /// <returns></returns>
 640     virtual public void SetScaleType( Efl.Gfx.ImageScaleType scale_type) {
 641                                  Efl.Gfx.IImageNativeInherit.efl_gfx_image_scale_type_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), scale_type);
 642         Eina.Error.RaiseIfUnhandledException();
 643                          }
 644     /// <summary>Returns 1.0 if not applicable (eg. height = 0).</summary>
 645     /// <returns>The image&apos;s ratio.</returns>
 646     virtual public double GetRatio() {
 647          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_ratio_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 648         Eina.Error.RaiseIfUnhandledException();
 649         return _ret_var;
 650  }
 651     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 652     /// When EFL renders an image, its source may be scaled to fit the size of the object. This function sets an area from the borders of the image inwards which is not to be scaled. This function is useful for making frames and for widget theming, where, for example, buttons may be of varying sizes, but their border size must remain constant.
 653     ///
 654     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 655     ///
 656     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 657     ///
 658     /// Note: By default, image objects have no borders set, i.e. <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> start as 0.
 659     ///
 660     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 661     /// <param name="l">The border&apos;s left width.</param>
 662     /// <param name="r">The border&apos;s right width.</param>
 663     /// <param name="t">The border&apos;s top height.</param>
 664     /// <param name="b">The border&apos;s bottom height.</param>
 665     /// <returns></returns>
 666     virtual public void GetBorder( out int l,  out int r,  out int t,  out int b) {
 667                                                                                                          Efl.Gfx.IImageNativeInherit.efl_gfx_image_border_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), out l,  out r,  out t,  out b);
 668         Eina.Error.RaiseIfUnhandledException();
 669                                                                          }
 670     /// <summary>Dimensions of this image&apos;s border, a region that does not scale with the center area.
 671     /// 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.
 672     ///
 673     /// The units used for <c>l</c>, <c>r</c>, <c>t</c> and <c>b</c> are canvas units (pixels).
 674     ///
 675     /// Note: The border region itself may be scaled by the <see cref="Efl.Gfx.IImage.SetBorderScale"/> function.
 676     ///
 677     /// 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.
 678     ///
 679     /// Note: Similar to the concepts of 9-patch images or cap insets.</summary>
 680     /// <param name="l">The border&apos;s left width.</param>
 681     /// <param name="r">The border&apos;s right width.</param>
 682     /// <param name="t">The border&apos;s top height.</param>
 683     /// <param name="b">The border&apos;s bottom height.</param>
 684     /// <returns></returns>
 685     virtual public void SetBorder( int l,  int r,  int t,  int b) {
 686                                                                                                          Efl.Gfx.IImageNativeInherit.efl_gfx_image_border_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), l,  r,  t,  b);
 687         Eina.Error.RaiseIfUnhandledException();
 688                                                                          }
 689     /// <summary>Scaling factor applied to the image borders.
 690     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 691     ///
 692     /// Default value is 1.0 (no scaling).</summary>
 693     /// <returns>The scale factor.</returns>
 694     virtual public double GetBorderScale() {
 695          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_border_scale_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 696         Eina.Error.RaiseIfUnhandledException();
 697         return _ret_var;
 698  }
 699     /// <summary>Scaling factor applied to the image borders.
 700     /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 701     ///
 702     /// Default value is 1.0 (no scaling).</summary>
 703     /// <param name="scale">The scale factor.</param>
 704     /// <returns></returns>
 705     virtual public void SetBorderScale( double scale) {
 706                                  Efl.Gfx.IImageNativeInherit.efl_gfx_image_border_scale_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), scale);
 707         Eina.Error.RaiseIfUnhandledException();
 708                          }
 709     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 710     /// 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.
 711     ///
 712     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 713     /// <returns>Fill mode of the center region.</returns>
 714     virtual public Efl.Gfx.BorderFillMode GetBorderCenterFill() {
 715          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_border_center_fill_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 716         Eina.Error.RaiseIfUnhandledException();
 717         return _ret_var;
 718  }
 719     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 720     /// 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.
 721     ///
 722     /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 723     /// <param name="fill">Fill mode of the center region.</param>
 724     /// <returns></returns>
 725     virtual public void SetBorderCenterFill( Efl.Gfx.BorderFillMode fill) {
 726                                  Efl.Gfx.IImageNativeInherit.efl_gfx_image_border_center_fill_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), fill);
 727         Eina.Error.RaiseIfUnhandledException();
 728                          }
 729     /// <summary>This represents the size of the original image in pixels.
 730     /// 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.
 731     ///
 732     /// This is a read-only property, and may return 0x0.</summary>
 733     /// <returns>The size in pixels.</returns>
 734     virtual public Eina.Size2D GetImageSize() {
 735          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 736         Eina.Error.RaiseIfUnhandledException();
 737         return _ret_var;
 738  }
 739     /// <summary>Get the content hint setting of a given image object of the canvas.
 740     /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 741     /// <returns>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></returns>
 742     virtual public Efl.Gfx.ImageContentHint GetContentHint() {
 743          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_content_hint_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 744         Eina.Error.RaiseIfUnhandledException();
 745         return _ret_var;
 746  }
 747     /// <summary>Set the content hint setting of a given image object of the canvas.
 748     /// 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>
 749     /// <param name="hint">Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></param>
 750     /// <returns></returns>
 751     virtual public void SetContentHint( Efl.Gfx.ImageContentHint hint) {
 752                                  Efl.Gfx.IImageNativeInherit.efl_gfx_image_content_hint_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), hint);
 753         Eina.Error.RaiseIfUnhandledException();
 754                          }
 755     /// <summary>Get the scale hint of a given image of the canvas.
 756     /// This function returns the scale hint value of the given image object of the canvas.</summary>
 757     /// <returns>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></returns>
 758     virtual public Efl.Gfx.ImageScaleHint GetScaleHint() {
 759          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_scale_hint_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 760         Eina.Error.RaiseIfUnhandledException();
 761         return _ret_var;
 762  }
 763     /// <summary>Set the scale hint of a given image of the canvas.
 764     /// 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>
 765     /// <param name="hint">Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></param>
 766     /// <returns></returns>
 767     virtual public void SetScaleHint( Efl.Gfx.ImageScaleHint hint) {
 768                                  Efl.Gfx.IImageNativeInherit.efl_gfx_image_scale_hint_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), hint);
 769         Eina.Error.RaiseIfUnhandledException();
 770                          }
 771     /// <summary>Gets the (last) file loading error for a given object.</summary>
 772     /// <returns>The load error code.</returns>
 773     virtual public Eina.Error GetImageLoadError() {
 774          var _ret_var = Efl.Gfx.IImageNativeInherit.efl_gfx_image_load_error_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 775         Eina.Error.RaiseIfUnhandledException();
 776         return _ret_var;
 777  }
 778     /// <summary>The dimensions of this object&apos;s viewport.
 779     /// 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.
 780     ///
 781     /// 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.
 782     ///
 783     /// In most cases the view should have the same dimensions as the object on the canvas, for best quality.
 784     ///
 785     /// <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.
 786     ///
 787     /// Refer to each implementing class specific documentation for more details.</summary>
 788     /// <returns>Size of the view.</returns>
 789     virtual public Eina.Size2D GetViewSize() {
 790          var _ret_var = Efl.Gfx.IViewNativeInherit.efl_gfx_view_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 791         Eina.Error.RaiseIfUnhandledException();
 792         return _ret_var;
 793  }
 794     /// <summary>The dimensions of this object&apos;s viewport.
 795     /// 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.
 796     ///
 797     /// 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.
 798     ///
 799     /// In most cases the view should have the same dimensions as the object on the canvas, for best quality.
 800     ///
 801     /// <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.
 802     ///
 803     /// Refer to each implementing class specific documentation for more details.</summary>
 804     /// <param name="size">Size of the view.</param>
 805     /// <returns></returns>
 806     virtual public void SetViewSize( Eina.Size2D size) {
 807          Eina.Size2D.NativeStruct _in_size = size;
 808                         Efl.Gfx.IViewNativeInherit.efl_gfx_view_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_size);
 809         Eina.Error.RaiseIfUnhandledException();
 810                          }
 811     /// <summary>Control the orientation of a given object.
 812 /// This can be used to set the rotation on an image or a window, for instance.</summary>
 813 /// <value>The rotation angle (CCW), see <see cref="Efl.Orient"/>.</value>
 814     public Efl.Orient Orientation {
 815         get { return GetOrientation(); }
 816         set { SetOrientation( value); }
 817     }
 818     /// <summary>Control the flip of the given image
 819 /// Use this function to change how your image is to be flipped: vertically or horizontally or transpose or traverse.</summary>
 820 /// <value>Flip method</value>
 821     public Efl.Flip Flip {
 822         get { return GetFlip(); }
 823         set { SetFlip( value); }
 824     }
 825     /// <summary>Marks this filter as changed.</summary>
 826 /// <value><c>true</c> if filter changed, <c>false</c> otherwise</value>
 827     public bool FilterChanged {
 828         set { SetFilterChanged( value); }
 829     }
 830     /// <summary>Marks this filter as invalid.</summary>
 831 /// <value><c>true</c> if filter is invalid, <c>false</c> otherwise</value>
 832     public bool FilterInvalid {
 833         set { SetFilterInvalid( value); }
 834     }
 835     /// <summary>Retrieve cached output buffer, if any.
 836 /// Does not increment the reference count.</summary>
 837 /// <value>Output buffer</value>
 838     public System.IntPtr FilterOutputBuffer {
 839         get { return GetFilterOutputBuffer(); }
 840     }
 841     /// <summary>Rectangular size of the pixel buffer as allocated in memory.</summary>
 842 /// <value>Size of the buffer in pixels.</value>
 843     public Eina.Size2D BufferSize {
 844         get { return GetBufferSize(); }
 845         set { SetBufferSize( value); }
 846     }
 847     /// <summary>The colorspace defines how pixels are encoded in the image in memory.
 848 /// By default, images are encoded in 32-bit BGRA, ie. each pixel takes 4 bytes in memory, with each channel B,G,R,A encoding the color with values from 0 to 255.
 849 ///
 850 /// All images used in EFL use alpha-premultipied BGRA values, which means that for each pixel, B &lt;= A, G &lt;= A and R &lt;= A.</summary>
 851 /// <value>Colorspace</value>
 852     public Efl.Gfx.Colorspace Colorspace {
 853         get { return GetColorspace(); }
 854     }
 855     /// <summary>Indicates whether the alpha channel should be used.
 856 /// This does not indicate whether the image source file contains an alpha channel, only whether to respect it or discard it.</summary>
 857 /// <value>Whether to use alpha channel (<c>true</c>) data or not (<c>false</c>).</value>
 858     public bool Alpha {
 859         get { return GetAlpha(); }
 860         set { SetAlpha( value); }
 861     }
 862     /// <summary>Length in bytes of one row of pixels in memory.
 863 /// Usually this will be equal to width * 4, with a plain BGRA image. This may return 0 if the stride is not applicable.
 864 ///
 865 /// When applicable, this will include the <see cref="Efl.Gfx.IBuffer.GetBufferBorders"/> as well as potential extra padding.</summary>
 866 /// <value>Stride</value>
 867     public int Stride {
 868         get { return GetStride(); }
 869     }
 870     /// <summary>Binds the object&apos;s <see cref="Efl.Gfx.IFill.Fill"/> property to its actual geometry.
 871 /// If <c>true</c>, then every time the object is resized, it will automatically trigger a call to <see cref="Efl.Gfx.IFill.SetFill"/> with the new size (and 0, 0 as source image&apos;s origin), so the image will cover the whole object&apos;s area.
 872 ///
 873 /// This property takes precedence over <see cref="Efl.Gfx.IFill.Fill"/>. If set to <c>false</c>, then <see cref="Efl.Gfx.IFill.Fill"/> should be set.
 874 ///
 875 /// This flag is <c>true</c> by default (used to be <c>false</c> with the old APIs, and was known as &quot;filled&quot;).</summary>
 876 /// <value><c>true</c> to make the fill property follow object size or <c>false</c> otherwise.</value>
 877     public bool FillAuto {
 878         get { return GetFillAuto(); }
 879         set { SetFillAuto( value); }
 880     }
 881     /// <summary>Specifies how to tile an image to fill its rectangle geometry.
 882 /// Note that if <c>w</c> or <c>h</c> are smaller than the dimensions of the object, the displayed image will be tiled around the object&apos;s area. To have only one copy of the bound image drawn, <c>x</c> and <c>y</c> must be 0 and <c>w</c> and <c>h</c> need to be the exact width and height of the image object itself, respectively.
 883 ///
 884 /// Setting this property will reset the <see cref="Efl.Gfx.IFill.FillAuto"/> to <c>false</c>.</summary>
 885 /// <value>The top-left corner to start drawing from as well as the size at which the bound image will be displayed.</value>
 886     public Eina.Rect Fill {
 887         get { return GetFill(); }
 888         set { SetFill( value); }
 889     }
 890     /// <summary>Whether to use high-quality image scaling algorithm for this image.
 891 /// When enabled, a higher quality image scaling algorithm is used when scaling images to sizes other than the source image&apos;s original one. This gives better results but is more computationally expensive.
 892 ///
 893 /// <c>true</c> by default</summary>
 894 /// <value>Whether to use smooth scale or not.</value>
 895     public bool SmoothScale {
 896         get { return GetSmoothScale(); }
 897         set { SetSmoothScale( value); }
 898     }
 899     /// <summary>Control how the image is scaled.</summary>
 900 /// <value>Image scale type</value>
 901     public Efl.Gfx.ImageScaleType ScaleType {
 902         get { return GetScaleType(); }
 903         set { SetScaleType( value); }
 904     }
 905     /// <summary>The native width/height ratio of the image.</summary>
 906 /// <value>The image&apos;s ratio.</value>
 907     public double Ratio {
 908         get { return GetRatio(); }
 909     }
 910     /// <summary>Scaling factor applied to the image borders.
 911 /// This value multiplies the size of the <see cref="Efl.Gfx.IImage.GetBorder"/> when scaling an object.
 912 ///
 913 /// Default value is 1.0 (no scaling).</summary>
 914 /// <value>The scale factor.</value>
 915     public double BorderScale {
 916         get { return GetBorderScale(); }
 917         set { SetBorderScale( value); }
 918     }
 919     /// <summary>Specifies how the center part of the object (not the borders) should be drawn when EFL is rendering it.
 920 /// 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.
 921 ///
 922 /// The default value is <see cref="Efl.Gfx.BorderFillMode.Default"/>, ie. render and scale the center area, respecting its transparency.</summary>
 923 /// <value>Fill mode of the center region.</value>
 924     public Efl.Gfx.BorderFillMode BorderCenterFill {
 925         get { return GetBorderCenterFill(); }
 926         set { SetBorderCenterFill( value); }
 927     }
 928     /// <summary>This represents the size of the original image in pixels.
 929 /// 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.
 930 ///
 931 /// This is a read-only property, and may return 0x0.</summary>
 932 /// <value>The size in pixels.</value>
 933     public Eina.Size2D ImageSize {
 934         get { return GetImageSize(); }
 935     }
 936     /// <summary>Get the content hint setting of a given image object of the canvas.
 937 /// This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.</summary>
 938 /// <value>Dynamic or static content hint, see <see cref="Efl.Gfx.ImageContentHint"/></value>
 939     public Efl.Gfx.ImageContentHint ContentHint {
 940         get { return GetContentHint(); }
 941         set { SetContentHint( value); }
 942     }
 943     /// <summary>Get the scale hint of a given image of the canvas.
 944 /// This function returns the scale hint value of the given image object of the canvas.</summary>
 945 /// <value>Scalable or static size hint, see <see cref="Efl.Gfx.ImageScaleHint"/></value>
 946     public Efl.Gfx.ImageScaleHint ScaleHint {
 947         get { return GetScaleHint(); }
 948         set { SetScaleHint( value); }
 949     }
 950     /// <summary>Gets the (last) file loading error for a given object.</summary>
 951 /// <value>The load error code.</value>
 952     public Eina.Error ImageLoadError {
 953         get { return GetImageLoadError(); }
 954     }
 955     /// <summary>The dimensions of this object&apos;s viewport.
 956 /// 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.
 957 ///
 958 /// 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.
 959 ///
 960 /// In most cases the view should have the same dimensions as the object on the canvas, for best quality.
 961 ///
 962 /// <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.
 963 ///
 964 /// Refer to each implementing class specific documentation for more details.</summary>
 965 /// <value>Size of the view.</value>
 966     public Eina.Size2D ViewSize {
 967         get { return GetViewSize(); }
 968         set { SetViewSize( value); }
 969     }
 970     private static IntPtr GetEflClassStatic()
 971     {
 972         return Efl.Canvas.ImageInternal.efl_canvas_image_internal_class_get();
 973     }
 974 }
 975 public class ImageInternalNativeInherit : Efl.Canvas.ObjectNativeInherit{
 976     public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Evas);
 977     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 978     {
 979         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 980         var methods = Efl.Eo.Globals.GetUserMethods(type);
 981         if (efl_file_save_static_delegate == null)
 982             efl_file_save_static_delegate = new efl_file_save_delegate(save);
 983         if (methods.FirstOrDefault(m => m.Name == "Save") != null)
 984             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)});
 985         if (efl_orientation_get_static_delegate == null)
 986             efl_orientation_get_static_delegate = new efl_orientation_get_delegate(orientation_get);
 987         if (methods.FirstOrDefault(m => m.Name == "GetOrientation") != null)
 988             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_orientation_get"), func = Marshal.GetFunctionPointerForDelegate(efl_orientation_get_static_delegate)});
 989         if (efl_orientation_set_static_delegate == null)
 990             efl_orientation_set_static_delegate = new efl_orientation_set_delegate(orientation_set);
 991         if (methods.FirstOrDefault(m => m.Name == "SetOrientation") != null)
 992             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_orientation_set"), func = Marshal.GetFunctionPointerForDelegate(efl_orientation_set_static_delegate)});
 993         if (efl_orientation_flip_get_static_delegate == null)
 994             efl_orientation_flip_get_static_delegate = new efl_orientation_flip_get_delegate(flip_get);
 995         if (methods.FirstOrDefault(m => m.Name == "GetFlip") != null)
 996             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_orientation_flip_get"), func = Marshal.GetFunctionPointerForDelegate(efl_orientation_flip_get_static_delegate)});
 997         if (efl_orientation_flip_set_static_delegate == null)
 998             efl_orientation_flip_set_static_delegate = new efl_orientation_flip_set_delegate(flip_set);
 999         if (methods.FirstOrDefault(m => m.Name == "SetFlip") != null)
1000             descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_orientation_flip_set"), func = Marshal.GetFunctionPointerForDelegate(efl_orientation_flip_set_static_delegate)});
1001         if (evas_filter_changed_set_static_delegate == null)
1002             evas_filter_changed_set_static_delegate = new evas_filter_changed_set_delegate(filter_changed_set);
1003         if (methods.FirstOrDefault(m => m.Name == "SetFilterChanged") != null)
1004             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)});
1005         if (evas_filter_invalid_set_static_delegate == null)
1006             evas_filter_invalid_set_static_delegate = new evas_filter_invalid_set_delegate(filter_invalid_set);
1007         if (methods.FirstOrDefault(m => m.Name == "SetFilterInvalid") != null)
1008             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)});
1009         if (evas_filter_output_buffer_get_static_delegate == null)
1010             evas_filter_output_buffer_get_static_delegate = new evas_filter_output_buffer_get_delegate(filter_output_buffer_get);
1011         if (methods.FirstOrDefault(m => m.Name == "GetFilterOutputBuffer") != null)
1012             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)});
1013         if (evas_filter_input_alpha_static_delegate == null)
1014             evas_filter_input_alpha_static_delegate = new evas_filter_input_alpha_delegate(filter_input_alpha);
1015         if (methods.FirstOrDefault(m => m.Name == "FilterInputAlpha") != null)
1016             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)});
1017         if (evas_filter_state_prepare_static_delegate == null)
1018             evas_filter_state_prepare_static_delegate = new evas_filter_state_prepare_delegate(filter_state_prepare);
1019         if (methods.FirstOrDefault(m => m.Name == "FilterStatePrepare") != null)
1020             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)});
1021         if (evas_filter_input_render_static_delegate == null)
1022             evas_filter_input_render_static_delegate = new evas_filter_input_render_delegate(filter_input_render);
1023         if (methods.FirstOrDefault(m => m.Name == "FilterInputRender") != null)
1024             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)});
1025         if (evas_filter_dirty_static_delegate == null)
1026             evas_filter_dirty_static_delegate = new evas_filter_dirty_delegate(filter_dirty);
1027         if (methods.FirstOrDefault(m => m.Name == "FilterDirty") != null)
1028             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)});
1029         if (efl_gfx_buffer_size_get_static_delegate == null)
1030             efl_gfx_buffer_size_get_static_delegate = new efl_gfx_buffer_size_get_delegate(buffer_size_get);
1031         if (methods.FirstOrDefault(m => m.Name == "GetBufferSize") != null)
1032             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)});
1033         if (efl_gfx_buffer_size_set_static_delegate == null)
1034             efl_gfx_buffer_size_set_static_delegate = new efl_gfx_buffer_size_set_delegate(buffer_size_set);
1035         if (methods.FirstOrDefault(m => m.Name == "SetBufferSize") != null)
1036             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)});
1037         if (efl_gfx_buffer_colorspace_get_static_delegate == null)
1038             efl_gfx_buffer_colorspace_get_static_delegate = new efl_gfx_buffer_colorspace_get_delegate(colorspace_get);
1039         if (methods.FirstOrDefault(m => m.Name == "GetColorspace") != null)
1040             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)});
1041         if (efl_gfx_buffer_alpha_get_static_delegate == null)
1042             efl_gfx_buffer_alpha_get_static_delegate = new efl_gfx_buffer_alpha_get_delegate(alpha_get);
1043         if (methods.FirstOrDefault(m => m.Name == "GetAlpha") != null)
1044             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)});
1045         if (efl_gfx_buffer_alpha_set_static_delegate == null)
1046             efl_gfx_buffer_alpha_set_static_delegate = new efl_gfx_buffer_alpha_set_delegate(alpha_set);
1047         if (methods.FirstOrDefault(m => m.Name == "SetAlpha") != null)
1048             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)});
1049         if (efl_gfx_buffer_stride_get_static_delegate == null)
1050             efl_gfx_buffer_stride_get_static_delegate = new efl_gfx_buffer_stride_get_delegate(stride_get);
1051         if (methods.FirstOrDefault(m => m.Name == "GetStride") != null)
1052             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)});
1053         if (efl_gfx_buffer_borders_get_static_delegate == null)
1054             efl_gfx_buffer_borders_get_static_delegate = new efl_gfx_buffer_borders_get_delegate(buffer_borders_get);
1055         if (methods.FirstOrDefault(m => m.Name == "GetBufferBorders") != null)
1056             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)});
1057         if (efl_gfx_buffer_update_add_static_delegate == null)
1058             efl_gfx_buffer_update_add_static_delegate = new efl_gfx_buffer_update_add_delegate(buffer_update_add);
1059         if (methods.FirstOrDefault(m => m.Name == "AddBufferUpdate") != null)
1060             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)});
1061         if (efl_gfx_buffer_map_static_delegate == null)
1062             efl_gfx_buffer_map_static_delegate = new efl_gfx_buffer_map_delegate(buffer_map);
1063         if (methods.FirstOrDefault(m => m.Name == "BufferMap") != null)
1064             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)});
1065         if (efl_gfx_buffer_unmap_static_delegate == null)
1066             efl_gfx_buffer_unmap_static_delegate = new efl_gfx_buffer_unmap_delegate(buffer_unmap);
1067         if (methods.FirstOrDefault(m => m.Name == "BufferUnmap") != null)
1068             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)});
1069         if (efl_gfx_buffer_copy_set_static_delegate == null)
1070             efl_gfx_buffer_copy_set_static_delegate = new efl_gfx_buffer_copy_set_delegate(buffer_copy_set);
1071         if (methods.FirstOrDefault(m => m.Name == "SetBufferCopy") != null)
1072             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)});
1073         if (efl_gfx_buffer_managed_set_static_delegate == null)
1074             efl_gfx_buffer_managed_set_static_delegate = new efl_gfx_buffer_managed_set_delegate(buffer_managed_set);
1075         if (methods.FirstOrDefault(m => m.Name == "SetBufferManaged") != null)
1076             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)});
1077         if (efl_gfx_buffer_managed_get_static_delegate == null)
1078             efl_gfx_buffer_managed_get_static_delegate = new efl_gfx_buffer_managed_get_delegate(buffer_managed_get);
1079         if (methods.FirstOrDefault(m => m.Name == "GetBufferManaged") != null)
1080             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)});
1081         if (efl_gfx_fill_auto_get_static_delegate == null)
1082             efl_gfx_fill_auto_get_static_delegate = new efl_gfx_fill_auto_get_delegate(fill_auto_get);
1083         if (methods.FirstOrDefault(m => m.Name == "GetFillAuto") != null)
1084             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)});
1085         if (efl_gfx_fill_auto_set_static_delegate == null)
1086             efl_gfx_fill_auto_set_static_delegate = new efl_gfx_fill_auto_set_delegate(fill_auto_set);
1087         if (methods.FirstOrDefault(m => m.Name == "SetFillAuto") != null)
1088             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)});
1089         if (efl_gfx_fill_get_static_delegate == null)
1090             efl_gfx_fill_get_static_delegate = new efl_gfx_fill_get_delegate(fill_get);
1091         if (methods.FirstOrDefault(m => m.Name == "GetFill") != null)
1092             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)});
1093         if (efl_gfx_fill_set_static_delegate == null)
1094             efl_gfx_fill_set_static_delegate = new efl_gfx_fill_set_delegate(fill_set);
1095         if (methods.FirstOrDefault(m => m.Name == "SetFill") != null)
1096             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)});
1097         if (efl_gfx_filter_program_get_static_delegate == null)
1098             efl_gfx_filter_program_get_static_delegate = new efl_gfx_filter_program_get_delegate(filter_program_get);
1099         if (methods.FirstOrDefault(m => m.Name == "GetFilterProgram") != null)
1100             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)});
1101         if (efl_gfx_filter_program_set_static_delegate == null)
1102             efl_gfx_filter_program_set_static_delegate = new efl_gfx_filter_program_set_delegate(filter_program_set);
1103         if (methods.FirstOrDefault(m => m.Name == "SetFilterProgram") != null)
1104             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)});
1105         if (efl_gfx_filter_state_get_static_delegate == null)
1106             efl_gfx_filter_state_get_static_delegate = new efl_gfx_filter_state_get_delegate(filter_state_get);
1107         if (methods.FirstOrDefault(m => m.Name == "GetFilterState") != null)
1108             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)});
1109         if (efl_gfx_filter_state_set_static_delegate == null)
1110             efl_gfx_filter_state_set_static_delegate = new efl_gfx_filter_state_set_delegate(filter_state_set);
1111         if (methods.FirstOrDefault(m => m.Name == "SetFilterState") != null)
1112             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)});
1113         if (efl_gfx_filter_padding_get_static_delegate == null)
1114             efl_gfx_filter_padding_get_static_delegate = new efl_gfx_filter_padding_get_delegate(filter_padding_get);
1115         if (methods.FirstOrDefault(m => m.Name == "GetFilterPadding") != null)
1116             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)});
1117         if (efl_gfx_filter_source_get_static_delegate == null)
1118             efl_gfx_filter_source_get_static_delegate = new efl_gfx_filter_source_get_delegate(filter_source_get);
1119         if (methods.FirstOrDefault(m => m.Name == "GetFilterSource") != null)
1120             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)});
1121         if (efl_gfx_filter_source_set_static_delegate == null)
1122             efl_gfx_filter_source_set_static_delegate = new efl_gfx_filter_source_set_delegate(filter_source_set);
1123         if (methods.FirstOrDefault(m => m.Name == "SetFilterSource") != null)
1124             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)});
1125         if (efl_gfx_filter_data_get_static_delegate == null)
1126             efl_gfx_filter_data_get_static_delegate = new efl_gfx_filter_data_get_delegate(filter_data_get);
1127         if (methods.FirstOrDefault(m => m.Name == "GetFilterData") != null)
1128             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)});
1129         if (efl_gfx_filter_data_set_static_delegate == null)
1130             efl_gfx_filter_data_set_static_delegate = new efl_gfx_filter_data_set_delegate(filter_data_set);
1131         if (methods.FirstOrDefault(m => m.Name == "SetFilterData") != null)
1132             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)});
1133         if (efl_gfx_image_smooth_scale_get_static_delegate == null)
1134             efl_gfx_image_smooth_scale_get_static_delegate = new efl_gfx_image_smooth_scale_get_delegate(smooth_scale_get);
1135         if (methods.FirstOrDefault(m => m.Name == "GetSmoothScale") != null)
1136             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)});
1137         if (efl_gfx_image_smooth_scale_set_static_delegate == null)
1138             efl_gfx_image_smooth_scale_set_static_delegate = new efl_gfx_image_smooth_scale_set_delegate(smooth_scale_set);
1139         if (methods.FirstOrDefault(m => m.Name == "SetSmoothScale") != null)
1140             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)});
1141         if (efl_gfx_image_scale_type_get_static_delegate == null)
1142             efl_gfx_image_scale_type_get_static_delegate = new efl_gfx_image_scale_type_get_delegate(scale_type_get);
1143         if (methods.FirstOrDefault(m => m.Name == "GetScaleType") != null)
1144             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)});
1145         if (efl_gfx_image_scale_type_set_static_delegate == null)
1146             efl_gfx_image_scale_type_set_static_delegate = new efl_gfx_image_scale_type_set_delegate(scale_type_set);
1147         if (methods.FirstOrDefault(m => m.Name == "SetScaleType") != null)
1148             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)});
1149         if (efl_gfx_image_ratio_get_static_delegate == null)
1150             efl_gfx_image_ratio_get_static_delegate = new efl_gfx_image_ratio_get_delegate(ratio_get);
1151         if (methods.FirstOrDefault(m => m.Name == "GetRatio") != null)
1152             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)});
1153         if (efl_gfx_image_border_get_static_delegate == null)
1154             efl_gfx_image_border_get_static_delegate = new efl_gfx_image_border_get_delegate(border_get);
1155         if (methods.FirstOrDefault(m => m.Name == "GetBorder") != null)
1156             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)});
1157         if (efl_gfx_image_border_set_static_delegate == null)
1158             efl_gfx_image_border_set_static_delegate = new efl_gfx_image_border_set_delegate(border_set);
1159         if (methods.FirstOrDefault(m => m.Name == "SetBorder") != null)
1160             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)});
1161         if (efl_gfx_image_border_scale_get_static_delegate == null)
1162             efl_gfx_image_border_scale_get_static_delegate = new efl_gfx_image_border_scale_get_delegate(border_scale_get);
1163         if (methods.FirstOrDefault(m => m.Name == "GetBorderScale") != null)
1164             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)});
1165         if (efl_gfx_image_border_scale_set_static_delegate == null)
1166             efl_gfx_image_border_scale_set_static_delegate = new efl_gfx_image_border_scale_set_delegate(border_scale_set);
1167         if (methods.FirstOrDefault(m => m.Name == "SetBorderScale") != null)
1168             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)});
1169         if (efl_gfx_image_border_center_fill_get_static_delegate == null)
1170             efl_gfx_image_border_center_fill_get_static_delegate = new efl_gfx_image_border_center_fill_get_delegate(border_center_fill_get);
1171         if (methods.FirstOrDefault(m => m.Name == "GetBorderCenterFill") != null)
1172             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)});
1173         if (efl_gfx_image_border_center_fill_set_static_delegate == null)
1174             efl_gfx_image_border_center_fill_set_static_delegate = new efl_gfx_image_border_center_fill_set_delegate(border_center_fill_set);
1175         if (methods.FirstOrDefault(m => m.Name == "SetBorderCenterFill") != null)
1176             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)});
1177         if (efl_gfx_image_size_get_static_delegate == null)
1178             efl_gfx_image_size_get_static_delegate = new efl_gfx_image_size_get_delegate(image_size_get);
1179         if (methods.FirstOrDefault(m => m.Name == "GetImageSize") != null)
1180             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)});
1181         if (efl_gfx_image_content_hint_get_static_delegate == null)
1182             efl_gfx_image_content_hint_get_static_delegate = new efl_gfx_image_content_hint_get_delegate(content_hint_get);
1183         if (methods.FirstOrDefault(m => m.Name == "GetContentHint") != null)
1184             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)});
1185         if (efl_gfx_image_content_hint_set_static_delegate == null)
1186             efl_gfx_image_content_hint_set_static_delegate = new efl_gfx_image_content_hint_set_delegate(content_hint_set);
1187         if (methods.FirstOrDefault(m => m.Name == "SetContentHint") != null)
1188             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)});
1189         if (efl_gfx_image_scale_hint_get_static_delegate == null)
1190             efl_gfx_image_scale_hint_get_static_delegate = new efl_gfx_image_scale_hint_get_delegate(scale_hint_get);
1191         if (methods.FirstOrDefault(m => m.Name == "GetScaleHint") != null)
1192             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)});
1193         if (efl_gfx_image_scale_hint_set_static_delegate == null)
1194             efl_gfx_image_scale_hint_set_static_delegate = new efl_gfx_image_scale_hint_set_delegate(scale_hint_set);
1195         if (methods.FirstOrDefault(m => m.Name == "SetScaleHint") != null)
1196             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)});
1197         if (efl_gfx_image_load_error_get_static_delegate == null)
1198             efl_gfx_image_load_error_get_static_delegate = new efl_gfx_image_load_error_get_delegate(image_load_error_get);
1199         if (methods.FirstOrDefault(m => m.Name == "GetImageLoadError") != null)
1200             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)});
1201         if (efl_gfx_view_size_get_static_delegate == null)
1202             efl_gfx_view_size_get_static_delegate = new efl_gfx_view_size_get_delegate(view_size_get);
1203         if (methods.FirstOrDefault(m => m.Name == "GetViewSize") != null)
1204             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)});
1205         if (efl_gfx_view_size_set_static_delegate == null)
1206             efl_gfx_view_size_set_static_delegate = new efl_gfx_view_size_set_delegate(view_size_set);
1207         if (methods.FirstOrDefault(m => m.Name == "SetViewSize") != null)
1208             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)});
1209         descs.AddRange(base.GetEoOps(type));
1210         return descs;
1211     }
1212     public override IntPtr GetEflClass()
1213     {
1214         return Efl.Canvas.ImageInternal.efl_canvas_image_internal_class_get();
1215     }
1216     public static new  IntPtr GetEflClassStatic()
1217     {
1218         return Efl.Canvas.ImageInternal.efl_canvas_image_internal_class_get();
1219     }
1220
1221
1222      [return: MarshalAs(UnmanagedType.U1)] 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);
1223
1224
1225      [return: MarshalAs(UnmanagedType.U1)] 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);
1226      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");
1227      private static bool save(System.IntPtr obj, System.IntPtr pd,  System.String file,  System.String key,  ref Efl.FileSaveInfo.NativeStruct info)
1228     {
1229         Eina.Log.Debug("function efl_file_save was called");
1230         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1231         if(wrapper != null) {
1232                                     Efl.FileSaveInfo _in_info = info;
1233                                                             bool _ret_var = default(bool);
1234             try {
1235                 _ret_var = ((ImageInternal)wrapper).Save( file,  key,  ref _in_info);
1236             } catch (Exception e) {
1237                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1238                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1239             }
1240                                                 info = _in_info;
1241         return _ret_var;
1242         } else {
1243             return efl_file_save_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  file,  key,  ref info);
1244         }
1245     }
1246     private static efl_file_save_delegate efl_file_save_static_delegate;
1247
1248
1249      private delegate Efl.Orient efl_orientation_get_delegate(System.IntPtr obj, System.IntPtr pd);
1250
1251
1252      public delegate Efl.Orient efl_orientation_get_api_delegate(System.IntPtr obj);
1253      public static Efl.Eo.FunctionWrapper<efl_orientation_get_api_delegate> efl_orientation_get_ptr = new Efl.Eo.FunctionWrapper<efl_orientation_get_api_delegate>(_Module, "efl_orientation_get");
1254      private static Efl.Orient orientation_get(System.IntPtr obj, System.IntPtr pd)
1255     {
1256         Eina.Log.Debug("function efl_orientation_get was called");
1257         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1258         if(wrapper != null) {
1259                         Efl.Orient _ret_var = default(Efl.Orient);
1260             try {
1261                 _ret_var = ((ImageInternal)wrapper).GetOrientation();
1262             } catch (Exception e) {
1263                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1264                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1265             }
1266         return _ret_var;
1267         } else {
1268             return efl_orientation_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1269         }
1270     }
1271     private static efl_orientation_get_delegate efl_orientation_get_static_delegate;
1272
1273
1274      private delegate void efl_orientation_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Orient dir);
1275
1276
1277      public delegate void efl_orientation_set_api_delegate(System.IntPtr obj,   Efl.Orient dir);
1278      public static Efl.Eo.FunctionWrapper<efl_orientation_set_api_delegate> efl_orientation_set_ptr = new Efl.Eo.FunctionWrapper<efl_orientation_set_api_delegate>(_Module, "efl_orientation_set");
1279      private static void orientation_set(System.IntPtr obj, System.IntPtr pd,  Efl.Orient dir)
1280     {
1281         Eina.Log.Debug("function efl_orientation_set was called");
1282         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1283         if(wrapper != null) {
1284
1285             try {
1286                 ((ImageInternal)wrapper).SetOrientation( dir);
1287             } catch (Exception e) {
1288                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1289                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1290             }
1291                                 } else {
1292             efl_orientation_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  dir);
1293         }
1294     }
1295     private static efl_orientation_set_delegate efl_orientation_set_static_delegate;
1296
1297
1298      private delegate Efl.Flip efl_orientation_flip_get_delegate(System.IntPtr obj, System.IntPtr pd);
1299
1300
1301      public delegate Efl.Flip efl_orientation_flip_get_api_delegate(System.IntPtr obj);
1302      public static Efl.Eo.FunctionWrapper<efl_orientation_flip_get_api_delegate> efl_orientation_flip_get_ptr = new Efl.Eo.FunctionWrapper<efl_orientation_flip_get_api_delegate>(_Module, "efl_orientation_flip_get");
1303      private static Efl.Flip flip_get(System.IntPtr obj, System.IntPtr pd)
1304     {
1305         Eina.Log.Debug("function efl_orientation_flip_get was called");
1306         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1307         if(wrapper != null) {
1308                         Efl.Flip _ret_var = default(Efl.Flip);
1309             try {
1310                 _ret_var = ((ImageInternal)wrapper).GetFlip();
1311             } catch (Exception e) {
1312                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1313                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1314             }
1315         return _ret_var;
1316         } else {
1317             return efl_orientation_flip_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1318         }
1319     }
1320     private static efl_orientation_flip_get_delegate efl_orientation_flip_get_static_delegate;
1321
1322
1323      private delegate void efl_orientation_flip_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Flip flip);
1324
1325
1326      public delegate void efl_orientation_flip_set_api_delegate(System.IntPtr obj,   Efl.Flip flip);
1327      public static Efl.Eo.FunctionWrapper<efl_orientation_flip_set_api_delegate> efl_orientation_flip_set_ptr = new Efl.Eo.FunctionWrapper<efl_orientation_flip_set_api_delegate>(_Module, "efl_orientation_flip_set");
1328      private static void flip_set(System.IntPtr obj, System.IntPtr pd,  Efl.Flip flip)
1329     {
1330         Eina.Log.Debug("function efl_orientation_flip_set was called");
1331         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1332         if(wrapper != null) {
1333
1334             try {
1335                 ((ImageInternal)wrapper).SetFlip( flip);
1336             } catch (Exception e) {
1337                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1338                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1339             }
1340                                 } else {
1341             efl_orientation_flip_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  flip);
1342         }
1343     }
1344     private static efl_orientation_flip_set_delegate efl_orientation_flip_set_static_delegate;
1345
1346
1347      private delegate void evas_filter_changed_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool val);
1348
1349
1350      public delegate void evas_filter_changed_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool val);
1351      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");
1352      private static void filter_changed_set(System.IntPtr obj, System.IntPtr pd,  bool val)
1353     {
1354         Eina.Log.Debug("function evas_filter_changed_set was called");
1355         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1356         if(wrapper != null) {
1357
1358             try {
1359                 ((ImageInternal)wrapper).SetFilterChanged( val);
1360             } catch (Exception e) {
1361                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1362                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1363             }
1364                                 } else {
1365             evas_filter_changed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  val);
1366         }
1367     }
1368     private static evas_filter_changed_set_delegate evas_filter_changed_set_static_delegate;
1369
1370
1371      private delegate void evas_filter_invalid_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool val);
1372
1373
1374      public delegate void evas_filter_invalid_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool val);
1375      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");
1376      private static void filter_invalid_set(System.IntPtr obj, System.IntPtr pd,  bool val)
1377     {
1378         Eina.Log.Debug("function evas_filter_invalid_set was called");
1379         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1380         if(wrapper != null) {
1381
1382             try {
1383                 ((ImageInternal)wrapper).SetFilterInvalid( val);
1384             } catch (Exception e) {
1385                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1386                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1387             }
1388                                 } else {
1389             evas_filter_invalid_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  val);
1390         }
1391     }
1392     private static evas_filter_invalid_set_delegate evas_filter_invalid_set_static_delegate;
1393
1394
1395      private delegate System.IntPtr evas_filter_output_buffer_get_delegate(System.IntPtr obj, System.IntPtr pd);
1396
1397
1398      public delegate System.IntPtr evas_filter_output_buffer_get_api_delegate(System.IntPtr obj);
1399      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");
1400      private static System.IntPtr filter_output_buffer_get(System.IntPtr obj, System.IntPtr pd)
1401     {
1402         Eina.Log.Debug("function evas_filter_output_buffer_get was called");
1403         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1404         if(wrapper != null) {
1405                         System.IntPtr _ret_var = default(System.IntPtr);
1406             try {
1407                 _ret_var = ((ImageInternal)wrapper).GetFilterOutputBuffer();
1408             } catch (Exception e) {
1409                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1410                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1411             }
1412         return _ret_var;
1413         } else {
1414             return evas_filter_output_buffer_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1415         }
1416     }
1417     private static evas_filter_output_buffer_get_delegate evas_filter_output_buffer_get_static_delegate;
1418
1419
1420      [return: MarshalAs(UnmanagedType.U1)] private delegate bool evas_filter_input_alpha_delegate(System.IntPtr obj, System.IntPtr pd);
1421
1422
1423      [return: MarshalAs(UnmanagedType.U1)] public delegate bool evas_filter_input_alpha_api_delegate(System.IntPtr obj);
1424      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");
1425      private static bool filter_input_alpha(System.IntPtr obj, System.IntPtr pd)
1426     {
1427         Eina.Log.Debug("function evas_filter_input_alpha was called");
1428         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1429         if(wrapper != null) {
1430                         bool _ret_var = default(bool);
1431             try {
1432                 _ret_var = ((ImageInternal)wrapper).FilterInputAlpha();
1433             } catch (Exception e) {
1434                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1435                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1436             }
1437         return _ret_var;
1438         } else {
1439             return evas_filter_input_alpha_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1440         }
1441     }
1442     private static evas_filter_input_alpha_delegate evas_filter_input_alpha_static_delegate;
1443
1444
1445      private delegate void evas_filter_state_prepare_delegate(System.IntPtr obj, System.IntPtr pd,   out Efl.Canvas.Filter.State.NativeStruct state,   System.IntPtr data);
1446
1447
1448      public delegate void evas_filter_state_prepare_api_delegate(System.IntPtr obj,   out Efl.Canvas.Filter.State.NativeStruct state,   System.IntPtr data);
1449      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");
1450      private static void filter_state_prepare(System.IntPtr obj, System.IntPtr pd,  out Efl.Canvas.Filter.State.NativeStruct state,  System.IntPtr data)
1451     {
1452         Eina.Log.Debug("function evas_filter_state_prepare was called");
1453         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1454         if(wrapper != null) {
1455                                     Efl.Canvas.Filter.State _out_state = default(Efl.Canvas.Filter.State);
1456
1457             try {
1458                 ((ImageInternal)wrapper).FilterStatePrepare( out _out_state,  data);
1459             } catch (Exception e) {
1460                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1461                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1462             }
1463         state = _out_state;
1464                                         } else {
1465             evas_filter_state_prepare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  out state,  data);
1466         }
1467     }
1468     private static evas_filter_state_prepare_delegate evas_filter_state_prepare_static_delegate;
1469
1470
1471      [return: MarshalAs(UnmanagedType.U1)] 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);
1472
1473
1474      [return: MarshalAs(UnmanagedType.U1)] 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);
1475      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");
1476      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)
1477     {
1478         Eina.Log.Debug("function evas_filter_input_render was called");
1479         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1480         if(wrapper != null) {
1481                                                                                                                                                                                                                                                                                                                         bool _ret_var = default(bool);
1482             try {
1483                 _ret_var = ((ImageInternal)wrapper).FilterInputRender( filter,  engine,  output,  drawctx,  data,  l,  r,  t,  b,  x,  y,  do_async);
1484             } catch (Exception e) {
1485                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1486                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1487             }
1488                                                                                                                                                                                                         return _ret_var;
1489         } else {
1490             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);
1491         }
1492     }
1493     private static evas_filter_input_render_delegate evas_filter_input_render_static_delegate;
1494
1495
1496      private delegate void evas_filter_dirty_delegate(System.IntPtr obj, System.IntPtr pd);
1497
1498
1499      public delegate void evas_filter_dirty_api_delegate(System.IntPtr obj);
1500      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");
1501      private static void filter_dirty(System.IntPtr obj, System.IntPtr pd)
1502     {
1503         Eina.Log.Debug("function evas_filter_dirty was called");
1504         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1505         if(wrapper != null) {
1506
1507             try {
1508                 ((ImageInternal)wrapper).FilterDirty();
1509             } catch (Exception e) {
1510                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1511                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1512             }
1513                 } else {
1514             evas_filter_dirty_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1515         }
1516     }
1517     private static evas_filter_dirty_delegate evas_filter_dirty_static_delegate;
1518
1519
1520      private delegate Eina.Size2D.NativeStruct efl_gfx_buffer_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
1521
1522
1523      public delegate Eina.Size2D.NativeStruct efl_gfx_buffer_size_get_api_delegate(System.IntPtr obj);
1524      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");
1525      private static Eina.Size2D.NativeStruct buffer_size_get(System.IntPtr obj, System.IntPtr pd)
1526     {
1527         Eina.Log.Debug("function efl_gfx_buffer_size_get was called");
1528         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1529         if(wrapper != null) {
1530                         Eina.Size2D _ret_var = default(Eina.Size2D);
1531             try {
1532                 _ret_var = ((ImageInternal)wrapper).GetBufferSize();
1533             } catch (Exception e) {
1534                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1535                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1536             }
1537         return _ret_var;
1538         } else {
1539             return efl_gfx_buffer_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1540         }
1541     }
1542     private static efl_gfx_buffer_size_get_delegate efl_gfx_buffer_size_get_static_delegate;
1543
1544
1545      private delegate void efl_gfx_buffer_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D.NativeStruct sz);
1546
1547
1548      public delegate void efl_gfx_buffer_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D.NativeStruct sz);
1549      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");
1550      private static void buffer_size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct sz)
1551     {
1552         Eina.Log.Debug("function efl_gfx_buffer_size_set was called");
1553         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1554         if(wrapper != null) {
1555                     Eina.Size2D _in_sz = sz;
1556
1557             try {
1558                 ((ImageInternal)wrapper).SetBufferSize( _in_sz);
1559             } catch (Exception e) {
1560                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1561                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1562             }
1563                                 } else {
1564             efl_gfx_buffer_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  sz);
1565         }
1566     }
1567     private static efl_gfx_buffer_size_set_delegate efl_gfx_buffer_size_set_static_delegate;
1568
1569
1570      private delegate Efl.Gfx.Colorspace efl_gfx_buffer_colorspace_get_delegate(System.IntPtr obj, System.IntPtr pd);
1571
1572
1573      public delegate Efl.Gfx.Colorspace efl_gfx_buffer_colorspace_get_api_delegate(System.IntPtr obj);
1574      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");
1575      private static Efl.Gfx.Colorspace colorspace_get(System.IntPtr obj, System.IntPtr pd)
1576     {
1577         Eina.Log.Debug("function efl_gfx_buffer_colorspace_get was called");
1578         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1579         if(wrapper != null) {
1580                         Efl.Gfx.Colorspace _ret_var = default(Efl.Gfx.Colorspace);
1581             try {
1582                 _ret_var = ((ImageInternal)wrapper).GetColorspace();
1583             } catch (Exception e) {
1584                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1585                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1586             }
1587         return _ret_var;
1588         } else {
1589             return efl_gfx_buffer_colorspace_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1590         }
1591     }
1592     private static efl_gfx_buffer_colorspace_get_delegate efl_gfx_buffer_colorspace_get_static_delegate;
1593
1594
1595      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_buffer_alpha_get_delegate(System.IntPtr obj, System.IntPtr pd);
1596
1597
1598      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_buffer_alpha_get_api_delegate(System.IntPtr obj);
1599      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");
1600      private static bool alpha_get(System.IntPtr obj, System.IntPtr pd)
1601     {
1602         Eina.Log.Debug("function efl_gfx_buffer_alpha_get was called");
1603         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1604         if(wrapper != null) {
1605                         bool _ret_var = default(bool);
1606             try {
1607                 _ret_var = ((ImageInternal)wrapper).GetAlpha();
1608             } catch (Exception e) {
1609                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1610                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1611             }
1612         return _ret_var;
1613         } else {
1614             return efl_gfx_buffer_alpha_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1615         }
1616     }
1617     private static efl_gfx_buffer_alpha_get_delegate efl_gfx_buffer_alpha_get_static_delegate;
1618
1619
1620      private delegate void efl_gfx_buffer_alpha_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool alpha);
1621
1622
1623      public delegate void efl_gfx_buffer_alpha_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool alpha);
1624      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");
1625      private static void alpha_set(System.IntPtr obj, System.IntPtr pd,  bool alpha)
1626     {
1627         Eina.Log.Debug("function efl_gfx_buffer_alpha_set was called");
1628         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1629         if(wrapper != null) {
1630
1631             try {
1632                 ((ImageInternal)wrapper).SetAlpha( alpha);
1633             } catch (Exception e) {
1634                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1635                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1636             }
1637                                 } else {
1638             efl_gfx_buffer_alpha_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  alpha);
1639         }
1640     }
1641     private static efl_gfx_buffer_alpha_set_delegate efl_gfx_buffer_alpha_set_static_delegate;
1642
1643
1644      private delegate int efl_gfx_buffer_stride_get_delegate(System.IntPtr obj, System.IntPtr pd);
1645
1646
1647      public delegate int efl_gfx_buffer_stride_get_api_delegate(System.IntPtr obj);
1648      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");
1649      private static int stride_get(System.IntPtr obj, System.IntPtr pd)
1650     {
1651         Eina.Log.Debug("function efl_gfx_buffer_stride_get was called");
1652         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1653         if(wrapper != null) {
1654                         int _ret_var = default(int);
1655             try {
1656                 _ret_var = ((ImageInternal)wrapper).GetStride();
1657             } catch (Exception e) {
1658                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1659                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1660             }
1661         return _ret_var;
1662         } else {
1663             return efl_gfx_buffer_stride_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1664         }
1665     }
1666     private static efl_gfx_buffer_stride_get_delegate efl_gfx_buffer_stride_get_static_delegate;
1667
1668
1669      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);
1670
1671
1672      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);
1673      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");
1674      private static void buffer_borders_get(System.IntPtr obj, System.IntPtr pd,  out uint l,  out uint r,  out uint t,  out uint b)
1675     {
1676         Eina.Log.Debug("function efl_gfx_buffer_borders_get was called");
1677         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1678         if(wrapper != null) {
1679                                                     l = default(uint);        r = default(uint);        t = default(uint);        b = default(uint);
1680             try {
1681                 ((ImageInternal)wrapper).GetBufferBorders( out l,  out r,  out t,  out b);
1682             } catch (Exception e) {
1683                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1684                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1685             }
1686                                                                                 } else {
1687             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);
1688         }
1689     }
1690     private static efl_gfx_buffer_borders_get_delegate efl_gfx_buffer_borders_get_static_delegate;
1691
1692
1693      private delegate void efl_gfx_buffer_update_add_delegate(System.IntPtr obj, System.IntPtr pd,   ref Eina.Rect.NativeStruct region);
1694
1695
1696      public delegate void efl_gfx_buffer_update_add_api_delegate(System.IntPtr obj,   ref Eina.Rect.NativeStruct region);
1697      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");
1698      private static void buffer_update_add(System.IntPtr obj, System.IntPtr pd,  ref Eina.Rect.NativeStruct region)
1699     {
1700         Eina.Log.Debug("function efl_gfx_buffer_update_add was called");
1701         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1702         if(wrapper != null) {
1703                     Eina.Rect _in_region = region;
1704
1705             try {
1706                 ((ImageInternal)wrapper).AddBufferUpdate( ref _in_region);
1707             } catch (Exception e) {
1708                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1709                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1710             }
1711                 region = _in_region;
1712                 } else {
1713             efl_gfx_buffer_update_add_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  ref region);
1714         }
1715     }
1716     private static efl_gfx_buffer_update_add_delegate efl_gfx_buffer_update_add_static_delegate;
1717
1718
1719      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);
1720
1721
1722      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);
1723      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");
1724      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)
1725     {
1726         Eina.Log.Debug("function efl_gfx_buffer_map was called");
1727         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1728         if(wrapper != null) {
1729                             Eina.Rect _in_region = region;
1730                                                                 stride = default(int);                                                    Eina.RwSlice _ret_var = default(Eina.RwSlice);
1731             try {
1732                 _ret_var = ((ImageInternal)wrapper).BufferMap( mode,  ref _in_region,  cspace,  plane,  out stride);
1733             } catch (Exception e) {
1734                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1735                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1736             }
1737                                                         region = _in_region;
1738                                 return _ret_var;
1739         } else {
1740             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);
1741         }
1742     }
1743     private static efl_gfx_buffer_map_delegate efl_gfx_buffer_map_static_delegate;
1744
1745
1746      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_buffer_unmap_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.RwSlice slice);
1747
1748
1749      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_buffer_unmap_api_delegate(System.IntPtr obj,   Eina.RwSlice slice);
1750      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");
1751      private static bool buffer_unmap(System.IntPtr obj, System.IntPtr pd,  Eina.RwSlice slice)
1752     {
1753         Eina.Log.Debug("function efl_gfx_buffer_unmap was called");
1754         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1755         if(wrapper != null) {
1756                                                 bool _ret_var = default(bool);
1757             try {
1758                 _ret_var = ((ImageInternal)wrapper).BufferUnmap( slice);
1759             } catch (Exception e) {
1760                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1761                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1762             }
1763                         return _ret_var;
1764         } else {
1765             return efl_gfx_buffer_unmap_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  slice);
1766         }
1767     }
1768     private static efl_gfx_buffer_unmap_delegate efl_gfx_buffer_unmap_static_delegate;
1769
1770
1771      [return: MarshalAs(UnmanagedType.U1)] 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);
1772
1773
1774      [return: MarshalAs(UnmanagedType.U1)] 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);
1775      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");
1776      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)
1777     {
1778         Eina.Log.Debug("function efl_gfx_buffer_copy_set was called");
1779         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1780         if(wrapper != null) {
1781                     var _in_slice = Eina.PrimitiveConversion.PointerToManaged<Eina.Slice>(slice);
1782         Eina.Size2D _in_size = size;
1783                                                                                                                     bool _ret_var = default(bool);
1784             try {
1785                 _ret_var = ((ImageInternal)wrapper).SetBufferCopy( _in_slice,  _in_size,  stride,  cspace,  plane);
1786             } catch (Exception e) {
1787                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1788                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1789             }
1790                                                                                         return _ret_var;
1791         } else {
1792             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);
1793         }
1794     }
1795     private static efl_gfx_buffer_copy_set_delegate efl_gfx_buffer_copy_set_static_delegate;
1796
1797
1798      [return: MarshalAs(UnmanagedType.U1)] 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);
1799
1800
1801      [return: MarshalAs(UnmanagedType.U1)] 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);
1802      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");
1803      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)
1804     {
1805         Eina.Log.Debug("function efl_gfx_buffer_managed_set was called");
1806         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1807         if(wrapper != null) {
1808                     var _in_slice = Eina.PrimitiveConversion.PointerToManaged<Eina.Slice>(slice);
1809         Eina.Size2D _in_size = size;
1810                                                                                                                     bool _ret_var = default(bool);
1811             try {
1812                 _ret_var = ((ImageInternal)wrapper).SetBufferManaged( _in_slice,  _in_size,  stride,  cspace,  plane);
1813             } catch (Exception e) {
1814                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1815                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1816             }
1817                                                                                         return _ret_var;
1818         } else {
1819             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);
1820         }
1821     }
1822     private static efl_gfx_buffer_managed_set_delegate efl_gfx_buffer_managed_set_static_delegate;
1823
1824
1825      private delegate Eina.Slice efl_gfx_buffer_managed_get_delegate(System.IntPtr obj, System.IntPtr pd,   int plane);
1826
1827
1828      public delegate Eina.Slice efl_gfx_buffer_managed_get_api_delegate(System.IntPtr obj,   int plane);
1829      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");
1830      private static Eina.Slice buffer_managed_get(System.IntPtr obj, System.IntPtr pd,  int plane)
1831     {
1832         Eina.Log.Debug("function efl_gfx_buffer_managed_get was called");
1833         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1834         if(wrapper != null) {
1835                                                 Eina.Slice _ret_var = default(Eina.Slice);
1836             try {
1837                 _ret_var = ((ImageInternal)wrapper).GetBufferManaged( plane);
1838             } catch (Exception e) {
1839                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1840                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1841             }
1842                         return _ret_var;
1843         } else {
1844             return efl_gfx_buffer_managed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  plane);
1845         }
1846     }
1847     private static efl_gfx_buffer_managed_get_delegate efl_gfx_buffer_managed_get_static_delegate;
1848
1849
1850      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_fill_auto_get_delegate(System.IntPtr obj, System.IntPtr pd);
1851
1852
1853      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_fill_auto_get_api_delegate(System.IntPtr obj);
1854      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");
1855      private static bool fill_auto_get(System.IntPtr obj, System.IntPtr pd)
1856     {
1857         Eina.Log.Debug("function efl_gfx_fill_auto_get was called");
1858         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1859         if(wrapper != null) {
1860                         bool _ret_var = default(bool);
1861             try {
1862                 _ret_var = ((ImageInternal)wrapper).GetFillAuto();
1863             } catch (Exception e) {
1864                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1865                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1866             }
1867         return _ret_var;
1868         } else {
1869             return efl_gfx_fill_auto_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1870         }
1871     }
1872     private static efl_gfx_fill_auto_get_delegate efl_gfx_fill_auto_get_static_delegate;
1873
1874
1875      private delegate void efl_gfx_fill_auto_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool filled);
1876
1877
1878      public delegate void efl_gfx_fill_auto_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool filled);
1879      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");
1880      private static void fill_auto_set(System.IntPtr obj, System.IntPtr pd,  bool filled)
1881     {
1882         Eina.Log.Debug("function efl_gfx_fill_auto_set was called");
1883         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1884         if(wrapper != null) {
1885
1886             try {
1887                 ((ImageInternal)wrapper).SetFillAuto( filled);
1888             } catch (Exception e) {
1889                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1890                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1891             }
1892                                 } else {
1893             efl_gfx_fill_auto_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  filled);
1894         }
1895     }
1896     private static efl_gfx_fill_auto_set_delegate efl_gfx_fill_auto_set_static_delegate;
1897
1898
1899      private delegate Eina.Rect.NativeStruct efl_gfx_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
1900
1901
1902      public delegate Eina.Rect.NativeStruct efl_gfx_fill_get_api_delegate(System.IntPtr obj);
1903      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");
1904      private static Eina.Rect.NativeStruct fill_get(System.IntPtr obj, System.IntPtr pd)
1905     {
1906         Eina.Log.Debug("function efl_gfx_fill_get was called");
1907         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1908         if(wrapper != null) {
1909                         Eina.Rect _ret_var = default(Eina.Rect);
1910             try {
1911                 _ret_var = ((ImageInternal)wrapper).GetFill();
1912             } catch (Exception e) {
1913                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1914                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1915             }
1916         return _ret_var;
1917         } else {
1918             return efl_gfx_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1919         }
1920     }
1921     private static efl_gfx_fill_get_delegate efl_gfx_fill_get_static_delegate;
1922
1923
1924      private delegate void efl_gfx_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Rect.NativeStruct fill);
1925
1926
1927      public delegate void efl_gfx_fill_set_api_delegate(System.IntPtr obj,   Eina.Rect.NativeStruct fill);
1928      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");
1929      private static void fill_set(System.IntPtr obj, System.IntPtr pd,  Eina.Rect.NativeStruct fill)
1930     {
1931         Eina.Log.Debug("function efl_gfx_fill_set was called");
1932         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1933         if(wrapper != null) {
1934                     Eina.Rect _in_fill = fill;
1935
1936             try {
1937                 ((ImageInternal)wrapper).SetFill( _in_fill);
1938             } catch (Exception e) {
1939                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1940                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1941             }
1942                                 } else {
1943             efl_gfx_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  fill);
1944         }
1945     }
1946     private static efl_gfx_fill_set_delegate efl_gfx_fill_set_static_delegate;
1947
1948
1949      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);
1950
1951
1952      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);
1953      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");
1954      private static void filter_program_get(System.IntPtr obj, System.IntPtr pd,  out System.String code,  out System.String name)
1955     {
1956         Eina.Log.Debug("function efl_gfx_filter_program_get was called");
1957         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1958         if(wrapper != null) {
1959                                     System.String _out_code = default(System.String);
1960         System.String _out_name = default(System.String);
1961
1962             try {
1963                 ((ImageInternal)wrapper).GetFilterProgram( out _out_code,  out _out_name);
1964             } catch (Exception e) {
1965                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1966                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1967             }
1968         code = _out_code;
1969         name = _out_name;
1970                                 } else {
1971             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);
1972         }
1973     }
1974     private static efl_gfx_filter_program_get_delegate efl_gfx_filter_program_get_static_delegate;
1975
1976
1977      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);
1978
1979
1980      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);
1981      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");
1982      private static void filter_program_set(System.IntPtr obj, System.IntPtr pd,  System.String code,  System.String name)
1983     {
1984         Eina.Log.Debug("function efl_gfx_filter_program_set was called");
1985         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1986         if(wrapper != null) {
1987
1988             try {
1989                 ((ImageInternal)wrapper).SetFilterProgram( code,  name);
1990             } catch (Exception e) {
1991                 Eina.Log.Warning($"Callback error: {e.ToString()}");
1992                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1993             }
1994                                                 } else {
1995             efl_gfx_filter_program_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  code,  name);
1996         }
1997     }
1998     private static efl_gfx_filter_program_set_delegate efl_gfx_filter_program_set_static_delegate;
1999
2000
2001      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);
2002
2003
2004      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);
2005      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");
2006      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)
2007     {
2008         Eina.Log.Debug("function efl_gfx_filter_state_get was called");
2009         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2010         if(wrapper != null) {
2011                                                             System.String _out_cur_state = default(System.String);
2012         cur_val = default(double);        System.String _out_next_state = default(System.String);
2013         next_val = default(double);        pos = default(double);
2014             try {
2015                 ((ImageInternal)wrapper).GetFilterState( out _out_cur_state,  out cur_val,  out _out_next_state,  out next_val,  out pos);
2016             } catch (Exception e) {
2017                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2018                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2019             }
2020         cur_state = _out_cur_state;
2021                 next_state = _out_next_state;
2022                                                                         } else {
2023             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);
2024         }
2025     }
2026     private static efl_gfx_filter_state_get_delegate efl_gfx_filter_state_get_static_delegate;
2027
2028
2029      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);
2030
2031
2032      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);
2033      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");
2034      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)
2035     {
2036         Eina.Log.Debug("function efl_gfx_filter_state_set was called");
2037         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2038         if(wrapper != null) {
2039
2040             try {
2041                 ((ImageInternal)wrapper).SetFilterState( cur_state,  cur_val,  next_state,  next_val,  pos);
2042             } catch (Exception e) {
2043                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2044                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2045             }
2046                                                                                                 } else {
2047             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);
2048         }
2049     }
2050     private static efl_gfx_filter_state_set_delegate efl_gfx_filter_state_set_static_delegate;
2051
2052
2053      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);
2054
2055
2056      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);
2057      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");
2058      private static void filter_padding_get(System.IntPtr obj, System.IntPtr pd,  out int l,  out int r,  out int t,  out int b)
2059     {
2060         Eina.Log.Debug("function efl_gfx_filter_padding_get was called");
2061         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2062         if(wrapper != null) {
2063                                                     l = default(int);        r = default(int);        t = default(int);        b = default(int);
2064             try {
2065                 ((ImageInternal)wrapper).GetFilterPadding( out l,  out r,  out t,  out b);
2066             } catch (Exception e) {
2067                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2068                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2069             }
2070                                                                                 } else {
2071             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);
2072         }
2073     }
2074     private static efl_gfx_filter_padding_get_delegate efl_gfx_filter_padding_get_static_delegate;
2075
2076
2077     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] 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);
2078
2079
2080     [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))] 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);
2081      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");
2082      private static Efl.Gfx.IEntity filter_source_get(System.IntPtr obj, System.IntPtr pd,  System.String name)
2083     {
2084         Eina.Log.Debug("function efl_gfx_filter_source_get was called");
2085         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2086         if(wrapper != null) {
2087                                                 Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
2088             try {
2089                 _ret_var = ((ImageInternal)wrapper).GetFilterSource( name);
2090             } catch (Exception e) {
2091                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2092                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2093             }
2094                         return _ret_var;
2095         } else {
2096             return efl_gfx_filter_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name);
2097         }
2098     }
2099     private static efl_gfx_filter_source_get_delegate efl_gfx_filter_source_get_static_delegate;
2100
2101
2102      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.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity source);
2103
2104
2105      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.MarshalTest<Efl.Gfx.IEntityConcrete, Efl.Eo.NonOwnTag>))]  Efl.Gfx.IEntity source);
2106      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");
2107      private static void filter_source_set(System.IntPtr obj, System.IntPtr pd,  System.String name,  Efl.Gfx.IEntity source)
2108     {
2109         Eina.Log.Debug("function efl_gfx_filter_source_set was called");
2110         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2111         if(wrapper != null) {
2112
2113             try {
2114                 ((ImageInternal)wrapper).SetFilterSource( name,  source);
2115             } catch (Exception e) {
2116                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2117                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2118             }
2119                                                 } else {
2120             efl_gfx_filter_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name,  source);
2121         }
2122     }
2123     private static efl_gfx_filter_source_set_delegate efl_gfx_filter_source_set_static_delegate;
2124
2125
2126      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);
2127
2128
2129      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);
2130      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");
2131      private static void filter_data_get(System.IntPtr obj, System.IntPtr pd,  System.String name,  out System.String value,  out bool execute)
2132     {
2133         Eina.Log.Debug("function efl_gfx_filter_data_get was called");
2134         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2135         if(wrapper != null) {
2136                                                     System.String _out_value = default(System.String);
2137         execute = default(bool);
2138             try {
2139                 ((ImageInternal)wrapper).GetFilterData( name,  out _out_value,  out execute);
2140             } catch (Exception e) {
2141                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2142                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2143             }
2144                 value = _out_value;
2145                                                 } else {
2146             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);
2147         }
2148     }
2149     private static efl_gfx_filter_data_get_delegate efl_gfx_filter_data_get_static_delegate;
2150
2151
2152      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);
2153
2154
2155      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);
2156      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");
2157      private static void filter_data_set(System.IntPtr obj, System.IntPtr pd,  System.String name,  System.String value,  bool execute)
2158     {
2159         Eina.Log.Debug("function efl_gfx_filter_data_set was called");
2160         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2161         if(wrapper != null) {
2162
2163             try {
2164                 ((ImageInternal)wrapper).SetFilterData( name,  value,  execute);
2165             } catch (Exception e) {
2166                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2167                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2168             }
2169                                                                 } else {
2170             efl_gfx_filter_data_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name,  value,  execute);
2171         }
2172     }
2173     private static efl_gfx_filter_data_set_delegate efl_gfx_filter_data_set_static_delegate;
2174
2175
2176      [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_gfx_image_smooth_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
2177
2178
2179      [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_gfx_image_smooth_scale_get_api_delegate(System.IntPtr obj);
2180      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");
2181      private static bool smooth_scale_get(System.IntPtr obj, System.IntPtr pd)
2182     {
2183         Eina.Log.Debug("function efl_gfx_image_smooth_scale_get was called");
2184         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2185         if(wrapper != null) {
2186                         bool _ret_var = default(bool);
2187             try {
2188                 _ret_var = ((ImageInternal)wrapper).GetSmoothScale();
2189             } catch (Exception e) {
2190                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2191                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2192             }
2193         return _ret_var;
2194         } else {
2195             return efl_gfx_image_smooth_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2196         }
2197     }
2198     private static efl_gfx_image_smooth_scale_get_delegate efl_gfx_image_smooth_scale_get_static_delegate;
2199
2200
2201      private delegate void efl_gfx_image_smooth_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool smooth_scale);
2202
2203
2204      public delegate void efl_gfx_image_smooth_scale_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool smooth_scale);
2205      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");
2206      private static void smooth_scale_set(System.IntPtr obj, System.IntPtr pd,  bool smooth_scale)
2207     {
2208         Eina.Log.Debug("function efl_gfx_image_smooth_scale_set was called");
2209         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2210         if(wrapper != null) {
2211
2212             try {
2213                 ((ImageInternal)wrapper).SetSmoothScale( smooth_scale);
2214             } catch (Exception e) {
2215                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2216                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2217             }
2218                                 } else {
2219             efl_gfx_image_smooth_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  smooth_scale);
2220         }
2221     }
2222     private static efl_gfx_image_smooth_scale_set_delegate efl_gfx_image_smooth_scale_set_static_delegate;
2223
2224
2225      private delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_delegate(System.IntPtr obj, System.IntPtr pd);
2226
2227
2228      public delegate Efl.Gfx.ImageScaleType efl_gfx_image_scale_type_get_api_delegate(System.IntPtr obj);
2229      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");
2230      private static Efl.Gfx.ImageScaleType scale_type_get(System.IntPtr obj, System.IntPtr pd)
2231     {
2232         Eina.Log.Debug("function efl_gfx_image_scale_type_get was called");
2233         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2234         if(wrapper != null) {
2235                         Efl.Gfx.ImageScaleType _ret_var = default(Efl.Gfx.ImageScaleType);
2236             try {
2237                 _ret_var = ((ImageInternal)wrapper).GetScaleType();
2238             } catch (Exception e) {
2239                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2240                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2241             }
2242         return _ret_var;
2243         } else {
2244             return efl_gfx_image_scale_type_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2245         }
2246     }
2247     private static efl_gfx_image_scale_type_get_delegate efl_gfx_image_scale_type_get_static_delegate;
2248
2249
2250      private delegate void efl_gfx_image_scale_type_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Gfx.ImageScaleType scale_type);
2251
2252
2253      public delegate void efl_gfx_image_scale_type_set_api_delegate(System.IntPtr obj,   Efl.Gfx.ImageScaleType scale_type);
2254      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");
2255      private static void scale_type_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleType scale_type)
2256     {
2257         Eina.Log.Debug("function efl_gfx_image_scale_type_set was called");
2258         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2259         if(wrapper != null) {
2260
2261             try {
2262                 ((ImageInternal)wrapper).SetScaleType( scale_type);
2263             } catch (Exception e) {
2264                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2265                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2266             }
2267                                 } else {
2268             efl_gfx_image_scale_type_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  scale_type);
2269         }
2270     }
2271     private static efl_gfx_image_scale_type_set_delegate efl_gfx_image_scale_type_set_static_delegate;
2272
2273
2274      private delegate double efl_gfx_image_ratio_get_delegate(System.IntPtr obj, System.IntPtr pd);
2275
2276
2277      public delegate double efl_gfx_image_ratio_get_api_delegate(System.IntPtr obj);
2278      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");
2279      private static double ratio_get(System.IntPtr obj, System.IntPtr pd)
2280     {
2281         Eina.Log.Debug("function efl_gfx_image_ratio_get was called");
2282         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2283         if(wrapper != null) {
2284                         double _ret_var = default(double);
2285             try {
2286                 _ret_var = ((ImageInternal)wrapper).GetRatio();
2287             } catch (Exception e) {
2288                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2289                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2290             }
2291         return _ret_var;
2292         } else {
2293             return efl_gfx_image_ratio_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2294         }
2295     }
2296     private static efl_gfx_image_ratio_get_delegate efl_gfx_image_ratio_get_static_delegate;
2297
2298
2299      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);
2300
2301
2302      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);
2303      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");
2304      private static void border_get(System.IntPtr obj, System.IntPtr pd,  out int l,  out int r,  out int t,  out int b)
2305     {
2306         Eina.Log.Debug("function efl_gfx_image_border_get was called");
2307         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2308         if(wrapper != null) {
2309                                                     l = default(int);        r = default(int);        t = default(int);        b = default(int);
2310             try {
2311                 ((ImageInternal)wrapper).GetBorder( out l,  out r,  out t,  out b);
2312             } catch (Exception e) {
2313                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2314                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2315             }
2316                                                                                 } else {
2317             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);
2318         }
2319     }
2320     private static efl_gfx_image_border_get_delegate efl_gfx_image_border_get_static_delegate;
2321
2322
2323      private delegate void efl_gfx_image_border_set_delegate(System.IntPtr obj, System.IntPtr pd,   int l,   int r,   int t,   int b);
2324
2325
2326      public delegate void efl_gfx_image_border_set_api_delegate(System.IntPtr obj,   int l,   int r,   int t,   int b);
2327      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");
2328      private static void border_set(System.IntPtr obj, System.IntPtr pd,  int l,  int r,  int t,  int b)
2329     {
2330         Eina.Log.Debug("function efl_gfx_image_border_set was called");
2331         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2332         if(wrapper != null) {
2333
2334             try {
2335                 ((ImageInternal)wrapper).SetBorder( l,  r,  t,  b);
2336             } catch (Exception e) {
2337                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2338                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2339             }
2340                                                                                 } else {
2341             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);
2342         }
2343     }
2344     private static efl_gfx_image_border_set_delegate efl_gfx_image_border_set_static_delegate;
2345
2346
2347      private delegate double efl_gfx_image_border_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
2348
2349
2350      public delegate double efl_gfx_image_border_scale_get_api_delegate(System.IntPtr obj);
2351      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");
2352      private static double border_scale_get(System.IntPtr obj, System.IntPtr pd)
2353     {
2354         Eina.Log.Debug("function efl_gfx_image_border_scale_get was called");
2355         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2356         if(wrapper != null) {
2357                         double _ret_var = default(double);
2358             try {
2359                 _ret_var = ((ImageInternal)wrapper).GetBorderScale();
2360             } catch (Exception e) {
2361                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2362                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2363             }
2364         return _ret_var;
2365         } else {
2366             return efl_gfx_image_border_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2367         }
2368     }
2369     private static efl_gfx_image_border_scale_get_delegate efl_gfx_image_border_scale_get_static_delegate;
2370
2371
2372      private delegate void efl_gfx_image_border_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,   double scale);
2373
2374
2375      public delegate void efl_gfx_image_border_scale_set_api_delegate(System.IntPtr obj,   double scale);
2376      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");
2377      private static void border_scale_set(System.IntPtr obj, System.IntPtr pd,  double scale)
2378     {
2379         Eina.Log.Debug("function efl_gfx_image_border_scale_set was called");
2380         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2381         if(wrapper != null) {
2382
2383             try {
2384                 ((ImageInternal)wrapper).SetBorderScale( scale);
2385             } catch (Exception e) {
2386                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2387                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2388             }
2389                                 } else {
2390             efl_gfx_image_border_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  scale);
2391         }
2392     }
2393     private static efl_gfx_image_border_scale_set_delegate efl_gfx_image_border_scale_set_static_delegate;
2394
2395
2396      private delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
2397
2398
2399      public delegate Efl.Gfx.BorderFillMode efl_gfx_image_border_center_fill_get_api_delegate(System.IntPtr obj);
2400      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");
2401      private static Efl.Gfx.BorderFillMode border_center_fill_get(System.IntPtr obj, System.IntPtr pd)
2402     {
2403         Eina.Log.Debug("function efl_gfx_image_border_center_fill_get was called");
2404         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2405         if(wrapper != null) {
2406                         Efl.Gfx.BorderFillMode _ret_var = default(Efl.Gfx.BorderFillMode);
2407             try {
2408                 _ret_var = ((ImageInternal)wrapper).GetBorderCenterFill();
2409             } catch (Exception e) {
2410                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2411                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2412             }
2413         return _ret_var;
2414         } else {
2415             return efl_gfx_image_border_center_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2416         }
2417     }
2418     private static efl_gfx_image_border_center_fill_get_delegate efl_gfx_image_border_center_fill_get_static_delegate;
2419
2420
2421      private delegate void efl_gfx_image_border_center_fill_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Gfx.BorderFillMode fill);
2422
2423
2424      public delegate void efl_gfx_image_border_center_fill_set_api_delegate(System.IntPtr obj,   Efl.Gfx.BorderFillMode fill);
2425      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");
2426      private static void border_center_fill_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.BorderFillMode fill)
2427     {
2428         Eina.Log.Debug("function efl_gfx_image_border_center_fill_set was called");
2429         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2430         if(wrapper != null) {
2431
2432             try {
2433                 ((ImageInternal)wrapper).SetBorderCenterFill( fill);
2434             } catch (Exception e) {
2435                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2436                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2437             }
2438                                 } else {
2439             efl_gfx_image_border_center_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  fill);
2440         }
2441     }
2442     private static efl_gfx_image_border_center_fill_set_delegate efl_gfx_image_border_center_fill_set_static_delegate;
2443
2444
2445      private delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2446
2447
2448      public delegate Eina.Size2D.NativeStruct efl_gfx_image_size_get_api_delegate(System.IntPtr obj);
2449      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");
2450      private static Eina.Size2D.NativeStruct image_size_get(System.IntPtr obj, System.IntPtr pd)
2451     {
2452         Eina.Log.Debug("function efl_gfx_image_size_get was called");
2453         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2454         if(wrapper != null) {
2455                         Eina.Size2D _ret_var = default(Eina.Size2D);
2456             try {
2457                 _ret_var = ((ImageInternal)wrapper).GetImageSize();
2458             } catch (Exception e) {
2459                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2460                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2461             }
2462         return _ret_var;
2463         } else {
2464             return efl_gfx_image_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2465         }
2466     }
2467     private static efl_gfx_image_size_get_delegate efl_gfx_image_size_get_static_delegate;
2468
2469
2470      private delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
2471
2472
2473      public delegate Efl.Gfx.ImageContentHint efl_gfx_image_content_hint_get_api_delegate(System.IntPtr obj);
2474      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");
2475      private static Efl.Gfx.ImageContentHint content_hint_get(System.IntPtr obj, System.IntPtr pd)
2476     {
2477         Eina.Log.Debug("function efl_gfx_image_content_hint_get was called");
2478         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2479         if(wrapper != null) {
2480                         Efl.Gfx.ImageContentHint _ret_var = default(Efl.Gfx.ImageContentHint);
2481             try {
2482                 _ret_var = ((ImageInternal)wrapper).GetContentHint();
2483             } catch (Exception e) {
2484                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2485                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2486             }
2487         return _ret_var;
2488         } else {
2489             return efl_gfx_image_content_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2490         }
2491     }
2492     private static efl_gfx_image_content_hint_get_delegate efl_gfx_image_content_hint_get_static_delegate;
2493
2494
2495      private delegate void efl_gfx_image_content_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Gfx.ImageContentHint hint);
2496
2497
2498      public delegate void efl_gfx_image_content_hint_set_api_delegate(System.IntPtr obj,   Efl.Gfx.ImageContentHint hint);
2499      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");
2500      private static void content_hint_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageContentHint hint)
2501     {
2502         Eina.Log.Debug("function efl_gfx_image_content_hint_set was called");
2503         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2504         if(wrapper != null) {
2505
2506             try {
2507                 ((ImageInternal)wrapper).SetContentHint( hint);
2508             } catch (Exception e) {
2509                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2510                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2511             }
2512                                 } else {
2513             efl_gfx_image_content_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  hint);
2514         }
2515     }
2516     private static efl_gfx_image_content_hint_set_delegate efl_gfx_image_content_hint_set_static_delegate;
2517
2518
2519      private delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_delegate(System.IntPtr obj, System.IntPtr pd);
2520
2521
2522      public delegate Efl.Gfx.ImageScaleHint efl_gfx_image_scale_hint_get_api_delegate(System.IntPtr obj);
2523      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");
2524      private static Efl.Gfx.ImageScaleHint scale_hint_get(System.IntPtr obj, System.IntPtr pd)
2525     {
2526         Eina.Log.Debug("function efl_gfx_image_scale_hint_get was called");
2527         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2528         if(wrapper != null) {
2529                         Efl.Gfx.ImageScaleHint _ret_var = default(Efl.Gfx.ImageScaleHint);
2530             try {
2531                 _ret_var = ((ImageInternal)wrapper).GetScaleHint();
2532             } catch (Exception e) {
2533                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2534                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2535             }
2536         return _ret_var;
2537         } else {
2538             return efl_gfx_image_scale_hint_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2539         }
2540     }
2541     private static efl_gfx_image_scale_hint_get_delegate efl_gfx_image_scale_hint_get_static_delegate;
2542
2543
2544      private delegate void efl_gfx_image_scale_hint_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Gfx.ImageScaleHint hint);
2545
2546
2547      public delegate void efl_gfx_image_scale_hint_set_api_delegate(System.IntPtr obj,   Efl.Gfx.ImageScaleHint hint);
2548      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");
2549      private static void scale_hint_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.ImageScaleHint hint)
2550     {
2551         Eina.Log.Debug("function efl_gfx_image_scale_hint_set was called");
2552         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2553         if(wrapper != null) {
2554
2555             try {
2556                 ((ImageInternal)wrapper).SetScaleHint( hint);
2557             } catch (Exception e) {
2558                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2559                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2560             }
2561                                 } else {
2562             efl_gfx_image_scale_hint_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  hint);
2563         }
2564     }
2565     private static efl_gfx_image_scale_hint_set_delegate efl_gfx_image_scale_hint_set_static_delegate;
2566
2567
2568      private delegate Eina.Error efl_gfx_image_load_error_get_delegate(System.IntPtr obj, System.IntPtr pd);
2569
2570
2571      public delegate Eina.Error efl_gfx_image_load_error_get_api_delegate(System.IntPtr obj);
2572      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");
2573      private static Eina.Error image_load_error_get(System.IntPtr obj, System.IntPtr pd)
2574     {
2575         Eina.Log.Debug("function efl_gfx_image_load_error_get was called");
2576         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2577         if(wrapper != null) {
2578                         Eina.Error _ret_var = default(Eina.Error);
2579             try {
2580                 _ret_var = ((ImageInternal)wrapper).GetImageLoadError();
2581             } catch (Exception e) {
2582                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2583                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2584             }
2585         return _ret_var;
2586         } else {
2587             return efl_gfx_image_load_error_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2588         }
2589     }
2590     private static efl_gfx_image_load_error_get_delegate efl_gfx_image_load_error_get_static_delegate;
2591
2592
2593      private delegate Eina.Size2D.NativeStruct efl_gfx_view_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2594
2595
2596      public delegate Eina.Size2D.NativeStruct efl_gfx_view_size_get_api_delegate(System.IntPtr obj);
2597      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");
2598      private static Eina.Size2D.NativeStruct view_size_get(System.IntPtr obj, System.IntPtr pd)
2599     {
2600         Eina.Log.Debug("function efl_gfx_view_size_get was called");
2601         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2602         if(wrapper != null) {
2603                         Eina.Size2D _ret_var = default(Eina.Size2D);
2604             try {
2605                 _ret_var = ((ImageInternal)wrapper).GetViewSize();
2606             } catch (Exception e) {
2607                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2608                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2609             }
2610         return _ret_var;
2611         } else {
2612             return efl_gfx_view_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2613         }
2614     }
2615     private static efl_gfx_view_size_get_delegate efl_gfx_view_size_get_static_delegate;
2616
2617
2618      private delegate void efl_gfx_view_size_set_delegate(System.IntPtr obj, System.IntPtr pd,   Eina.Size2D.NativeStruct size);
2619
2620
2621      public delegate void efl_gfx_view_size_set_api_delegate(System.IntPtr obj,   Eina.Size2D.NativeStruct size);
2622      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");
2623      private static void view_size_set(System.IntPtr obj, System.IntPtr pd,  Eina.Size2D.NativeStruct size)
2624     {
2625         Eina.Log.Debug("function efl_gfx_view_size_set was called");
2626         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2627         if(wrapper != null) {
2628                     Eina.Size2D _in_size = size;
2629
2630             try {
2631                 ((ImageInternal)wrapper).SetViewSize( _in_size);
2632             } catch (Exception e) {
2633                 Eina.Log.Warning($"Callback error: {e.ToString()}");
2634                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2635             }
2636                                 } else {
2637             efl_gfx_view_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  size);
2638         }
2639     }
2640     private static efl_gfx_view_size_set_delegate efl_gfx_view_size_set_static_delegate;
2641 }
2642 } }