internals/src/EflSharp/EflSharp/efl/efl_gfx_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 Gfx {
  11
  12 /// <summary>EFL graphics shape object interface</summary>
  13 [Efl.Gfx.IShapeConcrete.NativeMethods]
  14 [Efl.Eo.BindingEntity]
  15 public interface IShape :
  16     Efl.Gfx.IPath ,
  17     Efl.Eo.IWrapper, IDisposable
  18 {
  19     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
  20 /// <returns>Stroke scale value</returns>
  21 double GetStrokeScale();
  22     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
  23 /// <param name="s">Stroke scale value</param>
  24 void SetStrokeScale(double s);
  25     /// <summary>The color to be used for stroking the path.</summary>
  26 /// <param name="r">The red component of the given color.</param>
  27 /// <param name="g">The green component of the given color.</param>
  28 /// <param name="b">The blue component of the given color.</param>
  29 /// <param name="a">The alpha component of the given color.</param>
  30 void GetStrokeColor(out int r, out int g, out int b, out int a);
  31     /// <summary>The color to be used for stroking the path.</summary>
  32 /// <param name="r">The red component of the given color.</param>
  33 /// <param name="g">The green component of the given color.</param>
  34 /// <param name="b">The blue component of the given color.</param>
  35 /// <param name="a">The alpha component of the given color.</param>
  36 void SetStrokeColor(int r, int g, int b, int a);
  37     /// <summary>The stroke width to be used for stroking the path.</summary>
  38 /// <returns>Stroke width to be used</returns>
  39 double GetStrokeWidth();
  40     /// <summary>The stroke width to be used for stroking the path.</summary>
  41 /// <param name="w">Stroke width to be used</param>
  42 void SetStrokeWidth(double w);
  43     /// <summary>Not implemented</summary>
  44 /// <returns>Centered stroke location</returns>
  45 double GetStrokeLocation();
  46     /// <summary>Not implemented</summary>
  47 /// <param name="centered">Centered stroke location</param>
  48 void SetStrokeLocation(double centered);
  49     /// <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.
  50 /// See also <see cref="Efl.Gfx.Dash"/></summary>
  51 /// <param name="dash">Stroke dash</param>
  52 /// <param name="length">Stroke dash length</param>
  53 void GetStrokeDash(out Efl.Gfx.Dash dash, out uint length);
  54     /// <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.
  55 /// See also <see cref="Efl.Gfx.Dash"/></summary>
  56 /// <param name="dash">Stroke dash</param>
  57 /// <param name="length">Stroke dash length</param>
  58 void SetStrokeDash(ref Efl.Gfx.Dash dash, uint length);
  59     /// <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.
  60 /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
  61 /// <returns>Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></returns>
  62 Efl.Gfx.Cap GetStrokeCap();
  63     /// <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.
  64 /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
  65 /// <param name="c">Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></param>
  66 void SetStrokeCap(Efl.Gfx.Cap c);
  67     /// <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.
  68 /// See also <see cref="Efl.Gfx.Join"/>.</summary>
  69 /// <returns>Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></returns>
  70 Efl.Gfx.Join GetStrokeJoin();
  71     /// <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.
  72 /// See also <see cref="Efl.Gfx.Join"/>.</summary>
  73 /// <param name="j">Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></param>
  74 void SetStrokeJoin(Efl.Gfx.Join j);
  75     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
  76 /// <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>
  77 Efl.Gfx.FillRule GetFillRule();
  78     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
  79 /// <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>
  80 void SetFillRule(Efl.Gfx.FillRule fill_rule);
  81                                                                     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
  82     /// <value>Stroke scale value</value>
  83     double StrokeScale {
  84         get ;
  85         set ;
  86     }
  87     /// <summary>The stroke width to be used for stroking the path.</summary>
  88     /// <value>Stroke width to be used</value>
  89     double StrokeWidth {
  90         get ;
  91         set ;
  92     }
  93     /// <summary>Not implemented</summary>
  94     /// <value>Centered stroke location</value>
  95     double StrokeLocation {
  96         get ;
  97         set ;
  98     }
  99     /// <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.
 100     /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
 101     /// <value>Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></value>
 102     Efl.Gfx.Cap StrokeCap {
 103         get ;
 104         set ;
 105     }
 106     /// <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.
 107     /// See also <see cref="Efl.Gfx.Join"/>.</summary>
 108     /// <value>Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></value>
 109     Efl.Gfx.Join StrokeJoin {
 110         get ;
 111         set ;
 112     }
 113     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
 114     /// <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>
 115     Efl.Gfx.FillRule FillRule {
 116         get ;
 117         set ;
 118     }
 119 }
 120 /// <summary>EFL graphics shape object interface</summary>
 121 sealed public class IShapeConcrete :
 122     Efl.Eo.EoWrapper
 123     , IShape
 124     , Efl.Gfx.IPath
 125 {
 126     ///<summary>Pointer to the native class description.</summary>
 127     public override System.IntPtr NativeClass
 128     {
 129         get
 130         {
 131             if (((object)this).GetType() == typeof(IShapeConcrete))
 132             {
 133                 return GetEflClassStatic();
 134             }
 135             else
 136             {
 137                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 138             }
 139         }
 140     }
 141
 142     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
 143     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
 144     private IShapeConcrete(ConstructingHandle ch) : base(ch)
 145     {
 146     }
 147
 148     [System.Runtime.InteropServices.DllImport("libefl.so.1")] internal static extern System.IntPtr
 149         efl_gfx_shape_mixin_get();
 150     /// <summary>Initializes a new instance of the <see cref="IShape"/> class.
 151     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 152     /// <param name="wh">The native pointer to be wrapped.</param>
 153     private IShapeConcrete(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
 154     {
 155     }
 156
 157     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
 158     /// <returns>Stroke scale value</returns>
 159     public double GetStrokeScale() {
 160          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_scale_get_ptr.Value.Delegate(this.NativeHandle);
 161         Eina.Error.RaiseIfUnhandledException();
 162         return _ret_var;
 163  }
 164     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
 165     /// <param name="s">Stroke scale value</param>
 166     public void SetStrokeScale(double s) {
 167                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_scale_set_ptr.Value.Delegate(this.NativeHandle,s);
 168         Eina.Error.RaiseIfUnhandledException();
 169                          }
 170     /// <summary>The color to be used for stroking the path.</summary>
 171     /// <param name="r">The red component of the given color.</param>
 172     /// <param name="g">The green component of the given color.</param>
 173     /// <param name="b">The blue component of the given color.</param>
 174     /// <param name="a">The alpha component of the given color.</param>
 175     public void GetStrokeColor(out int r, out int g, out int b, out int a) {
 176                                                                                                          Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_color_get_ptr.Value.Delegate(this.NativeHandle,out r, out g, out b, out a);
 177         Eina.Error.RaiseIfUnhandledException();
 178                                                                          }
 179     /// <summary>The color to be used for stroking the path.</summary>
 180     /// <param name="r">The red component of the given color.</param>
 181     /// <param name="g">The green component of the given color.</param>
 182     /// <param name="b">The blue component of the given color.</param>
 183     /// <param name="a">The alpha component of the given color.</param>
 184     public void SetStrokeColor(int r, int g, int b, int a) {
 185                                                                                                          Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_color_set_ptr.Value.Delegate(this.NativeHandle,r, g, b, a);
 186         Eina.Error.RaiseIfUnhandledException();
 187                                                                          }
 188     /// <summary>The stroke width to be used for stroking the path.</summary>
 189     /// <returns>Stroke width to be used</returns>
 190     public double GetStrokeWidth() {
 191          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_width_get_ptr.Value.Delegate(this.NativeHandle);
 192         Eina.Error.RaiseIfUnhandledException();
 193         return _ret_var;
 194  }
 195     /// <summary>The stroke width to be used for stroking the path.</summary>
 196     /// <param name="w">Stroke width to be used</param>
 197     public void SetStrokeWidth(double w) {
 198                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_width_set_ptr.Value.Delegate(this.NativeHandle,w);
 199         Eina.Error.RaiseIfUnhandledException();
 200                          }
 201     /// <summary>Not implemented</summary>
 202     /// <returns>Centered stroke location</returns>
 203     public double GetStrokeLocation() {
 204          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_location_get_ptr.Value.Delegate(this.NativeHandle);
 205         Eina.Error.RaiseIfUnhandledException();
 206         return _ret_var;
 207  }
 208     /// <summary>Not implemented</summary>
 209     /// <param name="centered">Centered stroke location</param>
 210     public void SetStrokeLocation(double centered) {
 211                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_location_set_ptr.Value.Delegate(this.NativeHandle,centered);
 212         Eina.Error.RaiseIfUnhandledException();
 213                          }
 214     /// <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.
 215     /// See also <see cref="Efl.Gfx.Dash"/></summary>
 216     /// <param name="dash">Stroke dash</param>
 217     /// <param name="length">Stroke dash length</param>
 218     public void GetStrokeDash(out Efl.Gfx.Dash dash, out uint length) {
 219                          var _out_dash = new System.IntPtr();
 220                                 Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_dash_get_ptr.Value.Delegate(this.NativeHandle,out _out_dash, out length);
 221         Eina.Error.RaiseIfUnhandledException();
 222         dash = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.Dash>(_out_dash);
 223                                  }
 224     /// <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.
 225     /// See also <see cref="Efl.Gfx.Dash"/></summary>
 226     /// <param name="dash">Stroke dash</param>
 227     /// <param name="length">Stroke dash length</param>
 228     public void SetStrokeDash(ref Efl.Gfx.Dash dash, uint length) {
 229          Efl.Gfx.Dash.NativeStruct _in_dash = dash;
 230                                                 Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_dash_set_ptr.Value.Delegate(this.NativeHandle,ref _in_dash, length);
 231         Eina.Error.RaiseIfUnhandledException();
 232                         dash = _in_dash;
 233                  }
 234     /// <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.
 235     /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
 236     /// <returns>Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></returns>
 237     public Efl.Gfx.Cap GetStrokeCap() {
 238          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_cap_get_ptr.Value.Delegate(this.NativeHandle);
 239         Eina.Error.RaiseIfUnhandledException();
 240         return _ret_var;
 241  }
 242     /// <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.
 243     /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
 244     /// <param name="c">Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></param>
 245     public void SetStrokeCap(Efl.Gfx.Cap c) {
 246                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_cap_set_ptr.Value.Delegate(this.NativeHandle,c);
 247         Eina.Error.RaiseIfUnhandledException();
 248                          }
 249     /// <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.
 250     /// See also <see cref="Efl.Gfx.Join"/>.</summary>
 251     /// <returns>Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></returns>
 252     public Efl.Gfx.Join GetStrokeJoin() {
 253          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_join_get_ptr.Value.Delegate(this.NativeHandle);
 254         Eina.Error.RaiseIfUnhandledException();
 255         return _ret_var;
 256  }
 257     /// <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.
 258     /// See also <see cref="Efl.Gfx.Join"/>.</summary>
 259     /// <param name="j">Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></param>
 260     public void SetStrokeJoin(Efl.Gfx.Join j) {
 261                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_stroke_join_set_ptr.Value.Delegate(this.NativeHandle,j);
 262         Eina.Error.RaiseIfUnhandledException();
 263                          }
 264     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
 265     /// <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>
 266     public Efl.Gfx.FillRule GetFillRule() {
 267          var _ret_var = Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_fill_rule_get_ptr.Value.Delegate(this.NativeHandle);
 268         Eina.Error.RaiseIfUnhandledException();
 269         return _ret_var;
 270  }
 271     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
 272     /// <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>
 273     public void SetFillRule(Efl.Gfx.FillRule fill_rule) {
 274                                  Efl.Gfx.IShapeConcrete.NativeMethods.efl_gfx_shape_fill_rule_set_ptr.Value.Delegate(this.NativeHandle,fill_rule);
 275         Eina.Error.RaiseIfUnhandledException();
 276                          }
 277     /// <summary>Set the list of commands and points to be used to create the content of path.</summary>
 278     /// <param name="op">Command list</param>
 279     /// <param name="points">Point list</param>
 280     public void GetPath(out Efl.Gfx.PathCommandType op, out double points) {
 281                          System.IntPtr _out_op = System.IntPtr.Zero;
 282         System.IntPtr _out_points = System.IntPtr.Zero;
 283                         Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_get_ptr.Value.Delegate(this.NativeHandle,out _out_op, out _out_points);
 284         Eina.Error.RaiseIfUnhandledException();
 285         op = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.PathCommandType>(_out_op);
 286         points = Eina.PrimitiveConversion.PointerToManaged<double>(_out_points);
 287                          }
 288     /// <summary>Set the list of commands and points to be used to create the content of path.</summary>
 289     /// <param name="op">Command list</param>
 290     /// <param name="points">Point list</param>
 291     public void SetPath(Efl.Gfx.PathCommandType op, double points) {
 292          var _in_op = Eina.PrimitiveConversion.ManagedToPointerAlloc(op);
 293         var _in_points = Eina.PrimitiveConversion.ManagedToPointerAlloc(points);
 294                                         Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_set_ptr.Value.Delegate(this.NativeHandle,_in_op, _in_points);
 295         Eina.Error.RaiseIfUnhandledException();
 296                                          }
 297     /// <summary>Path length property</summary>
 298     /// <param name="commands">Commands</param>
 299     /// <param name="points">Points</param>
 300     public void GetLength(out uint commands, out uint points) {
 301                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_length_get_ptr.Value.Delegate(this.NativeHandle,out commands, out points);
 302         Eina.Error.RaiseIfUnhandledException();
 303                                          }
 304     /// <summary>Current point coordinates</summary>
 305     /// <param name="x">X co-ordinate of the current point.</param>
 306     /// <param name="y">Y co-ordinate of the current point.</param>
 307     public void GetCurrent(out double x, out double y) {
 308                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_current_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
 309         Eina.Error.RaiseIfUnhandledException();
 310                                          }
 311     /// <summary>Current control point coordinates</summary>
 312     /// <param name="x">X co-ordinate of control point.</param>
 313     /// <param name="y">Y co-ordinate of control point.</param>
 314     public void GetCurrentCtrl(out double x, out double y) {
 315                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_current_ctrl_get_ptr.Value.Delegate(this.NativeHandle,out x, out y);
 316         Eina.Error.RaiseIfUnhandledException();
 317                                          }
 318     /// <summary>Copy the path data from the object specified.</summary>
 319     /// <param name="dup_from">Shape object from where data will be copied.</param>
 320     public void CopyFrom(Efl.Object dup_from) {
 321                                  Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_copy_from_ptr.Value.Delegate(this.NativeHandle,dup_from);
 322         Eina.Error.RaiseIfUnhandledException();
 323                          }
 324     /// <summary>Compute and return the bounding box of the currently set path</summary>
 325     /// <param name="r">Contain the bounding box of the currently set path</param>
 326     public void GetBounds(out Eina.Rect r) {
 327                  var _out_r = new Eina.Rect.NativeStruct();
 328                 Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_bounds_get_ptr.Value.Delegate(this.NativeHandle,out _out_r);
 329         Eina.Error.RaiseIfUnhandledException();
 330         r = _out_r;
 331                  }
 332     /// <summary>Reset the path data of the path object.</summary>
 333     public void Reset() {
 334          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_reset_ptr.Value.Delegate(this.NativeHandle);
 335         Eina.Error.RaiseIfUnhandledException();
 336          }
 337     /// <summary>Moves the current point to the given point,  implicitly starting a new subpath and closing the previous one.
 338     /// See also <see cref="Efl.Gfx.IPath.CloseAppend"/>.</summary>
 339     /// <param name="x">X co-ordinate of the current point.</param>
 340     /// <param name="y">Y co-ordinate of the current point.</param>
 341     public void AppendMoveTo(double x, double y) {
 342                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_move_to_ptr.Value.Delegate(this.NativeHandle,x, y);
 343         Eina.Error.RaiseIfUnhandledException();
 344                                          }
 345     /// <summary>Adds a straight line from the current position to the given end point. After the line is drawn, the current position is updated to be at the end point of the line.
 346     /// If no current position present, it draws a line to itself, basically a point.
 347     ///
 348     /// See also <see cref="Efl.Gfx.IPath.AppendMoveTo"/>.</summary>
 349     /// <param name="x">X co-ordinate of end point of the line.</param>
 350     /// <param name="y">Y co-ordinate of end point of the line.</param>
 351     public void AppendLineTo(double x, double y) {
 352                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_line_to_ptr.Value.Delegate(this.NativeHandle,x, y);
 353         Eina.Error.RaiseIfUnhandledException();
 354                                          }
 355     /// <summary>Adds a quadratic Bezier curve between the current position and the given end point (x,y) using the control points specified by (ctrl_x, ctrl_y). After the path is drawn, the current position is updated to be at the end point of the path.</summary>
 356     /// <param name="x">X co-ordinate of end point of the line.</param>
 357     /// <param name="y">Y co-ordinate of end point of the line.</param>
 358     /// <param name="ctrl_x">X co-ordinate of control point.</param>
 359     /// <param name="ctrl_y">Y co-ordinate of control point.</param>
 360     public void AppendQuadraticTo(double x, double y, double ctrl_x, double ctrl_y) {
 361                                                                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_quadratic_to_ptr.Value.Delegate(this.NativeHandle,x, y, ctrl_x, ctrl_y);
 362         Eina.Error.RaiseIfUnhandledException();
 363                                                                          }
 364     /// <summary>Same as efl_gfx_path_append_quadratic_to() api only difference is that it uses the current control point to draw the bezier.
 365     /// See also <see cref="Efl.Gfx.IPath.AppendQuadraticTo"/>.</summary>
 366     /// <param name="x">X co-ordinate of end point of the line.</param>
 367     /// <param name="y">Y co-ordinate of end point of the line.</param>
 368     public void AppendSquadraticTo(double x, double y) {
 369                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_squadratic_to_ptr.Value.Delegate(this.NativeHandle,x, y);
 370         Eina.Error.RaiseIfUnhandledException();
 371                                          }
 372     /// <summary>Adds a cubic Bezier curve between the current position and the given end point (x,y) using the control points specified by (ctrl_x0, ctrl_y0), and (ctrl_x1, ctrl_y1). After the path is drawn, the current position is updated to be at the end point of the path.</summary>
 373     /// <param name="ctrl_x0">X co-ordinate of 1st control point.</param>
 374     /// <param name="ctrl_y0">Y co-ordinate of 1st control point.</param>
 375     /// <param name="ctrl_x1">X co-ordinate of 2nd control point.</param>
 376     /// <param name="ctrl_y1">Y co-ordinate of 2nd control point.</param>
 377     /// <param name="x">X co-ordinate of end point of the line.</param>
 378     /// <param name="y">Y co-ordinate of end point of the line.</param>
 379     public void AppendCubicTo(double ctrl_x0, double ctrl_y0, double ctrl_x1, double ctrl_y1, double x, double y) {
 380                                                                                                                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_cubic_to_ptr.Value.Delegate(this.NativeHandle,ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
 381         Eina.Error.RaiseIfUnhandledException();
 382                                                                                                          }
 383     /// <summary>Same as efl_gfx_path_append_cubic_to() api only difference is that it uses the current control point to draw the bezier.
 384     /// See also <see cref="Efl.Gfx.IPath.AppendCubicTo"/>.</summary>
 385     /// <param name="x">X co-ordinate of end point of the line.</param>
 386     /// <param name="y">Y co-ordinate of end point of the line.</param>
 387     /// <param name="ctrl_x">X co-ordinate of 2nd control point.</param>
 388     /// <param name="ctrl_y">Y co-ordinate of 2nd control point.</param>
 389     public void AppendScubicTo(double x, double y, double ctrl_x, double ctrl_y) {
 390                                                                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_scubic_to_ptr.Value.Delegate(this.NativeHandle,x, y, ctrl_x, ctrl_y);
 391         Eina.Error.RaiseIfUnhandledException();
 392                                                                          }
 393     /// <summary>Append an arc that connects from the current point int the point list to the given point (x,y). The arc is defined by the given radius in  x-direction (rx) and radius in y direction (ry).
 394     /// Use this api if you know the end point&apos;s of the arc otherwise use more convenient function <see cref="Efl.Gfx.IPath.AppendArc"/>.</summary>
 395     /// <param name="x">X co-ordinate of end point of the arc.</param>
 396     /// <param name="y">Y co-ordinate of end point of the arc.</param>
 397     /// <param name="rx">Radius of arc in x direction.</param>
 398     /// <param name="ry">Radius of arc in y direction.</param>
 399     /// <param name="angle">X-axis rotation , normally 0.</param>
 400     /// <param name="large_arc">Defines whether to draw the larger arc or smaller arc joining two point.</param>
 401     /// <param name="sweep">Defines whether the arc will be drawn counter-clockwise or clockwise from current point to the end point taking into account the large_arc property.</param>
 402     public void AppendArcTo(double x, double y, double rx, double ry, double angle, bool large_arc, bool sweep) {
 403                                                                                                                                                                                  Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_arc_to_ptr.Value.Delegate(this.NativeHandle,x, y, rx, ry, angle, large_arc, sweep);
 404         Eina.Error.RaiseIfUnhandledException();
 405                                                                                                                          }
 406     /// <summary>Append an arc that enclosed in the given rectangle (x, y, w, h). The angle is defined in counter clock wise , use -ve angle for clockwise arc.</summary>
 407     /// <param name="x">X co-ordinate of the rect.</param>
 408     /// <param name="y">Y co-ordinate of the rect.</param>
 409     /// <param name="w">Width of the rect.</param>
 410     /// <param name="h">Height of the rect.</param>
 411     /// <param name="start_angle">Angle at which the arc will start</param>
 412     /// <param name="sweep_length">@ Length of the arc.</param>
 413     public void AppendArc(double x, double y, double w, double h, double start_angle, double sweep_length) {
 414                                                                                                                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_arc_ptr.Value.Delegate(this.NativeHandle,x, y, w, h, start_angle, sweep_length);
 415         Eina.Error.RaiseIfUnhandledException();
 416                                                                                                          }
 417     /// <summary>Closes the current subpath by drawing a line to the beginning of the subpath, automatically starting a new path. The current point of the new path is (0, 0).
 418     /// If the subpath does not contain any points, this function does nothing.</summary>
 419     public void CloseAppend() {
 420          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_close_ptr.Value.Delegate(this.NativeHandle);
 421         Eina.Error.RaiseIfUnhandledException();
 422          }
 423     /// <summary>Append a circle with given center and radius.</summary>
 424     /// <param name="x">X co-ordinate of the center of the circle.</param>
 425     /// <param name="y">Y co-ordinate of the center of the circle.</param>
 426     /// <param name="radius">Radius of the circle.</param>
 427     public void AppendCircle(double x, double y, double radius) {
 428                                                                                  Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_circle_ptr.Value.Delegate(this.NativeHandle,x, y, radius);
 429         Eina.Error.RaiseIfUnhandledException();
 430                                                          }
 431     /// <summary>Append the given rectangle with rounded corner to the path.
 432     /// The xr and yr arguments specify the radii of the ellipses defining the corners of the rounded rectangle.
 433     ///
 434     /// xr and yr are specified in terms of width and height respectively.
 435     ///
 436     /// If xr and yr are 0, then it will draw a rectangle without rounded corner.</summary>
 437     /// <param name="x">X co-ordinate of the rectangle.</param>
 438     /// <param name="y">Y co-ordinate of the rectangle.</param>
 439     /// <param name="w">Width of the rectangle.</param>
 440     /// <param name="h">Height of the rectangle.</param>
 441     /// <param name="rx">The x radius of the rounded corner and should be in range [ 0 to w/2 ]</param>
 442     /// <param name="ry">The y radius of the rounded corner and should be in range [ 0 to h/2 ]</param>
 443     public void AppendRect(double x, double y, double w, double h, double rx, double ry) {
 444                                                                                                                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_rect_ptr.Value.Delegate(this.NativeHandle,x, y, w, h, rx, ry);
 445         Eina.Error.RaiseIfUnhandledException();
 446                                                                                                          }
 447     /// <summary>Append SVG path data</summary>
 448     /// <param name="svg_path_data">SVG path data to append</param>
 449     public void AppendSvgPath(System.String svg_path_data) {
 450                                  Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_append_svg_path_ptr.Value.Delegate(this.NativeHandle,svg_path_data);
 451         Eina.Error.RaiseIfUnhandledException();
 452                          }
 453     /// <summary>Creates intermediary path part-way between two paths
 454     /// Sets the points of the <c>obj</c> as the linear interpolation of the points in the <c>from</c> and <c>to</c> paths.  The path&apos;s x,y position and control point coordinates are likewise interpolated.
 455     ///
 456     /// The <c>from</c> and <c>to</c> paths must not already have equivalent points, and <c>to</c> must contain at least as many points as <c>from</c>, else the function returns <c>false</c> with no interpolation performed.  If <c>to</c> has more points than <c>from</c>, the excess points are ignored.</summary>
 457     /// <param name="from">Source path</param>
 458     /// <param name="to">Destination path</param>
 459     /// <param name="pos_map">Position map in range 0.0 to 1.0</param>
 460     /// <returns><c>true</c> on success, <c>false</c> otherwise</returns>
 461     public bool Interpolate(Efl.Object from, Efl.Object to, double pos_map) {
 462                                                                                  var _ret_var = Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_interpolate_ptr.Value.Delegate(this.NativeHandle,from, to, pos_map);
 463         Eina.Error.RaiseIfUnhandledException();
 464                                                         return _ret_var;
 465  }
 466     /// <summary>Equal commands in object</summary>
 467     /// <param name="with">Object</param>
 468     /// <returns>True on success, <c>false</c> otherwise</returns>
 469     public bool EqualCommands(Efl.Object with) {
 470                                  var _ret_var = Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_equal_commands_ptr.Value.Delegate(this.NativeHandle,with);
 471         Eina.Error.RaiseIfUnhandledException();
 472                         return _ret_var;
 473  }
 474     /// <summary>Reserve path commands buffer in advance. If you know the count of path commands coming, you can reserve commands buffer in advance to avoid buffer growing job.</summary>
 475     /// <param name="cmd_count">Commands count to reserve</param>
 476     /// <param name="pts_count">Pointers count to reserve</param>
 477     public void Reserve(uint cmd_count, uint pts_count) {
 478                                                          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_reserve_ptr.Value.Delegate(this.NativeHandle,cmd_count, pts_count);
 479         Eina.Error.RaiseIfUnhandledException();
 480                                          }
 481     /// <summary>Request to update the path object.
 482     /// One path object may get appending several path calls (such as append_cubic, append_rect, etc) to construct the final path data. Here commit means all path data is prepared and now object could update its own internal status based on the last path information.</summary>
 483     public void Commit() {
 484          Efl.Gfx.IPathConcrete.NativeMethods.efl_gfx_path_commit_ptr.Value.Delegate(this.NativeHandle);
 485         Eina.Error.RaiseIfUnhandledException();
 486          }
 487     /// <summary>The stroke scale to be used for stroking the path. Will be used along with stroke width property.</summary>
 488     /// <value>Stroke scale value</value>
 489     public double StrokeScale {
 490         get { return GetStrokeScale(); }
 491         set { SetStrokeScale(value); }
 492     }
 493     /// <summary>The stroke width to be used for stroking the path.</summary>
 494     /// <value>Stroke width to be used</value>
 495     public double StrokeWidth {
 496         get { return GetStrokeWidth(); }
 497         set { SetStrokeWidth(value); }
 498     }
 499     /// <summary>Not implemented</summary>
 500     /// <value>Centered stroke location</value>
 501     public double StrokeLocation {
 502         get { return GetStrokeLocation(); }
 503         set { SetStrokeLocation(value); }
 504     }
 505     /// <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.
 506     /// See also <see cref="Efl.Gfx.Cap"/>.</summary>
 507     /// <value>Cap style to use, default is <see cref="Efl.Gfx.Cap.Butt"/></value>
 508     public Efl.Gfx.Cap StrokeCap {
 509         get { return GetStrokeCap(); }
 510         set { SetStrokeCap(value); }
 511     }
 512     /// <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.
 513     /// See also <see cref="Efl.Gfx.Join"/>.</summary>
 514     /// <value>Join style to use, default is <see cref="Efl.Gfx.Join.Miter"/></value>
 515     public Efl.Gfx.Join StrokeJoin {
 516         get { return GetStrokeJoin(); }
 517         set { SetStrokeJoin(value); }
 518     }
 519     /// <summary>The fill rule of the given shape object. <see cref="Efl.Gfx.FillRule.Winding"/> or <see cref="Efl.Gfx.FillRule.OddEven"/>.</summary>
 520     /// <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>
 521     public Efl.Gfx.FillRule FillRule {
 522         get { return GetFillRule(); }
 523         set { SetFillRule(value); }
 524     }
 525     private static IntPtr GetEflClassStatic()
 526     {
 527         return Efl.Gfx.IShapeConcrete.efl_gfx_shape_mixin_get();
 528     }
 529     /// <summary>Wrapper for native methods and virtual method delegates.
 530     /// For internal use by generated code only.</summary>
 531     public new class NativeMethods : Efl.Eo.EoWrapper.NativeMethods
 532     {
 533         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 534         /// <summary>Gets the list of Eo operations to override.</summary>
 535         /// <returns>The list of Eo operations to be overload.</returns>
 536         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 537         {
 538             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 539             var methods = Efl.Eo.Globals.GetUserMethods(type);
 540
 541             if (efl_gfx_shape_stroke_scale_get_static_delegate == null)
 542             {
 543                 efl_gfx_shape_stroke_scale_get_static_delegate = new efl_gfx_shape_stroke_scale_get_delegate(stroke_scale_get);
 544             }
 545
 546             if (methods.FirstOrDefault(m => m.Name == "GetStrokeScale") != null)
 547             {
 548                 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) });
 549             }
 550
 551             if (efl_gfx_shape_stroke_scale_set_static_delegate == null)
 552             {
 553                 efl_gfx_shape_stroke_scale_set_static_delegate = new efl_gfx_shape_stroke_scale_set_delegate(stroke_scale_set);
 554             }
 555
 556             if (methods.FirstOrDefault(m => m.Name == "SetStrokeScale") != null)
 557             {
 558                 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) });
 559             }
 560
 561             if (efl_gfx_shape_stroke_color_get_static_delegate == null)
 562             {
 563                 efl_gfx_shape_stroke_color_get_static_delegate = new efl_gfx_shape_stroke_color_get_delegate(stroke_color_get);
 564             }
 565
 566             if (methods.FirstOrDefault(m => m.Name == "GetStrokeColor") != null)
 567             {
 568                 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) });
 569             }
 570
 571             if (efl_gfx_shape_stroke_color_set_static_delegate == null)
 572             {
 573                 efl_gfx_shape_stroke_color_set_static_delegate = new efl_gfx_shape_stroke_color_set_delegate(stroke_color_set);
 574             }
 575
 576             if (methods.FirstOrDefault(m => m.Name == "SetStrokeColor") != null)
 577             {
 578                 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) });
 579             }
 580
 581             if (efl_gfx_shape_stroke_width_get_static_delegate == null)
 582             {
 583                 efl_gfx_shape_stroke_width_get_static_delegate = new efl_gfx_shape_stroke_width_get_delegate(stroke_width_get);
 584             }
 585
 586             if (methods.FirstOrDefault(m => m.Name == "GetStrokeWidth") != null)
 587             {
 588                 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) });
 589             }
 590
 591             if (efl_gfx_shape_stroke_width_set_static_delegate == null)
 592             {
 593                 efl_gfx_shape_stroke_width_set_static_delegate = new efl_gfx_shape_stroke_width_set_delegate(stroke_width_set);
 594             }
 595
 596             if (methods.FirstOrDefault(m => m.Name == "SetStrokeWidth") != null)
 597             {
 598                 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) });
 599             }
 600
 601             if (efl_gfx_shape_stroke_location_get_static_delegate == null)
 602             {
 603                 efl_gfx_shape_stroke_location_get_static_delegate = new efl_gfx_shape_stroke_location_get_delegate(stroke_location_get);
 604             }
 605
 606             if (methods.FirstOrDefault(m => m.Name == "GetStrokeLocation") != null)
 607             {
 608                 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) });
 609             }
 610
 611             if (efl_gfx_shape_stroke_location_set_static_delegate == null)
 612             {
 613                 efl_gfx_shape_stroke_location_set_static_delegate = new efl_gfx_shape_stroke_location_set_delegate(stroke_location_set);
 614             }
 615
 616             if (methods.FirstOrDefault(m => m.Name == "SetStrokeLocation") != null)
 617             {
 618                 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) });
 619             }
 620
 621             if (efl_gfx_shape_stroke_dash_get_static_delegate == null)
 622             {
 623                 efl_gfx_shape_stroke_dash_get_static_delegate = new efl_gfx_shape_stroke_dash_get_delegate(stroke_dash_get);
 624             }
 625
 626             if (methods.FirstOrDefault(m => m.Name == "GetStrokeDash") != null)
 627             {
 628                 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) });
 629             }
 630
 631             if (efl_gfx_shape_stroke_dash_set_static_delegate == null)
 632             {
 633                 efl_gfx_shape_stroke_dash_set_static_delegate = new efl_gfx_shape_stroke_dash_set_delegate(stroke_dash_set);
 634             }
 635
 636             if (methods.FirstOrDefault(m => m.Name == "SetStrokeDash") != null)
 637             {
 638                 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) });
 639             }
 640
 641             if (efl_gfx_shape_stroke_cap_get_static_delegate == null)
 642             {
 643                 efl_gfx_shape_stroke_cap_get_static_delegate = new efl_gfx_shape_stroke_cap_get_delegate(stroke_cap_get);
 644             }
 645
 646             if (methods.FirstOrDefault(m => m.Name == "GetStrokeCap") != null)
 647             {
 648                 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) });
 649             }
 650
 651             if (efl_gfx_shape_stroke_cap_set_static_delegate == null)
 652             {
 653                 efl_gfx_shape_stroke_cap_set_static_delegate = new efl_gfx_shape_stroke_cap_set_delegate(stroke_cap_set);
 654             }
 655
 656             if (methods.FirstOrDefault(m => m.Name == "SetStrokeCap") != null)
 657             {
 658                 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) });
 659             }
 660
 661             if (efl_gfx_shape_stroke_join_get_static_delegate == null)
 662             {
 663                 efl_gfx_shape_stroke_join_get_static_delegate = new efl_gfx_shape_stroke_join_get_delegate(stroke_join_get);
 664             }
 665
 666             if (methods.FirstOrDefault(m => m.Name == "GetStrokeJoin") != null)
 667             {
 668                 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) });
 669             }
 670
 671             if (efl_gfx_shape_stroke_join_set_static_delegate == null)
 672             {
 673                 efl_gfx_shape_stroke_join_set_static_delegate = new efl_gfx_shape_stroke_join_set_delegate(stroke_join_set);
 674             }
 675
 676             if (methods.FirstOrDefault(m => m.Name == "SetStrokeJoin") != null)
 677             {
 678                 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) });
 679             }
 680
 681             if (efl_gfx_shape_fill_rule_get_static_delegate == null)
 682             {
 683                 efl_gfx_shape_fill_rule_get_static_delegate = new efl_gfx_shape_fill_rule_get_delegate(fill_rule_get);
 684             }
 685
 686             if (methods.FirstOrDefault(m => m.Name == "GetFillRule") != null)
 687             {
 688                 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) });
 689             }
 690
 691             if (efl_gfx_shape_fill_rule_set_static_delegate == null)
 692             {
 693                 efl_gfx_shape_fill_rule_set_static_delegate = new efl_gfx_shape_fill_rule_set_delegate(fill_rule_set);
 694             }
 695
 696             if (methods.FirstOrDefault(m => m.Name == "SetFillRule") != null)
 697             {
 698                 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) });
 699             }
 700
 701             if (efl_gfx_path_get_static_delegate == null)
 702             {
 703                 efl_gfx_path_get_static_delegate = new efl_gfx_path_get_delegate(path_get);
 704             }
 705
 706             if (methods.FirstOrDefault(m => m.Name == "GetPath") != null)
 707             {
 708                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_get_static_delegate) });
 709             }
 710
 711             if (efl_gfx_path_set_static_delegate == null)
 712             {
 713                 efl_gfx_path_set_static_delegate = new efl_gfx_path_set_delegate(path_set);
 714             }
 715
 716             if (methods.FirstOrDefault(m => m.Name == "SetPath") != null)
 717             {
 718                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_set"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_set_static_delegate) });
 719             }
 720
 721             if (efl_gfx_path_length_get_static_delegate == null)
 722             {
 723                 efl_gfx_path_length_get_static_delegate = new efl_gfx_path_length_get_delegate(length_get);
 724             }
 725
 726             if (methods.FirstOrDefault(m => m.Name == "GetLength") != null)
 727             {
 728                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_length_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_length_get_static_delegate) });
 729             }
 730
 731             if (efl_gfx_path_current_get_static_delegate == null)
 732             {
 733                 efl_gfx_path_current_get_static_delegate = new efl_gfx_path_current_get_delegate(current_get);
 734             }
 735
 736             if (methods.FirstOrDefault(m => m.Name == "GetCurrent") != null)
 737             {
 738                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_current_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_current_get_static_delegate) });
 739             }
 740
 741             if (efl_gfx_path_current_ctrl_get_static_delegate == null)
 742             {
 743                 efl_gfx_path_current_ctrl_get_static_delegate = new efl_gfx_path_current_ctrl_get_delegate(current_ctrl_get);
 744             }
 745
 746             if (methods.FirstOrDefault(m => m.Name == "GetCurrentCtrl") != null)
 747             {
 748                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_current_ctrl_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_current_ctrl_get_static_delegate) });
 749             }
 750
 751             if (efl_gfx_path_copy_from_static_delegate == null)
 752             {
 753                 efl_gfx_path_copy_from_static_delegate = new efl_gfx_path_copy_from_delegate(copy_from);
 754             }
 755
 756             if (methods.FirstOrDefault(m => m.Name == "CopyFrom") != null)
 757             {
 758                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_copy_from"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_copy_from_static_delegate) });
 759             }
 760
 761             if (efl_gfx_path_bounds_get_static_delegate == null)
 762             {
 763                 efl_gfx_path_bounds_get_static_delegate = new efl_gfx_path_bounds_get_delegate(bounds_get);
 764             }
 765
 766             if (methods.FirstOrDefault(m => m.Name == "GetBounds") != null)
 767             {
 768                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_bounds_get"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_bounds_get_static_delegate) });
 769             }
 770
 771             if (efl_gfx_path_reset_static_delegate == null)
 772             {
 773                 efl_gfx_path_reset_static_delegate = new efl_gfx_path_reset_delegate(reset);
 774             }
 775
 776             if (methods.FirstOrDefault(m => m.Name == "Reset") != null)
 777             {
 778                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_reset"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_reset_static_delegate) });
 779             }
 780
 781             if (efl_gfx_path_append_move_to_static_delegate == null)
 782             {
 783                 efl_gfx_path_append_move_to_static_delegate = new efl_gfx_path_append_move_to_delegate(append_move_to);
 784             }
 785
 786             if (methods.FirstOrDefault(m => m.Name == "AppendMoveTo") != null)
 787             {
 788                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_move_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_move_to_static_delegate) });
 789             }
 790
 791             if (efl_gfx_path_append_line_to_static_delegate == null)
 792             {
 793                 efl_gfx_path_append_line_to_static_delegate = new efl_gfx_path_append_line_to_delegate(append_line_to);
 794             }
 795
 796             if (methods.FirstOrDefault(m => m.Name == "AppendLineTo") != null)
 797             {
 798                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_line_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_line_to_static_delegate) });
 799             }
 800
 801             if (efl_gfx_path_append_quadratic_to_static_delegate == null)
 802             {
 803                 efl_gfx_path_append_quadratic_to_static_delegate = new efl_gfx_path_append_quadratic_to_delegate(append_quadratic_to);
 804             }
 805
 806             if (methods.FirstOrDefault(m => m.Name == "AppendQuadraticTo") != null)
 807             {
 808                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_quadratic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_quadratic_to_static_delegate) });
 809             }
 810
 811             if (efl_gfx_path_append_squadratic_to_static_delegate == null)
 812             {
 813                 efl_gfx_path_append_squadratic_to_static_delegate = new efl_gfx_path_append_squadratic_to_delegate(append_squadratic_to);
 814             }
 815
 816             if (methods.FirstOrDefault(m => m.Name == "AppendSquadraticTo") != null)
 817             {
 818                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_squadratic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_squadratic_to_static_delegate) });
 819             }
 820
 821             if (efl_gfx_path_append_cubic_to_static_delegate == null)
 822             {
 823                 efl_gfx_path_append_cubic_to_static_delegate = new efl_gfx_path_append_cubic_to_delegate(append_cubic_to);
 824             }
 825
 826             if (methods.FirstOrDefault(m => m.Name == "AppendCubicTo") != null)
 827             {
 828                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_cubic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_cubic_to_static_delegate) });
 829             }
 830
 831             if (efl_gfx_path_append_scubic_to_static_delegate == null)
 832             {
 833                 efl_gfx_path_append_scubic_to_static_delegate = new efl_gfx_path_append_scubic_to_delegate(append_scubic_to);
 834             }
 835
 836             if (methods.FirstOrDefault(m => m.Name == "AppendScubicTo") != null)
 837             {
 838                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_scubic_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_scubic_to_static_delegate) });
 839             }
 840
 841             if (efl_gfx_path_append_arc_to_static_delegate == null)
 842             {
 843                 efl_gfx_path_append_arc_to_static_delegate = new efl_gfx_path_append_arc_to_delegate(append_arc_to);
 844             }
 845
 846             if (methods.FirstOrDefault(m => m.Name == "AppendArcTo") != null)
 847             {
 848                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_arc_to"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_arc_to_static_delegate) });
 849             }
 850
 851             if (efl_gfx_path_append_arc_static_delegate == null)
 852             {
 853                 efl_gfx_path_append_arc_static_delegate = new efl_gfx_path_append_arc_delegate(append_arc);
 854             }
 855
 856             if (methods.FirstOrDefault(m => m.Name == "AppendArc") != null)
 857             {
 858                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_arc"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_arc_static_delegate) });
 859             }
 860
 861             if (efl_gfx_path_append_close_static_delegate == null)
 862             {
 863                 efl_gfx_path_append_close_static_delegate = new efl_gfx_path_append_close_delegate(append_close);
 864             }
 865
 866             if (methods.FirstOrDefault(m => m.Name == "CloseAppend") != null)
 867             {
 868                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_close"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_close_static_delegate) });
 869             }
 870
 871             if (efl_gfx_path_append_circle_static_delegate == null)
 872             {
 873                 efl_gfx_path_append_circle_static_delegate = new efl_gfx_path_append_circle_delegate(append_circle);
 874             }
 875
 876             if (methods.FirstOrDefault(m => m.Name == "AppendCircle") != null)
 877             {
 878                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_circle"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_circle_static_delegate) });
 879             }
 880
 881             if (efl_gfx_path_append_rect_static_delegate == null)
 882             {
 883                 efl_gfx_path_append_rect_static_delegate = new efl_gfx_path_append_rect_delegate(append_rect);
 884             }
 885
 886             if (methods.FirstOrDefault(m => m.Name == "AppendRect") != null)
 887             {
 888                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_rect"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_rect_static_delegate) });
 889             }
 890
 891             if (efl_gfx_path_append_svg_path_static_delegate == null)
 892             {
 893                 efl_gfx_path_append_svg_path_static_delegate = new efl_gfx_path_append_svg_path_delegate(append_svg_path);
 894             }
 895
 896             if (methods.FirstOrDefault(m => m.Name == "AppendSvgPath") != null)
 897             {
 898                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_append_svg_path"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_append_svg_path_static_delegate) });
 899             }
 900
 901             if (efl_gfx_path_interpolate_static_delegate == null)
 902             {
 903                 efl_gfx_path_interpolate_static_delegate = new efl_gfx_path_interpolate_delegate(interpolate);
 904             }
 905
 906             if (methods.FirstOrDefault(m => m.Name == "Interpolate") != null)
 907             {
 908                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_interpolate"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_interpolate_static_delegate) });
 909             }
 910
 911             if (efl_gfx_path_equal_commands_static_delegate == null)
 912             {
 913                 efl_gfx_path_equal_commands_static_delegate = new efl_gfx_path_equal_commands_delegate(equal_commands);
 914             }
 915
 916             if (methods.FirstOrDefault(m => m.Name == "EqualCommands") != null)
 917             {
 918                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_equal_commands"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_equal_commands_static_delegate) });
 919             }
 920
 921             if (efl_gfx_path_reserve_static_delegate == null)
 922             {
 923                 efl_gfx_path_reserve_static_delegate = new efl_gfx_path_reserve_delegate(reserve);
 924             }
 925
 926             if (methods.FirstOrDefault(m => m.Name == "Reserve") != null)
 927             {
 928                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_reserve"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_reserve_static_delegate) });
 929             }
 930
 931             if (efl_gfx_path_commit_static_delegate == null)
 932             {
 933                 efl_gfx_path_commit_static_delegate = new efl_gfx_path_commit_delegate(commit);
 934             }
 935
 936             if (methods.FirstOrDefault(m => m.Name == "Commit") != null)
 937             {
 938                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_gfx_path_commit"), func = Marshal.GetFunctionPointerForDelegate(efl_gfx_path_commit_static_delegate) });
 939             }
 940
 941             return descs;
 942         }
 943         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 944         /// <returns>The native class pointer.</returns>
 945         public override IntPtr GetEflClass()
 946         {
 947             return Efl.Gfx.IShapeConcrete.efl_gfx_shape_mixin_get();
 948         }
 949
 950         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 951
 952
 953         private delegate double efl_gfx_shape_stroke_scale_get_delegate(System.IntPtr obj, System.IntPtr pd);
 954
 955
 956         public delegate double efl_gfx_shape_stroke_scale_get_api_delegate(System.IntPtr obj);
 957
 958         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");
 959
 960         private static double stroke_scale_get(System.IntPtr obj, System.IntPtr pd)
 961         {
 962             Eina.Log.Debug("function efl_gfx_shape_stroke_scale_get was called");
 963             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 964             if (ws != null)
 965             {
 966             double _ret_var = default(double);
 967                 try
 968                 {
 969                     _ret_var = ((IShape)ws.Target).GetStrokeScale();
 970                 }
 971                 catch (Exception e)
 972                 {
 973                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 974                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 975                 }
 976
 977         return _ret_var;
 978
 979             }
 980             else
 981             {
 982                 return efl_gfx_shape_stroke_scale_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 983             }
 984         }
 985
 986         private static efl_gfx_shape_stroke_scale_get_delegate efl_gfx_shape_stroke_scale_get_static_delegate;
 987
 988
 989         private delegate void efl_gfx_shape_stroke_scale_set_delegate(System.IntPtr obj, System.IntPtr pd,  double s);
 990
 991
 992         public delegate void efl_gfx_shape_stroke_scale_set_api_delegate(System.IntPtr obj,  double s);
 993
 994         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");
 995
 996         private static void stroke_scale_set(System.IntPtr obj, System.IntPtr pd, double s)
 997         {
 998             Eina.Log.Debug("function efl_gfx_shape_stroke_scale_set was called");
 999             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1000             if (ws != null)
1001             {
1002
1003                 try
1004                 {
1005                     ((IShape)ws.Target).SetStrokeScale(s);
1006                 }
1007                 catch (Exception e)
1008                 {
1009                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1010                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1011                 }
1012
1013
1014             }
1015             else
1016             {
1017                 efl_gfx_shape_stroke_scale_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), s);
1018             }
1019         }
1020
1021         private static efl_gfx_shape_stroke_scale_set_delegate efl_gfx_shape_stroke_scale_set_static_delegate;
1022
1023
1024         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);
1025
1026
1027         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);
1028
1029         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");
1030
1031         private static void stroke_color_get(System.IntPtr obj, System.IntPtr pd, out int r, out int g, out int b, out int a)
1032         {
1033             Eina.Log.Debug("function efl_gfx_shape_stroke_color_get was called");
1034             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1035             if (ws != null)
1036             {
1037                                         r = default(int);        g = default(int);        b = default(int);        a = default(int);
1038                 try
1039                 {
1040                     ((IShape)ws.Target).GetStrokeColor(out r, out g, out b, out a);
1041                 }
1042                 catch (Exception e)
1043                 {
1044                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1045                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1046                 }
1047
1048
1049             }
1050             else
1051             {
1052                 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);
1053             }
1054         }
1055
1056         private static efl_gfx_shape_stroke_color_get_delegate efl_gfx_shape_stroke_color_get_static_delegate;
1057
1058
1059         private delegate void efl_gfx_shape_stroke_color_set_delegate(System.IntPtr obj, System.IntPtr pd,  int r,  int g,  int b,  int a);
1060
1061
1062         public delegate void efl_gfx_shape_stroke_color_set_api_delegate(System.IntPtr obj,  int r,  int g,  int b,  int a);
1063
1064         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");
1065
1066         private static void stroke_color_set(System.IntPtr obj, System.IntPtr pd, int r, int g, int b, int a)
1067         {
1068             Eina.Log.Debug("function efl_gfx_shape_stroke_color_set was called");
1069             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1070             if (ws != null)
1071             {
1072
1073                 try
1074                 {
1075                     ((IShape)ws.Target).SetStrokeColor(r, g, b, a);
1076                 }
1077                 catch (Exception e)
1078                 {
1079                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1080                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1081                 }
1082
1083
1084             }
1085             else
1086             {
1087                 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);
1088             }
1089         }
1090
1091         private static efl_gfx_shape_stroke_color_set_delegate efl_gfx_shape_stroke_color_set_static_delegate;
1092
1093
1094         private delegate double efl_gfx_shape_stroke_width_get_delegate(System.IntPtr obj, System.IntPtr pd);
1095
1096
1097         public delegate double efl_gfx_shape_stroke_width_get_api_delegate(System.IntPtr obj);
1098
1099         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");
1100
1101         private static double stroke_width_get(System.IntPtr obj, System.IntPtr pd)
1102         {
1103             Eina.Log.Debug("function efl_gfx_shape_stroke_width_get was called");
1104             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1105             if (ws != null)
1106             {
1107             double _ret_var = default(double);
1108                 try
1109                 {
1110                     _ret_var = ((IShape)ws.Target).GetStrokeWidth();
1111                 }
1112                 catch (Exception e)
1113                 {
1114                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1115                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1116                 }
1117
1118         return _ret_var;
1119
1120             }
1121             else
1122             {
1123                 return efl_gfx_shape_stroke_width_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1124             }
1125         }
1126
1127         private static efl_gfx_shape_stroke_width_get_delegate efl_gfx_shape_stroke_width_get_static_delegate;
1128
1129
1130         private delegate void efl_gfx_shape_stroke_width_set_delegate(System.IntPtr obj, System.IntPtr pd,  double w);
1131
1132
1133         public delegate void efl_gfx_shape_stroke_width_set_api_delegate(System.IntPtr obj,  double w);
1134
1135         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");
1136
1137         private static void stroke_width_set(System.IntPtr obj, System.IntPtr pd, double w)
1138         {
1139             Eina.Log.Debug("function efl_gfx_shape_stroke_width_set was called");
1140             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1141             if (ws != null)
1142             {
1143
1144                 try
1145                 {
1146                     ((IShape)ws.Target).SetStrokeWidth(w);
1147                 }
1148                 catch (Exception e)
1149                 {
1150                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1151                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1152                 }
1153
1154
1155             }
1156             else
1157             {
1158                 efl_gfx_shape_stroke_width_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), w);
1159             }
1160         }
1161
1162         private static efl_gfx_shape_stroke_width_set_delegate efl_gfx_shape_stroke_width_set_static_delegate;
1163
1164
1165         private delegate double efl_gfx_shape_stroke_location_get_delegate(System.IntPtr obj, System.IntPtr pd);
1166
1167
1168         public delegate double efl_gfx_shape_stroke_location_get_api_delegate(System.IntPtr obj);
1169
1170         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");
1171
1172         private static double stroke_location_get(System.IntPtr obj, System.IntPtr pd)
1173         {
1174             Eina.Log.Debug("function efl_gfx_shape_stroke_location_get was called");
1175             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1176             if (ws != null)
1177             {
1178             double _ret_var = default(double);
1179                 try
1180                 {
1181                     _ret_var = ((IShape)ws.Target).GetStrokeLocation();
1182                 }
1183                 catch (Exception e)
1184                 {
1185                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1186                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1187                 }
1188
1189         return _ret_var;
1190
1191             }
1192             else
1193             {
1194                 return efl_gfx_shape_stroke_location_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1195             }
1196         }
1197
1198         private static efl_gfx_shape_stroke_location_get_delegate efl_gfx_shape_stroke_location_get_static_delegate;
1199
1200
1201         private delegate void efl_gfx_shape_stroke_location_set_delegate(System.IntPtr obj, System.IntPtr pd,  double centered);
1202
1203
1204         public delegate void efl_gfx_shape_stroke_location_set_api_delegate(System.IntPtr obj,  double centered);
1205
1206         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");
1207
1208         private static void stroke_location_set(System.IntPtr obj, System.IntPtr pd, double centered)
1209         {
1210             Eina.Log.Debug("function efl_gfx_shape_stroke_location_set was called");
1211             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1212             if (ws != null)
1213             {
1214
1215                 try
1216                 {
1217                     ((IShape)ws.Target).SetStrokeLocation(centered);
1218                 }
1219                 catch (Exception e)
1220                 {
1221                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1222                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1223                 }
1224
1225
1226             }
1227             else
1228             {
1229                 efl_gfx_shape_stroke_location_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), centered);
1230             }
1231         }
1232
1233         private static efl_gfx_shape_stroke_location_set_delegate efl_gfx_shape_stroke_location_set_static_delegate;
1234
1235
1236         private delegate void efl_gfx_shape_stroke_dash_get_delegate(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr dash,  out uint length);
1237
1238
1239         public delegate void efl_gfx_shape_stroke_dash_get_api_delegate(System.IntPtr obj,  out System.IntPtr dash,  out uint length);
1240
1241         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");
1242
1243         private static void stroke_dash_get(System.IntPtr obj, System.IntPtr pd, out System.IntPtr dash, out uint length)
1244         {
1245             Eina.Log.Debug("function efl_gfx_shape_stroke_dash_get was called");
1246             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1247             if (ws != null)
1248             {
1249                         Efl.Gfx.Dash _out_dash = default(Efl.Gfx.Dash);
1250         length = default(uint);
1251                 try
1252                 {
1253                     ((IShape)ws.Target).GetStrokeDash(out _out_dash, out length);
1254                 }
1255                 catch (Exception e)
1256                 {
1257                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1258                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1259                 }
1260
1261         dash = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_dash);
1262
1263             }
1264             else
1265             {
1266                 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);
1267             }
1268         }
1269
1270         private static efl_gfx_shape_stroke_dash_get_delegate efl_gfx_shape_stroke_dash_get_static_delegate;
1271
1272
1273         private delegate void efl_gfx_shape_stroke_dash_set_delegate(System.IntPtr obj, System.IntPtr pd,  ref Efl.Gfx.Dash.NativeStruct dash,  uint length);
1274
1275
1276         public delegate void efl_gfx_shape_stroke_dash_set_api_delegate(System.IntPtr obj,  ref Efl.Gfx.Dash.NativeStruct dash,  uint length);
1277
1278         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");
1279
1280         private static void stroke_dash_set(System.IntPtr obj, System.IntPtr pd, ref Efl.Gfx.Dash.NativeStruct dash, uint length)
1281         {
1282             Eina.Log.Debug("function efl_gfx_shape_stroke_dash_set was called");
1283             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1284             if (ws != null)
1285             {
1286         Efl.Gfx.Dash _in_dash = dash;
1287
1288                 try
1289                 {
1290                     ((IShape)ws.Target).SetStrokeDash(ref _in_dash, length);
1291                 }
1292                 catch (Exception e)
1293                 {
1294                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1295                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1296                 }
1297
1298                         dash = _in_dash;
1299
1300             }
1301             else
1302             {
1303                 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);
1304             }
1305         }
1306
1307         private static efl_gfx_shape_stroke_dash_set_delegate efl_gfx_shape_stroke_dash_set_static_delegate;
1308
1309
1310         private delegate Efl.Gfx.Cap efl_gfx_shape_stroke_cap_get_delegate(System.IntPtr obj, System.IntPtr pd);
1311
1312
1313         public delegate Efl.Gfx.Cap efl_gfx_shape_stroke_cap_get_api_delegate(System.IntPtr obj);
1314
1315         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");
1316
1317         private static Efl.Gfx.Cap stroke_cap_get(System.IntPtr obj, System.IntPtr pd)
1318         {
1319             Eina.Log.Debug("function efl_gfx_shape_stroke_cap_get was called");
1320             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1321             if (ws != null)
1322             {
1323             Efl.Gfx.Cap _ret_var = default(Efl.Gfx.Cap);
1324                 try
1325                 {
1326                     _ret_var = ((IShape)ws.Target).GetStrokeCap();
1327                 }
1328                 catch (Exception e)
1329                 {
1330                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1331                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1332                 }
1333
1334         return _ret_var;
1335
1336             }
1337             else
1338             {
1339                 return efl_gfx_shape_stroke_cap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1340             }
1341         }
1342
1343         private static efl_gfx_shape_stroke_cap_get_delegate efl_gfx_shape_stroke_cap_get_static_delegate;
1344
1345
1346         private delegate void efl_gfx_shape_stroke_cap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Cap c);
1347
1348
1349         public delegate void efl_gfx_shape_stroke_cap_set_api_delegate(System.IntPtr obj,  Efl.Gfx.Cap c);
1350
1351         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");
1352
1353         private static void stroke_cap_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.Cap c)
1354         {
1355             Eina.Log.Debug("function efl_gfx_shape_stroke_cap_set was called");
1356             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1357             if (ws != null)
1358             {
1359
1360                 try
1361                 {
1362                     ((IShape)ws.Target).SetStrokeCap(c);
1363                 }
1364                 catch (Exception e)
1365                 {
1366                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1367                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1368                 }
1369
1370
1371             }
1372             else
1373             {
1374                 efl_gfx_shape_stroke_cap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), c);
1375             }
1376         }
1377
1378         private static efl_gfx_shape_stroke_cap_set_delegate efl_gfx_shape_stroke_cap_set_static_delegate;
1379
1380
1381         private delegate Efl.Gfx.Join efl_gfx_shape_stroke_join_get_delegate(System.IntPtr obj, System.IntPtr pd);
1382
1383
1384         public delegate Efl.Gfx.Join efl_gfx_shape_stroke_join_get_api_delegate(System.IntPtr obj);
1385
1386         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");
1387
1388         private static Efl.Gfx.Join stroke_join_get(System.IntPtr obj, System.IntPtr pd)
1389         {
1390             Eina.Log.Debug("function efl_gfx_shape_stroke_join_get was called");
1391             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1392             if (ws != null)
1393             {
1394             Efl.Gfx.Join _ret_var = default(Efl.Gfx.Join);
1395                 try
1396                 {
1397                     _ret_var = ((IShape)ws.Target).GetStrokeJoin();
1398                 }
1399                 catch (Exception e)
1400                 {
1401                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1402                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1403                 }
1404
1405         return _ret_var;
1406
1407             }
1408             else
1409             {
1410                 return efl_gfx_shape_stroke_join_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1411             }
1412         }
1413
1414         private static efl_gfx_shape_stroke_join_get_delegate efl_gfx_shape_stroke_join_get_static_delegate;
1415
1416
1417         private delegate void efl_gfx_shape_stroke_join_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.Join j);
1418
1419
1420         public delegate void efl_gfx_shape_stroke_join_set_api_delegate(System.IntPtr obj,  Efl.Gfx.Join j);
1421
1422         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");
1423
1424         private static void stroke_join_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.Join j)
1425         {
1426             Eina.Log.Debug("function efl_gfx_shape_stroke_join_set was called");
1427             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1428             if (ws != null)
1429             {
1430
1431                 try
1432                 {
1433                     ((IShape)ws.Target).SetStrokeJoin(j);
1434                 }
1435                 catch (Exception e)
1436                 {
1437                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1438                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1439                 }
1440
1441
1442             }
1443             else
1444             {
1445                 efl_gfx_shape_stroke_join_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), j);
1446             }
1447         }
1448
1449         private static efl_gfx_shape_stroke_join_set_delegate efl_gfx_shape_stroke_join_set_static_delegate;
1450
1451
1452         private delegate Efl.Gfx.FillRule efl_gfx_shape_fill_rule_get_delegate(System.IntPtr obj, System.IntPtr pd);
1453
1454
1455         public delegate Efl.Gfx.FillRule efl_gfx_shape_fill_rule_get_api_delegate(System.IntPtr obj);
1456
1457         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");
1458
1459         private static Efl.Gfx.FillRule fill_rule_get(System.IntPtr obj, System.IntPtr pd)
1460         {
1461             Eina.Log.Debug("function efl_gfx_shape_fill_rule_get was called");
1462             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1463             if (ws != null)
1464             {
1465             Efl.Gfx.FillRule _ret_var = default(Efl.Gfx.FillRule);
1466                 try
1467                 {
1468                     _ret_var = ((IShape)ws.Target).GetFillRule();
1469                 }
1470                 catch (Exception e)
1471                 {
1472                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1473                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1474                 }
1475
1476         return _ret_var;
1477
1478             }
1479             else
1480             {
1481                 return efl_gfx_shape_fill_rule_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1482             }
1483         }
1484
1485         private static efl_gfx_shape_fill_rule_get_delegate efl_gfx_shape_fill_rule_get_static_delegate;
1486
1487
1488         private delegate void efl_gfx_shape_fill_rule_set_delegate(System.IntPtr obj, System.IntPtr pd,  Efl.Gfx.FillRule fill_rule);
1489
1490
1491         public delegate void efl_gfx_shape_fill_rule_set_api_delegate(System.IntPtr obj,  Efl.Gfx.FillRule fill_rule);
1492
1493         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");
1494
1495         private static void fill_rule_set(System.IntPtr obj, System.IntPtr pd, Efl.Gfx.FillRule fill_rule)
1496         {
1497             Eina.Log.Debug("function efl_gfx_shape_fill_rule_set was called");
1498             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1499             if (ws != null)
1500             {
1501
1502                 try
1503                 {
1504                     ((IShape)ws.Target).SetFillRule(fill_rule);
1505                 }
1506                 catch (Exception e)
1507                 {
1508                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1509                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1510                 }
1511
1512
1513             }
1514             else
1515             {
1516                 efl_gfx_shape_fill_rule_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), fill_rule);
1517             }
1518         }
1519
1520         private static efl_gfx_shape_fill_rule_set_delegate efl_gfx_shape_fill_rule_set_static_delegate;
1521
1522
1523         private delegate void efl_gfx_path_get_delegate(System.IntPtr obj, System.IntPtr pd,  out System.IntPtr op,  out System.IntPtr points);
1524
1525
1526         public delegate void efl_gfx_path_get_api_delegate(System.IntPtr obj,  out System.IntPtr op,  out System.IntPtr points);
1527
1528         public static Efl.Eo.FunctionWrapper<efl_gfx_path_get_api_delegate> efl_gfx_path_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_get_api_delegate>(Module, "efl_gfx_path_get");
1529
1530         private static void path_get(System.IntPtr obj, System.IntPtr pd, out System.IntPtr op, out System.IntPtr points)
1531         {
1532             Eina.Log.Debug("function efl_gfx_path_get was called");
1533             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1534             if (ws != null)
1535             {
1536                         Efl.Gfx.PathCommandType _out_op = default(Efl.Gfx.PathCommandType);
1537         double _out_points = default(double);
1538
1539                 try
1540                 {
1541                     ((IShape)ws.Target).GetPath(out _out_op, out _out_points);
1542                 }
1543                 catch (Exception e)
1544                 {
1545                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1546                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1547                 }
1548
1549         op = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_op);
1550         points = Eina.PrimitiveConversion.ManagedToPointerAlloc(_out_points);
1551
1552             }
1553             else
1554             {
1555                 efl_gfx_path_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out op, out points);
1556             }
1557         }
1558
1559         private static efl_gfx_path_get_delegate efl_gfx_path_get_static_delegate;
1560
1561
1562         private delegate void efl_gfx_path_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr op,  System.IntPtr points);
1563
1564
1565         public delegate void efl_gfx_path_set_api_delegate(System.IntPtr obj,  System.IntPtr op,  System.IntPtr points);
1566
1567         public static Efl.Eo.FunctionWrapper<efl_gfx_path_set_api_delegate> efl_gfx_path_set_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_set_api_delegate>(Module, "efl_gfx_path_set");
1568
1569         private static void path_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr op, System.IntPtr points)
1570         {
1571             Eina.Log.Debug("function efl_gfx_path_set was called");
1572             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1573             if (ws != null)
1574             {
1575         var _in_op = Eina.PrimitiveConversion.PointerToManaged<Efl.Gfx.PathCommandType>(op);
1576         var _in_points = Eina.PrimitiveConversion.PointerToManaged<double>(points);
1577
1578                 try
1579                 {
1580                     ((IShape)ws.Target).SetPath(_in_op, _in_points);
1581                 }
1582                 catch (Exception e)
1583                 {
1584                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1585                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1586                 }
1587
1588
1589             }
1590             else
1591             {
1592                 efl_gfx_path_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), op, points);
1593             }
1594         }
1595
1596         private static efl_gfx_path_set_delegate efl_gfx_path_set_static_delegate;
1597
1598
1599         private delegate void efl_gfx_path_length_get_delegate(System.IntPtr obj, System.IntPtr pd,  out uint commands,  out uint points);
1600
1601
1602         public delegate void efl_gfx_path_length_get_api_delegate(System.IntPtr obj,  out uint commands,  out uint points);
1603
1604         public static Efl.Eo.FunctionWrapper<efl_gfx_path_length_get_api_delegate> efl_gfx_path_length_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_length_get_api_delegate>(Module, "efl_gfx_path_length_get");
1605
1606         private static void length_get(System.IntPtr obj, System.IntPtr pd, out uint commands, out uint points)
1607         {
1608             Eina.Log.Debug("function efl_gfx_path_length_get was called");
1609             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1610             if (ws != null)
1611             {
1612                         commands = default(uint);        points = default(uint);
1613                 try
1614                 {
1615                     ((IShape)ws.Target).GetLength(out commands, out points);
1616                 }
1617                 catch (Exception e)
1618                 {
1619                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1620                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1621                 }
1622
1623
1624             }
1625             else
1626             {
1627                 efl_gfx_path_length_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out commands, out points);
1628             }
1629         }
1630
1631         private static efl_gfx_path_length_get_delegate efl_gfx_path_length_get_static_delegate;
1632
1633
1634         private delegate void efl_gfx_path_current_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
1635
1636
1637         public delegate void efl_gfx_path_current_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
1638
1639         public static Efl.Eo.FunctionWrapper<efl_gfx_path_current_get_api_delegate> efl_gfx_path_current_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_current_get_api_delegate>(Module, "efl_gfx_path_current_get");
1640
1641         private static void current_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
1642         {
1643             Eina.Log.Debug("function efl_gfx_path_current_get was called");
1644             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1645             if (ws != null)
1646             {
1647                         x = default(double);        y = default(double);
1648                 try
1649                 {
1650                     ((IShape)ws.Target).GetCurrent(out x, out y);
1651                 }
1652                 catch (Exception e)
1653                 {
1654                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1655                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1656                 }
1657
1658
1659             }
1660             else
1661             {
1662                 efl_gfx_path_current_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
1663             }
1664         }
1665
1666         private static efl_gfx_path_current_get_delegate efl_gfx_path_current_get_static_delegate;
1667
1668
1669         private delegate void efl_gfx_path_current_ctrl_get_delegate(System.IntPtr obj, System.IntPtr pd,  out double x,  out double y);
1670
1671
1672         public delegate void efl_gfx_path_current_ctrl_get_api_delegate(System.IntPtr obj,  out double x,  out double y);
1673
1674         public static Efl.Eo.FunctionWrapper<efl_gfx_path_current_ctrl_get_api_delegate> efl_gfx_path_current_ctrl_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_current_ctrl_get_api_delegate>(Module, "efl_gfx_path_current_ctrl_get");
1675
1676         private static void current_ctrl_get(System.IntPtr obj, System.IntPtr pd, out double x, out double y)
1677         {
1678             Eina.Log.Debug("function efl_gfx_path_current_ctrl_get was called");
1679             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1680             if (ws != null)
1681             {
1682                         x = default(double);        y = default(double);
1683                 try
1684                 {
1685                     ((IShape)ws.Target).GetCurrentCtrl(out x, out y);
1686                 }
1687                 catch (Exception e)
1688                 {
1689                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1690                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1691                 }
1692
1693
1694             }
1695             else
1696             {
1697                 efl_gfx_path_current_ctrl_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out x, out y);
1698             }
1699         }
1700
1701         private static efl_gfx_path_current_ctrl_get_delegate efl_gfx_path_current_ctrl_get_static_delegate;
1702
1703
1704         private delegate void efl_gfx_path_copy_from_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object dup_from);
1705
1706
1707         public delegate void efl_gfx_path_copy_from_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object dup_from);
1708
1709         public static Efl.Eo.FunctionWrapper<efl_gfx_path_copy_from_api_delegate> efl_gfx_path_copy_from_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_copy_from_api_delegate>(Module, "efl_gfx_path_copy_from");
1710
1711         private static void copy_from(System.IntPtr obj, System.IntPtr pd, Efl.Object dup_from)
1712         {
1713             Eina.Log.Debug("function efl_gfx_path_copy_from was called");
1714             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1715             if (ws != null)
1716             {
1717
1718                 try
1719                 {
1720                     ((IShape)ws.Target).CopyFrom(dup_from);
1721                 }
1722                 catch (Exception e)
1723                 {
1724                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1725                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1726                 }
1727
1728
1729             }
1730             else
1731             {
1732                 efl_gfx_path_copy_from_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), dup_from);
1733             }
1734         }
1735
1736         private static efl_gfx_path_copy_from_delegate efl_gfx_path_copy_from_static_delegate;
1737
1738
1739         private delegate void efl_gfx_path_bounds_get_delegate(System.IntPtr obj, System.IntPtr pd,  out Eina.Rect.NativeStruct r);
1740
1741
1742         public delegate void efl_gfx_path_bounds_get_api_delegate(System.IntPtr obj,  out Eina.Rect.NativeStruct r);
1743
1744         public static Efl.Eo.FunctionWrapper<efl_gfx_path_bounds_get_api_delegate> efl_gfx_path_bounds_get_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_bounds_get_api_delegate>(Module, "efl_gfx_path_bounds_get");
1745
1746         private static void bounds_get(System.IntPtr obj, System.IntPtr pd, out Eina.Rect.NativeStruct r)
1747         {
1748             Eina.Log.Debug("function efl_gfx_path_bounds_get was called");
1749             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1750             if (ws != null)
1751             {
1752                 Eina.Rect _out_r = default(Eina.Rect);
1753
1754                 try
1755                 {
1756                     ((IShape)ws.Target).GetBounds(out _out_r);
1757                 }
1758                 catch (Exception e)
1759                 {
1760                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1761                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1762                 }
1763
1764         r = _out_r;
1765
1766             }
1767             else
1768             {
1769                 efl_gfx_path_bounds_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), out r);
1770             }
1771         }
1772
1773         private static efl_gfx_path_bounds_get_delegate efl_gfx_path_bounds_get_static_delegate;
1774
1775
1776         private delegate void efl_gfx_path_reset_delegate(System.IntPtr obj, System.IntPtr pd);
1777
1778
1779         public delegate void efl_gfx_path_reset_api_delegate(System.IntPtr obj);
1780
1781         public static Efl.Eo.FunctionWrapper<efl_gfx_path_reset_api_delegate> efl_gfx_path_reset_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_reset_api_delegate>(Module, "efl_gfx_path_reset");
1782
1783         private static void reset(System.IntPtr obj, System.IntPtr pd)
1784         {
1785             Eina.Log.Debug("function efl_gfx_path_reset was called");
1786             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1787             if (ws != null)
1788             {
1789
1790                 try
1791                 {
1792                     ((IShape)ws.Target).Reset();
1793                 }
1794                 catch (Exception e)
1795                 {
1796                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1797                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1798                 }
1799
1800
1801             }
1802             else
1803             {
1804                 efl_gfx_path_reset_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1805             }
1806         }
1807
1808         private static efl_gfx_path_reset_delegate efl_gfx_path_reset_static_delegate;
1809
1810
1811         private delegate void efl_gfx_path_append_move_to_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
1812
1813
1814         public delegate void efl_gfx_path_append_move_to_api_delegate(System.IntPtr obj,  double x,  double y);
1815
1816         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_move_to_api_delegate> efl_gfx_path_append_move_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_move_to_api_delegate>(Module, "efl_gfx_path_append_move_to");
1817
1818         private static void append_move_to(System.IntPtr obj, System.IntPtr pd, double x, double y)
1819         {
1820             Eina.Log.Debug("function efl_gfx_path_append_move_to was called");
1821             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1822             if (ws != null)
1823             {
1824
1825                 try
1826                 {
1827                     ((IShape)ws.Target).AppendMoveTo(x, y);
1828                 }
1829                 catch (Exception e)
1830                 {
1831                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1832                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1833                 }
1834
1835
1836             }
1837             else
1838             {
1839                 efl_gfx_path_append_move_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
1840             }
1841         }
1842
1843         private static efl_gfx_path_append_move_to_delegate efl_gfx_path_append_move_to_static_delegate;
1844
1845
1846         private delegate void efl_gfx_path_append_line_to_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
1847
1848
1849         public delegate void efl_gfx_path_append_line_to_api_delegate(System.IntPtr obj,  double x,  double y);
1850
1851         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_line_to_api_delegate> efl_gfx_path_append_line_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_line_to_api_delegate>(Module, "efl_gfx_path_append_line_to");
1852
1853         private static void append_line_to(System.IntPtr obj, System.IntPtr pd, double x, double y)
1854         {
1855             Eina.Log.Debug("function efl_gfx_path_append_line_to was called");
1856             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1857             if (ws != null)
1858             {
1859
1860                 try
1861                 {
1862                     ((IShape)ws.Target).AppendLineTo(x, y);
1863                 }
1864                 catch (Exception e)
1865                 {
1866                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1867                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1868                 }
1869
1870
1871             }
1872             else
1873             {
1874                 efl_gfx_path_append_line_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
1875             }
1876         }
1877
1878         private static efl_gfx_path_append_line_to_delegate efl_gfx_path_append_line_to_static_delegate;
1879
1880
1881         private delegate void efl_gfx_path_append_quadratic_to_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double ctrl_x,  double ctrl_y);
1882
1883
1884         public delegate void efl_gfx_path_append_quadratic_to_api_delegate(System.IntPtr obj,  double x,  double y,  double ctrl_x,  double ctrl_y);
1885
1886         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_quadratic_to_api_delegate> efl_gfx_path_append_quadratic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_quadratic_to_api_delegate>(Module, "efl_gfx_path_append_quadratic_to");
1887
1888         private static void append_quadratic_to(System.IntPtr obj, System.IntPtr pd, double x, double y, double ctrl_x, double ctrl_y)
1889         {
1890             Eina.Log.Debug("function efl_gfx_path_append_quadratic_to was called");
1891             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1892             if (ws != null)
1893             {
1894
1895                 try
1896                 {
1897                     ((IShape)ws.Target).AppendQuadraticTo(x, y, ctrl_x, ctrl_y);
1898                 }
1899                 catch (Exception e)
1900                 {
1901                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1902                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1903                 }
1904
1905
1906             }
1907             else
1908             {
1909                 efl_gfx_path_append_quadratic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y, ctrl_x, ctrl_y);
1910             }
1911         }
1912
1913         private static efl_gfx_path_append_quadratic_to_delegate efl_gfx_path_append_quadratic_to_static_delegate;
1914
1915
1916         private delegate void efl_gfx_path_append_squadratic_to_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y);
1917
1918
1919         public delegate void efl_gfx_path_append_squadratic_to_api_delegate(System.IntPtr obj,  double x,  double y);
1920
1921         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_squadratic_to_api_delegate> efl_gfx_path_append_squadratic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_squadratic_to_api_delegate>(Module, "efl_gfx_path_append_squadratic_to");
1922
1923         private static void append_squadratic_to(System.IntPtr obj, System.IntPtr pd, double x, double y)
1924         {
1925             Eina.Log.Debug("function efl_gfx_path_append_squadratic_to was called");
1926             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1927             if (ws != null)
1928             {
1929
1930                 try
1931                 {
1932                     ((IShape)ws.Target).AppendSquadraticTo(x, y);
1933                 }
1934                 catch (Exception e)
1935                 {
1936                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1937                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1938                 }
1939
1940
1941             }
1942             else
1943             {
1944                 efl_gfx_path_append_squadratic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y);
1945             }
1946         }
1947
1948         private static efl_gfx_path_append_squadratic_to_delegate efl_gfx_path_append_squadratic_to_static_delegate;
1949
1950
1951         private delegate void efl_gfx_path_append_cubic_to_delegate(System.IntPtr obj, System.IntPtr pd,  double ctrl_x0,  double ctrl_y0,  double ctrl_x1,  double ctrl_y1,  double x,  double y);
1952
1953
1954         public delegate void efl_gfx_path_append_cubic_to_api_delegate(System.IntPtr obj,  double ctrl_x0,  double ctrl_y0,  double ctrl_x1,  double ctrl_y1,  double x,  double y);
1955
1956         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_cubic_to_api_delegate> efl_gfx_path_append_cubic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_cubic_to_api_delegate>(Module, "efl_gfx_path_append_cubic_to");
1957
1958         private static void append_cubic_to(System.IntPtr obj, System.IntPtr pd, double ctrl_x0, double ctrl_y0, double ctrl_x1, double ctrl_y1, double x, double y)
1959         {
1960             Eina.Log.Debug("function efl_gfx_path_append_cubic_to was called");
1961             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1962             if (ws != null)
1963             {
1964
1965                 try
1966                 {
1967                     ((IShape)ws.Target).AppendCubicTo(ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
1968                 }
1969                 catch (Exception e)
1970                 {
1971                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1972                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1973                 }
1974
1975
1976             }
1977             else
1978             {
1979                 efl_gfx_path_append_cubic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
1980             }
1981         }
1982
1983         private static efl_gfx_path_append_cubic_to_delegate efl_gfx_path_append_cubic_to_static_delegate;
1984
1985
1986         private delegate void efl_gfx_path_append_scubic_to_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double ctrl_x,  double ctrl_y);
1987
1988
1989         public delegate void efl_gfx_path_append_scubic_to_api_delegate(System.IntPtr obj,  double x,  double y,  double ctrl_x,  double ctrl_y);
1990
1991         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_scubic_to_api_delegate> efl_gfx_path_append_scubic_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_scubic_to_api_delegate>(Module, "efl_gfx_path_append_scubic_to");
1992
1993         private static void append_scubic_to(System.IntPtr obj, System.IntPtr pd, double x, double y, double ctrl_x, double ctrl_y)
1994         {
1995             Eina.Log.Debug("function efl_gfx_path_append_scubic_to was called");
1996             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1997             if (ws != null)
1998             {
1999
2000                 try
2001                 {
2002                     ((IShape)ws.Target).AppendScubicTo(x, y, ctrl_x, ctrl_y);
2003                 }
2004                 catch (Exception e)
2005                 {
2006                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2007                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2008                 }
2009
2010
2011             }
2012             else
2013             {
2014                 efl_gfx_path_append_scubic_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y, ctrl_x, ctrl_y);
2015             }
2016         }
2017
2018         private static efl_gfx_path_append_scubic_to_delegate efl_gfx_path_append_scubic_to_static_delegate;
2019
2020
2021         private delegate void efl_gfx_path_append_arc_to_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double rx,  double ry,  double angle, [MarshalAs(UnmanagedType.U1)] bool large_arc, [MarshalAs(UnmanagedType.U1)] bool sweep);
2022
2023
2024         public delegate void efl_gfx_path_append_arc_to_api_delegate(System.IntPtr obj,  double x,  double y,  double rx,  double ry,  double angle, [MarshalAs(UnmanagedType.U1)] bool large_arc, [MarshalAs(UnmanagedType.U1)] bool sweep);
2025
2026         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_to_api_delegate> efl_gfx_path_append_arc_to_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_to_api_delegate>(Module, "efl_gfx_path_append_arc_to");
2027
2028         private static void append_arc_to(System.IntPtr obj, System.IntPtr pd, double x, double y, double rx, double ry, double angle, bool large_arc, bool sweep)
2029         {
2030             Eina.Log.Debug("function efl_gfx_path_append_arc_to was called");
2031             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2032             if (ws != null)
2033             {
2034
2035                 try
2036                 {
2037                     ((IShape)ws.Target).AppendArcTo(x, y, rx, ry, angle, large_arc, sweep);
2038                 }
2039                 catch (Exception e)
2040                 {
2041                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2042                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2043                 }
2044
2045
2046             }
2047             else
2048             {
2049                 efl_gfx_path_append_arc_to_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y, rx, ry, angle, large_arc, sweep);
2050             }
2051         }
2052
2053         private static efl_gfx_path_append_arc_to_delegate efl_gfx_path_append_arc_to_static_delegate;
2054
2055
2056         private delegate void efl_gfx_path_append_arc_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double w,  double h,  double start_angle,  double sweep_length);
2057
2058
2059         public delegate void efl_gfx_path_append_arc_api_delegate(System.IntPtr obj,  double x,  double y,  double w,  double h,  double start_angle,  double sweep_length);
2060
2061         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_api_delegate> efl_gfx_path_append_arc_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_arc_api_delegate>(Module, "efl_gfx_path_append_arc");
2062
2063         private static void append_arc(System.IntPtr obj, System.IntPtr pd, double x, double y, double w, double h, double start_angle, double sweep_length)
2064         {
2065             Eina.Log.Debug("function efl_gfx_path_append_arc was called");
2066             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2067             if (ws != null)
2068             {
2069
2070                 try
2071                 {
2072                     ((IShape)ws.Target).AppendArc(x, y, w, h, start_angle, sweep_length);
2073                 }
2074                 catch (Exception e)
2075                 {
2076                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2077                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2078                 }
2079
2080
2081             }
2082             else
2083             {
2084                 efl_gfx_path_append_arc_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y, w, h, start_angle, sweep_length);
2085             }
2086         }
2087
2088         private static efl_gfx_path_append_arc_delegate efl_gfx_path_append_arc_static_delegate;
2089
2090
2091         private delegate void efl_gfx_path_append_close_delegate(System.IntPtr obj, System.IntPtr pd);
2092
2093
2094         public delegate void efl_gfx_path_append_close_api_delegate(System.IntPtr obj);
2095
2096         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_close_api_delegate> efl_gfx_path_append_close_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_close_api_delegate>(Module, "efl_gfx_path_append_close");
2097
2098         private static void append_close(System.IntPtr obj, System.IntPtr pd)
2099         {
2100             Eina.Log.Debug("function efl_gfx_path_append_close was called");
2101             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2102             if (ws != null)
2103             {
2104
2105                 try
2106                 {
2107                     ((IShape)ws.Target).CloseAppend();
2108                 }
2109                 catch (Exception e)
2110                 {
2111                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2112                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2113                 }
2114
2115
2116             }
2117             else
2118             {
2119                 efl_gfx_path_append_close_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2120             }
2121         }
2122
2123         private static efl_gfx_path_append_close_delegate efl_gfx_path_append_close_static_delegate;
2124
2125
2126         private delegate void efl_gfx_path_append_circle_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double radius);
2127
2128
2129         public delegate void efl_gfx_path_append_circle_api_delegate(System.IntPtr obj,  double x,  double y,  double radius);
2130
2131         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_circle_api_delegate> efl_gfx_path_append_circle_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_circle_api_delegate>(Module, "efl_gfx_path_append_circle");
2132
2133         private static void append_circle(System.IntPtr obj, System.IntPtr pd, double x, double y, double radius)
2134         {
2135             Eina.Log.Debug("function efl_gfx_path_append_circle was called");
2136             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2137             if (ws != null)
2138             {
2139
2140                 try
2141                 {
2142                     ((IShape)ws.Target).AppendCircle(x, y, radius);
2143                 }
2144                 catch (Exception e)
2145                 {
2146                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2147                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2148                 }
2149
2150
2151             }
2152             else
2153             {
2154                 efl_gfx_path_append_circle_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y, radius);
2155             }
2156         }
2157
2158         private static efl_gfx_path_append_circle_delegate efl_gfx_path_append_circle_static_delegate;
2159
2160
2161         private delegate void efl_gfx_path_append_rect_delegate(System.IntPtr obj, System.IntPtr pd,  double x,  double y,  double w,  double h,  double rx,  double ry);
2162
2163
2164         public delegate void efl_gfx_path_append_rect_api_delegate(System.IntPtr obj,  double x,  double y,  double w,  double h,  double rx,  double ry);
2165
2166         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_rect_api_delegate> efl_gfx_path_append_rect_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_rect_api_delegate>(Module, "efl_gfx_path_append_rect");
2167
2168         private static void append_rect(System.IntPtr obj, System.IntPtr pd, double x, double y, double w, double h, double rx, double ry)
2169         {
2170             Eina.Log.Debug("function efl_gfx_path_append_rect was called");
2171             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2172             if (ws != null)
2173             {
2174
2175                 try
2176                 {
2177                     ((IShape)ws.Target).AppendRect(x, y, w, h, rx, ry);
2178                 }
2179                 catch (Exception e)
2180                 {
2181                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2182                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2183                 }
2184
2185
2186             }
2187             else
2188             {
2189                 efl_gfx_path_append_rect_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), x, y, w, h, rx, ry);
2190             }
2191         }
2192
2193         private static efl_gfx_path_append_rect_delegate efl_gfx_path_append_rect_static_delegate;
2194
2195
2196         private delegate void efl_gfx_path_append_svg_path_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String svg_path_data);
2197
2198
2199         public delegate void efl_gfx_path_append_svg_path_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String svg_path_data);
2200
2201         public static Efl.Eo.FunctionWrapper<efl_gfx_path_append_svg_path_api_delegate> efl_gfx_path_append_svg_path_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_append_svg_path_api_delegate>(Module, "efl_gfx_path_append_svg_path");
2202
2203         private static void append_svg_path(System.IntPtr obj, System.IntPtr pd, System.String svg_path_data)
2204         {
2205             Eina.Log.Debug("function efl_gfx_path_append_svg_path was called");
2206             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2207             if (ws != null)
2208             {
2209
2210                 try
2211                 {
2212                     ((IShape)ws.Target).AppendSvgPath(svg_path_data);
2213                 }
2214                 catch (Exception e)
2215                 {
2216                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2217                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2218                 }
2219
2220
2221             }
2222             else
2223             {
2224                 efl_gfx_path_append_svg_path_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), svg_path_data);
2225             }
2226         }
2227
2228         private static efl_gfx_path_append_svg_path_delegate efl_gfx_path_append_svg_path_static_delegate;
2229
2230         [return: MarshalAs(UnmanagedType.U1)]
2231         private delegate bool efl_gfx_path_interpolate_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object from, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object to,  double pos_map);
2232
2233         [return: MarshalAs(UnmanagedType.U1)]
2234         public delegate bool efl_gfx_path_interpolate_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object from, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object to,  double pos_map);
2235
2236         public static Efl.Eo.FunctionWrapper<efl_gfx_path_interpolate_api_delegate> efl_gfx_path_interpolate_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_interpolate_api_delegate>(Module, "efl_gfx_path_interpolate");
2237
2238         private static bool interpolate(System.IntPtr obj, System.IntPtr pd, Efl.Object from, Efl.Object to, double pos_map)
2239         {
2240             Eina.Log.Debug("function efl_gfx_path_interpolate was called");
2241             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2242             if (ws != null)
2243             {
2244                                                                                     bool _ret_var = default(bool);
2245                 try
2246                 {
2247                     _ret_var = ((IShape)ws.Target).Interpolate(from, to, pos_map);
2248                 }
2249                 catch (Exception e)
2250                 {
2251                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2252                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2253                 }
2254
2255                                                         return _ret_var;
2256
2257             }
2258             else
2259             {
2260                 return efl_gfx_path_interpolate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), from, to, pos_map);
2261             }
2262         }
2263
2264         private static efl_gfx_path_interpolate_delegate efl_gfx_path_interpolate_static_delegate;
2265
2266         [return: MarshalAs(UnmanagedType.U1)]
2267         private delegate bool efl_gfx_path_equal_commands_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object with);
2268
2269         [return: MarshalAs(UnmanagedType.U1)]
2270         public delegate bool efl_gfx_path_equal_commands_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.MarshalEo<Efl.Eo.NonOwnTag>))] Efl.Object with);
2271
2272         public static Efl.Eo.FunctionWrapper<efl_gfx_path_equal_commands_api_delegate> efl_gfx_path_equal_commands_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_equal_commands_api_delegate>(Module, "efl_gfx_path_equal_commands");
2273
2274         private static bool equal_commands(System.IntPtr obj, System.IntPtr pd, Efl.Object with)
2275         {
2276             Eina.Log.Debug("function efl_gfx_path_equal_commands was called");
2277             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2278             if (ws != null)
2279             {
2280                                     bool _ret_var = default(bool);
2281                 try
2282                 {
2283                     _ret_var = ((IShape)ws.Target).EqualCommands(with);
2284                 }
2285                 catch (Exception e)
2286                 {
2287                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2288                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2289                 }
2290
2291                         return _ret_var;
2292
2293             }
2294             else
2295             {
2296                 return efl_gfx_path_equal_commands_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), with);
2297             }
2298         }
2299
2300         private static efl_gfx_path_equal_commands_delegate efl_gfx_path_equal_commands_static_delegate;
2301
2302
2303         private delegate void efl_gfx_path_reserve_delegate(System.IntPtr obj, System.IntPtr pd,  uint cmd_count,  uint pts_count);
2304
2305
2306         public delegate void efl_gfx_path_reserve_api_delegate(System.IntPtr obj,  uint cmd_count,  uint pts_count);
2307
2308         public static Efl.Eo.FunctionWrapper<efl_gfx_path_reserve_api_delegate> efl_gfx_path_reserve_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_reserve_api_delegate>(Module, "efl_gfx_path_reserve");
2309
2310         private static void reserve(System.IntPtr obj, System.IntPtr pd, uint cmd_count, uint pts_count)
2311         {
2312             Eina.Log.Debug("function efl_gfx_path_reserve was called");
2313             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2314             if (ws != null)
2315             {
2316
2317                 try
2318                 {
2319                     ((IShape)ws.Target).Reserve(cmd_count, pts_count);
2320                 }
2321                 catch (Exception e)
2322                 {
2323                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2324                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2325                 }
2326
2327
2328             }
2329             else
2330             {
2331                 efl_gfx_path_reserve_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), cmd_count, pts_count);
2332             }
2333         }
2334
2335         private static efl_gfx_path_reserve_delegate efl_gfx_path_reserve_static_delegate;
2336
2337
2338         private delegate void efl_gfx_path_commit_delegate(System.IntPtr obj, System.IntPtr pd);
2339
2340
2341         public delegate void efl_gfx_path_commit_api_delegate(System.IntPtr obj);
2342
2343         public static Efl.Eo.FunctionWrapper<efl_gfx_path_commit_api_delegate> efl_gfx_path_commit_ptr = new Efl.Eo.FunctionWrapper<efl_gfx_path_commit_api_delegate>(Module, "efl_gfx_path_commit");
2344
2345         private static void commit(System.IntPtr obj, System.IntPtr pd)
2346         {
2347             Eina.Log.Debug("function efl_gfx_path_commit was called");
2348             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
2349             if (ws != null)
2350             {
2351
2352                 try
2353                 {
2354                     ((IShape)ws.Target).Commit();
2355                 }
2356                 catch (Exception e)
2357                 {
2358                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2359                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2360                 }
2361
2362
2363             }
2364             else
2365             {
2366                 efl_gfx_path_commit_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2367             }
2368         }
2369
2370         private static efl_gfx_path_commit_delegate efl_gfx_path_commit_static_delegate;
2371
2372         #pragma warning restore CA1707, CS1591, SA1300, SA1600
2373
2374 }
2375 }
2376 }
2377
2378 }
2379