svx/source/svdraw/svdograf.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: svdograf.cxx,v $
  10  * $Revision: 1.84.18.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #define _ANIMATION
  35 #include <unotools/streamwrap.hxx>
  36
  37 #include <sfx2/lnkbase.hxx>
  38 #include <math.h>
  39 #include <vcl/salbtype.hxx>
  40 #include <sot/formats.hxx>
  41 #include <sot/storage.hxx>
  42 #include <unotools/ucbstreamhelper.hxx>
  43 #include <unotools/localfilehelper.hxx>
  44 #include <svtools/style.hxx>
  45 #include <svtools/filter.hxx>
  46 #include <svtools/urihelper.hxx>
  47 #include <goodies/grfmgr.hxx>
  48 #include <vcl/svapp.hxx>
  49
  50 #include "linkmgr.hxx"
  51 #include <svx/svdetc.hxx>
  52 #include "svdglob.hxx"
  53 #include "svdstr.hrc"
  54 #include <svx/svdpool.hxx>
  55 #include <svx/svdmodel.hxx>
  56 #include <svx/svdpage.hxx>
  57 #include <svx/svdmrkv.hxx>
  58 #include <svx/svdpagv.hxx>
  59 #include "svdviter.hxx"
  60 #include <svx/svdview.hxx>
  61 #include "impgrf.hxx"
  62 #include <svx/svdograf.hxx>
  63 #include <svx/svdogrp.hxx>
  64 #include <svx/xbitmap.hxx>
  65 #include <svx/xbtmpit.hxx>
  66 #include <svx/xflbmtit.hxx>
  67 #include <svx/svdundo.hxx>
  68 #include "svdfmtf.hxx"
  69 #include <svx/sdgcpitm.hxx>
  70 #include <svx/eeitem.hxx>
  71 #include <svx/sdr/properties/graphicproperties.hxx>
  72 #include <svx/sdr/contact/viewcontactofgraphic.hxx>
  73 #include <basegfx/polygon/b2dpolygon.hxx>
  74 #include <basegfx/polygon/b2dpolygontools.hxx>
  75
  76 using namespace ::com::sun::star::uno;
  77 using namespace ::com::sun::star::io;
  78
  79 // -----------
  80 // - Defines -
  81 // -----------
  82
  83 #define GRAFSTREAMPOS_INVALID   0xffffffff
  84 #define SWAPGRAPHIC_TIMEOUT     5000
  85
  86 // ------------------
  87 // - SdrGraphicLink     -
  88 // ------------------
  89
  90 class SdrGraphicLink : public sfx2::SvBaseLink
  91 {
  92     SdrGrafObj*                 pGrafObj;
  93
  94 public:
  95                         SdrGraphicLink(SdrGrafObj* pObj);
  96     virtual                             ~SdrGraphicLink();
  97
  98     virtual void                Closed();
  99     virtual void                DataChanged( const String& rMimeType,
 100                                 const ::com::sun::star::uno::Any & rValue );
 101
 102     BOOL                                Connect() { return 0 != GetRealObject(); }
 103     void                                UpdateSynchron();
 104 };
 105
 106 // -----------------------------------------------------------------------------
 107
 108 SdrGraphicLink::SdrGraphicLink(SdrGrafObj* pObj):
 109     ::sfx2::SvBaseLink( ::sfx2::LINKUPDATE_ONCALL, SOT_FORMATSTR_ID_SVXB ),
 110     pGrafObj(pObj)
 111 {
 112     SetSynchron( FALSE );
 113 }
 114
 115 // -----------------------------------------------------------------------------
 116
 117 SdrGraphicLink::~SdrGraphicLink()
 118 {
 119 }
 120
 121 // -----------------------------------------------------------------------------
 122
 123 void SdrGraphicLink::DataChanged( const String& rMimeType,
 124                                 const ::com::sun::star::uno::Any & rValue )
 125 {
 126     SdrModel*       pModel      = pGrafObj ? pGrafObj->GetModel() : 0;
 127     SvxLinkManager* pLinkManager= pModel  ? pModel->GetLinkManager() : 0;
 128
 129     if( pLinkManager && rValue.hasValue() )
 130     {
 131         pLinkManager->GetDisplayNames( this, 0, &pGrafObj->aFileName, 0, &pGrafObj->aFilterName );
 132
 133         Graphic aGraphic;
 134         if( SvxLinkManager::GetGraphicFromAny( rMimeType, rValue, aGraphic ))
 135         {
 136             GraphicType eOldGraphicType = pGrafObj->GetGraphicType();  // kein Hereinswappen
 137             const sal_Bool bIsChanged = pModel->IsChanged();
 138
 139             pGrafObj->SetGraphic( aGraphic );
 140             if( GRAPHIC_NONE != eOldGraphicType )
 141                 pGrafObj->SetChanged();
 142             else
 143                 pModel->SetChanged( bIsChanged );
 144         }
 145         else if( SotExchange::GetFormatIdFromMimeType( rMimeType ) !=
 146                     SvxLinkManager::RegisterStatusInfoId() )
 147         {
 148             // only repaint, no objectchange
 149             pGrafObj->ActionChanged();
 150             // pGrafObj->BroadcastObjectChange();
 151         }
 152     }
 153 }
 154
 155 // -----------------------------------------------------------------------------
 156
 157 void SdrGraphicLink::Closed()
 158 {
 159     // Die Verbindung wird aufgehoben; pLink des Objekts auf NULL setzen, da die Link-Instanz ja gerade destruiert wird.
 160     pGrafObj->ForceSwapIn();
 161     pGrafObj->pGraphicLink=NULL;
 162     pGrafObj->ReleaseGraphicLink();
 163     SvBaseLink::Closed();
 164 }
 165
 166 // -----------------------------------------------------------------------------
 167
 168 void SdrGraphicLink::UpdateSynchron()
 169 {
 170     if( GetObj() )
 171     {
 172         String aMimeType( SotExchange::GetFormatMimeType( GetContentType() ));
 173         ::com::sun::star::uno::Any aValue;
 174         GetObj()->GetData( aValue, aMimeType, TRUE );
 175         DataChanged( aMimeType, aValue );
 176     }
 177 }
 178
 179 // --------------
 180 // - SdrGrafObj -
 181 // --------------
 182
 183 //////////////////////////////////////////////////////////////////////////////
 184 // BaseProperties section
 185
 186 sdr::properties::BaseProperties* SdrGrafObj::CreateObjectSpecificProperties()
 187 {
 188     return new sdr::properties::GraphicProperties(*this);
 189 }
 190
 191 //////////////////////////////////////////////////////////////////////////////
 192 // DrawContact section
 193
 194 sdr::contact::ViewContact* SdrGrafObj::CreateObjectSpecificViewContact()
 195 {
 196     return new sdr::contact::ViewContactOfGraphic(*this);
 197 }
 198
 199 //////////////////////////////////////////////////////////////////////////////
 200
 201 TYPEINIT1(SdrGrafObj,SdrRectObj);
 202
 203 // -----------------------------------------------------------------------------
 204
 205 SdrGrafObj::SdrGrafObj()
 206 :       SdrRectObj(),
 207     pGraphicLink        ( NULL ),
 208     bMirrored           ( FALSE )
 209 {
 210     pGraphic = new GraphicObject;
 211     pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), SWAPGRAPHIC_TIMEOUT );
 212     bNoShear = TRUE;
 213
 214     // #111096#
 215     mbGrafAnimationAllowed = sal_True;
 216
 217     // #i25616#
 218     mbLineIsOutsideGeometry = sal_True;
 219     mbInsidePaint = sal_False;
 220     mbIsPreview = sal_False;
 221
 222     // #i25616#
 223     mbSupportTextIndentingOnLineWidthChange = sal_False;
 224 }
 225
 226 // -----------------------------------------------------------------------------
 227
 228 SdrGrafObj::SdrGrafObj(const Graphic& rGrf, const Rectangle& rRect)
 229 :       SdrRectObj              ( rRect ),
 230     pGraphicLink        ( NULL ),
 231     bMirrored           ( FALSE )
 232 {
 233     pGraphic = new GraphicObject( rGrf );
 234     pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), SWAPGRAPHIC_TIMEOUT );
 235     bNoShear = TRUE;
 236
 237     // #111096#
 238     mbGrafAnimationAllowed = sal_True;
 239
 240     // #i25616#
 241     mbLineIsOutsideGeometry = sal_True;
 242     mbInsidePaint = sal_False;
 243     mbIsPreview = sal_False;
 244
 245     // #i25616#
 246     mbSupportTextIndentingOnLineWidthChange = sal_False;
 247 }
 248
 249 // -----------------------------------------------------------------------------
 250
 251 SdrGrafObj::SdrGrafObj( const Graphic& rGrf )
 252 :       SdrRectObj(),
 253     pGraphicLink        ( NULL ),
 254     bMirrored           ( FALSE )
 255 {
 256     pGraphic = new GraphicObject( rGrf );
 257     pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), SWAPGRAPHIC_TIMEOUT );
 258     bNoShear = TRUE;
 259
 260     // #111096#
 261     mbGrafAnimationAllowed = sal_True;
 262
 263     // #i25616#
 264     mbLineIsOutsideGeometry = sal_True;
 265     mbInsidePaint = sal_False;
 266     mbIsPreview = sal_False;
 267
 268     // #i25616#
 269     mbSupportTextIndentingOnLineWidthChange = sal_False;
 270 }
 271
 272 // -----------------------------------------------------------------------------
 273
 274 SdrGrafObj::~SdrGrafObj()
 275 {
 276     delete pGraphic;
 277     ImpLinkAbmeldung();
 278 }
 279
 280 // -----------------------------------------------------------------------------
 281
 282 void SdrGrafObj::SetGraphicObject( const GraphicObject& rGrfObj )
 283 {
 284     *pGraphic = rGrfObj;
 285     pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), SWAPGRAPHIC_TIMEOUT );
 286     pGraphic->SetUserData();
 287     mbIsPreview = sal_False;
 288     SetChanged();
 289     BroadcastObjectChange();
 290 }
 291
 292 // -----------------------------------------------------------------------------
 293
 294 const GraphicObject& SdrGrafObj::GetGraphicObject(bool bForceSwapIn) const
 295 {
 296     if(bForceSwapIn)
 297     {
 298         ForceSwapIn();
 299     }
 300
 301     return *pGraphic;
 302 }
 303
 304 // -----------------------------------------------------------------------------
 305
 306 void SdrGrafObj::SetGraphic( const Graphic& rGrf )
 307 {
 308     pGraphic->SetGraphic( rGrf );
 309     pGraphic->SetUserData();
 310     mbIsPreview = sal_False;
 311     SetChanged();
 312     BroadcastObjectChange();
 313 }
 314
 315 // -----------------------------------------------------------------------------
 316
 317 const Graphic& SdrGrafObj::GetGraphic() const
 318 {
 319     ForceSwapIn();
 320     return pGraphic->GetGraphic();
 321 }
 322
 323 // -----------------------------------------------------------------------------
 324
 325 Graphic SdrGrafObj::GetTransformedGraphic( ULONG nTransformFlags ) const
 326 {
 327     // #107947# Refactored most of the code to GraphicObject, where
 328     // everybody can use e.g. the cropping functionality
 329
 330     GraphicType     eType = GetGraphicType();
 331     MapMode             aDestMap( pModel->GetScaleUnit(), Point(), pModel->GetScaleFraction(), pModel->GetScaleFraction() );
 332     const Size      aDestSize( GetLogicRect().GetSize() );
 333     const BOOL      bMirror = ( nTransformFlags & SDRGRAFOBJ_TRANSFORMATTR_MIRROR ) != 0;
 334     const BOOL      bRotate = ( ( nTransformFlags & SDRGRAFOBJ_TRANSFORMATTR_ROTATE ) != 0 ) &&
 335         ( aGeo.nDrehWink && aGeo.nDrehWink != 18000 ) && ( GRAPHIC_NONE != eType );
 336
 337     // #104115# Need cropping info earlier
 338     ( (SdrGrafObj*) this )->ImpSetAttrToGrafInfo();
 339     GraphicAttr aActAttr;
 340
 341     if( SDRGRAFOBJ_TRANSFORMATTR_NONE != nTransformFlags &&
 342         GRAPHIC_NONE != eType )
 343     {
 344         // actually transform the graphic only in this case. On the
 345         // other hand, cropping will always happen
 346         aActAttr = aGrafInfo;
 347
 348         if( bMirror )
 349         {
 350             USHORT              nMirrorCase = ( aGeo.nDrehWink == 18000 ) ? ( bMirrored ? 3 : 4 ) : ( bMirrored ? 2 : 1 );
 351             FASTBOOL    bHMirr = nMirrorCase == 2 || nMirrorCase == 4;
 352             FASTBOOL    bVMirr = nMirrorCase == 3 || nMirrorCase == 4;
 353
 354             aActAttr.SetMirrorFlags( ( bHMirr ? BMP_MIRROR_HORZ : 0 ) | ( bVMirr ? BMP_MIRROR_VERT : 0 ) );
 355         }
 356
 357         if( bRotate )
 358             aActAttr.SetRotation( sal_uInt16(aGeo.nDrehWink / 10) );
 359     }
 360
 361     // #107947# Delegate to moved code in GraphicObject
 362     return GetGraphicObject().GetTransformedGraphic( aDestSize, aDestMap, aActAttr );
 363 }
 364
 365 // -----------------------------------------------------------------------------
 366
 367 GraphicType SdrGrafObj::GetGraphicType() const
 368 {
 369     return pGraphic->GetType();
 370 }
 371
 372 sal_Bool SdrGrafObj::IsAnimated() const
 373 {
 374     return pGraphic->IsAnimated();
 375 }
 376
 377 sal_Bool SdrGrafObj::IsEPS() const
 378 {
 379     return pGraphic->IsEPS();
 380 }
 381
 382 sal_Bool SdrGrafObj::IsSwappedOut() const
 383 {
 384     return mbIsPreview ? sal_True : pGraphic->IsSwappedOut();
 385 }
 386
 387 const MapMode& SdrGrafObj::GetGrafPrefMapMode() const
 388 {
 389     return pGraphic->GetPrefMapMode();
 390 }
 391
 392 const Size& SdrGrafObj::GetGrafPrefSize() const
 393 {
 394     return pGraphic->GetPrefSize();
 395 }
 396
 397 // -----------------------------------------------------------------------------
 398
 399 void SdrGrafObj::SetGrafStreamURL( const String& rGraphicStreamURL )
 400 {
 401     mbIsPreview = sal_False;
 402     if( !rGraphicStreamURL.Len() )
 403     {
 404         pGraphic->SetUserData();
 405     }
 406     else if( pModel->IsSwapGraphics() )
 407     {
 408         pGraphic->SetUserData( rGraphicStreamURL );
 409
 410         // set state of graphic object to 'swapped out'
 411         if( pGraphic->GetType() == GRAPHIC_NONE )
 412             pGraphic->SetSwapState();
 413     }
 414 }
 415
 416 // -----------------------------------------------------------------------------
 417
 418 String SdrGrafObj::GetGrafStreamURL() const
 419 {
 420     return pGraphic->GetUserData();
 421 }
 422
 423 // -----------------------------------------------------------------------------
 424
 425 void SdrGrafObj::SetFileName(const String& rFileName)
 426 {
 427     aFileName = rFileName;
 428     SetChanged();
 429 }
 430
 431 // -----------------------------------------------------------------------------
 432
 433 void SdrGrafObj::SetFilterName(const String& rFilterName)
 434 {
 435     aFilterName = rFilterName;
 436     SetChanged();
 437 }
 438
 439 // -----------------------------------------------------------------------------
 440
 441 void SdrGrafObj::ForceSwapIn() const
 442 {
 443     if( mbIsPreview )
 444     {
 445         // removing preview graphic
 446         const String aUserData( pGraphic->GetUserData() );
 447
 448         Graphic aEmpty;
 449         pGraphic->SetGraphic( aEmpty );
 450         pGraphic->SetUserData( aUserData );
 451         pGraphic->SetSwapState();
 452
 453         const_cast< SdrGrafObj* >( this )->mbIsPreview = sal_False;
 454     }
 455
 456     pGraphic->FireSwapInRequest();
 457
 458     if( pGraphic->IsSwappedOut() ||
 459         ( pGraphic->GetType() == GRAPHIC_NONE ) ||
 460         ( pGraphic->GetType() == GRAPHIC_DEFAULT ) )
 461     {
 462         Graphic aDefaultGraphic;
 463         aDefaultGraphic.SetDefaultType();
 464         pGraphic->SetGraphic( aDefaultGraphic );
 465     }
 466 }
 467
 468 // -----------------------------------------------------------------------------
 469
 470 void SdrGrafObj::ForceSwapOut() const
 471 {
 472     pGraphic->FireSwapOutRequest();
 473 }
 474
 475 // -----------------------------------------------------------------------------
 476
 477 void SdrGrafObj::ImpLinkAnmeldung()
 478 {
 479     SvxLinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL;
 480
 481     if( pLinkManager != NULL && pGraphicLink == NULL )
 482     {
 483         if( aFileName.Len() )
 484         {
 485             pGraphicLink = new SdrGraphicLink( this );
 486             pLinkManager->InsertFileLink( *pGraphicLink, OBJECT_CLIENT_GRF, aFileName, ( aFilterName.Len() ? &aFilterName : NULL ), NULL );
 487             pGraphicLink->Connect();
 488         }
 489     }
 490 }
 491
 492 // -----------------------------------------------------------------------------
 493
 494 void SdrGrafObj::ImpLinkAbmeldung()
 495 {
 496     SvxLinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL;
 497
 498     if( pLinkManager != NULL && pGraphicLink!=NULL)
 499     {
 500         // Bei Remove wird *pGraphicLink implizit deleted
 501         pLinkManager->Remove( pGraphicLink );
 502         pGraphicLink=NULL;
 503     }
 504 }
 505
 506 // -----------------------------------------------------------------------------
 507
 508 void SdrGrafObj::SetGraphicLink( const String& rFileName, const String& rFilterName )
 509 {
 510     ImpLinkAbmeldung();
 511     aFileName = rFileName;
 512     aFilterName = rFilterName;
 513     ImpLinkAnmeldung();
 514     pGraphic->SetUserData();
 515
 516     // #92205# A linked graphic is per definition swapped out (has to be loaded)
 517     pGraphic->SetSwapState();
 518 }
 519
 520 // -----------------------------------------------------------------------------
 521
 522 void SdrGrafObj::ReleaseGraphicLink()
 523 {
 524     ImpLinkAbmeldung();
 525     aFileName = String();
 526     aFilterName = String();
 527 }
 528
 529 // -----------------------------------------------------------------------------
 530
 531 void SdrGrafObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
 532 {
 533     FASTBOOL bAnim = pGraphic->IsAnimated();
 534     FASTBOOL bNoPresGrf = ( pGraphic->GetType() != GRAPHIC_NONE ) && !bEmptyPresObj;
 535
 536     rInfo.bResizeFreeAllowed = aGeo.nDrehWink % 9000 == 0 ||
 537                                aGeo.nDrehWink % 18000 == 0 ||
 538                                aGeo.nDrehWink % 27000 == 0;
 539
 540     rInfo.bResizePropAllowed = TRUE;
 541     rInfo.bRotateFreeAllowed = bNoPresGrf && !bAnim;
 542     rInfo.bRotate90Allowed = bNoPresGrf && !bAnim;
 543     rInfo.bMirrorFreeAllowed = bNoPresGrf && !bAnim;
 544     rInfo.bMirror45Allowed = bNoPresGrf && !bAnim;
 545     rInfo.bMirror90Allowed = !bEmptyPresObj;
 546     rInfo.bTransparenceAllowed = FALSE;
 547     rInfo.bGradientAllowed = FALSE;
 548     rInfo.bShearAllowed = FALSE;
 549     rInfo.bEdgeRadiusAllowed=FALSE;
 550     rInfo.bCanConvToPath = FALSE;
 551     rInfo.bCanConvToPathLineToArea = FALSE;
 552     rInfo.bCanConvToPolyLineToArea = FALSE;
 553     rInfo.bCanConvToPoly = !IsEPS();
 554     rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
 555 }
 556
 557 // -----------------------------------------------------------------------------
 558
 559 UINT16 SdrGrafObj::GetObjIdentifier() const
 560 {
 561     return UINT16( OBJ_GRAF );
 562 }
 563
 564 // -----------------------------------------------------------------------------
 565
 566 sal_Bool SdrGrafObj::ImpUpdateGraphicLink() const
 567 {
 568     sal_Bool    bRet = sal_False;
 569
 570     if( pGraphicLink )
 571     {
 572         const sal_Bool bIsChanged = pModel->IsChanged();
 573         pGraphicLink->UpdateSynchron();
 574         pModel->SetChanged( bIsChanged );
 575
 576         bRet = sal_True;
 577     }
 578
 579     return bRet;
 580 }
 581
 582 // -----------------------------------------------------------------------------
 583
 584 void SdrGrafObj::TakeObjNameSingul(XubString& rName) const
 585 {
 586     switch( pGraphic->GetType() )
 587     {
 588         case GRAPHIC_BITMAP:
 589         {
 590             const USHORT nId = ( ( pGraphic->IsTransparent() || ( (const SdrGrafTransparenceItem&) GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ?
 591                                  ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPTRANSLNK : STR_ObjNameSingulGRAFBMPTRANS ) :
 592                                  ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPLNK : STR_ObjNameSingulGRAFBMP ) );
 593
 594             rName=ImpGetResStr( nId );
 595         }
 596         break;
 597
 598         case GRAPHIC_GDIMETAFILE:
 599             rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNameSingulGRAFMTFLNK : STR_ObjNameSingulGRAFMTF );
 600         break;
 601
 602         case GRAPHIC_NONE:
 603             rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNameSingulGRAFNONELNK : STR_ObjNameSingulGRAFNONE );
 604         break;
 605
 606         default:
 607             rName=ImpGetResStr(  IsLinkedGraphic() ? STR_ObjNameSingulGRAFLNK : STR_ObjNameSingulGRAF );
 608         break;
 609     }
 610
 611     const String aName(GetName());
 612
 613     if( aName.Len() )
 614     {
 615         rName.AppendAscii( " '" );
 616         rName += aName;
 617         rName += sal_Unicode( '\'' );
 618     }
 619 }
 620
 621 // -----------------------------------------------------------------------------
 622
 623 void SdrGrafObj::TakeObjNamePlural( XubString& rName ) const
 624 {
 625     switch( pGraphic->GetType() )
 626     {
 627         case GRAPHIC_BITMAP:
 628         {
 629             const USHORT nId = ( ( pGraphic->IsTransparent() || ( (const SdrGrafTransparenceItem&) GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ?
 630                                  ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPTRANSLNK : STR_ObjNamePluralGRAFBMPTRANS ) :
 631                                  ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPLNK : STR_ObjNamePluralGRAFBMP ) );
 632
 633             rName=ImpGetResStr( nId );
 634         }
 635         break;
 636
 637         case GRAPHIC_GDIMETAFILE:
 638             rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNamePluralGRAFMTFLNK : STR_ObjNamePluralGRAFMTF );
 639         break;
 640
 641         case GRAPHIC_NONE:
 642             rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNamePluralGRAFNONELNK : STR_ObjNamePluralGRAFNONE );
 643         break;
 644
 645         default:
 646             rName=ImpGetResStr(  IsLinkedGraphic() ? STR_ObjNamePluralGRAFLNK : STR_ObjNamePluralGRAF );
 647         break;
 648     }
 649
 650     const String aName(GetName());
 651
 652     if( aName.Len() )
 653     {
 654         rName.AppendAscii( " '" );
 655         rName += aName;
 656         rName += sal_Unicode( '\'' );
 657     }
 658 }
 659
 660 // -----------------------------------------------------------------------------
 661
 662 SdrObject* SdrGrafObj::getFullDragClone() const
 663 {
 664     // call parent
 665     SdrGrafObj* pRetval = static_cast< SdrGrafObj* >(SdrRectObj::getFullDragClone());
 666
 667     // #i103116# the full drag clone leads to problems
 668     // with linked graphics, so reset the link in this
 669     // temporary interaction object and load graphic
 670     if(pRetval && IsLinkedGraphic())
 671     {
 672         pRetval->ForceSwapIn();
 673         pRetval->ReleaseGraphicLink();
 674     }
 675
 676     return pRetval;
 677 }
 678
 679 void SdrGrafObj::operator=( const SdrObject& rObj )
 680 {
 681     SdrRectObj::operator=( rObj );
 682
 683     const SdrGrafObj& rGraf = (SdrGrafObj&) rObj;
 684
 685     pGraphic->SetGraphic( rGraf.GetGraphic() );
 686     aCropRect = rGraf.aCropRect;
 687     aFileName = rGraf.aFileName;
 688     aFilterName = rGraf.aFilterName;
 689     bMirrored = rGraf.bMirrored;
 690
 691     if( rGraf.pGraphicLink != NULL)
 692     {
 693         SetGraphicLink( aFileName, aFilterName );
 694     }
 695
 696     ImpSetAttrToGrafInfo();
 697 }
 698
 699 // -----------------------------------------------------------------------------
 700 // #i25616#
 701
 702 basegfx::B2DPolyPolygon SdrGrafObj::TakeXorPoly() const
 703 {
 704     if(mbInsidePaint)
 705     {
 706         basegfx::B2DPolyPolygon aRetval;
 707
 708         // take grown rectangle
 709         const sal_Int32 nHalfLineWidth(ImpGetLineWdt() / 2);
 710         const Rectangle aGrownRect(
 711             aRect.Left() - nHalfLineWidth,
 712             aRect.Top() - nHalfLineWidth,
 713             aRect.Right() + nHalfLineWidth,
 714             aRect.Bottom() + nHalfLineWidth);
 715
 716         XPolygon aXPoly(ImpCalcXPoly(aGrownRect, GetEckenradius()));
 717         aRetval.append(aXPoly.getB2DPolygon());
 718
 719         return aRetval;
 720     }
 721     else
 722     {
 723         // call parent
 724         return SdrRectObj::TakeXorPoly();
 725     }
 726 }
 727
 728 // -----------------------------------------------------------------------------
 729
 730 sal_uInt32 SdrGrafObj::GetHdlCount() const
 731 {
 732     return 8L;
 733 }
 734
 735 // -----------------------------------------------------------------------------
 736
 737 SdrHdl* SdrGrafObj::GetHdl(sal_uInt32 nHdlNum) const
 738 {
 739     return SdrRectObj::GetHdl( nHdlNum + 1L );
 740 }
 741
 742 // -----------------------------------------------------------------------------
 743
 744 void SdrGrafObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 745 {
 746     SdrRectObj::NbcResize( rRef, xFact, yFact );
 747
 748     FASTBOOL bMirrX = xFact.GetNumerator() < 0;
 749     FASTBOOL bMirrY = yFact.GetNumerator() < 0;
 750
 751     if( bMirrX != bMirrY )
 752         bMirrored = !bMirrored;
 753 }
 754
 755 // -----------------------------------------------------------------------------
 756
 757 void SdrGrafObj::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
 758 {
 759     SdrRectObj::NbcRotate(rRef,nWink,sn,cs);
 760 }
 761
 762 // -----------------------------------------------------------------------------
 763
 764 void SdrGrafObj::NbcMirror(const Point& rRef1, const Point& rRef2)
 765 {
 766     SdrRectObj::NbcMirror(rRef1,rRef2);
 767     bMirrored = !bMirrored;
 768 }
 769
 770 // -----------------------------------------------------------------------------
 771
 772 void SdrGrafObj::NbcShear(const Point& rRef, long nWink, double tn, FASTBOOL bVShear)
 773 {
 774     SdrRectObj::NbcRotate( rRef, nWink, tn, bVShear );
 775 }
 776
 777 // -----------------------------------------------------------------------------
 778
 779 void SdrGrafObj::NbcSetSnapRect(const Rectangle& rRect)
 780 {
 781     SdrRectObj::NbcSetSnapRect(rRect);
 782 }
 783
 784 // -----------------------------------------------------------------------------
 785
 786 void SdrGrafObj::NbcSetLogicRect( const Rectangle& rRect)
 787 {
 788     //FASTBOOL bChg=rRect.GetSize()!=aRect.GetSize();
 789     SdrRectObj::NbcSetLogicRect(rRect);
 790 }
 791
 792 // -----------------------------------------------------------------------------
 793
 794 SdrObjGeoData* SdrGrafObj::NewGeoData() const
 795 {
 796     return new SdrGrafObjGeoData;
 797 }
 798
 799 // -----------------------------------------------------------------------------
 800
 801 void SdrGrafObj::SaveGeoData(SdrObjGeoData& rGeo) const
 802 {
 803     SdrRectObj::SaveGeoData(rGeo);
 804     SdrGrafObjGeoData& rGGeo=(SdrGrafObjGeoData&)rGeo;
 805     rGGeo.bMirrored=bMirrored;
 806 }
 807
 808 // -----------------------------------------------------------------------------
 809
 810 void SdrGrafObj::RestGeoData(const SdrObjGeoData& rGeo)
 811 {
 812     //long              nDrehMerk = aGeo.nDrehWink;
 813     //long              nShearMerk = aGeo.nShearWink;
 814     //FASTBOOL  bMirrMerk = bMirrored;
 815     Size                aSizMerk( aRect.GetSize() );
 816
 817     SdrRectObj::RestGeoData(rGeo);
 818     SdrGrafObjGeoData& rGGeo=(SdrGrafObjGeoData&)rGeo;
 819     bMirrored=rGGeo.bMirrored;
 820 }
 821
 822 // -----------------------------------------------------------------------------
 823
 824 void SdrGrafObj::SetPage( SdrPage* pNewPage )
 825 {
 826     FASTBOOL bRemove = pNewPage == NULL && pPage != NULL;
 827     FASTBOOL bInsert = pNewPage != NULL && pPage == NULL;
 828
 829     if( bRemove )
 830     {
 831         // hier kein SwapIn noetig, weil wenn nicht geladen, dann auch nicht animiert.
 832         if( pGraphic->IsAnimated())
 833             pGraphic->StopAnimation();
 834
 835         if( pGraphicLink != NULL )
 836             ImpLinkAbmeldung();
 837     }
 838
 839     SdrRectObj::SetPage( pNewPage );
 840
 841     if(aFileName.Len() && bInsert)
 842         ImpLinkAnmeldung();
 843 }
 844
 845 // -----------------------------------------------------------------------------
 846
 847 void SdrGrafObj::SetModel( SdrModel* pNewModel )
 848 {
 849     FASTBOOL bChg = pNewModel != pModel;
 850
 851     if( bChg )
 852     {
 853         if( pGraphic->HasUserData() )
 854         {
 855             ForceSwapIn();
 856             pGraphic->SetUserData();
 857         }
 858
 859         if( pGraphicLink != NULL )
 860             ImpLinkAbmeldung();
 861     }
 862
 863     // Model umsetzen
 864     SdrRectObj::SetModel(pNewModel);
 865
 866     if( bChg && aFileName.Len() )
 867         ImpLinkAnmeldung();
 868 }
 869
 870 // -----------------------------------------------------------------------------
 871
 872 void SdrGrafObj::StartAnimation( OutputDevice* /*pOutDev*/, const Point& /*rPoint*/, const Size& /*rSize*/, long /*nExtraData*/)
 873 {
 874     // #111096#
 875     // use new graf animation
 876     SetGrafAnimationAllowed(sal_True);
 877 }
 878
 879 // -----------------------------------------------------------------------------
 880
 881 void SdrGrafObj::StopAnimation(OutputDevice* /*pOutDev*/, long /*nExtraData*/)
 882 {
 883     // #111096#
 884     // use new graf animation
 885     SetGrafAnimationAllowed(sal_False);
 886 }
 887
 888 // -----------------------------------------------------------------------------
 889
 890 FASTBOOL SdrGrafObj::HasGDIMetaFile() const
 891 {
 892     return( pGraphic->GetType() == GRAPHIC_GDIMETAFILE );
 893 }
 894
 895 // -----------------------------------------------------------------------------
 896
 897 const GDIMetaFile* SdrGrafObj::GetGDIMetaFile() const
 898 {
 899     DBG_ERROR( "Invalid return value! Don't use it! (KA)" );
 900     return &GetGraphic().GetGDIMetaFile();
 901 }
 902
 903 // -----------------------------------------------------------------------------
 904
 905 SdrObject* SdrGrafObj::DoConvertToPolyObj(BOOL bBezier) const
 906 {
 907     SdrObject* pRetval = NULL;
 908
 909     switch( GetGraphicType() )
 910     {
 911         case GRAPHIC_GDIMETAFILE:
 912         {
 913             // NUR die aus dem MetaFile erzeugbaren Objekte in eine Gruppe packen und zurueckliefern
 914             SdrObjGroup*                        pGrp = new SdrObjGroup();
 915             ImpSdrGDIMetaFileImport aFilter(*GetModel());
 916             Point                                       aOutPos( aRect.TopLeft() );
 917             const Size                          aOutSiz( aRect.GetSize() );
 918
 919             aFilter.SetScaleRect(GetSnapRect());
 920             aFilter.SetLayer(GetLayer());
 921
 922             UINT32 nInsAnz = aFilter.DoImport(GetTransformedGraphic().GetGDIMetaFile(), *pGrp->GetSubList(), 0);
 923             if(nInsAnz)
 924             {
 925                 pRetval = pGrp;
 926                 pGrp->NbcSetLayer(GetLayer());
 927                 pGrp->SetModel(GetModel());
 928                 pRetval = ImpConvertAddText(pRetval, bBezier);
 929
 930                 // convert all children
 931                 if( pRetval )
 932                 {
 933                     SdrObject* pHalfDone = pRetval;
 934                     pRetval = pHalfDone->DoConvertToPolyObj(bBezier);
 935                     SdrObject::Free( pHalfDone ); // resulting object is newly created
 936
 937                     if( pRetval )
 938                     {
 939                         // flatten subgroups. As we call
 940                         // DoConvertToPolyObj() on the resulting group
 941                         // objects, subgroups can exist (e.g. text is
 942                         // a group object for every line).
 943                         SdrObjList* pList = pRetval->GetSubList();
 944                         if( pList )
 945                             pList->FlattenGroups();
 946                     }
 947                 }
 948             }
 949             else
 950                 delete pGrp;
 951             break;
 952         }
 953         case GRAPHIC_BITMAP:
 954         {
 955             // Grundobjekt kreieren und Fuellung ergaenzen
 956             pRetval = SdrRectObj::DoConvertToPolyObj(bBezier);
 957
 958             // Bitmap als Attribut retten
 959             if(pRetval)
 960             {
 961                 // Bitmap als Fuellung holen
 962                 SfxItemSet aSet(GetObjectItemSet());
 963
 964                 aSet.Put(XFillStyleItem(XFILL_BITMAP));
 965                 Bitmap aBitmap( GetTransformedGraphic().GetBitmap() );
 966                 XOBitmap aXBmp(aBitmap, XBITMAP_STRETCH);
 967                 aSet.Put(XFillBitmapItem(String(), aXBmp));
 968                 aSet.Put(XFillBmpTileItem(FALSE));
 969
 970                 pRetval->SetMergedItemSet(aSet);
 971             }
 972             break;
 973         }
 974         case GRAPHIC_NONE:
 975         case GRAPHIC_DEFAULT:
 976         {
 977             pRetval = SdrRectObj::DoConvertToPolyObj(bBezier);
 978             break;
 979         }
 980     }
 981
 982     return pRetval;
 983 }
 984
 985 // -----------------------------------------------------------------------------
 986
 987 void SdrGrafObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 988 {
 989     SetXPolyDirty();
 990     SdrRectObj::Notify( rBC, rHint );
 991     ImpSetAttrToGrafInfo();
 992 }
 993
 994 void SdrGrafObj::ImpSetAttrToGrafInfo()
 995 {
 996     const SfxItemSet& rSet = GetObjectItemSet();
 997     const sal_uInt16 nTrans = ( (SdrGrafTransparenceItem&) rSet.Get( SDRATTR_GRAFTRANSPARENCE ) ).GetValue();
 998     const SdrGrafCropItem&      rCrop = (const SdrGrafCropItem&) rSet.Get( SDRATTR_GRAFCROP );
 999
1000     aGrafInfo.SetLuminance( ( (SdrGrafLuminanceItem&) rSet.Get( SDRATTR_GRAFLUMINANCE ) ).GetValue() );
1001     aGrafInfo.SetContrast( ( (SdrGrafContrastItem&) rSet.Get( SDRATTR_GRAFCONTRAST ) ).GetValue() );
1002     aGrafInfo.SetChannelR( ( (SdrGrafRedItem&) rSet.Get( SDRATTR_GRAFRED ) ).GetValue() );
1003     aGrafInfo.SetChannelG( ( (SdrGrafGreenItem&) rSet.Get( SDRATTR_GRAFGREEN ) ).GetValue() );
1004     aGrafInfo.SetChannelB( ( (SdrGrafBlueItem&) rSet.Get( SDRATTR_GRAFBLUE ) ).GetValue() );
1005     aGrafInfo.SetGamma( ( (SdrGrafGamma100Item&) rSet.Get( SDRATTR_GRAFGAMMA ) ).GetValue() * 0.01 );
1006     aGrafInfo.SetTransparency( (BYTE) FRound( Min( nTrans, (USHORT) 100 )  * 2.55 ) );
1007     aGrafInfo.SetInvert( ( (SdrGrafInvertItem&) rSet.Get( SDRATTR_GRAFINVERT ) ).GetValue() );
1008     aGrafInfo.SetDrawMode( ( (SdrGrafModeItem&) rSet.Get( SDRATTR_GRAFMODE ) ).GetValue() );
1009     aGrafInfo.SetCrop( rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom() );
1010
1011     SetXPolyDirty();
1012     SetRectsDirty();
1013 }
1014
1015 // -----------------------------------------------------------------------------
1016
1017 void SdrGrafObj::ImpSetGrafInfoToAttr()
1018 {
1019     SetObjectItem( SdrGrafLuminanceItem( aGrafInfo.GetLuminance() ) );
1020     SetObjectItem( SdrGrafContrastItem( aGrafInfo.GetContrast() ) );
1021     SetObjectItem( SdrGrafRedItem( aGrafInfo.GetChannelR() ) );
1022     SetObjectItem( SdrGrafGreenItem( aGrafInfo.GetChannelG() ) );
1023     SetObjectItem( SdrGrafBlueItem( aGrafInfo.GetChannelB() ) );
1024     SetObjectItem( SdrGrafGamma100Item( FRound( aGrafInfo.GetGamma() * 100.0 ) ) );
1025     SetObjectItem( SdrGrafTransparenceItem( (USHORT) FRound( aGrafInfo.GetTransparency() / 2.55 ) ) );
1026     SetObjectItem( SdrGrafInvertItem( aGrafInfo.IsInvert() ) );
1027     SetObjectItem( SdrGrafModeItem( aGrafInfo.GetDrawMode() ) );
1028     SetObjectItem( SdrGrafCropItem( aGrafInfo.GetLeftCrop(), aGrafInfo.GetTopCrop(), aGrafInfo.GetRightCrop(), aGrafInfo.GetBottomCrop() ) );
1029 }
1030
1031 // -----------------------------------------------------------------------------
1032
1033 void SdrGrafObj::AdjustToMaxRect( const Rectangle& rMaxRect, BOOL bShrinkOnly )
1034 {
1035     Size aSize;
1036     Size aMaxSize( rMaxRect.GetSize() );
1037     if ( pGraphic->GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
1038         aSize = Application::GetDefaultDevice()->PixelToLogic( pGraphic->GetPrefSize(), MAP_100TH_MM );
1039     else
1040         aSize = OutputDevice::LogicToLogic( pGraphic->GetPrefSize(),
1041                                             pGraphic->GetPrefMapMode(),
1042                                             MapMode( MAP_100TH_MM ) );
1043
1044     if( aSize.Height() != 0 && aSize.Width() != 0 )
1045     {
1046         Point aPos( rMaxRect.TopLeft() );
1047
1048         // Falls Grafik zu gross, wird die Grafik
1049         // in die Seite eingepasst
1050         if ( (!bShrinkOnly                          ||
1051              ( aSize.Height() > aMaxSize.Height() ) ||
1052              ( aSize.Width()  > aMaxSize.Width()  ) )&&
1053              aSize.Height() && aMaxSize.Height() )
1054         {
1055             float fGrfWH =      (float)aSize.Width() /
1056                             (float)aSize.Height();
1057             float fWinWH =      (float)aMaxSize.Width() /
1058                             (float)aMaxSize.Height();
1059
1060             // Grafik an Pagesize anpassen (skaliert)
1061             if ( fGrfWH < fWinWH )
1062             {
1063                 aSize.Width() = (long)(aMaxSize.Height() * fGrfWH);
1064                 aSize.Height()= aMaxSize.Height();
1065             }
1066             else if ( fGrfWH > 0.F )
1067             {
1068                 aSize.Width() = aMaxSize.Width();
1069                 aSize.Height()= (long)(aMaxSize.Width() / fGrfWH);
1070             }
1071
1072             aPos = rMaxRect.Center();
1073         }
1074
1075         if( bShrinkOnly )
1076             aPos = aRect.TopLeft();
1077
1078         aPos.X() -= aSize.Width() / 2;
1079         aPos.Y() -= aSize.Height() / 2;
1080         SetLogicRect( Rectangle( aPos, aSize ) );
1081     }
1082 }
1083
1084 // -----------------------------------------------------------------------------
1085
1086 IMPL_LINK( SdrGrafObj, ImpSwapHdl, GraphicObject*, pO )
1087 {
1088     SvStream* pRet = GRFMGR_AUTOSWAPSTREAM_NONE;
1089
1090     if( pO->IsInSwapOut() )
1091     {
1092         if( pModel && !mbIsPreview && pModel->IsSwapGraphics() && pGraphic->GetSizeBytes() > 20480 )
1093         {
1094             // test if this object is visualized from someone
1095             // ## test only if there are VOCs other than the preview renderer
1096             if(!GetViewContact().HasViewObjectContacts(true))
1097             {
1098                 const ULONG     nSwapMode = pModel->GetSwapGraphicsMode();
1099
1100                 if( ( pGraphic->HasUserData() || pGraphicLink ) &&
1101                     ( nSwapMode & SDR_SWAPGRAPHICSMODE_PURGE ) )
1102                 {
1103                     pRet = NULL;
1104                 }
1105                 else if( nSwapMode & SDR_SWAPGRAPHICSMODE_TEMP )
1106                 {
1107                     pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1108                     pGraphic->SetUserData();
1109                 }
1110
1111                 // #i102380#
1112                 sdr::contact::ViewContactOfGraphic* pVC = dynamic_cast< sdr::contact::ViewContactOfGraphic* >(&GetViewContact());
1113
1114                 if(pVC)
1115                 {
1116                     pVC->flushGraphicObjects();
1117                 }
1118             }
1119         }
1120     }
1121     else if( pO->IsInSwapIn() )
1122     {
1123         // kann aus dem original Doc-Stream nachgeladen werden...
1124         if( pModel != NULL )
1125         {
1126             if( pGraphic->HasUserData() )
1127             {
1128                 SdrDocumentStreamInfo aStreamInfo;
1129
1130                 aStreamInfo.mbDeleteAfterUse = FALSE;
1131                 aStreamInfo.maUserData = pGraphic->GetUserData();
1132
1133                 SvStream* pStream = pModel->GetDocumentStream( aStreamInfo );
1134
1135                 if( pStream != NULL )
1136                 {
1137                     Graphic aGraphic;
1138
1139                     com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >* pFilterData = NULL;
1140
1141                     if(mbInsidePaint && !GetViewContact().HasViewObjectContacts(true))
1142                     {
1143 //                                                      Rectangle aSnapRect(GetSnapRect());
1144 //                                                      const Rectangle aSnapRectPixel(pOutDev->LogicToPixel(aSnapRect));
1145
1146                         pFilterData = new com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >( 3 );
1147
1148                         com::sun::star::awt::Size aPreviewSizeHint( 64, 64 );
1149                         sal_Bool bAllowPartialStreamRead = sal_True;
1150                         sal_Bool bCreateNativeLink = sal_False;
1151                         (*pFilterData)[ 0 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "PreviewSizeHint" ) );
1152                         (*pFilterData)[ 0 ].Value <<= aPreviewSizeHint;
1153                         (*pFilterData)[ 1 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "AllowPartialStreamRead" ) );
1154                         (*pFilterData)[ 1 ].Value <<= bAllowPartialStreamRead;
1155                         (*pFilterData)[ 2 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "CreateNativeLink" ) );
1156                         (*pFilterData)[ 2 ].Value <<= bCreateNativeLink;
1157
1158                         mbIsPreview = sal_True;
1159                     }
1160
1161                     if( !GetGrfFilter()->ImportGraphic( aGraphic, String(), *pStream,
1162                                                         GRFILTER_FORMAT_DONTKNOW, NULL, 0, pFilterData ) )
1163                     {
1164                         const String aUserData( pGraphic->GetUserData() );
1165
1166                         pGraphic->SetGraphic( aGraphic );
1167                         pGraphic->SetUserData( aUserData );
1168
1169                         // #142146# Graphic successfully swapped in.
1170                         pRet = GRFMGR_AUTOSWAPSTREAM_LOADED;
1171                     }
1172                     delete pFilterData;
1173
1174                     pStream->ResetError();
1175
1176                     if( aStreamInfo.mbDeleteAfterUse || aStreamInfo.mxStorageRef.is() )
1177                     {
1178                         if ( aStreamInfo.mxStorageRef.is() )
1179                         {
1180                             aStreamInfo.mxStorageRef->dispose();
1181                             aStreamInfo.mxStorageRef = 0;
1182                         }
1183
1184                         delete pStream;
1185                     }
1186                 }
1187             }
1188             else if( !ImpUpdateGraphicLink() )
1189             {
1190                 pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1191             }
1192             else
1193             {
1194                 pRet = GRFMGR_AUTOSWAPSTREAM_LOADED;
1195             }
1196         }
1197         else
1198             pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1199     }
1200
1201     return (long)(void*) pRet;
1202 }
1203
1204 // -----------------------------------------------------------------------------
1205
1206 // #111096#
1207 // Access to GrafAnimationAllowed flag
1208 sal_Bool SdrGrafObj::IsGrafAnimationAllowed() const
1209 {
1210     return mbGrafAnimationAllowed;
1211 }
1212
1213 void SdrGrafObj::SetGrafAnimationAllowed(sal_Bool bNew)
1214 {
1215     if(mbGrafAnimationAllowed != bNew)
1216     {
1217         mbGrafAnimationAllowed = bNew;
1218         ActionChanged();
1219     }
1220 }
1221
1222 // #i25616#
1223 sal_Bool SdrGrafObj::IsObjectTransparent() const
1224 {
1225     if(((const SdrGrafTransparenceItem&)GetObjectItem(SDRATTR_GRAFTRANSPARENCE)).GetValue()
1226         || pGraphic->IsTransparent())
1227     {
1228         return sal_True;
1229     }
1230
1231     return sal_False;
1232 }
1233
1234 Reference< XInputStream > SdrGrafObj::getInputStream()
1235 {
1236     Reference< XInputStream > xStream;
1237
1238     if( pModel )
1239     {
1240 //              if( !pGraphic->HasUserData() )
1241 //                      pGraphic->SwapOut();
1242
1243         // kann aus dem original Doc-Stream nachgeladen werden...
1244         if( pGraphic->HasUserData() )
1245         {
1246             SdrDocumentStreamInfo aStreamInfo;
1247
1248             aStreamInfo.mbDeleteAfterUse = FALSE;
1249             aStreamInfo.maUserData = pGraphic->GetUserData();
1250
1251             SvStream* pStream = pModel->GetDocumentStream( aStreamInfo );
1252
1253             if( pStream )
1254                 xStream.set( new utl::OInputStreamWrapper( pStream, sal_True ) );
1255         }
1256         else if( pGraphic && GetGraphic().IsLink() )
1257         {
1258             Graphic aGraphic( GetGraphic() );
1259             GfxLink aLink( aGraphic.GetLink() );
1260             sal_uInt32 nSize = aLink.GetDataSize();
1261             const void* pSourceData = (const void*)aLink.GetData();
1262             if( nSize && pSourceData )
1263             {
1264                 sal_uInt8 * pBuffer = new sal_uInt8[ nSize ];
1265                 if( pBuffer )
1266                 {
1267                     memcpy( pBuffer, pSourceData, nSize );
1268
1269                     SvMemoryStream* pStream = new SvMemoryStream( (void*)pBuffer, (sal_Size)nSize, STREAM_READ );
1270                     pStream->ObjectOwnsMemory( sal_True );
1271                     xStream.set( new utl::OInputStreamWrapper( pStream, sal_True ) );
1272                 }
1273             }
1274         }
1275
1276         if( !xStream.is() && aFileName.Len() )
1277         {
1278             SvFileStream* pStream = new SvFileStream( aFileName, STREAM_READ );
1279             if( pStream )
1280                 xStream.set( new utl::OInputStreamWrapper( pStream ) );
1281         }
1282     }
1283
1284     return xStream;
1285 }
1286
1287 // eof