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

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