package {

        import flash.display.MovieClip;

        import flash.text.TextField;

 

        public class SVGDisplayInFlash extends MovieClip {

 

                private static const HOLDER_NAME:String = "holder";

                private static const MESSAGE_NAME:String = "msg";

 

                private var holderMc:MovieClip;

                private var messageTxt:TextField;

 

                public function SVGDisplayInFlash() {

                        initInstance();

                }

 

                private function initInstance():void {

                        trace("SVGDisplayInFlash.initInstance()");

                        initStageObjects(); 

                }

 

                private function initStageObjects():void {

                        holderMc = this[HOLDER_NAME] as MovieClip;

                        messageTxt = this[MESSAGE_NAME] as TextField;

                        trace("SVGDisplayInFlash.initStageObjects()");

                        trace("\t", holderMc, messageTxt);

                }

        }

}

public function PathToArray(svgNode:XMLNode, dCmds:Array) {

        trace(svgNode)

        trace("-----------")

        trace(dCmds)

        trace("=====================")

        ..................

private function testPathToArray():void {

        const path:String = "<path fill='#ED1C24' d='M261.5,52.3c11.9,3.2-5.2,21,32.9,31.6C288.5,35.5,261.5,52.3,261.5,52.3z' />";

        const foo:XMLDocument = new XMLDocument(path);

        new PathToArray(foo.firstChild, []);

}

// if (thisColor == undefined) {

if (isNaN(thisColor)) {

private function getSVGData(url:String):void {

        const loader:URLLoader = new URLLoader();

        loader.addEventListener(Event.COMPLETE, onSVGLoaded);

        loader.load(new URLRequest(url));

}

 

private function onSVGLoaded(event:Event):void {

        const loader:URLLoader = event.target as URLLoader;

        const data:String = loader.data as String;

        const svg:XML = new XML(data);

        trace(svg.toXMLString());

}

private var svg:XMLDocument = new XMLDocument();

private var conv:PathToArray;

private var paths:Array;

private var nPathNodes:Number;

// holder.createEmptyMovieClip("p"+iPath, iPath+1);

 

const drawLayer:Sprite = new Sprite();

holderMc.addChild(drawLayer);

const drawTarget:Graphics = drawLayer.graphics;

msg.text = "";

paths = x.firstChild.firstChild.childNodes;

nPathNodes = paths.length;

getShapes(0);

svg.ignoreWhite = true;

svg.parseXML(data);

private var svg:XMLDocument = new XMLDocument();

svg.ignoreWhite = true;

private var conv:PathToArray;

private var paths:Array;

private var nPathNodes:Number;

 

private function onSVGLoaded(event:Event):void {

        const loader:URLLoader = event.target as URLLoader;

        const data:String = loader.data as String;

 

        messageTxt.text = "";

 

        svg.parseXML(data);

        paths = svg.firstChild.firstChild.childNodes;

        nPathNodes = paths.length;

 

        getShapes(0);

}

 

private function getShapes(iPath:Number):void {

        var dCmds:Array = new Array();

        var d:Array;

        var dp:Array;

 

        conv = new PathToArray(paths[iPath], dCmds);

 

        // draw the shapes in clips in holder movieclip

        // holder.createEmptyMovieClip("p"+iPath, iPath+1);

 

        const drawLayer:Sprite = new Sprite();

        holderMc.addChild(drawLayer);

        const drawTarget:Graphics = drawLayer.graphics;

 

        for (var i:Number=0; i<dCmds.length; i++) {

                d = dCmds[i];

                dp = d[1];

                switch (d[0]) {

                        case "F" :

                                drawTarget.beginFill(dp[0], dp[1]);

                                break;

                        case "S" :

                                drawTarget.lineStyle(dp[0], dp[1], dp[2]);

                                break;

                        case "M" :

                                drawTarget.moveTo(dp[0], dp[1]);

                                break;

                        case "L" :

                                drawTarget.lineTo(dp[0], dp[1]);

                                break;

                        case "C" :

                                drawTarget.curveTo(dp[0], dp[1], dp[2], dp[3]);

                                break;

                }

        }

        // repeat til all paths have been read

        if (++iPath < nPathNodes) getShapes(iPath);

}

var len:int = s.length;

var idx:int = 0;

var idx2:int = 0;

var rs:String = "";

 // БЫЛО

public static function shrinkSequencesOf(s:String, ch:String):String {

        var len = s.length;

        var idx = 0;

        var idx2 = 0;

        var rs = "";

 

        while ((idx2 = s.indexOf(ch, idx) + 1) != 0) {

                // include string up to first character in sequence

                rs += s.substring(idx, idx2);

                idx = idx2;

 

                // remove all subsequent characters in sequence

                while ((s.charAt(idx) == ch) && (idx < len)) idx++;

        }

        return rs + s.substring(idx, len);        

}

 

// СТАЛО

public static function shrinkSequencesOf(originalString:String, characterToBeFound:String):String {

        const length:uint = originalString.length;

        var startIndex:int = 0;

        var endIndex:int = 0;

        var resultString:String = "";

 

        while ((endIndex = originalString.indexOf(characterToBeFound, startIndex) + 1) != 0) {

                // include string up to first character in sequence

                resultString += originalString.substring(startIndex, endIndex);

                startIndex = endIndex;

 

                // remove all subsequent characters in sequence

                while ((originalString.charAt(startIndex) == characterToBeFound) && (startIndex < length)) { 

                        startIndex++;

                }

        }

        return resultString + originalString.substring(startIndex, length);        

}

private static const colors:Object = {

        colors.blue=0x0000ff;

        ........

        colors.yellowgreen=0x9acd32;

}

private static const colors:Object = {

        blue:0x0000ff,

        ........

        yellowgreen:0x9acd32

}

private function getAttribute(node:XMLNode, attributeName:String) : String {

        return node.attributes[attributeName];

}

hasRotate = getAttribute(node, "transform").indexOf("rotate");

// hasRotate = getAttribute(node, "transform").indexOf("rotate");

// if (hasRotate > -1) {

hasRotate = getAttribute(node, "transform").indexOf("rotate") > -1;

if (hasRotate) {

firstP = lastP = {x:Number(svgCmds[j]), y:Number(svgCmds[j + 1])};

firstP = lastP = new Point(Number(svgCmds[j]), Number(svgCmds[j + 1]));

internal class Fill {

 

        public var color:uint;

        public var alpha:Number;

 

        public function Fill(color:uint, alpha:Number) {

                initInstance(color, alpha);

        }

 

        private function initInstance(color : uint, alpha : Number) : void {

                this.color = color;

                this.alpha = alpha;

        }

}

 

internal class Stroke {

 

        public var color:uint;

        public var alpha:Number;

        public var width:Number;

 

        public function Stroke(color:uint, alpha:Number, width:Number) {

                initInstance(color, alpha, width);

        }

 

        private function initInstance(color : uint, alpha : Number, width : Number) : void {

                this.color = color;

                this.alpha = alpha;

                this.width = width;

        }

}

private var fill : Fill;

private var stroke : Stroke;

fill = {color:0, alpha:0};

fill = Fill({color:0, alpha:0});

fill = new Fill(0, 0);

public static function getQuadBez_RP(p1:Object, c1:Object, c2:Object, p2:Object, k:Number, qcurves:Array)

public static function pointOnCurve(p1x:Number, p1y:Number, cx:Number, cy:Number, p2x:Number, p2y:Number, t:Number):Object {

        return {x:p1x + t*(2*(1-t)*(cx-p1x) + t*(p2x - p1x)), y:p1y + t*(2*(1-t)*(cy-p1y) + t*(p2y - p1y))};

}

var middle:Point = new Point(mp.x, mp.y);

public static function pointOnCurve(p1x:Number, p1y:Number, cx:Number, cy:Number, p2x:Number, p2y:Number, t:Number):Point {

        return new Point(p1x + t*(2*(1-t)*(cx-p1x) + t*(p2x - p1x)), p1y + t*(2*(1-t)*(cy-p1y) + t*(p2y - p1y)));

}

public static function curveApproxLen(p1x:Number, p1y:Number, cx:Number, cy:Number, p2x:Number, p2y:Number):Number {

        var middle:Point = pointOnCurve(p1x, p1y, cx, cy, p2x, p2y, 0.5);

        var len1:Number = Math.sqrt((middle.x - p1x) * (middle.x - p1x) + (middle.y - p1y) * (middle.y - p1y));

        var len2:Number = Math.sqrt((middle.x - p2x) * (middle.x - p2x) + (middle.y - p2y) * (middle.y - p2y));

        return len1+len2;

}

private static function midpoint(p1x : Number, p1y: Number, p2x: Number, p2y: Number):Point {

        return new Point((p1x + p2x)/2, (p1y + p2y)/2);

}

public static function bezierSplit(p1x:Number, p1y:Number, c1x:Number, c1y:Number, c2x:Number, c2y:Number, p2x:Number, p2y:Number):Object {

        var p1:Point = new Point(p1x, p1y);

        var p2:Point = new Point(p2x, p2y);

 

        var p01:Point = midpoint (p1x, p1y, c1x, c1y);

        var p12:Point = midpoint (c1x, c1y, c2x, c2y);

        var p23:Point = midpoint (c2x, c2y, p2x, p2y);

 

        var p02:Point = midpoint (p01.x, p01.y, p12.x, p12.y);

        var p13:Point = midpoint (p12.x, p12.y, p23.x, p23.y);

        var p03:Point = midpoint (p02.x, p02.y, p13.x, p13.y);

 

        return { b0:{p1:p1, c1:p01, c2:p02, p2:p03}, b1:{p1:p03, c1:p13, c2:p23, p2:p2} };

}

public static function getQuadBez_RP(point1:Object, control1:Object, control2:Object, point2:Object, k:Number, qcurves:Array):void {

        // find intersection between bezier arms

        var p1:Point = new Point(point1.x, point1.y);

        var c1:Point = new Point(control1.x, control1.y);

        var c2:Point = new Point(control2.x, control2.y);

        var p2:Point = new Point(point2.x, point2.y);

        var s:Point = intersect2Lines (p1, c1, c2, p2);

        // find distance between the midpoints

        var dx:Number = (p1.x + p2.x + s.x * 4 - (c1.x + c2.x) * 3) * .125;

        var dy:Number = (p1.y + p2.y + s.y * 4 - (c1.y + c2.y) * 3) * .125;

        // split curve if the quadratic isn't close enough

        if (dx*dx + dy*dy > k) {

                var halves:Object = Math2.bezierSplit (p1.x, p1.y, c1.x, c1.y, c2.x, c2.y, p2.x, p2.y);

                var b0:Object = halves.b0; 

                var b1:Object = halves.b1;

                // recursive call to subdivide curve

                getQuadBez_RP (p1,     b0.c1, b0.c2, b0.p2, k, qcurves);

                getQuadBez_RP (b1.p1,  b1.c1, b1.c2, p2,    k, qcurves);

        } else {

                // end recursion by saving points

                qcurves.push({p1x:p1.x, p1y:p1.y, cx:s.x, cy:s.y, p2x:p2.x, p2y:p2.y});

        }

}

return [{p1:p1, c1:p01, c2:p02, p2:p03}, {p1:p03, c1:p13, c2:p23, p2:p2}];

return [[p1, p01, p02, p03], [p03, p13, p23, p2]];

// getQuadBez_RP (p1,     b0.c1, b0.c2, b0.p2, k, qcurves);

// getQuadBez_RP (b1.p1,  b1.c1, b1.c2, p2,    k, qcurves);

getQuadBez_RP (p1, bezier0[1], bezier0[2], bezier0[3], k, qcurves);

getQuadBez_RP(bezier1[0], bezier1[1], bezier1[2], p2,    k, qcurves);

var point1:Point = new Point(10, 15);

var point2:Array = new Array(10, 15);

var point3:Object = {x:10, y:15};

package com.itechnica.svg {

        import flash.geom.Point;        

 

        public class LineSVG {

 

                private var startPoint : Point;

                private var endPoint : Point;

 

                public function LineSVG(start:Point, end : Point) {

                        initInstance(start, end);

                }

 

                private function initInstance(start : Point, end : Point) : void {

                        startPoint = start;

                        endPoint = end;

                }

 

                public function get start() : Point {

                        return startPoint;

                }

                public function set start(value : Point):void {

                        startPoint = value;

                }

                public function get end() : Point {

                        return endPoint;

                }

                public function set end(value : Point):void {

                        endPoint = value;

                }

 

 

                /**

                * @returns Point the midpoint of current line segment

                */

                public function midpoint():Point {

                        return Point.interpolate(startPoint, endPoint, 0.5);

                }

        }

 

}

// var p01:Point = midpoint (p1x, p1y, c1x, c1y);

var p01:Point = new LineSVG(new Point(p1x, p1y), new Point(c1x, c1y)).midpoint();

package com.itechnica.svg {

        import flash.geom.Point;                

 

        public class CubicBezierSVG {

 

                private var startPoint : Point;

                private var startControlPoint : Point;

                private var endControlPoint : Point;

                private var endPoint : Point;

 

                public function CubicBezierSVG(start:Point, startControl:Point, endControl:Point, end:Point) {

                        initInstance(start, startControl, endControl, end);

                }

 

                private function initInstance(start : Point, startControl : Point, endControl : Point, end : Point) : void {

                        startPoint = start;

                        startControlPoint = startControl;

                        endControlPoint = endControl;

                        endPoint = end;

                }

 

                public function get start() : Point {

                        return startPoint;

                }

                public function set start(value : Point):void {

                        startPoint = value;

                }

 

                public function get startControl() : Point {

                        return startControlPoint;

                }

                public function set startControl(value : Point):void {

                        startControlPoint = value;

                }

 

                public function get endControl() : Point {

                        return endControlPoint;

                }

                public function set endControl(value : Point):void {

                        endControlPoint = value;

                }

                public function get end() : Point {

                        return endPoint;

                }

                public function set end(value : Point):void {

                        endPoint = value;

                }

 

 

        }

}

public function split():Array {

        var p01:Point = new LineSVG(startPoint, startControlPoint).midpoint();

        var p12:Point = new LineSVG(startControlPoint, endControlPoint).midpoint();

        var p23:Point = new LineSVG(endControlPoint, endPoint).midpoint();

 

        var p02:Point = new LineSVG(p01, p12).midpoint();

        var p13:Point = new LineSVG(p12, p23).midpoint();

        var p03:Point = new LineSVG(p02, p13).midpoint();

 

        return [

                new CubicBezierSVG(startPoint, p01, p02, p03), 

                new CubicBezierSVG(p03, p13, p23, endPoint)

        ];

}

public function split():Array {

        const startMidpoint:Point = new LineSVG(startPoint, startControlPoint).midpoint();

        const middleMidpoint:Point = new LineSVG(startControlPoint, endControlPoint).midpoint();

        const endMidpoint:Point = new LineSVG(endControlPoint, endPoint).midpoint();

 

        const startMiddleMidpoint:Point = new LineSVG(startMidpoint, middleMidpoint).midpoint();

        const middleEndMidpoint:Point = new LineSVG(middleMidpoint, endMidpoint).midpoint();

        const centerMidpoint:Point = new LineSVG(startMiddleMidpoint, middleEndMidpoint).midpoint();

 

        return [

                new CubicBezierSVG(startPoint, startMidpoint, startMiddleMidpoint, centerMidpoint), 

                new CubicBezierSVG(centerMidpoint, middleEndMidpoint, endMidpoint, endPoint)

                ];

}

private static function bezierSplit(p1x:Number, p1y:Number, c1x:Number, c1y:Number, c2x:Number, c2y:Number, p2x:Number, p2y:Number):Array {

        var curve : CubicBezierSVG = new CubicBezierSVG(

                new Point(p1x, p1y), 

                new Point(c1x, c1y),

                new Point(c2x, c2y),

                new Point(p2x, p2y)); 

 

        var halves:Array = curve.split();

        var firstCurve : CubicBezierSVG = halves[0] as CubicBezierSVG; 

        var secondCurve : CubicBezierSVG = halves[1] as CubicBezierSVG; 

 

        return [

                        [firstCurve.start, firstCurve.startControl, 

                        firstCurve.endControl, firstCurve.end], 

 

                        [secondCurve.start, secondCurve.startControl, 

                        secondCurve.endControl, secondCurve.end] 

        ];

}

public static function getQuadBez_RP(point1:Point, control1:Point, control2:Point, point2:Point, k:Number, qcurves:Array):void {

        // find intersection between bezier arms

        var s:Point = intersect2Lines (point1, control1, control2, point2);

        // find distance between the midpoints

        var dx:Number = (point1.x + point2.x + s.x * 4 - (control1.x + control2.x) * 3) * .125;

        var dy:Number = (point1.y + point2.y + s.y * 4 - (control1.y + control2.y) * 3) * .125;

        // split curve if the quadratic isn't close enough

        if (dx*dx + dy*dy > k) {

                var halves:Array = bezierSplit (point1.x, point1.y, control1.x, control1.y, control2.x, control2.y, point2.x, point2.y);

                var bezier0:Array = halves[0]; 

                var bezier1:Array = halves[1];

                // recursive call to subdivide curve

                getQuadBez_RP (point1, bezier0[1], bezier0[2], bezier0[3], k, qcurves);

                getQuadBez_RP(bezier1[0], bezier1[1], bezier1[2], point2,    k, qcurves);

        } else {

                // end recursion by saving points

                qcurves.push({p1x:point1.x, p1y:point1.y, cx:s.x, cy:s.y, p2x:point2.x, p2y:point2.y});

        }

}

var sourceBezier : CubicBezierSVG = new CubicBezierSVG(point1, control1, control2, point2);

var halves:Array = sourceBezier.split();

var bezier0:CubicBezierSVG = halves[0] as CubicBezierSVG; 

var bezier1:CubicBezierSVG = halves[1] as CubicBezierSVG;

getQuadBez_RP (point1, firstHalf.startControl, firstHalf.endControl, firstHalf.end, k, qcurves);

getQuadBez_RP(secondHalf.start, secondHalf.startControl, secondHalf.endControl, point2, k, qcurves);

var startArm : LineSVG = new LineSVG(point1, control1);

var s:Point = startArm.intersect2Lines (point1, control1, control2, point2);

var startArm : LineSVG = new LineSVG(point1, control1);

var endArm : LineSVG = new LineSVG(control2, point2);

var s:Point = startArm.getLineIntersection(endArm);

public function getLineIntersection(target : LineSVG) : Point {

        var dx1 : Number = end.x - start.x;

        var dx2 : Number = target.start.x - target.end.x;

 

        if (!(dx1 || dx2)) return null;

 

        var m1 : Number = (end.y - start.y) / dx1;

        var m2 : Number = (target.start.y - target.end.y) / dx2;

 

        if (!dx1) {

                return new Point(start.x, m2 * (start.x - target.end.x) + target.end.y);

        } else if (!dx2) {

                return new Point(target.end.x, m1 * (target.end.x - start.x) + start.y);

        }

        var xInt : Number = (-m2 * target.end.x + target.end.y + m1 * start.x - start.y) / (m1 - m2);

        var yInt : Number = m1 * (xInt - start.x) + start.y;

        return new Point(xInt, yInt);

}

const currentDistanceY : Number = end.y - start.y;

const targetDistanceY : Number = target.start.y - target.end.y;

 

var m1 : Number = currentDistanceY / currentDistanceX;

var m2 : Number = targetDistanceY / targetDistanceX;

const currentTangent : Number = currentDistanceY / currentDistanceX;

const targetTangent : Number = targetDistanceY / targetDistanceX;

public function getLineIntersection(target : LineSVG) : Point {

        const currentDistanceX : Number = end.x - start.x;

        const targetDistanceX : Number = target.start.x - target.end.x;

 

        if (!(currentDistanceX || targetDistanceX)) { 

                return null;

        }

        const currentDistanceY : Number = end.y - start.y;

        const targetDistanceY : Number = target.start.y - target.end.y;

 

        const currentTangent : Number = currentDistanceY / currentDistanceX;

        const targetTangent : Number = targetDistanceY / targetDistanceX;

 

        if (!currentDistanceX) {

                return new Point(start.x, targetTangent * (start.x - target.end.x) + target.end.y);

        } else if (!targetDistanceX) {

                return new Point(target.end.x, currentTangent * (target.end.x - start.x) + start.y);

        }

        const intersectionX : Number = (-targetTangent * target.end.x + target.end.y + currentTangent * start.x - start.y) / (currentTangent - targetTangent);

        const intersectionY : Number = currentTangent * (intersectionX - start.x) + start.y;

        return new Point(intersectionX, intersectionY);

}

const source:CubicBezierSVG = new CubicBezierSVG(point1, control1, control2, point2);

public static function getQuadBez_RP(start:Point, startControl:Point, endControl:Point, end:Point, k:Number, qcurves:Array):void {

        const source:CubicBezierSVG = new CubicBezierSVG(start, startControl, endControl, end);

        // find intersection between bezier arms

        var startArm : LineSVG = new LineSVG(source.start, source.startControl);

        var endArm : LineSVG = new LineSVG(source.endControl, source.end);

        var s:Point = startArm.getLineIntersection(endArm);

        // find distance between the midpoints

        var dx:Number = (source.start.x + source.end.x + s.x * 4 - (source.startControl.x + source.endControl.x) * 3) * .125;

        var dy:Number = (source.start.y + source.end.y + s.y * 4 - (source.startControl.y + source.endControl.y) * 3) * .125;

        // split curve if the quadratic isn't close enough

        if (dx*dx + dy*dy > k) {

                var sourceBezier : CubicBezierSVG = new CubicBezierSVG(source.start, source.startControl, source.endControl, source.end);

                var halves:Array = sourceBezier.split();

 

                var firstHalf:CubicBezierSVG = halves[0] as CubicBezierSVG; 

                var secondHalf:CubicBezierSVG = halves[1] as CubicBezierSVG;

                // recursive call to subdivide curve

                getQuadBez_RP (source.start, firstHalf.startControl, firstHalf.endControl, firstHalf.end, k, qcurves);

                getQuadBez_RP(secondHalf.start, secondHalf.startControl, secondHalf.endControl, source.end,    k, qcurves);

        } else {

                // end recursion by saving points

                qcurves.push({p1x:source.start.x, p1y:source.start.y, cx:s.x, cy:s.y, p2x:source.end.x, p2y:source.end.y});

        }

}

var source:CubicBezierSVG;

source = new CubicBezierSVG();

const source:CubicBezierSVG = this;

const source:CubicBezierSVG = new CubicBezierSVG(start, startControl, endControl, end);

getQuadBez_RP (source.start, firstHalf.startControl, firstHalf.endControl, firstHalf.end, k, qcurves);

getQuadBez_RP(secondHalf.start, secondHalf.startControl, secondHalf.endControl, source.end, k, qcurves);

public function split():Array {

        const startMidpoint:Point = Point.interpolate(startPoint, startControlPoint, 0.5);

        const middleMidpoint:Point = Point.interpolate(startControlPoint, endControlPoint, 0.5);

        const endMidpoint:Point = Point.interpolate(endControlPoint, endPoint, 0.5);

 

        const startMiddleMidpoint:Point = Point.interpolate(startMidpoint, middleMidpoint, 0.5);

        const middleEndMidpoint:Point = Point.interpolate(middleMidpoint, endMidpoint, 0.5);

        const centerMidpoint:Point = Point.interpolate(startMiddleMidpoint, middleEndMidpoint, 0.5);

 

        return [

                new CubicBezierSVG(startPoint, startMidpoint, startMiddleMidpoint, centerMidpoint), 

                new CubicBezierSVG(centerMidpoint, middleEndMidpoint, endMidpoint, endPoint)

                ];

}

return [

        new CubicBezierSVG(startPoint.clone(), startMidpoint, startMiddleMidpoint, centerMidpoint), 

        new CubicBezierSVG(centerMidpoint, middleEndMidpoint, endMidpoint, endPoint.clone())

        ];

var halves:Array = source.split();

getQuadBez_RP (firstHalf.start, firstHalf.startControl, firstHalf.endControl, firstHalf.end, k, qcurves);

getQuadBez_RP(secondHalf.start, secondHalf.startControl, secondHalf.endControl, secondHalf.end, k, qcurves);

const source:CubicBezierSVG = this;

.....

firstHalf.getQuadBez_RP (....

secondHalf.getQuadBez_RP(....

public function getQuadBez_RP(k:Number, qcurves:Array):void {

        const source:CubicBezierSVG = this;

        // find intersection between bezier arms

        var startArm : LineSVG = new LineSVG(source.start, source.startControl);

        var endArm : LineSVG = new LineSVG(source.endControl, source.end);

        var s:Point = startArm.getLineIntersection(endArm);

        // find distance between the midpoints

        var dx:Number = (source.start.x + source.end.x + s.x * 4 - (source.startControl.x + source.endControl.x) * 3) * .125;

        var dy:Number = (source.start.y + source.end.y + s.y * 4 - (source.startControl.y + source.endControl.y) * 3) * .125;

        // split curve if the quadratic isn't close enough

        if (dx*dx + dy*dy > k) {

                var halves:Array = source.split();

                var firstHalf:CubicBezierSVG = halves[0] as CubicBezierSVG; 

                var secondHalf:CubicBezierSVG = halves[1] as CubicBezierSVG;

                // recursive call to subdivide curve

                firstHalf.getQuadBez_RP (k, qcurves);

                secondHalf.getQuadBez_RP(k, qcurves);

        } else {

                // end recursion by saving points

                qcurves.push({p1x:source.start.x, p1y:source.start.y, cx:s.x, cy:s.y, p2x:source.end.x, p2y:source.end.y});

        }

}

package com.itechnica.svg {

        import flash.geom.Point;                

 

        public class QuadraticBezierSVG {

 

                private var startPoint:Point;

                private var controlPoint:Point;

                private var endPoint:Point;

 

                public function QuadraticBezierSVG(start:Point, control:Point, end:Point) {

                        initInstance(start, control, end);

                }

 

                private function initInstance(start:Point, control:Point, end:Point):void {

                        startPoint = start;

                        controlPoint = control;

                        endPoint = end;

                }

 

                public function get start ():Point {

                        return startPoint;

                }

                public function set start (value:Point):void {

                        startPoint = value;

                }

 

                public function get control ():Point {

                        return controlPoint;

                }

                public function set control (value:Point):void {

                        controlPoint = value;

                }

 

                public function get end ():Point {

                        return endPoint;

                }

                public function set end (value:Point):void {

                        endPoint = value;

                }

 

// это методы доступа к данным, одноименные с примененными в объекте:

                public function get p1x ():Number {

                        return start.x;

                }

                public function get p1y ():Number {

                        return start.y;

                }

 

                public function get cx ():Number {

                        return control.x;

                }

                public function get cy ():Number {

                        return control.y;

                }

                public function get p2x ():Number {

                        return end.x;

                }

                public function get p2y ():Number {

                        return end.y;

                }

 

 

        }

}

var quadraticStart:Point = new Point(source.start.x, source.start.y);

var quadraticControl:Point = new Point(s.x, s.y);

var quadraticEnd:Point = new Point(source.end.x, source.end.y);

var quadraticBezier:QuadraticBezierSVG = new QuadraticBezierSVG(quadraticStart, quadraticControl, quadraticEnd);

quadraticCurves.push(quadraticBezier);

// quadraticCurves.push({p1x:source.start.x, p1y:source.start.y, cx:s.x, cy:s.y, p2x:source.end.x, p2y:source.end.y});

quadraticCurves = [];

private function extractedCode():void {

        quadraticCurves = [];

        сubicBezier.toQuadraticBezierArray(1, quadraticCurves);

        for (ii = 0;ii < quadraticCurves.length; ii++) {

                drawCmds.push(['C', [quadraticCurves[ii].cx, quadraticCurves[ii].cy, quadraticCurves[ii].p2x, quadraticCurves[ii].p2y]]);

        }

}

private function extractedCode(сubicBezier:CubicBezierSVG):void {

        const quadraticCurves:Array = [];

        сubicBezier.toQuadraticBezierArray(1, quadraticCurves);

        for (var i:int = 0;i < quadraticCurves.length; i++) {

                drawCmds.push(['C', [quadraticCurves[i].cx, quadraticCurves[i].cy, quadraticCurves[i].p2x, quadraticCurves[i].p2y]]);

        }

}

extractedCode(сubicBezier);

private function pushCubicBezierDrawCommands(сubicBezier:CubicBezierSVG):void {

        const quadraticCurves:Array = [];

        сubicBezier.toQuadraticBezierArray(1, quadraticCurves);

        for (var i:int = 0;i < quadraticCurves.length; i++) {

                var curve:QuadraticBezierSVG = quadraticCurves[i] as QuadraticBezierSVG;

                if (curve!=null) {

                        drawCmds.push(['C', [curve.cx, curve.cy, curve.p2x, curve.p2y]]);

                } else {

                        throw new Error("com.itechnica.svg.PathToArray.pushCubicBezierDrawCommands: incorrect curve type"); 

                }

        }

}

drawCmds.push(['C', [curve.control.x, curve.control.y, curve.end.x, curve.end.y]]);

package com.itechnica.svg {

 

        public class DrawingCommand {

 

                private var commandType:String;

 

                public function DrawingCommand(type:String, ...args) {

                        initInstance(type, args);

                }

 

                private function initInstance(type:String, args:Array):void {

                        commandType = type;

 

                }

        }

}

package com.itechnica.svg.draw {

 

        public class DrawingCommand {

 

//                switch (d[0]) {

//                        case "F" :

//                                drawTarget.beginFill(dp[0], dp[1]);

//                                break;

//                        case "S" :

//                                drawTarget.lineStyle(dp[0], dp[1], dp[2]);

//                                break;

//                        case "M" :

//                                drawTarget.moveTo(dp[0], dp[1]);

//                                break;

//                        case "L" :

//                                drawTarget.lineTo(dp[0], dp[1]);

//                                break;

//                        case "C" :

//                                drawTarget.curveTo(dp[0], dp[1], dp[2], dp[3]);

//                                break;

//                }

 

        }

}

public static const FILL:String = "F";

public static const STYLE:String = "S";

public static const MOVE:String = "M"; 

public static const LINE:String = "L";

public static const CURVE:String = "C";

package com.itechnica.svg.draw {

 

        public class DrawingCommand {

 

                public static const FILL:String = "F";

                public static const STYLE:String = "S";

                public static const MOVE:String = "M"; 

                public static const LINE:String = "L";

                public static const CURVE:String = "C";

 

                public static function create(type:String, ...args):DrawingCommand {

                        switch (type) {

                                case FILL:

                                        return new FillCommand(args[0], args[1]);

                                break;

 

                                case STYLE:

                                        return new StyleCommand(args[0], args[1], args[2]);

                                break;

 

                                case MOVE:

                                        return new MoveCommand(args[0], args[1]);

                                break;

                                case LINE:

                                        return new LineCommand(args[0], args[1]);

                                break;

                                case CURVE:

                                        return new CurveCommand(args[0], args[1], args[2], args[2]);

                                break;

                                default:

                                        throw new Error("com.itechnica.svg.draw.DrawingCommand.create("+type+", ...args) - unknown type");

                        } 

                }

 

//                switch (d[0]) {

//                        case FILL :

//                                drawTarget.beginFill(dp[0], dp[1]);

//                                break;

//                        case "S" :

//                                drawTarget.lineStyle(dp[0], dp[1], dp[2]);

//                                break;

//                        case "M" :

//                                drawTarget.moveTo(dp[0], dp[1]);

//                                break;

//                        case "L" :

//                                drawTarget.lineTo(dp[0], dp[1]);

//                                break;

//                        case "C" :

//                                drawTarget.curveTo(dp[0], dp[1], dp[2], dp[3]);

//                                break;

//                }

        }

}