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