svtools/source/graphic/provider.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/mutex.hxx>
  21 #include <vcl/svapp.hxx>
  22 #include <vcl/image.hxx>
  23 #include <vcl/metaact.hxx>
  24 #include <vcl/msgbox.hxx>
  25 #include <vcl/imagerepository.hxx>
  26 #include <tools/rcid.h>
  27 #include <tools/resid.hxx>
  28 #include <tools/resmgr.hxx>
  29 #include <unotools/ucbstreamhelper.hxx>
  30 #include <vcl/graphicfilter.hxx>
  31 #include <vcl/wmf.hxx>
  32 #include <svl/solar.hrc>
  33 #include <vcl/virdev.hxx>
  34 #include <com/sun/star/io/XStream.hpp>
  35 #include <com/sun/star/text/GraphicCrop.hpp>
  36 #include <comphelper/servicehelper.hxx>
  37
  38 #include "descriptor.hxx"
  39 #include "graphic.hxx"
  40 #include <svtools/grfmgr.hxx>
  41 #include "provider.hxx"
  42 #include <vcl/dibtools.hxx>
  43
  44 using namespace com::sun::star;
  45
  46 namespace unographic {
  47
  48 #define UNO_NAME_GRAPHOBJ_URLPREFIX                             "vnd.sun.star.GraphicObject:"
  49
  50 // -------------------
  51 // - GraphicProvider -
  52 // -------------------
  53
  54 uno::Reference< uno::XInterface > SAL_CALL GraphicProvider_CreateInstance( const uno::Reference< lang::XMultiServiceFactory >& )
  55 {
  56     return (static_cast< ::cppu::OWeakObject* >(new GraphicProvider ));
  57 }
  58
  59 GraphicProvider::GraphicProvider()
  60 {
  61 }
  62
  63 // ------------------------------------------------------------------------------
  64
  65 GraphicProvider::~GraphicProvider()
  66 {
  67 }
  68
  69 // ------------------------------------------------------------------------------
  70
  71 OUString GraphicProvider::getImplementationName_Static()
  72     throw()
  73 {
  74     return OUString( "com.sun.star.comp.graphic.GraphicProvider" );
  75 }
  76
  77 // ------------------------------------------------------------------------------
  78
  79 uno::Sequence< OUString > GraphicProvider::getSupportedServiceNames_Static()
  80     throw()
  81 {
  82     uno::Sequence< OUString > aSeq( 1 );
  83
  84     aSeq.getArray()[ 0 ] = "com.sun.star.graphic.GraphicProvider";
  85
  86     return aSeq;
  87 }
  88
  89 // ------------------------------------------------------------------------------
  90
  91 OUString SAL_CALL GraphicProvider::getImplementationName()
  92     throw( uno::RuntimeException )
  93 {
  94     return getImplementationName_Static();
  95 }
  96
  97 // ------------------------------------------------------------------------------
  98
  99 sal_Bool SAL_CALL GraphicProvider::supportsService( const OUString& ServiceName )
 100     throw( uno::RuntimeException )
 101 {
 102     uno::Sequence< OUString >    aSNL( getSupportedServiceNames() );
 103     const OUString*              pArray = aSNL.getConstArray();
 104
 105     for( int i = 0; i < aSNL.getLength(); i++ )
 106         if( pArray[i] == ServiceName )
 107             return true;
 108
 109     return false;
 110 }
 111
 112 // ------------------------------------------------------------------------------
 113
 114 uno::Sequence< OUString > SAL_CALL GraphicProvider::getSupportedServiceNames()
 115     throw( uno::RuntimeException )
 116 {
 117     return getSupportedServiceNames_Static();
 118 }
 119
 120 // ------------------------------------------------------------------------------
 121
 122 uno::Sequence< uno::Type > SAL_CALL GraphicProvider::getTypes()
 123     throw(uno::RuntimeException)
 124 {
 125     uno::Sequence< uno::Type >  aTypes( 3 );
 126     uno::Type*                  pTypes = aTypes.getArray();
 127
 128     *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo>*)0);
 129     *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider>*)0);
 130     *pTypes++ = ::getCppuType((const uno::Reference< graphic::XGraphicProvider>*)0);
 131
 132     return aTypes;
 133 }
 134
 135 namespace
 136 {
 137     class theGraphicProviderUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theGraphicProviderUnoTunnelId > {};
 138 }
 139
 140 uno::Sequence< sal_Int8 > SAL_CALL GraphicProvider::getImplementationId()
 141     throw(uno::RuntimeException)
 142 {
 143     return theGraphicProviderUnoTunnelId::get().getSeq();
 144 }
 145
 146 // ------------------------------------------------------------------------------
 147
 148 uno::Reference< ::graphic::XGraphic > GraphicProvider::implLoadGraphicObject( const OUString& rResourceURL ) const
 149 {
 150     uno::Reference< ::graphic::XGraphic >   xRet;
 151     if( rResourceURL.startsWith( UNO_NAME_GRAPHOBJ_URLPREFIX ) )
 152     {
 153         // graphic manager url
 154         OUString aTmpStr( rResourceURL.copy( sizeof( UNO_NAME_GRAPHOBJ_URLPREFIX ) - 1 ) );
 155         OString aUniqueID(OUStringToOString(aTmpStr,
 156             RTL_TEXTENCODING_UTF8));
 157         GraphicObject aGrafObj(aUniqueID);
 158         // I don't call aGrafObj.GetXGraphic because it will call us back
 159         // into implLoadMemory ( with "private:memorygraphic" test )
 160         ::unographic::Graphic* pUnoGraphic = new ::unographic::Graphic;
 161         pUnoGraphic->init( aGrafObj.GetGraphic() );
 162         xRet = pUnoGraphic;
 163     }
 164     return xRet;
 165 }
 166
 167 uno::Reference< ::graphic::XGraphic > GraphicProvider::implLoadMemory( const OUString& rResourceURL ) const
 168 {
 169     uno::Reference< ::graphic::XGraphic >   xRet;
 170     sal_Int32                               nIndex = 0;
 171
 172     if( rResourceURL.getToken( 0, '/', nIndex ).equalsAscii( "private:memorygraphic" ) )
 173     {
 174         sal_Int64 nGraphicAddress = rResourceURL.getToken( 0, '/', nIndex ).toInt64();
 175
 176         if( nGraphicAddress )
 177         {
 178             ::unographic::Graphic* pUnoGraphic = new ::unographic::Graphic;
 179
 180             pUnoGraphic->init( *reinterpret_cast< ::Graphic* >( nGraphicAddress ) );
 181             xRet = pUnoGraphic;
 182         }
 183     }
 184
 185     return xRet;
 186 }
 187
 188 // ------------------------------------------------------------------------------
 189
 190 uno::Reference< ::graphic::XGraphic > GraphicProvider::implLoadRepositoryImage( const OUString& rResourceURL ) const
 191 {
 192     uno::Reference< ::graphic::XGraphic >   xRet;
 193     sal_Int32                               nIndex = 0;
 194
 195     if( rResourceURL.getToken( 0, '/', nIndex ).equalsAscii( "private:graphicrepository" ) )
 196     {
 197         OUString sPathName( rResourceURL.copy( nIndex ) );
 198         BitmapEx aBitmap;
 199         if ( ::vcl::ImageRepository::loadImage( sPathName, aBitmap, false ) )
 200         {
 201             Image aImage( aBitmap );
 202             xRet = aImage.GetXGraphic();
 203         }
 204     }
 205     return xRet;
 206 }
 207
 208
 209 // ------------------------------------------------------------------------------
 210
 211 uno::Reference< ::graphic::XGraphic > GraphicProvider::implLoadStandardImage( const OUString& rResourceURL ) const
 212 {
 213     uno::Reference< ::graphic::XGraphic >   xRet;
 214     sal_Int32                               nIndex = 0;
 215
 216     if( rResourceURL.getToken( 0, '/', nIndex ).equalsAscii( "private:standardimage" ) )
 217     {
 218         OUString sImageName( rResourceURL.copy( nIndex ) );
 219         if ( sImageName == "info" )
 220         {
 221             xRet = InfoBox::GetStandardImage().GetXGraphic();
 222         }
 223         else if ( sImageName == "warning" )
 224         {
 225             xRet = WarningBox::GetStandardImage().GetXGraphic();
 226         }
 227         else if ( sImageName == "error" )
 228         {
 229             xRet = ErrorBox::GetStandardImage().GetXGraphic();
 230         }
 231         else if ( sImageName == "query" )
 232         {
 233             xRet = QueryBox::GetStandardImage().GetXGraphic();
 234         }
 235     }
 236     return xRet;
 237 }
 238
 239 // ------------------------------------------------------------------------------
 240
 241 uno::Reference< ::graphic::XGraphic > GraphicProvider::implLoadBitmap( const uno::Reference< awt::XBitmap >& xBtm ) const
 242 {
 243     uno::Reference< ::graphic::XGraphic > xRet;
 244     uno::Sequence< sal_Int8 > aBmpSeq( xBtm->getDIB() );
 245     uno::Sequence< sal_Int8 > aMaskSeq( xBtm->getMaskDIB() );
 246     SvMemoryStream aBmpStream( aBmpSeq.getArray(), aBmpSeq.getLength(), STREAM_READ );
 247     Bitmap aBmp;
 248     BitmapEx aBmpEx;
 249
 250     ReadDIB(aBmp, aBmpStream, true);
 251
 252     if( aMaskSeq.getLength() )
 253     {
 254         SvMemoryStream aMaskStream( aMaskSeq.getArray(), aMaskSeq.getLength(), STREAM_READ );
 255         Bitmap aMask;
 256
 257         ReadDIB(aMask, aMaskStream, true);
 258         aBmpEx = BitmapEx( aBmp, aMask );
 259     }
 260     else
 261         aBmpEx = BitmapEx( aBmp );
 262
 263     if( !aBmpEx.IsEmpty() )
 264     {
 265         ::unographic::Graphic* pUnoGraphic = new ::unographic::Graphic;
 266
 267         pUnoGraphic->init( aBmpEx );
 268         xRet = pUnoGraphic;
 269     }
 270     return xRet;
 271 }
 272
 273 // ------------------------------------------------------------------------------
 274
 275 uno::Reference< ::graphic::XGraphic > GraphicProvider::implLoadResource( const OUString& rResourceURL ) const
 276 {
 277     uno::Reference< ::graphic::XGraphic >   xRet;
 278     sal_Int32                               nIndex = 0;
 279
 280     if( rResourceURL.getToken( 0, '/', nIndex ).equalsAscii( "private:resource" ) )
 281     {
 282         OString aResMgrName(OUStringToOString(
 283             rResourceURL.getToken(0, '/', nIndex), RTL_TEXTENCODING_ASCII_US));
 284
 285         ResMgr* pResMgr = ResMgr::CreateResMgr( aResMgrName.getStr(), Application::GetSettings().GetUILanguageTag() );
 286
 287         if( pResMgr )
 288         {
 289             const OUString   aResourceType( rResourceURL.getToken( 0, '/', nIndex ) );
 290             const ResId             aResId( rResourceURL.getToken( 0, '/', nIndex ).toInt32(), *pResMgr );
 291
 292             if( !aResourceType.isEmpty() )
 293             {
 294                 BitmapEx aBmpEx;
 295
 296                 if( aResourceType.equalsAscii( "bitmap" ) ||
 297                     aResourceType.equalsAscii( "bitmapex" ) )
 298                 {
 299                     aResId.SetRT( RSC_BITMAP );
 300
 301                     if( pResMgr->IsAvailable( aResId ) )
 302                     {
 303                         aBmpEx = BitmapEx( aResId );
 304                     }
 305                 }
 306                 else if( aResourceType.equalsAscii( "image" ) )
 307                 {
 308                     aResId.SetRT( RSC_IMAGE );
 309
 310                     if( pResMgr->IsAvailable( aResId ) )
 311                     {
 312                         const Image aImage( aResId );
 313                         aBmpEx = aImage.GetBitmapEx();
 314                     }
 315                 }
 316                 else if( aResourceType.equalsAscii( "imagelist" ) )
 317                 {
 318                     aResId.SetRT( RSC_IMAGELIST );
 319
 320                     if( pResMgr->IsAvailable( aResId ) )
 321                     {
 322                         const ImageList aImageList( aResId );
 323                         sal_Int32       nImageId = ( nIndex > -1 ) ? rResourceURL.getToken( 0, '/', nIndex ).toInt32() : 0;
 324
 325                         if( 0 < nImageId )
 326                         {
 327                             const Image aImage( aImageList.GetImage( sal::static_int_cast< sal_uInt16 >(nImageId) ) );
 328                             aBmpEx = aImage.GetBitmapEx();
 329                         }
 330                         else
 331                         {
 332                             aBmpEx = aImageList.GetAsHorizontalStrip();
 333                         }
 334                     }
 335                 }
 336
 337                 if( !aBmpEx.IsEmpty() )
 338                 {
 339                     ::unographic::Graphic* pUnoGraphic = new ::unographic::Graphic;
 340
 341                     pUnoGraphic->init( aBmpEx );
 342                     xRet = pUnoGraphic;
 343                 }
 344             }
 345
 346             delete pResMgr;
 347         }
 348     }
 349
 350     return xRet;
 351 }
 352
 353 // ------------------------------------------------------------------------------
 354
 355 uno::Reference< beans::XPropertySet > SAL_CALL GraphicProvider::queryGraphicDescriptor( const uno::Sequence< beans::PropertyValue >& rMediaProperties )
 356     throw ( io::IOException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 357 {
 358     uno::Reference< beans::XPropertySet > xRet;
 359
 360     OUString aURL;
 361     uno::Reference< io::XInputStream > xIStm;
 362     uno::Reference< awt::XBitmap >xBtm;
 363
 364     for( sal_Int32 i = 0; ( i < rMediaProperties.getLength() ) && !xRet.is(); ++i )
 365     {
 366         const OUString   aName( rMediaProperties[ i ].Name );
 367         const uno::Any          aValue( rMediaProperties[ i ].Value );
 368
 369         if (aName == "URL")
 370         {
 371             aValue >>= aURL;
 372         }
 373         else if (aName == "InputStream")
 374         {
 375             aValue >>= xIStm;
 376         }
 377         else if (aName == "Bitmap")
 378         {
 379             aValue >>= xBtm;
 380         }
 381     }
 382
 383     SolarMutexGuard g;
 384
 385     if( xIStm.is() )
 386     {
 387         GraphicDescriptor* pDescriptor = new GraphicDescriptor;
 388         pDescriptor->init( xIStm, aURL );
 389         xRet = pDescriptor;
 390     }
 391     else if( !aURL.isEmpty() )
 392     {
 393         uno::Reference< ::graphic::XGraphic > xGraphic( implLoadMemory( aURL ) );
 394         if( !xGraphic.is() )
 395             xGraphic = implLoadResource( aURL );
 396         if( !xGraphic.is() )
 397             xGraphic = implLoadGraphicObject( aURL );
 398
 399         if ( !xGraphic.is() )
 400             xGraphic = implLoadRepositoryImage( aURL );
 401
 402         if ( !xGraphic.is() )
 403             xGraphic = implLoadStandardImage( aURL );
 404
 405         if( xGraphic.is() )
 406         {
 407             xRet = uno::Reference< beans::XPropertySet >( xGraphic, uno::UNO_QUERY );
 408         }
 409         else
 410         {
 411             GraphicDescriptor* pDescriptor = new GraphicDescriptor;
 412             pDescriptor->init( aURL );
 413             xRet = pDescriptor;
 414         }
 415     }
 416     else if( xBtm.is() )
 417     {
 418         uno::Reference< ::graphic::XGraphic > xGraphic( implLoadBitmap( xBtm ) );
 419         if( xGraphic.is() )
 420             xRet = uno::Reference< beans::XPropertySet >( xGraphic, uno::UNO_QUERY );
 421     }
 422
 423     return xRet;
 424 }
 425
 426 // ------------------------------------------------------------------------------
 427
 428 uno::Reference< ::graphic::XGraphic > SAL_CALL GraphicProvider::queryGraphic( const uno::Sequence< ::beans::PropertyValue >& rMediaProperties )
 429     throw ( io::IOException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 430 {
 431     uno::Reference< ::graphic::XGraphic >   xRet;
 432     OUString                                aPath;
 433     SvStream*                               pIStm = NULL;
 434
 435     uno::Reference< io::XInputStream > xIStm;
 436     uno::Reference< awt::XBitmap >xBtm;
 437
 438     uno::Sequence< ::beans::PropertyValue > aFilterData;
 439
 440     for( sal_Int32 i = 0; ( i < rMediaProperties.getLength() ) && !pIStm && !xRet.is(); ++i )
 441     {
 442         const OUString   aName( rMediaProperties[ i ].Name );
 443         const uno::Any          aValue( rMediaProperties[ i ].Value );
 444
 445         if (aName == "URL")
 446         {
 447             OUString aURL;
 448             aValue >>= aURL;
 449             aPath = aURL;
 450         }
 451         else if (aName == "InputStream")
 452         {
 453             aValue >>= xIStm;
 454         }
 455         else if (aName == "Bitmap")
 456         {
 457             aValue >>= xBtm;
 458         }
 459         else if (aName == "FilterData")
 460         {
 461             aValue >>= aFilterData;
 462         }
 463     }
 464
 465     // Check for the goal width and height if they are defined
 466     sal_uInt16 nExtWidth = 0;
 467     sal_uInt16 nExtHeight = 0;
 468     sal_uInt16 nExtMapMode = 0;
 469     for( sal_Int32 i = 0; i < aFilterData.getLength(); ++i )
 470     {
 471         const OUString   aName( aFilterData[ i ].Name );
 472         const uno::Any          aValue( aFilterData[ i ].Value );
 473
 474         if (aName == "ExternalWidth")
 475         {
 476             aValue >>= nExtWidth;
 477         }
 478         else if (aName == "ExternalHeight")
 479         {
 480             aValue >>= nExtHeight;
 481         }
 482         else if (aName == "ExternalMapMode")
 483         {
 484             aValue >>= nExtMapMode;
 485         }
 486     }
 487
 488     SolarMutexGuard g;
 489
 490     if( xIStm.is() )
 491     {
 492         pIStm = ::utl::UcbStreamHelper::CreateStream( xIStm );
 493     }
 494     else if( !aPath.isEmpty() )
 495     {
 496         xRet = implLoadMemory( aPath );
 497
 498         if( !xRet.is() )
 499             xRet = implLoadGraphicObject( aPath );
 500
 501         if( !xRet.is() )
 502             xRet = implLoadResource( aPath );
 503
 504         if ( !xRet.is() )
 505             xRet = implLoadRepositoryImage( aPath );
 506
 507         if ( !xRet.is() )
 508             xRet = implLoadStandardImage( aPath );
 509
 510         if( !xRet.is() )
 511             pIStm = ::utl::UcbStreamHelper::CreateStream( aPath, STREAM_READ );
 512     }
 513     else if( xBtm.is() )
 514     {
 515         xRet = implLoadBitmap( xBtm );
 516     }
 517
 518     if( pIStm )
 519     {
 520         ::GraphicFilter& rFilter = ::GraphicFilter::GetGraphicFilter();
 521
 522         {
 523             ::Graphic aVCLGraphic;
 524
 525             // Define APM Header if goal height and width are defined
 526             WMF_EXTERNALHEADER aExtHeader;
 527             aExtHeader.xExt = nExtWidth;
 528             aExtHeader.yExt = nExtHeight;
 529             aExtHeader.mapMode = nExtMapMode;
 530             WMF_EXTERNALHEADER *pExtHeader = NULL;
 531             if ( nExtMapMode > 0 )
 532                 pExtHeader = &aExtHeader;
 533
 534             if( ( rFilter.ImportGraphic( aVCLGraphic, aPath, *pIStm,
 535                                          GRFILTER_FORMAT_DONTKNOW, NULL, 0, pExtHeader ) == GRFILTER_OK ) &&
 536                 ( aVCLGraphic.GetType() != GRAPHIC_NONE ) )
 537             {
 538                 ::unographic::Graphic* pUnoGraphic = new ::unographic::Graphic;
 539
 540                 pUnoGraphic->init( aVCLGraphic );
 541                 xRet = pUnoGraphic;
 542             }
 543         }
 544
 545         delete pIStm;
 546     }
 547
 548     return xRet;
 549 }
 550
 551 void ImplCalculateCropRect( ::Graphic& rGraphic, const text::GraphicCrop& rGraphicCropLogic, Rectangle& rGraphicCropPixel )
 552 {
 553     if ( rGraphicCropLogic.Left || rGraphicCropLogic.Top || rGraphicCropLogic.Right || rGraphicCropLogic.Bottom )
 554     {
 555         Size aSourceSizePixel( rGraphic.GetSizePixel() );
 556         if ( aSourceSizePixel.Width() && aSourceSizePixel.Height() )
 557         {
 558             if ( rGraphicCropLogic.Left || rGraphicCropLogic.Top || rGraphicCropLogic.Right || rGraphicCropLogic.Bottom )
 559             {
 560                 Size aSize100thMM( 0, 0 );
 561                 if( rGraphic.GetPrefMapMode().GetMapUnit() != MAP_PIXEL )
 562                 {
 563                     aSize100thMM = OutputDevice::LogicToLogic( rGraphic.GetPrefSize(), rGraphic.GetPrefMapMode(), MAP_100TH_MM );
 564                 }
 565                 else
 566                 {
 567                     aSize100thMM = Application::GetDefaultDevice()->PixelToLogic( rGraphic.GetPrefSize(), MAP_100TH_MM );
 568                 }
 569                 if ( aSize100thMM.Width() && aSize100thMM.Height() )
 570                 {
 571                     double fSourceSizePixelWidth = static_cast<double>(aSourceSizePixel.Width());
 572                     double fSourceSizePixelHeight= static_cast<double>(aSourceSizePixel.Height());
 573                     rGraphicCropPixel.Left() = static_cast< sal_Int32 >((fSourceSizePixelWidth * rGraphicCropLogic.Left ) / aSize100thMM.Width());
 574                     rGraphicCropPixel.Top() = static_cast< sal_Int32 >((fSourceSizePixelHeight * rGraphicCropLogic.Top ) / aSize100thMM.Height());
 575                     rGraphicCropPixel.Right() = static_cast< sal_Int32 >(( fSourceSizePixelWidth * ( aSize100thMM.Width() - rGraphicCropLogic.Right ) ) / aSize100thMM.Width() );
 576                     rGraphicCropPixel.Bottom() = static_cast< sal_Int32 >(( fSourceSizePixelHeight * ( aSize100thMM.Height() - rGraphicCropLogic.Bottom ) ) / aSize100thMM.Height() );
 577                 }
 578             }
 579         }
 580     }
 581 }
 582
 583 void ImplApplyBitmapScaling( ::Graphic& rGraphic, sal_Int32 nPixelWidth, sal_Int32 nPixelHeight )
 584 {
 585     if ( nPixelWidth && nPixelHeight )
 586     {
 587         BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 588         MapMode aPrefMapMode( aBmpEx.GetPrefMapMode() );
 589         Size    aPrefSize( aBmpEx.GetPrefSize() );
 590         aBmpEx.Scale( Size( nPixelWidth, nPixelHeight ) );
 591         aBmpEx.SetPrefMapMode( aPrefMapMode );
 592         aBmpEx.SetPrefSize( aPrefSize );
 593         rGraphic = aBmpEx;
 594     }
 595 }
 596
 597 void ImplApplyBitmapResolution( ::Graphic& rGraphic, sal_Int32 nImageResolution, const Size& rVisiblePixelSize, const awt::Size& rLogicalSize )
 598 {
 599     if ( nImageResolution && rLogicalSize.Width && rLogicalSize.Height )
 600     {
 601         const double fImageResolution = static_cast<double>( nImageResolution );
 602         const double fSourceDPIX = ( static_cast<double>(rVisiblePixelSize.Width()) * 2540.0 ) / static_cast<double>(rLogicalSize.Width);
 603         const double fSourceDPIY = ( static_cast<double>(rVisiblePixelSize.Height()) * 2540.0 ) / static_cast<double>(rLogicalSize.Height);
 604         const sal_Int32 nSourcePixelWidth( rGraphic.GetSizePixel().Width() );
 605         const sal_Int32 nSourcePixelHeight( rGraphic.GetSizePixel().Height() );
 606         const double fSourcePixelWidth = static_cast<double>( nSourcePixelWidth );
 607         const double fSourcePixelHeight= static_cast<double>( nSourcePixelHeight );
 608
 609         sal_Int32 nDestPixelWidth = nSourcePixelWidth;
 610         sal_Int32 nDestPixelHeight = nSourcePixelHeight;
 611
 612         // check, if the bitmap DPI exceeds the maximum DPI
 613         if( fSourceDPIX > fImageResolution )
 614         {
 615             nDestPixelWidth = static_cast<sal_Int32>(( fSourcePixelWidth * fImageResolution ) / fSourceDPIX);
 616             if ( !nDestPixelWidth || ( nDestPixelWidth > nSourcePixelWidth ) )
 617                 nDestPixelWidth = nSourcePixelWidth;
 618         }
 619         if ( fSourceDPIY > fImageResolution )
 620         {
 621             nDestPixelHeight= static_cast<sal_Int32>(( fSourcePixelHeight* fImageResolution ) / fSourceDPIY);
 622             if ( !nDestPixelHeight || ( nDestPixelHeight > nSourcePixelHeight ) )
 623                 nDestPixelHeight = nSourcePixelHeight;
 624         }
 625         if ( ( nDestPixelWidth != nSourcePixelWidth ) || ( nDestPixelHeight != nSourcePixelHeight ) )
 626             ImplApplyBitmapScaling( rGraphic, nDestPixelWidth, nDestPixelHeight );
 627     }
 628 }
 629
 630 void ImplApplyFilterData( ::Graphic& rGraphic, uno::Sequence< beans::PropertyValue >& rFilterData )
 631 {
 632     /* this method applies following attributes to the graphic, in the first step the
 633        cropping area (logical size in 100thmm) is applied, in the second step the resolution
 634        is applied, in the third step the graphic is scaled to the corresponding pixelsize.
 635        if a parameter value is zero or not available the corresponding step will be skipped */
 636
 637     sal_Int32 nPixelWidth = 0;
 638     sal_Int32 nPixelHeight= 0;
 639     sal_Int32 nImageResolution = 0;
 640     awt::Size aLogicalSize( 0, 0 );
 641     text::GraphicCrop aCropLogic( 0, 0, 0, 0 );
 642     sal_Bool bRemoveCropArea = sal_True;
 643
 644     for( sal_Int32 i = 0; i < rFilterData.getLength(); ++i )
 645     {
 646         const OUString   aName(  rFilterData[ i ].Name );
 647         const uno::Any          aValue( rFilterData[ i ].Value );
 648
 649         if (aName == "PixelWidth")
 650             aValue >>= nPixelWidth;
 651         else if (aName == "PixelHeight")
 652             aValue >>= nPixelHeight;
 653         else if (aName == "LogicalSize")
 654             aValue >>= aLogicalSize;
 655         else if (aName == "GraphicCropLogic")
 656             aValue >>= aCropLogic;
 657         else if (aName == "RemoveCropArea")
 658             aValue >>= bRemoveCropArea;
 659         else if (aName == "ImageResolution")
 660             aValue >>= nImageResolution;
 661     }
 662     if ( rGraphic.GetType() == GRAPHIC_BITMAP )
 663     {
 664         if(rGraphic.getSvgData().get())
 665         {
 666             // embedded Svg, no need to scale. Also no method to apply crop data currently
 667         }
 668         else
 669         {
 670             Rectangle aCropPixel( Point( 0, 0 ), rGraphic.GetSizePixel() );
 671             ImplCalculateCropRect( rGraphic, aCropLogic, aCropPixel );
 672             if ( bRemoveCropArea )
 673             {
 674                 BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 675                 aBmpEx.Crop( aCropPixel );
 676                 rGraphic = aBmpEx;
 677             }
 678             Size aVisiblePixelSize( bRemoveCropArea ? rGraphic.GetSizePixel() : aCropPixel.GetSize() );
 679             ImplApplyBitmapResolution( rGraphic, nImageResolution, aVisiblePixelSize, aLogicalSize );
 680             ImplApplyBitmapScaling( rGraphic, nPixelWidth, nPixelHeight );
 681         }
 682     }
 683     else if ( ( rGraphic.GetType() == GRAPHIC_GDIMETAFILE ) && nImageResolution )
 684     {
 685         VirtualDevice aDummyVDev;
 686         GDIMetaFile aMtf( rGraphic.GetGDIMetaFile() );
 687         Size aMtfSize( aDummyVDev.LogicToLogic( aMtf.GetPrefSize(), aMtf.GetPrefMapMode(), MAP_100TH_MM ) );
 688         if ( aMtfSize.Width() && aMtfSize.Height() )
 689         {
 690             MapMode aNewMapMode( MAP_100TH_MM );
 691             aNewMapMode.SetScaleX( static_cast< double >( aLogicalSize.Width ) / static_cast< double >( aMtfSize.Width() ) );
 692             aNewMapMode.SetScaleY( static_cast< double >( aLogicalSize.Height ) / static_cast< double >( aMtfSize.Height() ) );
 693             aDummyVDev.EnableOutput( sal_False );
 694             aDummyVDev.SetMapMode( aNewMapMode );
 695
 696             for( size_t i = 0, nObjCount = aMtf.GetActionSize(); i < nObjCount; i++ )
 697             {
 698                 MetaAction* pAction = aMtf.GetAction( i );
 699                 switch( pAction->GetType() )
 700                 {
 701                     // only optimizing common bitmap actions:
 702                     case( META_MAPMODE_ACTION ):
 703                     {
 704                         const_cast< MetaAction* >( pAction )->Execute( &aDummyVDev );
 705                         break;
 706                     }
 707                     case( META_PUSH_ACTION ):
 708                     {
 709                         const MetaPushAction* pA = (const MetaPushAction*)pAction;
 710                         aDummyVDev.Push( pA->GetFlags() );
 711                         break;
 712                     }
 713                     case( META_POP_ACTION ):
 714                     {
 715                         aDummyVDev.Pop();
 716                         break;
 717                     }
 718                     case( META_BMPSCALE_ACTION ):
 719                     case( META_BMPEXSCALE_ACTION ):
 720                     {
 721                         BitmapEx aBmpEx;
 722                         Point aPos;
 723                         Size aSize;
 724                         if ( pAction->GetType() == META_BMPSCALE_ACTION )
 725                         {
 726                             MetaBmpScaleAction* pScaleAction = dynamic_cast< MetaBmpScaleAction* >( pAction );
 727                             aBmpEx = pScaleAction->GetBitmap();
 728                             aPos = pScaleAction->GetPoint();
 729                             aSize = pScaleAction->GetSize();
 730                         }
 731                         else
 732                         {
 733                             MetaBmpExScaleAction* pScaleAction = dynamic_cast< MetaBmpExScaleAction* >( pAction );
 734                             aBmpEx = pScaleAction->GetBitmapEx();
 735                             aPos = pScaleAction->GetPoint();
 736                             aSize = pScaleAction->GetSize();
 737                         }
 738                         ::Graphic aGraphic( aBmpEx );
 739                         const Size aSize100thmm( aDummyVDev.LogicToPixel( aSize ) );
 740                         Size aSize100thmm2( aDummyVDev.PixelToLogic( aSize100thmm, MAP_100TH_MM ) );
 741
 742                         ImplApplyBitmapResolution( aGraphic, nImageResolution,
 743                             aGraphic.GetSizePixel(), awt::Size( aSize100thmm2.Width(), aSize100thmm2.Height() ) );
 744
 745                         MetaAction* pNewAction;
 746                         if ( pAction->GetType() == META_BMPSCALE_ACTION )
 747                             pNewAction = new MetaBmpScaleAction ( aPos, aSize, aGraphic.GetBitmap() );
 748                         else
 749                             pNewAction = new MetaBmpExScaleAction( aPos, aSize, aGraphic.GetBitmapEx() );
 750
 751                         MetaAction* pDeleteAction = aMtf.ReplaceAction( pNewAction, i );
 752                         if(pDeleteAction)
 753                             pDeleteAction->Delete();
 754                         break;
 755                     }
 756                     default:
 757                     case( META_BMP_ACTION ):
 758                     case( META_BMPSCALEPART_ACTION ):
 759                     case( META_BMPEX_ACTION ):
 760                     case( META_BMPEXSCALEPART_ACTION ):
 761                     case( META_MASK_ACTION ):
 762                     case( META_MASKSCALE_ACTION ):
 763                     break;
 764                 }
 765             }
 766             rGraphic = aMtf;
 767         }
 768     }
 769 }
 770
 771 // ------------------------------------------------------------------------------
 772
 773 void SAL_CALL GraphicProvider::storeGraphic( const uno::Reference< ::graphic::XGraphic >& rxGraphic, const uno::Sequence< beans::PropertyValue >& rMediaProperties )
 774     throw ( io::IOException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 775 {
 776     SolarMutexGuard g;
 777
 778     SvStream*   pOStm = NULL;
 779     OUString    aPath;
 780     sal_Int32   i;
 781
 782     for( i = 0; ( i < rMediaProperties.getLength() ) && !pOStm; ++i )
 783     {
 784         const OUString   aName( rMediaProperties[ i ].Name );
 785         const uno::Any          aValue( rMediaProperties[ i ].Value );
 786
 787         if (aName == "URL")
 788         {
 789             OUString aURL;
 790
 791             aValue >>= aURL;
 792             pOStm = ::utl::UcbStreamHelper::CreateStream( aURL, STREAM_WRITE | STREAM_TRUNC );
 793             aPath = aURL;
 794         }
 795         else if (aName == "OutputStream")
 796         {
 797             uno::Reference< io::XStream > xOStm;
 798
 799             aValue >>= xOStm;
 800
 801             if( xOStm.is() )
 802                 pOStm = ::utl::UcbStreamHelper::CreateStream( xOStm );
 803         }
 804     }
 805
 806     if( pOStm )
 807     {
 808         uno::Sequence< beans::PropertyValue >   aFilterDataSeq;
 809         const char*                             pFilterShortName = NULL;
 810
 811         for( i = 0; i < rMediaProperties.getLength(); ++i )
 812         {
 813             const OUString   aName( rMediaProperties[ i ].Name );
 814             const uno::Any          aValue( rMediaProperties[ i ].Value );
 815
 816             if (aName == "FilterData")
 817             {
 818                 aValue >>= aFilterDataSeq;
 819             }
 820             else if (aName == "MimeType")
 821             {
 822                 OUString aMimeType;
 823
 824                 aValue >>= aMimeType;
 825
 826                 if (aMimeType == MIMETYPE_BMP)
 827                     pFilterShortName = "bmp";
 828                 else if (aMimeType == MIMETYPE_EPS)
 829                     pFilterShortName = "eps";
 830                 else if (aMimeType == MIMETYPE_GIF)
 831                     pFilterShortName = "gif";
 832                 else if (aMimeType == MIMETYPE_JPG)
 833                     pFilterShortName = "jpg";
 834                 else if (aMimeType == MIMETYPE_MET)
 835                     pFilterShortName = "met";
 836                 else if (aMimeType == MIMETYPE_PNG)
 837                     pFilterShortName = "png";
 838                 else if (aMimeType == MIMETYPE_PCT)
 839                     pFilterShortName = "pct";
 840                 else if (aMimeType == MIMETYPE_PBM)
 841                     pFilterShortName = "pbm";
 842                 else if (aMimeType == MIMETYPE_PGM)
 843                     pFilterShortName = "pgm";
 844                 else if (aMimeType == MIMETYPE_PPM)
 845                     pFilterShortName = "ppm";
 846                 else if (aMimeType == MIMETYPE_RAS)
 847                     pFilterShortName = "ras";
 848                 else if (aMimeType == MIMETYPE_SVM)
 849                     pFilterShortName = "svm";
 850                 else if (aMimeType == MIMETYPE_TIF)
 851                     pFilterShortName = "tif";
 852                 else if (aMimeType == MIMETYPE_EMF)
 853                     pFilterShortName = "emf";
 854                 else if (aMimeType == MIMETYPE_WMF)
 855                     pFilterShortName = "wmf";
 856                 else if (aMimeType == MIMETYPE_XPM)
 857                     pFilterShortName = "xpm";
 858                 else if (aMimeType == MIMETYPE_SVG)
 859                     pFilterShortName = "svg";
 860                 else if (aMimeType == MIMETYPE_VCLGRAPHIC)
 861                     pFilterShortName = MIMETYPE_VCLGRAPHIC;
 862             }
 863         }
 864
 865         if( pFilterShortName )
 866         {
 867             ::GraphicFilter& rFilter = ::GraphicFilter::GetGraphicFilter();
 868
 869             {
 870                 const uno::Reference< XInterface >  xIFace( rxGraphic, uno::UNO_QUERY );
 871                 const ::Graphic*                    pGraphic = ::unographic::Graphic::getImplementation( xIFace );
 872
 873                 if( pGraphic && ( pGraphic->GetType() != GRAPHIC_NONE ) )
 874                 {
 875                     ::Graphic aGraphic( *pGraphic );
 876                     ImplApplyFilterData( aGraphic, aFilterDataSeq );
 877
 878                     /* sj: using a temporary memory stream, because some graphic filters are seeking behind
 879                        stream end (which leads to an invalid argument exception then). */
 880                     SvMemoryStream aMemStrm;
 881                     aMemStrm.SetVersion( SOFFICE_FILEFORMAT_CURRENT );
 882                     if( 0 == strcmp( pFilterShortName, MIMETYPE_VCLGRAPHIC ) )
 883                         aMemStrm << aGraphic;
 884                     else
 885                     {
 886                         rFilter.ExportGraphic( aGraphic, aPath, aMemStrm,
 887                                                 rFilter.GetExportFormatNumberForShortName( OUString::createFromAscii( pFilterShortName ) ),
 888                                                     ( aFilterDataSeq.getLength() ? &aFilterDataSeq : NULL ) );
 889                     }
 890                     aMemStrm.Seek( STREAM_SEEK_TO_END );
 891                     pOStm->Write( aMemStrm.GetData(), aMemStrm.Tell() );
 892                 }
 893             }
 894         }
 895         delete pOStm;
 896     }
 897 }
 898
 899 }
 900
 901 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */