internals/src/EflSharp/EflSharp/efl/efl_canvas_vg_gradient_linear.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 Canvas {
  12
  13 namespace Vg {
  14
  15 /// <summary>Efl vector graphics gradient linear class</summary>
  16 /// <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>
  17 [Efl.Canvas.Vg.GradientLinear.NativeMethods]
  18 [Efl.Eo.BindingEntity]
  19 public class GradientLinear : Efl.Canvas.Vg.Gradient, Efl.Gfx.IGradientLinear
  20 {
  21     /// <summary>Pointer to the native class description.</summary>
  22     public override System.IntPtr NativeClass
  23     {
  24         get
  25         {
  26             if (((object)this).GetType() == typeof(GradientLinear))
  27             {
  28                 return GetEflClassStatic();
  29             }
  30             else
  31             {
  32                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  33             }
  34         }
  35     }
  36
  37     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  38         efl_canvas_vg_gradient_linear_class_get();
  39     /// <summary>Initializes a new instance of the <see cref="GradientLinear"/> class.</summary>
  40     /// <param name="parent">Parent instance.</param>
  41     public GradientLinear(Efl.Object parent= null
  42             ) : base(efl_canvas_vg_gradient_linear_class_get(), parent)
  43     {
  44         FinishInstantiation();
  45     }
  46
  47     /// <summary>Subclasses should override this constructor if they are expected to be instantiated from native code.
  48     /// Do not call this constructor directly.</summary>
  49     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  50     protected GradientLinear(ConstructingHandle ch) : base(ch)
  51     {
  52     }
  53
  54     /// <summary>Initializes a new instance of the <see cref="GradientLinear"/> class.
  55     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  56     /// <param name="wh">The native pointer to be wrapped.</param>
  57     protected GradientLinear(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  58     {
  59     }
  60
  61     /// <summary>Initializes a new instance of the <see cref="GradientLinear"/> class.
  62     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  63     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  64     /// <param name="parent">The Efl.Object parent of this instance.</param>
  65     protected GradientLinear(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  66     {
  67     }
  68
  69     /// <summary>Gets the start point of this linear gradient.</summary>
  70     /// <param name="x">X co-ordinate of start point</param>
  71     /// <param name="y">Y co-ordinate of start point</param>
  72     virtual public void GetStart(out double x, out double y) {
  73                                                          Efl.Gfx.IGradientLinearConcrete.NativeMethods.efl_gfx_gradient_linear_start_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out x, out y);
  74         Eina.Error.RaiseIfUnhandledException();
  75                                          }
  76     /// <summary>Sets the start point of this linear gradient.</summary>
  77     /// <param name="x">X co-ordinate of start point</param>
  78     /// <param name="y">Y co-ordinate of start point</param>
  79     virtual public void SetStart(double x, double y) {
  80                                                          Efl.Gfx.IGradientLinearConcrete.NativeMethods.efl_gfx_gradient_linear_start_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),x, y);
  81         Eina.Error.RaiseIfUnhandledException();
  82                                          }
  83     /// <summary>Gets the end point of this linear gradient.</summary>
  84     /// <param name="x">X co-ordinate of end point</param>
  85     /// <param name="y">Y co-ordinate of end point</param>
  86     virtual public void GetEnd(out double x, out double y) {
  87                                                          Efl.Gfx.IGradientLinearConcrete.NativeMethods.efl_gfx_gradient_linear_end_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),out x, out y);
  88         Eina.Error.RaiseIfUnhandledException();
  89                                          }
  90     /// <summary>Sets the end point of this linear gradient.</summary>
  91     /// <param name="x">X co-ordinate of end point</param>
  92     /// <param name="y">Y co-ordinate of end point</param>
  93     virtual public void SetEnd(double x, double y) {
  94                                                          Efl.Gfx.IGradientLinearConcrete.NativeMethods.efl_gfx_gradient_linear_end_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),x, y);
  95         Eina.Error.RaiseIfUnhandledException();
  96                                          }
  97     /// <summary>Gets the start point of this linear gradient.</summary>
  98     /// <value>X co-ordinate of start point</value>
  99     public (double, double) Start {
 100         get {
 101             double _out_x = default(double);
 102             double _out_y = default(double);
 103             GetStart(out _out_x,out _out_y);
 104             return (_out_x,_out_y);
 105         }
 106         set { SetStart( value.Item1,  value.Item2); }
 107     }
 108     /// <summary>Gets the end point of this linear gradient.</summary>
 109     /// <value>X co-ordinate of end point</value>
 110     public (double, double) End {
 111         get {
 112             double _out_x = default(double);
 113             double _out_y = default(double);
 114             GetEnd(out _out_x,out _out_y);
 115             return (_out_x,_out_y);
 116         }
 117         set { SetEnd( value.Item1,  value.Item2); }
 118     }
 119     private static IntPtr GetEflClassStatic()
 120     {
 121         return Efl.Canvas.Vg.GradientLinear.efl_canvas_vg_gradient_linear_class_get();
 122     }
 123     /// <summary>Wrapper for native methods and virtual method delegates.
 124     /// For internal use by generated code only.</summary>
 125     public new class NativeMethods : Efl.Canvas.Vg.Gradient.NativeMethods
 126     {
 127         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 128         /// <summary>Gets the list of Eo operations to override.</summary>
 129         /// <returns>The list of Eo operations to be overload.</returns>
 130         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 131         {
 132             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 133             var methods = Efl.Eo.Globals.GetUserMethods(type);
 134
 135             if (efl_gfx_gradient_linear_start_get_static_delegate == null)
 136             {
 137                 efl_gfx_gradient_linear_start_get_static_delegate = new efl_gfx_gradient_linear_start_get_delegate(start_get);
 138             }
 139
 140             if (methods.FirstOrDefault(m => m.Name == "GetStart") != null)
 141             {
 142                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_linear_start_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_linear_start_get_static_delegate) });
 143             }
 144
 145             if (efl_gfx_gradient_linear_start_set_static_delegate == null)
 146             {
 147                 efl_gfx_gradient_linear_start_set_static_delegate = new efl_gfx_gradient_linear_start_set_delegate(start_set);
 148             }
 149
 150             if (methods.FirstOrDefault(m => m.Name == "SetStart") != null)
 151             {
 152                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_linear_start_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_linear_start_set_static_delegate) });
 153             }
 154
 155             if (efl_gfx_gradient_linear_end_get_static_delegate == null)
 156             {
 157                 efl_gfx_gradient_linear_end_get_static_delegate = new efl_gfx_gradient_linear_end_get_delegate(end_get);
 158             }
 159
 160             if (methods.FirstOrDefault(m => m.Name == "GetEnd") != null)
 161             {
 162                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_linear_end_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_linear_end_get_static_delegate) });
 163             }
 164
 165             if (efl_gfx_gradient_linear_end_set_static_delegate == null)
 166             {
 167                 efl_gfx_gradient_linear_end_set_static_delegate = new efl_gfx_gradient_linear_end_set_delegate(end_set);
 168             }
 169
 170             if (methods.FirstOrDefault(m => m.Name == "SetEnd") != null)
 171             {
 172                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_gradient_linear_end_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_gradient_linear_end_set_static_delegate) });
 173             }
 174
 175             descs.AddRange(base.GetEoOps(type));
 176             return descs;
 177         }
 178         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 179         /// <returns>The native class pointer.</returns>
 180         public override IntPtr GetEflClass()
 181         {
 182             return Efl.Canvas.Vg.GradientLinear.efl_canvas_vg_gradient_linear_class_get();
 183         }
 184
 185         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 186
 187
 188         private delegate void efl_gfx_gradient_linear_start_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
 189
 190
 191         public delegate void efl_gfx_gradient_linear_start_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
 192
 193         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_start_get_api_delegate> efl_gfx_gradient_linear_start_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_start_get_api_delegate>(Module, "efl_gfx_gradient_linear_start_get");
 194
 195         private static void start_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
 196         {
 197             Eina.Log.Debug("function efl_gfx_gradient_linear_start_get was called");
 198             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 199             if (ws != null)
 200             {
 201                         x = default(double);        y = default(double);
 202                 try
 203                 {
 204                     ((GradientLinear)ws.Target).GetStart(out x, out y);
 205                 }
 206                 catch (Exception e)
 207                 {
 208                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 209                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 210                 }
 211
 212
 213             }
 214             else
 215             {
 216                 efl_gfx_gradient_linear_start_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
 217             }
 218         }
 219
 220         private static efl_gfx_gradient_linear_start_get_delegate efl_gfx_gradient_linear_start_get_static_delegate;
 221
 222
 223         private delegate void efl_gfx_gradient_linear_start_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
 224
 225
 226         public delegate void efl_gfx_gradient_linear_start_set_api_delegate(System.IntPtr obj,  double x,  double y);
 227
 228         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_start_set_api_delegate> efl_gfx_gradient_linear_start_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_start_set_api_delegate>(Module, "efl_gfx_gradient_linear_start_set");
 229
 230         private static void start_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
 231         {
 232             Eina.Log.Debug("function efl_gfx_gradient_linear_start_set was called");
 233             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 234             if (ws != null)
 235             {
 236
 237                 try
 238                 {
 239                     ((GradientLinear)ws.Target).SetStart(x, y);
 240                 }
 241                 catch (Exception e)
 242                 {
 243                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 244                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 245                 }
 246
 247
 248             }
 249             else
 250             {
 251                 efl_gfx_gradient_linear_start_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
 252             }
 253         }
 254
 255         private static efl_gfx_gradient_linear_start_set_delegate efl_gfx_gradient_linear_start_set_static_delegate;
 256
 257
 258         private delegate void efl_gfx_gradient_linear_end_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
 259
 260
 261         public delegate void efl_gfx_gradient_linear_end_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
 262
 263         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_end_get_api_delegate> efl_gfx_gradient_linear_end_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_end_get_api_delegate>(Module, "efl_gfx_gradient_linear_end_get");
 264
 265         private static void end_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
 266         {
 267             Eina.Log.Debug("function efl_gfx_gradient_linear_end_get was called");
 268             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 269             if (ws != null)
 270             {
 271                         x = default(double);        y = default(double);
 272                 try
 273                 {
 274                     ((GradientLinear)ws.Target).GetEnd(out x, out y);
 275                 }
 276                 catch (Exception e)
 277                 {
 278                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 279                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 280                 }
 281
 282
 283             }
 284             else
 285             {
 286                 efl_gfx_gradient_linear_end_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
 287             }
 288         }
 289
 290         private static efl_gfx_gradient_linear_end_get_delegate efl_gfx_gradient_linear_end_get_static_delegate;
 291
 292
 293         private delegate void efl_gfx_gradient_linear_end_set_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
 294
 295
 296         public delegate void efl_gfx_gradient_linear_end_set_api_delegate(System.IntPtr obj,  double x,  double y);
 297
 298         public static Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_end_set_api_delegate> efl_gfx_gradient_linear_end_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_gradient_linear_end_set_api_delegate>(Module, "efl_gfx_gradient_linear_end_set");
 299
 300         private static void end_set(System.IntPtr obj, System.IntPtr pd, double x, double y)
 301         {
 302             Eina.Log.Debug("function efl_gfx_gradient_linear_end_set was called");
 303             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 304             if (ws != null)
 305             {
 306
 307                 try
 308                 {
 309                     ((GradientLinear)ws.Target).SetEnd(x, y);
 310                 }
 311                 catch (Exception e)
 312                 {
 313                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 314                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 315                 }
 316
 317
 318             }
 319             else
 320             {
 321                 efl_gfx_gradient_linear_end_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
 322             }
 323         }
 324
 325         private static efl_gfx_gradient_linear_end_set_delegate efl_gfx_gradient_linear_end_set_static_delegate;
 326
 327         #pragma warning restore CA1707, CS1591, SA1300, SA1600
 328
 329 }
 330 }
 331 }
 332
 333 }
 334
 335 }
 336
 337 #if EFL_BETA
 338 #pragma warning disable CS1591
 339 public static class Efl_Canvas_VgGradientLinear_ExtensionMethods {
 340
 341
 342 }
 343 #pragma warning restore CS1591
 344 #endif