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

   1 #define EFL_BETA
   2 #pragma warning disable CS1591
   3 using System;
   4 using System.Runtime.InteropServices;
   5 using System.Collections.Generic;
   6 using System.Linq;
   7 using System.Threading;
   8 using System.ComponentModel;
   9 namespace Efl {
  10
  11 namespace Ui {
  12
  13 /// <summary>A drop-shadow or glow effect around any widget.
  14 /// A simple drop-shadow effect can be applied to any widget by setting the color and blur radius on this part.
  15 ///
  16 /// For instance, a blue glow can be achieved with: obj.shadow().color_set(0, 128, 255, 255); obj.shadow().grow_set(2); obj.shadow().radius_set(3, 3);
  17 ///
  18 /// As another example, here&apos;s a black drop-shadow: obj.shadow().color_set(0, 0, 0, 255); obj.shadow().grow_set(1); obj.shadow().radius_set(5, 5); obj.shadow().offset_set(5, 5);
  19 ///
  20 /// It is also possible to manually specify which <see cref="Efl.Gfx.IFilter"/> program to use.</summary>
  21 /// <remarks>This is a <b>BETA</b> class. It can be modified or removed in the future. Do not use it for product development.</remarks>
  22 [Efl.Ui.WidgetPartShadow.NativeMethods]
  23 [Efl.Eo.BindingEntity]
  24 public class WidgetPartShadow : Efl.Ui.WidgetPart, Efl.Gfx.IBlur, Efl.Gfx.IColor, Efl.Gfx.IFilter
  25 {
  26     /// <summary>Pointer to the native class description.</summary>
  27     public override System.IntPtr NativeClass
  28     {
  29         get
  30         {
  31             if (((object)this).GetType() == typeof(WidgetPartShadow))
  32             {
  33                 return GetEflClassStatic();
  34             }
  35             else
  36             {
  37                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  38             }
  39         }
  40     }
  41
  42     [System.Runtime.InteropServices.DllImport(efl.Libs.Elementary)] internal static extern System.IntPtr
  43         efl_ui_widget_part_shadow_class_get();
  44     /// <summary>Initializes a new instance of the <see cref="WidgetPartShadow"/> class.</summary>
  45     /// <param name="parent">Parent instance.</param>
  46     public WidgetPartShadow(Efl.Object parent= null
  47             ) : base(efl_ui_widget_part_shadow_class_get(), parent)
  48     {
  49         FinishInstantiation();
  50     }
  51
  52     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  53     /// Do not call this constructor directly.</summary>
  54     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  55     protected WidgetPartShadow(ConstructingHandle ch) : base(ch)
  56     {
  57     }
  58
  59     /// <summary>Initializes a new instance of the <see cref="WidgetPartShadow"/> class.
  60     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  61     /// <param name="wh">The native pointer to be wrapped.</param>
  62     protected WidgetPartShadow(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  63     {
  64     }
  65
  66     /// <summary>Initializes a new instance of the <see cref="WidgetPartShadow"/> class.
  67     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  68     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  69     /// <param name="parent">The Efl.Object parent of this instance.</param>
  70     protected WidgetPartShadow(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  71     {
  72     }
  73
  74     /// <summary>The blur radius in pixels.</summary>
  75     /// <param name="rx">The horizontal blur radius.</param>
  76     /// <param name="ry">The vertical blur radius.</param>
  77     virtual public void GetRadius(out double rx, out double ry) {
  78                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_radius_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out rx, out ry);
  79         Eina.Error.RaiseIfUnhandledException();
  80                                          }
  81     /// <summary>The blur radius in pixels.</summary>
  82     /// <param name="rx">The horizontal blur radius.</param>
  83     /// <param name="ry">The vertical blur radius.</param>
  84     virtual public void SetRadius(double rx, double ry) {
  85                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_radius_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),rx, ry);
  86         Eina.Error.RaiseIfUnhandledException();
  87                                          }
  88     /// <summary>An offset relative to the original pixels.
  89     /// This property allows for drop shadow effects.</summary>
  90     /// <param name="ox">Horizontal offset in pixels.</param>
  91     /// <param name="oy">Vertical offset in pixels.</param>
  92     virtual public void GetOffset(out double ox, out double oy) {
  93                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_offset_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out ox, out oy);
  94         Eina.Error.RaiseIfUnhandledException();
  95                                          }
  96     /// <summary>An offset relative to the original pixels.
  97     /// This property allows for drop shadow effects.</summary>
  98     /// <param name="ox">Horizontal offset in pixels.</param>
  99     /// <param name="oy">Vertical offset in pixels.</param>
 100     virtual public void SetOffset(double ox, double oy) {
 101                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_offset_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),ox, oy);
 102         Eina.Error.RaiseIfUnhandledException();
 103                                          }
 104     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
 105     /// Growing is a combination of blur &amp; color levels adjustment. If the value of grow is positive, the pixels will appear more &quot;fat&quot; or &quot;bold&quot; than the original. If the value is negative, a shrink effect happens instead.
 106     ///
 107     /// This is can be used efficiently to create glow effects.</summary>
 108     /// <returns>How much to grow the original pixel data.</returns>
 109     virtual public double GetGrow() {
 110          var _ret_var = Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_grow_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 111         Eina.Error.RaiseIfUnhandledException();
 112         return _ret_var;
 113  }
 114     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
 115     /// Growing is a combination of blur &amp; color levels adjustment. If the value of grow is positive, the pixels will appear more &quot;fat&quot; or &quot;bold&quot; than the original. If the value is negative, a shrink effect happens instead.
 116     ///
 117     /// This is can be used efficiently to create glow effects.</summary>
 118     /// <param name="radius">How much to grow the original pixel data.</param>
 119     virtual public void SetGrow(double radius) {
 120                                  Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_grow_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),radius);
 121         Eina.Error.RaiseIfUnhandledException();
 122                          }
 123     /// <summary>Retrieves the general/main color of the given Evas object.
 124     /// Retrieves the main color&apos;s RGB component (and alpha channel) values, which range from 0 to 255. For the alpha channel, which defines the object&apos;s transparency level, 0 means totally transparent, while 255 means opaque. These color values are premultiplied by the alpha value.
 125     ///
 126     /// Usually youll use this attribute for text and rectangle objects, where the main color is their unique one. If set for objects which themselves have colors, like the images one, those colors get modulated by this one.
 127     ///
 128     /// All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
 129     ///
 130     /// Use null pointers on the components you&apos;re not interested in: they&apos;ll be ignored by the function.
 131     /// (Since EFL 1.22)</summary>
 132     virtual public void GetColor(out int r, out int g, out int b, out int a) {
 133                                                                                                          Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out r, out g, out b, out a);
 134         Eina.Error.RaiseIfUnhandledException();
 135                                                                          }
 136     /// <summary>Sets the general/main color of the given Evas object to the given one.
 137     /// See also <see cref="Efl.Gfx.IColor.GetColor"/> (for an example)
 138     ///
 139     /// These color values are expected to be premultiplied by alpha.
 140     /// (Since EFL 1.22)</summary>
 141     virtual public void SetColor(int r, int g, int b, int a) {
 142                                                                                                          Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),r, g, b, a);
 143         Eina.Error.RaiseIfUnhandledException();
 144                                                                          }
 145     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 146     /// (Since EFL 1.22)</summary>
 147     /// <returns>the hex color code.</returns>
 148     virtual public System.String GetColorCode() {
 149          var _ret_var = Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_code_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 150         Eina.Error.RaiseIfUnhandledException();
 151         return _ret_var;
 152  }
 153     /// <summary>Set the color of given Evas object to the given hex color code(#RRGGBBAA). e.g. efl_gfx_color_code_set(obj, &quot;#FFCCAACC&quot;);
 154     /// (Since EFL 1.22)</summary>
 155     /// <param name="colorcode">the hex color code.</param>
 156     virtual public void SetColorCode(System.String colorcode) {
 157                                  Efl.Gfx.IColorConcrete.NativeMethods.efl_gfx_color_code_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),colorcode);
 158         Eina.Error.RaiseIfUnhandledException();
 159                          }
 160     /// <summary>Gets the code of the filter program set on this object. May be <c>null</c>.</summary>
 161     /// <param name="code">The Lua program source code.</param>
 162     /// <param name="name">An optional name for this filter.</param>
 163     virtual public void GetFilterProgram(out System.String code, out System.String name) {
 164                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_program_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out code, out name);
 165         Eina.Error.RaiseIfUnhandledException();
 166                                          }
 167     /// <summary>Set a graphical filter program on this object.
 168     /// Valid for Text and Image objects at the moment.
 169     ///
 170     /// 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.
 171     ///
 172     /// Set to <c>null</c> to disable filtering.</summary>
 173     /// <param name="code">The Lua program source code.</param>
 174     /// <param name="name">An optional name for this filter.</param>
 175     virtual public void SetFilterProgram(System.String code, System.String name) {
 176                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_program_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),code, name);
 177         Eina.Error.RaiseIfUnhandledException();
 178                                          }
 179     /// <summary>Set the current state of the filter.
 180     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 181     ///
 182     /// 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>
 183     /// <param name="cur_state">Current state of the filter</param>
 184     /// <param name="cur_val">Current value</param>
 185     /// <param name="next_state">Next filter state, optional</param>
 186     /// <param name="next_val">Next value, optional</param>
 187     /// <param name="pos">Position, optional</param>
 188     virtual public void GetFilterState(out System.String cur_state, out double cur_val, out System.String next_state, out double next_val, out double pos) {
 189                                                                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_state_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out cur_state, out cur_val, out next_state, out next_val, out pos);
 190         Eina.Error.RaiseIfUnhandledException();
 191                                                                                          }
 192     /// <summary>Set the current state of the filter.
 193     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 194     ///
 195     /// 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>
 196     /// <param name="cur_state">Current state of the filter</param>
 197     /// <param name="cur_val">Current value</param>
 198     /// <param name="next_state">Next filter state, optional</param>
 199     /// <param name="next_val">Next value, optional</param>
 200     /// <param name="pos">Position, optional</param>
 201     virtual public void SetFilterState(System.String cur_state, double cur_val, System.String next_state, double next_val, double pos) {
 202                                                                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_state_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),cur_state, cur_val, next_state, next_val, pos);
 203         Eina.Error.RaiseIfUnhandledException();
 204                                                                                          }
 205     /// <summary>Gets the padding required to apply this filter.</summary>
 206     /// <param name="l">Padding on the left</param>
 207     /// <param name="r">Padding on the right</param>
 208     /// <param name="t">Padding on the top</param>
 209     /// <param name="b">Padding on the bottom</param>
 210     virtual public void GetFilterPadding(out int l, out int r, out int t, out int b) {
 211                                                                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_padding_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out l, out r, out t, out b);
 212         Eina.Error.RaiseIfUnhandledException();
 213                                                                          }
 214     /// <summary>Bind an object to use as a mask or texture in a filter program.
 215     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 216     /// <param name="name">Buffer name as used in the program.</param>
 217     /// <returns>Object to use as a source of pixels.</returns>
 218     virtual public Efl.Gfx.IEntity GetFilterSource(System.String name) {
 219                                  var _ret_var = Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_source_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name);
 220         Eina.Error.RaiseIfUnhandledException();
 221                         return _ret_var;
 222  }
 223     /// <summary>Bind an object to use as a mask or texture in a filter program.
 224     /// This will create automatically a new RGBA buffer containing the source object&apos;s pixels (as it is rendered).</summary>
 225     /// <param name="name">Buffer name as used in the program.</param>
 226     /// <param name="source">Object to use as a source of pixels.</param>
 227     virtual public void SetFilterSource(System.String name, Efl.Gfx.IEntity source) {
 228                                                          Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_source_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name, source);
 229         Eina.Error.RaiseIfUnhandledException();
 230                                          }
 231     /// <summary>Extra data used by the filter program.
 232     /// 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...
 233     ///
 234     /// 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>
 235     /// <param name="name">Name of the global variable</param>
 236     /// <param name="value">String value to use as data</param>
 237     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 238     virtual public void GetFilterData(System.String name, out System.String value, out bool execute) {
 239                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_data_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name, out value, out execute);
 240         Eina.Error.RaiseIfUnhandledException();
 241                                                          }
 242     /// <summary>Extra data used by the filter program.
 243     /// 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...
 244     ///
 245     /// 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>
 246     /// <param name="name">Name of the global variable</param>
 247     /// <param name="value">String value to use as data</param>
 248     /// <param name="execute">If <c>true</c>, execute &apos;name = value&apos;</param>
 249     virtual public void SetFilterData(System.String name, System.String value, bool execute) {
 250                                                                                  Efl.Gfx.IFilterConcrete.NativeMethods.efl_gfx_filter_data_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),name, value, execute);
 251         Eina.Error.RaiseIfUnhandledException();
 252                                                          }
 253     /// <summary>The blur radius in pixels.</summary>
 254     /// <value>The horizontal blur radius.</value>
 255     public (double, double) Radius {
 256         get {
 257             double _out_rx = default(double);
 258             double _out_ry = default(double);
 259             GetRadius(out _out_rx,out _out_ry);
 260             return (_out_rx,_out_ry);
 261         }
 262         set { SetRadius( value.Item1,  value.Item2); }
 263     }
 264     /// <summary>An offset relative to the original pixels.
 265     /// This property allows for drop shadow effects.</summary>
 266     /// <value>Horizontal offset in pixels.</value>
 267     public (double, double) Offset {
 268         get {
 269             double _out_ox = default(double);
 270             double _out_oy = default(double);
 271             GetOffset(out _out_ox,out _out_oy);
 272             return (_out_ox,_out_oy);
 273         }
 274         set { SetOffset( value.Item1,  value.Item2); }
 275     }
 276     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
 277     /// Growing is a combination of blur &amp; color levels adjustment. If the value of grow is positive, the pixels will appear more &quot;fat&quot; or &quot;bold&quot; than the original. If the value is negative, a shrink effect happens instead.
 278     ///
 279     /// This is can be used efficiently to create glow effects.</summary>
 280     /// <value>How much to grow the original pixel data.</value>
 281     public double Grow {
 282         get { return GetGrow(); }
 283         set { SetGrow(value); }
 284     }
 285     /// <summary>Retrieves the general/main color of the given Evas object.
 286     /// Retrieves the main color&apos;s RGB component (and alpha channel) values, which range from 0 to 255. For the alpha channel, which defines the object&apos;s transparency level, 0 means totally transparent, while 255 means opaque. These color values are premultiplied by the alpha value.
 287     ///
 288     /// Usually youll use this attribute for text and rectangle objects, where the main color is their unique one. If set for objects which themselves have colors, like the images one, those colors get modulated by this one.
 289     ///
 290     /// All newly created Evas rectangles get the default color values of 255 255 255 255 (opaque white).
 291     ///
 292     /// Use null pointers on the components you&apos;re not interested in: they&apos;ll be ignored by the function.
 293     /// (Since EFL 1.22)</summary>
 294     public (int, int, int, int) Color {
 295         get {
 296             int _out_r = default(int);
 297             int _out_g = default(int);
 298             int _out_b = default(int);
 299             int _out_a = default(int);
 300             GetColor(out _out_r,out _out_g,out _out_b,out _out_a);
 301             return (_out_r,_out_g,_out_b,_out_a);
 302         }
 303         set { SetColor( value.Item1,  value.Item2,  value.Item3,  value.Item4); }
 304     }
 305     /// <summary>Get hex color code of given Evas object. This returns a short lived hex color code string.
 306     /// (Since EFL 1.22)</summary>
 307     /// <value>the hex color code.</value>
 308     public System.String ColorCode {
 309         get { return GetColorCode(); }
 310         set { SetColorCode(value); }
 311     }
 312     /// <summary>Gets the code of the filter program set on this object. May be <c>null</c>.</summary>
 313     /// <value>The Lua program source code.</value>
 314     public (System.String, System.String) FilterProgram {
 315         get {
 316             System.String _out_code = default(System.String);
 317             System.String _out_name = default(System.String);
 318             GetFilterProgram(out _out_code,out _out_name);
 319             return (_out_code,_out_name);
 320         }
 321         set { SetFilterProgram( value.Item1,  value.Item2); }
 322     }
 323     /// <summary>Set the current state of the filter.
 324     /// This should be used by Edje (EFL&apos;s internal layout engine), but could also be used when implementing animations programmatically.
 325     ///
 326     /// 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>
 327     /// <value>Current state of the filter</value>
 328     public (System.String, double, System.String, double, double) FilterState {
 329         get {
 330             System.String _out_cur_state = default(System.String);
 331             double _out_cur_val = default(double);
 332             System.String _out_next_state = default(System.String);
 333             double _out_next_val = default(double);
 334             double _out_pos = default(double);
 335             GetFilterState(out _out_cur_state,out _out_cur_val,out _out_next_state,out _out_next_val,out _out_pos);
 336             return (_out_cur_state,_out_cur_val,_out_next_state,_out_next_val,_out_pos);
 337         }
 338         set { SetFilterState( value.Item1,  value.Item2,  value.Item3,  value.Item4,  value.Item5); }
 339     }
 340     /// <summary>Required padding to apply this filter without cropping.
 341     /// Read-only property that can be used to calculate the object&apos;s final geometry. This can be overridden (set) from inside the filter program by using the function &apos;padding_set&apos; in the Lua program.</summary>
 342     public (int, int, int, int) FilterPadding {
 343         get {
 344             int _out_l = default(int);
 345             int _out_r = default(int);
 346             int _out_t = default(int);
 347             int _out_b = default(int);
 348             GetFilterPadding(out _out_l,out _out_r,out _out_t,out _out_b);
 349             return (_out_l,_out_r,_out_t,_out_b);
 350         }
 351     }
 352     private static IntPtr GetEflClassStatic()
 353     {
 354         return Efl.Ui.WidgetPartShadow.efl_ui_widget_part_shadow_class_get();
 355     }
 356     /// <summary>Wrapper for native methods and virtual method delegates.
 357     /// For internal use by generated code only.</summary>
 358     public new class NativeMethods : Efl.Ui.WidgetPart.NativeMethods
 359     {
 360         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Elementary);
 361         /// <summary>Gets the list of Eo operations to override.</summary>
 362         /// <returns>The list of Eo operations to be overload.</returns>
 363         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 364         {
 365             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 366             var methods = Efl.Eo.Globals.GetUserMethods(type);
 367
 368             if (efl_gfx_blur_radius_get_static_delegate == null)
 369             {
 370                 efl_gfx_blur_radius_get_static_delegate = new efl_gfx_blur_radius_get_delegate(radius_get);
 371             }
 372
 373             if (methods.FirstOrDefault(m => m.Name == "GetRadius") != null)
 374             {
 375                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_blur_radius_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_blur_radius_get_static_delegate) });
 376             }
 377
 378             if (efl_gfx_blur_radius_set_static_delegate == null)
 379             {
 380                 efl_gfx_blur_radius_set_static_delegate = new efl_gfx_blur_radius_set_delegate(radius_set);
 381             }
 382
 383             if (methods.FirstOrDefault(m => m.Name == "SetRadius") != null)
 384             {
 385                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_blur_radius_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_blur_radius_set_static_delegate) });
 386             }
 387
 388             if (efl_gfx_blur_offset_get_static_delegate == null)
 389             {
 390                 efl_gfx_blur_offset_get_static_delegate = new efl_gfx_blur_offset_get_delegate(offset_get);
 391             }
 392
 393             if (methods.FirstOrDefault(m => m.Name == "GetOffset") != null)
 394             {
 395                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_blur_offset_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_blur_offset_get_static_delegate) });
 396             }
 397
 398             if (efl_gfx_blur_offset_set_static_delegate == null)
 399             {
 400                 efl_gfx_blur_offset_set_static_delegate = new efl_gfx_blur_offset_set_delegate(offset_set);
 401             }
 402
 403             if (methods.FirstOrDefault(m => m.Name == "SetOffset") != null)
 404             {
 405                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_blur_offset_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_blur_offset_set_static_delegate) });
 406             }
 407
 408             if (efl_gfx_blur_grow_get_static_delegate == null)
 409             {
 410                 efl_gfx_blur_grow_get_static_delegate = new efl_gfx_blur_grow_get_delegate(grow_get);
 411             }
 412
 413             if (methods.FirstOrDefault(m => m.Name == "GetGrow") != null)
 414             {
 415                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_blur_grow_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_blur_grow_get_static_delegate) });
 416             }
 417
 418             if (efl_gfx_blur_grow_set_static_delegate == null)
 419             {
 420                 efl_gfx_blur_grow_set_static_delegate = new efl_gfx_blur_grow_set_delegate(grow_set);
 421             }
 422
 423             if (methods.FirstOrDefault(m => m.Name == "SetGrow") != null)
 424             {
 425                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_blur_grow_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_blur_grow_set_static_delegate) });
 426             }
 427
 428             if (efl_gfx_color_get_static_delegate == null)
 429             {
 430                 efl_gfx_color_get_static_delegate = new efl_gfx_color_get_delegate(color_get);
 431             }
 432
 433             if (methods.FirstOrDefault(m => m.Name == "GetColor") != null)
 434             {
 435                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_get_static_delegate) });
 436             }
 437
 438             if (efl_gfx_color_set_static_delegate == null)
 439             {
 440                 efl_gfx_color_set_static_delegate = new efl_gfx_color_set_delegate(color_set);
 441             }
 442
 443             if (methods.FirstOrDefault(m => m.Name == "SetColor") != null)
 444             {
 445                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_set_static_delegate) });
 446             }
 447
 448             if (efl_gfx_color_code_get_static_delegate == null)
 449             {
 450                 efl_gfx_color_code_get_static_delegate = new efl_gfx_color_code_get_delegate(color_code_get);
 451             }
 452
 453             if (methods.FirstOrDefault(m => m.Name == "GetColorCode") != null)
 454             {
 455                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_code_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_code_get_static_delegate) });
 456             }
 457
 458             if (efl_gfx_color_code_set_static_delegate == null)
 459             {
 460                 efl_gfx_color_code_set_static_delegate = new efl_gfx_color_code_set_delegate(color_code_set);
 461             }
 462
 463             if (methods.FirstOrDefault(m => m.Name == "SetColorCode") != null)
 464             {
 465                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_color_code_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_color_code_set_static_delegate) });
 466             }
 467
 468             if (efl_gfx_filter_program_get_static_delegate == null)
 469             {
 470                 efl_gfx_filter_program_get_static_delegate = new efl_gfx_filter_program_get_delegate(filter_program_get);
 471             }
 472
 473             if (methods.FirstOrDefault(m => m.Name == "GetFilterProgram") != null)
 474             {
 475                 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) });
 476             }
 477
 478             if (efl_gfx_filter_program_set_static_delegate == null)
 479             {
 480                 efl_gfx_filter_program_set_static_delegate = new efl_gfx_filter_program_set_delegate(filter_program_set);
 481             }
 482
 483             if (methods.FirstOrDefault(m => m.Name == "SetFilterProgram") != null)
 484             {
 485                 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) });
 486             }
 487
 488             if (efl_gfx_filter_state_get_static_delegate == null)
 489             {
 490                 efl_gfx_filter_state_get_static_delegate = new efl_gfx_filter_state_get_delegate(filter_state_get);
 491             }
 492
 493             if (methods.FirstOrDefault(m => m.Name == "GetFilterState") != null)
 494             {
 495                 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) });
 496             }
 497
 498             if (efl_gfx_filter_state_set_static_delegate == null)
 499             {
 500                 efl_gfx_filter_state_set_static_delegate = new efl_gfx_filter_state_set_delegate(filter_state_set);
 501             }
 502
 503             if (methods.FirstOrDefault(m => m.Name == "SetFilterState") != null)
 504             {
 505                 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) });
 506             }
 507
 508             if (efl_gfx_filter_padding_get_static_delegate == null)
 509             {
 510                 efl_gfx_filter_padding_get_static_delegate = new efl_gfx_filter_padding_get_delegate(filter_padding_get);
 511             }
 512
 513             if (methods.FirstOrDefault(m => m.Name == "GetFilterPadding") != null)
 514             {
 515                 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) });
 516             }
 517
 518             if (efl_gfx_filter_source_get_static_delegate == null)
 519             {
 520                 efl_gfx_filter_source_get_static_delegate = new efl_gfx_filter_source_get_delegate(filter_source_get);
 521             }
 522
 523             if (methods.FirstOrDefault(m => m.Name == "GetFilterSource") != null)
 524             {
 525                 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) });
 526             }
 527
 528             if (efl_gfx_filter_source_set_static_delegate == null)
 529             {
 530                 efl_gfx_filter_source_set_static_delegate = new efl_gfx_filter_source_set_delegate(filter_source_set);
 531             }
 532
 533             if (methods.FirstOrDefault(m => m.Name == "SetFilterSource") != null)
 534             {
 535                 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) });
 536             }
 537
 538             if (efl_gfx_filter_data_get_static_delegate == null)
 539             {
 540                 efl_gfx_filter_data_get_static_delegate = new efl_gfx_filter_data_get_delegate(filter_data_get);
 541             }
 542
 543             if (methods.FirstOrDefault(m => m.Name == "GetFilterData") != null)
 544             {
 545                 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) });
 546             }
 547
 548             if (efl_gfx_filter_data_set_static_delegate == null)
 549             {
 550                 efl_gfx_filter_data_set_static_delegate = new efl_gfx_filter_data_set_delegate(filter_data_set);
 551             }
 552
 553             if (methods.FirstOrDefault(m => m.Name == "SetFilterData") != null)
 554             {
 555                 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) });
 556             }
 557
 558             descs.AddRange(base.GetEoOps(type));
 559             return descs;
 560         }
 561         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 562         /// <returns>The native class pointer.</returns>
 563         public override IntPtr GetEflClass()
 564         {
 565             return Efl.Ui.WidgetPartShadow.efl_ui_widget_part_shadow_class_get();
 566         }
 567
 568         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 569
 570
 571         private delegate void efl_gfx_blur_radius_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double rx,  out double ry);
 572
 573
 574         public delegate void efl_gfx_blur_radius_get_api_delegate(System.IntPtr obj,  out double rx,  out double ry);
 575
 576         public static Efl.Eo.FunctionWrapper<efl_gfx_blur_radius_get_api_delegate> efl_gfx_blur_radius_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_blur_radius_get_api_delegate>(Module, "efl_gfx_blur_radius_get");
 577
 578         private static void radius_get(System.IntPtr obj, System.IntPtr pd, out double rx, out double ry)
 579         {
 580             Eina.Log.Debug("function efl_gfx_blur_radius_get was called");
 581             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 582             if (ws != null)
 583             {
 584                         rx = default(double);        ry = default(double);
 585                 try
 586                 {
 587                     ((WidgetPartShadow)ws.Target).GetRadius(out rx, out ry);
 588                 }
 589                 catch (Exception e)
 590                 {
 591                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 592                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 593                 }
 594
 595
 596             }
 597             else
 598             {
 599                 efl_gfx_blur_radius_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out rx, out ry);
 600             }
 601         }
 602
 603         private static efl_gfx_blur_radius_get_delegate efl_gfx_blur_radius_get_static_delegate;
 604
 605
 606         private delegate void efl_gfx_blur_radius_set_delegate(System.IntPtr obj, System.IntPtr pd,  double rx,  double ry);
 607
 608
 609         public delegate void efl_gfx_blur_radius_set_api_delegate(System.IntPtr obj,  double rx,  double ry);
 610
 611         public static Efl.Eo.FunctionWrapper<efl_gfx_blur_radius_set_api_delegate> efl_gfx_blur_radius_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_blur_radius_set_api_delegate>(Module, "efl_gfx_blur_radius_set");
 612
 613         private static void radius_set(System.IntPtr obj, System.IntPtr pd, double rx, double ry)
 614         {
 615             Eina.Log.Debug("function efl_gfx_blur_radius_set was called");
 616             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 617             if (ws != null)
 618             {
 619
 620                 try
 621                 {
 622                     ((WidgetPartShadow)ws.Target).SetRadius(rx, ry);
 623                 }
 624                 catch (Exception e)
 625                 {
 626                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 627                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 628                 }
 629
 630
 631             }
 632             else
 633             {
 634                 efl_gfx_blur_radius_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rx, ry);
 635             }
 636         }
 637
 638         private static efl_gfx_blur_radius_set_delegate efl_gfx_blur_radius_set_static_delegate;
 639
 640
 641         private delegate void efl_gfx_blur_offset_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double ox,  out double oy);
 642
 643
 644         public delegate void efl_gfx_blur_offset_get_api_delegate(System.IntPtr obj,  out double ox,  out double oy);
 645
 646         public static Efl.Eo.FunctionWrapper<efl_gfx_blur_offset_get_api_delegate> efl_gfx_blur_offset_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_blur_offset_get_api_delegate>(Module, "efl_gfx_blur_offset_get");
 647
 648         private static void offset_get(System.IntPtr obj, System.IntPtr pd, out double ox, out double oy)
 649         {
 650             Eina.Log.Debug("function efl_gfx_blur_offset_get was called");
 651             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 652             if (ws != null)
 653             {
 654                         ox = default(double);        oy = default(double);
 655                 try
 656                 {
 657                     ((WidgetPartShadow)ws.Target).GetOffset(out ox, out oy);
 658                 }
 659                 catch (Exception e)
 660                 {
 661                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 662                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 663                 }
 664
 665
 666             }
 667             else
 668             {
 669                 efl_gfx_blur_offset_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out ox, out oy);
 670             }
 671         }
 672
 673         private static efl_gfx_blur_offset_get_delegate efl_gfx_blur_offset_get_static_delegate;
 674
 675
 676         private delegate void efl_gfx_blur_offset_set_delegate(System.IntPtr obj, System.IntPtr pd,  double ox,  double oy);
 677
 678
 679         public delegate void efl_gfx_blur_offset_set_api_delegate(System.IntPtr obj,  double ox,  double oy);
 680
 681         public static Efl.Eo.FunctionWrapper<efl_gfx_blur_offset_set_api_delegate> efl_gfx_blur_offset_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_blur_offset_set_api_delegate>(Module, "efl_gfx_blur_offset_set");
 682
 683         private static void offset_set(System.IntPtr obj, System.IntPtr pd, double ox, double oy)
 684         {
 685             Eina.Log.Debug("function efl_gfx_blur_offset_set was called");
 686             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 687             if (ws != null)
 688             {
 689
 690                 try
 691                 {
 692                     ((WidgetPartShadow)ws.Target).SetOffset(ox, oy);
 693                 }
 694                 catch (Exception e)
 695                 {
 696                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 697                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 698                 }
 699
 700
 701             }
 702             else
 703             {
 704                 efl_gfx_blur_offset_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ox, oy);
 705             }
 706         }
 707
 708         private static efl_gfx_blur_offset_set_delegate efl_gfx_blur_offset_set_static_delegate;
 709
 710
 711         private delegate double efl_gfx_blur_grow_get_delegate(System.IntPtr obj, System.IntPtr pd);
 712
 713
 714         public delegate double efl_gfx_blur_grow_get_api_delegate(System.IntPtr obj);
 715
 716         public static Efl.Eo.FunctionWrapper<efl_gfx_blur_grow_get_api_delegate> efl_gfx_blur_grow_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_blur_grow_get_api_delegate>(Module, "efl_gfx_blur_grow_get");
 717
 718         private static double grow_get(System.IntPtr obj, System.IntPtr pd)
 719         {
 720             Eina.Log.Debug("function efl_gfx_blur_grow_get was called");
 721             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 722             if (ws != null)
 723             {
 724             double _ret_var = default(double);
 725                 try
 726                 {
 727                     _ret_var = ((WidgetPartShadow)ws.Target).GetGrow();
 728                 }
 729                 catch (Exception e)
 730                 {
 731                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 732                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 733                 }
 734
 735         return _ret_var;
 736
 737             }
 738             else
 739             {
 740                 return efl_gfx_blur_grow_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 741             }
 742         }
 743
 744         private static efl_gfx_blur_grow_get_delegate efl_gfx_blur_grow_get_static_delegate;
 745
 746
 747         private delegate void efl_gfx_blur_grow_set_delegate(System.IntPtr obj, System.IntPtr pd,  double radius);
 748
 749
 750         public delegate void efl_gfx_blur_grow_set_api_delegate(System.IntPtr obj,  double radius);
 751
 752         public static Efl.Eo.FunctionWrapper<efl_gfx_blur_grow_set_api_delegate> efl_gfx_blur_grow_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_blur_grow_set_api_delegate>(Module, "efl_gfx_blur_grow_set");
 753
 754         private static void grow_set(System.IntPtr obj, System.IntPtr pd, double radius)
 755         {
 756             Eina.Log.Debug("function efl_gfx_blur_grow_set was called");
 757             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 758             if (ws != null)
 759             {
 760
 761                 try
 762                 {
 763                     ((WidgetPartShadow)ws.Target).SetGrow(radius);
 764                 }
 765                 catch (Exception e)
 766                 {
 767                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 768                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 769                 }
 770
 771
 772             }
 773             else
 774             {
 775                 efl_gfx_blur_grow_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radius);
 776             }
 777         }
 778
 779         private static efl_gfx_blur_grow_set_delegate efl_gfx_blur_grow_set_static_delegate;
 780
 781
 782         private delegate void efl_gfx_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int r,  out int g,  out int b,  out int a);
 783
 784
 785         public delegate void efl_gfx_color_get_api_delegate(System.IntPtr obj,  out int r,  out int g,  out int b,  out int a);
 786
 787         public static Efl.Eo.FunctionWrapper<efl_gfx_color_get_api_delegate> efl_gfx_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_get_api_delegate>(Module, "efl_gfx_color_get");
 788
 789         private static void color_get(System.IntPtr obj, System.IntPtr pd, out int r, out int g, out int b, out int a)
 790         {
 791             Eina.Log.Debug("function efl_gfx_color_get was called");
 792             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 793             if (ws != null)
 794             {
 795                                         r = default(int);        g = default(int);        b = default(int);        a = default(int);
 796                 try
 797                 {
 798                     ((WidgetPartShadow)ws.Target).GetColor(out r, out g, out b, out a);
 799                 }
 800                 catch (Exception e)
 801                 {
 802                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 803                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 804                 }
 805
 806
 807             }
 808             else
 809             {
 810                 efl_gfx_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
 811             }
 812         }
 813
 814         private static efl_gfx_color_get_delegate efl_gfx_color_get_static_delegate;
 815
 816
 817         private delegate void efl_gfx_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  int r,  int g,  int b,  int a);
 818
 819
 820         public delegate void efl_gfx_color_set_api_delegate(System.IntPtr obj,  int r,  int g,  int b,  int a);
 821
 822         public static Efl.Eo.FunctionWrapper<efl_gfx_color_set_api_delegate> efl_gfx_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_set_api_delegate>(Module, "efl_gfx_color_set");
 823
 824         private static void color_set(System.IntPtr obj, System.IntPtr pd, int r, int g, int b, int a)
 825         {
 826             Eina.Log.Debug("function efl_gfx_color_set was called");
 827             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 828             if (ws != null)
 829             {
 830
 831                 try
 832                 {
 833                     ((WidgetPartShadow)ws.Target).SetColor(r, g, b, a);
 834                 }
 835                 catch (Exception e)
 836                 {
 837                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 838                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 839                 }
 840
 841
 842             }
 843             else
 844             {
 845                 efl_gfx_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
 846             }
 847         }
 848
 849         private static efl_gfx_color_set_delegate efl_gfx_color_set_static_delegate;
 850
 851         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 852         private delegate System.String efl_gfx_color_code_get_delegate(System.IntPtr obj, System.IntPtr pd);
 853
 854         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 855         public delegate System.String efl_gfx_color_code_get_api_delegate(System.IntPtr obj);
 856
 857         public static Efl.Eo.FunctionWrapper<efl_gfx_color_code_get_api_delegate> efl_gfx_color_code_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_code_get_api_delegate>(Module, "efl_gfx_color_code_get");
 858
 859         private static System.String color_code_get(System.IntPtr obj, System.IntPtr pd)
 860         {
 861             Eina.Log.Debug("function efl_gfx_color_code_get was called");
 862             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 863             if (ws != null)
 864             {
 865             System.String _ret_var = default(System.String);
 866                 try
 867                 {
 868                     _ret_var = ((WidgetPartShadow)ws.Target).GetColorCode();
 869                 }
 870                 catch (Exception e)
 871                 {
 872                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 873                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 874                 }
 875
 876         return _ret_var;
 877
 878             }
 879             else
 880             {
 881                 return efl_gfx_color_code_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 882             }
 883         }
 884
 885         private static efl_gfx_color_code_get_delegate efl_gfx_color_code_get_static_delegate;
 886
 887
 888         private delegate void efl_gfx_color_code_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String colorcode);
 889
 890
 891         public delegate void efl_gfx_color_code_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String colorcode);
 892
 893         public static Efl.Eo.FunctionWrapper<efl_gfx_color_code_set_api_delegate> efl_gfx_color_code_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_color_code_set_api_delegate>(Module, "efl_gfx_color_code_set");
 894
 895         private static void color_code_set(System.IntPtr obj, System.IntPtr pd, System.String colorcode)
 896         {
 897             Eina.Log.Debug("function efl_gfx_color_code_set was called");
 898             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 899             if (ws != null)
 900             {
 901
 902                 try
 903                 {
 904                     ((WidgetPartShadow)ws.Target).SetColorCode(colorcode);
 905                 }
 906                 catch (Exception e)
 907                 {
 908                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 909                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 910                 }
 911
 912
 913             }
 914             else
 915             {
 916                 efl_gfx_color_code_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), colorcode);
 917             }
 918         }
 919
 920         private static efl_gfx_color_code_set_delegate efl_gfx_color_code_set_static_delegate;
 921
 922
 923         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);
 924
 925
 926         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);
 927
 928         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");
 929
 930         private static void filter_program_get(System.IntPtr obj, System.IntPtr pd, out System.String code, out System.String name)
 931         {
 932             Eina.Log.Debug("function efl_gfx_filter_program_get was called");
 933             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 934             if (ws != null)
 935             {
 936                         System.String _out_code = default(System.String);
 937         System.String _out_name = default(System.String);
 938
 939                 try
 940                 {
 941                     ((WidgetPartShadow)ws.Target).GetFilterProgram(out _out_code, out _out_name);
 942                 }
 943                 catch (Exception e)
 944                 {
 945                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 946                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 947                 }
 948
 949         code = _out_code;
 950         name = _out_name;
 951
 952             }
 953             else
 954             {
 955                 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);
 956             }
 957         }
 958
 959         private static efl_gfx_filter_program_get_delegate efl_gfx_filter_program_get_static_delegate;
 960
 961
 962         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);
 963
 964
 965         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);
 966
 967         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");
 968
 969         private static void filter_program_set(System.IntPtr obj, System.IntPtr pd, System.String code, System.String name)
 970         {
 971             Eina.Log.Debug("function efl_gfx_filter_program_set was called");
 972             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 973             if (ws != null)
 974             {
 975
 976                 try
 977                 {
 978                     ((WidgetPartShadow)ws.Target).SetFilterProgram(code, name);
 979                 }
 980                 catch (Exception e)
 981                 {
 982                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 983                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 984                 }
 985
 986
 987             }
 988             else
 989             {
 990                 efl_gfx_filter_program_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), code, name);
 991             }
 992         }
 993
 994         private static efl_gfx_filter_program_set_delegate efl_gfx_filter_program_set_static_delegate;
 995
 996
 997         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);
 998
 999
1000         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);
1001
1002         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");
1003
1004         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)
1005         {
1006             Eina.Log.Debug("function efl_gfx_filter_state_get was called");
1007             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1008             if (ws != null)
1009             {
1010                                                 System.String _out_cur_state = default(System.String);
1011         cur_val = default(double);        System.String _out_next_state = default(System.String);
1012         next_val = default(double);        pos = default(double);
1013                 try
1014                 {
1015                     ((WidgetPartShadow)ws.Target).GetFilterState(out _out_cur_state, out cur_val, out _out_next_state, out next_val, out pos);
1016                 }
1017                 catch (Exception e)
1018                 {
1019                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1020                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1021                 }
1022
1023         cur_state = _out_cur_state;
1024                 next_state = _out_next_state;
1025
1026             }
1027             else
1028             {
1029                 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);
1030             }
1031         }
1032
1033         private static efl_gfx_filter_state_get_delegate efl_gfx_filter_state_get_static_delegate;
1034
1035
1036         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);
1037
1038
1039         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);
1040
1041         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");
1042
1043         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)
1044         {
1045             Eina.Log.Debug("function efl_gfx_filter_state_set was called");
1046             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1047             if (ws != null)
1048             {
1049
1050                 try
1051                 {
1052                     ((WidgetPartShadow)ws.Target).SetFilterState(cur_state, cur_val, next_state, next_val, pos);
1053                 }
1054                 catch (Exception e)
1055                 {
1056                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1057                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1058                 }
1059
1060
1061             }
1062             else
1063             {
1064                 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);
1065             }
1066         }
1067
1068         private static efl_gfx_filter_state_set_delegate efl_gfx_filter_state_set_static_delegate;
1069
1070
1071         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);
1072
1073
1074         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);
1075
1076         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");
1077
1078         private static void filter_padding_get(System.IntPtr obj, System.IntPtr pd, out int l, out int r, out int t, out int b)
1079         {
1080             Eina.Log.Debug("function efl_gfx_filter_padding_get was called");
1081             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1082             if (ws != null)
1083             {
1084                                         l = default(int);        r = default(int);        t = default(int);        b = default(int);
1085                 try
1086                 {
1087                     ((WidgetPartShadow)ws.Target).GetFilterPadding(out l, out r, out t, out b);
1088                 }
1089                 catch (Exception e)
1090                 {
1091                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1092                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1093                 }
1094
1095
1096             }
1097             else
1098             {
1099                 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);
1100             }
1101         }
1102
1103         private static efl_gfx_filter_padding_get_delegate efl_gfx_filter_padding_get_static_delegate;
1104
1105         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1106         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);
1107
1108         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
1109         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);
1110
1111         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");
1112
1113         private static Efl.Gfx.IEntity filter_source_get(System.IntPtr obj, System.IntPtr pd, System.String name)
1114         {
1115             Eina.Log.Debug("function efl_gfx_filter_source_get was called");
1116             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1117             if (ws != null)
1118             {
1119                                     Efl.Gfx.IEntity _ret_var = default(Efl.Gfx.IEntity);
1120                 try
1121                 {
1122                     _ret_var = ((WidgetPartShadow)ws.Target).GetFilterSource(name);
1123                 }
1124                 catch (Exception e)
1125                 {
1126                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1127                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1128                 }
1129
1130                         return _ret_var;
1131
1132             }
1133             else
1134             {
1135                 return efl_gfx_filter_source_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name);
1136             }
1137         }
1138
1139         private static efl_gfx_filter_source_get_delegate efl_gfx_filter_source_get_static_delegate;
1140
1141
1142         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);
1143
1144
1145         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);
1146
1147         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");
1148
1149         private static void filter_source_set(System.IntPtr obj, System.IntPtr pd, System.String name, Efl.Gfx.IEntity source)
1150         {
1151             Eina.Log.Debug("function efl_gfx_filter_source_set was called");
1152             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1153             if (ws != null)
1154             {
1155
1156                 try
1157                 {
1158                     ((WidgetPartShadow)ws.Target).SetFilterSource(name, source);
1159                 }
1160                 catch (Exception e)
1161                 {
1162                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1163                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1164                 }
1165
1166
1167             }
1168             else
1169             {
1170                 efl_gfx_filter_source_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, source);
1171             }
1172         }
1173
1174         private static efl_gfx_filter_source_set_delegate efl_gfx_filter_source_set_static_delegate;
1175
1176
1177         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);
1178
1179
1180         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);
1181
1182         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");
1183
1184         private static void filter_data_get(System.IntPtr obj, System.IntPtr pd, System.String name, out System.String value, out bool execute)
1185         {
1186             Eina.Log.Debug("function efl_gfx_filter_data_get was called");
1187             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1188             if (ws != null)
1189             {
1190                                         System.String _out_value = default(System.String);
1191         execute = default(bool);
1192                 try
1193                 {
1194                     ((WidgetPartShadow)ws.Target).GetFilterData(name, out _out_value, out execute);
1195                 }
1196                 catch (Exception e)
1197                 {
1198                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1199                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1200                 }
1201
1202                 value = _out_value;
1203
1204             }
1205             else
1206             {
1207                 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);
1208             }
1209         }
1210
1211         private static efl_gfx_filter_data_get_delegate efl_gfx_filter_data_get_static_delegate;
1212
1213
1214         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);
1215
1216
1217         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);
1218
1219         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");
1220
1221         private static void filter_data_set(System.IntPtr obj, System.IntPtr pd, System.String name, System.String value, bool execute)
1222         {
1223             Eina.Log.Debug("function efl_gfx_filter_data_set was called");
1224             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1225             if (ws != null)
1226             {
1227
1228                 try
1229                 {
1230                     ((WidgetPartShadow)ws.Target).SetFilterData(name, value, execute);
1231                 }
1232                 catch (Exception e)
1233                 {
1234                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1235                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1236                 }
1237
1238
1239             }
1240             else
1241             {
1242                 efl_gfx_filter_data_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), name, value, execute);
1243             }
1244         }
1245
1246         private static efl_gfx_filter_data_set_delegate efl_gfx_filter_data_set_static_delegate;
1247
1248         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1249
1250 }
1251 }
1252 }
1253
1254 }
1255
1256 #if EFL_BETA
1257 #pragma warning disable CS1591
1258 public static class Efl_UiWidgetPartShadow_ExtensionMethods {
1259
1260
1261     public static Efl.BindableProperty<double> Grow<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartShadow, T>magic = null) where T : Efl.Ui.WidgetPartShadow {
1262         return new Efl.BindableProperty<double>("grow", fac);
1263     }
1264
1265
1266     public static Efl.BindableProperty<System.String> ColorCode<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<Efl.Ui.WidgetPartShadow, T>magic = null) where T : Efl.Ui.WidgetPartShadow {
1267         return new Efl.BindableProperty<System.String>("color_code", fac);
1268     }
1269
1270
1271
1272
1273
1274
1275 }
1276 #pragma warning restore CS1591
1277 #endif