xmloff/source/draw/shapeexport4.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: shapeexport4.cxx,v $
  10  * $Revision: 1.20 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmloff.hxx"
  33
  34 #include <com/sun/star/graphic/XGraphic.hpp>
  35 #include <com/sun/star/graphic/XGraphicProvider.hpp>
  36 #include <com/sun/star/embed/ElementModes.hpp>
  37 #include <com/sun/star/embed/XTransactedObject.hpp>
  38 #include <com/sun/star/io/XSeekableInputStream.hpp>
  39 #include <com/sun/star/drawing/HomogenMatrix.hpp>
  40 #include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
  41 #include <com/sun/star/drawing/ProjectionMode.hpp>
  42 #include <com/sun/star/drawing/ShadeMode.hpp>
  43 #include <com/sun/star/drawing/Direction3D.hpp>
  44 #include <com/sun/star/drawing/Position3D.hpp>
  45 #include <com/sun/star/drawing/CameraGeometry.hpp>
  46 #include <com/sun/star/drawing/DoubleSequence.hpp>
  47
  48 #include <com/sun/star/table/XColumnRowRange.hpp>
  49
  50 #ifndef _XMLOFF_SHAPEEXPORT_HXX
  51 #include <xmloff/shapeexport.hxx>
  52 #endif
  53 #include "sdpropls.hxx"
  54 #include <tools/debug.hxx>
  55 #include <rtl/ustrbuf.hxx>
  56 #include <xmloff/xmlexp.hxx>
  57 #include <xmloff/xmluconv.hxx>
  58 #include "xexptran.hxx"
  59 #include <xmloff/xmltoken.hxx>
  60 #include "EnhancedCustomShapeToken.hxx"
  61 #include <com/sun/star/container/XIdentifierContainer.hpp>
  62 #include <com/sun/star/drawing/ShadeMode.hpp>
  63 #include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
  64 #ifndef _COM_SUN_STAR_DRAWING_ENHANCEDCUSTOMSHAPEPARAMETERPARI_HPP_
  65 #include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
  66 #endif
  67 #include <com/sun/star/drawing/EnhancedCustomShapeGluePointType.hpp>
  68 #include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
  69 #include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
  70 #include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
  71 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
  72 #include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
  73 #include <com/sun/star/beans/PropertyValues.hpp>
  74 #include <rtl/math.hxx>
  75 #include <tools/string.hxx>
  76 #include <basegfx/vector/b3dvector.hxx>
  77
  78 #include "xmlnmspe.hxx"
  79 #include "XMLBase64Export.hxx"
  80
  81 using ::rtl::OUString;
  82 using ::rtl::OUStringBuffer;
  83
  84 using namespace ::com::sun::star;
  85 using namespace ::com::sun::star::io;
  86 using namespace ::xmloff::token;
  87 using namespace ::xmloff::EnhancedCustomShapeToken;
  88
  89 using ::com::sun::star::embed::XStorage;
  90 using ::com::sun::star::uno::UNO_QUERY;
  91 using ::com::sun::star::uno::UNO_QUERY_THROW;
  92 using ::com::sun::star::uno::Reference;
  93 using ::com::sun::star::uno::Sequence;
  94
  95 //////////////////////////////////////////////////////////////////////////////
  96
  97 void ExportParameter( rtl::OUStringBuffer& rStrBuffer, const com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter )
  98 {
  99     if ( rStrBuffer.getLength() )
 100         rStrBuffer.append( (sal_Unicode)' ' );
 101     if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
 102     {
 103         double fNumber = 0.0;
 104         rParameter.Value >>= fNumber;
 105         ::rtl::math::doubleToUStringBuffer( rStrBuffer, fNumber, rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max, '.', sal_True );
 106     }
 107     else
 108     {
 109         sal_Int32 nValue = 0;
 110         rParameter.Value >>= nValue;
 111
 112         switch( rParameter.Type )
 113         {
 114             case com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION :
 115             {
 116                 rStrBuffer.append( (sal_Unicode)'?' );
 117                 rStrBuffer.append( (sal_Unicode)'f' );
 118                 rStrBuffer.append( rtl::OUString::valueOf( nValue ) );
 119             }
 120             break;
 121
 122             case com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT :
 123             {
 124                 rStrBuffer.append( (sal_Unicode)'$' );
 125                 rStrBuffer.append( rtl::OUString::valueOf( nValue ) );
 126             }
 127             break;
 128
 129             case com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM :
 130                 rStrBuffer.append( GetXMLToken( XML_BOTTOM ) ); break;
 131             case com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT :
 132                 rStrBuffer.append( GetXMLToken( XML_RIGHT ) ); break;
 133             case com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP :
 134                 rStrBuffer.append( GetXMLToken( XML_TOP ) ); break;
 135             case com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT :
 136                 rStrBuffer.append( GetXMLToken( XML_LEFT ) ); break;
 137             case com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH :
 138                 rStrBuffer.append( GetXMLToken( XML_XSTRETCH ) ); break;
 139             case com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH :
 140                 rStrBuffer.append( GetXMLToken( XML_YSTRETCH ) ); break;
 141             case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE :
 142                 rStrBuffer.append( GetXMLToken( XML_HASSTROKE ) ); break;
 143             case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL :
 144                 rStrBuffer.append( GetXMLToken( XML_HASFILL ) ); break;
 145             case com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH :
 146                 rStrBuffer.append( GetXMLToken( XML_WIDTH ) ); break;
 147             case com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT :
 148                 rStrBuffer.append( GetXMLToken( XML_HEIGHT ) ); break;
 149             case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH :
 150                 rStrBuffer.append( GetXMLToken( XML_LOGWIDTH ) ); break;
 151             case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT :
 152                 rStrBuffer.append( GetXMLToken( XML_LOGHEIGHT ) ); break;
 153             default :
 154                 rStrBuffer.append( rtl::OUString::valueOf( nValue ) );
 155         }
 156     }
 157 }
 158
 159 void ImpExportEquations( SvXMLExport& rExport, const uno::Sequence< rtl::OUString >& rEquations )
 160 {
 161     sal_Int32 i;
 162     for ( i = 0; i < rEquations.getLength(); i++ )
 163     {
 164         rtl::OUString aStr( String( 'f' ) );
 165         aStr += rtl::OUString::valueOf( i );
 166         rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aStr );
 167
 168         aStr = rEquations[ i ];
 169         sal_Int32 nIndex = 0;
 170         do
 171         {
 172             nIndex = aStr.indexOf( (sal_Unicode)'?', nIndex );
 173             if ( nIndex != -1 )
 174             {
 175                 rtl::OUString aNew( aStr.copy( 0, nIndex + 1 ) );
 176                 aNew += String( 'f' );
 177                 aNew += aStr.copy( nIndex + 1, ( aStr.getLength() - nIndex ) - 1 );
 178                 aStr = aNew;
 179                 nIndex++;
 180             }
 181         } while( nIndex != -1 );
 182         rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FORMULA, aStr );
 183         SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_EQUATION, sal_True, sal_True );
 184     }
 185 }
 186
 187 void ImpExportHandles( SvXMLExport& rExport, const uno::Sequence< beans::PropertyValues >& rHandles )
 188 {
 189     sal_uInt32 i, j, nElements = rHandles.getLength();
 190     if ( nElements )
 191     {
 192         rtl::OUString           aStr;
 193         rtl::OUStringBuffer aStrBuffer;
 194
 195         for ( i = 0; i < nElements; i++ )
 196         {
 197             sal_Bool bPosition = sal_False;
 198             const uno::Sequence< beans::PropertyValue >& rPropSeq = rHandles[ i ];
 199             for ( j = 0; j < (sal_uInt32)rPropSeq.getLength(); j++ )
 200             {
 201                 const beans::PropertyValue& rPropVal = rPropSeq[ j ];
 202                 switch( EASGet( rPropVal.Name ) )
 203                 {
 204                     case EAS_Position :
 205                     {
 206                         com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition;
 207                         if ( rPropVal.Value >>= aPosition )
 208                         {
 209                             ExportParameter( aStrBuffer, aPosition.First );
 210                             ExportParameter( aStrBuffer, aPosition.Second );
 211                             aStr = aStrBuffer.makeStringAndClear();
 212                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POSITION, aStr );
 213                             bPosition = sal_True;
 214                         }
 215                     }
 216                     break;
 217                     case EAS_MirroredX :
 218                     {
 219                         sal_Bool bMirroredX = sal_Bool();
 220                         if ( rPropVal.Value >>= bMirroredX )
 221                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_HORIZONTAL,
 222                                 bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 223                     }
 224                     break;
 225                     case EAS_MirroredY :
 226                     {
 227                         sal_Bool bMirroredY = sal_Bool();
 228                         if ( rPropVal.Value >>= bMirroredY )
 229                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_VERTICAL,
 230                                 bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 231                     }
 232                     break;
 233                     case EAS_Switched :
 234                     {
 235                         sal_Bool bSwitched = sal_Bool();
 236                         if ( rPropVal.Value >>= bSwitched )
 237                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_SWITCHED,
 238                                 bSwitched ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 239                     }
 240                     break;
 241                     case EAS_Polar :
 242                     {
 243                         com::sun::star::drawing::EnhancedCustomShapeParameterPair aPolar;
 244                         if ( rPropVal.Value >>= aPolar )
 245                         {
 246                             ExportParameter( aStrBuffer, aPolar.First );
 247                             ExportParameter( aStrBuffer, aPolar.Second );
 248                             aStr = aStrBuffer.makeStringAndClear();
 249                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POLAR, aStr );
 250                         }
 251                     }
 252                     break;
 253                     case EAS_RadiusRangeMinimum :
 254                     {
 255                         com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum;
 256                         if ( rPropVal.Value >>= aRadiusRangeMinimum )
 257                         {
 258                             ExportParameter( aStrBuffer, aRadiusRangeMinimum );
 259                             aStr = aStrBuffer.makeStringAndClear();
 260                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MINIMUM, aStr );
 261                         }
 262                     }
 263                     break;
 264                     case EAS_RadiusRangeMaximum :
 265                     {
 266                         com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum;
 267                         if ( rPropVal.Value >>= aRadiusRangeMaximum )
 268                         {
 269                             ExportParameter( aStrBuffer, aRadiusRangeMaximum );
 270                             aStr = aStrBuffer.makeStringAndClear();
 271                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MAXIMUM, aStr );
 272                         }
 273                     }
 274                     break;
 275                     case EAS_RangeXMinimum :
 276                     {
 277                         com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMinimum;
 278                         if ( rPropVal.Value >>= aXRangeMinimum )
 279                         {
 280                             ExportParameter( aStrBuffer, aXRangeMinimum );
 281                             aStr = aStrBuffer.makeStringAndClear();
 282                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MINIMUM, aStr );
 283                         }
 284                     }
 285                     break;
 286                     case EAS_RangeXMaximum :
 287                     {
 288                         com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMaximum;
 289                         if ( rPropVal.Value >>= aXRangeMaximum )
 290                         {
 291                             ExportParameter( aStrBuffer, aXRangeMaximum );
 292                             aStr = aStrBuffer.makeStringAndClear();
 293                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MAXIMUM, aStr );
 294                         }
 295                     }
 296                     break;
 297                     case EAS_RangeYMinimum :
 298                     {
 299                         com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMinimum;
 300                         if ( rPropVal.Value >>= aYRangeMinimum )
 301                         {
 302                             ExportParameter( aStrBuffer, aYRangeMinimum );
 303                             aStr = aStrBuffer.makeStringAndClear();
 304                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MINIMUM, aStr );
 305                         }
 306                     }
 307                     break;
 308                     case EAS_RangeYMaximum :
 309                     {
 310                         com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMaximum;
 311                         if ( rPropVal.Value >>= aYRangeMaximum )
 312                         {
 313                             ExportParameter( aStrBuffer, aYRangeMaximum );
 314                             aStr = aStrBuffer.makeStringAndClear();
 315                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MAXIMUM, aStr );
 316                         }
 317                     }
 318                     break;
 319                     default:
 320                         break;
 321                 }
 322             }
 323             if ( bPosition )
 324                 SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_HANDLE, sal_True, sal_True );
 325             else
 326                 rExport.ClearAttrList();
 327         }
 328     }
 329 }
 330
 331 void ImpExportEnhancedPath( SvXMLExport& rExport,
 332     const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rCoordinates,
 333         const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment >& rSegments )
 334 {
 335
 336     rtl::OUString               aStr;
 337     rtl::OUStringBuffer aStrBuffer;
 338
 339     sal_Int32 i, j, k, l;
 340
 341     sal_Int32 nCoords = rCoordinates.getLength();
 342     sal_Int32 nSegments = rSegments.getLength();
 343     sal_Bool bSimpleSegments = nSegments == 0;
 344     if ( bSimpleSegments )
 345         nSegments = 4;
 346     for ( j = i = 0; j < nSegments; j++ )
 347     {
 348         com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
 349         if ( bSimpleSegments )
 350         {
 351             // if there are not enough segments we will default them
 352             switch( j )
 353             {
 354                 case 0 :
 355                 {
 356                     aSegment.Count = 1;
 357                     aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
 358                 }
 359                 break;
 360                 case 1 :
 361                 {
 362                     aSegment.Count = (sal_Int16)Min( nCoords - 1, (sal_Int32)32767 );
 363                     aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
 364                 }
 365                 break;
 366                 case 2 :
 367                 {
 368                     aSegment.Count = 1;
 369                     aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
 370                 }
 371                 break;
 372                 case 3 :
 373                 {
 374                     aSegment.Count = 1;
 375                     aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
 376                 }
 377                 break;
 378             }
 379         }
 380         else
 381             aSegment = rSegments[ j ];
 382
 383         if ( aStrBuffer.getLength() )
 384             aStrBuffer.append( (sal_Unicode)' ' );
 385
 386         sal_Int32 nParameter = 0;
 387         switch( aSegment.Command )
 388         {
 389             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH :
 390                 aStrBuffer.append( (sal_Unicode)'Z' ); break;
 391             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH :
 392                 aStrBuffer.append( (sal_Unicode)'N' ); break;
 393             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL :
 394                 aStrBuffer.append( (sal_Unicode)'F' ); break;
 395             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE :
 396                 aStrBuffer.append( (sal_Unicode)'S' ); break;
 397
 398             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO :
 399                 aStrBuffer.append( (sal_Unicode)'M' ); nParameter = 1; break;
 400             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO :
 401                 aStrBuffer.append( (sal_Unicode)'L' ); nParameter = 1; break;
 402             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO :
 403                 aStrBuffer.append( (sal_Unicode)'C' ); nParameter = 3; break;
 404             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO :
 405                 aStrBuffer.append( (sal_Unicode)'T' ); nParameter = 3; break;
 406             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE :
 407                 aStrBuffer.append( (sal_Unicode)'U' ); nParameter = 3; break;
 408             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO :
 409                 aStrBuffer.append( (sal_Unicode)'A' ); nParameter = 4; break;
 410             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC :
 411                 aStrBuffer.append( (sal_Unicode)'B' ); nParameter = 4; break;
 412             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO :
 413                 aStrBuffer.append( (sal_Unicode)'W' ); nParameter = 4; break;
 414             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC :
 415                 aStrBuffer.append( (sal_Unicode)'V' ); nParameter = 4; break;
 416             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX :
 417                 aStrBuffer.append( (sal_Unicode)'X' ); nParameter = 1; break;
 418             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY :
 419                 aStrBuffer.append( (sal_Unicode)'Y' ); nParameter = 1; break;
 420             case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO :
 421                 aStrBuffer.append( (sal_Unicode)'Q' ); nParameter = 2; break;
 422
 423             default : // ups, seems to be something wrong
 424             {
 425                 aSegment.Count = 1;
 426                 aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
 427             }
 428             break;
 429         }
 430         if ( nParameter )
 431         {
 432             for ( k = 0; k < aSegment.Count; k++ )
 433             {
 434                 if ( ( i + nParameter ) <= nCoords )
 435                 {
 436                     for ( l = 0; l < nParameter; l++ )
 437                     {
 438                         ExportParameter( aStrBuffer, rCoordinates[ i ].First );
 439                         ExportParameter( aStrBuffer, rCoordinates[ i++ ].Second );
 440                     }
 441                 }
 442                 else
 443                 {
 444                     j = nSegments;      // error -> exiting
 445                     break;
 446                 }
 447             }
 448         }
 449     }
 450     aStr = aStrBuffer.makeStringAndClear();
 451     rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ENHANCED_PATH, aStr );
 452 }
 453
 454 void ImpExportEnhancedGeometry( SvXMLExport& rExport, const uno::Reference< beans::XPropertySet >& xPropSet )
 455 {
 456     sal_Bool bEquations = sal_False;
 457     uno::Sequence< rtl::OUString > aEquations;
 458
 459     sal_Bool bHandles = sal_False;
 460     uno::Sequence< beans::PropertyValues > aHandles;
 461
 462     sal_Bool bCoordinates = sal_False;
 463     uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > aSegments;
 464     uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aCoordinates;
 465
 466     uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues;
 467
 468     rtl::OUString               aStr;
 469     rtl::OUStringBuffer aStrBuffer;
 470     SvXMLUnitConverter& rUnitConverter = rExport.GetMM100UnitConverter();
 471
 472     uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
 473
 474     // geometry
 475     const rtl::OUString sCustomShapeGeometry( RTL_CONSTASCII_USTRINGPARAM( "CustomShapeGeometry" ) );
 476     if ( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sCustomShapeGeometry ) )
 477     {
 478         uno::Any aGeoPropSet( xPropSet->getPropertyValue( sCustomShapeGeometry ) );
 479         uno::Sequence< beans::PropertyValue > aGeoPropSeq;
 480
 481         if ( aGeoPropSet >>= aGeoPropSeq )
 482         {
 483             const rtl::OUString sCustomShapeType( RTL_CONSTASCII_USTRINGPARAM( "NonPrimitive" ) );
 484             rtl::OUString aCustomShapeType( sCustomShapeType );
 485
 486             sal_Int32 j, nGeoPropCount = aGeoPropSeq.getLength();
 487             for ( j = 0; j < nGeoPropCount; j++ )
 488             {
 489                 const beans::PropertyValue& rGeoProp = aGeoPropSeq[ j ];
 490                 switch( EASGet( rGeoProp.Name ) )
 491                 {
 492                     case EAS_Type :
 493                     {
 494                         rGeoProp.Value >>= aCustomShapeType;
 495                     }
 496                     break;
 497                     case EAS_MirroredX :
 498                     {
 499                         sal_Bool bMirroredX = sal_Bool();
 500                         if ( rGeoProp.Value >>= bMirroredX )
 501                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_HORIZONTAL,
 502                                 bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 503                     }
 504                     break;
 505                     case EAS_MirroredY :
 506                     {
 507                         sal_Bool bMirroredY = sal_Bool();
 508                         if ( rGeoProp.Value >>= bMirroredY )
 509                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_VERTICAL,
 510                                 bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 511                     }
 512                     break;
 513                     case EAS_ViewBox :
 514                     {
 515                         awt::Rectangle aRect;
 516                         if ( rGeoProp.Value >>= aRect )
 517                         {
 518                             SdXMLImExViewBox aViewBox( aRect.X, aRect.Y, aRect.Width, aRect.Height );
 519                             rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() );
 520                         }
 521                     }
 522                     break;
 523                     case EAS_TextRotateAngle :
 524                     {
 525                         double fTextRotateAngle = 0;
 526                         if ( rGeoProp.Value >>= fTextRotateAngle )
 527                         {
 528                             rUnitConverter.convertDouble( aStrBuffer, fTextRotateAngle );
 529                             aStr = aStrBuffer.makeStringAndClear();
 530                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_ROTATE_ANGLE, aStr );
 531                         }
 532                     }
 533                     break;
 534                     case EAS_Extrusion :
 535                     {
 536                         uno::Sequence< beans::PropertyValue > aExtrusionPropSeq;
 537                         if ( rGeoProp.Value >>= aExtrusionPropSeq )
 538                         {
 539                             sal_Int32 i, nCount = aExtrusionPropSeq.getLength();
 540                             for ( i = 0; i < nCount; i++ )
 541                             {
 542                                 const beans::PropertyValue& rProp = aExtrusionPropSeq[ i ];
 543                                 switch( EASGet( rProp.Name ) )
 544                                 {
 545                                     case EAS_Extrusion :
 546                                     {
 547                                         sal_Bool bExtrusionOn = sal_Bool();
 548                                         if ( rProp.Value >>= bExtrusionOn )
 549                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION,
 550                                                 bExtrusionOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 551                                     }
 552                                     break;
 553                                     case EAS_Brightness :
 554                                     {
 555                                         double fExtrusionBrightness = 0;
 556                                         if ( rProp.Value >>= fExtrusionBrightness )
 557                                         {
 558                                             rUnitConverter.convertDouble( aStrBuffer, fExtrusionBrightness, sal_False, MAP_RELATIVE, MAP_RELATIVE );
 559                                             aStrBuffer.append( (sal_Unicode)'%' );
 560                                             aStr = aStrBuffer.makeStringAndClear();
 561                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_BRIGHTNESS, aStr );
 562                                         }
 563                                     }
 564                                     break;
 565                                     case EAS_Depth :
 566                                     {
 567                                         com::sun::star::drawing::EnhancedCustomShapeParameterPair aDepthParaPair;
 568                                         if ( rProp.Value >>= aDepthParaPair )
 569                                         {
 570                                             double fDepth = 0;
 571                                             if ( aDepthParaPair.First.Value >>= fDepth )
 572                                             {
 573                                                 rExport.GetMM100UnitConverter().convertDouble( aStrBuffer, fDepth, sal_True );
 574                                                 ExportParameter( aStrBuffer, aDepthParaPair.Second );
 575                                                 aStr = aStrBuffer.makeStringAndClear();
 576                                                 rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DEPTH, aStr );
 577                                             }
 578                                         }
 579                                     }
 580                                     break;
 581                                     case EAS_Diffusion :
 582                                     {
 583                                         double fExtrusionDiffusion = 0;
 584                                         if ( rProp.Value >>= fExtrusionDiffusion )
 585                                         {
 586                                             rUnitConverter.convertDouble( aStrBuffer, fExtrusionDiffusion, sal_False, MAP_RELATIVE, MAP_RELATIVE );
 587                                             aStrBuffer.append( (sal_Unicode)'%' );
 588                                             aStr = aStrBuffer.makeStringAndClear();
 589                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DIFFUSION, aStr );
 590                                         }
 591                                     }
 592                                     break;
 593                                     case EAS_NumberOfLineSegments :
 594                                     {
 595                                         sal_Int32 nExtrusionNumberOfLineSegments = 0;
 596                                         if ( rProp.Value >>= nExtrusionNumberOfLineSegments )
 597                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_NUMBER_OF_LINE_SEGMENTS, rtl::OUString::valueOf( nExtrusionNumberOfLineSegments ) );
 598                                     }
 599                                     break;
 600                                     case EAS_LightFace :
 601                                     {
 602                                         sal_Bool bExtrusionLightFace = sal_Bool();
 603                                         if ( rProp.Value >>= bExtrusionLightFace )
 604                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_LIGHT_FACE,
 605                                                 bExtrusionLightFace ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 606                                     }
 607                                     break;
 608                                     case EAS_FirstLightHarsh :
 609                                     {
 610                                         sal_Bool bExtrusionFirstLightHarsh = sal_Bool();
 611                                         if ( rProp.Value >>= bExtrusionFirstLightHarsh )
 612                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_HARSH,
 613                                                 bExtrusionFirstLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 614                                     }
 615                                     break;
 616                                     case EAS_SecondLightHarsh :
 617                                     {
 618                                         sal_Bool bExtrusionSecondLightHarsh = sal_Bool();
 619                                         if ( rProp.Value >>= bExtrusionSecondLightHarsh )
 620                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_HARSH,
 621                                                 bExtrusionSecondLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 622                                     }
 623                                     break;
 624                                     case EAS_FirstLightLevel :
 625                                     {
 626                                         double fExtrusionFirstLightLevel = 0;
 627                                         if ( rProp.Value >>= fExtrusionFirstLightLevel )
 628                                         {
 629                                             rUnitConverter.convertDouble( aStrBuffer, fExtrusionFirstLightLevel, sal_False, MAP_RELATIVE, MAP_RELATIVE );
 630                                             aStrBuffer.append( (sal_Unicode)'%' );
 631                                             aStr = aStrBuffer.makeStringAndClear();
 632                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_LEVEL, aStr );
 633                                         }
 634                                     }
 635                                     break;
 636                                     case EAS_SecondLightLevel :
 637                                     {
 638                                         double fExtrusionSecondLightLevel = 0;
 639                                         if ( rProp.Value >>= fExtrusionSecondLightLevel )
 640                                         {
 641                                             rUnitConverter.convertDouble( aStrBuffer, fExtrusionSecondLightLevel, sal_False, MAP_RELATIVE, MAP_RELATIVE );
 642                                             aStrBuffer.append( (sal_Unicode)'%' );
 643                                             aStr = aStrBuffer.makeStringAndClear();
 644                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_LEVEL, aStr );
 645                                         }
 646                                     }
 647                                     break;
 648                                     case EAS_FirstLightDirection :
 649                                     {
 650                                         drawing::Direction3D aExtrusionFirstLightDirection;
 651                                         if ( rProp.Value >>= aExtrusionFirstLightDirection )
 652                                         {
 653                                             ::basegfx::B3DVector aVec3D( aExtrusionFirstLightDirection.DirectionX, aExtrusionFirstLightDirection.DirectionY,
 654                                                 aExtrusionFirstLightDirection.DirectionZ );
 655                                             rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
 656                                             aStr = aStrBuffer.makeStringAndClear();
 657                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_DIRECTION, aStr );
 658                                         }
 659                                     }
 660                                     break;
 661                                     case EAS_SecondLightDirection :
 662                                     {
 663                                         drawing::Direction3D aExtrusionSecondLightDirection;
 664                                         if ( rProp.Value >>= aExtrusionSecondLightDirection )
 665                                         {
 666                                             ::basegfx::B3DVector aVec3D( aExtrusionSecondLightDirection.DirectionX, aExtrusionSecondLightDirection.DirectionY,
 667                                                 aExtrusionSecondLightDirection.DirectionZ );
 668                                             rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
 669                                             aStr = aStrBuffer.makeStringAndClear();
 670                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_DIRECTION, aStr );
 671                                         }
 672                                     }
 673                                     break;
 674                                     case EAS_Metal :
 675                                     {
 676                                         sal_Bool bExtrusionMetal = sal_Bool();
 677                                         if ( rProp.Value >>= bExtrusionMetal )
 678                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_METAL,
 679                                                 bExtrusionMetal ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 680                                     }
 681                                     break;
 682                                     case EAS_ShadeMode :
 683                                     {
 684                                         // shadeMode
 685                                         drawing::ShadeMode eShadeMode;
 686                                         if( rProp.Value >>= eShadeMode )
 687                                         {
 688                                             if( eShadeMode == drawing::ShadeMode_FLAT )
 689                                                 aStr = GetXMLToken( XML_FLAT );
 690                                             else if( eShadeMode == drawing::ShadeMode_PHONG )
 691                                                 aStr = GetXMLToken( XML_PHONG );
 692                                             else if( eShadeMode == drawing::ShadeMode_SMOOTH )
 693                                                 aStr = GetXMLToken( XML_GOURAUD );
 694                                             else
 695                                                 aStr = GetXMLToken( XML_DRAFT );
 696                                         }
 697                                         else
 698                                         {
 699                                             // ShadeMode enum not there, write default
 700                                             aStr = GetXMLToken( XML_FLAT);
 701                                         }
 702                                         rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr );
 703                                     }
 704                                     break;
 705                                     case EAS_RotateAngle :
 706                                     {
 707                                         com::sun::star::drawing::EnhancedCustomShapeParameterPair aRotateAngleParaPair;
 708                                         if ( rProp.Value >>= aRotateAngleParaPair )
 709                                         {
 710                                             ExportParameter( aStrBuffer, aRotateAngleParaPair.First );
 711                                             ExportParameter( aStrBuffer, aRotateAngleParaPair.Second );
 712                                             aStr = aStrBuffer.makeStringAndClear();
 713                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_ANGLE, aStr );
 714                                         }
 715                                     }
 716                                     break;
 717                                     case EAS_RotationCenter :
 718                                     {
 719                                         drawing::Direction3D aExtrusionRotationCenter;
 720                                         if ( rProp.Value >>= aExtrusionRotationCenter )
 721                                         {
 722                                             ::basegfx::B3DVector aVec3D( aExtrusionRotationCenter.DirectionX, aExtrusionRotationCenter.DirectionY,
 723                                                 aExtrusionRotationCenter.DirectionZ );
 724                                             rUnitConverter.convertB3DVector( aStrBuffer, aVec3D );
 725                                             aStr = aStrBuffer.makeStringAndClear();
 726                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_CENTER, aStr );
 727                                         }
 728                                     }
 729                                     break;
 730                                     case EAS_Shininess :
 731                                     {
 732                                         double fExtrusionShininess = 0;
 733                                         if ( rProp.Value >>= fExtrusionShininess )
 734                                         {
 735                                             rUnitConverter.convertDouble( aStrBuffer, fExtrusionShininess, sal_False, MAP_RELATIVE, MAP_RELATIVE );
 736                                             aStrBuffer.append( (sal_Unicode)'%' );
 737                                             aStr = aStrBuffer.makeStringAndClear();
 738                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SHININESS, aStr );
 739                                         }
 740                                     }
 741                                     break;
 742                                     case EAS_Skew :
 743                                     {
 744                                         com::sun::star::drawing::EnhancedCustomShapeParameterPair aSkewParaPair;
 745                                         if ( rProp.Value >>= aSkewParaPair )
 746                                         {
 747                                             ExportParameter( aStrBuffer, aSkewParaPair.First );
 748                                             ExportParameter( aStrBuffer, aSkewParaPair.Second );
 749                                             aStr = aStrBuffer.makeStringAndClear();
 750                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SKEW, aStr );
 751                                         }
 752                                     }
 753                                     break;
 754                                     case EAS_Specularity :
 755                                     {
 756                                         double fExtrusionSpecularity = 0;
 757                                         if ( rProp.Value >>= fExtrusionSpecularity )
 758                                         {
 759                                             rUnitConverter.convertDouble( aStrBuffer, fExtrusionSpecularity, sal_False, MAP_RELATIVE, MAP_RELATIVE );
 760                                             aStrBuffer.append( (sal_Unicode)'%' );
 761                                             aStr = aStrBuffer.makeStringAndClear();
 762                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SPECULARITY, aStr );
 763                                         }
 764                                     }
 765                                     break;
 766                                     case EAS_ProjectionMode :
 767                                     {
 768                                         drawing::ProjectionMode eProjectionMode;
 769                                         if ( rProp.Value >>= eProjectionMode )
 770                                             rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_PROJECTION,
 771                                                 eProjectionMode == drawing::ProjectionMode_PARALLEL ? GetXMLToken( XML_PARALLEL ) : GetXMLToken( XML_PERSPECTIVE ) );
 772                                     }
 773                                     break;
 774                                     case EAS_ViewPoint :
 775                                     {
 776                                         drawing::Position3D aExtrusionViewPoint;
 777                                         if ( rProp.Value >>= aExtrusionViewPoint )
 778                                         {
 779                                             rUnitConverter.convertPosition3D( aStrBuffer, aExtrusionViewPoint );
 780                                             aStr = aStrBuffer.makeStringAndClear();
 781                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_VIEWPOINT, aStr );
 782                                         }
 783                                     }
 784                                     break;
 785                                     case EAS_Origin :
 786                                     {
 787                                         com::sun::star::drawing::EnhancedCustomShapeParameterPair aOriginParaPair;
 788                                         if ( rProp.Value >>= aOriginParaPair )
 789                                         {
 790                                             ExportParameter( aStrBuffer, aOriginParaPair.First );
 791                                             ExportParameter( aStrBuffer, aOriginParaPair.Second );
 792                                             aStr = aStrBuffer.makeStringAndClear();
 793                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ORIGIN, aStr );
 794                                         }
 795                                     }
 796                                     break;
 797                                     case EAS_Color :
 798                                     {
 799                                         sal_Bool bExtrusionColor = sal_Bool();
 800                                         if ( rProp.Value >>= bExtrusionColor )
 801                                         {
 802                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_COLOR,
 803                                                 bExtrusionColor ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 804                                         }
 805                                     }
 806                                     break;
 807                                     default:
 808                                         break;
 809                                 }
 810                             }
 811                         }
 812                     }
 813                     break;
 814                     case EAS_TextPath :
 815                     {
 816                         uno::Sequence< beans::PropertyValue > aTextPathPropSeq;
 817                         if ( rGeoProp.Value >>= aTextPathPropSeq )
 818                         {
 819                             sal_Int32 i, nCount = aTextPathPropSeq.getLength();
 820                             for ( i = 0; i < nCount; i++ )
 821                             {
 822                                 const beans::PropertyValue& rProp = aTextPathPropSeq[ i ];
 823                                 switch( EASGet( rProp.Name ) )
 824                                 {
 825                                     case EAS_TextPath :
 826                                     {
 827                                         sal_Bool bTextPathOn = sal_Bool();
 828                                         if ( rProp.Value >>= bTextPathOn )
 829                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH,
 830                                                 bTextPathOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 831                                     }
 832                                     break;
 833                                     case EAS_TextPathMode :
 834                                     {
 835                                         com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode;
 836                                         if ( rProp.Value >>= eTextPathMode )
 837                                         {
 838                                             switch ( eTextPathMode )
 839                                             {
 840                                                 case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL: aStr = GetXMLToken( XML_NORMAL ); break;
 841                                                 case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH      : aStr = GetXMLToken( XML_PATH );   break;
 842                                                 case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE : aStr = GetXMLToken( XML_SHAPE );  break;
 843                                                 default:
 844                                                     break;
 845                                             }
 846                                             if ( aStr.getLength() )
 847                                                 rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_MODE, aStr );
 848                                         }
 849                                     }
 850                                     break;
 851                                     case EAS_ScaleX :
 852                                     {
 853                                         sal_Bool bScaleX = sal_Bool();
 854                                         if ( rProp.Value >>= bScaleX )
 855                                         {
 856                                             aStr = bScaleX ? GetXMLToken( XML_SHAPE ) : GetXMLToken( XML_PATH );
 857                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SCALE, aStr );
 858                                         }
 859                                     }
 860                                     break;
 861                                     case EAS_SameLetterHeights :
 862                                     {
 863                                         sal_Bool bSameLetterHeights = sal_Bool();
 864                                         if ( rProp.Value >>= bSameLetterHeights )
 865                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SAME_LETTER_HEIGHTS,
 866                                                 bSameLetterHeights ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 867                                     }
 868                                     break;
 869                                     default:
 870                                         break;
 871                                 }
 872                             }
 873                         }
 874                     }
 875                     break;
 876                     case EAS_Path :
 877                     {
 878                         uno::Sequence< beans::PropertyValue > aPathPropSeq;
 879                         if ( rGeoProp.Value >>= aPathPropSeq )
 880                         {
 881                             sal_Int32 i, nCount = aPathPropSeq.getLength();
 882                             for ( i = 0; i < nCount; i++ )
 883                             {
 884                                 const beans::PropertyValue& rProp = aPathPropSeq[ i ];
 885                                 switch( EASGet( rProp.Name ) )
 886                                 {
 887                                     case EAS_ExtrusionAllowed :
 888                                     {
 889                                         sal_Bool bExtrusionAllowed = sal_Bool();
 890                                         if ( rProp.Value >>= bExtrusionAllowed )
 891                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ALLOWED,
 892                                                 bExtrusionAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 893                                     }
 894                                     break;
 895                                     case EAS_ConcentricGradientFillAllowed :
 896                                     {
 897                                         sal_Bool bConcentricGradientFillAllowed = sal_Bool();
 898                                         if ( rProp.Value >>= bConcentricGradientFillAllowed )
 899                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONCENTRIC_GRADIENT_FILL_ALLOWED,
 900                                                 bConcentricGradientFillAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 901                                     }
 902                                     break;
 903                                     case EAS_TextPathAllowed  :
 904                                     {
 905                                         sal_Bool bTextPathAllowed = sal_Bool();
 906                                         if ( rProp.Value >>= bTextPathAllowed )
 907                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_ALLOWED,
 908                                                 bTextPathAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) );
 909                                     }
 910                                     break;
 911                                     case EAS_GluePoints :
 912                                     {
 913                                         com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> aGluePoints;
 914                                         if ( rProp.Value >>= aGluePoints )
 915                                         {
 916                                             sal_Int32 k, nElements = aGluePoints.getLength();
 917                                             if ( nElements )
 918                                             {
 919                                                 for( k = 0; k < nElements; k++ )
 920                                                 {
 921                                                     ExportParameter( aStrBuffer, aGluePoints[ k ].First );
 922                                                     ExportParameter( aStrBuffer, aGluePoints[ k ].Second );
 923                                                 }
 924                                                 aStr = aStrBuffer.makeStringAndClear();
 925                                             }
 926                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINTS, aStr );
 927                                         }
 928                                     }
 929                                     break;
 930                                     case EAS_GluePointType :
 931                                     {
 932                                         sal_Int16 nGluePointType = sal_Int16();
 933                                         if ( rProp.Value >>= nGluePointType )
 934                                         {
 935                                             switch ( nGluePointType )
 936                                             {
 937                                                 case com::sun::star::drawing::EnhancedCustomShapeGluePointType::NONE     : aStr = GetXMLToken( XML_NONE );    break;
 938                                                 case com::sun::star::drawing::EnhancedCustomShapeGluePointType::SEGMENTS : aStr = GetXMLToken( XML_SEGMENTS ); break;
 939                                                 case com::sun::star::drawing::EnhancedCustomShapeGluePointType::RECT     : aStr = GetXMLToken( XML_RECTANGLE ); break;
 940                                             }
 941                                             if ( aStr.getLength() )
 942                                                 rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINT_TYPE, aStr );
 943                                         }
 944                                     }
 945                                     break;
 946                                     case EAS_Coordinates :
 947                                     {
 948                                         bCoordinates = ( rProp.Value >>= aCoordinates );
 949                                     }
 950                                     break;
 951                                     case EAS_Segments :
 952                                     {
 953                                         rProp.Value >>= aSegments;
 954                                     }
 955                                     break;
 956                                     case EAS_StretchX :
 957                                     {
 958                                         sal_Int32 nStretchPoint = 0;
 959                                         if ( rProp.Value >>= nStretchPoint )
 960                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_X, rtl::OUString::valueOf( nStretchPoint ) );
 961                                     }
 962                                     break;
 963                                     case EAS_StretchY :
 964                                     {
 965                                         sal_Int32 nStretchPoint = 0;
 966                                         if ( rProp.Value >>= nStretchPoint )
 967                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_Y, rtl::OUString::valueOf( nStretchPoint ) );
 968                                     }
 969                                     break;
 970                                     case EAS_TextFrames :
 971                                     {
 972                                         com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aPathTextFrames;
 973                                         if ( rProp.Value >>= aPathTextFrames )
 974                                         {
 975                                             if ( (sal_uInt16)aPathTextFrames.getLength() )
 976                                             {
 977                                                 sal_uInt16 k, nElements = (sal_uInt16)aPathTextFrames.getLength();
 978                                                 for ( k = 0; k < nElements; k++ )
 979                                                 {
 980                                                     ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.First );
 981                                                     ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.Second );
 982                                                     ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.First );
 983                                                     ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.Second );
 984                                                 }
 985                                                 aStr = aStrBuffer.makeStringAndClear();
 986                                             }
 987                                             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_AREAS, aStr );
 988                                         }
 989                                     }
 990                                     break;
 991                                     default:
 992                                         break;
 993                                 }
 994                             }
 995                         }
 996                     }
 997                     break;
 998                     case EAS_Equations :
 999                     {
1000                         bEquations = ( rGeoProp.Value >>= aEquations );
1001                     }
1002                     break;
1003                     case EAS_Handles :
1004                     {
1005                         bHandles = ( rGeoProp.Value >>= aHandles );
1006                     }
1007                     break;
1008                     case EAS_AdjustmentValues :
1009                     {
1010                         rGeoProp.Value >>= aAdjustmentValues;
1011                     }
1012                     break;
1013                     default:
1014                         break;
1015                 }
1016             }   // for
1017             rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TYPE, aCustomShapeType );
1018
1019             // adjustments
1020             sal_Int32 nAdjustmentValues = aAdjustmentValues.getLength();
1021             if ( nAdjustmentValues )
1022             {
1023                 sal_Int32 i, nValue = 0;
1024                 for ( i = 0; i < nAdjustmentValues; i++ )
1025                 {
1026                     if ( i )
1027                         aStrBuffer.append( (sal_Unicode)' ' );
1028
1029                     const com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue& rAdj = aAdjustmentValues[ i ];
1030                     if ( rAdj.State == beans::PropertyState_DIRECT_VALUE )
1031                     {
1032                         if ( rAdj.Value.getValueTypeClass() == uno::TypeClass_DOUBLE )
1033                         {
1034                             double fValue;
1035                             rAdj.Value >>= fValue;
1036                             rUnitConverter.convertDouble( aStrBuffer, fValue );
1037                         }
1038                         else
1039                         {
1040                             rAdj.Value >>= nValue;
1041                             rUnitConverter.convertNumber( aStrBuffer, nValue );
1042                         }
1043                     }
1044                     else
1045                         rUnitConverter.convertNumber( aStrBuffer, 0 );                  // this should not be, but better than setting nothing
1046                 }
1047                 aStr = aStrBuffer.makeStringAndClear();
1048                 rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MODIFIERS, aStr );
1049             }
1050             if ( bCoordinates )
1051                 ImpExportEnhancedPath( rExport, aCoordinates, aSegments );
1052         }
1053     }
1054     SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_ENHANCED_GEOMETRY, sal_True, sal_True );
1055     if ( bEquations )
1056         ImpExportEquations( rExport, aEquations );
1057     if ( bHandles )
1058         ImpExportHandles( rExport, aHandles );
1059 }
1060
1061 void XMLShapeExport::ImpExportCustomShape(
1062     const uno::Reference< drawing::XShape >& xShape,
1063     XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint )
1064 {
1065     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1066     if ( xPropSet.is() )
1067     {
1068         rtl::OUString aStr;
1069         uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
1070
1071         // Transformation
1072         ImpExportNewTrans( xPropSet, nFeatures, pRefPoint );
1073
1074         if ( xPropSetInfo.is() )
1075         {
1076             const rtl::OUString sCustomShapeEngine( RTL_CONSTASCII_USTRINGPARAM( "CustomShapeEngine" ) );
1077             if ( xPropSetInfo->hasPropertyByName( sCustomShapeEngine ) )
1078             {
1079                 uno::Any aEngine( xPropSet->getPropertyValue( sCustomShapeEngine ) );
1080                 if ( ( aEngine >>= aStr ) && aStr.getLength() )
1081                     mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ENGINE, aStr );
1082             }
1083             const rtl::OUString sCustomShapeData( RTL_CONSTASCII_USTRINGPARAM( "CustomShapeData" ) );
1084             if ( xPropSetInfo->hasPropertyByName( sCustomShapeData ) )
1085             {
1086                 uno::Any aData( xPropSet->getPropertyValue( sCustomShapeData ) );
1087                 if ( ( aData >>= aStr ) && aStr.getLength() )
1088                     mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DATA, aStr );
1089             }
1090         }
1091         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1092         SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, bCreateNewline, sal_True );
1093         ImpExportDescription( xShape ); // #i68101#
1094         ImpExportEvents( xShape );
1095         ImpExportGluePoints( xShape );
1096         ImpExportText( xShape );
1097         ImpExportEnhancedGeometry( mrExport, xPropSet );
1098     }
1099 }
1100
1101 void XMLShapeExport::ImpExportTableShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType /*eShapeType*/, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint )
1102 {
1103     uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1104     uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
1105
1106     DBG_ASSERT( xPropSet.is() && xNamed.is(), "xmloff::XMLShapeExport::ImpExportTableShape(), tabe shape is not implementing needed interfaces");
1107     if(xPropSet.is() && xNamed.is()) try
1108     {
1109         // Transformation
1110         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1111
1112         sal_Bool bIsEmptyPresObj = sal_False;
1113
1114         // presentation settings
1115 //              if(eShapeType == XmlShapeTypePresTableShape)
1116 //                      bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) );
1117
1118         const bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 );
1119         const bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED));
1120
1121         SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, XML_FRAME, bCreateNewline, sal_True );
1122
1123         if( !bIsEmptyPresObj )
1124         {
1125             uno::Reference< container::XNamed > xTemplate( xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TableTemplate" ) ) ), uno::UNO_QUERY );
1126             if( xTemplate.is() )
1127             {
1128                 const OUString sTemplate( xTemplate->getName() );
1129                 if( sTemplate.getLength() )
1130                 {
1131                     mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TEMPLATE_NAME, sTemplate );
1132
1133                     for( const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; pEntry->msApiName; pEntry++ )
1134                     {
1135                         try
1136                         {
1137                             sal_Bool bBool = sal_False;
1138                             const OUString sAPIPropertyName( OUString(pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US ) );
1139
1140                             xPropSet->getPropertyValue( sAPIPropertyName ) >>= bBool;
1141                             if( bBool )
1142                                 mrExport.AddAttribute(pEntry->mnNameSpace, pEntry->meXMLName, XML_TRUE );
1143                         }
1144                         catch( uno::Exception& )
1145                         {
1146                             DBG_ERROR("XMLShapeExport::ImpExportTableShape(), exception caught!");
1147                         }
1148                     }
1149                 }
1150             }
1151             uno::Reference< table::XColumnRowRange > xRange( xPropSet->getPropertyValue( msModel ), uno::UNO_QUERY_THROW );
1152
1153             GetShapeTableExport()->exportTable( xRange );
1154
1155             uno::Reference< graphic::XGraphic > xGraphic( xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "ReplacementGraphic" ) ) ), uno::UNO_QUERY );
1156             if( xGraphic.is() ) try
1157             {
1158                 Reference< lang::XMultiServiceFactory > xSM( GetExport().getServiceFactory(), UNO_QUERY_THROW );
1159
1160                 uno::Reference< embed::XStorage > xPictureStorage;
1161                 uno::Reference< embed::XStorage > xStorage;
1162                 uno::Reference< io::XStream > xPictureStream;
1163
1164                 OUString sPictureName;
1165                 if( bExportEmbedded )
1166                 {
1167                     xPictureStream.set( xSM->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.MemoryStream" ) ) ), UNO_QUERY_THROW );
1168                 }
1169                 else
1170                 {
1171                     xStorage.set( GetExport().GetTargetStorage(), UNO_QUERY_THROW );
1172
1173                     xPictureStorage.set( xStorage->openStorageElement( OUString( RTL_CONSTASCII_USTRINGPARAM( "Pictures" ) ), ::embed::ElementModes::READWRITE ), uno::UNO_QUERY_THROW );
1174                     const OUString sPrefix( RTL_CONSTASCII_USTRINGPARAM("TablePreview") );
1175                     const OUString sSuffix( RTL_CONSTASCII_USTRINGPARAM(".svm") );
1176
1177                     sal_Int32 nIndex = 0;
1178                     do
1179                     {
1180                         sPictureName = sPrefix;
1181                         sPictureName += OUString::valueOf( ++nIndex );
1182                         sPictureName += sSuffix;
1183                     }
1184                     while( xPictureStorage->hasByName( sPictureName ) );
1185
1186                     xPictureStream.set( xPictureStorage->openStreamElement( sPictureName, ::embed::ElementModes::READWRITE ), UNO_QUERY_THROW );
1187                 }
1188
1189                 Reference< graphic::XGraphicProvider > xProvider( xSM->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.graphic.GraphicProvider" ) ) ), UNO_QUERY_THROW );
1190                 Sequence< beans::PropertyValue > aArgs( 2 );
1191                 aArgs[ 0 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "MimeType" ) );
1192                 aArgs[ 0 ].Value <<= OUString( RTL_CONSTASCII_USTRINGPARAM( "image/x-vclgraphic" ) );
1193                 aArgs[ 1 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "OutputStream" ) );
1194                 aArgs[ 1 ].Value <<= xPictureStream->getOutputStream();
1195                 xProvider->storeGraphic( xGraphic, aArgs );
1196
1197                 if( xPictureStorage.is() )
1198                 {
1199                     Reference< embed::XTransactedObject > xTrans( xPictureStorage, UNO_QUERY );
1200                     if( xTrans.is() )
1201                         xTrans->commit();
1202                 }
1203
1204                 if( !bExportEmbedded )
1205                 {
1206                     OUString sURL( RTL_CONSTASCII_USTRINGPARAM( "Pictures/" ) );
1207                     sURL += sPictureName;
1208                     mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
1209                     mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1210                     mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1211                     mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1212                 }
1213
1214                 SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, sal_False, sal_True );
1215
1216                 if( bExportEmbedded )
1217                 {
1218                     Reference< XSeekableInputStream > xSeekable( xPictureStream, UNO_QUERY_THROW );
1219                     xSeekable->seek(0);
1220
1221                     XMLBase64Export aBase64Exp( GetExport() );
1222                     aBase64Exp.exportOfficeBinaryDataElement( Reference < XInputStream >( xPictureStream, UNO_QUERY_THROW ) );
1223                 }
1224             }
1225             catch( uno::Exception& )
1226             {
1227                 DBG_ERROR("xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!");
1228             }
1229         }
1230
1231         ImpExportEvents( xShape );
1232         ImpExportGluePoints( xShape );
1233         ImpExportDescription( xShape ); // #i68101#
1234     }
1235     catch( uno::Exception& )
1236     {
1237         DBG_ERROR( "xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!" );
1238     }
1239 }