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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 namespace Filter {
  13
  14 /// <summary>Evas internal implementation of filters.</summary>
  15 [Efl.Canvas.Filter.IInternalConcrete.NativeMethods]
  16 public interface IInternal :
  17     Efl.Gfx.IFilter ,
  18     Efl.Eo.IWrapper, IDisposable
  19 {
  20     /// <summary>Marks this filter as changed.</summary>
  21 /// <param name="val"><c>true</c> if filter changed, <c>false</c> otherwise</param>
  22 void SetFilterChanged(bool val);
  23     /// <summary>Marks this filter as invalid.</summary>
  24 /// <param name="val"><c>true</c> if filter is invalid, <c>false</c> otherwise</param>
  25 void SetFilterInvalid(bool val);
  26     /// <summary>Retrieve cached output buffer, if any.
  27 /// Does not increment the reference count.</summary>
  28 /// <returns>Output buffer</returns>
  29 System.IntPtr GetFilterOutputBuffer();
  30     /// <summary>Called by Efl.Canvas.Filter.Internal to determine whether the input is alpha or rgba.</summary>
  31 /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
  32 bool FilterInputAlpha();
  33     /// <summary>Called by Efl.Canvas.Filter.Internal to request the parent class for state information (color, etc...).</summary>
  34 /// <param name="state">State info to fill in</param>
  35 /// <param name="data">Private data for the class</param>
  36 void FilterStatePrepare(out Efl.Canvas.Filter.State state, System.IntPtr data);
  37     /// <summary>Called by Efl.Canvas.Filter.Internal when the parent class must render the input.</summary>
  38 /// <param name="filter">Current filter context</param>
  39 /// <param name="engine">Engine context</param>
  40 /// <param name="output">Output context</param>
  41 /// <param name="drawctx">Draw context (for evas engine)</param>
  42 /// <param name="data">Private data used by textblock</param>
  43 /// <param name="l">Left</param>
  44 /// <param name="r">Right</param>
  45 /// <param name="t">Top</param>
  46 /// <param name="b">Bottom</param>
  47 /// <param name="x">X offset</param>
  48 /// <param name="y">Y offset</param>
  49 /// <param name="do_async"><c>true</c> when the operation should be done asynchronously, <c>false</c> otherwise</param>
  50 /// <returns>Indicates success from the object render function.</returns>
  51 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);
  52     /// <summary>Called when filter changes must trigger a redraw of the object.
  53 /// Virtual, to be implemented in the parent class.</summary>
  54 void FilterDirty();
  55                                 /// <summary>Marks this filter as changed.</summary>
  56 /// <value><c>true</c> if filter changed, <c>false</c> otherwise</value>
  57     bool FilterChanged {
  58         set ;
  59     }
  60     /// <summary>Marks this filter as invalid.</summary>
  61 /// <value><c>true</c> if filter is invalid, <c>false</c> otherwise</value>
  62     bool FilterInvalid {
  63         set ;
  64     }
  65     /// <summary>Retrieve cached output buffer, if any.
  66 /// Does not increment the reference count.</summary>
  67 /// <value>Output buffer</value>
  68     System.IntPtr FilterOutputBuffer {
  69         get ;
  70     }
  71 }
  72 /// <summary>Evas internal implementation of filters.</summary>
  73 sealed public class IInternalConcrete :
  74
  75 IInternal
  76     , Efl.Gfx.IFilter
  77 {
  78     ///<summary>Pointer to the native class description.</summary>
  79     public System.IntPtr NativeClass
  80     {
  81         get
  82         {
  83             if (((object)this).GetType() == typeof(IInternalConcrete))
  84             {
  85                 return GetEflClassStatic();
  86             }
  87             else
  88             {
  89                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  90             }
  91         }
  92     }
  93
  94     private  System.IntPtr handle;
  95     ///<summary>Pointer to the native instance.</summary>
  96     public System.IntPtr NativeHandle
  97     {
  98         get { return handle; }
  99     }
 100
 101     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
 102         efl_canvas_filter_internal_mixin_get();
 103     /// <summary>Initializes a new instance of the <see cref="IInternal"/> class.
 104     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 105     private IInternalConcrete(System.IntPtr raw)
 106     {
 107         handle = raw;
 108     }
 109     ///<summary>Destructor.</summary>
 110     ~IInternalConcrete()
 111     {
 112         Dispose(false);
 113     }
 114
 115     ///<summary>Releases the underlying native instance.</summary>
 116     private void Dispose(bool disposing)
 117     {
 118         if (handle != System.IntPtr.Zero)
 119         {
 120             IntPtr h = handle;
 121             handle = IntPtr.Zero;
 122
 123             IntPtr gcHandlePtr = IntPtr.Zero;
 124             if (disposing)
 125             {
 126                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 127             }
 128             else
 129             {
 130                 Monitor.Enter(Efl.All.InitLock);
 131                 if (Efl.All.MainLoopInitialized)
 132                 {
 133                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 134                 }
 135
 136                 Monitor.Exit(Efl.All.InitLock);
 137             }
 138         }
 139
 140     }
 141
 142     ///<summary>Releases the underlying native instance.</summary>
 143     public void Dispose()
 144     {
 145         Dispose(true);
 146         GC.SuppressFinalize(this);
 147     }
 148
 149     /// <summary>Verifies if the given object is equal to this one.</summary>
 150     /// <param name="instance">The object to compare to.</param>
 151     /// <returns>True if both objects point to the same native object.</returns>
 152     public override bool Equals(object instance)
 153     {
 154         var other = instance as Efl.Object;
 155         if (other == null)
 156         {
 157             return false;
 158         }
 159         return this.NativeHandle == other.NativeHandle;
 160     }
 161
 162     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 163     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 164     public override int GetHashCode()
 165     {
 166         return this.NativeHandle.ToInt32();
 167     }
 168
 169     /// <summary>Turns the native pointer into a string representation.</summary>
 170     /// <returns>A string with the type and the native pointer for this object.</returns>
 171     public override String ToString()
 172     {
 173         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 174     }
 175
 176     /// <summary>Marks this filter as changed.</summary>
 177     /// <param name="val"><c>true</c> if filter changed, <c>false</c> otherwise</param>
 178     public void SetFilterChanged(bool val) {
 179                                  Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_changed_set_ptr.Value.Delegate(this.NativeHandle,val);
 180         Eina.Error.RaiseIfUnhandledException();
 181                          }
 182     /// <summary>Marks this filter as invalid.</summary>
 183     /// <param name="val"><c>true</c> if filter is invalid, <c>false</c> otherwise</param>
 184     public void SetFilterInvalid(bool val) {
 185                                  Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_invalid_set_ptr.Value.Delegate(this.NativeHandle,val);
 186         Eina.Error.RaiseIfUnhandledException();
 187                          }
 188     /// <summary>Retrieve cached output buffer, if any.
 189     /// Does not increment the reference count.</summary>
 190     /// <returns>Output buffer</returns>
 191     public System.IntPtr GetFilterOutputBuffer() {
 192          var _ret_var = Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_output_buffer_get_ptr.Value.Delegate(this.NativeHandle);
 193         Eina.Error.RaiseIfUnhandledException();
 194         return _ret_var;
 195  }
 196     /// <summary>Called by Efl.Canvas.Filter.Internal to determine whether the input is alpha or rgba.</summary>
 197     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 198     public bool FilterInputAlpha() {
 199          var _ret_var = Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_input_alpha_ptr.Value.Delegate(this.NativeHandle);
 200         Eina.Error.RaiseIfUnhandledException();
 201         return _ret_var;
 202  }
 203     /// <summary>Called by Efl.Canvas.Filter.Internal to request the parent class for state information (color, etc...).</summary>
 204     /// <param name="state">State info to fill in</param>
 205     /// <param name="data">Private data for the class</param>
 206     public void FilterStatePrepare(out Efl.Canvas.Filter.State state, System.IntPtr data) {
 207                          var _out_state = new Efl.Canvas.Filter.State.NativeStruct();
 208                                 Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_state_prepare_ptr.Value.Delegate(this.NativeHandle,out _out_state, data);
 209         Eina.Error.RaiseIfUnhandledException();
 210         state = _out_state;
 211                                  }
 212     /// <summary>Called by Efl.Canvas.Filter.Internal when the parent class must render the input.</summary>
 213     /// <param name="filter">Current filter context</param>
 214     /// <param name="engine">Engine context</param>
 215     /// <param name="output">Output context</param>
 216     /// <param name="drawctx">Draw context (for evas engine)</param>
 217     /// <param name="data">Private data used by textblock</param>
 218     /// <param name="l">Left</param>
 219     /// <param name="r">Right</param>
 220     /// <param name="t">Top</param>
 221     /// <param name="b">Bottom</param>
 222     /// <param name="x">X offset</param>
 223     /// <param name="y">Y offset</param>
 224     /// <param name="do_async"><c>true</c> when the operation should be done asynchronously, <c>false</c> otherwise</param>
 225     /// <returns>Indicates success from the object render function.</returns>
 226     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) {
 227                                                                                                                                                                                                                                                                                                          var _ret_var = Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_input_render_ptr.Value.Delegate(this.NativeHandle,filter, engine, output, drawctx, data, l, r, t, b, x, y, do_async);
 228         Eina.Error.RaiseIfUnhandledException();
 229                                                                                                                                                                                                         return _ret_var;
 230  }
 231     /// <summary>Called when filter changes must trigger a redraw of the object.
 232     /// Virtual, to be implemented in the parent class.</summary>
 233     public void FilterDirty() {
 234          Efl.Canvas.Filter.IInternalConcrete.NativeMethods.evas_filter_dirty_ptr.Value.Delegate(this.NativeHandle);
 235         Eina.Error.RaiseIfUnhandledException();
 236          }
 237     /// <summary>Gets the code of the filter program set on this object. May be <c>null</c>.</summary>
 238     /// <param name="code">The Lua program source code.</param>
 239     /// <param name="name">An optional name for this filter.</param>
 240     public void GetFilterProgram(out System.String code, out System.String name) {
 241                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_program_get_ptr.Value.Delegate(this.NativeHandle,out code, out name);
 242         Eina.Error.RaiseIfUnhandledException();
 243                                          }
 244     /// <summary>Set a graphical filter program on this object.
 245     /// Valid for Text and Image objects at the moment.
 246     ///
 247     /// 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.
 248     ///
 249     /// Set to <c>null</c> to disable filtering.</summary>
 250     /// <param name="code">The Lua program source code.</param>
 251     /// <param name="name">An optional name for this filter.</param>
 252     public void SetFilterProgram(System.String code, System.String name) {
 253                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_program_set_ptr.Value.Delegate(this.NativeHandle,code, name);
 254         Eina.Error.RaiseIfUnhandledException();
 255                                          }
 256     /// <summary>Set the current state of the filter.
 257     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 258     ///
 259     /// A full state is defined by two states (name + value): origin state and target state of an ongoing animation, as well as the <c>pos</c> progress (from 0 to 1) of that animation timeline. The second state can be omitted if there is no ongoing animation.</summary>
 260     /// <param name="cur_state">Current state of the filter</param>
 261     /// <param name="cur_val">Current value</param>
 262     /// <param name="next_state">Next filter state, optional</param>
 263     /// <param name="next_val">Next value, optional</param>
 264     /// <param name="pos">Position, optional</param>
 265     public void GetFilterState(out System.String cur_state, out double cur_val, out System.String next_state, out double next_val, out double pos) {
 266                                                                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_state_get_ptr.Value.Delegate(this.NativeHandle,out cur_state, out cur_val, out next_state, out next_val, out pos);
 267         Eina.Error.RaiseIfUnhandledException();
 268                                                                                          }
 269     /// <summary>Set the current state of the filter.
 270     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 271     ///
 272     /// A full state is defined by two states (name + value): origin state and target state of an ongoing animation, as well as the <c>pos</c> progress (from 0 to 1) of that animation timeline. The second state can be omitted if there is no ongoing animation.</summary>
 273     /// <param name="cur_state">Current state of the filter</param>
 274     /// <param name="cur_val">Current value</param>
 275     /// <param name="next_state">Next filter state, optional</param>
 276     /// <param name="next_val">Next value, optional</param>
 277     /// <param name="pos">Position, optional</param>
 278     public void SetFilterState(System.String cur_state, double cur_val, System.String next_state, double next_val, double pos) {
 279                                                                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_state_set_ptr.Value.Delegate(this.NativeHandle,cur_state, cur_val, next_state, next_val, pos);
 280         Eina.Error.RaiseIfUnhandledException();
 281                                                                                          }
 282     /// <summary>Gets the padding required to apply this filter.</summary>
 283     /// <param name="l">Padding on the left</param>
 284     /// <param name="r">Padding on the right</param>
 285     /// <param name="t">Padding on the top</param>
 286     /// <param name="b">Padding on the bottom</param>
 287     public void GetFilterPadding(out int l, out int r, out int t, out int b) {
 288                                                                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_padding_get_ptr.Value.Delegate(this.NativeHandle,out l, out r, out t, out b);
 289         Eina.Error.RaiseIfUnhandledException();
 290                                                                          }
 291     /// <summary>Bind an object to use as a mask or texture in a filter program.
 292     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 293     /// <param name="name">Buffer name as used in the program.</param>
 294     /// <returns>Object to use as a source of pixels.</returns>
 295     public Efl.Gfx.IEntity GetFilterSource(System.String name) {
 296                                  var _ret_var = Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_source_get_ptr.Value.Delegate(this.NativeHandle,name);
 297         Eina.Error.RaiseIfUnhandledException();
 298                         return _ret_var;
 299  }
 300     /// <summary>Bind an object to use as a mask or texture in a filter program.
 301     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 302     /// <param name="name">Buffer name as used in the program.</param>
 303     /// <param name="source">Object to use as a source of pixels.</param>
 304     public void SetFilterSource(System.String name, Efl.Gfx.IEntity source) {
 305                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_source_set_ptr.Value.Delegate(this.NativeHandle,name, source);
 306         Eina.Error.RaiseIfUnhandledException();
 307                                          }
 308     /// <summary>Extra data used by the filter program.
 309     /// 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...
 310     ///
 311     /// If the <c>execute</c> flag is set, then the <c>value</c> can be complex and run, as if the original Lua program contained a line &apos;name = value&apos;. This can be used to pass in tables.</summary>
 312     /// <param name="name">Name of the global variable</param>
 313     /// <param name="value">String value to use as data</param>
 314     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 315     public void GetFilterData(System.String name, out System.String value, out bool execute) {
 316                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_data_get_ptr.Value.Delegate(this.NativeHandle,name, out value, out execute);
 317         Eina.Error.RaiseIfUnhandledException();
 318                                                          }
 319     /// <summary>Extra data used by the filter program.
 320     /// 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...
 321     ///
 322     /// If the <c>execute</c> flag is set, then the <c>value</c> can be complex and run, as if the original Lua program contained a line &apos;name = value&apos;. This can be used to pass in tables.</summary>
 323     /// <param name="name">Name of the global variable</param>
 324     /// <param name="value">String value to use as data</param>
 325     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 326     public void SetFilterData(System.String name, System.String value, bool execute) {
 327                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_data_set_ptr.Value.Delegate(this.NativeHandle,name, value, execute);
 328         Eina.Error.RaiseIfUnhandledException();
 329                                                          }
 330     /// <summary>Marks this filter as changed.</summary>
 331 /// <value><c>true</c> if filter changed, <c>false</c> otherwise</value>
 332     public bool FilterChanged {
 333         set { SetFilterChanged(value); }
 334     }
 335     /// <summary>Marks this filter as invalid.</summary>
 336 /// <value><c>true</c> if filter is invalid, <c>false</c> otherwise</value>
 337     public bool FilterInvalid {
 338         set { SetFilterInvalid(value); }
 339     }
 340     /// <summary>Retrieve cached output buffer, if any.
 341 /// Does not increment the reference count.</summary>
 342 /// <value>Output buffer</value>
 343     public System.IntPtr FilterOutputBuffer {
 344         get { return GetFilterOutputBuffer(); }
 345     }
 346     private static IntPtr GetEflClassStatic()
 347     {
 348         return Efl.Canvas.Filter.IInternalConcrete.efl_canvas_filter_internal_mixin_get();
 349     }
 350     /// <summary>Wrapper for native methods and virtual method delegates.
 351     /// For internal use by generated code only.</summary>
 352     public class NativeMethods  : Efl.Eo.NativeClass
 353     {
 354         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 355         /// <summary>Gets the list of Eo operations to override.</summary>
 356         /// <returns>The list of Eo operations to be overload.</returns>
 357         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 358         {
 359             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 360             var methods = Efl.Eo.Globals.GetUserMethods(type);
 361
 362             if (evas_filter_changed_set_static_delegate == null)
 363             {
 364                 evas_filter_changed_set_static_delegate = new evas_filter_changed_set_delegate(filter_changed_set);
 365             }
 366
 367             if (methods.FirstOrDefault(m => m.Name == "SetFilterChanged") != null)
 368             {
 369                 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) });
 370             }
 371
 372             if (evas_filter_invalid_set_static_delegate == null)
 373             {
 374                 evas_filter_invalid_set_static_delegate = new evas_filter_invalid_set_delegate(filter_invalid_set);
 375             }
 376
 377             if (methods.FirstOrDefault(m => m.Name == "SetFilterInvalid") != null)
 378             {
 379                 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) });
 380             }
 381
 382             if (evas_filter_output_buffer_get_static_delegate == null)
 383             {
 384                 evas_filter_output_buffer_get_static_delegate = new evas_filter_output_buffer_get_delegate(filter_output_buffer_get);
 385             }
 386
 387             if (methods.FirstOrDefault(m => m.Name == "GetFilterOutputBuffer") != null)
 388             {
 389                 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) });
 390             }
 391
 392             if (evas_filter_input_alpha_static_delegate == null)
 393             {
 394                 evas_filter_input_alpha_static_delegate = new evas_filter_input_alpha_delegate(filter_input_alpha);
 395             }
 396
 397             if (methods.FirstOrDefault(m => m.Name == "FilterInputAlpha") != null)
 398             {
 399                 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) });
 400             }
 401
 402             if (evas_filter_state_prepare_static_delegate == null)
 403             {
 404                 evas_filter_state_prepare_static_delegate = new evas_filter_state_prepare_delegate(filter_state_prepare);
 405             }
 406
 407             if (methods.FirstOrDefault(m => m.Name == "FilterStatePrepare") != null)
 408             {
 409                 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) });
 410             }
 411
 412             if (evas_filter_input_render_static_delegate == null)
 413             {
 414                 evas_filter_input_render_static_delegate = new evas_filter_input_render_delegate(filter_input_render);
 415             }
 416
 417             if (methods.FirstOrDefault(m => m.Name == "FilterInputRender") != null)
 418             {
 419                 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) });
 420             }
 421
 422             if (evas_filter_dirty_static_delegate == null)
 423             {
 424                 evas_filter_dirty_static_delegate = new evas_filter_dirty_delegate(filter_dirty);
 425             }
 426
 427             if (methods.FirstOrDefault(m => m.Name == "FilterDirty") != null)
 428             {
 429                 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) });
 430             }
 431
 432             if (efl_gfx_filter_program_get_static_delegate == null)
 433             {
 434                 efl_gfx_filter_program_get_static_delegate = new efl_gfx_filter_program_get_delegate(filter_program_get);
 435             }
 436
 437             if (methods.FirstOrDefault(m => m.Name == "GetFilterProgram") != null)
 438             {
 439                 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) });
 440             }
 441
 442             if (efl_gfx_filter_program_set_static_delegate == null)
 443             {
 444                 efl_gfx_filter_program_set_static_delegate = new efl_gfx_filter_program_set_delegate(filter_program_set);
 445             }
 446
 447             if (methods.FirstOrDefault(m => m.Name == "SetFilterProgram") != null)
 448             {
 449                 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) });
 450             }
 451
 452             if (efl_gfx_filter_state_get_static_delegate == null)
 453             {
 454                 efl_gfx_filter_state_get_static_delegate = new efl_gfx_filter_state_get_delegate(filter_state_get);
 455             }
 456
 457             if (methods.FirstOrDefault(m => m.Name == "GetFilterState") != null)
 458             {
 459                 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) });
 460             }
 461
 462             if (efl_gfx_filter_state_set_static_delegate == null)
 463             {
 464                 efl_gfx_filter_state_set_static_delegate = new efl_gfx_filter_state_set_delegate(filter_state_set);
 465             }
 466
 467             if (methods.FirstOrDefault(m => m.Name == "SetFilterState") != null)
 468             {
 469                 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) });
 470             }
 471
 472             if (efl_gfx_filter_padding_get_static_delegate == null)
 473             {
 474                 efl_gfx_filter_padding_get_static_delegate = new efl_gfx_filter_padding_get_delegate(filter_padding_get);
 475             }
 476
 477             if (methods.FirstOrDefault(m => m.Name == "GetFilterPadding") != null)
 478             {
 479                 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) });
 480             }
 481
 482             if (efl_gfx_filter_source_get_static_delegate == null)
 483             {
 484                 efl_gfx_filter_source_get_static_delegate = new efl_gfx_filter_source_get_delegate(filter_source_get);
 485             }
 486
 487             if (methods.FirstOrDefault(m => m.Name == "GetFilterSource") != null)
 488             {
 489                 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) });
 490             }
 491
 492             if (efl_gfx_filter_source_set_static_delegate == null)
 493             {
 494                 efl_gfx_filter_source_set_static_delegate = new efl_gfx_filter_source_set_delegate(filter_source_set);
 495             }
 496
 497             if (methods.FirstOrDefault(m => m.Name == "SetFilterSource") != null)
 498             {
 499                 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) });
 500             }
 501
 502             if (efl_gfx_filter_data_get_static_delegate == null)
 503             {
 504                 efl_gfx_filter_data_get_static_delegate = new efl_gfx_filter_data_get_delegate(filter_data_get);
 505             }
 506
 507             if (methods.FirstOrDefault(m => m.Name == "GetFilterData") != null)
 508             {
 509                 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) });
 510             }
 511
 512             if (efl_gfx_filter_data_set_static_delegate == null)
 513             {
 514                 efl_gfx_filter_data_set_static_delegate = new efl_gfx_filter_data_set_delegate(filter_data_set);
 515             }
 516
 517             if (methods.FirstOrDefault(m => m.Name == "SetFilterData") != null)
 518             {
 519                 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) });
 520             }
 521
 522             return descs;
 523         }
 524         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 525         /// <returns>The native class pointer.</returns>
 526         public override IntPtr GetEflClass()
 527         {
 528             return Efl.Canvas.Filter.IInternalConcrete.efl_canvas_filter_internal_mixin_get();
 529         }
 530
 531         #pragma warning disable CA1707, SA1300, SA1600
 532
 533
 534         private delegate void evas_filter_changed_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
 535
 536
 537         public delegate void evas_filter_changed_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
 538
 539         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");
 540
 541         private static void filter_changed_set(System.IntPtr obj, System.IntPtr pd, bool val)
 542         {
 543             Eina.Log.Debug("function evas_filter_changed_set was called");
 544             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 545             if (wrapper != null)
 546             {
 547
 548                 try
 549                 {
 550                     ((IInternalConcrete)wrapper).SetFilterChanged(val);
 551                 }
 552                 catch (Exception e)
 553                 {
 554                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 555                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 556                 }
 557
 558
 559             }
 560             else
 561             {
 562                 evas_filter_changed_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 563             }
 564         }
 565
 566         private static evas_filter_changed_set_delegate evas_filter_changed_set_static_delegate;
 567
 568
 569         private delegate void evas_filter_invalid_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool val);
 570
 571
 572         public delegate void evas_filter_invalid_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool val);
 573
 574         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");
 575
 576         private static void filter_invalid_set(System.IntPtr obj, System.IntPtr pd, bool val)
 577         {
 578             Eina.Log.Debug("function evas_filter_invalid_set was called");
 579             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 580             if (wrapper != null)
 581             {
 582
 583                 try
 584                 {
 585                     ((IInternalConcrete)wrapper).SetFilterInvalid(val);
 586                 }
 587                 catch (Exception e)
 588                 {
 589                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 590                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 591                 }
 592
 593
 594             }
 595             else
 596             {
 597                 evas_filter_invalid_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), val);
 598             }
 599         }
 600
 601         private static evas_filter_invalid_set_delegate evas_filter_invalid_set_static_delegate;
 602
 603
 604         private delegate System.IntPtr evas_filter_output_buffer_get_delegate(System.IntPtr obj, System.IntPtr pd);
 605
 606
 607         public delegate System.IntPtr evas_filter_output_buffer_get_api_delegate(System.IntPtr obj);
 608
 609         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");
 610
 611         private static System.IntPtr filter_output_buffer_get(System.IntPtr obj, System.IntPtr pd)
 612         {
 613             Eina.Log.Debug("function evas_filter_output_buffer_get was called");
 614             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 615             if (wrapper != null)
 616             {
 617             System.IntPtr _ret_var = default(System.IntPtr);
 618                 try
 619                 {
 620                     _ret_var = ((IInternalConcrete)wrapper).GetFilterOutputBuffer();
 621                 }
 622                 catch (Exception e)
 623                 {
 624                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 625                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 626                 }
 627
 628         return _ret_var;
 629
 630             }
 631             else
 632             {
 633                 return evas_filter_output_buffer_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 634             }
 635         }
 636
 637         private static evas_filter_output_buffer_get_delegate evas_filter_output_buffer_get_static_delegate;
 638
 639         [return: MarshalAs(UnmanagedType.U1)]
 640         private delegate bool evas_filter_input_alpha_delegate(System.IntPtr obj, System.IntPtr pd);
 641
 642         [return: MarshalAs(UnmanagedType.U1)]
 643         public delegate bool evas_filter_input_alpha_api_delegate(System.IntPtr obj);
 644
 645         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");
 646
 647         private static bool filter_input_alpha(System.IntPtr obj, System.IntPtr pd)
 648         {
 649             Eina.Log.Debug("function evas_filter_input_alpha was called");
 650             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 651             if (wrapper != null)
 652             {
 653             bool _ret_var = default(bool);
 654                 try
 655                 {
 656                     _ret_var = ((IInternalConcrete)wrapper).FilterInputAlpha();
 657                 }
 658                 catch (Exception e)
 659                 {
 660                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 661                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 662                 }
 663
 664         return _ret_var;
 665
 666             }
 667             else
 668             {
 669                 return evas_filter_input_alpha_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 670             }
 671         }
 672
 673         private static evas_filter_input_alpha_delegate evas_filter_input_alpha_static_delegate;
 674
 675
 676         private delegate void evas_filter_state_prepare_delegate(System.IntPtr obj, System.IntPtr pd,  out Efl.Canvas.Filter.State.NativeStruct state,  System.IntPtr data);
 677
 678
 679         public delegate void evas_filter_state_prepare_api_delegate(System.IntPtr obj,  out Efl.Canvas.Filter.State.NativeStruct state,  System.IntPtr data);
 680
 681         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");
 682
 683         private static void filter_state_prepare(System.IntPtr obj, System.IntPtr pd, out Efl.Canvas.Filter.State.NativeStruct state, System.IntPtr data)
 684         {
 685             Eina.Log.Debug("function evas_filter_state_prepare was called");
 686             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 687             if (wrapper != null)
 688             {
 689                         Efl.Canvas.Filter.State _out_state = default(Efl.Canvas.Filter.State);
 690
 691                 try
 692                 {
 693                     ((IInternalConcrete)wrapper).FilterStatePrepare(out _out_state, data);
 694                 }
 695                 catch (Exception e)
 696                 {
 697                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 698                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 699                 }
 700
 701         state = _out_state;
 702
 703             }
 704             else
 705             {
 706                 evas_filter_state_prepare_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out state, data);
 707             }
 708         }
 709
 710         private static evas_filter_state_prepare_delegate evas_filter_state_prepare_static_delegate;
 711
 712         [return: MarshalAs(UnmanagedType.U1)]
 713         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);
 714
 715         [return: MarshalAs(UnmanagedType.U1)]
 716         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);
 717
 718         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");
 719
 720         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)
 721         {
 722             Eina.Log.Debug("function evas_filter_input_render was called");
 723             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 724             if (wrapper != null)
 725             {
 726                                                                                                                                                                                                                                                                                                             bool _ret_var = default(bool);
 727                 try
 728                 {
 729                     _ret_var = ((IInternalConcrete)wrapper).FilterInputRender(filter, engine, output, drawctx, data, l, r, t, b, x, y, do_async);
 730                 }
 731                 catch (Exception e)
 732                 {
 733                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 734                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 735                 }
 736
 737                                                                                                                                                                                                         return _ret_var;
 738
 739             }
 740             else
 741             {
 742                 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);
 743             }
 744         }
 745
 746         private static evas_filter_input_render_delegate evas_filter_input_render_static_delegate;
 747
 748
 749         private delegate void evas_filter_dirty_delegate(System.IntPtr obj, System.IntPtr pd);
 750
 751
 752         public delegate void evas_filter_dirty_api_delegate(System.IntPtr obj);
 753
 754         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");
 755
 756         private static void filter_dirty(System.IntPtr obj, System.IntPtr pd)
 757         {
 758             Eina.Log.Debug("function evas_filter_dirty was called");
 759             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 760             if (wrapper != null)
 761             {
 762
 763                 try
 764                 {
 765                     ((IInternalConcrete)wrapper).FilterDirty();
 766                 }
 767                 catch (Exception e)
 768                 {
 769                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 770                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 771                 }
 772
 773
 774             }
 775             else
 776             {
 777                 evas_filter_dirty_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 778             }
 779         }
 780
 781         private static evas_filter_dirty_delegate evas_filter_dirty_static_delegate;
 782
 783
 784         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);
 785
 786
 787         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);
 788
 789         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");
 790
 791         private static void filter_program_get(System.IntPtr obj, System.IntPtr pd, out System.String code, out System.String name)
 792         {
 793             Eina.Log.Debug("function efl_gfx_filter_program_get was called");
 794             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 795             if (wrapper != null)
 796             {
 797                         System.String _out_code = default(System.String);
 798         System.String _out_name = default(System.String);
 799
 800                 try
 801                 {
 802                     ((IInternalConcrete)wrapper).GetFilterProgram(out _out_code, out _out_name);
 803                 }
 804                 catch (Exception e)
 805                 {
 806                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 807                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 808                 }
 809
 810         code = _out_code;
 811         name = _out_name;
 812
 813             }
 814             else
 815             {
 816                 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);
 817             }
 818         }
 819
 820         private static efl_gfx_filter_program_get_delegate efl_gfx_filter_program_get_static_delegate;
 821
 822
 823         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);
 824
 825
 826         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);
 827
 828         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");
 829
 830         private static void filter_program_set(System.IntPtr obj, System.IntPtr pd, System.String code, System.String name)
 831         {
 832             Eina.Log.Debug("function efl_gfx_filter_program_set was called");
 833             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 834             if (wrapper != null)
 835             {
 836
 837                 try
 838                 {
 839                     ((IInternalConcrete)wrapper).SetFilterProgram(code, name);
 840                 }
 841                 catch (Exception e)
 842                 {
 843                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 844                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 845                 }
 846
 847
 848             }
 849             else
 850             {
 851                 efl_gfx_filter_program_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), code, name);
 852             }
 853         }
 854
 855         private static efl_gfx_filter_program_set_delegate efl_gfx_filter_program_set_static_delegate;
 856
 857
 858         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);
 859
 860
 861         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);
 862
 863         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");
 864
 865         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)
 866         {
 867             Eina.Log.Debug("function efl_gfx_filter_state_get was called");
 868             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 869             if (wrapper != null)
 870             {
 871                                                 System.String _out_cur_state = default(System.String);
 872         cur_val = default(double);        System.String _out_next_state = default(System.String);
 873         next_val = default(double);        pos = default(double);
 874                 try
 875                 {
 876                     ((IInternalConcrete)wrapper).GetFilterState(out _out_cur_state, out cur_val, out _out_next_state, out next_val, out pos);
 877                 }
 878                 catch (Exception e)
 879                 {
 880                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 881                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 882                 }
 883
 884         cur_state = _out_cur_state;
 885                 next_state = _out_next_state;
 886
 887             }
 888             else
 889             {
 890                 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);
 891             }
 892         }
 893
 894         private static efl_gfx_filter_state_get_delegate efl_gfx_filter_state_get_static_delegate;
 895
 896
 897         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);
 898
 899
 900         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);
 901
 902         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");
 903
 904         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)
 905         {
 906             Eina.Log.Debug("function efl_gfx_filter_state_set was called");
 907             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 908             if (wrapper != null)
 909             {
 910
 911                 try
 912                 {
 913                     ((IInternalConcrete)wrapper).SetFilterState(cur_state, cur_val, next_state, next_val, pos);
 914                 }
 915                 catch (Exception e)
 916                 {
 917                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 918                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 919                 }
 920
 921
 922             }
 923             else
 924             {
 925                 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);
 926             }
 927         }
 928
 929         private static efl_gfx_filter_state_set_delegate efl_gfx_filter_state_set_static_delegate;
 930
 931
 932         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);
 933
 934
 935         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);
 936
 937         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");
 938
 939         private static void filter_padding_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
 940         {
 941             Eina.Log.Debug("function efl_gfx_filter_padding_get was called");
 942             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 943             if (wrapper != null)
 944             {
 945                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
 946                 try
 947                 {
 948                     ((IInternalConcrete)wrapper).GetFilterPadding(out l, out r, out t, out b);
 949                 }
 950                 catch (Exception e)
 951                 {
 952                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 953                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 954                 }
 955
 956
 957             }
 958             else
 959             {
 960                 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);
 961             }
 962         }
 963
 964         private static efl_gfx_filter_padding_get_delegate efl_gfx_filter_padding_get_static_delegate;
 965
 966         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 967         private delegate Efl.Gfx.IEntity efl_gfx_filter_source_get_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
 968
 969         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 970         public delegate Efl.Gfx.IEntity efl_gfx_filter_source_get_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name);
 971
 972         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");
 973
 974         private static Efl.Gfx.IEntity filter_source_get(System.IntPtr obj, System.IntPtr pd, System.String name)
 975         {
 976             Eina.Log.Debug("function efl_gfx_filter_source_get was called");
 977             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 978             if (wrapper != null)
 979             {
 980                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
 981                 try
 982                 {
 983                     _ret_var = ((IInternalConcrete)wrapper).GetFilterSource(name);
 984                 }
 985                 catch (Exception e)
 986                 {
 987                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 988                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 989                 }
 990
 991                         return _ret_var;
 992
 993             }
 994             else
 995             {
 996                 return efl_gfx_filter_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name);
 997             }
 998         }
 999
1000         private static efl_gfx_filter_source_get_delegate efl_gfx_filter_source_get_static_delegate;
1001
1002
1003         private delegate void efl_gfx_filter_source_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity source);
1004
1005
1006         public delegate void efl_gfx_filter_source_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String name, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Gfx.IEntity source);
1007
1008         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");
1009
1010         private static void filter_source_set(System.IntPtr obj, System.IntPtr pd, System.String name, Efl.Gfx.IEntity source)
1011         {
1012             Eina.Log.Debug("function efl_gfx_filter_source_set was called");
1013             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1014             if (wrapper != null)
1015             {
1016
1017                 try
1018                 {
1019                     ((IInternalConcrete)wrapper).SetFilterSource(name, source);
1020                 }
1021                 catch (Exception e)
1022                 {
1023                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1024                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1025                 }
1026
1027
1028             }
1029             else
1030             {
1031                 efl_gfx_filter_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, source);
1032             }
1033         }
1034
1035         private static efl_gfx_filter_source_set_delegate efl_gfx_filter_source_set_static_delegate;
1036
1037
1038         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);
1039
1040
1041         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);
1042
1043         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");
1044
1045         private static void filter_data_get(System.IntPtr obj, System.IntPtr pd, System.String name, out System.String value, out bool execute)
1046         {
1047             Eina.Log.Debug("function efl_gfx_filter_data_get was called");
1048             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1049             if (wrapper != null)
1050             {
1051                                         System.String _out_value = default(System.String);
1052         execute = default(bool);
1053                 try
1054                 {
1055                     ((IInternalConcrete)wrapper).GetFilterData(name, out _out_value, out execute);
1056                 }
1057                 catch (Exception e)
1058                 {
1059                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1060                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1061                 }
1062
1063                 value = _out_value;
1064
1065             }
1066             else
1067             {
1068                 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);
1069             }
1070         }
1071
1072         private static efl_gfx_filter_data_get_delegate efl_gfx_filter_data_get_static_delegate;
1073
1074
1075         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);
1076
1077
1078         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);
1079
1080         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");
1081
1082         private static void filter_data_set(System.IntPtr obj, System.IntPtr pd, System.String name, System.String value, bool execute)
1083         {
1084             Eina.Log.Debug("function efl_gfx_filter_data_set was called");
1085             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1086             if (wrapper != null)
1087             {
1088
1089                 try
1090                 {
1091                     ((IInternalConcrete)wrapper).SetFilterData(name, value, execute);
1092                 }
1093                 catch (Exception e)
1094                 {
1095                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1096                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1097                 }
1098
1099
1100             }
1101             else
1102             {
1103                 efl_gfx_filter_data_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, value, execute);
1104             }
1105         }
1106
1107         private static efl_gfx_filter_data_set_delegate efl_gfx_filter_data_set_static_delegate;
1108
1109         #pragma warning restore CA1707, SA1300, SA1600
1110
1111 }
1112 }
1113 }
1114
1115 }
1116
1117 }
1118
1119 namespace Efl {
1120
1121 namespace Gfx {
1122
1123 /// <summary>32 bit color data structure</summary>
1124 [StructLayout(LayoutKind.Sequential)]
1125 public struct Color32
1126 {
1127     /// <summary>Red component of the color</summary>
1128     public byte R;
1129     /// <summary>Green component of the color</summary>
1130     public byte G;
1131     /// <summary>Blue component of the color</summary>
1132     public byte B;
1133     /// <summary>Translucent component of the color</summary>
1134     public byte A;
1135     ///<summary>Constructor for Color32.</summary>
1136     public Color32(
1137         byte R = default(byte),
1138         byte G = default(byte),
1139         byte B = default(byte),
1140         byte A = default(byte)    )
1141     {
1142         this.R = R;
1143         this.G = G;
1144         this.B = B;
1145         this.A = A;
1146     }
1147
1148     public static implicit operator Color32(IntPtr ptr)
1149     {
1150         var tmp = (Color32.NativeStruct)Marshal.PtrToStructure(ptr, typeof(Color32.NativeStruct));
1151         return tmp;
1152     }
1153
1154     ///<summary>Internal wrapper for struct Color32.</summary>
1155     [StructLayout(LayoutKind.Sequential)]
1156     public struct NativeStruct
1157     {
1158
1159         public byte R;
1160
1161         public byte G;
1162
1163         public byte B;
1164
1165         public byte A;
1166         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
1167         public static implicit operator Color32.NativeStruct(Color32 _external_struct)
1168         {
1169             var _internal_struct = new Color32.NativeStruct();
1170             _internal_struct.R = _external_struct.R;
1171             _internal_struct.G = _external_struct.G;
1172             _internal_struct.B = _external_struct.B;
1173             _internal_struct.A = _external_struct.A;
1174             return _internal_struct;
1175         }
1176
1177         ///<summary>Implicit conversion to the managed representation.</summary>
1178         public static implicit operator Color32(Color32.NativeStruct _internal_struct)
1179         {
1180             var _external_struct = new Color32();
1181             _external_struct.R = _internal_struct.R;
1182             _external_struct.G = _internal_struct.G;
1183             _external_struct.B = _internal_struct.B;
1184             _external_struct.A = _internal_struct.A;
1185             return _external_struct;
1186         }
1187
1188     }
1189
1190 }
1191
1192 }
1193
1194 }
1195
1196 namespace Efl {
1197
1198 namespace Canvas {
1199
1200 namespace Filter {
1201
1202 /// <summary>Filter state name structure</summary>
1203 [StructLayout(LayoutKind.Sequential)]
1204 public struct StateName
1205 {
1206     /// <summary>Filter state name</summary>
1207     public System.String Name;
1208     /// <summary>Filter state value</summary>
1209     public double Value;
1210     ///<summary>Constructor for StateName.</summary>
1211     public StateName(
1212         System.String Name = default(System.String),
1213         double Value = default(double)    )
1214     {
1215         this.Name = Name;
1216         this.Value = Value;
1217     }
1218
1219     public static implicit operator StateName(IntPtr ptr)
1220     {
1221         var tmp = (StateName.NativeStruct)Marshal.PtrToStructure(ptr, typeof(StateName.NativeStruct));
1222         return tmp;
1223     }
1224
1225     ///<summary>Internal wrapper for struct StateName.</summary>
1226     [StructLayout(LayoutKind.Sequential)]
1227     public struct NativeStruct
1228     {
1229         ///<summary>Internal wrapper for field Name</summary>
1230         public System.IntPtr Name;
1231
1232         public double Value;
1233         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
1234         public static implicit operator StateName.NativeStruct(StateName _external_struct)
1235         {
1236             var _internal_struct = new StateName.NativeStruct();
1237             _internal_struct.Name = Eina.MemoryNative.StrDup(_external_struct.Name);
1238             _internal_struct.Value = _external_struct.Value;
1239             return _internal_struct;
1240         }
1241
1242         ///<summary>Implicit conversion to the managed representation.</summary>
1243         public static implicit operator StateName(StateName.NativeStruct _internal_struct)
1244         {
1245             var _external_struct = new StateName();
1246             _external_struct.Name = Eina.StringConversion.NativeUtf8ToManagedString(_internal_struct.Name);
1247             _external_struct.Value = _internal_struct.Value;
1248             return _external_struct;
1249         }
1250
1251     }
1252
1253 }
1254
1255 }
1256
1257 }
1258
1259 }
1260
1261 namespace Efl {
1262
1263 namespace Canvas {
1264
1265 namespace Filter {
1266
1267 /// <summary>Filter state text structure</summary>
1268 [StructLayout(LayoutKind.Sequential)]
1269 public struct StateText
1270 {
1271     /// <summary>Text outline color</summary>
1272     public Efl.Gfx.Color32 Outline;
1273     /// <summary>Text shadow color</summary>
1274     public Efl.Gfx.Color32 Shadow;
1275     /// <summary>Text glow color</summary>
1276     public Efl.Gfx.Color32 Glow;
1277     /// <summary>Text glow2 color</summary>
1278     public Efl.Gfx.Color32 Glow2;
1279     ///<summary>Constructor for StateText.</summary>
1280     public StateText(
1281         Efl.Gfx.Color32 Outline = default(Efl.Gfx.Color32),
1282         Efl.Gfx.Color32 Shadow = default(Efl.Gfx.Color32),
1283         Efl.Gfx.Color32 Glow = default(Efl.Gfx.Color32),
1284         Efl.Gfx.Color32 Glow2 = default(Efl.Gfx.Color32)    )
1285     {
1286         this.Outline = Outline;
1287         this.Shadow = Shadow;
1288         this.Glow = Glow;
1289         this.Glow2 = Glow2;
1290     }
1291
1292     public static implicit operator StateText(IntPtr ptr)
1293     {
1294         var tmp = (StateText.NativeStruct)Marshal.PtrToStructure(ptr, typeof(StateText.NativeStruct));
1295         return tmp;
1296     }
1297
1298     ///<summary>Internal wrapper for struct StateText.</summary>
1299     [StructLayout(LayoutKind.Sequential)]
1300     public struct NativeStruct
1301     {
1302
1303         public Efl.Gfx.Color32.NativeStruct Outline;
1304
1305         public Efl.Gfx.Color32.NativeStruct Shadow;
1306
1307         public Efl.Gfx.Color32.NativeStruct Glow;
1308
1309         public Efl.Gfx.Color32.NativeStruct Glow2;
1310         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
1311         public static implicit operator StateText.NativeStruct(StateText _external_struct)
1312         {
1313             var _internal_struct = new StateText.NativeStruct();
1314             _internal_struct.Outline = _external_struct.Outline;
1315             _internal_struct.Shadow = _external_struct.Shadow;
1316             _internal_struct.Glow = _external_struct.Glow;
1317             _internal_struct.Glow2 = _external_struct.Glow2;
1318             return _internal_struct;
1319         }
1320
1321         ///<summary>Implicit conversion to the managed representation.</summary>
1322         public static implicit operator StateText(StateText.NativeStruct _internal_struct)
1323         {
1324             var _external_struct = new StateText();
1325             _external_struct.Outline = _internal_struct.Outline;
1326             _external_struct.Shadow = _internal_struct.Shadow;
1327             _external_struct.Glow = _internal_struct.Glow;
1328             _external_struct.Glow2 = _internal_struct.Glow2;
1329             return _external_struct;
1330         }
1331
1332     }
1333
1334 }
1335
1336 }
1337
1338 }
1339
1340 }
1341
1342 namespace Efl {
1343
1344 namespace Canvas {
1345
1346 namespace Filter {
1347
1348 /// <summary>Internal structure representing the state of a Gfx Filter</summary>
1349 [StructLayout(LayoutKind.Sequential)]
1350 public struct State
1351 {
1352     /// <summary>Text state</summary>
1353     public Efl.Canvas.Filter.StateText Text;
1354     /// <summary>Color</summary>
1355     public Efl.Gfx.Color32 Color;
1356     /// <summary>Current state</summary>
1357     public Efl.Canvas.Filter.StateName Cur;
1358     /// <summary>Next state</summary>
1359     public Efl.Canvas.Filter.StateName Next;
1360     /// <summary>Width</summary>
1361     public int W;
1362     /// <summary>Height</summary>
1363     public int H;
1364     /// <summary>Scale factor</summary>
1365     public double Scale;
1366     /// <summary>Position</summary>
1367     public double Pos;
1368     ///<summary>Constructor for State.</summary>
1369     public State(
1370         Efl.Canvas.Filter.StateText Text = default(Efl.Canvas.Filter.StateText),
1371         Efl.Gfx.Color32 Color = default(Efl.Gfx.Color32),
1372         Efl.Canvas.Filter.StateName Cur = default(Efl.Canvas.Filter.StateName),
1373         Efl.Canvas.Filter.StateName Next = default(Efl.Canvas.Filter.StateName),
1374         int W = default(int),
1375         int H = default(int),
1376         double Scale = default(double),
1377         double Pos = default(double)    )
1378     {
1379         this.Text = Text;
1380         this.Color = Color;
1381         this.Cur = Cur;
1382         this.Next = Next;
1383         this.W = W;
1384         this.H = H;
1385         this.Scale = Scale;
1386         this.Pos = Pos;
1387     }
1388
1389     public static implicit operator State(IntPtr ptr)
1390     {
1391         var tmp = (State.NativeStruct)Marshal.PtrToStructure(ptr, typeof(State.NativeStruct));
1392         return tmp;
1393     }
1394
1395     ///<summary>Internal wrapper for struct State.</summary>
1396     [StructLayout(LayoutKind.Sequential)]
1397     public struct NativeStruct
1398     {
1399
1400         public Efl.Canvas.Filter.StateText.NativeStruct Text;
1401
1402         public Efl.Gfx.Color32.NativeStruct Color;
1403
1404         public Efl.Canvas.Filter.StateName.NativeStruct Cur;
1405
1406         public Efl.Canvas.Filter.StateName.NativeStruct Next;
1407
1408         public int W;
1409
1410         public int H;
1411
1412         public double Scale;
1413
1414         public double Pos;
1415         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
1416         public static implicit operator State.NativeStruct(State _external_struct)
1417         {
1418             var _internal_struct = new State.NativeStruct();
1419             _internal_struct.Text = _external_struct.Text;
1420             _internal_struct.Color = _external_struct.Color;
1421             _internal_struct.Cur = _external_struct.Cur;
1422             _internal_struct.Next = _external_struct.Next;
1423             _internal_struct.W = _external_struct.W;
1424             _internal_struct.H = _external_struct.H;
1425             _internal_struct.Scale = _external_struct.Scale;
1426             _internal_struct.Pos = _external_struct.Pos;
1427             return _internal_struct;
1428         }
1429
1430         ///<summary>Implicit conversion to the managed representation.</summary>
1431         public static implicit operator State(State.NativeStruct _internal_struct)
1432         {
1433             var _external_struct = new State();
1434             _external_struct.Text = _internal_struct.Text;
1435             _external_struct.Color = _internal_struct.Color;
1436             _external_struct.Cur = _internal_struct.Cur;
1437             _external_struct.Next = _internal_struct.Next;
1438             _external_struct.W = _internal_struct.W;
1439             _external_struct.H = _internal_struct.H;
1440             _external_struct.Scale = _internal_struct.Scale;
1441             _external_struct.Pos = _internal_struct.Pos;
1442             return _external_struct;
1443         }
1444
1445     }
1446
1447 }
1448
1449 }
1450
1451 }
1452
1453 }
1454