internals/src/EflSharp/EflSharp/efl/efl_canvas_vg_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 Canvas {
  11
  12 namespace Vg {
  13
  14 /// <summary>Efl vector graphics gradient radial class</summary>
  15 [Efl.Canvas.Vg.GradientRadial.NativeMethods]
  16 [Efl.Eo.BindingEntity]
  17 public class GradientRadial : Efl.Canvas.Vg.Gradient, Efl.Gfx.IGradientRadial
  18 {
  19     ///<summary>Pointer to the native class description.</summary>
  20     public override System.IntPtr NativeClass
  21     {
  22         get
  23         {
  24             if (((object)this).GetType() == typeof(GradientRadial))
  25             {
  26                 return GetEflClassStatic();
  27             }
  28             else
  29             {
  30                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  31             }
  32         }
  33     }
  34
  35     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  36         efl_canvas_vg_gradient_radial_class_get();
  37     /// <summary>Initializes a new instance of the <see cref="GradientRadial"/> class.</summary>
  38     /// <param name="parent">Parent instance.</param>
  39     public GradientRadial(Efl.Object parent= null
  40             ) : base(efl_canvas_vg_gradient_radial_class_get(), parent)
  41     {
  42         FinishInstantiation();
  43     }
  44
  45     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  46     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  47     protected GradientRadial(ConstructingHandle ch) : base(ch)
  48     {
  49     }
  50
  51     /// <summary>Initializes a new instance of the <see cref="GradientRadial"/> class.
  52     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  53     /// <param name="wh">The native pointer to be wrapped.</param>
  54     protected GradientRadial(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  55     {
  56     }
  57
  58     /// <summary>Initializes a new instance of the <see cref="GradientRadial"/> class.
  59     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  60     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  61     /// <param name="parent">The Efl.Object parent of this instance.</param>
  62     protected GradientRadial(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  63     {
  64     }
  65
  66     /// <summary>Gets the center of this radial gradient.</summary>
  67     /// <param name="x">X co-ordinate of center point</param>
  68     /// <param name="y">Y co-ordinate of center point</param>
  69     virtual public void GetCenter(out double x, out double y) {
  70                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_center_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out x, out y);
  71         Eina.Error.RaiseIfUnhandledException();
  72                                          }
  73     /// <summary>Sets the center of this radial gradient.</summary>
  74     /// <param name="x">X co-ordinate of center point</param>
  75     /// <param name="y">Y co-ordinate of center point</param>
  76     virtual public void SetCenter(double x, double y) {
  77                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_center_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),x, y);
  78         Eina.Error.RaiseIfUnhandledException();
  79                                          }
  80     /// <summary>Gets the center radius of this radial gradient.</summary>
  81     /// <returns>Center radius</returns>
  82     virtual public double GetRadius() {
  83          var _ret_var = Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_radius_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
  84         Eina.Error.RaiseIfUnhandledException();
  85         return _ret_var;
  86  }
  87     /// <summary>Sets the center radius of this radial gradient.</summary>
  88     /// <param name="r">Center radius</param>
  89     virtual public void SetRadius(double r) {
  90                                  Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_radius_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),r);
  91         Eina.Error.RaiseIfUnhandledException();
  92                          }
  93     /// <summary>Gets the focal point of this radial gradient.</summary>
  94     /// <param name="x">X co-ordinate of focal point</param>
  95     /// <param name="y">Y co-ordinate of focal point</param>
  96     virtual public void GetFocal(out double x, out double y) {
  97                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_focal_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out x, out y);
  98         Eina.Error.RaiseIfUnhandledException();
  99                                          }
 100     /// <summary>Sets the focal point of this radial gradient.</summary>
 101     /// <param name="x">X co-ordinate of focal point</param>
 102     /// <param name="y">Y co-ordinate of focal point</param>
 103     virtual public void SetFocal(double x, double y) {
 104                                                          Efl.Gfx.IGradientRadialConcrete.NativeMethods.efl_gfx_gradient_radial_focal_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),x, y);
 105         Eina.Error.RaiseIfUnhandledException();
 106                                          }
 107     /// <summary>Gets the center radius of this radial gradient.</summary>
 108     /// <value>Center radius</value>
 109     public double Radius {
 110         get { return GetRadius(); }
 111         set { SetRadius(value); }
 112     }
 113     private static IntPtr GetEflClassStatic()
 114     {
 115         return Efl.Canvas.Vg.GradientRadial.efl_canvas_vg_gradient_radial_class_get();
 116     }
 117     /// <summary>Wrapper for native methods and virtual method delegates.
 118     /// For internal use by generated code only.</summary>
 119     public new class NativeMethods : Efl.Canvas.Vg.Gradient.NativeMethods
 120     {
 121         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 122         /// <summary>Gets the list of Eo operations to override.</summary>
 123         /// <returns>The list of Eo operations to be overload.</returns>
 124         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 125         {
 126             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 127             var methods = Efl.Eo.Globals.GetUserMethods(type);
 128
 129             if (efl_gfx_gradient_radial_center_get_static_delegate == null)
 130             {
 131                 efl_gfx_gradient_radial_center_get_static_delegate = new efl_gfx_gradient_radial_center_get_delegate(center_get);
 132             }
 133
 134             if (methods.FirstOrDefault(m => m.Name == "GetCenter") != null)
 135             {
 136                 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) });
 137             }
 138
 139             if (efl_gfx_gradient_radial_center_set_static_delegate == null)
 140             {
 141                 efl_gfx_gradient_radial_center_set_static_delegate = new efl_gfx_gradient_radial_center_set_delegate(center_set);
 142             }
 143
 144             if (methods.FirstOrDefault(m => m.Name == "SetCenter") != null)
 145             {
 146                 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) });
 147             }
 148
 149             if (efl_gfx_gradient_radial_radius_get_static_delegate == null)
 150             {
 151                 efl_gfx_gradient_radial_radius_get_static_delegate = new efl_gfx_gradient_radial_radius_get_delegate(radius_get);
 152             }
 153
 154             if (methods.FirstOrDefault(m => m.Name == "GetRadius") != null)
 155             {
 156                 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) });
 157             }
 158
 159             if (efl_gfx_gradient_radial_radius_set_static_delegate == null)
 160             {
 161                 efl_gfx_gradient_radial_radius_set_static_delegate = new efl_gfx_gradient_radial_radius_set_delegate(radius_set);
 162             }
 163
 164             if (methods.FirstOrDefault(m => m.Name == "SetRadius") != null)
 165             {
 166                 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) });
 167             }
 168
 169             if (efl_gfx_gradient_radial_focal_get_static_delegate == null)
 170             {
 171                 efl_gfx_gradient_radial_focal_get_static_delegate = new efl_gfx_gradient_radial_focal_get_delegate(focal_get);
 172             }
 173
 174             if (methods.FirstOrDefault(m => m.Name == "GetFocal") != null)
 175             {
 176                 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) });
 177             }
 178
 179             if (efl_gfx_gradient_radial_focal_set_static_delegate == null)
 180             {
 181                 efl_gfx_gradient_radial_focal_set_static_delegate = new efl_gfx_gradient_radial_focal_set_delegate(focal_set);
 182             }
 183
 184             if (methods.FirstOrDefault(m => m.Name == "SetFocal") != null)
 185             {
 186                 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) });
 187             }
 188
 189             descs.AddRange(base.GetEoOps(type));
 190             return descs;
 191         }
 192         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 193         /// <returns>The native class pointer.</returns>
 194         public override IntPtr GetEflClass()
 195         {
 196             return Efl.Canvas.Vg.GradientRadial.efl_canvas_vg_gradient_radial_class_get();
 197         }
 198
 199         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 200
 201
 202         private delegate void efl_gfx_gradient_radial_center_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
 203
 204
 205         public delegate void efl_gfx_gradient_radial_center_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
 206
 207         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");
 208
 209         private static void center_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
 210         {
 211             Eina.Log.Debug("function efl_gfx_gradient_radial_center_get was called");
 212             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 213             if (ws != null)
 214             {
 215                         x = default(double);        y = default(double);
 216                 try
 217                 {
 218                     ((GradientRadial)ws.Target).GetCenter(out x, out y);
 219                 }
 220                 catch (Exception e)
 221                 {
 222                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 223                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 224                 }
 225
 226
 227             }
 228             else
 229             {
 230                 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);
 231             }
 232         }
 233
 234         private static efl_gfx_gradient_radial_center_get_delegate efl_gfx_gradient_radial_center_get_static_delegate;
 235
 236
 237         private delegate void efl_gfx_gradient_radial_center_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
 238
 239
 240         public delegate void efl_gfx_gradient_radial_center_set_api_delegate(System.IntPtr obj,  double x,  double y);
 241
 242         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");
 243
 244         private static void center_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
 245         {
 246             Eina.Log.Debug("function efl_gfx_gradient_radial_center_set was called");
 247             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 248             if (ws != null)
 249             {
 250
 251                 try
 252                 {
 253                     ((GradientRadial)ws.Target).SetCenter(x, y);
 254                 }
 255                 catch (Exception e)
 256                 {
 257                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 258                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 259                 }
 260
 261
 262             }
 263             else
 264             {
 265                 efl_gfx_gradient_radial_center_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
 266             }
 267         }
 268
 269         private static efl_gfx_gradient_radial_center_set_delegate efl_gfx_gradient_radial_center_set_static_delegate;
 270
 271
 272         private delegate double efl_gfx_gradient_radial_radius_get_delegate(System.IntPtr obj, System.IntPtr pd);
 273
 274
 275         public delegate double efl_gfx_gradient_radial_radius_get_api_delegate(System.IntPtr obj);
 276
 277         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");
 278
 279         private static double radius_get(System.IntPtr obj, System.IntPtr pd)
 280         {
 281             Eina.Log.Debug("function efl_gfx_gradient_radial_radius_get was called");
 282             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 283             if (ws != null)
 284             {
 285             double _ret_var = default(double);
 286                 try
 287                 {
 288                     _ret_var = ((GradientRadial)ws.Target).GetRadius();
 289                 }
 290                 catch (Exception e)
 291                 {
 292                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 293                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 294                 }
 295
 296         return _ret_var;
 297
 298             }
 299             else
 300             {
 301                 return efl_gfx_gradient_radial_radius_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 302             }
 303         }
 304
 305         private static efl_gfx_gradient_radial_radius_get_delegate efl_gfx_gradient_radial_radius_get_static_delegate;
 306
 307
 308         private delegate void efl_gfx_gradient_radial_radius_set_delegate(System.IntPtr obj, System.IntPtr pd,  double r);
 309
 310
 311         public delegate void efl_gfx_gradient_radial_radius_set_api_delegate(System.IntPtr obj,  double r);
 312
 313         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");
 314
 315         private static void radius_set(System.IntPtr obj, System.IntPtr pd, double r)
 316         {
 317             Eina.Log.Debug("function efl_gfx_gradient_radial_radius_set was called");
 318             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 319             if (ws != null)
 320             {
 321
 322                 try
 323                 {
 324                     ((GradientRadial)ws.Target).SetRadius(r);
 325                 }
 326                 catch (Exception e)
 327                 {
 328                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 329                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 330                 }
 331
 332
 333             }
 334             else
 335             {
 336                 efl_gfx_gradient_radial_radius_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r);
 337             }
 338         }
 339
 340         private static efl_gfx_gradient_radial_radius_set_delegate efl_gfx_gradient_radial_radius_set_static_delegate;
 341
 342
 343         private delegate void efl_gfx_gradient_radial_focal_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
 344
 345
 346         public delegate void efl_gfx_gradient_radial_focal_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
 347
 348         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");
 349
 350         private static void focal_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
 351         {
 352             Eina.Log.Debug("function efl_gfx_gradient_radial_focal_get was called");
 353             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 354             if (ws != null)
 355             {
 356                         x = default(double);        y = default(double);
 357                 try
 358                 {
 359                     ((GradientRadial)ws.Target).GetFocal(out x, out y);
 360                 }
 361                 catch (Exception e)
 362                 {
 363                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 364                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 365                 }
 366
 367
 368             }
 369             else
 370             {
 371                 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);
 372             }
 373         }
 374
 375         private static efl_gfx_gradient_radial_focal_get_delegate efl_gfx_gradient_radial_focal_get_static_delegate;
 376
 377
 378         private delegate void efl_gfx_gradient_radial_focal_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
 379
 380
 381         public delegate void efl_gfx_gradient_radial_focal_set_api_delegate(System.IntPtr obj,  double x,  double y);
 382
 383         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");
 384
 385         private static void focal_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
 386         {
 387             Eina.Log.Debug("function efl_gfx_gradient_radial_focal_set was called");
 388             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 389             if (ws != null)
 390             {
 391
 392                 try
 393                 {
 394                     ((GradientRadial)ws.Target).SetFocal(x, y);
 395                 }
 396                 catch (Exception e)
 397                 {
 398                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 399                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 400                 }
 401
 402
 403             }
 404             else
 405             {
 406                 efl_gfx_gradient_radial_focal_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
 407             }
 408         }
 409
 410         private static efl_gfx_gradient_radial_focal_set_delegate efl_gfx_gradient_radial_focal_set_static_delegate;
 411
 412         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 413
 414 }
 415 }
 416 }
 417
 418 }
 419
 420 }
 421