vcl/source/gdi/gfxlink.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: gfxlink.cxx,v $
  10  * $Revision: 1.19 $
  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_vcl.hxx"
  33
  34 #include <tools/vcompat.hxx>
  35 #include <tools/urlobj.hxx>
  36 #include <tools/debug.hxx>
  37 #include <unotools/ucbstreamhelper.hxx>
  38 #include <unotools/tempfile.hxx>
  39 #include <ucbhelper/content.hxx>
  40 #include <vcl/graph.hxx>
  41 #include <vcl/gfxlink.hxx>
  42 #include <vcl/cvtgrf.hxx>
  43 #include <com/sun/star/ucb/CommandAbortedException.hpp>
  44
  45 // -----------
  46 // - GfxLink -
  47 // -----------
  48
  49 GfxLink::GfxLink() :
  50     meType              ( GFX_LINK_TYPE_NONE ),
  51     mpBuf               ( NULL ),
  52     mpSwap              ( NULL ),
  53     mnBufSize   ( 0 ),
  54     mnUserId    ( 0UL ),
  55     mpImpData   ( new ImpGfxLink )
  56 {
  57 }
  58
  59 // ------------------------------------------------------------------------
  60
  61 GfxLink::GfxLink( const GfxLink& rGfxLink ) :
  62     mpImpData( new ImpGfxLink )
  63 {
  64     ImplCopy( rGfxLink );
  65 }
  66
  67 // ------------------------------------------------------------------------
  68
  69 GfxLink::GfxLink( BYTE* pBuf, sal_uInt32 nSize, GfxLinkType nType, BOOL bOwns ) :
  70     mpImpData( new ImpGfxLink )
  71 {
  72     DBG_ASSERT( (pBuf != NULL && nSize) || (!bOwns && nSize == 0),
  73                 "GfxLink::GfxLink(): empty/NULL buffer given" );
  74
  75     meType = nType;
  76     mnBufSize = nSize;
  77     mpSwap = NULL;
  78     mnUserId = 0UL;
  79
  80     if( bOwns )
  81         mpBuf = new ImpBuffer( pBuf );
  82     else if( nSize )
  83     {
  84         mpBuf = new ImpBuffer( nSize );
  85         memcpy( mpBuf->mpBuffer, pBuf, nSize );
  86     }
  87     else
  88         mpBuf = NULL;
  89 }
  90
  91 // ------------------------------------------------------------------------
  92
  93 GfxLink::~GfxLink()
  94 {
  95     if( mpBuf && !( --mpBuf->mnRefCount ) )
  96         delete mpBuf;
  97
  98     if( mpSwap && !( --mpSwap->mnRefCount ) )
  99         delete mpSwap;
 100
 101     delete mpImpData;
 102 }
 103
 104 // ------------------------------------------------------------------------
 105
 106 GfxLink& GfxLink::operator=( const GfxLink& rGfxLink )
 107 {
 108     if( &rGfxLink != this )
 109     {
 110         if ( mpBuf && !( --mpBuf->mnRefCount ) )
 111             delete mpBuf;
 112
 113         if( mpSwap && !( --mpSwap->mnRefCount ) )
 114             delete mpSwap;
 115
 116         ImplCopy( rGfxLink );
 117     }
 118
 119     return *this;
 120 }
 121
 122 // ------------------------------------------------------------------------
 123
 124 sal_Bool GfxLink::IsEqual( const GfxLink& rGfxLink ) const
 125 {
 126     sal_Bool bIsEqual = sal_False;
 127
 128     if ( ( mnBufSize == rGfxLink.mnBufSize ) && ( meType == rGfxLink.meType ) )
 129     {
 130         const sal_uInt8* pSource = GetData();
 131         const sal_uInt8* pDest = rGfxLink.GetData();
 132         sal_uInt32 nSourceSize = GetDataSize();
 133         sal_uInt32 nDestSize = rGfxLink.GetDataSize();
 134         if ( pSource && pDest && ( nSourceSize == nDestSize ) )
 135         {
 136             bIsEqual = memcmp( pSource, pDest, nSourceSize ) == 0;
 137         }
 138         else if ( ( pSource == 0 ) && ( pDest == 0 ) )
 139             bIsEqual = sal_True;
 140     }
 141     return bIsEqual;
 142 }
 143
 144 // ------------------------------------------------------------------------
 145
 146 void GfxLink::ImplCopy( const GfxLink& rGfxLink )
 147 {
 148     mnBufSize = rGfxLink.mnBufSize;
 149     meType = rGfxLink.meType;
 150     mpBuf = rGfxLink.mpBuf;
 151     mpSwap = rGfxLink.mpSwap;
 152     mnUserId = rGfxLink.mnUserId;
 153     *mpImpData = *rGfxLink.mpImpData;
 154
 155     if( mpBuf )
 156         mpBuf->mnRefCount++;
 157
 158     if( mpSwap )
 159         mpSwap->mnRefCount++;
 160 }
 161
 162 // ------------------------------------------------------------------------
 163
 164 GfxLinkType GfxLink::GetType() const
 165 {
 166     return meType;
 167 }
 168
 169 // ------------------------------------------------------------------------
 170
 171 BOOL GfxLink::IsNative() const
 172 {
 173     return( meType >= GFX_LINK_FIRST_NATIVE_ID && meType <= GFX_LINK_LAST_NATIVE_ID );
 174 }
 175
 176 // ------------------------------------------------------------------------
 177
 178 sal_uInt32 GfxLink::GetDataSize() const
 179 {
 180     return mnBufSize;
 181 }
 182
 183 // ------------------------------------------------------------------------
 184
 185 const BYTE* GfxLink::GetData() const
 186 {
 187     if( IsSwappedOut() )
 188         ( (GfxLink*) this )->SwapIn();
 189
 190     return( mpBuf ? mpBuf->mpBuffer : NULL );
 191 }
 192
 193 // ------------------------------------------------------------------------
 194
 195 const Size&     GfxLink::GetPrefSize() const
 196 {
 197     return mpImpData->maPrefSize;
 198 }
 199
 200 // ------------------------------------------------------------------------
 201
 202 void GfxLink::SetPrefSize( const Size& rPrefSize )
 203 {
 204     mpImpData->maPrefSize = rPrefSize;
 205     mpImpData->mbPrefSizeValid = true;
 206 }
 207
 208 // ------------------------------------------------------------------------
 209
 210 bool GfxLink::IsPrefSizeValid()
 211 {
 212     return mpImpData->mbPrefSizeValid;
 213 }
 214
 215 // ------------------------------------------------------------------------
 216
 217 const MapMode& GfxLink::GetPrefMapMode() const
 218 {
 219     return mpImpData->maPrefMapMode;
 220 }
 221
 222 // ------------------------------------------------------------------------
 223
 224 void GfxLink::SetPrefMapMode( const MapMode& rPrefMapMode )
 225 {
 226     mpImpData->maPrefMapMode = rPrefMapMode;
 227     mpImpData->mbPrefMapModeValid = true;
 228 }
 229
 230 // ------------------------------------------------------------------------
 231
 232 bool GfxLink::IsPrefMapModeValid()
 233 {
 234     return mpImpData->mbPrefMapModeValid;
 235 }
 236
 237 // ------------------------------------------------------------------------
 238
 239 BOOL GfxLink::LoadNative( Graphic& rGraphic )
 240 {
 241     BOOL bRet = FALSE;
 242
 243     if( IsNative() && mnBufSize )
 244     {
 245         const BYTE* pData = GetData();
 246
 247         if( pData )
 248         {
 249             SvMemoryStream      aMemStm;
 250             ULONG                       nCvtType;
 251
 252             aMemStm.SetBuffer( (char*) pData, mnBufSize, FALSE, mnBufSize );
 253
 254             switch( meType )
 255             {
 256                 case( GFX_LINK_TYPE_NATIVE_GIF ): nCvtType = CVT_GIF; break;
 257                 case( GFX_LINK_TYPE_NATIVE_JPG ): nCvtType = CVT_JPG; break;
 258                 case( GFX_LINK_TYPE_NATIVE_PNG ): nCvtType = CVT_PNG; break;
 259                 case( GFX_LINK_TYPE_NATIVE_TIF ): nCvtType = CVT_TIF; break;
 260                 case( GFX_LINK_TYPE_NATIVE_WMF ): nCvtType = CVT_WMF; break;
 261                 case( GFX_LINK_TYPE_NATIVE_MET ): nCvtType = CVT_MET; break;
 262                 case( GFX_LINK_TYPE_NATIVE_PCT ): nCvtType = CVT_PCT; break;
 263
 264                 default: nCvtType = CVT_UNKNOWN; break;
 265             }
 266
 267             if( nCvtType && ( GraphicConverter::Import( aMemStm, rGraphic, nCvtType ) == ERRCODE_NONE ) )
 268                 bRet = TRUE;
 269         }
 270     }
 271
 272     return bRet;
 273 }
 274
 275 // ------------------------------------------------------------------------
 276
 277 void GfxLink::SwapOut()
 278 {
 279     if( !IsSwappedOut() && mpBuf )
 280     {
 281         mpSwap = new ImpSwap( mpBuf->mpBuffer, mnBufSize );
 282
 283         if( !mpSwap->IsSwapped() )
 284         {
 285             delete mpSwap;
 286             mpSwap = NULL;
 287         }
 288         else
 289         {
 290             if( !( --mpBuf->mnRefCount ) )
 291                 delete mpBuf;
 292
 293             mpBuf = NULL;
 294         }
 295     }
 296 }
 297
 298 // ------------------------------------------------------------------------
 299
 300 void GfxLink::SwapIn()
 301 {
 302     if( IsSwappedOut() )
 303     {
 304         mpBuf = new ImpBuffer( mpSwap->GetData() );
 305
 306         if( !( --mpSwap->mnRefCount ) )
 307             delete mpSwap;
 308
 309         mpSwap = NULL;
 310     }
 311 }
 312
 313 // ------------------------------------------------------------------------
 314
 315 BOOL GfxLink::ExportNative( SvStream& rOStream ) const
 316 {
 317     if( GetDataSize() )
 318     {
 319         if( IsSwappedOut() )
 320             mpSwap->WriteTo( rOStream );
 321         else if( GetData() )
 322             rOStream.Write( GetData(), GetDataSize() );
 323     }
 324
 325     return ( rOStream.GetError() == ERRCODE_NONE );
 326 }
 327
 328 // ------------------------------------------------------------------------
 329
 330 SvStream& operator<<( SvStream& rOStream, const GfxLink& rGfxLink )
 331 {
 332     VersionCompat* pCompat = new VersionCompat( rOStream, STREAM_WRITE, 2 );
 333
 334     // Version 1
 335     rOStream << (UINT16) rGfxLink.GetType() << rGfxLink.GetDataSize() << rGfxLink.GetUserId();
 336
 337     // Version 2
 338     rOStream << rGfxLink.GetPrefSize() << rGfxLink.GetPrefMapMode();
 339
 340     delete pCompat;
 341
 342     if( rGfxLink.GetDataSize() )
 343     {
 344         if( rGfxLink.IsSwappedOut() )
 345             rGfxLink.mpSwap->WriteTo( rOStream );
 346         else if( rGfxLink.GetData() )
 347             rOStream.Write( rGfxLink.GetData(), rGfxLink.GetDataSize() );
 348     }
 349
 350     return rOStream;
 351 }
 352
 353 // ------------------------------------------------------------------------
 354
 355 SvStream& operator>>( SvStream& rIStream, GfxLink& rGfxLink)
 356 {
 357     Size            aSize;
 358     MapMode         aMapMode;
 359     sal_uInt32          nSize;
 360     sal_uInt32          nUserId;
 361     UINT16                      nType;
 362     BYTE*                       pBuf;
 363     bool                        bMapAndSizeValid( false );
 364     VersionCompat*      pCompat = new VersionCompat( rIStream, STREAM_READ );
 365
 366     // Version 1
 367     rIStream >> nType >> nSize >> nUserId;
 368
 369     if( pCompat->GetVersion() >= 2 )
 370     {
 371         rIStream >> aSize >> aMapMode;
 372         bMapAndSizeValid = true;
 373     }
 374
 375     delete pCompat;
 376
 377     pBuf = new BYTE[ nSize ];
 378     rIStream.Read( pBuf, nSize );
 379
 380     rGfxLink = GfxLink( pBuf, nSize, (GfxLinkType) nType, TRUE );
 381     rGfxLink.SetUserId( nUserId );
 382
 383     if( bMapAndSizeValid )
 384     {
 385         rGfxLink.SetPrefSize( aSize );
 386         rGfxLink.SetPrefMapMode( aMapMode );
 387     }
 388
 389     return rIStream;
 390 }
 391
 392 // -----------
 393 // - ImpSwap -
 394 // -----------
 395
 396 ImpSwap::ImpSwap( BYTE* pData, ULONG nDataSize ) :
 397             mnDataSize( nDataSize ),
 398             mnRefCount( 1UL )
 399 {
 400     if( pData && mnDataSize )
 401     {
 402         ::utl::TempFile aTempFile;
 403
 404         maURL = INetURLObject(aTempFile.GetURL());
 405
 406         if( maURL.GetMainURL( INetURLObject::NO_DECODE ).getLength() )
 407         {
 408             SvStream* pOStm = ::utl::UcbStreamHelper::CreateStream( maURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READWRITE | STREAM_SHARE_DENYWRITE );
 409
 410             if( pOStm )
 411             {
 412                 pOStm->Write( pData, mnDataSize );
 413                 sal_Bool bError = ( ERRCODE_NONE != pOStm->GetError() );
 414                 delete pOStm;
 415
 416                 if( bError )
 417                 {
 418                     try
 419                     {
 420                         ::ucbhelper::Content aCnt( maURL.GetMainURL( INetURLObject::NO_DECODE ),
 421                                              ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() );
 422
 423                         aCnt.executeCommand( ::rtl::OUString::createFromAscii( "delete" ),
 424                                              ::com::sun::star::uno::makeAny( sal_Bool( sal_True ) ) );
 425                     }
 426                     catch( const ::com::sun::star::ucb::ContentCreationException& )
 427                     {
 428                     }
 429                     catch( const ::com::sun::star::uno::RuntimeException& )
 430                     {
 431                     }
 432                     catch( const ::com::sun::star::ucb::CommandAbortedException& )
 433                     {
 434                     }
 435                     catch( const ::com::sun::star::uno::Exception& )
 436                     {
 437                     }
 438
 439                     maURL = INetURLObject();
 440                 }
 441             }
 442         }
 443     }
 444 }
 445
 446 // ------------------------------------------------------------------------
 447
 448 ImpSwap::~ImpSwap()
 449 {
 450     if( IsSwapped() )
 451     {
 452         try
 453         {
 454             ::ucbhelper::Content aCnt( maURL.GetMainURL( INetURLObject::NO_DECODE ),
 455                                  ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >() );
 456
 457             aCnt.executeCommand( ::rtl::OUString::createFromAscii( "delete" ),
 458                                  ::com::sun::star::uno::makeAny( sal_Bool( sal_True ) ) );
 459         }
 460         catch( const ::com::sun::star::ucb::ContentCreationException& )
 461         {
 462         }
 463         catch( const ::com::sun::star::uno::RuntimeException& )
 464         {
 465         }
 466         catch( const ::com::sun::star::ucb::CommandAbortedException& )
 467         {
 468         }
 469         catch( const ::com::sun::star::uno::Exception& )
 470         {
 471         }
 472     }
 473 }
 474
 475 // ------------------------------------------------------------------------
 476
 477 BYTE* ImpSwap::GetData() const
 478 {
 479     BYTE* pData;
 480
 481     if( IsSwapped() )
 482     {
 483         SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( maURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READWRITE );
 484
 485         if( pIStm )
 486         {
 487             pData = new BYTE[ mnDataSize ];
 488             pIStm->Read( pData, mnDataSize );
 489             sal_Bool bError = ( ERRCODE_NONE != pIStm->GetError() );
 490             delete pIStm;
 491
 492             if( bError )
 493                 delete[] pData, pData = NULL;
 494         }
 495         else
 496             pData = NULL;
 497     }
 498     else
 499         pData = NULL;
 500
 501     return pData;
 502 }
 503
 504 // ------------------------------------------------------------------------
 505
 506 void ImpSwap::WriteTo( SvStream& rOStm ) const
 507 {
 508     BYTE* pData = GetData();
 509
 510     if( pData )
 511     {
 512         rOStm.Write( pData, mnDataSize );
 513         delete[] pData;
 514     }
 515 }