oox/source/export/vmlexport.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile$
  10  * $Revision$
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <oox/export/vmlexport.hxx>
  32
  33 #include <tokens.hxx>
  34
  35 #include <rtl/strbuf.hxx>
  36 #include <rtl/ustring.hxx>
  37
  38 #include <tools/stream.hxx>
  39
  40 #include <cstdio>
  41
  42 using rtl::OString;
  43 using rtl::OStringBuffer;
  44 using rtl::OUString;
  45 using rtl::OUStringBuffer;
  46
  47 using namespace sax_fastparser;
  48 using namespace oox::vml;
  49
  50 /// Implementation of an empty stream that silently succeeds, but does nothing.
  51 ///
  52 /// In fact, this is a hack.  The right solution is to abstract EscherEx to be
  53 /// able to work without SvStream; but at the moment it is better to live with
  54 /// this I guess.
  55 class SvNullStream : public SvStream
  56 {
  57 protected:
  58     virtual sal_Size GetData( void* pData, sal_Size nSize ) { memset( pData, 0, nSize ); return nSize; }
  59     virtual sal_Size PutData( const void*, sal_Size nSize ) { return nSize; }
  60     virtual sal_Size SeekPos( sal_Size nPos ) { return nPos; }
  61     virtual void SetSize( sal_Size ) {}
  62     virtual void FlushData() {}
  63
  64 public:
  65     SvNullStream() : SvStream() {}
  66     virtual ~SvNullStream() {}
  67 };
  68
  69 VMLExport::VMLExport( ::sax_fastparser::FSHelperPtr pSerializer )
  70     : EscherEx( *( new SvNullStream ), 0 ),
  71       m_pSerializer( pSerializer ),
  72       m_pShapeAttrList( NULL ),
  73       m_nShapeType( ESCHER_ShpInst_Nil ),
  74       m_pShapeStyle( new OStringBuffer( 200 ) ),
  75       m_pShapeTypeWritten( new bool[ ESCHER_ShpInst_COUNT ] )
  76 {
  77     mnGroupLevel = 1;
  78     memset( m_pShapeTypeWritten, 0, ESCHER_ShpInst_COUNT * sizeof( bool ) );
  79 }
  80
  81 VMLExport::~VMLExport()
  82 {
  83     delete mpOutStrm, mpOutStrm = NULL;
  84     delete m_pShapeStyle, m_pShapeStyle = NULL;
  85     delete[] m_pShapeTypeWritten, m_pShapeTypeWritten = NULL;
  86 }
  87
  88 void VMLExport::OpenContainer( UINT16 nEscherContainer, int nRecInstance )
  89 {
  90     EscherEx::OpenContainer( nEscherContainer, nRecInstance );
  91
  92     if ( nEscherContainer == ESCHER_SpContainer )
  93     {
  94         // opening a shape container
  95 #if OSL_DEBUG_LEVEL > 0
  96         if ( m_nShapeType != ESCHER_ShpInst_Nil )
  97             fprintf( stderr, "Warning!  VMLExport::OpenContainer(): opening shape inside a shape.\n" );
  98 #endif
  99         m_nShapeType = ESCHER_ShpInst_Nil;
 100         m_pShapeAttrList = m_pSerializer->createAttrList();
 101
 102         if ( m_pShapeStyle->getLength() )
 103             m_pShapeStyle->makeStringAndClear();
 104
 105         m_pShapeStyle->ensureCapacity( 200 );
 106
 107         // postpone the ouput so that we are able to write even the elements
 108         // that we learn inside Commit()
 109         m_pSerializer->mark();
 110     }
 111 }
 112
 113 void VMLExport::CloseContainer()
 114 {
 115     if ( mRecTypes.back() == ESCHER_SpContainer )
 116     {
 117         // write the shape now when we have all the info
 118         sal_Int32 nShapeElement = StartShape();
 119
 120         m_pSerializer->mergeTopMarks();
 121
 122         EndShape( nShapeElement );
 123
 124         // cleanup
 125         m_nShapeType = ESCHER_ShpInst_Nil;
 126         m_pShapeAttrList = NULL;
 127     }
 128
 129     EscherEx::CloseContainer();
 130 }
 131
 132 UINT32 VMLExport::EnterGroup( const String& rShapeName, const Rectangle* pRect )
 133 {
 134     UINT32 nShapeId = GetShapeID();
 135
 136     OStringBuffer aStyle( 200 );
 137     FastAttributeList *pAttrList = m_pSerializer->createAttrList();
 138
 139     pAttrList->add( XML_id, ShapeIdString( nShapeId ) );
 140
 141     if ( rShapeName.Len() )
 142         pAttrList->add( XML_alt, OUStringToOString( OUString( rShapeName ), RTL_TEXTENCODING_UTF8 ) );
 143
 144     // style
 145     if ( pRect )
 146         AddRectangleDimensions( aStyle, *pRect );
 147
 148     if ( aStyle.getLength() )
 149         pAttrList->add( XML_style, aStyle.makeStringAndClear() );
 150
 151     // coordorigin/coordsize
 152     if ( pRect && ( mnGroupLevel == 1 ) )
 153     {
 154         pAttrList->add( XML_coordorigin,
 155                 OStringBuffer( 20 ).append( sal_Int32( pRect->Left() ) )
 156                 .append( "," ).append( sal_Int32( pRect->Top() ) )
 157                 .makeStringAndClear() );
 158
 159         pAttrList->add( XML_coordsize,
 160                 OStringBuffer( 20 ).append( sal_Int32( pRect->Right() ) - sal_Int32( pRect->Left() ) )
 161                 .append( "," ).append( sal_Int32( pRect->Bottom() ) - sal_Int32( pRect->Top() ) )
 162                 .makeStringAndClear() );
 163     }
 164
 165     m_pSerializer->startElementNS( XML_v, XML_group, XFastAttributeListRef( pAttrList ) );
 166
 167     mnGroupLevel++;
 168     return nShapeId;
 169 }
 170
 171 void VMLExport::LeaveGroup()
 172 {
 173     --mnGroupLevel;
 174     m_pSerializer->endElementNS( XML_v, XML_group );
 175 }
 176
 177 void VMLExport::AddShape( UINT32 nShapeType, UINT32 nShapeFlags, UINT32 nShapeId )
 178 {
 179     m_nShapeType = nShapeType;
 180     m_nShapeFlags = nShapeFlags;
 181
 182     m_pShapeAttrList->add( XML_id, ShapeIdString( nShapeId ) );
 183 }
 184
 185 static void impl_AddArrowHead( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
 186 {
 187     if ( !pAttrList )
 188         return;
 189
 190     const char *pArrowHead = NULL;
 191     switch ( nValue )
 192     {
 193         case ESCHER_LineNoEnd:           pArrowHead = "none"; break;
 194         case ESCHER_LineArrowEnd:        pArrowHead = "block"; break;
 195         case ESCHER_LineArrowStealthEnd: pArrowHead = "classic"; break;
 196         case ESCHER_LineArrowDiamondEnd: pArrowHead = "diamond"; break;
 197         case ESCHER_LineArrowOvalEnd:    pArrowHead = "oval"; break;
 198         case ESCHER_LineArrowOpenEnd:    pArrowHead = "open"; break;
 199     }
 200
 201     if ( pArrowHead )
 202         pAttrList->add( nElement, pArrowHead );
 203 }
 204
 205 static void impl_AddArrowLength( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
 206 {
 207     if ( !pAttrList )
 208         return;
 209
 210     const char *pArrowLength = NULL;
 211     switch ( nValue )
 212     {
 213         case ESCHER_LineShortArrow:     pArrowLength = "short"; break;
 214         case ESCHER_LineMediumLenArrow: pArrowLength = "medium"; break;
 215         case ESCHER_LineLongArrow:      pArrowLength = "long"; break;
 216     }
 217
 218     if ( pArrowLength )
 219         pAttrList->add( nElement, pArrowLength );
 220 }
 221
 222 static void impl_AddArrowWidth( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
 223 {
 224     if ( !pAttrList )
 225         return;
 226
 227     const char *pArrowWidth = NULL;
 228     switch ( nValue )
 229     {
 230         case ESCHER_LineNarrowArrow:      pArrowWidth = "narrow"; break;
 231         case ESCHER_LineMediumWidthArrow: pArrowWidth = "medium"; break;
 232         case ESCHER_LineWideArrow:        pArrowWidth = "wide"; break;
 233     }
 234
 235     if ( pArrowWidth )
 236         pAttrList->add( nElement, pArrowWidth );
 237 }
 238
 239 static void impl_AddBool( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, bool bValue )
 240 {
 241     if ( !pAttrList )
 242         return;
 243
 244     pAttrList->add( nElement, bValue? "t": "f" );
 245 }
 246
 247 static void impl_AddColor( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nColor )
 248 {
 249 #if OSL_DEBUG_LEVEL > 0
 250     if ( nColor & 0xFF000000 )
 251         fprintf( stderr, "TODO: this is not a RGB value!\n" );
 252 #endif
 253
 254     if ( !pAttrList || ( nColor & 0xFF000000 ) )
 255         return;
 256
 257     nColor = ( ( nColor & 0xFF ) << 16 ) + ( nColor & 0xFF00 ) + ( ( nColor & 0xFF0000 ) >> 16 );
 258
 259     const char *pColor = NULL;
 260     char pRgbColor[10];
 261     switch ( nColor )
 262     {
 263         case 0x000000: pColor = "black"; break;
 264         case 0xC0C0C0: pColor = "silver"; break;
 265         case 0x808080: pColor = "gray"; break;
 266         case 0xFFFFFF: pColor = "white"; break;
 267         case 0x800000: pColor = "maroon"; break;
 268         case 0xFF0000: pColor = "red"; break;
 269         case 0x800080: pColor = "purple"; break;
 270         case 0xFF00FF: pColor = "fuchsia"; break;
 271         case 0x008000: pColor = "green"; break;
 272         case 0x00FF00: pColor = "lime"; break;
 273         case 0x808000: pColor = "olive"; break;
 274         case 0xFFFF00: pColor = "yellow"; break;
 275         case 0x000080: pColor = "navy"; break;
 276         case 0x0000FF: pColor = "blue"; break;
 277         case 0x008080: pColor = "teal"; break;
 278         case 0x00FFFF: pColor = "aqua"; break;
 279         default:
 280             {
 281                 snprintf( pRgbColor, sizeof( pRgbColor ), "#%06x", static_cast< unsigned int >( nColor ) ); // not too handy to use OString::valueOf() here :-(
 282                 pColor = pRgbColor;
 283             }
 284             break;
 285     }
 286
 287     pAttrList->add( nElement, pColor );
 288 }
 289
 290 static void impl_AddInt( sax_fastparser::FastAttributeList *pAttrList, sal_Int32 nElement, sal_uInt32 nValue )
 291 {
 292     if ( !pAttrList )
 293         return;
 294
 295     pAttrList->add( nElement, OString::valueOf( static_cast< sal_Int32 >( nValue ) ).getStr() );
 296 }
 297
 298 inline sal_uInt16 impl_GetUInt16( const sal_uInt8* &pVal )
 299 {
 300     sal_uInt16 nRet = *pVal++;
 301     nRet += ( *pVal++ ) << 8;
 302     return nRet;
 303 }
 304
 305 inline sal_Int32 impl_GetPointComponent( const sal_uInt8* &pVal, sal_uInt16 nPointSize )
 306 {
 307     sal_Int32 nRet = 0;
 308     if ( ( nPointSize == 0xfff0 ) || ( nPointSize == 4 ) )
 309     {
 310         sal_uInt16 nUnsigned = *pVal++;
 311         nUnsigned += ( *pVal++ ) << 8;
 312
 313         nRet = sal_Int16( nUnsigned );
 314     }
 315     else if ( nPointSize == 8 )
 316     {
 317         sal_uInt32 nUnsigned = *pVal++;
 318         nUnsigned += ( *pVal++ ) << 8;
 319         nUnsigned += ( *pVal++ ) << 16;
 320         nUnsigned += ( *pVal++ ) << 24;
 321
 322         nRet = nUnsigned;
 323     }
 324
 325     return nRet;
 326 }
 327
 328 void VMLExport::Commit( EscherPropertyContainer& rProps, const Rectangle& rRect )
 329 {
 330     if ( m_nShapeType == ESCHER_ShpInst_Nil )
 331         return;
 332
 333     // postpone the output of the embedded elements so that they are written
 334     // inside the shapes
 335     m_pSerializer->mark();
 336
 337     // dimensions
 338     if ( m_nShapeType == ESCHER_ShpInst_Line )
 339         AddLineDimensions( rRect );
 340     else
 341         AddRectangleDimensions( *m_pShapeStyle, rRect );
 342
 343     // properties
 344     bool bAlreadyWritten[ 0xFFF ];
 345     memset( bAlreadyWritten, 0, sizeof( bAlreadyWritten ) );
 346     const EscherProperties &rOpts = rProps.GetOpts();
 347     for ( EscherProperties::const_iterator it = rOpts.begin(); it != rOpts.end(); ++it )
 348     {
 349         sal_uInt16 nId = ( it->nPropId & 0x0FFF );
 350
 351         if ( bAlreadyWritten[ nId ] )
 352             continue;
 353
 354         switch ( nId )
 355         {
 356             case ESCHER_Prop_WrapText: // 133
 357                 {
 358                     const char *pWrapType = NULL;
 359                     switch ( it->nPropValue )
 360                     {
 361                         case ESCHER_WrapSquare:
 362                         case ESCHER_WrapByPoints:  pWrapType = "square"; break; // these two are equivalent according to the docu
 363                         case ESCHER_WrapNone:      pWrapType = "none"; break;
 364                         case ESCHER_WrapTopBottom: pWrapType = "topAndBottom"; break;
 365                         case ESCHER_WrapThrough:   pWrapType = "through"; break;
 366                     }
 367                     if ( pWrapType )
 368                         m_pSerializer->singleElementNS( XML_w10, XML_wrap,
 369                                 FSNS( XML_w10, XML_type ), pWrapType,
 370                                 FSEND );
 371                 }
 372                 bAlreadyWritten[ ESCHER_Prop_WrapText ] = true;
 373                 break;
 374
 375             // coordorigin
 376             case ESCHER_Prop_geoLeft: // 320
 377             case ESCHER_Prop_geoTop: // 321
 378                 {
 379                     sal_uInt32 nLeft = 0, nTop = 0;
 380
 381                     if ( nId == ESCHER_Prop_geoLeft )
 382                     {
 383                         nLeft = it->nPropValue;
 384                         rProps.GetOpt( ESCHER_Prop_geoTop, nTop );
 385                     }
 386                     else
 387                     {
 388                         nTop = it->nPropValue;
 389                         rProps.GetOpt( ESCHER_Prop_geoLeft, nLeft );
 390                     }
 391
 392                     m_pShapeAttrList->add( XML_coordorigin,
 393                             OStringBuffer( 20 ).append( sal_Int32( nLeft ) )
 394                             .append( "," ).append( sal_Int32( nTop ) )
 395                             .makeStringAndClear() );
 396                 }
 397                 bAlreadyWritten[ ESCHER_Prop_geoLeft ] = true;
 398                 bAlreadyWritten[ ESCHER_Prop_geoTop ] = true;
 399                 break;
 400
 401             // coordsize
 402             case ESCHER_Prop_geoRight: // 322
 403             case ESCHER_Prop_geoBottom: // 323
 404                 {
 405                     sal_uInt32 nLeft = 0, nRight = 0, nTop = 0, nBottom = 0;
 406                     rProps.GetOpt( ESCHER_Prop_geoLeft, nLeft );
 407                     rProps.GetOpt( ESCHER_Prop_geoTop, nTop );
 408
 409                     if ( nId == ESCHER_Prop_geoRight )
 410                     {
 411                         nRight = it->nPropValue;
 412                         rProps.GetOpt( ESCHER_Prop_geoBottom, nBottom );
 413                     }
 414                     else
 415                     {
 416                         nBottom = it->nPropValue;
 417                         rProps.GetOpt( ESCHER_Prop_geoRight, nRight );
 418                     }
 419
 420                     m_pShapeAttrList->add( XML_coordsize,
 421                             OStringBuffer( 20 ).append( sal_Int32( nRight ) - sal_Int32( nLeft ) )
 422                             .append( "," ).append( sal_Int32( nBottom ) - sal_Int32( nTop ) )
 423                             .makeStringAndClear() );
 424                 }
 425                 bAlreadyWritten[ ESCHER_Prop_geoRight ] = true;
 426                 bAlreadyWritten[ ESCHER_Prop_geoBottom ] = true;
 427                 break;
 428
 429             case ESCHER_Prop_pVertices: // 325
 430             case ESCHER_Prop_pSegmentInfo: // 326
 431                 {
 432                     EscherPropSortStruct aVertices;
 433                     EscherPropSortStruct aSegments;
 434
 435                     if ( rProps.GetOpt( ESCHER_Prop_pVertices, aVertices ) &&
 436                          rProps.GetOpt( ESCHER_Prop_pSegmentInfo, aSegments ) )
 437                     {
 438                         const sal_uInt8 *pVerticesIt = aVertices.pBuf + 6;
 439                         const sal_uInt8 *pSegmentIt = aSegments.pBuf;
 440                         OStringBuffer aPath( 512 );
 441
 442                         sal_uInt16 nPointSize = aVertices.pBuf[4] + ( aVertices.pBuf[5] << 8 );
 443
 444                         // number of segments
 445                         sal_uInt16 nSegments = impl_GetUInt16( pSegmentIt );
 446                         pSegmentIt += 4;
 447
 448                         for ( ; nSegments; --nSegments )
 449                         {
 450                             sal_uInt16 nSeg = impl_GetUInt16( pSegmentIt );
 451                             switch ( nSeg )
 452                             {
 453                                 case 0x4000: // moveto
 454                                     {
 455                                         sal_Int32 nX = impl_GetPointComponent( pVerticesIt, nPointSize );
 456                                         sal_Int32 nY = impl_GetPointComponent( pVerticesIt, nPointSize );
 457                                         aPath.append( "m" ).append( nX ).append( "," ).append( nY );
 458                                     }
 459                                     break;
 460                                 case 0xb300:
 461                                 case 0xac00:
 462                                     break;
 463                                 case 0x0001: // lineto
 464                                     {
 465                                         sal_Int32 nX = impl_GetPointComponent( pVerticesIt, nPointSize );
 466                                         sal_Int32 nY = impl_GetPointComponent( pVerticesIt, nPointSize );
 467                                         aPath.append( "l" ).append( nX ).append( "," ).append( nY );
 468                                     }
 469                                     break;
 470                                 case 0x2001: // curveto
 471                                     {
 472                                         sal_Int32 nX1 = impl_GetPointComponent( pVerticesIt, nPointSize );
 473                                         sal_Int32 nY1 = impl_GetPointComponent( pVerticesIt, nPointSize );
 474                                         sal_Int32 nX2 = impl_GetPointComponent( pVerticesIt, nPointSize );
 475                                         sal_Int32 nY2 = impl_GetPointComponent( pVerticesIt, nPointSize );
 476                                         sal_Int32 nX3 = impl_GetPointComponent( pVerticesIt, nPointSize );
 477                                         sal_Int32 nY3 = impl_GetPointComponent( pVerticesIt, nPointSize );
 478                                         aPath.append( "c" ).append( nX1 ).append( "," ).append( nY1 ).append( "," )
 479                                             .append( nX2 ).append( "," ).append( nY2 ).append( "," )
 480                                             .append( nX3 ).append( "," ).append( nY3 );
 481                                     }
 482                                     break;
 483                                 case 0xaa00: // nofill
 484                                     aPath.append( "nf" );
 485                                     break;
 486                                 case 0xab00: // nostroke
 487                                     aPath.append( "ns" );
 488                                     break;
 489                                 case 0x6001: // close
 490                                     aPath.append( "x" );
 491                                     break;
 492                                 case 0x8000: // end
 493                                     aPath.append( "e" );
 494                                     break;
 495                                 default:
 496 #if OSL_DEBUG_LEVEL > 0
 497                                     fprintf( stderr, "TODO: unhandled segment '%x' in the path\n", nSeg );
 498 #endif
 499                                     break;
 500                             }
 501                         }
 502
 503                         if ( aPath.getLength() )
 504                             m_pShapeAttrList->add( XML_path, aPath.getStr() );
 505                     }
 506 #if OSL_DEBUG_LEVEL > 0
 507                     else
 508                         fprintf( stderr, "TODO: unhandled shape path, missing either pVertices or pSegmentInfo.\n" );
 509 #endif
 510                 }
 511                 bAlreadyWritten[ ESCHER_Prop_pVertices ] = true;
 512                 bAlreadyWritten[ ESCHER_Prop_pSegmentInfo ] = true;
 513                 break;
 514
 515             case ESCHER_Prop_fillType: // 384
 516             case ESCHER_Prop_fillColor: // 385
 517             case ESCHER_Prop_fillBackColor: // 387
 518             case ESCHER_Prop_fNoFillHitTest: // 447
 519                 {
 520                     sal_uInt32 nValue;
 521                     sax_fastparser::FastAttributeList *pAttrList = m_pSerializer->createAttrList();
 522
 523                     if ( rProps.GetOpt( ESCHER_Prop_fillType, nValue ) )
 524                     {
 525                         const char *pFillType = NULL;
 526                         switch ( nValue )
 527                         {
 528                             case ESCHER_FillSolid:       pFillType = "solid"; break;
 529                             // TODO case ESCHER_FillPattern:     pFillType = ""; break;
 530                             // TODO case ESCHER_FillTexture:     pFillType = ""; break;
 531                             // TODO case ESCHER_FillPicture:     pFillType = ""; break;
 532                             // TODO case ESCHER_FillShade:       pFillType = ""; break;
 533                             // TODO case ESCHER_FillShadeCenter: pFillType = ""; break;
 534                             // TODO case ESCHER_FillShadeShape:  pFillType = ""; break;
 535                             // TODO case ESCHER_FillShadeScale:  pFillType = ""; break;
 536                             // TODO case ESCHER_FillShadeTitle:  pFillType = ""; break;
 537                             // TODO case ESCHER_FillBackground:  pFillType = ""; break;
 538                             default:
 539 #if OSL_DEBUG_LEVEL > 0
 540                                 fprintf( stderr, "TODO: unhandled fill type\n" );
 541 #endif
 542                                 break;
 543                         }
 544                         if ( pFillType )
 545                             pAttrList->add( XML_type, pFillType );
 546                     }
 547
 548                     if ( rProps.GetOpt( ESCHER_Prop_fillColor, nValue ) )
 549                         impl_AddColor( pAttrList, XML_color, nValue );
 550
 551                     if ( rProps.GetOpt( ESCHER_Prop_fillBackColor, nValue ) )
 552                         impl_AddColor( pAttrList, XML_color2, nValue );
 553
 554                     if ( rProps.GetOpt( ESCHER_Prop_fNoFillHitTest, nValue ) )
 555                         impl_AddBool( pAttrList, XML_detectmouseclick, nValue );
 556
 557                     m_pSerializer->singleElementNS( XML_v, XML_fill, XFastAttributeListRef( pAttrList ) );
 558                 }
 559                 bAlreadyWritten[ ESCHER_Prop_fillType ] = true;
 560                 bAlreadyWritten[ ESCHER_Prop_fillColor ] = true;
 561                 bAlreadyWritten[ ESCHER_Prop_fillBackColor ] = true;
 562                 bAlreadyWritten[ ESCHER_Prop_fNoFillHitTest ] = true;
 563                 break;
 564
 565             case ESCHER_Prop_lineColor: // 448
 566             case ESCHER_Prop_lineWidth: // 459
 567             case ESCHER_Prop_lineDashing: // 462
 568             case ESCHER_Prop_lineStartArrowhead: // 464
 569             case ESCHER_Prop_lineEndArrowhead: // 465
 570             case ESCHER_Prop_lineStartArrowWidth: // 466
 571             case ESCHER_Prop_lineStartArrowLength: // 467
 572             case ESCHER_Prop_lineEndArrowWidth: // 468
 573             case ESCHER_Prop_lineEndArrowLength: // 469
 574             case ESCHER_Prop_lineJoinStyle: // 470
 575             case ESCHER_Prop_lineEndCapStyle: // 471
 576                 {
 577                     sal_uInt32 nValue;
 578                     sax_fastparser::FastAttributeList *pAttrList = m_pSerializer->createAttrList();
 579
 580                     if ( rProps.GetOpt( ESCHER_Prop_lineColor, nValue ) )
 581                         impl_AddColor( pAttrList, XML_color, nValue );
 582
 583                     if ( rProps.GetOpt( ESCHER_Prop_lineWidth, nValue ) )
 584                         impl_AddInt( pAttrList, XML_weight, nValue );
 585
 586                     if ( rProps.GetOpt( ESCHER_Prop_lineDashing, nValue ) )
 587                     {
 588                         const char *pDashStyle = NULL;
 589                         switch ( nValue )
 590                         {
 591                             case ESCHER_LineSolid:             pDashStyle = "solid"; break;
 592                             case ESCHER_LineDashSys:           pDashStyle = "shortdash"; break;
 593                             case ESCHER_LineDotSys:            pDashStyle = "shortdot"; break;
 594                             case ESCHER_LineDashDotSys:        pDashStyle = "shortdashdot"; break;
 595                             case ESCHER_LineDashDotDotSys:     pDashStyle = "shortdashdotdot"; break;
 596                             case ESCHER_LineDotGEL:            pDashStyle = "dot"; break;
 597                             case ESCHER_LineDashGEL:           pDashStyle = "dash"; break;
 598                             case ESCHER_LineLongDashGEL:       pDashStyle = "longdash"; break;
 599                             case ESCHER_LineDashDotGEL:        pDashStyle = "dashdot"; break;
 600                             case ESCHER_LineLongDashDotGEL:    pDashStyle = "longdashdot"; break;
 601                             case ESCHER_LineLongDashDotDotGEL: pDashStyle = "longdashdotdot"; break;
 602                         }
 603                         if ( pDashStyle )
 604                             pAttrList->add( XML_dashstyle, pDashStyle );
 605                     }
 606
 607                     if ( rProps.GetOpt( ESCHER_Prop_lineStartArrowhead, nValue ) )
 608                         impl_AddArrowHead( pAttrList, XML_startarrow, nValue );
 609
 610                     if ( rProps.GetOpt( ESCHER_Prop_lineEndArrowhead, nValue ) )
 611                         impl_AddArrowHead( pAttrList, XML_endarrow, nValue );
 612
 613                     if ( rProps.GetOpt( ESCHER_Prop_lineStartArrowWidth, nValue ) )
 614                         impl_AddArrowWidth( pAttrList, XML_startarrowwidth, nValue );
 615
 616                     if ( rProps.GetOpt( ESCHER_Prop_lineStartArrowLength, nValue ) )
 617                         impl_AddArrowLength( pAttrList, XML_startarrowlength, nValue );
 618
 619                     if ( rProps.GetOpt( ESCHER_Prop_lineEndArrowWidth, nValue ) )
 620                         impl_AddArrowWidth( pAttrList, XML_endarrowwidth, nValue );
 621
 622                     if ( rProps.GetOpt( ESCHER_Prop_lineEndArrowLength, nValue ) )
 623                         impl_AddArrowLength( pAttrList, XML_endarrowlength, nValue );
 624
 625                     if ( rProps.GetOpt( ESCHER_Prop_lineJoinStyle, nValue ) )
 626                     {
 627                         const char *pJoinStyle = NULL;
 628                         switch ( nValue )
 629                         {
 630                             case ESCHER_LineJoinBevel: pJoinStyle = "bevel"; break;
 631                             case ESCHER_LineJoinMiter: pJoinStyle = "miter"; break;
 632                             case ESCHER_LineJoinRound: pJoinStyle = "round"; break;
 633                         }
 634                         if ( pJoinStyle )
 635                             pAttrList->add( XML_joinstyle, pJoinStyle );
 636                     }
 637
 638                     if ( rProps.GetOpt( ESCHER_Prop_lineEndCapStyle, nValue ) )
 639                     {
 640                         const char *pEndCap = NULL;
 641                         switch ( nValue )
 642                         {
 643                             case ESCHER_LineEndCapRound:  pEndCap = "round"; break;
 644                             case ESCHER_LineEndCapSquare: pEndCap = "square"; break;
 645                             case ESCHER_LineEndCapFlat:   pEndCap = "flat"; break;
 646                         }
 647                         if ( pEndCap )
 648                             pAttrList->add( XML_endcap, pEndCap );
 649                     }
 650
 651                     m_pSerializer->singleElementNS( XML_v, XML_stroke, XFastAttributeListRef( pAttrList ) );
 652                 }
 653                 bAlreadyWritten[ ESCHER_Prop_lineColor ] = true;
 654                 bAlreadyWritten[ ESCHER_Prop_lineWidth ] = true;
 655                 bAlreadyWritten[ ESCHER_Prop_lineDashing ] = true;
 656                 bAlreadyWritten[ ESCHER_Prop_lineStartArrowhead ] = true;
 657                 bAlreadyWritten[ ESCHER_Prop_lineEndArrowhead ] = true;
 658                 bAlreadyWritten[ ESCHER_Prop_lineStartArrowWidth ] = true;
 659                 bAlreadyWritten[ ESCHER_Prop_lineStartArrowLength ] = true;
 660                 bAlreadyWritten[ ESCHER_Prop_lineEndArrowWidth ] = true;
 661                 bAlreadyWritten[ ESCHER_Prop_lineEndArrowLength ] = true;
 662                 bAlreadyWritten[ ESCHER_Prop_lineJoinStyle ] = true;
 663                 bAlreadyWritten[ ESCHER_Prop_lineEndCapStyle ] = true;
 664                 break;
 665
 666             case ESCHER_Prop_fHidden:
 667                 m_pShapeStyle->append( ";visibility:hidden" );
 668                 break;
 669             default:
 670 #if OSL_DEBUG_LEVEL > 0
 671                 fprintf( stderr, "TODO VMLExport::Commit(), unimplemented id: %d, value: %d, data: [%d, %p]\n",
 672                         it->nPropId, it->nPropValue, it->nPropSize, it->pBuf );
 673                 if ( it->nPropSize )
 674                 {
 675                     const sal_uInt8 *pIt = it->pBuf;
 676                     fprintf( stderr, "    ( " );
 677                     for ( int nCount = it->nPropSize; nCount; --nCount )
 678                     {
 679                         fprintf( stderr, "%02x ", *pIt );
 680                         ++pIt;
 681                     }
 682                     fprintf( stderr, ")\n" );
 683                 }
 684 #endif
 685                 break;
 686         }
 687     }
 688
 689     m_pSerializer->mergeTopMarks( sax_fastparser::MERGE_MARKS_POSTPONE );
 690 }
 691
 692 OString VMLExport::ShapeIdString( sal_uInt32 nId )
 693 {
 694     return OStringBuffer( 20 ).append( "shape_" ).append( sal_Int64( nId ) ).makeStringAndClear();
 695 }
 696
 697 void VMLExport::AddLineDimensions( const Rectangle& rRectangle )
 698 {
 699     // style
 700     if ( m_pShapeStyle->getLength() )
 701         m_pShapeStyle->append( ";" );
 702
 703     m_pShapeStyle->append( "position:absolute" );
 704
 705     switch ( m_nShapeFlags & 0xC0 )
 706     {
 707         case 0x40: m_pShapeStyle->append( ";flip:y" ); break;
 708         case 0x80: m_pShapeStyle->append( ";flip:x" ); break;
 709         case 0xC0: m_pShapeStyle->append( ";flip:xy" ); break;
 710     }
 711
 712     // the actual dimensions
 713     OString aLeft, aTop, aRight, aBottom;
 714
 715     if ( mnGroupLevel == 1 )
 716     {
 717         const OString aPt( "pt" );
 718         aLeft = OString::valueOf( double( rRectangle.Left() ) / 20 ) + aPt;
 719         aTop = OString::valueOf( double( rRectangle.Top() ) / 20 ) + aPt;
 720         aRight = OString::valueOf( double( rRectangle.Right() ) / 20 ) + aPt;
 721         aBottom = OString::valueOf( double( rRectangle.Bottom() ) / 20 ) + aPt;
 722     }
 723     else
 724     {
 725         aLeft = OString::valueOf( rRectangle.Left() );
 726         aTop = OString::valueOf( rRectangle.Top() );
 727         aRight = OString::valueOf( rRectangle.Right() );
 728         aBottom = OString::valueOf( rRectangle.Bottom() );
 729     }
 730
 731     m_pShapeAttrList->add( XML_from,
 732             OStringBuffer( 20 ).append( aLeft )
 733             .append( "," ).append( aTop )
 734             .makeStringAndClear() );
 735
 736     m_pShapeAttrList->add( XML_to,
 737             OStringBuffer( 20 ).append( aRight )
 738             .append( "," ).append( aBottom )
 739             .makeStringAndClear() );
 740 }
 741
 742 void VMLExport::AddRectangleDimensions( rtl::OStringBuffer& rBuffer, const Rectangle& rRectangle )
 743 {
 744     if ( rBuffer.getLength() )
 745         rBuffer.append( ";" );
 746
 747     rBuffer.append( "position:absolute;" );
 748
 749     if ( mnGroupLevel == 1 )
 750     {
 751         rBuffer.append( "margin-left:" ).append( double( rRectangle.Left() ) / 20 )
 752             .append( "pt;margin-top:" ).append( double( rRectangle.Top() ) / 20 )
 753             .append( "pt;width:" ).append( double( rRectangle.Right() - rRectangle.Left() ) / 20 )
 754             .append( "pt;height:" ).append( double( rRectangle.Bottom() - rRectangle.Top() ) / 20 )
 755             .append( "pt" );
 756     }
 757     else
 758     {
 759         rBuffer.append( "left:" ).append( rRectangle.Left() )
 760             .append( ";top:" ).append( rRectangle.Top() )
 761             .append( ";width:" ).append( rRectangle.Right() - rRectangle.Left() )
 762             .append( ";height:" ).append( rRectangle.Bottom() - rRectangle.Top() );
 763     }
 764 }
 765
 766 void VMLExport::AddShapeAttribute( sal_Int32 nAttribute, const rtl::OString& rValue )
 767 {
 768     m_pShapeAttrList->add( nAttribute, rValue );
 769 }
 770
 771 extern const char* pShapeTypes[];
 772
 773 sal_Int32 VMLExport::StartShape()
 774 {
 775     if ( m_nShapeType == ESCHER_ShpInst_Nil )
 776         return -1;
 777
 778     // some of the shapes have their own name ;-)
 779     sal_Int32 nShapeElement = -1;
 780     bool bReferToShapeType = false;
 781     switch ( m_nShapeType )
 782     {
 783         case ESCHER_ShpInst_NotPrimitive:   nShapeElement = XML_shape;     break;
 784         case ESCHER_ShpInst_Rectangle:      nShapeElement = XML_rect;      break;
 785         case ESCHER_ShpInst_RoundRectangle: nShapeElement = XML_roundrect; break;
 786         case ESCHER_ShpInst_Ellipse:        nShapeElement = XML_oval;      break;
 787         case ESCHER_ShpInst_Arc:            nShapeElement = XML_arc;       break;
 788         case ESCHER_ShpInst_Line:           nShapeElement = XML_line;      break;
 789         default:
 790             if ( m_nShapeType < ESCHER_ShpInst_COUNT )
 791             {
 792                 nShapeElement = XML_shape;
 793
 794                 // a predefined shape?
 795                 const char* pShapeType = pShapeTypes[ m_nShapeType ];
 796                 if ( pShapeType )
 797                 {
 798                     bReferToShapeType = true;
 799                     if ( !m_pShapeTypeWritten[ m_nShapeType ] )
 800                     {
 801                         m_pSerializer->write( pShapeType );
 802                         m_pShapeTypeWritten[ m_nShapeType ] = true;
 803                     }
 804                 }
 805                 else
 806                 {
 807                     // rectangle is probably the best fallback...
 808                     nShapeElement = XML_rect;
 809                 }
 810             }
 811             break;
 812     }
 813
 814     // add style
 815     m_pShapeAttrList->add( XML_style, m_pShapeStyle->makeStringAndClear() );
 816
 817     if ( nShapeElement >= 0 )
 818     {
 819         if ( bReferToShapeType )
 820         {
 821             m_pShapeAttrList->add( XML_type, OStringBuffer( 20 )
 822                     .append( "shapetype_" ).append( sal_Int32( m_nShapeType ) )
 823                     .makeStringAndClear() );
 824         }
 825
 826         // start of the shape
 827         m_pSerializer->startElementNS( XML_v, nShapeElement, XFastAttributeListRef( m_pShapeAttrList ) );
 828     }
 829
 830     return nShapeElement;
 831 }
 832
 833 void VMLExport::EndShape( sal_Int32 nShapeElement )
 834 {
 835     if ( nShapeElement >= 0 )
 836     {
 837         // end of the shape
 838         m_pSerializer->endElementNS( XML_v, nShapeElement );
 839     }
 840 }