internals/src/EflSharp/EflSharp/efl/efl_gfx_blur.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 Gfx {
  11
  12 /// <summary>A simple API to apply blur effects.
  13 /// Those API&apos;s might use <see cref="Efl.Gfx.IFilter"/> internally. It might be necessary to also specify the color of the blur with <see cref="Efl.Gfx.IColor.GetColor"/>.</summary>
  14 [Efl.Gfx.IBlurConcrete.NativeMethods]
  15 public interface IBlur :
  16     Efl.Eo.IWrapper, IDisposable
  17 {
  18     /// <summary>The blur radius in pixels.</summary>
  19 /// <param name="rx">The horizontal blur radius.</param>
  20 /// <param name="ry">The vertical blur radius.</param>
  21 void GetRadius(out double rx, out double ry);
  22     /// <summary>The blur radius in pixels.</summary>
  23 /// <param name="rx">The horizontal blur radius.</param>
  24 /// <param name="ry">The vertical blur radius.</param>
  25 void SetRadius(double rx, double ry);
  26     /// <summary>An offset relative to the original pixels.
  27 /// This property allows for drop shadow effects.</summary>
  28 /// <param name="ox">Horizontal offset in pixels.</param>
  29 /// <param name="oy">Vertical offset in pixels.</param>
  30 void GetOffset(out double ox, out double oy);
  31     /// <summary>An offset relative to the original pixels.
  32 /// This property allows for drop shadow effects.</summary>
  33 /// <param name="ox">Horizontal offset in pixels.</param>
  34 /// <param name="oy">Vertical offset in pixels.</param>
  35 void SetOffset(double ox, double oy);
  36     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
  37 /// 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.
  38 ///
  39 /// This is can be used efficiently to create glow effects.</summary>
  40 /// <returns>How much to grow the original pixel data.</returns>
  41 double GetGrow();
  42     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
  43 /// 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.
  44 ///
  45 /// This is can be used efficiently to create glow effects.</summary>
  46 /// <param name="radius">How much to grow the original pixel data.</param>
  47 void SetGrow(double radius);
  48                             /// <summary>How much the original image should be &quot;grown&quot; before blurring.
  49 /// 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.
  50 ///
  51 /// This is can be used efficiently to create glow effects.</summary>
  52 /// <value>How much to grow the original pixel data.</value>
  53     double Grow {
  54         get ;
  55         set ;
  56     }
  57 }
  58 /// <summary>A simple API to apply blur effects.
  59 /// Those API&apos;s might use <see cref="Efl.Gfx.IFilter"/> internally. It might be necessary to also specify the color of the blur with <see cref="Efl.Gfx.IColor.GetColor"/>.</summary>
  60 sealed public class IBlurConcrete :
  61
  62 IBlur
  63
  64 {
  65     ///<summary>Pointer to the native class description.</summary>
  66     public System.IntPtr NativeClass
  67     {
  68         get
  69         {
  70             if (((object)this).GetType() == typeof(IBlurConcrete))
  71             {
  72                 return GetEflClassStatic();
  73             }
  74             else
  75             {
  76                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  77             }
  78         }
  79     }
  80
  81     private  System.IntPtr handle;
  82     ///<summary>Pointer to the native instance.</summary>
  83     public System.IntPtr NativeHandle
  84     {
  85         get { return handle; }
  86     }
  87
  88     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
  89         efl_gfx_blur_interface_get();
  90     /// <summary>Initializes a new instance of the <see cref="IBlur"/> class.
  91     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  92     private IBlurConcrete(System.IntPtr raw)
  93     {
  94         handle = raw;
  95     }
  96     ///<summary>Destructor.</summary>
  97     ~IBlurConcrete()
  98     {
  99         Dispose(false);
 100     }
 101
 102     ///<summary>Releases the underlying native instance.</summary>
 103     private void Dispose(bool disposing)
 104     {
 105         if (handle != System.IntPtr.Zero)
 106         {
 107             IntPtr h = handle;
 108             handle = IntPtr.Zero;
 109
 110             IntPtr gcHandlePtr = IntPtr.Zero;
 111             if (disposing)
 112             {
 113                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 114             }
 115             else
 116             {
 117                 Monitor.Enter(Efl.All.InitLock);
 118                 if (Efl.All.MainLoopInitialized)
 119                 {
 120                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 121                 }
 122
 123                 Monitor.Exit(Efl.All.InitLock);
 124             }
 125         }
 126
 127     }
 128
 129     ///<summary>Releases the underlying native instance.</summary>
 130     public void Dispose()
 131     {
 132         Dispose(true);
 133         GC.SuppressFinalize(this);
 134     }
 135
 136     /// <summary>Verifies if the given object is equal to this one.</summary>
 137     /// <param name="instance">The object to compare to.</param>
 138     /// <returns>True if both objects point to the same native object.</returns>
 139     public override bool Equals(object instance)
 140     {
 141         var other = instance as Efl.Object;
 142         if (other == null)
 143         {
 144             return false;
 145         }
 146         return this.NativeHandle == other.NativeHandle;
 147     }
 148
 149     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 150     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 151     public override int GetHashCode()
 152     {
 153         return this.NativeHandle.ToInt32();
 154     }
 155
 156     /// <summary>Turns the native pointer into a string representation.</summary>
 157     /// <returns>A string with the type and the native pointer for this object.</returns>
 158     public override String ToString()
 159     {
 160         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 161     }
 162
 163     /// <summary>The blur radius in pixels.</summary>
 164     /// <param name="rx">The horizontal blur radius.</param>
 165     /// <param name="ry">The vertical blur radius.</param>
 166     public void GetRadius(out double rx, out double ry) {
 167                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_radius_get_ptr.Value.Delegate(this.NativeHandle,out rx, out ry);
 168         Eina.Error.RaiseIfUnhandledException();
 169                                          }
 170     /// <summary>The blur radius in pixels.</summary>
 171     /// <param name="rx">The horizontal blur radius.</param>
 172     /// <param name="ry">The vertical blur radius.</param>
 173     public void SetRadius(double rx, double ry) {
 174                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_radius_set_ptr.Value.Delegate(this.NativeHandle,rx, ry);
 175         Eina.Error.RaiseIfUnhandledException();
 176                                          }
 177     /// <summary>An offset relative to the original pixels.
 178     /// This property allows for drop shadow effects.</summary>
 179     /// <param name="ox">Horizontal offset in pixels.</param>
 180     /// <param name="oy">Vertical offset in pixels.</param>
 181     public void GetOffset(out double ox, out double oy) {
 182                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_offset_get_ptr.Value.Delegate(this.NativeHandle,out ox, out oy);
 183         Eina.Error.RaiseIfUnhandledException();
 184                                          }
 185     /// <summary>An offset relative to the original pixels.
 186     /// This property allows for drop shadow effects.</summary>
 187     /// <param name="ox">Horizontal offset in pixels.</param>
 188     /// <param name="oy">Vertical offset in pixels.</param>
 189     public void SetOffset(double ox, double oy) {
 190                                                          Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_offset_set_ptr.Value.Delegate(this.NativeHandle,ox, oy);
 191         Eina.Error.RaiseIfUnhandledException();
 192                                          }
 193     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
 194     /// 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.
 195     ///
 196     /// This is can be used efficiently to create glow effects.</summary>
 197     /// <returns>How much to grow the original pixel data.</returns>
 198     public double GetGrow() {
 199          var _ret_var = Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_grow_get_ptr.Value.Delegate(this.NativeHandle);
 200         Eina.Error.RaiseIfUnhandledException();
 201         return _ret_var;
 202  }
 203     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
 204     /// 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.
 205     ///
 206     /// This is can be used efficiently to create glow effects.</summary>
 207     /// <param name="radius">How much to grow the original pixel data.</param>
 208     public void SetGrow(double radius) {
 209                                  Efl.Gfx.IBlurConcrete.NativeMethods.efl_gfx_blur_grow_set_ptr.Value.Delegate(this.NativeHandle,radius);
 210         Eina.Error.RaiseIfUnhandledException();
 211                          }
 212     /// <summary>How much the original image should be &quot;grown&quot; before blurring.
 213 /// 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.
 214 ///
 215 /// This is can be used efficiently to create glow effects.</summary>
 216 /// <value>How much to grow the original pixel data.</value>
 217     public double Grow {
 218         get { return GetGrow(); }
 219         set { SetGrow(value); }
 220     }
 221     private static IntPtr GetEflClassStatic()
 222     {
 223         return Efl.Gfx.IBlurConcrete.efl_gfx_blur_interface_get();
 224     }
 225     /// <summary>Wrapper for native methods and virtual method delegates.
 226     /// For internal use by generated code only.</summary>
 227     public class NativeMethods  : Efl.Eo.NativeClass
 228     {
 229         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 230         /// <summary>Gets the list of Eo operations to override.</summary>
 231         /// <returns>The list of Eo operations to be overload.</returns>
 232         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 233         {
 234             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 235             var methods = Efl.Eo.Globals.GetUserMethods(type);
 236
 237             if (efl_gfx_blur_radius_get_static_delegate == null)
 238             {
 239                 efl_gfx_blur_radius_get_static_delegate = new efl_gfx_blur_radius_get_delegate(radius_get);
 240             }
 241
 242             if (methods.FirstOrDefault(m => m.Name == "GetRadius") != null)
 243             {
 244                 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) });
 245             }
 246
 247             if (efl_gfx_blur_radius_set_static_delegate == null)
 248             {
 249                 efl_gfx_blur_radius_set_static_delegate = new efl_gfx_blur_radius_set_delegate(radius_set);
 250             }
 251
 252             if (methods.FirstOrDefault(m => m.Name == "SetRadius") != null)
 253             {
 254                 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) });
 255             }
 256
 257             if (efl_gfx_blur_offset_get_static_delegate == null)
 258             {
 259                 efl_gfx_blur_offset_get_static_delegate = new efl_gfx_blur_offset_get_delegate(offset_get);
 260             }
 261
 262             if (methods.FirstOrDefault(m => m.Name == "GetOffset") != null)
 263             {
 264                 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) });
 265             }
 266
 267             if (efl_gfx_blur_offset_set_static_delegate == null)
 268             {
 269                 efl_gfx_blur_offset_set_static_delegate = new efl_gfx_blur_offset_set_delegate(offset_set);
 270             }
 271
 272             if (methods.FirstOrDefault(m => m.Name == "SetOffset") != null)
 273             {
 274                 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) });
 275             }
 276
 277             if (efl_gfx_blur_grow_get_static_delegate == null)
 278             {
 279                 efl_gfx_blur_grow_get_static_delegate = new efl_gfx_blur_grow_get_delegate(grow_get);
 280             }
 281
 282             if (methods.FirstOrDefault(m => m.Name == "GetGrow") != null)
 283             {
 284                 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) });
 285             }
 286
 287             if (efl_gfx_blur_grow_set_static_delegate == null)
 288             {
 289                 efl_gfx_blur_grow_set_static_delegate = new efl_gfx_blur_grow_set_delegate(grow_set);
 290             }
 291
 292             if (methods.FirstOrDefault(m => m.Name == "SetGrow") != null)
 293             {
 294                 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) });
 295             }
 296
 297             return descs;
 298         }
 299         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 300         /// <returns>The native class pointer.</returns>
 301         public override IntPtr GetEflClass()
 302         {
 303             return Efl.Gfx.IBlurConcrete.efl_gfx_blur_interface_get();
 304         }
 305
 306         #pragma warning disable CA1707, SA1300, SA1600
 307
 308
 309         private delegate void efl_gfx_blur_radius_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double rx,  out double ry);
 310
 311
 312         public delegate void efl_gfx_blur_radius_get_api_delegate(System.IntPtr obj,  out double rx,  out double ry);
 313
 314         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");
 315
 316         private static void radius_get(System.IntPtr obj, System.IntPtr pd, out double rx, out double ry)
 317         {
 318             Eina.Log.Debug("function efl_gfx_blur_radius_get was called");
 319             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 320             if (wrapper != null)
 321             {
 322                         rx = default(double);        ry = default(double);
 323                 try
 324                 {
 325                     ((IBlur)wrapper).GetRadius(out rx, out ry);
 326                 }
 327                 catch (Exception e)
 328                 {
 329                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 330                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 331                 }
 332
 333
 334             }
 335             else
 336             {
 337                 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);
 338             }
 339         }
 340
 341         private static efl_gfx_blur_radius_get_delegate efl_gfx_blur_radius_get_static_delegate;
 342
 343
 344         private delegate void efl_gfx_blur_radius_set_delegate(System.IntPtr obj, System.IntPtr pd,  double rx,  double ry);
 345
 346
 347         public delegate void efl_gfx_blur_radius_set_api_delegate(System.IntPtr obj,  double rx,  double ry);
 348
 349         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");
 350
 351         private static void radius_set(System.IntPtr obj, System.IntPtr pd, double rx, double ry)
 352         {
 353             Eina.Log.Debug("function efl_gfx_blur_radius_set was called");
 354             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 355             if (wrapper != null)
 356             {
 357
 358                 try
 359                 {
 360                     ((IBlur)wrapper).SetRadius(rx, ry);
 361                 }
 362                 catch (Exception e)
 363                 {
 364                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 365                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 366                 }
 367
 368
 369             }
 370             else
 371             {
 372                 efl_gfx_blur_radius_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), rx, ry);
 373             }
 374         }
 375
 376         private static efl_gfx_blur_radius_set_delegate efl_gfx_blur_radius_set_static_delegate;
 377
 378
 379         private delegate void efl_gfx_blur_offset_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double ox,  out double oy);
 380
 381
 382         public delegate void efl_gfx_blur_offset_get_api_delegate(System.IntPtr obj,  out double ox,  out double oy);
 383
 384         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");
 385
 386         private static void offset_get(System.IntPtr obj, System.IntPtr pd, out double ox, out double oy)
 387         {
 388             Eina.Log.Debug("function efl_gfx_blur_offset_get was called");
 389             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 390             if (wrapper != null)
 391             {
 392                         ox = default(double);        oy = default(double);
 393                 try
 394                 {
 395                     ((IBlur)wrapper).GetOffset(out ox, out oy);
 396                 }
 397                 catch (Exception e)
 398                 {
 399                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 400                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 401                 }
 402
 403
 404             }
 405             else
 406             {
 407                 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);
 408             }
 409         }
 410
 411         private static efl_gfx_blur_offset_get_delegate efl_gfx_blur_offset_get_static_delegate;
 412
 413
 414         private delegate void efl_gfx_blur_offset_set_delegate(System.IntPtr obj, System.IntPtr pd,  double ox,  double oy);
 415
 416
 417         public delegate void efl_gfx_blur_offset_set_api_delegate(System.IntPtr obj,  double ox,  double oy);
 418
 419         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");
 420
 421         private static void offset_set(System.IntPtr obj, System.IntPtr pd, double ox, double oy)
 422         {
 423             Eina.Log.Debug("function efl_gfx_blur_offset_set was called");
 424             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 425             if (wrapper != null)
 426             {
 427
 428                 try
 429                 {
 430                     ((IBlur)wrapper).SetOffset(ox, oy);
 431                 }
 432                 catch (Exception e)
 433                 {
 434                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 435                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 436                 }
 437
 438
 439             }
 440             else
 441             {
 442                 efl_gfx_blur_offset_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ox, oy);
 443             }
 444         }
 445
 446         private static efl_gfx_blur_offset_set_delegate efl_gfx_blur_offset_set_static_delegate;
 447
 448
 449         private delegate double efl_gfx_blur_grow_get_delegate(System.IntPtr obj, System.IntPtr pd);
 450
 451
 452         public delegate double efl_gfx_blur_grow_get_api_delegate(System.IntPtr obj);
 453
 454         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");
 455
 456         private static double grow_get(System.IntPtr obj, System.IntPtr pd)
 457         {
 458             Eina.Log.Debug("function efl_gfx_blur_grow_get was called");
 459             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 460             if (wrapper != null)
 461             {
 462             double _ret_var = default(double);
 463                 try
 464                 {
 465                     _ret_var = ((IBlur)wrapper).GetGrow();
 466                 }
 467                 catch (Exception e)
 468                 {
 469                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 470                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 471                 }
 472
 473         return _ret_var;
 474
 475             }
 476             else
 477             {
 478                 return efl_gfx_blur_grow_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 479             }
 480         }
 481
 482         private static efl_gfx_blur_grow_get_delegate efl_gfx_blur_grow_get_static_delegate;
 483
 484
 485         private delegate void efl_gfx_blur_grow_set_delegate(System.IntPtr obj, System.IntPtr pd,  double radius);
 486
 487
 488         public delegate void efl_gfx_blur_grow_set_api_delegate(System.IntPtr obj,  double radius);
 489
 490         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");
 491
 492         private static void grow_set(System.IntPtr obj, System.IntPtr pd, double radius)
 493         {
 494             Eina.Log.Debug("function efl_gfx_blur_grow_set was called");
 495             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 496             if (wrapper != null)
 497             {
 498
 499                 try
 500                 {
 501                     ((IBlur)wrapper).SetGrow(radius);
 502                 }
 503                 catch (Exception e)
 504                 {
 505                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 506                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 507                 }
 508
 509
 510             }
 511             else
 512             {
 513                 efl_gfx_blur_grow_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), radius);
 514             }
 515         }
 516
 517         private static efl_gfx_blur_grow_set_delegate efl_gfx_blur_grow_set_static_delegate;
 518
 519         #pragma warning restore CA1707, SA1300, SA1600
 520
 521 }
 522 }
 523 }
 524
 525 }
 526