Example #1
0
 internal void DeInitializeWorkingPath()
 {
     _isInitialized = false;
     _geometry      = null;
     _context       = null;
     _path          = null;
 }
Example #2
0
        internal void InitializeWorkingPath(XPoint start)
        {
            _geometry = XPathGeometry.Create(
                ImmutableArray.Create <XPathFigure>(),
                _editor.Project.Options.DefaultFillRule);

            _context = new XPathGeometryContext(_geometry);

            _context.BeginFigure(
                start,
                _editor.Project.Options.DefaultIsFilled,
                _editor.Project.Options.DefaultIsClosed);

            var style = _editor.Project.CurrentStyleLibrary.Selected;

            _path = XPath.Create(
                "Path",
                _editor.Project.Options.CloneStyle ? style.Clone() : style,
                _geometry,
                _editor.Project.Options.DefaultIsStroked,
                _editor.Project.Options.DefaultIsFilled);

            _editor.Project.CurrentContainer.WorkingLayer.Shapes = _editor.Project.CurrentContainer.WorkingLayer.Shapes.Add(_path);

            _previousPathTool = _editor.CurrentPathTool;
            _isInitialized    = true;
        }
        /// <summary>
        /// Parse a SVG path geometry string.
        /// </summary>
        /// <param name="context">The geometry context.</param>
        /// <param name="pathString">The path geometry string</param>
        /// <param name="startIndex">The string start index.</param>
        public void Parse(XGeometryContext context, string pathString, int startIndex)
        {
            _context         = context;
            _pathString      = pathString;
            _pathLength      = pathString.Length;
            _curIndex        = startIndex;
            _secondLastPoint = Point2.Create(0, 0);
            _lastPoint       = Point2.Create(0, 0);
            _lastStart       = Point2.Create(0, 0);
            _figureStarted   = false;
            bool first    = true;
            char last_cmd = ' ';

            while (ReadToken())
            {
                char cmd = _token;

                if (first)
                {
                    if ((cmd != 'M') && (cmd != 'm'))
                    {
                        InvalidToken();
                    }

                    first = false;
                }

                switch (cmd)
                {
                case 'm':
                case 'M':
                    _lastPoint = ReadPoint(cmd, !_allowComma);

                    _context.BeginFigure(XPoint.FromPoint2(_lastPoint), _isFilled, !_isClosed);
                    _figureStarted = true;
                    _lastStart     = _lastPoint;
                    last_cmd       = 'M';

                    while (IsNumber(_allowComma))
                    {
                        _lastPoint = ReadPoint(cmd, !_allowComma);
                        _context.LineTo(XPoint.FromPoint2(_lastPoint), _isStroked, !_isSmoothJoin);
                        last_cmd = 'L';
                    }
                    break;

                case 'l':
                case 'L':
                case 'h':
                case 'H':
                case 'v':
                case 'V':
                    EnsureFigure();

                    do
                    {
                        switch (cmd)
                        {
                        case 'l':
                            _lastPoint = ReadPoint(cmd, !_allowComma);
                            break;

                        case 'L':
                            _lastPoint = ReadPoint(cmd, !_allowComma);
                            break;

                        case 'h':
                            _lastPoint.X += ReadNumber(!_allowComma);
                            break;

                        case 'H':
                            _lastPoint.X = ReadNumber(!_allowComma);
                            break;

                        case 'v':
                            _lastPoint.Y += ReadNumber(!_allowComma);
                            break;

                        case 'V':
                            _lastPoint.Y = ReadNumber(!_allowComma);
                            break;
                        }

                        _context.LineTo(XPoint.FromPoint2(_lastPoint), _isStroked, !_isSmoothJoin);
                    }while (IsNumber(_allowComma));

                    last_cmd = 'L';
                    break;

                case 'c':
                case 'C':
                case 's':
                case 'S':
                    EnsureFigure();

                    do
                    {
                        Point2 p;

                        if ((cmd == 's') || (cmd == 'S'))
                        {
                            if (last_cmd == 'C')
                            {
                                p = Reflect();
                            }
                            else
                            {
                                p = _lastPoint;
                            }

                            _secondLastPoint = ReadPoint(cmd, !_allowComma);
                        }
                        else
                        {
                            p = ReadPoint(cmd, !_allowComma);

                            _secondLastPoint = ReadPoint(cmd, _allowComma);
                        }

                        _lastPoint = ReadPoint(cmd, _allowComma);
                        _context.CubicBezierTo(
                            XPoint.FromPoint2(p),
                            XPoint.FromPoint2(_secondLastPoint),
                            XPoint.FromPoint2(_lastPoint),
                            _isStroked,
                            !_isSmoothJoin);

                        last_cmd = 'C';
                    }while (IsNumber(_allowComma));

                    break;

                case 'q':
                case 'Q':
                case 't':
                case 'T':
                    EnsureFigure();

                    do
                    {
                        if ((cmd == 't') || (cmd == 'T'))
                        {
                            if (last_cmd == 'Q')
                            {
                                _secondLastPoint = Reflect();
                            }
                            else
                            {
                                _secondLastPoint = _lastPoint;
                            }

                            _lastPoint = ReadPoint(cmd, !_allowComma);
                        }
                        else
                        {
                            _secondLastPoint = ReadPoint(cmd, !_allowComma);
                            _lastPoint       = ReadPoint(cmd, _allowComma);
                        }

                        _context.QuadraticBezierTo(
                            XPoint.FromPoint2(_secondLastPoint),
                            XPoint.FromPoint2(_lastPoint),
                            _isStroked,
                            !_isSmoothJoin);

                        last_cmd = 'Q';
                    }while (IsNumber(_allowComma));

                    break;

                case 'a':
                case 'A':
                    EnsureFigure();

                    do
                    {
                        double w        = ReadNumber(!_allowComma);
                        double h        = ReadNumber(_allowComma);
                        double rotation = ReadNumber(_allowComma);
                        bool   large    = ReadBool();
                        bool   sweep    = ReadBool();

                        _lastPoint = ReadPoint(cmd, _allowComma);

                        _context.ArcTo(
                            XPoint.FromPoint2(_lastPoint),
                            XPathSize.Create(w, h),
                            rotation,
                            large,
                            sweep ? XSweepDirection.Clockwise : XSweepDirection.Counterclockwise,
                            _isStroked,
                            !_isSmoothJoin);
                    }while (IsNumber(_allowComma));

                    last_cmd = 'A';
                    break;

                case 'z':
                case 'Z':
                    EnsureFigure();
                    _context.SetClosedState(_isClosed);

                    _figureStarted = false;
                    last_cmd       = 'Z';
                    _lastPoint     = _lastStart;
                    break;

                default:
                    InvalidToken();
                    break;
                }
            }
        }
        /// <summary>
        /// Parse a SVG path geometry string.
        /// </summary>
        /// <param name="context">The geometry context.</param>
        /// <param name="pathString">The path geometry string</param>
        /// <param name="startIndex">The string start index.</param>
        public void Parse(XGeometryContext context, string pathString, int startIndex)
        {
            _context = context;
            _pathString = pathString;
            _pathLength = pathString.Length;
            _curIndex = startIndex;
            _secondLastPoint = Point2.Create(0, 0);
            _lastPoint = Point2.Create(0, 0);
            _lastStart = Point2.Create(0, 0);
            _figureStarted = false;
            bool first = true;
            char last_cmd = ' ';

            while (ReadToken())
            {
                char cmd = _token;

                if (first)
                {
                    if ((cmd != 'M') && (cmd != 'm'))
                    {
                        InvalidToken();
                    }

                    first = false;
                }

                switch (cmd)
                {
                    case 'm':
                    case 'M':
                        _lastPoint = ReadPoint(cmd, !_allowComma);

                        _context.BeginFigure(XPoint.FromPoint2(_lastPoint), _isFilled, !_isClosed);
                        _figureStarted = true;
                        _lastStart = _lastPoint;
                        last_cmd = 'M';

                        while (IsNumber(_allowComma))
                        {
                            _lastPoint = ReadPoint(cmd, !_allowComma);
                            _context.LineTo(XPoint.FromPoint2(_lastPoint), _isStroked, !_isSmoothJoin);
                            last_cmd = 'L';
                        }
                        break;

                    case 'l':
                    case 'L':
                    case 'h':
                    case 'H':
                    case 'v':
                    case 'V':
                        EnsureFigure();

                        do
                        {
                            switch (cmd)
                            {
                                case 'l':
                                    _lastPoint = ReadPoint(cmd, !_allowComma);
                                    break;
                                case 'L':
                                    _lastPoint = ReadPoint(cmd, !_allowComma);
                                    break;
                                case 'h':
                                    _lastPoint.X += ReadNumber(!_allowComma);
                                    break;
                                case 'H':
                                    _lastPoint.X = ReadNumber(!_allowComma);
                                    break;
                                case 'v':
                                    _lastPoint.Y += ReadNumber(!_allowComma);
                                    break;
                                case 'V':
                                    _lastPoint.Y = ReadNumber(!_allowComma);
                                    break;
                            }

                            _context.LineTo(XPoint.FromPoint2(_lastPoint), _isStroked, !_isSmoothJoin);
                        }
                        while (IsNumber(_allowComma));

                        last_cmd = 'L';
                        break;

                    case 'c':
                    case 'C':
                    case 's':
                    case 'S':
                        EnsureFigure();

                        do
                        {
                            Point2 p;

                            if ((cmd == 's') || (cmd == 'S'))
                            {
                                if (last_cmd == 'C')
                                {
                                    p = Reflect();
                                }
                                else
                                {
                                    p = _lastPoint;
                                }

                                _secondLastPoint = ReadPoint(cmd, !_allowComma);
                            }
                            else
                            {
                                p = ReadPoint(cmd, !_allowComma);

                                _secondLastPoint = ReadPoint(cmd, _allowComma);
                            }

                            _lastPoint = ReadPoint(cmd, _allowComma);
                            _context.CubicBezierTo(
                                XPoint.FromPoint2(p),
                                XPoint.FromPoint2(_secondLastPoint),
                                XPoint.FromPoint2(_lastPoint),
                                _isStroked,
                                !_isSmoothJoin);

                            last_cmd = 'C';
                        }
                        while (IsNumber(_allowComma));

                        break;

                    case 'q':
                    case 'Q':
                    case 't':
                    case 'T':
                        EnsureFigure();

                        do
                        {
                            if ((cmd == 't') || (cmd == 'T'))
                            {
                                if (last_cmd == 'Q')
                                {
                                    _secondLastPoint = Reflect();
                                }
                                else
                                {
                                    _secondLastPoint = _lastPoint;
                                }

                                _lastPoint = ReadPoint(cmd, !_allowComma);
                            }
                            else
                            {
                                _secondLastPoint = ReadPoint(cmd, !_allowComma);
                                _lastPoint = ReadPoint(cmd, _allowComma);
                            }

                            _context.QuadraticBezierTo(
                                XPoint.FromPoint2(_secondLastPoint),
                                XPoint.FromPoint2(_lastPoint),
                                _isStroked,
                                !_isSmoothJoin);

                            last_cmd = 'Q';
                        }
                        while (IsNumber(_allowComma));

                        break;

                    case 'a':
                    case 'A':
                        EnsureFigure();

                        do
                        {
                            double w = ReadNumber(!_allowComma);
                            double h = ReadNumber(_allowComma);
                            double rotation = ReadNumber(_allowComma);
                            bool large = ReadBool();
                            bool sweep = ReadBool();

                            _lastPoint = ReadPoint(cmd, _allowComma);

                            _context.ArcTo(
                                XPoint.FromPoint2(_lastPoint),
                                XPathSize.Create(w, h),
                                rotation,
                                large,
                                sweep ? XSweepDirection.Clockwise : XSweepDirection.Counterclockwise,
                                _isStroked,
                                !_isSmoothJoin);
                        }
                        while (IsNumber(_allowComma));

                        last_cmd = 'A';
                        break;

                    case 'z':
                    case 'Z':
                        EnsureFigure();
                        _context.SetClosedState(_isClosed);

                        _figureStarted = false;
                        last_cmd = 'Z';
                        _lastPoint = _lastStart;
                        break;

                    default:
                        InvalidToken();
                        break;
                }
            }
        }