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