libreoffice/xmloff/source/draw/ximpcustomshape.cxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */

#include "ximpcustomshape.hxx"
#include "ximpshap.hxx"
#include <rtl/math.hxx>
#include <rtl/ustrbuf.hxx>
#include <rtl/ustring.hxx>
#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/xml/sax/XAttributeList.hpp>
#include <com/sun/star/container/XIndexContainer.hpp>
#include <xmloff/xmltoken.hxx>
#include "EnhancedCustomShapeToken.hxx"
#include <xmloff/xmlimp.hxx>
#include <xmloff/xmltkmap.hxx>
#include <xmloff/xmlnmspe.hxx>
#include <xmloff/nmspmap.hxx>
#include <xmloff/xmluconv.hxx>
#include "xexptran.hxx"
#include <xmloff/xmlerror.hxx>
#include <com/sun/star/drawing/Direction3D.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
#include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
#include <com/sun/star/drawing/ProjectionMode.hpp>
#include <com/sun/star/drawing/HomogenMatrix3.hpp>
#include <boost/unordered_map.hpp>
#include <basegfx/vector/b2dvector.hxx>
#include <sax/tools/converter.hxx>

using namespace ::com::sun::star;
using namespace ::xmloff::token;
using namespace ::xmloff::EnhancedCustomShapeToken;

TYPEINIT1( XMLEnhancedCustomShapeContext, SvXMLImportContext );

XMLEnhancedCustomShapeContext::XMLEnhancedCustomShapeContext( SvXMLImport& rImport,
            ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& rxShape,
                sal_uInt16 nPrefix, const OUString& rLocalName,
                    std::vector< com::sun::star::beans::PropertyValue >& rCustomShapeGeometry ) :
        SvXMLImportContext( rImport, nPrefix, rLocalName ),
        mrUnitConverter( rImport.GetMM100UnitConverter() ),
        mrxShape( rxShape ),
        mrCustomShapeGeometry( rCustomShapeGeometry )
{
}

const SvXMLEnumMapEntry aXML_GluePointEnumMap[] =
{
    { XML_NONE,         0 },
    { XML_SEGMENTS,     1 },
    { XML_NONE,         2 },
    { XML_RECTANGLE,    3 },
    { XML_TOKEN_INVALID, 0 }
};
void GetBool( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    bool bAttrBool;
    if (::sax::Converter::convertBool( bAttrBool, rValue ))
    {
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= bAttrBool;
        rDest.push_back( aProp );
    }
}

void GetInt32( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    sal_Int32 nAttrNumber;
    if (::sax::Converter::convertNumber( nAttrNumber, rValue ))
    {
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= nAttrNumber;
        rDest.push_back( aProp );
    }
}

void GetDouble( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    double fAttrDouble;
    if (::sax::Converter::convertDouble( fAttrDouble, rValue ))
    {
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= fAttrDouble;
        rDest.push_back( aProp );
    }
}

void GetString( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    beans::PropertyValue aProp;
    aProp.Name = EASGet( eDestProp );
    aProp.Value <<= rValue;
    rDest.push_back( aProp );
}

void GetEnum( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                         const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp,
                        const SvXMLEnumMapEntry& rMap )
{
    sal_uInt16 eKind;
    if( SvXMLUnitConverter::convertEnum( eKind, rValue, &rMap ) )
    {
        sal_Int16 nEnum = (sal_Int16)eKind;
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= nEnum;
        rDest.push_back( aProp );
    }
}

void GetDoublePercentage( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                         const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    sal_Int16 const eSrcUnit = ::sax::Converter::GetUnitFromString(
            rValue, util::MeasureUnit::MM_100TH);
    if (util::MeasureUnit::PERCENT == eSrcUnit)
    {
        rtl_math_ConversionStatus eStatus;
        double fAttrDouble = ::rtl::math::stringToDouble( rValue,
            '.', ',', &eStatus, NULL );
        if ( eStatus == rtl_math_ConversionStatus_Ok )
        {
            beans::PropertyValue aProp;
            aProp.Name = EASGet( eDestProp );
            aProp.Value <<= fAttrDouble;
            rDest.push_back( aProp );
        }
    }
}

void GetB3DVector( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                         const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    ::basegfx::B3DVector aB3DVector;
    if ( SvXMLUnitConverter::convertB3DVector( aB3DVector, rValue ) )
    {
        drawing::Direction3D aDirection3D( aB3DVector.getX(), aB3DVector.getY(), aB3DVector.getZ() );
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aDirection3D;
        rDest.push_back( aProp );
    }
}

bool GetEquationName( const OUString& rEquation, const sal_Int32 nStart, OUString& rEquationName )
{
    sal_Int32 nIndex = nStart;
    while( nIndex < rEquation.getLength() )
    {
        sal_Unicode nChar = rEquation[ nIndex ];
        if (
            ( ( nChar >= 'a' ) && ( nChar <= 'z' ) )
            || ( ( nChar >= 'A' ) && ( nChar <= 'Z' ) )
            || ( ( nChar >= '0' ) && ( nChar <= '9' ) )
            )
        {
            nIndex++;
        }
        else
            break;
    }
    bool bValid = ( nIndex - nStart ) != 0;
    if ( bValid )
        rEquationName = rEquation.copy( nStart, nIndex - nStart );
    return bValid;
}

bool GetNextParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter, sal_Int32& nIndex, const OUString& rParaString )
{
    if ( nIndex >= rParaString.getLength() )
        return false;

    bool bValid = true;
    bool bNumberRequired = true;
    bool bMustBePositiveWholeNumbered = false;

    rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL;
    if ( rParaString[ nIndex ] == '$' )
    {
        rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT;
        bMustBePositiveWholeNumbered = true;
        nIndex++;
    }
    else if ( rParaString[ nIndex ] == '?' )
    {
        nIndex++;
        bNumberRequired = false;
        OUString aEquationName;
        bValid = GetEquationName( rParaString, nIndex, aEquationName );
        if ( bValid )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION;
            rParameter.Value <<= aEquationName;
            nIndex += aEquationName.getLength();
        }
    }
    else if ( rParaString[ nIndex ] > '9' )
    {
        bNumberRequired = false;
        if ( rParaString.matchIgnoreAsciiCaseAsciiL( "left", 4, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT;
            nIndex += 4;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "top", 3, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP;
            nIndex += 3;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "right", 5, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT;
            nIndex += 5;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "bottom", 6, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM;
            nIndex += 6;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "xstretch", 8, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH;
            nIndex += 8;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "ystretch", 8, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH;
            nIndex += 8;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "hasstroke", 9, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE;
            nIndex += 9;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "hasfill", 7, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL;
            nIndex += 7;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "width", 5, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH;
            nIndex += 5;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "height", 6, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT;
            nIndex += 6;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "logwidth", 8, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH;
            nIndex += 8;
        }
        else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "logheight", 9, nIndex ) )
        {
            rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT;
            nIndex += 9;
        }
        else
            bValid = false;
    }
    if ( bValid )
    {
        if ( bNumberRequired )
        {
            sal_Int32 nStartIndex = nIndex;
            sal_Int32 nEIndex = 0;  // index of "E" in double

            bool bE = false;    // set if a double is including a "E" statement
            bool bENum = false; // there is at least one number after "E"
            bool bDot = false;  // set if there is a dot included
            bool bEnd = false;  // set for each value that can not be part of a double/integer

            while( ( nIndex < rParaString.getLength() ) && bValid )
            {
                switch( rParaString[ nIndex ] )
                {
                    case '.' :
                    {
                        if ( bMustBePositiveWholeNumbered )
                            bValid = false;
                        else
                        {
                            if ( bDot )
                                bValid = false;
                            else
                                bDot = true;
                        }
                    }
                    break;
                    case '-' :
                    {
                        if ( bMustBePositiveWholeNumbered )
                            bValid = false;
                        else
                        {
                            if ( nStartIndex == nIndex )
                               bValid = true;
                            else if ( bE )
                            {
                                if ( nEIndex + 1 == nIndex )
                                    bValid = true;
                                else if ( bENum )
                                    bEnd = true;
                                else
                                    bValid = false;
                            }
                        }
                    }
                    break;

                    case 'e' :
                    case 'E' :
                    {
                        if ( bMustBePositiveWholeNumbered )
                            bEnd = true;
                        else
                        {
                            if ( !bE )
                            {
                                bE = true;
                                nEIndex = nIndex;
                            }
                            else
                                bEnd = true;
                        }
                    }
                    break;
                    case '0' :
                    case '1' :
                    case '2' :
                    case '3' :
                    case '4' :
                    case '5' :
                    case '6' :
                    case '7' :
                    case '8' :
                    case '9' :
                    {
                        if ( bE && ! bENum )
                            bENum = true;
                    }
                    break;
                    default:
                        bEnd = true;
                }
                if ( !bEnd )
                    nIndex++;
                else
                    break;
            }
            if ( nIndex == nStartIndex )
                bValid = false;
            if ( bValid )
            {
                OUString aNumber( rParaString.copy( nStartIndex, nIndex - nStartIndex ) );
                if ( bE || bDot )
                {
                    double fAttrDouble;
                    if (::sax::Converter::convertDouble(fAttrDouble, aNumber))
                        rParameter.Value <<= fAttrDouble;
                    else
                        bValid = false;
                }
                else
                {
                    sal_Int32 nValue;
                    if (::sax::Converter::convertNumber(nValue, aNumber))
                        rParameter.Value <<= nValue;
                    else
                        bValid = false;
                }
            }
        }
    }
    if ( bValid )
    {
        // skipping white spaces and commas (#i121507#)
        const sal_Unicode aSpace(' ');
        const sal_Unicode aCommata(',');

        while(nIndex < rParaString.getLength())
        {
            const sal_Unicode aCandidate(rParaString[nIndex]);

            if(aSpace == aCandidate || aCommata == aCandidate)
            {
                nIndex++;
            }
            else
            {
                break;
            }
        }
    }
    return bValid;
}

void GetPosition3D( std::vector< com::sun::star::beans::PropertyValue >& rDest,                     // e.g. draw:extrusion-viewpoint
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp,
                        SvXMLUnitConverter& rUnitConverter )
{
    drawing::Position3D aPosition3D;
    if ( rUnitConverter.convertPosition3D( aPosition3D, rValue ) )
    {
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aPosition3D;
        rDest.push_back( aProp );
    }
}

void GetDoubleSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,                 // e.g. draw:glue-point-leaving-directions
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    std::vector< double > vDirection;
    sal_Int32 nIndex = 0;
    do
    {
        double fAttrDouble;
        OUString aToken( rValue.getToken( 0, ',', nIndex ) );
        if (!::sax::Converter::convertDouble( fAttrDouble, aToken ))
            break;
        else
            vDirection.push_back( fAttrDouble );
    }
    while ( nIndex >= 0 );

    if ( !vDirection.empty() )
    {
        uno::Sequence< double > aDirectionsSeq( vDirection.size() );
        std::vector< double >::const_iterator aIter = vDirection.begin();
        std::vector< double >::const_iterator aEnd = vDirection.end();
        double* pValues = aDirectionsSeq.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aDirectionsSeq;
        rDest.push_back( aProp );
    }
}

void GetSizeSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,
                      const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    std::vector< sal_Int32 > vNum;
    sal_Int32 nIndex = 0;
    do
    {
        sal_Int32 n;
        OUString aToken( rValue.getToken( 0, ' ', nIndex ) );
        if (!::sax::Converter::convertNumber( n, aToken ))
            break;
        else
            vNum.push_back( n );
    }
    while ( nIndex >= 0 );

    if ( !vNum.empty() )
    {
        uno::Sequence< awt::Size > aSizeSeq( vNum.size() / 2 );
        std::vector< sal_Int32 >::const_iterator aIter = vNum.begin();
        std::vector< sal_Int32 >::const_iterator aEnd = vNum.end();
        awt::Size* pValues = aSizeSeq.getArray();

        while ( aIter != aEnd ) {
            pValues->Width = *aIter++;
            if ( aIter != aEnd )
                pValues->Height = *aIter++;
            pValues ++;
        }

        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aSizeSeq;
        rDest.push_back( aProp );
    }
}

void GetEnhancedParameter( std::vector< com::sun::star::beans::PropertyValue >& rDest,              // e.g. draw:handle-position
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    sal_Int32 nIndex = 0;
    com::sun::star::drawing::EnhancedCustomShapeParameter aParameter;
    if ( GetNextParameter( aParameter, nIndex, rValue ) )
    {
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aParameter;
        rDest.push_back( aProp );
    }
}

void GetEnhancedParameterPair( std::vector< com::sun::star::beans::PropertyValue >& rDest,          // e.g. draw:handle-position
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    sal_Int32 nIndex = 0;
    com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameterPair;
    if ( GetNextParameter( aParameterPair.First, nIndex, rValue )
        && GetNextParameter( aParameterPair.Second, nIndex, rValue ) )
    {
        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aParameterPair;
        rDest.push_back( aProp );
    }
}

sal_Int32 GetEnhancedParameterPairSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,     // e.g. draw:glue-points
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair > vParameter;
    com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameter;

    sal_Int32 nIndex = 0;
    while ( GetNextParameter( aParameter.First, nIndex, rValue )
            && GetNextParameter( aParameter.Second, nIndex, rValue ) )
    {
        vParameter.push_back( aParameter );
    }
    if ( !vParameter.empty() )
    {
        uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aParameterSeq( vParameter.size() );
        std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aIter = vParameter.begin();
        std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aEnd = vParameter.end();
        com::sun::star::drawing::EnhancedCustomShapeParameterPair* pValues = aParameterSeq.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aParameterSeq;
        rDest.push_back( aProp );
    }
    return vParameter.size();
}

void GetEnhancedRectangleSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,      // e.g. draw:text-areas
                        const OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
    std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame > vTextFrame;
    com::sun::star::drawing::EnhancedCustomShapeTextFrame aParameter;

    sal_Int32 nIndex = 0;

    while ( GetNextParameter( aParameter.TopLeft.First, nIndex, rValue )
            && GetNextParameter( aParameter.TopLeft.Second, nIndex, rValue )
            && GetNextParameter( aParameter.BottomRight.First, nIndex, rValue )
            && GetNextParameter( aParameter.BottomRight.Second, nIndex, rValue ) )
    {
        vTextFrame.push_back( aParameter );
    }
    if ( !vTextFrame.empty() )
    {
        uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aTextFrameSeq( vTextFrame.size() );
        std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame >::const_iterator aIter = vTextFrame.begin();
        std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame >::const_iterator aEnd = vTextFrame.end();
        com::sun::star::drawing::EnhancedCustomShapeTextFrame* pValues = aTextFrameSeq.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        beans::PropertyValue aProp;
        aProp.Name = EASGet( eDestProp );
        aProp.Value <<= aTextFrameSeq;
        rDest.push_back( aProp );
    }
}

void GetEnhancedPath( std::vector< com::sun::star::beans::PropertyValue >& rDest,                   // e.g. draw:enhanced-path
                        const OUString& rValue )
{
    std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >    vCoordinates;
    std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >      vSegments;

    sal_Int32 nIndex = 0;
    sal_Int32 nParameterCount = 0;

    sal_Int32 nParametersNeeded = 1;
    sal_Int16 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;

    bool bValid = true;

    while( bValid && ( nIndex < rValue.getLength() ) )
    {
        switch( rValue[ nIndex ] )
        {
            case 'M' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
                nParametersNeeded = 1;
                nIndex++;
            }
            break;
            case 'L' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
                nParametersNeeded = 1;
                nIndex++;
            }
            break;
            case 'C' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO;
                nParametersNeeded = 3;
                nIndex++;
            }
            break;
            case 'Z' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'N' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'F' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'S' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'T' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO;
                nParametersNeeded = 3;
                nIndex++;
            }
            break;
            case 'U' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE;
                nParametersNeeded = 3;
                nIndex++;
            }
            break;
            case 'A' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO;
                nParametersNeeded = 4;
                nIndex++;
            }
            break;
            case 'B' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC;
                nParametersNeeded = 4;
                nIndex++;
            }
            break;
            case 'G' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO;
                nParametersNeeded = 2;
                nIndex++;
            }
            break;
            case 'H' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKEN;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'I' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKENLESS;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'J' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTEN;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'K' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTENLESS;
                nParametersNeeded = 0;
                nIndex++;
            }
            break;
            case 'W' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO;
                nParametersNeeded = 4;
                nIndex++;
            }
            break;
            case 'V' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC;
                nParametersNeeded = 4;
                nIndex++;
            }
            break;
            case 'X' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX;
                nParametersNeeded = 1;
                nIndex++;
            }
            break;
            case 'Y' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY;
                nParametersNeeded = 1;
                nIndex++;
            }
            break;
            case 'Q' :
            {
                nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO;
                nParametersNeeded = 2;
                nIndex++;
            }
            break;
            case ' ' :
            {
                nIndex++;
            }
            break;

            case '$' :
            case '?' :
            case '0' :
            case '1' :
            case '2' :
            case '3' :
            case '4' :
            case '5' :
            case '6' :
            case '7' :
            case '8' :
            case '9' :
            case '.' :
            case '-' :
            {
                com::sun::star::drawing::EnhancedCustomShapeParameterPair aPair;
                if ( GetNextParameter( aPair.First, nIndex, rValue ) &&
                        GetNextParameter( aPair.Second, nIndex, rValue ) )
                {
                    vCoordinates.push_back( aPair );
                    nParameterCount++;
                }
                else
                    bValid = false;
            }
            break;
            default:
                nIndex++;
            break;
        }
        if ( !nParameterCount && !nParametersNeeded )
        {
            com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
            aSegment.Command = nLatestSegmentCommand;
            aSegment.Count = 0;
            vSegments.push_back( aSegment );
            nParametersNeeded = 0x7fffffff;
        }
        else if ( nParameterCount >= nParametersNeeded )
        {
            // check if the last command is identical,
            // if so, we just need to increment the count
            if ( !vSegments.empty() && ( vSegments[ vSegments.size() - 1 ].Command == nLatestSegmentCommand ) )
                vSegments[ vSegments.size() -1 ].Count++;
            else
            {
                com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
                aSegment.Command = nLatestSegmentCommand;
                aSegment.Count = 1;
                vSegments.push_back( aSegment );
            }
            nParameterCount = 0;
        }
    }
    // adding the Coordinates property
    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > seqCoordinates( vCoordinates.size() );
    std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aCoordinatesIter = vCoordinates.begin();
    std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aCoordinatesEnd = vCoordinates.end();
    com::sun::star::drawing::EnhancedCustomShapeParameterPair* pCoordinateValues = seqCoordinates.getArray();

    while ( aCoordinatesIter != aCoordinatesEnd )
        *pCoordinateValues++ = *aCoordinatesIter++;

    beans::PropertyValue aProp;
    aProp.Name = EASGet( EAS_Coordinates );
    aProp.Value <<= seqCoordinates;
    rDest.push_back( aProp );


    // adding the Segments property
    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > seqSegments( vSegments.size() );
    std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >::const_iterator aSegmentsIter = vSegments.begin();
    std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >::const_iterator aSegmentsEnd = vSegments.end();
    com::sun::star::drawing::EnhancedCustomShapeSegment* pSegmentValues = seqSegments.getArray();

    while ( aSegmentsIter != aSegmentsEnd )
        *pSegmentValues++ = *aSegmentsIter++;

    aProp.Name = EASGet( EAS_Segments );
    aProp.Value <<= seqSegments;
    rDest.push_back( aProp );
}

void GetAdjustmentValues( std::vector< com::sun::star::beans::PropertyValue >& rDest,               // draw:adjustments
                        const OUString& rValue )
{
    std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > vAdjustmentValue;
    com::sun::star::drawing::EnhancedCustomShapeParameter aParameter;
    sal_Int32 nIndex = 0;
    while ( GetNextParameter( aParameter, nIndex, rValue ) )
    {
        com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue aAdj;
        if ( aParameter.Type == com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL )
        {
            aAdj.Value <<= aParameter.Value;
            aAdj.State = beans::PropertyState_DIRECT_VALUE;
        }
        else
            aAdj.State = beans::PropertyState_DEFAULT_VALUE;    // this should not be, but better than setting nothing

        vAdjustmentValue.push_back( aAdj );
    }

    sal_Int32 nAdjustmentValues = vAdjustmentValue.size();
    if ( nAdjustmentValues )
    {
        uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues( nAdjustmentValues );
        std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue >::const_iterator aIter = vAdjustmentValue.begin();
        std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue >::const_iterator aEnd = vAdjustmentValue.end();
        com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue* pValues = aAdjustmentValues.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        beans::PropertyValue aProp;
        aProp.Name = EASGet( EAS_AdjustmentValues );
        aProp.Value <<= aAdjustmentValues;
        rDest.push_back( aProp );
    }
}

void XMLEnhancedCustomShapeContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
{
    sal_Int16 nLength = xAttrList->getLength();
    if ( nLength )
    {
        sal_Int32               nAttrNumber;
        for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
        {
            OUString aLocalName;
            const OUString& rValue = xAttrList->getValueByIndex( nAttr );
            /* sven fixme, this must be checked! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );

            switch( EASGet( aLocalName ) )
            {
                case EAS_type :
                    GetString( mrCustomShapeGeometry, rValue, EAS_Type );
                break;
                case EAS_mirror_horizontal :
                    GetBool( mrCustomShapeGeometry, rValue, EAS_MirroredX );
                break;
                case EAS_mirror_vertical :
                    GetBool( mrCustomShapeGeometry, rValue, EAS_MirroredY );
                break;
                case EAS_viewBox :
                {
                    SdXMLImExViewBox aViewBox( rValue, GetImport().GetMM100UnitConverter() );
                    awt::Rectangle aRect(
                        basegfx::fround(aViewBox.GetX()),
                        basegfx::fround(aViewBox.GetY()),
                        basegfx::fround(aViewBox.GetWidth()),
                        basegfx::fround(aViewBox.GetHeight()));

                    if(0 == aRect.Width && 0 == aRect.Height)
                    {
                        // #i124452# If in svg:viewBox no width and height is given the objects should normally
                        // not be visible at all, but in this case it is a bug in LO to write empty svg:viewBox
                        // entries for CustomShapes. To allow for a better ODF user experience, just correct this
                        // here by getting the real object scale from the already set transformation from the xShape.
                        // Hopefully LO will fix that bug (but this will still leave the files with the error), but
                        // even when not this will do no harm as long no one uses this state explicitely for some
                        // purpose (e.g. to really have CustomShapes without content, but unlikely).
                        uno::Reference< beans::XPropertySet > xProps(mrxShape, uno::UNO_QUERY_THROW);
                        uno::Any aObjectTransform = xProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation")));
                        drawing::HomogenMatrix3 aTransformMatrix;
                        aObjectTransform >>= aTransformMatrix;
                        basegfx::B2DHomMatrix aMatrix;

                        aMatrix.set(0, 0, aTransformMatrix.Line1.Column1);
                        aMatrix.set(0, 1, aTransformMatrix.Line1.Column2);
                        aMatrix.set(0, 2, aTransformMatrix.Line1.Column3);
                        aMatrix.set(1, 0, aTransformMatrix.Line2.Column1);
                        aMatrix.set(1, 1, aTransformMatrix.Line2.Column2);
                        aMatrix.set(1, 2, aTransformMatrix.Line2.Column3);
                        aMatrix.set(2, 0, aTransformMatrix.Line3.Column1);
                        aMatrix.set(2, 1, aTransformMatrix.Line3.Column2);
                        aMatrix.set(2, 2, aTransformMatrix.Line3.Column3);

                        basegfx::B2DVector aScale, aTranslate;
                        double fRotate, fShearX;

                        aMatrix.decompose(aScale, aTranslate, fRotate, fShearX);

                        aRect.Width = basegfx::fround(fabs(aScale.getX()));
                        aRect.Height = basegfx::fround(fabs(aScale.getY()));
                    }

                    beans::PropertyValue aProp;
                    aProp.Name = EASGet( EAS_ViewBox );
                    aProp.Value <<= aRect;
                    mrCustomShapeGeometry.push_back( aProp );
                }
                break;
                case EAS_sub_view_size:
                    GetSizeSequence( maPath, rValue, EAS_SubViewSize );
                break;
                case EAS_text_rotate_angle :
                    GetDouble( mrCustomShapeGeometry, rValue, EAS_TextRotateAngle );
                break;
                case EAS_extrusion_allowed :
                    GetBool( maPath, rValue, EAS_ExtrusionAllowed );
                break;
                case EAS_text_path_allowed :
                    GetBool( maPath, rValue, EAS_TextPathAllowed );
                break;
                case EAS_concentric_gradient_fill_allowed :
                    GetBool( maPath, rValue, EAS_ConcentricGradientFillAllowed );
                break;
                case EAS_extrusion :
                    GetBool( maExtrusion, rValue, EAS_Extrusion );
                break;
                case EAS_extrusion_brightness :
                    GetDoublePercentage( maExtrusion, rValue, EAS_Brightness );
                break;
                case EAS_extrusion_depth :
                {
                    sal_Int32 nIndex = 0;
                    com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameterPair;
                    com::sun::star::drawing::EnhancedCustomShapeParameter& rDepth = aParameterPair.First;
                    com::sun::star::drawing::EnhancedCustomShapeParameter& rFraction = aParameterPair.Second;
                    if ( GetNextParameter( rDepth, nIndex, rValue ) )
                    {
                        // try to catch the unit for the depth
                        sal_Int16 const eSrcUnit(
                            ::sax::Converter::GetUnitFromString(
                                rValue, util::MeasureUnit::MM_100TH));

                        OUStringBuffer aUnitStr;
                        double fFactor = ::sax::Converter::GetConversionFactor(
                            aUnitStr, util::MeasureUnit::MM_100TH, eSrcUnit);
                        if ( ( fFactor != 1.0 ) && ( fFactor != 0.0 ) )
                        {
                            double fDepth(0.0);
                            if ( rDepth.Value >>= fDepth )
                            {
                                fDepth /= fFactor;
                                rDepth.Value <<= fDepth;
                            }
                        }
                        if ( rValue.matchIgnoreAsciiCase( aUnitStr.toString(), nIndex ) )
                            nIndex += aUnitStr.getLength();

                        // skipping white spaces
                        while( ( nIndex < rValue.getLength() ) && rValue[ nIndex ] == ' ' )
                            nIndex++;

                        if ( GetNextParameter( rFraction, nIndex, rValue ) )
                        {
                            beans::PropertyValue aProp;
                            aProp.Name = EASGet( EAS_Depth );
                            aProp.Value <<= aParameterPair;
                            maExtrusion.push_back( aProp );
                        }
                    }
                }
                break;
                case EAS_extrusion_diffusion :
                    GetDoublePercentage( maExtrusion, rValue, EAS_Diffusion );
                break;
                case EAS_extrusion_number_of_line_segments :
                    GetInt32( maExtrusion, rValue, EAS_NumberOfLineSegments );
                break;
                case EAS_extrusion_light_face :
                    GetBool( maExtrusion, rValue, EAS_LightFace );
                break;
                case EAS_extrusion_first_light_harsh :
                    GetBool( maExtrusion, rValue, EAS_FirstLightHarsh );
                break;
                case EAS_extrusion_second_light_harsh :
                    GetBool( maExtrusion, rValue, EAS_SecondLightHarsh );
                break;
                case EAS_extrusion_first_light_level :
                    GetDoublePercentage( maExtrusion, rValue, EAS_FirstLightLevel );
                break;
                case EAS_extrusion_second_light_level :
                    GetDoublePercentage( maExtrusion, rValue, EAS_SecondLightLevel );
                break;
                case EAS_extrusion_first_light_direction :
                    GetB3DVector( maExtrusion, rValue, EAS_FirstLightDirection );
                break;
                case EAS_extrusion_second_light_direction :
                    GetB3DVector( maExtrusion, rValue, EAS_SecondLightDirection );
                break;
                case EAS_extrusion_metal :
                    GetBool( maExtrusion, rValue, EAS_Metal );
                break;
                case EAS_shade_mode :
                {
                    drawing::ShadeMode eShadeMode( drawing::ShadeMode_FLAT );
                    if( IsXMLToken( rValue, XML_PHONG ) )
                        eShadeMode = drawing::ShadeMode_PHONG;
                    else if ( IsXMLToken( rValue, XML_GOURAUD ) )
                        eShadeMode = drawing::ShadeMode_SMOOTH;
                    else if ( IsXMLToken( rValue, XML_DRAFT ) )
                        eShadeMode = drawing::ShadeMode_DRAFT;

                    beans::PropertyValue aProp;
                    aProp.Name = EASGet( EAS_ShadeMode );
                    aProp.Value <<= eShadeMode;
                    maExtrusion.push_back( aProp );
                }
                break;
                case EAS_extrusion_rotation_angle :
                    GetEnhancedParameterPair( maExtrusion, rValue, EAS_RotateAngle );
                break;
                case EAS_extrusion_rotation_center :
                    GetB3DVector( maExtrusion, rValue, EAS_RotationCenter );
                break;
                case EAS_extrusion_shininess :
                    GetDoublePercentage( maExtrusion, rValue, EAS_Shininess );
                break;
                case EAS_extrusion_skew :
                    GetEnhancedParameterPair( maExtrusion, rValue, EAS_Skew );
                break;
                case EAS_extrusion_specularity :
                    GetDoublePercentage( maExtrusion, rValue, EAS_Specularity );
                break;
                case EAS_projection :
                {
                    drawing::ProjectionMode eProjectionMode( drawing::ProjectionMode_PERSPECTIVE );
                    if( IsXMLToken( rValue, XML_PARALLEL ) )
                        eProjectionMode = drawing::ProjectionMode_PARALLEL;

                    beans::PropertyValue aProp;
                    aProp.Name = EASGet( EAS_ProjectionMode );
                    aProp.Value <<= eProjectionMode;
                    maExtrusion.push_back( aProp );
                }
                break;
                case EAS_extrusion_viewpoint :
                    GetPosition3D( maExtrusion, rValue, EAS_ViewPoint, mrUnitConverter );
                break;
                case EAS_extrusion_origin :
                    GetEnhancedParameterPair( maExtrusion, rValue, EAS_Origin );
                break;
                case EAS_extrusion_color :
                    GetBool( maExtrusion, rValue, EAS_Color );
                break;
                case EAS_enhanced_path :
                    GetEnhancedPath( maPath, rValue );
                break;
                case EAS_path_stretchpoint_x :
                {
                    if (::sax::Converter::convertNumber(nAttrNumber, rValue))
                    {
                        beans::PropertyValue aProp;
                        aProp.Name = EASGet( EAS_StretchX );
                        aProp.Value <<= nAttrNumber;
                        maPath.push_back( aProp );
                    }
                }
                break;
                case EAS_path_stretchpoint_y :
                {
                    if (::sax::Converter::convertNumber(nAttrNumber, rValue))
                    {
                        beans::PropertyValue aProp;
                        aProp.Name = EASGet( EAS_StretchY );
                        aProp.Value <<= nAttrNumber;
                        maPath.push_back( aProp );
                    }
                }
                break;
                case EAS_text_areas :
                    GetEnhancedRectangleSequence( maPath, rValue, EAS_TextFrames );
                break;
                case EAS_glue_points :
                {
                    sal_Int32 i, nPairs = GetEnhancedParameterPairSequence( maPath, rValue, EAS_GluePoints );
                    GetImport().GetShapeImport()->moveGluePointMapping( mrxShape, nPairs );
                    for ( i = 0; i < nPairs; i++ )
                        GetImport().GetShapeImport()->addGluePointMapping( mrxShape, i + 4, i + 4 );
                }
                break;
                case EAS_glue_point_type :
                    GetEnum( maPath, rValue, EAS_GluePointType, *aXML_GluePointEnumMap );
                break;
                case EAS_glue_point_leaving_directions :
                    GetDoubleSequence( maPath, rValue, EAS_GluePointLeavingDirections );
                break;
                case EAS_text_path :
                    GetBool( maTextPath, rValue, EAS_TextPath );
                break;
                case EAS_text_path_mode :
                {
                    com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode( com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL );
                    if( IsXMLToken( rValue, XML_PATH ) )
                        eTextPathMode = com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH;
                    else if ( IsXMLToken( rValue, XML_SHAPE ) )
                        eTextPathMode = com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE;

                    beans::PropertyValue aProp;
                    aProp.Name = EASGet( EAS_TextPathMode );
                    aProp.Value <<= eTextPathMode;
                    maTextPath.push_back( aProp );
                }
                break;
                case EAS_text_path_scale :
                {
                    bool bScaleX = IsXMLToken( rValue, XML_SHAPE );
                    beans::PropertyValue aProp;
                    aProp.Name = EASGet( EAS_ScaleX );
                    aProp.Value <<= bScaleX;
                    maTextPath.push_back( aProp );
                }
                break;
                case EAS_text_path_same_letter_heights :
                    GetBool( maTextPath, rValue, EAS_SameLetterHeights );
                break;
                case EAS_modifiers :
                    GetAdjustmentValues( mrCustomShapeGeometry, rValue );
                break;
                default:
                    break;
            }
        }
    }
}

void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
                                    const std::vector< beans::PropertyValues >& rElement,
                                        const OUString& rElementName )
{
    if ( !rElement.empty() )
    {
        uno::Sequence< beans::PropertyValues > aPropSeq( rElement.size() );
        std::vector< beans::PropertyValues >::const_iterator aIter = rElement.begin();
        std::vector< beans::PropertyValues >::const_iterator aEnd = rElement.end();
        beans::PropertyValues* pValues = aPropSeq.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        beans::PropertyValue aProp;
        aProp.Name = rElementName;
        aProp.Value <<= aPropSeq;
        rPropVec.push_back( aProp );
    }
}

void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
                                    const std::vector< OUString >& rElement,
                                        const OUString& rElementName )
{
    if ( !rElement.empty() )
    {
        uno::Sequence< OUString > aPropSeq( rElement.size() );
        std::vector< OUString >::const_iterator aIter = rElement.begin();
        std::vector< OUString >::const_iterator aEnd = rElement.end();
        OUString* pValues = aPropSeq.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        beans::PropertyValue aProp;
        aProp.Name = rElementName;
        aProp.Value <<= aPropSeq;
        rPropVec.push_back( aProp );
    }
}

void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
                                    const std::vector< com::sun::star::beans::PropertyValue >& rElement,
                                        const OUString& rElementName )
{
    if ( !rElement.empty() )
    {
        uno::Sequence< beans::PropertyValue > aPropSeq( rElement.size() );
        std::vector< beans::PropertyValue >::const_iterator aIter = rElement.begin();
        std::vector< beans::PropertyValue >::const_iterator aEnd = rElement.end();
        beans::PropertyValue* pValues = aPropSeq.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        beans::PropertyValue aProp;
        aProp.Name = rElementName;
        aProp.Value <<= aPropSeq;
        rPropVec.push_back( aProp );
    }
}

typedef boost::unordered_map< OUString, sal_Int32, OUStringHash, OUStringEqFunc> EquationHashMap;

/* if rPara.Type is from type EnhancedCustomShapeParameterType::EQUATION, the name of the equation
   will be converted from OUString to index */
void CheckAndResolveEquationParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rPara, EquationHashMap* pH )
{
    if ( rPara.Type == com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION )
    {
        OUString aEquationName;
        if ( rPara.Value >>= aEquationName )
        {
            sal_Int32 nIndex = 0;
            EquationHashMap::iterator aHashIter( pH->find( aEquationName ) );
            if ( aHashIter != pH->end() )
                nIndex = (*aHashIter).second;
            rPara.Value <<= nIndex;
        }
    }
}

void XMLEnhancedCustomShapeContext::EndElement()
{
    // resolve properties that are indexing a Equation
    if ( !maEquations.empty() )
    {
        // creating hash map containing the name and index of each equation
        EquationHashMap* pH = new EquationHashMap;
        std::vector< OUString >::iterator aEquationNameIter = maEquationNames.begin();
        std::vector< OUString >::iterator aEquationNameEnd  = maEquationNames.end();
        while( aEquationNameIter != aEquationNameEnd )
        {
            (*pH)[ *aEquationNameIter ] = (sal_Int32)( aEquationNameIter - maEquationNames.begin() );
            ++aEquationNameIter;
        }

        // resolve equation
        std::vector< OUString >::iterator aEquationIter = maEquations.begin();
        std::vector< OUString >::iterator aEquationEnd  = maEquations.end();
        while( aEquationIter != aEquationEnd )
        {
            sal_Int32 nIndexOf = 0;
            do
            {
                nIndexOf = aEquationIter->indexOf( '?', nIndexOf );
                if ( nIndexOf != -1 )
                {
                    OUString aEquationName;
                    if ( GetEquationName( *aEquationIter, nIndexOf + 1, aEquationName ) )
                    {
                        // copying first characters inclusive '?'
                        OUString aNew( aEquationIter->copy( 0, nIndexOf + 1 ) );
                        sal_Int32 nIndex = 0;
                        EquationHashMap::iterator aHashIter( pH->find( aEquationName ) );
                        if ( aHashIter != pH->end() )
                            nIndex = (*aHashIter).second;
                        aNew += OUString::number( nIndex );
                        aNew += aEquationIter->copy( nIndexOf + aEquationName.getLength() + 1 );
                        *aEquationIter = aNew;
                    }
                    nIndexOf++;
                }
            }
            while( nIndexOf != -1 );
            ++aEquationIter;
        }

        // Path
        sal_Int32 i;
        std::vector< beans::PropertyValue >::iterator aPathIter = maPath.begin();
        std::vector< beans::PropertyValue >::iterator aPathEnd  = maPath.end();
        while ( aPathIter != aPathEnd )
        {
            switch( EASGet( aPathIter->Name ) )
            {
                case EAS_Coordinates :
                case EAS_GluePoints :
                {
                    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rSeq =
                        *((uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >*)
                            aPathIter->Value.getValue());
                    for ( i = 0; i < rSeq.getLength(); i++ )
                    {
                        CheckAndResolveEquationParameter( rSeq[ i ].First, pH );
                        CheckAndResolveEquationParameter( rSeq[ i ].Second, pH );
                    }
                }
                break;
                case EAS_TextFrames :
                {
                    uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame >& rSeq =
                        *((uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame >*)
                            aPathIter->Value.getValue());
                    for ( i = 0; i < rSeq.getLength(); i++ )
                    {
                        CheckAndResolveEquationParameter( rSeq[ i ].TopLeft.First, pH );
                        CheckAndResolveEquationParameter( rSeq[ i ].TopLeft.Second, pH );
                        CheckAndResolveEquationParameter( rSeq[ i ].BottomRight.First, pH );
                        CheckAndResolveEquationParameter( rSeq[ i ].BottomRight.Second, pH );
                    }
                }
                break;
                default:
                    break;
            }
            ++aPathIter;
        }
        std::vector< beans::PropertyValues >::iterator aHandleIter = maHandles.begin();
        std::vector< beans::PropertyValues >::iterator aHandleEnd  = maHandles.end();
        while ( aHandleIter != aHandleEnd )
        {
            beans::PropertyValue* pValues = aHandleIter->getArray();
            for ( i = 0; i < aHandleIter->getLength(); i++ )
            {
                switch( EASGet( pValues->Name ) )
                {
                    case EAS_RangeYMinimum :
                    case EAS_RangeYMaximum :
                    case EAS_RangeXMinimum :
                    case EAS_RangeXMaximum :
                    case EAS_RadiusRangeMinimum :
                    case EAS_RadiusRangeMaximum :
                    {
                        CheckAndResolveEquationParameter( *((com::sun::star::drawing::EnhancedCustomShapeParameter*)
                            pValues->Value.getValue()), pH );
                    }
                    break;

                    case EAS_Position :
                    case EAS_Polar :
                    {
                        CheckAndResolveEquationParameter( (*((com::sun::star::drawing::EnhancedCustomShapeParameterPair*)
                            pValues->Value.getValue())).First, pH );
                        CheckAndResolveEquationParameter( (*((com::sun::star::drawing::EnhancedCustomShapeParameterPair*)
                            pValues->Value.getValue())).Second, pH );
                    }
                    break;
                    default:
                        break;
                }
                pValues++;
            }
            ++aHandleIter;
        }
        delete pH;
    }

    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maExtrusion, EASGet( EAS_Extrusion ) );
    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maPath,      EASGet( EAS_Path ) );
    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maTextPath,  EASGet( EAS_TextPath ) );
    SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maEquations, EASGet( EAS_Equations ) );
    if  ( !maHandles.empty() )
        SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maHandles, EASGet( EAS_Handles ) );
}

SvXMLImportContext* XMLEnhancedCustomShapeContext::CreateChildContext( sal_uInt16 nPrefix,const OUString& rLocalName,
                                                                    const uno::Reference< xml::sax::XAttributeList> & xAttrList )
{
    EnhancedCustomShapeTokenEnum aTokenEnum = EASGet( rLocalName );
    if ( aTokenEnum == EAS_equation )
    {
        sal_Int16 nLength = xAttrList->getLength();
        if ( nLength )
        {
            OUString aFormula;
            OUString aFormulaName;
            for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
            {
                OUString aLocalName;
                const OUString& rValue = xAttrList->getValueByIndex( nAttr );
                /* fixme sven, this needs to be chekced! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );

                switch( EASGet( aLocalName ) )
                {
                    case EAS_formula :
                        aFormula = rValue;
                    break;
                    case EAS_name :
                        aFormulaName = rValue;
                    break;
                    default:
                        break;
                }
            }
            if ( !aFormulaName.isEmpty() || !aFormula.isEmpty() )
            {
                maEquations.push_back( aFormula );
                maEquationNames.push_back( aFormulaName );
            }
        }
    }
    else if ( aTokenEnum == EAS_handle )
    {
        std::vector< com::sun::star::beans::PropertyValue > aHandle;
        const sal_Int16 nLength = xAttrList->getLength();
        for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
        {
            OUString aLocalName;
            const OUString& rValue = xAttrList->getValueByIndex( nAttr );
            /* fixme sven, this needs to be chekced! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );
            switch( EASGet( aLocalName ) )
            {
                case EAS_handle_mirror_vertical :
                    GetBool( aHandle, rValue, EAS_MirroredY );
                break;
                case EAS_handle_mirror_horizontal :
                    GetBool( aHandle, rValue, EAS_MirroredX );
                break;
                case EAS_handle_switched :
                    GetBool( aHandle, rValue, EAS_Switched );
                break;
                case EAS_handle_position :
                    GetEnhancedParameterPair( aHandle, rValue, EAS_Position );
                break;
                case EAS_handle_range_x_minimum :
                    GetEnhancedParameter( aHandle, rValue, EAS_RangeXMinimum );
                break;
                case EAS_handle_range_x_maximum :
                    GetEnhancedParameter( aHandle, rValue, EAS_RangeXMaximum );
                break;
                case EAS_handle_range_y_minimum :
                    GetEnhancedParameter( aHandle, rValue, EAS_RangeYMinimum );
                break;
                case EAS_handle_range_y_maximum :
                    GetEnhancedParameter( aHandle, rValue, EAS_RangeYMaximum );
                break;
                case EAS_handle_polar :
                    GetEnhancedParameterPair( aHandle, rValue, EAS_Polar );
                break;
                case EAS_handle_radius_range_minimum :
                    GetEnhancedParameter( aHandle, rValue, EAS_RadiusRangeMinimum );
                break;
                case EAS_handle_radius_range_maximum :
                    GetEnhancedParameter( aHandle, rValue, EAS_RadiusRangeMaximum );
                break;
                default:
                    break;
            }
        }
        beans::PropertyValues aPropSeq( aHandle.size() );
        std::vector< beans::PropertyValue >::const_iterator aIter = aHandle.begin();
        std::vector< beans::PropertyValue >::const_iterator aEnd = aHandle.end();
        beans::PropertyValue* pValues = aPropSeq.getArray();

        while ( aIter != aEnd )
            *pValues++ = *aIter++;

        maHandles.push_back( aPropSeq );
    }
    return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */