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