// The variable contains value of minimal area that can

    // be displayed using internal object filling. Sometimes

    // a problem occurs, when object is to narrow and edges

    // are close to themselves. It implies small filling area

    // and objects are not visible then. The solution is to

    // draw object borders that time. 

    // TODO: this value shouldn't be hardcoded. The user

    // should be able to choose proper value.

    const double minAreaThreshold;

    /**

     * \brief Reads path and count the area of the smallest rectangle containing it.

     *

     * Function reads path and counts area of it. It's used

     * when EOFILLPATH occurs to check if the area is big 

     * enough to draw it using internal filling. Otherwise

     * we need to add object borders by calling strokePath.

     * The decision is taken by comparing area value to 

     * minAreaThreshold variable.

     *

     * @param area will contain the value of smallest rectangle

     * containing the path.

     * @return reference to the path.

     **/

    uno::Reference<rendering::XPolyPolygon2D> readPath(double & area);

} 

uno::Reference<rendering::XPolyPolygon2D> Parser::readPath(double & area)

{

    const rtl::OString aSubPathMarker( "subpath" );

    if( 0 != readNextToken().compareTo( aSubPathMarker ) )

        OSL_PRECOND(false, "broken path");

    basegfx::B2DPolyPolygon aResult;

    double xmax = 0.0;

    double ymax = 0.0;

    double xmin = INT_MAX;

    double ymin = INT_MAX;

    double width = 0.0;

    double heigth = 0.0;

    while( m_nCharIndex != -1 )

    {

        basegfx::B2DPolygon aSubPath;

        sal_Int32 nClosedFlag;

        readInt32( nClosedFlag );

        aSubPath.setClosed( nClosedFlag != 0 );

        sal_Int32 nContiguousControlPoints(0);

        sal_Int32 nDummy=m_nCharIndex;

        rtl::OString aCurrToken( m_aLine.getToken(m_nNextToken,' ',nDummy) );

        while( m_nCharIndex != -1 && 0 != aCurrToken.compareTo(aSubPathMarker) )

        {

            sal_Int32 nCurveFlag;

            double    nX, nY;

            readDouble( nX );

            readDouble( nY );

            readInt32(  nCurveFlag );

            if(nX < xmin)

                xmin = nX;

            if(nX > xmax)

                xmax = nX;

            if(nY < ymin)

                ymin = nY;

            if(nY > ymax)

                ymax = nY;

            aSubPath.append(basegfx::B2DPoint(nX,nY));

            if( nCurveFlag )

            {

                ++nContiguousControlPoints;

            }

            else if( nContiguousControlPoints )

            {

                OSL_PRECOND(nContiguousControlPoints==2,"broken bezier path");

                // have two control points before us. the current one

                // is a normal point - thus, convert previous points

                // into bezier segment

                const sal_uInt32 nPoints( aSubPath.count() );

                const basegfx::B2DPoint aCtrlA( aSubPath.getB2DPoint(nPoints-3) );

                const basegfx::B2DPoint aCtrlB( aSubPath.getB2DPoint(nPoints-2) );

                const basegfx::B2DPoint aEnd( aSubPath.getB2DPoint(nPoints-1) );

                aSubPath.remove(nPoints-3, 3);

                aSubPath.appendBezierSegment(aCtrlA, aCtrlB, aEnd);

                nContiguousControlPoints=0;

            }

            // one token look-ahead (new subpath or more points?

            nDummy=m_nCharIndex;

            aCurrToken = m_aLine.getToken(m_nNextToken,' ',nDummy);

        }

        aResult.append( aSubPath );

        if( m_nCharIndex != -1 )

			readNextToken();

    }

    width = xmax - xmin;

    heigth = ymax - ymin;

    area = width * heigth;

    return static_cast<rendering::XLinePolyPolygon2D*>(

        new basegfx::unotools::UnoPolyPolygon(aResult));