incubator-ooo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a..@apache.org
Subject svn commit: r1209140 [8/11] - in /incubator/ooo/branches/alg/svgreplacement/main: ./ basegfx/inc/basegfx/matrix/ basegfx/inc/basegfx/polygon/ basegfx/source/polygon/ cppcanvas/source/mtfrenderer/ drawinglayer/ drawinglayer/inc/drawinglayer/primitive2d/...
Date Thu, 01 Dec 2011 16:26:53 GMT
Added: incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextnode.cxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextnode.cxx?rev=1209140&view=auto
==============================================================================
--- incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextnode.cxx (added)
+++ incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextnode.cxx Thu Dec  1 16:25:17 2011
@@ -0,0 +1,277 @@
+/**************************************************************
+ * 
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * 
+ *************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_svgio.hxx"
+
+#include <svgio/svgreader/svgtextnode.hxx>
+#include <svgio/svgreader/svgcharacternode.hxx>
+#include <svgio/svgreader/svgstyleattributes.hxx>
+#include <svgio/svgreader/svgtrefnode.hxx>
+#include <svgio/svgreader/svgtextpathnode.hxx>
+#include <svgio/svgreader/svgtspannode.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace svgio
+{
+    namespace svgreader
+    {
+        SvgTextNode::SvgTextNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGTokenText, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            mpaTransform(0),
+            maSvgTextPositions()
+        {
+        }
+
+        SvgTextNode::~SvgTextNode()
+        {
+            if(mpaTransform) delete mpaTransform;
+        }
+
+        const SvgStyleAttributes* SvgTextNode::getSvgStyleAttributes() const
+        {
+            static rtl::OUString aClassStr(rtl::OUString::createFromAscii("text"));
+            maSvgStyleAttributes.checkForCssStyle(aClassStr);
+
+            return &maSvgStyleAttributes;
+        }
+
+        void SvgTextNode::parseAttribute(const rtl::OUString& rTokenName, SVGToken aSVGToken, const rtl::OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(rTokenName, aSVGToken, aContent);
+
+            // read text position attributes
+            maSvgTextPositions.parseTextPositionAttributes(rTokenName, aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGTokenStyle:
+                {
+                    maSvgStyleAttributes.readStyle(aContent);
+                    break;
+                }
+                case SVGTokenTransform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(&aMatrix);
+                    }
+                    break;
+                }
+            }
+        }
+
+        void SvgTextNode::addTextPrimitives(const SvgNode& rCandidate, drawinglayer::primitive2d::Primitive2DVector& rTarget, drawinglayer::primitive2d::Primitive2DVector& rSource) const
+        {
+            if(!rSource.empty())
+            {
+                const SvgStyleAttributes* pAttributes = rCandidate.getSvgStyleAttributes();
+
+                if(pAttributes)
+                {
+                    // add text with taking all Fill/Stroke attributes into account
+                    pAttributes->add_text(rTarget, rSource);
+                }
+                else
+                {
+                    // should not happen, every subnode from SvgTextNode will at least
+                    // return the attributes from SvgTextNode. Nonetheless, add text
+                    rTarget.insert(rTarget.end(), rSource.begin(), rSource.end());
+                }
+            }
+        }
+
+        void SvgTextNode::DecomposeChild(const SvgNode& rCandidate, drawinglayer::primitive2d::Primitive2DVector& rTarget, SvgTextPosition& rSvgTextPosition) const
+        {
+            switch(rCandidate.getType())
+            {
+                case SVGTokenCharacter:
+                {
+                    // direct SvgTextPathNode derivates, decompose them
+                    const SvgCharacterNode& rSvgCharacterNode = static_cast< const SvgCharacterNode& >(rCandidate);
+                    rSvgCharacterNode.decomposeText(rTarget, rSvgTextPosition);
+                    break;
+                }
+                case SVGTokenTextPath:
+                {
+                    // direct TextPath decompose
+                    const SvgTextPathNode& rSvgTextPathNode = static_cast< const SvgTextPathNode& >(rCandidate);
+                    const SvgNodeVector& rChildren = rSvgTextPathNode.getChildren();
+                    const sal_uInt32 nCount(rChildren.size());
+
+                    if(nCount && rSvgTextPathNode.isValid())
+                    {
+                        // remember original TextStart to later detect hor/ver offsets
+                        const basegfx::B2DPoint aTextStart(rSvgTextPosition.getPosition());
+                        drawinglayer::primitive2d::Primitive2DVector aNewTarget;
+
+                        // decompose to regular TextPrimitives
+                        for(sal_uInt32 a(0); a < nCount; a++)
+                        {
+                            DecomposeChild(*rChildren[a], aNewTarget, rSvgTextPosition);
+                        }
+
+                        if(!aNewTarget.empty())
+                        {
+                            const drawinglayer::primitive2d::Primitive2DSequence aPathContent(Primitive2DVectorToPrimitive2DSequence(aNewTarget));
+                            aNewTarget.clear();
+
+                            // dismantle TextPrimitives and map them on curve/path
+                            rSvgTextPathNode.decomposePathNode(aPathContent, aNewTarget, aTextStart);
+                        }
+
+                        if(!aNewTarget.empty())
+                        {
+                            addTextPrimitives(rCandidate, rTarget, aNewTarget);
+                        }
+                    }
+
+                    break;
+                }
+                case SVGTokenTspan:
+                {
+                    // Tspan may have children, call recursively
+                    const SvgTspanNode& rSvgTspanNode = static_cast< const SvgTspanNode& >(rCandidate);
+                    const SvgNodeVector& rChildren = rSvgTspanNode.getChildren();
+                    const sal_uInt32 nCount(rChildren.size());
+
+                    if(nCount)
+                    {
+                        SvgTextPosition aSvgTextPosition(&rSvgTextPosition, rSvgTspanNode, rSvgTspanNode.getSvgTextPositions());
+                        drawinglayer::primitive2d::Primitive2DVector aNewTarget;
+
+                        for(sal_uInt32 a(0); a < nCount; a++)
+                        {
+                            DecomposeChild(*rChildren[a], aNewTarget, aSvgTextPosition);
+                        }
+
+                        rSvgTextPosition.setPosition(aSvgTextPosition.getPosition());
+                        
+                        if(!aNewTarget.empty())
+                        {
+                            addTextPrimitives(rCandidate, rTarget, aNewTarget);
+                        }
+                    }
+                    break;
+                }
+                case SVGTokenTref:
+                {
+                    const SvgTrefNode& rSvgTrefNode = static_cast< const SvgTrefNode& >(rCandidate);
+                    const SvgTextNode* pRefText = rSvgTrefNode.getReferencedSvgTextNode();
+
+                    if(pRefText)
+                    {
+                        const SvgNodeVector& rChildren = pRefText->getChildren();
+                        const sal_uInt32 nCount(rChildren.size());
+                        drawinglayer::primitive2d::Primitive2DVector aNewTarget;
+
+                        if(nCount)
+                        {
+                            for(sal_uInt32 a(0); a < nCount; a++)
+                            {
+                                const SvgNode& rChildCandidate = *rChildren[a];
+                                const_cast< SvgNode& >(rChildCandidate).setAlternativeParent(this);
+    
+                                DecomposeChild(rChildCandidate, aNewTarget, rSvgTextPosition);
+                                const_cast< SvgNode& >(rChildCandidate).setAlternativeParent(0);
+                            }
+                            
+                            if(!aNewTarget.empty())
+                            {
+                                addTextPrimitives(rCandidate, rTarget, aNewTarget);
+                            }
+                        }
+                    }
+
+                    break;
+                }
+                default:
+                {
+                    OSL_ENSURE(false, "Unexpected node in text token (!)");
+                    break;
+                }
+            }
+        }
+
+        void SvgTextNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DVector& rTarget, bool bReferenced) const
+        {
+            // text has a group of child nodes, allowed are SVGTokenCharacter, SVGTokenTspan,
+            // SVGTokenTref and SVGTokenTextPath. These increase a given current text position
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(pStyle && !getChildren().empty())
+            {
+                SvgTextPosition aSvgTextPosition(0, *this, getSvgTextPositions());
+                drawinglayer::primitive2d::Primitive2DVector aNewTarget;
+                const SvgNodeVector& rChildren = getChildren();
+                const sal_uInt32 nCount(rChildren.size());
+
+                for(sal_uInt32 a(0); a < nCount; a++)
+                {
+                    const SvgNode& rCandidate = *rChildren[a];
+    
+                    DecomposeChild(rCandidate, aNewTarget, aSvgTextPosition);
+                }
+                
+                if(!aNewTarget.empty())
+                {
+                    drawinglayer::primitive2d::Primitive2DVector aNewTarget2;
+
+                    addTextPrimitives(*this, aNewTarget2, aNewTarget);
+                    aNewTarget = aNewTarget2;
+                }
+
+                if(!aNewTarget.empty())
+                {
+                    if(getTransform())
+                    {
+                        // create embedding group element with transformation
+                        rTarget.push_back(
+                            new drawinglayer::primitive2d::TransformPrimitive2D(
+                                *getTransform(),
+                                Primitive2DVectorToPrimitive2DSequence(aNewTarget)));
+                        aNewTarget.clear();
+                    }
+                    else
+                    {
+                        // append to current target
+                        rTarget.insert(rTarget.end(), aNewTarget.begin(), aNewTarget.end());
+                    }
+                }
+            }
+        }
+    } // end of namespace svgreader
+} // end of namespace svgio
+
+//////////////////////////////////////////////////////////////////////////////
+// eof

Added: incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextpathnode.cxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextpathnode.cxx?rev=1209140&view=auto
==============================================================================
--- incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextpathnode.cxx (added)
+++ incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtextpathnode.cxx Thu Dec  1 16:25:17 2011
@@ -0,0 +1,527 @@
+/**************************************************************
+ * 
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * 
+ *************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_svgio.hxx"
+
+#include <svgio/svgreader/svgtextpathnode.hxx>
+#include <svgio/svgreader/svgstyleattributes.hxx>
+#include <svgio/svgreader/svgpathnode.hxx>
+#include <svgio/svgreader/svgdocument.hxx>
+#include <svgio/svgreader/svgtrefnode.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <drawinglayer/primitive2d/textbreakuphelper.hxx>
+#include <drawinglayer/primitive2d/groupprimitive2d.hxx>
+#include <basegfx/curve/b2dcubicbezier.hxx>
+#include <basegfx/curve/b2dbeziertools.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace svgio
+{
+    namespace svgreader
+    {
+        class pathTextBreakupHelper : public drawinglayer::primitive2d::TextBreakupHelper
+        {
+        private:
+            const basegfx::B2DPolygon&      mrPolygon;
+            const double                    mfBasegfxPathLength;
+            const double                    mfUserToBasegfx;
+            double                          mfPosition;
+            const basegfx::B2DPoint&        mrTextStart;
+
+            const sal_uInt32                mnMaxIndex;
+            sal_uInt32                      mnIndex;
+            basegfx::B2DCubicBezier         maCurrentSegment;
+            basegfx::B2DCubicBezierHelper*  mpB2DCubicBezierHelper;
+            double                          mfCurrentSegmentLength;
+            double                          mfSegmentStartPosition;
+
+        protected:
+            /// allow user callback to allow changes to the new TextTransformation. Default
+            /// does nothing.
+            virtual bool allowChange(sal_uInt32 nCount, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength);
+
+            void freeB2DCubicBezierHelper();
+            basegfx::B2DCubicBezierHelper* getB2DCubicBezierHelper();
+            void advanceToPosition(double fNewPosition);
+
+        public:
+            pathTextBreakupHelper(
+                const drawinglayer::primitive2d::Primitive2DReference& rxSource,
+                const basegfx::B2DPolygon& rPolygon,
+                const double fBasegfxPathLength,
+                const double fUserToBasegfx,
+                double fPosition,
+                const basegfx::B2DPoint& rTextStart);
+            virtual ~pathTextBreakupHelper();
+
+            // read access to evtl. advanced position
+            double getPosition() const { return mfPosition; }
+
+            // get length of given text
+            double getLength(const rtl::OUString& rText) const;
+        };
+
+        double pathTextBreakupHelper::getLength(const rtl::OUString& rText) const
+        {
+            const sal_uInt32 nLength(rText.getLength());
+
+            if(nLength)
+            {
+                return getTextLayouter().getTextWidth(rText, 0, nLength);
+            }
+            
+            return 0.0;
+        }
+
+        void pathTextBreakupHelper::freeB2DCubicBezierHelper()
+        {
+            if(mpB2DCubicBezierHelper)
+            {
+                delete mpB2DCubicBezierHelper;
+                mpB2DCubicBezierHelper = 0;
+            }
+        }
+
+        basegfx::B2DCubicBezierHelper* pathTextBreakupHelper::getB2DCubicBezierHelper()
+        {
+            if(!mpB2DCubicBezierHelper && maCurrentSegment.isBezier())
+            {
+                mpB2DCubicBezierHelper = new basegfx::B2DCubicBezierHelper(maCurrentSegment);
+            }
+
+            return mpB2DCubicBezierHelper;
+        }
+
+        void pathTextBreakupHelper::advanceToPosition(double fNewPosition)
+        {
+            while(mfSegmentStartPosition + mfCurrentSegmentLength < fNewPosition && mnIndex < mnMaxIndex)
+            {
+                mfSegmentStartPosition += mfCurrentSegmentLength;
+                mnIndex++;
+
+                if(mnIndex < mnMaxIndex)
+                {
+                    freeB2DCubicBezierHelper();
+                    mrPolygon.getBezierSegment(mnIndex % mrPolygon.count(), maCurrentSegment);
+                    maCurrentSegment.testAndSolveTrivialBezier();
+                    mfCurrentSegmentLength = getB2DCubicBezierHelper()
+                        ? getB2DCubicBezierHelper()->getLength()
+                        : maCurrentSegment.getLength();
+                }
+            }
+
+            mfPosition = fNewPosition;
+        }
+
+        pathTextBreakupHelper::pathTextBreakupHelper(
+            const drawinglayer::primitive2d::Primitive2DReference& rxSource,
+            const basegfx::B2DPolygon& rPolygon,
+            const double fBasegfxPathLength,
+            const double fUserToBasegfx,
+            double fPosition,
+            const basegfx::B2DPoint& rTextStart)
+        :   drawinglayer::primitive2d::TextBreakupHelper(rxSource),
+            mrPolygon(rPolygon),
+            mfBasegfxPathLength(fBasegfxPathLength),
+            mfUserToBasegfx(fUserToBasegfx),
+            mfPosition(0.0),
+            mrTextStart(rTextStart),
+            mnMaxIndex(rPolygon.isClosed() ? rPolygon.count() : rPolygon.count() - 1),
+            mnIndex(0),
+            maCurrentSegment(),
+            mpB2DCubicBezierHelper(0),
+            mfCurrentSegmentLength(0.0),
+            mfSegmentStartPosition(0.0)
+        {
+            mrPolygon.getBezierSegment(mnIndex % mrPolygon.count(), maCurrentSegment);
+            mfCurrentSegmentLength = maCurrentSegment.getLength();
+
+            advanceToPosition(fPosition);
+        }
+
+        pathTextBreakupHelper::~pathTextBreakupHelper()
+        {
+            freeB2DCubicBezierHelper();
+        }
+
+        bool pathTextBreakupHelper::allowChange(sal_uInt32 nCount, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength)
+        {
+            bool bRetval(false);
+
+            if(mfPosition < mfBasegfxPathLength && nLength && getCastedSource() && mnIndex < mnMaxIndex)
+            {
+                const double fSnippetWidth(
+                    getTextLayouter().getTextWidth(
+                        getCastedSource()->getText(),
+                        nIndex,
+                        nLength));
+
+                if(basegfx::fTools::more(fSnippetWidth, 0.0))
+                {
+                    const ::rtl::OUString aText(getCastedSource()->getText());
+                    const ::rtl::OUString aTrimmedChars(aText.copy(nIndex, nLength).trim());
+                    const double fEndPos(mfPosition + fSnippetWidth);
+
+                    if(aTrimmedChars.getLength() && (mfPosition < mfBasegfxPathLength || fEndPos > 0.0))
+                    {
+                        const double fHalfSnippetWidth(fSnippetWidth * 0.5);
+
+                        advanceToPosition(mfPosition + fHalfSnippetWidth);
+
+                        // create representation for this snippet
+                        bRetval = true;
+
+                        // get target position and tangent in that pint
+                        basegfx::B2DPoint aPosition(0.0, 0.0);
+                        basegfx::B2DVector aTangent(0.0, 1.0);
+
+                        if(mfPosition < 0.0)
+                        {
+                            // snippet center is left of first segment, but right edge is on it (SVG allows that)
+                            aTangent = maCurrentSegment.getTangent(0.0);
+                            aTangent.normalize();
+                            aPosition = maCurrentSegment.getStartPoint() + (aTangent * (mfPosition - mfSegmentStartPosition));
+                        }
+                        else if(mfPosition > mfBasegfxPathLength)
+                        {
+                            // snippet center is right of last segment, but left edge is on it (SVG allows that)
+                            aTangent = maCurrentSegment.getTangent(1.0);
+                            aTangent.normalize();
+                            aPosition = maCurrentSegment.getEndPoint() + (aTangent * (mfPosition - mfSegmentStartPosition));
+                        }
+                        else
+                        {
+                            // snippet center inside segment, interpolate
+                            double fBezierDistance(mfPosition - mfSegmentStartPosition);
+                            
+                            if(getB2DCubicBezierHelper())
+                            {
+                                // use B2DCubicBezierHelper to bridge the non-linear gap between
+                                // length and bezier distances (if it's a bezier segment)
+                                fBezierDistance = getB2DCubicBezierHelper()->distanceToRelative(fBezierDistance);
+                            }
+                            else
+                            {
+                                // linear relationship, make relative to segment length
+                                fBezierDistance = fBezierDistance / mfCurrentSegmentLength;
+                            }
+
+                            aPosition = maCurrentSegment.interpolatePoint(fBezierDistance);
+                            aTangent = maCurrentSegment.getTangent(fBezierDistance);
+                            aTangent.normalize();
+                        }
+
+                        // detect evtl. hor/ver translations (depends on text direction)
+                        const basegfx::B2DPoint aBasePoint(rNewTransform * basegfx::B2DPoint(0.0, 0.0));
+                        const basegfx::B2DVector aOffset(aBasePoint - mrTextStart);
+
+                        if(!basegfx::fTools::equalZero(aOffset.getY()))
+                        {
+                            // ...and apply
+                            aPosition.setY(aPosition.getY() + aOffset.getY());
+                        }
+
+                        // move target position from snippet center to left text start
+                        aPosition -= fHalfSnippetWidth * aTangent;
+
+                        // remove current translation
+                        rNewTransform.translate(-aBasePoint.getX(), -aBasePoint.getY());
+
+                        // rotate due to tangent
+                        rNewTransform.rotate(atan2(aTangent.getY(), aTangent.getX()));
+
+                        // add new translation
+                        rNewTransform.translate(aPosition.getX(), aPosition.getY());
+                    }
+                            
+                    // advance to end
+                    advanceToPosition(fEndPos);
+                }
+            }
+
+            return bRetval;
+        }
+
+    } // end of namespace svgreader
+} // end of namespace svgio
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace svgio
+{
+    namespace svgreader
+    {
+        void SvgTextPathNode::tryToFindLink()
+        {
+            if(!mpXLink && maXLink.getLength())
+            {
+                mpXLink = dynamic_cast< const SvgPathNode* >(getDocument().findSvgNodeById(maXLink));
+            }
+        }
+
+        SvgTextPathNode::SvgTextPathNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGTokenTextPath, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maXLink(),
+            mpXLink(0),
+            maStartOffset(),
+            mbMethod(true),
+            mbSpacing(false)
+        {
+        }
+
+        SvgTextPathNode::~SvgTextPathNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgTextPathNode::getSvgStyleAttributes() const
+        {
+            return &maSvgStyleAttributes;
+        }
+
+        void SvgTextPathNode::parseAttribute(const rtl::OUString& rTokenName, SVGToken aSVGToken, const rtl::OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(rTokenName, aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(rTokenName, aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGTokenStyle:
+                {
+                    maSvgStyleAttributes.readStyle(aContent);
+                    break;
+                }
+                case SVGTokenStartOffset:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            setStartOffset(aNum);
+                        }
+                    }
+                    break;
+                }
+                case SVGTokenMethod:
+                {
+                    if(aContent.getLength())
+                    {
+                        static rtl::OUString aStrAlign(rtl::OUString::createFromAscii("align"));
+                        static rtl::OUString aStrStretch(rtl::OUString::createFromAscii("stretch"));
+
+                        if(aContent.match(aStrAlign))
+                        {
+                            setMethod(true);
+                        }
+                        else if(aContent.match(aStrStretch))
+                        {
+                            setMethod(false);
+                        }
+                    }
+                    break;
+                }
+                case SVGTokenSpacing:
+                {
+                    if(aContent.getLength())
+                    {
+                        static rtl::OUString aStrAuto(rtl::OUString::createFromAscii("auto"));
+                        static rtl::OUString aStrExact(rtl::OUString::createFromAscii("exact"));
+
+                        if(aContent.match(aStrAuto))
+                        {
+                            setSpacing(true);
+                        }
+                        else if(aContent.match(aStrExact))
+                        {
+                            setSpacing(false);
+                        }
+                    }
+                    break;
+                }
+                case SVGTokenXlinkHref:
+                {
+                    const sal_Int32 nLen(aContent.getLength());
+
+                    if(nLen && sal_Unicode('#') == aContent[0])
+                    {
+                        maXLink = aContent.copy(1);
+                        tryToFindLink();
+                    }
+                    break;
+                }
+            }
+        }
+
+        const SvgPathNode* SvgTextPathNode::getReferencedSvgPathNode() const
+        {
+            const_cast< SvgTextPathNode* >(this)->tryToFindLink();
+
+            return mpXLink;
+        }
+
+        bool SvgTextPathNode::isValid() const
+        {
+            const SvgPathNode* pSvgPathNode = getReferencedSvgPathNode();
+
+            if(!pSvgPathNode)
+            {
+                return false;
+            }
+
+            const basegfx::B2DPolyPolygon* pPolyPolyPath = pSvgPathNode->getPath();
+
+            if(!pPolyPolyPath || !pPolyPolyPath->count())
+            {
+                return false;
+            }
+
+            const basegfx::B2DPolygon aPolygon(pPolyPolyPath->getB2DPolygon(0));
+
+            if(!aPolygon.count())
+            {
+                return false;
+            }
+
+            const double fBasegfxPathLength(basegfx::tools::getLength(aPolygon));
+
+            if(basegfx::fTools::equalZero(fBasegfxPathLength))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        void SvgTextPathNode::decomposePathNode(
+            const drawinglayer::primitive2d::Primitive2DSequence& rPathContent, 
+            drawinglayer::primitive2d::Primitive2DVector& rTarget, 
+            const basegfx::B2DPoint& rTextStart) const
+        {
+            if(rPathContent.hasElements())
+            {
+                const SvgPathNode* pSvgPathNode = getReferencedSvgPathNode();
+
+                if(pSvgPathNode)
+                {
+                    const basegfx::B2DPolyPolygon* pPolyPolyPath = pSvgPathNode->getPath();
+
+                    if(pPolyPolyPath && pPolyPolyPath->count())
+                    {
+                        basegfx::B2DPolygon aPolygon(pPolyPolyPath->getB2DPolygon(0));
+
+                        if(pSvgPathNode->getTransform())
+                        {
+                            aPolygon.transform(*pSvgPathNode->getTransform());
+                        }
+
+                        const double fBasegfxPathLength(basegfx::tools::getLength(aPolygon));
+
+                        if(!basegfx::fTools::equalZero(fBasegfxPathLength))
+                        {
+                            double fUserToBasegfx(1.0); // multiply: user->basegfx, divide: basegfx->user
+
+                            if(pSvgPathNode->getPathLength().isSet())
+                            {
+                                const double fUserLength(pSvgPathNode->getPathLength().solve(*this, length));
+
+                                if(fUserLength > 0.0 && !basegfx::fTools::equal(fUserLength, fBasegfxPathLength))
+                                {
+                                    fUserToBasegfx = fUserLength / fBasegfxPathLength;
+                                }
+                            }
+
+                            double fPosition(0.0);
+                            
+                            if(getStartOffset().isSet())
+                            {
+                                if(Unit_percent == getStartOffset().getUnit())
+                                {
+                                    // percent are relative to path length
+                                    fPosition = getStartOffset().getNumber() * 0.01 * fBasegfxPathLength;
+                                }
+                                else
+                                {
+                                    fPosition = getStartOffset().solve(*this, length) * fUserToBasegfx;
+                                }
+                            }
+
+                            if(fPosition >= 0.0)
+                            {
+                                const sal_Int32 nLength(rPathContent.getLength());
+                                sal_Int32 nCurrent(0);
+
+                                while(fPosition < fBasegfxPathLength && nCurrent < nLength)
+                                {
+                                    const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pCandidate = 0;
+                                    const drawinglayer::primitive2d::Primitive2DReference xReference(rPathContent[nCurrent]);
+                                    
+                                    if(xReference.is())
+                                    {
+                                        pCandidate = dynamic_cast< const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* >(xReference.get());
+                                    }
+
+                                    if(pCandidate)
+                                    {
+                                        pathTextBreakupHelper aPathTextBreakupHelper(
+                                            xReference,
+                                            aPolygon,
+                                            fBasegfxPathLength,
+                                            fUserToBasegfx,
+                                            fPosition,
+                                            rTextStart);
+
+                                        const drawinglayer::primitive2d::Primitive2DSequence aResult(
+                                            aPathTextBreakupHelper.getResult(drawinglayer::primitive2d::BreakupUnit_character));
+
+                                        if(aResult.hasElements())
+                                        {
+                                            rTarget.push_back(new drawinglayer::primitive2d::GroupPrimitive2D(aResult));
+                                        }
+
+                                        // advance position to consumed
+                                        fPosition = aPathTextBreakupHelper.getPosition();
+                                    }
+
+                                    nCurrent++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    } // end of namespace svgreader
+} // end of namespace svgio
+
+//////////////////////////////////////////////////////////////////////////////
+// eof

Added: incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtoken.cxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtoken.cxx?rev=1209140&view=auto
==============================================================================
--- incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtoken.cxx (added)
+++ incubator/ooo/branches/alg/svgreplacement/main/svgio/source/svgreader/svgtoken.cxx Thu Dec  1 16:25:17 2011
@@ -0,0 +1,275 @@
+/**************************************************************
+ * 
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ * 
+ *************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_svgio.hxx"
+
+#include <svgio/svgreader/svgtoken.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace svgio
+{
+    namespace svgreader
+    {
+        static rtl::OUString aSVGStrWidth(rtl::OUString::createFromAscii("width"));
+        static rtl::OUString aSVGStrHeight(rtl::OUString::createFromAscii("height"));
+        static rtl::OUString aSVGStrViewBox(rtl::OUString::createFromAscii("viewBox"));
+        static rtl::OUString aSVGStrTransform(rtl::OUString::createFromAscii("transform"));
+        static rtl::OUString aSVGStrStyle(rtl::OUString::createFromAscii("style"));
+        static rtl::OUString aSVGStrD(rtl::OUString::createFromAscii("d"));
+        static rtl::OUString aSVGStrX(rtl::OUString::createFromAscii("x"));
+        static rtl::OUString aSVGStrY(rtl::OUString::createFromAscii("y"));
+        static rtl::OUString aSVGStrXmlns(rtl::OUString::createFromAscii("xmlns")); 
+        static rtl::OUString aSVGStrVersion(rtl::OUString::createFromAscii("version")); 
+        static rtl::OUString aSVGStrId(rtl::OUString::createFromAscii("id")); 
+        static rtl::OUString aSVGStrRx(rtl::OUString::createFromAscii("rx")); 
+        static rtl::OUString aSVGStrRy(rtl::OUString::createFromAscii("ry")); 
+        static rtl::OUString aSVGStrPoints(rtl::OUString::createFromAscii("points")); 
+        static rtl::OUString aSVGStrDx(rtl::OUString::createFromAscii("dx")); 
+        static rtl::OUString aSVGStrDy(rtl::OUString::createFromAscii("dy")); 
+        static rtl::OUString aSVGStrRotate(rtl::OUString::createFromAscii("rotate")); 
+        static rtl::OUString aSVGStrTextLength(rtl::OUString::createFromAscii("textLength")); 
+        static rtl::OUString aSVGStrLengthAdjust(rtl::OUString::createFromAscii("lengthAdjust")); 
+        static rtl::OUString aSVGStrFont(rtl::OUString::createFromAscii("font")); 
+        static rtl::OUString aSVGStrFontFamily(rtl::OUString::createFromAscii("font-family")); 
+        static rtl::OUString aSVGStrFontSize(rtl::OUString::createFromAscii("font-size")); 
+        static rtl::OUString aSVGStrFontSizeAdjust(rtl::OUString::createFromAscii("font-size-adjust")); 
+        static rtl::OUString aSVGStrFontStretch(rtl::OUString::createFromAscii("font-stretch")); 
+        static rtl::OUString aSVGStrFontStyle(rtl::OUString::createFromAscii("font-style")); 
+        static rtl::OUString aSVGStrFontVariant(rtl::OUString::createFromAscii("font-variant")); 
+        static rtl::OUString aSVGStrFontWeight(rtl::OUString::createFromAscii("font-weight")); 
+        static rtl::OUString aSVGStrDirection(rtl::OUString::createFromAscii("direction")); 
+        static rtl::OUString aSVGStrLetterSpacing(rtl::OUString::createFromAscii("letter-spacing")); 
+        static rtl::OUString aSVGStrTextDecoration(rtl::OUString::createFromAscii("text-decoration")); 
+        static rtl::OUString aSVGStrUnicodeBidi(rtl::OUString::createFromAscii("unicode-bidi")); 
+        static rtl::OUString aSVGStrWordSpacing(rtl::OUString::createFromAscii("word-spacing")); 
+        static rtl::OUString aSVGStrTspan(rtl::OUString::createFromAscii("tspan")); 
+        static rtl::OUString aSVGStrTref(rtl::OUString::createFromAscii("tref")); 
+        static rtl::OUString aSVGStrTextPath(rtl::OUString::createFromAscii("textPath")); 
+        static rtl::OUString aSVGStrStartOffset(rtl::OUString::createFromAscii("startOffset")); 
+        static rtl::OUString aSVGStrMethod(rtl::OUString::createFromAscii("method")); 
+        static rtl::OUString aSVGStrSpacing(rtl::OUString::createFromAscii("spacing")); 
+        static rtl::OUString aSVGStrTextAlign(rtl::OUString::createFromAscii("text-align")); 
+        static rtl::OUString aSVGStrPathLength(rtl::OUString::createFromAscii("pathLength")); 
+        static rtl::OUString aSVGStrType(rtl::OUString::createFromAscii("type")); 
+        static rtl::OUString aSVGStrClass(rtl::OUString::createFromAscii("class")); 
+        static rtl::OUString aSVGStrTextAnchor(rtl::OUString::createFromAscii("text-anchor")); 
+        static rtl::OUString aSVGStrXmlSpace(rtl::OUString::createFromAscii("xml:space")); 
+
+        static rtl::OUString aSVGStrPreserveAspectRatio(rtl::OUString::createFromAscii("preserveAspectRatio")); 
+        static rtl::OUString aSVGStrDefer(rtl::OUString::createFromAscii("defer")); 
+        static rtl::OUString aSVGStrNone(rtl::OUString::createFromAscii("none")); 
+        static rtl::OUString aSVGStrXMinYMin(rtl::OUString::createFromAscii("xMinYMin")); 
+        static rtl::OUString aSVGStrXMidYMin(rtl::OUString::createFromAscii("xMidYMin")); 
+        static rtl::OUString aSVGStrXMaxYMin(rtl::OUString::createFromAscii("xMaxYMin")); 
+        static rtl::OUString aSVGStrXMinYMid(rtl::OUString::createFromAscii("xMinYMid")); 
+        static rtl::OUString aSVGStrXMidYMid(rtl::OUString::createFromAscii("xMidYMid")); 
+        static rtl::OUString aSVGStrXMaxYMid(rtl::OUString::createFromAscii("xMaxYMid")); 
+        static rtl::OUString aSVGStrXMinYMax(rtl::OUString::createFromAscii("xMinYMax")); 
+        static rtl::OUString aSVGStrXMidYMax(rtl::OUString::createFromAscii("xMidYMax")); 
+        static rtl::OUString aSVGStrXMaxYMax(rtl::OUString::createFromAscii("xMaxYMax")); 
+        static rtl::OUString aSVGStrMeet(rtl::OUString::createFromAscii("meet")); 
+        static rtl::OUString aSVGStrSlice(rtl::OUString::createFromAscii("slice")); 
+
+        static rtl::OUString aSVGStrDefs(rtl::OUString::createFromAscii("defs")); 
+        static rtl::OUString aSVGStrG(rtl::OUString::createFromAscii("g"));
+        static rtl::OUString aSVGStrSvg(rtl::OUString::createFromAscii("svg"));
+        static rtl::OUString aSVGStrSymbol(rtl::OUString::createFromAscii("symbol"));
+        static rtl::OUString aSVGStrUse(rtl::OUString::createFromAscii("use"));
+
+        static rtl::OUString aSVGStrCircle(rtl::OUString::createFromAscii("circle"));
+        static rtl::OUString aSVGStrEllipse(rtl::OUString::createFromAscii("ellipse"));
+        static rtl::OUString aSVGStrLine(rtl::OUString::createFromAscii("line"));
+        static rtl::OUString aSVGStrPath(rtl::OUString::createFromAscii("path"));
+        static rtl::OUString aSVGStrPolygon(rtl::OUString::createFromAscii("polygon")); 
+        static rtl::OUString aSVGStrPolyline(rtl::OUString::createFromAscii("polyline")); 
+        static rtl::OUString aSVGStrRect(rtl::OUString::createFromAscii("rect")); 
+        static rtl::OUString aSVGStrImage(rtl::OUString::createFromAscii("image")); 
+        
+        static rtl::OUString aSVGStrLinearGradient(rtl::OUString::createFromAscii("linearGradient")); 
+        static rtl::OUString aSVGStrRadialGradient(rtl::OUString::createFromAscii("radialGradient")); 
+        static rtl::OUString aSVGStrStop(rtl::OUString::createFromAscii("stop")); 
+        static rtl::OUString aSVGStrOffset(rtl::OUString::createFromAscii("offset")); 
+        static rtl::OUString aSVGStrX1(rtl::OUString::createFromAscii("x1")); 
+        static rtl::OUString aSVGStrY1(rtl::OUString::createFromAscii("y1")); 
+        static rtl::OUString aSVGStrX2(rtl::OUString::createFromAscii("x2")); 
+        static rtl::OUString aSVGStrY2(rtl::OUString::createFromAscii("y2")); 
+        static rtl::OUString aSVGStrCx(rtl::OUString::createFromAscii("cx")); 
+        static rtl::OUString aSVGStrCy(rtl::OUString::createFromAscii("cy")); 
+        static rtl::OUString aSVGStrFx(rtl::OUString::createFromAscii("fx")); 
+        static rtl::OUString aSVGStrFy(rtl::OUString::createFromAscii("fy")); 
+        static rtl::OUString aSVGStrR(rtl::OUString::createFromAscii("r")); 
+        static rtl::OUString aSVGStrGradientUnits(rtl::OUString::createFromAscii("gradientUnits")); 
+        static rtl::OUString aSVGStrGradientTransform(rtl::OUString::createFromAscii("gradientTransform")); 
+        static rtl::OUString aSVGStrSpreadMethod(rtl::OUString::createFromAscii("spreadMethod")); 
+        static rtl::OUString aSVGStrXlinkHref(rtl::OUString::createFromAscii("xlink:href")); 
+        static rtl::OUString aSVGStrStopColor(rtl::OUString::createFromAscii("stop-color")); 
+        static rtl::OUString aSVGStrStopOpacity(rtl::OUString::createFromAscii("stop-opacity")); 
+
+        static rtl::OUString aSVGStrFill(rtl::OUString::createFromAscii("fill"));
+        static rtl::OUString aSVGStrFillOpacity(rtl::OUString::createFromAscii("fill-opacity")); 
+        static rtl::OUString aSVGStrFillRule(rtl::OUString::createFromAscii("fill-rule")); 
+
+        static rtl::OUString aSVGStrStroke(rtl::OUString::createFromAscii("stroke"));
+        static rtl::OUString aSVGStrStrokeDasharray(rtl::OUString::createFromAscii("stroke-dasharray")); 
+        static rtl::OUString aSVGStrStrokeDashoffset(rtl::OUString::createFromAscii("stroke-dashoffset")); 
+        static rtl::OUString aSVGStrStrokeLinecap(rtl::OUString::createFromAscii("stroke-linecap")); 
+        static rtl::OUString aSVGStrStrokeLinejoin(rtl::OUString::createFromAscii("stroke-linejoin")); 
+        static rtl::OUString aSVGStrStrokeMiterlimit(rtl::OUString::createFromAscii("stroke-miterlimit")); 
+        static rtl::OUString aSVGStrStrokeOpacity(rtl::OUString::createFromAscii("stroke-opacity")); 
+        static rtl::OUString aSVGStrStrokeWidth(rtl::OUString::createFromAscii("stroke-width")); 
+
+        static rtl::OUString aSVGStrText(rtl::OUString::createFromAscii("text")); 
+
+        SVGToken StrToSVGToken(const rtl::OUString& rStr)
+        {
+            typedef std::hash_map< rtl::OUString, SVGToken, rtl::OUStringHash > SVGTokenMapper;
+            typedef std::pair< rtl::OUString, SVGToken > SVGTokenValueType;
+            static SVGTokenMapper aSVGTokenMapperList;
+
+            if(aSVGTokenMapperList.empty())
+            {
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrWidth, SVGTokenWidth));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrHeight, SVGTokenHeight));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrViewBox, SVGTokenViewBox));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrTransform, SVGTokenTransform));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStyle, SVGTokenStyle));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrD, SVGTokenD));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrX, SVGTokenX));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrY, SVGTokenY));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXmlns, SVGTokenXmlns));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrVersion, SVGTokenVersion));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrId, SVGTokenId));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrRx, SVGTokenRx));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrRy, SVGTokenRy));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrPoints, SVGTokenPoints));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrDx, SVGTokenDx));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrDy, SVGTokenDy));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrRotate, SVGTokenRotate));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFont, SVGTokenFont));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFontFamily, SVGTokenFontFamily));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFontSize, SVGTokenFontSize));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFontSizeAdjust, SVGTokenFontSizeAdjust));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFontStretch, SVGTokenFontStretch));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFontStyle, SVGTokenFontStyle));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFontVariant, SVGTokenFontVariant));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFontWeight, SVGTokenFontWeight));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrDirection, SVGTokenDirection));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrLetterSpacing, SVGTokenLetterSpacing));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrTextDecoration, SVGTokenTextDecoration));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrUnicodeBidi, SVGTokenUnicodeBidi));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrWordSpacing, SVGTokenWordSpacing));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrTspan, SVGTokenTspan));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrTref, SVGTokenTref));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrTextPath, SVGTokenTextPath));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStartOffset, SVGTokenStartOffset));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrMethod, SVGTokenMethod));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrSpacing, SVGTokenSpacing));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrTextAlign, SVGTokenTextAlign));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrPathLength, SVGTokenPathLength));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrType, SVGTokenType));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrClass, SVGTokenClass));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrTextAnchor, SVGTokenTextAnchor));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXmlSpace, SVGTokenXmlSpace));
+
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrPreserveAspectRatio, SVGTokenPreserveAspectRatio));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrDefer, SVGTokenDefer));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrNone, SVGTokenNone));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMinYMin, SVGTokenXMinYMin));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMidYMin, SVGTokenXMidYMin));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMaxYMin, SVGTokenXMaxYMin));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMinYMid, SVGTokenXMinYMid));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMidYMid, SVGTokenXMidYMid));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMaxYMid, SVGTokenXMaxYMid));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMinYMax, SVGTokenXMinYMax));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMidYMax, SVGTokenXMidYMax));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXMaxYMax, SVGTokenXMaxYMax));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrMeet, SVGTokenMeet));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrSlice, SVGTokenSlice));
+                
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrDefs, SVGTokenDefs));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrG, SVGTokenG));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrSvg, SVGTokenSvg));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrSymbol, SVGTokenSymbol));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrUse, SVGTokenUse));
+
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrCircle, SVGTokenCircle));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrEllipse, SVGTokenEllipse));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrLine, SVGTokenLine));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrPath, SVGTokenPath));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrPolygon, SVGTokenPolygon));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrPolyline, SVGTokenPolyline));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrRect, SVGTokenRect));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrImage, SVGTokenImage));
+                
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrLinearGradient, SVGTokenLinearGradient));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrRadialGradient, SVGTokenRadialGradient));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStop, SVGTokenStop));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrOffset, SVGTokenOffset));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrX1, SVGTokenX1));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrY1, SVGTokenY1));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrX2, SVGTokenX2));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrY2, SVGTokenY2));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrCx, SVGTokenCx));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrCy, SVGTokenCy));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFx, SVGTokenFx));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFy, SVGTokenFy));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrR, SVGTokenR));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrGradientUnits, SVGTokenGradientUnits));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrGradientTransform, SVGTokenGradientTransform));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrSpreadMethod, SVGTokenSpreadMethod));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrXlinkHref, SVGTokenXlinkHref));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStopColor, SVGTokenStopColor));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStopOpacity, SVGTokenStopOpacity));
+                
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFill, SVGTokenFill));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFillOpacity, SVGTokenFillOpacity));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrFillRule, SVGTokenFillRule));
+
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStroke, SVGTokenStroke));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStrokeDasharray, SVGTokenStrokeDasharray));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStrokeDashoffset, SVGTokenStrokeDashoffset));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStrokeLinecap, SVGTokenStrokeLinecap));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStrokeLinejoin, SVGTokenStrokeLinejoin));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStrokeMiterlimit, SVGTokenStrokeMiterlimit));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStrokeOpacity, SVGTokenStrokeOpacity));
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrStrokeWidth, SVGTokenStrokeWidth));
+
+                aSVGTokenMapperList.insert(SVGTokenValueType(aSVGStrText, SVGTokenText));
+            }
+
+            const SVGTokenMapper::const_iterator aResult(aSVGTokenMapperList.find(rStr));
+
+            if(aResult == aSVGTokenMapperList.end())
+            {
+                return SVGTokenUnknown;
+            }
+            else
+            {
+                return aResult->second;
+            }
+        }
+    } // end of namespace svgreader
+} // end of namespace svgio
+
+//////////////////////////////////////////////////////////////////////////////
+// eof



Mime
View raw message