xmloff/source/draw/ximpcustomshape.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include "ximpcustomshape.hxx"
  30 #include "ximpshap.hxx"
  31 #include <rtl/math.hxx>
  32 #include <rtl/ustrbuf.hxx>
  33 #include <rtl/ustring.hxx>
  34 #include <com/sun/star/uno/Reference.h>
  35 #include <com/sun/star/beans/XPropertySet.hpp>
  36 #include <com/sun/star/xml/sax/XAttributeList.hpp>
  37 #include <com/sun/star/container/XIndexContainer.hpp>
  38 #include <xmloff/xmltoken.hxx>
  39 #include "EnhancedCustomShapeToken.hxx"
  40 #include <xmloff/xmlimp.hxx>
  41 #include <xmloff/xmltkmap.hxx>
  42 #include "xmloff/xmlnmspe.hxx"
  43 #include <xmloff/nmspmap.hxx>
  44 #include <xmloff/xmluconv.hxx>
  45 #include "xexptran.hxx"
  46 #include "xmloff/xmlerror.hxx"
  47 #include <com/sun/star/drawing/Direction3D.hpp>
  48 #include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
  49 #include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
  50 #include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
  51 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
  52 #include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
  53 #include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
  54 #include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
  55 #include <com/sun/star/drawing/ProjectionMode.hpp>
  56 #include <boost/unordered_map.hpp>
  57 #include <sax/tools/converter.hxx>
  58
  59 using namespace ::com::sun::star;
  60 using namespace ::xmloff::token;
  61 using namespace ::xmloff::EnhancedCustomShapeToken;
  62
  63 TYPEINIT1( XMLEnhancedCustomShapeContext, SvXMLImportContext );
  64
  65 XMLEnhancedCustomShapeContext::XMLEnhancedCustomShapeContext( SvXMLImport& rImport,
  66             ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& rxShape,
  67                 sal_uInt16 nPrefix, const rtl::OUString& rLocalName,
  68                     std::vector< com::sun::star::beans::PropertyValue >& rCustomShapeGeometry ) :
  69         SvXMLImportContext( rImport, nPrefix, rLocalName ),
  70         mrUnitConverter( rImport.GetMM100UnitConverter() ),
  71         mrxShape( rxShape ),
  72         mrCustomShapeGeometry( rCustomShapeGeometry )
  73 {
  74 }
  75
  76 const SvXMLEnumMapEntry aXML_GluePointEnumMap[] =
  77 {
  78     { XML_NONE,         0 },
  79     { XML_SEGMENTS,     1 },
  80     { XML_NONE,         2 },
  81     { XML_RECTANGLE,    3 },
  82     { XML_TOKEN_INVALID, 0 }
  83 };
  84 void GetBool( std::vector< com::sun::star::beans::PropertyValue >& rDest,
  85                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
  86 {
  87     bool bAttrBool;
  88     if (::sax::Converter::convertBool( bAttrBool, rValue ))
  89     {
  90         beans::PropertyValue aProp;
  91         aProp.Name = EASGet( eDestProp );
  92         aProp.Value <<= bAttrBool;
  93         rDest.push_back( aProp );
  94     }
  95 }
  96
  97 void GetInt32( std::vector< com::sun::star::beans::PropertyValue >& rDest,
  98                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
  99 {
 100     sal_Int32 nAttrNumber;
 101     if (::sax::Converter::convertNumber( nAttrNumber, rValue ))
 102     {
 103         beans::PropertyValue aProp;
 104         aProp.Name = EASGet( eDestProp );
 105         aProp.Value <<= nAttrNumber;
 106         rDest.push_back( aProp );
 107     }
 108 }
 109
 110 void GetDouble( std::vector< com::sun::star::beans::PropertyValue >& rDest,
 111                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 112 {
 113     double fAttrDouble;
 114     if (::sax::Converter::convertDouble( fAttrDouble, rValue ))
 115     {
 116         beans::PropertyValue aProp;
 117         aProp.Name = EASGet( eDestProp );
 118         aProp.Value <<= fAttrDouble;
 119         rDest.push_back( aProp );
 120     }
 121 }
 122
 123 void GetDistance( std::vector< com::sun::star::beans::PropertyValue >& rDest,
 124                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 125 {
 126     double fAttrDouble;
 127     sal_Int16 const eSrcUnit( ::sax::Converter::GetUnitFromString(
 128                 rValue, util::MeasureUnit::MM_100TH) );
 129     if (::sax::Converter::convertDouble(fAttrDouble, rValue, eSrcUnit,
 130                 util::MeasureUnit::MM_100TH))
 131     {
 132         beans::PropertyValue aProp;
 133         aProp.Name = EASGet( eDestProp );
 134         aProp.Value <<= fAttrDouble;
 135         rDest.push_back( aProp );
 136     }
 137 }
 138
 139 void GetString( std::vector< com::sun::star::beans::PropertyValue >& rDest,
 140                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 141 {
 142     beans::PropertyValue aProp;
 143     aProp.Name = EASGet( eDestProp );
 144     aProp.Value <<= rValue;
 145     rDest.push_back( aProp );
 146 }
 147
 148 void GetEnum( std::vector< com::sun::star::beans::PropertyValue >& rDest,
 149                          const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp,
 150                         const SvXMLEnumMapEntry& rMap )
 151 {
 152     sal_uInt16 eKind;
 153     if( SvXMLUnitConverter::convertEnum( eKind, rValue, &rMap ) )
 154     {
 155         sal_Int16 nEnum = (sal_Int16)eKind;
 156         beans::PropertyValue aProp;
 157         aProp.Name = EASGet( eDestProp );
 158         aProp.Value <<= nEnum;
 159         rDest.push_back( aProp );
 160     }
 161 }
 162
 163 void GetDoublePercentage( std::vector< com::sun::star::beans::PropertyValue >& rDest,
 164                          const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 165 {
 166     sal_Int16 const eSrcUnit = ::sax::Converter::GetUnitFromString(
 167             rValue, util::MeasureUnit::MM_100TH);
 168     if (util::MeasureUnit::PERCENT == eSrcUnit)
 169     {
 170         rtl_math_ConversionStatus eStatus;
 171         double fAttrDouble = ::rtl::math::stringToDouble( rValue,
 172             (sal_Unicode)('.'), (sal_Unicode)(','), &eStatus, NULL );
 173         if ( eStatus == rtl_math_ConversionStatus_Ok )
 174         {
 175             beans::PropertyValue aProp;
 176             aProp.Name = EASGet( eDestProp );
 177             aProp.Value <<= fAttrDouble;
 178             rDest.push_back( aProp );
 179         }
 180     }
 181 }
 182
 183 void GetB3DVector( std::vector< com::sun::star::beans::PropertyValue >& rDest,
 184                          const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 185 {
 186     ::basegfx::B3DVector aB3DVector;
 187     if ( SvXMLUnitConverter::convertB3DVector( aB3DVector, rValue ) )
 188     {
 189         drawing::Direction3D aDirection3D( aB3DVector.getX(), aB3DVector.getY(), aB3DVector.getZ() );
 190         beans::PropertyValue aProp;
 191         aProp.Name = EASGet( eDestProp );
 192         aProp.Value <<= aDirection3D;
 193         rDest.push_back( aProp );
 194     }
 195 }
 196
 197 sal_Bool GetEquationName( const rtl::OUString& rEquation, const sal_Int32 nStart, rtl::OUString& rEquationName )
 198 {
 199     sal_Int32 nIndex = nStart;
 200     while( nIndex < rEquation.getLength() )
 201     {
 202         sal_Unicode nChar = rEquation[ nIndex ];
 203         if (
 204             ( ( nChar >= 'a' ) && ( nChar <= 'z' ) )
 205             || ( ( nChar >= 'A' ) && ( nChar <= 'Z' ) )
 206             || ( ( nChar >= '0' ) && ( nChar <= '9' ) )
 207             )
 208         {
 209             nIndex++;
 210         }
 211         else
 212             break;
 213     }
 214     sal_Bool bValid = ( nIndex - nStart ) != 0;
 215     if ( bValid )
 216         rEquationName = rEquation.copy( nStart, nIndex - nStart );
 217     return bValid;
 218 }
 219
 220 sal_Bool GetNextParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter, sal_Int32& nIndex, const rtl::OUString& rParaString )
 221 {
 222     if ( nIndex >= rParaString.getLength() )
 223         return sal_False;
 224
 225     sal_Bool bValid = sal_True;
 226     sal_Bool bNumberRequired = sal_True;
 227     sal_Bool bMustBePositiveWholeNumbered = sal_False;
 228
 229     rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL;
 230     if ( rParaString[ nIndex ] == (sal_Unicode)'$' )
 231     {
 232         rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT;
 233         bMustBePositiveWholeNumbered = sal_True;
 234         nIndex++;
 235     }
 236     else if ( rParaString[ nIndex ] == (sal_Unicode)'?' )
 237     {
 238         nIndex++;
 239         bNumberRequired = sal_False;
 240         rtl::OUString aEquationName;
 241         bValid = GetEquationName( rParaString, nIndex, aEquationName );
 242         if ( bValid )
 243         {
 244             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION;
 245             rParameter.Value <<= aEquationName;
 246             nIndex += aEquationName.getLength();
 247         }
 248     }
 249     else if ( rParaString[ nIndex ] > (sal_Unicode)'9' )
 250     {
 251         bNumberRequired = sal_False;
 252         if ( rParaString.matchIgnoreAsciiCaseAsciiL( "left", 4, nIndex ) )
 253         {
 254             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT;
 255             nIndex += 4;
 256         }
 257         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "top", 3, nIndex ) )
 258         {
 259             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP;
 260             nIndex += 3;
 261         }
 262         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "right", 5, nIndex ) )
 263         {
 264             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT;
 265             nIndex += 5;
 266         }
 267         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "bottom", 6, nIndex ) )
 268         {
 269             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM;
 270             nIndex += 6;
 271         }
 272         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "xstretch", 8, nIndex ) )
 273         {
 274             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH;
 275             nIndex += 8;
 276         }
 277         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "ystretch", 8, nIndex ) )
 278         {
 279             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH;
 280             nIndex += 8;
 281         }
 282         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "hasstroke", 9, nIndex ) )
 283         {
 284             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE;
 285             nIndex += 9;
 286         }
 287         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "hasfill", 7, nIndex ) )
 288         {
 289             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL;
 290             nIndex += 7;
 291         }
 292         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "width", 5, nIndex ) )
 293         {
 294             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH;
 295             nIndex += 5;
 296         }
 297         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "height", 6, nIndex ) )
 298         {
 299             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT;
 300             nIndex += 6;
 301         }
 302         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "logwidth", 8, nIndex ) )
 303         {
 304             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH;
 305             nIndex += 8;
 306         }
 307         else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "logheight", 9, nIndex ) )
 308         {
 309             rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT;
 310             nIndex += 9;
 311         }
 312         else
 313             bValid = sal_False;
 314     }
 315     if ( bValid )
 316     {
 317         if ( bNumberRequired )
 318         {
 319             sal_Int32 nStartIndex = nIndex;
 320             sal_Int32 nEIndex = 0;  // index of "E" in double
 321
 322             sal_Bool bE = sal_False;    // set if a double is including a "E" statement
 323             sal_Bool bENum = sal_False; // there is at least one number after "E"
 324             sal_Bool bDot = sal_False;  // set if there is a dot included
 325             sal_Bool bEnd = sal_False;  // set for each value that can not be part of a double/integer
 326
 327             while( ( nIndex < rParaString.getLength() ) && bValid )
 328             {
 329                 switch( rParaString[ nIndex ] )
 330                 {
 331                     case '.' :
 332                     {
 333                         if ( bMustBePositiveWholeNumbered )
 334                             bValid = sal_False;
 335                         else
 336                         {
 337                             if ( bDot )
 338                                 bValid = sal_False;
 339                             else
 340                                 bDot = sal_True;
 341                         }
 342                     }
 343                     break;
 344                     case '-' :
 345                     {
 346                         if ( bMustBePositiveWholeNumbered )
 347                             bValid = sal_False;
 348                         else
 349                         {
 350                             if ( nStartIndex == nIndex )
 351                                bValid = sal_True;
 352                             else if ( bE )
 353                             {
 354                                 if ( nEIndex + 1 == nIndex )
 355                                     bValid = sal_True;
 356                                 else if ( bENum )
 357                                     bEnd = sal_True;
 358                                 else
 359                                     bValid = sal_False;
 360                             }
 361                         }
 362                     }
 363                     break;
 364
 365                     case 'e' :
 366                     case 'E' :
 367                     {
 368                         if ( bMustBePositiveWholeNumbered )
 369                             bEnd = sal_True;
 370                         else
 371                         {
 372                             if ( !bE )
 373                             {
 374                                 bE = sal_True;
 375                                 nEIndex = nIndex;
 376                             }
 377                             else
 378                                 bEnd = sal_True;
 379                         }
 380                     }
 381                     break;
 382                     case '0' :
 383                     case '1' :
 384                     case '2' :
 385                     case '3' :
 386                     case '4' :
 387                     case '5' :
 388                     case '6' :
 389                     case '7' :
 390                     case '8' :
 391                     case '9' :
 392                     {
 393                         if ( bE && ! bENum )
 394                             bENum = sal_True;
 395                     }
 396                     break;
 397                     default:
 398                         bEnd = sal_True;
 399                 }
 400                 if ( !bEnd )
 401                     nIndex++;
 402                 else
 403                     break;
 404             }
 405             if ( nIndex == nStartIndex )
 406                 bValid = sal_False;
 407             if ( bValid )
 408             {
 409                 rtl::OUString aNumber( rParaString.copy( nStartIndex, nIndex - nStartIndex ) );
 410                 if ( bE || bDot )
 411                 {
 412                     double fAttrDouble;
 413                     if (::sax::Converter::convertDouble(fAttrDouble, aNumber))
 414                         rParameter.Value <<= fAttrDouble;
 415                     else
 416                         bValid = sal_False;
 417                 }
 418                 else
 419                 {
 420                     sal_Int32 nValue;
 421                     if (::sax::Converter::convertNumber(nValue, aNumber))
 422                         rParameter.Value <<= nValue;
 423                     else
 424                         bValid = sal_False;
 425                 }
 426             }
 427         }
 428     }
 429     if ( bValid )
 430     {   // skipping white spaces
 431         while( ( nIndex < rParaString.getLength() ) && rParaString[ nIndex ] == (sal_Unicode)' ' )
 432             nIndex++;
 433     }
 434     return bValid;
 435 }
 436
 437 void GetPosition3D( std::vector< com::sun::star::beans::PropertyValue >& rDest,                     // e.g. draw:extrusion-viewpoint
 438                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp,
 439                         SvXMLUnitConverter& rUnitConverter )
 440 {
 441     drawing::Position3D aPosition3D;
 442     if ( rUnitConverter.convertPosition3D( aPosition3D, rValue ) )
 443     {
 444         beans::PropertyValue aProp;
 445         aProp.Name = EASGet( eDestProp );
 446         aProp.Value <<= aPosition3D;
 447         rDest.push_back( aProp );
 448     }
 449 }
 450
 451 void GetDoubleSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,                 // e.g. draw:glue-point-leaving-directions
 452                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 453 {
 454     std::vector< double > vDirection;
 455     sal_Int32 nIndex = 0;
 456     do
 457     {
 458         double fAttrDouble;
 459         rtl::OUString aToken( rValue.getToken( 0, ',', nIndex ) );
 460         if (!::sax::Converter::convertDouble( fAttrDouble, aToken ))
 461             break;
 462         else
 463             vDirection.push_back( fAttrDouble );
 464     }
 465     while ( nIndex >= 0 );
 466
 467     if ( !vDirection.empty() )
 468     {
 469         uno::Sequence< double > aDirectionsSeq( vDirection.size() );
 470         std::vector< double >::const_iterator aIter = vDirection.begin();
 471         std::vector< double >::const_iterator aEnd = vDirection.end();
 472         double* pValues = aDirectionsSeq.getArray();
 473
 474         while ( aIter != aEnd )
 475             *pValues++ = *aIter++;
 476
 477         beans::PropertyValue aProp;
 478         aProp.Name = EASGet( eDestProp );
 479         aProp.Value <<= aDirectionsSeq;
 480         rDest.push_back( aProp );
 481     }
 482 }
 483
 484 void GetEnhancedParameter( std::vector< com::sun::star::beans::PropertyValue >& rDest,              // e.g. draw:handle-position
 485                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 486 {
 487     sal_Int32 nIndex = 0;
 488     com::sun::star::drawing::EnhancedCustomShapeParameter aParameter;
 489     if ( GetNextParameter( aParameter, nIndex, rValue ) )
 490     {
 491         beans::PropertyValue aProp;
 492         aProp.Name = EASGet( eDestProp );
 493         aProp.Value <<= aParameter;
 494         rDest.push_back( aProp );
 495     }
 496 }
 497
 498 void GetEnhancedParameterPair( std::vector< com::sun::star::beans::PropertyValue >& rDest,          // e.g. draw:handle-position
 499                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 500 {
 501     sal_Int32 nIndex = 0;
 502     com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameterPair;
 503     if ( GetNextParameter( aParameterPair.First, nIndex, rValue )
 504         && GetNextParameter( aParameterPair.Second, nIndex, rValue ) )
 505     {
 506         beans::PropertyValue aProp;
 507         aProp.Name = EASGet( eDestProp );
 508         aProp.Value <<= aParameterPair;
 509         rDest.push_back( aProp );
 510     }
 511 }
 512
 513 sal_Int32 GetEnhancedParameterPairSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,     // e.g. draw:glue-points
 514                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 515 {
 516     std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair > vParameter;
 517     com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameter;
 518
 519     sal_Int32 nIndex = 0;
 520     while ( GetNextParameter( aParameter.First, nIndex, rValue )
 521             && GetNextParameter( aParameter.Second, nIndex, rValue ) )
 522     {
 523         vParameter.push_back( aParameter );
 524     }
 525     if ( !vParameter.empty() )
 526     {
 527         uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aParameterSeq( vParameter.size() );
 528         std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aIter = vParameter.begin();
 529         std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aEnd = vParameter.end();
 530         com::sun::star::drawing::EnhancedCustomShapeParameterPair* pValues = aParameterSeq.getArray();
 531
 532         while ( aIter != aEnd )
 533             *pValues++ = *aIter++;
 534
 535         beans::PropertyValue aProp;
 536         aProp.Name = EASGet( eDestProp );
 537         aProp.Value <<= aParameterSeq;
 538         rDest.push_back( aProp );
 539     }
 540     return vParameter.size();
 541 }
 542
 543 void GetEnhancedRectangleSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,      // e.g. draw:text-areas
 544                         const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
 545 {
 546     std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame > vTextFrame;
 547     com::sun::star::drawing::EnhancedCustomShapeTextFrame aParameter;
 548
 549     sal_Int32 nIndex = 0;
 550
 551     while ( GetNextParameter( aParameter.TopLeft.First, nIndex, rValue )
 552             && GetNextParameter( aParameter.TopLeft.Second, nIndex, rValue )
 553             && GetNextParameter( aParameter.BottomRight.First, nIndex, rValue )
 554             && GetNextParameter( aParameter.BottomRight.Second, nIndex, rValue ) )
 555     {
 556         vTextFrame.push_back( aParameter );
 557     }
 558     if ( !vTextFrame.empty() )
 559     {
 560         uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aTextFrameSeq( vTextFrame.size() );
 561         std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame >::const_iterator aIter = vTextFrame.begin();
 562         std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame >::const_iterator aEnd = vTextFrame.end();
 563         com::sun::star::drawing::EnhancedCustomShapeTextFrame* pValues = aTextFrameSeq.getArray();
 564
 565         while ( aIter != aEnd )
 566             *pValues++ = *aIter++;
 567
 568         beans::PropertyValue aProp;
 569         aProp.Name = EASGet( eDestProp );
 570         aProp.Value <<= aTextFrameSeq;
 571         rDest.push_back( aProp );
 572     }
 573 }
 574
 575 void GetEnhancedPath( std::vector< com::sun::star::beans::PropertyValue >& rDest,                   // e.g. draw:enhanced-path
 576                         const rtl::OUString& rValue )
 577 {
 578     std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >    vCoordinates;
 579     std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >      vSegments;
 580
 581     sal_Int32 nIndex = 0;
 582     sal_Int32 nParameterCount = 0;
 583
 584     sal_Int32 nParametersNeeded = 1;
 585     sal_Int16 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
 586
 587     sal_Bool bValid = sal_True;
 588
 589     while( bValid && ( nIndex < rValue.getLength() ) )
 590     {
 591         switch( rValue[ nIndex ] )
 592         {
 593             case 'M' :
 594             {
 595                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
 596                 nParametersNeeded = 1;
 597                 nIndex++;
 598             }
 599             break;
 600             case 'L' :
 601             {
 602                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
 603                 nParametersNeeded = 1;
 604                 nIndex++;
 605             }
 606             break;
 607             case 'C' :
 608             {
 609                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO;
 610                 nParametersNeeded = 3;
 611                 nIndex++;
 612             }
 613             break;
 614             case 'Z' :
 615             {
 616                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
 617                 nParametersNeeded = 0;
 618                 nIndex++;
 619             }
 620             break;
 621             case 'N' :
 622             {
 623                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
 624                 nParametersNeeded = 0;
 625                 nIndex++;
 626             }
 627             break;
 628             case 'F' :
 629             {
 630                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL;
 631                 nParametersNeeded = 0;
 632                 nIndex++;
 633             }
 634             break;
 635             case 'S' :
 636             {
 637                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE;
 638                 nParametersNeeded = 0;
 639                 nIndex++;
 640             }
 641             break;
 642             case 'T' :
 643             {
 644                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO;
 645                 nParametersNeeded = 3;
 646                 nIndex++;
 647             }
 648             break;
 649             case 'U' :
 650             {
 651                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE;
 652                 nParametersNeeded = 3;
 653                 nIndex++;
 654             }
 655             break;
 656             case 'A' :
 657             {
 658                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO;
 659                 nParametersNeeded = 4;
 660                 nIndex++;
 661             }
 662             break;
 663             case 'B' :
 664             {
 665                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC;
 666                 nParametersNeeded = 4;
 667                 nIndex++;
 668             }
 669             break;
 670             case 'G' :
 671             {
 672                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO;
 673                 nParametersNeeded = 2;
 674                 nIndex++;
 675             }
 676             break;
 677             case 'W' :
 678             {
 679                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO;
 680                 nParametersNeeded = 4;
 681                 nIndex++;
 682             }
 683             break;
 684             case 'V' :
 685             {
 686                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC;
 687                 nParametersNeeded = 4;
 688                 nIndex++;
 689             }
 690             break;
 691             case 'X' :
 692             {
 693                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX;
 694                 nParametersNeeded = 1;
 695                 nIndex++;
 696             }
 697             break;
 698             case 'Y' :
 699             {
 700                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY;
 701                 nParametersNeeded = 1;
 702                 nIndex++;
 703             }
 704             break;
 705             case 'Q' :
 706             {
 707                 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO;
 708                 nParametersNeeded = 2;
 709                 nIndex++;
 710             }
 711             break;
 712             case ' ' :
 713             {
 714                 nIndex++;
 715             }
 716             break;
 717
 718             case '$' :
 719             case '?' :
 720             case '0' :
 721             case '1' :
 722             case '2' :
 723             case '3' :
 724             case '4' :
 725             case '5' :
 726             case '6' :
 727             case '7' :
 728             case '8' :
 729             case '9' :
 730             case '.' :
 731             case '-' :
 732             {
 733                 com::sun::star::drawing::EnhancedCustomShapeParameterPair aPair;
 734                 if ( GetNextParameter( aPair.First, nIndex, rValue ) &&
 735                         GetNextParameter( aPair.Second, nIndex, rValue ) )
 736                 {
 737                     vCoordinates.push_back( aPair );
 738                     nParameterCount++;
 739                 }
 740                 else
 741                     bValid = sal_False;
 742             }
 743             break;
 744             default:
 745                 nIndex++;
 746             break;
 747         }
 748         if ( !nParameterCount && !nParametersNeeded )
 749         {
 750             com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
 751             aSegment.Command = nLatestSegmentCommand;
 752             aSegment.Count = 0;
 753             vSegments.push_back( aSegment );
 754             nParametersNeeded = 0x7fffffff;
 755         }
 756         else if ( nParameterCount >= nParametersNeeded )
 757         {
 758             // check if the last command is identical,
 759             // if so, we just need to increment the count
 760             if ( !vSegments.empty() && ( vSegments[ vSegments.size() - 1 ].Command == nLatestSegmentCommand ) )
 761                 vSegments[ vSegments.size() -1 ].Count++;
 762             else
 763             {
 764                 com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
 765                 aSegment.Command = nLatestSegmentCommand;
 766                 aSegment.Count = 1;
 767                 vSegments.push_back( aSegment );
 768             }
 769             nParameterCount = 0;
 770         }
 771     }
 772     // adding the Coordinates property
 773     uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > seqCoordinates( vCoordinates.size() );
 774     std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aCoordinatesIter = vCoordinates.begin();
 775     std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aCoordinatesEnd = vCoordinates.end();
 776     com::sun::star::drawing::EnhancedCustomShapeParameterPair* pCoordinateValues = seqCoordinates.getArray();
 777
 778     while ( aCoordinatesIter != aCoordinatesEnd )
 779         *pCoordinateValues++ = *aCoordinatesIter++;
 780
 781     beans::PropertyValue aProp;
 782     aProp.Name = EASGet( EAS_Coordinates );
 783     aProp.Value <<= seqCoordinates;
 784     rDest.push_back( aProp );
 785
 786
 787     // adding the Segments property
 788     uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > seqSegments( vSegments.size() );
 789     std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >::const_iterator aSegmentsIter = vSegments.begin();
 790     std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >::const_iterator aSegmentsEnd = vSegments.end();
 791     com::sun::star::drawing::EnhancedCustomShapeSegment* pSegmentValues = seqSegments.getArray();
 792
 793     while ( aSegmentsIter != aSegmentsEnd )
 794         *pSegmentValues++ = *aSegmentsIter++;
 795
 796     aProp.Name = EASGet( EAS_Segments );
 797     aProp.Value <<= seqSegments;
 798     rDest.push_back( aProp );
 799 }
 800
 801 void GetAdjustmentValues( std::vector< com::sun::star::beans::PropertyValue >& rDest,               // draw:adjustments
 802                         const rtl::OUString& rValue )
 803 {
 804     std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > vAdjustmentValue;
 805     com::sun::star::drawing::EnhancedCustomShapeParameter aParameter;
 806     sal_Int32 nIndex = 0;
 807     while ( GetNextParameter( aParameter, nIndex, rValue ) )
 808     {
 809         com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue aAdj;
 810         if ( aParameter.Type == com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL )
 811         {
 812             aAdj.Value <<= aParameter.Value;
 813             aAdj.State = beans::PropertyState_DIRECT_VALUE;
 814         }
 815         else
 816             aAdj.State = beans::PropertyState_DEFAULT_VALUE;    // this should not be, but better than setting nothing
 817
 818         vAdjustmentValue.push_back( aAdj );
 819     }
 820
 821     sal_Int32 nAdjustmentValues = vAdjustmentValue.size();
 822     if ( nAdjustmentValues )
 823     {
 824         uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues( nAdjustmentValues );
 825         std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue >::const_iterator aIter = vAdjustmentValue.begin();
 826         std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue >::const_iterator aEnd = vAdjustmentValue.end();
 827         com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue* pValues = aAdjustmentValues.getArray();
 828
 829         while ( aIter != aEnd )
 830             *pValues++ = *aIter++;
 831
 832         beans::PropertyValue aProp;
 833         aProp.Name = EASGet( EAS_AdjustmentValues );
 834         aProp.Value <<= aAdjustmentValues;
 835         rDest.push_back( aProp );
 836     }
 837 }
 838
 839 void XMLEnhancedCustomShapeContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
 840 {
 841     sal_Int16 nLength = xAttrList->getLength();
 842     if ( nLength )
 843     {
 844         sal_Int32               nAttrNumber;
 845         for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
 846         {
 847             rtl::OUString aLocalName;
 848             const rtl::OUString& rValue = xAttrList->getValueByIndex( nAttr );
 849             /* sven fixme, this must be checked! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );
 850
 851             switch( EASGet( aLocalName ) )
 852             {
 853                 case EAS_type :
 854                     GetString( mrCustomShapeGeometry, rValue, EAS_Type );
 855                 break;
 856                 case EAS_mirror_horizontal :
 857                     GetBool( mrCustomShapeGeometry, rValue, EAS_MirroredX );
 858                 break;
 859                 case EAS_mirror_vertical :
 860                     GetBool( mrCustomShapeGeometry, rValue, EAS_MirroredY );
 861                 break;
 862                 case EAS_viewBox :
 863                 {
 864                     SdXMLImExViewBox aViewBox( rValue, GetImport().GetMM100UnitConverter() );
 865                     awt::Rectangle aRect( aViewBox.GetX(), aViewBox.GetY(), aViewBox.GetWidth(), aViewBox.GetHeight() );
 866                     beans::PropertyValue aProp;
 867                     aProp.Name = EASGet( EAS_ViewBox );
 868                     aProp.Value <<= aRect;
 869                     mrCustomShapeGeometry.push_back( aProp );
 870                 }
 871                 break;
 872                 case EAS_text_rotate_angle :
 873                     GetDouble( mrCustomShapeGeometry, rValue, EAS_TextRotateAngle );
 874                 break;
 875                 case EAS_extrusion_allowed :
 876                     GetBool( maPath, rValue, EAS_ExtrusionAllowed );
 877                 break;
 878                 case EAS_text_path_allowed :
 879                     GetBool( maPath, rValue, EAS_TextPathAllowed );
 880                 break;
 881                 case EAS_concentric_gradient_fill_allowed :
 882                     GetBool( maPath, rValue, EAS_ConcentricGradientFillAllowed );
 883                 break;
 884                 case EAS_extrusion :
 885                     GetBool( maExtrusion, rValue, EAS_Extrusion );
 886                 break;
 887                 case EAS_extrusion_brightness :
 888                     GetDoublePercentage( maExtrusion, rValue, EAS_Brightness );
 889                 break;
 890                 case EAS_extrusion_depth :
 891                 {
 892                     sal_Int32 nIndex = 0;
 893                     com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameterPair;
 894                     com::sun::star::drawing::EnhancedCustomShapeParameter& rDepth = aParameterPair.First;
 895                     com::sun::star::drawing::EnhancedCustomShapeParameter& rFraction = aParameterPair.Second;
 896                     if ( GetNextParameter( rDepth, nIndex, rValue ) )
 897                     {
 898                         // try to catch the unit for the depth
 899                         sal_Int16 const eSrcUnit(
 900                             ::sax::Converter::GetUnitFromString(
 901                                 rValue, util::MeasureUnit::MM_100TH));
 902
 903                         rtl::OUStringBuffer aUnitStr;
 904                         double fFactor = ::sax::Converter::GetConversionFactor(
 905                             aUnitStr, util::MeasureUnit::MM_100TH, eSrcUnit);
 906                         if ( ( fFactor != 1.0 ) && ( fFactor != 0.0 ) )
 907                         {
 908                             double fDepth(0.0);
 909                             if ( rDepth.Value >>= fDepth )
 910                             {
 911                                 fDepth /= fFactor;
 912                                 rDepth.Value <<= fDepth;
 913                             }
 914                         }
 915                         if ( rValue.matchIgnoreAsciiCase( aUnitStr.toString(), nIndex ) )
 916                             nIndex += aUnitStr.getLength();
 917
 918                         // skipping white spaces
 919                         while( ( nIndex < rValue.getLength() ) && rValue[ nIndex ] == (sal_Unicode)' ' )
 920                             nIndex++;
 921
 922                         if ( GetNextParameter( rFraction, nIndex, rValue ) )
 923                         {
 924                             beans::PropertyValue aProp;
 925                             aProp.Name = EASGet( EAS_Depth );
 926                             aProp.Value <<= aParameterPair;
 927                             maExtrusion.push_back( aProp );
 928                         }
 929                     }
 930                 }
 931                 break;
 932                 case EAS_extrusion_diffusion :
 933                     GetDoublePercentage( maExtrusion, rValue, EAS_Diffusion );
 934                 break;
 935                 case EAS_extrusion_number_of_line_segments :
 936                     GetInt32( maExtrusion, rValue, EAS_NumberOfLineSegments );
 937                 break;
 938                 case EAS_extrusion_light_face :
 939                     GetBool( maExtrusion, rValue, EAS_LightFace );
 940                 break;
 941                 case EAS_extrusion_first_light_harsh :
 942                     GetBool( maExtrusion, rValue, EAS_FirstLightHarsh );
 943                 break;
 944                 case EAS_extrusion_second_light_harsh :
 945                     GetBool( maExtrusion, rValue, EAS_SecondLightHarsh );
 946                 break;
 947                 case EAS_extrusion_first_light_level :
 948                     GetDoublePercentage( maExtrusion, rValue, EAS_FirstLightLevel );
 949                 break;
 950                 case EAS_extrusion_second_light_level :
 951                     GetDoublePercentage( maExtrusion, rValue, EAS_SecondLightLevel );
 952                 break;
 953                 case EAS_extrusion_first_light_direction :
 954                     GetB3DVector( maExtrusion, rValue, EAS_FirstLightDirection );
 955                 break;
 956                 case EAS_extrusion_second_light_direction :
 957                     GetB3DVector( maExtrusion, rValue, EAS_SecondLightDirection );
 958                 break;
 959                 case EAS_extrusion_metal :
 960                     GetBool( maExtrusion, rValue, EAS_Metal );
 961                 break;
 962                 case EAS_shade_mode :
 963                 {
 964                     drawing::ShadeMode eShadeMode( drawing::ShadeMode_FLAT );
 965                     if( IsXMLToken( rValue, XML_PHONG ) )
 966                         eShadeMode = drawing::ShadeMode_PHONG;
 967                     else if ( IsXMLToken( rValue, XML_GOURAUD ) )
 968                         eShadeMode = drawing::ShadeMode_SMOOTH;
 969                     else if ( IsXMLToken( rValue, XML_DRAFT ) )
 970                         eShadeMode = drawing::ShadeMode_DRAFT;
 971
 972                     beans::PropertyValue aProp;
 973                     aProp.Name = EASGet( EAS_ShadeMode );
 974                     aProp.Value <<= eShadeMode;
 975                     maExtrusion.push_back( aProp );
 976                 }
 977                 break;
 978                 case EAS_extrusion_rotation_angle :
 979                     GetEnhancedParameterPair( maExtrusion, rValue, EAS_RotateAngle );
 980                 break;
 981                 case EAS_extrusion_rotation_center :
 982                     GetB3DVector( maExtrusion, rValue, EAS_RotationCenter );
 983                 break;
 984                 case EAS_extrusion_shininess :
 985                     GetDoublePercentage( maExtrusion, rValue, EAS_Shininess );
 986                 break;
 987                 case EAS_extrusion_skew :
 988                     GetEnhancedParameterPair( maExtrusion, rValue, EAS_Skew );
 989                 break;
 990                 case EAS_extrusion_specularity :
 991                     GetDoublePercentage( maExtrusion, rValue, EAS_Specularity );
 992                 break;
 993                 case EAS_projection :
 994                 {
 995                     drawing::ProjectionMode eProjectionMode( drawing::ProjectionMode_PERSPECTIVE );
 996                     if( IsXMLToken( rValue, XML_PARALLEL ) )
 997                         eProjectionMode = drawing::ProjectionMode_PARALLEL;
 998
 999                     beans::PropertyValue aProp;
1000                     aProp.Name = EASGet( EAS_ProjectionMode );
1001                     aProp.Value <<= eProjectionMode;
1002                     maExtrusion.push_back( aProp );
1003                 }
1004                 break;
1005                 case EAS_extrusion_viewpoint :
1006                     GetPosition3D( maExtrusion, rValue, EAS_ViewPoint, mrUnitConverter );
1007                 break;
1008                 case EAS_extrusion_origin :
1009                     GetEnhancedParameterPair( maExtrusion, rValue, EAS_Origin );
1010                 break;
1011                 case EAS_extrusion_color :
1012                     GetBool( maExtrusion, rValue, EAS_Color );
1013                 break;
1014                 case EAS_enhanced_path :
1015                     GetEnhancedPath( maPath, rValue );
1016                 break;
1017                 case EAS_path_stretchpoint_x :
1018                 {
1019                     if (::sax::Converter::convertNumber(nAttrNumber, rValue))
1020                     {
1021                         beans::PropertyValue aProp;
1022                         aProp.Name = EASGet( EAS_StretchX );
1023                         aProp.Value <<= nAttrNumber;
1024                         maPath.push_back( aProp );
1025                     }
1026                 }
1027                 break;
1028                 case EAS_path_stretchpoint_y :
1029                 {
1030                     if (::sax::Converter::convertNumber(nAttrNumber, rValue))
1031                     {
1032                         beans::PropertyValue aProp;
1033                         aProp.Name = EASGet( EAS_StretchY );
1034                         aProp.Value <<= nAttrNumber;
1035                         maPath.push_back( aProp );
1036                     }
1037                 }
1038                 break;
1039                 case EAS_text_areas :
1040                     GetEnhancedRectangleSequence( maPath, rValue, EAS_TextFrames );
1041                 break;
1042                 case EAS_glue_points :
1043                 {
1044                     sal_Int32 i, nPairs = GetEnhancedParameterPairSequence( maPath, rValue, EAS_GluePoints );
1045                     GetImport().GetShapeImport()->moveGluePointMapping( mrxShape, nPairs );
1046                     for ( i = 0; i < nPairs; i++ )
1047                         GetImport().GetShapeImport()->addGluePointMapping( mrxShape, i + 4, i + 4 );
1048                 }
1049                 break;
1050                 case EAS_glue_point_type :
1051                     GetEnum( maPath, rValue, EAS_GluePointType, *aXML_GluePointEnumMap );
1052                 break;
1053                 case EAS_glue_point_leaving_directions :
1054                     GetDoubleSequence( maPath, rValue, EAS_GluePointLeavingDirections );
1055                 break;
1056                 case EAS_text_path :
1057                     GetBool( maTextPath, rValue, EAS_TextPath );
1058                 break;
1059                 case EAS_text_path_mode :
1060                 {
1061                     com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode( com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL );
1062                     if( IsXMLToken( rValue, XML_PATH ) )
1063                         eTextPathMode = com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH;
1064                     else if ( IsXMLToken( rValue, XML_SHAPE ) )
1065                         eTextPathMode = com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE;
1066
1067                     beans::PropertyValue aProp;
1068                     aProp.Name = EASGet( EAS_TextPathMode );
1069                     aProp.Value <<= eTextPathMode;
1070                     maTextPath.push_back( aProp );
1071                 }
1072                 break;
1073                 case EAS_text_path_scale :
1074                 {
1075                     sal_Bool bScaleX = IsXMLToken( rValue, XML_SHAPE );
1076                     beans::PropertyValue aProp;
1077                     aProp.Name = EASGet( EAS_ScaleX );
1078                     aProp.Value <<= bScaleX;
1079                     maTextPath.push_back( aProp );
1080                 }
1081                 break;
1082                 case EAS_text_path_same_letter_heights :
1083                     GetBool( maTextPath, rValue, EAS_SameLetterHeights );
1084                 break;
1085                 case EAS_modifiers :
1086                     GetAdjustmentValues( mrCustomShapeGeometry, rValue );
1087                 break;
1088                 default:
1089                     break;
1090             }
1091         }
1092     }
1093 }
1094
1095 void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
1096                                     const std::vector< beans::PropertyValues >& rElement,
1097                                         const rtl::OUString& rElementName )
1098 {
1099     if ( !rElement.empty() )
1100     {
1101         uno::Sequence< beans::PropertyValues > aPropSeq( rElement.size() );
1102         std::vector< beans::PropertyValues >::const_iterator aIter = rElement.begin();
1103         std::vector< beans::PropertyValues >::const_iterator aEnd = rElement.end();
1104         beans::PropertyValues* pValues = aPropSeq.getArray();
1105
1106         while ( aIter != aEnd )
1107             *pValues++ = *aIter++;
1108
1109         beans::PropertyValue aProp;
1110         aProp.Name = rElementName;
1111         aProp.Value <<= aPropSeq;
1112         rPropVec.push_back( aProp );
1113     }
1114 }
1115
1116 void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
1117                                     const std::vector< rtl::OUString >& rElement,
1118                                         const rtl::OUString& rElementName )
1119 {
1120     if ( !rElement.empty() )
1121     {
1122         uno::Sequence< rtl::OUString > aPropSeq( rElement.size() );
1123         std::vector< rtl::OUString >::const_iterator aIter = rElement.begin();
1124         std::vector< rtl::OUString >::const_iterator aEnd = rElement.end();
1125         rtl::OUString* pValues = aPropSeq.getArray();
1126
1127         while ( aIter != aEnd )
1128             *pValues++ = *aIter++;
1129
1130         beans::PropertyValue aProp;
1131         aProp.Name = rElementName;
1132         aProp.Value <<= aPropSeq;
1133         rPropVec.push_back( aProp );
1134     }
1135 }
1136
1137 void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
1138                                     const std::vector< com::sun::star::beans::PropertyValue >& rElement,
1139                                         const rtl::OUString& rElementName )
1140 {
1141     if ( !rElement.empty() )
1142     {
1143         uno::Sequence< beans::PropertyValue > aPropSeq( rElement.size() );
1144         std::vector< beans::PropertyValue >::const_iterator aIter = rElement.begin();
1145         std::vector< beans::PropertyValue >::const_iterator aEnd = rElement.end();
1146         beans::PropertyValue* pValues = aPropSeq.getArray();
1147
1148         while ( aIter != aEnd )
1149             *pValues++ = *aIter++;
1150
1151         beans::PropertyValue aProp;
1152         aProp.Name = rElementName;
1153         aProp.Value <<= aPropSeq;
1154         rPropVec.push_back( aProp );
1155     }
1156 }
1157
1158 typedef boost::unordered_map< rtl::OUString, sal_Int32, rtl::OUStringHash, OUStringEqFunc> EquationHashMap;
1159
1160 /* if rPara.Type is from type EnhancedCustomShapeParameterType::EQUATION, the name of the equation
1161    will be converted from rtl::OUString to index */
1162 void CheckAndResolveEquationParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rPara, EquationHashMap* pH )
1163 {
1164     if ( rPara.Type == com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION )
1165     {
1166         rtl::OUString aEquationName;
1167         if ( rPara.Value >>= aEquationName )
1168         {
1169             sal_Int32 nIndex = 0;
1170             EquationHashMap::iterator aHashIter( pH->find( aEquationName ) );
1171             if ( aHashIter != pH->end() )
1172                 nIndex = (*aHashIter).second;
1173             rPara.Value <<= nIndex;
1174         }
1175     }
1176 }
1177
1178 void XMLEnhancedCustomShapeContext::EndElement()
1179 {
1180     // resolve properties that are indexing a Equation
1181     if ( !maEquations.empty() )
1182     {
1183         // creating hash map containing the name and index of each equation
1184         EquationHashMap* pH = new EquationHashMap;
1185         std::vector< rtl::OUString >::iterator aEquationNameIter = maEquationNames.begin();
1186         std::vector< rtl::OUString >::iterator aEquationNameEnd  = maEquationNames.end();
1187         while( aEquationNameIter != aEquationNameEnd )
1188         {
1189             (*pH)[ *aEquationNameIter ] = (sal_Int32)( aEquationNameIter - maEquationNames.begin() );
1190             ++aEquationNameIter;
1191         }
1192
1193         // resolve equation
1194         std::vector< rtl::OUString >::iterator aEquationIter = maEquations.begin();
1195         std::vector< rtl::OUString >::iterator aEquationEnd  = maEquations.end();
1196         while( aEquationIter != aEquationEnd )
1197         {
1198             sal_Int32 nIndexOf = 0;
1199             do
1200             {
1201                 nIndexOf = aEquationIter->indexOf( '?', nIndexOf );
1202                 if ( nIndexOf != -1 )
1203                 {
1204                     rtl::OUString aEquationName;
1205                     if ( GetEquationName( *aEquationIter, nIndexOf + 1, aEquationName ) )
1206                     {
1207                         // copying first characters inclusive '?'
1208                         rtl::OUString aNew( aEquationIter->copy( 0, nIndexOf + 1 ) );
1209                         sal_Int32 nIndex = 0;
1210                         EquationHashMap::iterator aHashIter( pH->find( aEquationName ) );
1211                         if ( aHashIter != pH->end() )
1212                             nIndex = (*aHashIter).second;
1213                         aNew += rtl::OUString::valueOf( nIndex );
1214                         aNew += aEquationIter->copy( nIndexOf + aEquationName.getLength() + 1 );
1215                         *aEquationIter = aNew;
1216                     }
1217                     nIndexOf++;
1218                 }
1219             }
1220             while( nIndexOf != -1 );
1221             ++aEquationIter;
1222         }
1223
1224         // Path
1225         sal_Int32 i;
1226         std::vector< beans::PropertyValue >::iterator aPathIter = maPath.begin();
1227         std::vector< beans::PropertyValue >::iterator aPathEnd  = maPath.end();
1228         while ( aPathIter != aPathEnd )
1229         {
1230             switch( EASGet( aPathIter->Name ) )
1231             {
1232                 case EAS_Coordinates :
1233                 case EAS_GluePoints :
1234                 {
1235                     uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rSeq =
1236                         *((uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >*)
1237                             aPathIter->Value.getValue());
1238                     for ( i = 0; i < rSeq.getLength(); i++ )
1239                     {
1240                         CheckAndResolveEquationParameter( rSeq[ i ].First, pH );
1241                         CheckAndResolveEquationParameter( rSeq[ i ].Second, pH );
1242                     }
1243                 }
1244                 break;
1245                 case EAS_TextFrames :
1246                 {
1247                     uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame >& rSeq =
1248                         *((uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame >*)
1249                             aPathIter->Value.getValue());
1250                     for ( i = 0; i < rSeq.getLength(); i++ )
1251                     {
1252                         CheckAndResolveEquationParameter( rSeq[ i ].TopLeft.First, pH );
1253                         CheckAndResolveEquationParameter( rSeq[ i ].TopLeft.Second, pH );
1254                         CheckAndResolveEquationParameter( rSeq[ i ].BottomRight.First, pH );
1255                         CheckAndResolveEquationParameter( rSeq[ i ].BottomRight.Second, pH );
1256                     }
1257                 }
1258                 break;
1259                 default:
1260                     break;
1261             }
1262             ++aPathIter;
1263         }
1264         std::vector< beans::PropertyValues >::iterator aHandleIter = maHandles.begin();
1265         std::vector< beans::PropertyValues >::iterator aHandleEnd  = maHandles.end();
1266         while ( aHandleIter != aHandleEnd )
1267         {
1268             beans::PropertyValue* pValues = aHandleIter->getArray();
1269             for ( i = 0; i < aHandleIter->getLength(); i++ )
1270             {
1271                 switch( EASGet( pValues->Name ) )
1272                 {
1273                     case EAS_RangeYMinimum :
1274                     case EAS_RangeYMaximum :
1275                     case EAS_RangeXMinimum :
1276                     case EAS_RangeXMaximum :
1277                     case EAS_RadiusRangeMinimum :
1278                     case EAS_RadiusRangeMaximum :
1279                     {
1280                         CheckAndResolveEquationParameter( *((com::sun::star::drawing::EnhancedCustomShapeParameter*)
1281                             pValues->Value.getValue()), pH );
1282                     }
1283                     break;
1284
1285                     case EAS_Position :
1286                     case EAS_Polar :
1287                     {
1288                         CheckAndResolveEquationParameter( (*((com::sun::star::drawing::EnhancedCustomShapeParameterPair*)
1289                             pValues->Value.getValue())).First, pH );
1290                         CheckAndResolveEquationParameter( (*((com::sun::star::drawing::EnhancedCustomShapeParameterPair*)
1291                             pValues->Value.getValue())).Second, pH );
1292                     }
1293                     break;
1294                     default:
1295                         break;
1296                 }
1297                 pValues++;
1298             }
1299             ++aHandleIter;
1300         }
1301         delete pH;
1302     }
1303
1304     SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maExtrusion, EASGet( EAS_Extrusion ) );
1305     SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maPath,      EASGet( EAS_Path ) );
1306     SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maTextPath,  EASGet( EAS_TextPath ) );
1307     SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maEquations, EASGet( EAS_Equations ) );
1308     if  ( !maHandles.empty() )
1309         SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maHandles, EASGet( EAS_Handles ) );
1310 }
1311
1312 SvXMLImportContext* XMLEnhancedCustomShapeContext::CreateChildContext( sal_uInt16 nPrefix,const rtl::OUString& rLocalName,
1313                                                                     const uno::Reference< xml::sax::XAttributeList> & xAttrList )
1314 {
1315     EnhancedCustomShapeTokenEnum aTokenEnum = EASGet( rLocalName );
1316     if ( aTokenEnum == EAS_equation )
1317     {
1318         sal_Int16 nLength = xAttrList->getLength();
1319         if ( nLength )
1320         {
1321             rtl::OUString aFormula;
1322             rtl::OUString aFormulaName;
1323             for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
1324             {
1325                 rtl::OUString aLocalName;
1326                 const rtl::OUString& rValue = xAttrList->getValueByIndex( nAttr );
1327                 /* fixme sven, this needs to be chekced! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );
1328
1329                 switch( EASGet( aLocalName ) )
1330                 {
1331                     case EAS_formula :
1332                         aFormula = rValue;
1333                     break;
1334                     case EAS_name :
1335                         aFormulaName = rValue;
1336                     break;
1337                     default:
1338                         break;
1339                 }
1340             }
1341             if ( !aFormulaName.isEmpty() || !aFormula.isEmpty() )
1342             {
1343                 maEquations.push_back( aFormula );
1344                 maEquationNames.push_back( aFormulaName );
1345             }
1346         }
1347     }
1348     else if ( aTokenEnum == EAS_handle )
1349     {
1350         std::vector< com::sun::star::beans::PropertyValue > aHandle;
1351         const sal_Int16 nLength = xAttrList->getLength();
1352         for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
1353         {
1354             rtl::OUString aLocalName;
1355             const rtl::OUString& rValue = xAttrList->getValueByIndex( nAttr );
1356             /* fixme sven, this needs to be chekced! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );
1357             switch( EASGet( aLocalName ) )
1358             {
1359                 case EAS_handle_mirror_vertical :
1360                     GetBool( aHandle, rValue, EAS_MirroredY );
1361                 break;
1362                 case EAS_handle_mirror_horizontal :
1363                     GetBool( aHandle, rValue, EAS_MirroredX );
1364                 break;
1365                 case EAS_handle_switched :
1366                     GetBool( aHandle, rValue, EAS_Switched );
1367                 break;
1368                 case EAS_handle_position :
1369                     GetEnhancedParameterPair( aHandle, rValue, EAS_Position );
1370                 break;
1371                 case EAS_handle_range_x_minimum :
1372                     GetEnhancedParameter( aHandle, rValue, EAS_RangeXMinimum );
1373                 break;
1374                 case EAS_handle_range_x_maximum :
1375                     GetEnhancedParameter( aHandle, rValue, EAS_RangeXMaximum );
1376                 break;
1377                 case EAS_handle_range_y_minimum :
1378                     GetEnhancedParameter( aHandle, rValue, EAS_RangeYMinimum );
1379                 break;
1380                 case EAS_handle_range_y_maximum :
1381                     GetEnhancedParameter( aHandle, rValue, EAS_RangeYMaximum );
1382                 break;
1383                 case EAS_handle_polar :
1384                     GetEnhancedParameterPair( aHandle, rValue, EAS_Polar );
1385                 break;
1386                 case EAS_handle_radius_range_minimum :
1387                     GetEnhancedParameter( aHandle, rValue, EAS_RadiusRangeMinimum );
1388                 break;
1389                 case EAS_handle_radius_range_maximum :
1390                     GetEnhancedParameter( aHandle, rValue, EAS_RadiusRangeMaximum );
1391                 break;
1392                 default:
1393                     break;
1394             }
1395         }
1396         beans::PropertyValues aPropSeq( aHandle.size() );
1397         std::vector< beans::PropertyValue >::const_iterator aIter = aHandle.begin();
1398         std::vector< beans::PropertyValue >::const_iterator aEnd = aHandle.end();
1399         beans::PropertyValue* pValues = aPropSeq.getArray();
1400
1401         while ( aIter != aEnd )
1402             *pValues++ = *aIter++;
1403
1404         maHandles.push_back( aPropSeq );
1405     }
1406     return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
1407 }
1408
1409 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */