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