internals/src/EflSharp/EflSharp/efl_gfx_filter.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 Gfx {
   8 /// <summary>Graphical filters can be applied to any object implementing this interface.
   9 /// Filters are programmable effects that run whenever the object is rendered on its canvas. The program language is Lua and a complete reference can be found under &quot;EFL Graphics Filters&quot;.
  10 ///
  11 /// This was a beta feature since 1.15.
  12 /// 1.18</summary>
  13 [FilterNativeInherit]
  14 public interface Filter :
  15    Efl.Eo.IWrapper, IDisposable
  16 {
  17    /// <summary>Gets the code of the filter program set on this object. May be <c>null</c>.
  18 /// 1.18</summary>
  19 /// <param name="code">The Lua program source code.
  20 /// 1.18</param>
  21 /// <param name="name">An optional name for this filter.
  22 /// 1.18</param>
  23 /// <returns></returns>
  24  void GetFilterProgram( out  System.String code,  out  System.String name);
  25    /// <summary>Set a graphical filter program on this object.
  26 /// Valid for Text and Image objects at the moment.
  27 ///
  28 /// 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.
  29 ///
  30 /// Set to <c>null</c> to disable filtering.
  31 /// 1.18</summary>
  32 /// <param name="code">The Lua program source code.
  33 /// 1.18</param>
  34 /// <param name="name">An optional name for this filter.
  35 /// 1.18</param>
  36 /// <returns></returns>
  37  void SetFilterProgram(  System.String code,   System.String name);
  38    /// <summary>Set the current state of the filter.
  39 /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
  40 ///
  41 /// 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.
  42 /// 1.18</summary>
  43 /// <param name="cur_state">Current state of the filter
  44 /// 1.18</param>
  45 /// <param name="cur_val">Current value
  46 /// 1.18</param>
  47 /// <param name="next_state">Next filter state, optional
  48 /// 1.18</param>
  49 /// <param name="next_val">Next value, optional
  50 /// 1.18</param>
  51 /// <param name="pos">Position, optional
  52 /// 1.18</param>
  53 /// <returns></returns>
  54  void GetFilterState( out  System.String cur_state,  out double cur_val,  out  System.String next_state,  out double next_val,  out double pos);
  55    /// <summary>Set the current state of the filter.
  56 /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
  57 ///
  58 /// 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.
  59 /// 1.18</summary>
  60 /// <param name="cur_state">Current state of the filter
  61 /// 1.18</param>
  62 /// <param name="cur_val">Current value
  63 /// 1.18</param>
  64 /// <param name="next_state">Next filter state, optional
  65 /// 1.18</param>
  66 /// <param name="next_val">Next value, optional
  67 /// 1.18</param>
  68 /// <param name="pos">Position, optional
  69 /// 1.18</param>
  70 /// <returns></returns>
  71  void SetFilterState(  System.String cur_state,  double cur_val,   System.String next_state,  double next_val,  double pos);
  72    /// <summary>Gets the padding required to apply this filter.
  73 /// 1.18</summary>
  74 /// <param name="l">Padding on the left
  75 /// 1.18</param>
  76 /// <param name="r">Padding on the right
  77 /// 1.18</param>
  78 /// <param name="t">Padding on the top
  79 /// 1.18</param>
  80 /// <param name="b">Padding on the bottom
  81 /// 1.18</param>
  82 /// <returns></returns>
  83  void GetFilterPadding( out  int l,  out  int r,  out  int t,  out  int b);
  84    /// <summary>Bind an object to use as a mask or texture in a filter program.
  85 /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).
  86 /// 1.18</summary>
  87 /// <param name="name">Buffer name as used in the program.
  88 /// 1.18</param>
  89 /// <returns>Object to use as a source of pixels.
  90 /// 1.18</returns>
  91 Efl.Gfx.Entity GetFilterSource(  System.String name);
  92    /// <summary>Bind an object to use as a mask or texture in a filter program.
  93 /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).
  94 /// 1.18</summary>
  95 /// <param name="name">Buffer name as used in the program.
  96 /// 1.18</param>
  97 /// <param name="source">Object to use as a source of pixels.
  98 /// 1.18</param>
  99 /// <returns></returns>
 100  void SetFilterSource(  System.String name,  Efl.Gfx.Entity source);
 101    /// <summary>Extra data used by the filter program.
 102 /// 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...
 103 ///
 104 /// 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.
 105 /// 1.18</summary>
 106 /// <param name="name">Name of the global variable
 107 /// 1.18</param>
 108 /// <param name="value">String value to use as data
 109 /// 1.18</param>
 110 /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;
 111 /// 1.18</param>
 112 /// <returns></returns>
 113  void GetFilterData(  System.String name,  out  System.String value,  out bool execute);
 114    /// <summary>Extra data used by the filter program.
 115 /// 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...
 116 ///
 117 /// 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.
 118 /// 1.18</summary>
 119 /// <param name="name">Name of the global variable
 120 /// 1.18</param>
 121 /// <param name="value">String value to use as data
 122 /// 1.18</param>
 123 /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;
 124 /// 1.18</param>
 125 /// <returns></returns>
 126  void SetFilterData(  System.String name,   System.String value,  bool execute);
 127                            }
 128 /// <summary>Graphical filters can be applied to any object implementing this interface.
 129 /// Filters are programmable effects that run whenever the object is rendered on its canvas. The program language is Lua and a complete reference can be found under &quot;EFL Graphics Filters&quot;.
 130 ///
 131 /// This was a beta feature since 1.15.
 132 /// 1.18</summary>
 133 sealed public class FilterConcrete :
 134
 135 Filter
 136
 137 {
 138    ///<summary>Pointer to the native class description.</summary>
 139    public System.IntPtr NativeClass {
 140       get {
 141          if (((object)this).GetType() == typeof (FilterConcrete))
 142             return Efl.Gfx.FilterNativeInherit.GetEflClassStatic();
 143          else
 144             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 145       }
 146    }
 147    private  System.IntPtr handle;
 148    ///<summary>Pointer to the native instance.</summary>
 149    public System.IntPtr NativeHandle {
 150       get { return handle; }
 151    }
 152    [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 153       efl_gfx_filter_interface_get();
 154    ///<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>
 155    public FilterConcrete(System.IntPtr raw)
 156    {
 157       handle = raw;
 158       register_event_proxies();
 159    }
 160    ///<summary>Destructor.</summary>
 161    ~FilterConcrete()
 162    {
 163       Dispose(false);
 164    }
 165    ///<summary>Releases the underlying native instance.</summary>
 166    void Dispose(bool disposing)
 167    {
 168       if (handle != System.IntPtr.Zero) {
 169          Efl.Eo.Globals.efl_unref(handle);
 170          handle = System.IntPtr.Zero;
 171       }
 172    }
 173    ///<summary>Releases the underlying native instance.</summary>
 174    public void Dispose()
 175    {
 176       Dispose(true);
 177       GC.SuppressFinalize(this);
 178    }
 179    ///<summary>Casts obj into an instance of this type.</summary>
 180    public static FilterConcrete static_cast(Efl.Object obj)
 181    {
 182       if (obj == null)
 183          throw new System.ArgumentNullException("obj");
 184       return new FilterConcrete(obj.NativeHandle);
 185    }
 186    ///<summary>Verifies if the given object is equal to this one.</summary>
 187    public override bool Equals(object obj)
 188    {
 189       var other = obj as Efl.Object;
 190       if (other == null)
 191          return false;
 192       return this.NativeHandle == other.NativeHandle;
 193    }
 194    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 195    public override int GetHashCode()
 196    {
 197       return this.NativeHandle.ToInt32();
 198    }
 199    ///<summary>Turns the native pointer into a string representation.</summary>
 200    public override String ToString()
 201    {
 202       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 203    }
 204     void register_event_proxies()
 205    {
 206    }
 207    /// <summary>Gets the code of the filter program set on this object. May be <c>null</c>.
 208    /// 1.18</summary>
 209    /// <param name="code">The Lua program source code.
 210    /// 1.18</param>
 211    /// <param name="name">An optional name for this filter.
 212    /// 1.18</param>
 213    /// <returns></returns>
 214    public  void GetFilterProgram( out  System.String code,  out  System.String name) {
 215                                            Efl.Gfx.FilterNativeInherit.efl_gfx_filter_program_get_ptr.Value.Delegate(this.NativeHandle, out code,  out name);
 216       Eina.Error.RaiseIfUnhandledException();
 217                                }
 218    /// <summary>Set a graphical filter program on this object.
 219    /// Valid for Text and Image objects at the moment.
 220    ///
 221    /// 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.
 222    ///
 223    /// Set to <c>null</c> to disable filtering.
 224    /// 1.18</summary>
 225    /// <param name="code">The Lua program source code.
 226    /// 1.18</param>
 227    /// <param name="name">An optional name for this filter.
 228    /// 1.18</param>
 229    /// <returns></returns>
 230    public  void SetFilterProgram(  System.String code,   System.String name) {
 231                                            Efl.Gfx.FilterNativeInherit.efl_gfx_filter_program_set_ptr.Value.Delegate(this.NativeHandle, code,  name);
 232       Eina.Error.RaiseIfUnhandledException();
 233                                }
 234    /// <summary>Set the current state of the filter.
 235    /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 236    ///
 237    /// 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.
 238    /// 1.18</summary>
 239    /// <param name="cur_state">Current state of the filter
 240    /// 1.18</param>
 241    /// <param name="cur_val">Current value
 242    /// 1.18</param>
 243    /// <param name="next_state">Next filter state, optional
 244    /// 1.18</param>
 245    /// <param name="next_val">Next value, optional
 246    /// 1.18</param>
 247    /// <param name="pos">Position, optional
 248    /// 1.18</param>
 249    /// <returns></returns>
 250    public  void GetFilterState( out  System.String cur_state,  out double cur_val,  out  System.String next_state,  out double next_val,  out double pos) {
 251                                                                                                  Efl.Gfx.FilterNativeInherit.efl_gfx_filter_state_get_ptr.Value.Delegate(this.NativeHandle, out cur_state,  out cur_val,  out next_state,  out next_val,  out pos);
 252       Eina.Error.RaiseIfUnhandledException();
 253                                                                    }
 254    /// <summary>Set the current state of the filter.
 255    /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 256    ///
 257    /// 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.
 258    /// 1.18</summary>
 259    /// <param name="cur_state">Current state of the filter
 260    /// 1.18</param>
 261    /// <param name="cur_val">Current value
 262    /// 1.18</param>
 263    /// <param name="next_state">Next filter state, optional
 264    /// 1.18</param>
 265    /// <param name="next_val">Next value, optional
 266    /// 1.18</param>
 267    /// <param name="pos">Position, optional
 268    /// 1.18</param>
 269    /// <returns></returns>
 270    public  void SetFilterState(  System.String cur_state,  double cur_val,   System.String next_state,  double next_val,  double pos) {
 271                                                                                                  Efl.Gfx.FilterNativeInherit.efl_gfx_filter_state_set_ptr.Value.Delegate(this.NativeHandle, cur_state,  cur_val,  next_state,  next_val,  pos);
 272       Eina.Error.RaiseIfUnhandledException();
 273                                                                    }
 274    /// <summary>Gets the padding required to apply this filter.
 275    /// 1.18</summary>
 276    /// <param name="l">Padding on the left
 277    /// 1.18</param>
 278    /// <param name="r">Padding on the right
 279    /// 1.18</param>
 280    /// <param name="t">Padding on the top
 281    /// 1.18</param>
 282    /// <param name="b">Padding on the bottom
 283    /// 1.18</param>
 284    /// <returns></returns>
 285    public  void GetFilterPadding( out  int l,  out  int r,  out  int t,  out  int b) {
 286                                                                                Efl.Gfx.FilterNativeInherit.efl_gfx_filter_padding_get_ptr.Value.Delegate(this.NativeHandle, out l,  out r,  out t,  out b);
 287       Eina.Error.RaiseIfUnhandledException();
 288                                                        }
 289    /// <summary>Bind an object to use as a mask or texture in a filter program.
 290    /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).
 291    /// 1.18</summary>
 292    /// <param name="name">Buffer name as used in the program.
 293    /// 1.18</param>
 294    /// <returns>Object to use as a source of pixels.
 295    /// 1.18</returns>
 296    public Efl.Gfx.Entity GetFilterSource(  System.String name) {
 297                          var _ret_var = Efl.Gfx.FilterNativeInherit.efl_gfx_filter_source_get_ptr.Value.Delegate(this.NativeHandle, name);
 298       Eina.Error.RaiseIfUnhandledException();
 299                   return _ret_var;
 300  }
 301    /// <summary>Bind an object to use as a mask or texture in a filter program.
 302    /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).
 303    /// 1.18</summary>
 304    /// <param name="name">Buffer name as used in the program.
 305    /// 1.18</param>
 306    /// <param name="source">Object to use as a source of pixels.
 307    /// 1.18</param>
 308    /// <returns></returns>
 309    public  void SetFilterSource(  System.String name,  Efl.Gfx.Entity source) {
 310                                            Efl.Gfx.FilterNativeInherit.efl_gfx_filter_source_set_ptr.Value.Delegate(this.NativeHandle, name,  source);
 311       Eina.Error.RaiseIfUnhandledException();
 312                                }
 313    /// <summary>Extra data used by the filter program.
 314    /// 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...
 315    ///
 316    /// 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.
 317    /// 1.18</summary>
 318    /// <param name="name">Name of the global variable
 319    /// 1.18</param>
 320    /// <param name="value">String value to use as data
 321    /// 1.18</param>
 322    /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;
 323    /// 1.18</param>
 324    /// <returns></returns>
 325    public  void GetFilterData(  System.String name,  out  System.String value,  out bool execute) {
 326                                                              Efl.Gfx.FilterNativeInherit.efl_gfx_filter_data_get_ptr.Value.Delegate(this.NativeHandle, name,  out value,  out execute);
 327       Eina.Error.RaiseIfUnhandledException();
 328                                            }
 329    /// <summary>Extra data used by the filter program.
 330    /// 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...
 331    ///
 332    /// 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.
 333    /// 1.18</summary>
 334    /// <param name="name">Name of the global variable
 335    /// 1.18</param>
 336    /// <param name="value">String value to use as data
 337    /// 1.18</param>
 338    /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;
 339    /// 1.18</param>
 340    /// <returns></returns>
 341    public  void SetFilterData(  System.String name,   System.String value,  bool execute) {
 342                                                              Efl.Gfx.FilterNativeInherit.efl_gfx_filter_data_set_ptr.Value.Delegate(this.NativeHandle, name,  value,  execute);
 343       Eina.Error.RaiseIfUnhandledException();
 344                                            }
 345 }
 346 public class FilterNativeInherit  : Efl.Eo.NativeClass{
 347    public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 348    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 349    {
 350       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 351       if (efl_gfx_filter_program_get_static_delegate == null)
 352       efl_gfx_filter_program_get_static_delegate = new efl_gfx_filter_program_get_delegate(filter_program_get);
 353       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)});
 354       if (efl_gfx_filter_program_set_static_delegate == null)
 355       efl_gfx_filter_program_set_static_delegate = new efl_gfx_filter_program_set_delegate(filter_program_set);
 356       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)});
 357       if (efl_gfx_filter_state_get_static_delegate == null)
 358       efl_gfx_filter_state_get_static_delegate = new efl_gfx_filter_state_get_delegate(filter_state_get);
 359       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)});
 360       if (efl_gfx_filter_state_set_static_delegate == null)
 361       efl_gfx_filter_state_set_static_delegate = new efl_gfx_filter_state_set_delegate(filter_state_set);
 362       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)});
 363       if (efl_gfx_filter_padding_get_static_delegate == null)
 364       efl_gfx_filter_padding_get_static_delegate = new efl_gfx_filter_padding_get_delegate(filter_padding_get);
 365       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)});
 366       if (efl_gfx_filter_source_get_static_delegate == null)
 367       efl_gfx_filter_source_get_static_delegate = new efl_gfx_filter_source_get_delegate(filter_source_get);
 368       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)});
 369       if (efl_gfx_filter_source_set_static_delegate == null)
 370       efl_gfx_filter_source_set_static_delegate = new efl_gfx_filter_source_set_delegate(filter_source_set);
 371       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)});
 372       if (efl_gfx_filter_data_get_static_delegate == null)
 373       efl_gfx_filter_data_get_static_delegate = new efl_gfx_filter_data_get_delegate(filter_data_get);
 374       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)});
 375       if (efl_gfx_filter_data_set_static_delegate == null)
 376       efl_gfx_filter_data_set_static_delegate = new efl_gfx_filter_data_set_delegate(filter_data_set);
 377       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)});
 378       return descs;
 379    }
 380    public override IntPtr GetEflClass()
 381    {
 382       return Efl.Gfx.FilterConcrete.efl_gfx_filter_interface_get();
 383    }
 384    public static  IntPtr GetEflClassStatic()
 385    {
 386       return Efl.Gfx.FilterConcrete.efl_gfx_filter_interface_get();
 387    }
 388
 389
 390     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);
 391
 392
 393     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);
 394     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");
 395     private static  void filter_program_get(System.IntPtr obj, System.IntPtr pd,  out  System.String code,  out  System.String name)
 396    {
 397       Eina.Log.Debug("function efl_gfx_filter_program_get was called");
 398       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 399       if(wrapper != null) {
 400                             System.String _out_code = default( System.String);
 401        System.String _out_name = default( System.String);
 402
 403          try {
 404             ((Filter)wrapper).GetFilterProgram( out _out_code,  out _out_name);
 405          } catch (Exception e) {
 406             Eina.Log.Warning($"Callback error: {e.ToString()}");
 407             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 408          }
 409       code = _out_code;
 410       name = _out_name;
 411                         } else {
 412          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);
 413       }
 414    }
 415    private static efl_gfx_filter_program_get_delegate efl_gfx_filter_program_get_static_delegate;
 416
 417
 418     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);
 419
 420
 421     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);
 422     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");
 423     private static  void filter_program_set(System.IntPtr obj, System.IntPtr pd,   System.String code,   System.String name)
 424    {
 425       Eina.Log.Debug("function efl_gfx_filter_program_set was called");
 426       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 427       if(wrapper != null) {
 428
 429          try {
 430             ((Filter)wrapper).SetFilterProgram( code,  name);
 431          } catch (Exception e) {
 432             Eina.Log.Warning($"Callback error: {e.ToString()}");
 433             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 434          }
 435                                     } else {
 436          efl_gfx_filter_program_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  code,  name);
 437       }
 438    }
 439    private static efl_gfx_filter_program_set_delegate efl_gfx_filter_program_set_static_delegate;
 440
 441
 442     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);
 443
 444
 445     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);
 446     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");
 447     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)
 448    {
 449       Eina.Log.Debug("function efl_gfx_filter_state_get was called");
 450       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 451       if(wrapper != null) {
 452                                               System.String _out_cur_state = default( System.String);
 453       cur_val = default(double);       System.String _out_next_state = default( System.String);
 454       next_val = default(double);      pos = default(double);
 455          try {
 456             ((Filter)wrapper).GetFilterState( out _out_cur_state,  out cur_val,  out _out_next_state,  out next_val,  out pos);
 457          } catch (Exception e) {
 458             Eina.Log.Warning($"Callback error: {e.ToString()}");
 459             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 460          }
 461       cur_state = _out_cur_state;
 462             next_state = _out_next_state;
 463                                                       } else {
 464          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);
 465       }
 466    }
 467    private static efl_gfx_filter_state_get_delegate efl_gfx_filter_state_get_static_delegate;
 468
 469
 470     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);
 471
 472
 473     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);
 474     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");
 475     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)
 476    {
 477       Eina.Log.Debug("function efl_gfx_filter_state_set was called");
 478       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 479       if(wrapper != null) {
 480
 481          try {
 482             ((Filter)wrapper).SetFilterState( cur_state,  cur_val,  next_state,  next_val,  pos);
 483          } catch (Exception e) {
 484             Eina.Log.Warning($"Callback error: {e.ToString()}");
 485             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 486          }
 487                                                                         } else {
 488          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);
 489       }
 490    }
 491    private static efl_gfx_filter_state_set_delegate efl_gfx_filter_state_set_static_delegate;
 492
 493
 494     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);
 495
 496
 497     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);
 498     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");
 499     private static  void filter_padding_get(System.IntPtr obj, System.IntPtr pd,  out  int l,  out  int r,  out  int t,  out  int b)
 500    {
 501       Eina.Log.Debug("function efl_gfx_filter_padding_get was called");
 502       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 503       if(wrapper != null) {
 504                                        l = default( int);      r = default( int);      t = default( int);      b = default( int);
 505          try {
 506             ((Filter)wrapper).GetFilterPadding( out l,  out r,  out t,  out b);
 507          } catch (Exception e) {
 508             Eina.Log.Warning($"Callback error: {e.ToString()}");
 509             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 510          }
 511                                                             } else {
 512          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);
 513       }
 514    }
 515    private static efl_gfx_filter_padding_get_delegate efl_gfx_filter_padding_get_static_delegate;
 516
 517
 518    [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);
 519
 520
 521    [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);
 522     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");
 523     private static Efl.Gfx.Entity filter_source_get(System.IntPtr obj, System.IntPtr pd,   System.String name)
 524    {
 525       Eina.Log.Debug("function efl_gfx_filter_source_get was called");
 526       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 527       if(wrapper != null) {
 528                                     Efl.Gfx.Entity _ret_var = default(Efl.Gfx.Entity);
 529          try {
 530             _ret_var = ((Filter)wrapper).GetFilterSource( name);
 531          } catch (Exception e) {
 532             Eina.Log.Warning($"Callback error: {e.ToString()}");
 533             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 534          }
 535                   return _ret_var;
 536       } else {
 537          return efl_gfx_filter_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name);
 538       }
 539    }
 540    private static efl_gfx_filter_source_get_delegate efl_gfx_filter_source_get_static_delegate;
 541
 542
 543     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);
 544
 545
 546     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);
 547     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");
 548     private static  void filter_source_set(System.IntPtr obj, System.IntPtr pd,   System.String name,  Efl.Gfx.Entity source)
 549    {
 550       Eina.Log.Debug("function efl_gfx_filter_source_set was called");
 551       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 552       if(wrapper != null) {
 553
 554          try {
 555             ((Filter)wrapper).SetFilterSource( name,  source);
 556          } catch (Exception e) {
 557             Eina.Log.Warning($"Callback error: {e.ToString()}");
 558             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 559          }
 560                                     } else {
 561          efl_gfx_filter_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name,  source);
 562       }
 563    }
 564    private static efl_gfx_filter_source_set_delegate efl_gfx_filter_source_set_static_delegate;
 565
 566
 567     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);
 568
 569
 570     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);
 571     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");
 572     private static  void filter_data_get(System.IntPtr obj, System.IntPtr pd,   System.String name,  out  System.String value,  out bool execute)
 573    {
 574       Eina.Log.Debug("function efl_gfx_filter_data_get was called");
 575       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 576       if(wrapper != null) {
 577                                         System.String _out_value = default( System.String);
 578       execute = default(bool);
 579          try {
 580             ((Filter)wrapper).GetFilterData( name,  out _out_value,  out execute);
 581          } catch (Exception e) {
 582             Eina.Log.Warning($"Callback error: {e.ToString()}");
 583             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 584          }
 585             value = _out_value;
 586                                     } else {
 587          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);
 588       }
 589    }
 590    private static efl_gfx_filter_data_get_delegate efl_gfx_filter_data_get_static_delegate;
 591
 592
 593     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);
 594
 595
 596     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);
 597     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");
 598     private static  void filter_data_set(System.IntPtr obj, System.IntPtr pd,   System.String name,   System.String value,  bool execute)
 599    {
 600       Eina.Log.Debug("function efl_gfx_filter_data_set was called");
 601       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 602       if(wrapper != null) {
 603
 604          try {
 605             ((Filter)wrapper).SetFilterData( name,  value,  execute);
 606          } catch (Exception e) {
 607             Eina.Log.Warning($"Callback error: {e.ToString()}");
 608             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 609          }
 610                                                 } else {
 611          efl_gfx_filter_data_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  name,  value,  execute);
 612       }
 613    }
 614    private static efl_gfx_filter_data_set_delegate efl_gfx_filter_data_set_static_delegate;
 615 }
 616 } }