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/image.hxx>
  25 #include <impgraph.hxx>
  26 #include <com/sun/star/graphic/XGraphic.hpp>
  27 #include <comphelper/servicehelper.hxx>
  28 #include <cppuhelper/typeprovider.hxx>
  29 #include <graphic/UnoGraphic.hxx>
  30 #include <vcl/GraphicExternalLink.hxx>
  31
  32 using namespace ::com::sun::star;
  33
  34 namespace
  35 {
  36
  37 void ImplDrawDefault(OutputDevice& rOutDev, const OUString* pText,
  38                      vcl::Font* pFont, const BitmapEx* pBitmapEx,
  39                      const Point& rDestPt, const Size& rDestSize)
  40 {
  41     sal_uInt16  nPixel = static_cast<sal_uInt16>(rOutDev.PixelToLogic( Size( 1, 1 ) ).Width());
  42     sal_uInt16  nPixelWidth = nPixel;
  43     Point       aPoint( rDestPt.X() + nPixelWidth, rDestPt.Y() + nPixelWidth );
  44     Size        aSize( rDestSize.Width() - ( nPixelWidth << 1 ), rDestSize.Height() - ( nPixelWidth << 1 ) );
  45     bool        bFilled = ( pBitmapEx != nullptr || pFont != nullptr );
  46     tools::Rectangle   aBorderRect( aPoint, aSize );
  47
  48     rOutDev.Push();
  49
  50     rOutDev.SetFillColor();
  51
  52     // On the printer a black rectangle and on the screen one with 3D effect
  53     rOutDev.DrawBorder(aBorderRect);
  54
  55     aPoint.AdjustX(nPixelWidth + 2*nPixel );
  56     aPoint.AdjustY(nPixelWidth + 2*nPixel );
  57     aSize.AdjustWidth( -(2*nPixelWidth + 4*nPixel) );
  58     aSize.AdjustHeight( -(2*nPixelWidth + 4*nPixel) );
  59
  60     if( !aSize.IsEmpty() && pBitmapEx && !pBitmapEx->IsEmpty() )
  61     {
  62         Size aBitmapSize( rOutDev.PixelToLogic( pBitmapEx->GetSizePixel() ) );
  63
  64         if( aSize.Height() > aBitmapSize.Height() && aSize.Width() > aBitmapSize.Width() )
  65         {
  66             rOutDev.DrawBitmapEx( aPoint, *pBitmapEx );
  67             aPoint.AdjustX(aBitmapSize.Width() + 2*nPixel );
  68             aSize.AdjustWidth( -(aBitmapSize.Width() + 2*nPixel) );
  69         }
  70     }
  71
  72     if ( !aSize.IsEmpty() && pFont && pText && pText->getLength() && rOutDev.IsOutputEnabled() )
  73     {
  74         MapMode aMapMode( MapUnit::MapPoint );
  75         Size aSz = rOutDev.LogicToLogic( Size( 0, 12 ), &aMapMode, nullptr );
  76         tools::Long    nThreshold = aSz.Height() / 2;
  77         tools::Long    nStep = nThreshold / 3;
  78
  79         if ( !nStep )
  80             nStep = aSz.Height() - nThreshold;
  81
  82         for(;; aSz.AdjustHeight( -nStep ) )
  83         {
  84             pFont->SetFontSize( aSz );
  85             rOutDev.SetFont( *pFont );
  86
  87             tools::Long nTextHeight = rOutDev.GetTextHeight();
  88             tools::Long nTextWidth = rOutDev.GetTextWidth( *pText );
  89             if ( nTextHeight )
  90             {
  91                 // The approximation does not respect imprecisions caused
  92                 // by word wraps
  93                 tools::Long nLines = aSize.Height() / nTextHeight;
  94                 tools::Long nWidth = aSize.Width() * nLines; // Approximation!!!
  95
  96                 if ( nTextWidth <= nWidth || aSz.Height() <= nThreshold )
  97                 {
  98                     sal_Int32 nStart = 0;
  99                     sal_Int32 nLen = 0;
 100
 101                     while( nStart < pText->getLength() && (*pText)[nStart] == ' ' )
 102                         nStart++;
 103                     while( nStart+nLen < pText->getLength() && (*pText)[nStart+nLen] != ' ' )
 104                         nLen++;
 105                     while( nStart < pText->getLength() && nLines-- )
 106                     {
 107                         sal_Int32 nNext = nLen;
 108                         do
 109                         {
 110                             while ( nStart+nNext < pText->getLength() && (*pText)[nStart+nNext] == ' ' )
 111                                 nNext++;
 112                             while ( nStart+nNext < pText->getLength() && (*pText)[nStart+nNext] != ' ' )
 113                                 nNext++;
 114                             nTextWidth = rOutDev.GetTextWidth( *pText, nStart, nNext );
 115                             if ( nTextWidth > aSize.Width() )
 116                                 break;
 117                             nLen = nNext;
 118                         }
 119                         while ( nStart+nNext < pText->getLength() );
 120
 121                         sal_Int32 n = nLen;
 122                         nTextWidth = rOutDev.GetTextWidth( *pText, nStart, n );
 123                         while( nTextWidth > aSize.Width() )
 124                             nTextWidth = rOutDev.GetTextWidth( *pText, nStart, --n );
 125                         rOutDev.DrawText( aPoint, *pText, nStart, n );
 126
 127                         aPoint.AdjustY(nTextHeight );
 128                         nStart      = sal::static_int_cast<sal_uInt16>(nStart + nLen);
 129                         nLen        = nNext-nLen;
 130                         while( nStart < pText->getLength() && (*pText)[nStart] == ' ' )
 131                         {
 132                             nStart++;
 133                             nLen--;
 134                         }
 135                     }
 136                     break;
 137                 }
 138             }
 139             else
 140                 break;
 141         }
 142     }
 143
 144     // If the default graphic does not have content, we draw a red rectangle
 145     if( !bFilled )
 146     {
 147         aBorderRect.AdjustLeft( 1 );
 148         aBorderRect.AdjustTop( 1 );
 149         aBorderRect.AdjustRight( -1 );
 150         aBorderRect.AdjustBottom( -1 );
 151
 152         rOutDev.SetLineColor( COL_LIGHTRED );
 153         rOutDev.DrawLine( aBorderRect.TopLeft(), aBorderRect.BottomRight() );
 154         rOutDev.DrawLine( aBorderRect.TopRight(), aBorderRect.BottomLeft() );
 155     }
 156
 157     rOutDev.Pop();
 158 }
 159
 160 } // end anonymous namespace
 161
 162 Graphic::Graphic()
 163     : mxImpGraphic(vcl::graphic::Manager::get().newInstance())
 164 {
 165 }
 166
 167 Graphic::Graphic(const Graphic& rGraphic)
 168 {
 169     if( rGraphic.IsAnimated() )
 170         mxImpGraphic = vcl::graphic::Manager::get().copy(rGraphic.mxImpGraphic);
 171     else
 172         mxImpGraphic = rGraphic.mxImpGraphic;
 173 }
 174
 175 Graphic::Graphic(Graphic&& rGraphic) noexcept
 176     : mxImpGraphic(std::move(rGraphic.mxImpGraphic))
 177 {
 178 }
 179
 180 Graphic::Graphic(std::shared_ptr<GfxLink> const & rGfxLink, sal_Int32 nPageIndex)
 181     : mxImpGraphic(vcl::graphic::Manager::get().newInstance(rGfxLink, nPageIndex))
 182 {
 183 }
 184
 185 Graphic::Graphic(GraphicExternalLink const & rGraphicExternalLink)
 186     : mxImpGraphic(vcl::graphic::Manager::get().newInstance(rGraphicExternalLink))
 187 {
 188 }
 189
 190 Graphic::Graphic(const BitmapEx& rBmpEx)
 191     : mxImpGraphic(vcl::graphic::Manager::get().newInstance(rBmpEx))
 192 {
 193 }
 194
 195 // We use XGraphic for passing toolbar images across app UNO aps
 196 // and we need to be able to see and preserve 'stock' images too.
 197 Graphic::Graphic(const Image& rImage)
 198     // FIXME: should really defer the BitmapEx load.
 199     : mxImpGraphic(std::make_shared<ImpGraphic>(rImage.GetBitmapEx()))
 200 {
 201     OUString aStock = rImage.GetStock();
 202     if (aStock.getLength())
 203         mxImpGraphic->setOriginURL("private:graphicrepository/" + aStock);
 204 }
 205
 206 Graphic::Graphic(const std::shared_ptr<VectorGraphicData>& rVectorGraphicDataPtr)
 207     : mxImpGraphic(vcl::graphic::Manager::get().newInstance(rVectorGraphicDataPtr))
 208 {
 209 }
 210
 211 Graphic::Graphic(const Animation& rAnimation)
 212     : mxImpGraphic(vcl::graphic::Manager::get().newInstance(rAnimation))
 213 {
 214 }
 215
 216 Graphic::Graphic(const GDIMetaFile& rMtf)
 217     : mxImpGraphic(vcl::graphic::Manager::get().newInstance(rMtf))
 218 {
 219 }
 220
 221 Graphic::Graphic( const css::uno::Reference< css::graphic::XGraphic >& rxGraphic )
 222 {
 223     const ::Graphic* pGraphic = comphelper::getUnoTunnelImplementation<::Graphic>(rxGraphic);
 224
 225     if( pGraphic )
 226     {
 227         if (pGraphic->IsAnimated())
 228             mxImpGraphic = vcl::graphic::Manager::get().copy(pGraphic->mxImpGraphic);
 229         else
 230             mxImpGraphic = pGraphic->mxImpGraphic;
 231     }
 232     else
 233         mxImpGraphic = vcl::graphic::Manager::get().newInstance();
 234 }
 235
 236 void Graphic::ImplTestRefCount()
 237 {
 238     if (mxImpGraphic.use_count() > 1)
 239     {
 240         mxImpGraphic = vcl::graphic::Manager::get().copy(mxImpGraphic);
 241     }
 242 }
 243
 244 bool Graphic::isAvailable() const
 245 {
 246     return mxImpGraphic->isAvailable();
 247 }
 248
 249 bool Graphic::makeAvailable()
 250 {
 251     return mxImpGraphic->makeAvailable();
 252 }
 253
 254 Graphic& Graphic::operator=( const Graphic& rGraphic )
 255 {
 256     if( &rGraphic != this )
 257     {
 258         if( rGraphic.IsAnimated() )
 259             mxImpGraphic = vcl::graphic::Manager::get().copy(rGraphic.mxImpGraphic);
 260         else
 261             mxImpGraphic = rGraphic.mxImpGraphic;
 262     }
 263
 264     return *this;
 265 }
 266
 267 Graphic& Graphic::operator=(Graphic&& rGraphic) noexcept
 268 {
 269     mxImpGraphic = std::move(rGraphic.mxImpGraphic);
 270     return *this;
 271 }
 272
 273 bool Graphic::operator==( const Graphic& rGraphic ) const
 274 {
 275     return (*mxImpGraphic == *rGraphic.mxImpGraphic);
 276 }
 277
 278 bool Graphic::operator!=( const Graphic& rGraphic ) const
 279 {
 280     return (*mxImpGraphic != *rGraphic.mxImpGraphic);
 281 }
 282
 283 bool Graphic::IsNone() const
 284 {
 285     return GraphicType::NONE == mxImpGraphic->getType();
 286 }
 287
 288 void Graphic::Clear()
 289 {
 290     ImplTestRefCount();
 291     mxImpGraphic->clear();
 292 }
 293
 294 GraphicType Graphic::GetType() const
 295 {
 296     return mxImpGraphic->getType();
 297 }
 298
 299 void Graphic::SetDefaultType()
 300 {
 301     ImplTestRefCount();
 302     mxImpGraphic->setDefaultType();
 303 }
 304
 305 bool Graphic::IsSupportedGraphic() const
 306 {
 307     return mxImpGraphic->isSupportedGraphic();
 308 }
 309
 310 bool Graphic::IsTransparent() const
 311 {
 312     return mxImpGraphic->isTransparent();
 313 }
 314
 315 bool Graphic::IsAlpha() const
 316 {
 317     return mxImpGraphic->isAlpha();
 318 }
 319
 320 bool Graphic::IsAnimated() const
 321 {
 322     return mxImpGraphic->isAnimated();
 323 }
 324
 325 bool Graphic::IsEPS() const
 326 {
 327     return mxImpGraphic->isEPS();
 328 }
 329
 330 BitmapEx Graphic::GetBitmapEx(const GraphicConversionParameters& rParameters) const
 331 {
 332     return mxImpGraphic->getBitmapEx(rParameters);
 333 }
 334
 335 Animation Graphic::GetAnimation() const
 336 {
 337     return mxImpGraphic->getAnimation();
 338 }
 339
 340 const GDIMetaFile& Graphic::GetGDIMetaFile() const
 341 {
 342     return mxImpGraphic->getGDIMetaFile();
 343 }
 344
 345 const BitmapEx& Graphic::GetBitmapExRef() const
 346 {
 347     return mxImpGraphic->getBitmapExRef();
 348 }
 349
 350 uno::Reference<graphic::XGraphic> Graphic::GetXGraphic() const
 351 {
 352     uno::Reference<graphic::XGraphic> xGraphic;
 353
 354     if (GetType() != GraphicType::NONE)
 355     {
 356         rtl::Reference<unographic::Graphic> pUnoGraphic = new unographic::Graphic;
 357         pUnoGraphic->init(*this);
 358         xGraphic = pUnoGraphic;
 359     }
 360
 361     return xGraphic;
 362 }
 363
 364 Size Graphic::GetPrefSize() const
 365 {
 366     return mxImpGraphic->getPrefSize();
 367 }
 368
 369 void Graphic::SetPrefSize( const Size& rPrefSize )
 370 {
 371     ImplTestRefCount();
 372     mxImpGraphic->setPrefSize( rPrefSize );
 373 }
 374
 375 MapMode Graphic::GetPrefMapMode() const
 376 {
 377     return mxImpGraphic->getPrefMapMode();
 378 }
 379
 380 void Graphic::SetPrefMapMode( const MapMode& rPrefMapMode )
 381 {
 382     ImplTestRefCount();
 383     mxImpGraphic->setPrefMapMode( rPrefMapMode );
 384 }
 385
 386 basegfx::B2DSize Graphic::GetPPI() const
 387 {
 388     double nGrfDPIx;
 389     double nGrfDPIy;
 390
 391     const MapMode aGrfMap(GetPrefMapMode());
 392     const Size aGrfPixelSize(GetSizePixel());
 393     const Size aGrfPrefMapModeSize(GetPrefSize());
 394     if (aGrfMap.GetMapUnit() == MapUnit::MapInch)
 395     {
 396         nGrfDPIx = aGrfPixelSize.Width() / ( static_cast<double>(aGrfMap.GetScaleX()) * aGrfPrefMapModeSize.Width() );
 397         nGrfDPIy = aGrfPixelSize.Height() / ( static_cast<double>(aGrfMap.GetScaleY()) * aGrfPrefMapModeSize.Height() );
 398     }
 399     else
 400     {
 401         const Size aGrf1000thInchSize = OutputDevice::LogicToLogic(
 402                 aGrfPrefMapModeSize, aGrfMap, MapMode(MapUnit::Map1000thInch));
 403         nGrfDPIx = 1000.0 * aGrfPixelSize.Width() / aGrf1000thInchSize.Width();
 404         nGrfDPIy = 1000.0 * aGrfPixelSize.Height() / aGrf1000thInchSize.Height();
 405     }
 406
 407     return basegfx::B2DSize(nGrfDPIx, nGrfDPIy);
 408 }
 409
 410 Size Graphic::GetSizePixel( const OutputDevice* pRefDevice ) const
 411 {
 412     Size aRet;
 413
 414     if( GraphicType::Bitmap == mxImpGraphic->getType() )
 415         aRet = mxImpGraphic->getSizePixel();
 416     else
 417         aRet = ( pRefDevice ? pRefDevice : Application::GetDefaultDevice() )->LogicToPixel( GetPrefSize(), GetPrefMapMode() );
 418
 419     return aRet;
 420 }
 421
 422 sal_uLong Graphic::GetSizeBytes() const
 423 {
 424     return mxImpGraphic->getSizeBytes();
 425 }
 426
 427 void Graphic::Draw(OutputDevice& rOutDev, const Point& rDestPt) const
 428 {
 429     mxImpGraphic->draw(rOutDev, rDestPt);
 430 }
 431
 432 void Graphic::Draw(OutputDevice& rOutDev, const Point& rDestPt,
 433                    const Size& rDestSz) const
 434 {
 435     if( GraphicType::Default == mxImpGraphic->getType() )
 436         ImplDrawDefault(rOutDev, nullptr, nullptr, nullptr, rDestPt, rDestSz);
 437     else
 438         mxImpGraphic->draw(rOutDev, rDestPt, rDestSz);
 439 }
 440
 441 void Graphic::DrawEx(OutputDevice& rOutDev, const OUString& rText,
 442                      vcl::Font& rFont, const BitmapEx& rBitmap,
 443                      const Point& rDestPt, const Size& rDestSz)
 444 {
 445     ImplDrawDefault(rOutDev, &rText, &rFont, &rBitmap, rDestPt, rDestSz);
 446 }
 447
 448 void Graphic::StartAnimation(OutputDevice& rOutDev, const Point& rDestPt,
 449                              const Size& rDestSz, tools::Long nExtraData,
 450                              OutputDevice* pFirstFrameOutDev)
 451 {
 452     ImplTestRefCount();
 453     mxImpGraphic->startAnimation(rOutDev, rDestPt, rDestSz, nExtraData, pFirstFrameOutDev);
 454 }
 455
 456 void Graphic::StopAnimation( const OutputDevice* pOutDev, tools::Long nExtraData )
 457 {
 458     ImplTestRefCount();
 459     mxImpGraphic->stopAnimation( pOutDev, nExtraData );
 460 }
 461
 462 void Graphic::SetAnimationNotifyHdl( const Link<Animation*,void>& rLink )
 463 {
 464     mxImpGraphic->setAnimationNotifyHdl( rLink );
 465 }
 466
 467 Link<Animation*,void> Graphic::GetAnimationNotifyHdl() const
 468 {
 469     return mxImpGraphic->getAnimationNotifyHdl();
 470 }
 471
 472 sal_uInt32 Graphic::GetAnimationLoopCount() const
 473 {
 474     return mxImpGraphic->getAnimationLoopCount();
 475 }
 476
 477 std::shared_ptr<GraphicReader>& Graphic::GetReaderContext()
 478 {
 479     return mxImpGraphic->getContext();
 480 }
 481
 482 void Graphic::SetReaderContext( const std::shared_ptr<GraphicReader> &pReader )
 483 {
 484     mxImpGraphic->setContext( pReader );
 485 }
 486
 487 void Graphic::SetDummyContext( bool value )
 488 {
 489     mxImpGraphic->setDummyContext( value );
 490 }
 491
 492 bool Graphic::IsDummyContext() const
 493 {
 494     return mxImpGraphic->isDummyContext();
 495 }
 496
 497 void Graphic::SetGfxLink( const std::shared_ptr<GfxLink>& rGfxLink )
 498 {
 499     ImplTestRefCount();
 500     mxImpGraphic->setGfxLink(rGfxLink);
 501 }
 502
 503 const std::shared_ptr<GfxLink> & Graphic::GetSharedGfxLink() const
 504 {
 505     return mxImpGraphic->getSharedGfxLink();
 506 }
 507
 508 GfxLink Graphic::GetGfxLink() const
 509 {
 510     return mxImpGraphic->getGfxLink();
 511 }
 512
 513 bool Graphic::IsGfxLink() const
 514 {
 515     return mxImpGraphic->isGfxLink();
 516 }
 517
 518 BitmapChecksum Graphic::GetChecksum() const
 519 {
 520     return mxImpGraphic->getChecksum();
 521 }
 522
 523 const std::shared_ptr<VectorGraphicData>& Graphic::getVectorGraphicData() const
 524 {
 525     return mxImpGraphic->getVectorGraphicData();
 526 }
 527
 528 sal_Int32 Graphic::getPageNumber() const
 529 {
 530     return mxImpGraphic->getPageNumber();
 531 }
 532
 533 OUString Graphic::getOriginURL() const
 534 {
 535     if (mxImpGraphic)
 536     {
 537         return mxImpGraphic->getOriginURL();
 538     }
 539     return OUString();
 540 }
 541
 542 void Graphic::setOriginURL(OUString const & rOriginURL)
 543 {
 544     if (mxImpGraphic)
 545     {
 546         mxImpGraphic->setOriginURL(rOriginURL);
 547     }
 548 }
 549
 550 OString Graphic::getUniqueID() const
 551 {
 552     OString aUniqueString;
 553     if (mxImpGraphic)
 554         aUniqueString = mxImpGraphic->getUniqueID();
 555     return aUniqueString;
 556 }
 557
 558 namespace {
 559
 560 struct Id: public rtl::Static<cppu::OImplementationId, Id> {};
 561
 562 }
 563
 564 css::uno::Sequence<sal_Int8> Graphic::getUnoTunnelId() {
 565     return Id::get().getImplementationId();
 566 }
 567
 568 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */