/**************************************************************
*
* 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_xmloff.hxx"
#include "ximpcustomshape.hxx"
#include "ximpshap.hxx"
#include "xmlehelp.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 <tools/debug.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 <hash_map>
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 rtl::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 rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
sal_Bool bAttrBool;
if ( SvXMLUnitConverter::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 rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
sal_Int32 nAttrNumber;
if ( SvXMLUnitConverter::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 rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
double fAttrDouble;
if ( SvXMLUnitConverter::convertDouble( fAttrDouble, rValue ) )
{
beans::PropertyValue aProp;
aProp.Name = EASGet( eDestProp );
aProp.Value <<= fAttrDouble;
rDest.push_back( aProp );
}
}
void GetDistance( std::vector< com::sun::star::beans::PropertyValue >& rDest,
const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
double fAttrDouble;
MapUnit eSrcUnit( SvXMLExportHelper::GetUnitFromString( rValue, MAP_100TH_MM ) );
if ( SvXMLUnitConverter::convertDouble( fAttrDouble, rValue, eSrcUnit, MAP_100TH_MM ) )
{
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 rtl::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 rtl::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 rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
MapUnit eSrcUnit = SvXMLExportHelper::GetUnitFromString( rValue, MAP_100TH_MM );
if ( eSrcUnit == MAP_RELATIVE )
{
rtl_math_ConversionStatus eStatus;
double fAttrDouble = ::rtl::math::stringToDouble( rValue,
(sal_Unicode)('.'), (sal_Unicode)(','), &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 rtl::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 );
}
}
sal_Bool GetEquationName( const rtl::OUString& rEquation, const sal_Int32 nStart, rtl::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;
}
sal_Bool bValid = ( nIndex - nStart ) != 0;
if ( bValid )
rEquationName = rEquation.copy( nStart, nIndex - nStart );
return bValid;
}
sal_Bool GetNextParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter, sal_Int32& nIndex, const rtl::OUString& rParaString )
{
if ( nIndex >= rParaString.getLength() )
return sal_False;
sal_Bool bValid = sal_True;
sal_Bool bNumberRequired = sal_True;
sal_Bool bMustBePositiveWholeNumbered = sal_False;
rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL;
if ( rParaString[ nIndex ] == (sal_Unicode)'$' )
{
rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT;
bMustBePositiveWholeNumbered = sal_True;
nIndex++;
}
else if ( rParaString[ nIndex ] == (sal_Unicode)'?' )
{
nIndex++;
bNumberRequired = sal_False;
rtl::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 ] > (sal_Unicode)'9' )
{
bNumberRequired = sal_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 = sal_False;
}
if ( bValid )
{
if ( bNumberRequired )
{
sal_Int32 nStartIndex = nIndex;
sal_Bool bM = sal_False; // set if the value is negative
sal_Bool bE = sal_False; // set if a double is including a "E" statement
sal_Bool bEM = sal_False; // set if a double is including a "E-"statement
sal_Bool bDot = sal_False; // set if there is a dot included
sal_Bool bEnd = sal_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 = sal_False;
else
{
if ( bDot )
bValid = sal_False;
else
bDot = sal_True;
}
}
break;
case '-' :
{
if ( bMustBePositiveWholeNumbered )
bValid = sal_False;
else
{
if ( nStartIndex == nIndex )
bM = sal_True;
else if ( bE )
bEM = sal_True;
else
bValid = sal_False;
}
}
break;
case 'e' :
case 'E' :
{
if ( bMustBePositiveWholeNumbered )
bEnd = sal_True;
else
{
if ( !bE )
bE = sal_True;
else
bEnd = sal_True;
}
}
break;
case '0' :
case '1' :
case '2' :
case '3' :
case '4' :
case '5' :
case '6' :
case '7' :
case '8' :
case '9' :
break;
default:
bEnd = sal_True;
}
if ( !bEnd )
nIndex++;
else
break;
}
if ( nIndex == nStartIndex )
bValid = sal_False;
if ( bValid )
{
rtl::OUString aNumber( rParaString.copy( nStartIndex, nIndex - nStartIndex ) );
if ( bE || bDot )
{
double fAttrDouble;
if ( SvXMLUnitConverter::convertDouble( fAttrDouble, aNumber ) )
rParameter.Value <<= fAttrDouble;
else
bValid = sal_False;
}
else
{
sal_Int32 nValue;
if ( SvXMLUnitConverter::convertNumber( nValue, aNumber ) )
rParameter.Value <<= nValue;
else
bValid = sal_False;
}
}
}
}
if ( bValid )
{
// skipping white spaces and commatas (#121507#)
const sal_Unicode aSpace(sal_Unicode(' '));
const sal_Unicode aCommata(sal_Unicode(','));
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 rtl::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 rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
{
std::vector< double > vDirection;
sal_Int32 nIndex = 0;
do
{
double fAttrDouble;
rtl::OUString aToken( rValue.getToken( 0, ',', nIndex ) );
if ( !SvXMLUnitConverter::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 GetEnhancedParameter( std::vector< com::sun::star::beans::PropertyValue >& rDest, // e.g. draw:handle-position
const rtl::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 rtl::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 rtl::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 rtl::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 rtl::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;
sal_Bool bValid = sal_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 '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 = sal_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 rtl::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++ )
{
rtl::OUString aLocalName;
const rtl::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( aViewBox.GetX(), aViewBox.GetY(), aViewBox.GetWidth(), aViewBox.GetHeight() );
beans::PropertyValue aProp;
aProp.Name = EASGet( EAS_ViewBox );
aProp.Value <<= aRect;
mrCustomShapeGeometry.push_back( aProp );
}
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
MapUnit eSrcUnit( SvXMLExportHelper::GetUnitFromString( rValue, MAP_100TH_MM ) );
rtl::OUStringBuffer aUnitStr;
double fFactor = SvXMLExportHelper::GetConversionFactor( aUnitStr, MAP_100TH_MM, eSrcUnit );
if ( ( fFactor != 1.0 ) && ( fFactor != 0.0 ) )
{
double fDepth;
if ( rDepth.Value >>= fDepth )
{
fDepth /= fFactor;
rDepth.Value <<= fDepth;
}
}
if ( rValue.matchIgnoreAsciiCase( rtl::OUString( aUnitStr ), nIndex ) )
nIndex += aUnitStr.getLength();
// skipping white spaces
while( ( nIndex < rValue.getLength() ) && rValue[ nIndex ] == (sal_Unicode)' ' )
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 ( SvXMLUnitConverter::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 ( SvXMLUnitConverter::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 :
{
sal_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 rtl::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< rtl::OUString >& rElement,
const rtl::OUString& rElementName )
{
if ( !rElement.empty() )
{
uno::Sequence< rtl::OUString > aPropSeq( rElement.size() );
std::vector< rtl::OUString >::const_iterator aIter = rElement.begin();
std::vector< rtl::OUString >::const_iterator aEnd = rElement.end();
rtl::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 rtl::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 std::hash_map< rtl::OUString, sal_Int32, rtl::OUStringHash, OUStringEqFunc> EquationHashMap;
/* if rPara.Type is from type EnhancedCustomShapeParameterType::EQUATION, the name of the equation
will be converted from rtl::OUString to index */
void CheckAndResolveEquationParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rPara, EquationHashMap* pH )
{
if ( rPara.Type == com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION )
{
rtl::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< rtl::OUString >::iterator aEquationNameIter = maEquationNames.begin();
std::vector< rtl::OUString >::iterator aEquationNameEnd = maEquationNames.end();
while( aEquationNameIter != aEquationNameEnd )
{
(*pH)[ *aEquationNameIter ] = (sal_Int32)( aEquationNameIter - maEquationNames.begin() );
aEquationNameIter++;
}
// resolve equation
std::vector< rtl::OUString >::iterator aEquationIter = maEquations.begin();
std::vector< rtl::OUString >::iterator aEquationEnd = maEquations.end();
while( aEquationIter != aEquationEnd )
{
sal_Int32 nIndexOf = 0;
do
{
nIndexOf = aEquationIter->indexOf( '?', nIndexOf );
if ( nIndexOf != -1 )
{
rtl::OUString aEquationName;
if ( GetEquationName( *aEquationIter, nIndexOf + 1, aEquationName ) )
{
// copying first characters inclusive '?'
rtl::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 += rtl::OUString::valueOf( 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 rtl::OUString& rLocalName,
const uno::Reference< xml::sax::XAttributeList> & xAttrList )
{
EnhancedCustomShapeTokenEnum aTokenEnum = EASGet( rLocalName );
if ( aTokenEnum == EAS_equation )
{
sal_Int16 nLength = xAttrList->getLength();
if ( nLength )
{
rtl::OUString aFormula;
rtl::OUString aFormulaName;
for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
{
rtl::OUString aLocalName;
const rtl::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.getLength() || aFormula.getLength() )
{
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++ )
{
rtl::OUString aLocalName;
const rtl::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 );
}