vcl/source/gdi/graph.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 <tools/fract.hxx>
  21 #include <vcl/outdev.hxx>
  22 #include <vcl/svapp.hxx>
  23 #include <vcl/graph.hxx>
  24 #include <vcl/metaact.hxx>
  25 #include <impgraph.hxx>
  26 #include <comphelper/processfactory.hxx>
  27 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  28 #include <com/sun/star/graphic/GraphicProvider.hpp>
  29 #include <com/sun/star/graphic/XGraphicProvider.hpp>
  30 #include <com/sun/star/lang/XUnoTunnel.hpp>
  31 #include <com/sun/star/lang/XTypeProvider.hpp>
  32 #include <com/sun/star/graphic/XGraphic.hpp>
  33 #include <cppuhelper/typeprovider.hxx>
  34
  35 using namespace ::com::sun::star;
  36
  37 namespace
  38 {
  39
  40 void ImplDrawDefault( OutputDevice* pOutDev, const OUString* pText,
  41                              vcl::Font* pFont, const Bitmap* pBitmap, const BitmapEx* pBitmapEx,
  42                              const Point& rDestPt, const Size& rDestSize )
  43 {
  44     sal_uInt16  nPixel = (sal_uInt16) pOutDev->PixelToLogic( Size( 1, 1 ) ).Width();
  45     sal_uInt16  nPixelWidth = nPixel;
  46     Point       aPoint( rDestPt.X() + nPixelWidth, rDestPt.Y() + nPixelWidth );
  47     Size        aSize( rDestSize.Width() - ( nPixelWidth << 1 ), rDestSize.Height() - ( nPixelWidth << 1 ) );
  48     bool        bFilled = ( pBitmap != nullptr || pBitmapEx != nullptr || pFont != nullptr );
  49     tools::Rectangle   aBorderRect( aPoint, aSize );
  50
  51     pOutDev->Push();
  52
  53     pOutDev->SetFillColor();
  54
  55     // On the printer a black rectangle and on the screen one with 3D effect
  56     if ( pOutDev->GetOutDevType() == OUTDEV_PRINTER )
  57         pOutDev->SetLineColor( COL_BLACK );
  58     else
  59     {
  60         aBorderRect.Left() += nPixel;
  61         aBorderRect.Top() += nPixel;
  62
  63         pOutDev->SetLineColor( COL_LIGHTGRAY );
  64         pOutDev->DrawRect( aBorderRect );
  65
  66         aBorderRect.Left() -= nPixel;
  67         aBorderRect.Top() -= nPixel;
  68         aBorderRect.Right() -= nPixel;
  69         aBorderRect.Bottom() -= nPixel;
  70         pOutDev->SetLineColor( COL_GRAY );
  71     }
  72
  73     pOutDev->DrawRect( aBorderRect );
  74
  75     aPoint.X() += nPixelWidth + 2*nPixel;
  76     aPoint.Y() += nPixelWidth + 2*nPixel;
  77     aSize.Width() -= 2*nPixelWidth + 4*nPixel;
  78     aSize.Height() -= 2*nPixelWidth + 4*nPixel;
  79
  80     if( aSize.Width() > 0 && aSize.Height() > 0
  81         && (  ( pBitmap && !!*pBitmap ) || ( pBitmapEx && !!*pBitmapEx ) ) )
  82     {
  83         Size aBitmapSize( pOutDev->PixelToLogic( pBitmap ? pBitmap->GetSizePixel() : pBitmapEx->GetSizePixel() ) );
  84
  85         if( aSize.Height() > aBitmapSize.Height() && aSize.Width() > aBitmapSize.Width() )
  86         {
  87             if ( pBitmap )
  88                 pOutDev->DrawBitmap( aPoint, *pBitmap );
  89             else
  90                 pOutDev->DrawBitmapEx( aPoint, *pBitmapEx );
  91             aPoint.X() += aBitmapSize.Width() + 2*nPixel;
  92             aSize.Width() -= aBitmapSize.Width() + 2*nPixel;
  93         }
  94     }
  95
  96     if ( aSize.Width() > 0 && aSize.Height() > 0 && pFont && pText && pText->getLength()
  97          && !(!pOutDev->IsOutputEnabled() /*&& pOutDev->GetConnectMetaFile() */) )
  98     {
  99         MapMode aMapMode( MapUnit::MapPoint );
 100         Size    aSz = pOutDev->LogicToLogic( Size( 0, 12 ), &aMapMode, nullptr );
 101         long    nThreshold = aSz.Height() / 2;
 102         long    nStep = nThreshold / 3;
 103
 104         if ( !nStep )
 105             nStep = aSz.Height() - nThreshold;
 106
 107         for(;; aSz.Height() -= nStep )
 108         {
 109             pFont->SetFontSize( aSz );
 110             pOutDev->SetFont( *pFont );
 111
 112             long nTextHeight = pOutDev->GetTextHeight();
 113             long nTextWidth = pOutDev->GetTextWidth( *pText );
 114             if ( nTextHeight )
 115             {
 116                 // The approximation does not respect imprecisions caused
 117                 // by word wraps
 118                 long nLines = aSize.Height() / nTextHeight;
 119                 long nWidth = aSize.Width() * nLines; // Approximation!!!
 120
 121                 if ( nTextWidth <= nWidth || aSz.Height() <= nThreshold )
 122                 {
 123                     sal_Int32 nStart = 0;
 124                     sal_Int32 nLen = 0;
 125
 126                     while( nStart < pText->getLength() && (*pText)[nStart] == ' ' )
 127                         nStart++;
 128                     while( nStart+nLen < pText->getLength() && (*pText)[nStart+nLen] != ' ' )
 129                         nLen++;
 130                     while( nStart < pText->getLength() && nLines-- )
 131                     {
 132                         sal_Int32 nNext = nLen;
 133                         do
 134                         {
 135                             while ( nStart+nNext < pText->getLength() && (*pText)[nStart+nNext] == ' ' )
 136                                 nNext++;
 137                             while ( nStart+nNext < pText->getLength() && (*pText)[nStart+nNext] != ' ' )
 138                                 nNext++;
 139                             nTextWidth = pOutDev->GetTextWidth( *pText, nStart, nNext );
 140                             if ( nTextWidth > aSize.Width() )
 141                                 break;
 142                             nLen = nNext;
 143                         }
 144                         while ( nStart+nNext < pText->getLength() );
 145
 146                         sal_Int32 n = nLen;
 147                         nTextWidth = pOutDev->GetTextWidth( *pText, nStart, n );
 148                         while( nTextWidth > aSize.Width() )
 149                             nTextWidth = pOutDev->GetTextWidth( *pText, nStart, --n );
 150                         pOutDev->DrawText( aPoint, *pText, nStart, n );
 151
 152                         aPoint.Y() += nTextHeight;
 153                         nStart      = sal::static_int_cast<sal_uInt16>(nStart + nLen);
 154                         nLen        = nNext-nLen;
 155                         while( nStart < pText->getLength() && (*pText)[nStart] == ' ' )
 156                         {
 157                             nStart++;
 158                             nLen--;
 159                         }
 160                     }
 161                     break;
 162                 }
 163             }
 164             else
 165                 break;
 166         }
 167     }
 168
 169     // If the default graphic does not have content, we draw a red rectangle
 170     if( !bFilled )
 171     {
 172         aBorderRect.Left()++;
 173         aBorderRect.Top()++;
 174         aBorderRect.Right()--;
 175         aBorderRect.Bottom()--;
 176
 177         pOutDev->SetLineColor( COL_LIGHTRED );
 178         pOutDev->DrawLine( aBorderRect.TopLeft(), aBorderRect.BottomRight() );
 179         pOutDev->DrawLine( aBorderRect.TopRight(), aBorderRect.BottomLeft() );
 180     }
 181
 182     pOutDev->Pop();
 183 }
 184
 185 } // end anonymous namespace
 186
 187 Graphic::Graphic()
 188     : mxImpGraphic(new ImpGraphic)
 189 {
 190 }
 191
 192 Graphic::Graphic(const Graphic& rGraphic)
 193 {
 194     if( rGraphic.IsAnimated() )
 195         mxImpGraphic.reset(new ImpGraphic(*rGraphic.mxImpGraphic));
 196     else
 197         mxImpGraphic = rGraphic.mxImpGraphic;
 198 }
 199
 200 Graphic::Graphic(Graphic&& rGraphic)
 201     : mxImpGraphic(std::move(rGraphic.mxImpGraphic))
 202 {
 203 }
 204
 205 Graphic::Graphic(const Bitmap& rBmp)
 206     : mxImpGraphic(new ImpGraphic(rBmp))
 207 {
 208 }
 209
 210 Graphic::Graphic(const BitmapEx& rBmpEx)
 211     : mxImpGraphic(new ImpGraphic(rBmpEx))
 212 {
 213 }
 214
 215 Graphic::Graphic(const SvgDataPtr& rSvgDataPtr)
 216     : mxImpGraphic(new ImpGraphic(rSvgDataPtr))
 217 {
 218 }
 219
 220 Graphic::Graphic(const Animation& rAnimation)
 221     : mxImpGraphic(new ImpGraphic(rAnimation))
 222 {
 223 }
 224
 225 Graphic::Graphic(const GDIMetaFile& rMtf)
 226     : mxImpGraphic(new ImpGraphic(rMtf))
 227 {
 228 }
 229
 230 Graphic::Graphic( const css::uno::Reference< css::graphic::XGraphic >& rxGraphic )
 231 {
 232     uno::Reference< lang::XUnoTunnel >      xTunnel( rxGraphic, uno::UNO_QUERY );
 233     const ::Graphic*                        pGraphic = ( xTunnel.is() ?
 234                                                          reinterpret_cast< ::Graphic* >( xTunnel->getSomething( getUnoTunnelId() ) ) :
 235                                                           nullptr );
 236
 237     if( pGraphic )
 238     {
 239         if (pGraphic->IsAnimated())
 240             mxImpGraphic.reset(new ImpGraphic(*pGraphic->mxImpGraphic));
 241         else
 242             mxImpGraphic = pGraphic->mxImpGraphic;
 243     }
 244     else
 245         mxImpGraphic.reset(new ImpGraphic);
 246 }
 247
 248 void Graphic::ImplTestRefCount()
 249 {
 250     if (!mxImpGraphic.unique())
 251     {
 252         mxImpGraphic.reset(new ImpGraphic(*mxImpGraphic));
 253     }
 254 }
 255
 256 Graphic& Graphic::operator=( const Graphic& rGraphic )
 257 {
 258     if( &rGraphic != this )
 259     {
 260         if( rGraphic.IsAnimated() )
 261         {
 262             mxImpGraphic.reset(new ImpGraphic(*rGraphic.mxImpGraphic));
 263         }
 264         else
 265         {
 266             mxImpGraphic = rGraphic.mxImpGraphic;
 267         }
 268     }
 269
 270     return *this;
 271 }
 272
 273 Graphic& Graphic::operator=(Graphic&& rGraphic)
 274 {
 275     mxImpGraphic = std::move(rGraphic.mxImpGraphic);
 276     return *this;
 277 }
 278
 279 bool Graphic::operator==( const Graphic& rGraphic ) const
 280 {
 281     return (*mxImpGraphic == *rGraphic.mxImpGraphic);
 282 }
 283
 284 bool Graphic::operator!=( const Graphic& rGraphic ) const
 285 {
 286     return (*mxImpGraphic != *rGraphic.mxImpGraphic);
 287 }
 288
 289 bool Graphic::operator!() const
 290 {
 291     return (GraphicType::NONE == mxImpGraphic->ImplGetType());
 292 }
 293
 294 void Graphic::Clear()
 295 {
 296     ImplTestRefCount();
 297     mxImpGraphic->ImplClear();
 298 }
 299
 300 GraphicType Graphic::GetType() const
 301 {
 302     return mxImpGraphic->ImplGetType();
 303 }
 304
 305 void Graphic::SetDefaultType()
 306 {
 307     ImplTestRefCount();
 308     mxImpGraphic->ImplSetDefaultType();
 309 }
 310
 311 bool Graphic::IsSupportedGraphic() const
 312 {
 313     return mxImpGraphic->ImplIsSupportedGraphic();
 314 }
 315
 316 bool Graphic::IsTransparent() const
 317 {
 318     return mxImpGraphic->ImplIsTransparent();
 319 }
 320
 321 bool Graphic::IsAlpha() const
 322 {
 323     return mxImpGraphic->ImplIsAlpha();
 324 }
 325
 326 bool Graphic::IsAnimated() const
 327 {
 328     return mxImpGraphic->ImplIsAnimated();
 329 }
 330
 331 bool Graphic::IsEPS() const
 332 {
 333     return mxImpGraphic->ImplIsEPS();
 334 }
 335
 336 Bitmap Graphic::GetBitmap(const GraphicConversionParameters& rParameters) const
 337 {
 338     return mxImpGraphic->ImplGetBitmap(rParameters);
 339 }
 340
 341 BitmapEx Graphic::GetBitmapEx(const GraphicConversionParameters& rParameters) const
 342 {
 343     return mxImpGraphic->ImplGetBitmapEx(rParameters);
 344 }
 345
 346 Animation Graphic::GetAnimation() const
 347 {
 348     return mxImpGraphic->ImplGetAnimation();
 349 }
 350
 351 const GDIMetaFile& Graphic::GetGDIMetaFile() const
 352 {
 353     return mxImpGraphic->ImplGetGDIMetaFile();
 354 }
 355
 356 const BitmapEx& Graphic::GetBitmapExRef() const
 357 {
 358     return mxImpGraphic->ImplGetBitmapExRef();
 359 }
 360
 361 uno::Reference< graphic::XGraphic > Graphic::GetXGraphic() const
 362 {
 363     uno::Reference< graphic::XGraphic > xRet;
 364
 365     if( GetType() != GraphicType::NONE )
 366     {
 367         uno::Reference < uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
 368         uno::Reference< graphic::XGraphicProvider > xProv( graphic::GraphicProvider::create( xContext ) );
 369
 370         uno::Sequence< beans::PropertyValue > aLoadProps( 1 );
 371         OUString aURL = "private:memorygraphic/" + OUString::number( reinterpret_cast< sal_Int64 >( this ) );
 372
 373         aLoadProps[ 0 ].Name = "URL";
 374         aLoadProps[ 0 ].Value <<= aURL;
 375
 376         xRet = xProv->queryGraphic( aLoadProps );
 377     }
 378
 379     return xRet;
 380 }
 381
 382 Size Graphic::GetPrefSize() const
 383 {
 384     return mxImpGraphic->ImplGetPrefSize();
 385 }
 386
 387 void Graphic::SetPrefSize( const Size& rPrefSize )
 388 {
 389     ImplTestRefCount();
 390     mxImpGraphic->ImplSetPrefSize( rPrefSize );
 391 }
 392
 393 MapMode Graphic::GetPrefMapMode() const
 394 {
 395     return mxImpGraphic->ImplGetPrefMapMode();
 396 }
 397
 398 void Graphic::SetPrefMapMode( const MapMode& rPrefMapMode )
 399 {
 400     ImplTestRefCount();
 401     mxImpGraphic->ImplSetPrefMapMode( rPrefMapMode );
 402 }
 403
 404 basegfx::B2DSize Graphic::GetPPI() const
 405 {
 406     double nGrfDPIx;
 407     double nGrfDPIy;
 408
 409     const MapMode aGrfMap(GetPrefMapMode());
 410     const Size aGrfPixelSize(GetSizePixel());
 411     const Size aGrfPrefMapModeSize(GetPrefSize());
 412     if (aGrfMap.GetMapUnit() == MapUnit::MapInch)
 413     {
 414         nGrfDPIx = aGrfPixelSize.Width() / ( (double)aGrfMap.GetScaleX() * aGrfPrefMapModeSize.Width() );
 415         nGrfDPIy = aGrfPixelSize.Height() / ( (double)aGrfMap.GetScaleY() * aGrfPrefMapModeSize.Height() );
 416     }
 417     else
 418     {
 419         const Size aGrf1000thInchSize = OutputDevice::LogicToLogic(aGrfPrefMapModeSize, aGrfMap, MapUnit::Map1000thInch);
 420         nGrfDPIx = 1000.0 * aGrfPixelSize.Width() / aGrf1000thInchSize.Width();
 421         nGrfDPIy = 1000.0 * aGrfPixelSize.Height() / aGrf1000thInchSize.Height();
 422     }
 423
 424     return basegfx::B2DSize(nGrfDPIx, nGrfDPIy);
 425 }
 426
 427 Size Graphic::GetSizePixel( const OutputDevice* pRefDevice ) const
 428 {
 429     Size aRet;
 430
 431     if( GraphicType::Bitmap == mxImpGraphic->ImplGetType() )
 432         aRet = mxImpGraphic->ImplGetBitmapEx(GraphicConversionParameters()).GetSizePixel();
 433     else
 434         aRet = ( pRefDevice ? pRefDevice : Application::GetDefaultDevice() )->LogicToPixel( GetPrefSize(), GetPrefMapMode() );
 435
 436     return aRet;
 437 }
 438
 439 sal_uLong Graphic::GetSizeBytes() const
 440 {
 441     return mxImpGraphic->ImplGetSizeBytes();
 442 }
 443
 444 void Graphic::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
 445 {
 446     mxImpGraphic->ImplDraw( pOutDev, rDestPt );
 447 }
 448
 449 void Graphic::Draw( OutputDevice* pOutDev,
 450                     const Point& rDestPt, const Size& rDestSz ) const
 451 {
 452     if( GraphicType::Default == mxImpGraphic->ImplGetType() )
 453         ImplDrawDefault( pOutDev, nullptr, nullptr, nullptr, nullptr, rDestPt, rDestSz );
 454     else
 455         mxImpGraphic->ImplDraw( pOutDev, rDestPt, rDestSz );
 456 }
 457
 458 void Graphic::DrawEx( OutputDevice* pOutDev, const OUString& rText,
 459                     vcl::Font& rFont, const BitmapEx& rBitmap,
 460                     const Point& rDestPt, const Size& rDestSz )
 461 {
 462     ImplDrawDefault( pOutDev, &rText, &rFont, nullptr, &rBitmap, rDestPt, rDestSz );
 463 }
 464
 465 void Graphic::StartAnimation( OutputDevice* pOutDev, const Point& rDestPt,
 466                               const Size& rDestSz, long nExtraData,
 467                               OutputDevice* pFirstFrameOutDev )
 468 {
 469     ImplTestRefCount();
 470     mxImpGraphic->ImplStartAnimation( pOutDev, rDestPt, rDestSz, nExtraData, pFirstFrameOutDev );
 471 }
 472
 473 void Graphic::StopAnimation( OutputDevice* pOutDev, long nExtraData )
 474 {
 475     ImplTestRefCount();
 476     mxImpGraphic->ImplStopAnimation( pOutDev, nExtraData );
 477 }
 478
 479 void Graphic::SetAnimationNotifyHdl( const Link<Animation*,void>& rLink )
 480 {
 481     mxImpGraphic->ImplSetAnimationNotifyHdl( rLink );
 482 }
 483
 484 Link<Animation*,void> Graphic::GetAnimationNotifyHdl() const
 485 {
 486     return mxImpGraphic->ImplGetAnimationNotifyHdl();
 487 }
 488
 489 sal_uLong Graphic::GetAnimationLoopCount() const
 490 {
 491     return mxImpGraphic->ImplGetAnimationLoopCount();
 492 }
 493
 494 std::shared_ptr<GraphicReader>& Graphic::GetContext()
 495 {
 496     return mxImpGraphic->ImplGetContext();
 497 }
 498
 499 void Graphic::SetContext( const std::shared_ptr<GraphicReader> &pReader )
 500 {
 501     mxImpGraphic->ImplSetContext( pReader );
 502 }
 503
 504 void Graphic::SetDummyContext( bool value )
 505 {
 506     mxImpGraphic->ImplSetDummyContext( value );
 507 }
 508
 509 bool Graphic::IsDummyContext()
 510 {
 511     return mxImpGraphic->ImplIsDummyContext();
 512 }
 513
 514 bool Graphic::SwapOut()
 515 {
 516     ImplTestRefCount();
 517     return mxImpGraphic->ImplSwapOut();
 518 }
 519
 520 void Graphic::SwapOutAsLink()
 521 {
 522     ImplTestRefCount();
 523     mxImpGraphic->ImplSwapOutAsLink();
 524 }
 525
 526 bool Graphic::SwapOut( SvStream* pOStream )
 527 {
 528     ImplTestRefCount();
 529     return mxImpGraphic->ImplSwapOut( pOStream );
 530 }
 531
 532 bool Graphic::SwapIn()
 533 {
 534     ImplTestRefCount();
 535     return mxImpGraphic->ImplSwapIn();
 536 }
 537
 538 bool Graphic::SwapIn( SvStream* pStrm )
 539 {
 540     ImplTestRefCount();
 541     return mxImpGraphic->ImplSwapIn( pStrm );
 542 }
 543
 544 bool Graphic::IsSwapOut() const
 545 {
 546     return mxImpGraphic->ImplIsSwapOut();
 547 }
 548
 549 void Graphic::SetLink( const GfxLink& rGfxLink )
 550 {
 551     ImplTestRefCount();
 552     mxImpGraphic->ImplSetLink( rGfxLink );
 553 }
 554
 555 GfxLink Graphic::GetLink() const
 556 {
 557     return mxImpGraphic->ImplGetLink();
 558 }
 559
 560 bool Graphic::IsLink() const
 561 {
 562     return mxImpGraphic->ImplIsLink();
 563 }
 564
 565 BitmapChecksum Graphic::GetChecksum() const
 566 {
 567     return mxImpGraphic->ImplGetChecksum();
 568 }
 569
 570 bool Graphic::ExportNative( SvStream& rOStream ) const
 571 {
 572     return mxImpGraphic->ImplExportNative( rOStream );
 573 }
 574
 575 void ReadGraphic(SvStream& rIStream, Graphic& rGraphic)
 576 {
 577     rGraphic.ImplTestRefCount();
 578     ReadImpGraphic(rIStream, *rGraphic.mxImpGraphic);
 579 }
 580
 581 void WriteGraphic( SvStream& rOStream, const Graphic& rGraphic )
 582 {
 583     WriteImpGraphic(rOStream, *rGraphic.mxImpGraphic);
 584 }
 585
 586 const SvgDataPtr& Graphic::getSvgData() const
 587 {
 588     return mxImpGraphic->getSvgData();
 589 }
 590
 591 void Graphic::setPdfData(const uno::Sequence<sal_Int8>& rPdfData)
 592 {
 593     ImplTestRefCount();
 594     mxImpGraphic->maPdfData = rPdfData;
 595 }
 596
 597 const uno::Sequence<sal_Int8>& Graphic::getPdfData() const
 598 {
 599     return mxImpGraphic->maPdfData;
 600 }
 601
 602 namespace {
 603
 604 struct Id: public rtl::Static<cppu::OImplementationId, Id> {};
 605
 606 }
 607
 608 css::uno::Sequence<sal_Int8> Graphic::getUnoTunnelId() {
 609     return Id::get().getImplementationId();
 610 }
 611
 612 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */