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

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 namespace Canvas {
  11
  12 namespace Vg {
  13
  14 /// <summary>Efl vector graphics shape class</summary>
  15 [Efl.Canvas.Vg.Shape.NativeMethods]
  16 public class Shape : Efl.Canvas.Vg.Node, Efl.Eo.IWrapper,Efl.Gfx.IShape
  17 {
  18     ///<summary>Pointer to the native class description.</summary>
  19     public override System.IntPtr NativeClass
  20     {
  21         get
  22         {
  23             if (((object)this).GetType() == typeof(Shape))
  24             {
  25                 return GetEflClassStatic();
  26             }
  27             else
  28             {
  29                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  30             }
  31         }
  32     }
  33
  34     [System.Runtime.InteropServices.DllImport(efl.Libs.Evas)] internal static extern System.IntPtr
  35         efl_canvas_vg_shape_class_get();
  36     /// <summary>Initializes a new instance of the <see cref="Shape"/> class.</summary>
  37     /// <param name="parent">Parent instance.</param>
  38     public Shape(Efl.Object parent= null
  39             ) : base(efl_canvas_vg_shape_class_get(), typeof(Shape), parent)
  40     {
  41         FinishInstantiation();
  42     }
  43
  44     /// <summary>Initializes a new instance of the <see cref="Shape"/> class.
  45     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  46     /// <param name="raw">The native pointer to be wrapped.</param>
  47     protected Shape(System.IntPtr raw) : base(raw)
  48     {
  49             }
  50
  51     /// <summary>Initializes a new instance of the <see cref="Shape"/> class.
  52     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  53     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  54     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  55     /// <param name="parent">The Efl.Object parent of this instance.</param>
  56     protected Shape(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  57     {
  58     }
  59
  60     /// <summary>Verifies if the given object is equal to this one.</summary>
  61     /// <param name="instance">The object to compare to.</param>
  62     /// <returns>True if both objects point to the same native object.</returns>
  63     public override bool Equals(object instance)
  64     {
  65         var other = instance as Efl.Object;
  66         if (other == null)
  67         {
  68             return false;
  69         }
  70         return this.NativeHandle == other.NativeHandle;
  71     }
  72
  73     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  74     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  75     public override int GetHashCode()
  76     {
  77         return this.NativeHandle.ToInt32();
  78     }
  79
  80     /// <summary>Turns the native pointer into a string representation.</summary>
  81     /// <returns>A string with the type and the native pointer for this object.</returns>
  82     public override String ToString()
  83     {
  84         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  85     }
  86
  87     /// <summary>Fill of the shape object</summary>
  88     /// <returns>Fill object</returns>
  89     virtual public Efl.Canvas.Vg.Node GetFill() {
  90          var _ret_var = Efl.Canvas.Vg.Shape.NativeMethods.efl_canvas_vg_shape_fill_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  91         Eina.Error.RaiseIfUnhandledException();
  92         return _ret_var;
  93  }
  94     /// <summary>Fill of the shape object</summary>
  95     /// <param name="f">Fill object</param>
  96     virtual public void SetFill(Efl.Canvas.Vg.Node f) {
  97                                  Efl.Canvas.Vg.Shape.NativeMethods.efl_canvas_vg_shape_fill_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),f);
  98         Eina.Error.RaiseIfUnhandledException();
  99                          }
 100     /// <summary>Stroke fill of the shape object</summary>
 101     /// <returns>Stroke fill object</returns>
 102     virtual public Efl.Canvas.Vg.Node GetStrokeFill() {
 103          var _ret_var = Efl.Canvas.Vg.Shape.NativeMethods.efl_canvas_vg_shape_stroke_fill_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 104         Eina.Error.RaiseIfUnhandledException();
 105         return _ret_var;
 106  }
 107     /// <summary>Stroke fill of the shape object</summary>
 108     /// <param name="f">Stroke fill object</param>
 109     virtual public void SetStrokeFill(Efl.Canvas.Vg.Node f) {
 110                                  Efl.Canvas.Vg.Shape.NativeMethods.efl_canvas_vg_shape_stroke_fill_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),f);
 111         Eina.Error.RaiseIfUnhandledException();
 112                          }
 113     /// <summary>Stroke marker of the shape object</summary>
 114     /// <returns>Stroke marker object</returns>
 115     virtual public Efl.Canvas.Vg.Node GetStrokeMarker() {
 116          var _ret_var = Efl.Canvas.Vg.Shape.NativeMethods.efl_canvas_vg_shape_stroke_marker_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 117         Eina.Error.RaiseIfUnhandledException();
 118         return _ret_var;
 119  }
 120     /// <summary>Stroke marker of the shape object</summary>
 121     /// <param name="m">Stroke marker object</param>
 122     virtual public void SetStrokeMarker(Efl.Canvas.Vg.Node m) {
 123                                  Efl.Canvas.Vg.Shape.NativeMethods.efl_canvas_vg_shape_stroke_marker_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),m);
 124         Eina.Error.RaiseIfUnhandledException();
 125                          }
 126     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
 127     /// <returns>Stroke scale value</returns>
 128     virtual public double GetStrokeScale() {
 129          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_scale_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 130         Eina.Error.RaiseIfUnhandledException();
 131         return _ret_var;
 132  }
 133     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
 134     /// <param name="s">Stroke scale value</param>
 135     virtual public void SetStrokeScale(double s) {
 136                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_scale_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),s);
 137         Eina.Error.RaiseIfUnhandledException();
 138                          }
 139     /// <summary>The color to be used for stroking the path.</summary>
 140     /// <param name="r">The red component of the given color.</param>
 141     /// <param name="g">The green component of the given color.</param>
 142     /// <param name="b">The blue component of the given color.</param>
 143     /// <param name="a">The alpha component of the given color.</param>
 144     virtual public void GetStrokeColor(out int r, out int g, out int b, out int a) {
 145                                                                                                          Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_color_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out r, out g, out b, out a);
 146         Eina.Error.RaiseIfUnhandledException();
 147                                                                          }
 148     /// <summary>The color to be used for stroking the path.</summary>
 149     /// <param name="r">The red component of the given color.</param>
 150     /// <param name="g">The green component of the given color.</param>
 151     /// <param name="b">The blue component of the given color.</param>
 152     /// <param name="a">The alpha component of the given color.</param>
 153     virtual public void SetStrokeColor(int r, int g, int b, int a) {
 154                                                                                                          Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_color_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),r, g, b, a);
 155         Eina.Error.RaiseIfUnhandledException();
 156                                                                          }
 157     /// <summary>The stroke width to be used for stroking the path.</summary>
 158     /// <returns>Stroke width to be used</returns>
 159     virtual public double GetStrokeWidth() {
 160          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_width_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 161         Eina.Error.RaiseIfUnhandledException();
 162         return _ret_var;
 163  }
 164     /// <summary>The stroke width to be used for stroking the path.</summary>
 165     /// <param name="w">Stroke width to be used</param>
 166     virtual public void SetStrokeWidth(double w) {
 167                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_width_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),w);
 168         Eina.Error.RaiseIfUnhandledException();
 169                          }
 170     /// <summary>Not implemented</summary>
 171     /// <returns>Centered stroke location</returns>
 172     virtual public double GetStrokeLocation() {
 173          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_location_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 174         Eina.Error.RaiseIfUnhandledException();
 175         return _ret_var;
 176  }
 177     /// <summary>Not implemented</summary>
 178     /// <param name="centered">Centered stroke location</param>
 179     virtual public void SetStrokeLocation(double centered) {
 180                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_location_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),centered);
 181         Eina.Error.RaiseIfUnhandledException();
 182                          }
 183     /// <summary>Set stroke dash pattern. A dash pattern is specified by dashes, an array of <see cref="Efl.Gfx.Dash"/>. <see cref="Efl.Gfx.Dash"/> values(length, gap) must be positive.
 184     /// See also <see cref="Efl.Gfx.Dash"/></summary>
 185     /// <param name="dash">Stroke dash</param>
 186     /// <param name="length">Stroke dash length</param>
 187     virtual public void GetStrokeDash(out Efl.Gfx.Dash dash, out uint length) {
 188                          var _out_dash = new System.IntPtr();
 189                                 Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_dash_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),out _out_dash, out length);
 190         Eina.Error.RaiseIfUnhandledException();
 191         dash = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.Dash>(_out_dash);
 192                                  }
 193     /// <summary>Set stroke dash pattern. A dash pattern is specified by dashes, an array of <see cref="Efl.Gfx.Dash"/>. <see cref="Efl.Gfx.Dash"/> values(length, gap) must be positive.
 194     /// See also <see cref="Efl.Gfx.Dash"/></summary>
 195     /// <param name="dash">Stroke dash</param>
 196     /// <param name="length">Stroke dash length</param>
 197     virtual public void SetStrokeDash(ref Efl.Gfx.Dash dash, uint length) {
 198          Efl.Gfx.Dash.NativeStruct _in_dash = dash;
 199                                                 Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_dash_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),ref _in_dash, length);
 200         Eina.Error.RaiseIfUnhandledException();
 201                         dash = _in_dash;
 202                  }
 203     /// <summary>The cap style to be used for stroking the path. The cap will be used for capping the end point of a open subpath.
 204     /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
 205     /// <returns>Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></returns>
 206     virtual public Efl.Gfx.Cap GetStrokeCap() {
 207          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_cap_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 208         Eina.Error.RaiseIfUnhandledException();
 209         return _ret_var;
 210  }
 211     /// <summary>The cap style to be used for stroking the path. The cap will be used for capping the end point of a open subpath.
 212     /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
 213     /// <param name="c">Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></param>
 214     virtual public void SetStrokeCap(Efl.Gfx.Cap c) {
 215                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_cap_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),c);
 216         Eina.Error.RaiseIfUnhandledException();
 217                          }
 218     /// <summary>The join style to be used for stroking the path. The join style will be used for joining the two line segment while stroking the path.
 219     /// See also <see cref="Efl.Gfx.Join"/>.</summary>
 220     /// <returns>Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></returns>
 221     virtual public Efl.Gfx.Join GetStrokeJoin() {
 222          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_join_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 223         Eina.Error.RaiseIfUnhandledException();
 224         return _ret_var;
 225  }
 226     /// <summary>The join style to be used for stroking the path. The join style will be used for joining the two line segment while stroking the path.
 227     /// See also <see cref="Efl.Gfx.Join"/>.</summary>
 228     /// <param name="j">Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></param>
 229     virtual public void SetStrokeJoin(Efl.Gfx.Join j) {
 230                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_join_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),j);
 231         Eina.Error.RaiseIfUnhandledException();
 232                          }
 233     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
 234     /// <returns>The current fill rule of the shape object. One of <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/></returns>
 235     virtual public Efl.Gfx.FillRule GetFillRule() {
 236          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_fill_rule_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 237         Eina.Error.RaiseIfUnhandledException();
 238         return _ret_var;
 239  }
 240     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
 241     /// <param name="fill_rule">The current fill rule of the shape object. One of <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/></param>
 242     virtual public void SetFillRule(Efl.Gfx.FillRule fill_rule) {
 243                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_fill_rule_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),fill_rule);
 244         Eina.Error.RaiseIfUnhandledException();
 245                          }
 246     /// <summary>Fill of the shape object</summary>
 247 /// <value>Fill object</value>
 248     public Efl.Canvas.Vg.Node Fill {
 249         get { return GetFill(); }
 250         set { SetFill(value); }
 251     }
 252     /// <summary>Stroke fill of the shape object</summary>
 253 /// <value>Stroke fill object</value>
 254     public Efl.Canvas.Vg.Node StrokeFill {
 255         get { return GetStrokeFill(); }
 256         set { SetStrokeFill(value); }
 257     }
 258     /// <summary>Stroke marker of the shape object</summary>
 259 /// <value>Stroke marker object</value>
 260     public Efl.Canvas.Vg.Node StrokeMarker {
 261         get { return GetStrokeMarker(); }
 262         set { SetStrokeMarker(value); }
 263     }
 264     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
 265 /// <value>Stroke scale value</value>
 266     public double StrokeScale {
 267         get { return GetStrokeScale(); }
 268         set { SetStrokeScale(value); }
 269     }
 270     /// <summary>The stroke width to be used for stroking the path.</summary>
 271 /// <value>Stroke width to be used</value>
 272     public double StrokeWidth {
 273         get { return GetStrokeWidth(); }
 274         set { SetStrokeWidth(value); }
 275     }
 276     /// <summary>Not implemented</summary>
 277 /// <value>Centered stroke location</value>
 278     public double StrokeLocation {
 279         get { return GetStrokeLocation(); }
 280         set { SetStrokeLocation(value); }
 281     }
 282     /// <summary>The cap style to be used for stroking the path. The cap will be used for capping the end point of a open subpath.
 283 /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
 284 /// <value>Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></value>
 285     public Efl.Gfx.Cap StrokeCap {
 286         get { return GetStrokeCap(); }
 287         set { SetStrokeCap(value); }
 288     }
 289     /// <summary>The join style to be used for stroking the path. The join style will be used for joining the two line segment while stroking the path.
 290 /// See also <see cref="Efl.Gfx.Join"/>.</summary>
 291 /// <value>Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></value>
 292     public Efl.Gfx.Join StrokeJoin {
 293         get { return GetStrokeJoin(); }
 294         set { SetStrokeJoin(value); }
 295     }
 296     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
 297 /// <value>The current fill rule of the shape object. One of <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/></value>
 298     public Efl.Gfx.FillRule FillRule {
 299         get { return GetFillRule(); }
 300         set { SetFillRule(value); }
 301     }
 302     private static IntPtr GetEflClassStatic()
 303     {
 304         return Efl.Canvas.Vg.Shape.efl_canvas_vg_shape_class_get();
 305     }
 306     /// <summary>Wrapper for native methods and virtual method delegates.
 307     /// For internal use by generated code only.</summary>
 308     public new class NativeMethods : Efl.Canvas.Vg.Node.NativeMethods
 309     {
 310         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Evas);
 311         /// <summary>Gets the list of Eo operations to override.</summary>
 312         /// <returns>The list of Eo operations to be overload.</returns>
 313         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 314         {
 315             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 316             var methods = Efl.Eo.Globals.GetUserMethods(type);
 317
 318             if (efl_canvas_vg_shape_fill_get_static_delegate == null)
 319             {
 320                 efl_canvas_vg_shape_fill_get_static_delegate = new efl_canvas_vg_shape_fill_get_delegate(fill_get);
 321             }
 322
 323             if (methods.FirstOrDefault(m => m.Name == "GetFill") != null)
 324             {
 325                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_shape_fill_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_shape_fill_get_static_delegate) });
 326             }
 327
 328             if (efl_canvas_vg_shape_fill_set_static_delegate == null)
 329             {
 330                 efl_canvas_vg_shape_fill_set_static_delegate = new efl_canvas_vg_shape_fill_set_delegate(fill_set);
 331             }
 332
 333             if (methods.FirstOrDefault(m => m.Name == "SetFill") != null)
 334             {
 335                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_shape_fill_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_shape_fill_set_static_delegate) });
 336             }
 337
 338             if (efl_canvas_vg_shape_stroke_fill_get_static_delegate == null)
 339             {
 340                 efl_canvas_vg_shape_stroke_fill_get_static_delegate = new efl_canvas_vg_shape_stroke_fill_get_delegate(stroke_fill_get);
 341             }
 342
 343             if (methods.FirstOrDefault(m => m.Name == "GetStrokeFill") != null)
 344             {
 345                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_shape_stroke_fill_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_shape_stroke_fill_get_static_delegate) });
 346             }
 347
 348             if (efl_canvas_vg_shape_stroke_fill_set_static_delegate == null)
 349             {
 350                 efl_canvas_vg_shape_stroke_fill_set_static_delegate = new efl_canvas_vg_shape_stroke_fill_set_delegate(stroke_fill_set);
 351             }
 352
 353             if (methods.FirstOrDefault(m => m.Name == "SetStrokeFill") != null)
 354             {
 355                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_shape_stroke_fill_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_shape_stroke_fill_set_static_delegate) });
 356             }
 357
 358             if (efl_canvas_vg_shape_stroke_marker_get_static_delegate == null)
 359             {
 360                 efl_canvas_vg_shape_stroke_marker_get_static_delegate = new efl_canvas_vg_shape_stroke_marker_get_delegate(stroke_marker_get);
 361             }
 362
 363             if (methods.FirstOrDefault(m => m.Name == "GetStrokeMarker") != null)
 364             {
 365                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_shape_stroke_marker_get"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_shape_stroke_marker_get_static_delegate) });
 366             }
 367
 368             if (efl_canvas_vg_shape_stroke_marker_set_static_delegate == null)
 369             {
 370                 efl_canvas_vg_shape_stroke_marker_set_static_delegate = new efl_canvas_vg_shape_stroke_marker_set_delegate(stroke_marker_set);
 371             }
 372
 373             if (methods.FirstOrDefault(m => m.Name == "SetStrokeMarker") != null)
 374             {
 375                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_canvas_vg_shape_stroke_marker_set"), func = Marshal.GetFunctionPointerForDelegate(efl_canvas_vg_shape_stroke_marker_set_static_delegate) });
 376             }
 377
 378             if (efl_gfx_shape_stroke_scale_get_static_delegate == null)
 379             {
 380                 efl_gfx_shape_stroke_scale_get_static_delegate = new efl_gfx_shape_stroke_scale_get_delegate(stroke_scale_get);
 381             }
 382
 383             if (methods.FirstOrDefault(m => m.Name == "GetStrokeScale") != null)
 384             {
 385                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_scale_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_scale_get_static_delegate) });
 386             }
 387
 388             if (efl_gfx_shape_stroke_scale_set_static_delegate == null)
 389             {
 390                 efl_gfx_shape_stroke_scale_set_static_delegate = new efl_gfx_shape_stroke_scale_set_delegate(stroke_scale_set);
 391             }
 392
 393             if (methods.FirstOrDefault(m => m.Name == "SetStrokeScale") != null)
 394             {
 395                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_scale_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_scale_set_static_delegate) });
 396             }
 397
 398             if (efl_gfx_shape_stroke_color_get_static_delegate == null)
 399             {
 400                 efl_gfx_shape_stroke_color_get_static_delegate = new efl_gfx_shape_stroke_color_get_delegate(stroke_color_get);
 401             }
 402
 403             if (methods.FirstOrDefault(m => m.Name == "GetStrokeColor") != null)
 404             {
 405                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_color_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_color_get_static_delegate) });
 406             }
 407
 408             if (efl_gfx_shape_stroke_color_set_static_delegate == null)
 409             {
 410                 efl_gfx_shape_stroke_color_set_static_delegate = new efl_gfx_shape_stroke_color_set_delegate(stroke_color_set);
 411             }
 412
 413             if (methods.FirstOrDefault(m => m.Name == "SetStrokeColor") != null)
 414             {
 415                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_color_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_color_set_static_delegate) });
 416             }
 417
 418             if (efl_gfx_shape_stroke_width_get_static_delegate == null)
 419             {
 420                 efl_gfx_shape_stroke_width_get_static_delegate = new efl_gfx_shape_stroke_width_get_delegate(stroke_width_get);
 421             }
 422
 423             if (methods.FirstOrDefault(m => m.Name == "GetStrokeWidth") != null)
 424             {
 425                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_width_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_width_get_static_delegate) });
 426             }
 427
 428             if (efl_gfx_shape_stroke_width_set_static_delegate == null)
 429             {
 430                 efl_gfx_shape_stroke_width_set_static_delegate = new efl_gfx_shape_stroke_width_set_delegate(stroke_width_set);
 431             }
 432
 433             if (methods.FirstOrDefault(m => m.Name == "SetStrokeWidth") != null)
 434             {
 435                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_width_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_width_set_static_delegate) });
 436             }
 437
 438             if (efl_gfx_shape_stroke_location_get_static_delegate == null)
 439             {
 440                 efl_gfx_shape_stroke_location_get_static_delegate = new efl_gfx_shape_stroke_location_get_delegate(stroke_location_get);
 441             }
 442
 443             if (methods.FirstOrDefault(m => m.Name == "GetStrokeLocation") != null)
 444             {
 445                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_location_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_location_get_static_delegate) });
 446             }
 447
 448             if (efl_gfx_shape_stroke_location_set_static_delegate == null)
 449             {
 450                 efl_gfx_shape_stroke_location_set_static_delegate = new efl_gfx_shape_stroke_location_set_delegate(stroke_location_set);
 451             }
 452
 453             if (methods.FirstOrDefault(m => m.Name == "SetStrokeLocation") != null)
 454             {
 455                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_location_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_location_set_static_delegate) });
 456             }
 457
 458             if (efl_gfx_shape_stroke_dash_get_static_delegate == null)
 459             {
 460                 efl_gfx_shape_stroke_dash_get_static_delegate = new efl_gfx_shape_stroke_dash_get_delegate(stroke_dash_get);
 461             }
 462
 463             if (methods.FirstOrDefault(m => m.Name == "GetStrokeDash") != null)
 464             {
 465                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_dash_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_dash_get_static_delegate) });
 466             }
 467
 468             if (efl_gfx_shape_stroke_dash_set_static_delegate == null)
 469             {
 470                 efl_gfx_shape_stroke_dash_set_static_delegate = new efl_gfx_shape_stroke_dash_set_delegate(stroke_dash_set);
 471             }
 472
 473             if (methods.FirstOrDefault(m => m.Name == "SetStrokeDash") != null)
 474             {
 475                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_dash_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_dash_set_static_delegate) });
 476             }
 477
 478             if (efl_gfx_shape_stroke_cap_get_static_delegate == null)
 479             {
 480                 efl_gfx_shape_stroke_cap_get_static_delegate = new efl_gfx_shape_stroke_cap_get_delegate(stroke_cap_get);
 481             }
 482
 483             if (methods.FirstOrDefault(m => m.Name == "GetStrokeCap") != null)
 484             {
 485                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_cap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_cap_get_static_delegate) });
 486             }
 487
 488             if (efl_gfx_shape_stroke_cap_set_static_delegate == null)
 489             {
 490                 efl_gfx_shape_stroke_cap_set_static_delegate = new efl_gfx_shape_stroke_cap_set_delegate(stroke_cap_set);
 491             }
 492
 493             if (methods.FirstOrDefault(m => m.Name == "SetStrokeCap") != null)
 494             {
 495                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_cap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_cap_set_static_delegate) });
 496             }
 497
 498             if (efl_gfx_shape_stroke_join_get_static_delegate == null)
 499             {
 500                 efl_gfx_shape_stroke_join_get_static_delegate = new efl_gfx_shape_stroke_join_get_delegate(stroke_join_get);
 501             }
 502
 503             if (methods.FirstOrDefault(m => m.Name == "GetStrokeJoin") != null)
 504             {
 505                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_join_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_join_get_static_delegate) });
 506             }
 507
 508             if (efl_gfx_shape_stroke_join_set_static_delegate == null)
 509             {
 510                 efl_gfx_shape_stroke_join_set_static_delegate = new efl_gfx_shape_stroke_join_set_delegate(stroke_join_set);
 511             }
 512
 513             if (methods.FirstOrDefault(m => m.Name == "SetStrokeJoin") != null)
 514             {
 515                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_stroke_join_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_stroke_join_set_static_delegate) });
 516             }
 517
 518             if (efl_gfx_shape_fill_rule_get_static_delegate == null)
 519             {
 520                 efl_gfx_shape_fill_rule_get_static_delegate = new efl_gfx_shape_fill_rule_get_delegate(fill_rule_get);
 521             }
 522
 523             if (methods.FirstOrDefault(m => m.Name == "GetFillRule") != null)
 524             {
 525                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_fill_rule_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_fill_rule_get_static_delegate) });
 526             }
 527
 528             if (efl_gfx_shape_fill_rule_set_static_delegate == null)
 529             {
 530                 efl_gfx_shape_fill_rule_set_static_delegate = new efl_gfx_shape_fill_rule_set_delegate(fill_rule_set);
 531             }
 532
 533             if (methods.FirstOrDefault(m => m.Name == "SetFillRule") != null)
 534             {
 535                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_shape_fill_rule_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_shape_fill_rule_set_static_delegate) });
 536             }
 537
 538             descs.AddRange(base.GetEoOps(type));
 539             return descs;
 540         }
 541         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 542         /// <returns>The native class pointer.</returns>
 543         public override IntPtr GetEflClass()
 544         {
 545             return Efl.Canvas.Vg.Shape.efl_canvas_vg_shape_class_get();
 546         }
 547
 548         #pragma warning disable CA1707, SA1300, SA1600
 549
 550         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 551         private delegate Efl.Canvas.Vg.Node efl_canvas_vg_shape_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
 552
 553         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 554         public delegate Efl.Canvas.Vg.Node efl_canvas_vg_shape_fill_get_api_delegate(System.IntPtr obj);
 555
 556         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_fill_get_api_delegate> efl_canvas_vg_shape_fill_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_fill_get_api_delegate>(Module, "efl_canvas_vg_shape_fill_get");
 557
 558         private static Efl.Canvas.Vg.Node fill_get(System.IntPtr obj, System.IntPtr pd)
 559         {
 560             Eina.Log.Debug("function efl_canvas_vg_shape_fill_get was called");
 561             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 562             if (wrapper != null)
 563             {
 564             Efl.Canvas.Vg.Node _ret_var = default(Efl.Canvas.Vg.Node);
 565                 try
 566                 {
 567                     _ret_var = ((Shape)wrapper).GetFill();
 568                 }
 569                 catch (Exception e)
 570                 {
 571                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 572                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 573                 }
 574
 575         return _ret_var;
 576
 577             }
 578             else
 579             {
 580                 return efl_canvas_vg_shape_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 581             }
 582         }
 583
 584         private static efl_canvas_vg_shape_fill_get_delegate efl_canvas_vg_shape_fill_get_static_delegate;
 585
 586
 587         private delegate void efl_canvas_vg_shape_fill_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node f);
 588
 589
 590         public delegate void efl_canvas_vg_shape_fill_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node f);
 591
 592         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_fill_set_api_delegate> efl_canvas_vg_shape_fill_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_fill_set_api_delegate>(Module, "efl_canvas_vg_shape_fill_set");
 593
 594         private static void fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Vg.Node f)
 595         {
 596             Eina.Log.Debug("function efl_canvas_vg_shape_fill_set was called");
 597             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 598             if (wrapper != null)
 599             {
 600
 601                 try
 602                 {
 603                     ((Shape)wrapper).SetFill(f);
 604                 }
 605                 catch (Exception e)
 606                 {
 607                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 608                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 609                 }
 610
 611
 612             }
 613             else
 614             {
 615                 efl_canvas_vg_shape_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
 616             }
 617         }
 618
 619         private static efl_canvas_vg_shape_fill_set_delegate efl_canvas_vg_shape_fill_set_static_delegate;
 620
 621         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 622         private delegate Efl.Canvas.Vg.Node efl_canvas_vg_shape_stroke_fill_get_delegate(System.IntPtr obj, System.IntPtr pd);
 623
 624         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 625         public delegate Efl.Canvas.Vg.Node efl_canvas_vg_shape_stroke_fill_get_api_delegate(System.IntPtr obj);
 626
 627         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_fill_get_api_delegate> efl_canvas_vg_shape_stroke_fill_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_fill_get_api_delegate>(Module, "efl_canvas_vg_shape_stroke_fill_get");
 628
 629         private static Efl.Canvas.Vg.Node stroke_fill_get(System.IntPtr obj, System.IntPtr pd)
 630         {
 631             Eina.Log.Debug("function efl_canvas_vg_shape_stroke_fill_get was called");
 632             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 633             if (wrapper != null)
 634             {
 635             Efl.Canvas.Vg.Node _ret_var = default(Efl.Canvas.Vg.Node);
 636                 try
 637                 {
 638                     _ret_var = ((Shape)wrapper).GetStrokeFill();
 639                 }
 640                 catch (Exception e)
 641                 {
 642                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 643                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 644                 }
 645
 646         return _ret_var;
 647
 648             }
 649             else
 650             {
 651                 return efl_canvas_vg_shape_stroke_fill_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 652             }
 653         }
 654
 655         private static efl_canvas_vg_shape_stroke_fill_get_delegate efl_canvas_vg_shape_stroke_fill_get_static_delegate;
 656
 657
 658         private delegate void efl_canvas_vg_shape_stroke_fill_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node f);
 659
 660
 661         public delegate void efl_canvas_vg_shape_stroke_fill_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node f);
 662
 663         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_fill_set_api_delegate> efl_canvas_vg_shape_stroke_fill_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_fill_set_api_delegate>(Module, "efl_canvas_vg_shape_stroke_fill_set");
 664
 665         private static void stroke_fill_set(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Vg.Node f)
 666         {
 667             Eina.Log.Debug("function efl_canvas_vg_shape_stroke_fill_set was called");
 668             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 669             if (wrapper != null)
 670             {
 671
 672                 try
 673                 {
 674                     ((Shape)wrapper).SetStrokeFill(f);
 675                 }
 676                 catch (Exception e)
 677                 {
 678                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 679                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 680                 }
 681
 682
 683             }
 684             else
 685             {
 686                 efl_canvas_vg_shape_stroke_fill_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
 687             }
 688         }
 689
 690         private static efl_canvas_vg_shape_stroke_fill_set_delegate efl_canvas_vg_shape_stroke_fill_set_static_delegate;
 691
 692         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 693         private delegate Efl.Canvas.Vg.Node efl_canvas_vg_shape_stroke_marker_get_delegate(System.IntPtr obj, System.IntPtr pd);
 694
 695         [return:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))]
 696         public delegate Efl.Canvas.Vg.Node efl_canvas_vg_shape_stroke_marker_get_api_delegate(System.IntPtr obj);
 697
 698         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_marker_get_api_delegate> efl_canvas_vg_shape_stroke_marker_get_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_marker_get_api_delegate>(Module, "efl_canvas_vg_shape_stroke_marker_get");
 699
 700         private static Efl.Canvas.Vg.Node stroke_marker_get(System.IntPtr obj, System.IntPtr pd)
 701         {
 702             Eina.Log.Debug("function efl_canvas_vg_shape_stroke_marker_get was called");
 703             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 704             if (wrapper != null)
 705             {
 706             Efl.Canvas.Vg.Node _ret_var = default(Efl.Canvas.Vg.Node);
 707                 try
 708                 {
 709                     _ret_var = ((Shape)wrapper).GetStrokeMarker();
 710                 }
 711                 catch (Exception e)
 712                 {
 713                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 714                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 715                 }
 716
 717         return _ret_var;
 718
 719             }
 720             else
 721             {
 722                 return efl_canvas_vg_shape_stroke_marker_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 723             }
 724         }
 725
 726         private static efl_canvas_vg_shape_stroke_marker_get_delegate efl_canvas_vg_shape_stroke_marker_get_static_delegate;
 727
 728
 729         private delegate void efl_canvas_vg_shape_stroke_marker_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node m);
 730
 731
 732         public delegate void efl_canvas_vg_shape_stroke_marker_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Canvas.Vg.Node m);
 733
 734         public static Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_marker_set_api_delegate> efl_canvas_vg_shape_stroke_marker_set_ptr = new Efl.Eo.FunctionWrapper<efl_canvas_vg_shape_stroke_marker_set_api_delegate>(Module, "efl_canvas_vg_shape_stroke_marker_set");
 735
 736         private static void stroke_marker_set(System.IntPtr obj, System.IntPtr pd, Efl.Canvas.Vg.Node m)
 737         {
 738             Eina.Log.Debug("function efl_canvas_vg_shape_stroke_marker_set was called");
 739             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 740             if (wrapper != null)
 741             {
 742
 743                 try
 744                 {
 745                     ((Shape)wrapper).SetStrokeMarker(m);
 746                 }
 747                 catch (Exception e)
 748                 {
 749                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 750                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 751                 }
 752
 753
 754             }
 755             else
 756             {
 757                 efl_canvas_vg_shape_stroke_marker_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), m);
 758             }
 759         }
 760
 761         private static efl_canvas_vg_shape_stroke_marker_set_delegate efl_canvas_vg_shape_stroke_marker_set_static_delegate;
 762
 763
 764         private delegate double efl_gfx_shape_stroke_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
 765
 766
 767         public delegate double efl_gfx_shape_stroke_scale_get_api_delegate(System.IntPtr obj);
 768
 769         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_scale_get_api_delegate> efl_gfx_shape_stroke_scale_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_scale_get_api_delegate>(Module, "efl_gfx_shape_stroke_scale_get");
 770
 771         private static double stroke_scale_get(System.IntPtr obj, System.IntPtr pd)
 772         {
 773             Eina.Log.Debug("function efl_gfx_shape_stroke_scale_get was called");
 774             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 775             if (wrapper != null)
 776             {
 777             double _ret_var = default(double);
 778                 try
 779                 {
 780                     _ret_var = ((Shape)wrapper).GetStrokeScale();
 781                 }
 782                 catch (Exception e)
 783                 {
 784                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 785                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 786                 }
 787
 788         return _ret_var;
 789
 790             }
 791             else
 792             {
 793                 return efl_gfx_shape_stroke_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 794             }
 795         }
 796
 797         private static efl_gfx_shape_stroke_scale_get_delegate efl_gfx_shape_stroke_scale_get_static_delegate;
 798
 799
 800         private delegate void efl_gfx_shape_stroke_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double s);
 801
 802
 803         public delegate void efl_gfx_shape_stroke_scale_set_api_delegate(System.IntPtr obj,  double s);
 804
 805         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_scale_set_api_delegate> efl_gfx_shape_stroke_scale_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_scale_set_api_delegate>(Module, "efl_gfx_shape_stroke_scale_set");
 806
 807         private static void stroke_scale_set(System.IntPtr obj, System.IntPtr pd, double s)
 808         {
 809             Eina.Log.Debug("function efl_gfx_shape_stroke_scale_set was called");
 810             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 811             if (wrapper != null)
 812             {
 813
 814                 try
 815                 {
 816                     ((Shape)wrapper).SetStrokeScale(s);
 817                 }
 818                 catch (Exception e)
 819                 {
 820                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 821                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 822                 }
 823
 824
 825             }
 826             else
 827             {
 828                 efl_gfx_shape_stroke_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), s);
 829             }
 830         }
 831
 832         private static efl_gfx_shape_stroke_scale_set_delegate efl_gfx_shape_stroke_scale_set_static_delegate;
 833
 834
 835         private delegate void efl_gfx_shape_stroke_color_get_delegate(System.IntPtr obj, System.IntPtr pd,  out int r,  out int g,  out int b,  out int a);
 836
 837
 838         public delegate void efl_gfx_shape_stroke_color_get_api_delegate(System.IntPtr obj,  out int r,  out int g,  out int b,  out int a);
 839
 840         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_color_get_api_delegate> efl_gfx_shape_stroke_color_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_color_get_api_delegate>(Module, "efl_gfx_shape_stroke_color_get");
 841
 842         private static void stroke_color_get(System.IntPtr obj, System.IntPtr pd, out int r, out int g, out int b, out int a)
 843         {
 844             Eina.Log.Debug("function efl_gfx_shape_stroke_color_get was called");
 845             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 846             if (wrapper != null)
 847             {
 848                                         r = default(int);        g = default(int);        b = default(int);        a = default(int);
 849                 try
 850                 {
 851                     ((Shape)wrapper).GetStrokeColor(out r, out g, out b, out a);
 852                 }
 853                 catch (Exception e)
 854                 {
 855                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 856                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 857                 }
 858
 859
 860             }
 861             else
 862             {
 863                 efl_gfx_shape_stroke_color_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r, out g, out b, out a);
 864             }
 865         }
 866
 867         private static efl_gfx_shape_stroke_color_get_delegate efl_gfx_shape_stroke_color_get_static_delegate;
 868
 869
 870         private delegate void efl_gfx_shape_stroke_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  int r,  int g,  int b,  int a);
 871
 872
 873         public delegate void efl_gfx_shape_stroke_color_set_api_delegate(System.IntPtr obj,  int r,  int g,  int b,  int a);
 874
 875         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_color_set_api_delegate> efl_gfx_shape_stroke_color_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_color_set_api_delegate>(Module, "efl_gfx_shape_stroke_color_set");
 876
 877         private static void stroke_color_set(System.IntPtr obj, System.IntPtr pd, int r, int g, int b, int a)
 878         {
 879             Eina.Log.Debug("function efl_gfx_shape_stroke_color_set was called");
 880             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 881             if (wrapper != null)
 882             {
 883
 884                 try
 885                 {
 886                     ((Shape)wrapper).SetStrokeColor(r, g, b, a);
 887                 }
 888                 catch (Exception e)
 889                 {
 890                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 891                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 892                 }
 893
 894
 895             }
 896             else
 897             {
 898                 efl_gfx_shape_stroke_color_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), r, g, b, a);
 899             }
 900         }
 901
 902         private static efl_gfx_shape_stroke_color_set_delegate efl_gfx_shape_stroke_color_set_static_delegate;
 903
 904
 905         private delegate double efl_gfx_shape_stroke_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
 906
 907
 908         public delegate double efl_gfx_shape_stroke_width_get_api_delegate(System.IntPtr obj);
 909
 910         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_width_get_api_delegate> efl_gfx_shape_stroke_width_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_width_get_api_delegate>(Module, "efl_gfx_shape_stroke_width_get");
 911
 912         private static double stroke_width_get(System.IntPtr obj, System.IntPtr pd)
 913         {
 914             Eina.Log.Debug("function efl_gfx_shape_stroke_width_get was called");
 915             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 916             if (wrapper != null)
 917             {
 918             double _ret_var = default(double);
 919                 try
 920                 {
 921                     _ret_var = ((Shape)wrapper).GetStrokeWidth();
 922                 }
 923                 catch (Exception e)
 924                 {
 925                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 926                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 927                 }
 928
 929         return _ret_var;
 930
 931             }
 932             else
 933             {
 934                 return efl_gfx_shape_stroke_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 935             }
 936         }
 937
 938         private static efl_gfx_shape_stroke_width_get_delegate efl_gfx_shape_stroke_width_get_static_delegate;
 939
 940
 941         private delegate void efl_gfx_shape_stroke_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  double w);
 942
 943
 944         public delegate void efl_gfx_shape_stroke_width_set_api_delegate(System.IntPtr obj,  double w);
 945
 946         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_width_set_api_delegate> efl_gfx_shape_stroke_width_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_width_set_api_delegate>(Module, "efl_gfx_shape_stroke_width_set");
 947
 948         private static void stroke_width_set(System.IntPtr obj, System.IntPtr pd, double w)
 949         {
 950             Eina.Log.Debug("function efl_gfx_shape_stroke_width_set was called");
 951             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 952             if (wrapper != null)
 953             {
 954
 955                 try
 956                 {
 957                     ((Shape)wrapper).SetStrokeWidth(w);
 958                 }
 959                 catch (Exception e)
 960                 {
 961                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 962                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 963                 }
 964
 965
 966             }
 967             else
 968             {
 969                 efl_gfx_shape_stroke_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), w);
 970             }
 971         }
 972
 973         private static efl_gfx_shape_stroke_width_set_delegate efl_gfx_shape_stroke_width_set_static_delegate;
 974
 975
 976         private delegate double efl_gfx_shape_stroke_location_get_delegate(System.IntPtr obj, System.IntPtr pd);
 977
 978
 979         public delegate double efl_gfx_shape_stroke_location_get_api_delegate(System.IntPtr obj);
 980
 981         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_location_get_api_delegate> efl_gfx_shape_stroke_location_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_location_get_api_delegate>(Module, "efl_gfx_shape_stroke_location_get");
 982
 983         private static double stroke_location_get(System.IntPtr obj, System.IntPtr pd)
 984         {
 985             Eina.Log.Debug("function efl_gfx_shape_stroke_location_get was called");
 986             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 987             if (wrapper != null)
 988             {
 989             double _ret_var = default(double);
 990                 try
 991                 {
 992                     _ret_var = ((Shape)wrapper).GetStrokeLocation();
 993                 }
 994                 catch (Exception e)
 995                 {
 996                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 997                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 998                 }
 999
1000         return _ret_var;
1001
1002             }
1003             else
1004             {
1005                 return efl_gfx_shape_stroke_location_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1006             }
1007         }
1008
1009         private static efl_gfx_shape_stroke_location_get_delegate efl_gfx_shape_stroke_location_get_static_delegate;
1010
1011
1012         private delegate void efl_gfx_shape_stroke_location_set_delegate(System.IntPtr obj, System.IntPtr pd,  double centered);
1013
1014
1015         public delegate void efl_gfx_shape_stroke_location_set_api_delegate(System.IntPtr obj,  double centered);
1016
1017         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_location_set_api_delegate> efl_gfx_shape_stroke_location_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_location_set_api_delegate>(Module, "efl_gfx_shape_stroke_location_set");
1018
1019         private static void stroke_location_set(System.IntPtr obj, System.IntPtr pd, double centered)
1020         {
1021             Eina.Log.Debug("function efl_gfx_shape_stroke_location_set was called");
1022             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1023             if (wrapper != null)
1024             {
1025
1026                 try
1027                 {
1028                     ((Shape)wrapper).SetStrokeLocation(centered);
1029                 }
1030                 catch (Exception e)
1031                 {
1032                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1033                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1034                 }
1035
1036
1037             }
1038             else
1039             {
1040                 efl_gfx_shape_stroke_location_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), centered);
1041             }
1042         }
1043
1044         private static efl_gfx_shape_stroke_location_set_delegate efl_gfx_shape_stroke_location_set_static_delegate;
1045
1046
1047         private delegate void efl_gfx_shape_stroke_dash_get_delegate(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr dash,  out uint length);
1048
1049
1050         public delegate void efl_gfx_shape_stroke_dash_get_api_delegate(System.IntPtr obj,  out System.IntPtr dash,  out uint length);
1051
1052         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_dash_get_api_delegate> efl_gfx_shape_stroke_dash_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_dash_get_api_delegate>(Module, "efl_gfx_shape_stroke_dash_get");
1053
1054         private static void stroke_dash_get(System.IntPtr obj, System.IntPtr pd, out System.IntPtr dash, out uint length)
1055         {
1056             Eina.Log.Debug("function efl_gfx_shape_stroke_dash_get was called");
1057             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1058             if (wrapper != null)
1059             {
1060                         Efl.Gfx.Dash _out_dash = default(Efl.Gfx.Dash);
1061         length = default(uint);
1062                 try
1063                 {
1064                     ((Shape)wrapper).GetStrokeDash(out _out_dash, out length);
1065                 }
1066                 catch (Exception e)
1067                 {
1068                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1069                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1070                 }
1071
1072         dash = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_dash);
1073
1074             }
1075             else
1076             {
1077                 efl_gfx_shape_stroke_dash_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out dash, out length);
1078             }
1079         }
1080
1081         private static efl_gfx_shape_stroke_dash_get_delegate efl_gfx_shape_stroke_dash_get_static_delegate;
1082
1083
1084         private delegate void efl_gfx_shape_stroke_dash_set_delegate(System.IntPtr obj, System.IntPtr pd,  ref Efl.Gfx.Dash.NativeStruct dash,  uint length);
1085
1086
1087         public delegate void efl_gfx_shape_stroke_dash_set_api_delegate(System.IntPtr obj,  ref Efl.Gfx.Dash.NativeStruct dash,  uint length);
1088
1089         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_dash_set_api_delegate> efl_gfx_shape_stroke_dash_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_dash_set_api_delegate>(Module, "efl_gfx_shape_stroke_dash_set");
1090
1091         private static void stroke_dash_set(System.IntPtr obj, System.IntPtr pd, ref Efl.Gfx.Dash.NativeStruct dash, uint length)
1092         {
1093             Eina.Log.Debug("function efl_gfx_shape_stroke_dash_set was called");
1094             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1095             if (wrapper != null)
1096             {
1097         Efl.Gfx.Dash _in_dash = dash;
1098
1099                 try
1100                 {
1101                     ((Shape)wrapper).SetStrokeDash(ref _in_dash, length);
1102                 }
1103                 catch (Exception e)
1104                 {
1105                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1106                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1107                 }
1108
1109                         dash = _in_dash;
1110
1111             }
1112             else
1113             {
1114                 efl_gfx_shape_stroke_dash_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref dash, length);
1115             }
1116         }
1117
1118         private static efl_gfx_shape_stroke_dash_set_delegate efl_gfx_shape_stroke_dash_set_static_delegate;
1119
1120
1121         private delegate Efl.Gfx.Cap efl_gfx_shape_stroke_cap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1122
1123
1124         public delegate Efl.Gfx.Cap efl_gfx_shape_stroke_cap_get_api_delegate(System.IntPtr obj);
1125
1126         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_cap_get_api_delegate> efl_gfx_shape_stroke_cap_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_cap_get_api_delegate>(Module, "efl_gfx_shape_stroke_cap_get");
1127
1128         private static Efl.Gfx.Cap stroke_cap_get(System.IntPtr obj, System.IntPtr pd)
1129         {
1130             Eina.Log.Debug("function efl_gfx_shape_stroke_cap_get was called");
1131             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1132             if (wrapper != null)
1133             {
1134             Efl.Gfx.Cap _ret_var = default(Efl.Gfx.Cap);
1135                 try
1136                 {
1137                     _ret_var = ((Shape)wrapper).GetStrokeCap();
1138                 }
1139                 catch (Exception e)
1140                 {
1141                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1142                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1143                 }
1144
1145         return _ret_var;
1146
1147             }
1148             else
1149             {
1150                 return efl_gfx_shape_stroke_cap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1151             }
1152         }
1153
1154         private static efl_gfx_shape_stroke_cap_get_delegate efl_gfx_shape_stroke_cap_get_static_delegate;
1155
1156
1157         private delegate void efl_gfx_shape_stroke_cap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Cap c);
1158
1159
1160         public delegate void efl_gfx_shape_stroke_cap_set_api_delegate(System.IntPtr obj,  Efl.Gfx.Cap c);
1161
1162         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_cap_set_api_delegate> efl_gfx_shape_stroke_cap_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_cap_set_api_delegate>(Module, "efl_gfx_shape_stroke_cap_set");
1163
1164         private static void stroke_cap_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.Cap c)
1165         {
1166             Eina.Log.Debug("function efl_gfx_shape_stroke_cap_set was called");
1167             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1168             if (wrapper != null)
1169             {
1170
1171                 try
1172                 {
1173                     ((Shape)wrapper).SetStrokeCap(c);
1174                 }
1175                 catch (Exception e)
1176                 {
1177                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1178                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1179                 }
1180
1181
1182             }
1183             else
1184             {
1185                 efl_gfx_shape_stroke_cap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), c);
1186             }
1187         }
1188
1189         private static efl_gfx_shape_stroke_cap_set_delegate efl_gfx_shape_stroke_cap_set_static_delegate;
1190
1191
1192         private delegate Efl.Gfx.Join efl_gfx_shape_stroke_join_get_delegate(System.IntPtr obj, System.IntPtr pd);
1193
1194
1195         public delegate Efl.Gfx.Join efl_gfx_shape_stroke_join_get_api_delegate(System.IntPtr obj);
1196
1197         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_join_get_api_delegate> efl_gfx_shape_stroke_join_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_join_get_api_delegate>(Module, "efl_gfx_shape_stroke_join_get");
1198
1199         private static Efl.Gfx.Join stroke_join_get(System.IntPtr obj, System.IntPtr pd)
1200         {
1201             Eina.Log.Debug("function efl_gfx_shape_stroke_join_get was called");
1202             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1203             if (wrapper != null)
1204             {
1205             Efl.Gfx.Join _ret_var = default(Efl.Gfx.Join);
1206                 try
1207                 {
1208                     _ret_var = ((Shape)wrapper).GetStrokeJoin();
1209                 }
1210                 catch (Exception e)
1211                 {
1212                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1213                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1214                 }
1215
1216         return _ret_var;
1217
1218             }
1219             else
1220             {
1221                 return efl_gfx_shape_stroke_join_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1222             }
1223         }
1224
1225         private static efl_gfx_shape_stroke_join_get_delegate efl_gfx_shape_stroke_join_get_static_delegate;
1226
1227
1228         private delegate void efl_gfx_shape_stroke_join_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Join j);
1229
1230
1231         public delegate void efl_gfx_shape_stroke_join_set_api_delegate(System.IntPtr obj,  Efl.Gfx.Join j);
1232
1233         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_join_set_api_delegate> efl_gfx_shape_stroke_join_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_stroke_join_set_api_delegate>(Module, "efl_gfx_shape_stroke_join_set");
1234
1235         private static void stroke_join_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.Join j)
1236         {
1237             Eina.Log.Debug("function efl_gfx_shape_stroke_join_set was called");
1238             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1239             if (wrapper != null)
1240             {
1241
1242                 try
1243                 {
1244                     ((Shape)wrapper).SetStrokeJoin(j);
1245                 }
1246                 catch (Exception e)
1247                 {
1248                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1249                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1250                 }
1251
1252
1253             }
1254             else
1255             {
1256                 efl_gfx_shape_stroke_join_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), j);
1257             }
1258         }
1259
1260         private static efl_gfx_shape_stroke_join_set_delegate efl_gfx_shape_stroke_join_set_static_delegate;
1261
1262
1263         private delegate Efl.Gfx.FillRule efl_gfx_shape_fill_rule_get_delegate(System.IntPtr obj, System.IntPtr pd);
1264
1265
1266         public delegate Efl.Gfx.FillRule efl_gfx_shape_fill_rule_get_api_delegate(System.IntPtr obj);
1267
1268         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_fill_rule_get_api_delegate> efl_gfx_shape_fill_rule_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_fill_rule_get_api_delegate>(Module, "efl_gfx_shape_fill_rule_get");
1269
1270         private static Efl.Gfx.FillRule fill_rule_get(System.IntPtr obj, System.IntPtr pd)
1271         {
1272             Eina.Log.Debug("function efl_gfx_shape_fill_rule_get was called");
1273             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1274             if (wrapper != null)
1275             {
1276             Efl.Gfx.FillRule _ret_var = default(Efl.Gfx.FillRule);
1277                 try
1278                 {
1279                     _ret_var = ((Shape)wrapper).GetFillRule();
1280                 }
1281                 catch (Exception e)
1282                 {
1283                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1284                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1285                 }
1286
1287         return _ret_var;
1288
1289             }
1290             else
1291             {
1292                 return efl_gfx_shape_fill_rule_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1293             }
1294         }
1295
1296         private static efl_gfx_shape_fill_rule_get_delegate efl_gfx_shape_fill_rule_get_static_delegate;
1297
1298
1299         private delegate void efl_gfx_shape_fill_rule_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.FillRule fill_rule);
1300
1301
1302         public delegate void efl_gfx_shape_fill_rule_set_api_delegate(System.IntPtr obj,  Efl.Gfx.FillRule fill_rule);
1303
1304         public static Efl.Eo.FunctionWrapper<efl_gfx_shape_fill_rule_set_api_delegate> efl_gfx_shape_fill_rule_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_shape_fill_rule_set_api_delegate>(Module, "efl_gfx_shape_fill_rule_set");
1305
1306         private static void fill_rule_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.FillRule fill_rule)
1307         {
1308             Eina.Log.Debug("function efl_gfx_shape_fill_rule_set was called");
1309             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1310             if (wrapper != null)
1311             {
1312
1313                 try
1314                 {
1315                     ((Shape)wrapper).SetFillRule(fill_rule);
1316                 }
1317                 catch (Exception e)
1318                 {
1319                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1320                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1321                 }
1322
1323
1324             }
1325             else
1326             {
1327                 efl_gfx_shape_fill_rule_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill_rule);
1328             }
1329         }
1330
1331         private static efl_gfx_shape_fill_rule_set_delegate efl_gfx_shape_fill_rule_set_static_delegate;
1332
1333         #pragma warning restore CA1707, SA1300, SA1600
1334
1335 }
1336 }
1337 }
1338
1339 }
1340
1341 }
1342