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 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_svx.hxx" 26 27 #define _ANIMATION 28 #include <unotools/streamwrap.hxx> 29 30 #include <sfx2/lnkbase.hxx> 31 #include <math.h> 32 #include <vcl/salbtype.hxx> 33 #include <sot/formats.hxx> 34 #include <sot/storage.hxx> 35 #include <unotools/ucbstreamhelper.hxx> 36 #include <unotools/localfilehelper.hxx> 37 #include <svl/style.hxx> 38 #include <svtools/filter.hxx> 39 #include <svl/urihelper.hxx> 40 #include <svtools/grfmgr.hxx> 41 #include <vcl/svapp.hxx> 42 43 #include <sfx2/linkmgr.hxx> 44 #include <sfx2/docfile.hxx> 45 #include <svx/svdetc.hxx> 46 #include "svx/svdglob.hxx" 47 #include "svx/svdstr.hrc" 48 #include <svx/svdpool.hxx> 49 #include <svx/svdmodel.hxx> 50 #include <svx/svdpage.hxx> 51 #include <svx/svdmrkv.hxx> 52 #include <svx/svdpagv.hxx> 53 #include "svx/svdviter.hxx" 54 #include <svx/svdview.hxx> 55 #include "svtools/filter.hxx" 56 #include <svx/svdograf.hxx> 57 #include <svx/svdogrp.hxx> 58 #include <svx/xbtmpit.hxx> 59 #include <svx/xflbmtit.hxx> 60 #include <svx/svdundo.hxx> 61 #include "svdfmtf.hxx" 62 #include <svx/sdgcpitm.hxx> 63 #include <editeng/eeitem.hxx> 64 #include <svx/sdr/properties/graphicproperties.hxx> 65 #include <svx/sdr/contact/viewcontactofgraphic.hxx> 66 #include <basegfx/polygon/b2dpolygon.hxx> 67 #include <basegfx/polygon/b2dpolygontools.hxx> 68 #include <osl/thread.hxx> 69 #include <vos/mutex.hxx> 70 #include <drawinglayer/processor2d/objectinfoextractor2d.hxx> 71 #include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx> 72 #include <unotools/cacheoptions.hxx> 73 #include <basegfx/matrix/b2dhommatrixtools.hxx> 74 75 using namespace ::com::sun::star::uno; 76 using namespace ::com::sun::star::io; 77 78 // ----------- 79 // - Defines - 80 // ----------- 81 82 #define GRAFSTREAMPOS_INVALID 0xffffffff 83 #define SWAPGRAPHIC_TIMEOUT 5000 84 85 // #122985# it is not correct to se the swap-timeout to a hard-coded 5000ms as it was before. 86 // Added code and experimented what to do as a good compromize, see description 87 sal_uInt32 getCacheTimeInMs() 88 { 89 static bool bSetAtAll(true); 90 91 if(bSetAtAll) 92 { 93 static bool bSetToPreferenceTime(true); 94 95 if(bSetToPreferenceTime) 96 { 97 const SvtCacheOptions aCacheOptions; 98 const sal_Int32 nSeconds(aCacheOptions.GetGraphicManagerObjectReleaseTime()); 99 100 // the default is 10 minutes. The minimum is one minute, thus 60 seconds. When the minimum 101 // should match to the former hard-coded 5 seconds, we have a divisor of 12 to use. For the 102 // default of 10 minutes this would mean 50 seconds. Compared to before this is ten times 103 // more (would allow better navigation by switching through pages) and is controllable 104 // by the user by setting the tools/options/memory/Remove_from_memory_after setting. Seems 105 // to be a good compromize to me. 106 return nSeconds * 1000 / 12; 107 } 108 else 109 { 110 return SWAPGRAPHIC_TIMEOUT; 111 } 112 } 113 114 return 0; 115 } 116 117 // ------------------ 118 // - SdrGraphicLink - 119 // ------------------ 120 121 122 const Graphic ImpLoadLinkedGraphic( const String aFileName, const String aFilterName ) 123 { 124 Graphic aGraphic; 125 126 SfxMedium xMed( aFileName, STREAM_STD_READ, sal_True ); 127 xMed.DownLoad(); 128 129 SvStream* pInStrm = xMed.GetInStream(); 130 if ( pInStrm ) 131 { 132 pInStrm->Seek( STREAM_SEEK_TO_BEGIN ); 133 GraphicFilter* pGF = GraphicFilter::GetGraphicFilter(); 134 135 const sal_uInt16 nFilter = aFilterName.Len() && pGF->GetImportFormatCount() 136 ? pGF->GetImportFormatNumber( aFilterName ) 137 : GRFILTER_FORMAT_DONTKNOW; 138 139 com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue > aFilterData( 1 ); 140 141 // Room for improvment: 142 // As this is a linked graphic the GfxLink is not needed if saving/loading our own format. 143 // But this link is required by some filters to access the native graphic (pdf export/ms export), 144 // there we should create a new service to provide this data if needed 145 aFilterData[ 0 ].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CreateNativeLink" ) ); 146 aFilterData[ 0 ].Value = Any( sal_True ); 147 148 // #123042# for e.g SVG the path is needed, so hand it over here. I have no real idea 149 // what consequences this may have; maybe this is not handed over by purpose here. Not 150 // handing it over means that any GraphicFormat that internallv needs a path as base 151 // to interpret included links may fail. 152 // Alternatively the path may be set at the result after this call when it is known 153 // that it is a SVG graphic, but only because noone yet tried to interpret it. 154 pGF->ImportGraphic( aGraphic, aFileName, *pInStrm, nFilter, NULL, 0, &aFilterData ); 155 } 156 return aGraphic; 157 } 158 159 class SdrGraphicUpdater; 160 class SdrGraphicLink : public sfx2::SvBaseLink 161 { 162 SdrGrafObj* pGrafObj; 163 SdrGraphicUpdater* pGraphicUpdater; 164 165 public: 166 SdrGraphicLink(SdrGrafObj* pObj); 167 virtual ~SdrGraphicLink(); 168 169 virtual void Closed(); 170 virtual void DataChanged( const String& rMimeType, 171 const ::com::sun::star::uno::Any & rValue ); 172 void DataChanged( const Graphic& rGraphic ); 173 174 sal_Bool Connect() { return 0 != GetRealObject(); } 175 void UpdateAsynchron(); 176 void RemoveGraphicUpdater(); 177 }; 178 179 class SdrGraphicUpdater : public ::osl::Thread 180 { 181 public: 182 SdrGraphicUpdater( const String& rFileName, const String& rFilterName, SdrGraphicLink& ); 183 virtual ~SdrGraphicUpdater( void ); 184 185 void SAL_CALL Terminate( void ); 186 187 sal_Bool GraphicLinkChanged( const String& rFileName ){ return maFileName != rFileName; }; 188 189 protected: 190 191 /** is called from the inherited create method and acts as the 192 main function of this thread. 193 */ 194 virtual void SAL_CALL run(void); 195 196 /** Called after the thread is terminated via the terminate 197 method. Used to kill the thread by calling delete on this. 198 */ 199 virtual void SAL_CALL onTerminated(void); 200 201 private: 202 203 const String maFileName; 204 const String maFilterName; 205 SdrGraphicLink& mrGraphicLink; 206 207 volatile bool mbIsTerminated; 208 }; 209 210 SdrGraphicUpdater::SdrGraphicUpdater( const String& rFileName, const String& rFilterName, SdrGraphicLink& rGraphicLink ) 211 : maFileName( rFileName ) 212 , maFilterName( rFilterName ) 213 , mrGraphicLink( rGraphicLink ) 214 , mbIsTerminated( sal_False ) 215 { 216 create(); 217 } 218 219 SdrGraphicUpdater::~SdrGraphicUpdater( void ) 220 { 221 } 222 223 void SdrGraphicUpdater::Terminate() 224 { 225 mbIsTerminated = sal_True; 226 } 227 228 void SAL_CALL SdrGraphicUpdater::onTerminated(void) 229 { 230 delete this; 231 } 232 233 void SAL_CALL SdrGraphicUpdater::run(void) 234 { 235 Graphic aGraphic( ImpLoadLinkedGraphic( maFileName, maFilterName ) ); 236 vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 237 if ( !mbIsTerminated ) 238 { 239 mrGraphicLink.DataChanged( aGraphic ); 240 mrGraphicLink.RemoveGraphicUpdater(); 241 } 242 } 243 244 // ----------------------------------------------------------------------------- 245 246 SdrGraphicLink::SdrGraphicLink(SdrGrafObj* pObj) 247 : ::sfx2::SvBaseLink( ::sfx2::LINKUPDATE_ONCALL, SOT_FORMATSTR_ID_SVXB ) 248 , pGrafObj( pObj ) 249 , pGraphicUpdater( NULL ) 250 { 251 SetSynchron( sal_False ); 252 } 253 254 // ----------------------------------------------------------------------------- 255 256 SdrGraphicLink::~SdrGraphicLink() 257 { 258 if ( pGraphicUpdater ) 259 pGraphicUpdater->Terminate(); 260 } 261 262 // ----------------------------------------------------------------------------- 263 264 void SdrGraphicLink::DataChanged( const Graphic& rGraphic ) 265 { 266 pGrafObj->ImpSetLinkedGraphic( rGraphic ); 267 } 268 269 // ----------------------------------------------------------------------------- 270 271 void SdrGraphicLink::RemoveGraphicUpdater() 272 { 273 pGraphicUpdater = NULL; 274 } 275 276 // ----------------------------------------------------------------------------- 277 278 void SdrGraphicLink::DataChanged( const String& rMimeType, 279 const ::com::sun::star::uno::Any & rValue ) 280 { 281 SdrModel* pModel = pGrafObj ? pGrafObj->GetModel() : 0; 282 sfx2::LinkManager* pLinkManager= pModel ? pModel->GetLinkManager() : 0; 283 284 if( pLinkManager && rValue.hasValue() ) 285 { 286 pLinkManager->GetDisplayNames( this, 0, &pGrafObj->aFileName, 0, &pGrafObj->aFilterName ); 287 288 Graphic aGraphic; 289 if( sfx2::LinkManager::GetGraphicFromAny( rMimeType, rValue, aGraphic )) 290 { 291 pGrafObj->NbcSetGraphic( aGraphic ); 292 pGrafObj->ActionChanged(); 293 } 294 else if( SotExchange::GetFormatIdFromMimeType( rMimeType ) != sfx2::LinkManager::RegisterStatusInfoId() ) 295 { 296 // broadcasting, to update slidesorter 297 pGrafObj->BroadcastObjectChange(); 298 } 299 } 300 } 301 302 // ----------------------------------------------------------------------------- 303 304 void SdrGraphicLink::Closed() 305 { 306 // Die Verbindung wird aufgehoben; pLink des Objekts auf NULL setzen, da die Link-Instanz ja gerade destruiert wird. 307 pGrafObj->ForceSwapIn(); 308 pGrafObj->pGraphicLink=NULL; 309 pGrafObj->ReleaseGraphicLink(); 310 SvBaseLink::Closed(); 311 } 312 313 // ----------------------------------------------------------------------------- 314 315 void SdrGraphicLink::UpdateAsynchron() 316 { 317 if( GetObj() ) 318 { 319 if ( pGraphicUpdater ) 320 { 321 if ( pGraphicUpdater->GraphicLinkChanged( pGrafObj->GetFileName() ) ) 322 { 323 pGraphicUpdater->Terminate(); 324 pGraphicUpdater = new SdrGraphicUpdater( pGrafObj->GetFileName(), pGrafObj->GetFilterName(), *this ); 325 } 326 } 327 else 328 pGraphicUpdater = new SdrGraphicUpdater( pGrafObj->GetFileName(), pGrafObj->GetFilterName(), *this ); 329 } 330 } 331 332 // -------------- 333 // - SdrGrafObj - 334 // -------------- 335 336 ////////////////////////////////////////////////////////////////////////////// 337 // BaseProperties section 338 339 sdr::properties::BaseProperties* SdrGrafObj::CreateObjectSpecificProperties() 340 { 341 return new sdr::properties::GraphicProperties(*this); 342 } 343 344 ////////////////////////////////////////////////////////////////////////////// 345 // DrawContact section 346 347 sdr::contact::ViewContact* SdrGrafObj::CreateObjectSpecificViewContact() 348 { 349 return new sdr::contact::ViewContactOfGraphic(*this); 350 } 351 352 ////////////////////////////////////////////////////////////////////////////// 353 // check if SVG and if try to get ObjectInfoPrimitive2D and extract info 354 355 void SdrGrafObj::onGraphicChanged() 356 { 357 String aName; 358 String aTitle; 359 String aDesc; 360 361 if(pGraphic) 362 { 363 const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData(); 364 365 if(rSvgDataPtr.get()) 366 { 367 const drawinglayer::primitive2d::Primitive2DSequence aSequence(rSvgDataPtr->getPrimitive2DSequence()); 368 369 if(aSequence.hasElements()) 370 { 371 drawinglayer::geometry::ViewInformation2D aViewInformation2D; 372 drawinglayer::processor2d::ObjectInfoPrimitiveExtractor2D aProcessor(aViewInformation2D); 373 374 aProcessor.process(aSequence); 375 376 const drawinglayer::primitive2d::ObjectInfoPrimitive2D* pResult = aProcessor.getResult(); 377 378 if(pResult) 379 { 380 aName = pResult->getName(); 381 aTitle = pResult->getTitle(); 382 aDesc = pResult->getDesc(); 383 } 384 } 385 } 386 } 387 388 if(aName.Len()) 389 { 390 SetName(aName); 391 } 392 393 if(aTitle.Len()) 394 { 395 SetTitle(aTitle); 396 } 397 398 if(aDesc.Len()) 399 { 400 SetDescription(aDesc); 401 } 402 } 403 404 ////////////////////////////////////////////////////////////////////////////// 405 406 TYPEINIT1(SdrGrafObj,SdrRectObj); 407 408 // ----------------------------------------------------------------------------- 409 410 SdrGrafObj::SdrGrafObj() 411 : SdrRectObj(), 412 pGraphicLink ( NULL ), 413 bMirrored ( sal_False ) 414 { 415 pGraphic = new GraphicObject; 416 mpReplacementGraphic = 0; 417 pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() ); 418 onGraphicChanged(); 419 420 // #i118485# Shear allowed and possible now 421 bNoShear = false; 422 423 // #111096# 424 mbGrafAnimationAllowed = sal_True; 425 426 // #i25616# 427 mbLineIsOutsideGeometry = sal_True; 428 mbInsidePaint = sal_False; 429 mbIsPreview = sal_False; 430 431 // #i25616# 432 mbSupportTextIndentingOnLineWidthChange = sal_False; 433 } 434 435 // ----------------------------------------------------------------------------- 436 437 SdrGrafObj::SdrGrafObj(const Graphic& rGrf, const Rectangle& rRect) 438 : SdrRectObj ( rRect ), 439 pGraphicLink ( NULL ), 440 bMirrored ( sal_False ) 441 { 442 pGraphic = new GraphicObject( rGrf ); 443 mpReplacementGraphic = 0; 444 pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() ); 445 onGraphicChanged(); 446 447 // #i118485# Shear allowed and possible now 448 bNoShear = false; 449 450 // #111096# 451 mbGrafAnimationAllowed = sal_True; 452 453 // #i25616# 454 mbLineIsOutsideGeometry = sal_True; 455 mbInsidePaint = sal_False; 456 mbIsPreview = sal_False; 457 458 // #i25616# 459 mbSupportTextIndentingOnLineWidthChange = sal_False; 460 } 461 462 // ----------------------------------------------------------------------------- 463 464 SdrGrafObj::SdrGrafObj( const Graphic& rGrf ) 465 : SdrRectObj(), 466 pGraphicLink ( NULL ), 467 bMirrored ( sal_False ) 468 { 469 pGraphic = new GraphicObject( rGrf ); 470 mpReplacementGraphic = 0; 471 pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() ); 472 onGraphicChanged(); 473 474 // #i118485# Shear allowed and possible now 475 bNoShear = false; 476 477 // #111096# 478 mbGrafAnimationAllowed = sal_True; 479 480 // #i25616# 481 mbLineIsOutsideGeometry = sal_True; 482 mbInsidePaint = sal_False; 483 mbIsPreview = sal_False; 484 485 // #i25616# 486 mbSupportTextIndentingOnLineWidthChange = sal_False; 487 } 488 489 // ----------------------------------------------------------------------------- 490 491 SdrGrafObj::~SdrGrafObj() 492 { 493 delete pGraphic; 494 delete mpReplacementGraphic; 495 ImpLinkAbmeldung(); 496 } 497 498 // ----------------------------------------------------------------------------- 499 500 void SdrGrafObj::SetGraphicObject( const GraphicObject& rGrfObj ) 501 { 502 *pGraphic = rGrfObj; 503 delete mpReplacementGraphic; 504 mpReplacementGraphic = 0; 505 pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() ); 506 pGraphic->SetUserData(); 507 mbIsPreview = sal_False; 508 SetChanged(); 509 BroadcastObjectChange(); 510 onGraphicChanged(); 511 } 512 513 // ----------------------------------------------------------------------------- 514 515 const GraphicObject& SdrGrafObj::GetGraphicObject(bool bForceSwapIn) const 516 { 517 if(bForceSwapIn) 518 { 519 ForceSwapIn(); 520 } 521 522 return *pGraphic; 523 } 524 525 const GraphicObject* SdrGrafObj::GetReplacementGraphicObject() const 526 { 527 if(!mpReplacementGraphic && pGraphic) 528 { 529 const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData(); 530 531 if(rSvgDataPtr.get()) 532 { 533 const_cast< SdrGrafObj* >(this)->mpReplacementGraphic = new GraphicObject(rSvgDataPtr->getReplacement()); 534 } 535 } 536 537 return mpReplacementGraphic; 538 } 539 540 // ----------------------------------------------------------------------------- 541 542 void SdrGrafObj::NbcSetGraphic( const Graphic& rGrf ) 543 { 544 pGraphic->SetGraphic( rGrf ); 545 delete mpReplacementGraphic; 546 mpReplacementGraphic = 0; 547 pGraphic->SetUserData(); 548 mbIsPreview = sal_False; 549 onGraphicChanged(); 550 } 551 552 void SdrGrafObj::SetGraphic( const Graphic& rGrf ) 553 { 554 NbcSetGraphic(rGrf); 555 SetChanged(); 556 BroadcastObjectChange(); 557 } 558 559 // ----------------------------------------------------------------------------- 560 561 const Graphic& SdrGrafObj::GetGraphic() const 562 { 563 ForceSwapIn(); 564 return pGraphic->GetGraphic(); 565 } 566 567 // ----------------------------------------------------------------------------- 568 569 Graphic SdrGrafObj::GetTransformedGraphic( sal_uIntPtr nTransformFlags ) const 570 { 571 // #107947# Refactored most of the code to GraphicObject, where 572 // everybody can use e.g. the cropping functionality 573 574 GraphicType eType = GetGraphicType(); 575 MapMode aDestMap( pModel->GetScaleUnit(), Point(), pModel->GetScaleFraction(), pModel->GetScaleFraction() ); 576 const Size aDestSize( GetLogicRect().GetSize() ); 577 const sal_Bool bMirror = ( nTransformFlags & SDRGRAFOBJ_TRANSFORMATTR_MIRROR ) != 0; 578 const sal_Bool bRotate = ( ( nTransformFlags & SDRGRAFOBJ_TRANSFORMATTR_ROTATE ) != 0 ) && 579 ( aGeo.nDrehWink && aGeo.nDrehWink != 18000 ) && ( GRAPHIC_NONE != eType ); 580 581 // #104115# Need cropping info earlier 582 ( (SdrGrafObj*) this )->ImpSetAttrToGrafInfo(); 583 GraphicAttr aActAttr; 584 585 if( SDRGRAFOBJ_TRANSFORMATTR_NONE != nTransformFlags && 586 GRAPHIC_NONE != eType ) 587 { 588 // actually transform the graphic only in this case. On the 589 // other hand, cropping will always happen 590 aActAttr = aGrafInfo; 591 592 if( bMirror ) 593 { 594 sal_uInt16 nMirrorCase = ( aGeo.nDrehWink == 18000 ) ? ( bMirrored ? 3 : 4 ) : ( bMirrored ? 2 : 1 ); 595 FASTBOOL bHMirr = nMirrorCase == 2 || nMirrorCase == 4; 596 FASTBOOL bVMirr = nMirrorCase == 3 || nMirrorCase == 4; 597 598 aActAttr.SetMirrorFlags( ( bHMirr ? BMP_MIRROR_HORZ : 0 ) | ( bVMirr ? BMP_MIRROR_VERT : 0 ) ); 599 } 600 601 if( bRotate ) 602 aActAttr.SetRotation( sal_uInt16(aGeo.nDrehWink / 10) ); 603 } 604 605 // #107947# Delegate to moved code in GraphicObject 606 return GetGraphicObject().GetTransformedGraphic( aDestSize, aDestMap, aActAttr ); 607 } 608 609 // ----------------------------------------------------------------------------- 610 611 GraphicType SdrGrafObj::GetGraphicType() const 612 { 613 return pGraphic->GetType(); 614 } 615 616 sal_Bool SdrGrafObj::IsAnimated() const 617 { 618 return pGraphic->IsAnimated(); 619 } 620 621 sal_Bool SdrGrafObj::IsEPS() const 622 { 623 return pGraphic->IsEPS(); 624 } 625 626 sal_Bool SdrGrafObj::IsSwappedOut() const 627 { 628 return mbIsPreview ? sal_True : pGraphic->IsSwappedOut(); 629 } 630 631 const MapMode& SdrGrafObj::GetGrafPrefMapMode() const 632 { 633 return pGraphic->GetPrefMapMode(); 634 } 635 636 const Size& SdrGrafObj::GetGrafPrefSize() const 637 { 638 return pGraphic->GetPrefSize(); 639 } 640 641 // ----------------------------------------------------------------------------- 642 643 void SdrGrafObj::SetGrafStreamURL( const String& rGraphicStreamURL ) 644 { 645 mbIsPreview = sal_False; 646 if( !rGraphicStreamURL.Len() ) 647 { 648 pGraphic->SetUserData(); 649 } 650 else if( pModel->IsSwapGraphics() ) 651 { 652 pGraphic->SetUserData( rGraphicStreamURL ); 653 654 // set state of graphic object to 'swapped out' 655 if( pGraphic->GetType() == GRAPHIC_NONE ) 656 pGraphic->SetSwapState(); 657 } 658 } 659 660 // ----------------------------------------------------------------------------- 661 662 String SdrGrafObj::GetGrafStreamURL() const 663 { 664 return pGraphic->GetUserData(); 665 } 666 667 // ----------------------------------------------------------------------------- 668 669 void SdrGrafObj::SetFileName(const String& rFileName) 670 { 671 aFileName = rFileName; 672 SetChanged(); 673 } 674 675 // ----------------------------------------------------------------------------- 676 677 void SdrGrafObj::SetFilterName(const String& rFilterName) 678 { 679 aFilterName = rFilterName; 680 SetChanged(); 681 } 682 683 // ----------------------------------------------------------------------------- 684 685 void SdrGrafObj::ForceSwapIn() const 686 { 687 if( mbIsPreview ) 688 { 689 // removing preview graphic 690 const String aUserData( pGraphic->GetUserData() ); 691 692 Graphic aEmpty; 693 pGraphic->SetGraphic( aEmpty ); 694 pGraphic->SetUserData( aUserData ); 695 pGraphic->SetSwapState(); 696 697 const_cast< SdrGrafObj* >( this )->mbIsPreview = sal_False; 698 } 699 if ( pGraphicLink && pGraphic->IsSwappedOut() ) 700 ImpUpdateGraphicLink( sal_False ); 701 else 702 pGraphic->FireSwapInRequest(); 703 704 if( pGraphic->IsSwappedOut() || 705 ( pGraphic->GetType() == GRAPHIC_NONE ) || 706 ( pGraphic->GetType() == GRAPHIC_DEFAULT ) ) 707 { 708 Graphic aDefaultGraphic; 709 aDefaultGraphic.SetDefaultType(); 710 pGraphic->SetGraphic( aDefaultGraphic ); 711 } 712 } 713 714 // ----------------------------------------------------------------------------- 715 716 void SdrGrafObj::ForceSwapOut() const 717 { 718 pGraphic->FireSwapOutRequest(); 719 } 720 721 // ----------------------------------------------------------------------------- 722 723 void SdrGrafObj::ImpLinkAnmeldung() 724 { 725 sfx2::LinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL; 726 727 if( pLinkManager != NULL && pGraphicLink == NULL ) 728 { 729 if( aFileName.Len() ) 730 { 731 pGraphicLink = new SdrGraphicLink( this ); 732 pLinkManager->InsertFileLink( *pGraphicLink, OBJECT_CLIENT_GRF, aFileName, ( aFilterName.Len() ? &aFilterName : NULL ), NULL ); 733 pGraphicLink->Connect(); 734 } 735 } 736 } 737 738 // ----------------------------------------------------------------------------- 739 740 void SdrGrafObj::ImpLinkAbmeldung() 741 { 742 sfx2::LinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL; 743 744 if( pLinkManager != NULL && pGraphicLink!=NULL) 745 { 746 // Bei Remove wird *pGraphicLink implizit deleted 747 pLinkManager->Remove( pGraphicLink ); 748 pGraphicLink=NULL; 749 } 750 } 751 752 // ----------------------------------------------------------------------------- 753 754 void SdrGrafObj::SetGraphicLink( const String& rFileName, const String& rFilterName ) 755 { 756 ImpLinkAbmeldung(); 757 aFileName = rFileName; 758 aFilterName = rFilterName; 759 ImpLinkAnmeldung(); 760 pGraphic->SetUserData(); 761 762 // #92205# A linked graphic is per definition swapped out (has to be loaded) 763 pGraphic->SetSwapState(); 764 } 765 766 // ----------------------------------------------------------------------------- 767 768 void SdrGrafObj::ReleaseGraphicLink() 769 { 770 ImpLinkAbmeldung(); 771 aFileName = String(); 772 aFilterName = String(); 773 } 774 775 // ----------------------------------------------------------------------------- 776 777 void SdrGrafObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const 778 { 779 FASTBOOL bNoPresGrf = ( pGraphic->GetType() != GRAPHIC_NONE ) && !bEmptyPresObj; 780 781 rInfo.bResizeFreeAllowed = aGeo.nDrehWink % 9000 == 0 || 782 aGeo.nDrehWink % 18000 == 0 || 783 aGeo.nDrehWink % 27000 == 0; 784 785 rInfo.bResizePropAllowed = sal_True; 786 rInfo.bRotateFreeAllowed = bNoPresGrf; 787 rInfo.bRotate90Allowed = bNoPresGrf; 788 rInfo.bMirrorFreeAllowed = bNoPresGrf; 789 rInfo.bMirror45Allowed = bNoPresGrf; 790 rInfo.bMirror90Allowed = !bEmptyPresObj; 791 rInfo.bTransparenceAllowed = sal_False; 792 rInfo.bGradientAllowed = sal_False; 793 794 // #i118485# Shear allowed and possible now 795 rInfo.bShearAllowed = true; 796 797 rInfo.bEdgeRadiusAllowed=sal_False; 798 rInfo.bCanConvToPath = !IsEPS(); 799 rInfo.bCanConvToPathLineToArea = sal_False; 800 rInfo.bCanConvToPolyLineToArea = sal_False; 801 rInfo.bCanConvToPoly = !IsEPS(); 802 rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary()); 803 } 804 805 // ----------------------------------------------------------------------------- 806 807 sal_uInt16 SdrGrafObj::GetObjIdentifier() const 808 { 809 return sal_uInt16( OBJ_GRAF ); 810 } 811 812 // ----------------------------------------------------------------------------- 813 814 /* The graphic of the GraphicLink will be loaded. If it is called with 815 bAsynchron = true then the graphic will be set later via DataChanged 816 */ 817 sal_Bool SdrGrafObj::ImpUpdateGraphicLink( sal_Bool bAsynchron ) const 818 { 819 sal_Bool bRet = sal_False; 820 if( pGraphicLink ) 821 { 822 sfx2::LinkManager *linkMgr = pGraphicLink->GetLinkManager(); 823 if ((linkMgr == NULL) || (linkMgr->GetUserAllowsLinkUpdate(NULL))) { 824 if ( bAsynchron ) 825 pGraphicLink->UpdateAsynchron(); 826 else 827 pGraphicLink->DataChanged( ImpLoadLinkedGraphic( aFileName, aFilterName ) ); 828 } // else links shall not be updated 829 bRet = sal_True; 830 } 831 return bRet; 832 } 833 834 // ----------------------------------------------------------------------------- 835 836 void SdrGrafObj::ImpSetLinkedGraphic( const Graphic& rGraphic ) 837 { 838 const sal_Bool bIsChanged = GetModel()->IsChanged(); 839 NbcSetGraphic( rGraphic ); 840 ActionChanged(); 841 BroadcastObjectChange(); 842 GetModel()->SetChanged( bIsChanged ); 843 } 844 845 // ----------------------------------------------------------------------------- 846 847 void SdrGrafObj::TakeObjNameSingul(XubString& rName) const 848 { 849 if(pGraphic) 850 { 851 const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData(); 852 853 if(rSvgDataPtr.get()) 854 { 855 rName = ImpGetResStr(STR_ObjNameSingulGRAFSVG); 856 } 857 else 858 { 859 switch( pGraphic->GetType() ) 860 { 861 case GRAPHIC_BITMAP: 862 { 863 const sal_uInt16 nId = ( ( pGraphic->IsTransparent() || ( (const SdrGrafTransparenceItem&) GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ? 864 ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPTRANSLNK : STR_ObjNameSingulGRAFBMPTRANS ) : 865 ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPLNK : STR_ObjNameSingulGRAFBMP ) ); 866 867 rName=ImpGetResStr( nId ); 868 } 869 break; 870 871 case GRAPHIC_GDIMETAFILE: 872 rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNameSingulGRAFMTFLNK : STR_ObjNameSingulGRAFMTF ); 873 break; 874 875 case GRAPHIC_NONE: 876 rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNameSingulGRAFNONELNK : STR_ObjNameSingulGRAFNONE ); 877 break; 878 879 default: 880 rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNameSingulGRAFLNK : STR_ObjNameSingulGRAF ); 881 break; 882 } 883 } 884 885 const String aName(GetName()); 886 887 if( aName.Len() ) 888 { 889 rName.AppendAscii( " '" ); 890 rName += aName; 891 rName += sal_Unicode( '\'' ); 892 } 893 } 894 } 895 896 // ----------------------------------------------------------------------------- 897 898 void SdrGrafObj::TakeObjNamePlural( XubString& rName ) const 899 { 900 if(pGraphic) 901 { 902 const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData(); 903 904 if(rSvgDataPtr.get()) 905 { 906 rName = ImpGetResStr(STR_ObjNamePluralGRAFSVG); 907 } 908 else 909 { 910 switch( pGraphic->GetType() ) 911 { 912 case GRAPHIC_BITMAP: 913 { 914 const sal_uInt16 nId = ( ( pGraphic->IsTransparent() || ( (const SdrGrafTransparenceItem&) GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ? 915 ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPTRANSLNK : STR_ObjNamePluralGRAFBMPTRANS ) : 916 ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPLNK : STR_ObjNamePluralGRAFBMP ) ); 917 918 rName=ImpGetResStr( nId ); 919 } 920 break; 921 922 case GRAPHIC_GDIMETAFILE: 923 rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNamePluralGRAFMTFLNK : STR_ObjNamePluralGRAFMTF ); 924 break; 925 926 case GRAPHIC_NONE: 927 rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNamePluralGRAFNONELNK : STR_ObjNamePluralGRAFNONE ); 928 break; 929 930 default: 931 rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNamePluralGRAFLNK : STR_ObjNamePluralGRAF ); 932 break; 933 } 934 } 935 936 const String aName(GetName()); 937 938 if( aName.Len() ) 939 { 940 rName.AppendAscii( " '" ); 941 rName += aName; 942 rName += sal_Unicode( '\'' ); 943 } 944 } 945 } 946 947 // ----------------------------------------------------------------------------- 948 949 SdrObject* SdrGrafObj::getFullDragClone() const 950 { 951 // call parent 952 SdrGrafObj* pRetval = static_cast< SdrGrafObj* >(SdrRectObj::getFullDragClone()); 953 954 // #i103116# the full drag clone leads to problems 955 // with linked graphics, so reset the link in this 956 // temporary interaction object and load graphic 957 if(pRetval && IsLinkedGraphic()) 958 { 959 pRetval->ForceSwapIn(); 960 pRetval->ReleaseGraphicLink(); 961 } 962 963 return pRetval; 964 } 965 966 void SdrGrafObj::operator=( const SdrObject& rObj ) 967 { 968 SdrRectObj::operator=( rObj ); 969 970 const SdrGrafObj& rGraf = (SdrGrafObj&) rObj; 971 972 pGraphic->SetGraphic( rGraf.GetGraphic(), &rGraf.GetGraphicObject() ); 973 aCropRect = rGraf.aCropRect; 974 aFileName = rGraf.aFileName; 975 aFilterName = rGraf.aFilterName; 976 bMirrored = rGraf.bMirrored; 977 978 if( rGraf.pGraphicLink != NULL) 979 { 980 SetGraphicLink( aFileName, aFilterName ); 981 } 982 983 ImpSetAttrToGrafInfo(); 984 } 985 986 // ----------------------------------------------------------------------------- 987 // #i25616# 988 989 basegfx::B2DPolyPolygon SdrGrafObj::TakeXorPoly() const 990 { 991 if(mbInsidePaint) 992 { 993 basegfx::B2DPolyPolygon aRetval; 994 995 // take grown rectangle 996 const sal_Int32 nHalfLineWidth(ImpGetLineWdt() / 2); 997 const Rectangle aGrownRect( 998 aRect.Left() - nHalfLineWidth, 999 aRect.Top() - nHalfLineWidth, 1000 aRect.Right() + nHalfLineWidth, 1001 aRect.Bottom() + nHalfLineWidth); 1002 1003 XPolygon aXPoly(ImpCalcXPoly(aGrownRect, GetEckenradius())); 1004 aRetval.append(aXPoly.getB2DPolygon()); 1005 1006 return aRetval; 1007 } 1008 else 1009 { 1010 // call parent 1011 return SdrRectObj::TakeXorPoly(); 1012 } 1013 } 1014 1015 // ----------------------------------------------------------------------------- 1016 1017 sal_uInt32 SdrGrafObj::GetHdlCount() const 1018 { 1019 return 8L; 1020 } 1021 1022 // ----------------------------------------------------------------------------- 1023 1024 SdrHdl* SdrGrafObj::GetHdl(sal_uInt32 nHdlNum) const 1025 { 1026 return SdrRectObj::GetHdl( nHdlNum + 1L ); 1027 } 1028 1029 // ----------------------------------------------------------------------------- 1030 1031 void SdrGrafObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact) 1032 { 1033 SdrRectObj::NbcResize( rRef, xFact, yFact ); 1034 1035 FASTBOOL bMirrX = xFact.GetNumerator() < 0; 1036 FASTBOOL bMirrY = yFact.GetNumerator() < 0; 1037 1038 if( bMirrX != bMirrY ) 1039 bMirrored = !bMirrored; 1040 } 1041 1042 // ----------------------------------------------------------------------------- 1043 1044 void SdrGrafObj::NbcRotate(const Point& rRef, long nWink, double sn, double cs) 1045 { 1046 SdrRectObj::NbcRotate(rRef,nWink,sn,cs); 1047 } 1048 1049 // ----------------------------------------------------------------------------- 1050 1051 void SdrGrafObj::NbcMirror(const Point& rRef1, const Point& rRef2) 1052 { 1053 SdrRectObj::NbcMirror(rRef1,rRef2); 1054 bMirrored = !bMirrored; 1055 } 1056 1057 // ----------------------------------------------------------------------------- 1058 1059 void SdrGrafObj::NbcShear(const Point& rRef, long nWink, double tn, FASTBOOL bVShear) 1060 { 1061 // #i118485# Call Shear now, old version redirected to rotate 1062 SdrRectObj::NbcShear(rRef, nWink, tn, bVShear); 1063 } 1064 1065 // ----------------------------------------------------------------------------- 1066 1067 void SdrGrafObj::NbcSetSnapRect(const Rectangle& rRect) 1068 { 1069 SdrRectObj::NbcSetSnapRect(rRect); 1070 } 1071 1072 // ----------------------------------------------------------------------------- 1073 1074 void SdrGrafObj::NbcSetLogicRect( const Rectangle& rRect) 1075 { 1076 //int bChg=rRect.GetSize()!=aRect.GetSize(); 1077 SdrRectObj::NbcSetLogicRect(rRect); 1078 } 1079 1080 // ----------------------------------------------------------------------------- 1081 1082 SdrObjGeoData* SdrGrafObj::NewGeoData() const 1083 { 1084 return new SdrGrafObjGeoData; 1085 } 1086 1087 // ----------------------------------------------------------------------------- 1088 1089 void SdrGrafObj::SaveGeoData(SdrObjGeoData& rGeo) const 1090 { 1091 SdrRectObj::SaveGeoData(rGeo); 1092 SdrGrafObjGeoData& rGGeo=(SdrGrafObjGeoData&)rGeo; 1093 rGGeo.bMirrored=bMirrored; 1094 } 1095 1096 // ----------------------------------------------------------------------------- 1097 1098 void SdrGrafObj::RestGeoData(const SdrObjGeoData& rGeo) 1099 { 1100 //long nDrehMerk = aGeo.nDrehWink; 1101 //long nShearMerk = aGeo.nShearWink; 1102 //int bMirrMerk = bMirrored; 1103 Size aSizMerk( aRect.GetSize() ); 1104 1105 SdrRectObj::RestGeoData(rGeo); 1106 SdrGrafObjGeoData& rGGeo=(SdrGrafObjGeoData&)rGeo; 1107 bMirrored=rGGeo.bMirrored; 1108 } 1109 1110 // ----------------------------------------------------------------------------- 1111 1112 void SdrGrafObj::SetPage( SdrPage* pNewPage ) 1113 { 1114 FASTBOOL bRemove = pNewPage == NULL && pPage != NULL; 1115 FASTBOOL bInsert = pNewPage != NULL && pPage == NULL; 1116 1117 if( bRemove ) 1118 { 1119 // hier kein SwapIn noetig, weil wenn nicht geladen, dann auch nicht animiert. 1120 if( pGraphic->IsAnimated()) 1121 pGraphic->StopAnimation(); 1122 1123 if( pGraphicLink != NULL ) 1124 ImpLinkAbmeldung(); 1125 } 1126 1127 if(!pModel && !GetStyleSheet() && pNewPage->GetModel()) 1128 { 1129 // #119287# Set default StyleSheet for SdrGrafObj here, it is different from 'Default'. This 1130 // needs to be done before the style 'Default' is set from the :SetModel() call which is triggered 1131 // from the following :SetPage(). 1132 // TTTT: Needs to be moved in branch aw080 due to having a SdrModel from the beginning, is at this 1133 // place for convenience currently (works in both versions, is not in the way) 1134 SfxStyleSheet* pSheet = pNewPage->GetModel()->GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj(); 1135 1136 if(pSheet) 1137 { 1138 SetStyleSheet(pSheet, false); 1139 } 1140 else 1141 { 1142 SetMergedItem(XFillStyleItem(XFILL_NONE)); 1143 SetMergedItem(XLineStyleItem(XLINE_NONE)); 1144 } 1145 } 1146 1147 SdrRectObj::SetPage( pNewPage ); 1148 1149 if(aFileName.Len() && bInsert) 1150 ImpLinkAnmeldung(); 1151 } 1152 1153 // ----------------------------------------------------------------------------- 1154 1155 void SdrGrafObj::SetModel( SdrModel* pNewModel ) 1156 { 1157 FASTBOOL bChg = pNewModel != pModel; 1158 1159 if( bChg ) 1160 { 1161 if( pGraphic->HasUserData() ) 1162 { 1163 ForceSwapIn(); 1164 pGraphic->SetUserData(); 1165 } 1166 1167 if( pGraphicLink != NULL ) 1168 ImpLinkAbmeldung(); 1169 } 1170 1171 // Model umsetzen 1172 SdrRectObj::SetModel(pNewModel); 1173 1174 if( bChg && aFileName.Len() ) 1175 ImpLinkAnmeldung(); 1176 } 1177 1178 // ----------------------------------------------------------------------------- 1179 1180 void SdrGrafObj::StartAnimation( OutputDevice* /*pOutDev*/, const Point& /*rPoint*/, const Size& /*rSize*/, long /*nExtraData*/) 1181 { 1182 // #111096# 1183 // use new graf animation 1184 SetGrafAnimationAllowed(sal_True); 1185 } 1186 1187 // ----------------------------------------------------------------------------- 1188 1189 void SdrGrafObj::StopAnimation(OutputDevice* /*pOutDev*/, long /*nExtraData*/) 1190 { 1191 // #111096# 1192 // use new graf animation 1193 SetGrafAnimationAllowed(sal_False); 1194 } 1195 1196 // ----------------------------------------------------------------------------- 1197 1198 FASTBOOL SdrGrafObj::HasGDIMetaFile() const 1199 { 1200 return( pGraphic->GetType() == GRAPHIC_GDIMETAFILE ); 1201 } 1202 1203 // ----------------------------------------------------------------------------- 1204 1205 const GDIMetaFile* SdrGrafObj::GetGDIMetaFile() const 1206 { 1207 DBG_ERROR( "Invalid return value! Don't use it! (KA)" ); 1208 return &GetGraphic().GetGDIMetaFile(); 1209 } 1210 1211 // ----------------------------------------------------------------------------- 1212 1213 bool SdrGrafObj::isEmbeddedSvg() const 1214 { 1215 return GRAPHIC_BITMAP == GetGraphicType() && GetGraphic().getSvgData().get(); 1216 } 1217 1218 GDIMetaFile SdrGrafObj::getMetafileFromEmbeddedSvg() const 1219 { 1220 GDIMetaFile aRetval; 1221 1222 if(isEmbeddedSvg() && GetModel()) 1223 { 1224 VirtualDevice aOut; 1225 const Rectangle aBoundRect(GetCurrentBoundRect()); 1226 const MapMode aMap(GetModel()->GetScaleUnit(), Point(), GetModel()->GetScaleFraction(), GetModel()->GetScaleFraction()); 1227 1228 aOut.EnableOutput(false); 1229 aOut.SetMapMode(aMap); 1230 aRetval.Record(&aOut); 1231 SingleObjectPainter(aOut); 1232 aRetval.Stop(); 1233 aRetval.WindStart(); 1234 aRetval.Move(-aBoundRect.Left(), -aBoundRect.Top()); 1235 aRetval.SetPrefMapMode(aMap); 1236 aRetval.SetPrefSize(aBoundRect.GetSize()); 1237 } 1238 1239 return aRetval; 1240 } 1241 1242 SdrObject* SdrGrafObj::DoConvertToPolyObj(sal_Bool bBezier, bool bAddText) const 1243 { 1244 SdrObject* pRetval = NULL; 1245 GraphicType aGraphicType(GetGraphicType()); 1246 GDIMetaFile aMtf; 1247 1248 if(isEmbeddedSvg()) 1249 { 1250 // Embedded Svg 1251 // There is currently no helper to create SdrObjects from primitives (even if I'm thinking 1252 // about writing one for some time). To get the roundtrip to SdrObjects it is necessary to 1253 // use the old converter path over the MetaFile mechanism. Create Metafile from Svg 1254 // primitives here pretty directly 1255 aMtf = getMetafileFromEmbeddedSvg(); 1256 aGraphicType = GRAPHIC_GDIMETAFILE; 1257 } 1258 else if(GRAPHIC_GDIMETAFILE == aGraphicType) 1259 { 1260 aMtf = GetTransformedGraphic(SDRGRAFOBJ_TRANSFORMATTR_COLOR|SDRGRAFOBJ_TRANSFORMATTR_MIRROR).GetGDIMetaFile(); 1261 } 1262 1263 switch(aGraphicType) 1264 { 1265 case GRAPHIC_GDIMETAFILE: 1266 { 1267 // NUR die aus dem MetaFile erzeugbaren Objekte in eine Gruppe packen und zurueckliefern 1268 ImpSdrGDIMetaFileImport aFilter(*GetModel(), GetLayer(), aRect); 1269 SdrObjGroup* pGrp = new SdrObjGroup(); 1270 sal_uInt32 nInsAnz = aFilter.DoImport(aMtf, *pGrp->GetSubList(), 0); 1271 1272 if(nInsAnz) 1273 { 1274 { 1275 // copy transformation 1276 GeoStat aGeoStat(GetGeoStat()); 1277 1278 if(aGeoStat.nShearWink) 1279 { 1280 aGeoStat.RecalcTan(); 1281 pGrp->NbcShear(aRect.TopLeft(), aGeoStat.nShearWink, aGeoStat.nTan, false); 1282 } 1283 1284 if(aGeoStat.nDrehWink) 1285 { 1286 aGeoStat.RecalcSinCos(); 1287 pGrp->NbcRotate(aRect.TopLeft(), aGeoStat.nDrehWink, aGeoStat.nSin, aGeoStat.nCos); 1288 } 1289 } 1290 1291 pRetval = pGrp; 1292 pGrp->NbcSetLayer(GetLayer()); 1293 pGrp->SetModel(GetModel()); 1294 1295 if(bAddText) 1296 { 1297 pRetval = ImpConvertAddText(pRetval, bBezier); 1298 } 1299 1300 // convert all children 1301 if( pRetval ) 1302 { 1303 SdrObject* pHalfDone = pRetval; 1304 pRetval = pHalfDone->DoConvertToPolyObj(bBezier, bAddText); 1305 SdrObject::Free( pHalfDone ); // resulting object is newly created 1306 1307 if( pRetval ) 1308 { 1309 // flatten subgroups. As we call 1310 // DoConvertToPolyObj() on the resulting group 1311 // objects, subgroups can exist (e.g. text is 1312 // a group object for every line). 1313 SdrObjList* pList = pRetval->GetSubList(); 1314 if( pList ) 1315 pList->FlattenGroups(); 1316 } 1317 } 1318 } 1319 else 1320 { 1321 delete pGrp; 1322 } 1323 1324 // #i118485# convert line and fill 1325 SdrObject* pLineFill = SdrRectObj::DoConvertToPolyObj(bBezier, false); 1326 1327 if(pLineFill) 1328 { 1329 if(pRetval) 1330 { 1331 pGrp = dynamic_cast< SdrObjGroup* >(pRetval); 1332 1333 if(!pGrp) 1334 { 1335 pGrp = new SdrObjGroup(); 1336 1337 pGrp->NbcSetLayer(GetLayer()); 1338 pGrp->SetModel(GetModel()); 1339 pGrp->GetSubList()->NbcInsertObject(pRetval); 1340 } 1341 1342 pGrp->GetSubList()->NbcInsertObject(pLineFill, 0); 1343 } 1344 else 1345 { 1346 pRetval = pLineFill; 1347 } 1348 } 1349 1350 break; 1351 } 1352 case GRAPHIC_BITMAP: 1353 { 1354 // Grundobjekt kreieren und Fuellung ergaenzen 1355 pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText); 1356 1357 // Bitmap als Attribut retten 1358 if(pRetval) 1359 { 1360 // Bitmap als Fuellung holen 1361 SfxItemSet aSet(GetObjectItemSet()); 1362 1363 aSet.Put(XFillStyleItem(XFILL_BITMAP)); 1364 const BitmapEx aBitmapEx(GetTransformedGraphic().GetBitmapEx()); 1365 aSet.Put(XFillBitmapItem(String(), Graphic(aBitmapEx))); 1366 aSet.Put(XFillBmpTileItem(false)); 1367 1368 pRetval->SetMergedItemSet(aSet); 1369 } 1370 break; 1371 } 1372 case GRAPHIC_NONE: 1373 case GRAPHIC_DEFAULT: 1374 { 1375 pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText); 1376 break; 1377 } 1378 } 1379 1380 return pRetval; 1381 } 1382 1383 // ----------------------------------------------------------------------------- 1384 1385 void SdrGrafObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) 1386 { 1387 SetXPolyDirty(); 1388 SdrRectObj::Notify( rBC, rHint ); 1389 ImpSetAttrToGrafInfo(); 1390 } 1391 1392 void SdrGrafObj::ImpSetAttrToGrafInfo() 1393 { 1394 const SfxItemSet& rSet = GetObjectItemSet(); 1395 const sal_uInt16 nTrans = ( (SdrGrafTransparenceItem&) rSet.Get( SDRATTR_GRAFTRANSPARENCE ) ).GetValue(); 1396 const SdrGrafCropItem& rCrop = (const SdrGrafCropItem&) rSet.Get( SDRATTR_GRAFCROP ); 1397 1398 aGrafInfo.SetLuminance( ( (SdrGrafLuminanceItem&) rSet.Get( SDRATTR_GRAFLUMINANCE ) ).GetValue() ); 1399 aGrafInfo.SetContrast( ( (SdrGrafContrastItem&) rSet.Get( SDRATTR_GRAFCONTRAST ) ).GetValue() ); 1400 aGrafInfo.SetChannelR( ( (SdrGrafRedItem&) rSet.Get( SDRATTR_GRAFRED ) ).GetValue() ); 1401 aGrafInfo.SetChannelG( ( (SdrGrafGreenItem&) rSet.Get( SDRATTR_GRAFGREEN ) ).GetValue() ); 1402 aGrafInfo.SetChannelB( ( (SdrGrafBlueItem&) rSet.Get( SDRATTR_GRAFBLUE ) ).GetValue() ); 1403 aGrafInfo.SetGamma( ( (SdrGrafGamma100Item&) rSet.Get( SDRATTR_GRAFGAMMA ) ).GetValue() * 0.01 ); 1404 aGrafInfo.SetTransparency( (sal_uInt8) FRound( Min( nTrans, (sal_uInt16) 100 ) * 2.55 ) ); 1405 aGrafInfo.SetInvert( ( (SdrGrafInvertItem&) rSet.Get( SDRATTR_GRAFINVERT ) ).GetValue() ); 1406 aGrafInfo.SetDrawMode( ( (SdrGrafModeItem&) rSet.Get( SDRATTR_GRAFMODE ) ).GetValue() ); 1407 aGrafInfo.SetCrop( rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom() ); 1408 1409 SetXPolyDirty(); 1410 SetRectsDirty(); 1411 } 1412 1413 // ----------------------------------------------------------------------------- 1414 1415 void SdrGrafObj::ImpSetGrafInfoToAttr() 1416 { 1417 SetObjectItem( SdrGrafLuminanceItem( aGrafInfo.GetLuminance() ) ); 1418 SetObjectItem( SdrGrafContrastItem( aGrafInfo.GetContrast() ) ); 1419 SetObjectItem( SdrGrafRedItem( aGrafInfo.GetChannelR() ) ); 1420 SetObjectItem( SdrGrafGreenItem( aGrafInfo.GetChannelG() ) ); 1421 SetObjectItem( SdrGrafBlueItem( aGrafInfo.GetChannelB() ) ); 1422 SetObjectItem( SdrGrafGamma100Item( FRound( aGrafInfo.GetGamma() * 100.0 ) ) ); 1423 SetObjectItem( SdrGrafTransparenceItem( (sal_uInt16) FRound( aGrafInfo.GetTransparency() / 2.55 ) ) ); 1424 SetObjectItem( SdrGrafInvertItem( aGrafInfo.IsInvert() ) ); 1425 SetObjectItem( SdrGrafModeItem( aGrafInfo.GetDrawMode() ) ); 1426 SetObjectItem( SdrGrafCropItem( aGrafInfo.GetLeftCrop(), aGrafInfo.GetTopCrop(), aGrafInfo.GetRightCrop(), aGrafInfo.GetBottomCrop() ) ); 1427 } 1428 1429 // ----------------------------------------------------------------------------- 1430 1431 void SdrGrafObj::AdjustToMaxRect( const Rectangle& rMaxRect, bool bShrinkOnly ) 1432 { 1433 Size aSize; 1434 Size aMaxSize( rMaxRect.GetSize() ); 1435 if ( pGraphic->GetPrefMapMode().GetMapUnit() == MAP_PIXEL ) 1436 aSize = Application::GetDefaultDevice()->PixelToLogic( pGraphic->GetPrefSize(), MAP_100TH_MM ); 1437 else 1438 aSize = OutputDevice::LogicToLogic( pGraphic->GetPrefSize(), 1439 pGraphic->GetPrefMapMode(), 1440 MapMode( MAP_100TH_MM ) ); 1441 1442 if( aSize.Height() != 0 && aSize.Width() != 0 ) 1443 { 1444 Point aPos( rMaxRect.TopLeft() ); 1445 1446 // Falls Grafik zu gross, wird die Grafik 1447 // in die Seite eingepasst 1448 if ( (!bShrinkOnly || 1449 ( aSize.Height() > aMaxSize.Height() ) || 1450 ( aSize.Width() > aMaxSize.Width() ) )&& 1451 aSize.Height() && aMaxSize.Height() ) 1452 { 1453 float fGrfWH = (float)aSize.Width() / 1454 (float)aSize.Height(); 1455 float fWinWH = (float)aMaxSize.Width() / 1456 (float)aMaxSize.Height(); 1457 1458 // Grafik an Pagesize anpassen (skaliert) 1459 if ( fGrfWH < fWinWH ) 1460 { 1461 aSize.Width() = (long)(aMaxSize.Height() * fGrfWH); 1462 aSize.Height()= aMaxSize.Height(); 1463 } 1464 else if ( fGrfWH > 0.F ) 1465 { 1466 aSize.Width() = aMaxSize.Width(); 1467 aSize.Height()= (long)(aMaxSize.Width() / fGrfWH); 1468 } 1469 1470 aPos = rMaxRect.Center(); 1471 } 1472 1473 if( bShrinkOnly ) 1474 aPos = aRect.TopLeft(); 1475 1476 aPos.X() -= aSize.Width() / 2; 1477 aPos.Y() -= aSize.Height() / 2; 1478 SetLogicRect( Rectangle( aPos, aSize ) ); 1479 } 1480 } 1481 1482 // ----------------------------------------------------------------------------- 1483 1484 IMPL_LINK( SdrGrafObj, ImpSwapHdl, GraphicObject*, pO ) 1485 { 1486 SvStream* pRet = GRFMGR_AUTOSWAPSTREAM_NONE; 1487 1488 if( pO->IsInSwapOut() ) 1489 { 1490 if( pModel && !mbIsPreview && pModel->IsSwapGraphics() && pGraphic->GetSizeBytes() > 20480 ) 1491 { 1492 // test if this object is visualized from someone 1493 // ## test only if there are VOCs other than the preview renderer 1494 if(!GetViewContact().HasViewObjectContacts(true)) 1495 { 1496 const sal_uIntPtr nSwapMode = pModel->GetSwapGraphicsMode(); 1497 1498 if( ( pGraphic->HasUserData() || pGraphicLink ) && 1499 ( nSwapMode & SDR_SWAPGRAPHICSMODE_PURGE ) ) 1500 { 1501 pRet = GRFMGR_AUTOSWAPSTREAM_LINK; 1502 } 1503 else if( nSwapMode & SDR_SWAPGRAPHICSMODE_TEMP ) 1504 { 1505 pRet = GRFMGR_AUTOSWAPSTREAM_TEMP; 1506 pGraphic->SetUserData(); 1507 } 1508 1509 // #i102380# 1510 sdr::contact::ViewContactOfGraphic* pVC = dynamic_cast< sdr::contact::ViewContactOfGraphic* >(&GetViewContact()); 1511 1512 if(pVC) 1513 { 1514 pVC->flushGraphicObjects(); 1515 } 1516 } 1517 } 1518 } 1519 else if( pO->IsInSwapIn() ) 1520 { 1521 // kann aus dem original Doc-Stream nachgeladen werden... 1522 if( pModel != NULL ) 1523 { 1524 if( pGraphic->HasUserData() ) 1525 { 1526 SdrDocumentStreamInfo aStreamInfo; 1527 1528 aStreamInfo.mbDeleteAfterUse = sal_False; 1529 aStreamInfo.maUserData = pGraphic->GetUserData(); 1530 1531 SvStream* pStream = pModel->GetDocumentStream( aStreamInfo ); 1532 1533 if( pStream != NULL ) 1534 { 1535 Graphic aGraphic; 1536 1537 com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >* pFilterData = NULL; 1538 1539 if(mbInsidePaint && !GetViewContact().HasViewObjectContacts(true)) 1540 { 1541 pFilterData = new com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >( 3 ); 1542 1543 const com::sun::star::awt::Size aPreviewSizeHint( 64, 64 ); 1544 const sal_Bool bAllowPartialStreamRead = sal_True; 1545 // create <GfxLink> instance also for previews in order to avoid that its corresponding 1546 // data is cleared in the graphic cache entry in case that the preview data equals the complete graphic data 1547 const sal_Bool bCreateNativeLink = sal_True; 1548 (*pFilterData)[ 0 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "PreviewSizeHint" ) ); 1549 (*pFilterData)[ 0 ].Value <<= aPreviewSizeHint; 1550 (*pFilterData)[ 1 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "AllowPartialStreamRead" ) ); 1551 (*pFilterData)[ 1 ].Value <<= bAllowPartialStreamRead; 1552 (*pFilterData)[ 2 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "CreateNativeLink" ) ); 1553 (*pFilterData)[ 2 ].Value <<= bCreateNativeLink; 1554 1555 mbIsPreview = sal_True; 1556 } 1557 1558 if(!GraphicFilter::GetGraphicFilter()->ImportGraphic( 1559 aGraphic, aStreamInfo.maUserData, *pStream, 1560 GRFILTER_FORMAT_DONTKNOW, NULL, 0, pFilterData)) 1561 { 1562 const String aUserData( pGraphic->GetUserData() ); 1563 1564 pGraphic->SetGraphic( aGraphic ); 1565 pGraphic->SetUserData( aUserData ); 1566 1567 // #142146# Graphic successfully swapped in. 1568 pRet = GRFMGR_AUTOSWAPSTREAM_LOADED; 1569 } 1570 delete pFilterData; 1571 1572 pStream->ResetError(); 1573 1574 if( aStreamInfo.mbDeleteAfterUse || aStreamInfo.mxStorageRef.is() ) 1575 { 1576 if ( aStreamInfo.mxStorageRef.is() ) 1577 { 1578 aStreamInfo.mxStorageRef->dispose(); 1579 aStreamInfo.mxStorageRef = 0; 1580 } 1581 1582 delete pStream; 1583 } 1584 } 1585 } 1586 else if( !ImpUpdateGraphicLink( sal_False ) ) 1587 { 1588 pRet = GRFMGR_AUTOSWAPSTREAM_TEMP; 1589 } 1590 else 1591 { 1592 pRet = GRFMGR_AUTOSWAPSTREAM_LOADED; 1593 } 1594 } 1595 else 1596 pRet = GRFMGR_AUTOSWAPSTREAM_TEMP; 1597 } 1598 1599 return (long)(void*) pRet; 1600 } 1601 1602 // ----------------------------------------------------------------------------- 1603 1604 // #111096# 1605 // Access to GrafAnimationAllowed flag 1606 sal_Bool SdrGrafObj::IsGrafAnimationAllowed() const 1607 { 1608 return mbGrafAnimationAllowed; 1609 } 1610 1611 void SdrGrafObj::SetGrafAnimationAllowed(sal_Bool bNew) 1612 { 1613 if(mbGrafAnimationAllowed != bNew) 1614 { 1615 mbGrafAnimationAllowed = bNew; 1616 ActionChanged(); 1617 } 1618 } 1619 1620 // #i25616# 1621 sal_Bool SdrGrafObj::IsObjectTransparent() const 1622 { 1623 if(((const SdrGrafTransparenceItem&)GetObjectItem(SDRATTR_GRAFTRANSPARENCE)).GetValue() 1624 || pGraphic->IsTransparent()) 1625 { 1626 return sal_True; 1627 } 1628 1629 return sal_False; 1630 } 1631 1632 Reference< XInputStream > SdrGrafObj::getInputStream() 1633 { 1634 Reference< XInputStream > xStream; 1635 1636 if( pModel ) 1637 { 1638 // if( !pGraphic->HasUserData() ) 1639 // pGraphic->SwapOut(); 1640 1641 // kann aus dem original Doc-Stream nachgeladen werden... 1642 if( pGraphic->HasUserData() ) 1643 { 1644 SdrDocumentStreamInfo aStreamInfo; 1645 1646 aStreamInfo.mbDeleteAfterUse = sal_False; 1647 aStreamInfo.maUserData = pGraphic->GetUserData(); 1648 1649 SvStream* pStream = pModel->GetDocumentStream( aStreamInfo ); 1650 1651 if( pStream ) 1652 xStream.set( new utl::OInputStreamWrapper( pStream, sal_True ) ); 1653 } 1654 else if( pGraphic && GetGraphic().IsLink() ) 1655 { 1656 Graphic aGraphic( GetGraphic() ); 1657 GfxLink aLink( aGraphic.GetLink() ); 1658 sal_uInt32 nSize = aLink.GetDataSize(); 1659 const void* pSourceData = (const void*)aLink.GetData(); 1660 if( nSize && pSourceData ) 1661 { 1662 sal_uInt8 * pBuffer = new sal_uInt8[ nSize ]; 1663 if( pBuffer ) 1664 { 1665 memcpy( pBuffer, pSourceData, nSize ); 1666 1667 SvMemoryStream* pStream = new SvMemoryStream( (void*)pBuffer, (sal_Size)nSize, STREAM_READ ); 1668 pStream->ObjectOwnsMemory( sal_True ); 1669 xStream.set( new utl::OInputStreamWrapper( pStream, sal_True ) ); 1670 } 1671 } 1672 } 1673 1674 if( !xStream.is() && aFileName.Len() ) 1675 { 1676 SvFileStream* pStream = new SvFileStream( aFileName, STREAM_READ ); 1677 if( pStream ) 1678 xStream.set( new utl::OInputStreamWrapper( pStream ) ); 1679 } 1680 } 1681 1682 return xStream; 1683 } 1684 1685 // moved crop handle creation here; this is the object type using them 1686 void SdrGrafObj::addCropHandles(SdrHdlList& rTarget) const 1687 { 1688 basegfx::B2DHomMatrix aMatrix; 1689 basegfx::B2DPolyPolygon aPolyPolygon; 1690 1691 // get object transformation 1692 TRGetBaseGeometry(aMatrix, aPolyPolygon); 1693 1694 // part of object transformation correction, but used later, so defined outside next scope 1695 double fShearX(0.0), fRotate(0.0); 1696 1697 { // TTTT correct shear, it comes currently mirrored from TRGetBaseGeometry, can be removed with aw080 1698 basegfx::B2DTuple aScale; 1699 basegfx::B2DTuple aTranslate; 1700 1701 aMatrix.decompose(aScale, aTranslate, fRotate, fShearX); 1702 1703 if(!basegfx::fTools::equalZero(fShearX)) 1704 { 1705 // shearX is used, correct it 1706 fShearX = -fShearX; 1707 } 1708 1709 aMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix( 1710 aScale, 1711 fShearX, 1712 fRotate, 1713 aTranslate); 1714 } 1715 1716 // get crop values 1717 const SdrGrafCropItem& rCrop = static_cast< const SdrGrafCropItem& >(GetMergedItem(SDRATTR_GRAFCROP)); 1718 1719 if(rCrop.GetLeft() || rCrop.GetTop() || rCrop.GetRight() ||rCrop.GetBottom()) 1720 { 1721 // decompose object transformation to have current translate and scale 1722 basegfx::B2DVector aScale, aTranslate; 1723 double fRotate, fShearX; 1724 1725 aMatrix.decompose(aScale, aTranslate, fRotate, fShearX); 1726 1727 if(!aScale.equalZero()) 1728 { 1729 // get crop scale 1730 const basegfx::B2DVector aCropScaleFactor( 1731 GetGraphicObject().calculateCropScaling( 1732 aScale.getX(), 1733 aScale.getY(), 1734 rCrop.GetLeft(), 1735 rCrop.GetTop(), 1736 rCrop.GetRight(), 1737 rCrop.GetBottom())); 1738 1739 // apply crop scale 1740 const double fCropLeft(rCrop.GetLeft() * aCropScaleFactor.getX()); 1741 const double fCropTop(rCrop.GetTop() * aCropScaleFactor.getY()); 1742 const double fCropRight(rCrop.GetRight() * aCropScaleFactor.getX()); 1743 const double fCropBottom(rCrop.GetBottom() * aCropScaleFactor.getY()); 1744 basegfx::B2DHomMatrix aMatrixForCropViewHdl(aMatrix); 1745 1746 if(IsMirrored()) 1747 { 1748 // create corrected new matrix, TTTT can be removed with aw080 1749 // the old mirror only can mirror horizontally; the vertical mirror 1750 // is faked by using the horizontal and 180 degree rotation. Since 1751 // the object can be rotated differently from 180 degree, this is 1752 // not safe to detect. Just correct horizontal mirror (which is 1753 // in IsMirrored()) and keep the rotation angle 1754 // caution: Do not modify aMatrix, it is used below to calculate 1755 // the exact handle positions 1756 basegfx::B2DHomMatrix aPreMultiply; 1757 1758 // mirrored X, apply 1759 aPreMultiply.translate(-0.5, 0.0); 1760 aPreMultiply.scale(-1.0, 1.0); 1761 aPreMultiply.translate(0.5, 0.0); 1762 1763 aMatrixForCropViewHdl = aMatrixForCropViewHdl * aPreMultiply; 1764 } 1765 1766 rTarget.AddHdl( 1767 new SdrCropViewHdl( 1768 aMatrixForCropViewHdl, 1769 GetGraphicObject().GetGraphic(), 1770 fCropLeft, 1771 fCropTop, 1772 fCropRight, 1773 fCropBottom)); 1774 } 1775 } 1776 1777 basegfx::B2DPoint aPos; 1778 1779 aPos = aMatrix * basegfx::B2DPoint(0.0, 0.0); 1780 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPLFT, fShearX, fRotate)); 1781 aPos = aMatrix * basegfx::B2DPoint(0.5, 0.0); 1782 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPPER, fShearX, fRotate)); 1783 aPos = aMatrix * basegfx::B2DPoint(1.0, 0.0); 1784 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPRGT, fShearX, fRotate)); 1785 aPos = aMatrix * basegfx::B2DPoint(0.0, 0.5); 1786 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LEFT , fShearX, fRotate)); 1787 aPos = aMatrix * basegfx::B2DPoint(1.0, 0.5); 1788 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_RIGHT, fShearX, fRotate)); 1789 aPos = aMatrix * basegfx::B2DPoint(0.0, 1.0); 1790 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LWLFT, fShearX, fRotate)); 1791 aPos = aMatrix * basegfx::B2DPoint(0.5, 1.0); 1792 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LOWER, fShearX, fRotate)); 1793 aPos = aMatrix * basegfx::B2DPoint(1.0, 1.0); 1794 rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LWRGT, fShearX, fRotate)); 1795 } 1796 1797 // eof 1798