sfx2/source/doc/graphhelp.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: graphhelp.cxx,v $
  10  * $Revision: 1.12 $
  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_sfx2.hxx"
  33
  34 #ifdef WNT
  35
  36 #undef WB_LEFT
  37 #undef WB_RIGHT
  38
  39 #define UINT64 USE_WIN_UINT64
  40 #define INT64 USE_WIN_INT64
  41 #define UINT32 USE_WIN_UINT32
  42 #define INT32 USE_WIN_INT32
  43
  44 #include <tools/presys.h>
  45 #if defined _MSC_VER
  46 #pragma warning(push, 1)
  47 #endif
  48 #include <windows.h>
  49 #if defined _MSC_VER
  50 #pragma warning(pop)
  51 #endif
  52 #include <tools/postsys.h>
  53
  54 #undef UINT64
  55 #undef INT64
  56 #undef UINT32
  57 #undef INT32
  58
  59 #endif
  60 #include <com/sun/star/uno/Exception.hpp>
  61 #include <com/sun/star/datatransfer/XTransferable.hpp>
  62 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  63 #include <com/sun/star/graphic/XGraphicProvider.hpp>
  64 #include <com/sun/star/graphic/XGraphic.hpp>
  65 #include <com/sun/star/io/XStream.hpp>
  66
  67
  68 #include <osl/thread.h>
  69 #include <vcl/gdimtf.hxx>
  70 #include <vcl/graph.hxx>
  71 #include <vcl/cvtgrf.hxx>
  72 #include <vcl/outdev.hxx>
  73 #include <vcl/virdev.hxx>
  74 #include <vcl/bitmapex.hxx>
  75 #include <vcl/salbtype.hxx>
  76
  77 #include <tools/stream.hxx>
  78 #include <unotools/tempfile.hxx>
  79 #include <unotools/ucbstreamhelper.hxx>
  80 #include <unotools/streamwrap.hxx>
  81 #include <comphelper/processfactory.hxx>
  82
  83
  84 #include "sfxresid.hxx"
  85 #include "graphhelp.hxx"
  86 #include "doc.hrc"
  87
  88 using namespace ::com::sun::star;
  89
  90 #define THUMBNAIL_RESOLUTION 256
  91
  92 //---------------------------------------------------------------
  93 // static
  94 SvMemoryStream* GraphicHelper::getFormatStrFromGDI_Impl( const GDIMetaFile* pGDIMeta, sal_uInt32 nFormat )
  95 {
  96     SvMemoryStream* pResult = NULL;
  97     if ( pGDIMeta )
  98     {
  99         SvMemoryStream* pStream = new SvMemoryStream( 65535, 65535 );
 100         if ( pStream )
 101         {
 102             Graphic aGraph( *pGDIMeta );
 103             if ( GraphicConverter::Export( *pStream, aGraph, nFormat ) == 0 )
 104                 pResult = pStream;
 105             else
 106                 delete pStream;
 107         }
 108     }
 109
 110     return pResult;
 111 }
 112
 113 //---------------------------------------------------------------
 114 // static
 115 void* GraphicHelper::getEnhMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta )
 116 {
 117     (void)pGDIMeta;  // unused
 118     void* pResult = NULL;
 119
 120 #ifdef WNT
 121     if ( pGDIMeta )
 122     {
 123         String aStr = ::rtl::OUString::createFromAscii( ".emf" );
 124         ::utl::TempFile aTempFile( ::rtl::OUString(),
 125                                    &aStr,
 126                                    NULL,
 127                                    sal_False );
 128
 129         ::rtl::OUString aMetaFile = aTempFile.GetFileName();
 130         ::rtl::OUString aMetaURL = aTempFile.GetURL();
 131         ::rtl::OString aWinFile = ::rtl::OUStringToOString( aMetaFile, osl_getThreadTextEncoding() );
 132
 133         SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aMetaURL, STREAM_STD_READWRITE );
 134         if ( pStream )
 135         {
 136             Graphic aGraph( *pGDIMeta );
 137             sal_Bool bFailed = (sal_Bool)GraphicConverter::Export( *pStream, aGraph, CVT_EMF );
 138             pStream->Flush();
 139             delete pStream;
 140
 141             if ( !bFailed )
 142                 pResult = GetEnhMetaFileA( aWinFile.getStr() );
 143         }
 144     }
 145 #endif
 146
 147     return pResult;
 148 }
 149
 150 //---------------------------------------------------------------
 151 // static
 152 void* GraphicHelper::getWinMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta, const Size& aMetaSize )
 153 {
 154     (void)pGDIMeta;  // unused
 155     (void)aMetaSize; // unused
 156     void* pResult = NULL;
 157
 158 #ifdef WNT
 159     if ( pGDIMeta )
 160     {
 161         SvMemoryStream* pStream = new SvMemoryStream( 65535, 65535 );
 162         if ( pStream )
 163         {
 164             Graphic aGraph( *pGDIMeta );
 165             sal_Bool bFailed = (sal_Bool)GraphicConverter::Export( *pStream, aGraph, CVT_WMF );
 166             pStream->Flush();
 167             if ( !bFailed )
 168             {
 169                 sal_Int32 nLength = pStream->Seek( STREAM_SEEK_TO_END );
 170                 if ( nLength > 22 )
 171                 {
 172                     HMETAFILE hMeta = SetMetaFileBitsEx( nLength - 22,
 173                                     ( reinterpret_cast< const sal_uChar*>( pStream->GetData() ) ) + 22 );
 174
 175                     if ( hMeta )
 176                     {
 177                         HGLOBAL hMemory = GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, sizeof( METAFILEPICT ) );
 178
 179                         if ( hMemory )
 180                         {
 181                                METAFILEPICT* pMF = (METAFILEPICT*)GlobalLock( hMemory );
 182
 183                                pMF->hMF = hMeta;
 184                                pMF->mm = MM_ANISOTROPIC;
 185
 186                             MapMode aMetaMode = pGDIMeta->GetPrefMapMode();
 187                             MapMode aWinMode( MAP_100TH_MM );
 188
 189                             if ( aWinMode == pGDIMeta->GetPrefMapMode() )
 190                             {
 191                                 pMF->xExt = aMetaSize.Width();
 192                                 pMF->yExt = aMetaSize.Height();
 193                             }
 194                             else
 195                             {
 196                                 Size aWinSize = OutputDevice::LogicToLogic( Size( aMetaSize.Width(), aMetaSize.Height() ),
 197                                                                             pGDIMeta->GetPrefMapMode(),
 198                                                                             aWinMode );
 199                                 pMF->xExt = aWinSize.Width();
 200                                 pMF->yExt = aWinSize.Height();
 201                             }
 202
 203                             GlobalUnlock( hMemory );
 204                             pResult = (void*)hMemory;
 205                         }
 206                         else
 207                                DeleteMetaFile( hMeta );
 208                     }
 209                 }
 210             }
 211
 212             delete pStream;
 213         }
 214     }
 215
 216 #endif
 217
 218
 219     return pResult;
 220 }
 221
 222 //---------------------------------------------------------------
 223 // static
 224 sal_Bool GraphicHelper::supportsMetaFileHandle_Impl()
 225 {
 226 #ifdef WNT
 227     return sal_True;
 228 #else
 229     return sal_False;
 230 #endif
 231 }
 232
 233 //---------------------------------------------------------------
 234 // static
 235 sal_Bool GraphicHelper::mergeBitmaps_Impl( const BitmapEx& rBmpEx, const BitmapEx& rOverlay,
 236                    const Rectangle& rOverlayRect, BitmapEx& rReturn )
 237 {
 238     // the implementation is provided by KA
 239
 240     Point                       aNullPt;
 241     Rectangle           aBmpRect( aNullPt, rBmpEx.GetSizePixel() );
 242     VirtualDevice       aVDev;
 243
 244     if( !rReturn.IsEmpty() )
 245         rReturn.SetEmpty();
 246
 247     if( !rBmpEx.IsEmpty() && aVDev.SetOutputSizePixel( aBmpRect.GetSize() ) )
 248     {
 249         Rectangle aOverlayRect( rOverlayRect );
 250
 251         aOverlayRect.Intersection( aBmpRect );
 252
 253         if( rOverlay.IsEmpty() || rOverlayRect.IsEmpty() )
 254             rReturn = rBmpEx;
 255         else
 256         {
 257             aVDev.DrawBitmap( aNullPt, aVDev.GetOutputSizePixel(), rBmpEx.GetBitmap() );
 258             aVDev.DrawBitmapEx( aOverlayRect.TopLeft(), aOverlayRect.GetSize(), rOverlay );
 259
 260             Bitmap aBmp( aVDev.GetBitmap( aNullPt, aVDev.GetOutputSizePixel() ) );
 261             aBmp.Convert( BMP_CONVERSION_24BIT );
 262
 263             if( !rBmpEx.IsTransparent() )
 264                 rReturn = aBmp;
 265             else
 266             {
 267                 aVDev.DrawBitmap( aNullPt, aVDev.GetOutputSizePixel(), rBmpEx.GetMask() );
 268                 Bitmap aOverlayMergeBmp( aVDev.GetBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize() ) );
 269
 270                 if( rOverlay.IsTransparent() )
 271                     aVDev.DrawBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize(), rOverlay.GetMask() );
 272                 else
 273                 {
 274                     aVDev.SetLineColor( COL_BLACK );
 275                     aVDev.SetFillColor( COL_BLACK );
 276                     aVDev.DrawRect( aOverlayRect);
 277                 }
 278
 279                 aOverlayMergeBmp.CombineSimple( aVDev.GetBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize() ), BMP_COMBINE_AND );
 280                 aVDev.DrawBitmap( aOverlayRect.TopLeft(), aOverlayRect.GetSize(), aOverlayMergeBmp );
 281                 rReturn = BitmapEx( aBmp, aVDev.GetBitmap( aNullPt, aVDev.GetOutputSizePixel() ) );
 282             }
 283         }
 284     }
 285
 286     return !rReturn.IsEmpty();
 287 }
 288
 289
 290 //---------------------------------------------------------------
 291 // static
 292 sal_Bool GraphicHelper::createThumb_Impl( const GDIMetaFile& rMtf,
 293                        sal_uInt32 nMaximumExtent,
 294                        BitmapEx& rBmpEx,
 295                        const BitmapEx* pOverlay,
 296                        const Rectangle* pOverlayRect )
 297 {
 298     // the implementation is provided by KA
 299
 300     // initialization seems to be complicated but is used to avoid rounding errors
 301     VirtualDevice       aVDev;
 302     const Point     aNullPt;
 303     const Point     aTLPix( aVDev.LogicToPixel( aNullPt, rMtf.GetPrefMapMode() ) );
 304     const Point     aBRPix( aVDev.LogicToPixel( Point( rMtf.GetPrefSize().Width() - 1, rMtf.GetPrefSize().Height() - 1 ), rMtf.GetPrefMapMode() ) );
 305     Size            aDrawSize( aVDev.LogicToPixel( rMtf.GetPrefSize(), rMtf.GetPrefMapMode() ) );
 306     Size                        aSizePix( labs( aBRPix.X() - aTLPix.X() ) + 1, labs( aBRPix.Y() - aTLPix.Y() ) + 1 );
 307     Point                       aPosPix;
 308
 309     if ( !rBmpEx.IsEmpty() )
 310         rBmpEx.SetEmpty();
 311
 312     // determine size that has the same aspect ratio as image size and
 313     // fits into the rectangle determined by nMaximumExtent
 314     if ( aSizePix.Width() && aSizePix.Height() &&
 315             ( sal::static_int_cast<sal_uInt32>(aSizePix.Width()) > nMaximumExtent ||
 316               sal::static_int_cast<sal_uInt32>(aSizePix.Height()) > nMaximumExtent ) )
 317     {
 318         const Size  aOldSizePix( aSizePix );
 319         double      fWH = static_cast< double >( aSizePix.Width() ) / aSizePix.Height();
 320
 321         if ( fWH <= 1.0 )
 322         {
 323             aSizePix.Width() = FRound( nMaximumExtent * fWH );
 324             aSizePix.Height() = nMaximumExtent;
 325         }
 326         else
 327         {
 328             aSizePix.Width() = nMaximumExtent;
 329             aSizePix.Height() = FRound(  nMaximumExtent / fWH );
 330         }
 331
 332         aDrawSize.Width() = FRound( ( static_cast< double >( aDrawSize.Width() ) * aSizePix.Width() ) / aOldSizePix.Width() );
 333         aDrawSize.Height() = FRound( ( static_cast< double >( aDrawSize.Height() ) * aSizePix.Height() ) / aOldSizePix.Height() );
 334     }
 335
 336     Size                aFullSize;
 337     Point               aBackPosPix;
 338     Rectangle   aOverlayRect;
 339
 340     // calculate addigtional positions and sizes if an overlay image is used
 341     if (  pOverlay )
 342     {
 343         aFullSize = Size( nMaximumExtent, nMaximumExtent );
 344         aOverlayRect = Rectangle( aNullPt, aFullSize  );
 345
 346         aOverlayRect.Intersection( pOverlayRect ? *pOverlayRect : Rectangle( aNullPt, pOverlay->GetSizePixel() ) );
 347
 348         if ( !aOverlayRect.IsEmpty() )
 349             aBackPosPix = Point( ( nMaximumExtent - aSizePix.Width() ) >> 1, ( nMaximumExtent - aSizePix.Height() ) >> 1 );
 350         else
 351             pOverlay = NULL;
 352     }
 353     else
 354     {
 355         aFullSize = aSizePix;
 356         pOverlay = NULL;
 357     }
 358
 359     // draw image(s) into VDev and get resulting image
 360     if ( aVDev.SetOutputSizePixel( aFullSize ) )
 361     {
 362         // draw metafile into VDev
 363         const_cast< GDIMetaFile& >( rMtf ).WindStart();
 364         const_cast< GDIMetaFile& >( rMtf ).Play( &aVDev, aBackPosPix, aDrawSize );
 365
 366         // draw overlay if neccessary
 367         if ( pOverlay )
 368             aVDev.DrawBitmapEx( aOverlayRect.TopLeft(), aOverlayRect.GetSize(), *pOverlay );
 369
 370         // get paint bitmap
 371         Bitmap aBmp( aVDev.GetBitmap( aNullPt, aVDev.GetOutputSizePixel() ) );
 372
 373         // assure that we have a true color image
 374         if ( aBmp.GetBitCount() != 24 )
 375             aBmp.Convert( BMP_CONVERSION_24BIT );
 376
 377         rBmpEx = BitmapEx( aBmp );
 378     }
 379
 380     return !rBmpEx.IsEmpty();
 381 }
 382
 383 //---------------------------------------------------------------
 384 // static
 385 sal_Bool GraphicHelper::getThumbnailFormatFromGDI_Impl( GDIMetaFile* pMetaFile,
 386                                                         sal_Bool bSigned,
 387                                                         const uno::Reference< io::XStream >& xStream )
 388 {
 389     sal_Bool bResult = sal_False;
 390     SvStream* pStream = NULL;
 391
 392     if ( xStream.is() )
 393         pStream = ::utl::UcbStreamHelper::CreateStream( xStream );
 394
 395     if ( pMetaFile && pStream && !pStream->GetError() )
 396     {
 397         BitmapEx aResultBitmap;
 398         BitmapEx* pSignatureBitmap = NULL;
 399
 400         if ( bSigned )
 401             pSignatureBitmap = new BitmapEx( SfxResId( BMP_SIGNATURE ) );
 402
 403         bResult = createThumb_Impl( *pMetaFile,
 404                                        THUMBNAIL_RESOLUTION,
 405                                        aResultBitmap,
 406                                     pSignatureBitmap );
 407         if ( bResult )
 408             bResult = ( !aResultBitmap.IsEmpty()
 409                         && GraphicConverter::Export( *pStream, aResultBitmap, CVT_PNG ) == 0
 410                         && ( pStream->Flush(), !pStream->GetError() ) );
 411
 412         if ( pSignatureBitmap )
 413             delete pSignatureBitmap;
 414
 415         delete pStream;
 416     }
 417
 418     return bResult;
 419 }
 420
 421 //---------------------------------------------------------------
 422 // static
 423 sal_Bool GraphicHelper::getSignedThumbnailFormatFromBitmap_Impl( const BitmapEx& aBitmap,
 424                                                                  const uno::Reference< io::XStream >& xStream )
 425 {
 426     sal_Bool bResult = sal_False;
 427     SvStream* pStream = NULL;
 428
 429     if ( xStream.is() )
 430         pStream = ::utl::UcbStreamHelper::CreateStream( xStream );
 431
 432     if ( pStream && !pStream->GetError() )
 433     {
 434         BitmapEx aResultBitmap;
 435         BitmapEx aSignatureBitmap( SfxResId( BMP_SIGNATURE ) );
 436
 437         bResult = mergeBitmaps_Impl( aBitmap,
 438                                     aSignatureBitmap,
 439                                     Rectangle( Point(), aBitmap.GetSizePixel() ),
 440                                     aResultBitmap );
 441
 442         if ( bResult )
 443         {
 444             bResult = ( !aResultBitmap.IsEmpty()
 445                         && GraphicConverter::Export( *pStream, aResultBitmap, CVT_PNG ) == 0
 446                         && ( pStream->Flush(), !pStream->GetError() ) );
 447         }
 448
 449         delete pStream;
 450     }
 451
 452     return bResult;
 453 }
 454
 455 //---------------------------------------------------------------
 456 // static
 457 sal_Bool GraphicHelper::getThumbnailReplacement_Impl( sal_Int32 nResID, const uno::Reference< io::XStream >& xStream )
 458 {
 459     sal_Bool bResult = sal_False;
 460     if ( nResID && xStream.is() )
 461     {
 462         uno::Reference< lang::XMultiServiceFactory > xServiceManager = ::comphelper::getProcessServiceFactory();
 463         if ( xServiceManager.is() )
 464         {
 465             try
 466             {
 467                 uno::Reference< graphic::XGraphicProvider > xGraphProvider(
 468                     xServiceManager->createInstance(
 469                         ::rtl::OUString::createFromAscii( "com.sun.star.graphic.GraphicProvider" ) ),
 470                     uno::UNO_QUERY );
 471                 if ( xGraphProvider.is() )
 472                 {
 473                     ::rtl::OUString aURL = ::rtl::OUString::createFromAscii( "private:resource/sfx/bitmapex/" );
 474                     aURL += ::rtl::OUString::valueOf( nResID );
 475
 476                     uno::Sequence< beans::PropertyValue > aMediaProps( 1 );
 477                     aMediaProps[0].Name = ::rtl::OUString::createFromAscii( "URL" );
 478                     aMediaProps[0].Value <<= aURL;
 479
 480                     uno::Reference< graphic::XGraphic > xGraphic = xGraphProvider->queryGraphic( aMediaProps );
 481                     if ( xGraphic.is() )
 482                     {
 483                         uno::Sequence< beans::PropertyValue > aStoreProps( 2 );
 484                         aStoreProps[0].Name = ::rtl::OUString::createFromAscii( "OutputStream" );
 485                         aStoreProps[0].Value <<= xStream;
 486                         aStoreProps[1].Name = ::rtl::OUString::createFromAscii( "MimeType" );
 487                         aStoreProps[1].Value <<= ::rtl::OUString::createFromAscii( "image/png" );
 488
 489                         xGraphProvider->storeGraphic( xGraphic, aStoreProps );
 490                         bResult = sal_True;
 491                     }
 492                 }
 493             }
 494             catch( uno::Exception& )
 495             {
 496             }
 497         }
 498     }
 499
 500     return bResult;
 501 }
 502
 503 //---------------------------------------------------------------
 504 // static
 505 sal_uInt16 GraphicHelper::getThumbnailReplacementIDByFactoryName_Impl( const ::rtl::OUString& aFactoryShortName, sal_Bool /*bIsTemplate*/ )
 506 {
 507     sal_uInt16 nResult = 0;
 508
 509     if ( aFactoryShortName.equalsAscii( "scalc" ) )
 510     {
 511         nResult = BMP_128X128_CALC_DOC;
 512     }
 513     else if ( aFactoryShortName.equalsAscii( "sdraw" ) )
 514     {
 515         nResult = BMP_128X128_DRAW_DOC;
 516     }
 517     else if ( aFactoryShortName.equalsAscii( "simpress" ) )
 518     {
 519         nResult = BMP_128X128_IMPRESS_DOC;
 520     }
 521     else if ( aFactoryShortName.equalsAscii( "smath" ) )
 522     {
 523         nResult = BMP_128X128_MATH_DOC;
 524     }
 525     else if ( aFactoryShortName.equalsAscii( "swriter" ) || aFactoryShortName.compareToAscii( "swriter/", 8 ) == 0 )
 526     {
 527         nResult = BMP_128X128_WRITER_DOC;
 528     }
 529
 530     return nResult;
 531 }
 532