1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 // MARKER(update_precomp.py): autogen include statement, do not remove 23 #include "precompiled_xmloff.hxx" 24 25 #include <tools/debug.hxx> 26 #include <com/sun/star/document/XEventsSupplier.hpp> 27 #include <com/sun/star/container/XNameReplace.hpp> 28 #include <com/sun/star/presentation/ClickAction.hpp> 29 #include <com/sun/star/drawing/FillStyle.hpp> 30 #include <com/sun/star/drawing/LineStyle.hpp> 31 #include "unointerfacetouniqueidentifiermapper.hxx" 32 #include <com/sun/star/drawing/XGluePointsSupplier.hpp> 33 #include <com/sun/star/container/XIdentifierAccess.hpp> 34 #include <com/sun/star/drawing/GluePoint2.hpp> 35 #include <com/sun/star/drawing/Alignment.hpp> 36 #include <com/sun/star/drawing/EscapeDirection.hpp> 37 #include <com/sun/star/media/ZoomLevel.hpp> 38 #include <com/sun/star/awt/Rectangle.hpp> 39 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> 40 #include <com/sun/star/container/XNameAccess.hpp> 41 #include <comphelper/extract.hxx> 42 #include "ximpshap.hxx" 43 #include <xmloff/XMLBase64ImportContext.hxx> 44 #include <xmloff/XMLShapeStyleContext.hxx> 45 #include <xmloff/xmluconv.hxx> 46 #include <com/sun/star/container/XNamed.hpp> 47 #include <com/sun/star/drawing/CircleKind.hpp> 48 #include <com/sun/star/beans/XPropertySet.hpp> 49 #include <com/sun/star/awt/XControlModel.hpp> 50 #include <com/sun/star/drawing/XControlShape.hpp> 51 #include <com/sun/star/drawing/PointSequenceSequence.hpp> 52 #include <com/sun/star/drawing/PointSequence.hpp> 53 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> 54 #include <com/sun/star/lang/XServiceInfo.hpp> 55 #include <com/sun/star/util/XCloneable.hpp> 56 #include <com/sun/star/beans/XMultiPropertyStates.hpp> 57 #include "xexptran.hxx" 58 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp> 59 #include <com/sun/star/beans/XPropertySetInfo.hpp> 60 #include <com/sun/star/drawing/ConnectorType.hpp> 61 #include <com/sun/star/drawing/HomogenMatrix3.hpp> 62 #include "PropertySetMerger.hxx" 63 #include <xmloff/families.hxx> 64 #include "ximpstyl.hxx" 65 #include"xmloff/xmlnmspe.hxx" 66 #include <xmloff/xmltoken.hxx> 67 #include "EnhancedCustomShapeToken.hxx" 68 #include "XMLReplacementImageContext.hxx" 69 #include "XMLImageMapContext.hxx" 70 #include "sdpropls.hxx" 71 #include "eventimp.hxx" 72 #include "descriptionimp.hxx" 73 #include "ximpcustomshape.hxx" 74 #include "XMLEmbeddedObjectImportContext.hxx" 75 #include "xmloff/xmlerror.hxx" 76 #include <basegfx/matrix/b2dhommatrix.hxx> 77 #include <tools/string.hxx> 78 #include <com/sun/star/drawing/XEnhancedCustomShapeDefaulter.hpp> 79 #include <com/sun/star/container/XChild.hpp> 80 #include <com/sun/star/text/XTextDocument.hpp> 81 #include <basegfx/vector/b2dvector.hxx> 82 #include <basegfx/point/b2dpoint.hxx> 83 #include <basegfx/polygon/b2dpolygon.hxx> 84 #include <basegfx/polygon/b2dpolygontools.hxx> 85 #include <basegfx/polygon/b2dpolypolygontools.hxx> 86 #include <basegfx/matrix/b2dhommatrixtools.hxx> 87 88 using ::rtl::OUString; 89 using ::rtl::OUStringBuffer; 90 91 using namespace ::com::sun::star; 92 using namespace ::com::sun::star::uno; 93 using namespace ::com::sun::star::drawing; 94 using namespace ::com::sun::star::style; 95 using namespace ::com::sun::star::container; 96 using namespace ::com::sun::star::document; 97 using namespace ::xmloff::token; 98 using namespace ::xmloff::EnhancedCustomShapeToken; 99 100 SvXMLEnumMapEntry aXML_GlueAlignment_EnumMap[] = 101 { 102 { XML_TOP_LEFT, drawing::Alignment_TOP_LEFT }, 103 { XML_TOP, drawing::Alignment_TOP }, 104 { XML_TOP_RIGHT, drawing::Alignment_TOP_RIGHT }, 105 { XML_LEFT, drawing::Alignment_LEFT }, 106 { XML_CENTER, drawing::Alignment_CENTER }, 107 { XML_RIGHT, drawing::Alignment_RIGHT }, 108 { XML_BOTTOM_LEFT, drawing::Alignment_BOTTOM_LEFT }, 109 { XML_BOTTOM, drawing::Alignment_BOTTOM }, 110 { XML_BOTTOM_RIGHT, drawing::Alignment_BOTTOM_RIGHT }, 111 { XML_TOKEN_INVALID, 0 } 112 }; 113 114 SvXMLEnumMapEntry aXML_GlueEscapeDirection_EnumMap[] = 115 { 116 { XML_AUTO, drawing::EscapeDirection_SMART }, 117 { XML_LEFT, drawing::EscapeDirection_LEFT }, 118 { XML_RIGHT, drawing::EscapeDirection_RIGHT }, 119 { XML_UP, drawing::EscapeDirection_UP }, 120 { XML_DOWN, drawing::EscapeDirection_DOWN }, 121 { XML_HORIZONTAL, drawing::EscapeDirection_HORIZONTAL }, 122 { XML_VERTICAL, drawing::EscapeDirection_VERTICAL }, 123 { XML_TOKEN_INVALID, 0 } 124 }; 125 126 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 127 128 static bool ImpIsEmptyURL( const ::rtl::OUString& rURL ) 129 { 130 if( rURL.getLength() == 0 ) 131 return true; 132 133 // #i13140# Also compare against 'toplevel' URLs. which also 134 // result in empty filename strings. 135 if( 0 == rURL.compareToAscii( "#./" ) ) 136 return true; 137 138 return false; 139 } 140 141 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 142 143 TYPEINIT1( SvXMLShapeContext, SvXMLImportContext ); 144 TYPEINIT1( SdXMLShapeContext, SvXMLShapeContext ); 145 146 SdXMLShapeContext::SdXMLShapeContext( 147 SvXMLImport& rImport, 148 sal_uInt16 nPrfx, 149 const OUString& rLocalName, 150 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 151 uno::Reference< drawing::XShapes >& rShapes, 152 sal_Bool bTemporaryShape) 153 : SvXMLShapeContext( rImport, nPrfx, rLocalName, bTemporaryShape ) 154 , mxShapes( rShapes ) 155 , mxAttrList(xAttrList) 156 , mbListContextPushed( false ) 157 , mnStyleFamily(XML_STYLE_FAMILY_SD_GRAPHICS_ID) 158 , mbIsPlaceholder(sal_False) 159 , mbClearDefaultAttributes( true ) 160 , mbIsUserTransformed(sal_False) 161 , mnZOrder(-1) 162 , maSize(1, 1) 163 , maPosition(0, 0) 164 , maUsedTransformation() 165 , mbVisible(true) 166 , mbPrintable(true) 167 { 168 } 169 170 ////////////////////////////////////////////////////////////////////////////// 171 172 SdXMLShapeContext::~SdXMLShapeContext() 173 { 174 } 175 176 ////////////////////////////////////////////////////////////////////////////// 177 178 SvXMLImportContext *SdXMLShapeContext::CreateChildContext( sal_uInt16 p_nPrefix, 179 const OUString& rLocalName, 180 const uno::Reference< xml::sax::XAttributeList>& xAttrList ) 181 { 182 SvXMLImportContext * pContext = NULL; 183 184 // #i68101# 185 if( p_nPrefix == XML_NAMESPACE_SVG && 186 (IsXMLToken( rLocalName, XML_TITLE ) || IsXMLToken( rLocalName, XML_DESC ) ) ) 187 { 188 pContext = new SdXMLDescriptionContext( GetImport(), p_nPrefix, rLocalName, xAttrList, mxShape ); 189 } 190 else if( p_nPrefix == XML_NAMESPACE_OFFICE && IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) ) 191 { 192 pContext = new SdXMLEventsContext( GetImport(), p_nPrefix, rLocalName, xAttrList, mxShape ); 193 } 194 else if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_GLUE_POINT ) ) 195 { 196 addGluePoint( xAttrList ); 197 } 198 else if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_THUMBNAIL ) ) 199 { 200 // search attributes for xlink:href 201 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; 202 for(sal_Int16 i=0; i < nAttrCount; i++) 203 { 204 OUString sAttrName = xAttrList->getNameByIndex( i ); 205 OUString aLocalName; 206 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName ); 207 208 if( nPrefix == XML_NAMESPACE_XLINK ) 209 { 210 if( IsXMLToken( aLocalName, XML_HREF ) ) 211 { 212 maThumbnailURL = xAttrList->getValueByIndex( i ); 213 break; 214 } 215 } 216 } 217 } 218 else 219 { 220 // create text cursor on demand 221 if( !mxCursor.is() ) 222 { 223 uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY ); 224 if( xText.is() ) 225 { 226 UniReference < XMLTextImportHelper > xTxtImport = 227 GetImport().GetTextImport(); 228 mxOldCursor = xTxtImport->GetCursor(); 229 mxCursor = xText->createTextCursor(); 230 if( mxCursor.is() ) 231 { 232 xTxtImport->SetCursor( mxCursor ); 233 } 234 235 // remember old list item and block (#91964#) and reset them 236 // for the text frame 237 xTxtImport->PushListContext(); 238 mbListContextPushed = true; 239 } 240 } 241 242 // if we have a text cursor, lets try to import some text 243 if( mxCursor.is() ) 244 { 245 pContext = GetImport().GetTextImport()->CreateTextChildContext( 246 GetImport(), p_nPrefix, rLocalName, xAttrList ); 247 } 248 } 249 250 // call parent for content 251 if(!pContext) 252 pContext = SvXMLImportContext::CreateChildContext( p_nPrefix, rLocalName, xAttrList ); 253 254 return pContext; 255 } 256 257 void SdXMLShapeContext::addGluePoint( const uno::Reference< xml::sax::XAttributeList>& xAttrList ) 258 { 259 // get the glue points container for this shape if its not already there 260 if( !mxGluePoints.is() ) 261 { 262 uno::Reference< drawing::XGluePointsSupplier > xSupplier( mxShape, uno::UNO_QUERY ); 263 if( !xSupplier.is() ) 264 return; 265 266 mxGluePoints = uno::Reference< container::XIdentifierContainer >::query( xSupplier->getGluePoints() ); 267 268 if( !mxGluePoints.is() ) 269 return; 270 } 271 272 drawing::GluePoint2 aGluePoint; 273 aGluePoint.IsUserDefined = sal_True; 274 aGluePoint.Position.X = 0; 275 aGluePoint.Position.Y = 0; 276 aGluePoint.Escape = drawing::EscapeDirection_SMART; 277 aGluePoint.PositionAlignment = drawing::Alignment_CENTER; 278 aGluePoint.IsRelative = sal_True; 279 280 sal_Int32 nId = -1; 281 282 // read attributes for the 3DScene 283 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; 284 for(sal_Int16 i=0; i < nAttrCount; i++) 285 { 286 OUString sAttrName = xAttrList->getNameByIndex( i ); 287 OUString aLocalName; 288 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName ); 289 const OUString sValue( xAttrList->getValueByIndex( i ) ); 290 291 if( nPrefix == XML_NAMESPACE_SVG ) 292 { 293 if( IsXMLToken( aLocalName, XML_X ) ) 294 { 295 GetImport().GetMM100UnitConverter().convertMeasure(aGluePoint.Position.X, sValue); 296 } 297 else if( IsXMLToken( aLocalName, XML_Y ) ) 298 { 299 GetImport().GetMM100UnitConverter().convertMeasure(aGluePoint.Position.Y, sValue); 300 } 301 } 302 else if( nPrefix == XML_NAMESPACE_DRAW ) 303 { 304 if( IsXMLToken( aLocalName, XML_ID ) ) 305 { 306 nId = sValue.toInt32(); 307 } 308 else if( IsXMLToken( aLocalName, XML_ALIGN ) ) 309 { 310 sal_uInt16 eKind; 311 if( SvXMLUnitConverter::convertEnum( eKind, sValue, aXML_GlueAlignment_EnumMap ) ) 312 { 313 aGluePoint.PositionAlignment = (drawing::Alignment)eKind; 314 aGluePoint.IsRelative = sal_False; 315 } 316 } 317 else if( IsXMLToken( aLocalName, XML_ESCAPE_DIRECTION ) ) 318 { 319 sal_uInt16 eKind; 320 if( SvXMLUnitConverter::convertEnum( eKind, sValue, aXML_GlueEscapeDirection_EnumMap ) ) 321 { 322 aGluePoint.Escape = (drawing::EscapeDirection)eKind; 323 } 324 } 325 } 326 } 327 328 if( nId != -1 ) 329 { 330 try 331 { 332 sal_Int32 nInternalId = mxGluePoints->insert( uno::makeAny( aGluePoint ) ); 333 GetImport().GetShapeImport()->addGluePointMapping( mxShape, nId, nInternalId ); 334 } 335 catch( uno::Exception& ) 336 { 337 DBG_ERROR( "exception during setting of glue points!"); 338 } 339 } 340 } 341 ////////////////////////////////////////////////////////////////////////////// 342 343 void SdXMLShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>&) 344 { 345 GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes ); 346 } 347 348 void SdXMLShapeContext::EndElement() 349 { 350 if(mxCursor.is()) 351 { 352 // delete addition newline 353 const OUString aEmpty; 354 mxCursor->gotoEnd( sal_False ); 355 mxCursor->goLeft( 1, sal_True ); 356 mxCursor->setString( aEmpty ); 357 358 // reset cursor 359 GetImport().GetTextImport()->ResetCursor(); 360 } 361 362 if(mxOldCursor.is()) 363 GetImport().GetTextImport()->SetCursor( mxOldCursor ); 364 365 // reinstall old list item (if necessary) #91964# 366 if (mbListContextPushed) { 367 GetImport().GetTextImport()->PopListContext(); 368 } 369 370 if( msHyperlink.getLength() != 0 ) try 371 { 372 const OUString sBookmark( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ); 373 374 Reference< XEventsSupplier > xEventsSupplier( mxShape, UNO_QUERY ); 375 if( xEventsSupplier.is() ) 376 { 377 const OUString sEventType( RTL_CONSTASCII_USTRINGPARAM( "EventType" ) ); 378 const OUString sClickAction( RTL_CONSTASCII_USTRINGPARAM( "ClickAction" ) ); 379 380 Reference< XNameReplace > xEvents( xEventsSupplier->getEvents(), UNO_QUERY_THROW ); 381 382 uno::Sequence< beans::PropertyValue > aProperties( 3 ); 383 aProperties[0].Name = sEventType; 384 aProperties[0].Handle = -1; 385 aProperties[0].Value <<= OUString( RTL_CONSTASCII_USTRINGPARAM("Presentation") ); 386 aProperties[0].State = beans::PropertyState_DIRECT_VALUE; 387 388 aProperties[1].Name = sClickAction; 389 aProperties[1].Handle = -1; 390 aProperties[1].Value <<= ::com::sun::star::presentation::ClickAction_DOCUMENT; 391 aProperties[1].State = beans::PropertyState_DIRECT_VALUE; 392 393 aProperties[2].Name = sBookmark; 394 aProperties[2].Handle = -1; 395 aProperties[2].Value <<= msHyperlink; 396 aProperties[2].State = beans::PropertyState_DIRECT_VALUE; 397 398 const OUString sAPIEventName( RTL_CONSTASCII_USTRINGPARAM( "OnClick" ) ); 399 xEvents->replaceByName( sAPIEventName, Any( aProperties ) ); 400 } 401 else 402 { 403 // in draw use the Bookmark property 404 Reference< beans::XPropertySet > xSet( mxShape, UNO_QUERY_THROW ); 405 xSet->setPropertyValue( sBookmark, Any( msHyperlink ) ); 406 xSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "OnClick" ) ), Any( ::com::sun::star::presentation::ClickAction_DOCUMENT ) ); 407 } 408 } 409 catch( Exception& ) 410 { 411 DBG_ERROR("xmloff::SdXMLShapeContext::EndElement(), exception caught while setting hyperlink!"); 412 } 413 414 if( mxLockable.is() ) 415 mxLockable->removeActionLock(); 416 } 417 418 ////////////////////////////////////////////////////////////////////////////// 419 420 void SdXMLShapeContext::AddShape(uno::Reference< drawing::XShape >& xShape) 421 { 422 if(xShape.is()) 423 { 424 // set shape local 425 mxShape = xShape; 426 427 if(maShapeName.getLength()) 428 { 429 uno::Reference< container::XNamed > xNamed( mxShape, uno::UNO_QUERY ); 430 if( xNamed.is() ) 431 xNamed->setName( maShapeName ); 432 } 433 434 UniReference< XMLShapeImportHelper > xImp( GetImport().GetShapeImport() ); 435 xImp->addShape( xShape, mxAttrList, mxShapes ); 436 437 if( mbClearDefaultAttributes ) 438 { 439 uno::Reference<beans::XMultiPropertyStates> xMultiPropertyStates(xShape, uno::UNO_QUERY ); 440 if (xMultiPropertyStates.is()) 441 xMultiPropertyStates->setAllPropertiesToDefault(); 442 } 443 444 if( !mbVisible || !mbPrintable ) try 445 { 446 uno::Reference< beans::XPropertySet > xSet( xShape, uno::UNO_QUERY_THROW ); 447 if( !mbVisible ) 448 xSet->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Visible" ) ), uno::Any( sal_False ) ); 449 450 if( !mbPrintable ) 451 xSet->setPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Printable" ) ), uno::Any( sal_False ) ); 452 } 453 catch( Exception& ) 454 { 455 DBG_ERROR( "SdXMLShapeContext::AddShape(), exception caught!" ); 456 } 457 458 // #107848# 459 if(!mbTemporaryShape && (!GetImport().HasTextImport() 460 || !GetImport().GetTextImport()->IsInsideDeleteContext())) 461 { 462 xImp->shapeWithZIndexAdded( xShape, mnZOrder ); 463 } 464 465 if( maShapeId.getLength() ) 466 { 467 const SdXMLGraphicObjectShapeContext* pGSC = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(this); 468 469 /* avoid registering when LateRegister is needed. E.g. MultiImage support where in-between multiple 470 xShapes with the same ID would be registered. Registration is done after deciding which image 471 to keep, see calls to solveMultipleImages */ 472 if(!pGSC || !pGSC->getLateAddToIdentifierMapper()) 473 { 474 uno::Reference< uno::XInterface > xRef( xShape, uno::UNO_QUERY ); 475 GetImport().getInterfaceToIdentifierMapper().registerReference( maShapeId, xRef ); 476 } 477 } 478 479 // #91065# count only if counting for shape import is enabled 480 if(GetImport().GetShapeImport()->IsHandleProgressBarEnabled()) 481 { 482 // #80365# increment progress bar at load once for each draw object 483 GetImport().GetProgressBarHelper()->Increment(); 484 } 485 } 486 487 mxLockable = uno::Reference< document::XActionLockable >::query( xShape ); 488 489 if( mxLockable.is() ) 490 mxLockable->addActionLock(); 491 492 } 493 494 ////////////////////////////////////////////////////////////////////////////// 495 496 void SdXMLShapeContext::AddShape(const char* pServiceName ) 497 { 498 uno::Reference< lang::XMultiServiceFactory > xServiceFact(GetImport().GetModel(), uno::UNO_QUERY); 499 if(xServiceFact.is()) 500 { 501 try 502 { 503 // --> OD 2006-02-22 #b6382898# 504 // Since fix for issue i33294 the Writer model doesn't support 505 // com.sun.star.drawing.OLE2Shape anymore. 506 // To handle Draw OLE objects it's decided to import these 507 // objects as com.sun.star.drawing.OLE2Shape and convert these 508 // objects after the import into com.sun.star.drawing.GraphicObjectShape. 509 uno::Reference< drawing::XShape > xShape; 510 if ( OUString::createFromAscii(pServiceName).compareToAscii( "com.sun.star.drawing.OLE2Shape" ) == 0 && 511 uno::Reference< text::XTextDocument >(GetImport().GetModel(), uno::UNO_QUERY).is() ) 512 { 513 xShape = uno::Reference< drawing::XShape >(xServiceFact->createInstance(OUString::createFromAscii("com.sun.star.drawing.temporaryForXMLImportOLE2Shape")), uno::UNO_QUERY); 514 } 515 else 516 { 517 xShape = uno::Reference< drawing::XShape >(xServiceFact->createInstance(OUString::createFromAscii(pServiceName)), uno::UNO_QUERY); 518 } 519 // <-- 520 if( xShape.is() ) 521 AddShape( xShape ); 522 } 523 catch( const uno::Exception& e ) 524 { 525 uno::Sequence<rtl::OUString> aSeq( 1 ); 526 aSeq[0] = OUString::createFromAscii(pServiceName); 527 GetImport().SetError( XMLERROR_FLAG_ERROR | XMLERROR_API, 528 aSeq, e.Message, NULL ); 529 } 530 } 531 } 532 533 ////////////////////////////////////////////////////////////////////////////// 534 535 void SdXMLShapeContext::SetTransformation() 536 { 537 if(mxShape.is()) 538 { 539 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 540 if(xPropSet.is()) 541 { 542 maUsedTransformation.identity(); 543 544 if(maSize.Width != 1 || maSize.Height != 1) 545 { 546 // take care there are no zeros used by error 547 if(0 == maSize.Width) 548 maSize.Width = 1; 549 if(0 == maSize.Height) 550 maSize.Height = 1; 551 552 // set global size. This should always be used. 553 maUsedTransformation.scale(maSize.Width, maSize.Height); 554 } 555 556 if(maPosition.X != 0 || maPosition.Y != 0) 557 { 558 // if global position is used, add it to transformation 559 maUsedTransformation.translate(maPosition.X, maPosition.Y); 560 } 561 562 if(mnTransform.NeedsAction()) 563 { 564 // transformation is used, apply to object. 565 // NOTICE: The transformation is applied AFTER evtl. used 566 // global positioning and scaling is used, so any shear or 567 // rotate used herein is applied around the (0,0) position 568 // of the PAGE object !!! 569 ::basegfx::B2DHomMatrix aMat; 570 mnTransform.GetFullTransform(aMat); 571 572 // now add to transformation 573 maUsedTransformation *= aMat; 574 } 575 576 // now set transformation for this object 577 uno::Any aAny; 578 drawing::HomogenMatrix3 aMatrix; 579 580 aMatrix.Line1.Column1 = maUsedTransformation.get(0, 0); 581 aMatrix.Line1.Column2 = maUsedTransformation.get(0, 1); 582 aMatrix.Line1.Column3 = maUsedTransformation.get(0, 2); 583 584 aMatrix.Line2.Column1 = maUsedTransformation.get(1, 0); 585 aMatrix.Line2.Column2 = maUsedTransformation.get(1, 1); 586 aMatrix.Line2.Column3 = maUsedTransformation.get(1, 2); 587 588 aMatrix.Line3.Column1 = maUsedTransformation.get(2, 0); 589 aMatrix.Line3.Column2 = maUsedTransformation.get(2, 1); 590 aMatrix.Line3.Column3 = maUsedTransformation.get(2, 2); 591 592 aAny <<= aMatrix; 593 594 xPropSet->setPropertyValue( 595 OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation")), aAny); 596 } 597 } 598 } 599 600 ////////////////////////////////////////////////////////////////////////////// 601 602 void SdXMLShapeContext::SetStyle( bool bSupportsStyle /* = true */) 603 { 604 try 605 { 606 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 607 if( !xPropSet.is() ) 608 return; 609 610 do 611 { 612 XMLPropStyleContext* pDocStyle = NULL; 613 614 // set style on shape 615 if(maDrawStyleName.getLength() == 0) 616 break; 617 618 const SvXMLStyleContext* pStyle = 0L; 619 sal_Bool bAutoStyle(sal_False); 620 621 if(GetImport().GetShapeImport()->GetAutoStylesContext()) 622 pStyle = GetImport().GetShapeImport()->GetAutoStylesContext()->FindStyleChildContext(mnStyleFamily, maDrawStyleName); 623 624 if(pStyle) 625 bAutoStyle = sal_True; 626 627 if(!pStyle && GetImport().GetShapeImport()->GetStylesContext()) 628 pStyle = GetImport().GetShapeImport()->GetStylesContext()->FindStyleChildContext(mnStyleFamily, maDrawStyleName); 629 630 OUString aStyleName = maDrawStyleName; 631 uno::Reference< style::XStyle > xStyle; 632 633 if( pStyle && pStyle->ISA(XMLShapeStyleContext) ) 634 { 635 pDocStyle = PTR_CAST( XMLShapeStyleContext, pStyle ); 636 637 if( pDocStyle->GetStyle().is() ) 638 { 639 xStyle = pDocStyle->GetStyle(); 640 } 641 else 642 { 643 aStyleName = pDocStyle->GetParentName(); 644 } 645 } 646 647 if( !xStyle.is() && aStyleName.getLength() ) 648 { 649 try 650 { 651 652 uno::Reference< style::XStyleFamiliesSupplier > xFamiliesSupplier( GetImport().GetModel(), uno::UNO_QUERY ); 653 654 if( xFamiliesSupplier.is() ) 655 { 656 uno::Reference< container::XNameAccess > xFamilies( xFamiliesSupplier->getStyleFamilies() ); 657 if( xFamilies.is() ) 658 { 659 660 uno::Reference< container::XNameAccess > xFamily; 661 662 if( XML_STYLE_FAMILY_SD_PRESENTATION_ID == mnStyleFamily ) 663 { 664 aStyleName = GetImport().GetStyleDisplayName( 665 XML_STYLE_FAMILY_SD_PRESENTATION_ID, 666 aStyleName ); 667 sal_Int32 nPos = aStyleName.lastIndexOf( sal_Unicode('-') ); 668 if( -1 != nPos ) 669 { 670 OUString aFamily( aStyleName.copy( 0, nPos ) ); 671 672 xFamilies->getByName( aFamily ) >>= xFamily; 673 aStyleName = aStyleName.copy( nPos + 1 ); 674 } 675 } 676 else 677 { 678 // get graphics familie 679 xFamilies->getByName( OUString( RTL_CONSTASCII_USTRINGPARAM( "graphics" ) ) ) >>= xFamily; 680 aStyleName = GetImport().GetStyleDisplayName( 681 XML_STYLE_FAMILY_SD_GRAPHICS_ID, 682 aStyleName ); 683 } 684 685 if( xFamily.is() ) 686 xFamily->getByName( aStyleName ) >>= xStyle; 687 } 688 } 689 } 690 catch( uno::Exception& ) 691 { 692 DBG_ERROR( "could not find style for shape!" ); 693 } 694 } 695 696 if( bSupportsStyle && xStyle.is() ) 697 { 698 try 699 { 700 // set style on object 701 uno::Any aAny; 702 aAny <<= xStyle; 703 xPropSet->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Style")), aAny); 704 } 705 catch( uno::Exception& ) 706 { 707 DBG_ERROR( "could not find style for shape!" ); 708 } 709 } 710 711 // if this is an auto style, set its properties 712 if(bAutoStyle && pDocStyle) 713 { 714 // set PropertySet on object 715 pDocStyle->FillPropertySet(xPropSet); 716 } 717 718 } while(0); 719 720 // try to set text auto style 721 do 722 { 723 // set style on shape 724 if( 0 == maTextStyleName.getLength() ) 725 break; 726 727 if( NULL == GetImport().GetShapeImport()->GetAutoStylesContext()) 728 break; 729 730 const SvXMLStyleContext* pTempStyle = GetImport().GetShapeImport()->GetAutoStylesContext()->FindStyleChildContext(XML_STYLE_FAMILY_TEXT_PARAGRAPH, maTextStyleName); 731 XMLPropStyleContext* pStyle = PTR_CAST( XMLPropStyleContext, pTempStyle ); // use temp var, PTR_CAST is a bad macro, FindStyleChildContext will be called twice 732 if( pStyle == NULL ) 733 break; 734 735 // set PropertySet on object 736 pStyle->FillPropertySet(xPropSet); 737 738 } while(0); 739 } 740 catch( uno::Exception& ) 741 { 742 } 743 } 744 745 void SdXMLShapeContext::SetLayer() 746 { 747 if( maLayerName.getLength() ) 748 { 749 try 750 { 751 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 752 if(xPropSet.is() ) 753 { 754 uno::Any aAny; 755 aAny <<= maLayerName; 756 757 xPropSet->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("LayerName")), aAny); 758 return; 759 } 760 } 761 catch( uno::Exception e ) 762 { 763 } 764 } 765 } 766 767 void SdXMLShapeContext::SetThumbnail() 768 { 769 if( 0 == maThumbnailURL.getLength() ) 770 return; 771 772 try 773 { 774 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 775 if( !xPropSet.is() ) 776 return; 777 778 const OUString sProperty(RTL_CONSTASCII_USTRINGPARAM("ThumbnailGraphicURL")); 779 780 uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); 781 if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName( sProperty ) ) 782 { 783 // load the thumbnail graphic and export it to a wmf stream so we can set 784 // it at the api 785 786 const OUString aInternalURL( GetImport().ResolveGraphicObjectURL( maThumbnailURL, sal_False ) ); 787 xPropSet->setPropertyValue( sProperty, uno::makeAny( aInternalURL ) ); 788 } 789 } 790 catch( uno::Exception e ) 791 { 792 } 793 } 794 795 // this is called from the parent group for each unparsed attribute in the attribute list 796 void SdXMLShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 797 { 798 bool bHaveXmlId( false ); 799 if( (XML_NAMESPACE_DRAW == nPrefix) || (XML_NAMESPACE_DRAW_EXT == nPrefix) ) 800 { 801 if( IsXMLToken( rLocalName, XML_ZINDEX ) ) 802 { 803 mnZOrder = rValue.toInt32(); 804 } 805 else if( IsXMLToken( rLocalName, XML_ID ) ) 806 { 807 if (!bHaveXmlId) { maShapeId = rValue; }; 808 } 809 else if( IsXMLToken( rLocalName, XML_NAME ) ) 810 { 811 maShapeName = rValue; 812 } 813 else if( IsXMLToken( rLocalName, XML_STYLE_NAME ) ) 814 { 815 maDrawStyleName = rValue; 816 } 817 else if( IsXMLToken( rLocalName, XML_TEXT_STYLE_NAME ) ) 818 { 819 maTextStyleName = rValue; 820 } 821 else if( IsXMLToken( rLocalName, XML_LAYER ) ) 822 { 823 maLayerName = rValue; 824 } 825 else if( IsXMLToken( rLocalName, XML_TRANSFORM ) ) 826 { 827 mnTransform.SetString(rValue, GetImport().GetMM100UnitConverter()); 828 } 829 else if( IsXMLToken( rLocalName, XML_DISPLAY ) ) 830 { 831 mbVisible = IsXMLToken( rValue, XML_ALWAYS ) || IsXMLToken( rValue, XML_SCREEN ); 832 mbPrintable = IsXMLToken( rValue, XML_ALWAYS ) || IsXMLToken( rValue, XML_PRINTER ); 833 } 834 } 835 else if( XML_NAMESPACE_PRESENTATION == nPrefix ) 836 { 837 if( IsXMLToken( rLocalName, XML_USER_TRANSFORMED ) ) 838 { 839 mbIsUserTransformed = IsXMLToken( rValue, XML_TRUE ); 840 } 841 else if( IsXMLToken( rLocalName, XML_PLACEHOLDER ) ) 842 { 843 mbIsPlaceholder = IsXMLToken( rValue, XML_TRUE ); 844 if( mbIsPlaceholder ) 845 mbClearDefaultAttributes = false; 846 } 847 else if( IsXMLToken( rLocalName, XML_CLASS ) ) 848 { 849 maPresentationClass = rValue; 850 } 851 else if( IsXMLToken( rLocalName, XML_STYLE_NAME ) ) 852 { 853 maDrawStyleName = rValue; 854 mnStyleFamily = XML_STYLE_FAMILY_SD_PRESENTATION_ID; 855 } 856 } 857 else if( XML_NAMESPACE_SVG == nPrefix ) 858 { 859 if( IsXMLToken( rLocalName, XML_X ) ) 860 { 861 GetImport().GetMM100UnitConverter().convertMeasure(maPosition.X, rValue); 862 } 863 else if( IsXMLToken( rLocalName, XML_Y ) ) 864 { 865 GetImport().GetMM100UnitConverter().convertMeasure(maPosition.Y, rValue); 866 } 867 else if( IsXMLToken( rLocalName, XML_WIDTH ) ) 868 { 869 GetImport().GetMM100UnitConverter().convertMeasure(maSize.Width, rValue); 870 if( maSize.Width > 0 ) 871 maSize.Width += 1; 872 else if( maSize.Width < 0 ) 873 maSize.Width -= 1; 874 } 875 else if( IsXMLToken( rLocalName, XML_HEIGHT ) ) 876 { 877 GetImport().GetMM100UnitConverter().convertMeasure(maSize.Height, rValue); 878 if( maSize.Height > 0 ) 879 maSize.Height += 1; 880 else if( maSize.Height < 0 ) 881 maSize.Height -= 1; 882 } 883 else if( IsXMLToken( rLocalName, XML_TRANSFORM ) ) 884 { 885 // because of #85127# take svg:transform into account and hanle like 886 // draw:transform for compatibility 887 mnTransform.SetString(rValue, GetImport().GetMM100UnitConverter()); 888 } 889 890 // #i68101# 891 else if( IsXMLToken( rLocalName, XML_TITLE ) ) 892 { 893 maShapeTitle = rValue; 894 } 895 else if( IsXMLToken( rLocalName, XML_DESC ) ) 896 { 897 maShapeDescription = rValue; 898 } 899 } 900 else if( (XML_NAMESPACE_NONE == nPrefix) || (XML_NAMESPACE_XML == nPrefix) ) 901 { 902 if( IsXMLToken( rLocalName, XML_ID ) ) 903 { 904 maShapeId = rValue; 905 bHaveXmlId = true; 906 } 907 } 908 } 909 910 sal_Bool SdXMLShapeContext::isPresentationShape() const 911 { 912 if( maPresentationClass.getLength() && (const_cast<SdXMLShapeContext*>(this))->GetImport().GetShapeImport()->IsPresentationShapesSupported() ) 913 { 914 if(XML_STYLE_FAMILY_SD_PRESENTATION_ID == mnStyleFamily) 915 { 916 return sal_True; 917 } 918 919 if( IsXMLToken( maPresentationClass, XML_HEADER ) || IsXMLToken( maPresentationClass, XML_FOOTER ) || 920 IsXMLToken( maPresentationClass, XML_PAGE_NUMBER ) || IsXMLToken( maPresentationClass, XML_DATE_TIME ) ) 921 { 922 return sal_True; 923 } 924 } 925 926 return sal_False; 927 } 928 929 void SdXMLShapeContext::onDemandRescueUsefulDataFromTemporary( const SvXMLImportContext& rCandidate ) 930 { 931 const SdXMLShapeContext* pCandidate = dynamic_cast< const SdXMLShapeContext* >(&rCandidate); 932 933 if(!mxGluePoints.is() && pCandidate) 934 { 935 // try to rescue GluePoints from rCandidate to local if we not yet have GluePoints by copying them 936 uno::Reference< drawing::XGluePointsSupplier > xSourceSupplier( pCandidate->getShape(), uno::UNO_QUERY ); 937 if( !xSourceSupplier.is() ) 938 return; 939 940 uno::Reference< container::XIdentifierAccess > xSourceGluePoints( xSourceSupplier->getGluePoints(), uno::UNO_QUERY ); 941 if( !xSourceGluePoints.is() ) 942 return; 943 944 uno::Sequence< sal_Int32 > aSourceIdSequence( xSourceGluePoints->getIdentifiers() ); 945 const sal_Int32 nSourceCount(aSourceIdSequence.getLength()); 946 UniReference< XMLShapeImportHelper > xSourceShapeImportHelper(const_cast< SdXMLShapeContext* >(pCandidate)->GetImport().GetShapeImport()); 947 948 if(nSourceCount) 949 { 950 // rCandidate has GluePoints; prepare the GluePoint container for the local shape 951 uno::Reference< drawing::XGluePointsSupplier > xSupplier( mxShape, uno::UNO_QUERY ); 952 if( !xSupplier.is() ) 953 return; 954 955 mxGluePoints = uno::Reference< container::XIdentifierContainer >::query( xSupplier->getGluePoints() ); 956 957 if( !mxGluePoints.is() ) 958 return; 959 960 drawing::GluePoint2 aSourceGluePoint; 961 962 for( sal_Int32 nSourceIndex(0); nSourceIndex < nSourceCount; nSourceIndex++ ) 963 { 964 const sal_Int32 nSourceIdentifier = aSourceIdSequence[nSourceIndex]; 965 966 // loop over GluePoints which are UserDefined (avoid the auto mapped ones) 967 if((xSourceGluePoints->getByIdentifier( nSourceIdentifier ) >>= aSourceGluePoint) 968 && aSourceGluePoint.IsUserDefined) 969 { 970 // get original mappingID back, this is the draw:id imported with a draw:glue-point 971 const sal_Int32 nDestinnationId = xSourceShapeImportHelper->findGluePointMapping( 972 pCandidate->getShape(), 973 nSourceIdentifier ); 974 975 if(-1 != nSourceIdentifier) 976 { 977 // if we got that we are able to add a copy of that GluePoint to the local 978 // context and xShape since we have all information that the source shape 979 // and context had at import time 980 try 981 { 982 const sal_Int32 nInternalId = mxGluePoints->insert( uno::makeAny( aSourceGluePoint ) ); 983 GetImport().GetShapeImport()->addGluePointMapping( mxShape, nDestinnationId, nInternalId ); 984 } 985 catch( uno::Exception& ) 986 { 987 DBG_ERROR( "exception during setting of glue points!"); 988 } 989 } 990 } 991 } 992 } 993 } 994 } 995 996 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 997 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 998 999 TYPEINIT1( SdXMLRectShapeContext, SdXMLShapeContext ); 1000 1001 SdXMLRectShapeContext::SdXMLRectShapeContext( 1002 SvXMLImport& rImport, 1003 sal_uInt16 nPrfx, 1004 const OUString& rLocalName, 1005 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1006 uno::Reference< drawing::XShapes >& rShapes, 1007 sal_Bool bTemporaryShape) 1008 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 1009 mnRadius( 0L ) 1010 { 1011 } 1012 1013 ////////////////////////////////////////////////////////////////////////////// 1014 1015 SdXMLRectShapeContext::~SdXMLRectShapeContext() 1016 { 1017 } 1018 1019 ////////////////////////////////////////////////////////////////////////////// 1020 1021 // this is called from the parent group for each unparsed attribute in the attribute list 1022 void SdXMLRectShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1023 { 1024 if( XML_NAMESPACE_DRAW == nPrefix ) 1025 { 1026 if( IsXMLToken( rLocalName, XML_CORNER_RADIUS ) ) 1027 { 1028 GetImport().GetMM100UnitConverter().convertMeasure(mnRadius, rValue); 1029 return; 1030 } 1031 } 1032 1033 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 1034 } 1035 1036 ////////////////////////////////////////////////////////////////////////////// 1037 1038 void SdXMLRectShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 1039 { 1040 // create rectangle shape 1041 AddShape("com.sun.star.drawing.RectangleShape"); 1042 if(mxShape.is()) 1043 { 1044 // Add, set Style and properties from base shape 1045 SetStyle(); 1046 SetLayer(); 1047 1048 // set pos, size, shear and rotate 1049 SetTransformation(); 1050 1051 if(mnRadius) 1052 { 1053 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 1054 if(xPropSet.is()) 1055 { 1056 try 1057 { 1058 xPropSet->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CornerRadius")), uno::makeAny( mnRadius ) ); 1059 } 1060 catch( uno::Exception& ) 1061 { 1062 DBG_ERROR( "exception during setting of corner radius!"); 1063 } 1064 } 1065 } 1066 SdXMLShapeContext::StartElement(xAttrList); 1067 } 1068 } 1069 1070 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1071 ////////////////////////////////////////3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1072 1073 TYPEINIT1( SdXMLLineShapeContext, SdXMLShapeContext ); 1074 1075 SdXMLLineShapeContext::SdXMLLineShapeContext( 1076 SvXMLImport& rImport, 1077 sal_uInt16 nPrfx, 1078 const OUString& rLocalName, 1079 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1080 uno::Reference< drawing::XShapes >& rShapes, 1081 sal_Bool bTemporaryShape) 1082 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 1083 mnX1( 0L ), 1084 mnY1( 0L ), 1085 mnX2( 1L ), 1086 mnY2( 1L ) 1087 { 1088 } 1089 1090 ////////////////////////////////////////////////////////////////////////////// 1091 1092 SdXMLLineShapeContext::~SdXMLLineShapeContext() 1093 { 1094 } 1095 1096 ////////////////////////////////////////////////////////////////////////////// 1097 1098 // this is called from the parent group for each unparsed attribute in the attribute list 1099 void SdXMLLineShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1100 { 1101 if( XML_NAMESPACE_SVG == nPrefix ) 1102 { 1103 if( IsXMLToken( rLocalName, XML_X1 ) ) 1104 { 1105 GetImport().GetMM100UnitConverter().convertMeasure(mnX1, rValue); 1106 return; 1107 } 1108 if( IsXMLToken( rLocalName, XML_Y1 ) ) 1109 { 1110 GetImport().GetMM100UnitConverter().convertMeasure(mnY1, rValue); 1111 return; 1112 } 1113 if( IsXMLToken( rLocalName, XML_X2 ) ) 1114 { 1115 GetImport().GetMM100UnitConverter().convertMeasure(mnX2, rValue); 1116 return; 1117 } 1118 if( IsXMLToken( rLocalName, XML_Y2 ) ) 1119 { 1120 GetImport().GetMM100UnitConverter().convertMeasure(mnY2, rValue); 1121 return; 1122 } 1123 } 1124 1125 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 1126 } 1127 1128 ////////////////////////////////////////////////////////////////////////////// 1129 1130 void SdXMLLineShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 1131 { 1132 // #85920# use SetTransformation() to handle import of simple lines. 1133 // This is necessary to kake into account all anchor positions and 1134 // other things. All shape imports use the same import schemata now. 1135 // create necessary shape (Line Shape) 1136 AddShape("com.sun.star.drawing.PolyLineShape"); 1137 1138 if(mxShape.is()) 1139 { 1140 // Add, set Style and properties from base shape 1141 SetStyle(); 1142 SetLayer(); 1143 1144 // get sizes and offsets 1145 awt::Point aTopLeft(mnX1, mnY1); 1146 awt::Point aBottomRight(mnX2, mnY2); 1147 1148 if(mnX1 > mnX2) 1149 { 1150 aTopLeft.X = mnX2; 1151 aBottomRight.X = mnX1; 1152 } 1153 1154 if(mnY1 > mnY2) 1155 { 1156 aTopLeft.Y = mnY2; 1157 aBottomRight.Y = mnY1; 1158 } 1159 1160 // set local parameters on shape 1161 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 1162 if(xPropSet.is()) 1163 { 1164 drawing::PointSequenceSequence aPolyPoly(1L); 1165 drawing::PointSequence* pOuterSequence = aPolyPoly.getArray(); 1166 pOuterSequence->realloc(2L); 1167 awt::Point* pInnerSequence = pOuterSequence->getArray(); 1168 uno::Any aAny; 1169 1170 *pInnerSequence = awt::Point( mnX1 - aTopLeft.X, mnY1 - aTopLeft.Y); 1171 pInnerSequence++; 1172 *pInnerSequence = awt::Point( mnX2 - aTopLeft.X, mnY2 - aTopLeft.Y); 1173 1174 aAny <<= aPolyPoly; 1175 xPropSet->setPropertyValue( 1176 OUString(RTL_CONSTASCII_USTRINGPARAM("Geometry")), aAny); 1177 } 1178 1179 // set sizes for transformation 1180 maSize.Width = aBottomRight.X - aTopLeft.X; 1181 maSize.Height = aBottomRight.Y - aTopLeft.Y; 1182 maPosition.X = aTopLeft.X; 1183 maPosition.Y = aTopLeft.Y; 1184 1185 // set pos, size, shear and rotate and get copy of matrix 1186 SetTransformation(); 1187 1188 SdXMLShapeContext::StartElement(xAttrList); 1189 } 1190 } 1191 1192 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1193 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1194 1195 TYPEINIT1( SdXMLEllipseShapeContext, SdXMLShapeContext ); 1196 1197 SdXMLEllipseShapeContext::SdXMLEllipseShapeContext( 1198 SvXMLImport& rImport, 1199 sal_uInt16 nPrfx, 1200 const OUString& rLocalName, 1201 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1202 uno::Reference< drawing::XShapes >& rShapes, 1203 sal_Bool bTemporaryShape) 1204 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 1205 mnCX( 0L ), 1206 mnCY( 0L ), 1207 mnRX( 1L ), 1208 mnRY( 1L ), 1209 meKind( drawing::CircleKind_FULL ), 1210 mnStartAngle( 0 ), 1211 mnEndAngle( 0 ) 1212 { 1213 } 1214 1215 ////////////////////////////////////////////////////////////////////////////// 1216 1217 SdXMLEllipseShapeContext::~SdXMLEllipseShapeContext() 1218 { 1219 } 1220 1221 ////////////////////////////////////////////////////////////////////////////// 1222 1223 // this is called from the parent group for each unparsed attribute in the attribute list 1224 void SdXMLEllipseShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1225 { 1226 if( XML_NAMESPACE_SVG == nPrefix ) 1227 { 1228 if( IsXMLToken( rLocalName, XML_RX ) ) 1229 { 1230 GetImport().GetMM100UnitConverter().convertMeasure(mnRX, rValue); 1231 return; 1232 } 1233 if( IsXMLToken( rLocalName, XML_RY ) ) 1234 { 1235 GetImport().GetMM100UnitConverter().convertMeasure(mnRY, rValue); 1236 return; 1237 } 1238 if( IsXMLToken( rLocalName, XML_CX ) ) 1239 { 1240 GetImport().GetMM100UnitConverter().convertMeasure(mnCX, rValue); 1241 return; 1242 } 1243 if( IsXMLToken( rLocalName, XML_CY ) ) 1244 { 1245 GetImport().GetMM100UnitConverter().convertMeasure(mnCY, rValue); 1246 return; 1247 } 1248 if( IsXMLToken( rLocalName, XML_R ) ) 1249 { 1250 // single radius, it's a circle and both radii are the same 1251 GetImport().GetMM100UnitConverter().convertMeasure(mnRX, rValue); 1252 mnRY = mnRX; 1253 return; 1254 } 1255 } 1256 else if( XML_NAMESPACE_DRAW == nPrefix ) 1257 { 1258 if( IsXMLToken( rLocalName, XML_KIND ) ) 1259 { 1260 sal_uInt16 eKind; 1261 if( SvXMLUnitConverter::convertEnum( eKind, rValue, aXML_CircleKind_EnumMap ) ) 1262 { 1263 meKind = eKind; 1264 } 1265 return; 1266 } 1267 if( IsXMLToken( rLocalName, XML_START_ANGLE ) ) 1268 { 1269 double dStartAngle; 1270 if( SvXMLUnitConverter::convertDouble( dStartAngle, rValue ) ) 1271 mnStartAngle = (sal_Int32)(dStartAngle * 100.0); 1272 return; 1273 } 1274 if( IsXMLToken( rLocalName, XML_END_ANGLE ) ) 1275 { 1276 double dEndAngle; 1277 if( SvXMLUnitConverter::convertDouble( dEndAngle, rValue ) ) 1278 mnEndAngle = (sal_Int32)(dEndAngle * 100.0); 1279 return; 1280 } 1281 } 1282 1283 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 1284 } 1285 1286 ////////////////////////////////////////////////////////////////////////////// 1287 1288 void SdXMLEllipseShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 1289 { 1290 // create rectangle shape 1291 AddShape("com.sun.star.drawing.EllipseShape"); 1292 if(mxShape.is()) 1293 { 1294 // Add, set Style and properties from base shape 1295 SetStyle(); 1296 SetLayer(); 1297 1298 if(mnCX != 0 || mnCY != 0 || mnRX != 1 || mnRY != 1) 1299 { 1300 // #121972# center/radius is used, put to pos and size 1301 maSize.Width = 2 * mnRX; 1302 maSize.Height = 2 * mnRY; 1303 maPosition.X = mnCX - mnRX; 1304 maPosition.Y = mnCY - mnRY; 1305 } 1306 1307 // set pos, size, shear and rotate 1308 SetTransformation(); 1309 1310 if( meKind != drawing::CircleKind_FULL ) 1311 { 1312 uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY ); 1313 if( xPropSet.is() ) 1314 { 1315 uno::Any aAny; 1316 aAny <<= (drawing::CircleKind)meKind; 1317 xPropSet->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CircleKind")), aAny ); 1318 1319 aAny <<= mnStartAngle; 1320 xPropSet->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CircleStartAngle")), aAny ); 1321 1322 aAny <<= mnEndAngle; 1323 xPropSet->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CircleEndAngle")), aAny ); 1324 } 1325 } 1326 1327 SdXMLShapeContext::StartElement(xAttrList); 1328 } 1329 } 1330 1331 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1332 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1333 1334 TYPEINIT1( SdXMLPolygonShapeContext, SdXMLShapeContext ); 1335 1336 SdXMLPolygonShapeContext::SdXMLPolygonShapeContext( 1337 SvXMLImport& rImport, 1338 sal_uInt16 nPrfx, 1339 const OUString& rLocalName, 1340 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1341 uno::Reference< drawing::XShapes >& rShapes, sal_Bool bClosed, sal_Bool bTemporaryShape) 1342 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 1343 mbClosed( bClosed ) 1344 { 1345 } 1346 1347 ////////////////////////////////////////////////////////////////////////////// 1348 1349 // this is called from the parent group for each unparsed attribute in the attribute list 1350 void SdXMLPolygonShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1351 { 1352 if( XML_NAMESPACE_SVG == nPrefix ) 1353 { 1354 if( IsXMLToken( rLocalName, XML_VIEWBOX ) ) 1355 { 1356 maViewBox = rValue; 1357 return; 1358 } 1359 } 1360 else if( XML_NAMESPACE_DRAW == nPrefix ) 1361 { 1362 if( IsXMLToken( rLocalName, XML_POINTS ) ) 1363 { 1364 maPoints = rValue; 1365 return; 1366 } 1367 } 1368 1369 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 1370 } 1371 1372 ////////////////////////////////////////////////////////////////////////////// 1373 1374 SdXMLPolygonShapeContext::~SdXMLPolygonShapeContext() 1375 { 1376 } 1377 1378 ////////////////////////////////////////////////////////////////////////////// 1379 1380 void SdXMLPolygonShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 1381 { 1382 // Add, set Style and properties from base shape 1383 if(mbClosed) 1384 AddShape("com.sun.star.drawing.PolyPolygonShape"); 1385 else 1386 AddShape("com.sun.star.drawing.PolyLineShape"); 1387 1388 if( mxShape.is() ) 1389 { 1390 SetStyle(); 1391 SetLayer(); 1392 1393 // set local parameters on shape 1394 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 1395 if(xPropSet.is()) 1396 { 1397 // set polygon 1398 if(maPoints.getLength() && maViewBox.getLength()) 1399 { 1400 const SdXMLImExViewBox aViewBox(maViewBox, GetImport().GetMM100UnitConverter()); 1401 basegfx::B2DVector aSize(aViewBox.GetWidth(), aViewBox.GetHeight()); 1402 1403 // Is this correct? It overrides ViewBox stuff; OTOH it makes no 1404 // sense to have the geometry content size different from object size 1405 if(maSize.Width != 0 && maSize.Height != 0) 1406 { 1407 aSize = basegfx::B2DVector(maSize.Width, maSize.Height); 1408 } 1409 1410 basegfx::B2DPolygon aPolygon; 1411 1412 if(basegfx::tools::importFromSvgPoints(aPolygon, maPoints)) 1413 { 1414 if(aPolygon.count()) 1415 { 1416 const basegfx::B2DRange aSourceRange( 1417 aViewBox.GetX(), aViewBox.GetY(), 1418 aViewBox.GetX() + aViewBox.GetWidth(), aViewBox.GetY() + aViewBox.GetHeight()); 1419 const basegfx::B2DRange aTargetRange( 1420 aViewBox.GetX(), aViewBox.GetY(), 1421 aViewBox.GetX() + aSize.getX(), aViewBox.GetY() + aSize.getY()); 1422 1423 if(!aSourceRange.equal(aTargetRange)) 1424 { 1425 aPolygon.transform( 1426 basegfx::tools::createSourceRangeTargetRangeTransform( 1427 aSourceRange, 1428 aTargetRange)); 1429 } 1430 1431 com::sun::star::drawing::PointSequenceSequence aPointSequenceSequence; 1432 uno::Any aAny; 1433 1434 basegfx::tools::B2DPolyPolygonToUnoPointSequenceSequence(basegfx::B2DPolyPolygon(aPolygon), aPointSequenceSequence); 1435 aAny <<= aPointSequenceSequence; 1436 xPropSet->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Geometry")), aAny); 1437 } 1438 } 1439 } 1440 } 1441 1442 // set pos, size, shear and rotate and get copy of matrix 1443 SetTransformation(); 1444 1445 SdXMLShapeContext::StartElement(xAttrList); 1446 } 1447 } 1448 1449 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1450 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1451 1452 TYPEINIT1( SdXMLPathShapeContext, SdXMLShapeContext ); 1453 1454 SdXMLPathShapeContext::SdXMLPathShapeContext( 1455 SvXMLImport& rImport, 1456 sal_uInt16 nPrfx, 1457 const OUString& rLocalName, 1458 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1459 uno::Reference< drawing::XShapes >& rShapes, 1460 sal_Bool bTemporaryShape) 1461 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 1462 mbClosed( sal_True ) 1463 { 1464 } 1465 1466 ////////////////////////////////////////////////////////////////////////////// 1467 1468 SdXMLPathShapeContext::~SdXMLPathShapeContext() 1469 { 1470 } 1471 1472 ////////////////////////////////////////////////////////////////////////////// 1473 1474 // this is called from the parent group for each unparsed attribute in the attribute list 1475 void SdXMLPathShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1476 { 1477 if( XML_NAMESPACE_SVG == nPrefix ) 1478 { 1479 if( IsXMLToken( rLocalName, XML_VIEWBOX ) ) 1480 { 1481 maViewBox = rValue; 1482 return; 1483 } 1484 else if( IsXMLToken( rLocalName, XML_D ) ) 1485 { 1486 maD = rValue; 1487 return; 1488 } 1489 } 1490 1491 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 1492 } 1493 1494 ////////////////////////////////////////////////////////////////////////////// 1495 1496 void SdXMLPathShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 1497 { 1498 // create polygon shape 1499 if(maD.getLength()) 1500 { 1501 const SdXMLImExViewBox aViewBox(maViewBox, GetImport().GetMM100UnitConverter()); 1502 basegfx::B2DVector aSize(aViewBox.GetWidth(), aViewBox.GetHeight()); 1503 1504 // Is this correct? It overrides ViewBox stuff; OTOH it makes no 1505 // sense to have the geometry content size different from object size 1506 if(maSize.Width != 0 && maSize.Height != 0) 1507 { 1508 aSize = basegfx::B2DVector(maSize.Width, maSize.Height); 1509 } 1510 1511 basegfx::B2DPolyPolygon aPolyPolygon; 1512 1513 if(basegfx::tools::importFromSvgD(aPolyPolygon, maD, true, 0)) 1514 { 1515 if(aPolyPolygon.count()) 1516 { 1517 const basegfx::B2DRange aSourceRange( 1518 aViewBox.GetX(), aViewBox.GetY(), 1519 aViewBox.GetX() + aViewBox.GetWidth(), aViewBox.GetY() + aViewBox.GetHeight()); 1520 const basegfx::B2DRange aTargetRange( 1521 aViewBox.GetX(), aViewBox.GetY(), 1522 aViewBox.GetX() + aSize.getX(), aViewBox.GetY() + aSize.getY()); 1523 1524 if(!aSourceRange.equal(aTargetRange)) 1525 { 1526 aPolyPolygon.transform( 1527 basegfx::tools::createSourceRangeTargetRangeTransform( 1528 aSourceRange, 1529 aTargetRange)); 1530 } 1531 1532 // create shape 1533 const char* pService; 1534 1535 if(aPolyPolygon.areControlPointsUsed()) 1536 { 1537 if(aPolyPolygon.isClosed()) 1538 { 1539 pService = "com.sun.star.drawing.ClosedBezierShape"; 1540 } 1541 else 1542 { 1543 pService = "com.sun.star.drawing.OpenBezierShape"; 1544 } 1545 } 1546 else 1547 { 1548 if(aPolyPolygon.isClosed()) 1549 { 1550 pService = "com.sun.star.drawing.PolyPolygonShape"; 1551 } 1552 else 1553 { 1554 pService = "com.sun.star.drawing.PolyLineShape"; 1555 } 1556 } 1557 1558 // Add, set Style and properties from base shape 1559 AddShape(pService); 1560 1561 // #89344# test for mxShape.is() and not for mxShapes.is() to support 1562 // shape import helper classes WITHOUT XShapes (member mxShapes). This 1563 // is used by the writer. 1564 if( mxShape.is() ) 1565 { 1566 SetStyle(); 1567 SetLayer(); 1568 1569 // set local parameters on shape 1570 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 1571 1572 if(xPropSet.is()) 1573 { 1574 uno::Any aAny; 1575 1576 // set polygon data 1577 if(aPolyPolygon.areControlPointsUsed()) 1578 { 1579 drawing::PolyPolygonBezierCoords aSourcePolyPolygon; 1580 1581 basegfx::tools::B2DPolyPolygonToUnoPolyPolygonBezierCoords( 1582 aPolyPolygon, 1583 aSourcePolyPolygon); 1584 aAny <<= aSourcePolyPolygon; 1585 } 1586 else 1587 { 1588 drawing::PointSequenceSequence aSourcePolyPolygon; 1589 1590 basegfx::tools::B2DPolyPolygonToUnoPointSequenceSequence( 1591 aPolyPolygon, 1592 aSourcePolyPolygon); 1593 aAny <<= aSourcePolyPolygon; 1594 } 1595 1596 xPropSet->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Geometry")), aAny); 1597 } 1598 1599 // set pos, size, shear and rotate 1600 SetTransformation(); 1601 1602 SdXMLShapeContext::StartElement(xAttrList); 1603 } 1604 } 1605 } 1606 } 1607 } 1608 1609 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1610 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1611 1612 TYPEINIT1( SdXMLTextBoxShapeContext, SdXMLShapeContext ); 1613 1614 SdXMLTextBoxShapeContext::SdXMLTextBoxShapeContext( 1615 SvXMLImport& rImport, 1616 sal_uInt16 nPrfx, 1617 const OUString& rLocalName, 1618 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1619 uno::Reference< drawing::XShapes >& rShapes, 1620 sal_Bool bTemporaryShape) 1621 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 1622 mnRadius(0) 1623 { 1624 } 1625 1626 ////////////////////////////////////////////////////////////////////////////// 1627 1628 SdXMLTextBoxShapeContext::~SdXMLTextBoxShapeContext() 1629 { 1630 } 1631 1632 ////////////////////////////////////////////////////////////////////////////// 1633 1634 // this is called from the parent group for each unparsed attribute in the attribute list 1635 void SdXMLTextBoxShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1636 { 1637 if( XML_NAMESPACE_DRAW == nPrefix ) 1638 { 1639 if( IsXMLToken( rLocalName, XML_CORNER_RADIUS ) ) 1640 { 1641 GetImport().GetMM100UnitConverter().convertMeasure(mnRadius, rValue); 1642 return; 1643 } 1644 } 1645 1646 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 1647 } 1648 1649 ////////////////////////////////////////////////////////////////////////////// 1650 1651 void SdXMLTextBoxShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>&) 1652 { 1653 // create textbox shape 1654 sal_Bool bIsPresShape = sal_False; 1655 bool bClearText = false; 1656 1657 const char *pService = NULL; 1658 1659 if( isPresentationShape() ) 1660 { 1661 // check if the current document supports presentation shapes 1662 if( GetImport().GetShapeImport()->IsPresentationShapesSupported() ) 1663 { 1664 if( IsXMLToken( maPresentationClass, XML_PRESENTATION_SUBTITLE )) 1665 { 1666 // XmlShapeTypePresSubtitleShape 1667 pService = "com.sun.star.presentation.SubtitleShape"; 1668 } 1669 else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_OUTLINE ) ) 1670 { 1671 // XmlShapeTypePresOutlinerShape 1672 pService = "com.sun.star.presentation.OutlinerShape"; 1673 } 1674 else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_NOTES ) ) 1675 { 1676 // XmlShapeTypePresNotesShape 1677 pService = "com.sun.star.presentation.NotesShape"; 1678 } 1679 else if( IsXMLToken( maPresentationClass, XML_HEADER ) ) 1680 { 1681 // XmlShapeTypePresHeaderShape 1682 pService = "com.sun.star.presentation.HeaderShape"; 1683 bClearText = true; 1684 } 1685 else if( IsXMLToken( maPresentationClass, XML_FOOTER ) ) 1686 { 1687 // XmlShapeTypePresFooterShape 1688 pService = "com.sun.star.presentation.FooterShape"; 1689 bClearText = true; 1690 } 1691 else if( IsXMLToken( maPresentationClass, XML_PAGE_NUMBER ) ) 1692 { 1693 // XmlShapeTypePresSlideNumberShape 1694 pService = "com.sun.star.presentation.SlideNumberShape"; 1695 bClearText = true; 1696 } 1697 else if( IsXMLToken( maPresentationClass, XML_DATE_TIME ) ) 1698 { 1699 // XmlShapeTypePresDateTimeShape 1700 pService = "com.sun.star.presentation.DateTimeShape"; 1701 bClearText = true; 1702 } 1703 else // IsXMLToken( maPresentationClass, XML_PRESENTATION_TITLE ) ) 1704 { 1705 // XmlShapeTypePresTitleTextShape 1706 pService = "com.sun.star.presentation.TitleTextShape"; 1707 } 1708 bIsPresShape = sal_True; 1709 } 1710 } 1711 1712 if( NULL == pService ) 1713 { 1714 // normal text shape 1715 pService = "com.sun.star.drawing.TextShape"; 1716 } 1717 1718 // Add, set Style and properties from base shape 1719 AddShape(pService); 1720 1721 if( mxShape.is() ) 1722 { 1723 SetStyle(); 1724 SetLayer(); 1725 1726 if(bIsPresShape) 1727 { 1728 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 1729 if(xProps.is()) 1730 { 1731 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() ); 1732 if( xPropsInfo.is() ) 1733 { 1734 if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ))) 1735 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ), ::cppu::bool2any( sal_False ) ); 1736 1737 if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ))) 1738 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ), ::cppu::bool2any( sal_False ) ); 1739 } 1740 } 1741 } 1742 1743 if( bClearText ) 1744 { 1745 uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY ); 1746 OUString aEmpty; 1747 xText->setString( aEmpty ); 1748 } 1749 1750 // set parameters on shape 1751 //A AW->CL: Eventually You need to strip scale and translate from the transformation 1752 //A to reach the same goal again. 1753 //A if(!bIsPresShape || mbIsUserTransformed) 1754 //A { 1755 //A // set pos and size on shape, this should remove binding 1756 //A // to pres object on masterpage 1757 //A SetSizeAndPosition(); 1758 //A } 1759 1760 // set pos, size, shear and rotate 1761 SetTransformation(); 1762 1763 if(mnRadius) 1764 { 1765 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 1766 if(xPropSet.is()) 1767 { 1768 try 1769 { 1770 xPropSet->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CornerRadius")), uno::makeAny( mnRadius ) ); 1771 } 1772 catch( uno::Exception& ) 1773 { 1774 DBG_ERROR( "exception during setting of corner radius!"); 1775 } 1776 } 1777 } 1778 1779 SdXMLShapeContext::StartElement(mxAttrList); 1780 } 1781 } 1782 1783 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1784 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1785 1786 TYPEINIT1( SdXMLControlShapeContext, SdXMLShapeContext ); 1787 1788 SdXMLControlShapeContext::SdXMLControlShapeContext( 1789 SvXMLImport& rImport, 1790 sal_uInt16 nPrfx, 1791 const OUString& rLocalName, 1792 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1793 uno::Reference< drawing::XShapes >& rShapes, 1794 sal_Bool bTemporaryShape) 1795 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ) 1796 { 1797 } 1798 1799 ////////////////////////////////////////////////////////////////////////////// 1800 1801 SdXMLControlShapeContext::~SdXMLControlShapeContext() 1802 { 1803 } 1804 1805 ////////////////////////////////////////////////////////////////////////////// 1806 1807 // this is called from the parent group for each unparsed attribute in the attribute list 1808 void SdXMLControlShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1809 { 1810 if( XML_NAMESPACE_DRAW == nPrefix ) 1811 { 1812 if( IsXMLToken( rLocalName, XML_CONTROL ) ) 1813 { 1814 maFormId = rValue; 1815 return; 1816 } 1817 } 1818 1819 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 1820 } 1821 1822 void SdXMLControlShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 1823 { 1824 // create Control shape 1825 // add, set style and properties from base shape 1826 AddShape("com.sun.star.drawing.ControlShape"); 1827 if( mxShape.is() ) 1828 { 1829 DBG_ASSERT( maFormId.getLength(), "draw:control without a form:id attribute!" ); 1830 if( maFormId.getLength() ) 1831 { 1832 #ifndef SVX_LIGHT 1833 if( GetImport().IsFormsSupported() ) 1834 { 1835 uno::Reference< awt::XControlModel > xControlModel( GetImport().GetFormImport()->lookupControl( maFormId ), uno::UNO_QUERY ); 1836 if( xControlModel.is() ) 1837 { 1838 uno::Reference< drawing::XControlShape > xControl( mxShape, uno::UNO_QUERY ); 1839 if( xControl.is() ) 1840 xControl->setControl( xControlModel ); 1841 1842 } 1843 } 1844 #endif // #ifndef SVX_LIGHT 1845 } 1846 1847 SetStyle(); 1848 SetLayer(); 1849 1850 // set pos, size, shear and rotate 1851 SetTransformation(); 1852 1853 SdXMLShapeContext::StartElement(xAttrList); 1854 } 1855 } 1856 1857 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1858 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 1859 1860 TYPEINIT1( SdXMLConnectorShapeContext, SdXMLShapeContext ); 1861 1862 SdXMLConnectorShapeContext::SdXMLConnectorShapeContext( 1863 SvXMLImport& rImport, 1864 sal_uInt16 nPrfx, 1865 const OUString& rLocalName, 1866 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 1867 uno::Reference< drawing::XShapes >& rShapes, 1868 sal_Bool bTemporaryShape) 1869 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 1870 maStart(0,0), 1871 maEnd(1,1), 1872 mnType( (sal_uInt16)drawing::ConnectorType_STANDARD ), 1873 mnStartGlueId(-1), 1874 mnEndGlueId(-1), 1875 mnDelta1(0), 1876 mnDelta2(0), 1877 mnDelta3(0) 1878 { 1879 } 1880 1881 ////////////////////////////////////////////////////////////////////////////// 1882 1883 SdXMLConnectorShapeContext::~SdXMLConnectorShapeContext() 1884 { 1885 } 1886 1887 ////////////////////////////////////////////////////////////////////////////// 1888 1889 // this is called from the parent group for each unparsed attribute in the attribute list 1890 void SdXMLConnectorShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 1891 { 1892 switch( nPrefix ) 1893 { 1894 case XML_NAMESPACE_DRAW: 1895 { 1896 if( IsXMLToken( rLocalName, XML_START_SHAPE ) ) 1897 { 1898 maStartShapeId = rValue; 1899 return; 1900 } 1901 if( IsXMLToken( rLocalName, XML_START_GLUE_POINT ) ) 1902 { 1903 mnStartGlueId = rValue.toInt32(); 1904 return; 1905 } 1906 if( IsXMLToken( rLocalName, XML_END_SHAPE ) ) 1907 { 1908 maEndShapeId = rValue; 1909 return; 1910 } 1911 if( IsXMLToken( rLocalName, XML_END_GLUE_POINT ) ) 1912 { 1913 mnEndGlueId = rValue.toInt32(); 1914 return; 1915 } 1916 if( IsXMLToken( rLocalName, XML_LINE_SKEW ) ) 1917 { 1918 SvXMLTokenEnumerator aTokenEnum( rValue ); 1919 OUString aToken; 1920 if( aTokenEnum.getNextToken( aToken ) ) 1921 { 1922 GetImport().GetMM100UnitConverter().convertMeasure(mnDelta1, aToken); 1923 if( aTokenEnum.getNextToken( aToken ) ) 1924 { 1925 GetImport().GetMM100UnitConverter().convertMeasure(mnDelta2, aToken); 1926 if( aTokenEnum.getNextToken( aToken ) ) 1927 { 1928 GetImport().GetMM100UnitConverter().convertMeasure(mnDelta3, aToken); 1929 } 1930 } 1931 } 1932 return; 1933 } 1934 if( IsXMLToken( rLocalName, XML_TYPE ) ) 1935 { 1936 SvXMLUnitConverter::convertEnum( mnType, rValue, aXML_ConnectionKind_EnumMap ); 1937 return; 1938 } 1939 // #121965# draw:transform may be used in ODF1.2, e.g. exports from MS seem to use these 1940 else if( IsXMLToken( rLocalName, XML_TRANSFORM ) ) 1941 { 1942 mnTransform.SetString(rValue, GetImport().GetMM100UnitConverter()); 1943 } 1944 } 1945 case XML_NAMESPACE_SVG: 1946 { 1947 if( IsXMLToken( rLocalName, XML_X1 ) ) 1948 { 1949 GetImport().GetMM100UnitConverter().convertMeasure(maStart.X, rValue); 1950 return; 1951 } 1952 if( IsXMLToken( rLocalName, XML_Y1 ) ) 1953 { 1954 GetImport().GetMM100UnitConverter().convertMeasure(maStart.Y, rValue); 1955 return; 1956 } 1957 if( IsXMLToken( rLocalName, XML_X2 ) ) 1958 { 1959 GetImport().GetMM100UnitConverter().convertMeasure(maEnd.X, rValue); 1960 return; 1961 } 1962 if( IsXMLToken( rLocalName, XML_Y2 ) ) 1963 { 1964 GetImport().GetMM100UnitConverter().convertMeasure(maEnd.Y, rValue); 1965 return; 1966 } 1967 if( IsXMLToken( rLocalName, XML_D ) ) 1968 { 1969 basegfx::B2DPolyPolygon aPolyPolygon; 1970 1971 if(basegfx::tools::importFromSvgD(aPolyPolygon, rValue, true, 0)) 1972 { 1973 if(aPolyPolygon.count()) 1974 { 1975 // set polygon data 1976 if(aPolyPolygon.areControlPointsUsed()) 1977 { 1978 drawing::PolyPolygonBezierCoords aSourcePolyPolygon; 1979 1980 basegfx::tools::B2DPolyPolygonToUnoPolyPolygonBezierCoords( 1981 aPolyPolygon, 1982 aSourcePolyPolygon); 1983 maPath <<= aSourcePolyPolygon; 1984 } 1985 else 1986 { 1987 drawing::PointSequenceSequence aSourcePolyPolygon; 1988 1989 basegfx::tools::B2DPolyPolygonToUnoPointSequenceSequence( 1990 aPolyPolygon, 1991 aSourcePolyPolygon); 1992 maPath <<= aSourcePolyPolygon; 1993 } 1994 } 1995 } 1996 } 1997 } 1998 } 1999 2000 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 2001 } 2002 2003 ////////////////////////////////////////////////////////////////////////////// 2004 2005 void SdXMLConnectorShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 2006 { 2007 // #107928# 2008 // For security reasons, do not add empty connectors. There may have been an error in EA2 2009 // that created empty, far set off connectors (e.g. 63 meters below top of document). This 2010 // is not guaranteed, but it's definitely safe to not add empty connectors. 2011 sal_Bool bDoAdd(sal_True); 2012 2013 if( 0 == maStartShapeId.getLength() 2014 && 0 == maEndShapeId.getLength() 2015 && maStart.X == maEnd.X 2016 && maStart.Y == maEnd.Y 2017 && 0 == mnDelta1 2018 && 0 == mnDelta2 2019 && 0 == mnDelta3 2020 ) 2021 { 2022 bDoAdd = sal_False; 2023 } 2024 2025 if(bDoAdd) 2026 { 2027 // create Connector shape 2028 // add, set style and properties from base shape 2029 AddShape("com.sun.star.drawing.ConnectorShape"); 2030 if(mxShape.is()) 2031 { 2032 // #121965# if draw:transform is used, apply directly to the start 2033 // and end positions before using these 2034 if(mnTransform.NeedsAction()) 2035 { 2036 // transformation is used, apply to object. 2037 ::basegfx::B2DHomMatrix aMat; 2038 mnTransform.GetFullTransform(aMat); 2039 2040 if(!aMat.isIdentity()) 2041 { 2042 basegfx::B2DPoint aStart(maStart.X, maStart.Y); 2043 basegfx::B2DPoint aEnd(maEnd.X, maEnd.Y); 2044 2045 aStart = aMat * aStart; 2046 aEnd = aMat * aEnd; 2047 2048 maStart.X = basegfx::fround(aStart.getX()); 2049 maStart.Y = basegfx::fround(aStart.getY()); 2050 maEnd.X = basegfx::fround(aEnd.getX()); 2051 maEnd.Y = basegfx::fround(aEnd.getY()); 2052 } 2053 } 2054 2055 // add connection ids 2056 if( maStartShapeId.getLength() ) 2057 GetImport().GetShapeImport()->addShapeConnection( mxShape, sal_True, maStartShapeId, mnStartGlueId ); 2058 if( maEndShapeId.getLength() ) 2059 GetImport().GetShapeImport()->addShapeConnection( mxShape, sal_False, maEndShapeId, mnEndGlueId ); 2060 2061 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 2062 if( xProps.is() ) 2063 { 2064 uno::Any aAny; 2065 aAny <<= maStart; 2066 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartPosition")), aAny); 2067 2068 aAny <<= maEnd; 2069 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndPosition")), aAny ); 2070 2071 aAny <<= (drawing::ConnectorType)mnType; 2072 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeKind")), aAny ); 2073 2074 aAny <<= mnDelta1; 2075 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeLine1Delta")), aAny ); 2076 2077 aAny <<= mnDelta2; 2078 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeLine2Delta")), aAny ); 2079 2080 aAny <<= mnDelta3; 2081 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EdgeLine3Delta")), aAny ); 2082 } 2083 SetStyle(); 2084 SetLayer(); 2085 2086 if ( maPath.hasValue() ) 2087 { 2088 // --> OD #i115492# 2089 // Ignore svg:d attribute for text documents created by OpenOffice.org 2090 // versions before OOo 3.3, because these OOo versions are storing 2091 // svg:d values not using the correct unit. 2092 bool bApplySVGD( true ); 2093 if ( uno::Reference< text::XTextDocument >(GetImport().GetModel(), uno::UNO_QUERY).is() ) 2094 { 2095 sal_Int32 nUPD( 0 ); 2096 sal_Int32 nBuild( 0 ); 2097 const bool bBuildIdFound = GetImport().getBuildIds( nUPD, nBuild ); 2098 if ( GetImport().IsTextDocInOOoFileFormat() || 2099 ( bBuildIdFound && 2100 ( ( nUPD == 641 ) || ( nUPD == 645 ) || // prior OOo 2.0 2101 ( nUPD == 680 ) || // OOo 2.x 2102 ( nUPD == 300 ) || // OOo 3.0 - OOo 3.0.1 2103 ( nUPD == 310 ) || // OOo 3.1 - OOo 3.1.1 2104 ( nUPD == 320 ) ) ) ) // OOo 3.2 - OOo 3.2.1 2105 { 2106 bApplySVGD = false; 2107 } 2108 } 2109 2110 if ( bApplySVGD ) 2111 { 2112 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("PolyPolygonBezier") ), maPath ); 2113 } 2114 // <-- 2115 } 2116 2117 SdXMLShapeContext::StartElement(xAttrList); 2118 } 2119 } 2120 } 2121 2122 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2123 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2124 2125 TYPEINIT1( SdXMLMeasureShapeContext, SdXMLShapeContext ); 2126 2127 SdXMLMeasureShapeContext::SdXMLMeasureShapeContext( 2128 SvXMLImport& rImport, 2129 sal_uInt16 nPrfx, 2130 const OUString& rLocalName, 2131 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 2132 uno::Reference< drawing::XShapes >& rShapes, 2133 sal_Bool bTemporaryShape) 2134 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 2135 maStart(0,0), 2136 maEnd(1,1) 2137 { 2138 } 2139 2140 ////////////////////////////////////////////////////////////////////////////// 2141 2142 SdXMLMeasureShapeContext::~SdXMLMeasureShapeContext() 2143 { 2144 } 2145 2146 // this is called from the parent group for each unparsed attribute in the attribute list 2147 void SdXMLMeasureShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 2148 { 2149 switch( nPrefix ) 2150 { 2151 case XML_NAMESPACE_SVG: 2152 { 2153 if( IsXMLToken( rLocalName, XML_X1 ) ) 2154 { 2155 GetImport().GetMM100UnitConverter().convertMeasure(maStart.X, rValue); 2156 return; 2157 } 2158 if( IsXMLToken( rLocalName, XML_Y1 ) ) 2159 { 2160 GetImport().GetMM100UnitConverter().convertMeasure(maStart.Y, rValue); 2161 return; 2162 } 2163 if( IsXMLToken( rLocalName, XML_X2 ) ) 2164 { 2165 GetImport().GetMM100UnitConverter().convertMeasure(maEnd.X, rValue); 2166 return; 2167 } 2168 if( IsXMLToken( rLocalName, XML_Y2 ) ) 2169 { 2170 GetImport().GetMM100UnitConverter().convertMeasure(maEnd.Y, rValue); 2171 return; 2172 } 2173 } 2174 } 2175 2176 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 2177 } 2178 2179 ////////////////////////////////////////////////////////////////////////////// 2180 2181 void SdXMLMeasureShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 2182 { 2183 // create Measure shape 2184 // add, set style and properties from base shape 2185 AddShape("com.sun.star.drawing.MeasureShape"); 2186 if(mxShape.is()) 2187 { 2188 SetStyle(); 2189 SetLayer(); 2190 2191 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 2192 if( xProps.is() ) 2193 { 2194 uno::Any aAny; 2195 aAny <<= maStart; 2196 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("StartPosition")), aAny); 2197 2198 aAny <<= maEnd; 2199 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("EndPosition")), aAny ); 2200 } 2201 2202 // delete pre created fields 2203 uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY ); 2204 if( xText.is() ) 2205 { 2206 const OUString aEmpty( RTL_CONSTASCII_USTRINGPARAM( " " ) ); 2207 xText->setString( aEmpty ); 2208 } 2209 2210 SdXMLShapeContext::StartElement(xAttrList); 2211 } 2212 } 2213 2214 void SdXMLMeasureShapeContext::EndElement() 2215 { 2216 do 2217 { 2218 // delete pre created fields 2219 uno::Reference< text::XText > xText( mxShape, uno::UNO_QUERY ); 2220 if( !xText.is() ) 2221 break; 2222 2223 uno::Reference< text::XTextCursor > xCursor( xText->createTextCursor() ); 2224 if( !xCursor.is() ) 2225 break; 2226 2227 const OUString aEmpty; 2228 xCursor->collapseToStart(); 2229 xCursor->goRight( 1, sal_True ); 2230 xCursor->setString( aEmpty ); 2231 } 2232 while(0); 2233 2234 SdXMLShapeContext::EndElement(); 2235 } 2236 2237 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2238 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2239 2240 TYPEINIT1( SdXMLPageShapeContext, SdXMLShapeContext ); 2241 2242 SdXMLPageShapeContext::SdXMLPageShapeContext( 2243 SvXMLImport& rImport, 2244 sal_uInt16 nPrfx, 2245 const OUString& rLocalName, 2246 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 2247 uno::Reference< drawing::XShapes >& rShapes, 2248 sal_Bool bTemporaryShape) 2249 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), mnPageNumber(0) 2250 { 2251 mbClearDefaultAttributes = false; 2252 } 2253 2254 ////////////////////////////////////////////////////////////////////////////// 2255 2256 SdXMLPageShapeContext::~SdXMLPageShapeContext() 2257 { 2258 } 2259 2260 ////////////////////////////////////////////////////////////////////////////// 2261 2262 // this is called from the parent group for each unparsed attribute in the attribute list 2263 void SdXMLPageShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 2264 { 2265 if( XML_NAMESPACE_DRAW == nPrefix ) 2266 { 2267 if( IsXMLToken( rLocalName, XML_PAGE_NUMBER ) ) 2268 { 2269 mnPageNumber = rValue.toInt32(); 2270 return; 2271 } 2272 } 2273 2274 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 2275 } 2276 2277 ////////////////////////////////////////////////////////////////////////////// 2278 2279 void SdXMLPageShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 2280 { 2281 // create Page shape 2282 // add, set style and properties from base shape 2283 2284 // #86163# take into account which type of PageShape needs to 2285 // be constructed. It's an pres shape if presentation:XML_CLASS == XML_PRESENTATION_PAGE. 2286 sal_Bool bIsPresentation = maPresentationClass.getLength() && 2287 GetImport().GetShapeImport()->IsPresentationShapesSupported(); 2288 2289 uno::Reference< lang::XServiceInfo > xInfo( mxShapes, uno::UNO_QUERY ); 2290 const sal_Bool bIsOnHandoutPage = xInfo.is() && xInfo->supportsService( OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.HandoutMasterPage")) ); 2291 2292 if( bIsOnHandoutPage ) 2293 { 2294 AddShape("com.sun.star.presentation.HandoutShape"); 2295 } 2296 else 2297 { 2298 if(bIsPresentation && !IsXMLToken( maPresentationClass, XML_PRESENTATION_PAGE ) ) 2299 { 2300 bIsPresentation = sal_False; 2301 } 2302 2303 if(bIsPresentation) 2304 { 2305 AddShape("com.sun.star.presentation.PageShape"); 2306 } 2307 else 2308 { 2309 AddShape("com.sun.star.drawing.PageShape"); 2310 } 2311 } 2312 2313 if(mxShape.is()) 2314 { 2315 SetStyle(); 2316 SetLayer(); 2317 2318 // set pos, size, shear and rotate 2319 SetTransformation(); 2320 2321 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 2322 if(xPropSet.is()) 2323 { 2324 uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() ); 2325 const OUString aPageNumberStr(RTL_CONSTASCII_USTRINGPARAM("PageNumber")); 2326 if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(aPageNumberStr)) 2327 xPropSet->setPropertyValue(aPageNumberStr, uno::makeAny( mnPageNumber )); 2328 } 2329 2330 SdXMLShapeContext::StartElement(xAttrList); 2331 } 2332 } 2333 2334 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2335 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2336 2337 TYPEINIT1( SdXMLCaptionShapeContext, SdXMLShapeContext ); 2338 2339 SdXMLCaptionShapeContext::SdXMLCaptionShapeContext( 2340 SvXMLImport& rImport, 2341 sal_uInt16 nPrfx, 2342 const OUString& rLocalName, 2343 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 2344 uno::Reference< drawing::XShapes >& rShapes, 2345 sal_Bool bTemporaryShape) 2346 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 2347 // #86616# for correct edge rounding import mnRadius needs to be initialized 2348 mnRadius( 0L ) 2349 { 2350 } 2351 2352 ////////////////////////////////////////////////////////////////////////////// 2353 2354 SdXMLCaptionShapeContext::~SdXMLCaptionShapeContext() 2355 { 2356 } 2357 2358 ////////////////////////////////////////////////////////////////////////////// 2359 2360 void SdXMLCaptionShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 2361 { 2362 // create Caption shape 2363 // add, set style and properties from base shape 2364 AddShape("com.sun.star.drawing.CaptionShape"); 2365 if( mxShape.is() ) 2366 { 2367 SetStyle(); 2368 SetLayer(); 2369 2370 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 2371 2372 // SJ: If AutoGrowWidthItem is set, SetTransformation will lead to the wrong SnapRect 2373 // because NbcAdjustTextFrameWidthAndHeight() is called (text is set later and center alignment 2374 // is the default setting, so the top left reference point that is used by the caption point is 2375 // no longer correct) There are two ways to solve this problem, temporarily disabling the 2376 // autogrowwith as we are doing here or to apply the CaptionPoint after setting text 2377 sal_Bool bIsAutoGrowWidth = sal_False; 2378 if ( xProps.is() ) 2379 { 2380 uno::Any aAny( xProps->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("TextAutoGrowWidth") ) ) ); 2381 aAny >>= bIsAutoGrowWidth; 2382 2383 if ( bIsAutoGrowWidth ) 2384 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("TextAutoGrowWidth")), uno::makeAny( sal_False ) ); 2385 } 2386 2387 // set pos, size, shear and rotate 2388 SetTransformation(); 2389 if( xProps.is() ) 2390 xProps->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CaptionPoint")), uno::makeAny( maCaptionPoint ) ); 2391 2392 if ( bIsAutoGrowWidth ) 2393 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("TextAutoGrowWidth")), uno::makeAny( sal_True ) ); 2394 2395 if(mnRadius) 2396 { 2397 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 2398 if(xPropSet.is()) 2399 { 2400 try 2401 { 2402 xPropSet->setPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("CornerRadius")), uno::makeAny( mnRadius ) ); 2403 } 2404 catch( uno::Exception& ) 2405 { 2406 DBG_ERROR( "exception during setting of corner radius!"); 2407 } 2408 } 2409 } 2410 2411 SdXMLShapeContext::StartElement(xAttrList); 2412 } 2413 } 2414 2415 // this is called from the parent group for each unparsed attribute in the attribute list 2416 void SdXMLCaptionShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 2417 { 2418 if( XML_NAMESPACE_DRAW == nPrefix ) 2419 { 2420 if( IsXMLToken( rLocalName, XML_CAPTION_POINT_X ) ) 2421 { 2422 GetImport().GetMM100UnitConverter().convertMeasure(maCaptionPoint.X, rValue); 2423 return; 2424 } 2425 if( IsXMLToken( rLocalName, XML_CAPTION_POINT_Y ) ) 2426 { 2427 GetImport().GetMM100UnitConverter().convertMeasure(maCaptionPoint.Y, rValue); 2428 return; 2429 } 2430 if( IsXMLToken( rLocalName, XML_CORNER_RADIUS ) ) 2431 { 2432 GetImport().GetMM100UnitConverter().convertMeasure(mnRadius, rValue); 2433 return; 2434 } 2435 } 2436 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 2437 } 2438 2439 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2440 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2441 2442 TYPEINIT1( SdXMLGraphicObjectShapeContext, SdXMLShapeContext ); 2443 2444 SdXMLGraphicObjectShapeContext::SdXMLGraphicObjectShapeContext( 2445 SvXMLImport& rImport, 2446 sal_uInt16 nPrfx, 2447 const OUString& rLocalName, 2448 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 2449 uno::Reference< drawing::XShapes >& rShapes, 2450 sal_Bool bTemporaryShape) 2451 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 2452 maURL(), 2453 mbLateAddToIdentifierMapper(false) 2454 { 2455 } 2456 2457 ////////////////////////////////////////////////////////////////////////////// 2458 2459 // this is called from the parent group for each unparsed attribute in the attribute list 2460 void SdXMLGraphicObjectShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 2461 { 2462 if( XML_NAMESPACE_XLINK == nPrefix ) 2463 { 2464 if( IsXMLToken( rLocalName, XML_HREF ) ) 2465 { 2466 maURL = rValue; 2467 return; 2468 } 2469 } 2470 2471 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 2472 } 2473 2474 ////////////////////////////////////////////////////////////////////////////// 2475 2476 void SdXMLGraphicObjectShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& ) 2477 { 2478 // create graphic object shape 2479 const char *pService; 2480 2481 if( IsXMLToken( maPresentationClass, XML_GRAPHIC ) && GetImport().GetShapeImport()->IsPresentationShapesSupported() ) 2482 { 2483 pService = "com.sun.star.presentation.GraphicObjectShape"; 2484 } 2485 else 2486 { 2487 pService = "com.sun.star.drawing.GraphicObjectShape"; 2488 } 2489 2490 AddShape( pService ); 2491 2492 if(mxShape.is()) 2493 { 2494 SetStyle(); 2495 SetLayer(); 2496 2497 uno::Reference< beans::XPropertySet > xPropset(mxShape, uno::UNO_QUERY); 2498 if(xPropset.is()) 2499 { 2500 // since OOo 1.x had no line or fill style for graphics, but may create 2501 // documents with them, we have to override them here 2502 sal_Int32 nUPD, nBuildId; 2503 if( GetImport().getBuildIds( nUPD, nBuildId ) && (nUPD == 645) ) try 2504 { 2505 xPropset->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("FillStyle")), Any( FillStyle_NONE ) ); 2506 xPropset->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("LineStyle")), Any( LineStyle_NONE ) ); 2507 } 2508 catch( Exception& ) 2509 { 2510 } 2511 2512 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xPropset->getPropertySetInfo() ); 2513 if( xPropsInfo.is() && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ))) 2514 xPropset->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ), ::cppu::bool2any( mbIsPlaceholder ) ); 2515 2516 if( !mbIsPlaceholder ) 2517 { 2518 if( maURL.getLength() ) 2519 { 2520 uno::Any aAny; 2521 aAny <<= GetImport().ResolveGraphicObjectURL( maURL, GetImport().isGraphicLoadOnDemandSupported() ); 2522 try 2523 { 2524 xPropset->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicURL") ), aAny ); 2525 xPropset->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicStreamURL") ), aAny ); 2526 } 2527 catch (lang::IllegalArgumentException const &) 2528 { 2529 } 2530 } 2531 } 2532 } 2533 2534 if(mbIsUserTransformed) 2535 { 2536 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 2537 if(xProps.is()) 2538 { 2539 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() ); 2540 if( xPropsInfo.is() ) 2541 { 2542 if( xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ))) 2543 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ), ::cppu::bool2any( sal_False ) ); 2544 } 2545 } 2546 } 2547 2548 // set pos, size, shear and rotate 2549 SetTransformation(); 2550 2551 SdXMLShapeContext::StartElement(mxAttrList); 2552 } 2553 } 2554 2555 void SdXMLGraphicObjectShapeContext::EndElement() 2556 { 2557 if( mxBase64Stream.is() ) 2558 { 2559 OUString sURL( GetImport().ResolveGraphicObjectURLFromBase64( mxBase64Stream ) ); 2560 if( sURL.getLength() ) 2561 { 2562 try 2563 { 2564 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 2565 if(xProps.is()) 2566 { 2567 const uno::Any aAny( uno::makeAny( sURL ) ); 2568 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicURL") ), aAny ); 2569 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicStreamURL") ), aAny ); 2570 } 2571 } 2572 catch (lang::IllegalArgumentException const &) 2573 { 2574 } 2575 } 2576 } 2577 2578 SdXMLShapeContext::EndElement(); 2579 } 2580 2581 2582 ////////////////////////////////////////////////////////////////////////////// 2583 2584 SvXMLImportContext* SdXMLGraphicObjectShapeContext::CreateChildContext( 2585 sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, 2586 const uno::Reference<xml::sax::XAttributeList>& xAttrList ) 2587 { 2588 SvXMLImportContext* pContext = NULL; 2589 2590 if( (XML_NAMESPACE_OFFICE == nPrefix) && 2591 xmloff::token::IsXMLToken( rLocalName, xmloff::token::XML_BINARY_DATA ) ) 2592 { 2593 if( !maURL.getLength() && !mxBase64Stream.is() ) 2594 { 2595 mxBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64(); 2596 if( mxBase64Stream.is() ) 2597 pContext = new XMLBase64ImportContext( GetImport(), nPrefix, 2598 rLocalName, xAttrList, 2599 mxBase64Stream ); 2600 } 2601 } 2602 2603 // delegate to parent class if no context could be created 2604 if ( NULL == pContext ) 2605 pContext = SdXMLShapeContext::CreateChildContext(nPrefix, rLocalName, 2606 xAttrList); 2607 2608 return pContext; 2609 } 2610 2611 ////////////////////////////////////////////////////////////////////////////// 2612 2613 SdXMLGraphicObjectShapeContext::~SdXMLGraphicObjectShapeContext() 2614 { 2615 2616 } 2617 2618 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2619 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 2620 2621 TYPEINIT1( SdXMLChartShapeContext, SdXMLShapeContext ); 2622 2623 SdXMLChartShapeContext::SdXMLChartShapeContext( 2624 SvXMLImport& rImport, 2625 sal_uInt16 nPrfx, 2626 const OUString& rLocalName, 2627 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 2628 uno::Reference< drawing::XShapes >& rShapes, 2629 sal_Bool bTemporaryShape) 2630 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 2631 mpChartContext( NULL ) 2632 { 2633 } 2634 2635 ////////////////////////////////////////////////////////////////////////////// 2636 2637 SdXMLChartShapeContext::~SdXMLChartShapeContext() 2638 { 2639 if( mpChartContext ) 2640 delete mpChartContext; 2641 } 2642 2643 ////////////////////////////////////////////////////////////////////////////// 2644 2645 void SdXMLChartShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>& xAttrList) 2646 { 2647 const sal_Bool bIsPresentation = isPresentationShape(); 2648 2649 AddShape( bIsPresentation ? "com.sun.star.presentation.ChartShape" : "com.sun.star.drawing.OLE2Shape" ); 2650 2651 if(mxShape.is()) 2652 { 2653 SetStyle(); 2654 SetLayer(); 2655 2656 if( !mbIsPlaceholder ) 2657 { 2658 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 2659 if(xProps.is()) 2660 { 2661 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() ); 2662 if( xPropsInfo.is() && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ))) 2663 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ), ::cppu::bool2any( sal_False ) ); 2664 2665 uno::Any aAny; 2666 2667 const OUString aCLSID( RTL_CONSTASCII_USTRINGPARAM("12DCAE26-281F-416F-a234-c3086127382e")); 2668 2669 aAny <<= aCLSID; 2670 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CLSID") ), aAny ); 2671 2672 #ifndef SVX_LIGHT 2673 aAny = xProps->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("Model") ) ); 2674 uno::Reference< frame::XModel > xChartModel; 2675 if( aAny >>= xChartModel ) 2676 { 2677 mpChartContext = GetImport().GetChartImport()->CreateChartContext( GetImport(), XML_NAMESPACE_SVG, GetXMLToken(XML_CHART), xChartModel, xAttrList ); 2678 } 2679 #endif 2680 } 2681 } 2682 2683 if(mbIsUserTransformed) 2684 { 2685 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 2686 if(xProps.is()) 2687 { 2688 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() ); 2689 if( xPropsInfo.is() ) 2690 { 2691 if( xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ))) 2692 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ), ::cppu::bool2any( sal_False ) ); 2693 } 2694 } 2695 } 2696 2697 2698 // set pos, size, shear and rotate 2699 SetTransformation(); 2700 2701 SdXMLShapeContext::StartElement(xAttrList); 2702 2703 if( mpChartContext ) 2704 mpChartContext->StartElement( xAttrList ); 2705 } 2706 } 2707 2708 void SdXMLChartShapeContext::EndElement() 2709 { 2710 if( mpChartContext ) 2711 mpChartContext->EndElement(); 2712 2713 SdXMLShapeContext::EndElement(); 2714 } 2715 2716 void SdXMLChartShapeContext::Characters( const ::rtl::OUString& rChars ) 2717 { 2718 if( mpChartContext ) 2719 mpChartContext->Characters( rChars ); 2720 } 2721 2722 SvXMLImportContext * SdXMLChartShapeContext::CreateChildContext( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, 2723 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList ) 2724 { 2725 if( mpChartContext ) 2726 return mpChartContext->CreateChildContext( nPrefix, rLocalName, xAttrList ); 2727 2728 return NULL; 2729 } 2730 2731 ////////////////////////////////////////////////////////////////////////////// 2732 2733 TYPEINIT1( SdXMLObjectShapeContext, SdXMLShapeContext ); 2734 2735 SdXMLObjectShapeContext::SdXMLObjectShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx, 2736 const rtl::OUString& rLocalName, 2737 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 2738 com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes, 2739 sal_Bool bTemporaryShape) 2740 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ) 2741 { 2742 } 2743 2744 SdXMLObjectShapeContext::~SdXMLObjectShapeContext() 2745 { 2746 } 2747 2748 void SdXMLObjectShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& ) 2749 { 2750 // #96717# in theorie, if we don't have a url we shouldn't even 2751 // export this ole shape. But practical its to risky right now 2752 // to change this so we better dispose this on load 2753 //if( !mbIsPlaceholder && ImpIsEmptyURL(maHref) ) 2754 // return; 2755 2756 // #100592# this BugFix prevents that a shape is created. CL 2757 // is thinking about an alternative. 2758 // #i13140# Check for more than empty string in maHref, there are 2759 // other possibilities that maHref results in empty container 2760 // storage names 2761 if( !(GetImport().getImportFlags() & IMPORT_EMBEDDED) && !mbIsPlaceholder && ImpIsEmptyURL(maHref) ) 2762 return; 2763 2764 const char* pService = "com.sun.star.drawing.OLE2Shape"; 2765 2766 sal_Bool bIsPresShape = maPresentationClass.getLength() && GetImport().GetShapeImport()->IsPresentationShapesSupported(); 2767 2768 if( bIsPresShape ) 2769 { 2770 if( IsXMLToken( maPresentationClass, XML_PRESENTATION_CHART ) ) 2771 { 2772 pService = "com.sun.star.presentation.ChartShape"; 2773 } 2774 else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_TABLE ) ) 2775 { 2776 pService = "com.sun.star.presentation.CalcShape"; 2777 } 2778 else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_OBJECT ) ) 2779 { 2780 pService = "com.sun.star.presentation.OLE2Shape"; 2781 } 2782 } 2783 2784 AddShape( pService ); 2785 2786 if( mxShape.is() ) 2787 { 2788 SetLayer(); 2789 2790 if(bIsPresShape) 2791 { 2792 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 2793 if(xProps.is()) 2794 { 2795 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() ); 2796 if( xPropsInfo.is() ) 2797 { 2798 if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ))) 2799 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ), ::cppu::bool2any( sal_False ) ); 2800 2801 if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ))) 2802 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ), ::cppu::bool2any( sal_False ) ); 2803 } 2804 } 2805 } 2806 2807 if( !mbIsPlaceholder && maHref.getLength() ) 2808 { 2809 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 2810 2811 if( xProps.is() ) 2812 { 2813 OUString aPersistName = GetImport().ResolveEmbeddedObjectURL( maHref, maCLSID ); 2814 2815 if ( GetImport().IsPackageURL( maHref ) ) 2816 { 2817 const OUString sURL(RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.EmbeddedObject:" )); 2818 2819 if ( aPersistName.compareTo( sURL, sURL.getLength() ) == 0 ) 2820 aPersistName = aPersistName.copy( sURL.getLength() ); 2821 2822 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PersistName" ) ), 2823 uno::makeAny( aPersistName ) ); 2824 } 2825 else 2826 { 2827 // this is OOo link object 2828 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "LinkURL" ) ), 2829 uno::makeAny( aPersistName ) ); 2830 } 2831 } 2832 } 2833 2834 // set pos, size, shear and rotate 2835 SetTransformation(); 2836 2837 SetStyle(); 2838 2839 GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes ); 2840 } 2841 } 2842 2843 void SdXMLObjectShapeContext::EndElement() 2844 { 2845 // #i67705# 2846 const sal_uInt16 nGeneratorVersion(GetImport().getGeneratorVersion()); 2847 2848 if(nGeneratorVersion < SvXMLImport::OOo_34x) 2849 { 2850 // #i118485# 2851 // If it's an old file from us written before OOo3.4, we need to correct 2852 // FillStyle and LineStyle for OLE2 objects. The error was that the old paint 2853 // implementations just ignored added fill/linestyles completely, thus 2854 // those objects need to be corrected to not show blue and hairline which 2855 // always was the default, but would be shown now 2856 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 2857 2858 if( xProps.is() ) 2859 { 2860 xProps->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FillStyle")), uno::makeAny(drawing::FillStyle_NONE)); 2861 xProps->setPropertyValue(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("LineStyle")), uno::makeAny(drawing::LineStyle_NONE)); 2862 } 2863 } 2864 2865 // #100592# 2866 if( mxBase64Stream.is() ) 2867 { 2868 OUString aPersistName( GetImport().ResolveEmbeddedObjectURLFromBase64() ); 2869 const OUString sURL(RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.EmbeddedObject:" )); 2870 2871 aPersistName = aPersistName.copy( sURL.getLength() ); 2872 2873 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 2874 if( xProps.is() ) 2875 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PersistName" ) ), uno::makeAny( aPersistName ) ); 2876 } 2877 2878 SdXMLShapeContext::EndElement(); 2879 } 2880 2881 // this is called from the parent group for each unparsed attribute in the attribute list 2882 void SdXMLObjectShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 2883 { 2884 switch( nPrefix ) 2885 { 2886 case XML_NAMESPACE_DRAW: 2887 if( IsXMLToken( rLocalName, XML_CLASS_ID ) ) 2888 { 2889 maCLSID = rValue; 2890 return; 2891 } 2892 break; 2893 case XML_NAMESPACE_XLINK: 2894 if( IsXMLToken( rLocalName, XML_HREF ) ) 2895 { 2896 maHref = rValue; 2897 return; 2898 } 2899 break; 2900 } 2901 2902 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 2903 } 2904 2905 SvXMLImportContext* SdXMLObjectShapeContext::CreateChildContext( 2906 sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, 2907 const uno::Reference<xml::sax::XAttributeList>& xAttrList ) 2908 { 2909 // #100592# 2910 SvXMLImportContext* pContext = NULL; 2911 2912 if((XML_NAMESPACE_OFFICE == nPrefix) && IsXMLToken(rLocalName, XML_BINARY_DATA)) 2913 { 2914 mxBase64Stream = GetImport().GetStreamForEmbeddedObjectURLFromBase64(); 2915 if( mxBase64Stream.is() ) 2916 pContext = new XMLBase64ImportContext( GetImport(), nPrefix, 2917 rLocalName, xAttrList, 2918 mxBase64Stream ); 2919 } 2920 else if( ((XML_NAMESPACE_OFFICE == nPrefix) && IsXMLToken(rLocalName, XML_DOCUMENT)) || 2921 ((XML_NAMESPACE_MATH == nPrefix) && IsXMLToken(rLocalName, XML_MATH)) ) 2922 { 2923 XMLEmbeddedObjectImportContext *pEContext = 2924 new XMLEmbeddedObjectImportContext( GetImport(), nPrefix, 2925 rLocalName, xAttrList ); 2926 maCLSID = pEContext->GetFilterCLSID(); 2927 if( maCLSID.getLength() != 0 ) 2928 { 2929 uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY); 2930 if( xPropSet.is() ) 2931 { 2932 xPropSet->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("CLSID") ), uno::makeAny( maCLSID ) ); 2933 2934 uno::Reference< lang::XComponent > xComp; 2935 xPropSet->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("Model") ) ) >>= xComp; 2936 DBG_ASSERT( xComp.is(), "no xModel for own OLE format" ); 2937 pEContext->SetComponent( xComp ); 2938 } 2939 } 2940 pContext = pEContext; 2941 } 2942 2943 // delegate to parent class if no context could be created 2944 if(!pContext) 2945 pContext = SdXMLShapeContext::CreateChildContext(nPrefix, rLocalName, xAttrList); 2946 2947 return pContext; 2948 } 2949 2950 ////////////////////////////////////////////////////////////////////////////// 2951 2952 TYPEINIT1( SdXMLAppletShapeContext, SdXMLShapeContext ); 2953 2954 SdXMLAppletShapeContext::SdXMLAppletShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx, 2955 const rtl::OUString& rLocalName, 2956 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 2957 com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes, 2958 sal_Bool bTemporaryShape) 2959 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 2960 mbIsScript( sal_False ) 2961 { 2962 } 2963 2964 SdXMLAppletShapeContext::~SdXMLAppletShapeContext() 2965 { 2966 } 2967 2968 void SdXMLAppletShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& ) 2969 { 2970 const char* pService = "com.sun.star.drawing.AppletShape"; 2971 AddShape( pService ); 2972 2973 if( mxShape.is() ) 2974 { 2975 SetLayer(); 2976 2977 // set pos, size, shear and rotate 2978 SetTransformation(); 2979 GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes ); 2980 } 2981 } 2982 2983 // this is called from the parent group for each unparsed attribute in the attribute list 2984 void SdXMLAppletShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 2985 { 2986 switch( nPrefix ) 2987 { 2988 case XML_NAMESPACE_DRAW: 2989 if( IsXMLToken( rLocalName, XML_APPLET_NAME ) ) 2990 { 2991 maAppletName = rValue; 2992 return; 2993 } 2994 if( IsXMLToken( rLocalName, XML_CODE ) ) 2995 { 2996 maAppletCode = rValue; 2997 return; 2998 } 2999 if( IsXMLToken( rLocalName, XML_MAY_SCRIPT ) ) 3000 { 3001 mbIsScript = IsXMLToken( rValue, XML_TRUE ); 3002 return; 3003 } 3004 break; 3005 case XML_NAMESPACE_XLINK: 3006 if( IsXMLToken( rLocalName, XML_HREF ) ) 3007 { 3008 maHref = GetImport().GetAbsoluteReference(rValue); 3009 return; 3010 } 3011 break; 3012 } 3013 3014 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 3015 } 3016 3017 void SdXMLAppletShapeContext::EndElement() 3018 { 3019 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 3020 if( xProps.is() ) 3021 { 3022 uno::Any aAny; 3023 3024 if ( maSize.Width && maSize.Height ) 3025 { 3026 // the visual area for applet must be set on loading 3027 awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height ); 3028 aAny <<= aRect; 3029 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "VisibleArea" ) ), aAny ); 3030 } 3031 3032 if( maParams.getLength() ) 3033 { 3034 aAny <<= maParams; 3035 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletCommands" ) ), aAny ); 3036 } 3037 3038 if( maHref.getLength() ) 3039 { 3040 aAny <<= maHref; 3041 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletCodeBase" ) ), aAny ); 3042 } 3043 3044 if( maAppletName.getLength() ) 3045 { 3046 aAny <<= maAppletName; 3047 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletName" ) ), aAny ); 3048 } 3049 3050 if( mbIsScript ) 3051 { 3052 aAny <<= mbIsScript; 3053 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletIsScript" ) ), aAny ); 3054 3055 } 3056 3057 if( maAppletCode.getLength() ) 3058 { 3059 aAny <<= maAppletCode; 3060 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletCode" ) ), aAny ); 3061 } 3062 3063 aAny <<= ::rtl::OUString( GetImport().GetDocumentBase() ); 3064 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "AppletDocBase" ) ), aAny ); 3065 3066 SetThumbnail(); 3067 } 3068 3069 SdXMLShapeContext::EndElement(); 3070 } 3071 3072 SvXMLImportContext * SdXMLAppletShapeContext::CreateChildContext( sal_uInt16 p_nPrefix, const ::rtl::OUString& rLocalName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList ) 3073 { 3074 if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_PARAM ) ) 3075 { 3076 OUString aParamName, aParamValue; 3077 const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; 3078 // now parse the attribute list and look for draw:name and draw:value 3079 for(sal_Int16 a(0); a < nAttrCount; a++) 3080 { 3081 const OUString& rAttrName = xAttrList->getNameByIndex(a); 3082 OUString aLocalName; 3083 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName); 3084 const OUString aValue( xAttrList->getValueByIndex(a) ); 3085 3086 if( nPrefix == XML_NAMESPACE_DRAW ) 3087 { 3088 if( IsXMLToken( aLocalName, XML_NAME ) ) 3089 { 3090 aParamName = aValue; 3091 } 3092 else if( IsXMLToken( aLocalName, XML_VALUE ) ) 3093 { 3094 aParamValue = aValue; 3095 } 3096 } 3097 } 3098 3099 if( aParamName.getLength() ) 3100 { 3101 sal_Int32 nIndex = maParams.getLength(); 3102 maParams.realloc( nIndex + 1 ); 3103 maParams[nIndex].Name = aParamName; 3104 maParams[nIndex].Handle = -1; 3105 maParams[nIndex].Value <<= aParamValue; 3106 maParams[nIndex].State = beans::PropertyState_DIRECT_VALUE; 3107 } 3108 3109 return new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName ); 3110 } 3111 3112 return SdXMLShapeContext::CreateChildContext( p_nPrefix, rLocalName, xAttrList ); 3113 } 3114 3115 ////////////////////////////////////////////////////////////////////////////// 3116 3117 TYPEINIT1( SdXMLPluginShapeContext, SdXMLShapeContext ); 3118 3119 SdXMLPluginShapeContext::SdXMLPluginShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx, 3120 const rtl::OUString& rLocalName, 3121 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 3122 com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes, 3123 sal_Bool bTemporaryShape) : 3124 SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 3125 mbMedia( false ) 3126 { 3127 } 3128 3129 SdXMLPluginShapeContext::~SdXMLPluginShapeContext() 3130 { 3131 } 3132 3133 void SdXMLPluginShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList) 3134 { 3135 // watch for MimeType attribute to see if we have a media object 3136 for( sal_Int16 n = 0, nAttrCount = ( xAttrList.is() ? xAttrList->getLength() : 0 ); n < nAttrCount; ++n ) 3137 { 3138 OUString aLocalName; 3139 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( n ), &aLocalName ); 3140 3141 if( nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( aLocalName, XML_MIME_TYPE ) ) 3142 { 3143 if( 0 == xAttrList->getValueByIndex( n ).compareToAscii( "application/vnd.sun.star.media" ) ) 3144 mbMedia = true; 3145 3146 // leave this loop 3147 n = nAttrCount - 1; 3148 } 3149 } 3150 3151 const char* pService; 3152 3153 sal_Bool bIsPresShape = sal_False; 3154 3155 if( mbMedia ) 3156 { 3157 pService = "com.sun.star.drawing.MediaShape"; 3158 3159 bIsPresShape = maPresentationClass.getLength() && GetImport().GetShapeImport()->IsPresentationShapesSupported(); 3160 if( bIsPresShape ) 3161 { 3162 if( IsXMLToken( maPresentationClass, XML_PRESENTATION_OBJECT ) ) 3163 { 3164 pService = "com.sun.star.presentation.MediaShape"; 3165 } 3166 } 3167 } 3168 else 3169 pService = "com.sun.star.drawing.PluginShape"; 3170 3171 AddShape( pService ); 3172 3173 if( mxShape.is() ) 3174 { 3175 SetLayer(); 3176 3177 if(bIsPresShape) 3178 { 3179 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 3180 if(xProps.is()) 3181 { 3182 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() ); 3183 if( xPropsInfo.is() ) 3184 { 3185 if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ))) 3186 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ), ::cppu::bool2any( sal_False ) ); 3187 3188 if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ))) 3189 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ), ::cppu::bool2any( sal_False ) ); 3190 } 3191 } 3192 } 3193 3194 // set pos, size, shear and rotate 3195 SetTransformation(); 3196 GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes ); 3197 } 3198 } 3199 3200 // this is called from the parent group for each unparsed attribute in the attribute list 3201 void SdXMLPluginShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 3202 { 3203 switch( nPrefix ) 3204 { 3205 case XML_NAMESPACE_DRAW: 3206 if( IsXMLToken( rLocalName, XML_MIME_TYPE ) ) 3207 { 3208 maMimeType = rValue; 3209 return; 3210 } 3211 break; 3212 case XML_NAMESPACE_XLINK: 3213 if( IsXMLToken( rLocalName, XML_HREF ) ) 3214 { 3215 maHref = GetImport().GetAbsoluteReference(rValue); 3216 return; 3217 } 3218 break; 3219 } 3220 3221 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 3222 } 3223 3224 void SdXMLPluginShapeContext::EndElement() 3225 { 3226 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 3227 3228 if( xProps.is() ) 3229 { 3230 uno::Any aAny; 3231 3232 if ( maSize.Width && maSize.Height ) 3233 { 3234 const rtl::OUString sVisibleArea( RTL_CONSTASCII_USTRINGPARAM( "VisibleArea" ) ); 3235 uno::Reference< beans::XPropertySetInfo > aXPropSetInfo( xProps->getPropertySetInfo() ); 3236 if ( !aXPropSetInfo.is() || aXPropSetInfo->hasPropertyByName( sVisibleArea ) ) 3237 { 3238 // the visual area for a plugin must be set on loading 3239 awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height ); 3240 aAny <<= aRect; 3241 xProps->setPropertyValue( sVisibleArea, aAny ); 3242 } 3243 } 3244 3245 if( !mbMedia ) 3246 { 3247 // in case we have a plugin object 3248 if( maParams.getLength() ) 3249 { 3250 aAny <<= maParams; 3251 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PluginCommands" ) ), aAny ); 3252 } 3253 3254 if( maMimeType.getLength() ) 3255 { 3256 aAny <<= maMimeType; 3257 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PluginMimeType" ) ), aAny ); 3258 } 3259 3260 if( maHref.getLength() ) 3261 { 3262 aAny <<= maHref; 3263 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "PluginURL" ) ), aAny ); 3264 } 3265 } 3266 else 3267 { 3268 // in case we have a media object 3269 3270 OUString sTempRef; 3271 3272 // check for package URL 3273 if( GetImport().IsPackageURL( maHref ) ) 3274 { 3275 sTempRef = OUString( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package:" ) ); 3276 } 3277 3278 sTempRef += maHref; 3279 3280 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaURL" ) ), uno::makeAny( sTempRef ) ); 3281 3282 for( sal_Int32 nParam = 0; nParam < maParams.getLength(); ++nParam ) 3283 { 3284 const OUString& rName = maParams[ nParam ].Name; 3285 3286 if( 0 == rName.compareToAscii( "Loop" ) ) 3287 { 3288 OUString aValueStr; 3289 maParams[ nParam ].Value >>= aValueStr; 3290 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Loop" ) ), 3291 uno::makeAny( static_cast< sal_Bool >( 0 == aValueStr.compareToAscii( "true" ) ) ) ); 3292 } 3293 else if( 0 == rName.compareToAscii( "Mute" ) ) 3294 { 3295 OUString aValueStr; 3296 maParams[ nParam ].Value >>= aValueStr; 3297 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Mute" ) ), 3298 uno::makeAny( static_cast< sal_Bool >( 0 == aValueStr.compareToAscii( "true" ) ) ) ); 3299 } 3300 else if( 0 == rName.compareToAscii( "VolumeDB" ) ) 3301 { 3302 OUString aValueStr; 3303 maParams[ nParam ].Value >>= aValueStr; 3304 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "VolumeDB" ) ), 3305 uno::makeAny( static_cast< sal_Int16 >( aValueStr.toInt32() ) ) ); 3306 } 3307 else if( 0 == rName.compareToAscii( "Zoom" ) ) 3308 { 3309 OUString aZoomStr; 3310 media::ZoomLevel eZoomLevel; 3311 3312 maParams[ nParam ].Value >>= aZoomStr; 3313 3314 if( 0 == aZoomStr.compareToAscii( "25%" ) ) 3315 eZoomLevel = media::ZoomLevel_ZOOM_1_TO_4; 3316 else if( 0 == aZoomStr.compareToAscii( "50%" ) ) 3317 eZoomLevel = media::ZoomLevel_ZOOM_1_TO_2; 3318 else if( 0 == aZoomStr.compareToAscii( "100%" ) ) 3319 eZoomLevel = media::ZoomLevel_ORIGINAL; 3320 else if( 0 == aZoomStr.compareToAscii( "200%" ) ) 3321 eZoomLevel = media::ZoomLevel_ZOOM_2_TO_1; 3322 else if( 0 == aZoomStr.compareToAscii( "400%" ) ) 3323 eZoomLevel = media::ZoomLevel_ZOOM_4_TO_1; 3324 else if( 0 == aZoomStr.compareToAscii( "fit" ) ) 3325 eZoomLevel = media::ZoomLevel_FIT_TO_WINDOW; 3326 else if( 0 == aZoomStr.compareToAscii( "fixedfit" ) ) 3327 eZoomLevel = media::ZoomLevel_FIT_TO_WINDOW_FIXED_ASPECT; 3328 else if( 0 == aZoomStr.compareToAscii( "fullscreen" ) ) 3329 eZoomLevel = media::ZoomLevel_FULLSCREEN; 3330 else 3331 eZoomLevel = media::ZoomLevel_NOT_AVAILABLE; 3332 3333 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Zoom" ) ), uno::makeAny( eZoomLevel ) ); 3334 } 3335 } 3336 } 3337 3338 SetThumbnail(); 3339 } 3340 3341 SdXMLShapeContext::EndElement(); 3342 } 3343 3344 SvXMLImportContext * SdXMLPluginShapeContext::CreateChildContext( sal_uInt16 p_nPrefix, const ::rtl::OUString& rLocalName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList ) 3345 { 3346 if( p_nPrefix == XML_NAMESPACE_DRAW && IsXMLToken( rLocalName, XML_PARAM ) ) 3347 { 3348 OUString aParamName, aParamValue; 3349 const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; 3350 // now parse the attribute list and look for draw:name and draw:value 3351 for(sal_Int16 a(0); a < nAttrCount; a++) 3352 { 3353 const OUString& rAttrName = xAttrList->getNameByIndex(a); 3354 OUString aLocalName; 3355 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(rAttrName, &aLocalName); 3356 const OUString aValue( xAttrList->getValueByIndex(a) ); 3357 3358 if( nPrefix == XML_NAMESPACE_DRAW ) 3359 { 3360 if( IsXMLToken( aLocalName, XML_NAME ) ) 3361 { 3362 aParamName = aValue; 3363 } 3364 else if( IsXMLToken( aLocalName, XML_VALUE ) ) 3365 { 3366 aParamValue = aValue; 3367 } 3368 } 3369 3370 if( aParamName.getLength() ) 3371 { 3372 sal_Int32 nIndex = maParams.getLength(); 3373 maParams.realloc( nIndex + 1 ); 3374 maParams[nIndex].Name = aParamName; 3375 maParams[nIndex].Handle = -1; 3376 maParams[nIndex].Value <<= aParamValue; 3377 maParams[nIndex].State = beans::PropertyState_DIRECT_VALUE; 3378 } 3379 } 3380 3381 return new SvXMLImportContext( GetImport(), p_nPrefix, rLocalName ); 3382 } 3383 3384 return SdXMLShapeContext::CreateChildContext( p_nPrefix, rLocalName, xAttrList ); 3385 } 3386 3387 ////////////////////////////////////////////////////////////////////////////// 3388 3389 TYPEINIT1( SdXMLFloatingFrameShapeContext, SdXMLShapeContext ); 3390 3391 SdXMLFloatingFrameShapeContext::SdXMLFloatingFrameShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx, 3392 const rtl::OUString& rLocalName, 3393 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 3394 com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes, 3395 sal_Bool bTemporaryShape) 3396 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ) 3397 { 3398 } 3399 3400 SdXMLFloatingFrameShapeContext::~SdXMLFloatingFrameShapeContext() 3401 { 3402 } 3403 3404 void SdXMLFloatingFrameShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& ) 3405 { 3406 const char* pService = "com.sun.star.drawing.FrameShape"; 3407 AddShape( pService ); 3408 3409 if( mxShape.is() ) 3410 { 3411 SetLayer(); 3412 3413 // set pos, size, shear and rotate 3414 SetTransformation(); 3415 3416 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 3417 if( xProps.is() ) 3418 { 3419 uno::Any aAny; 3420 3421 if( maFrameName.getLength() ) 3422 { 3423 aAny <<= maFrameName; 3424 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "FrameName" ) ), aAny ); 3425 } 3426 3427 if( maHref.getLength() ) 3428 { 3429 aAny <<= maHref; 3430 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "FrameURL" ) ), aAny ); 3431 } 3432 } 3433 3434 SetStyle(); 3435 3436 GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes ); 3437 } 3438 } 3439 3440 // this is called from the parent group for each unparsed attribute in the attribute list 3441 void SdXMLFloatingFrameShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 3442 { 3443 switch( nPrefix ) 3444 { 3445 case XML_NAMESPACE_DRAW: 3446 if( IsXMLToken( rLocalName, XML_FRAME_NAME ) ) 3447 { 3448 maFrameName = rValue; 3449 return; 3450 } 3451 break; 3452 case XML_NAMESPACE_XLINK: 3453 if( IsXMLToken( rLocalName, XML_HREF ) ) 3454 { 3455 maHref = GetImport().GetAbsoluteReference(rValue); 3456 return; 3457 } 3458 break; 3459 } 3460 3461 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 3462 } 3463 3464 void SdXMLFloatingFrameShapeContext::EndElement() 3465 { 3466 uno::Reference< beans::XPropertySet > xProps( mxShape, uno::UNO_QUERY ); 3467 3468 if( xProps.is() ) 3469 { 3470 if ( maSize.Width && maSize.Height ) 3471 { 3472 // the visual area for a floating frame must be set on loading 3473 awt::Rectangle aRect( 0, 0, maSize.Width, maSize.Height ); 3474 uno::Any aAny; 3475 aAny <<= aRect; 3476 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "VisibleArea" ) ), aAny ); 3477 } 3478 } 3479 3480 SetThumbnail(); 3481 SdXMLShapeContext::EndElement(); 3482 } 3483 3484 ////////////////////////////////////////////////////////////////////////////// 3485 3486 TYPEINIT1( SdXMLFrameShapeContext, SdXMLShapeContext ); 3487 3488 SdXMLFrameShapeContext::SdXMLFrameShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx, 3489 const rtl::OUString& rLocalName, 3490 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 3491 com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes, 3492 sal_Bool bTemporaryShape) 3493 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ), 3494 multiImageImportHelper(), 3495 mbSupportsReplacement( sal_False ), 3496 mxImplContext(), 3497 mxReplImplContext() 3498 { 3499 uno::Reference < util::XCloneable > xClone( xAttrList, uno::UNO_QUERY ); 3500 if( xClone.is() ) 3501 mxAttrList.set( xClone->createClone(), uno::UNO_QUERY ); 3502 else 3503 mxAttrList = new SvXMLAttributeList( xAttrList ); 3504 3505 } 3506 3507 SdXMLFrameShapeContext::~SdXMLFrameShapeContext() 3508 { 3509 } 3510 3511 void SdXMLFrameShapeContext::removeGraphicFromImportContext(const SvXMLImportContext& rContext) const 3512 { 3513 const SdXMLGraphicObjectShapeContext* pSdXMLGraphicObjectShapeContext = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(&rContext); 3514 3515 if(pSdXMLGraphicObjectShapeContext) 3516 { 3517 try 3518 { 3519 uno::Reference< container::XChild > xChild(pSdXMLGraphicObjectShapeContext->getShape(), uno::UNO_QUERY_THROW); 3520 3521 if(xChild.is()) 3522 { 3523 uno::Reference< drawing::XShapes > xParent(xChild->getParent(), uno::UNO_QUERY_THROW); 3524 3525 if(xParent.is()) 3526 { 3527 // remove from parent 3528 xParent->remove(pSdXMLGraphicObjectShapeContext->getShape()); 3529 3530 // dispose 3531 uno::Reference< lang::XComponent > xComp(pSdXMLGraphicObjectShapeContext->getShape(), UNO_QUERY); 3532 3533 if(xComp.is()) 3534 { 3535 xComp->dispose(); 3536 } 3537 } 3538 } 3539 } 3540 catch( uno::Exception& ) 3541 { 3542 DBG_ERROR( "Error in cleanup of multiple graphic object import (!)" ); 3543 } 3544 } 3545 } 3546 3547 rtl::OUString SdXMLFrameShapeContext::getGraphicURLFromImportContext(const SvXMLImportContext& rContext) const 3548 { 3549 rtl::OUString aRetval; 3550 const SdXMLGraphicObjectShapeContext* pSdXMLGraphicObjectShapeContext = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(&rContext); 3551 3552 if(pSdXMLGraphicObjectShapeContext) 3553 { 3554 try 3555 { 3556 const uno::Reference< beans::XPropertySet > xPropSet(pSdXMLGraphicObjectShapeContext->getShape(), uno::UNO_QUERY_THROW); 3557 3558 if(xPropSet.is()) 3559 { 3560 xPropSet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicStreamURL"))) >>= aRetval; 3561 3562 if(!aRetval.getLength()) 3563 { 3564 // it maybe a link, try GraphicURL 3565 xPropSet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GraphicURL"))) >>= aRetval; 3566 } 3567 } 3568 } 3569 catch( uno::Exception& ) 3570 { 3571 DBG_ERROR( "Error in cleanup of multiple graphic object import (!)" ); 3572 } 3573 } 3574 3575 return aRetval; 3576 } 3577 3578 SvXMLImportContext *SdXMLFrameShapeContext::CreateChildContext( sal_uInt16 nPrefix, 3579 const OUString& rLocalName, 3580 const uno::Reference< xml::sax::XAttributeList>& xAttrList ) 3581 { 3582 SvXMLImportContext * pContext = 0; 3583 3584 if( !mxImplContext.Is() ) 3585 { 3586 pContext = GetImport().GetShapeImport()->CreateFrameChildContext( 3587 GetImport(), nPrefix, rLocalName, xAttrList, mxShapes, mxAttrList); 3588 3589 mxImplContext = pContext; 3590 mbSupportsReplacement = IsXMLToken(rLocalName, XML_OBJECT ) || IsXMLToken(rLocalName, XML_OBJECT_OLE); 3591 setSupportsMultipleContents(IsXMLToken(rLocalName, XML_IMAGE)); 3592 3593 if(getSupportsMultipleContents()) 3594 { 3595 SdXMLGraphicObjectShapeContext* pGSC = dynamic_cast< SdXMLGraphicObjectShapeContext* >(pContext); 3596 3597 if(pGSC) 3598 { 3599 // mark context as LateAdd to avoid conflicts with multiple objects registering with the same ID 3600 pGSC->setLateAddToIdentifierMapper(true); 3601 addContent(*mxImplContext); 3602 } 3603 } 3604 } 3605 else if(getSupportsMultipleContents() && XML_NAMESPACE_DRAW == nPrefix && IsXMLToken(rLocalName, XML_IMAGE)) 3606 { 3607 // read another image 3608 pContext = GetImport().GetShapeImport()->CreateFrameChildContext( 3609 GetImport(), nPrefix, rLocalName, xAttrList, mxShapes, mxAttrList); 3610 mxImplContext = pContext; 3611 3612 SdXMLGraphicObjectShapeContext* pGSC = dynamic_cast< SdXMLGraphicObjectShapeContext* >(pContext); 3613 3614 if(pGSC) 3615 { 3616 // mark context as LateAdd to avoid conflicts with multiple objects registering with the same ID 3617 pGSC->setLateAddToIdentifierMapper(true); 3618 addContent(*mxImplContext); 3619 } 3620 } 3621 else if( mbSupportsReplacement && !mxReplImplContext && 3622 XML_NAMESPACE_DRAW == nPrefix && 3623 IsXMLToken( rLocalName, XML_IMAGE ) ) 3624 { 3625 // read replacement image 3626 SvXMLImportContext *pImplContext = &mxImplContext; 3627 SdXMLShapeContext *pSContext = 3628 PTR_CAST( SdXMLShapeContext, pImplContext ); 3629 if( pSContext ) 3630 { 3631 uno::Reference < beans::XPropertySet > xPropSet( 3632 pSContext->getShape(), uno::UNO_QUERY ); 3633 if( xPropSet.is() ) 3634 { 3635 pContext = new XMLReplacementImageContext( GetImport(), 3636 nPrefix, rLocalName, xAttrList, xPropSet ); 3637 mxReplImplContext = pContext; 3638 } 3639 } 3640 } 3641 else if( 3642 ( nPrefix == XML_NAMESPACE_SVG && // #i68101# 3643 (IsXMLToken( rLocalName, XML_TITLE ) || IsXMLToken( rLocalName, XML_DESC ) ) ) || 3644 (nPrefix == XML_NAMESPACE_OFFICE && IsXMLToken( rLocalName, XML_EVENT_LISTENERS ) ) || 3645 (nPrefix == XML_NAMESPACE_DRAW && (IsXMLToken( rLocalName, XML_GLUE_POINT ) || 3646 IsXMLToken( rLocalName, XML_THUMBNAIL ) ) ) ) 3647 { 3648 SvXMLImportContext *pImplContext = &mxImplContext; 3649 pContext = PTR_CAST( SdXMLShapeContext, pImplContext )->CreateChildContext( nPrefix, 3650 rLocalName, xAttrList ); 3651 } 3652 else if ( (XML_NAMESPACE_DRAW == nPrefix) && IsXMLToken( rLocalName, XML_IMAGE_MAP ) ) 3653 { 3654 SdXMLShapeContext *pSContext = dynamic_cast< SdXMLShapeContext* >( &mxImplContext ); 3655 if( pSContext ) 3656 { 3657 uno::Reference < beans::XPropertySet > xPropSet( pSContext->getShape(), uno::UNO_QUERY ); 3658 if (xPropSet.is()) 3659 { 3660 pContext = new XMLImageMapContext(GetImport(), nPrefix, rLocalName, xPropSet); 3661 } 3662 } 3663 } 3664 3665 // call parent for content 3666 if(!pContext) 3667 pContext = SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList ); 3668 3669 return pContext; 3670 } 3671 3672 void SdXMLFrameShapeContext::StartElement(const uno::Reference< xml::sax::XAttributeList>&) 3673 { 3674 // ignore 3675 } 3676 3677 void SdXMLFrameShapeContext::EndElement() 3678 { 3679 /// solve if multiple image child contexts were imported 3680 const SvXMLImportContext* pWinner = solveMultipleImages(); 3681 const SdXMLGraphicObjectShapeContext* pGSCWinner = dynamic_cast< const SdXMLGraphicObjectShapeContext* >(pWinner); 3682 3683 /// if we have a winner and it's on LateAdd, add it now 3684 if(pGSCWinner && pGSCWinner->getLateAddToIdentifierMapper() && pGSCWinner->getShapeId().getLength()) 3685 { 3686 uno::Reference< uno::XInterface > xRef( pGSCWinner->getShape(), uno::UNO_QUERY ); 3687 GetImport().getInterfaceToIdentifierMapper().registerReference( pGSCWinner->getShapeId(), xRef ); 3688 } 3689 3690 if( !mxImplContext.Is() ) 3691 { 3692 // now check if this is an empty presentation object 3693 sal_Int16 nAttrCount = mxAttrList.is() ? mxAttrList->getLength() : 0; 3694 for(sal_Int16 a(0); a < nAttrCount; a++) 3695 { 3696 OUString aLocalName; 3697 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName(mxAttrList->getNameByIndex(a), &aLocalName); 3698 3699 if( nPrefix == XML_NAMESPACE_PRESENTATION ) 3700 { 3701 if( IsXMLToken( aLocalName, XML_PLACEHOLDER ) ) 3702 { 3703 mbIsPlaceholder = IsXMLToken( mxAttrList->getValueByIndex(a), XML_TRUE ); 3704 } 3705 else if( IsXMLToken( aLocalName, XML_CLASS ) ) 3706 { 3707 maPresentationClass = mxAttrList->getValueByIndex(a); 3708 } 3709 } 3710 } 3711 3712 if( (maPresentationClass.getLength() != 0) && mbIsPlaceholder ) 3713 { 3714 uno::Reference< xml::sax::XAttributeList> xEmpty; 3715 3716 enum XMLTokenEnum eToken = XML_TEXT_BOX; 3717 3718 if( IsXMLToken( maPresentationClass, XML_GRAPHIC ) ) 3719 { 3720 eToken = XML_IMAGE; 3721 3722 } 3723 else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_PAGE ) ) 3724 { 3725 eToken = XML_PAGE_THUMBNAIL; 3726 } 3727 else if( IsXMLToken( maPresentationClass, XML_PRESENTATION_CHART ) || 3728 IsXMLToken( maPresentationClass, XML_PRESENTATION_TABLE ) || 3729 IsXMLToken( maPresentationClass, XML_PRESENTATION_OBJECT ) ) 3730 { 3731 eToken = XML_OBJECT; 3732 } 3733 3734 mxImplContext = GetImport().GetShapeImport()->CreateFrameChildContext( 3735 GetImport(), XML_NAMESPACE_DRAW, GetXMLToken( eToken ), mxAttrList, mxShapes, xEmpty ); 3736 3737 if( mxImplContext.Is() ) 3738 { 3739 mxImplContext->StartElement( mxAttrList ); 3740 mxImplContext->EndElement(); 3741 } 3742 } 3743 } 3744 3745 mxImplContext = 0; 3746 SdXMLShapeContext::EndElement(); 3747 } 3748 3749 void SdXMLFrameShapeContext::processAttribute( sal_uInt16, 3750 const ::rtl::OUString&, const ::rtl::OUString& ) 3751 { 3752 // ignore 3753 } 3754 3755 TYPEINIT1( SdXMLCustomShapeContext, SdXMLShapeContext ); 3756 3757 SdXMLCustomShapeContext::SdXMLCustomShapeContext( 3758 SvXMLImport& rImport, 3759 sal_uInt16 nPrfx, 3760 const OUString& rLocalName, 3761 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, 3762 uno::Reference< drawing::XShapes >& rShapes, 3763 sal_Bool bTemporaryShape) 3764 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, bTemporaryShape ) 3765 { 3766 } 3767 3768 ////////////////////////////////////////////////////////////////////////////// 3769 3770 SdXMLCustomShapeContext::~SdXMLCustomShapeContext() 3771 { 3772 } 3773 3774 ////////////////////////////////////////////////////////////////////////////// 3775 3776 // this is called from the parent group for each unparsed attribute in the attribute list 3777 void SdXMLCustomShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 3778 { 3779 if( XML_NAMESPACE_DRAW == nPrefix ) 3780 { 3781 if( IsXMLToken( rLocalName, XML_ENGINE ) ) 3782 { 3783 maCustomShapeEngine = rValue; 3784 return; 3785 } 3786 if ( IsXMLToken( rLocalName, XML_DATA ) ) 3787 { 3788 maCustomShapeData = rValue; 3789 return; 3790 } 3791 } 3792 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 3793 } 3794 3795 ////////////////////////////////////////////////////////////////////////////// 3796 3797 void SdXMLCustomShapeContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList ) 3798 { 3799 // create rectangle shape 3800 AddShape("com.sun.star.drawing.CustomShape"); 3801 if ( mxShape.is() ) 3802 { 3803 // Add, set Style and properties from base shape 3804 SetStyle(); 3805 SetLayer(); 3806 3807 // set pos, size, shear and rotate 3808 SetTransformation(); 3809 3810 try 3811 { 3812 uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY ); 3813 if( xPropSet.is() ) 3814 { 3815 if ( maCustomShapeEngine.getLength() ) 3816 { 3817 uno::Any aAny; 3818 aAny <<= maCustomShapeEngine; 3819 xPropSet->setPropertyValue( EASGet( EAS_CustomShapeEngine ), aAny ); 3820 } 3821 if ( maCustomShapeData.getLength() ) 3822 { 3823 uno::Any aAny; 3824 aAny <<= maCustomShapeData; 3825 xPropSet->setPropertyValue( EASGet( EAS_CustomShapeData ), aAny ); 3826 } 3827 } 3828 } 3829 catch( uno::Exception& ) 3830 { 3831 DBG_ERROR( "could not set enhanced customshape geometry" ); 3832 } 3833 SdXMLShapeContext::StartElement(xAttrList); 3834 } 3835 } 3836 3837 void SdXMLCustomShapeContext::EndElement() 3838 { 3839 // for backward compatibility, the above SetTransformation() may alraedy have 3840 // applied a call to SetMirroredX/SetMirroredY. This is not yet added to the 3841 // beans::PropertyValues in maCustomShapeGeometry. When applying these now, this 3842 // would be lost again. 3843 // TTTT: Remove again after aw080 3844 if(!maUsedTransformation.isIdentity()) 3845 { 3846 basegfx::B2DVector aScale, aTranslate; 3847 double fRotate, fShearX; 3848 3849 maUsedTransformation.decompose(aScale, aTranslate, fRotate, fShearX); 3850 3851 bool bFlippedX(aScale.getX() < 0.0); 3852 bool bFlippedY(aScale.getY() < 0.0); 3853 3854 if(bFlippedX && bFlippedY) 3855 { 3856 // when both are used it is the same as 180 degree rotation; reset 3857 bFlippedX = bFlippedY = false; 3858 } 3859 3860 if(bFlippedX || bFlippedY) 3861 { 3862 beans::PropertyValue aNewPoroperty; 3863 3864 if(bFlippedX) 3865 { 3866 aNewPoroperty.Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MirroredX")); 3867 } 3868 else 3869 { 3870 aNewPoroperty.Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MirroredY")); 3871 } 3872 3873 aNewPoroperty.Handle = -1; 3874 aNewPoroperty.Value <<= sal_True; 3875 aNewPoroperty.State = beans::PropertyState_DIRECT_VALUE; 3876 3877 maCustomShapeGeometry.push_back(aNewPoroperty); 3878 } 3879 } 3880 3881 if ( !maCustomShapeGeometry.empty() ) 3882 { 3883 const rtl::OUString sCustomShapeGeometry ( RTL_CONSTASCII_USTRINGPARAM( "CustomShapeGeometry" ) ); 3884 3885 // converting the vector to a sequence 3886 uno::Sequence< beans::PropertyValue > aSeq( maCustomShapeGeometry.size() ); 3887 beans::PropertyValue* pValues = aSeq.getArray(); 3888 std::vector< beans::PropertyValue >::const_iterator aIter( maCustomShapeGeometry.begin() ); 3889 std::vector< beans::PropertyValue >::const_iterator aEnd( maCustomShapeGeometry.end() ); 3890 while ( aIter != aEnd ) 3891 *pValues++ = *aIter++; 3892 3893 try 3894 { 3895 uno::Reference< beans::XPropertySet > xPropSet( mxShape, uno::UNO_QUERY ); 3896 if( xPropSet.is() ) 3897 { 3898 uno::Any aAny; 3899 aAny <<= aSeq; 3900 xPropSet->setPropertyValue( sCustomShapeGeometry, aAny ); 3901 } 3902 } 3903 catch( uno::Exception& ) 3904 { 3905 DBG_ERROR( "could not set enhanced customshape geometry" ); 3906 } 3907 3908 sal_Int32 nUPD( 0 ); 3909 sal_Int32 nBuild( 0 ); 3910 GetImport().getBuildIds( nUPD, nBuild ); 3911 if( ((nUPD >= 640 && nUPD <= 645) || (nUPD == 680)) && (nBuild <= 9221) ) 3912 { 3913 Reference< drawing::XEnhancedCustomShapeDefaulter > xDefaulter( mxShape, UNO_QUERY ); 3914 if( xDefaulter.is() ) 3915 { 3916 rtl::OUString aEmptyType; 3917 xDefaulter->createCustomShapeDefaults( aEmptyType ); 3918 } 3919 } 3920 } 3921 3922 SdXMLShapeContext::EndElement(); 3923 } 3924 3925 ////////////////////////////////////////////////////////////////////////////// 3926 3927 SvXMLImportContext* SdXMLCustomShapeContext::CreateChildContext( 3928 sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, 3929 const uno::Reference<xml::sax::XAttributeList>& xAttrList ) 3930 { 3931 SvXMLImportContext* pContext = NULL; 3932 if ( XML_NAMESPACE_DRAW == nPrefix ) 3933 { 3934 if ( IsXMLToken( rLocalName, XML_ENHANCED_GEOMETRY ) ) 3935 { 3936 uno::Reference< beans::XPropertySet > xPropSet( mxShape,uno::UNO_QUERY ); 3937 if ( xPropSet.is() ) 3938 pContext = new XMLEnhancedCustomShapeContext( GetImport(), mxShape, nPrefix, rLocalName, maCustomShapeGeometry ); 3939 } 3940 } 3941 // delegate to parent class if no context could be created 3942 if ( NULL == pContext ) 3943 pContext = SdXMLShapeContext::CreateChildContext( nPrefix, rLocalName, 3944 xAttrList); 3945 return pContext; 3946 } 3947 3948 /////////////////////////////////////////////////////////////////////// 3949 3950 ////////////////////////////////////////////////////////////////////////////// 3951 3952 TYPEINIT1( SdXMLTableShapeContext, SdXMLShapeContext ); 3953 3954 SdXMLTableShapeContext::SdXMLTableShapeContext( SvXMLImport& rImport, sal_uInt16 nPrfx, const rtl::OUString& rLocalName, const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList>& xAttrList, com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& rShapes ) 3955 : SdXMLShapeContext( rImport, nPrfx, rLocalName, xAttrList, rShapes, sal_False ) 3956 { 3957 memset( &maTemplateStylesUsed, 0, sizeof( maTemplateStylesUsed ) ); 3958 } 3959 3960 SdXMLTableShapeContext::~SdXMLTableShapeContext() 3961 { 3962 } 3963 3964 void SdXMLTableShapeContext::StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList ) 3965 { 3966 const char* pService = "com.sun.star.drawing.TableShape"; 3967 3968 sal_Bool bIsPresShape = maPresentationClass.getLength() && GetImport().GetShapeImport()->IsPresentationShapesSupported(); 3969 if( bIsPresShape ) 3970 { 3971 if( IsXMLToken( maPresentationClass, XML_PRESENTATION_TABLE ) ) 3972 { 3973 pService = "com.sun.star.presentation.TableShape"; 3974 } 3975 } 3976 3977 AddShape( pService ); 3978 3979 if( mxShape.is() ) 3980 { 3981 SetLayer(); 3982 3983 uno::Reference< beans::XPropertySet > xProps(mxShape, uno::UNO_QUERY); 3984 3985 if(bIsPresShape) 3986 { 3987 if(xProps.is()) 3988 { 3989 uno::Reference< beans::XPropertySetInfo > xPropsInfo( xProps->getPropertySetInfo() ); 3990 if( xPropsInfo.is() ) 3991 { 3992 if( !mbIsPlaceholder && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ))) 3993 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsEmptyPresentationObject") ), ::cppu::bool2any( sal_False ) ); 3994 3995 if( mbIsUserTransformed && xPropsInfo->hasPropertyByName(OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ))) 3996 xProps->setPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("IsPlaceholderDependent") ), ::cppu::bool2any( sal_False ) ); 3997 } 3998 } 3999 } 4000 4001 SetStyle(); 4002 4003 if( xProps.is() ) 4004 { 4005 if( msTemplateStyleName.getLength() ) try 4006 { 4007 Reference< XStyleFamiliesSupplier > xFamiliesSupp( GetImport().GetModel(), UNO_QUERY_THROW ); 4008 Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() ); 4009 const OUString sFamilyName( RTL_CONSTASCII_USTRINGPARAM("table" ) ); 4010 Reference< XNameAccess > xTableFamily( xFamilies->getByName( sFamilyName ), UNO_QUERY_THROW ); 4011 Reference< XStyle > xTableStyle( xTableFamily->getByName( msTemplateStyleName ), UNO_QUERY_THROW ); 4012 xProps->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TableTemplate" ) ), Any( xTableStyle ) ); 4013 } 4014 catch( Exception& ) 4015 { 4016 DBG_ERROR("SdXMLTableShapeContext::StartElement(), exception caught!"); 4017 } 4018 4019 const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; 4020 for( int i = 0; pEntry->msApiName && (i < 6); i++, pEntry++ ) 4021 { 4022 try 4023 { 4024 const OUString sAPIPropertyName( OUString(pEntry->msApiName, pEntry->nApiNameLength, RTL_TEXTENCODING_ASCII_US ) ); 4025 xProps->setPropertyValue( sAPIPropertyName, Any( maTemplateStylesUsed[i] ) ); 4026 } 4027 catch( Exception& ) 4028 { 4029 DBG_ERROR("SdXMLTableShapeContext::StartElement(), exception caught!"); 4030 } 4031 } 4032 } 4033 4034 GetImport().GetShapeImport()->finishShape( mxShape, mxAttrList, mxShapes ); 4035 4036 const rtl::Reference< XMLTableImport >& xTableImport( GetImport().GetShapeImport()->GetShapeTableImport() ); 4037 if( xTableImport.is() && xProps.is() ) 4038 { 4039 uno::Reference< table::XColumnRowRange > xColumnRowRange( 4040 xProps->getPropertyValue( OUString(RTL_CONSTASCII_USTRINGPARAM("Model") ) ), uno::UNO_QUERY ); 4041 4042 if( xColumnRowRange.is() ) 4043 mxTableImportContext = xTableImport->CreateTableContext( GetPrefix(), GetLocalName(), xColumnRowRange ); 4044 4045 if( mxTableImportContext.Is() ) 4046 mxTableImportContext->StartElement( xAttrList ); 4047 } 4048 } 4049 } 4050 4051 void SdXMLTableShapeContext::EndElement() 4052 { 4053 if( mxTableImportContext.Is() ) 4054 mxTableImportContext->EndElement(); 4055 4056 SdXMLShapeContext::EndElement(); 4057 4058 if( mxShape.is() ) 4059 { 4060 // set pos, size, shear and rotate 4061 SetTransformation(); 4062 } 4063 } 4064 4065 // this is called from the parent group for each unparsed attribute in the attribute list 4066 void SdXMLTableShapeContext::processAttribute( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const ::rtl::OUString& rValue ) 4067 { 4068 if( nPrefix == XML_NAMESPACE_TABLE ) 4069 { 4070 if( IsXMLToken( rLocalName, XML_TEMPLATE_NAME ) ) 4071 { 4072 msTemplateStyleName = rValue; 4073 } 4074 else 4075 { 4076 int i = 0; 4077 const XMLPropertyMapEntry* pEntry = &aXMLTableShapeAttributes[0]; 4078 while( pEntry->msApiName && (i < 6) ) 4079 { 4080 if( IsXMLToken( rLocalName, pEntry->meXMLName ) ) 4081 { 4082 if( IsXMLToken( rValue, XML_TRUE ) ) 4083 maTemplateStylesUsed[i] = sal_True; 4084 break; 4085 } 4086 pEntry++; 4087 i++; 4088 } 4089 } 4090 } 4091 SdXMLShapeContext::processAttribute( nPrefix, rLocalName, rValue ); 4092 } 4093 4094 SvXMLImportContext* SdXMLTableShapeContext::CreateChildContext( sal_uInt16 nPrefix, const ::rtl::OUString& rLocalName, const uno::Reference<xml::sax::XAttributeList>& xAttrList ) 4095 { 4096 if( mxTableImportContext.Is() && (nPrefix == XML_NAMESPACE_TABLE) ) 4097 return mxTableImportContext->CreateChildContext(nPrefix, rLocalName, xAttrList); 4098 else 4099 return SdXMLShapeContext::CreateChildContext(nPrefix, rLocalName, xAttrList); 4100 } 4101 4102