From 94755bd8f24582cc40c4257c971f518c270a52e7 Mon Sep 17 00:00:00 2001 From: Tor Lillqvist Date: Sun, 13 Oct 2013 14:36:21 +0300 Subject: Combine a pointlessly split class implementation and bin unused private field Change-Id: I44cee32e256e0767bb3b40bdba93e15b717c9ba6 --- include/xmloff/shapeexport.hxx | 1 - xmloff/Library_xo.mk | 3 - xmloff/source/draw/shapeexport.cxx | 3809 ++++++++++++++++++++++++++++++++++- xmloff/source/draw/shapeexport2.cxx | 2095 ------------------- xmloff/source/draw/shapeexport3.cxx | 477 ----- xmloff/source/draw/shapeexport4.cxx | 1314 ------------ 6 files changed, 3785 insertions(+), 3914 deletions(-) delete mode 100644 xmloff/source/draw/shapeexport2.cxx delete mode 100644 xmloff/source/draw/shapeexport3.cxx delete mode 100644 xmloff/source/draw/shapeexport4.cxx diff --git a/include/xmloff/shapeexport.hxx b/include/xmloff/shapeexport.hxx index 8dfaa0f89d5e..6dbe719cc352 100644 --- a/include/xmloff/shapeexport.hxx +++ b/include/xmloff/shapeexport.hxx @@ -162,7 +162,6 @@ private: UniReference< XMLPropertyHandlerFactory > mxSdPropHdlFactory; UniReference< SvXMLExportPropertyMapper > mxPropertySetMapper; UniReference< XMLAnimationsExporter > mxAnimationsExporter; - sal_Int32 mnNextUniqueShapeId; ShapesInfos maShapesInfos; ShapesInfos::iterator maCurrentShapesIter; sal_Bool mbExportLayer; diff --git a/xmloff/Library_xo.mk b/xmloff/Library_xo.mk index b72172b8cb3a..46ae11fbe24a 100644 --- a/xmloff/Library_xo.mk +++ b/xmloff/Library_xo.mk @@ -138,9 +138,6 @@ $(eval $(call gb_Library_add_exception_objects,xo,\ xmloff/source/draw/sdxmlexp \ xmloff/source/draw/sdxmlimp \ xmloff/source/draw/shapeexport \ - xmloff/source/draw/shapeexport2 \ - xmloff/source/draw/shapeexport3 \ - xmloff/source/draw/shapeexport4 \ xmloff/source/draw/shapeimport \ xmloff/source/draw/xexptran \ xmloff/source/draw/ximp3dobject \ diff --git a/xmloff/source/draw/shapeexport.cxx b/xmloff/source/draw/shapeexport.cxx index 6274da4c7f30..16f5d173b282 100644 --- a/xmloff/source/draw/shapeexport.cxx +++ b/xmloff/source/draw/shapeexport.cxx @@ -19,47 +19,99 @@ #include -#include -#include -#include -#include -#include +#include +#include +#include + +#include +#include #include -#include -#include -#include +#include +#include #include -#include +#include +#include +#include #include +#include +#include +#include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include -#include -#include "PropertySetMerger.hxx" +#include -#include -#include "sdpropls.hxx" -#include "sdxmlexp_impl.hxx" -#include -#include -#include -#include #include +#include +#include + +#include +#include + +#include + +#include #include -#include +#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include -#include "xmloff/xmlnmspe.hxx" +#include "anim.hxx" +#include "EnhancedCustomShapeToken.hxx" +#include "PropertySetMerger.hxx" +#include "sdpropls.hxx" +#include "sdxmlexp_impl.hxx" +#include "xexptran.hxx" +#include "XMLBase64Export.hxx" +#include "XMLImageMapExport.hxx" using namespace ::com::sun::star; +using namespace ::xmloff::EnhancedCustomShapeToken; using namespace ::xmloff::token; XMLShapeExport::XMLShapeExport(SvXMLExport& rExp, SvXMLExportPropertyMapper *pExtMapper ) : mrExport( rExp ), - mnNextUniqueShapeId(1), maShapesInfos(), maCurrentShapesIter(maShapesInfos.end()), mbExportLayer( sal_False ), @@ -1214,4 +1266,3713 @@ const rtl::Reference< XMLTableExport >& XMLShapeExport::GetShapeTableExport() return mxShapeTableExport; } +void XMLShapeExport::ImpExportNewTrans(const uno::Reference< beans::XPropertySet >& xPropSet, + sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + // get matrix + ::basegfx::B2DHomMatrix aMatrix; + ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet); + + // decompose and correct abour pRefPoint + ::basegfx::B2DTuple aTRScale; + double fTRShear(0.0); + double fTRRotate(0.0); + ::basegfx::B2DTuple aTRTranslate; + ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint); + + // use features and write + ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures); +} + +void XMLShapeExport::ImpExportNewTrans_GetB2DHomMatrix(::basegfx::B2DHomMatrix& rMatrix, + const uno::Reference< beans::XPropertySet >& xPropSet) +{ + /* Get , if it exist + and if the document is exported into the OpenOffice.org file format. + This property only exists at service com::sun::star::text::Shape - the + Writer UNO service for shapes. + This code is needed, because the positioning attributes in the + OpenOffice.org file format are given in horizontal left-to-right layout + regardless the layout direction the shape is in. In the OASIS Open Office + file format the positioning attributes are correctly given in the layout + direction the shape is in. Thus, this code provides the conversion from + the OASIS Open Office file format to the OpenOffice.org file format. (#i28749#) + */ + uno::Any aAny; + if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 && + xPropSet->getPropertySetInfo()->hasPropertyByName( + OUString("TransformationInHoriL2R")) ) + { + aAny = xPropSet->getPropertyValue("TransformationInHoriL2R"); + } + else + { + aAny = xPropSet->getPropertyValue("Transformation"); + } + drawing::HomogenMatrix3 aMatrix; + aAny >>= aMatrix; + + rMatrix.set(0, 0, aMatrix.Line1.Column1); + rMatrix.set(0, 1, aMatrix.Line1.Column2); + rMatrix.set(0, 2, aMatrix.Line1.Column3); + rMatrix.set(1, 0, aMatrix.Line2.Column1); + rMatrix.set(1, 1, aMatrix.Line2.Column2); + rMatrix.set(1, 2, aMatrix.Line2.Column3); + rMatrix.set(2, 0, aMatrix.Line3.Column1); + rMatrix.set(2, 1, aMatrix.Line3.Column2); + rMatrix.set(2, 2, aMatrix.Line3.Column3); +} + +void XMLShapeExport::ImpExportNewTrans_DecomposeAndRefPoint(const ::basegfx::B2DHomMatrix& rMatrix, ::basegfx::B2DTuple& rTRScale, + double& fTRShear, double& fTRRotate, ::basegfx::B2DTuple& rTRTranslate, com::sun::star::awt::Point* pRefPoint) +{ + // decompose matrix + rMatrix.decompose(rTRScale, rTRTranslate, fTRRotate, fTRShear); + + // correct translation about pRefPoint + if(pRefPoint) + { + rTRTranslate -= ::basegfx::B2DTuple(pRefPoint->X, pRefPoint->Y); + } +} + +void XMLShapeExport::ImpExportNewTrans_FeaturesAndWrite(::basegfx::B2DTuple& rTRScale, double fTRShear, + double fTRRotate, ::basegfx::B2DTuple& rTRTranslate, const sal_Int32 nFeatures) +{ + // always write Size (rTRScale) since this statement carries the union + // of the object + OUString aStr; + OUStringBuffer sStringBuffer; + ::basegfx::B2DTuple aTRScale(rTRScale); + + // svg: width + if(!(nFeatures & SEF_EXPORT_WIDTH)) + { + aTRScale.setX(1.0); + } + else + { + if( aTRScale.getX() > 0.0 ) + aTRScale.setX(aTRScale.getX() - 1.0); + else if( aTRScale.getX() < 0.0 ) + aTRScale.setX(aTRScale.getX() + 1.0); + } + + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + FRound(aTRScale.getX())); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, aStr); + + // svg: height + if(!(nFeatures & SEF_EXPORT_HEIGHT)) + { + aTRScale.setY(1.0); + } + else + { + if( aTRScale.getY() > 0.0 ) + aTRScale.setY(aTRScale.getY() - 1.0); + else if( aTRScale.getY() < 0.0 ) + aTRScale.setY(aTRScale.getY() + 1.0); + } + + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + FRound(aTRScale.getY())); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, aStr); + + // decide if transformation is necessary + sal_Bool bTransformationIsNeccessary(fTRShear != 0.0 || fTRRotate != 0.0); + + if(bTransformationIsNeccessary) + { + // write transformation, but WITHOUT scale which is exported as size above + SdXMLImExTransform2D aTransform; + + aTransform.AddSkewX(atan(fTRShear)); + + // #i78696# + // fTRRotate is mathematically correct, but due to the error + // we export/import it mirrored. Since the API implementation is fixed and + // uses the correctly oriented angle, it is necessary for compatibility to + // mirror the angle here to stay at the old behaviour. There is a follow-up + // task (#i78698#) to fix this in the next ODF FileFormat version + aTransform.AddRotate(-fTRRotate); + + aTransform.AddTranslate(rTRTranslate); + + // does transformation need to be exported? + if(aTransform.NeedsAction()) + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter())); + } + else + { + // no shear, no rotate; just add object position to export and we are done + if(nFeatures & SEF_EXPORT_X) + { + // svg: x + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + FRound(rTRTranslate.getX())); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X, aStr); + } + + if(nFeatures & SEF_EXPORT_Y) + { + // svg: y + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + FRound(rTRTranslate.getY())); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y, aStr); + } + } +} + +sal_Bool XMLShapeExport::ImpExportPresentationAttributes( const uno::Reference< beans::XPropertySet >& xPropSet, const OUString& rClass ) +{ + sal_Bool bIsEmpty = sal_False; + + // write presentation class entry + mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, rClass); + + if( xPropSet.is() ) + { + uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); + + sal_Bool bTemp = false; + + // is empty pes shape? + if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsEmptyPresentationObject")) + { + xPropSet->getPropertyValue("IsEmptyPresentationObject") >>= bIsEmpty; + if( bIsEmpty ) + mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, XML_TRUE); + } + + // is user-transformed? + if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsPlaceholderDependent")) + { + xPropSet->getPropertyValue("IsPlaceholderDependent") >>= bTemp; + if(!bTemp) + mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_USER_TRANSFORMED, XML_TRUE); + } + } + + return bIsEmpty; +} + +void XMLShapeExport::ImpExportText( const uno::Reference< drawing::XShape >& xShape ) +{ + uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY ); + if( xText.is() ) + { + uno::Reference< container::XEnumerationAccess > xEnumAccess( xShape, uno::UNO_QUERY ); + if( xEnumAccess.is() && xEnumAccess->hasElements() ) + mrExport.GetTextParagraphExport()->exportText( xText ); + } +} + + +namespace { + +const sal_Int32 FOUND_CLICKACTION = 0x00000001; +const sal_Int32 FOUND_BOOKMARK = 0x00000002; +const sal_Int32 FOUND_EFFECT = 0x00000004; +const sal_Int32 FOUND_PLAYFULL = 0x00000008; +const sal_Int32 FOUND_VERB = 0x00000010; +const sal_Int32 FOUND_SOUNDURL = 0x00000020; +const sal_Int32 FOUND_SPEED = 0x00000040; +const sal_Int32 FOUND_CLICKEVENTTYPE = 0x00000080; +const sal_Int32 FOUND_MACRO = 0x00000100; +const sal_Int32 FOUND_LIBRARY = 0x00000200; + +} // namespace + +void XMLShapeExport::ImpExportEvents( const uno::Reference< drawing::XShape >& xShape ) +{ + uno::Reference< document::XEventsSupplier > xEventsSupplier( xShape, uno::UNO_QUERY ); + if( !xEventsSupplier.is() ) + return; + + uno::Reference< container::XNameAccess > xEvents( xEventsSupplier->getEvents(), uno::UNO_QUERY ); + DBG_ASSERT( xEvents.is(), "XEventsSupplier::getEvents() returned NULL" ); + if( !xEvents.is() ) + return; + + sal_Int32 nFound = 0; + + OUString aClickEventType; + presentation::ClickAction eClickAction = presentation::ClickAction_NONE; + presentation::AnimationEffect eEffect = presentation::AnimationEffect_NONE; + presentation::AnimationSpeed eSpeed = presentation::AnimationSpeed_SLOW; + OUString aStrSoundURL; + sal_Bool bPlayFull = false; + sal_Int32 nVerb = 0; + OUString aStrMacro; + OUString aStrLibrary; + OUString aStrBookmark; + + uno::Sequence< beans::PropertyValue > aClickProperties; + if( xEvents->hasByName( msOnClick ) && (xEvents->getByName( msOnClick ) >>= aClickProperties) ) + { + const beans::PropertyValue* pProperty = aClickProperties.getConstArray(); + const beans::PropertyValue* pPropertyEnd = pProperty + aClickProperties.getLength(); + for( ; pProperty != pPropertyEnd; ++pProperty ) + { + if( ( ( nFound & FOUND_CLICKEVENTTYPE ) == 0 ) && pProperty->Name == msEventType ) + { + if( pProperty->Value >>= aClickEventType ) + nFound |= FOUND_CLICKEVENTTYPE; + } + else if( ( ( nFound & FOUND_CLICKACTION ) == 0 ) && pProperty->Name == msClickAction ) + { + if( pProperty->Value >>= eClickAction ) + nFound |= FOUND_CLICKACTION; + } + else if( ( ( nFound & FOUND_MACRO ) == 0 ) && ( pProperty->Name == msMacroName || pProperty->Name == msScript ) ) + { + if( pProperty->Value >>= aStrMacro ) + nFound |= FOUND_MACRO; + } + else if( ( ( nFound & FOUND_LIBRARY ) == 0 ) && pProperty->Name == msLibrary ) + { + if( pProperty->Value >>= aStrLibrary ) + nFound |= FOUND_LIBRARY; + } + else if( ( ( nFound & FOUND_EFFECT ) == 0 ) && pProperty->Name == msEffect ) + { + if( pProperty->Value >>= eEffect ) + nFound |= FOUND_EFFECT; + } + else if( ( ( nFound & FOUND_BOOKMARK ) == 0 ) && pProperty->Name == msBookmark ) + { + if( pProperty->Value >>= aStrBookmark ) + nFound |= FOUND_BOOKMARK; + } + else if( ( ( nFound & FOUND_SPEED ) == 0 ) && pProperty->Name == msSpeed ) + { + if( pProperty->Value >>= eSpeed ) + nFound |= FOUND_SPEED; + } + else if( ( ( nFound & FOUND_SOUNDURL ) == 0 ) && pProperty->Name == msSoundURL ) + { + if( pProperty->Value >>= aStrSoundURL ) + nFound |= FOUND_SOUNDURL; + } + else if( ( ( nFound & FOUND_PLAYFULL ) == 0 ) && pProperty->Name == msPlayFull ) + { + if( pProperty->Value >>= bPlayFull ) + nFound |= FOUND_PLAYFULL; + } + else if( ( ( nFound & FOUND_VERB ) == 0 ) && pProperty->Name == msVerb ) + { + if( pProperty->Value >>= nVerb ) + nFound |= FOUND_VERB; + } + } + } + + // create the XML elements + + if( aClickEventType == msPresentation ) + { + if( ((nFound & FOUND_CLICKACTION) == 0) || (eClickAction == presentation::ClickAction_NONE) ) + return; + + SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True); + + enum XMLTokenEnum eStrAction; + + switch( eClickAction ) + { + case presentation::ClickAction_PREVPAGE: eStrAction = XML_PREVIOUS_PAGE; break; + case presentation::ClickAction_NEXTPAGE: eStrAction = XML_NEXT_PAGE; break; + case presentation::ClickAction_FIRSTPAGE: eStrAction = XML_FIRST_PAGE; break; + case presentation::ClickAction_LASTPAGE: eStrAction = XML_LAST_PAGE; break; + case presentation::ClickAction_INVISIBLE: eStrAction = XML_HIDE; break; + case presentation::ClickAction_STOPPRESENTATION:eStrAction = XML_STOP; break; + case presentation::ClickAction_PROGRAM: eStrAction = XML_EXECUTE; break; + case presentation::ClickAction_BOOKMARK: eStrAction = XML_SHOW; break; + case presentation::ClickAction_DOCUMENT: eStrAction = XML_SHOW; break; + case presentation::ClickAction_MACRO: eStrAction = XML_EXECUTE_MACRO; break; + case presentation::ClickAction_VERB: eStrAction = XML_VERB; break; + case presentation::ClickAction_VANISH: eStrAction = XML_FADE_OUT; break; + case presentation::ClickAction_SOUND: eStrAction = XML_SOUND; break; + default: + OSL_FAIL( "unknown presentation::ClickAction found!" ); + eStrAction = XML_UNKNOWN; + } + + OUString aEventQName( + mrExport.GetNamespaceMap().GetQNameByKey( + XML_NAMESPACE_DOM, OUString( "click" ) ) ); + mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName ); + mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_ACTION, eStrAction ); + + if( eClickAction == presentation::ClickAction_VANISH ) + { + if( nFound & FOUND_EFFECT ) + { + XMLEffect eKind; + XMLEffectDirection eDirection; + sal_Int16 nStartScale; + bool bIn; + + SdXMLImplSetEffect( eEffect, eKind, eDirection, nStartScale, bIn ); + + if( eKind != EK_none ) + { + SvXMLUnitConverter::convertEnum( msBuffer, eKind, aXML_AnimationEffect_EnumMap ); + mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_EFFECT, msBuffer.makeStringAndClear() ); + } + + if( eDirection != ED_none ) + { + SvXMLUnitConverter::convertEnum( msBuffer, eDirection, aXML_AnimationDirection_EnumMap ); + mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_DIRECTION, msBuffer.makeStringAndClear() ); + } + + if( nStartScale != -1 ) + { + ::sax::Converter::convertPercent( msBuffer, nStartScale ); + mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_START_SCALE, msBuffer.makeStringAndClear() ); + } + } + + if( nFound & FOUND_SPEED && eEffect != presentation::AnimationEffect_NONE ) + { + if( eSpeed != presentation::AnimationSpeed_MEDIUM ) + { + SvXMLUnitConverter::convertEnum( msBuffer, eSpeed, aXML_AnimationSpeed_EnumMap ); + mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, msBuffer.makeStringAndClear() ); + } + } + } + + if( eClickAction == presentation::ClickAction_PROGRAM || + eClickAction == presentation::ClickAction_BOOKMARK || + eClickAction == presentation::ClickAction_DOCUMENT ) + { + if( eClickAction == presentation::ClickAction_BOOKMARK ) + msBuffer.append( sal_Unicode('#') ); + + msBuffer.append( aStrBookmark ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(msBuffer.makeStringAndClear()) ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST ); + } + + if( ( nFound & FOUND_VERB ) && eClickAction == presentation::ClickAction_VERB ) + { + msBuffer.append( nVerb ); + mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_VERB, msBuffer.makeStringAndClear()); + } + + SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_PRESENTATION, XML_EVENT_LISTENER, sal_True, sal_True); + + if( eClickAction == presentation::ClickAction_VANISH || eClickAction == presentation::ClickAction_SOUND ) + { + if( ( nFound & FOUND_SOUNDURL ) && !aStrSoundURL.isEmpty() ) + { + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStrSoundURL) ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST ); + if( nFound & FOUND_PLAYFULL && bPlayFull ) + mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PLAY_FULL, XML_TRUE ); + + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, sal_True, sal_True ); + } + } + } + else if( aClickEventType == msStarBasic ) + { + if( nFound & FOUND_MACRO ) + { + SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True); + + mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, + mrExport.GetNamespaceMap().GetQNameByKey( + XML_NAMESPACE_OOO, + OUString( "starbasic" ) ) ); + OUString aEventQName( + mrExport.GetNamespaceMap().GetQNameByKey( + XML_NAMESPACE_DOM, OUString( "click" ) ) ); + mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName ); + + if( nFound & FOUND_LIBRARY ) + { + OUString sLocation( GetXMLToken( + (aStrLibrary.equalsIgnoreAsciiCase("StarOffice") || + aStrLibrary.equalsIgnoreAsciiCase("application") ) ? XML_APPLICATION + : XML_DOCUMENT ) ); + mrExport.AddAttribute(XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, + sLocation + ":" + aStrMacro); + } + else + { + mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, aStrMacro ); + } + + SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True); + } + } + else if( aClickEventType == msScript ) + { + if( nFound & FOUND_MACRO ) + { + SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True); + if ( nFound & FOUND_MACRO ) + { + mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, mrExport.GetNamespaceMap().GetQNameByKey( + XML_NAMESPACE_OOO, GetXMLToken(XML_SCRIPT) ) ); + OUString aEventQName( + mrExport.GetNamespaceMap().GetQNameByKey( + XML_NAMESPACE_DOM, OUString( "click" ) ) ); + mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aStrMacro ); + + SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True); + } + } + } +} + +/** #i68101# export shape Title and Description */ +void XMLShapeExport::ImpExportDescription( const uno::Reference< drawing::XShape >& xShape ) +{ + try + { + OUString aTitle; + OUString aDescription; + + uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY_THROW ); + xProps->getPropertyValue("Title") >>= aTitle; + xProps->getPropertyValue("Description") >>= aDescription; + + if(!aTitle.isEmpty()) + { + SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_TITLE, sal_True, sal_False); + mrExport.Characters( aTitle ); + } + + if(!aDescription.isEmpty()) + { + SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_DESC, sal_True, sal_False ); + mrExport.Characters( aDescription ); + } + } + catch( uno::Exception& ) + { + OSL_FAIL( "could not export Title and/or Description for shape!" ); + } +} + +void XMLShapeExport::ImpExportGroupShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY); + if(xShapes.is() && xShapes->getCount()) + { + // write group shape + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aPGR(mrExport, XML_NAMESPACE_DRAW, XML_G, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + + // #89764# if export of position is supressed for group shape, + // positions of contained objects should be written relative to + // the upper left edge of the group. + awt::Point aUpperLeft; + + if(!(nFeatures & SEF_EXPORT_POSITION)) + { + nFeatures |= SEF_EXPORT_POSITION; + aUpperLeft = xShape->getPosition(); + pRefPoint = &aUpperLeft; + } + + // write members + exportShapes( xShapes, nFeatures, pRefPoint ); + } +} + +void XMLShapeExport::ImpExportTextBoxShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); + + // presentation attribute (if presentation) + sal_Bool bIsPresShape(sal_False); + sal_Bool bIsEmptyPresObj(sal_False); + OUString aStr; + + switch(eShapeType) + { + case XmlShapeTypePresSubtitleShape: + { + aStr = GetXMLToken(XML_PRESENTATION_SUBTITLE); + bIsPresShape = sal_True; + break; + } + case XmlShapeTypePresTitleTextShape: + { + aStr = GetXMLToken(XML_PRESENTATION_TITLE); + bIsPresShape = sal_True; + break; + } + case XmlShapeTypePresOutlinerShape: + { + aStr = GetXMLToken(XML_PRESENTATION_OUTLINE); + bIsPresShape = sal_True; + break; + } + case XmlShapeTypePresNotesShape: + { + aStr = GetXMLToken(XML_PRESENTATION_NOTES); + bIsPresShape = sal_True; + break; + } + case XmlShapeTypePresHeaderShape: + { + aStr = GetXMLToken(XML_HEADER); + bIsPresShape = sal_True; + break; + } + case XmlShapeTypePresFooterShape: + { + aStr = GetXMLToken(XML_FOOTER); + bIsPresShape = sal_True; + break; + } + case XmlShapeTypePresSlideNumberShape: + { + aStr = GetXMLToken(XML_PAGE_NUMBER); + bIsPresShape = sal_True; + break; + } + case XmlShapeTypePresDateTimeShape: + { + aStr = GetXMLToken(XML_DATE_TIME); + bIsPresShape = sal_True; + break; + } + default: + break; + } + + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + if(bIsPresShape) + bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, aStr ); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, + XML_FRAME, bCreateNewline, sal_True ); + + // evtl. corner radius? + sal_Int32 nCornerRadius(0L); + xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius; + if(nCornerRadius) + { + OUStringBuffer sStringBuffer; + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + nCornerRadius); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear()); + } + + { + // write text-box + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_TEXT_BOX, sal_True, sal_True); + if(!bIsEmptyPresObj) + ImpExportText( xShape ); + } + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + } +} + +void XMLShapeExport::ImpExportRectangleShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + // evtl. corner radius? + sal_Int32 nCornerRadius(0L); + xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius; + if(nCornerRadius) + { + OUStringBuffer sStringBuffer; + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + nCornerRadius); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear()); + } + + // write rectangle + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_RECT, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + } +} + +void XMLShapeExport::ImpExportLineShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + OUString aStr; + OUStringBuffer sStringBuffer; + awt::Point aStart(0,0); + awt::Point aEnd(1,1); + + // #85920# use 'Geometry' to get the points of the line + // since this slot take anchor pos into account. + + // get matrix + ::basegfx::B2DHomMatrix aMatrix; + ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet); + + // decompose and correct about pRefPoint + ::basegfx::B2DTuple aTRScale; + double fTRShear(0.0); + double fTRRotate(0.0); + ::basegfx::B2DTuple aTRTranslate; + ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint); + + // create base position + awt::Point aBasePosition(FRound(aTRTranslate.getX()), FRound(aTRTranslate.getY())); + + // get the two points + uno::Any aAny(xPropSet->getPropertyValue("Geometry")); + drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue(); + + if(pSourcePolyPolygon) + { + drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray(); + if(pOuterSequence) + { + drawing::PointSequence* pInnerSequence = pOuterSequence++; + if(pInnerSequence) + { + awt::Point* pArray = pInnerSequence->getArray(); + if(pArray) + { + if(pInnerSequence->getLength() > 0) + { + aStart = awt::Point( + pArray->X + aBasePosition.X, + pArray->Y + aBasePosition.Y); + pArray++; + } + + if(pInnerSequence->getLength() > 1) + { + aEnd = awt::Point( + pArray->X + aBasePosition.X, + pArray->Y + aBasePosition.Y); + } + } + } + } + } + + if( nFeatures & SEF_EXPORT_X ) + { + // svg: x1 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aStart.X); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr); + } + else + { + aEnd.X -= aStart.X; + } + + if( nFeatures & SEF_EXPORT_Y ) + { + // svg: y1 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aStart.Y); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr); + } + else + { + aEnd.Y -= aStart.Y; + } + + // svg: x2 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aEnd.X); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr); + + // svg: y2 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aEnd.Y); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr); + + // write line + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_LINE, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + } +} + +void XMLShapeExport::ImpExportEllipseShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // get size to decide between Circle and Ellipse + awt::Size aSize = xShape->getSize(); + sal_Int32 nRx((aSize.Width + 1) / 2); + sal_Int32 nRy((aSize.Height + 1) / 2); + sal_Bool bCircle(nRx == nRy); + + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + drawing::CircleKind eKind = drawing::CircleKind_FULL; + xPropSet->getPropertyValue("CircleKind") >>= eKind; + if( eKind != drawing::CircleKind_FULL ) + { + OUStringBuffer sStringBuffer; + sal_Int32 nStartAngle = 0; + sal_Int32 nEndAngle = 0; + xPropSet->getPropertyValue("CircleStartAngle") >>= nStartAngle; + xPropSet->getPropertyValue("CircleEndAngle") >>= nEndAngle; + + const double dStartAngle = nStartAngle / 100.0; + const double dEndAngle = nEndAngle / 100.0; + + // export circle kind + SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eKind, aXML_CircleKind_EnumMap ); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_KIND, sStringBuffer.makeStringAndClear() ); + + // export start angle + ::sax::Converter::convertDouble( sStringBuffer, dStartAngle ); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_ANGLE, sStringBuffer.makeStringAndClear() ); + + // export end angle + ::sax::Converter::convertDouble( sStringBuffer, dEndAngle ); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_ANGLE, sStringBuffer.makeStringAndClear() ); + } + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + + if(bCircle) + { + // write circle + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CIRCLE, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + } + else + { + // write ellipse + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_ELLIPSE, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + } + } +} + +void XMLShapeExport::ImpExportPolygonShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + sal_Bool bClosed(eShapeType == XmlShapeTypeDrawPolyPolygonShape + || eShapeType == XmlShapeTypeDrawClosedBezierShape); + sal_Bool bBezier(eShapeType == XmlShapeTypeDrawClosedBezierShape + || eShapeType == XmlShapeTypeDrawOpenBezierShape); + + // get matrix + ::basegfx::B2DHomMatrix aMatrix; + ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet); + + // decompose and correct abour pRefPoint + ::basegfx::B2DTuple aTRScale; + double fTRShear(0.0); + double fTRRotate(0.0); + ::basegfx::B2DTuple aTRTranslate; + ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint); + + // use features and write + ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures); + + // create and export ViewBox + awt::Point aPoint(0, 0); + awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY())); + SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString()); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + + if(bBezier) + { + // get PolygonBezier + uno::Any aAny( xPropSet->getPropertyValue("Geometry") ); + drawing::PolyPolygonBezierCoords* pSourcePolyPolygon = + (drawing::PolyPolygonBezierCoords*)aAny.getValue(); + + if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength()) + { + sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength()); + drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray(); + drawing::FlagSequence* pOuterFlags = pSourcePolyPolygon->Flags.getArray(); + + if(pOuterSequence && pOuterFlags) + { + // prepare svx:d element export + SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); + + for(sal_Int32 a(0L); a < nOuterCnt; a++) + { + drawing::PointSequence* pSequence = pOuterSequence++; + drawing::FlagSequence* pFlags = pOuterFlags++; + + if(pSequence && pFlags) + { + aSvgDElement.AddPolygon(pSequence, pFlags, + aPoint, aSize, bClosed); + } + } + + // write point array + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); + } + + // write object now + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + } + } + else + { + // get non-bezier polygon + uno::Any aAny( xPropSet->getPropertyValue("Geometry") ); + drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue(); + + if(pSourcePolyPolygon && pSourcePolyPolygon->getLength()) + { + sal_Int32 nOuterCnt(pSourcePolyPolygon->getLength()); + + if(1L == nOuterCnt && !bBezier) + { + // simple polygon shape, can be written as svg:points sequence + drawing::PointSequence* pSequence = pSourcePolyPolygon->getArray(); + if(pSequence) + { + SdXMLImExPointsElement aPoints(pSequence, aViewBox, aPoint, aSize, + // #96328# + bClosed); + + // write point array + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_POINTS, aPoints.GetExportString()); + } + + // write object now + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, + bClosed ? XML_POLYGON : XML_POLYLINE , bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + } + else + { + // polypolygon or bezier, needs to be written as a svg:path sequence + drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray(); + if(pOuterSequence) + { + // prepare svx:d element export + SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); + + for(sal_Int32 a(0L); a < nOuterCnt; a++) + { + drawing::PointSequence* pSequence = pOuterSequence++; + if(pSequence) + { + aSvgDElement.AddPolygon(pSequence, 0L, aPoint, + aSize, bClosed); + } + } + + // write point array + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); + } + + // write object now + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + } + } + } + } +} + +void XMLShapeExport::ImpExportGraphicObjectShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + sal_Bool bIsEmptyPresObj = sal_False; + uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); + + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + OUString sImageURL; + + if(eShapeType == XmlShapeTypePresGraphicObjectShape) + bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_GRAPHIC) ); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, + XML_FRAME, bCreateNewline, sal_True ); + + const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ); + + if( !bIsEmptyPresObj || bSaveBackwardsCompatible ) + { + if( !bIsEmptyPresObj ) + { + OUString aReplacementUrl; + xPropSet->getPropertyValue("ReplacementGraphicURL") >>= aReplacementUrl; + + // If there is no url, then then graphic is empty + if(!aReplacementUrl.isEmpty()) + { + const OUString aStr = mrExport.AddEmbeddedGraphicObject(aReplacementUrl); + + if(aStr.getLength()) + { + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + + // xlink:href for replacement, only written for Svg content + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True); + + // optional office:binary-data + mrExport.AddEmbeddedGraphicObjectAsBase64(aReplacementUrl); + } + } + + OUString aStreamURL; + OUString aStr; + + xPropSet->getPropertyValue("GraphicStreamURL") >>= aStreamURL; + xPropSet->getPropertyValue("GraphicURL") >>= sImageURL; + + OUString aResolveURL( sImageURL ); + const OUString sPackageURL( "vnd.sun.star.Package:" ); + + // sj: trying to preserve the filename + if ( aStreamURL.match( sPackageURL, 0 ) ) + { + OUString sRequestedName( aStreamURL.copy( sPackageURL.getLength(), aStreamURL.getLength() - sPackageURL.getLength() ) ); + sal_Int32 nLastIndex = sRequestedName.lastIndexOf( '/' ) + 1; + if ( ( nLastIndex > 0 ) && ( nLastIndex < sRequestedName.getLength() ) ) + sRequestedName = sRequestedName.copy( nLastIndex, sRequestedName.getLength() - nLastIndex ); + nLastIndex = sRequestedName.lastIndexOf( '.' ); + if ( nLastIndex >= 0 ) + sRequestedName = sRequestedName.copy( 0, nLastIndex ); + if ( !sRequestedName.isEmpty() ) + { + aResolveURL = aResolveURL.concat( OUString("?requestedName=")); + aResolveURL = aResolveURL.concat( sRequestedName ); + } + } + + aStr = mrExport.AddEmbeddedGraphicObject( aResolveURL ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr ); + + if( !aStr.isEmpty() ) + { + if( aStr[ 0 ] == '#' ) + { + aStreamURL = sPackageURL; + aStreamURL = aStreamURL.concat( aStr.copy( 1, aStr.getLength() - 1 ) ); + } + + // update stream URL for load on demand + uno::Any aAny; + aAny <<= aStreamURL; + xPropSet->setPropertyValue("GraphicStreamURL", aAny ); + + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + } + } + else + { + OUString aStr; + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + } + + { + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True); + + if( !sImageURL.isEmpty() ) + { + // optional office:binary-data + mrExport.AddEmbeddedGraphicObjectAsBase64( sImageURL ); + } + if( !bIsEmptyPresObj ) + ImpExportText( xShape ); + } + } + + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + + // image map + GetExport().GetImageMapExport().Export( xPropSet ); + ImpExportDescription( xShape ); // #i68101# + } +} + +void XMLShapeExport::ImpExportChartShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint, + SvXMLAttributeList* pAttrList ) +{ + ImpExportOLE2Shape( xShape, eShapeType, nFeatures, pRefPoint, pAttrList ); +} + +void XMLShapeExport::ImpExportControlShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + } + + uno::Reference< drawing::XControlShape > xControl( xShape, uno::UNO_QUERY ); + DBG_ASSERT( xControl.is(), "Control shape is not supporting XControlShape" ); + if( xControl.is() ) + { + uno::Reference< beans::XPropertySet > xControlModel( xControl->getControl(), uno::UNO_QUERY ); + DBG_ASSERT( xControlModel.is(), "Control shape has not XControlModel" ); + if( xControlModel.is() ) + { + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONTROL, mrExport.GetFormExport()->getControlId( xControlModel ) ); + } + } + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONTROL, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# +} + +void XMLShapeExport::ImpExportConnectorShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) +{ + uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY ); + + OUString aStr; + OUStringBuffer sStringBuffer; + + // export connection kind + drawing::ConnectorType eType = drawing::ConnectorType_STANDARD; + uno::Any aAny = xProps->getPropertyValue("EdgeKind"); + aAny >>= eType; + + if( eType != drawing::ConnectorType_STANDARD ) + { + SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eType, aXML_ConnectionKind_EnumMap ); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TYPE, aStr); + } + + // export line skew + sal_Int32 nDelta1 = 0, nDelta2 = 0, nDelta3 = 0; + + aAny = xProps->getPropertyValue("EdgeLine1Delta"); + aAny >>= nDelta1; + aAny = xProps->getPropertyValue("EdgeLine2Delta"); + aAny >>= nDelta2; + aAny = xProps->getPropertyValue("EdgeLine3Delta"); + aAny >>= nDelta3; + + if( nDelta1 != 0 || nDelta2 != 0 || nDelta3 != 0 ) + { + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + nDelta1); + if( nDelta2 != 0 || nDelta3 != 0 ) + { + const char aSpace = ' '; + sStringBuffer.appendAscii( &aSpace, 1 ); + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + nDelta2); + if( nDelta3 != 0 ) + { + sStringBuffer.appendAscii( &aSpace, 1 ); + mrExport.GetMM100UnitConverter().convertMeasureToXML( + sStringBuffer, nDelta3); + } + } + + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_LINE_SKEW, aStr); + } + + // export start and end point + awt::Point aStart(0,0); + awt::Point aEnd(1,1); + + /* Get and + , if they exist and if the document is exported + into the OpenOffice.org file format. + These properties only exist at service com::sun::star::text::Shape - the + Writer UNO service for shapes. + This code is needed, because the positioning attributes in the + OpenOffice.org file format are given in horizontal left-to-right layout + regardless the layout direction the shape is in. In the OASIS Open Office + file format the positioning attributes are correctly given in the layout + direction the shape is in. Thus, this code provides the conversion from + the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#) + */ + if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 && + xProps->getPropertySetInfo()->hasPropertyByName( + OUString("StartPositionInHoriL2R")) && + xProps->getPropertySetInfo()->hasPropertyByName( + OUString("EndPositionInHoriL2R")) ) + { + xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart; + xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd; + } + else + { + xProps->getPropertyValue("StartPosition") >>= aStart; + xProps->getPropertyValue("EndPosition") >>= aEnd; + } + + if( pRefPoint ) + { + aStart.X -= pRefPoint->X; + aStart.Y -= pRefPoint->Y; + aEnd.X -= pRefPoint->X; + aEnd.Y -= pRefPoint->Y; + } + + if( nFeatures & SEF_EXPORT_X ) + { + // svg: x1 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aStart.X); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr); + } + else + { + aEnd.X -= aStart.X; + } + + if( nFeatures & SEF_EXPORT_Y ) + { + // svg: y1 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aStart.Y); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr); + } + else + { + aEnd.Y -= aStart.Y; + } + + // svg: x2 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr); + + // svg: y2 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr); + + // #i39320# + uno::Reference< uno::XInterface > xRefS; + uno::Reference< uno::XInterface > xRefE; + + // export start connection + xProps->getPropertyValue("StartShape") >>= xRefS; + if( xRefS.is() ) + { + const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefS ); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_SHAPE, rShapeId); + + aAny = xProps->getPropertyValue("StartGluePointIndex"); + sal_Int32 nGluePointId = 0; + if( aAny >>= nGluePointId ) + { + if( nGluePointId != -1 ) + { + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_GLUE_POINT, OUString::number( nGluePointId )); + } + } + } + + // export end connection + xProps->getPropertyValue("EndShape") >>= xRefE; + if( xRefE.is() ) + { + const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefE ); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_SHAPE, rShapeId); + + aAny = xProps->getPropertyValue("EndGluePointIndex"); + sal_Int32 nGluePointId = 0; + if( aAny >>= nGluePointId ) + { + if( nGluePointId != -1 ) + { + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_GLUE_POINT, OUString::number( nGluePointId )); + } + } + } + + if( xProps->getPropertyValue("PolyPolygonBezier") >>= aAny ) + { + // get PolygonBezier + drawing::PolyPolygonBezierCoords* pSourcePolyPolygon = + (drawing::PolyPolygonBezierCoords*)aAny.getValue(); + + if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength()) + { + sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength()); + drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray(); + drawing::FlagSequence* pOuterFlags = pSourcePolyPolygon->Flags.getArray(); + + if(pOuterSequence && pOuterFlags) + { + // prepare svx:d element export + awt::Point aPoint( 0, 0 ); + awt::Size aSize( 1, 1 ); + SdXMLImExViewBox aViewBox( 0, 0, 1, 1 ); + SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); + + for(sal_Int32 a(0L); a < nOuterCnt; a++) + { + drawing::PointSequence* pSequence = pOuterSequence++; + drawing::FlagSequence* pFlags = pOuterFlags++; + + if(pSequence && pFlags) + { + aSvgDElement.AddPolygon(pSequence, pFlags, + aPoint, aSize, sal_False ); + } + } + + // write point array + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); + } + } + } + + // get matrix + ::basegfx::B2DHomMatrix aMatrix; + ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xProps); + + // decompose and correct about pRefPoint + ::basegfx::B2DTuple aTRScale; + double fTRShear(0.0); + double fTRRotate(0.0); + ::basegfx::B2DTuple aTRTranslate; + ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, + fTRRotate, aTRTranslate, pRefPoint); + + // fdo#49678: create and export ViewBox + awt::Point aPoint(0, 0); + awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY())); + SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString()); + + // write connector shape. Add Export later. + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONNECTOR, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); +} + +void XMLShapeExport::ImpExportMeasureShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) +{ + uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY ); + + OUString aStr; + OUStringBuffer sStringBuffer; + + // export start and end point + awt::Point aStart(0,0); + awt::Point aEnd(1,1); + + /* Get and + , if they exist and if the document is exported + into the OpenOffice.org file format. + These properties only exist at service com::sun::star::text::Shape - the + Writer UNO service for shapes. + This code is needed, because the positioning attributes in the + OpenOffice.org file format are given in horizontal left-to-right layout + regardless the layout direction the shape is in. In the OASIS Open Office + file format the positioning attributes are correctly given in the layout + direction the shape is in. Thus, this code provides the conversion from + the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#) + */ + if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 && + xProps->getPropertySetInfo()->hasPropertyByName( + OUString("StartPositionInHoriL2R")) && + xProps->getPropertySetInfo()->hasPropertyByName( + OUString("EndPositionInHoriL2R")) ) + { + xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart; + xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd; + } + else + { + xProps->getPropertyValue("StartPosition") >>= aStart; + xProps->getPropertyValue("EndPosition") >>= aEnd; + } + + if( pRefPoint ) + { + aStart.X -= pRefPoint->X; + aStart.Y -= pRefPoint->Y; + aEnd.X -= pRefPoint->X; + aEnd.Y -= pRefPoint->Y; + } + + if( nFeatures & SEF_EXPORT_X ) + { + // svg: x1 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aStart.X); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr); + } + else + { + aEnd.X -= aStart.X; + } + + if( nFeatures & SEF_EXPORT_Y ) + { + // svg: y1 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + aStart.Y); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr); + } + else + { + aEnd.Y -= aStart.Y; + } + + // svg: x2 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr); + + // svg: y2 + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr); + + // write measure shape + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_MEASURE, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + + uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY ); + if( xText.is() ) + mrExport.GetTextParagraphExport()->exportText( xText ); +} + +void XMLShapeExport::ImpExportOLE2Shape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */, + SvXMLAttributeList* pAttrList /* = NULL */ ) +{ + uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY); + + DBG_ASSERT( xPropSet.is() && xNamed.is(), "ole shape is not implementing needed interfaces"); + if(xPropSet.is() && xNamed.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + sal_Bool bIsEmptyPresObj = sal_False; + + // presentation settings + if(eShapeType == XmlShapeTypePresOLE2Shape) + bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) ); + else if(eShapeType == XmlShapeTypePresChartShape) + bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_CHART) ); + else if(eShapeType == XmlShapeTypePresSheetShape) + bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) ); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + sal_Bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED)); + OUString sPersistName; + SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, + XML_FRAME, bCreateNewline, sal_True ); + + const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ); + + if( !bIsEmptyPresObj || bSaveBackwardsCompatible ) + { + if (pAttrList) + { + mrExport.AddAttributeList(pAttrList); + } + + OUString sClassId; + OUString sURL; + sal_Bool bInternal = false; + xPropSet->getPropertyValue("IsInternal") >>= bInternal; + + if( !bIsEmptyPresObj ) + { + + if ( bInternal ) + { + // OOo internal links have no storage persistance, URL is stored in the XML file + // the result LinkURL is empty in case the object is not a link + xPropSet->getPropertyValue("LinkURL") >>= sURL; + } + + xPropSet->getPropertyValue("PersistName") >>= sPersistName; + if ( sURL.isEmpty() ) + { + if( !sPersistName.isEmpty() ) + { + sURL = OUString( "vnd.sun.star.EmbeddedObject:" ); + sURL += sPersistName; + } + } + + if( !bInternal ) + xPropSet->getPropertyValue("CLSID") >>= sClassId; + + if( !sClassId.isEmpty() ) + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CLASS_ID, sClassId ); + + if(eShapeType != XmlShapeTypePresChartShape && eShapeType != XmlShapeTypeDrawChartShape) + { + // #i118485# Add text export, the draw OLE shape allows text now + // fdo#58571 chart objects don't allow text:p + ImpExportText( xShape ); + } + + if(!bExportEmbedded) + { + // xlink:href + if( !sURL.isEmpty() ) + { + // #96717# in theorie, if we don't have a url we shouldn't even + // export this ole shape. But practical its to risky right now + // to change this so we better dispose this on load + sURL = mrExport.AddEmbeddedObject( sURL ); + + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + } + } + } + else + { + // export empty href for empty placeholders to be valid ODF + OUString sEmptyURL; + + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sEmptyURL ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + } + + enum XMLTokenEnum eElem = sClassId.isEmpty() ? XML_OBJECT : XML_OBJECT_OLE ; + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, eElem, sal_True, sal_True ); + + if(bExportEmbedded && !bIsEmptyPresObj) + { + // #100592# + if(bInternal) + { + // embedded XML + uno::Reference< lang::XComponent > xComp; + xPropSet->getPropertyValue("Model") >>= xComp; + DBG_ASSERT( xComp.is(), "no xModel for own OLE format" ); + mrExport.ExportEmbeddedOwnObject( xComp ); + } + else + { + // embed as Base64 + // this is an alien object ( currently MSOLE is the only supported type of such objects ) + // in case it is not an OASIS format the object should be asked to store replacement image if possible + + OUString sURLRequest( sURL ); + if ( ( mrExport.getExportFlags() & EXPORT_OASIS ) == 0 ) + sURLRequest += OUString( "?oasis=false" ); + mrExport.AddEmbeddedObjectAsBase64( sURLRequest ); + } + } + } + if( !bIsEmptyPresObj ) + { + OUString sURL( "vnd.sun.star.GraphicObject:" ); + sURL += sPersistName; + if( !bExportEmbedded ) + { + sURL = GetExport().AddEmbeddedObject( sURL ); + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + } + + SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, + XML_IMAGE, sal_False, sal_True ); + + if( bExportEmbedded ) + GetExport().AddEmbeddedObjectAsBase64( sURL ); + } + + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportDescription( xShape ); // #i68101# + } +} + +void XMLShapeExport::ImpExportPageShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // #86163# Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + // export page number used for this page + uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); + const OUString aPageNumberStr("PageNumber"); + if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr)) + { + sal_Int32 nPageNumber = 0; + xPropSet->getPropertyValue(aPageNumberStr) >>= nPageNumber; + if( nPageNumber ) + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_PAGE_NUMBER, OUString::number(nPageNumber)); + } + + // a presentation page shape, normally used on notes pages only. If + // it is used not as presentation shape, it may have been created with + // copy-paste exchange between draw and impress (this IS possible...) + if(eShapeType == XmlShapeTypePresPageShape) + { + mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, + XML_PRESENTATION_PAGE); + } + + // write Page shape + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PAGE_THUMBNAIL, bCreateNewline, sal_True); + } +} + +void XMLShapeExport::ImpExportCaptionShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + // evtl. corner radius? + sal_Int32 nCornerRadius(0L); + xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius; + if(nCornerRadius) + { + OUStringBuffer sStringBuffer; + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + nCornerRadius); + mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear()); + } + + awt::Point aCaptionPoint; + xPropSet->getPropertyValue("CaptionPoint") >>= aCaptionPoint; + + mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer, + aCaptionPoint.X); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_X, msBuffer.makeStringAndClear() ); + mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer, + aCaptionPoint.Y); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_Y, msBuffer.makeStringAndClear() ); + + // write Caption shape. Add export later. + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + sal_Bool bAnnotation( (nFeatures & SEF_EXPORT_ANNOTATION) == SEF_EXPORT_ANNOTATION ); + + SvXMLElementExport aObj( mrExport, + (bAnnotation ? XML_NAMESPACE_OFFICE + : XML_NAMESPACE_DRAW), + (bAnnotation ? XML_ANNOTATION : XML_CAPTION), + bCreateNewline, sal_True ); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + if( bAnnotation ) + mrExport.exportAnnotationMeta( xShape ); + ImpExportText( xShape ); + } +} + +void XMLShapeExport::ImpExportFrameShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, + XML_FRAME, bCreateNewline, sal_True ); + + // export frame url + OUString aStr; + xPropSet->getPropertyValue("FrameURL") >>= aStr; + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + + // export name + xPropSet->getPropertyValue("FrameName") >>= aStr; + if( !aStr.isEmpty() ) + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FRAME_NAME, aStr ); + + // write floating frame + { + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_FLOATING_FRAME, sal_True, sal_True); + } + } +} + +void XMLShapeExport::ImpExportAppletShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, + XML_FRAME, bCreateNewline, sal_True ); + + // export frame url + OUString aStr; + xPropSet->getPropertyValue("AppletCodeBase") >>= aStr; + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + + // export draw:applet-name + xPropSet->getPropertyValue("AppletName") >>= aStr; + if( !aStr.isEmpty() ) + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_APPLET_NAME, aStr ); + + // export draw:code + xPropSet->getPropertyValue("AppletCode") >>= aStr; + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CODE, aStr ); + + // export draw:may-script + sal_Bool bIsScript = false; + xPropSet->getPropertyValue("AppletIsScript") >>= bIsScript; + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, bIsScript ? XML_TRUE : XML_FALSE ); + + { + // write applet + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_APPLET, sal_True, sal_True); + + // export parameters + uno::Sequence< beans::PropertyValue > aCommands; + xPropSet->getPropertyValue("AppletCommands") >>= aCommands; + const sal_Int32 nCount = aCommands.getLength(); + for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ ) + { + aCommands[nIndex].Value >>= aStr; + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name ); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr ); + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ); + } + } + } +} + +void XMLShapeExport::ImpExportPluginShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, + XML_FRAME, bCreateNewline, sal_True ); + + // export plugin url + OUString aStr; + xPropSet->getPropertyValue("PluginURL") >>= aStr; + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + + // export mime-type + xPropSet->getPropertyValue("PluginMimeType") >>= aStr; + if(!aStr.isEmpty()) + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, aStr ); + + { + // write plugin + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, sal_True, sal_True); + + // export parameters + uno::Sequence< beans::PropertyValue > aCommands; + xPropSet->getPropertyValue("PluginCommands") >>= aCommands; + const sal_Int32 nCount = aCommands.getLength(); + for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ ) + { + aCommands[nIndex].Value >>= aStr; + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name ); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr ); + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ); + } + } + } +} + +static void lcl_CopyStream( + uno::Reference const& xInStream, + uno::Reference const& xTarget, + OUString const& rPath) +{ + ::comphelper::LifecycleProxy proxy; + uno::Reference const xStream( + ::comphelper::OStorageHelper::GetStreamAtPackageURL(xTarget, rPath, + embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE, proxy)); + uno::Reference const xOutStream( + (xStream.is()) ? xStream->getOutputStream() : 0); + if (!xOutStream.is()) + { + SAL_WARN("xmloff", "no output stream"); + throw uno::Exception( + OUString("no output stream"),0); + } + uno::Reference< beans::XPropertySet > const xStreamProps(xStream, + uno::UNO_QUERY); + if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage + xStreamProps->setPropertyValue( + OUString("MediaType"), + uno::makeAny(OUString( + //FIXME how to detect real media type? + //but currently xmloff has this one hardcoded anyway... + "application/vnd.sun.star.media"))); + xStreamProps->setPropertyValue( // turn off compression + OUString("Compressed"), + uno::makeAny(sal_False)); + } + ::comphelper::OStorageHelper::CopyInputToOutput(xInStream, xOutStream); + xOutStream->closeOutput(); + proxy.commitStorages(); +} + +static char const s_PkgScheme[] = "vnd.sun.star.Package:"; + +static OUString +lcl_StoreMediaAndGetURL(SvXMLExport & rExport, + uno::Reference const& xPropSet, + OUString const& rURL) +{ + if (0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( + rURL.getStr(), rURL.getLength(), + s_PkgScheme, SAL_N_ELEMENTS(s_PkgScheme) - 1)) + { + try // video is embedded + { + uno::Reference const xTarget( + rExport.GetTargetStorage(), uno::UNO_QUERY_THROW); + uno::Reference xInStream; + xPropSet->getPropertyValue( + OUString("PrivateStream")) + >>= xInStream; + + if (!xInStream.is()) + { + SAL_WARN("xmloff", "no input stream"); + return OUString(); + } + + OUString const urlPath( + rURL.copy(SAL_N_ELEMENTS(s_PkgScheme)-1)); + + lcl_CopyStream(xInStream, xTarget, rURL); + + return urlPath; + } + catch (uno::Exception const& e) + { + SAL_INFO("xmloff", "exception while storing embedded media: '" + << e.Message << "'"); + } + return OUString(); + } + else + { + return rExport.GetRelativeReference(rURL); // linked + } +} + +void XMLShapeExport::ImpExportMediaShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + if(eShapeType == XmlShapeTypePresMediaShape) + ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) ); + + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, + XML_FRAME, bCreateNewline, sal_True ); + + // export media url + OUString aMediaURL; + xPropSet->getPropertyValue("MediaURL") >>= aMediaURL; + OUString const persistentURL = + lcl_StoreMediaAndGetURL(GetExport(), xPropSet, aMediaURL); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, persistentURL ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + + // export mime-type + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, OUString( "application/vnd.sun.star.media" ) ); + + // write plugin + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, !( nFeatures & SEF_EXPORT_NO_WS ), sal_True); + + // export parameters + const OUString aFalseStr( "false" ), aTrueStr( "true" ); + + sal_Bool bLoop = false; + const OUString aLoopStr( "Loop" ); + xPropSet->getPropertyValue( aLoopStr ) >>= bLoop; + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aLoopStr ); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bLoop ? aTrueStr : aFalseStr ); + delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); + + sal_Bool bMute = false; + const OUString aMuteStr( "Mute" ); + xPropSet->getPropertyValue( aMuteStr ) >>= bMute; + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aMuteStr ); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bMute ? aTrueStr : aFalseStr ); + delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); + + sal_Int16 nVolumeDB = 0; + const OUString aVolumeDBStr( "VolumeDB" ); + xPropSet->getPropertyValue("VolumeDB") >>= nVolumeDB; + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aVolumeDBStr ); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, OUString::number( nVolumeDB ) ); + delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); + + media::ZoomLevel eZoom; + const OUString aZoomStr( "Zoom" ); + OUString aZoomValue; + xPropSet->getPropertyValue("Zoom") >>= eZoom; + switch( eZoom ) + { + case( media::ZoomLevel_ZOOM_1_TO_4 ): aZoomValue = OUString( "25%" ); break; + case( media::ZoomLevel_ZOOM_1_TO_2 ): aZoomValue = OUString( "50%" ); break; + case( media::ZoomLevel_ORIGINAL ): aZoomValue = OUString( "100%" ); break; + case( media::ZoomLevel_ZOOM_2_TO_1 ): aZoomValue = OUString( "200%" ); break; + case( media::ZoomLevel_ZOOM_4_TO_1 ): aZoomValue = OUString( "400%" ); break; + case( media::ZoomLevel_FIT_TO_WINDOW ): aZoomValue = OUString( "fit" ); break; + case( media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT ): aZoomValue = OUString( "fixedfit" ); break; + case( media::ZoomLevel_FULLSCREEN ): aZoomValue = OUString( "fullscreen" ); break; + + default: + break; + } + + if( !aZoomValue.isEmpty() ) + { + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aZoomStr ); + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aZoomValue ); + delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); + } + } +} + +void XMLShapeExport::ImpExport3DSceneShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) +{ + uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY); + if(xShapes.is() && xShapes->getCount()) + { + uno::Reference< beans::XPropertySet > xPropSet( xShape, uno::UNO_QUERY ); + DBG_ASSERT( xPropSet.is(), "XMLShapeExport::ImpExport3DSceneShape can't export a scene without a propertyset" ); + if( xPropSet.is() ) + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + // 3d attributes + export3DSceneAttributes( xPropSet ); + + // write 3DScene shape + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DR3D, XML_SCENE, bCreateNewline, sal_True); + + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + + // write 3DSceneLights + export3DLamps( xPropSet ); + + // #89764# if export of position is supressed for group shape, + // positions of contained objects should be written relative to + // the upper left edge of the group. + awt::Point aUpperLeft; + + if(!(nFeatures & SEF_EXPORT_POSITION)) + { + nFeatures |= SEF_EXPORT_POSITION; + aUpperLeft = xShape->getPosition(); + pRefPoint = &aUpperLeft; + } + + // write members + exportShapes( xShapes, nFeatures, pRefPoint ); + } + } +} + +void XMLShapeExport::ImpExport3DShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType eShapeType, sal_Int32 /* nFeatures = SEF_DEFAULT */, awt::Point* /*pRefPoint = NULL */) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if(xPropSet.is()) + { + OUString aStr; + OUStringBuffer sStringBuffer; + + // transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix") + uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix"); + drawing::HomogenMatrix xHomMat; + aAny >>= xHomMat; + SdXMLImExTransform3D aTransform; + aTransform.AddHomogenMatrix(xHomMat); + if(aTransform.NeedsAction()) + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter())); + + switch(eShapeType) + { + case XmlShapeTypeDraw3DCubeObject: + { + // write 3DCube shape + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_CUBE, sal_True, sal_True); + + // minEdge + aAny = xPropSet->getPropertyValue("D3DPosition"); + drawing::Position3D aPosition3D; + aAny >>= aPosition3D; + ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ); + + // maxEdge + aAny = xPropSet->getPropertyValue("D3DSize"); + drawing::Direction3D aDirection3D; + aAny >>= aDirection3D; + ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ); + + // transform maxEdge from distance to pos + aDir3D = aPos3D + aDir3D; + + // write minEdge + if(aPos3D != ::basegfx::B3DVector(-2500.0, -2500.0, -2500.0)) // write only when not default + { + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MIN_EDGE, aStr); + } + + // write maxEdge + if(aDir3D != ::basegfx::B3DVector(2500.0, 2500.0, 2500.0)) // write only when not default + { + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MAX_EDGE, aStr); + } + + break; + } + case XmlShapeTypeDraw3DSphereObject: + { + // write 3DSphere shape + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_SPHERE, sal_True, sal_True); + + // Center + aAny = xPropSet->getPropertyValue("D3DPosition"); + drawing::Position3D aPosition3D; + aAny >>= aPosition3D; + ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ); + + // Size + aAny = xPropSet->getPropertyValue("D3DSize"); + drawing::Direction3D aDirection3D; + aAny >>= aDirection3D; + ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ); + + // write Center + if(aPos3D != ::basegfx::B3DVector(0.0, 0.0, 0.0)) // write only when not default + { + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_CENTER, aStr); + } + + // write Size + if(aDir3D != ::basegfx::B3DVector(5000.0, 5000.0, 5000.0)) // write only when not default + { + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SIZE, aStr); + } + + break; + } + case XmlShapeTypeDraw3DLatheObject: + case XmlShapeTypeDraw3DExtrudeObject: + { + // write special 3DLathe/3DExtrude attributes + aAny = xPropSet->getPropertyValue("D3DPolyPolygon3D"); + drawing::PolyPolygonShape3D xPolyPolygon3D; + aAny >>= xPolyPolygon3D; + + // look for maximal values + double fXMin = 0; + double fXMax = 0; + double fYMin = 0; + double fYMax = 0; + sal_Bool bInit(sal_False); + sal_Int32 nOuterSequenceCount(xPolyPolygon3D.SequenceX.getLength()); + drawing::DoubleSequence* pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray(); + drawing::DoubleSequence* pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray(); + + sal_Int32 a; + for (a = 0; a < nOuterSequenceCount; a++) + { + sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength()); + double* pArrayX = pInnerSequenceX->getArray(); + double* pArrayY = pInnerSequenceY->getArray(); + + for(sal_Int32 b(0L); b < nInnerSequenceCount; b++) + { + double fX = *pArrayX++; + double fY = *pArrayY++; + + if(bInit) + { + if(fX > fXMax) + fXMax = fX; + + if(fX < fXMin) + fXMin = fX; + + if(fY > fYMax) + fYMax = fY; + + if(fY < fYMin) + fYMin = fY; + } + else + { + fXMin = fXMax = fX; + fYMin = fYMax = fY; + bInit = sal_True; + } + } + + pInnerSequenceX++; + pInnerSequenceY++; + } + + // export ViewBox + awt::Point aMinPoint(FRound(fXMin), FRound(fYMin)); + awt::Size aMaxSize(FRound(fXMax) - aMinPoint.X, FRound(fYMax) - aMinPoint.Y); + SdXMLImExViewBox aViewBox( + aMinPoint.X, aMinPoint.Y, aMaxSize.Width, aMaxSize.Height); + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, + aViewBox.GetExportString()); + + // prepare svx:d element export + SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); + pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray(); + pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray(); + + for (a = 0; a < nOuterSequenceCount; a++) + { + sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength()); + double* pArrayX = pInnerSequenceX->getArray(); + double* pArrayY = pInnerSequenceY->getArray(); + drawing::PointSequence aPoly(nInnerSequenceCount); + awt::Point* pInnerSequence = aPoly.getArray(); + + for(sal_Int32 b(0L); b < nInnerSequenceCount; b++) + { + double fX = *pArrayX++; + double fY = *pArrayY++; + + *pInnerSequence = awt::Point(FRound(fX), FRound(fY)); + pInnerSequence++; + } + + // calculate closed flag + awt::Point* pFirst = aPoly.getArray(); + awt::Point* pLast = pFirst + (nInnerSequenceCount - 1); + sal_Bool bClosed = (pFirst->X == pLast->X && pFirst->Y == pLast->Y); + + aSvgDElement.AddPolygon(&aPoly, 0L, aMinPoint, + aMaxSize, bClosed); + + // #80594# corrected error in PolyPolygon3D export for 3D XML + pInnerSequenceX++; + pInnerSequenceY++; + } + + // write point array + mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); + + if(eShapeType == XmlShapeTypeDraw3DLatheObject) + { + // write 3DLathe shape + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_ROTATE, sal_True, sal_True); + } + else + { + // write 3DExtrude shape + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_EXTRUDE, sal_True, sal_True); + } + break; + } + default: + break; + } + } +} + +/** helper for chart that adds all attributes of a 3d scene element to the export */ +void XMLShapeExport::export3DSceneAttributes( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet ) +{ + OUString aStr; + OUStringBuffer sStringBuffer; + + // world transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix") + uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix"); + drawing::HomogenMatrix xHomMat; + aAny >>= xHomMat; + SdXMLImExTransform3D aTransform; + aTransform.AddHomogenMatrix(xHomMat); + if(aTransform.NeedsAction()) + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter())); + + // VRP, VPN, VUP + aAny = xPropSet->getPropertyValue("D3DCameraGeometry"); + drawing::CameraGeometry aCamGeo; + aAny >>= aCamGeo; + + ::basegfx::B3DVector aVRP(aCamGeo.vrp.PositionX, aCamGeo.vrp.PositionY, aCamGeo.vrp.PositionZ); + if(aVRP != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default + { + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVRP); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VRP, aStr); + } + + ::basegfx::B3DVector aVPN(aCamGeo.vpn.DirectionX, aCamGeo.vpn.DirectionY, aCamGeo.vpn.DirectionZ); + if(aVPN != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default + { + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVPN); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VPN, aStr); + } + + ::basegfx::B3DVector aVUP(aCamGeo.vup.DirectionX, aCamGeo.vup.DirectionY, aCamGeo.vup.DirectionZ); + if(aVUP != ::basegfx::B3DVector(0.0, 1.0, 0.0)) // write only when not default + { + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVUP); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VUP, aStr); + } + + // projection "D3DScenePerspective" drawing::ProjectionMode + aAny = xPropSet->getPropertyValue("D3DScenePerspective"); + drawing::ProjectionMode xPrjMode; + aAny >>= xPrjMode; + if(xPrjMode == drawing::ProjectionMode_PARALLEL) + aStr = GetXMLToken(XML_PARALLEL); + else + aStr = GetXMLToken(XML_PERSPECTIVE); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_PROJECTION, aStr); + + // distance + aAny = xPropSet->getPropertyValue("D3DSceneDistance"); + sal_Int32 nDistance = 0; + aAny >>= nDistance; + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + nDistance); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DISTANCE, aStr); + + // focalLength + aAny = xPropSet->getPropertyValue("D3DSceneFocalLength"); + sal_Int32 nFocalLength = 0; + aAny >>= nFocalLength; + mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, + nFocalLength); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_FOCAL_LENGTH, aStr); + + // shadowSlant + aAny = xPropSet->getPropertyValue("D3DSceneShadowSlant"); + sal_Int16 nShadowSlant = 0; + aAny >>= nShadowSlant; + ::sax::Converter::convertNumber(sStringBuffer, (sal_Int32)nShadowSlant); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADOW_SLANT, aStr); + + // shadeMode + aAny = xPropSet->getPropertyValue("D3DSceneShadeMode"); + drawing::ShadeMode xShadeMode; + if(aAny >>= xShadeMode) + { + if(xShadeMode == drawing::ShadeMode_FLAT) + aStr = GetXMLToken(XML_FLAT); + else if(xShadeMode == drawing::ShadeMode_PHONG) + aStr = GetXMLToken(XML_PHONG); + else if(xShadeMode == drawing::ShadeMode_SMOOTH) + aStr = GetXMLToken(XML_GOURAUD); + else + aStr = GetXMLToken(XML_DRAFT); + } + else + { + // ShadeMode enum not there, write default + aStr = GetXMLToken(XML_GOURAUD); + } + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr); + + // ambientColor + aAny = xPropSet->getPropertyValue("D3DSceneAmbientColor"); + sal_Int32 nAmbientColor = 0; + aAny >>= nAmbientColor; + ::sax::Converter::convertColor(sStringBuffer, nAmbientColor); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_AMBIENT_COLOR, aStr); + + // lightingMode + aAny = xPropSet->getPropertyValue("D3DSceneTwoSidedLighting"); + sal_Bool bTwoSidedLighting = false; + aAny >>= bTwoSidedLighting; + ::sax::Converter::convertBool(sStringBuffer, bTwoSidedLighting); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_LIGHTING_MODE, aStr); +} + +/** helper for chart that exports all lamps from the propertyset */ +void XMLShapeExport::export3DLamps( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet ) +{ + // write lamps 1..8 as content + OUString aStr; + OUStringBuffer sStringBuffer; + + const OUString aColorPropName("D3DSceneLightColor"); + const OUString aDirectionPropName("D3DSceneLightDirection"); + const OUString aLightOnPropName("D3DSceneLightOn"); + + OUString aPropName; + OUString aIndexStr; + ::basegfx::B3DVector aLightDirection; + drawing::Direction3D xLightDir; + sal_Bool bLightOnOff = false; + for(sal_Int32 nLamp = 1; nLamp <= 8; nLamp++) + { + aIndexStr = OUString::number( nLamp ); + + // lightcolor + aPropName = aColorPropName; + aPropName += aIndexStr; + sal_Int32 nLightColor = 0; + xPropSet->getPropertyValue( aPropName ) >>= nLightColor; + ::sax::Converter::convertColor(sStringBuffer, nLightColor); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIFFUSE_COLOR, aStr); + + // lightdirection + aPropName = aDirectionPropName; + aPropName += aIndexStr; + xPropSet->getPropertyValue(aPropName) >>= xLightDir; + aLightDirection = ::basegfx::B3DVector(xLightDir.DirectionX, xLightDir.DirectionY, xLightDir.DirectionZ); + mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aLightDirection); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIRECTION, aStr); + + // lighton + aPropName = aLightOnPropName; + aPropName += aIndexStr; + xPropSet->getPropertyValue(aPropName) >>= bLightOnOff; + ::sax::Converter::convertBool(sStringBuffer, bLightOnOff); + aStr = sStringBuffer.makeStringAndClear(); + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_ENABLED, aStr); + + // specular + mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SPECULAR, + nLamp == 1 ? XML_TRUE : XML_FALSE); + + // write light entry + SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_LIGHT, sal_True, sal_True); + } +} + + +// using namespace ::com::sun::star::io; +// using namespace ::xmloff::EnhancedCustomShapeToken; + + +void ExportParameter( OUStringBuffer& rStrBuffer, const com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter ) +{ + if ( !rStrBuffer.isEmpty() ) + rStrBuffer.append( (sal_Unicode)' ' ); + if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE ) + { + double fNumber = 0.0; + rParameter.Value >>= fNumber; + ::rtl::math::doubleToUStringBuffer( rStrBuffer, fNumber, rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max, '.', sal_True ); + } + else + { + sal_Int32 nValue = 0; + rParameter.Value >>= nValue; + + switch( rParameter.Type ) + { + case com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION : + { + rStrBuffer.append( "?f" + OUString::number( nValue ) ); + } + break; + + case com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT : + { + rStrBuffer.append( (sal_Unicode)'$' ); + rStrBuffer.append( OUString::number( nValue ) ); + } + break; + + case com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM : + rStrBuffer.append( GetXMLToken( XML_BOTTOM ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT : + rStrBuffer.append( GetXMLToken( XML_RIGHT ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP : + rStrBuffer.append( GetXMLToken( XML_TOP ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT : + rStrBuffer.append( GetXMLToken( XML_LEFT ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH : + rStrBuffer.append( GetXMLToken( XML_XSTRETCH ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH : + rStrBuffer.append( GetXMLToken( XML_YSTRETCH ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE : + rStrBuffer.append( GetXMLToken( XML_HASSTROKE ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL : + rStrBuffer.append( GetXMLToken( XML_HASFILL ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH : + rStrBuffer.append( GetXMLToken( XML_WIDTH ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT : + rStrBuffer.append( GetXMLToken( XML_HEIGHT ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH : + rStrBuffer.append( GetXMLToken( XML_LOGWIDTH ) ); break; + case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT : + rStrBuffer.append( GetXMLToken( XML_LOGHEIGHT ) ); break; + default : + rStrBuffer.append( OUString::number( nValue ) ); + } + } +} + +void ImpExportEquations( SvXMLExport& rExport, const uno::Sequence< OUString >& rEquations ) +{ + sal_Int32 i; + for ( i = 0; i < rEquations.getLength(); i++ ) + { + OUString aStr(static_cast('f')); + aStr += OUString::number( i ); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aStr ); + + aStr = rEquations[ i ]; + sal_Int32 nIndex = 0; + do + { + nIndex = aStr.indexOf( (sal_Unicode)'?', nIndex ); + if ( nIndex != -1 ) + { + OUString aNew( aStr.copy( 0, nIndex + 1 ) ); + aNew += OUString(static_cast('f')); + aNew += aStr.copy( nIndex + 1, ( aStr.getLength() - nIndex ) - 1 ); + aStr = aNew; + nIndex++; + } + } while( nIndex != -1 ); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FORMULA, aStr ); + SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_EQUATION, sal_True, sal_True ); + } +} + +void ImpExportHandles( SvXMLExport& rExport, const uno::Sequence< beans::PropertyValues >& rHandles ) +{ + sal_uInt32 i, j, nElements = rHandles.getLength(); + if ( nElements ) + { + OUString aStr; + OUStringBuffer aStrBuffer; + + for ( i = 0; i < nElements; i++ ) + { + sal_Bool bPosition = sal_False; + const uno::Sequence< beans::PropertyValue >& rPropSeq = rHandles[ i ]; + for ( j = 0; j < (sal_uInt32)rPropSeq.getLength(); j++ ) + { + const beans::PropertyValue& rPropVal = rPropSeq[ j ]; + switch( EASGet( rPropVal.Name ) ) + { + case EAS_Position : + { + com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition; + if ( rPropVal.Value >>= aPosition ) + { + ExportParameter( aStrBuffer, aPosition.First ); + ExportParameter( aStrBuffer, aPosition.Second ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POSITION, aStr ); + bPosition = sal_True; + } + } + break; + case EAS_MirroredX : + { + sal_Bool bMirroredX = sal_Bool(); + if ( rPropVal.Value >>= bMirroredX ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_HORIZONTAL, + bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_MirroredY : + { + sal_Bool bMirroredY = sal_Bool(); + if ( rPropVal.Value >>= bMirroredY ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_VERTICAL, + bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_Switched : + { + sal_Bool bSwitched = sal_Bool(); + if ( rPropVal.Value >>= bSwitched ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_SWITCHED, + bSwitched ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_Polar : + { + com::sun::star::drawing::EnhancedCustomShapeParameterPair aPolar; + if ( rPropVal.Value >>= aPolar ) + { + ExportParameter( aStrBuffer, aPolar.First ); + ExportParameter( aStrBuffer, aPolar.Second ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POLAR, aStr ); + } + } + break; + case EAS_RadiusRangeMinimum : + { + com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum; + if ( rPropVal.Value >>= aRadiusRangeMinimum ) + { + ExportParameter( aStrBuffer, aRadiusRangeMinimum ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MINIMUM, aStr ); + } + } + break; + case EAS_RadiusRangeMaximum : + { + com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum; + if ( rPropVal.Value >>= aRadiusRangeMaximum ) + { + ExportParameter( aStrBuffer, aRadiusRangeMaximum ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MAXIMUM, aStr ); + } + } + break; + case EAS_RangeXMinimum : + { + com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMinimum; + if ( rPropVal.Value >>= aXRangeMinimum ) + { + ExportParameter( aStrBuffer, aXRangeMinimum ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MINIMUM, aStr ); + } + } + break; + case EAS_RangeXMaximum : + { + com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMaximum; + if ( rPropVal.Value >>= aXRangeMaximum ) + { + ExportParameter( aStrBuffer, aXRangeMaximum ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MAXIMUM, aStr ); + } + } + break; + case EAS_RangeYMinimum : + { + com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMinimum; + if ( rPropVal.Value >>= aYRangeMinimum ) + { + ExportParameter( aStrBuffer, aYRangeMinimum ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MINIMUM, aStr ); + } + } + break; + case EAS_RangeYMaximum : + { + com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMaximum; + if ( rPropVal.Value >>= aYRangeMaximum ) + { + ExportParameter( aStrBuffer, aYRangeMaximum ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MAXIMUM, aStr ); + } + } + break; + default: + break; + } + } + if ( bPosition ) + SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_HANDLE, sal_True, sal_True ); + else + rExport.ClearAttrList(); + } + } +} + +void ImpExportEnhancedPath( SvXMLExport& rExport, + const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rCoordinates, + const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment >& rSegments, + bool bExtended = false ) +{ + + OUString aStr; + OUStringBuffer aStrBuffer; + bool bNeedExtended = false; + + sal_Int32 i, j, k, l; + + sal_Int32 nCoords = rCoordinates.getLength(); + sal_Int32 nSegments = rSegments.getLength(); + sal_Bool bSimpleSegments = nSegments == 0; + if ( bSimpleSegments ) + nSegments = 4; + for ( j = i = 0; j < nSegments; j++ ) + { + com::sun::star::drawing::EnhancedCustomShapeSegment aSegment; + if ( bSimpleSegments ) + { + // if there are not enough segments we will default them + switch( j ) + { + case 0 : + { + aSegment.Count = 1; + aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO; + } + break; + case 1 : + { + aSegment.Count = (sal_Int16)std::min( nCoords - 1, (sal_Int32)32767 ); + aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO; + } + break; + case 2 : + { + aSegment.Count = 1; + aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH; + } + break; + case 3 : + { + aSegment.Count = 1; + aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH; + } + break; + } + } + else + aSegment = rSegments[ j ]; + + if ( !aStrBuffer.isEmpty() ) + aStrBuffer.append( (sal_Unicode)' ' ); + + sal_Int32 nParameter = 0; + switch( aSegment.Command ) + { + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH : + aStrBuffer.append( (sal_Unicode)'Z' ); break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH : + aStrBuffer.append( (sal_Unicode)'N' ); break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL : + aStrBuffer.append( (sal_Unicode)'F' ); break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE : + aStrBuffer.append( (sal_Unicode)'S' ); break; + + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO : + aStrBuffer.append( (sal_Unicode)'M' ); nParameter = 1; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO : + aStrBuffer.append( (sal_Unicode)'L' ); nParameter = 1; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO : + aStrBuffer.append( (sal_Unicode)'C' ); nParameter = 3; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO : + aStrBuffer.append( (sal_Unicode)'T' ); nParameter = 3; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE : + aStrBuffer.append( (sal_Unicode)'U' ); nParameter = 3; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO : + aStrBuffer.append( (sal_Unicode)'A' ); nParameter = 4; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC : + aStrBuffer.append( (sal_Unicode)'B' ); nParameter = 4; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO : + aStrBuffer.append( (sal_Unicode)'W' ); nParameter = 4; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC : + aStrBuffer.append( (sal_Unicode)'V' ); nParameter = 4; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX : + aStrBuffer.append( (sal_Unicode)'X' ); nParameter = 1; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY : + aStrBuffer.append( (sal_Unicode)'Y' ); nParameter = 1; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO : + aStrBuffer.append( (sal_Unicode)'Q' ); nParameter = 2; break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO : + if ( bExtended ) { + aStrBuffer.append( (sal_Unicode)'G' ); + nParameter = 2; + } else { + aStrBuffer.setLength( aStrBuffer.getLength() - 1); + bNeedExtended = true; + i += 2; + } + break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKEN : + if ( bExtended ) + aStrBuffer.append( (sal_Unicode)'H' ); + else + bNeedExtended = true; + break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKENLESS : + if ( bExtended ) + aStrBuffer.append( (sal_Unicode)'I' ); + else + bNeedExtended = true; + break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTEN : + if ( bExtended ) + aStrBuffer.append( (sal_Unicode)'J' ); + else + bNeedExtended = true; + break; + case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTENLESS : + if ( bExtended ) + aStrBuffer.append( (sal_Unicode)'K' ); + else + bNeedExtended = true; + break; + default : // ups, seems to be something wrong + { + aSegment.Count = 1; + aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO; + } + break; + } + if ( nParameter ) + { + for ( k = 0; k < aSegment.Count; k++ ) + { + if ( ( i + nParameter ) <= nCoords ) + { + for ( l = 0; l < nParameter; l++ ) + { + ExportParameter( aStrBuffer, rCoordinates[ i ].First ); + ExportParameter( aStrBuffer, rCoordinates[ i++ ].Second ); + } + } + else + { + j = nSegments; // error -> exiting + break; + } + } + } + } + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( bExtended ? XML_NAMESPACE_DRAW_EXT : XML_NAMESPACE_DRAW, XML_ENHANCED_PATH, aStr ); + if ( !bExtended && bNeedExtended ) + ImpExportEnhancedPath( rExport, rCoordinates, rSegments, true ); +} + +void ImpExportEnhancedGeometry( SvXMLExport& rExport, const uno::Reference< beans::XPropertySet >& xPropSet ) +{ + sal_Bool bEquations = sal_False; + uno::Sequence< OUString > aEquations; + + sal_Bool bHandles = sal_False; + uno::Sequence< beans::PropertyValues > aHandles; + + sal_Bool bCoordinates = sal_False; + uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > aSegments; + uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aCoordinates; + + uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues; + + OUString aStr; + OUStringBuffer aStrBuffer; + SvXMLUnitConverter& rUnitConverter = rExport.GetMM100UnitConverter(); + + uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); + + // geometry + const OUString sCustomShapeGeometry( "CustomShapeGeometry" ); + if ( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sCustomShapeGeometry ) ) + { + uno::Any aGeoPropSet( xPropSet->getPropertyValue( sCustomShapeGeometry ) ); + uno::Sequence< beans::PropertyValue > aGeoPropSeq; + + if ( aGeoPropSet >>= aGeoPropSeq ) + { + const OUString sCustomShapeType( "non-primitive" ); + OUString aCustomShapeType( sCustomShapeType ); + + sal_Int32 j, nGeoPropCount = aGeoPropSeq.getLength(); + for ( j = 0; j < nGeoPropCount; j++ ) + { + const beans::PropertyValue& rGeoProp = aGeoPropSeq[ j ]; + switch( EASGet( rGeoProp.Name ) ) + { + case EAS_Type : + { + rGeoProp.Value >>= aCustomShapeType; + } + break; + case EAS_MirroredX : + { + sal_Bool bMirroredX = sal_Bool(); + if ( rGeoProp.Value >>= bMirroredX ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_HORIZONTAL, + bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_MirroredY : + { + sal_Bool bMirroredY = sal_Bool(); + if ( rGeoProp.Value >>= bMirroredY ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_VERTICAL, + bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_ViewBox : + { + awt::Rectangle aRect; + if ( rGeoProp.Value >>= aRect ) + { + SdXMLImExViewBox aViewBox( aRect.X, aRect.Y, aRect.Width, aRect.Height ); + rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() ); + } + } + break; + case EAS_TextRotateAngle : + { + double fTextRotateAngle = 0; + if ( rGeoProp.Value >>= fTextRotateAngle ) + { + ::sax::Converter::convertDouble( + aStrBuffer, fTextRotateAngle ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_ROTATE_ANGLE, aStr ); + } + } + break; + case EAS_Extrusion : + { + uno::Sequence< beans::PropertyValue > aExtrusionPropSeq; + if ( rGeoProp.Value >>= aExtrusionPropSeq ) + { + sal_Int32 i, nCount = aExtrusionPropSeq.getLength(); + for ( i = 0; i < nCount; i++ ) + { + const beans::PropertyValue& rProp = aExtrusionPropSeq[ i ]; + switch( EASGet( rProp.Name ) ) + { + case EAS_Extrusion : + { + sal_Bool bExtrusionOn = sal_Bool(); + if ( rProp.Value >>= bExtrusionOn ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION, + bExtrusionOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_Brightness : + { + double fExtrusionBrightness = 0; + if ( rProp.Value >>= fExtrusionBrightness ) + { + ::sax::Converter::convertDouble( + aStrBuffer, + fExtrusionBrightness, + false, + util::MeasureUnit::PERCENT, + util::MeasureUnit::PERCENT); + aStrBuffer.append( (sal_Unicode)'%' ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_BRIGHTNESS, aStr ); + } + } + break; + case EAS_Depth : + { + com::sun::star::drawing::EnhancedCustomShapeParameterPair aDepthParaPair; + if ( rProp.Value >>= aDepthParaPair ) + { + double fDepth = 0; + if ( aDepthParaPair.First.Value >>= fDepth ) + { + rExport.GetMM100UnitConverter().convertDouble( aStrBuffer, fDepth, sal_True ); + ExportParameter( aStrBuffer, aDepthParaPair.Second ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DEPTH, aStr ); + } + } + } + break; + case EAS_Diffusion : + { + double fExtrusionDiffusion = 0; + if ( rProp.Value >>= fExtrusionDiffusion ) + { + ::sax::Converter::convertDouble( + aStrBuffer, + fExtrusionDiffusion, + false, + util::MeasureUnit::PERCENT, + util::MeasureUnit::PERCENT); + aStrBuffer.append( (sal_Unicode)'%' ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DIFFUSION, aStr ); + } + } + break; + case EAS_NumberOfLineSegments : + { + sal_Int32 nExtrusionNumberOfLineSegments = 0; + if ( rProp.Value >>= nExtrusionNumberOfLineSegments ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_NUMBER_OF_LINE_SEGMENTS, OUString::number( nExtrusionNumberOfLineSegments ) ); + } + break; + case EAS_LightFace : + { + sal_Bool bExtrusionLightFace = sal_Bool(); + if ( rProp.Value >>= bExtrusionLightFace ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_LIGHT_FACE, + bExtrusionLightFace ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_FirstLightHarsh : + { + sal_Bool bExtrusionFirstLightHarsh = sal_Bool(); + if ( rProp.Value >>= bExtrusionFirstLightHarsh ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_HARSH, + bExtrusionFirstLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_SecondLightHarsh : + { + sal_Bool bExtrusionSecondLightHarsh = sal_Bool(); + if ( rProp.Value >>= bExtrusionSecondLightHarsh ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_HARSH, + bExtrusionSecondLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_FirstLightLevel : + { + double fExtrusionFirstLightLevel = 0; + if ( rProp.Value >>= fExtrusionFirstLightLevel ) + { + ::sax::Converter::convertDouble( + aStrBuffer, + fExtrusionFirstLightLevel, + false, + util::MeasureUnit::PERCENT, + util::MeasureUnit::PERCENT); + aStrBuffer.append( (sal_Unicode)'%' ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_LEVEL, aStr ); + } + } + break; + case EAS_SecondLightLevel : + { + double fExtrusionSecondLightLevel = 0; + if ( rProp.Value >>= fExtrusionSecondLightLevel ) + { + ::sax::Converter::convertDouble( + aStrBuffer, + fExtrusionSecondLightLevel, + false, + util::MeasureUnit::PERCENT, + util::MeasureUnit::PERCENT); + aStrBuffer.append( (sal_Unicode)'%' ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_LEVEL, aStr ); + } + } + break; + case EAS_FirstLightDirection : + { + drawing::Direction3D aExtrusionFirstLightDirection; + if ( rProp.Value >>= aExtrusionFirstLightDirection ) + { + ::basegfx::B3DVector aVec3D( aExtrusionFirstLightDirection.DirectionX, aExtrusionFirstLightDirection.DirectionY, + aExtrusionFirstLightDirection.DirectionZ ); + rUnitConverter.convertB3DVector( aStrBuffer, aVec3D ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_DIRECTION, aStr ); + } + } + break; + case EAS_SecondLightDirection : + { + drawing::Direction3D aExtrusionSecondLightDirection; + if ( rProp.Value >>= aExtrusionSecondLightDirection ) + { + ::basegfx::B3DVector aVec3D( aExtrusionSecondLightDirection.DirectionX, aExtrusionSecondLightDirection.DirectionY, + aExtrusionSecondLightDirection.DirectionZ ); + rUnitConverter.convertB3DVector( aStrBuffer, aVec3D ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_DIRECTION, aStr ); + } + } + break; + case EAS_Metal : + { + sal_Bool bExtrusionMetal = sal_Bool(); + if ( rProp.Value >>= bExtrusionMetal ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_METAL, + bExtrusionMetal ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_ShadeMode : + { + // shadeMode + drawing::ShadeMode eShadeMode; + if( rProp.Value >>= eShadeMode ) + { + if( eShadeMode == drawing::ShadeMode_FLAT ) + aStr = GetXMLToken( XML_FLAT ); + else if( eShadeMode == drawing::ShadeMode_PHONG ) + aStr = GetXMLToken( XML_PHONG ); + else if( eShadeMode == drawing::ShadeMode_SMOOTH ) + aStr = GetXMLToken( XML_GOURAUD ); + else + aStr = GetXMLToken( XML_DRAFT ); + } + else + { + // ShadeMode enum not there, write default + aStr = GetXMLToken( XML_FLAT); + } + rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr ); + } + break; + case EAS_RotateAngle : + { + com::sun::star::drawing::EnhancedCustomShapeParameterPair aRotateAngleParaPair; + if ( rProp.Value >>= aRotateAngleParaPair ) + { + ExportParameter( aStrBuffer, aRotateAngleParaPair.First ); + ExportParameter( aStrBuffer, aRotateAngleParaPair.Second ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_ANGLE, aStr ); + } + } + break; + case EAS_RotationCenter : + { + drawing::Direction3D aExtrusionRotationCenter; + if ( rProp.Value >>= aExtrusionRotationCenter ) + { + ::basegfx::B3DVector aVec3D( aExtrusionRotationCenter.DirectionX, aExtrusionRotationCenter.DirectionY, + aExtrusionRotationCenter.DirectionZ ); + rUnitConverter.convertB3DVector( aStrBuffer, aVec3D ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_CENTER, aStr ); + } + } + break; + case EAS_Shininess : + { + double fExtrusionShininess = 0; + if ( rProp.Value >>= fExtrusionShininess ) + { + ::sax::Converter::convertDouble( + aStrBuffer, + fExtrusionShininess, + false, + util::MeasureUnit::PERCENT, + util::MeasureUnit::PERCENT); + aStrBuffer.append( (sal_Unicode)'%' ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SHININESS, aStr ); + } + } + break; + case EAS_Skew : + { + com::sun::star::drawing::EnhancedCustomShapeParameterPair aSkewParaPair; + if ( rProp.Value >>= aSkewParaPair ) + { + ExportParameter( aStrBuffer, aSkewParaPair.First ); + ExportParameter( aStrBuffer, aSkewParaPair.Second ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SKEW, aStr ); + } + } + break; + case EAS_Specularity : + { + double fExtrusionSpecularity = 0; + if ( rProp.Value >>= fExtrusionSpecularity ) + { + ::sax::Converter::convertDouble( + aStrBuffer, + fExtrusionSpecularity, + false, + util::MeasureUnit::PERCENT, + util::MeasureUnit::PERCENT); + aStrBuffer.append( (sal_Unicode)'%' ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SPECULARITY, aStr ); + } + } + break; + case EAS_ProjectionMode : + { + drawing::ProjectionMode eProjectionMode; + if ( rProp.Value >>= eProjectionMode ) + rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_PROJECTION, + eProjectionMode == drawing::ProjectionMode_PARALLEL ? GetXMLToken( XML_PARALLEL ) : GetXMLToken( XML_PERSPECTIVE ) ); + } + break; + case EAS_ViewPoint : + { + drawing::Position3D aExtrusionViewPoint; + if ( rProp.Value >>= aExtrusionViewPoint ) + { + rUnitConverter.convertPosition3D( aStrBuffer, aExtrusionViewPoint ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_VIEWPOINT, aStr ); + } + } + break; + case EAS_Origin : + { + com::sun::star::drawing::EnhancedCustomShapeParameterPair aOriginParaPair; + if ( rProp.Value >>= aOriginParaPair ) + { + ExportParameter( aStrBuffer, aOriginParaPair.First ); + ExportParameter( aStrBuffer, aOriginParaPair.Second ); + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ORIGIN, aStr ); + } + } + break; + case EAS_Color : + { + sal_Bool bExtrusionColor = sal_Bool(); + if ( rProp.Value >>= bExtrusionColor ) + { + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_COLOR, + bExtrusionColor ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + } + break; + default: + break; + } + } + } + } + break; + case EAS_TextPath : + { + uno::Sequence< beans::PropertyValue > aTextPathPropSeq; + if ( rGeoProp.Value >>= aTextPathPropSeq ) + { + sal_Int32 i, nCount = aTextPathPropSeq.getLength(); + for ( i = 0; i < nCount; i++ ) + { + const beans::PropertyValue& rProp = aTextPathPropSeq[ i ]; + switch( EASGet( rProp.Name ) ) + { + case EAS_TextPath : + { + sal_Bool bTextPathOn = sal_Bool(); + if ( rProp.Value >>= bTextPathOn ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH, + bTextPathOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_TextPathMode : + { + com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode; + if ( rProp.Value >>= eTextPathMode ) + { + switch ( eTextPathMode ) + { + case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL: aStr = GetXMLToken( XML_NORMAL ); break; + case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH : aStr = GetXMLToken( XML_PATH ); break; + case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE : aStr = GetXMLToken( XML_SHAPE ); break; + default: + break; + } + if ( !aStr.isEmpty() ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_MODE, aStr ); + } + } + break; + case EAS_ScaleX : + { + sal_Bool bScaleX = sal_Bool(); + if ( rProp.Value >>= bScaleX ) + { + aStr = bScaleX ? GetXMLToken( XML_SHAPE ) : GetXMLToken( XML_PATH ); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SCALE, aStr ); + } + } + break; + case EAS_SameLetterHeights : + { + sal_Bool bSameLetterHeights = sal_Bool(); + if ( rProp.Value >>= bSameLetterHeights ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SAME_LETTER_HEIGHTS, + bSameLetterHeights ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + default: + break; + } + } + } + } + break; + case EAS_Path : + { + uno::Sequence< beans::PropertyValue > aPathPropSeq; + if ( rGeoProp.Value >>= aPathPropSeq ) + { + sal_Int32 i, nCount = aPathPropSeq.getLength(); + for ( i = 0; i < nCount; i++ ) + { + const beans::PropertyValue& rProp = aPathPropSeq[ i ]; + + switch( EASGet( rProp.Name ) ) + { + case EAS_SubViewSize: + { + uno::Sequence< awt::Size > aSubViewSizes; + rProp.Value >>= aSubViewSizes; + + for ( int nIdx = 0; nIdx < aSubViewSizes.getLength(); nIdx++ ) + { + if ( nIdx ) + aStrBuffer.append(' '); + ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Width ); + aStrBuffer.append(' '); + ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Height ); + } + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW_EXT, XML_SUB_VIEW_SIZE, aStr ); + } + break; + case EAS_ExtrusionAllowed : + { + sal_Bool bExtrusionAllowed = sal_Bool(); + if ( rProp.Value >>= bExtrusionAllowed ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ALLOWED, + bExtrusionAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_ConcentricGradientFillAllowed : + { + sal_Bool bConcentricGradientFillAllowed = sal_Bool(); + if ( rProp.Value >>= bConcentricGradientFillAllowed ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONCENTRIC_GRADIENT_FILL_ALLOWED, + bConcentricGradientFillAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_TextPathAllowed : + { + sal_Bool bTextPathAllowed = sal_Bool(); + if ( rProp.Value >>= bTextPathAllowed ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_ALLOWED, + bTextPathAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); + } + break; + case EAS_GluePoints : + { + com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> aGluePoints; + if ( rProp.Value >>= aGluePoints ) + { + sal_Int32 k, nElements = aGluePoints.getLength(); + if ( nElements ) + { + for( k = 0; k < nElements; k++ ) + { + ExportParameter( aStrBuffer, aGluePoints[ k ].First ); + ExportParameter( aStrBuffer, aGluePoints[ k ].Second ); + } + aStr = aStrBuffer.makeStringAndClear(); + } + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINTS, aStr ); + } + } + break; + case EAS_GluePointType : + { + sal_Int16 nGluePointType = sal_Int16(); + if ( rProp.Value >>= nGluePointType ) + { + switch ( nGluePointType ) + { + case com::sun::star::drawing::EnhancedCustomShapeGluePointType::NONE : aStr = GetXMLToken( XML_NONE ); break; + case com::sun::star::drawing::EnhancedCustomShapeGluePointType::SEGMENTS : aStr = GetXMLToken( XML_SEGMENTS ); break; + case com::sun::star::drawing::EnhancedCustomShapeGluePointType::RECT : aStr = GetXMLToken( XML_RECTANGLE ); break; + } + if ( !aStr.isEmpty() ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINT_TYPE, aStr ); + } + } + break; + case EAS_Coordinates : + { + bCoordinates = ( rProp.Value >>= aCoordinates ); + } + break; + case EAS_Segments : + { + rProp.Value >>= aSegments; + } + break; + case EAS_StretchX : + { + sal_Int32 nStretchPoint = 0; + if ( rProp.Value >>= nStretchPoint ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_X, OUString::number( nStretchPoint ) ); + } + break; + case EAS_StretchY : + { + sal_Int32 nStretchPoint = 0; + if ( rProp.Value >>= nStretchPoint ) + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_Y, OUString::number( nStretchPoint ) ); + } + break; + case EAS_TextFrames : + { + com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aPathTextFrames; + if ( rProp.Value >>= aPathTextFrames ) + { + if ( (sal_uInt16)aPathTextFrames.getLength() ) + { + sal_uInt16 k, nElements = (sal_uInt16)aPathTextFrames.getLength(); + for ( k = 0; k < nElements; k++ ) + { + ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.First ); + ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.Second ); + ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.First ); + ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.Second ); + } + aStr = aStrBuffer.makeStringAndClear(); + } + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_AREAS, aStr ); + } + } + break; + default: + break; + } + } + } + } + break; + case EAS_Equations : + { + bEquations = ( rGeoProp.Value >>= aEquations ); + } + break; + case EAS_Handles : + { + bHandles = ( rGeoProp.Value >>= aHandles ); + } + break; + case EAS_AdjustmentValues : + { + rGeoProp.Value >>= aAdjustmentValues; + } + break; + default: + break; + } + } // for + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TYPE, aCustomShapeType ); + + // adjustments + sal_Int32 nAdjustmentValues = aAdjustmentValues.getLength(); + if ( nAdjustmentValues ) + { + sal_Int32 i, nValue = 0; + for ( i = 0; i < nAdjustmentValues; i++ ) + { + if ( i ) + aStrBuffer.append( (sal_Unicode)' ' ); + + const com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue& rAdj = aAdjustmentValues[ i ]; + if ( rAdj.State == beans::PropertyState_DIRECT_VALUE ) + { + if ( rAdj.Value.getValueTypeClass() == uno::TypeClass_DOUBLE ) + { + double fValue = 0.0; + rAdj.Value >>= fValue; + ::sax::Converter::convertDouble(aStrBuffer, fValue); + } + else + { + rAdj.Value >>= nValue; + ::sax::Converter::convertNumber(aStrBuffer, nValue); + } + } + else + { + // this should not be, but better than setting nothing + ::sax::Converter::convertNumber( aStrBuffer, 0 ); + } + } + aStr = aStrBuffer.makeStringAndClear(); + rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MODIFIERS, aStr ); + } + if ( bCoordinates ) + ImpExportEnhancedPath( rExport, aCoordinates, aSegments ); + } + } + SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_ENHANCED_GEOMETRY, sal_True, sal_True ); + if ( bEquations ) + ImpExportEquations( rExport, aEquations ); + if ( bHandles ) + ImpExportHandles( rExport, aHandles ); +} + +void XMLShapeExport::ImpExportCustomShape( + const uno::Reference< drawing::XShape >& xShape, + XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint ) +{ + const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + if ( xPropSet.is() ) + { + OUString aStr; + uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); + + // Transformation + ImpExportNewTrans( xPropSet, nFeatures, pRefPoint ); + + if ( xPropSetInfo.is() ) + { + const OUString sCustomShapeEngine( "CustomShapeEngine" ); + if ( xPropSetInfo->hasPropertyByName( sCustomShapeEngine ) ) + { + uno::Any aEngine( xPropSet->getPropertyValue( sCustomShapeEngine ) ); + if ( ( aEngine >>= aStr ) && !aStr.isEmpty() ) + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ENGINE, aStr ); + } + const OUString sCustomShapeData( "CustomShapeData" ); + if ( xPropSetInfo->hasPropertyByName( sCustomShapeData ) ) + { + uno::Any aData( xPropSet->getPropertyValue( sCustomShapeData ) ); + if ( ( aData >>= aStr ) && !aStr.isEmpty() ) + mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DATA, aStr ); + } + } + sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# + SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, bCreateNewline, sal_True ); + ImpExportDescription( xShape ); // #i68101# + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportText( xShape ); + ImpExportEnhancedGeometry( mrExport, xPropSet ); + } +} + +void XMLShapeExport::ImpExportTableShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint ) +{ + uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); + uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY); + + DBG_ASSERT( xPropSet.is() && xNamed.is(), "xmloff::XMLShapeExport::ImpExportTableShape(), tabe shape is not implementing needed interfaces"); + if(xPropSet.is() && xNamed.is()) try + { + // Transformation + ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); + + sal_Bool bIsEmptyPresObj = sal_False; + + // presentation settings + if(eShapeType == XmlShapeTypePresTableShape) + bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) ); + + const bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); + const bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED)); + + SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, XML_FRAME, bCreateNewline, sal_True ); + + // do not export in ODF 1.1 or older + if( mrExport.getDefaultVersion() >= SvtSaveOptions::ODFVER_012 ) + { + if( !bIsEmptyPresObj ) + { + uno::Reference< container::XNamed > xTemplate( xPropSet->getPropertyValue("TableTemplate"), uno::UNO_QUERY ); + if( xTemplate.is() ) + { + const OUString sTemplate( xTemplate->getName() ); + if( !sTemplate.isEmpty() ) + { + mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TEMPLATE_NAME, sTemplate ); + + for( const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; pEntry->msApiName; pEntry++ ) + { + try + { + sal_Bool bBool = sal_False; + const OUString sAPIPropertyName( OUString(pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US ) ); + + xPropSet->getPropertyValue( sAPIPropertyName ) >>= bBool; + if( bBool ) + mrExport.AddAttribute(pEntry->mnNameSpace, pEntry->meXMLName, XML_TRUE ); + } + catch( uno::Exception& ) + { + OSL_FAIL("XMLShapeExport::ImpExportTableShape(), exception caught!"); + } + } + } + } + + uno::Reference< table::XColumnRowRange > xRange( xPropSet->getPropertyValue( msModel ), uno::UNO_QUERY_THROW ); + GetShapeTableExport()->exportTable( xRange ); + } + } + + if( !bIsEmptyPresObj ) + { + uno::Reference< graphic::XGraphic > xGraphic( xPropSet->getPropertyValue("ReplacementGraphic"), uno::UNO_QUERY ); + if( xGraphic.is() ) try + { + uno::Reference< uno::XComponentContext > xContext = GetExport().getComponentContext(); + + uno::Reference< embed::XStorage > xPictureStorage; + uno::Reference< embed::XStorage > xStorage; + uno::Reference< io::XStream > xPictureStream; + + OUString sPictureName; + if( bExportEmbedded ) + { + xPictureStream.set( xContext->getServiceManager()->createInstanceWithContext( "com.sun.star.comp.MemoryStream", xContext), uno::UNO_QUERY_THROW ); + } + else + { + xStorage.set( GetExport().GetTargetStorage(), uno::UNO_QUERY_THROW ); + + xPictureStorage.set( xStorage->openStorageElement( OUString( "Pictures" ), ::embed::ElementModes::READWRITE ), uno::UNO_QUERY_THROW ); + const OUString sPrefix( "TablePreview" ); + const OUString sSuffix( ".svm" ); + + sal_Int32 nIndex = 0; + do + { + sPictureName = sPrefix; + sPictureName += OUString::number( ++nIndex ); + sPictureName += sSuffix; + } + while( xPictureStorage->hasByName( sPictureName ) ); + + xPictureStream.set( xPictureStorage->openStreamElement( sPictureName, ::embed::ElementModes::READWRITE ), uno::UNO_QUERY_THROW ); + } + + uno::Reference< graphic::XGraphicProvider > xProvider( graphic::GraphicProvider::create(xContext) ); + uno::Sequence< beans::PropertyValue > aArgs( 2 ); + aArgs[ 0 ].Name = OUString( "MimeType" ); + aArgs[ 0 ].Value <<= OUString( "image/x-vclgraphic" ); + aArgs[ 1 ].Name = OUString( "OutputStream" ); + aArgs[ 1 ].Value <<= xPictureStream->getOutputStream(); + xProvider->storeGraphic( xGraphic, aArgs ); + + if( xPictureStorage.is() ) + { + uno::Reference< embed::XTransactedObject > xTrans( xPictureStorage, uno::UNO_QUERY ); + if( xTrans.is() ) + xTrans->commit(); + } + + if( !bExportEmbedded ) + { + OUString sURL( "Pictures/" ); + sURL += sPictureName; + mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); + mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); + } + + SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, sal_False, sal_True ); + + if( bExportEmbedded ) + { + uno::Reference< io::XSeekableInputStream > xSeekable( xPictureStream, uno::UNO_QUERY_THROW ); + xSeekable->seek(0); + + XMLBase64Export aBase64Exp( GetExport() ); + aBase64Exp.exportOfficeBinaryDataElement( uno::Reference < io::XInputStream >( xPictureStream, uno::UNO_QUERY_THROW ) ); + } + } + catch( uno::Exception& ) + { + OSL_FAIL("xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!"); + } + } + + ImpExportEvents( xShape ); + ImpExportGluePoints( xShape ); + ImpExportDescription( xShape ); // #i68101# + } + catch( uno::Exception& ) + { + OSL_FAIL( "xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!" ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/xmloff/source/draw/shapeexport2.cxx b/xmloff/source/draw/shapeexport2.cxx deleted file mode 100644 index 781bdab3bcba..000000000000 --- a/xmloff/source/draw/shapeexport2.cxx +++ /dev/null @@ -1,2095 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include - -#include "anim.hxx" - -#include -#include "sdpropls.hxx" -#include -#include -#include -#include -#include -#include "XMLImageMapExport.hxx" -#include "xexptran.hxx" -#include -#include - -#include "xmloff/xmlnmspe.hxx" -#include -#include - -using namespace ::com::sun::star; -using namespace ::xmloff::token; - -void XMLShapeExport::ImpExportNewTrans(const uno::Reference< beans::XPropertySet >& xPropSet, - sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - // get matrix - ::basegfx::B2DHomMatrix aMatrix; - ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet); - - // decompose and correct abour pRefPoint - ::basegfx::B2DTuple aTRScale; - double fTRShear(0.0); - double fTRRotate(0.0); - ::basegfx::B2DTuple aTRTranslate; - ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint); - - // use features and write - ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures); -} - -void XMLShapeExport::ImpExportNewTrans_GetB2DHomMatrix(::basegfx::B2DHomMatrix& rMatrix, - const uno::Reference< beans::XPropertySet >& xPropSet) -{ - /* Get , if it exist - and if the document is exported into the OpenOffice.org file format. - This property only exists at service com::sun::star::text::Shape - the - Writer UNO service for shapes. - This code is needed, because the positioning attributes in the - OpenOffice.org file format are given in horizontal left-to-right layout - regardless the layout direction the shape is in. In the OASIS Open Office - file format the positioning attributes are correctly given in the layout - direction the shape is in. Thus, this code provides the conversion from - the OASIS Open Office file format to the OpenOffice.org file format. (#i28749#) - */ - uno::Any aAny; - if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 && - xPropSet->getPropertySetInfo()->hasPropertyByName( - OUString("TransformationInHoriL2R")) ) - { - aAny = xPropSet->getPropertyValue("TransformationInHoriL2R"); - } - else - { - aAny = xPropSet->getPropertyValue("Transformation"); - } - drawing::HomogenMatrix3 aMatrix; - aAny >>= aMatrix; - - rMatrix.set(0, 0, aMatrix.Line1.Column1); - rMatrix.set(0, 1, aMatrix.Line1.Column2); - rMatrix.set(0, 2, aMatrix.Line1.Column3); - rMatrix.set(1, 0, aMatrix.Line2.Column1); - rMatrix.set(1, 1, aMatrix.Line2.Column2); - rMatrix.set(1, 2, aMatrix.Line2.Column3); - rMatrix.set(2, 0, aMatrix.Line3.Column1); - rMatrix.set(2, 1, aMatrix.Line3.Column2); - rMatrix.set(2, 2, aMatrix.Line3.Column3); -} - -void XMLShapeExport::ImpExportNewTrans_DecomposeAndRefPoint(const ::basegfx::B2DHomMatrix& rMatrix, ::basegfx::B2DTuple& rTRScale, - double& fTRShear, double& fTRRotate, ::basegfx::B2DTuple& rTRTranslate, com::sun::star::awt::Point* pRefPoint) -{ - // decompose matrix - rMatrix.decompose(rTRScale, rTRTranslate, fTRRotate, fTRShear); - - // correct translation about pRefPoint - if(pRefPoint) - { - rTRTranslate -= ::basegfx::B2DTuple(pRefPoint->X, pRefPoint->Y); - } -} - -void XMLShapeExport::ImpExportNewTrans_FeaturesAndWrite(::basegfx::B2DTuple& rTRScale, double fTRShear, - double fTRRotate, ::basegfx::B2DTuple& rTRTranslate, const sal_Int32 nFeatures) -{ - // always write Size (rTRScale) since this statement carries the union - // of the object - OUString aStr; - OUStringBuffer sStringBuffer; - ::basegfx::B2DTuple aTRScale(rTRScale); - - // svg: width - if(!(nFeatures & SEF_EXPORT_WIDTH)) - { - aTRScale.setX(1.0); - } - else - { - if( aTRScale.getX() > 0.0 ) - aTRScale.setX(aTRScale.getX() - 1.0); - else if( aTRScale.getX() < 0.0 ) - aTRScale.setX(aTRScale.getX() + 1.0); - } - - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - FRound(aTRScale.getX())); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_WIDTH, aStr); - - // svg: height - if(!(nFeatures & SEF_EXPORT_HEIGHT)) - { - aTRScale.setY(1.0); - } - else - { - if( aTRScale.getY() > 0.0 ) - aTRScale.setY(aTRScale.getY() - 1.0); - else if( aTRScale.getY() < 0.0 ) - aTRScale.setY(aTRScale.getY() + 1.0); - } - - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - FRound(aTRScale.getY())); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_HEIGHT, aStr); - - // decide if transformation is necessary - sal_Bool bTransformationIsNeccessary(fTRShear != 0.0 || fTRRotate != 0.0); - - if(bTransformationIsNeccessary) - { - // write transformation, but WITHOUT scale which is exported as size above - SdXMLImExTransform2D aTransform; - - aTransform.AddSkewX(atan(fTRShear)); - - // #i78696# - // fTRRotate is mathematically correct, but due to the error - // we export/import it mirrored. Since the API implementation is fixed and - // uses the correctly oriented angle, it is necessary for compatibility to - // mirror the angle here to stay at the old behaviour. There is a follow-up - // task (#i78698#) to fix this in the next ODF FileFormat version - aTransform.AddRotate(-fTRRotate); - - aTransform.AddTranslate(rTRTranslate); - - // does transformation need to be exported? - if(aTransform.NeedsAction()) - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter())); - } - else - { - // no shear, no rotate; just add object position to export and we are done - if(nFeatures & SEF_EXPORT_X) - { - // svg: x - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - FRound(rTRTranslate.getX())); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X, aStr); - } - - if(nFeatures & SEF_EXPORT_Y) - { - // svg: y - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - FRound(rTRTranslate.getY())); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y, aStr); - } - } -} - -sal_Bool XMLShapeExport::ImpExportPresentationAttributes( const uno::Reference< beans::XPropertySet >& xPropSet, const OUString& rClass ) -{ - sal_Bool bIsEmpty = sal_False; - - // write presentation class entry - mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, rClass); - - if( xPropSet.is() ) - { - uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); - - sal_Bool bTemp = false; - - // is empty pes shape? - if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsEmptyPresentationObject")) - { - xPropSet->getPropertyValue("IsEmptyPresentationObject") >>= bIsEmpty; - if( bIsEmpty ) - mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_PLACEHOLDER, XML_TRUE); - } - - // is user-transformed? - if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName("IsPlaceholderDependent")) - { - xPropSet->getPropertyValue("IsPlaceholderDependent") >>= bTemp; - if(!bTemp) - mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_USER_TRANSFORMED, XML_TRUE); - } - } - - return bIsEmpty; -} - -void XMLShapeExport::ImpExportText( const uno::Reference< drawing::XShape >& xShape ) -{ - uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY ); - if( xText.is() ) - { - uno::Reference< container::XEnumerationAccess > xEnumAccess( xShape, uno::UNO_QUERY ); - if( xEnumAccess.is() && xEnumAccess->hasElements() ) - mrExport.GetTextParagraphExport()->exportText( xText ); - } -} - -#include -#include - -namespace { - -const sal_Int32 FOUND_CLICKACTION = 0x00000001; -const sal_Int32 FOUND_BOOKMARK = 0x00000002; -const sal_Int32 FOUND_EFFECT = 0x00000004; -const sal_Int32 FOUND_PLAYFULL = 0x00000008; -const sal_Int32 FOUND_VERB = 0x00000010; -const sal_Int32 FOUND_SOUNDURL = 0x00000020; -const sal_Int32 FOUND_SPEED = 0x00000040; -const sal_Int32 FOUND_CLICKEVENTTYPE = 0x00000080; -const sal_Int32 FOUND_MACRO = 0x00000100; -const sal_Int32 FOUND_LIBRARY = 0x00000200; - -} // namespace - -void XMLShapeExport::ImpExportEvents( const uno::Reference< drawing::XShape >& xShape ) -{ - uno::Reference< document::XEventsSupplier > xEventsSupplier( xShape, uno::UNO_QUERY ); - if( !xEventsSupplier.is() ) - return; - - uno::Reference< container::XNameAccess > xEvents( xEventsSupplier->getEvents(), uno::UNO_QUERY ); - DBG_ASSERT( xEvents.is(), "XEventsSupplier::getEvents() returned NULL" ); - if( !xEvents.is() ) - return; - - sal_Int32 nFound = 0; - - OUString aClickEventType; - presentation::ClickAction eClickAction = presentation::ClickAction_NONE; - presentation::AnimationEffect eEffect = presentation::AnimationEffect_NONE; - presentation::AnimationSpeed eSpeed = presentation::AnimationSpeed_SLOW; - OUString aStrSoundURL; - sal_Bool bPlayFull = false; - sal_Int32 nVerb = 0; - OUString aStrMacro; - OUString aStrLibrary; - OUString aStrBookmark; - - uno::Sequence< beans::PropertyValue > aClickProperties; - if( xEvents->hasByName( msOnClick ) && (xEvents->getByName( msOnClick ) >>= aClickProperties) ) - { - const beans::PropertyValue* pProperty = aClickProperties.getConstArray(); - const beans::PropertyValue* pPropertyEnd = pProperty + aClickProperties.getLength(); - for( ; pProperty != pPropertyEnd; ++pProperty ) - { - if( ( ( nFound & FOUND_CLICKEVENTTYPE ) == 0 ) && pProperty->Name == msEventType ) - { - if( pProperty->Value >>= aClickEventType ) - nFound |= FOUND_CLICKEVENTTYPE; - } - else if( ( ( nFound & FOUND_CLICKACTION ) == 0 ) && pProperty->Name == msClickAction ) - { - if( pProperty->Value >>= eClickAction ) - nFound |= FOUND_CLICKACTION; - } - else if( ( ( nFound & FOUND_MACRO ) == 0 ) && ( pProperty->Name == msMacroName || pProperty->Name == msScript ) ) - { - if( pProperty->Value >>= aStrMacro ) - nFound |= FOUND_MACRO; - } - else if( ( ( nFound & FOUND_LIBRARY ) == 0 ) && pProperty->Name == msLibrary ) - { - if( pProperty->Value >>= aStrLibrary ) - nFound |= FOUND_LIBRARY; - } - else if( ( ( nFound & FOUND_EFFECT ) == 0 ) && pProperty->Name == msEffect ) - { - if( pProperty->Value >>= eEffect ) - nFound |= FOUND_EFFECT; - } - else if( ( ( nFound & FOUND_BOOKMARK ) == 0 ) && pProperty->Name == msBookmark ) - { - if( pProperty->Value >>= aStrBookmark ) - nFound |= FOUND_BOOKMARK; - } - else if( ( ( nFound & FOUND_SPEED ) == 0 ) && pProperty->Name == msSpeed ) - { - if( pProperty->Value >>= eSpeed ) - nFound |= FOUND_SPEED; - } - else if( ( ( nFound & FOUND_SOUNDURL ) == 0 ) && pProperty->Name == msSoundURL ) - { - if( pProperty->Value >>= aStrSoundURL ) - nFound |= FOUND_SOUNDURL; - } - else if( ( ( nFound & FOUND_PLAYFULL ) == 0 ) && pProperty->Name == msPlayFull ) - { - if( pProperty->Value >>= bPlayFull ) - nFound |= FOUND_PLAYFULL; - } - else if( ( ( nFound & FOUND_VERB ) == 0 ) && pProperty->Name == msVerb ) - { - if( pProperty->Value >>= nVerb ) - nFound |= FOUND_VERB; - } - } - } - - // create the XML elements - - if( aClickEventType == msPresentation ) - { - if( ((nFound & FOUND_CLICKACTION) == 0) || (eClickAction == presentation::ClickAction_NONE) ) - return; - - SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True); - - enum XMLTokenEnum eStrAction; - - switch( eClickAction ) - { - case presentation::ClickAction_PREVPAGE: eStrAction = XML_PREVIOUS_PAGE; break; - case presentation::ClickAction_NEXTPAGE: eStrAction = XML_NEXT_PAGE; break; - case presentation::ClickAction_FIRSTPAGE: eStrAction = XML_FIRST_PAGE; break; - case presentation::ClickAction_LASTPAGE: eStrAction = XML_LAST_PAGE; break; - case presentation::ClickAction_INVISIBLE: eStrAction = XML_HIDE; break; - case presentation::ClickAction_STOPPRESENTATION:eStrAction = XML_STOP; break; - case presentation::ClickAction_PROGRAM: eStrAction = XML_EXECUTE; break; - case presentation::ClickAction_BOOKMARK: eStrAction = XML_SHOW; break; - case presentation::ClickAction_DOCUMENT: eStrAction = XML_SHOW; break; - case presentation::ClickAction_MACRO: eStrAction = XML_EXECUTE_MACRO; break; - case presentation::ClickAction_VERB: eStrAction = XML_VERB; break; - case presentation::ClickAction_VANISH: eStrAction = XML_FADE_OUT; break; - case presentation::ClickAction_SOUND: eStrAction = XML_SOUND; break; - default: - OSL_FAIL( "unknown presentation::ClickAction found!" ); - eStrAction = XML_UNKNOWN; - } - - OUString aEventQName( - mrExport.GetNamespaceMap().GetQNameByKey( - XML_NAMESPACE_DOM, OUString( "click" ) ) ); - mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName ); - mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_ACTION, eStrAction ); - - if( eClickAction == presentation::ClickAction_VANISH ) - { - if( nFound & FOUND_EFFECT ) - { - XMLEffect eKind; - XMLEffectDirection eDirection; - sal_Int16 nStartScale; - bool bIn; - - SdXMLImplSetEffect( eEffect, eKind, eDirection, nStartScale, bIn ); - - if( eKind != EK_none ) - { - SvXMLUnitConverter::convertEnum( msBuffer, eKind, aXML_AnimationEffect_EnumMap ); - mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_EFFECT, msBuffer.makeStringAndClear() ); - } - - if( eDirection != ED_none ) - { - SvXMLUnitConverter::convertEnum( msBuffer, eDirection, aXML_AnimationDirection_EnumMap ); - mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_DIRECTION, msBuffer.makeStringAndClear() ); - } - - if( nStartScale != -1 ) - { - ::sax::Converter::convertPercent( msBuffer, nStartScale ); - mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_START_SCALE, msBuffer.makeStringAndClear() ); - } - } - - if( nFound & FOUND_SPEED && eEffect != presentation::AnimationEffect_NONE ) - { - if( eSpeed != presentation::AnimationSpeed_MEDIUM ) - { - SvXMLUnitConverter::convertEnum( msBuffer, eSpeed, aXML_AnimationSpeed_EnumMap ); - mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_SPEED, msBuffer.makeStringAndClear() ); - } - } - } - - if( eClickAction == presentation::ClickAction_PROGRAM || - eClickAction == presentation::ClickAction_BOOKMARK || - eClickAction == presentation::ClickAction_DOCUMENT ) - { - if( eClickAction == presentation::ClickAction_BOOKMARK ) - msBuffer.append( sal_Unicode('#') ); - - msBuffer.append( aStrBookmark ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(msBuffer.makeStringAndClear()) ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST ); - } - - if( ( nFound & FOUND_VERB ) && eClickAction == presentation::ClickAction_VERB ) - { - msBuffer.append( nVerb ); - mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_VERB, msBuffer.makeStringAndClear()); - } - - SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_PRESENTATION, XML_EVENT_LISTENER, sal_True, sal_True); - - if( eClickAction == presentation::ClickAction_VANISH || eClickAction == presentation::ClickAction_SOUND ) - { - if( ( nFound & FOUND_SOUNDURL ) && !aStrSoundURL.isEmpty() ) - { - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStrSoundURL) ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_NEW ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST ); - if( nFound & FOUND_PLAYFULL && bPlayFull ) - mrExport.AddAttribute( XML_NAMESPACE_PRESENTATION, XML_PLAY_FULL, XML_TRUE ); - - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_PRESENTATION, XML_SOUND, sal_True, sal_True ); - } - } - } - else if( aClickEventType == msStarBasic ) - { - if( nFound & FOUND_MACRO ) - { - SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True); - - mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, - mrExport.GetNamespaceMap().GetQNameByKey( - XML_NAMESPACE_OOO, - OUString( "starbasic" ) ) ); - OUString aEventQName( - mrExport.GetNamespaceMap().GetQNameByKey( - XML_NAMESPACE_DOM, OUString( "click" ) ) ); - mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName ); - - if( nFound & FOUND_LIBRARY ) - { - OUString sLocation( GetXMLToken( - (aStrLibrary.equalsIgnoreAsciiCase("StarOffice") || - aStrLibrary.equalsIgnoreAsciiCase("application") ) ? XML_APPLICATION - : XML_DOCUMENT ) ); - mrExport.AddAttribute(XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, - sLocation + ":" + aStrMacro); - } - else - { - mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_MACRO_NAME, aStrMacro ); - } - - SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True); - } - } - else if( aClickEventType == msScript ) - { - if( nFound & FOUND_MACRO ) - { - SvXMLElementExport aEventsElemt(mrExport, XML_NAMESPACE_OFFICE, XML_EVENT_LISTENERS, sal_True, sal_True); - if ( nFound & FOUND_MACRO ) - { - mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, mrExport.GetNamespaceMap().GetQNameByKey( - XML_NAMESPACE_OOO, GetXMLToken(XML_SCRIPT) ) ); - OUString aEventQName( - mrExport.GetNamespaceMap().GetQNameByKey( - XML_NAMESPACE_DOM, OUString( "click" ) ) ); - mrExport.AddAttribute( XML_NAMESPACE_SCRIPT, XML_EVENT_NAME, aEventQName ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aStrMacro ); - - SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SCRIPT, XML_EVENT_LISTENER, sal_True, sal_True); - } - } - } -} - -/** #i68101# export shape Title and Description */ -void XMLShapeExport::ImpExportDescription( const uno::Reference< drawing::XShape >& xShape ) -{ - try - { - OUString aTitle; - OUString aDescription; - - uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY_THROW ); - xProps->getPropertyValue("Title") >>= aTitle; - xProps->getPropertyValue("Description") >>= aDescription; - - if(!aTitle.isEmpty()) - { - SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_TITLE, sal_True, sal_False); - mrExport.Characters( aTitle ); - } - - if(!aDescription.isEmpty()) - { - SvXMLElementExport aEventElemt(mrExport, XML_NAMESPACE_SVG, XML_DESC, sal_True, sal_False ); - mrExport.Characters( aDescription ); - } - } - catch( uno::Exception& ) - { - OSL_FAIL( "could not export Title and/or Description for shape!" ); - } -} - -void XMLShapeExport::ImpExportGroupShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY); - if(xShapes.is() && xShapes->getCount()) - { - // write group shape - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aPGR(mrExport, XML_NAMESPACE_DRAW, XML_G, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - - // #89764# if export of position is supressed for group shape, - // positions of contained objects should be written relative to - // the upper left edge of the group. - awt::Point aUpperLeft; - - if(!(nFeatures & SEF_EXPORT_POSITION)) - { - nFeatures |= SEF_EXPORT_POSITION; - aUpperLeft = xShape->getPosition(); - pRefPoint = &aUpperLeft; - } - - // write members - exportShapes( xShapes, nFeatures, pRefPoint ); - } -} - -void XMLShapeExport::ImpExportTextBoxShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); - - // presentation attribute (if presentation) - sal_Bool bIsPresShape(sal_False); - sal_Bool bIsEmptyPresObj(sal_False); - OUString aStr; - - switch(eShapeType) - { - case XmlShapeTypePresSubtitleShape: - { - aStr = GetXMLToken(XML_PRESENTATION_SUBTITLE); - bIsPresShape = sal_True; - break; - } - case XmlShapeTypePresTitleTextShape: - { - aStr = GetXMLToken(XML_PRESENTATION_TITLE); - bIsPresShape = sal_True; - break; - } - case XmlShapeTypePresOutlinerShape: - { - aStr = GetXMLToken(XML_PRESENTATION_OUTLINE); - bIsPresShape = sal_True; - break; - } - case XmlShapeTypePresNotesShape: - { - aStr = GetXMLToken(XML_PRESENTATION_NOTES); - bIsPresShape = sal_True; - break; - } - case XmlShapeTypePresHeaderShape: - { - aStr = GetXMLToken(XML_HEADER); - bIsPresShape = sal_True; - break; - } - case XmlShapeTypePresFooterShape: - { - aStr = GetXMLToken(XML_FOOTER); - bIsPresShape = sal_True; - break; - } - case XmlShapeTypePresSlideNumberShape: - { - aStr = GetXMLToken(XML_PAGE_NUMBER); - bIsPresShape = sal_True; - break; - } - case XmlShapeTypePresDateTimeShape: - { - aStr = GetXMLToken(XML_DATE_TIME); - bIsPresShape = sal_True; - break; - } - default: - break; - } - - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - if(bIsPresShape) - bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, aStr ); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, - XML_FRAME, bCreateNewline, sal_True ); - - // evtl. corner radius? - sal_Int32 nCornerRadius(0L); - xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius; - if(nCornerRadius) - { - OUStringBuffer sStringBuffer; - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - nCornerRadius); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear()); - } - - { - // write text-box - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_TEXT_BOX, sal_True, sal_True); - if(!bIsEmptyPresObj) - ImpExportText( xShape ); - } - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - } -} - -void XMLShapeExport::ImpExportRectangleShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - // evtl. corner radius? - sal_Int32 nCornerRadius(0L); - xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius; - if(nCornerRadius) - { - OUStringBuffer sStringBuffer; - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - nCornerRadius); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear()); - } - - // write rectangle - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_RECT, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - } -} - -void XMLShapeExport::ImpExportLineShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - OUString aStr; - OUStringBuffer sStringBuffer; - awt::Point aStart(0,0); - awt::Point aEnd(1,1); - - // #85920# use 'Geometry' to get the points of the line - // since this slot take anchor pos into account. - - // get matrix - ::basegfx::B2DHomMatrix aMatrix; - ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet); - - // decompose and correct about pRefPoint - ::basegfx::B2DTuple aTRScale; - double fTRShear(0.0); - double fTRRotate(0.0); - ::basegfx::B2DTuple aTRTranslate; - ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint); - - // create base position - awt::Point aBasePosition(FRound(aTRTranslate.getX()), FRound(aTRTranslate.getY())); - - // get the two points - uno::Any aAny(xPropSet->getPropertyValue("Geometry")); - drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue(); - - if(pSourcePolyPolygon) - { - drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray(); - if(pOuterSequence) - { - drawing::PointSequence* pInnerSequence = pOuterSequence++; - if(pInnerSequence) - { - awt::Point* pArray = pInnerSequence->getArray(); - if(pArray) - { - if(pInnerSequence->getLength() > 0) - { - aStart = awt::Point( - pArray->X + aBasePosition.X, - pArray->Y + aBasePosition.Y); - pArray++; - } - - if(pInnerSequence->getLength() > 1) - { - aEnd = awt::Point( - pArray->X + aBasePosition.X, - pArray->Y + aBasePosition.Y); - } - } - } - } - } - - if( nFeatures & SEF_EXPORT_X ) - { - // svg: x1 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aStart.X); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr); - } - else - { - aEnd.X -= aStart.X; - } - - if( nFeatures & SEF_EXPORT_Y ) - { - // svg: y1 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aStart.Y); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr); - } - else - { - aEnd.Y -= aStart.Y; - } - - // svg: x2 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aEnd.X); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr); - - // svg: y2 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aEnd.Y); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr); - - // write line - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_LINE, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - } -} - -void XMLShapeExport::ImpExportEllipseShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // get size to decide between Circle and Ellipse - awt::Size aSize = xShape->getSize(); - sal_Int32 nRx((aSize.Width + 1) / 2); - sal_Int32 nRy((aSize.Height + 1) / 2); - sal_Bool bCircle(nRx == nRy); - - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - drawing::CircleKind eKind = drawing::CircleKind_FULL; - xPropSet->getPropertyValue("CircleKind") >>= eKind; - if( eKind != drawing::CircleKind_FULL ) - { - OUStringBuffer sStringBuffer; - sal_Int32 nStartAngle = 0; - sal_Int32 nEndAngle = 0; - xPropSet->getPropertyValue("CircleStartAngle") >>= nStartAngle; - xPropSet->getPropertyValue("CircleEndAngle") >>= nEndAngle; - - const double dStartAngle = nStartAngle / 100.0; - const double dEndAngle = nEndAngle / 100.0; - - // export circle kind - SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eKind, aXML_CircleKind_EnumMap ); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_KIND, sStringBuffer.makeStringAndClear() ); - - // export start angle - ::sax::Converter::convertDouble( sStringBuffer, dStartAngle ); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_ANGLE, sStringBuffer.makeStringAndClear() ); - - // export end angle - ::sax::Converter::convertDouble( sStringBuffer, dEndAngle ); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_ANGLE, sStringBuffer.makeStringAndClear() ); - } - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - - if(bCircle) - { - // write circle - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CIRCLE, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - } - else - { - // write ellipse - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_ELLIPSE, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - } - } -} - -void XMLShapeExport::ImpExportPolygonShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - sal_Bool bClosed(eShapeType == XmlShapeTypeDrawPolyPolygonShape - || eShapeType == XmlShapeTypeDrawClosedBezierShape); - sal_Bool bBezier(eShapeType == XmlShapeTypeDrawClosedBezierShape - || eShapeType == XmlShapeTypeDrawOpenBezierShape); - - // get matrix - ::basegfx::B2DHomMatrix aMatrix; - ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xPropSet); - - // decompose and correct abour pRefPoint - ::basegfx::B2DTuple aTRScale; - double fTRShear(0.0); - double fTRRotate(0.0); - ::basegfx::B2DTuple aTRTranslate; - ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, fTRRotate, aTRTranslate, pRefPoint); - - // use features and write - ImpExportNewTrans_FeaturesAndWrite(aTRScale, fTRShear, fTRRotate, aTRTranslate, nFeatures); - - // create and export ViewBox - awt::Point aPoint(0, 0); - awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY())); - SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString()); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - - if(bBezier) - { - // get PolygonBezier - uno::Any aAny( xPropSet->getPropertyValue("Geometry") ); - drawing::PolyPolygonBezierCoords* pSourcePolyPolygon = - (drawing::PolyPolygonBezierCoords*)aAny.getValue(); - - if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength()) - { - sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength()); - drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray(); - drawing::FlagSequence* pOuterFlags = pSourcePolyPolygon->Flags.getArray(); - - if(pOuterSequence && pOuterFlags) - { - // prepare svx:d element export - SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); - - for(sal_Int32 a(0L); a < nOuterCnt; a++) - { - drawing::PointSequence* pSequence = pOuterSequence++; - drawing::FlagSequence* pFlags = pOuterFlags++; - - if(pSequence && pFlags) - { - aSvgDElement.AddPolygon(pSequence, pFlags, - aPoint, aSize, bClosed); - } - } - - // write point array - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); - } - - // write object now - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - } - } - else - { - // get non-bezier polygon - uno::Any aAny( xPropSet->getPropertyValue("Geometry") ); - drawing::PointSequenceSequence* pSourcePolyPolygon = (drawing::PointSequenceSequence*)aAny.getValue(); - - if(pSourcePolyPolygon && pSourcePolyPolygon->getLength()) - { - sal_Int32 nOuterCnt(pSourcePolyPolygon->getLength()); - - if(1L == nOuterCnt && !bBezier) - { - // simple polygon shape, can be written as svg:points sequence - drawing::PointSequence* pSequence = pSourcePolyPolygon->getArray(); - if(pSequence) - { - SdXMLImExPointsElement aPoints(pSequence, aViewBox, aPoint, aSize, - // #96328# - bClosed); - - // write point array - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_POINTS, aPoints.GetExportString()); - } - - // write object now - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, - bClosed ? XML_POLYGON : XML_POLYLINE , bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - } - else - { - // polypolygon or bezier, needs to be written as a svg:path sequence - drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->getArray(); - if(pOuterSequence) - { - // prepare svx:d element export - SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); - - for(sal_Int32 a(0L); a < nOuterCnt; a++) - { - drawing::PointSequence* pSequence = pOuterSequence++; - if(pSequence) - { - aSvgDElement.AddPolygon(pSequence, 0L, aPoint, - aSize, bClosed); - } - } - - // write point array - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); - } - - // write object now - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PATH, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - } - } - } - } -} - -void XMLShapeExport::ImpExportGraphicObjectShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - sal_Bool bIsEmptyPresObj = sal_False; - uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); - - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - OUString sImageURL; - - if(eShapeType == XmlShapeTypePresGraphicObjectShape) - bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_GRAPHIC) ); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, - XML_FRAME, bCreateNewline, sal_True ); - - const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ); - - if( !bIsEmptyPresObj || bSaveBackwardsCompatible ) - { - if( !bIsEmptyPresObj ) - { - OUString aReplacementUrl; - xPropSet->getPropertyValue("ReplacementGraphicURL") >>= aReplacementUrl; - - // If there is no url, then then graphic is empty - if(!aReplacementUrl.isEmpty()) - { - const OUString aStr = mrExport.AddEmbeddedGraphicObject(aReplacementUrl); - - if(aStr.getLength()) - { - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - - // xlink:href for replacement, only written for Svg content - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True); - - // optional office:binary-data - mrExport.AddEmbeddedGraphicObjectAsBase64(aReplacementUrl); - } - } - - OUString aStreamURL; - OUString aStr; - - xPropSet->getPropertyValue("GraphicStreamURL") >>= aStreamURL; - xPropSet->getPropertyValue("GraphicURL") >>= sImageURL; - - OUString aResolveURL( sImageURL ); - const OUString sPackageURL( "vnd.sun.star.Package:" ); - - // sj: trying to preserve the filename - if ( aStreamURL.match( sPackageURL, 0 ) ) - { - OUString sRequestedName( aStreamURL.copy( sPackageURL.getLength(), aStreamURL.getLength() - sPackageURL.getLength() ) ); - sal_Int32 nLastIndex = sRequestedName.lastIndexOf( '/' ) + 1; - if ( ( nLastIndex > 0 ) && ( nLastIndex < sRequestedName.getLength() ) ) - sRequestedName = sRequestedName.copy( nLastIndex, sRequestedName.getLength() - nLastIndex ); - nLastIndex = sRequestedName.lastIndexOf( '.' ); - if ( nLastIndex >= 0 ) - sRequestedName = sRequestedName.copy( 0, nLastIndex ); - if ( !sRequestedName.isEmpty() ) - { - aResolveURL = aResolveURL.concat( OUString("?requestedName=")); - aResolveURL = aResolveURL.concat( sRequestedName ); - } - } - - aStr = mrExport.AddEmbeddedGraphicObject( aResolveURL ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr ); - - if( !aStr.isEmpty() ) - { - if( aStr[ 0 ] == '#' ) - { - aStreamURL = sPackageURL; - aStreamURL = aStreamURL.concat( aStr.copy( 1, aStr.getLength() - 1 ) ); - } - - // update stream URL for load on demand - uno::Any aAny; - aAny <<= aStreamURL; - xPropSet->setPropertyValue("GraphicStreamURL", aAny ); - - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - } - } - else - { - OUString aStr; - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aStr ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - } - - { - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_IMAGE, sal_True, sal_True); - - if( !sImageURL.isEmpty() ) - { - // optional office:binary-data - mrExport.AddEmbeddedGraphicObjectAsBase64( sImageURL ); - } - if( !bIsEmptyPresObj ) - ImpExportText( xShape ); - } - } - - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - - // image map - GetExport().GetImageMapExport().Export( xPropSet ); - ImpExportDescription( xShape ); // #i68101# - } -} - -void XMLShapeExport::ImpExportChartShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint, - SvXMLAttributeList* pAttrList ) -{ - ImpExportOLE2Shape( xShape, eShapeType, nFeatures, pRefPoint, pAttrList ); -} - -void XMLShapeExport::ImpExportControlShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - } - - uno::Reference< drawing::XControlShape > xControl( xShape, uno::UNO_QUERY ); - DBG_ASSERT( xControl.is(), "Control shape is not supporting XControlShape" ); - if( xControl.is() ) - { - uno::Reference< beans::XPropertySet > xControlModel( xControl->getControl(), uno::UNO_QUERY ); - DBG_ASSERT( xControlModel.is(), "Control shape has not XControlModel" ); - if( xControlModel.is() ) - { - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONTROL, mrExport.GetFormExport()->getControlId( xControlModel ) ); - } - } - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONTROL, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# -} - -void XMLShapeExport::ImpExportConnectorShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) -{ - uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY ); - - OUString aStr; - OUStringBuffer sStringBuffer; - - // export connection kind - drawing::ConnectorType eType = drawing::ConnectorType_STANDARD; - uno::Any aAny = xProps->getPropertyValue("EdgeKind"); - aAny >>= eType; - - if( eType != drawing::ConnectorType_STANDARD ) - { - SvXMLUnitConverter::convertEnum( sStringBuffer, (sal_uInt16)eType, aXML_ConnectionKind_EnumMap ); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_TYPE, aStr); - } - - // export line skew - sal_Int32 nDelta1 = 0, nDelta2 = 0, nDelta3 = 0; - - aAny = xProps->getPropertyValue("EdgeLine1Delta"); - aAny >>= nDelta1; - aAny = xProps->getPropertyValue("EdgeLine2Delta"); - aAny >>= nDelta2; - aAny = xProps->getPropertyValue("EdgeLine3Delta"); - aAny >>= nDelta3; - - if( nDelta1 != 0 || nDelta2 != 0 || nDelta3 != 0 ) - { - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - nDelta1); - if( nDelta2 != 0 || nDelta3 != 0 ) - { - const char aSpace = ' '; - sStringBuffer.appendAscii( &aSpace, 1 ); - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - nDelta2); - if( nDelta3 != 0 ) - { - sStringBuffer.appendAscii( &aSpace, 1 ); - mrExport.GetMM100UnitConverter().convertMeasureToXML( - sStringBuffer, nDelta3); - } - } - - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_LINE_SKEW, aStr); - } - - // export start and end point - awt::Point aStart(0,0); - awt::Point aEnd(1,1); - - /* Get and - , if they exist and if the document is exported - into the OpenOffice.org file format. - These properties only exist at service com::sun::star::text::Shape - the - Writer UNO service for shapes. - This code is needed, because the positioning attributes in the - OpenOffice.org file format are given in horizontal left-to-right layout - regardless the layout direction the shape is in. In the OASIS Open Office - file format the positioning attributes are correctly given in the layout - direction the shape is in. Thus, this code provides the conversion from - the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#) - */ - if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 && - xProps->getPropertySetInfo()->hasPropertyByName( - OUString("StartPositionInHoriL2R")) && - xProps->getPropertySetInfo()->hasPropertyByName( - OUString("EndPositionInHoriL2R")) ) - { - xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart; - xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd; - } - else - { - xProps->getPropertyValue("StartPosition") >>= aStart; - xProps->getPropertyValue("EndPosition") >>= aEnd; - } - - if( pRefPoint ) - { - aStart.X -= pRefPoint->X; - aStart.Y -= pRefPoint->Y; - aEnd.X -= pRefPoint->X; - aEnd.Y -= pRefPoint->Y; - } - - if( nFeatures & SEF_EXPORT_X ) - { - // svg: x1 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aStart.X); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr); - } - else - { - aEnd.X -= aStart.X; - } - - if( nFeatures & SEF_EXPORT_Y ) - { - // svg: y1 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aStart.Y); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr); - } - else - { - aEnd.Y -= aStart.Y; - } - - // svg: x2 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr); - - // svg: y2 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr); - - // #i39320# - uno::Reference< uno::XInterface > xRefS; - uno::Reference< uno::XInterface > xRefE; - - // export start connection - xProps->getPropertyValue("StartShape") >>= xRefS; - if( xRefS.is() ) - { - const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefS ); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_SHAPE, rShapeId); - - aAny = xProps->getPropertyValue("StartGluePointIndex"); - sal_Int32 nGluePointId = 0; - if( aAny >>= nGluePointId ) - { - if( nGluePointId != -1 ) - { - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_START_GLUE_POINT, OUString::number( nGluePointId )); - } - } - } - - // export end connection - xProps->getPropertyValue("EndShape") >>= xRefE; - if( xRefE.is() ) - { - const OUString& rShapeId = mrExport.getInterfaceToIdentifierMapper().getIdentifier( xRefE ); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_SHAPE, rShapeId); - - aAny = xProps->getPropertyValue("EndGluePointIndex"); - sal_Int32 nGluePointId = 0; - if( aAny >>= nGluePointId ) - { - if( nGluePointId != -1 ) - { - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_END_GLUE_POINT, OUString::number( nGluePointId )); - } - } - } - - if( xProps->getPropertyValue("PolyPolygonBezier") >>= aAny ) - { - // get PolygonBezier - drawing::PolyPolygonBezierCoords* pSourcePolyPolygon = - (drawing::PolyPolygonBezierCoords*)aAny.getValue(); - - if(pSourcePolyPolygon && pSourcePolyPolygon->Coordinates.getLength()) - { - sal_Int32 nOuterCnt(pSourcePolyPolygon->Coordinates.getLength()); - drawing::PointSequence* pOuterSequence = pSourcePolyPolygon->Coordinates.getArray(); - drawing::FlagSequence* pOuterFlags = pSourcePolyPolygon->Flags.getArray(); - - if(pOuterSequence && pOuterFlags) - { - // prepare svx:d element export - awt::Point aPoint( 0, 0 ); - awt::Size aSize( 1, 1 ); - SdXMLImExViewBox aViewBox( 0, 0, 1, 1 ); - SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); - - for(sal_Int32 a(0L); a < nOuterCnt; a++) - { - drawing::PointSequence* pSequence = pOuterSequence++; - drawing::FlagSequence* pFlags = pOuterFlags++; - - if(pSequence && pFlags) - { - aSvgDElement.AddPolygon(pSequence, pFlags, - aPoint, aSize, sal_False ); - } - } - - // write point array - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); - } - } - } - - // get matrix - ::basegfx::B2DHomMatrix aMatrix; - ImpExportNewTrans_GetB2DHomMatrix(aMatrix, xProps); - - // decompose and correct about pRefPoint - ::basegfx::B2DTuple aTRScale; - double fTRShear(0.0); - double fTRRotate(0.0); - ::basegfx::B2DTuple aTRTranslate; - ImpExportNewTrans_DecomposeAndRefPoint(aMatrix, aTRScale, fTRShear, - fTRRotate, aTRTranslate, pRefPoint); - - // fdo#49678: create and export ViewBox - awt::Point aPoint(0, 0); - awt::Size aSize(FRound(aTRScale.getX()), FRound(aTRScale.getY())); - SdXMLImExViewBox aViewBox(0, 0, aSize.Width, aSize.Height); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString()); - - // write connector shape. Add Export later. - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_CONNECTOR, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); -} - -void XMLShapeExport::ImpExportMeasureShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) -{ - uno::Reference< beans::XPropertySet > xProps( xShape, uno::UNO_QUERY ); - - OUString aStr; - OUStringBuffer sStringBuffer; - - // export start and end point - awt::Point aStart(0,0); - awt::Point aEnd(1,1); - - /* Get and - , if they exist and if the document is exported - into the OpenOffice.org file format. - These properties only exist at service com::sun::star::text::Shape - the - Writer UNO service for shapes. - This code is needed, because the positioning attributes in the - OpenOffice.org file format are given in horizontal left-to-right layout - regardless the layout direction the shape is in. In the OASIS Open Office - file format the positioning attributes are correctly given in the layout - direction the shape is in. Thus, this code provides the conversion from - the OASIS Open Office file format to the OpenOffice.org file format. (#i36248#) - */ - if ( ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 && - xProps->getPropertySetInfo()->hasPropertyByName( - OUString("StartPositionInHoriL2R")) && - xProps->getPropertySetInfo()->hasPropertyByName( - OUString("EndPositionInHoriL2R")) ) - { - xProps->getPropertyValue("StartPositionInHoriL2R") >>= aStart; - xProps->getPropertyValue("EndPositionInHoriL2R") >>= aEnd; - } - else - { - xProps->getPropertyValue("StartPosition") >>= aStart; - xProps->getPropertyValue("EndPosition") >>= aEnd; - } - - if( pRefPoint ) - { - aStart.X -= pRefPoint->X; - aStart.Y -= pRefPoint->Y; - aEnd.X -= pRefPoint->X; - aEnd.Y -= pRefPoint->Y; - } - - if( nFeatures & SEF_EXPORT_X ) - { - // svg: x1 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aStart.X); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X1, aStr); - } - else - { - aEnd.X -= aStart.X; - } - - if( nFeatures & SEF_EXPORT_Y ) - { - // svg: y1 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - aStart.Y); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y1, aStr); - } - else - { - aEnd.Y -= aStart.Y; - } - - // svg: x2 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.X); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_X2, aStr); - - // svg: y2 - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, aEnd.Y); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_Y2, aStr); - - // write measure shape - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_MEASURE, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - - uno::Reference< text::XText > xText( xShape, uno::UNO_QUERY ); - if( xText.is() ) - mrExport.GetTextParagraphExport()->exportText( xText ); -} - -void XMLShapeExport::ImpExportOLE2Shape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */, - SvXMLAttributeList* pAttrList /* = NULL */ ) -{ - uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY); - - DBG_ASSERT( xPropSet.is() && xNamed.is(), "ole shape is not implementing needed interfaces"); - if(xPropSet.is() && xNamed.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - sal_Bool bIsEmptyPresObj = sal_False; - - // presentation settings - if(eShapeType == XmlShapeTypePresOLE2Shape) - bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) ); - else if(eShapeType == XmlShapeTypePresChartShape) - bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_CHART) ); - else if(eShapeType == XmlShapeTypePresSheetShape) - bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) ); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - sal_Bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED)); - OUString sPersistName; - SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, - XML_FRAME, bCreateNewline, sal_True ); - - const bool bSaveBackwardsCompatible = ( mrExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ); - - if( !bIsEmptyPresObj || bSaveBackwardsCompatible ) - { - if (pAttrList) - { - mrExport.AddAttributeList(pAttrList); - } - - OUString sClassId; - OUString sURL; - sal_Bool bInternal = false; - xPropSet->getPropertyValue("IsInternal") >>= bInternal; - - if( !bIsEmptyPresObj ) - { - - if ( bInternal ) - { - // OOo internal links have no storage persistance, URL is stored in the XML file - // the result LinkURL is empty in case the object is not a link - xPropSet->getPropertyValue("LinkURL") >>= sURL; - } - - xPropSet->getPropertyValue("PersistName") >>= sPersistName; - if ( sURL.isEmpty() ) - { - if( !sPersistName.isEmpty() ) - { - sURL = OUString( "vnd.sun.star.EmbeddedObject:" ); - sURL += sPersistName; - } - } - - if( !bInternal ) - xPropSet->getPropertyValue("CLSID") >>= sClassId; - - if( !sClassId.isEmpty() ) - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CLASS_ID, sClassId ); - - if(eShapeType != XmlShapeTypePresChartShape && eShapeType != XmlShapeTypeDrawChartShape) - { - // #i118485# Add text export, the draw OLE shape allows text now - // fdo#58571 chart objects don't allow text:p - ImpExportText( xShape ); - } - - if(!bExportEmbedded) - { - // xlink:href - if( !sURL.isEmpty() ) - { - // #96717# in theorie, if we don't have a url we shouldn't even - // export this ole shape. But practical its to risky right now - // to change this so we better dispose this on load - sURL = mrExport.AddEmbeddedObject( sURL ); - - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - } - } - } - else - { - // export empty href for empty placeholders to be valid ODF - OUString sEmptyURL; - - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sEmptyURL ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - } - - enum XMLTokenEnum eElem = sClassId.isEmpty() ? XML_OBJECT : XML_OBJECT_OLE ; - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, eElem, sal_True, sal_True ); - - if(bExportEmbedded && !bIsEmptyPresObj) - { - // #100592# - if(bInternal) - { - // embedded XML - uno::Reference< lang::XComponent > xComp; - xPropSet->getPropertyValue("Model") >>= xComp; - DBG_ASSERT( xComp.is(), "no xModel for own OLE format" ); - mrExport.ExportEmbeddedOwnObject( xComp ); - } - else - { - // embed as Base64 - // this is an alien object ( currently MSOLE is the only supported type of such objects ) - // in case it is not an OASIS format the object should be asked to store replacement image if possible - - OUString sURLRequest( sURL ); - if ( ( mrExport.getExportFlags() & EXPORT_OASIS ) == 0 ) - sURLRequest += OUString( "?oasis=false" ); - mrExport.AddEmbeddedObjectAsBase64( sURLRequest ); - } - } - } - if( !bIsEmptyPresObj ) - { - OUString sURL( "vnd.sun.star.GraphicObject:" ); - sURL += sPersistName; - if( !bExportEmbedded ) - { - sURL = GetExport().AddEmbeddedObject( sURL ); - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - } - - SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, - XML_IMAGE, sal_False, sal_True ); - - if( bExportEmbedded ) - GetExport().AddEmbeddedObjectAsBase64( sURL ); - } - - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportDescription( xShape ); // #i68101# - } -} - -void XMLShapeExport::ImpExportPageShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // #86163# Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - // export page number used for this page - uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); - const OUString aPageNumberStr("PageNumber"); - if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr)) - { - sal_Int32 nPageNumber = 0; - xPropSet->getPropertyValue(aPageNumberStr) >>= nPageNumber; - if( nPageNumber ) - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_PAGE_NUMBER, OUString::number(nPageNumber)); - } - - // a presentation page shape, normally used on notes pages only. If - // it is used not as presentation shape, it may have been created with - // copy-paste exchange between draw and impress (this IS possible...) - if(eShapeType == XmlShapeTypePresPageShape) - { - mrExport.AddAttribute(XML_NAMESPACE_PRESENTATION, XML_CLASS, - XML_PRESENTATION_PAGE); - } - - // write Page shape - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PAGE_THUMBNAIL, bCreateNewline, sal_True); - } -} - -void XMLShapeExport::ImpExportCaptionShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures /* = SEF_DEFAULT */, awt::Point* pRefPoint /* = NULL */) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - // evtl. corner radius? - sal_Int32 nCornerRadius(0L); - xPropSet->getPropertyValue("CornerRadius") >>= nCornerRadius; - if(nCornerRadius) - { - OUStringBuffer sStringBuffer; - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - nCornerRadius); - mrExport.AddAttribute(XML_NAMESPACE_DRAW, XML_CORNER_RADIUS, sStringBuffer.makeStringAndClear()); - } - - awt::Point aCaptionPoint; - xPropSet->getPropertyValue("CaptionPoint") >>= aCaptionPoint; - - mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer, - aCaptionPoint.X); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_X, msBuffer.makeStringAndClear() ); - mrExport.GetMM100UnitConverter().convertMeasureToXML(msBuffer, - aCaptionPoint.Y); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CAPTION_POINT_Y, msBuffer.makeStringAndClear() ); - - // write Caption shape. Add export later. - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - sal_Bool bAnnotation( (nFeatures & SEF_EXPORT_ANNOTATION) == SEF_EXPORT_ANNOTATION ); - - SvXMLElementExport aObj( mrExport, - (bAnnotation ? XML_NAMESPACE_OFFICE - : XML_NAMESPACE_DRAW), - (bAnnotation ? XML_ANNOTATION : XML_CAPTION), - bCreateNewline, sal_True ); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - if( bAnnotation ) - mrExport.exportAnnotationMeta( xShape ); - ImpExportText( xShape ); - } -} - -void XMLShapeExport::ImpExportFrameShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, - XML_FRAME, bCreateNewline, sal_True ); - - // export frame url - OUString aStr; - xPropSet->getPropertyValue("FrameURL") >>= aStr; - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - - // export name - xPropSet->getPropertyValue("FrameName") >>= aStr; - if( !aStr.isEmpty() ) - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FRAME_NAME, aStr ); - - // write floating frame - { - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_FLOATING_FRAME, sal_True, sal_True); - } - } -} - -void XMLShapeExport::ImpExportAppletShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, - XML_FRAME, bCreateNewline, sal_True ); - - // export frame url - OUString aStr; - xPropSet->getPropertyValue("AppletCodeBase") >>= aStr; - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - - // export draw:applet-name - xPropSet->getPropertyValue("AppletName") >>= aStr; - if( !aStr.isEmpty() ) - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_APPLET_NAME, aStr ); - - // export draw:code - xPropSet->getPropertyValue("AppletCode") >>= aStr; - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CODE, aStr ); - - // export draw:may-script - sal_Bool bIsScript = false; - xPropSet->getPropertyValue("AppletIsScript") >>= bIsScript; - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, bIsScript ? XML_TRUE : XML_FALSE ); - - { - // write applet - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_APPLET, sal_True, sal_True); - - // export parameters - uno::Sequence< beans::PropertyValue > aCommands; - xPropSet->getPropertyValue("AppletCommands") >>= aCommands; - const sal_Int32 nCount = aCommands.getLength(); - for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ ) - { - aCommands[nIndex].Value >>= aStr; - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name ); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr ); - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ); - } - } - } -} - -void XMLShapeExport::ImpExportPluginShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, - XML_FRAME, bCreateNewline, sal_True ); - - // export plugin url - OUString aStr; - xPropSet->getPropertyValue("PluginURL") >>= aStr; - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, GetExport().GetRelativeReference(aStr) ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - - // export mime-type - xPropSet->getPropertyValue("PluginMimeType") >>= aStr; - if(!aStr.isEmpty()) - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, aStr ); - - { - // write plugin - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, sal_True, sal_True); - - // export parameters - uno::Sequence< beans::PropertyValue > aCommands; - xPropSet->getPropertyValue("PluginCommands") >>= aCommands; - const sal_Int32 nCount = aCommands.getLength(); - for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ ) - { - aCommands[nIndex].Value >>= aStr; - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aCommands[nIndex].Name ); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aStr ); - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ); - } - } - } -} - -static void lcl_CopyStream( - uno::Reference const& xInStream, - uno::Reference const& xTarget, - OUString const& rPath) -{ - ::comphelper::LifecycleProxy proxy; - uno::Reference const xStream( - ::comphelper::OStorageHelper::GetStreamAtPackageURL(xTarget, rPath, - embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE, proxy)); - uno::Reference const xOutStream( - (xStream.is()) ? xStream->getOutputStream() : 0); - if (!xOutStream.is()) - { - SAL_WARN("xmloff", "no output stream"); - throw uno::Exception( - OUString("no output stream"),0); - } - uno::Reference< beans::XPropertySet > const xStreamProps(xStream, - uno::UNO_QUERY); - if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage - xStreamProps->setPropertyValue( - OUString("MediaType"), - uno::makeAny(OUString( - //FIXME how to detect real media type? - //but currently xmloff has this one hardcoded anyway... - "application/vnd.sun.star.media"))); - xStreamProps->setPropertyValue( // turn off compression - OUString("Compressed"), - uno::makeAny(sal_False)); - } - ::comphelper::OStorageHelper::CopyInputToOutput(xInStream, xOutStream); - xOutStream->closeOutput(); - proxy.commitStorages(); -} - -static char const s_PkgScheme[] = "vnd.sun.star.Package:"; - -static OUString -lcl_StoreMediaAndGetURL(SvXMLExport & rExport, - uno::Reference const& xPropSet, - OUString const& rURL) -{ - if (0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( - rURL.getStr(), rURL.getLength(), - s_PkgScheme, SAL_N_ELEMENTS(s_PkgScheme) - 1)) - { - try // video is embedded - { - uno::Reference const xTarget( - rExport.GetTargetStorage(), uno::UNO_QUERY_THROW); - uno::Reference xInStream; - xPropSet->getPropertyValue( - OUString("PrivateStream")) - >>= xInStream; - - if (!xInStream.is()) - { - SAL_WARN("xmloff", "no input stream"); - return OUString(); - } - - OUString const urlPath( - rURL.copy(SAL_N_ELEMENTS(s_PkgScheme)-1)); - - lcl_CopyStream(xInStream, xTarget, rURL); - - return urlPath; - } - catch (uno::Exception const& e) - { - SAL_INFO("xmloff", "exception while storing embedded media: '" - << e.Message << "'"); - } - return OUString(); - } - else - { - return rExport.GetRelativeReference(rURL); // linked - } -} - -void XMLShapeExport::ImpExportMediaShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - if(eShapeType == XmlShapeTypePresMediaShape) - ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_OBJECT) ); - - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DRAW, - XML_FRAME, bCreateNewline, sal_True ); - - // export media url - OUString aMediaURL; - xPropSet->getPropertyValue("MediaURL") >>= aMediaURL; - OUString const persistentURL = - lcl_StoreMediaAndGetURL(GetExport(), xPropSet, aMediaURL); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_HREF, persistentURL ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute ( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - - // export mime-type - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIME_TYPE, OUString( "application/vnd.sun.star.media" ) ); - - // write plugin - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DRAW, XML_PLUGIN, !( nFeatures & SEF_EXPORT_NO_WS ), sal_True); - - // export parameters - const OUString aFalseStr( "false" ), aTrueStr( "true" ); - - sal_Bool bLoop = false; - const OUString aLoopStr( "Loop" ); - xPropSet->getPropertyValue( aLoopStr ) >>= bLoop; - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aLoopStr ); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bLoop ? aTrueStr : aFalseStr ); - delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); - - sal_Bool bMute = false; - const OUString aMuteStr( "Mute" ); - xPropSet->getPropertyValue( aMuteStr ) >>= bMute; - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aMuteStr ); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, bMute ? aTrueStr : aFalseStr ); - delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); - - sal_Int16 nVolumeDB = 0; - const OUString aVolumeDBStr( "VolumeDB" ); - xPropSet->getPropertyValue("VolumeDB") >>= nVolumeDB; - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aVolumeDBStr ); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, OUString::number( nVolumeDB ) ); - delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); - - media::ZoomLevel eZoom; - const OUString aZoomStr( "Zoom" ); - OUString aZoomValue; - xPropSet->getPropertyValue("Zoom") >>= eZoom; - switch( eZoom ) - { - case( media::ZoomLevel_ZOOM_1_TO_4 ): aZoomValue = OUString( "25%" ); break; - case( media::ZoomLevel_ZOOM_1_TO_2 ): aZoomValue = OUString( "50%" ); break; - case( media::ZoomLevel_ORIGINAL ): aZoomValue = OUString( "100%" ); break; - case( media::ZoomLevel_ZOOM_2_TO_1 ): aZoomValue = OUString( "200%" ); break; - case( media::ZoomLevel_ZOOM_4_TO_1 ): aZoomValue = OUString( "400%" ); break; - case( media::ZoomLevel_FIT_TO_WINDOW ): aZoomValue = OUString( "fit" ); break; - case( media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT ): aZoomValue = OUString( "fixedfit" ); break; - case( media::ZoomLevel_FULLSCREEN ): aZoomValue = OUString( "fullscreen" ); break; - - default: - break; - } - - if( !aZoomValue.isEmpty() ) - { - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aZoomStr ); - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_VALUE, aZoomValue ); - delete( new SvXMLElementExport( mrExport, XML_NAMESPACE_DRAW, XML_PARAM, sal_False, sal_True ) ); - } - } -} - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/xmloff/source/draw/shapeexport3.cxx b/xmloff/source/draw/shapeexport3.cxx deleted file mode 100644 index b2d6cbb7e864..000000000000 --- a/xmloff/source/draw/shapeexport3.cxx +++ /dev/null @@ -1,477 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include -#include "sdpropls.hxx" -#include -#include -#include -#include -#include "xexptran.hxx" -#include -#include - -#include "xmloff/xmlnmspe.hxx" - -using namespace ::com::sun::star; -using namespace ::xmloff::token; - -void XMLShapeExport::ImpExport3DSceneShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType, sal_Int32 nFeatures, awt::Point* pRefPoint) -{ - uno::Reference< drawing::XShapes > xShapes(xShape, uno::UNO_QUERY); - if(xShapes.is() && xShapes->getCount()) - { - uno::Reference< beans::XPropertySet > xPropSet( xShape, uno::UNO_QUERY ); - DBG_ASSERT( xPropSet.is(), "XMLShapeExport::ImpExport3DSceneShape can't export a scene without a propertyset" ); - if( xPropSet.is() ) - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - // 3d attributes - export3DSceneAttributes( xPropSet ); - - // write 3DScene shape - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DR3D, XML_SCENE, bCreateNewline, sal_True); - - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - - // write 3DSceneLights - export3DLamps( xPropSet ); - - // #89764# if export of position is supressed for group shape, - // positions of contained objects should be written relative to - // the upper left edge of the group. - awt::Point aUpperLeft; - - if(!(nFeatures & SEF_EXPORT_POSITION)) - { - nFeatures |= SEF_EXPORT_POSITION; - aUpperLeft = xShape->getPosition(); - pRefPoint = &aUpperLeft; - } - - // write members - exportShapes( xShapes, nFeatures, pRefPoint ); - } - } -} - -void XMLShapeExport::ImpExport3DShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType eShapeType, sal_Int32 /* nFeatures = SEF_DEFAULT */, awt::Point* /*pRefPoint = NULL */) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if(xPropSet.is()) - { - OUString aStr; - OUStringBuffer sStringBuffer; - - // transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix") - uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix"); - drawing::HomogenMatrix xHomMat; - aAny >>= xHomMat; - SdXMLImExTransform3D aTransform; - aTransform.AddHomogenMatrix(xHomMat); - if(aTransform.NeedsAction()) - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter())); - - switch(eShapeType) - { - case XmlShapeTypeDraw3DCubeObject: - { - // write 3DCube shape - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_CUBE, sal_True, sal_True); - - // minEdge - aAny = xPropSet->getPropertyValue("D3DPosition"); - drawing::Position3D aPosition3D; - aAny >>= aPosition3D; - ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ); - - // maxEdge - aAny = xPropSet->getPropertyValue("D3DSize"); - drawing::Direction3D aDirection3D; - aAny >>= aDirection3D; - ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ); - - // transform maxEdge from distance to pos - aDir3D = aPos3D + aDir3D; - - // write minEdge - if(aPos3D != ::basegfx::B3DVector(-2500.0, -2500.0, -2500.0)) // write only when not default - { - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MIN_EDGE, aStr); - } - - // write maxEdge - if(aDir3D != ::basegfx::B3DVector(2500.0, 2500.0, 2500.0)) // write only when not default - { - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_MAX_EDGE, aStr); - } - - break; - } - case XmlShapeTypeDraw3DSphereObject: - { - // write 3DSphere shape - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_SPHERE, sal_True, sal_True); - - // Center - aAny = xPropSet->getPropertyValue("D3DPosition"); - drawing::Position3D aPosition3D; - aAny >>= aPosition3D; - ::basegfx::B3DVector aPos3D(aPosition3D.PositionX, aPosition3D.PositionY, aPosition3D.PositionZ); - - // Size - aAny = xPropSet->getPropertyValue("D3DSize"); - drawing::Direction3D aDirection3D; - aAny >>= aDirection3D; - ::basegfx::B3DVector aDir3D(aDirection3D.DirectionX, aDirection3D.DirectionY, aDirection3D.DirectionZ); - - // write Center - if(aPos3D != ::basegfx::B3DVector(0.0, 0.0, 0.0)) // write only when not default - { - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aPos3D); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_CENTER, aStr); - } - - // write Size - if(aDir3D != ::basegfx::B3DVector(5000.0, 5000.0, 5000.0)) // write only when not default - { - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aDir3D); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SIZE, aStr); - } - - break; - } - case XmlShapeTypeDraw3DLatheObject: - case XmlShapeTypeDraw3DExtrudeObject: - { - // write special 3DLathe/3DExtrude attributes - aAny = xPropSet->getPropertyValue("D3DPolyPolygon3D"); - drawing::PolyPolygonShape3D xPolyPolygon3D; - aAny >>= xPolyPolygon3D; - - // look for maximal values - double fXMin = 0; - double fXMax = 0; - double fYMin = 0; - double fYMax = 0; - sal_Bool bInit(sal_False); - sal_Int32 nOuterSequenceCount(xPolyPolygon3D.SequenceX.getLength()); - drawing::DoubleSequence* pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray(); - drawing::DoubleSequence* pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray(); - - sal_Int32 a; - for (a = 0; a < nOuterSequenceCount; a++) - { - sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength()); - double* pArrayX = pInnerSequenceX->getArray(); - double* pArrayY = pInnerSequenceY->getArray(); - - for(sal_Int32 b(0L); b < nInnerSequenceCount; b++) - { - double fX = *pArrayX++; - double fY = *pArrayY++; - - if(bInit) - { - if(fX > fXMax) - fXMax = fX; - - if(fX < fXMin) - fXMin = fX; - - if(fY > fYMax) - fYMax = fY; - - if(fY < fYMin) - fYMin = fY; - } - else - { - fXMin = fXMax = fX; - fYMin = fYMax = fY; - bInit = sal_True; - } - } - - pInnerSequenceX++; - pInnerSequenceY++; - } - - // export ViewBox - awt::Point aMinPoint(FRound(fXMin), FRound(fYMin)); - awt::Size aMaxSize(FRound(fXMax) - aMinPoint.X, FRound(fYMax) - aMinPoint.Y); - SdXMLImExViewBox aViewBox( - aMinPoint.X, aMinPoint.Y, aMaxSize.Width, aMaxSize.Height); - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_VIEWBOX, - aViewBox.GetExportString()); - - // prepare svx:d element export - SdXMLImExSvgDElement aSvgDElement(aViewBox, GetExport()); - pInnerSequenceX = xPolyPolygon3D.SequenceX.getArray(); - pInnerSequenceY = xPolyPolygon3D.SequenceY.getArray(); - - for (a = 0; a < nOuterSequenceCount; a++) - { - sal_Int32 nInnerSequenceCount(pInnerSequenceX->getLength()); - double* pArrayX = pInnerSequenceX->getArray(); - double* pArrayY = pInnerSequenceY->getArray(); - drawing::PointSequence aPoly(nInnerSequenceCount); - awt::Point* pInnerSequence = aPoly.getArray(); - - for(sal_Int32 b(0L); b < nInnerSequenceCount; b++) - { - double fX = *pArrayX++; - double fY = *pArrayY++; - - *pInnerSequence = awt::Point(FRound(fX), FRound(fY)); - pInnerSequence++; - } - - // calculate closed flag - awt::Point* pFirst = aPoly.getArray(); - awt::Point* pLast = pFirst + (nInnerSequenceCount - 1); - sal_Bool bClosed = (pFirst->X == pLast->X && pFirst->Y == pLast->Y); - - aSvgDElement.AddPolygon(&aPoly, 0L, aMinPoint, - aMaxSize, bClosed); - - // #80594# corrected error in PolyPolygon3D export for 3D XML - pInnerSequenceX++; - pInnerSequenceY++; - } - - // write point array - mrExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aSvgDElement.GetExportString()); - - if(eShapeType == XmlShapeTypeDraw3DLatheObject) - { - // write 3DLathe shape - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_ROTATE, sal_True, sal_True); - } - else - { - // write 3DExtrude shape - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_EXTRUDE, sal_True, sal_True); - } - break; - } - default: - break; - } - } -} - -/** helper for chart that adds all attributes of a 3d scene element to the export */ -void XMLShapeExport::export3DSceneAttributes( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet ) -{ - OUString aStr; - OUStringBuffer sStringBuffer; - - // world transformation (UNO_NAME_3D_TRANSFORM_MATRIX == "D3DTransformMatrix") - uno::Any aAny = xPropSet->getPropertyValue("D3DTransformMatrix"); - drawing::HomogenMatrix xHomMat; - aAny >>= xHomMat; - SdXMLImExTransform3D aTransform; - aTransform.AddHomogenMatrix(xHomMat); - if(aTransform.NeedsAction()) - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_TRANSFORM, aTransform.GetExportString(mrExport.GetMM100UnitConverter())); - - // VRP, VPN, VUP - aAny = xPropSet->getPropertyValue("D3DCameraGeometry"); - drawing::CameraGeometry aCamGeo; - aAny >>= aCamGeo; - - ::basegfx::B3DVector aVRP(aCamGeo.vrp.PositionX, aCamGeo.vrp.PositionY, aCamGeo.vrp.PositionZ); - if(aVRP != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default - { - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVRP); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VRP, aStr); - } - - ::basegfx::B3DVector aVPN(aCamGeo.vpn.DirectionX, aCamGeo.vpn.DirectionY, aCamGeo.vpn.DirectionZ); - if(aVPN != ::basegfx::B3DVector(0.0, 0.0, 1.0)) // write only when not default - { - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVPN); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VPN, aStr); - } - - ::basegfx::B3DVector aVUP(aCamGeo.vup.DirectionX, aCamGeo.vup.DirectionY, aCamGeo.vup.DirectionZ); - if(aVUP != ::basegfx::B3DVector(0.0, 1.0, 0.0)) // write only when not default - { - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aVUP); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_VUP, aStr); - } - - // projection "D3DScenePerspective" drawing::ProjectionMode - aAny = xPropSet->getPropertyValue("D3DScenePerspective"); - drawing::ProjectionMode xPrjMode; - aAny >>= xPrjMode; - if(xPrjMode == drawing::ProjectionMode_PARALLEL) - aStr = GetXMLToken(XML_PARALLEL); - else - aStr = GetXMLToken(XML_PERSPECTIVE); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_PROJECTION, aStr); - - // distance - aAny = xPropSet->getPropertyValue("D3DSceneDistance"); - sal_Int32 nDistance = 0; - aAny >>= nDistance; - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - nDistance); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DISTANCE, aStr); - - // focalLength - aAny = xPropSet->getPropertyValue("D3DSceneFocalLength"); - sal_Int32 nFocalLength = 0; - aAny >>= nFocalLength; - mrExport.GetMM100UnitConverter().convertMeasureToXML(sStringBuffer, - nFocalLength); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_FOCAL_LENGTH, aStr); - - // shadowSlant - aAny = xPropSet->getPropertyValue("D3DSceneShadowSlant"); - sal_Int16 nShadowSlant = 0; - aAny >>= nShadowSlant; - ::sax::Converter::convertNumber(sStringBuffer, (sal_Int32)nShadowSlant); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADOW_SLANT, aStr); - - // shadeMode - aAny = xPropSet->getPropertyValue("D3DSceneShadeMode"); - drawing::ShadeMode xShadeMode; - if(aAny >>= xShadeMode) - { - if(xShadeMode == drawing::ShadeMode_FLAT) - aStr = GetXMLToken(XML_FLAT); - else if(xShadeMode == drawing::ShadeMode_PHONG) - aStr = GetXMLToken(XML_PHONG); - else if(xShadeMode == drawing::ShadeMode_SMOOTH) - aStr = GetXMLToken(XML_GOURAUD); - else - aStr = GetXMLToken(XML_DRAFT); - } - else - { - // ShadeMode enum not there, write default - aStr = GetXMLToken(XML_GOURAUD); - } - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr); - - // ambientColor - aAny = xPropSet->getPropertyValue("D3DSceneAmbientColor"); - sal_Int32 nAmbientColor = 0; - aAny >>= nAmbientColor; - ::sax::Converter::convertColor(sStringBuffer, nAmbientColor); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_AMBIENT_COLOR, aStr); - - // lightingMode - aAny = xPropSet->getPropertyValue("D3DSceneTwoSidedLighting"); - sal_Bool bTwoSidedLighting = false; - aAny >>= bTwoSidedLighting; - ::sax::Converter::convertBool(sStringBuffer, bTwoSidedLighting); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_LIGHTING_MODE, aStr); -} - -/** helper for chart that exports all lamps from the propertyset */ -void XMLShapeExport::export3DLamps( const com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet >& xPropSet ) -{ - // write lamps 1..8 as content - OUString aStr; - OUStringBuffer sStringBuffer; - - const OUString aColorPropName("D3DSceneLightColor"); - const OUString aDirectionPropName("D3DSceneLightDirection"); - const OUString aLightOnPropName("D3DSceneLightOn"); - - OUString aPropName; - OUString aIndexStr; - ::basegfx::B3DVector aLightDirection; - drawing::Direction3D xLightDir; - sal_Bool bLightOnOff = false; - for(sal_Int32 nLamp = 1; nLamp <= 8; nLamp++) - { - aIndexStr = OUString::number( nLamp ); - - // lightcolor - aPropName = aColorPropName; - aPropName += aIndexStr; - sal_Int32 nLightColor = 0; - xPropSet->getPropertyValue( aPropName ) >>= nLightColor; - ::sax::Converter::convertColor(sStringBuffer, nLightColor); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIFFUSE_COLOR, aStr); - - // lightdirection - aPropName = aDirectionPropName; - aPropName += aIndexStr; - xPropSet->getPropertyValue(aPropName) >>= xLightDir; - aLightDirection = ::basegfx::B3DVector(xLightDir.DirectionX, xLightDir.DirectionY, xLightDir.DirectionZ); - mrExport.GetMM100UnitConverter().convertB3DVector(sStringBuffer, aLightDirection); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_DIRECTION, aStr); - - // lighton - aPropName = aLightOnPropName; - aPropName += aIndexStr; - xPropSet->getPropertyValue(aPropName) >>= bLightOnOff; - ::sax::Converter::convertBool(sStringBuffer, bLightOnOff); - aStr = sStringBuffer.makeStringAndClear(); - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_ENABLED, aStr); - - // specular - mrExport.AddAttribute(XML_NAMESPACE_DR3D, XML_SPECULAR, - nLamp == 1 ? XML_TRUE : XML_FALSE); - - // write light entry - SvXMLElementExport aOBJ(mrExport, XML_NAMESPACE_DR3D, XML_LIGHT, sal_True, sal_True); - } -} - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/xmloff/source/draw/shapeexport4.cxx b/xmloff/source/draw/shapeexport4.cxx deleted file mode 100644 index 472d6ae732cd..000000000000 --- a/xmloff/source/draw/shapeexport4.cxx +++ /dev/null @@ -1,1314 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include - -#include -#include "sdpropls.hxx" -#include -#include -#include -#include -#include "xexptran.hxx" -#include -#include "EnhancedCustomShapeToken.hxx" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "xmloff/xmlnmspe.hxx" -#include "XMLBase64Export.hxx" -#include - -using namespace ::com::sun::star; -using namespace ::com::sun::star::io; -using namespace ::xmloff::token; -using namespace ::xmloff::EnhancedCustomShapeToken; - -using ::com::sun::star::embed::XStorage; -using ::com::sun::star::uno::UNO_QUERY; -using ::com::sun::star::uno::UNO_QUERY_THROW; -using ::com::sun::star::uno::Reference; -using ::com::sun::star::uno::Sequence; - -void ExportParameter( OUStringBuffer& rStrBuffer, const com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter ) -{ - if ( !rStrBuffer.isEmpty() ) - rStrBuffer.append( (sal_Unicode)' ' ); - if ( rParameter.Value.getValueTypeClass() == uno::TypeClass_DOUBLE ) - { - double fNumber = 0.0; - rParameter.Value >>= fNumber; - ::rtl::math::doubleToUStringBuffer( rStrBuffer, fNumber, rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max, '.', sal_True ); - } - else - { - sal_Int32 nValue = 0; - rParameter.Value >>= nValue; - - switch( rParameter.Type ) - { - case com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION : - { - rStrBuffer.append( "?f" + OUString::number( nValue ) ); - } - break; - - case com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT : - { - rStrBuffer.append( (sal_Unicode)'$' ); - rStrBuffer.append( OUString::number( nValue ) ); - } - break; - - case com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM : - rStrBuffer.append( GetXMLToken( XML_BOTTOM ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT : - rStrBuffer.append( GetXMLToken( XML_RIGHT ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP : - rStrBuffer.append( GetXMLToken( XML_TOP ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT : - rStrBuffer.append( GetXMLToken( XML_LEFT ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH : - rStrBuffer.append( GetXMLToken( XML_XSTRETCH ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH : - rStrBuffer.append( GetXMLToken( XML_YSTRETCH ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE : - rStrBuffer.append( GetXMLToken( XML_HASSTROKE ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL : - rStrBuffer.append( GetXMLToken( XML_HASFILL ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH : - rStrBuffer.append( GetXMLToken( XML_WIDTH ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT : - rStrBuffer.append( GetXMLToken( XML_HEIGHT ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH : - rStrBuffer.append( GetXMLToken( XML_LOGWIDTH ) ); break; - case com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT : - rStrBuffer.append( GetXMLToken( XML_LOGHEIGHT ) ); break; - default : - rStrBuffer.append( OUString::number( nValue ) ); - } - } -} - -void ImpExportEquations( SvXMLExport& rExport, const uno::Sequence< OUString >& rEquations ) -{ - sal_Int32 i; - for ( i = 0; i < rEquations.getLength(); i++ ) - { - OUString aStr(static_cast('f')); - aStr += OUString::number( i ); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME, aStr ); - - aStr = rEquations[ i ]; - sal_Int32 nIndex = 0; - do - { - nIndex = aStr.indexOf( (sal_Unicode)'?', nIndex ); - if ( nIndex != -1 ) - { - OUString aNew( aStr.copy( 0, nIndex + 1 ) ); - aNew += OUString(static_cast('f')); - aNew += aStr.copy( nIndex + 1, ( aStr.getLength() - nIndex ) - 1 ); - aStr = aNew; - nIndex++; - } - } while( nIndex != -1 ); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_FORMULA, aStr ); - SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_EQUATION, sal_True, sal_True ); - } -} - -void ImpExportHandles( SvXMLExport& rExport, const uno::Sequence< beans::PropertyValues >& rHandles ) -{ - sal_uInt32 i, j, nElements = rHandles.getLength(); - if ( nElements ) - { - OUString aStr; - OUStringBuffer aStrBuffer; - - for ( i = 0; i < nElements; i++ ) - { - sal_Bool bPosition = sal_False; - const uno::Sequence< beans::PropertyValue >& rPropSeq = rHandles[ i ]; - for ( j = 0; j < (sal_uInt32)rPropSeq.getLength(); j++ ) - { - const beans::PropertyValue& rPropVal = rPropSeq[ j ]; - switch( EASGet( rPropVal.Name ) ) - { - case EAS_Position : - { - com::sun::star::drawing::EnhancedCustomShapeParameterPair aPosition; - if ( rPropVal.Value >>= aPosition ) - { - ExportParameter( aStrBuffer, aPosition.First ); - ExportParameter( aStrBuffer, aPosition.Second ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POSITION, aStr ); - bPosition = sal_True; - } - } - break; - case EAS_MirroredX : - { - sal_Bool bMirroredX = sal_Bool(); - if ( rPropVal.Value >>= bMirroredX ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_HORIZONTAL, - bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_MirroredY : - { - sal_Bool bMirroredY = sal_Bool(); - if ( rPropVal.Value >>= bMirroredY ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_MIRROR_VERTICAL, - bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_Switched : - { - sal_Bool bSwitched = sal_Bool(); - if ( rPropVal.Value >>= bSwitched ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_SWITCHED, - bSwitched ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_Polar : - { - com::sun::star::drawing::EnhancedCustomShapeParameterPair aPolar; - if ( rPropVal.Value >>= aPolar ) - { - ExportParameter( aStrBuffer, aPolar.First ); - ExportParameter( aStrBuffer, aPolar.Second ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_POLAR, aStr ); - } - } - break; - case EAS_RadiusRangeMinimum : - { - com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMinimum; - if ( rPropVal.Value >>= aRadiusRangeMinimum ) - { - ExportParameter( aStrBuffer, aRadiusRangeMinimum ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MINIMUM, aStr ); - } - } - break; - case EAS_RadiusRangeMaximum : - { - com::sun::star::drawing::EnhancedCustomShapeParameter aRadiusRangeMaximum; - if ( rPropVal.Value >>= aRadiusRangeMaximum ) - { - ExportParameter( aStrBuffer, aRadiusRangeMaximum ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RADIUS_RANGE_MAXIMUM, aStr ); - } - } - break; - case EAS_RangeXMinimum : - { - com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMinimum; - if ( rPropVal.Value >>= aXRangeMinimum ) - { - ExportParameter( aStrBuffer, aXRangeMinimum ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MINIMUM, aStr ); - } - } - break; - case EAS_RangeXMaximum : - { - com::sun::star::drawing::EnhancedCustomShapeParameter aXRangeMaximum; - if ( rPropVal.Value >>= aXRangeMaximum ) - { - ExportParameter( aStrBuffer, aXRangeMaximum ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_X_MAXIMUM, aStr ); - } - } - break; - case EAS_RangeYMinimum : - { - com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMinimum; - if ( rPropVal.Value >>= aYRangeMinimum ) - { - ExportParameter( aStrBuffer, aYRangeMinimum ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MINIMUM, aStr ); - } - } - break; - case EAS_RangeYMaximum : - { - com::sun::star::drawing::EnhancedCustomShapeParameter aYRangeMaximum; - if ( rPropVal.Value >>= aYRangeMaximum ) - { - ExportParameter( aStrBuffer, aYRangeMaximum ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_HANDLE_RANGE_Y_MAXIMUM, aStr ); - } - } - break; - default: - break; - } - } - if ( bPosition ) - SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_HANDLE, sal_True, sal_True ); - else - rExport.ClearAttrList(); - } - } -} - -void ImpExportEnhancedPath( SvXMLExport& rExport, - const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rCoordinates, - const uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment >& rSegments, - bool bExtended = false ) -{ - - OUString aStr; - OUStringBuffer aStrBuffer; - bool bNeedExtended = false; - - sal_Int32 i, j, k, l; - - sal_Int32 nCoords = rCoordinates.getLength(); - sal_Int32 nSegments = rSegments.getLength(); - sal_Bool bSimpleSegments = nSegments == 0; - if ( bSimpleSegments ) - nSegments = 4; - for ( j = i = 0; j < nSegments; j++ ) - { - com::sun::star::drawing::EnhancedCustomShapeSegment aSegment; - if ( bSimpleSegments ) - { - // if there are not enough segments we will default them - switch( j ) - { - case 0 : - { - aSegment.Count = 1; - aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO; - } - break; - case 1 : - { - aSegment.Count = (sal_Int16)std::min( nCoords - 1, (sal_Int32)32767 ); - aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO; - } - break; - case 2 : - { - aSegment.Count = 1; - aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH; - } - break; - case 3 : - { - aSegment.Count = 1; - aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH; - } - break; - } - } - else - aSegment = rSegments[ j ]; - - if ( !aStrBuffer.isEmpty() ) - aStrBuffer.append( (sal_Unicode)' ' ); - - sal_Int32 nParameter = 0; - switch( aSegment.Command ) - { - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH : - aStrBuffer.append( (sal_Unicode)'Z' ); break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH : - aStrBuffer.append( (sal_Unicode)'N' ); break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL : - aStrBuffer.append( (sal_Unicode)'F' ); break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE : - aStrBuffer.append( (sal_Unicode)'S' ); break; - - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO : - aStrBuffer.append( (sal_Unicode)'M' ); nParameter = 1; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO : - aStrBuffer.append( (sal_Unicode)'L' ); nParameter = 1; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO : - aStrBuffer.append( (sal_Unicode)'C' ); nParameter = 3; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO : - aStrBuffer.append( (sal_Unicode)'T' ); nParameter = 3; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE : - aStrBuffer.append( (sal_Unicode)'U' ); nParameter = 3; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO : - aStrBuffer.append( (sal_Unicode)'A' ); nParameter = 4; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC : - aStrBuffer.append( (sal_Unicode)'B' ); nParameter = 4; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO : - aStrBuffer.append( (sal_Unicode)'W' ); nParameter = 4; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC : - aStrBuffer.append( (sal_Unicode)'V' ); nParameter = 4; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX : - aStrBuffer.append( (sal_Unicode)'X' ); nParameter = 1; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY : - aStrBuffer.append( (sal_Unicode)'Y' ); nParameter = 1; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO : - aStrBuffer.append( (sal_Unicode)'Q' ); nParameter = 2; break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCANGLETO : - if ( bExtended ) { - aStrBuffer.append( (sal_Unicode)'G' ); - nParameter = 2; - } else { - aStrBuffer.setLength( aStrBuffer.getLength() - 1); - bNeedExtended = true; - i += 2; - } - break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKEN : - if ( bExtended ) - aStrBuffer.append( (sal_Unicode)'H' ); - else - bNeedExtended = true; - break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::DARKENLESS : - if ( bExtended ) - aStrBuffer.append( (sal_Unicode)'I' ); - else - bNeedExtended = true; - break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTEN : - if ( bExtended ) - aStrBuffer.append( (sal_Unicode)'J' ); - else - bNeedExtended = true; - break; - case com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LIGHTENLESS : - if ( bExtended ) - aStrBuffer.append( (sal_Unicode)'K' ); - else - bNeedExtended = true; - break; - default : // ups, seems to be something wrong - { - aSegment.Count = 1; - aSegment.Command = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO; - } - break; - } - if ( nParameter ) - { - for ( k = 0; k < aSegment.Count; k++ ) - { - if ( ( i + nParameter ) <= nCoords ) - { - for ( l = 0; l < nParameter; l++ ) - { - ExportParameter( aStrBuffer, rCoordinates[ i ].First ); - ExportParameter( aStrBuffer, rCoordinates[ i++ ].Second ); - } - } - else - { - j = nSegments; // error -> exiting - break; - } - } - } - } - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( bExtended ? XML_NAMESPACE_DRAW_EXT : XML_NAMESPACE_DRAW, XML_ENHANCED_PATH, aStr ); - if ( !bExtended && bNeedExtended ) - ImpExportEnhancedPath( rExport, rCoordinates, rSegments, true ); -} - -void ImpExportEnhancedGeometry( SvXMLExport& rExport, const uno::Reference< beans::XPropertySet >& xPropSet ) -{ - sal_Bool bEquations = sal_False; - uno::Sequence< OUString > aEquations; - - sal_Bool bHandles = sal_False; - uno::Sequence< beans::PropertyValues > aHandles; - - sal_Bool bCoordinates = sal_False; - uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > aSegments; - uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aCoordinates; - - uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues; - - OUString aStr; - OUStringBuffer aStrBuffer; - SvXMLUnitConverter& rUnitConverter = rExport.GetMM100UnitConverter(); - - uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); - - // geometry - const OUString sCustomShapeGeometry( "CustomShapeGeometry" ); - if ( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sCustomShapeGeometry ) ) - { - uno::Any aGeoPropSet( xPropSet->getPropertyValue( sCustomShapeGeometry ) ); - uno::Sequence< beans::PropertyValue > aGeoPropSeq; - - if ( aGeoPropSet >>= aGeoPropSeq ) - { - const OUString sCustomShapeType( "non-primitive" ); - OUString aCustomShapeType( sCustomShapeType ); - - sal_Int32 j, nGeoPropCount = aGeoPropSeq.getLength(); - for ( j = 0; j < nGeoPropCount; j++ ) - { - const beans::PropertyValue& rGeoProp = aGeoPropSeq[ j ]; - switch( EASGet( rGeoProp.Name ) ) - { - case EAS_Type : - { - rGeoProp.Value >>= aCustomShapeType; - } - break; - case EAS_MirroredX : - { - sal_Bool bMirroredX = sal_Bool(); - if ( rGeoProp.Value >>= bMirroredX ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_HORIZONTAL, - bMirroredX ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_MirroredY : - { - sal_Bool bMirroredY = sal_Bool(); - if ( rGeoProp.Value >>= bMirroredY ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MIRROR_VERTICAL, - bMirroredY ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_ViewBox : - { - awt::Rectangle aRect; - if ( rGeoProp.Value >>= aRect ) - { - SdXMLImExViewBox aViewBox( aRect.X, aRect.Y, aRect.Width, aRect.Height ); - rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() ); - } - } - break; - case EAS_TextRotateAngle : - { - double fTextRotateAngle = 0; - if ( rGeoProp.Value >>= fTextRotateAngle ) - { - ::sax::Converter::convertDouble( - aStrBuffer, fTextRotateAngle ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_ROTATE_ANGLE, aStr ); - } - } - break; - case EAS_Extrusion : - { - uno::Sequence< beans::PropertyValue > aExtrusionPropSeq; - if ( rGeoProp.Value >>= aExtrusionPropSeq ) - { - sal_Int32 i, nCount = aExtrusionPropSeq.getLength(); - for ( i = 0; i < nCount; i++ ) - { - const beans::PropertyValue& rProp = aExtrusionPropSeq[ i ]; - switch( EASGet( rProp.Name ) ) - { - case EAS_Extrusion : - { - sal_Bool bExtrusionOn = sal_Bool(); - if ( rProp.Value >>= bExtrusionOn ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION, - bExtrusionOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_Brightness : - { - double fExtrusionBrightness = 0; - if ( rProp.Value >>= fExtrusionBrightness ) - { - ::sax::Converter::convertDouble( - aStrBuffer, - fExtrusionBrightness, - false, - util::MeasureUnit::PERCENT, - util::MeasureUnit::PERCENT); - aStrBuffer.append( (sal_Unicode)'%' ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_BRIGHTNESS, aStr ); - } - } - break; - case EAS_Depth : - { - com::sun::star::drawing::EnhancedCustomShapeParameterPair aDepthParaPair; - if ( rProp.Value >>= aDepthParaPair ) - { - double fDepth = 0; - if ( aDepthParaPair.First.Value >>= fDepth ) - { - rExport.GetMM100UnitConverter().convertDouble( aStrBuffer, fDepth, sal_True ); - ExportParameter( aStrBuffer, aDepthParaPair.Second ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DEPTH, aStr ); - } - } - } - break; - case EAS_Diffusion : - { - double fExtrusionDiffusion = 0; - if ( rProp.Value >>= fExtrusionDiffusion ) - { - ::sax::Converter::convertDouble( - aStrBuffer, - fExtrusionDiffusion, - false, - util::MeasureUnit::PERCENT, - util::MeasureUnit::PERCENT); - aStrBuffer.append( (sal_Unicode)'%' ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_DIFFUSION, aStr ); - } - } - break; - case EAS_NumberOfLineSegments : - { - sal_Int32 nExtrusionNumberOfLineSegments = 0; - if ( rProp.Value >>= nExtrusionNumberOfLineSegments ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_NUMBER_OF_LINE_SEGMENTS, OUString::number( nExtrusionNumberOfLineSegments ) ); - } - break; - case EAS_LightFace : - { - sal_Bool bExtrusionLightFace = sal_Bool(); - if ( rProp.Value >>= bExtrusionLightFace ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_LIGHT_FACE, - bExtrusionLightFace ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_FirstLightHarsh : - { - sal_Bool bExtrusionFirstLightHarsh = sal_Bool(); - if ( rProp.Value >>= bExtrusionFirstLightHarsh ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_HARSH, - bExtrusionFirstLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_SecondLightHarsh : - { - sal_Bool bExtrusionSecondLightHarsh = sal_Bool(); - if ( rProp.Value >>= bExtrusionSecondLightHarsh ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_HARSH, - bExtrusionSecondLightHarsh ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_FirstLightLevel : - { - double fExtrusionFirstLightLevel = 0; - if ( rProp.Value >>= fExtrusionFirstLightLevel ) - { - ::sax::Converter::convertDouble( - aStrBuffer, - fExtrusionFirstLightLevel, - false, - util::MeasureUnit::PERCENT, - util::MeasureUnit::PERCENT); - aStrBuffer.append( (sal_Unicode)'%' ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_LEVEL, aStr ); - } - } - break; - case EAS_SecondLightLevel : - { - double fExtrusionSecondLightLevel = 0; - if ( rProp.Value >>= fExtrusionSecondLightLevel ) - { - ::sax::Converter::convertDouble( - aStrBuffer, - fExtrusionSecondLightLevel, - false, - util::MeasureUnit::PERCENT, - util::MeasureUnit::PERCENT); - aStrBuffer.append( (sal_Unicode)'%' ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_LEVEL, aStr ); - } - } - break; - case EAS_FirstLightDirection : - { - drawing::Direction3D aExtrusionFirstLightDirection; - if ( rProp.Value >>= aExtrusionFirstLightDirection ) - { - ::basegfx::B3DVector aVec3D( aExtrusionFirstLightDirection.DirectionX, aExtrusionFirstLightDirection.DirectionY, - aExtrusionFirstLightDirection.DirectionZ ); - rUnitConverter.convertB3DVector( aStrBuffer, aVec3D ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_FIRST_LIGHT_DIRECTION, aStr ); - } - } - break; - case EAS_SecondLightDirection : - { - drawing::Direction3D aExtrusionSecondLightDirection; - if ( rProp.Value >>= aExtrusionSecondLightDirection ) - { - ::basegfx::B3DVector aVec3D( aExtrusionSecondLightDirection.DirectionX, aExtrusionSecondLightDirection.DirectionY, - aExtrusionSecondLightDirection.DirectionZ ); - rUnitConverter.convertB3DVector( aStrBuffer, aVec3D ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SECOND_LIGHT_DIRECTION, aStr ); - } - } - break; - case EAS_Metal : - { - sal_Bool bExtrusionMetal = sal_Bool(); - if ( rProp.Value >>= bExtrusionMetal ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_METAL, - bExtrusionMetal ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_ShadeMode : - { - // shadeMode - drawing::ShadeMode eShadeMode; - if( rProp.Value >>= eShadeMode ) - { - if( eShadeMode == drawing::ShadeMode_FLAT ) - aStr = GetXMLToken( XML_FLAT ); - else if( eShadeMode == drawing::ShadeMode_PHONG ) - aStr = GetXMLToken( XML_PHONG ); - else if( eShadeMode == drawing::ShadeMode_SMOOTH ) - aStr = GetXMLToken( XML_GOURAUD ); - else - aStr = GetXMLToken( XML_DRAFT ); - } - else - { - // ShadeMode enum not there, write default - aStr = GetXMLToken( XML_FLAT); - } - rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_SHADE_MODE, aStr ); - } - break; - case EAS_RotateAngle : - { - com::sun::star::drawing::EnhancedCustomShapeParameterPair aRotateAngleParaPair; - if ( rProp.Value >>= aRotateAngleParaPair ) - { - ExportParameter( aStrBuffer, aRotateAngleParaPair.First ); - ExportParameter( aStrBuffer, aRotateAngleParaPair.Second ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_ANGLE, aStr ); - } - } - break; - case EAS_RotationCenter : - { - drawing::Direction3D aExtrusionRotationCenter; - if ( rProp.Value >>= aExtrusionRotationCenter ) - { - ::basegfx::B3DVector aVec3D( aExtrusionRotationCenter.DirectionX, aExtrusionRotationCenter.DirectionY, - aExtrusionRotationCenter.DirectionZ ); - rUnitConverter.convertB3DVector( aStrBuffer, aVec3D ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ROTATION_CENTER, aStr ); - } - } - break; - case EAS_Shininess : - { - double fExtrusionShininess = 0; - if ( rProp.Value >>= fExtrusionShininess ) - { - ::sax::Converter::convertDouble( - aStrBuffer, - fExtrusionShininess, - false, - util::MeasureUnit::PERCENT, - util::MeasureUnit::PERCENT); - aStrBuffer.append( (sal_Unicode)'%' ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SHININESS, aStr ); - } - } - break; - case EAS_Skew : - { - com::sun::star::drawing::EnhancedCustomShapeParameterPair aSkewParaPair; - if ( rProp.Value >>= aSkewParaPair ) - { - ExportParameter( aStrBuffer, aSkewParaPair.First ); - ExportParameter( aStrBuffer, aSkewParaPair.Second ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SKEW, aStr ); - } - } - break; - case EAS_Specularity : - { - double fExtrusionSpecularity = 0; - if ( rProp.Value >>= fExtrusionSpecularity ) - { - ::sax::Converter::convertDouble( - aStrBuffer, - fExtrusionSpecularity, - false, - util::MeasureUnit::PERCENT, - util::MeasureUnit::PERCENT); - aStrBuffer.append( (sal_Unicode)'%' ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_SPECULARITY, aStr ); - } - } - break; - case EAS_ProjectionMode : - { - drawing::ProjectionMode eProjectionMode; - if ( rProp.Value >>= eProjectionMode ) - rExport.AddAttribute( XML_NAMESPACE_DR3D, XML_PROJECTION, - eProjectionMode == drawing::ProjectionMode_PARALLEL ? GetXMLToken( XML_PARALLEL ) : GetXMLToken( XML_PERSPECTIVE ) ); - } - break; - case EAS_ViewPoint : - { - drawing::Position3D aExtrusionViewPoint; - if ( rProp.Value >>= aExtrusionViewPoint ) - { - rUnitConverter.convertPosition3D( aStrBuffer, aExtrusionViewPoint ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_VIEWPOINT, aStr ); - } - } - break; - case EAS_Origin : - { - com::sun::star::drawing::EnhancedCustomShapeParameterPair aOriginParaPair; - if ( rProp.Value >>= aOriginParaPair ) - { - ExportParameter( aStrBuffer, aOriginParaPair.First ); - ExportParameter( aStrBuffer, aOriginParaPair.Second ); - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ORIGIN, aStr ); - } - } - break; - case EAS_Color : - { - sal_Bool bExtrusionColor = sal_Bool(); - if ( rProp.Value >>= bExtrusionColor ) - { - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_COLOR, - bExtrusionColor ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - } - break; - default: - break; - } - } - } - } - break; - case EAS_TextPath : - { - uno::Sequence< beans::PropertyValue > aTextPathPropSeq; - if ( rGeoProp.Value >>= aTextPathPropSeq ) - { - sal_Int32 i, nCount = aTextPathPropSeq.getLength(); - for ( i = 0; i < nCount; i++ ) - { - const beans::PropertyValue& rProp = aTextPathPropSeq[ i ]; - switch( EASGet( rProp.Name ) ) - { - case EAS_TextPath : - { - sal_Bool bTextPathOn = sal_Bool(); - if ( rProp.Value >>= bTextPathOn ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH, - bTextPathOn ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_TextPathMode : - { - com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode; - if ( rProp.Value >>= eTextPathMode ) - { - switch ( eTextPathMode ) - { - case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL: aStr = GetXMLToken( XML_NORMAL ); break; - case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH : aStr = GetXMLToken( XML_PATH ); break; - case com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE : aStr = GetXMLToken( XML_SHAPE ); break; - default: - break; - } - if ( !aStr.isEmpty() ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_MODE, aStr ); - } - } - break; - case EAS_ScaleX : - { - sal_Bool bScaleX = sal_Bool(); - if ( rProp.Value >>= bScaleX ) - { - aStr = bScaleX ? GetXMLToken( XML_SHAPE ) : GetXMLToken( XML_PATH ); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SCALE, aStr ); - } - } - break; - case EAS_SameLetterHeights : - { - sal_Bool bSameLetterHeights = sal_Bool(); - if ( rProp.Value >>= bSameLetterHeights ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_SAME_LETTER_HEIGHTS, - bSameLetterHeights ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - default: - break; - } - } - } - } - break; - case EAS_Path : - { - uno::Sequence< beans::PropertyValue > aPathPropSeq; - if ( rGeoProp.Value >>= aPathPropSeq ) - { - sal_Int32 i, nCount = aPathPropSeq.getLength(); - for ( i = 0; i < nCount; i++ ) - { - const beans::PropertyValue& rProp = aPathPropSeq[ i ]; - - switch( EASGet( rProp.Name ) ) - { - case EAS_SubViewSize: - { - uno::Sequence< awt::Size > aSubViewSizes; - rProp.Value >>= aSubViewSizes; - - for ( int nIdx = 0; nIdx < aSubViewSizes.getLength(); nIdx++ ) - { - if ( nIdx ) - aStrBuffer.append(' '); - ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Width ); - aStrBuffer.append(' '); - ::sax::Converter::convertNumber( aStrBuffer, aSubViewSizes[nIdx].Height ); - } - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW_EXT, XML_SUB_VIEW_SIZE, aStr ); - } - break; - case EAS_ExtrusionAllowed : - { - sal_Bool bExtrusionAllowed = sal_Bool(); - if ( rProp.Value >>= bExtrusionAllowed ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_EXTRUSION_ALLOWED, - bExtrusionAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_ConcentricGradientFillAllowed : - { - sal_Bool bConcentricGradientFillAllowed = sal_Bool(); - if ( rProp.Value >>= bConcentricGradientFillAllowed ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CONCENTRIC_GRADIENT_FILL_ALLOWED, - bConcentricGradientFillAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_TextPathAllowed : - { - sal_Bool bTextPathAllowed = sal_Bool(); - if ( rProp.Value >>= bTextPathAllowed ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_PATH_ALLOWED, - bTextPathAllowed ? GetXMLToken( XML_TRUE ) : GetXMLToken( XML_FALSE ) ); - } - break; - case EAS_GluePoints : - { - com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair> aGluePoints; - if ( rProp.Value >>= aGluePoints ) - { - sal_Int32 k, nElements = aGluePoints.getLength(); - if ( nElements ) - { - for( k = 0; k < nElements; k++ ) - { - ExportParameter( aStrBuffer, aGluePoints[ k ].First ); - ExportParameter( aStrBuffer, aGluePoints[ k ].Second ); - } - aStr = aStrBuffer.makeStringAndClear(); - } - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINTS, aStr ); - } - } - break; - case EAS_GluePointType : - { - sal_Int16 nGluePointType = sal_Int16(); - if ( rProp.Value >>= nGluePointType ) - { - switch ( nGluePointType ) - { - case com::sun::star::drawing::EnhancedCustomShapeGluePointType::NONE : aStr = GetXMLToken( XML_NONE ); break; - case com::sun::star::drawing::EnhancedCustomShapeGluePointType::SEGMENTS : aStr = GetXMLToken( XML_SEGMENTS ); break; - case com::sun::star::drawing::EnhancedCustomShapeGluePointType::RECT : aStr = GetXMLToken( XML_RECTANGLE ); break; - } - if ( !aStr.isEmpty() ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GLUE_POINT_TYPE, aStr ); - } - } - break; - case EAS_Coordinates : - { - bCoordinates = ( rProp.Value >>= aCoordinates ); - } - break; - case EAS_Segments : - { - rProp.Value >>= aSegments; - } - break; - case EAS_StretchX : - { - sal_Int32 nStretchPoint = 0; - if ( rProp.Value >>= nStretchPoint ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_X, OUString::number( nStretchPoint ) ); - } - break; - case EAS_StretchY : - { - sal_Int32 nStretchPoint = 0; - if ( rProp.Value >>= nStretchPoint ) - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_PATH_STRETCHPOINT_Y, OUString::number( nStretchPoint ) ); - } - break; - case EAS_TextFrames : - { - com::sun::star::uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aPathTextFrames; - if ( rProp.Value >>= aPathTextFrames ) - { - if ( (sal_uInt16)aPathTextFrames.getLength() ) - { - sal_uInt16 k, nElements = (sal_uInt16)aPathTextFrames.getLength(); - for ( k = 0; k < nElements; k++ ) - { - ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.First ); - ExportParameter( aStrBuffer, aPathTextFrames[ k ].TopLeft.Second ); - ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.First ); - ExportParameter( aStrBuffer, aPathTextFrames[ k ].BottomRight.Second ); - } - aStr = aStrBuffer.makeStringAndClear(); - } - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TEXT_AREAS, aStr ); - } - } - break; - default: - break; - } - } - } - } - break; - case EAS_Equations : - { - bEquations = ( rGeoProp.Value >>= aEquations ); - } - break; - case EAS_Handles : - { - bHandles = ( rGeoProp.Value >>= aHandles ); - } - break; - case EAS_AdjustmentValues : - { - rGeoProp.Value >>= aAdjustmentValues; - } - break; - default: - break; - } - } // for - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_TYPE, aCustomShapeType ); - - // adjustments - sal_Int32 nAdjustmentValues = aAdjustmentValues.getLength(); - if ( nAdjustmentValues ) - { - sal_Int32 i, nValue = 0; - for ( i = 0; i < nAdjustmentValues; i++ ) - { - if ( i ) - aStrBuffer.append( (sal_Unicode)' ' ); - - const com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue& rAdj = aAdjustmentValues[ i ]; - if ( rAdj.State == beans::PropertyState_DIRECT_VALUE ) - { - if ( rAdj.Value.getValueTypeClass() == uno::TypeClass_DOUBLE ) - { - double fValue = 0.0; - rAdj.Value >>= fValue; - ::sax::Converter::convertDouble(aStrBuffer, fValue); - } - else - { - rAdj.Value >>= nValue; - ::sax::Converter::convertNumber(aStrBuffer, nValue); - } - } - else - { - // this should not be, but better than setting nothing - ::sax::Converter::convertNumber( aStrBuffer, 0 ); - } - } - aStr = aStrBuffer.makeStringAndClear(); - rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_MODIFIERS, aStr ); - } - if ( bCoordinates ) - ImpExportEnhancedPath( rExport, aCoordinates, aSegments ); - } - } - SvXMLElementExport aOBJ( rExport, XML_NAMESPACE_DRAW, XML_ENHANCED_GEOMETRY, sal_True, sal_True ); - if ( bEquations ) - ImpExportEquations( rExport, aEquations ); - if ( bHandles ) - ImpExportHandles( rExport, aHandles ); -} - -void XMLShapeExport::ImpExportCustomShape( - const uno::Reference< drawing::XShape >& xShape, - XmlShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint ) -{ - const uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - if ( xPropSet.is() ) - { - OUString aStr; - uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); - - // Transformation - ImpExportNewTrans( xPropSet, nFeatures, pRefPoint ); - - if ( xPropSetInfo.is() ) - { - const OUString sCustomShapeEngine( "CustomShapeEngine" ); - if ( xPropSetInfo->hasPropertyByName( sCustomShapeEngine ) ) - { - uno::Any aEngine( xPropSet->getPropertyValue( sCustomShapeEngine ) ); - if ( ( aEngine >>= aStr ) && !aStr.isEmpty() ) - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ENGINE, aStr ); - } - const OUString sCustomShapeData( "CustomShapeData" ); - if ( xPropSetInfo->hasPropertyByName( sCustomShapeData ) ) - { - uno::Any aData( xPropSet->getPropertyValue( sCustomShapeData ) ); - if ( ( aData >>= aStr ) && !aStr.isEmpty() ) - mrExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DATA, aStr ); - } - } - sal_Bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); // #86116#/#92210# - SvXMLElementExport aOBJ( mrExport, XML_NAMESPACE_DRAW, XML_CUSTOM_SHAPE, bCreateNewline, sal_True ); - ImpExportDescription( xShape ); // #i68101# - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportText( xShape ); - ImpExportEnhancedGeometry( mrExport, xPropSet ); - } -} - -void XMLShapeExport::ImpExportTableShape( const uno::Reference< drawing::XShape >& xShape, XmlShapeType eShapeType, sal_Int32 nFeatures, com::sun::star::awt::Point* pRefPoint ) -{ - uno::Reference< beans::XPropertySet > xPropSet(xShape, uno::UNO_QUERY); - uno::Reference< container::XNamed > xNamed(xShape, uno::UNO_QUERY); - - DBG_ASSERT( xPropSet.is() && xNamed.is(), "xmloff::XMLShapeExport::ImpExportTableShape(), tabe shape is not implementing needed interfaces"); - if(xPropSet.is() && xNamed.is()) try - { - // Transformation - ImpExportNewTrans(xPropSet, nFeatures, pRefPoint); - - sal_Bool bIsEmptyPresObj = sal_False; - - // presentation settings - if(eShapeType == XmlShapeTypePresTableShape) - bIsEmptyPresObj = ImpExportPresentationAttributes( xPropSet, GetXMLToken(XML_PRESENTATION_TABLE) ); - - const bool bCreateNewline( (nFeatures & SEF_EXPORT_NO_WS) == 0 ); - const bool bExportEmbedded(0 != (mrExport.getExportFlags() & EXPORT_EMBEDDED)); - - SvXMLElementExport aElement( mrExport, XML_NAMESPACE_DRAW, XML_FRAME, bCreateNewline, sal_True ); - - // do not export in ODF 1.1 or older - if( mrExport.getDefaultVersion() >= SvtSaveOptions::ODFVER_012 ) - { - if( !bIsEmptyPresObj ) - { - uno::Reference< container::XNamed > xTemplate( xPropSet->getPropertyValue("TableTemplate"), uno::UNO_QUERY ); - if( xTemplate.is() ) - { - const OUString sTemplate( xTemplate->getName() ); - if( !sTemplate.isEmpty() ) - { - mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TEMPLATE_NAME, sTemplate ); - - for( const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; pEntry->msApiName; pEntry++ ) - { - try - { - sal_Bool bBool = sal_False; - const OUString sAPIPropertyName( OUString(pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US ) ); - - xPropSet->getPropertyValue( sAPIPropertyName ) >>= bBool; - if( bBool ) - mrExport.AddAttribute(pEntry->mnNameSpace, pEntry->meXMLName, XML_TRUE ); - } - catch( uno::Exception& ) - { - OSL_FAIL("XMLShapeExport::ImpExportTableShape(), exception caught!"); - } - } - } - } - - uno::Reference< table::XColumnRowRange > xRange( xPropSet->getPropertyValue( msModel ), uno::UNO_QUERY_THROW ); - GetShapeTableExport()->exportTable( xRange ); - } - } - - if( !bIsEmptyPresObj ) - { - uno::Reference< graphic::XGraphic > xGraphic( xPropSet->getPropertyValue("ReplacementGraphic"), uno::UNO_QUERY ); - if( xGraphic.is() ) try - { - Reference< uno::XComponentContext > xContext = GetExport().getComponentContext(); - - uno::Reference< embed::XStorage > xPictureStorage; - uno::Reference< embed::XStorage > xStorage; - uno::Reference< io::XStream > xPictureStream; - - OUString sPictureName; - if( bExportEmbedded ) - { - xPictureStream.set( xContext->getServiceManager()->createInstanceWithContext( "com.sun.star.comp.MemoryStream", xContext), UNO_QUERY_THROW ); - } - else - { - xStorage.set( GetExport().GetTargetStorage(), UNO_QUERY_THROW ); - - xPictureStorage.set( xStorage->openStorageElement( OUString( "Pictures" ), ::embed::ElementModes::READWRITE ), uno::UNO_QUERY_THROW ); - const OUString sPrefix( "TablePreview" ); - const OUString sSuffix( ".svm" ); - - sal_Int32 nIndex = 0; - do - { - sPictureName = sPrefix; - sPictureName += OUString::number( ++nIndex ); - sPictureName += sSuffix; - } - while( xPictureStorage->hasByName( sPictureName ) ); - - xPictureStream.set( xPictureStorage->openStreamElement( sPictureName, ::embed::ElementModes::READWRITE ), UNO_QUERY_THROW ); - } - - Reference< graphic::XGraphicProvider > xProvider( graphic::GraphicProvider::create(xContext) ); - Sequence< beans::PropertyValue > aArgs( 2 ); - aArgs[ 0 ].Name = OUString( "MimeType" ); - aArgs[ 0 ].Value <<= OUString( "image/x-vclgraphic" ); - aArgs[ 1 ].Name = OUString( "OutputStream" ); - aArgs[ 1 ].Value <<= xPictureStream->getOutputStream(); - xProvider->storeGraphic( xGraphic, aArgs ); - - if( xPictureStorage.is() ) - { - Reference< embed::XTransactedObject > xTrans( xPictureStorage, UNO_QUERY ); - if( xTrans.is() ) - xTrans->commit(); - } - - if( !bExportEmbedded ) - { - OUString sURL( "Pictures/" ); - sURL += sPictureName; - mrExport.AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sURL ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED ); - mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD ); - } - - SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_DRAW, XML_IMAGE, sal_False, sal_True ); - - if( bExportEmbedded ) - { - Reference< XSeekableInputStream > xSeekable( xPictureStream, UNO_QUERY_THROW ); - xSeekable->seek(0); - - XMLBase64Export aBase64Exp( GetExport() ); - aBase64Exp.exportOfficeBinaryDataElement( Reference < XInputStream >( xPictureStream, UNO_QUERY_THROW ) ); - } - } - catch( uno::Exception& ) - { - OSL_FAIL("xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!"); - } - } - - ImpExportEvents( xShape ); - ImpExportGluePoints( xShape ); - ImpExportDescription( xShape ); // #i68101# - } - catch( uno::Exception& ) - { - OSL_FAIL( "xmloff::XMLShapeExport::ImpExportTableShape(), exception caught!" ); - } -} - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit