//--------------------------------------------------------------------------------
 //Methods: ArcTo
 //--------------------------------------------------------------------------------
 public void ArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     if((this.isUseWidth) && ((int)this._width > 1))
       ArcTo(r1, r2, angle, largeArcFlag, sweepFlag, p, this._width);
     else
       this._basicDraw.ArcTo(r1, r2, angle, largeArcFlag, sweepFlag, p);
 }

 //-----
 public void Circle(SVGPoint p, float r, SVGColor? strokeColor)
 {
     if(strokeColor != null) {
       SetColor(strokeColor.Value.color);
     }
     Circle(p, r);
 }

 public SVGGEllipse(SVGPoint p, float r1, float r2, float angle)
 {
     _p = p;
     _r1 = r1;
     _r2 = r2;
     _angle = angle;
 }

 /*-------------------------------------------------------------------------------
   //Method: Arc4Path
   /-------------------------------------------------------------------------------*/
 public void ArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     SVGPoint[] points = new SVGPoint[1];
     points[0] = p;
     ExpandBounds(points, (r1 > r2) ? 2 * (int)r1 + 2 : 2 * (int)r2 + 2, (r1 > r2) ? 2 * (int)r1 + 2 : 2 * (int)r2 + 2);
     //---------------
     this._basicDraw.ArcTo(r1, r2, angle, largeArcFlag, sweepFlag, p);
 }

 //================================================================================
 public SVGGArcAbs(float r1, float r2, float angle,
           bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     this._r1 = r1;
     this._r2 = r2;
     this._angle = angle;
     this._largeArcFlag = largeArcFlag;
     this._sweepFlag = sweepFlag;
     this._p = p;
 }

 public SVGGraphicsPath()
 {
     beginPoint = new SVGPoint(0f, 0f);
     endPoint = new SVGPoint(0f, 0f);
     needSetFirstPoint = true;
     boundUL = new SVGPoint(+10000f, +10000f);
     boundBR = new SVGPoint(-10000f, -10000f);
     transformList = new SVGTransformList();
     listObject = new ArrayList();
     listType = new ArrayList();
 }

    //--------------------------------------------------------------------------------
    //AngleBetween2Vector
    //--------------------------------------------------------------------------------
    //Tinh goc giua 2 vector (p1,p2) (p3,p4);
    public float AngleBetween2Vector(SVGPoint p1, SVGPoint p2, SVGPoint p3, SVGPoint p4)
    {
        SVGPoint vt1, vt2;
        vt1 = new SVGPoint(p2.x - p1.x, p2.y - p1.y);
        vt2 = new SVGPoint(p4.x - p3.x, p4.y - p3.y);
        float t1 = vt1.x*vt2.x + vt1.y*vt2.y;
        float gtvt1 = (float)Math.Sqrt(vt1.x * vt1.x + vt1.y*vt1.y);
        float gtvt2 = (float)Math.Sqrt(vt2.x * vt2.x + vt2.y*vt2.y);
        float t2 = gtvt1 * gtvt2;
        float cosAngle = t1/t2;

        return((float)Math.Acos(cosAngle));
    }

    public void BeginSubBuffer()
    {
        this._boundTopLeft = new SVGPoint(+10000f, +10000f);
        this._boundBottomRight = new SVGPoint(-10000f, -10000f);

        this._subW = this._width;
        this._subH = this._height;
        this._inZoneL = 0;
        this._inZoneT = 0;
        this._translateX = 0;
        this._translateY = 0;

        this._flagStep = 0;
        for(int i = 0; i < this._subW; i++)
          for(int j = 0; j < this._subH; j++)
        this._flag[i, j] = 0;
        this._flagStep = 1;
    }

 private void SetFirstPoint(SVGPoint p)
 {
     if(needSetFirstPoint) {
       beginPoint.SetValue(p);
       needSetFirstPoint = false;
     }
 }

    private void RenderPolylineElement(SVGPolylineElement polylineElement, ISVGPathDraw pathDraw)
    {
        int length = polylineElement.listPoints.Count;
        SVGPoint[] points = new SVGPoint[length];

        for(int i = 0; i < length; i++)
          points[i] = polylineElement.listPoints[i].MatrixTransform(matrixTransform);
        pathDraw.Polyline(points);
    }

 private void RenderCircleElement(SVGCircleElement elem, ISVGPathDraw pathDraw)
 {
     SVGPoint p = new SVGPoint(elem.cx.value, elem.cy.value).MatrixTransform(matrixTransform);
     pathDraw.Circle(p, elem.r.value);
 }

 private void ExpandBounds(SVGPoint point)
 {
     ExpandBounds(point.x, point.y);
 }

 public void AddQuadraticCurveTo(SVGPoint p1, SVGPoint p)
 {
     SetLastPoint(p);
     SVGGQuadraticAbs svgGQuadraticAbs = new SVGGQuadraticAbs(p1, p);
     listType.Add(SVGPathElementType.QuadraticCurveTo);
     listObject.Add(svgGQuadraticAbs);
 }

 //-----
 public void Circle(SVGPoint p, float r, SVGColor? strokeColor)
 {
     PreCircle(p, r);
     EndSubBuffer(strokeColor);
 }

 public void AddLineTo(SVGPoint p)
 {
     listType.Add(SVGPathElementType.LineTo);
     listObject.Add(p);
 }

    public void AddMoveTo(SVGPoint p)
    {
        SetFirstPoint(p);
        SetLastPoint(p);

        listType.Add(SVGPathElementType.MoveTo);
        listObject.Add(p);
    }

 public void Reset()
 {
     beginPoint = new SVGPoint(0f, 0f);
     endPoint = new SVGPoint(0f, 0f);
     needSetFirstPoint = true;
     boundUL = new SVGPoint(+10000f, +10000f);
     boundBR = new SVGPoint(-10000f, -10000f);
     _fillRule = SVGFillRule.NoneZero;
     transformList.Clear();
     listObject.Clear();
     listType.Clear();
 }

    public void Add(SVGCircleElement circleElement)
    {
        SVGPoint p = new SVGPoint(circleElement.cx.value, circleElement.cy.value);
        SetFirstPoint(p);
        SetLastPoint(p);

        listType.Add(SVGPathElementType.Circle);
        listObject.Add(circleElement);
    }

 private void RenderEllipseElement(SVGEllipseElement elem, ISVGPathDraw pathDraw)
 {
     SVGPoint p = new SVGPoint(elem.cx.value, elem.cy.value).MatrixTransform(matrixTransform);
     pathDraw.Ellipse(p, elem.rx.value, elem.ry.value, transformAngle);
 }

 public void AddArcTo(float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, SVGPoint p)
 {
     SetLastPoint(p);
     SVGGArcAbs svgGArcAbs = new SVGGArcAbs(r1, r2, angle, largeArcFlag, sweepFlag, p);
     listType.Add(SVGPathElementType.ArcTo);
     listObject.Add(svgGArcAbs);
 }