xmloff/source/draw/shapeexport2.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: shapeexport2.cxx,v $
  10  * $Revision: 1.66 $
  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 #include "unointerfacetouniqueidentifiermapper.hxx"
  34 #include <com/sun/star/text/XText.hpp>
  35 #include <com/sun/star/container/XNamed.hpp>
  36 #include <com/sun/star/container/XEnumerationAccess.hpp>
  37 #include <com/sun/star/chart/XChartDocument.hpp>
  38 #include <com/sun/star/drawing/CircleKind.hpp>
  39 #include <com/sun/star/drawing/ConnectorType.hpp>
  40 #include <com/sun/star/drawing/XControlShape.hpp>
  41 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
  42 #include <com/sun/star/document/XEventsSupplier.hpp>
  43 #include <com/sun/star/drawing/HomogenMatrix3.hpp>
  44 #include <com/sun/star/media/ZoomLevel.hpp>
  45 #include "anim.hxx"
  46
  47 #ifndef _XMLOFF_SHAPEEXPORT_HXX
  48 #include <xmloff/shapeexport.hxx>
  49 #endif
  50 #include "sdpropls.hxx"
  51 #include <tools/debug.hxx>
  52 #include <tools/urlobj.hxx>
  53 #include <rtl/ustrbuf.hxx>
  54 #include <xmloff/xmlexp.hxx>
  55 #include <xmloff/xmluconv.hxx>
  56 #include "XMLImageMapExport.hxx"
  57 #include "xexptran.hxx"
  58 #include <vcl/salbtype.hxx>             // FRound
  59 #include <xmloff/xmltoken.hxx>
  60 #include <xmloff/nmspmap.hxx>
  61
  62 #include "xmlnmspe.hxx"
  63 #include <basegfx/matrix/b2dhommatrix.hxx>
  64 #include <basegfx/tuple/b2dtuple.hxx>
  65
  66 using ::rtl::OUString;
  67 using ::rtl::OUStringBuffer;
  68
  69 using namespace ::com::sun::star;
  70 using namespace ::xmloff::token;
  71
  72
  73 //////////////////////////////////////////////////////////////////////////////
  74
  75 void XMLShapeExport::ImpExportNewTrans(const uno::Reference< beans::XPropertySet >& xPropSet,
  76     sal_Int32 nFeatures, awt::Point* pRefPoint)
  77 {
  78     // get matrix
  79     ::basegfx::B2DHomMatrix aMatrix;
  80     ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
  81
  82     // decompose and correct abour pRefPoint
  83     ::basegfx::B2DTuple aTRScale;
  84     double fTRShear(0.0);
  85     double fTRRotate(0.0);
  86     ::basegfx::B2DTuple aTRTranslate;
  87     ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
  88
  89     // use features and write
  90     ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
  91 }
  92
  93 void XMLShapeExport::ImpExportNewTrans_GetB2DHomMatrix(::basegfx::B2DHomMatrix& rMatrix,
  94     const uno::Reference< beans::XPropertySet >& xPropSet)
  95 {
  96     // --> OD 2004-08-09 #i28749# - Get <TransformationInHoriL2R>, if it exist
  97     // and if the document is exported into the OpenOffice.org file format.
  98     // This property only exists at service com::sun::star::text::Shape - the
  99     // Writer UNO service for shapes.
 100     // This code is needed, because the positioning attributes in the
 101     // OpenOffice.org file format are given in horizontal left-to-right layout
 102     // regardless the layout direction the shape is in. In the OASIS Open Office
 103     // file format the positioning attributes are correctly given in the layout
 104     // direction the shape is in. Thus, this code provides the conversion from
 105     // the OASIS Open Office file format to the OpenOffice.org file format.
 106     uno::Any aAny;
 107     if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
 108          xPropSet->getPropertySetInfo()->hasPropertyByName(
 109             OUString(RTL_CONSTASCII_USTRINGPARAM("TransformationInHoriL2R"))) )
 110     {
 111         aAny = xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("TransformationInHoriL2R")));
 112     }
 113     else
 114     {
 115         aAny = xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation")));
 116     }
 117     // <--
 118     drawing::HomogenMatrix3 aMatrix;
 119     aAny >>= aMatrix;
 120
 121     rMatrix.set(0, 0, aMatrix.Line1.Column1);
 122     rMatrix.set(0, 1, aMatrix.Line1.Column2);
 123     rMatrix.set(0, 2, aMatrix.Line1.Column3);
 124     rMatrix.set(1, 0, aMatrix.Line2.Column1);
 125     rMatrix.set(1, 1, aMatrix.Line2.Column2);
 126     rMatrix.set(1, 2, aMatrix.Line2.Column3);
 127     rMatrix.set(2, 0, aMatrix.Line3.Column1);
 128     rMatrix.set(2, 1, aMatrix.Line3.Column2);
 129     rMatrix.set(2, 2, aMatrix.Line3.Column3);
 130 }
 131
 132 void XMLShapeExport::ImpExportNewTrans_DecomposeAndRefPoint(const ::basegfx::B2DHomMatrix& rMatrix, ::basegfx::B2DTuple& rTRScale,
 133     double& fTRShear, double& fTRRotate, ::basegfx::B2DTuple& rTRTranslate, com::sun::star::awt::Point* pRefPoint)
 134 {
 135     // decompose matrix
 136     rMatrix.decompose(rTRScale, rTRTranslate, fTRRotate, fTRShear);
 137
 138     // correct translation about pRefPoint
 139     if(pRefPoint)
 140     {
 141         rTRTranslate -= ::basegfx::B2DTuple(pRefPoint->X, pRefPoint->Y);
 142     }
 143 }
 144
 145 void XMLShapeExport::ImpExportNewTrans_FeaturesAndWrite(::basegfx::B2DTuple& rTRScale, double fTRShear,
 146     double fTRRotate, ::basegfx::B2DTuple& rTRTranslate, const sal_Int32 nFeatures)
 147 {
 148     // allways write Size (rTRScale) since this statement carries the union
 149     // of the object
 150     OUString aStr;
 151     OUStringBuffer sStringBuffer;
 152     ::basegfx::B2DTuple aTRScale(rTRScale);
 153
 154     // svg: width
 155     if(!(nFeatures & SEF_EXPORT_WIDTH))
 156     {
 157         aTRScale.setX(1.0);
 158     }
 159     else
 160     {
 161         if( aTRScale.getX() > 0.0 )
 162             aTRScale.setX(aTRScale.getX() - 1.0);
 163         else if( aTRScale.getX() < 0.0 )
 164             aTRScale.setX(aTRScale.getX() + 1.0);
 165     }
 166
 167     mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, FRound(aTRScale.getX()));
 168     aStr = sStringBuffer.makeStringAndClear();
 169     mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, aStr);
 170
 171     // svg: height
 172     if(!(nFeatures & SEF_EXPORT_HEIGHT))
 173     {
 174         aTRScale.setY(1.0);
 175     }
 176     else
 177     {
 178         if( aTRScale.getY() > 0.0 )
 179             aTRScale.setY(aTRScale.getY() - 1.0);
 180         else if( aTRScale.getY() < 0.0 )
 181             aTRScale.setY(aTRScale.getY() + 1.0);
 182     }
 183
 184     mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, FRound(aTRScale.getY()));
 185     aStr = sStringBuffer.makeStringAndClear();
 186     mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, aStr);
 187
 188     // decide if transformation is neccessary
 189     BOOL bTransformationIsNeccessary(fTRShear != 0.0 || fTRRotate != 0.0);
 190
 191     if(bTransformationIsNeccessary)
 192     {
 193         // write transformation, but WITHOUT scale which is exported as size above
 194         SdXMLImExTransform2D aTransform;
 195
 196         aTransform.AddSkewX(atan(fTRShear));
 197
 198         // #i78696#
 199         // fTRRotate is mathematically correct, but due to the error
 200         // we export/import it mirrored. Since the API implementation is fixed and
 201         // uses the correctly oriented angle, it is necessary for compatibility to
 202         // mirror the angle here to stay at the old behaviour. There is a follow-up
 203         // task (#i78698#) to fix this in the next ODF FileFormat version
 204         aTransform.AddRotate(-fTRRotate);
 205
 206         aTransform.AddTranslate(rTRTranslate);
 207
 208         // does transformation need to be exported?
 209         if(aTransform.NeedsAction())
 210             mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter()));
 211     }
 212     else
 213     {
 214         // no shear, no rotate; just add object position to export and we are done
 215         if(nFeatures & SEF_EXPORT_X)
 216         {
 217             // svg: x
 218             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, FRound(rTRTranslate.getX()));
 219             aStr = sStringBuffer.makeStringAndClear();
 220             mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X, aStr);
 221         }
 222
 223         if(nFeatures & SEF_EXPORT_Y)
 224         {
 225             // svg: y
 226             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, FRound(rTRTranslate.getY()));
 227             aStr = sStringBuffer.makeStringAndClear();
 228             mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y, aStr);
 229         }
 230     }
 231 }
 232
 233 //////////////////////////////////////////////////////////////////////////////
 234
 235 sal_Bool XMLShapeExport::ImpExportPresentationAttributes( const uno::Reference< beans::XPropertySet >& xPropSet, const rtl::OUString& rClass )
 236 {
 237     sal_Bool bIsEmpty = sal_False;
 238
 239     OUStringBuffer sStringBuffer;
 240
 241     // write presentation class entry
 242     mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, rClass);
 243
 244     if( xPropSet.is() )
 245     {
 246         uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
 247
 248         sal_Bool bTemp = false;
 249
 250         // is empty pes shape?
 251         if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject"))))
 252         {
 253             xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject"))) >>= bIsEmpty;
 254             if( bIsEmpty )
 255                 mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, XML_TRUE);
 256         }
 257
 258         // is user-transformed?
 259         if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent"))))
 260         {
 261             xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent"))) >>= bTemp;
 262             if(!bTemp)
 263                 mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_USER_TRANSFORMED, XML_TRUE);
 264         }
 265     }
 266
 267     return bIsEmpty;
 268 }
 269
 270 //////////////////////////////////////////////////////////////////////////////
 271
 272 void XMLShapeExport::ImpExportText( const uno::Reference< drawing::XShape >& xShape )
 273 {
 274     uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
 275     if( xText.is() )
 276     {
 277         uno::Reference< container::XEnumerationAccess > xEnumAccess( xShape, uno::UNO_QUERY );
 278         if( xEnumAccess.is() && xEnumAccess->hasElements() )
 279             mrExport.GetTextParagraphExport()->exportText( xText );
 280     }
 281 }
 282
 283 //////////////////////////////////////////////////////////////////////////////
 284 #include <com/sun/star/presentation/ClickAction.hpp>
 285 #include <com/sun/star/presentation/AnimationSpeed.hpp>
 286
 287 namespace {
 288
 289 const sal_Int32 FOUND_CLICKACTION       = 0x00000001;
 290 const sal_Int32 FOUND_BOOKMARK          = 0x00000002;
 291 const sal_Int32 FOUND_EFFECT            = 0x00000004;
 292 const sal_Int32 FOUND_PLAYFULL          = 0x00000008;
 293 const sal_Int32 FOUND_VERB              = 0x00000010;
 294 const sal_Int32 FOUND_SOUNDURL          = 0x00000020;
 295 const sal_Int32 FOUND_SPEED             = 0x00000040;
 296 const sal_Int32 FOUND_CLICKEVENTTYPE    = 0x00000080;
 297 const sal_Int32 FOUND_MACRO             = 0x00000100;
 298 const sal_Int32 FOUND_LIBRARY           = 0x00000200;
 299 const sal_Int32 FOUND_ACTIONEVENTTYPE   = 0x00000400;
 300
 301 } // namespace
 302
 303 void XMLShapeExport::ImpExportEvents( const uno::Reference< drawing::XShape >& xShape )
 304 {
 305     uno::Reference< document::XEventsSupplier > xEventsSupplier( xShape, uno::UNO_QUERY );
 306     if( !xEventsSupplier.is() )
 307         return;
 308
 309     uno::Reference< container::XNameAccess > xEvents( xEventsSupplier->getEvents(), uno::UNO_QUERY );
 310     DBG_ASSERT( xEvents.is(), "XEventsSupplier::getEvents() returned NULL" );
 311     if( !xEvents.is() )
 312         return;
 313
 314     sal_Int32 nFound = 0;
 315
 316     // extract properties from "OnClick" event --------------------------------
 317
 318     OUString aClickEventType;
 319     presentation::ClickAction eClickAction = presentation::ClickAction_NONE;
 320     presentation::AnimationEffect eEffect = presentation::AnimationEffect_NONE;
 321     presentation::AnimationSpeed eSpeed = presentation::AnimationSpeed_SLOW;
 322     OUString aStrSoundURL;
 323     sal_Bool bPlayFull = false;
 324     sal_Int32 nVerb = 0;
 325     OUString aStrMacro;
 326     OUString aStrLibrary;
 327     OUString aStrBookmark;
 328
 329     uno::Sequence< beans::PropertyValue > aClickProperties;
 330     if( xEvents->hasByName( msOnClick ) && (xEvents->getByName( msOnClick ) >>= aClickProperties) )
 331     {
 332         const beans::PropertyValue* pProperty = aClickProperties.getConstArray();
 333         const beans::PropertyValue* pPropertyEnd = pProperty + aClickProperties.getLength();
 334         for( ; pProperty != pPropertyEnd; ++pProperty )
 335         {
 336             if( ( ( nFound & FOUND_CLICKEVENTTYPE ) == 0 ) && pProperty->Name == msEventType )
 337             {
 338                 if( pProperty->Value >>= aClickEventType )
 339                     nFound |= FOUND_CLICKEVENTTYPE;
 340             }
 341             else if( ( ( nFound & FOUND_CLICKACTION ) == 0 ) && pProperty->Name == msClickAction )
 342             {
 343                 if( pProperty->Value >>= eClickAction )
 344                     nFound |= FOUND_CLICKACTION;
 345             }
 346             else if( ( ( nFound & FOUND_MACRO ) == 0 ) && ( pProperty->Name == msMacroName || pProperty->Name == msScript ) )
 347             {
 348                 if( pProperty->Value >>= aStrMacro )
 349                     nFound |= FOUND_MACRO;
 350             }
 351             else if( ( ( nFound & FOUND_LIBRARY ) == 0 ) && pProperty->Name == msLibrary )
 352             {
 353                 if( pProperty->Value >>= aStrLibrary )
 354                     nFound |= FOUND_LIBRARY;
 355             }
 356             else if( ( ( nFound & FOUND_EFFECT ) == 0 ) && pProperty->Name == msEffect )
 357             {
 358                 if( pProperty->Value >>= eEffect )
 359                     nFound |= FOUND_EFFECT;
 360             }
 361             else if( ( ( nFound & FOUND_BOOKMARK ) == 0 ) && pProperty->Name == msBookmark )
 362             {
 363                 if( pProperty->Value >>= aStrBookmark )
 364                     nFound |= FOUND_BOOKMARK;
 365             }
 366             else if( ( ( nFound & FOUND_SPEED ) == 0 ) && pProperty->Name == msSpeed )
 367             {
 368                 if( pProperty->Value >>= eSpeed )
 369                     nFound |= FOUND_SPEED;
 370             }
 371             else if( ( ( nFound & FOUND_SOUNDURL ) == 0 ) && pProperty->Name == msSoundURL )
 372             {
 373                 if( pProperty->Value >>= aStrSoundURL )
 374                     nFound |= FOUND_SOUNDURL;
 375             }
 376             else if( ( ( nFound & FOUND_PLAYFULL ) == 0 ) && pProperty->Name == msPlayFull )
 377             {
 378                 if( pProperty->Value >>= bPlayFull )
 379                     nFound |= FOUND_PLAYFULL;
 380             }
 381             else if( ( ( nFound & FOUND_VERB ) == 0 ) && pProperty->Name == msVerb )
 382             {
 383                 if( pProperty->Value >>= nVerb )
 384                     nFound |= FOUND_VERB;
 385             }
 386         }
 387     }
 388
 389     // create the XML elements
 390
 391     if( aClickEventType == msPresentation )
 392     {
 393         if( ((nFound & FOUND_CLICKACTION) == 0) || (eClickAction == presentation::ClickAction_NONE) )
 394             return;
 395
 396         SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
 397
 398         enum XMLTokenEnum eStrAction;
 399
 400         switch( eClickAction )
 401         {
 402             case presentation::ClickAction_PREVPAGE:        eStrAction = XML_PREVIOUS_PAGE; break;
 403             case presentation::ClickAction_NEXTPAGE:        eStrAction = XML_NEXT_PAGE; break;
 404             case presentation::ClickAction_FIRSTPAGE:       eStrAction = XML_FIRST_PAGE; break;
 405             case presentation::ClickAction_LASTPAGE:        eStrAction = XML_LAST_PAGE; break;
 406             case presentation::ClickAction_INVISIBLE:       eStrAction = XML_HIDE; break;
 407             case presentation::ClickAction_STOPPRESENTATION:eStrAction = XML_STOP; break;
 408             case presentation::ClickAction_PROGRAM:         eStrAction = XML_EXECUTE; break;
 409             case presentation::ClickAction_BOOKMARK:        eStrAction = XML_SHOW; break;
 410             case presentation::ClickAction_DOCUMENT:        eStrAction = XML_SHOW; break;
 411             case presentation::ClickAction_MACRO:           eStrAction = XML_EXECUTE_MACRO; break;
 412             case presentation::ClickAction_VERB:            eStrAction = XML_VERB; break;
 413             case presentation::ClickAction_VANISH:          eStrAction = XML_FADE_OUT; break;
 414             case presentation::ClickAction_SOUND:           eStrAction = XML_SOUND; break;
 415             default:
 416                 DBG_ERROR( "unknown presentation::ClickAction found!" );
 417                 eStrAction = XML_UNKNOWN;
 418         }
 419
 420         OUString aEventQName(
 421             mrExport.GetNamespaceMap().GetQNameByKey(
 422                     XML_NAMESPACE_DOM, OUString( RTL_CONSTASCII_USTRINGPARAM( "click" ) ) ) );
 423         mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
 424         mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_ACTION, eStrAction );
 425
 426         if( eClickAction == presentation::ClickAction_VANISH )
 427         {
 428             if( nFound & FOUND_EFFECT )
 429             {
 430                 XMLEffect eKind;
 431                 XMLEffectDirection eDirection;
 432                 sal_Int16 nStartScale;
 433                 sal_Bool bIn;
 434
 435                 SdXMLImplSetEffect( eEffect, eKind, eDirection, nStartScale, bIn );
 436
 437                 if( eKind != EK_none )
 438                 {
 439                     SvXMLUnitConverter::convertEnum( msBuffer, eKind, aXML_AnimationEffect_EnumMap );
 440                     mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_EFFECT, msBuffer.makeStringAndClear() );
 441                 }
 442
 443                 if( eDirection != ED_none )
 444                 {
 445                     SvXMLUnitConverter::convertEnum( msBuffer, eDirection, aXML_AnimationDirection_EnumMap );
 446                     mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_DIRECTION, msBuffer.makeStringAndClear() );
 447                 }
 448
 449                 if( nStartScale != -1 )
 450                 {
 451                     SvXMLUnitConverter::convertPercent( msBuffer, nStartScale );
 452                     mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_START_SCALE, msBuffer.makeStringAndClear() );
 453                 }
 454             }
 455
 456             if( nFound & FOUND_SPEED && eEffect != presentation::AnimationEffect_NONE )
 457             {
 458                  if( eSpeed != presentation::AnimationSpeed_MEDIUM )
 459                     {
 460                     SvXMLUnitConverter::convertEnum( msBuffer, eSpeed, aXML_AnimationSpeed_EnumMap );
 461                     mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, msBuffer.makeStringAndClear() );
 462                 }
 463             }
 464         }
 465
 466         if( eClickAction == presentation::ClickAction_PROGRAM ||
 467             eClickAction == presentation::ClickAction_BOOKMARK ||
 468             eClickAction == presentation::ClickAction_DOCUMENT )
 469         {
 470             if( eClickAction == presentation::ClickAction_BOOKMARK )
 471                 msBuffer.append( sal_Unicode('#') );
 472
 473             msBuffer.append( aStrBookmark );
 474             mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(msBuffer.makeStringAndClear()) );
 475             mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
 476             mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
 477             mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
 478         }
 479
 480         if( ( nFound & FOUND_VERB ) && eClickAction == presentation::ClickAction_VERB )
 481         {
 482             msBuffer.append( nVerb );
 483             mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_VERB, msBuffer.makeStringAndClear());
 484         }
 485
 486         SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_PRESENTATION, XML_EVENT_LISTENER, sal_True, sal_True);
 487
 488         if( eClickAction == presentation::ClickAction_VANISH || eClickAction == presentation::ClickAction_SOUND )
 489         {
 490             if( ( nFound & FOUND_SOUNDURL ) && aStrSoundURL.getLength() != 0 )
 491             {
 492                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStrSoundURL) );
 493                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
 494                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW );
 495                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
 496                 if( nFound & FOUND_PLAYFULL && bPlayFull )
 497                     mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PLAY_FULL, XML_TRUE );
 498
 499                 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, sal_True, sal_True );
 500             }
 501        }
 502     }
 503     else if( aClickEventType == msStarBasic )
 504     {
 505         if( nFound & FOUND_MACRO )
 506         {
 507             SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
 508
 509             mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE,
 510                         mrExport.GetNamespaceMap().GetQNameByKey(
 511                             XML_NAMESPACE_OOO,
 512                             OUString( RTL_CONSTASCII_USTRINGPARAM(
 513                                             "starbasic" ) ) ) );
 514             OUString aEventQName(
 515                 mrExport.GetNamespaceMap().GetQNameByKey(
 516                         XML_NAMESPACE_DOM, OUString( RTL_CONSTASCII_USTRINGPARAM( "click" ) ) ) );
 517             mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
 518
 519             if( nFound & FOUND_LIBRARY )
 520             {
 521                 OUString sLocation( GetXMLToken(
 522                     (aStrLibrary.equalsIgnoreAsciiCaseAscii("StarOffice") ||
 523                      aStrLibrary.equalsIgnoreAsciiCaseAscii("application") ) ? XML_APPLICATION
 524                                                                        : XML_DOCUMENT ) );
 525                 OUStringBuffer sTmp( sLocation.getLength() + aStrMacro.getLength() + 1 );
 526                 sTmp = sLocation;
 527                 sTmp.append( sal_Unicode( ':' ) );
 528                 sTmp.append( aStrMacro );
 529                 mrExport.AddAttribute(XML_NAMESPACE_SCRIPT, XML_MACRO_NAME,
 530                                      sTmp.makeStringAndClear());
 531             }
 532             else
 533             {
 534                 mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, aStrMacro );
 535             }
 536
 537             SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True);
 538         }
 539     }
 540     else if( aClickEventType == msScript )
 541     {
 542         if( nFound & FOUND_MACRO )
 543         {
 544             SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True);
 545             if ( nFound & FOUND_MACRO )
 546             {
 547                 mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, mrExport.GetNamespaceMap().GetQNameByKey(
 548                          XML_NAMESPACE_OOO, GetXMLToken(XML_SCRIPT) ) );
 549                 OUString aEventQName(
 550                     mrExport.GetNamespaceMap().GetQNameByKey(
 551                             XML_NAMESPACE_DOM, OUString( RTL_CONSTASCII_USTRINGPARAM( "click" ) ) ) );
 552                 mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName );
 553                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aStrMacro );
 554
 555                 SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True);
 556             }
 557             }
 558         }
 559     }
 560
 561 //////////////////////////////////////////////////////////////////////////////
 562
 563 /** #i68101# export shape Title and Description */
 564 void XMLShapeExport::ImpExportDescription( const uno::Reference< drawing::XShape >& xShape )
 565 {
 566     try
 567     {
 568         OUString aTitle;
 569         OUString aDescription;
 570
 571         uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY_THROW );
 572         xProps->getPropertyValue( OUString::createFromAscii( "Title" ) ) >>= aTitle;
 573         xProps->getPropertyValue( OUString::createFromAscii( "Description" ) ) >>= aDescription;
 574
 575         if(aTitle.getLength())
 576         {
 577             SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_TITLE, sal_True, sal_False);
 578             mrExport.Characters( aTitle );
 579         }
 580
 581         if(aDescription.getLength())
 582         {
 583             SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_DESC, sal_True, sal_False );
 584             mrExport.Characters( aDescription );
 585         }
 586     }
 587     catch( uno::Exception& )
 588     {
 589         DBG_ERROR( "could not export Title and/or Description for shape!" );
 590     }
 591 }
 592
 593 //////////////////////////////////////////////////////////////////////////////
 594
 595 void XMLShapeExport::ImpExportGroupShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
 596 {
 597     uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY);
 598     if(xShapes.is() && xShapes->getCount())
 599     {
 600         // write group shape
 601         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
 602         SvXMLElementExport aPGR(mrExport, XML_NAMESPACE_DRAW, XML_G, bCreateNewline, sal_True);
 603
 604         ImpExportDescription( xShape ); // #i68101#
 605         ImpExportEvents( xShape );
 606         ImpExportGluePoints( xShape );
 607
 608         // #89764# if export of position is supressed for group shape,
 609         // positions of contained objects should be written relative to
 610         // the upper left edge of the group.
 611         awt::Point aUpperLeft;
 612
 613         if(!(nFeatures & SEF_EXPORT_POSITION))
 614         {
 615             nFeatures |= SEF_EXPORT_POSITION;
 616             aUpperLeft = xShape->getPosition();
 617             pRefPoint = &aUpperLeft;
 618         }
 619
 620         // write members
 621         exportShapes( xShapes, nFeatures, pRefPoint );
 622     }
 623 }
 624
 625 //////////////////////////////////////////////////////////////////////////////
 626
 627 void XMLShapeExport::ImpExportTextBoxShape(
 628     const uno::Reference< drawing::XShape >& xShape,
 629     XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
 630 {
 631     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
 632     if(xPropSet.is())
 633     {
 634         uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
 635
 636         // presentation attribute (if presentation)
 637         sal_Bool bIsPresShape(FALSE);
 638         sal_Bool bIsEmptyPresObj(FALSE);
 639         OUString aStr;
 640
 641         switch(eShapeType)
 642         {
 643             case XmlShapeTypePresSubtitleShape:
 644             {
 645                 aStr = GetXMLToken(XML_PRESENTATION_SUBTITLE);
 646                 bIsPresShape = TRUE;
 647                 break;
 648             }
 649             case XmlShapeTypePresTitleTextShape:
 650             {
 651                 aStr = GetXMLToken(XML_PRESENTATION_TITLE);
 652                 bIsPresShape = TRUE;
 653                 break;
 654             }
 655             case XmlShapeTypePresOutlinerShape:
 656             {
 657                 aStr = GetXMLToken(XML_PRESENTATION_OUTLINE);
 658                 bIsPresShape = TRUE;
 659                 break;
 660             }
 661             case XmlShapeTypePresNotesShape:
 662             {
 663                 aStr = GetXMLToken(XML_PRESENTATION_NOTES);
 664                 bIsPresShape = TRUE;
 665                 break;
 666             }
 667             case XmlShapeTypePresHeaderShape:
 668             {
 669                 aStr = GetXMLToken(XML_HEADER);
 670                 bIsPresShape = TRUE;
 671                 break;
 672             }
 673             case XmlShapeTypePresFooterShape:
 674             {
 675                 aStr = GetXMLToken(XML_FOOTER);
 676                 bIsPresShape = TRUE;
 677                 break;
 678             }
 679             case XmlShapeTypePresSlideNumberShape:
 680             {
 681                 aStr = GetXMLToken(XML_PAGE_NUMBER);
 682                 bIsPresShape = TRUE;
 683                 break;
 684             }
 685             case XmlShapeTypePresDateTimeShape:
 686             {
 687                 aStr = GetXMLToken(XML_DATE_TIME);
 688                 bIsPresShape = TRUE;
 689                 break;
 690             }
 691             default:
 692                 break;
 693         }
 694
 695         // Transformation
 696         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
 697
 698         if(bIsPresShape)
 699             bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, aStr );
 700
 701
 702         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
 703         SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
 704                                   XML_FRAME, bCreateNewline, sal_True );
 705
 706         // evtl. corner radius?
 707         sal_Int32 nCornerRadius(0L);
 708         xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CornerRadius"))) >>= nCornerRadius;
 709         if(nCornerRadius)
 710         {
 711             OUStringBuffer sStringBuffer;
 712             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, nCornerRadius);
 713             mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
 714         }
 715
 716         {
 717             // write text-box
 718             SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_TEXT_BOX, sal_True, sal_True);
 719             if(!bIsEmptyPresObj)
 720                 ImpExportText( xShape );
 721         }
 722
 723         ImpExportDescription( xShape ); // #i68101#
 724         ImpExportEvents( xShape );
 725         ImpExportGluePoints( xShape );
 726     }
 727 }
 728
 729 //////////////////////////////////////////////////////////////////////////////
 730
 731 void XMLShapeExport::ImpExportRectangleShape(
 732     const uno::Reference< drawing::XShape >& xShape,
 733     XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
 734 {
 735     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
 736     if(xPropSet.is())
 737     {
 738         // Transformation
 739         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
 740
 741         // evtl. corner radius?
 742         sal_Int32 nCornerRadius(0L);
 743         xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CornerRadius"))) >>= nCornerRadius;
 744         if(nCornerRadius)
 745         {
 746             OUStringBuffer sStringBuffer;
 747             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, nCornerRadius);
 748             mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
 749         }
 750
 751         // write rectangle
 752         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
 753         SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_RECT, bCreateNewline, sal_True);
 754
 755         ImpExportDescription( xShape ); // #i68101#
 756         ImpExportEvents( xShape );
 757         ImpExportGluePoints( xShape );
 758         ImpExportText( xShape );
 759     }
 760 }
 761
 762 //////////////////////////////////////////////////////////////////////////////
 763
 764 void XMLShapeExport::ImpExportLineShape(
 765     const uno::Reference< drawing::XShape >& xShape,
 766     XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
 767 {
 768     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
 769     if(xPropSet.is())
 770     {
 771         OUString aStr;
 772         OUStringBuffer sStringBuffer;
 773         awt::Point aStart(0,0);
 774         awt::Point aEnd(1,1);
 775
 776         // #85920# use 'Geometry' to get the points of the line
 777         // since this slot take anchor pos into account.
 778
 779         // get matrix
 780         ::basegfx::B2DHomMatrix aMatrix;
 781         ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
 782
 783         // decompose and correct about pRefPoint
 784         ::basegfx::B2DTuple aTRScale;
 785         double fTRShear(0.0);
 786         double fTRRotate(0.0);
 787         ::basegfx::B2DTuple aTRTranslate;
 788         ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
 789
 790         // create base position
 791         awt::Point aBasePosition(FRound(aTRTranslate.getX()), FRound(aTRTranslate.getY()));
 792
 793         // get the two points
 794         uno::Any aAny(xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Geometry"))));
 795         drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue();
 796
 797         if(pSourcePolyPolygon)
 798         {
 799             drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray();
 800             if(pOuterSequence)
 801             {
 802                 drawing::PointSequence* pInnerSequence = pOuterSequence++;
 803                 if(pInnerSequence)
 804                 {
 805                     awt::Point* pArray = pInnerSequence->getArray();
 806                     if(pArray)
 807                     {
 808                         if(pInnerSequence->getLength() > 0)
 809                         {
 810                             aStart = awt::Point(
 811                                 pArray->X + aBasePosition.X,
 812                                 pArray->Y + aBasePosition.Y);
 813                             pArray++;
 814                         }
 815
 816                         if(pInnerSequence->getLength() > 1)
 817                         {
 818                             aEnd = awt::Point(
 819                                 pArray->X + aBasePosition.X,
 820                                 pArray->Y + aBasePosition.Y);
 821                         }
 822                     }
 823                 }
 824             }
 825         }
 826
 827         if( nFeatures & SEF_EXPORT_X )
 828         {
 829             // svg: x1
 830             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aStart.X);
 831             aStr = sStringBuffer.makeStringAndClear();
 832             mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
 833         }
 834         else
 835         {
 836             aEnd.X -= aStart.X;
 837         }
 838
 839         if( nFeatures & SEF_EXPORT_Y )
 840         {
 841             // svg: y1
 842             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aStart.Y);
 843             aStr = sStringBuffer.makeStringAndClear();
 844             mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
 845         }
 846         else
 847         {
 848             aEnd.Y -= aStart.Y;
 849         }
 850
 851         // svg: x2
 852         mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aEnd.X);
 853         aStr = sStringBuffer.makeStringAndClear();
 854         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
 855
 856         // svg: y2
 857         mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aEnd.Y);
 858         aStr = sStringBuffer.makeStringAndClear();
 859         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
 860
 861         // write line
 862         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
 863         SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_LINE, bCreateNewline, sal_True);
 864
 865         ImpExportDescription( xShape ); // #i68101#
 866         ImpExportEvents( xShape );
 867         ImpExportGluePoints( xShape );
 868         ImpExportText( xShape );
 869     }
 870 }
 871
 872 //////////////////////////////////////////////////////////////////////////////
 873
 874 void XMLShapeExport::ImpExportEllipseShape(
 875     const uno::Reference< drawing::XShape >& xShape,
 876     XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
 877 {
 878     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
 879     if(xPropSet.is())
 880     {
 881         // get size to decide between Circle and Ellipse
 882         awt::Size aSize = xShape->getSize();
 883         sal_Int32 nRx((aSize.Width + 1) / 2);
 884         sal_Int32 nRy((aSize.Height + 1) / 2);
 885         BOOL bCircle(nRx == nRy);
 886
 887         // Transformation
 888         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
 889
 890         drawing::CircleKind eKind = drawing::CircleKind_FULL;
 891         xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CircleKind")) ) >>= eKind;
 892         if( eKind != drawing::CircleKind_FULL )
 893         {
 894             OUStringBuffer sStringBuffer;
 895             sal_Int32 nStartAngle = 0;
 896             sal_Int32 nEndAngle = 0;
 897             xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CircleStartAngle")) ) >>= nStartAngle;
 898             xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CircleEndAngle")) ) >>= nEndAngle;
 899
 900             const double dStartAngle = nStartAngle / 100.0;
 901             const double dEndAngle = nEndAngle / 100.0;
 902
 903             // export circle kind
 904             SvXMLUnitConverter::convertEnum( sStringBuffer, (USHORT)eKind, aXML_CircleKind_EnumMap );
 905             mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_KIND, sStringBuffer.makeStringAndClear() );
 906
 907             // export start angle
 908             SvXMLUnitConverter::convertDouble( sStringBuffer, dStartAngle );
 909             mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_ANGLE, sStringBuffer.makeStringAndClear() );
 910
 911             // export end angle
 912             SvXMLUnitConverter::convertDouble( sStringBuffer, dEndAngle );
 913             mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_ANGLE, sStringBuffer.makeStringAndClear() );
 914         }
 915
 916         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
 917
 918         if(bCircle)
 919         {
 920             // write circle
 921             SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CIRCLE, bCreateNewline, sal_True);
 922
 923             ImpExportDescription( xShape ); // #i68101#
 924             ImpExportEvents( xShape );
 925             ImpExportGluePoints( xShape );
 926             ImpExportText( xShape );
 927         }
 928         else
 929         {
 930             // write ellipse
 931             SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_ELLIPSE, bCreateNewline, sal_True);
 932
 933             ImpExportDescription( xShape ); // #i68101#
 934             ImpExportEvents( xShape );
 935             ImpExportGluePoints( xShape );
 936             ImpExportText( xShape );
 937         }
 938     }
 939 }
 940
 941 //////////////////////////////////////////////////////////////////////////////
 942
 943 void XMLShapeExport::ImpExportPolygonShape(
 944     const uno::Reference< drawing::XShape >& xShape,
 945     XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
 946 {
 947     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
 948     if(xPropSet.is())
 949     {
 950         BOOL bClosed(eShapeType == XmlShapeTypeDrawPolyPolygonShape
 951             || eShapeType == XmlShapeTypeDrawClosedBezierShape);
 952         BOOL bBezier(eShapeType == XmlShapeTypeDrawClosedBezierShape
 953             || eShapeType == XmlShapeTypeDrawOpenBezierShape);
 954
 955         // get matrix
 956         ::basegfx::B2DHomMatrix aMatrix;
 957         ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet);
 958
 959         // decompose and correct abour pRefPoint
 960         ::basegfx::B2DTuple aTRScale;
 961         double fTRShear(0.0);
 962         double fTRRotate(0.0);
 963         ::basegfx::B2DTuple aTRTranslate;
 964         ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint);
 965
 966         // use features and write
 967         ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures);
 968
 969         // create and export ViewBox
 970         awt::Point aPoint(0, 0);
 971         awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY()));
 972         SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height);
 973         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString());
 974
 975         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
 976
 977         if(bBezier)
 978         {
 979             // get PolygonBezier
 980             uno::Any aAny( xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Geometry"))) );
 981             drawing::PolyPolygonBezierCoords* pSourcePolyPolygon =
 982                 (drawing::PolyPolygonBezierCoords*)aAny.getValue();
 983
 984             if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
 985             {
 986                 sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength());
 987                 drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray();
 988                 drawing::FlagSequence*  pOuterFlags = pSourcePolyPolygon->Flags.getArray();
 989
 990                 if(pOuterSequence && pOuterFlags)
 991                 {
 992                     // prepare svx:d element export
 993                     SdXMLImExSvgDElement aSvgDElement(aViewBox);
 994
 995                     for(sal_Int32 a(0L); a < nOuterCnt; a++)
 996                     {
 997                         drawing::PointSequence* pSequence = pOuterSequence++;
 998                         drawing::FlagSequence* pFlags = pOuterFlags++;
 999
1000                         if(pSequence && pFlags)
1001                         {
1002                             aSvgDElement.AddPolygon(pSequence, pFlags,
1003                                 aPoint, aSize, bClosed);
1004                         }
1005                     }
1006
1007                     // write point array
1008                     mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
1009                 }
1010
1011                 // write object now
1012                 SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True);
1013
1014                 ImpExportDescription( xShape ); // #i68101#
1015                 ImpExportEvents( xShape );
1016                 ImpExportGluePoints( xShape );
1017                 ImpExportText( xShape );
1018             }
1019         }
1020         else
1021         {
1022             // get non-bezier polygon
1023             uno::Any aAny( xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Geometry"))) );
1024             drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue();
1025
1026             if(pSourcePolyPolygon && pSourcePolyPolygon->getLength())
1027             {
1028                 sal_Int32 nOuterCnt(pSourcePolyPolygon->getLength());
1029
1030                 if(1L == nOuterCnt && !bBezier)
1031                 {
1032                     // simple polygon shape, can be written as svg:points sequence
1033                     drawing::PointSequence* pSequence = pSourcePolyPolygon->getArray();
1034                     if(pSequence)
1035                     {
1036                         SdXMLImExPointsElement aPoints(pSequence, aViewBox, aPoint, aSize,
1037                             // #96328#
1038                             bClosed);
1039
1040                         // write point array
1041                         mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_POINTS, aPoints.GetExportString());
1042                     }
1043
1044                     // write object now
1045                     SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW,
1046                         bClosed ? XML_POLYGON : XML_POLYLINE , bCreateNewline, sal_True);
1047
1048                     ImpExportDescription( xShape ); // #i68101#
1049                     ImpExportEvents( xShape );
1050                     ImpExportGluePoints( xShape );
1051                     ImpExportText( xShape );
1052                 }
1053                 else
1054                 {
1055                     // polypolygon or bezier, needs to be written as a svg:path sequence
1056                     drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray();
1057                     if(pOuterSequence)
1058                     {
1059                         // prepare svx:d element export
1060                         SdXMLImExSvgDElement aSvgDElement(aViewBox);
1061
1062                         for(sal_Int32 a(0L); a < nOuterCnt; a++)
1063                         {
1064                             drawing::PointSequence* pSequence = pOuterSequence++;
1065                             if(pSequence)
1066                             {
1067                                 aSvgDElement.AddPolygon(pSequence, 0L, aPoint,
1068                                     aSize, bClosed);
1069                             }
1070                         }
1071
1072                         // write point array
1073                         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
1074                     }
1075
1076                     // write object now
1077                     SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True);
1078
1079                     ImpExportDescription( xShape ); // #i68101#
1080                     ImpExportEvents( xShape );
1081                     ImpExportGluePoints( xShape );
1082                     ImpExportText( xShape );
1083                 }
1084             }
1085         }
1086     }
1087 }
1088
1089 //////////////////////////////////////////////////////////////////////////////
1090
1091 void XMLShapeExport::ImpExportGraphicObjectShape(
1092     const uno::Reference< drawing::XShape >& xShape,
1093     XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
1094 {
1095     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1096     if(xPropSet.is())
1097     {
1098         sal_Bool bIsEmptyPresObj = sal_False;
1099         uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
1100
1101         // Transformation
1102         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1103
1104         OUString sImageURL;
1105
1106         if(eShapeType == XmlShapeTypePresGraphicObjectShape)
1107             bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_GRAPHIC) );
1108
1109         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1110         SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
1111                                   XML_FRAME, bCreateNewline, sal_True );
1112
1113         const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE );
1114
1115         if( !bIsEmptyPresObj || bSaveBackwardsCompatible )
1116         {
1117             if( !bIsEmptyPresObj )
1118             {
1119                 OUString aStreamURL;
1120                 OUString aStr;
1121
1122                 xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicStreamURL"))) >>= aStreamURL;
1123                 xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicURL"))) >>= sImageURL;
1124
1125                 OUString aResolveURL( sImageURL );
1126                 const rtl::OUString sPackageURL( RTL_CONSTASCII_USTRINGPARAM("vnd.sun.star.Package:") );
1127
1128                     // sj: trying to preserve the filename
1129                 if ( aStreamURL.match( sPackageURL, 0 ) )
1130                 {
1131                     rtl::OUString sRequestedName( aStreamURL.copy( sPackageURL.getLength(), aStreamURL.getLength() - sPackageURL.getLength() ) );
1132                     sal_Int32 nLastIndex = sRequestedName.lastIndexOf( '/' ) + 1;
1133                     if ( ( nLastIndex > 0 ) && ( nLastIndex < sRequestedName.getLength() ) )
1134                         sRequestedName = sRequestedName.copy( nLastIndex, sRequestedName.getLength() - nLastIndex );
1135                     nLastIndex = sRequestedName.lastIndexOf( '.' );
1136                     if ( nLastIndex >= 0 )
1137                         sRequestedName = sRequestedName.copy( 0, nLastIndex );
1138                     if ( sRequestedName.getLength() )
1139                     {
1140                         aResolveURL = aResolveURL.concat( OUString(RTL_CONSTASCII_USTRINGPARAM("?requestedName=")));
1141                         aResolveURL = aResolveURL.concat( sRequestedName );
1142                     }
1143                 }
1144
1145                 aStr = mrExport.AddEmbeddedGraphicObject( aResolveURL );
1146                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr );
1147
1148                 if( aStr.getLength() )
1149                 {
1150                     if( aStr[ 0 ] == '#' )
1151                     {
1152                         aStreamURL = OUString::createFromAscii( "vnd.sun.star.Package:" );
1153                         aStreamURL = aStreamURL.concat( aStr.copy( 1, aStr.getLength() - 1 ) );
1154                     }
1155
1156                     // update stream URL for load on demand
1157                     uno::Any aAny;
1158                     aAny <<= aStreamURL;
1159                     xPropSet->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicStreamURL")), aAny );
1160
1161                     mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1162                     mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1163                     mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1164                 }
1165             }
1166             else
1167             {
1168                 OUString aStr;
1169                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr );
1170                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1171                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1172                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1173             }
1174
1175             {
1176                 SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True);
1177
1178                 if( sImageURL.getLength() )
1179                 {
1180                     // optional office:binary-data
1181                     mrExport.AddEmbeddedGraphicObjectAsBase64( sImageURL );
1182                 }
1183                 if( !bIsEmptyPresObj )
1184                     ImpExportText( xShape );
1185             }
1186         }
1187
1188         ImpExportEvents( xShape );
1189         ImpExportGluePoints( xShape );
1190
1191         // image map
1192         GetExport().GetImageMapExport().Export( xPropSet );
1193         ImpExportDescription( xShape ); // #i68101#
1194     }
1195 }
1196
1197 //////////////////////////////////////////////////////////////////////////////
1198
1199 void XMLShapeExport::ImpExportChartShape(
1200     const uno::Reference< drawing::XShape >& xShape,
1201     XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint,
1202     SvXMLAttributeList* pAttrList )
1203 {
1204     ImpExportOLE2Shape( xShape, eShapeType, nFeatures, pRefPoint, pAttrList );
1205 /*
1206         // Transformation
1207         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1208
1209         uno::Reference< chart::XChartDocument > xChartDoc;
1210         if( !bIsEmptyPresObj )
1211             xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("Model") ) ) >>= xChartDoc;
1212
1213         if( xChartDoc.is() )
1214         {
1215             // export chart data if the flag is not set (default)
1216             sal_Bool bExportOwnData = ( nFeatures & SEF_EXPORT_NO_CHART_DATA ) == 0;
1217             mrExport.GetChartExport()->exportChart( xChartDoc, bExportOwnData );
1218         }
1219         else
1220         {
1221             // write chart object (fake for now, replace later)
1222             SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_CHART, XML_CHART, sal_True, sal_True);
1223         }
1224     }
1225 */
1226 }
1227
1228 //////////////////////////////////////////////////////////////////////////////
1229
1230 void XMLShapeExport::ImpExportControlShape(
1231     const uno::Reference< drawing::XShape >& xShape,
1232     XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint)
1233 {
1234     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1235     if(xPropSet.is())
1236     {
1237         // Transformation
1238         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1239     }
1240
1241     uno::Reference< drawing::XControlShape > xControl( xShape, uno::UNO_QUERY );
1242     DBG_ASSERT( xControl.is(), "Control shape is not supporting XControlShape" );
1243     if( xControl.is() )
1244     {
1245         uno::Reference< beans::XPropertySet > xControlModel( xControl->getControl(), uno::UNO_QUERY );
1246         DBG_ASSERT( xControlModel.is(), "Control shape has not XControlModel" );
1247         if( xControlModel.is() )
1248         {
1249             mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONTROL, mrExport.GetFormExport()->getControlId( xControlModel ) );
1250         }
1251     }
1252
1253     sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1254     SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONTROL, bCreateNewline, sal_True);
1255
1256     ImpExportDescription( xShape ); // #i68101#
1257 }
1258
1259 //////////////////////////////////////////////////////////////////////////////
1260
1261 void XMLShapeExport::ImpExportConnectorShape(
1262     const uno::Reference< drawing::XShape >& xShape,
1263     XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
1264 {
1265     uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
1266
1267     OUString aStr;
1268     OUStringBuffer sStringBuffer;
1269
1270     // export connection kind
1271     drawing::ConnectorType eType = drawing::ConnectorType_STANDARD;
1272     uno::Any aAny = xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeKind")));
1273     aAny >>= eType;
1274
1275     if( eType != drawing::ConnectorType_STANDARD )
1276     {
1277         SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eType, aXML_ConnectionKind_EnumMap );
1278         aStr = sStringBuffer.makeStringAndClear();
1279         mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TYPE, aStr);
1280     }
1281
1282     // export line skew
1283     sal_Int32 nDelta1 = 0, nDelta2 = 0, nDelta3 = 0;
1284
1285     aAny = xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeLine1Delta")));
1286     aAny >>= nDelta1;
1287     aAny = xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeLine2Delta")));
1288     aAny >>= nDelta2;
1289     aAny = xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeLine3Delta")));
1290     aAny >>= nDelta3;
1291
1292     if( nDelta1 != 0 || nDelta2 != 0 || nDelta3 != 0 )
1293     {
1294         mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, nDelta1);
1295         if( nDelta2 != 0 || nDelta3 != 0 )
1296         {
1297             const char aSpace = ' ';
1298             sStringBuffer.appendAscii( &aSpace, 1 );
1299             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, nDelta2);
1300             if( nDelta3 != 0 )
1301             {
1302                 sStringBuffer.appendAscii( &aSpace, 1 );
1303                 mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, nDelta3);
1304             }
1305         }
1306
1307         aStr = sStringBuffer.makeStringAndClear();
1308         mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_LINE_SKEW, aStr);
1309     }
1310
1311     // export start and end point
1312     awt::Point aStart(0,0);
1313     awt::Point aEnd(1,1);
1314
1315     // --> OD 2004-08-09 #i36248# - Get <StartPositionInHoriL2R> and
1316     // <EndPositionInHoriL2R>, if they exist and if the document is exported
1317     // into the OpenOffice.org file format.
1318     // These properties only exist at service com::sun::star::text::Shape - the
1319     // Writer UNO service for shapes.
1320     // This code is needed, because the positioning attributes in the
1321     // OpenOffice.org file format are given in horizontal left-to-right layout
1322     // regardless the layout direction the shape is in. In the OASIS Open Office
1323     // file format the positioning attributes are correctly given in the layout
1324     // direction the shape is in. Thus, this code provides the conversion from
1325     // the OASIS Open Office file format to the OpenOffice.org file format.
1326     if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
1327          xProps->getPropertySetInfo()->hasPropertyByName(
1328             OUString(RTL_CONSTASCII_USTRINGPARAM("StartPositionInHoriL2R"))) &&
1329          xProps->getPropertySetInfo()->hasPropertyByName(
1330             OUString(RTL_CONSTASCII_USTRINGPARAM("EndPositionInHoriL2R"))) )
1331     {
1332         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartPositionInHoriL2R"))) >>= aStart;
1333         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndPositionInHoriL2R"))) >>= aEnd;
1334     }
1335     else
1336     {
1337         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartPosition"))) >>= aStart;
1338         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndPosition"))) >>= aEnd;
1339     }
1340     // <--
1341
1342     if( pRefPoint )
1343     {
1344         aStart.X -= pRefPoint->X;
1345         aStart.Y -= pRefPoint->Y;
1346         aEnd.X -= pRefPoint->X;
1347         aEnd.Y -= pRefPoint->Y;
1348     }
1349
1350     if( nFeatures & SEF_EXPORT_X )
1351     {
1352         // svg: x1
1353         mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aStart.X);
1354         aStr = sStringBuffer.makeStringAndClear();
1355         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
1356     }
1357     else
1358     {
1359         aEnd.X -= aStart.X;
1360     }
1361
1362     if( nFeatures & SEF_EXPORT_Y )
1363     {
1364         // svg: y1
1365         mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aStart.Y);
1366         aStr = sStringBuffer.makeStringAndClear();
1367         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
1368     }
1369     else
1370     {
1371         aEnd.Y -= aStart.Y;
1372     }
1373
1374     // svg: x2
1375     mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aEnd.X);
1376     aStr = sStringBuffer.makeStringAndClear();
1377     mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
1378
1379     // svg: y2
1380     mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aEnd.Y);
1381     aStr = sStringBuffer.makeStringAndClear();
1382     mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
1383
1384     // #i39320#
1385     uno::Reference< uno::XInterface > xRefS;
1386     uno::Reference< uno::XInterface > xRefE;
1387
1388     // export start connection
1389     xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartShape") ) ) >>= xRefS;
1390     if( xRefS.is() )
1391     {
1392         const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefS );
1393         mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_SHAPE, rShapeId);
1394
1395         aAny = xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartGluePointIndex")) );
1396         sal_Int32 nGluePointId = 0;
1397         if( aAny >>= nGluePointId )
1398         {
1399             if( nGluePointId != -1 )
1400             {
1401                 mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_GLUE_POINT, OUString::valueOf( nGluePointId ));
1402             }
1403         }
1404     }
1405
1406     // export end connection
1407     xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndShape")) ) >>= xRefE;
1408     if( xRefE.is() )
1409     {
1410         const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefE );
1411         mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_SHAPE, rShapeId);
1412
1413         aAny = xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndGluePointIndex")) );
1414         sal_Int32 nGluePointId = 0;
1415         if( aAny >>= nGluePointId )
1416         {
1417             if( nGluePointId != -1 )
1418             {
1419                 mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_GLUE_POINT, OUString::valueOf( nGluePointId ));
1420             }
1421         }
1422     }
1423
1424     if( xProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM("PolyPolygonBezier") ) ) >>= aAny )
1425     {
1426         // get PolygonBezier
1427         drawing::PolyPolygonBezierCoords* pSourcePolyPolygon =
1428             (drawing::PolyPolygonBezierCoords*)aAny.getValue();
1429
1430         if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength())
1431         {
1432             sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength());
1433             drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray();
1434             drawing::FlagSequence*  pOuterFlags = pSourcePolyPolygon->Flags.getArray();
1435
1436             if(pOuterSequence && pOuterFlags)
1437             {
1438                 // prepare svx:d element export
1439                 awt::Point aPoint( 0, 0 );
1440                 awt::Size aSize( 1, 1 );
1441                 SdXMLImExViewBox aViewBox( 0, 0, 1, 1 );
1442                 SdXMLImExSvgDElement aSvgDElement(aViewBox);
1443
1444                 for(sal_Int32 a(0L); a < nOuterCnt; a++)
1445                 {
1446                     drawing::PointSequence* pSequence = pOuterSequence++;
1447                     drawing::FlagSequence* pFlags = pOuterFlags++;
1448
1449                     if(pSequence && pFlags)
1450                     {
1451                         aSvgDElement.AddPolygon(pSequence, pFlags,
1452                             aPoint, aSize, sal_False );
1453                     }
1454                 }
1455
1456                 // write point array
1457                 mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString());
1458             }
1459         }
1460     }
1461
1462     // write connector shape. Add Export later.
1463     sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1464     SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONNECTOR, bCreateNewline, sal_True);
1465
1466     ImpExportDescription( xShape ); // #i68101#
1467     ImpExportEvents( xShape );
1468     ImpExportGluePoints( xShape );
1469     ImpExportText( xShape );
1470 }
1471
1472 //////////////////////////////////////////////////////////////////////////////
1473
1474 void XMLShapeExport::ImpExportMeasureShape(
1475     const uno::Reference< drawing::XShape >& xShape,
1476     XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
1477 {
1478     uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY );
1479
1480     OUString aStr;
1481     OUStringBuffer sStringBuffer;
1482
1483     // export start and end point
1484     awt::Point aStart(0,0);
1485     awt::Point aEnd(1,1);
1486
1487     // --> OD 2004-08-09 #i36248# - Get <StartPositionInHoriL2R> and
1488     // <EndPositionInHoriL2R>, if they exist and if the document is exported
1489     // into the OpenOffice.org file format.
1490     // These properties only exist at service com::sun::star::text::Shape - the
1491     // Writer UNO service for shapes.
1492     // This code is needed, because the positioning attributes in the
1493     // OpenOffice.org file format are given in horizontal left-to-right layout
1494     // regardless the layout direction the shape is in. In the OASIS Open Office
1495     // file format the positioning attributes are correctly given in the layout
1496     // direction the shape is in. Thus, this code provides the conversion from
1497     // the OASIS Open Office file format to the OpenOffice.org file format.
1498     if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 &&
1499          xProps->getPropertySetInfo()->hasPropertyByName(
1500             OUString(RTL_CONSTASCII_USTRINGPARAM("StartPositionInHoriL2R"))) &&
1501          xProps->getPropertySetInfo()->hasPropertyByName(
1502             OUString(RTL_CONSTASCII_USTRINGPARAM("EndPositionInHoriL2R"))) )
1503     {
1504         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartPositionInHoriL2R"))) >>= aStart;
1505         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndPositionInHoriL2R"))) >>= aEnd;
1506     }
1507     else
1508     {
1509         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartPosition"))) >>= aStart;
1510         xProps->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndPosition"))) >>= aEnd;
1511     }
1512     // <--
1513
1514     if( pRefPoint )
1515     {
1516         aStart.X -= pRefPoint->X;
1517         aStart.Y -= pRefPoint->Y;
1518         aEnd.X -= pRefPoint->X;
1519         aEnd.Y -= pRefPoint->Y;
1520     }
1521
1522     if( nFeatures & SEF_EXPORT_X )
1523     {
1524         // svg: x1
1525         mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aStart.X);
1526         aStr = sStringBuffer.makeStringAndClear();
1527         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr);
1528     }
1529     else
1530     {
1531         aEnd.X -= aStart.X;
1532     }
1533
1534     if( nFeatures & SEF_EXPORT_Y )
1535     {
1536         // svg: y1
1537         mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aStart.Y);
1538         aStr = sStringBuffer.makeStringAndClear();
1539         mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr);
1540     }
1541     else
1542     {
1543         aEnd.Y -= aStart.Y;
1544     }
1545
1546     // svg: x2
1547     mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aEnd.X);
1548     aStr = sStringBuffer.makeStringAndClear();
1549     mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr);
1550
1551     // svg: y2
1552     mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, aEnd.Y);
1553     aStr = sStringBuffer.makeStringAndClear();
1554     mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr);
1555
1556     // write measure shape
1557     sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1558     SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_MEASURE, bCreateNewline, sal_True);
1559
1560     ImpExportDescription( xShape ); // #i68101#
1561     ImpExportEvents( xShape );
1562     ImpExportGluePoints( xShape );
1563
1564     uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY );
1565     if( xText.is() )
1566         mrExport.GetTextParagraphExport()->exportText( xText );
1567 }
1568
1569 //////////////////////////////////////////////////////////////////////////////
1570
1571 void XMLShapeExport::ImpExportOLE2Shape(
1572     const uno::Reference< drawing::XShape >& xShape,
1573     XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */,
1574     SvXMLAttributeList* pAttrList /* = NULL */ )
1575 {
1576     uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1577     uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY);
1578
1579     DBG_ASSERT( xPropSet.is() && xNamed.is(), "ole shape is not implementing needed interfaces");
1580     if(xPropSet.is() && xNamed.is())
1581     {
1582         // Transformation
1583         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1584
1585         sal_Bool bIsEmptyPresObj = sal_False;
1586
1587         // presentation settings
1588         if(eShapeType == XmlShapeTypePresOLE2Shape)
1589             bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) );
1590         else if(eShapeType == XmlShapeTypePresChartShape)
1591             bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_CHART) );
1592         else if(eShapeType == XmlShapeTypePresSheetShape)
1593             bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) );
1594
1595         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1596         sal_Bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED));
1597         OUString sPersistName;
1598         SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
1599                                   XML_FRAME, bCreateNewline, sal_True );
1600
1601         const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE );
1602
1603         if( !bIsEmptyPresObj || bSaveBackwardsCompatible )
1604         {
1605             if (pAttrList)
1606             {
1607                 mrExport.AddAttributeList(pAttrList);
1608             }
1609
1610             OUString sClassId;
1611             OUString sURL;
1612             sal_Bool bInternal = false;
1613             xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("IsInternal"))) >>= bInternal;
1614
1615             if( !bIsEmptyPresObj )
1616             {
1617
1618                 if ( bInternal )
1619                 {
1620                     // OOo internal links have no storage persistance, URL is stored in the XML file
1621                     // the result LinkURL is empty in case the object is not a link
1622                     xPropSet->getPropertyValue( OUString::createFromAscii( "LinkURL" ) ) >>= sURL;
1623                 }
1624
1625                 xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM( "PersistName" ) ) ) >>= sPersistName;
1626                 if ( !sURL.getLength() )
1627                 {
1628                     if( sPersistName.getLength() )
1629                     {
1630                         sURL = OUString( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.EmbeddedObject:" ) );
1631                         sURL += sPersistName;
1632                     }
1633                 }
1634
1635                 if( !bInternal )
1636                     xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CLSID"))) >>= sClassId;
1637
1638                 if( sClassId.getLength() )
1639                     mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CLASS_ID, sClassId );
1640                 if(!bExportEmbedded)
1641                 {
1642                     // xlink:href
1643                     if( sURL.getLength() )
1644                     {
1645                         // #96717# in theorie, if we don't have a url we shouldn't even
1646                         // export this ole shape. But practical its to risky right now
1647                         // to change this so we better dispose this on load
1648                         sURL = mrExport.AddEmbeddedObject( sURL );
1649
1650                         mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
1651                         mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1652                         mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1653                         mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1654                     }
1655                 }
1656             }
1657             else
1658             {
1659                 // export empty href for empty placeholders to be valid odf
1660                 OUString sEmptyURL;
1661
1662                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sEmptyURL );
1663                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1664                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1665                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1666             }
1667
1668             enum XMLTokenEnum eElem = sClassId.getLength() ? XML_OBJECT_OLE : XML_OBJECT;
1669             SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, eElem, sal_True, sal_True );
1670
1671             if(bExportEmbedded && !bIsEmptyPresObj)
1672             {
1673                 // #100592#
1674                 if(bInternal)
1675                 {
1676                     // embedded XML
1677                     uno::Reference< lang::XComponent > xComp;
1678                     xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("Model") ) ) >>= xComp;
1679                     DBG_ASSERT( xComp.is(), "no xModel for own OLE format" );
1680                     mrExport.ExportEmbeddedOwnObject( xComp );
1681                 }
1682                 else
1683                 {
1684                     // embed as Base64
1685                     // this is an alien object ( currently MSOLE is the only supported type of such objects )
1686                     // in case it is not an OASIS format the object should be asked to store replacement image if possible
1687
1688                     ::rtl::OUString sURLRequest( sURL );
1689                     if ( ( mrExport.getExportFlags() & EXPORT_OASIS ) == 0 )
1690                         sURLRequest += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "?oasis=false" ) );
1691                     mrExport.AddEmbeddedObjectAsBase64( sURLRequest );
1692                 }
1693             }
1694         }
1695         if( !bIsEmptyPresObj )
1696         {
1697             OUString sURL( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.GraphicObject:" ) );
1698             sURL += sPersistName;
1699             if( !bExportEmbedded )
1700             {
1701                 sURL = GetExport().AddEmbeddedObject( sURL );
1702                 mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL );
1703                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1704                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1705                 mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1706             }
1707
1708             SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW,
1709                                       XML_IMAGE, sal_False, sal_True );
1710
1711             if( bExportEmbedded )
1712                 GetExport().AddEmbeddedObjectAsBase64( sURL );
1713         }
1714
1715         ImpExportEvents( xShape );
1716         ImpExportGluePoints( xShape );
1717         ImpExportDescription( xShape ); // #i68101#
1718     }
1719 }
1720
1721 //////////////////////////////////////////////////////////////////////////////
1722
1723 void XMLShapeExport::ImpExportPageShape(
1724     const uno::Reference< drawing::XShape >& xShape,
1725     XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
1726 {
1727     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1728     if(xPropSet.is())
1729     {
1730         // #86163# Transformation
1731         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1732
1733         // export page number used for this page
1734         uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
1735         const OUString aPageNumberStr(RTL_CONSTASCII_USTRINGPARAM("PageNumber"));
1736         if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr))
1737         {
1738             sal_Int32 nPageNumber = 0;
1739             xPropSet->getPropertyValue(aPageNumberStr) >>= nPageNumber;
1740             if( nPageNumber )
1741                 mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_PAGE_NUMBER, OUString::valueOf(nPageNumber));
1742         }
1743
1744         // a presentation page shape, normally used on notes pages only. If
1745         // it is used not as presentation shape, it may have been created with
1746         // copy-paste exchange between draw and impress (this IS possible...)
1747         if(eShapeType == XmlShapeTypePresPageShape)
1748         {
1749             mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS,
1750                                  XML_PRESENTATION_PAGE);
1751         }
1752
1753         // write Page shape
1754         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1755         SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PAGE_THUMBNAIL, bCreateNewline, sal_True);
1756     }
1757 }
1758
1759 //////////////////////////////////////////////////////////////////////////////
1760
1761 void XMLShapeExport::ImpExportCaptionShape(
1762     const uno::Reference< drawing::XShape >& xShape,
1763     XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */)
1764 {
1765     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1766     if(xPropSet.is())
1767     {
1768         // Transformation
1769         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1770
1771         // evtl. corner radius?
1772         sal_Int32 nCornerRadius(0L);
1773         xPropSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CornerRadius"))) >>= nCornerRadius;
1774         if(nCornerRadius)
1775         {
1776             OUStringBuffer sStringBuffer;
1777             mrExport.GetMM100UnitConverter().convertMeasure(sStringBuffer, nCornerRadius);
1778             mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear());
1779         }
1780
1781         awt::Point aCaptionPoint;
1782         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "CaptionPoint" ) ) ) >>= aCaptionPoint;
1783
1784         mrExport.GetMM100UnitConverter().convertMeasure(msBuffer, aCaptionPoint.X);
1785         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_X, msBuffer.makeStringAndClear() );
1786         mrExport.GetMM100UnitConverter().convertMeasure(msBuffer, aCaptionPoint.Y);
1787         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_Y, msBuffer.makeStringAndClear() );
1788
1789         // write Caption shape. Add export later.
1790         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1791         sal_Bool bAnnotation( (nFeatures & SEF_EXPORT_ANNOTATION) == SEF_EXPORT_ANNOTATION );
1792
1793         SvXMLElementExport aObj( mrExport,
1794                                  (bAnnotation ? XML_NAMESPACE_OFFICE
1795                                                : XML_NAMESPACE_DRAW),
1796                                  (bAnnotation ? XML_ANNOTATION : XML_CAPTION),
1797                                  bCreateNewline, sal_True );
1798
1799         ImpExportDescription( xShape ); // #i68101#
1800         ImpExportEvents( xShape );
1801         ImpExportGluePoints( xShape );
1802         if( bAnnotation )
1803             mrExport.exportAnnotationMeta( xShape );
1804         ImpExportText( xShape );
1805     }
1806 }
1807
1808 //////////////////////////////////////////////////////////////////////////////
1809
1810 void XMLShapeExport::ImpExportFrameShape(
1811     const uno::Reference< drawing::XShape >& xShape,
1812     XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
1813 {
1814     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1815     if(xPropSet.is())
1816     {
1817         // Transformation
1818         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1819
1820         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1821         SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
1822                                   XML_FRAME, bCreateNewline, sal_True );
1823
1824         // export frame url
1825         OUString aStr;
1826         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "FrameURL" ) ) ) >>= aStr;
1827         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
1828         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1829         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1830         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1831
1832         // export name
1833         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "FrameName" ) ) ) >>= aStr;
1834         if( aStr.getLength() )
1835             mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FRAME_NAME, aStr );
1836
1837         // write floating frame
1838         {
1839             SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_FLOATING_FRAME, sal_True, sal_True);
1840         }
1841     }
1842 }
1843
1844 //////////////////////////////////////////////////////////////////////////////
1845
1846 void XMLShapeExport::ImpExportAppletShape(
1847     const uno::Reference< drawing::XShape >& xShape,
1848     XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
1849 {
1850     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1851     if(xPropSet.is())
1852     {
1853         // Transformation
1854         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1855
1856         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1857         SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
1858                                   XML_FRAME, bCreateNewline, sal_True );
1859
1860         // export frame url
1861         OUString aStr;
1862         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletCodeBase" ) ) ) >>= aStr;
1863         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
1864         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1865         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1866         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1867
1868         // export draw:applet-name
1869         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletName" ) ) ) >>= aStr;
1870         if( aStr.getLength() )
1871             mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_APPLET_NAME, aStr );
1872
1873         // export draw:code
1874         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletCode" ) ) ) >>= aStr;
1875         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CODE, aStr );
1876
1877         // export draw:may-script
1878         sal_Bool bIsScript = false;
1879         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletIsScript" ) ) ) >>= bIsScript;
1880         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, bIsScript ? XML_TRUE : XML_FALSE );
1881
1882         {
1883             // write applet
1884             SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_APPLET, sal_True, sal_True);
1885
1886             // export parameters
1887             uno::Sequence< beans::PropertyValue > aCommands;
1888             xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletCommands" ) ) ) >>= aCommands;
1889             const sal_Int32 nCount = aCommands.getLength();
1890             for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
1891             {
1892                 aCommands[nIndex].Value >>= aStr;
1893                 mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name );
1894                 mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
1895                 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True );
1896             }
1897         }
1898     }
1899 }
1900
1901 //////////////////////////////////////////////////////////////////////////////
1902
1903 void XMLShapeExport::ImpExportPluginShape(
1904     const uno::Reference< drawing::XShape >& xShape,
1905     XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
1906 {
1907     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1908     if(xPropSet.is())
1909     {
1910         // Transformation
1911         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1912
1913         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1914         SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW,
1915                                   XML_FRAME, bCreateNewline, sal_True );
1916
1917         // export plugin url
1918         OUString aStr;
1919         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PluginURL" ) ) ) >>= aStr;
1920         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) );
1921         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1922         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1923         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1924
1925
1926         // export mime-type
1927         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PluginMimeType" ) ) ) >>= aStr;
1928         if(aStr.getLength())
1929             mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, aStr );
1930
1931         {
1932             // write plugin
1933             SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, sal_True, sal_True);
1934
1935             // export parameters
1936             uno::Sequence< beans::PropertyValue > aCommands;
1937             xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PluginCommands" ) ) ) >>= aCommands;
1938             const sal_Int32 nCount = aCommands.getLength();
1939             for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
1940             {
1941                 aCommands[nIndex].Value >>= aStr;
1942                 mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name );
1943                 mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr );
1944                 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True );
1945             }
1946         }
1947     }
1948 }
1949
1950 //////////////////////////////////////////////////////////////////////////////
1951
1952 void XMLShapeExport::ImpExportMediaShape(
1953     const uno::Reference< drawing::XShape >& xShape,
1954     XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint)
1955 {
1956     const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY);
1957     if(xPropSet.is())
1958     {
1959         // Transformation
1960         ImpExportNewTrans(xPropSet, nFeatures, pRefPoint);
1961
1962         sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210#
1963         SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW,
1964                                   XML_FRAME, bCreateNewline, sal_True );
1965
1966         // export media url
1967         OUString aMediaURL;
1968         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaURL" ) ) ) >>= aMediaURL;
1969         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference( aMediaURL ) );
1970         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
1971         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
1972         mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
1973
1974         // export mime-type
1975         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, OUString( RTL_CONSTASCII_USTRINGPARAM( "application/vnd.sun.star.media" ) ) );
1976
1977         // write plugin
1978         SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, !( nFeatures & SEF_EXPORT_NO_WS ), sal_True);
1979
1980         // export parameters
1981         const OUString aFalseStr( RTL_CONSTASCII_USTRINGPARAM( "false" ) ), aTrueStr( RTL_CONSTASCII_USTRINGPARAM( "true" ) );
1982
1983         sal_Bool bLoop = false;
1984         const OUString aLoopStr( RTL_CONSTASCII_USTRINGPARAM( "Loop" ) );
1985         xPropSet->getPropertyValue( aLoopStr ) >>= bLoop;
1986         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aLoopStr );
1987         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bLoop ? aTrueStr : aFalseStr );
1988         delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
1989
1990         sal_Bool bMute = false;
1991         const OUString aMuteStr( RTL_CONSTASCII_USTRINGPARAM( "Mute" ) );
1992         xPropSet->getPropertyValue( aMuteStr ) >>= bMute;
1993         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aMuteStr );
1994         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bMute ? aTrueStr : aFalseStr );
1995         delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
1996
1997         sal_Int16 nVolumeDB = 0;
1998         const OUString aVolumeDBStr( RTL_CONSTASCII_USTRINGPARAM( "VolumeDB" ) );
1999         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "VolumeDB" ) ) ) >>= nVolumeDB;
2000         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aVolumeDBStr );
2001         mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, OUString::valueOf( static_cast< sal_Int32 >( nVolumeDB ) ) );
2002         delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
2003
2004         media::ZoomLevel eZoom;
2005         const OUString aZoomStr( RTL_CONSTASCII_USTRINGPARAM( "Zoom" ) );
2006         OUString aZoomValue;
2007         xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Zoom" ) ) ) >>= eZoom;
2008         switch( eZoom )
2009         {
2010             case( media::ZoomLevel_ZOOM_1_TO_4 ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "25%" ) ); break;
2011             case( media::ZoomLevel_ZOOM_1_TO_2 ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "50%" ) ); break;
2012             case( media::ZoomLevel_ORIGINAL ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "100%" ) ); break;
2013             case( media::ZoomLevel_ZOOM_2_TO_1 ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "200%" ) ); break;
2014             case( media::ZoomLevel_ZOOM_4_TO_1 ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "400%" ) ); break;
2015             case( media::ZoomLevel_FIT_TO_WINDOW ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "fit" ) ); break;
2016             case( media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "fixedfit" ) ); break;
2017             case( media::ZoomLevel_FULLSCREEN ): aZoomValue = OUString( RTL_CONSTASCII_USTRINGPARAM( "fullscreen" ) ); break;
2018
2019             default:
2020             break;
2021         }
2022
2023         if( aZoomValue.getLength() )
2024         {
2025             mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aZoomStr );
2026             mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aZoomValue );
2027             delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) );
2028         }
2029     }
2030 }