vcl/source/gdi/gfxlink.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 <osl/file.h>
  21 #include <tools/vcompat.hxx>
  22 #include <tools/debug.hxx>
  23 #include <unotools/ucbstreamhelper.hxx>
  24 #include <unotools/tempfile.hxx>
  25 #include <ucbhelper/content.hxx>
  26 #include <vcl/graph.hxx>
  27 #include <vcl/gfxlink.hxx>
  28 #include <vcl/cvtgrf.hxx>
  29 #include <com/sun/star/ucb/CommandAbortedException.hpp>
  30 #include <memory>
  31
  32 GfxLink::GfxLink() :
  33     meType      ( GFX_LINK_TYPE_NONE ),
  34     mpBuf       ( NULL ),
  35     mpSwap      ( NULL ),
  36     mnBufSize   ( 0 ),
  37     mnUserId    ( 0UL ),
  38     mpImpData   ( new ImpGfxLink )
  39 {
  40 }
  41
  42 GfxLink::GfxLink( const GfxLink& rGfxLink ) :
  43     mpImpData( new ImpGfxLink )
  44 {
  45     ImplCopy( rGfxLink );
  46 }
  47
  48 GfxLink::GfxLink( sal_uInt8* pBuf, sal_uInt32 nSize, GfxLinkType nType, bool bOwns ) :
  49     mpImpData( new ImpGfxLink )
  50 {
  51     DBG_ASSERT( (pBuf != NULL && nSize) || (!bOwns && nSize == 0),
  52                 "GfxLink::GfxLink(): empty/NULL buffer given" );
  53
  54     meType = nType;
  55     mnBufSize = nSize;
  56     mpSwap = NULL;
  57     mnUserId = 0UL;
  58
  59     if( bOwns )
  60         mpBuf = new ImpBuffer( pBuf );
  61     else if( nSize )
  62     {
  63         mpBuf = new ImpBuffer( nSize );
  64         memcpy( mpBuf->mpBuffer, pBuf, nSize );
  65     }
  66     else
  67         mpBuf = NULL;
  68 }
  69
  70 GfxLink::~GfxLink()
  71 {
  72     if( mpBuf && !( --mpBuf->mnRefCount ) )
  73         delete mpBuf;
  74
  75     if( mpSwap && !( --mpSwap->mnRefCount ) )
  76         delete mpSwap;
  77
  78     delete mpImpData;
  79 }
  80
  81 GfxLink& GfxLink::operator=( const GfxLink& rGfxLink )
  82 {
  83     if( &rGfxLink != this )
  84     {
  85         if ( mpBuf && !( --mpBuf->mnRefCount ) )
  86             delete mpBuf;
  87
  88         if( mpSwap && !( --mpSwap->mnRefCount ) )
  89             delete mpSwap;
  90
  91         ImplCopy( rGfxLink );
  92     }
  93
  94     return *this;
  95 }
  96
  97 bool GfxLink::IsEqual( const GfxLink& rGfxLink ) const
  98 {
  99     bool bIsEqual = false;
 100
 101     if ( ( mnBufSize == rGfxLink.mnBufSize ) && ( meType == rGfxLink.meType ) )
 102     {
 103         const sal_uInt8* pSource = GetData();
 104         const sal_uInt8* pDest = rGfxLink.GetData();
 105         sal_uInt32 nSourceSize = GetDataSize();
 106         sal_uInt32 nDestSize = rGfxLink.GetDataSize();
 107         if ( pSource && pDest && ( nSourceSize == nDestSize ) )
 108         {
 109             bIsEqual = memcmp( pSource, pDest, nSourceSize ) == 0;
 110         }
 111         else if ( ( pSource == 0 ) && ( pDest == 0 ) )
 112             bIsEqual = true;
 113     }
 114     return bIsEqual;
 115 }
 116
 117 void GfxLink::ImplCopy( const GfxLink& rGfxLink )
 118 {
 119     mnBufSize = rGfxLink.mnBufSize;
 120     meType = rGfxLink.meType;
 121     mpBuf = rGfxLink.mpBuf;
 122     mpSwap = rGfxLink.mpSwap;
 123     mnUserId = rGfxLink.mnUserId;
 124     *mpImpData = *rGfxLink.mpImpData;
 125
 126     if( mpBuf )
 127         mpBuf->mnRefCount++;
 128
 129     if( mpSwap )
 130         mpSwap->mnRefCount++;
 131 }
 132
 133
 134 bool GfxLink::IsNative() const
 135 {
 136     return( meType >= GFX_LINK_FIRST_NATIVE_ID && meType <= GFX_LINK_LAST_NATIVE_ID );
 137 }
 138
 139
 140 const sal_uInt8* GfxLink::GetData() const
 141 {
 142     if( IsSwappedOut() )
 143         const_cast<GfxLink*>(this)->SwapIn();
 144
 145     return( mpBuf ? mpBuf->mpBuffer : NULL );
 146 }
 147
 148
 149 void GfxLink::SetPrefSize( const Size& rPrefSize )
 150 {
 151     mpImpData->maPrefSize = rPrefSize;
 152     mpImpData->mbPrefSizeValid = true;
 153 }
 154
 155
 156
 157 void GfxLink::SetPrefMapMode( const MapMode& rPrefMapMode )
 158 {
 159     mpImpData->maPrefMapMode = rPrefMapMode;
 160     mpImpData->mbPrefMapModeValid = true;
 161 }
 162
 163
 164 bool GfxLink::LoadNative( Graphic& rGraphic )
 165 {
 166     bool bRet = false;
 167
 168     if( IsNative() && mnBufSize )
 169     {
 170         const sal_uInt8* pData = GetData();
 171
 172         if( pData )
 173         {
 174             SvMemoryStream  aMemStm;
 175             sal_uLong           nCvtType;
 176
 177             aMemStm.SetBuffer( const_cast<sal_uInt8*>(pData), mnBufSize, false, mnBufSize );
 178
 179             switch( meType )
 180             {
 181                 case( GFX_LINK_TYPE_NATIVE_GIF ): nCvtType = CVT_GIF; break;
 182
 183                 // #i15508# added BMP type for better exports (reload when swapped - checked, works)
 184                 case( GFX_LINK_TYPE_NATIVE_BMP ): nCvtType = CVT_BMP; break;
 185
 186                 case( GFX_LINK_TYPE_NATIVE_JPG ): nCvtType = CVT_JPG; break;
 187                 case( GFX_LINK_TYPE_NATIVE_PNG ): nCvtType = CVT_PNG; break;
 188                 case( GFX_LINK_TYPE_NATIVE_TIF ): nCvtType = CVT_TIF; break;
 189                 case( GFX_LINK_TYPE_NATIVE_WMF ): nCvtType = CVT_WMF; break;
 190                 case( GFX_LINK_TYPE_NATIVE_MET ): nCvtType = CVT_MET; break;
 191                 case( GFX_LINK_TYPE_NATIVE_PCT ): nCvtType = CVT_PCT; break;
 192                 case( GFX_LINK_TYPE_NATIVE_SVG ): nCvtType = CVT_SVG; break;
 193
 194                 default: nCvtType = CVT_UNKNOWN; break;
 195             }
 196
 197             if( nCvtType && ( GraphicConverter::Import( aMemStm, rGraphic, nCvtType ) == ERRCODE_NONE ) )
 198                 bRet = true;
 199         }
 200     }
 201
 202     return bRet;
 203 }
 204
 205 void GfxLink::SwapOut()
 206 {
 207     if( !IsSwappedOut() && mpBuf )
 208     {
 209         mpSwap = new ImpSwap( mpBuf->mpBuffer, mnBufSize );
 210
 211         if( !mpSwap->IsSwapped() )
 212         {
 213             delete mpSwap;
 214             mpSwap = NULL;
 215         }
 216         else
 217         {
 218             if( !( --mpBuf->mnRefCount ) )
 219                 delete mpBuf;
 220
 221             mpBuf = NULL;
 222         }
 223     }
 224 }
 225
 226 void GfxLink::SwapIn()
 227 {
 228     if( IsSwappedOut() )
 229     {
 230         mpBuf = new ImpBuffer( mpSwap->GetData() );
 231
 232         if( !( --mpSwap->mnRefCount ) )
 233             delete mpSwap;
 234
 235         mpSwap = NULL;
 236     }
 237 }
 238
 239 bool GfxLink::ExportNative( SvStream& rOStream ) const
 240 {
 241     if( GetDataSize() )
 242     {
 243         if( IsSwappedOut() )
 244             mpSwap->WriteTo( rOStream );
 245         else if( GetData() )
 246             rOStream.Write( GetData(), GetDataSize() );
 247     }
 248
 249     return ( rOStream.GetError() == ERRCODE_NONE );
 250 }
 251
 252 SvStream& WriteGfxLink( SvStream& rOStream, const GfxLink& rGfxLink )
 253 {
 254     VersionCompat* pCompat = new VersionCompat( rOStream, StreamMode::WRITE, 2 );
 255
 256     // Version 1
 257     rOStream.WriteUInt16( rGfxLink.GetType() ).WriteUInt32( rGfxLink.GetDataSize() ).WriteUInt32( rGfxLink.GetUserId() );
 258
 259     // Version 2
 260     WritePair( rOStream, rGfxLink.GetPrefSize() );
 261     WriteMapMode( rOStream, rGfxLink.GetPrefMapMode() );
 262
 263     delete pCompat;
 264
 265     if( rGfxLink.GetDataSize() )
 266     {
 267         if( rGfxLink.IsSwappedOut() )
 268             rGfxLink.mpSwap->WriteTo( rOStream );
 269         else if( rGfxLink.GetData() )
 270             rOStream.Write( rGfxLink.GetData(), rGfxLink.GetDataSize() );
 271     }
 272
 273     return rOStream;
 274 }
 275
 276 SvStream& ReadGfxLink( SvStream& rIStream, GfxLink& rGfxLink)
 277 {
 278     Size            aSize;
 279     MapMode         aMapMode;
 280     sal_uInt32      nSize;
 281     sal_uInt32      nUserId;
 282     sal_uInt16          nType;
 283     sal_uInt8*          pBuf;
 284     bool            bMapAndSizeValid( false );
 285     VersionCompat*  pCompat = new VersionCompat( rIStream, StreamMode::READ );
 286
 287     // Version 1
 288     rIStream.ReadUInt16( nType ).ReadUInt32( nSize ).ReadUInt32( nUserId );
 289
 290     if( pCompat->GetVersion() >= 2 )
 291     {
 292         ReadPair( rIStream, aSize );
 293         ReadMapMode( rIStream, aMapMode );
 294         bMapAndSizeValid = true;
 295     }
 296
 297     delete pCompat;
 298
 299     pBuf = new sal_uInt8[ nSize ];
 300     rIStream.Read( pBuf, nSize );
 301
 302     rGfxLink = GfxLink( pBuf, nSize, (GfxLinkType) nType, true );
 303     rGfxLink.SetUserId( nUserId );
 304
 305     if( bMapAndSizeValid )
 306     {
 307         rGfxLink.SetPrefSize( aSize );
 308         rGfxLink.SetPrefMapMode( aMapMode );
 309     }
 310
 311     return rIStream;
 312 }
 313
 314 ImpSwap::ImpSwap( sal_uInt8* pData, sal_uLong nDataSize ) :
 315             mnDataSize( nDataSize ),
 316             mnRefCount( 1UL )
 317 {
 318     if( pData && mnDataSize )
 319     {
 320         ::utl::TempFile aTempFile;
 321
 322         maURL = aTempFile.GetURL();
 323         if( !maURL.isEmpty() )
 324         {
 325             std::unique_ptr<SvStream> xOStm(::utl::UcbStreamHelper::CreateStream( maURL, STREAM_READWRITE | StreamMode::SHARE_DENYWRITE ));
 326             if( xOStm )
 327             {
 328                 xOStm->Write( pData, mnDataSize );
 329                 bool bError = ( ERRCODE_NONE != xOStm->GetError() );
 330                 xOStm.reset();
 331
 332                 if( bError )
 333                 {
 334                     osl_removeFile( maURL.pData );
 335                     maURL.clear();
 336                 }
 337             }
 338         }
 339     }
 340 }
 341
 342 ImpSwap::~ImpSwap()
 343 {
 344     if( IsSwapped() )
 345         osl_removeFile( maURL.pData );
 346 }
 347
 348 sal_uInt8* ImpSwap::GetData() const
 349 {
 350     sal_uInt8* pData;
 351
 352     if( IsSwapped() )
 353     {
 354         std::unique_ptr<SvStream> xIStm(::utl::UcbStreamHelper::CreateStream( maURL, STREAM_READWRITE ));
 355         if( xIStm )
 356         {
 357             pData = new sal_uInt8[ mnDataSize ];
 358             xIStm->Read( pData, mnDataSize );
 359             bool bError = ( ERRCODE_NONE != xIStm->GetError() );
 360             sal_Size nActReadSize = xIStm->Tell();
 361             if (nActReadSize != mnDataSize)
 362             {
 363                 bError = true;
 364             }
 365             xIStm.reset();
 366
 367             if( bError )
 368                 delete[] pData, pData = NULL;
 369         }
 370         else
 371             pData = NULL;
 372     }
 373     else
 374         pData = NULL;
 375
 376     return pData;
 377 }
 378
 379 void ImpSwap::WriteTo( SvStream& rOStm ) const
 380 {
 381     sal_uInt8* pData = GetData();
 382
 383     if( pData )
 384     {
 385         rOStm.Write( pData, mnDataSize );
 386         delete[] pData;
 387     }
 388 }
 389
 390 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */