internals/src/EflSharp/EflSharp/efl/efl_gfx_gradient_radial.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>Efl graphics gradient radial interface</summary>
  13 [Efl.Gfx.IGradientRadialConcrete.NativeMethods]
  14 public interface IGradientRadial :
  15     Efl.Gfx.IGradient ,
  16     Efl.Eo.IWrapper, IDisposable
  17 {
  18     /// <summary>Gets the center of this radial gradient.</summary>
  19 /// <param name="x">X co-ordinate of center point</param>
  20 /// <param name="y">Y co-ordinate of center point</param>
  21 void GetCenter(out double x, out double y);
  22     /// <summary>Sets the center of this radial gradient.</summary>
  23 /// <param name="x">X co-ordinate of center point</param>
  24 /// <param name="y">Y co-ordinate of center point</param>
  25 void SetCenter(double x, double y);
  26     /// <summary>Gets the center radius of this radial gradient.</summary>
  27 /// <returns>Center radius</returns>
  28 double GetRadius();
  29     /// <summary>Sets the center radius of this radial gradient.</summary>
  30 /// <param name="r">Center radius</param>
  31 void SetRadius(double r);
  32     /// <summary>Gets the focal point of this radial gradient.</summary>
  33 /// <param name="x">X co-ordinate of focal point</param>
  34 /// <param name="y">Y co-ordinate of focal point</param>
  35 void GetFocal(out double x, out double y);
  36     /// <summary>Sets the focal point of this radial gradient.</summary>
  37 /// <param name="x">X co-ordinate of focal point</param>
  38 /// <param name="y">Y co-ordinate of focal point</param>
  39 void SetFocal(double x, double y);
  40                             /// <summary>Gets the center radius of this radial gradient.</summary>
  41     /// <value>Center radius</value>
  42     double Radius {
  43         get ;
  44         set ;
  45     }
  46 }
  47 /// <summary>Efl graphics gradient radial interface</summary>
  48 sealed public class IGradientRadialConcrete :
  49     Efl.Eo.EoWrapper
  50     , IGradientRadial
  51     , Efl.Gfx.IGradient
  52 {
  53     ///<summary>Pointer to the native class description.</summary>
  54     public override System.IntPtr NativeClass
  55     {
  56         get
  57         {
  58             if (((object)this).GetType() == typeof(IGradientRadialConcrete))
  59             {
  60                 return GetEflClassStatic();
  61             }
  62             else
  63             {
  64                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  65             }
  66         }
  67     }
  68
  69     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
  70         efl_gfx_gradient_radial_interface_get();
  71     /// <summary>Initializes a new instance of the <see cref="IGradientRadial"/> class.
  72     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
  73     private IGradientRadialConcrete(System.IntPtr raw) : base(raw)
  74     {
  75     }
  76
  77     /// <summary>Gets the center of this radial gradient.</summary>
  78     /// <param name="x">X co-ordinate of center point</param>
  79     /// <param name="y">Y co-ordinate of center point</param>
  80     public void GetCenter(out double x, out double y) {
  81                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_center_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
  82         Eina.Error.RaiseIfUnhandledException();
  83                                          }
  84     /// <summary>Sets the center of this radial gradient.</summary>
  85     /// <param name="x">X co-ordinate of center point</param>
  86     /// <param name="y">Y co-ordinate of center point</param>
  87     public void SetCenter(double x, double y) {
  88                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_center_set_ptr.Value.Delegate(this.NativeHandle,x, y);
  89         Eina.Error.RaiseIfUnhandledException();
  90                                          }
  91     /// <summary>Gets the center radius of this radial gradient.</summary>
  92     /// <returns>Center radius</returns>
  93     public double GetRadius() {
  94          var _ret_var = Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_radius_get_ptr.Value.Delegate(this.NativeHandle);
  95         Eina.Error.RaiseIfUnhandledException();
  96         return _ret_var;
  97  }
  98     /// <summary>Sets the center radius of this radial gradient.</summary>
  99     /// <param name="r">Center radius</param>
 100     public void SetRadius(double r) {
 101                                  Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_radius_set_ptr.Value.Delegate(this.NativeHandle,r);
 102         Eina.Error.RaiseIfUnhandledException();
 103                          }
 104     /// <summary>Gets the focal point of this radial gradient.</summary>
 105     /// <param name="x">X co-ordinate of focal point</param>
 106     /// <param name="y">Y co-ordinate of focal point</param>
 107     public void GetFocal(out double x, out double y) {
 108                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_focal_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
 109         Eina.Error.RaiseIfUnhandledException();
 110                                          }
 111     /// <summary>Sets the focal point of this radial gradient.</summary>
 112     /// <param name="x">X co-ordinate of focal point</param>
 113     /// <param name="y">Y co-ordinate of focal point</param>
 114     public void SetFocal(double x, double y) {
 115                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_focal_set_ptr.Value.Delegate(this.NativeHandle,x, y);
 116         Eina.Error.RaiseIfUnhandledException();
 117                                          }
 118     /// <summary>Get the list of color stops.</summary>
 119     /// <param name="colors">Color stops list</param>
 120     /// <param name="length">Length of the list</param>
 121     public void GetStop(out Efl.Gfx.GradientStop colors, out uint length) {
 122                          var _out_colors = new System.IntPtr();
 123                                 Efl.Gfx.IGradientConcrete.NativeMethods.efl_gfx_gradient_stop_get_ptr.Value.Delegate(this.NativeHandle,out _out_colors, out length);
 124         Eina.Error.RaiseIfUnhandledException();
 125         colors = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.GradientStop>(_out_colors);
 126                                  }
 127     /// <summary>Set the list of color stops for the gradient</summary>
 128     /// <param name="colors">Color stops list</param>
 129     /// <param name="length">Length of the list</param>
 130     public void SetStop(ref Efl.Gfx.GradientStop colors, uint length) {
 131          Efl.Gfx.GradientStop.NativeStruct _in_colors = colors;
 132                                                 Efl.Gfx.IGradientConcrete.NativeMethods.efl_gfx_gradient_stop_set_ptr.Value.Delegate(this.NativeHandle,ref _in_colors, length);
 133         Eina.Error.RaiseIfUnhandledException();
 134                         colors = _in_colors;
 135                  }
 136     /// <summary>Returns the spread method use by this gradient. The default is EFL_GFX_GRADIENT_SPREAD_PAD.</summary>
 137     /// <returns>Spread type to be used</returns>
 138     public Efl.Gfx.GradientSpread GetSpread() {
 139          var _ret_var = Efl.Gfx.IGradientConcrete.NativeMethods.efl_gfx_gradient_spread_get_ptr.Value.Delegate(this.NativeHandle);
 140         Eina.Error.RaiseIfUnhandledException();
 141         return _ret_var;
 142  }
 143     /// <summary>Specifies the spread method that should be used for this gradient.</summary>
 144     /// <param name="s">Spread type to be used</param>
 145     public void SetSpread(Efl.Gfx.GradientSpread s) {
 146                                  Efl.Gfx.IGradientConcrete.NativeMethods.efl_gfx_gradient_spread_set_ptr.Value.Delegate(this.NativeHandle,s);
 147         Eina.Error.RaiseIfUnhandledException();
 148                          }
 149     /// <summary>Gets the center radius of this radial gradient.</summary>
 150     /// <value>Center radius</value>
 151     public double Radius {
 152         get { return GetRadius(); }
 153         set { SetRadius(value); }
 154     }
 155     /// <summary>Returns the spread method use by this gradient. The default is EFL_GFX_GRADIENT_SPREAD_PAD.</summary>
 156     /// <value>Spread type to be used</value>
 157     public Efl.Gfx.GradientSpread Spread {
 158         get { return GetSpread(); }
 159         set { SetSpread(value); }
 160     }
 161     private static IntPtr GetEflClassStatic()
 162     {
 163         return Efl.Gfx.IGradientRadialConcrete.efl_gfx_gradient_radial_interface_get();
 164     }
 165     /// <summary>Wrapper for native methods and virtual method delegates.
 166     /// For internal use by generated code only.</summary>
 167     public class NativeMethods  : Efl.Eo.NativeClass
 168     {
 169         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 170         /// <summary>Gets the list of Eo operations to override.</summary>
 171         /// <returns>The list of Eo operations to be overload.</returns>
 172         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 173         {
 174             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 175             var methods = Efl.Eo.Globals.GetUserMethods(type);
 176
 177             if (efl_gfx_gradient_radial_center_get_static_delegate == null)
 178             {
 179                 efl_gfx_gradient_radial_center_get_static_delegate = new efl_gfx_gradient_radial_center_get_delegate(center_get);
 180             }
 181
 182             if (methods.FirstOrDefault(m => m.Name == "GetCenter") != null)
 183             {
 184                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_radial_center_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_radial_center_get_static_delegate) });
 185             }
 186
 187             if (efl_gfx_gradient_radial_center_set_static_delegate == null)
 188             {
 189                 efl_gfx_gradient_radial_center_set_static_delegate = new efl_gfx_gradient_radial_center_set_delegate(center_set);
 190             }
 191
 192             if (methods.FirstOrDefault(m => m.Name == "SetCenter") != null)
 193             {
 194                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_radial_center_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_radial_center_set_static_delegate) });
 195             }
 196
 197             if (efl_gfx_gradient_radial_radius_get_static_delegate == null)
 198             {
 199                 efl_gfx_gradient_radial_radius_get_static_delegate = new efl_gfx_gradient_radial_radius_get_delegate(radius_get);
 200             }
 201
 202             if (methods.FirstOrDefault(m => m.Name == "GetRadius") != null)
 203             {
 204                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_radial_radius_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_radial_radius_get_static_delegate) });
 205             }
 206
 207             if (efl_gfx_gradient_radial_radius_set_static_delegate == null)
 208             {
 209                 efl_gfx_gradient_radial_radius_set_static_delegate = new efl_gfx_gradient_radial_radius_set_delegate(radius_set);
 210             }
 211
 212             if (methods.FirstOrDefault(m => m.Name == "SetRadius") != null)
 213             {
 214                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_radial_radius_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_radial_radius_set_static_delegate) });
 215             }
 216
 217             if (efl_gfx_gradient_radial_focal_get_static_delegate == null)
 218             {
 219                 efl_gfx_gradient_radial_focal_get_static_delegate = new efl_gfx_gradient_radial_focal_get_delegate(focal_get);
 220             }
 221
 222             if (methods.FirstOrDefault(m => m.Name == "GetFocal") != null)
 223             {
 224                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_radial_focal_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_radial_focal_get_static_delegate) });
 225             }
 226
 227             if (efl_gfx_gradient_radial_focal_set_static_delegate == null)
 228             {
 229                 efl_gfx_gradient_radial_focal_set_static_delegate = new efl_gfx_gradient_radial_focal_set_delegate(focal_set);
 230             }
 231
 232             if (methods.FirstOrDefault(m => m.Name == "SetFocal") != null)
 233             {
 234                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_radial_focal_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_radial_focal_set_static_delegate) });
 235             }
 236
 237             if (efl_gfx_gradient_stop_get_static_delegate == null)
 238             {
 239                 efl_gfx_gradient_stop_get_static_delegate = new efl_gfx_gradient_stop_get_delegate(stop_get);
 240             }
 241
 242             if (methods.FirstOrDefault(m => m.Name == "GetStop") != null)
 243             {
 244                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_stop_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_stop_get_static_delegate) });
 245             }
 246
 247             if (efl_gfx_gradient_stop_set_static_delegate == null)
 248             {
 249                 efl_gfx_gradient_stop_set_static_delegate = new efl_gfx_gradient_stop_set_delegate(stop_set);
 250             }
 251
 252             if (methods.FirstOrDefault(m => m.Name == "SetStop") != null)
 253             {
 254                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_stop_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_stop_set_static_delegate) });
 255             }
 256
 257             if (efl_gfx_gradient_spread_get_static_delegate == null)
 258             {
 259                 efl_gfx_gradient_spread_get_static_delegate = new efl_gfx_gradient_spread_get_delegate(spread_get);
 260             }
 261
 262             if (methods.FirstOrDefault(m => m.Name == "GetSpread") != null)
 263             {
 264                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_spread_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_spread_get_static_delegate) });
 265             }
 266
 267             if (efl_gfx_gradient_spread_set_static_delegate == null)
 268             {
 269                 efl_gfx_gradient_spread_set_static_delegate = new efl_gfx_gradient_spread_set_delegate(spread_set);
 270             }
 271
 272             if (methods.FirstOrDefault(m => m.Name == "SetSpread") != null)
 273             {
 274                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_spread_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_spread_set_static_delegate) });
 275             }
 276
 277             return descs;
 278         }
 279         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 280         /// <returns>The native class pointer.</returns>
 281         public override IntPtr GetEflClass()
 282         {
 283             return Efl.Gfx.IGradientRadialConcrete.efl_gfx_gradient_radial_interface_get();
 284         }
 285
 286         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 287
 288
 289         private delegate void efl_gfx_gradient_radial_center_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
 290
 291
 292         public delegate void efl_gfx_gradient_radial_center_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
 293
 294         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_center_get_api_delegate> efl_gfx_gradient_radial_center_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_center_get_api_delegate>(Module, "efl_gfx_gradient_radial_center_get");
 295
 296         private static void center_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
 297         {
 298             Eina.Log.Debug("function efl_gfx_gradient_radial_center_get was called");
 299             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 300             if (ws != null)
 301             {
 302                         x = default(double);        y = default(double);
 303                 try
 304                 {
 305                     ((IGradientRadial)ws.Target).GetCenter(out x, out y);
 306                 }
 307                 catch (Exception e)
 308                 {
 309                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 310                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 311                 }
 312
 313
 314             }
 315             else
 316             {
 317                 efl_gfx_gradient_radial_center_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
 318             }
 319         }
 320
 321         private static efl_gfx_gradient_radial_center_get_delegate efl_gfx_gradient_radial_center_get_static_delegate;
 322
 323
 324         private delegate void efl_gfx_gradient_radial_center_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
 325
 326
 327         public delegate void efl_gfx_gradient_radial_center_set_api_delegate(System.IntPtr obj,  double x,  double y);
 328
 329         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_center_set_api_delegate> efl_gfx_gradient_radial_center_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_center_set_api_delegate>(Module, "efl_gfx_gradient_radial_center_set");
 330
 331         private static void center_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
 332         {
 333             Eina.Log.Debug("function efl_gfx_gradient_radial_center_set was called");
 334             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 335             if (ws != null)
 336             {
 337
 338                 try
 339                 {
 340                     ((IGradientRadial)ws.Target).SetCenter(x, y);
 341                 }
 342                 catch (Exception e)
 343                 {
 344                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 345                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 346                 }
 347
 348
 349             }
 350             else
 351             {
 352                 efl_gfx_gradient_radial_center_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
 353             }
 354         }
 355
 356         private static efl_gfx_gradient_radial_center_set_delegate efl_gfx_gradient_radial_center_set_static_delegate;
 357
 358
 359         private delegate double efl_gfx_gradient_radial_radius_get_delegate(System.IntPtr obj, System.IntPtr pd);
 360
 361
 362         public delegate double efl_gfx_gradient_radial_radius_get_api_delegate(System.IntPtr obj);
 363
 364         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_radius_get_api_delegate> efl_gfx_gradient_radial_radius_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_radius_get_api_delegate>(Module, "efl_gfx_gradient_radial_radius_get");
 365
 366         private static double radius_get(System.IntPtr obj, System.IntPtr pd)
 367         {
 368             Eina.Log.Debug("function efl_gfx_gradient_radial_radius_get was called");
 369             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 370             if (ws != null)
 371             {
 372             double _ret_var = default(double);
 373                 try
 374                 {
 375                     _ret_var = ((IGradientRadial)ws.Target).GetRadius();
 376                 }
 377                 catch (Exception e)
 378                 {
 379                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 380                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 381                 }
 382
 383         return _ret_var;
 384
 385             }
 386             else
 387             {
 388                 return efl_gfx_gradient_radial_radius_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 389             }
 390         }
 391
 392         private static efl_gfx_gradient_radial_radius_get_delegate efl_gfx_gradient_radial_radius_get_static_delegate;
 393
 394
 395         private delegate void efl_gfx_gradient_radial_radius_set_delegate(System.IntPtr obj, System.IntPtr pd,  double r);
 396
 397
 398         public delegate void efl_gfx_gradient_radial_radius_set_api_delegate(System.IntPtr obj,  double r);
 399
 400         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_radius_set_api_delegate> efl_gfx_gradient_radial_radius_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_radius_set_api_delegate>(Module, "efl_gfx_gradient_radial_radius_set");
 401
 402         private static void radius_set(System.IntPtr obj, System.IntPtr pd, double r)
 403         {
 404             Eina.Log.Debug("function efl_gfx_gradient_radial_radius_set was called");
 405             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 406             if (ws != null)
 407             {
 408
 409                 try
 410                 {
 411                     ((IGradientRadial)ws.Target).SetRadius(r);
 412                 }
 413                 catch (Exception e)
 414                 {
 415                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 416                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 417                 }
 418
 419
 420             }
 421             else
 422             {
 423                 efl_gfx_gradient_radial_radius_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r);
 424             }
 425         }
 426
 427         private static efl_gfx_gradient_radial_radius_set_delegate efl_gfx_gradient_radial_radius_set_static_delegate;
 428
 429
 430         private delegate void efl_gfx_gradient_radial_focal_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
 431
 432
 433         public delegate void efl_gfx_gradient_radial_focal_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
 434
 435         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_focal_get_api_delegate> efl_gfx_gradient_radial_focal_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_focal_get_api_delegate>(Module, "efl_gfx_gradient_radial_focal_get");
 436
 437         private static void focal_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
 438         {
 439             Eina.Log.Debug("function efl_gfx_gradient_radial_focal_get was called");
 440             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 441             if (ws != null)
 442             {
 443                         x = default(double);        y = default(double);
 444                 try
 445                 {
 446                     ((IGradientRadial)ws.Target).GetFocal(out x, out y);
 447                 }
 448                 catch (Exception e)
 449                 {
 450                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 451                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 452                 }
 453
 454
 455             }
 456             else
 457             {
 458                 efl_gfx_gradient_radial_focal_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
 459             }
 460         }
 461
 462         private static efl_gfx_gradient_radial_focal_get_delegate efl_gfx_gradient_radial_focal_get_static_delegate;
 463
 464
 465         private delegate void efl_gfx_gradient_radial_focal_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
 466
 467
 468         public delegate void efl_gfx_gradient_radial_focal_set_api_delegate(System.IntPtr obj,  double x,  double y);
 469
 470         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_focal_set_api_delegate> efl_gfx_gradient_radial_focal_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_radial_focal_set_api_delegate>(Module, "efl_gfx_gradient_radial_focal_set");
 471
 472         private static void focal_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
 473         {
 474             Eina.Log.Debug("function efl_gfx_gradient_radial_focal_set was called");
 475             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 476             if (ws != null)
 477             {
 478
 479                 try
 480                 {
 481                     ((IGradientRadial)ws.Target).SetFocal(x, y);
 482                 }
 483                 catch (Exception e)
 484                 {
 485                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 486                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 487                 }
 488
 489
 490             }
 491             else
 492             {
 493                 efl_gfx_gradient_radial_focal_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
 494             }
 495         }
 496
 497         private static efl_gfx_gradient_radial_focal_set_delegate efl_gfx_gradient_radial_focal_set_static_delegate;
 498
 499
 500         private delegate void efl_gfx_gradient_stop_get_delegate(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr colors,  out uint length);
 501
 502
 503         public delegate void efl_gfx_gradient_stop_get_api_delegate(System.IntPtr obj,  out System.IntPtr colors,  out uint length);
 504
 505         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_stop_get_api_delegate> efl_gfx_gradient_stop_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_stop_get_api_delegate>(Module, "efl_gfx_gradient_stop_get");
 506
 507         private static void stop_get(System.IntPtr obj, System.IntPtr pd, out System.IntPtr colors, out uint length)
 508         {
 509             Eina.Log.Debug("function efl_gfx_gradient_stop_get was called");
 510             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 511             if (ws != null)
 512             {
 513                         Efl.Gfx.GradientStop _out_colors = default(Efl.Gfx.GradientStop);
 514         length = default(uint);
 515                 try
 516                 {
 517                     ((IGradientRadial)ws.Target).GetStop(out _out_colors, out length);
 518                 }
 519                 catch (Exception e)
 520                 {
 521                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 522                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 523                 }
 524
 525         colors = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_colors);
 526
 527             }
 528             else
 529             {
 530                 efl_gfx_gradient_stop_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out colors, out length);
 531             }
 532         }
 533
 534         private static efl_gfx_gradient_stop_get_delegate efl_gfx_gradient_stop_get_static_delegate;
 535
 536
 537         private delegate void efl_gfx_gradient_stop_set_delegate(System.IntPtr obj, System.IntPtr pd,  ref Efl.Gfx.GradientStop.NativeStruct colors,  uint length);
 538
 539
 540         public delegate void efl_gfx_gradient_stop_set_api_delegate(System.IntPtr obj,  ref Efl.Gfx.GradientStop.NativeStruct colors,  uint length);
 541
 542         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_stop_set_api_delegate> efl_gfx_gradient_stop_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_stop_set_api_delegate>(Module, "efl_gfx_gradient_stop_set");
 543
 544         private static void stop_set(System.IntPtr obj, System.IntPtr pd, ref Efl.Gfx.GradientStop.NativeStruct colors, uint length)
 545         {
 546             Eina.Log.Debug("function efl_gfx_gradient_stop_set was called");
 547             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 548             if (ws != null)
 549             {
 550         Efl.Gfx.GradientStop _in_colors = colors;
 551
 552                 try
 553                 {
 554                     ((IGradientRadial)ws.Target).SetStop(ref _in_colors, length);
 555                 }
 556                 catch (Exception e)
 557                 {
 558                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 559                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 560                 }
 561
 562                         colors = _in_colors;
 563
 564             }
 565             else
 566             {
 567                 efl_gfx_gradient_stop_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref colors, length);
 568             }
 569         }
 570
 571         private static efl_gfx_gradient_stop_set_delegate efl_gfx_gradient_stop_set_static_delegate;
 572
 573
 574         private delegate Efl.Gfx.GradientSpread efl_gfx_gradient_spread_get_delegate(System.IntPtr obj, System.IntPtr pd);
 575
 576
 577         public delegate Efl.Gfx.GradientSpread efl_gfx_gradient_spread_get_api_delegate(System.IntPtr obj);
 578
 579         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_spread_get_api_delegate> efl_gfx_gradient_spread_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_spread_get_api_delegate>(Module, "efl_gfx_gradient_spread_get");
 580
 581         private static Efl.Gfx.GradientSpread spread_get(System.IntPtr obj, System.IntPtr pd)
 582         {
 583             Eina.Log.Debug("function efl_gfx_gradient_spread_get was called");
 584             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 585             if (ws != null)
 586             {
 587             Efl.Gfx.GradientSpread _ret_var = default(Efl.Gfx.GradientSpread);
 588                 try
 589                 {
 590                     _ret_var = ((IGradientRadial)ws.Target).GetSpread();
 591                 }
 592                 catch (Exception e)
 593                 {
 594                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 595                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 596                 }
 597
 598         return _ret_var;
 599
 600             }
 601             else
 602             {
 603                 return efl_gfx_gradient_spread_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 604             }
 605         }
 606
 607         private static efl_gfx_gradient_spread_get_delegate efl_gfx_gradient_spread_get_static_delegate;
 608
 609
 610         private delegate void efl_gfx_gradient_spread_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.GradientSpread s);
 611
 612
 613         public delegate void efl_gfx_gradient_spread_set_api_delegate(System.IntPtr obj,  Efl.Gfx.GradientSpread s);
 614
 615         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_spread_set_api_delegate> efl_gfx_gradient_spread_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_spread_set_api_delegate>(Module, "efl_gfx_gradient_spread_set");
 616
 617         private static void spread_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.GradientSpread s)
 618         {
 619             Eina.Log.Debug("function efl_gfx_gradient_spread_set was called");
 620             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 621             if (ws != null)
 622             {
 623
 624                 try
 625                 {
 626                     ((IGradientRadial)ws.Target).SetSpread(s);
 627                 }
 628                 catch (Exception e)
 629                 {
 630                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 631                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 632                 }
 633
 634
 635             }
 636             else
 637             {
 638                 efl_gfx_gradient_spread_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), s);
 639             }
 640         }
 641
 642         private static efl_gfx_gradient_spread_set_delegate efl_gfx_gradient_spread_set_static_delegate;
 643
 644         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 645
 646 }
 647 }
 648 }
 649
 650 }
 651