/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 192, column 9 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name spritecanvashelper.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/canvas/inc -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx

/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <sal/config.h>
21#include <sal/log.hxx>

23#include <boost/cast.hpp>

25#include <basegfx/range/b2drectangle.hxx>
26#include <rtl/math.hxx>
27#include <tools/diagnose_ex.h>
28#include <vcl/canvastools.hxx>
29#include <vcl/outdev.hxx>
30#include <vcl/window.hxx>

32#include <canvas/canvastools.hxx>

34#include "canvascustomsprite.hxx"
35#include "spritecanvashelper.hxx"
36#include "spritecanvas.hxx"

38using namespace ::com::sun::star;

40#define FPS_BOUNDS::tools::Rectangle(0,0,130,90) ::tools::Rectangle(0,0,130,90)
41#define INFO_COLORCOL_RED COL_RED

43namespace vclcanvas
44{
  namespace
  {
      /** Sprite redraw at original position

          Used to repaint the whole canvas (background and all
          sprites)
       */
      void spriteRedraw( OutputDevice&                      rOutDev,
                         const ::canvas::Sprite::Reference& rSprite )
      {
          // downcast to derived vclcanvas::Sprite interface, which
          // provides the actual redraw methods.
          ::boost::polymorphic_downcast< Sprite* >(rSprite.get())->redraw(rOutDev,
                                                                          true);
      }

      double calcNumPixel( const ::canvas::Sprite::Reference& rSprite )
      {
          const ::basegfx::B2DSize& rSize(
              ::boost::polymorphic_downcast< Sprite* >(rSprite.get())->getSizePixel() );

          return rSize.getX() * rSize.getY();
      }

      void repaintBackground( OutputDevice&               rOutDev,
                              OutputDevice const &        rBackBuffer,
                              const ::basegfx::B2DRange&  rArea )
      {
          const ::Point& rPos( vcl::unotools::pointFromB2DPoint( rArea.getMinimum()) );
          const ::Size& rSize( vcl::unotools::sizeFromB2DSize( rArea.getRange()) );

          rOutDev.DrawOutDev( rPos, rSize, rPos, rSize, rBackBuffer );
      }

      void opaqueUpdateSpriteArea( const ::canvas::Sprite::Reference& rSprite,
                                   OutputDevice&                      rOutDev,
                                   const ::basegfx::B2IRange&         rArea )
      {
          const ::tools::Rectangle& rRequestedArea(
              vcl::unotools::rectangleFromB2IRectangle( rArea ) );

          // clip output to actual update region (otherwise a)
          // wouldn't save much render time, and b) will clutter
          // scrolled sprite content outside this area)
          rOutDev.EnableMapMode( false );
          rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
          rOutDev.SetClipRegion(vcl::Region(rRequestedArea));

          // repaint affected sprite directly to output device (at
          // the actual screen output position)
          ::boost::polymorphic_downcast< Sprite* >(
              rSprite.get() )->redraw( rOutDev,
                                       false ); // rendering
                                                // directly to
                                                // frontbuffer
      }

      void renderInfoText( OutputDevice&          rOutDev,
                           const OUString& rStr,
                           const Point&           rPos )
      {
          vcl::Font aVCLFont;
          aVCLFont.SetFontHeight( 20 );
          aVCLFont.SetColor( INFO_COLORCOL_RED );

          rOutDev.SetTextAlign(ALIGN_TOP);
          rOutDev.SetTextColor( INFO_COLORCOL_RED );
          rOutDev.SetFont( aVCLFont );

          rOutDev.DrawText( rPos, rStr );
      }

  }

  SpriteCanvasHelper::SpriteCanvasHelper() :
      mpRedrawManager( nullptr ),
      mpOwningSpriteCanvas( nullptr ),
      maVDev(VclPtr<VirtualDevice>::Create()),
      maLastUpdate(),
      mbShowFrameInfo( false ),
      mbShowSpriteBounds( false ),
      mbIsUnsafeScrolling( false )
  {
128#if OSL_DEBUG_LEVEL1 > 0
      // inverse defaults for verbose debug mode
      mbShowFrameInfo = true;
      // this looks like drawing errors, enable only if explicitly asked for
      static bool enableShowSpriteBounds = getenv("CANVAS_SPRITE_BOUNDS") != nullptr;
      mbShowSpriteBounds = enableShowSpriteBounds;
134#endif
  }

  SpriteCanvasHelper::~SpriteCanvasHelper()
  {
      SolarMutexGuard aGuard;
      maVDev.disposeAndClear();
1
Calling 'VclPtr::disposeAndClear'→
  }

  void SpriteCanvasHelper::init( const OutDevProviderSharedPtr& rOutDev,
                                 SpriteCanvas&                  rOwningSpriteCanvas,
                                 ::canvas::SpriteRedrawManager& rManager,
                                 bool                           bProtect,
                                 bool                           bHaveAlpha )
  {
      mpOwningSpriteCanvas = &rOwningSpriteCanvas;
      mpRedrawManager = &rManager;

      CanvasHelper::init(rOwningSpriteCanvas,rOutDev,bProtect,bHaveAlpha);
  }

  void SpriteCanvasHelper::disposing()
  {
      mpRedrawManager = nullptr;
      mpOwningSpriteCanvas = nullptr;

      // forward to base
      CanvasHelper::disposing();
  }

  uno::Reference< rendering::XAnimatedSprite > SpriteCanvasHelper::createSpriteFromAnimation(
      const uno::Reference< rendering::XAnimation >&  )
  {
      return uno::Reference< rendering::XAnimatedSprite >();
  }

  uno::Reference< rendering::XAnimatedSprite > SpriteCanvasHelper::createSpriteFromBitmaps(
      const uno::Sequence< uno::Reference< rendering::XBitmap > >& ,
      sal_Int8                                                      )
  {
      return uno::Reference< rendering::XAnimatedSprite >();
  }

  uno::Reference< rendering::XCustomSprite > SpriteCanvasHelper::createCustomSprite( const geometry::RealSize2D& spriteSize )
  {
      if( !mpRedrawManager || !mpDevice )
          return uno::Reference< rendering::XCustomSprite >(); // we're disposed

      return uno::Reference< rendering::XCustomSprite >(
          new CanvasCustomSprite( spriteSize,
                                  *mpDevice,
                                  mpOwningSpriteCanvas,
                                  mpOwningSpriteCanvas->getFrontBuffer(),
                                  mbShowSpriteBounds ) );
  }

  uno::Reference< rendering::XSprite > SpriteCanvasHelper::createClonedSprite( const uno::Reference< rendering::XSprite >&  )
  {
      return uno::Reference< rendering::XSprite >();
  }

  bool SpriteCanvasHelper::updateScreen( bool bUpdateAll,
                                         bool&    io_bSurfaceDirty )
  {
      if( !mpRedrawManager ||
          !mpOwningSpriteCanvas ||
          !mpOwningSpriteCanvas->getFrontBuffer() ||
          !mpOwningSpriteCanvas->getBackBuffer() )
      {
          return false; // disposed, or otherwise dysfunctional
      }

      // commit to backbuffer
      flush();

      OutputDevice&       rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() );
      BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() );
      OutputDevice&       rBackOutDev( pBackBuffer->getOutDev() );

      // actual OutputDevice is a shared resource - restore its
      // state when done.
      tools::OutDevStateKeeper aStateKeeper( rOutDev );

      const Size  aOutDevSize( rBackOutDev.GetOutputSizePixel() );
      const Point aEmptyPoint(0,0);

      vcl::Window* pTargetWindow = nullptr;
      if( rOutDev.GetOutDevType() == OUTDEV_WINDOW )
      {
          pTargetWindow = &static_cast<vcl::Window&>(rOutDev); // TODO(Q3): Evil downcast.

          // we're double-buffered, thus no need for paint area-limiting
          // clips. besides that, will interfere with animations (as for
          // Window-invalidate repaints, only parts of the window will
          // be redrawn otherwise)
          const vcl::Region aFullWindowRegion( ::tools::Rectangle(aEmptyPoint,
                                                    aOutDevSize) );
          pTargetWindow->ExpandPaintClipRegion(aFullWindowRegion);
      }

      // TODO(P1): Might be worthwhile to track areas of background
      // changes, too.
      if( !bUpdateAll && !io_bSurfaceDirty )
      {
          if( mbShowFrameInfo )
          {
              // also repaint background below frame counter (fake
              // that as a sprite vanishing in this area)
              mpRedrawManager->updateSprite( ::canvas::Sprite::Reference(),
                                             ::basegfx::B2DPoint(),
                                             ::basegfx::B2DRectangle( 0.0, 0.0,
                                                                      FPS_BOUNDS::tools::Rectangle(0,0,130,90).Right(),
                                                                      FPS_BOUNDS::tools::Rectangle(0,0,130,90).Bottom() ) );
          }

          // background has not changed, so we're free to optimize
          // repaint to areas where a sprite has changed

          // process each independent area of overlapping sprites
          // separately.
          mpRedrawManager->forEachSpriteArea( *this );
      }
      else
      {
          // background has changed, so we currently have no choice
          // but repaint everything (or caller requested that)

          maVDev->SetOutputSizePixel( aOutDevSize );
          maVDev->EnableMapMode( false );
          maVDev->DrawOutDev( aEmptyPoint, aOutDevSize,
                              aEmptyPoint, aOutDevSize,
                              rBackOutDev );

          // repaint all active sprites on top of background into
          // VDev.
          OutputDevice& rTmpOutDev( *maVDev );
          mpRedrawManager->forEachSprite(
                  [&rTmpOutDev]( const ::canvas::Sprite::Reference& rSprite )
                  { spriteRedraw( rTmpOutDev, rSprite ); }
                  );

          // flush to screen
          rOutDev.EnableMapMode( false );
          rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
          rOutDev.SetClipRegion();
          rOutDev.DrawOutDev( aEmptyPoint, aOutDevSize,
                              aEmptyPoint, aOutDevSize,
                              *maVDev );
      }

      // change record vector must be cleared, for the next turn of
      // rendering and sprite changing
      mpRedrawManager->clearChangeRecords();

      io_bSurfaceDirty = false;

      if( mbShowFrameInfo )
      {
          renderFrameCounter( rOutDev );
          renderSpriteCount( rOutDev );
          renderMemUsage( rOutDev );
      }

297#if OSL_DEBUG_LEVEL1 > 0
      static ::canvas::tools::ElapsedTime aElapsedTime;

      // log time immediately after surface flip
      SAL_INFO("canvas.vcl", "SpriteCanvasHelper::updateScreen(): flip done at " <<do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "canvas.vcl")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime(); ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime(); ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false)
                 aElapsedTime.getElapsedTime() )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "canvas.vcl")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime(); ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime()), 0); } else { ::std::
ostringstream sal_detail_stream; sal_detail_stream << "SpriteCanvasHelper::updateScreen(): flip done at "
 << aElapsedTime.getElapsedTime(); ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("canvas.vcl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "302" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
303#endif

      // sync output with screen, to ensure that we don't queue up
      // render requests (calling code might rely on timing,
      // i.e. assume that things are visible on screen after
      // updateScreen() returns).
      if( pTargetWindow )
      {
          // commit to screen
          pTargetWindow->Flush();
      }

      return true;
  }

  void SpriteCanvasHelper::backgroundPaint( const ::basegfx::B2DRange& rUpdateRect )
  {
      ENSURE_OR_THROW( mpOwningSpriteCanvas &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "323" ": "), "%s", "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getBackBuffer() &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "323" ": "), "%s", "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getFrontBuffer(),if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "323" ": "), "%s", "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       "SpriteCanvasHelper::backgroundPaint(): NULL device pointer " )if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "323" ": "), "%s", "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::backgroundPaint(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); };

      OutputDevice&       rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() );
      BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() );
      OutputDevice&       rBackOutDev( pBackBuffer->getOutDev() );

      repaintBackground( rOutDev, rBackOutDev, rUpdateRect );
  }

  void SpriteCanvasHelper::scrollUpdate( const ::basegfx::B2DRange&                       rMoveStart,
                                         const ::basegfx::B2DRange&                       rMoveEnd,
                                         const ::canvas::SpriteRedrawManager::UpdateArea& rUpdateArea )
  {
      ENSURE_OR_THROW( mpOwningSpriteCanvas &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "339" ": "), "%s", "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getBackBuffer() &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "339" ": "), "%s", "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getFrontBuffer(),if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "339" ": "), "%s", "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       "SpriteCanvasHelper::scrollUpdate(): NULL device pointer " )if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "339" ": "), "%s", "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::scrollUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); };

      OutputDevice&       rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() );
      BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() );
      OutputDevice&       rBackOutDev( pBackBuffer->getOutDev() );

      const Size&                rTargetSizePixel( rOutDev.GetOutputSizePixel() );
      const ::basegfx::B2IRange  aOutputBounds( 0,0,
                                                rTargetSizePixel.Width(),
                                                rTargetSizePixel.Height() );

      // round rectangles to integer pixel. Note: have to be
      // extremely careful here, to avoid off-by-one errors for
      // the destination area: otherwise, the next scroll update
      // would copy pixel that are not supposed to be part of
      // the sprite.
      ::basegfx::B2IRange aSourceRect(
          ::canvas::tools::spritePixelAreaFromB2DRange( rMoveStart ) );
      const ::basegfx::B2IRange& rDestRect(
          ::canvas::tools::spritePixelAreaFromB2DRange( rMoveEnd ) );
      ::basegfx::B2IPoint aDestPos( rDestRect.getMinimum() );

      std::vector< ::basegfx::B2IRange > aUnscrollableAreas;

      // Since strictly speaking, this scroll algorithm is plain
      // buggy, the scrolled area might actually lie _below_ another
      // window - we've made this feature configurable via
      // mbIsUnsafeScrolling.

      // clip to output bounds (cannot properly scroll stuff
      // _outside_ our screen area)
      if( !mbIsUnsafeScrolling ||
          !::canvas::tools::clipScrollArea( aSourceRect,
                                            aDestPos,
                                            aUnscrollableAreas,
                                            aOutputBounds ) )
      {
          // fully clipped scroll area: cannot simply scroll
          // then. Perform normal opaque update (can use that, since
          // one of the preconditions for scrollable update is
          // opaque sprite content)

          // repaint all affected sprites directly to output device
          for( const auto& rComponent : rUpdateArea.maComponentList )
          {
              const ::canvas::Sprite::Reference& rSprite( rComponent.second.getSprite() );

              if( rSprite.is() )
                  ::boost::polymorphic_downcast< Sprite* >(
                      rSprite.get() )->redraw( rOutDev,
                                               false );
          }
      }
      else
      {
          // scroll rOutDev content
          rOutDev.CopyArea( vcl::unotools::pointFromB2IPoint( aDestPos ),
                            vcl::unotools::pointFromB2IPoint( aSourceRect.getMinimum() ),
                            // TODO(Q2): use numeric_cast to check range
                            ::Size( static_cast<sal_Int32>(aSourceRect.getRange().getX()),
                                    static_cast<sal_Int32>(aSourceRect.getRange().getY()) ) );

          const ::canvas::SpriteRedrawManager::SpriteConnectedRanges::ComponentListType::const_iterator
              aFirst( rUpdateArea.maComponentList.begin() );

          ENSURE_OR_THROW( aFirst->second.getSprite().is(),if( !(aFirst->second.getSprite().is()) ){ do { if (true &&
 (!(aFirst->second.getSprite().is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "405" ": "), "%s", "VCLCanvas::scrollUpdate(): no sprite"
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "VCLCanvas::scrollUpdate(): no sprite"
), css::uno::Reference< css::uno::XInterface >() ); }
                            "VCLCanvas::scrollUpdate(): no sprite" )if( !(aFirst->second.getSprite().is()) ){ do { if (true &&
 (!(aFirst->second.getSprite().is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "405" ": "), "%s", "VCLCanvas::scrollUpdate(): no sprite"
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "VCLCanvas::scrollUpdate(): no sprite"
), css::uno::Reference< css::uno::XInterface >() ); };

          // repaint uncovered areas from sprite. Need to actually
          // clip here, since we're only repainting _parts_ of the
          // sprite
          rOutDev.Push( PushFlags::CLIPREGION );

          for( const auto& rArea : aUnscrollableAreas )
              opaqueUpdateSpriteArea( aFirst->second.getSprite(),
                                      rOutDev, rArea );

          rOutDev.Pop();
      }

      // repaint uncovered areas from backbuffer - take the
      // _rounded_ rectangles from above, to have the update
      // consistent with the scroll above.
      std::vector< ::basegfx::B2DRange > aUncoveredAreas;
      ::basegfx::computeSetDifference( aUncoveredAreas,
                                       rUpdateArea.maTotalBounds,
                                       ::basegfx::B2DRange( rDestRect ) );

      for( const auto& rArea : aUncoveredAreas )
          repaintBackground( rOutDev, rBackOutDev, rArea );
  }

  void SpriteCanvasHelper::opaqueUpdate( SAL_UNUSED_PARAMETER__attribute__ ((unused)) const ::basegfx::B2DRange&,
                                         const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
  {
      ENSURE_OR_THROW( mpOwningSpriteCanvas &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "437" ": "), "%s", "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getBackBuffer() &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "437" ": "), "%s", "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getFrontBuffer(),if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "437" ": "), "%s", "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer " )if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "437" ": "), "%s", "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::opaqueUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); };

      OutputDevice& rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() );

      // no need to clip output to actual update region - there will
      // always be ALL sprites contained in the rectangular update
      // area contained in rTotalArea (that's the way
      // B2DConnectedRanges work). If rTotalArea appears to be
      // smaller than the sprite - then this sprite carries a clip,
      // and the update will be constrained to that rect.

      // repaint all affected sprites directly to output device
      for( const auto& rSprite : rSortedUpdateSprites )
      {
          if( rSprite.is() )
              ::boost::polymorphic_downcast< Sprite* >(
                  rSprite.get() )->redraw( rOutDev,
                                           false );
      }
  }

  void SpriteCanvasHelper::genericUpdate( const ::basegfx::B2DRange&                          rRequestedArea,
                                          const std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites )
  {
      ENSURE_OR_THROW( mpOwningSpriteCanvas &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "464" ": "), "%s", "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getBackBuffer() &&if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "464" ": "), "%s", "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       mpOwningSpriteCanvas->getFrontBuffer(),if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "464" ": "), "%s", "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); }
                       "SpriteCanvasHelper::genericUpdate(): NULL device pointer " )if( !(mpOwningSpriteCanvas && mpOwningSpriteCanvas->
getBackBuffer() && mpOwningSpriteCanvas->getFrontBuffer
()) ){ do { if (true && (!(mpOwningSpriteCanvas &&
 mpOwningSpriteCanvas->getBackBuffer() && mpOwningSpriteCanvas
->getFrontBuffer()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/canvas/source/vcl/spritecanvashelper.cxx"
 ":" "464" ": "), "%s", "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
); } } while (false); throw css::uno::RuntimeException( __func__
 + OUStringLiteral(u",\n" "SpriteCanvasHelper::genericUpdate(): NULL device pointer "
), css::uno::Reference< css::uno::XInterface >() ); };

      OutputDevice&       rOutDev( mpOwningSpriteCanvas->getFrontBuffer()->getOutDev() );
      BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() );
      OutputDevice&       rBackOutDev( pBackBuffer->getOutDev() );

      // limit size of update VDev to target outdev's size
      const Size& rTargetSizePixel( rOutDev.GetOutputSizePixel() );

      // round output position towards zero. Don't want to truncate
      // a fraction of a sprite pixel...  Clip position at origin,
      // otherwise, truncation of size below might leave visible
      // areas uncovered by VDev.
      const ::Point aOutputPosition(
          std::max( sal_Int32( 0 ),
                      static_cast< sal_Int32 >(rRequestedArea.getMinX()) ),
          std::max( sal_Int32( 0 ),
                      static_cast< sal_Int32 >(rRequestedArea.getMinY()) ) );
      // round output size towards +infty. Don't want to truncate a
      // fraction of a sprite pixel... Limit coverage of VDev to
      // output device's area (i.e. not only to total size, but to
      // cover _only_ the visible parts).
      const ::Size aOutputSize(
          std::max( sal_Int32( 0 ),
                      std::min( static_cast< sal_Int32 >(rTargetSizePixel.Width() - aOutputPosition.X()),
                                  ::canvas::tools::roundUp( rRequestedArea.getMaxX() - aOutputPosition.X() ))),
          std::max( sal_Int32( 0 ),
                      std::min( static_cast< sal_Int32 >(rTargetSizePixel.Height() - aOutputPosition.Y()),
                                  ::canvas::tools::roundUp( rRequestedArea.getMaxY() - aOutputPosition.Y() ))));

      // early exit for empty output area.
      if( aOutputSize.Width() == 0 &&
          aOutputSize.Height() == 0 )
      {
          return;
      }

      const Point aEmptyPoint(0,0);
      const Size  aCurrOutputSize( maVDev->GetOutputSizePixel() );

      // adapt maVDev's size to the area that actually needs the
      // repaint.
      if( aCurrOutputSize.Width() < aOutputSize.Width() ||
          aCurrOutputSize.Height() < aOutputSize.Height() )
      {
          // TODO(P1): Come up with a clever tactic to reduce maVDev
          // from time to time. Reduction with threshold (say, if
          // maVDev is more than twice too large) is not wise, as
          // this might then toggle within the same updateScreen(),
          // but for different disjunct sprite areas.
          maVDev->SetOutputSizePixel( aOutputSize );
      }

      // paint background
      maVDev->EnableMapMode( false );
      maVDev->SetAntialiasing( AntialiasingFlags::Enable );
      maVDev->SetClipRegion();
      maVDev->DrawOutDev( aEmptyPoint, aOutputSize,
                          aOutputPosition, aOutputSize,
                          rBackOutDev );

      // repaint all affected sprites on top of background into
      // VDev.
      for( const auto& rSprite : rSortedUpdateSprites )
      {
          if( rSprite.is() )
          {
              Sprite* pSprite = ::boost::polymorphic_downcast< Sprite* >( rSprite.get() );

              // calc relative sprite position in rUpdateArea (which
              // need not be the whole screen!)
              const ::basegfx::B2DPoint& rSpriteScreenPos( pSprite->getPosPixel() );
              const ::basegfx::B2DPoint& rSpriteRenderPos(
                      rSpriteScreenPos - vcl::unotools::b2DPointFromPoint(aOutputPosition)
                      );

              pSprite->redraw( *maVDev, rSpriteRenderPos, true );
          }
      }

      // flush to screen
      rOutDev.EnableMapMode( false );
      rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
      rOutDev.DrawOutDev( aOutputPosition, aOutputSize,
                          aEmptyPoint, aOutputSize,
                          *maVDev );
  }

  void SpriteCanvasHelper::renderFrameCounter( OutputDevice& rOutDev )
  {
      const double denominator( maLastUpdate.getElapsedTime() );
      maLastUpdate.reset();

      OUString text( ::rtl::math::doubleToUString( denominator == 0.0 ? 100.0 : 1.0/denominator,
                                                          rtl_math_StringFormat_F,
                                                          2,'.',nullptr,' ') );

      // pad with leading space
      while( text.getLength() < 6 )
          text = " " + text;

      text += " fps";

      renderInfoText( rOutDev,
                      text,
                      Point(0, 0) );
  }

  namespace
  {
      template< typename T > struct Adder
      {
          typedef void result_type;

          Adder( T& rAdderTarget,
                 T  nIncrement ) :
              mpTarget( &rAdderTarget ),
              mnIncrement( nIncrement )
          {
          }

          void operator()( const ::canvas::Sprite::Reference& ) { *mpTarget += mnIncrement; }
          void operator()( T nIncrement ) { *mpTarget += nIncrement; }

          T* mpTarget;
          T  mnIncrement;
      };

      template< typename T> Adder<T> makeAdder( T& rAdderTarget,
                                                T  nIncrement )
      {
          return Adder<T>(rAdderTarget, nIncrement);
      }
  }

  void SpriteCanvasHelper::renderSpriteCount( OutputDevice& rOutDev )
  {
      if( !mpRedrawManager )
          return;

      sal_Int32 nCount(0);

      mpRedrawManager->forEachSprite( makeAdder(nCount,sal_Int32(1)) );
      OUString text( OUString::number(nCount) );

      // pad with leading space
      while( text.getLength() < 3 )
          text = " " + text;

      text = "Sprites: " + text;

      renderInfoText( rOutDev,
                      text,
                      Point(0, 30) );
  }

  void SpriteCanvasHelper::renderMemUsage( OutputDevice& rOutDev )
  {
      BackBufferSharedPtr pBackBuffer( mpOwningSpriteCanvas->getBackBuffer() );

      if( !(mpRedrawManager &&
          pBackBuffer) )
          return;

      double nPixel(0.0);

      // accumulate pixel count for each sprite into fCount
      mpRedrawManager->forEachSprite(
              [&nPixel]( const ::canvas::Sprite::Reference& rSprite )
              { makeAdder( nPixel, 1.0 )( calcNumPixel(rSprite) ); }
              );

      static const int NUM_VIRDEV(2);
      static const int BYTES_PER_PIXEL(3);

      const Size& rVDevSize( maVDev->GetOutputSizePixel() );
      const Size& rBackBufferSize( pBackBuffer->getOutDev().GetOutputSizePixel() );

      const double nMemUsage( nPixel * NUM_VIRDEV * BYTES_PER_PIXEL +
                              rVDevSize.Width()*rVDevSize.Height() * BYTES_PER_PIXEL +
                              rBackBufferSize.Width()*rBackBufferSize.Height() * BYTES_PER_PIXEL );

      OUString text( ::rtl::math::doubleToUString( nMemUsage / 1048576.0,
                                                          rtl_math_StringFormat_F,
                                                          2,'.',nullptr,' ') );

      // pad with leading space
      while( text.getLength() < 4 )
          text = " " + text;

      text = "Mem: " + text + "MB";

      renderInfoText( rOutDev,
                      text,
                      Point(0, 60) );
  }
660}

662/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
  }

  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
    */
  reference_type * get() const
  {
      return m_rInnerRef.get();
  }

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
2
←
Calling copy constructor for 'Reference<VirtualDevice>'→
5
←
Returning from copy constructor for 'Reference<VirtualDevice>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
6
←
Calling 'Reference::clear'→
13
←
Returning; memory was released→
      if (aTmp.get()) {
14
←
Calling 'Reference::get'→
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

442/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
3
←
Assuming field 'm_pBody' is non-null→
4
←
Taking true branch→
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody6.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
7
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
8
←
Calling 'VclReferenceBase::release'→
12
←
Returning; memory was released→
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
15
←
Use of memory after it is freed
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

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#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
9
←
Assuming the condition is true→
10
←
Taking true branch→
40            delete this;
11
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif