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

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