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.ComponentModel;
   7 namespace Efl { namespace Gfx {
   8 /// <summary>Efl graphics gradient linear interface</summary>
   9 [IGradientLinearNativeInherit]
  10 public interface IGradientLinear :
  11     Efl.Gfx.IGradient ,
  12     Efl.Eo.IWrapper, IDisposable
  13 {
  14     /// <summary>Gets the start point of this linear gradient.</summary>
  15 /// <param name="x">X co-ordinate of start point</param>
  16 /// <param name="y">Y co-ordinate of start point</param>
  17 /// <returns></returns>
  18 void GetStart( out double x,  out double y);
  19     /// <summary>Sets 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 /// <returns></returns>
  23 void SetStart( double x,  double y);
  24     /// <summary>Gets the end point of this linear gradient.</summary>
  25 /// <param name="x">X co-ordinate of end point</param>
  26 /// <param name="y">Y co-ordinate of end point</param>
  27 /// <returns></returns>
  28 void GetEnd( out double x,  out double y);
  29     /// <summary>Sets 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 /// <returns></returns>
  33 void SetEnd( double x,  double y);
  34                 }
  35 /// <summary>Efl graphics gradient linear interface</summary>
  36 sealed public class IGradientLinearConcrete :
  37
  38 IGradientLinear
  39     , Efl.Gfx.IGradient
  40 {
  41     ///<summary>Pointer to the native class description.</summary>
  42     public System.IntPtr NativeClass {
  43         get {
  44             if (((object)this).GetType() == typeof (IGradientLinearConcrete))
  45                 return Efl.Gfx.IGradientLinearNativeInherit.GetEflClassStatic();
  46             else
  47                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  48         }
  49     }
  50     private  System.IntPtr handle;
  51     ///<summary>Pointer to the native instance.</summary>
  52     public System.IntPtr NativeHandle {
  53         get { return handle; }
  54     }
  55     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
  56         efl_gfx_gradient_linear_interface_get();
  57     ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  58     private IGradientLinearConcrete(System.IntPtr raw)
  59     {
  60         handle = raw;
  61         RegisterEventProxies();
  62     }
  63     ///<summary>Destructor.</summary>
  64     ~IGradientLinearConcrete()
  65     {
  66         Dispose(false);
  67     }
  68     ///<summary>Releases the underlying native instance.</summary>
  69     void Dispose(bool disposing)
  70     {
  71         if (handle != System.IntPtr.Zero) {
  72             Efl.Eo.Globals.efl_unref(handle);
  73             handle = System.IntPtr.Zero;
  74         }
  75     }
  76     ///<summary>Releases the underlying native instance.</summary>
  77     public void Dispose()
  78     {
  79         Dispose(true);
  80         GC.SuppressFinalize(this);
  81     }
  82     ///<summary>Verifies if the given object is equal to this one.</summary>
  83     public override bool Equals(object obj)
  84     {
  85         var other = obj as Efl.Object;
  86         if (other == null)
  87             return false;
  88         return this.NativeHandle == other.NativeHandle;
  89     }
  90     ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  91     public override int GetHashCode()
  92     {
  93         return this.NativeHandle.ToInt32();
  94     }
  95     ///<summary>Turns the native pointer into a string representation.</summary>
  96     public override String ToString()
  97     {
  98         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  99     }
 100     ///<summary>Register the Eo event wrappers making the bridge to C# events. Internal usage only.</summary>
 101      void RegisterEventProxies()
 102     {
 103     }
 104     /// <summary>Gets the start point of this linear gradient.</summary>
 105     /// <param name="x">X co-ordinate of start point</param>
 106     /// <param name="y">Y co-ordinate of start point</param>
 107     /// <returns></returns>
 108     public void GetStart( out double x,  out double y) {
 109                                                          Efl.Gfx.IGradientLinearNativeInherit.efl_gfx_gradient_linear_start_get_ptr.Value.Delegate(this.NativeHandle, out x,  out y);
 110         Eina.Error.RaiseIfUnhandledException();
 111                                          }
 112     /// <summary>Sets the start point of this linear gradient.</summary>
 113     /// <param name="x">X co-ordinate of start point</param>
 114     /// <param name="y">Y co-ordinate of start point</param>
 115     /// <returns></returns>
 116     public void SetStart( double x,  double y) {
 117                                                          Efl.Gfx.IGradientLinearNativeInherit.efl_gfx_gradient_linear_start_set_ptr.Value.Delegate(this.NativeHandle, x,  y);
 118         Eina.Error.RaiseIfUnhandledException();
 119                                          }
 120     /// <summary>Gets the end point of this linear gradient.</summary>
 121     /// <param name="x">X co-ordinate of end point</param>
 122     /// <param name="y">Y co-ordinate of end point</param>
 123     /// <returns></returns>
 124     public void GetEnd( out double x,  out double y) {
 125                                                          Efl.Gfx.IGradientLinearNativeInherit.efl_gfx_gradient_linear_end_get_ptr.Value.Delegate(this.NativeHandle, out x,  out y);
 126         Eina.Error.RaiseIfUnhandledException();
 127                                          }
 128     /// <summary>Sets the end point of this linear gradient.</summary>
 129     /// <param name="x">X co-ordinate of end point</param>
 130     /// <param name="y">Y co-ordinate of end point</param>
 131     /// <returns></returns>
 132     public void SetEnd( double x,  double y) {
 133                                                          Efl.Gfx.IGradientLinearNativeInherit.efl_gfx_gradient_linear_end_set_ptr.Value.Delegate(this.NativeHandle, x,  y);
 134         Eina.Error.RaiseIfUnhandledException();
 135                                          }
 136     /// <summary>Get the list of color stops.</summary>
 137     /// <param name="colors">Color stops list</param>
 138     /// <param name="length">Length of the list</param>
 139     /// <returns></returns>
 140     public void GetStop( out Efl.Gfx.GradientStop colors,  out uint length) {
 141                          var _out_colors = new System.IntPtr();
 142                                 Efl.Gfx.IGradientNativeInherit.efl_gfx_gradient_stop_get_ptr.Value.Delegate(this.NativeHandle, out _out_colors,  out length);
 143         Eina.Error.RaiseIfUnhandledException();
 144         colors = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.GradientStop>(_out_colors);
 145                                  }
 146     /// <summary>Set the list of color stops for the gradient</summary>
 147     /// <param name="colors">Color stops list</param>
 148     /// <param name="length">Length of the list</param>
 149     /// <returns></returns>
 150     public void SetStop( ref Efl.Gfx.GradientStop colors,  uint length) {
 151          Efl.Gfx.GradientStop.NativeStruct _in_colors = colors;
 152                                                 Efl.Gfx.IGradientNativeInherit.efl_gfx_gradient_stop_set_ptr.Value.Delegate(this.NativeHandle, ref _in_colors,  length);
 153         Eina.Error.RaiseIfUnhandledException();
 154                         colors = _in_colors;
 155                  }
 156     /// <summary>Returns the spread method use by this gradient. The default is EFL_GFX_GRADIENT_SPREAD_PAD.</summary>
 157     /// <returns>Spread type to be used</returns>
 158     public Efl.Gfx.GradientSpread GetSpread() {
 159          var _ret_var = Efl.Gfx.IGradientNativeInherit.efl_gfx_gradient_spread_get_ptr.Value.Delegate(this.NativeHandle);
 160         Eina.Error.RaiseIfUnhandledException();
 161         return _ret_var;
 162  }
 163     /// <summary>Specifies the spread method that should be used for this gradient.</summary>
 164     /// <param name="s">Spread type to be used</param>
 165     /// <returns></returns>
 166     public void SetSpread( Efl.Gfx.GradientSpread s) {
 167                                  Efl.Gfx.IGradientNativeInherit.efl_gfx_gradient_spread_set_ptr.Value.Delegate(this.NativeHandle, s);
 168         Eina.Error.RaiseIfUnhandledException();
 169                          }
 170     /// <summary>Returns the spread method use by this gradient. The default is EFL_GFX_GRADIENT_SPREAD_PAD.</summary>
 171 /// <value>Spread type to be used</value>
 172     public Efl.Gfx.GradientSpread Spread {
 173         get { return GetSpread(); }
 174         set { SetSpread( value); }
 175     }
 176     private static IntPtr GetEflClassStatic()
 177     {
 178         return Efl.Gfx.IGradientLinearConcrete.efl_gfx_gradient_linear_interface_get();
 179     }
 180 }
 181 public class IGradientLinearNativeInherit  : Efl.Eo.NativeClass{
 182     public  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Efl);
 183     public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 184     {
 185         var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 186         var methods = Efl.Eo.Globals.GetUserMethods(type);
 187         if (efl_gfx_gradient_linear_start_get_static_delegate == null)
 188             efl_gfx_gradient_linear_start_get_static_delegate = new efl_gfx_gradient_linear_start_get_delegate(start_get);
 189         if (methods.FirstOrDefault(m => m.Name == "GetStart") != null)
 190             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)});
 191         if (efl_gfx_gradient_linear_start_set_static_delegate == null)
 192             efl_gfx_gradient_linear_start_set_static_delegate = new efl_gfx_gradient_linear_start_set_delegate(start_set);
 193         if (methods.FirstOrDefault(m => m.Name == "SetStart") != null)
 194             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)});
 195         if (efl_gfx_gradient_linear_end_get_static_delegate == null)
 196             efl_gfx_gradient_linear_end_get_static_delegate = new efl_gfx_gradient_linear_end_get_delegate(end_get);
 197         if (methods.FirstOrDefault(m => m.Name == "GetEnd") != null)
 198             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)});
 199         if (efl_gfx_gradient_linear_end_set_static_delegate == null)
 200             efl_gfx_gradient_linear_end_set_static_delegate = new efl_gfx_gradient_linear_end_set_delegate(end_set);
 201         if (methods.FirstOrDefault(m => m.Name == "SetEnd") != null)
 202             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)});
 203         if (efl_gfx_gradient_stop_get_static_delegate == null)
 204             efl_gfx_gradient_stop_get_static_delegate = new efl_gfx_gradient_stop_get_delegate(stop_get);
 205         if (methods.FirstOrDefault(m => m.Name == "GetStop") != null)
 206             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)});
 207         if (efl_gfx_gradient_stop_set_static_delegate == null)
 208             efl_gfx_gradient_stop_set_static_delegate = new efl_gfx_gradient_stop_set_delegate(stop_set);
 209         if (methods.FirstOrDefault(m => m.Name == "SetStop") != null)
 210             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)});
 211         if (efl_gfx_gradient_spread_get_static_delegate == null)
 212             efl_gfx_gradient_spread_get_static_delegate = new efl_gfx_gradient_spread_get_delegate(spread_get);
 213         if (methods.FirstOrDefault(m => m.Name == "GetSpread") != null)
 214             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)});
 215         if (efl_gfx_gradient_spread_set_static_delegate == null)
 216             efl_gfx_gradient_spread_set_static_delegate = new efl_gfx_gradient_spread_set_delegate(spread_set);
 217         if (methods.FirstOrDefault(m => m.Name == "SetSpread") != null)
 218             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)});
 219         return descs;
 220     }
 221     public override IntPtr GetEflClass()
 222     {
 223         return Efl.Gfx.IGradientLinearConcrete.efl_gfx_gradient_linear_interface_get();
 224     }
 225     public static  IntPtr GetEflClassStatic()
 226     {
 227         return Efl.Gfx.IGradientLinearConcrete.efl_gfx_gradient_linear_interface_get();
 228     }
 229
 230
 231      private delegate void efl_gfx_gradient_linear_start_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
 232
 233
 234      public delegate void efl_gfx_gradient_linear_start_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
 235      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");
 236      private static void start_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
 237     {
 238         Eina.Log.Debug("function efl_gfx_gradient_linear_start_get was called");
 239         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 240         if(wrapper != null) {
 241                                     x = default(double);        y = default(double);
 242             try {
 243                 ((IGradientLinear)wrapper).GetStart( out x,  out y);
 244             } catch (Exception e) {
 245                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 246                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 247             }
 248                                                 } else {
 249             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);
 250         }
 251     }
 252     private static efl_gfx_gradient_linear_start_get_delegate efl_gfx_gradient_linear_start_get_static_delegate;
 253
 254
 255      private delegate void efl_gfx_gradient_linear_start_set_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
 256
 257
 258      public delegate void efl_gfx_gradient_linear_start_set_api_delegate(System.IntPtr obj,   double x,   double y);
 259      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");
 260      private static void start_set(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
 261     {
 262         Eina.Log.Debug("function efl_gfx_gradient_linear_start_set was called");
 263         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 264         if(wrapper != null) {
 265
 266             try {
 267                 ((IGradientLinear)wrapper).SetStart( x,  y);
 268             } catch (Exception e) {
 269                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 270                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 271             }
 272                                                 } else {
 273             efl_gfx_gradient_linear_start_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  x,  y);
 274         }
 275     }
 276     private static efl_gfx_gradient_linear_start_set_delegate efl_gfx_gradient_linear_start_set_static_delegate;
 277
 278
 279      private delegate void efl_gfx_gradient_linear_end_get_delegate(System.IntPtr obj, System.IntPtr pd,   out double x,   out double y);
 280
 281
 282      public delegate void efl_gfx_gradient_linear_end_get_api_delegate(System.IntPtr obj,   out double x,   out double y);
 283      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");
 284      private static void end_get(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y)
 285     {
 286         Eina.Log.Debug("function efl_gfx_gradient_linear_end_get was called");
 287         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 288         if(wrapper != null) {
 289                                     x = default(double);        y = default(double);
 290             try {
 291                 ((IGradientLinear)wrapper).GetEnd( out x,  out y);
 292             } catch (Exception e) {
 293                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 294                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 295             }
 296                                                 } else {
 297             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);
 298         }
 299     }
 300     private static efl_gfx_gradient_linear_end_get_delegate efl_gfx_gradient_linear_end_get_static_delegate;
 301
 302
 303      private delegate void efl_gfx_gradient_linear_end_set_delegate(System.IntPtr obj, System.IntPtr pd,   double x,   double y);
 304
 305
 306      public delegate void efl_gfx_gradient_linear_end_set_api_delegate(System.IntPtr obj,   double x,   double y);
 307      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");
 308      private static void end_set(System.IntPtr obj, System.IntPtr pd,  double x,  double y)
 309     {
 310         Eina.Log.Debug("function efl_gfx_gradient_linear_end_set was called");
 311         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 312         if(wrapper != null) {
 313
 314             try {
 315                 ((IGradientLinear)wrapper).SetEnd( x,  y);
 316             } catch (Exception e) {
 317                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 318                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 319             }
 320                                                 } else {
 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     private static efl_gfx_gradient_linear_end_set_delegate efl_gfx_gradient_linear_end_set_static_delegate;
 325
 326
 327      private delegate void efl_gfx_gradient_stop_get_delegate(System.IntPtr obj, System.IntPtr pd,   out System.IntPtr colors,   out uint length);
 328
 329
 330      public delegate void efl_gfx_gradient_stop_get_api_delegate(System.IntPtr obj,   out System.IntPtr colors,   out uint length);
 331      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");
 332      private static void stop_get(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr colors,  out uint length)
 333     {
 334         Eina.Log.Debug("function efl_gfx_gradient_stop_get was called");
 335         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 336         if(wrapper != null) {
 337                                     Efl.Gfx.GradientStop _out_colors = default(Efl.Gfx.GradientStop);
 338         length = default(uint);
 339             try {
 340                 ((IGradientLinear)wrapper).GetStop( out _out_colors,  out length);
 341             } catch (Exception e) {
 342                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 343                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 344             }
 345         colors = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_colors);
 346                                         } else {
 347             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);
 348         }
 349     }
 350     private static efl_gfx_gradient_stop_get_delegate efl_gfx_gradient_stop_get_static_delegate;
 351
 352
 353      private delegate void efl_gfx_gradient_stop_set_delegate(System.IntPtr obj, System.IntPtr pd,   ref Efl.Gfx.GradientStop.NativeStruct colors,   uint length);
 354
 355
 356      public delegate void efl_gfx_gradient_stop_set_api_delegate(System.IntPtr obj,   ref Efl.Gfx.GradientStop.NativeStruct colors,   uint length);
 357      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");
 358      private static void stop_set(System.IntPtr obj, System.IntPtr pd,  ref Efl.Gfx.GradientStop.NativeStruct colors,  uint length)
 359     {
 360         Eina.Log.Debug("function efl_gfx_gradient_stop_set was called");
 361         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 362         if(wrapper != null) {
 363                     Efl.Gfx.GradientStop _in_colors = colors;
 364
 365             try {
 366                 ((IGradientLinear)wrapper).SetStop( ref _in_colors,  length);
 367             } catch (Exception e) {
 368                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 369                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 370             }
 371                         colors = _in_colors;
 372                         } else {
 373             efl_gfx_gradient_stop_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  ref colors,  length);
 374         }
 375     }
 376     private static efl_gfx_gradient_stop_set_delegate efl_gfx_gradient_stop_set_static_delegate;
 377
 378
 379      private delegate Efl.Gfx.GradientSpread efl_gfx_gradient_spread_get_delegate(System.IntPtr obj, System.IntPtr pd);
 380
 381
 382      public delegate Efl.Gfx.GradientSpread efl_gfx_gradient_spread_get_api_delegate(System.IntPtr obj);
 383      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");
 384      private static Efl.Gfx.GradientSpread spread_get(System.IntPtr obj, System.IntPtr pd)
 385     {
 386         Eina.Log.Debug("function efl_gfx_gradient_spread_get was called");
 387         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 388         if(wrapper != null) {
 389                         Efl.Gfx.GradientSpread _ret_var = default(Efl.Gfx.GradientSpread);
 390             try {
 391                 _ret_var = ((IGradientLinear)wrapper).GetSpread();
 392             } catch (Exception e) {
 393                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 394                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 395             }
 396         return _ret_var;
 397         } else {
 398             return efl_gfx_gradient_spread_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 399         }
 400     }
 401     private static efl_gfx_gradient_spread_get_delegate efl_gfx_gradient_spread_get_static_delegate;
 402
 403
 404      private delegate void efl_gfx_gradient_spread_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.Gfx.GradientSpread s);
 405
 406
 407      public delegate void efl_gfx_gradient_spread_set_api_delegate(System.IntPtr obj,   Efl.Gfx.GradientSpread s);
 408      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");
 409      private static void spread_set(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.GradientSpread s)
 410     {
 411         Eina.Log.Debug("function efl_gfx_gradient_spread_set was called");
 412         Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 413         if(wrapper != null) {
 414
 415             try {
 416                 ((IGradientLinear)wrapper).SetSpread( s);
 417             } catch (Exception e) {
 418                 Eina.Log.Warning($"Callback error: {e.ToString()}");
 419                 Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 420             }
 421                                 } else {
 422             efl_gfx_gradient_spread_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  s);
 423         }
 424     }
 425     private static efl_gfx_gradient_spread_set_delegate efl_gfx_gradient_spread_set_static_delegate;
 426 }
 427 } }