svtools/source/graphic/grfmgr.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "sal/config.h"
  21
  22 #include <algorithm>
  23
  24 #include <officecfg/Office/Common.hxx>
  25 #include <tools/vcompat.hxx>
  26 #include <tools/helpers.hxx>
  27 #include <unotools/ucbstreamhelper.hxx>
  28 #include <unotools/localfilehelper.hxx>
  29 #include <unotools/tempfile.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <vcl/cvtgrf.hxx>
  32 #include <vcl/metaact.hxx>
  33 #include <vcl/virdev.hxx>
  34 #include <svtools/grfmgr.hxx>
  35
  36 #include <vcl/pdfextoutdevdata.hxx>
  37
  38 #include <com/sun/star/container/XNameContainer.hpp>
  39 #include <com/sun/star/beans/XPropertySet.hpp>
  40
  41 using com::sun::star::uno::Reference;
  42 using com::sun::star::uno::XInterface;
  43 using com::sun::star::uno::UNO_QUERY;
  44 using com::sun::star::uno::Sequence;
  45 using com::sun::star::container::XNameContainer;
  46 using com::sun::star::beans::XPropertySet;
  47
  48 GraphicManager* GraphicObject::mpGlobalMgr = NULL;
  49
  50 struct GrfSimpleCacheObj
  51 {
  52     Graphic     maGraphic;
  53     GraphicAttr maAttr;
  54
  55                 GrfSimpleCacheObj( const Graphic& rGraphic, const GraphicAttr& rAttr ) :
  56                     maGraphic( rGraphic ), maAttr( rAttr ) {}
  57 };
  58
  59 TYPEINIT1_AUTOFACTORY( GraphicObject, SvDataCopyStream );
  60
  61 GraphicObject::GraphicObject( const GraphicManager* pMgr ) :
  62     maLink      (),
  63     maUserData  ()
  64 {
  65     ImplConstruct();
  66     ImplAssignGraphicData();
  67     ImplSetGraphicManager( pMgr );
  68 }
  69
  70 GraphicObject::GraphicObject( const Graphic& rGraphic, const GraphicManager* pMgr ) :
  71     maGraphic   ( rGraphic ),
  72     maLink      (),
  73     maUserData  ()
  74 {
  75     ImplConstruct();
  76     ImplAssignGraphicData();
  77     ImplSetGraphicManager( pMgr );
  78 }
  79
  80 GraphicObject::GraphicObject( const GraphicObject& rGraphicObj, const GraphicManager* pMgr ) :
  81     SvDataCopyStream(),
  82     maGraphic   ( rGraphicObj.GetGraphic() ),
  83     maAttr      ( rGraphicObj.maAttr ),
  84     maLink      ( rGraphicObj.maLink ),
  85     maUserData  ( rGraphicObj.maUserData )
  86 {
  87     ImplConstruct();
  88     ImplAssignGraphicData();
  89     ImplSetGraphicManager( pMgr, NULL, &rGraphicObj );
  90 }
  91
  92 GraphicObject::GraphicObject( const OString& rUniqueID, const GraphicManager* pMgr ) :
  93     maLink      (),
  94     maUserData  ()
  95 {
  96     ImplConstruct();
  97
  98     // assign default properties
  99     ImplAssignGraphicData();
 100
 101     ImplSetGraphicManager( pMgr, &rUniqueID );
 102
 103     // update properties
 104     ImplAssignGraphicData();
 105 }
 106
 107 GraphicObject::~GraphicObject()
 108 {
 109     if( mpMgr )
 110     {
 111         mpMgr->ImplUnregisterObj( *this );
 112
 113         if( ( mpMgr == mpGlobalMgr ) && !mpGlobalMgr->ImplHasObjects() )
 114             delete mpGlobalMgr, mpGlobalMgr = NULL;
 115     }
 116
 117     delete mpSwapOutTimer;
 118     delete mpSwapStreamHdl;
 119     delete mpSimpleCache;
 120 }
 121
 122 void GraphicObject::ImplConstruct()
 123 {
 124     mpMgr = NULL;
 125     mpSwapStreamHdl = NULL;
 126     mpSwapOutTimer = NULL;
 127     mpSimpleCache = NULL;
 128     mnAnimationLoopCount = 0;
 129     mbAutoSwapped = sal_False;
 130     mbIsInSwapIn = sal_False;
 131     mbIsInSwapOut = sal_False;
 132 }
 133
 134 void GraphicObject::ImplAssignGraphicData()
 135 {
 136     maPrefSize = maGraphic.GetPrefSize();
 137     maPrefMapMode = maGraphic.GetPrefMapMode();
 138     mnSizeBytes = maGraphic.GetSizeBytes();
 139     meType = maGraphic.GetType();
 140     mbTransparent = maGraphic.IsTransparent();
 141     mbAlpha = maGraphic.IsAlpha();
 142     mbAnimated = maGraphic.IsAnimated();
 143     mbEPS = maGraphic.IsEPS();
 144     mnAnimationLoopCount = ( mbAnimated ? maGraphic.GetAnimationLoopCount() : 0 );
 145 }
 146
 147 void GraphicObject::ImplSetGraphicManager( const GraphicManager* pMgr, const OString* pID, const GraphicObject* pCopyObj )
 148 {
 149     if( !mpMgr || ( pMgr != mpMgr ) )
 150     {
 151         if( !pMgr && mpMgr && ( mpMgr == mpGlobalMgr ) )
 152             return;
 153         else
 154         {
 155             if( mpMgr )
 156             {
 157                 mpMgr->ImplUnregisterObj( *this );
 158
 159                 if( ( mpMgr == mpGlobalMgr ) && !mpGlobalMgr->ImplHasObjects() )
 160                     delete mpGlobalMgr, mpGlobalMgr = NULL;
 161             }
 162
 163             if( !pMgr )
 164             {
 165                 if( !mpGlobalMgr )
 166                 {
 167                     mpGlobalMgr = new GraphicManager(
 168                         (officecfg::Office::Common::Cache::GraphicManager::
 169                          TotalCacheSize::get()),
 170                         (officecfg::Office::Common::Cache::GraphicManager::
 171                          ObjectCacheSize::get()));
 172                     mpGlobalMgr->SetCacheTimeout(
 173                         officecfg::Office::Common::Cache::GraphicManager::
 174                         ObjectReleaseTime::get());
 175                 }
 176
 177                 mpMgr = mpGlobalMgr;
 178             }
 179             else
 180                 mpMgr = (GraphicManager*) pMgr;
 181
 182             mpMgr->ImplRegisterObj( *this, maGraphic, pID, pCopyObj );
 183         }
 184     }
 185 }
 186
 187 void GraphicObject::ImplAutoSwapIn()
 188 {
 189     if( IsSwappedOut() )
 190     {
 191         if( mpMgr && mpMgr->ImplFillSwappedGraphicObject( *this, maGraphic ) )
 192             mbAutoSwapped = sal_False;
 193         else
 194         {
 195             mbIsInSwapIn = sal_True;
 196
 197             if( maGraphic.SwapIn() )
 198                 mbAutoSwapped = sal_False;
 199             else
 200             {
 201                 SvStream* pStream = GetSwapStream();
 202
 203                 if( GRFMGR_AUTOSWAPSTREAM_NONE != pStream )
 204                 {
 205                     if( GRFMGR_AUTOSWAPSTREAM_LINK == pStream )
 206                     {
 207                         if( HasLink() )
 208                         {
 209                             OUString aURLStr;
 210
 211                             if( ::utl::LocalFileHelper::ConvertPhysicalNameToURL( GetLink(), aURLStr ) )
 212                             {
 213                                 SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( aURLStr, STREAM_READ );
 214
 215                                 if( pIStm )
 216                                 {
 217                                     (*pIStm) >> maGraphic;
 218                                     mbAutoSwapped = ( maGraphic.GetType() != GRAPHIC_NONE );
 219                                     delete pIStm;
 220                                 }
 221                             }
 222                         }
 223                     }
 224                     else if( GRFMGR_AUTOSWAPSTREAM_TEMP == pStream )
 225                         mbAutoSwapped = !maGraphic.SwapIn();
 226                     else if( GRFMGR_AUTOSWAPSTREAM_LOADED == pStream )
 227                         mbAutoSwapped = maGraphic.IsSwapOut();
 228                     else
 229                     {
 230                         mbAutoSwapped = !maGraphic.SwapIn( pStream );
 231                         delete pStream;
 232                     }
 233                 }
 234                 else
 235                 {
 236                     DBG_ASSERT( ( GRAPHIC_NONE == meType ) || ( GRAPHIC_DEFAULT == meType ),
 237                                 "GraphicObject::ImplAutoSwapIn: could not get stream to swap in graphic! (=>KA)" );
 238                 }
 239             }
 240
 241             mbIsInSwapIn = sal_False;
 242
 243             if( !mbAutoSwapped && mpMgr )
 244                 mpMgr->ImplGraphicObjectWasSwappedIn( *this );
 245         }
 246     }
 247 }
 248
 249 sal_Bool GraphicObject::ImplGetCropParams( OutputDevice* pOut, Point& rPt, Size& rSz, const GraphicAttr* pAttr,
 250                                        PolyPolygon& rClipPolyPoly, sal_Bool& bRectClipRegion ) const
 251 {
 252     sal_Bool bRet = sal_False;
 253
 254     if( GetType() != GRAPHIC_NONE )
 255     {
 256         Polygon         aClipPoly( Rectangle( rPt, rSz ) );
 257         const sal_uInt16    nRot10 = pAttr->GetRotation() % 3600;
 258         const Point     aOldOrigin( rPt );
 259         const MapMode   aMap100( MAP_100TH_MM );
 260         Size            aSize100;
 261         long            nTotalWidth, nTotalHeight;
 262
 263         if( nRot10 )
 264         {
 265             aClipPoly.Rotate( rPt, nRot10 );
 266             bRectClipRegion = sal_False;
 267         }
 268         else
 269             bRectClipRegion = sal_True;
 270
 271         rClipPolyPoly = aClipPoly;
 272
 273         if( maGraphic.GetPrefMapMode() == MAP_PIXEL )
 274             aSize100 = Application::GetDefaultDevice()->PixelToLogic( maGraphic.GetPrefSize(), aMap100 );
 275         else
 276         {
 277             MapMode m(maGraphic.GetPrefMapMode());
 278             aSize100 = pOut->LogicToLogic( maGraphic.GetPrefSize(), &m, &aMap100 );
 279         }
 280
 281         nTotalWidth = aSize100.Width() - pAttr->GetLeftCrop() - pAttr->GetRightCrop();
 282         nTotalHeight = aSize100.Height() - pAttr->GetTopCrop() - pAttr->GetBottomCrop();
 283
 284         if( aSize100.Width() > 0 && aSize100.Height() > 0 && nTotalWidth > 0 && nTotalHeight > 0 )
 285         {
 286             double fScale = (double) aSize100.Width() / nTotalWidth;
 287             const long nNewLeft = -FRound( ( ( pAttr->GetMirrorFlags() & BMP_MIRROR_HORZ ) ? pAttr->GetRightCrop() : pAttr->GetLeftCrop() ) * fScale );
 288             const long nNewRight = nNewLeft + FRound( aSize100.Width() * fScale ) - 1;
 289
 290             fScale = (double) rSz.Width() / aSize100.Width();
 291             rPt.X() += FRound( nNewLeft * fScale );
 292             rSz.Width() = FRound( ( nNewRight - nNewLeft + 1 ) * fScale );
 293
 294             fScale = (double) aSize100.Height() / nTotalHeight;
 295             const long nNewTop = -FRound( ( ( pAttr->GetMirrorFlags() & BMP_MIRROR_VERT ) ? pAttr->GetBottomCrop() : pAttr->GetTopCrop() ) * fScale );
 296             const long nNewBottom = nNewTop + FRound( aSize100.Height() * fScale ) - 1;
 297
 298             fScale = (double) rSz.Height() / aSize100.Height();
 299             rPt.Y() += FRound( nNewTop * fScale );
 300             rSz.Height() = FRound( ( nNewBottom - nNewTop + 1 ) * fScale );
 301
 302             if( nRot10 )
 303             {
 304                 Polygon aOriginPoly( 1 );
 305
 306                 aOriginPoly[ 0 ] = rPt;
 307                 aOriginPoly.Rotate( aOldOrigin, nRot10 );
 308                 rPt = aOriginPoly[ 0 ];
 309             }
 310
 311             bRet = sal_True;
 312         }
 313     }
 314
 315     return bRet;
 316 }
 317
 318 GraphicObject& GraphicObject::operator=( const GraphicObject& rGraphicObj )
 319 {
 320     if( &rGraphicObj != this )
 321     {
 322         mpMgr->ImplUnregisterObj( *this );
 323
 324         delete mpSwapStreamHdl, mpSwapStreamHdl = NULL;
 325         delete mpSimpleCache, mpSimpleCache = NULL;
 326
 327         maGraphic = rGraphicObj.GetGraphic();
 328         maAttr = rGraphicObj.maAttr;
 329         maLink = rGraphicObj.maLink;
 330         maUserData = rGraphicObj.maUserData;
 331         ImplAssignGraphicData();
 332         mbAutoSwapped = sal_False;
 333         mpMgr = rGraphicObj.mpMgr;
 334
 335         mpMgr->ImplRegisterObj( *this, maGraphic, NULL, &rGraphicObj );
 336     }
 337
 338     return *this;
 339 }
 340
 341 sal_Bool GraphicObject::operator==( const GraphicObject& rGraphicObj ) const
 342 {
 343     return( ( rGraphicObj.maGraphic == maGraphic ) &&
 344             ( rGraphicObj.maAttr == maAttr ) &&
 345             ( rGraphicObj.GetLink() == GetLink() ) );
 346 }
 347
 348 void GraphicObject::Load( SvStream& rIStm )
 349 {
 350     rIStm >> *this;
 351 }
 352
 353 void GraphicObject::Save( SvStream& rOStm )
 354 {
 355     rOStm << *this;
 356 }
 357
 358 void GraphicObject::Assign( const SvDataCopyStream& rCopyStream )
 359 {
 360     *this = (const GraphicObject& ) rCopyStream;
 361 }
 362
 363 OString GraphicObject::GetUniqueID() const
 364 {
 365     if ( !IsInSwapIn() && IsEPS() )
 366         const_cast<GraphicObject*>(this)->FireSwapInRequest();
 367
 368     OString aRet;
 369
 370     if( mpMgr )
 371         aRet = mpMgr->ImplGetUniqueID( *this );
 372
 373     return aRet;
 374 }
 375
 376 SvStream* GraphicObject::GetSwapStream() const
 377 {
 378     return( HasSwapStreamHdl() ? (SvStream*) mpSwapStreamHdl->Call( (void*) this ) : GRFMGR_AUTOSWAPSTREAM_NONE );
 379 }
 380
 381 void GraphicObject::SetAttr( const GraphicAttr& rAttr )
 382 {
 383     maAttr = rAttr;
 384
 385     if( mpSimpleCache && ( mpSimpleCache->maAttr != rAttr ) )
 386         delete mpSimpleCache, mpSimpleCache = NULL;
 387 }
 388
 389 void GraphicObject::SetLink()
 390 {
 391     maLink = "";
 392 }
 393
 394 void GraphicObject::SetLink( const OUString& rLink )
 395 {
 396     maLink = rLink;
 397 }
 398
 399 void GraphicObject::SetUserData()
 400 {
 401     maUserData = "";
 402 }
 403
 404 void GraphicObject::SetUserData( const OUString& rUserData )
 405 {
 406     maUserData = rUserData;
 407 }
 408
 409 void GraphicObject::SetSwapStreamHdl()
 410 {
 411     if( mpSwapStreamHdl )
 412     {
 413         delete mpSwapOutTimer, mpSwapOutTimer = NULL;
 414         delete mpSwapStreamHdl, mpSwapStreamHdl = NULL;
 415     }
 416 }
 417
 418 void GraphicObject::SetSwapStreamHdl( const Link& rHdl, const sal_uLong nSwapOutTimeout )
 419 {
 420     delete mpSwapStreamHdl, mpSwapStreamHdl = new Link( rHdl );
 421
 422     if( nSwapOutTimeout )
 423     {
 424         if( !mpSwapOutTimer )
 425         {
 426             mpSwapOutTimer = new Timer;
 427             mpSwapOutTimer->SetTimeoutHdl( LINK( this, GraphicObject, ImplAutoSwapOutHdl ) );
 428         }
 429
 430         mpSwapOutTimer->SetTimeout( nSwapOutTimeout );
 431         mpSwapOutTimer->Start();
 432     }
 433     else
 434         delete mpSwapOutTimer, mpSwapOutTimer = NULL;
 435 }
 436
 437 void GraphicObject::FireSwapInRequest()
 438 {
 439     ImplAutoSwapIn();
 440 }
 441
 442 void GraphicObject::FireSwapOutRequest()
 443 {
 444     ImplAutoSwapOutHdl( NULL );
 445 }
 446
 447 void GraphicObject::GraphicManagerDestroyed()
 448 {
 449     // we're alive, but our manager doesn't live anymore ==> connect to default manager
 450     mpMgr = NULL;
 451     ImplSetGraphicManager( NULL );
 452 }
 453
 454 sal_Bool GraphicObject::IsCached( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 455                               const GraphicAttr* pAttr, sal_uLong nFlags ) const
 456 {
 457     sal_Bool bRet;
 458
 459     if( nFlags & GRFMGR_DRAW_CACHED )
 460     {
 461         Point aPt( rPt );
 462         Size aSz( rSz );
 463         if ( pAttr->IsCropped() )
 464         {
 465             PolyPolygon aClipPolyPoly;
 466             sal_Bool        bRectClip;
 467             ImplGetCropParams( pOut, aPt, aSz, pAttr, aClipPolyPoly, bRectClip );
 468         }
 469         bRet = mpMgr->IsInCache( pOut, aPt, aSz, *this, ( pAttr ? *pAttr : GetAttr() ) );
 470     }
 471     else
 472         bRet = sal_False;
 473
 474     return bRet;
 475 }
 476
 477 void GraphicObject::ReleaseFromCache()
 478 {
 479
 480     mpMgr->ReleaseFromCache( *this );
 481 }
 482
 483 bool GraphicObject::Draw( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 484                           const GraphicAttr* pAttr, sal_uLong nFlags )
 485 {
 486     GraphicAttr         aAttr( pAttr ? *pAttr : GetAttr() );
 487     Point               aPt( rPt );
 488     Size                aSz( rSz );
 489     const sal_uInt32    nOldDrawMode = pOut->GetDrawMode();
 490     sal_Bool                bCropped = aAttr.IsCropped();
 491     sal_Bool                bCached = sal_False;
 492     bool bRet;
 493
 494     // #i29534# Provide output rects for PDF writer
 495     Rectangle           aCropRect;
 496
 497     if( !( GRFMGR_DRAW_USE_DRAWMODE_SETTINGS & nFlags ) )
 498         pOut->SetDrawMode( nOldDrawMode & ( ~( DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT ) ) );
 499
 500     // mirrored horizontically
 501     if( aSz.Width() < 0L )
 502     {
 503         aPt.X() += aSz.Width() + 1;
 504         aSz.Width() = -aSz.Width();
 505         aAttr.SetMirrorFlags( aAttr.GetMirrorFlags() ^ BMP_MIRROR_HORZ );
 506     }
 507
 508     // mirrored vertically
 509     if( aSz.Height() < 0L )
 510     {
 511         aPt.Y() += aSz.Height() + 1;
 512         aSz.Height() = -aSz.Height();
 513         aAttr.SetMirrorFlags( aAttr.GetMirrorFlags() ^ BMP_MIRROR_VERT );
 514     }
 515
 516     if( bCropped )
 517     {
 518         PolyPolygon aClipPolyPoly;
 519         sal_Bool        bRectClip;
 520         const sal_Bool  bCrop = ImplGetCropParams( pOut, aPt, aSz, &aAttr, aClipPolyPoly, bRectClip );
 521
 522         pOut->Push( PUSH_CLIPREGION );
 523
 524         if( bCrop )
 525         {
 526             if( bRectClip )
 527             {
 528                 // #i29534# Store crop rect for later forwarding to
 529                 // PDF writer
 530                 aCropRect = aClipPolyPoly.GetBoundRect();
 531                 pOut->IntersectClipRegion( aCropRect );
 532             }
 533             else
 534             {
 535                 pOut->IntersectClipRegion(Region(aClipPolyPoly));
 536             }
 537         }
 538     }
 539
 540     bRet = mpMgr->DrawObj( pOut, aPt, aSz, *this, aAttr, nFlags, bCached );
 541
 542     if( bCropped )
 543         pOut->Pop();
 544
 545     pOut->SetDrawMode( nOldDrawMode );
 546
 547     // #i29534# Moved below OutDev restoration, to avoid multiple swap-ins
 548     // (code above needs to call GetGraphic twice)
 549     if( bCached )
 550     {
 551         if( mpSwapOutTimer )
 552             mpSwapOutTimer->Start();
 553         else
 554             FireSwapOutRequest();
 555     }
 556
 557     return bRet;
 558 }
 559
 560 // #i105243#
 561 sal_Bool GraphicObject::DrawWithPDFHandling( OutputDevice& rOutDev,
 562                                          const Point& rPt, const Size& rSz,
 563                                          const GraphicAttr* pGrfAttr,
 564                                          const sal_uLong nFlags )
 565 {
 566     const GraphicAttr aGrfAttr( pGrfAttr ? *pGrfAttr : GetAttr() );
 567
 568     // Notify PDF writer about linked graphic (if any)
 569     sal_Bool bWritingPdfLinkedGraphic( sal_False );
 570     Point aPt( rPt );
 571     Size aSz( rSz );
 572     Rectangle aCropRect;
 573     vcl::PDFExtOutDevData* pPDFExtOutDevData =
 574             dynamic_cast<vcl::PDFExtOutDevData*>(rOutDev.GetExtOutDevData());
 575     if( pPDFExtOutDevData )
 576     {
 577         // only delegate image handling to PDF, if no special treatment is necessary
 578         if( GetGraphic().IsLink() &&
 579             rSz.Width() > 0L &&
 580             rSz.Height() > 0L &&
 581             !aGrfAttr.IsSpecialDrawMode() &&
 582             !aGrfAttr.IsMirrored() &&
 583             !aGrfAttr.IsRotated() &&
 584             !aGrfAttr.IsAdjusted() )
 585         {
 586             bWritingPdfLinkedGraphic = true;
 587
 588             if( aGrfAttr.IsCropped() )
 589             {
 590                 PolyPolygon aClipPolyPoly;
 591                 sal_Bool bRectClip;
 592                 const sal_Bool bCrop = ImplGetCropParams( &rOutDev,
 593                                                       aPt, aSz,
 594                                                       &aGrfAttr,
 595                                                       aClipPolyPoly,
 596                                                       bRectClip );
 597                 if ( bCrop && bRectClip )
 598                 {
 599                     aCropRect = aClipPolyPoly.GetBoundRect();
 600                 }
 601             }
 602
 603             pPDFExtOutDevData->BeginGroup();
 604         }
 605     }
 606
 607     sal_Bool bRet = Draw( &rOutDev, rPt, rSz, &aGrfAttr, nFlags );
 608
 609     // Notify PDF writer about linked graphic (if any)
 610     if( bWritingPdfLinkedGraphic )
 611     {
 612         pPDFExtOutDevData->EndGroup( const_cast< Graphic& >(GetGraphic()),
 613                                      aGrfAttr.GetTransparency(),
 614                                      Rectangle( aPt, aSz ),
 615                                      aCropRect );
 616     }
 617
 618     return bRet;
 619 }
 620
 621 sal_Bool GraphicObject::DrawTiled( OutputDevice* pOut, const Rectangle& rArea, const Size& rSize,
 622                                const Size& rOffset, const GraphicAttr* pAttr, sal_uLong nFlags, int nTileCacheSize1D )
 623 {
 624     if( pOut == NULL || rSize.Width() == 0 || rSize.Height() == 0 )
 625         return sal_False;
 626
 627     const MapMode   aOutMapMode( pOut->GetMapMode() );
 628     const MapMode   aMapMode( aOutMapMode.GetMapUnit(), Point(), aOutMapMode.GetScaleX(), aOutMapMode.GetScaleY() );
 629     // #106258# Clamp size to 1 for zero values. This is okay, since
 630     // logical size of zero is handled above already
 631     const Size      aOutTileSize( ::std::max( 1L, pOut->LogicToPixel( rSize, aOutMapMode ).Width() ),
 632                                   ::std::max( 1L, pOut->LogicToPixel( rSize, aOutMapMode ).Height() ) );
 633
 634     //#i69780 clip final tile size to a sane max size
 635     while (((sal_Int64)rSize.Width() * nTileCacheSize1D) > SAL_MAX_UINT16)
 636         nTileCacheSize1D /= 2;
 637     while (((sal_Int64)rSize.Height() * nTileCacheSize1D) > SAL_MAX_UINT16)
 638         nTileCacheSize1D /= 2;
 639
 640     return ImplDrawTiled( pOut, rArea, aOutTileSize, rOffset, pAttr, nFlags, nTileCacheSize1D );
 641 }
 642
 643 sal_Bool GraphicObject::StartAnimation( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 644                                     long nExtraData, const GraphicAttr* pAttr, sal_uLong /*nFlags*/,
 645                                     OutputDevice* pFirstFrameOutDev )
 646 {
 647     sal_Bool bRet = sal_False;
 648
 649     GetGraphic();
 650
 651     if( !IsSwappedOut() )
 652     {
 653         const GraphicAttr aAttr( pAttr ? *pAttr : GetAttr() );
 654
 655         if( mbAnimated )
 656         {
 657             Point   aPt( rPt );
 658             Size    aSz( rSz );
 659             sal_Bool    bCropped = aAttr.IsCropped();
 660
 661             if( bCropped )
 662             {
 663                 PolyPolygon aClipPolyPoly;
 664                 sal_Bool        bRectClip;
 665                 const sal_Bool  bCrop = ImplGetCropParams( pOut, aPt, aSz, &aAttr, aClipPolyPoly, bRectClip );
 666
 667                 pOut->Push( PUSH_CLIPREGION );
 668
 669                 if( bCrop )
 670                 {
 671                     if( bRectClip )
 672                         pOut->IntersectClipRegion( aClipPolyPoly.GetBoundRect() );
 673                     else
 674                         pOut->IntersectClipRegion(Region(aClipPolyPoly));
 675                 }
 676             }
 677
 678             if( !mpSimpleCache || ( mpSimpleCache->maAttr != aAttr ) || pFirstFrameOutDev )
 679             {
 680                 if( mpSimpleCache )
 681                     delete mpSimpleCache;
 682
 683                 mpSimpleCache = new GrfSimpleCacheObj( GetTransformedGraphic( &aAttr ), aAttr );
 684                 mpSimpleCache->maGraphic.SetAnimationNotifyHdl( GetAnimationNotifyHdl() );
 685             }
 686
 687             mpSimpleCache->maGraphic.StartAnimation( pOut, aPt, aSz, nExtraData, pFirstFrameOutDev );
 688
 689             if( bCropped )
 690                 pOut->Pop();
 691
 692             bRet = sal_True;
 693         }
 694         else
 695             bRet = Draw( pOut, rPt, rSz, &aAttr, GRFMGR_DRAW_STANDARD );
 696     }
 697
 698     return bRet;
 699 }
 700
 701 void GraphicObject::StopAnimation( OutputDevice* pOut, long nExtraData )
 702 {
 703     if( mpSimpleCache )
 704         mpSimpleCache->maGraphic.StopAnimation( pOut, nExtraData );
 705 }
 706
 707 const Graphic& GraphicObject::GetGraphic() const
 708 {
 709     if( mbAutoSwapped )
 710         ( (GraphicObject*) this )->ImplAutoSwapIn();
 711
 712     return maGraphic;
 713 }
 714
 715 void GraphicObject::SetGraphic( const Graphic& rGraphic, const GraphicObject* pCopyObj )
 716 {
 717     mpMgr->ImplUnregisterObj( *this );
 718
 719     if( mpSwapOutTimer )
 720         mpSwapOutTimer->Stop();
 721
 722     maGraphic = rGraphic;
 723     mbAutoSwapped = sal_False;
 724     ImplAssignGraphicData();
 725     maLink = "";
 726     delete mpSimpleCache, mpSimpleCache = NULL;
 727
 728     mpMgr->ImplRegisterObj( *this, maGraphic, 0, pCopyObj);
 729
 730     if( mpSwapOutTimer )
 731         mpSwapOutTimer->Start();
 732 }
 733
 734 void GraphicObject::SetGraphic( const Graphic& rGraphic, const OUString& rLink )
 735 {
 736     SetGraphic( rGraphic );
 737     maLink = rLink;
 738 }
 739
 740 Graphic GraphicObject::GetTransformedGraphic( const Size& rDestSize, const MapMode& rDestMap, const GraphicAttr& rAttr ) const
 741 {
 742     // #104550# Extracted from svx/source/svdraw/svdograf.cxx
 743     Graphic             aTransGraphic( maGraphic );
 744     const GraphicType   eType = GetType();
 745     const Size          aSrcSize( aTransGraphic.GetPrefSize() );
 746
 747     // #104115# Convert the crop margins to graphic object mapmode
 748     const MapMode aMapGraph( aTransGraphic.GetPrefMapMode() );
 749     const MapMode aMap100( MAP_100TH_MM );
 750
 751     Size aCropLeftTop;
 752     Size aCropRightBottom;
 753
 754     if( GRAPHIC_GDIMETAFILE == eType )
 755     {
 756         GDIMetaFile aMtf( aTransGraphic.GetGDIMetaFile() );
 757
 758         if( aMapGraph == MAP_PIXEL )
 759         {
 760             // crops are in 1/100th mm -> to aMapGraph -> to MAP_PIXEL
 761             aCropLeftTop = Application::GetDefaultDevice()->LogicToPixel(
 762                 Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 763                 aMap100);
 764             aCropRightBottom = Application::GetDefaultDevice()->LogicToPixel(
 765                 Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 766                 aMap100);
 767         }
 768         else
 769         {
 770             // crops are in GraphicObject units -> to aMapGraph
 771             aCropLeftTop = OutputDevice::LogicToLogic(
 772                 Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 773                 aMap100,
 774                 aMapGraph);
 775             aCropRightBottom = OutputDevice::LogicToLogic(
 776                 Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 777                 aMap100,
 778                 aMapGraph);
 779         }
 780
 781         // #104115# If the metafile is cropped, give it a special
 782         // treatment: clip against the remaining area, scale up such
 783         // that this area later fills the desired size, and move the
 784         // origin to the upper left edge of that area.
 785         if( rAttr.IsCropped() )
 786         {
 787             const MapMode aMtfMapMode( aMtf.GetPrefMapMode() );
 788
 789             Rectangle aClipRect( aMtfMapMode.GetOrigin().X() + aCropLeftTop.Width(),
 790                                  aMtfMapMode.GetOrigin().Y() + aCropLeftTop.Height(),
 791                                  aMtfMapMode.GetOrigin().X() + aSrcSize.Width() - aCropRightBottom.Width(),
 792                                  aMtfMapMode.GetOrigin().Y() + aSrcSize.Height() - aCropRightBottom.Height() );
 793
 794             // #104115# To correctly crop rotated metafiles, clip by view rectangle
 795             aMtf.AddAction( new MetaISectRectClipRegionAction( aClipRect ), 0 );
 796
 797             // #104115# To crop the metafile, scale larger than the output rectangle
 798             aMtf.Scale( (double)rDestSize.Width() / (aSrcSize.Width() - aCropLeftTop.Width() - aCropRightBottom.Width()),
 799                         (double)rDestSize.Height() / (aSrcSize.Height() - aCropLeftTop.Height() - aCropRightBottom.Height()) );
 800
 801             // #104115# Adapt the pref size by hand (scale changes it
 802             // proportionally, but we want it to be smaller than the
 803             // former size, to crop the excess out)
 804             aMtf.SetPrefSize( Size( (long)((double)rDestSize.Width() *  (1.0 + (aCropLeftTop.Width() + aCropRightBottom.Width()) / aSrcSize.Width())  + .5),
 805                                     (long)((double)rDestSize.Height() * (1.0 + (aCropLeftTop.Height() + aCropRightBottom.Height()) / aSrcSize.Height()) + .5) ) );
 806
 807             // #104115# Adapt the origin of the new mapmode, such that it
 808             // is shifted to the place where the cropped output starts
 809             Point aNewOrigin( (long)((double)aMtfMapMode.GetOrigin().X() + rDestSize.Width() * aCropLeftTop.Width() / (aSrcSize.Width() - aCropLeftTop.Width() - aCropRightBottom.Width()) + .5),
 810                               (long)((double)aMtfMapMode.GetOrigin().Y() + rDestSize.Height() * aCropLeftTop.Height() / (aSrcSize.Height() - aCropLeftTop.Height() - aCropRightBottom.Height()) + .5) );
 811             MapMode aNewMap( rDestMap );
 812             aNewMap.SetOrigin( OutputDevice::LogicToLogic(aNewOrigin, aMtfMapMode, rDestMap) );
 813             aMtf.SetPrefMapMode( aNewMap );
 814         }
 815         else
 816         {
 817             aMtf.Scale( Fraction( rDestSize.Width(), aSrcSize.Width() ), Fraction( rDestSize.Height(), aSrcSize.Height() ) );
 818             aMtf.SetPrefMapMode( rDestMap );
 819         }
 820
 821         aTransGraphic = aMtf;
 822     }
 823     else if( GRAPHIC_BITMAP == eType )
 824     {
 825         BitmapEx aBitmapEx( aTransGraphic.GetBitmapEx() );
 826         Rectangle aCropRect;
 827
 828         // convert crops to pixel
 829         if(rAttr.IsCropped())
 830         {
 831             if( aMapGraph == MAP_PIXEL )
 832             {
 833                 // crops are in 1/100th mm -> to MAP_PIXEL
 834                 aCropLeftTop = Application::GetDefaultDevice()->LogicToPixel(
 835                     Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 836                     aMap100);
 837                 aCropRightBottom = Application::GetDefaultDevice()->LogicToPixel(
 838                     Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 839                     aMap100);
 840             }
 841             else
 842             {
 843                 // crops are in GraphicObject units -> to MAP_PIXEL
 844                 aCropLeftTop = Application::GetDefaultDevice()->LogicToPixel(
 845                     Size(rAttr.GetLeftCrop(), rAttr.GetTopCrop()),
 846                     aMapGraph);
 847                 aCropRightBottom = Application::GetDefaultDevice()->LogicToPixel(
 848                     Size(rAttr.GetRightCrop(), rAttr.GetBottomCrop()),
 849                     aMapGraph);
 850             }
 851
 852             // convert from prefmapmode to pixel
 853             Size aSrcSizePixel(
 854                 Application::GetDefaultDevice()->LogicToPixel(
 855                     aSrcSize,
 856                     aMapGraph));
 857
 858             if(rAttr.IsCropped()
 859                 && (aSrcSizePixel.Width() != aBitmapEx.GetSizePixel().Width() || aSrcSizePixel.Height() != aBitmapEx.GetSizePixel().Height())
 860                 && aSrcSizePixel.Width())
 861             {
 862                 // the size in pixels calculated from Graphic's internal MapMode (aTransGraphic.GetPrefMapMode())
 863                 // and it's internal size (aTransGraphic.GetPrefSize()) is different from it's real pixel size.
 864                 // This can be interpreted as this values to be set wrong, but needs to be corrected since e.g.
 865                 // existing cropping is calculated based on this logic values already.
 866                 // aBitmapEx.Scale(aSrcSizePixel);
 867
 868                 // another possibility is to adapt the values created so far with a factor; this
 869                 // will keep the original Bitmap untouched and thus quality will not change
 870                 // caution: convert to double first, else pretty big errors may occurr
 871                 const double fFactorX((double)aBitmapEx.GetSizePixel().Width() / aSrcSizePixel.Width());
 872                 const double fFactorY((double)aBitmapEx.GetSizePixel().Height() / aSrcSizePixel.Height());
 873
 874                 aCropLeftTop.Width() = basegfx::fround(aCropLeftTop.Width() * fFactorX);
 875                 aCropLeftTop.Height() = basegfx::fround(aCropLeftTop.Height() * fFactorY);
 876                 aCropRightBottom.Width() = basegfx::fround(aCropRightBottom.Width() * fFactorX);
 877                 aCropRightBottom.Height() = basegfx::fround(aCropRightBottom.Height() * fFactorY);
 878
 879                 aSrcSizePixel = aBitmapEx.GetSizePixel();
 880             }
 881
 882             // setup crop rectangle in pixel
 883             aCropRect = Rectangle( aCropLeftTop.Width(), aCropLeftTop.Height(),
 884                                  aSrcSizePixel.Width() - aCropRightBottom.Width(),
 885                                  aSrcSizePixel.Height() - aCropRightBottom.Height() );
 886         }
 887
 888         // #105641# Also crop animations
 889         if( aTransGraphic.IsAnimated() )
 890         {
 891             sal_uInt16 nFrame;
 892             Animation aAnim( aTransGraphic.GetAnimation() );
 893
 894             for( nFrame=0; nFrame<aAnim.Count(); ++nFrame )
 895             {
 896                 AnimationBitmap aAnimBmp( aAnim.Get( nFrame ) );
 897
 898                 if( !aCropRect.IsInside( Rectangle(aAnimBmp.aPosPix, aAnimBmp.aSizePix) ) )
 899                 {
 900                     // setup actual cropping (relative to frame position)
 901                     Rectangle aCropRectRel( aCropRect );
 902                     aCropRectRel.Move( -aAnimBmp.aPosPix.X(),
 903                                        -aAnimBmp.aPosPix.Y() );
 904
 905                     // cropping affects this frame, apply it then
 906                     // do _not_ apply enlargement, this is done below
 907                     ImplTransformBitmap( aAnimBmp.aBmpEx, rAttr, Size(), Size(),
 908                                          aCropRectRel, rDestSize, sal_False );
 909
 910                     aAnim.Replace( aAnimBmp, nFrame );
 911                 }
 912                 // else: bitmap completely within crop area,
 913                 // i.e. nothing is cropped away
 914             }
 915
 916             // now, apply enlargement (if any) through global animation size
 917             if( aCropLeftTop.Width() < 0 ||
 918                 aCropLeftTop.Height() < 0 ||
 919                 aCropRightBottom.Width() < 0 ||
 920                 aCropRightBottom.Height() < 0 )
 921             {
 922                 Size aNewSize( aAnim.GetDisplaySizePixel() );
 923                 aNewSize.Width() += aCropRightBottom.Width() < 0 ? -aCropRightBottom.Width() : 0;
 924                 aNewSize.Width() += aCropLeftTop.Width() < 0 ? -aCropLeftTop.Width() : 0;
 925                 aNewSize.Height() += aCropRightBottom.Height() < 0 ? -aCropRightBottom.Height() : 0;
 926                 aNewSize.Height() += aCropLeftTop.Height() < 0 ? -aCropLeftTop.Height() : 0;
 927                 aAnim.SetDisplaySizePixel( aNewSize );
 928             }
 929
 930             // if topleft has changed, we must move all frames to the
 931             // right and bottom, resp.
 932             if( aCropLeftTop.Width() < 0 ||
 933                 aCropLeftTop.Height() < 0 )
 934             {
 935                 Point aPosOffset( aCropLeftTop.Width() < 0 ? -aCropLeftTop.Width() : 0,
 936                                   aCropLeftTop.Height() < 0 ? -aCropLeftTop.Height() : 0 );
 937
 938                 for( nFrame=0; nFrame<aAnim.Count(); ++nFrame )
 939                 {
 940                     AnimationBitmap aAnimBmp( aAnim.Get( nFrame ) );
 941
 942                     aAnimBmp.aPosPix += aPosOffset;
 943
 944                     aAnim.Replace( aAnimBmp, nFrame );
 945                 }
 946             }
 947
 948             aTransGraphic = aAnim;
 949         }
 950         else
 951         {
 952             ImplTransformBitmap( aBitmapEx, rAttr, aCropLeftTop, aCropRightBottom,
 953                                  aCropRect, rDestSize, sal_True );
 954
 955             aTransGraphic = aBitmapEx;
 956         }
 957
 958         aTransGraphic.SetPrefSize( rDestSize );
 959         aTransGraphic.SetPrefMapMode( rDestMap );
 960     }
 961
 962     GraphicObject aGrfObj( aTransGraphic );
 963     aTransGraphic = aGrfObj.GetTransformedGraphic( &rAttr );
 964
 965     return aTransGraphic;
 966 }
 967
 968 Graphic GraphicObject::GetTransformedGraphic( const GraphicAttr* pAttr ) const // TODO: Change to Impl
 969 {
 970     GetGraphic();
 971
 972     Graphic     aGraphic;
 973     GraphicAttr aAttr( pAttr ? *pAttr : GetAttr() );
 974
 975     if( maGraphic.IsSupportedGraphic() && !maGraphic.IsSwapOut() )
 976     {
 977         if( aAttr.IsSpecialDrawMode() || aAttr.IsAdjusted() || aAttr.IsMirrored() || aAttr.IsRotated() || aAttr.IsTransparent() )
 978         {
 979             if( GetType() == GRAPHIC_BITMAP )
 980             {
 981                 if( IsAnimated() )
 982                 {
 983                     Animation aAnimation( maGraphic.GetAnimation() );
 984                     GraphicManager::ImplAdjust( aAnimation, aAttr, ADJUSTMENT_ALL );
 985                     aAnimation.SetLoopCount( mnAnimationLoopCount );
 986                     aGraphic = aAnimation;
 987                 }
 988                 else
 989                 {
 990                     BitmapEx aBmpEx( maGraphic.GetBitmapEx() );
 991                     GraphicManager::ImplAdjust( aBmpEx, aAttr, ADJUSTMENT_ALL );
 992                     aGraphic = aBmpEx;
 993                 }
 994             }
 995             else
 996             {
 997                 GDIMetaFile aMtf( maGraphic.GetGDIMetaFile() );
 998                 GraphicManager::ImplAdjust( aMtf, aAttr, ADJUSTMENT_ALL );
 999                 aGraphic = aMtf;
1000             }
1001         }
1002         else
1003         {
1004             if( ( GetType() == GRAPHIC_BITMAP ) && IsAnimated() )
1005             {
1006                 Animation aAnimation( maGraphic.GetAnimation() );
1007                 aAnimation.SetLoopCount( mnAnimationLoopCount );
1008                 aGraphic = aAnimation;
1009             }
1010             else
1011                 aGraphic = maGraphic;
1012         }
1013     }
1014
1015     return aGraphic;
1016 }
1017
1018 sal_Bool GraphicObject::SwapOut()
1019 {
1020     sal_Bool bRet = ( !mbAutoSwapped ? maGraphic.SwapOut() : sal_False );
1021
1022     if( bRet && mpMgr )
1023         mpMgr->ImplGraphicObjectWasSwappedOut( *this );
1024
1025     return bRet;
1026 }
1027
1028 sal_Bool GraphicObject::SwapOut( SvStream* pOStm )
1029 {
1030     sal_Bool bRet = ( !mbAutoSwapped ? maGraphic.SwapOut( pOStm ) : sal_False );
1031
1032     if( bRet && mpMgr )
1033         mpMgr->ImplGraphicObjectWasSwappedOut( *this );
1034
1035     return bRet;
1036 }
1037
1038 sal_Bool GraphicObject::SwapIn()
1039 {
1040     sal_Bool bRet;
1041
1042     if( mbAutoSwapped )
1043     {
1044         ImplAutoSwapIn();
1045         bRet = sal_True;
1046     }
1047     else if( mpMgr && mpMgr->ImplFillSwappedGraphicObject( *this, maGraphic ) )
1048         bRet = sal_True;
1049     else
1050     {
1051         bRet = maGraphic.SwapIn();
1052
1053         if( bRet && mpMgr )
1054             mpMgr->ImplGraphicObjectWasSwappedIn( *this );
1055     }
1056
1057     if( bRet )
1058         ImplAssignGraphicData();
1059
1060     return bRet;
1061 }
1062
1063 void GraphicObject::SetSwapState()
1064 {
1065     if( !IsSwappedOut() )
1066     {
1067         mbAutoSwapped = sal_True;
1068
1069         if( mpMgr )
1070             mpMgr->ImplGraphicObjectWasSwappedOut( *this );
1071     }
1072 }
1073
1074 IMPL_LINK_NOARG(GraphicObject, ImplAutoSwapOutHdl)
1075 {
1076     if( !IsSwappedOut() )
1077     {
1078         mbIsInSwapOut = sal_True;
1079
1080         SvStream* pStream = GetSwapStream();
1081
1082         if( GRFMGR_AUTOSWAPSTREAM_NONE != pStream )
1083         {
1084             if( GRFMGR_AUTOSWAPSTREAM_LINK == pStream )
1085                 mbAutoSwapped = SwapOut( NULL );
1086             else
1087             {
1088                 if( GRFMGR_AUTOSWAPSTREAM_TEMP == pStream )
1089                     mbAutoSwapped = SwapOut();
1090                 else
1091                 {
1092                     mbAutoSwapped = SwapOut( pStream );
1093                     delete pStream;
1094                 }
1095             }
1096         }
1097
1098         mbIsInSwapOut = sal_False;
1099     }
1100
1101     if( mpSwapOutTimer )
1102         mpSwapOutTimer->Start();
1103
1104     return 0L;
1105 }
1106
1107 SvStream& operator>>( SvStream& rIStm, GraphicObject& rGraphicObj )
1108 {
1109     VersionCompat   aCompat( rIStm, STREAM_READ );
1110     Graphic         aGraphic;
1111     GraphicAttr     aAttr;
1112     sal_Bool            bLink;
1113
1114     rIStm >> aGraphic >> aAttr >> bLink;
1115
1116     rGraphicObj.SetGraphic( aGraphic );
1117     rGraphicObj.SetAttr( aAttr );
1118
1119     if( bLink )
1120     {
1121         OUString aLink = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rIStm, RTL_TEXTENCODING_UTF8);
1122         rGraphicObj.SetLink(aLink);
1123     }
1124     else
1125         rGraphicObj.SetLink();
1126
1127     rGraphicObj.SetSwapStreamHdl();
1128
1129     return rIStm;
1130 }
1131
1132 SvStream& operator<<( SvStream& rOStm, const GraphicObject& rGraphicObj )
1133 {
1134     VersionCompat   aCompat( rOStm, STREAM_WRITE, 1 );
1135     const sal_Bool      bLink =  rGraphicObj.HasLink();
1136
1137     rOStm << rGraphicObj.GetGraphic() << rGraphicObj.GetAttr() << bLink;
1138
1139     if( bLink )
1140         write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rOStm, rGraphicObj.GetLink(), RTL_TEXTENCODING_UTF8);
1141
1142     return rOStm;
1143 }
1144
1145 #define UNO_NAME_GRAPHOBJ_URLPREFIX "vnd.sun.star.GraphicObject:"
1146
1147 GraphicObject GraphicObject::CreateGraphicObjectFromURL( const OUString &rURL )
1148 {
1149     const OUString aURL( rURL ), aPrefix( UNO_NAME_GRAPHOBJ_URLPREFIX );
1150     if( aURL.startsWith( aPrefix ) )
1151     {
1152         // graphic manager url
1153         OString aUniqueID(OUStringToOString(rURL.copy(sizeof(UNO_NAME_GRAPHOBJ_URLPREFIX) - 1), RTL_TEXTENCODING_UTF8));
1154         return GraphicObject( aUniqueID );
1155     }
1156     else
1157     {
1158         Graphic     aGraphic;
1159         if ( !aURL.isEmpty() )
1160         {
1161             SvStream*   pStream = utl::UcbStreamHelper::CreateStream( aURL, STREAM_READ );
1162             if( pStream )
1163             {
1164                 GraphicConverter::Import( *pStream, aGraphic );
1165                 delete pStream;
1166             }
1167         }
1168
1169         return GraphicObject( aGraphic );
1170     }
1171 }
1172
1173 void
1174 GraphicObject::InspectForGraphicObjectImageURL( const Reference< XInterface >& xIf,  std::vector< OUString >& rvEmbedImgUrls )
1175 {
1176     static OUString sImageURL( "ImageURL" );
1177     Reference< XPropertySet > xProps( xIf, UNO_QUERY );
1178     if ( xProps.is() )
1179     {
1180
1181         if ( xProps->getPropertySetInfo()->hasPropertyByName( sImageURL ) )
1182         {
1183             OUString sURL;
1184             xProps->getPropertyValue( sImageURL ) >>= sURL;
1185             if ( !sURL.isEmpty() && sURL.startsWith( UNO_NAME_GRAPHOBJ_URLPREFIX ) )
1186                 rvEmbedImgUrls.push_back( sURL );
1187         }
1188     }
1189     Reference< XNameContainer > xContainer( xIf, UNO_QUERY );
1190     if ( xContainer.is() )
1191     {
1192         Sequence< OUString > sNames = xContainer->getElementNames();
1193         sal_Int32 nContainees = sNames.getLength();
1194         for ( sal_Int32 index = 0; index < nContainees; ++index )
1195         {
1196             Reference< XInterface > xCtrl;
1197             xContainer->getByName( sNames[ index ] ) >>= xCtrl;
1198             InspectForGraphicObjectImageURL( xCtrl, rvEmbedImgUrls );
1199         }
1200     }
1201 }
1202
1203 // calculate scalings between real image size and logic object size. This
1204 // is necessary since the crop values are relative to original bitmap size
1205 basegfx::B2DVector GraphicObject::calculateCropScaling(
1206     double fWidth,
1207     double fHeight,
1208     double fLeftCrop,
1209     double fTopCrop,
1210     double fRightCrop,
1211     double fBottomCrop) const
1212 {
1213     const MapMode aMapMode100thmm(MAP_100TH_MM);
1214     Size aBitmapSize(GetPrefSize());
1215     double fFactorX(1.0);
1216     double fFactorY(1.0);
1217
1218     if(MAP_PIXEL == GetPrefMapMode().GetMapUnit())
1219     {
1220         aBitmapSize = Application::GetDefaultDevice()->PixelToLogic(aBitmapSize, aMapMode100thmm);
1221     }
1222     else
1223     {
1224         aBitmapSize = Application::GetDefaultDevice()->LogicToLogic(aBitmapSize, GetPrefMapMode(), aMapMode100thmm);
1225     }
1226
1227     const double fDivX(aBitmapSize.Width() - fLeftCrop - fRightCrop);
1228     const double fDivY(aBitmapSize.Height() - fTopCrop - fBottomCrop);
1229
1230     if(!basegfx::fTools::equalZero(fDivX))
1231     {
1232         fFactorX = fabs(fWidth) / fDivX;
1233     }
1234
1235     if(!basegfx::fTools::equalZero(fDivY))
1236     {
1237         fFactorY = fabs(fHeight) / fDivY;
1238     }
1239
1240     return basegfx::B2DVector(fFactorX,fFactorY);
1241 }
1242
1243 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */