/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 dlgctrl.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 SVX_DLLIMPLEMENTATION -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -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/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -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/svx/source/dialog/dlgctrl.cxx

/home/maarten/src/libreoffice/core/svx/source/dialog/dlgctrl.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 <vcl/svapp.hxx>
21#include <vcl/settings.hxx>
22#include <vcl/virdev.hxx>
23#include <vcl/event.hxx>
24#include <sfx2/dialoghelper.hxx>
25#include <sfx2/weldutils.hxx>
26#include <svx/relfld.hxx>
27#include <svx/xlineit0.hxx>
28#include <svx/xtable.hxx>
29#include <svx/strings.hrc>
30#include <bitmaps.hlst>
31#include <svx/dlgctrl.hxx>
32#include <svx/dialmgr.hxx>
33#include <tools/debug.hxx>
34#include <svxpixelctlaccessiblecontext.hxx>
35#include <svtools/colorcfg.hxx>
36#include <svxrectctaccessiblecontext.hxx>
37#include <basegfx/point/b2dpoint.hxx>
38#include <basegfx/polygon/b2dpolygon.hxx>
39#include <svx/svdorect.hxx>
40#include <svx/svdmodel.hxx>
41#include <svx/svdopath.hxx>
42#include <sdr/contact/objectcontactofobjlistpainter.hxx>
43#include <svx/sdr/contact/displayinfo.hxx>
44#include <vcl/BitmapTools.hxx>

46#define OUTPUT_DRAWMODE_COLOR(DrawModeFlags::Default)       (DrawModeFlags::Default)
47#define OUTPUT_DRAWMODE_CONTRAST(DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags
::SettingsText | DrawModeFlags::SettingsGradient)    (DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient)

49using namespace ::com::sun::star;
50using namespace ::com::sun::star::uno;
51using namespace ::com::sun::star::lang;
52using namespace ::com::sun::star::accessibility;

54// Control for display and selection of the corner points and
55// mid point of an object

57BitmapEx& SvxRectCtl::GetRectBitmap()
58{
  if( !pBitmap )
      InitRectBitmap();

  return *pBitmap;
63}

65SvxRectCtl::SvxRectCtl(SvxTabPage* pPage, RectPoint eRpt, sal_uInt16 nBorder)
  : m_pPage(pPage)
  , nBorderWidth(Application::GetDefaultDevice()->LogicToPixel(Size(nBorder, 0), MapMode(MapUnit::Map100thMM)).Width())
  , eRP(eRpt)
  , eDefRP(eRpt)
  , m_nState(CTL_STATE::NONE)
  , mbCompleteDisable(false)
72{
73}

75void SvxRectCtl::SetDrawingArea(weld::DrawingArea* pDrawingArea)
76{
  CustomWidgetController::SetDrawingArea(pDrawingArea);
  Size aSize(pDrawingArea->get_approximate_digit_width() * 25,
             pDrawingArea->get_text_height() * 5);
  pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
  Resize_Impl(aSize);
82}

84void SvxRectCtl::SetControlSettings(RectPoint eRpt, sal_uInt16 nBorder)
85{
  nBorderWidth = Application::GetDefaultDevice()->LogicToPixel(Size(nBorder, 0), MapMode(MapUnit::Map100thMM)).Width();
  eDefRP = eRpt;
  Resize();
89}

91SvxRectCtl::~SvxRectCtl()
92{
  pBitmap.reset();
  pAccContext.clear();
95}

97void SvxRectCtl::Resize()
98{
  Resize_Impl(GetOutputSizePixel());
100}

102void SvxRectCtl::Resize_Impl(const Size &rSize)
103{
  aPtLT = Point( 0 + nBorderWidth,  0 + nBorderWidth );
  aPtMT = Point( rSize.Width() / 2, 0 + nBorderWidth );
  aPtRT = Point( rSize.Width() - nBorderWidth, 0 + nBorderWidth );

  aPtLM = Point( 0 + nBorderWidth,  rSize.Height() / 2 );
  aPtMM = Point( rSize.Width() / 2, rSize.Height() / 2 );
  aPtRM = Point( rSize.Width() - nBorderWidth, rSize.Height() / 2 );

  aPtLB = Point( 0 + nBorderWidth,    rSize.Height() - nBorderWidth );
  aPtMB = Point( rSize.Width() / 2,   rSize.Height() - nBorderWidth );
  aPtRB = Point( rSize.Width() - nBorderWidth, rSize.Height() - nBorderWidth );

  Reset();
  StyleUpdated();
118}

120void SvxRectCtl::InitRectBitmap()
121{
  pBitmap.reset();

  const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
  svtools::ColorConfig aColorConfig;

  pBitmap.reset(new BitmapEx(RID_SVXCTRL_RECTBTNS"svx/res/rectbtns.png"));

  // set bitmap-colors
  Color aColorAry1[7];
  Color aColorAry2[7];
  aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 );  // light-gray
  aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 );  // yellow
  aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF );  // white
  aColorAry1[3] = Color( 0x80, 0x80, 0x80 );  // dark-gray
  aColorAry1[4] = Color( 0x00, 0x00, 0x00 );  // black
  aColorAry1[5] = Color( 0x00, 0xFF, 0x00 );  // green
  aColorAry1[6] = Color( 0x00, 0x00, 0xFF );  // blue
  aColorAry2[0] = rStyles.GetDialogColor();       // background
  aColorAry2[1] = rStyles.GetWindowColor();
  aColorAry2[2] = rStyles.GetLightColor();
  aColorAry2[3] = rStyles.GetShadowColor();
  aColorAry2[4] = rStyles.GetDarkShadowColor();
  aColorAry2[5] = aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor;
  aColorAry2[6] = rStyles.GetDialogColor();

147#ifdef DBG_UTIL
  static bool     bModify = false;
  bool&           rModify = bModify;
  if( rModify )
  {
      static int      n = 0;
      static sal_uInt8    r = 0xFF;
      static sal_uInt8    g = 0x00;
      static sal_uInt8    b = 0xFF;
      int&            rn = n;
      sal_uInt8&          rr = r;
      sal_uInt8&          rg = g;
      sal_uInt8&          rb = b;
      aColorAry2[ rn ] = Color( rr, rg, rb );
  }
162#endif

  pBitmap->Replace( aColorAry1, aColorAry2, 7 );
165}

167void SvxRectCtl::StyleUpdated()
168{
  pBitmap.reset(); // forces new creating of bitmap
  CustomWidgetController::StyleUpdated();
171}

173void SvxRectCtl::InitSettings(vcl::RenderContext& rRenderContext)
174{
  svtools::ColorConfig aColorConfig;
  Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor);
  rRenderContext.SetTextColor(aTextColor);
  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  rRenderContext.SetBackground(rStyleSettings.GetWindowColor());
180}

182// The clicked rectangle (3 x 3) is determined and the parent (dialog)
183// is notified that the item was changed
184bool SvxRectCtl::MouseButtonDown(const MouseEvent& rMEvt)
185{
  // CompletelyDisabled() added to have a disabled state for SvxRectCtl
  if(!IsCompletelyDisabled())
  {
      aPtNew = GetApproxLogPtFromPixPt( rMEvt.GetPosPixel() );
      eRP = GetRPFromPoint( aPtNew );
      SetActualRP( eRP );

      if (m_pPage)
          m_pPage->PointChanged(GetDrawingArea(), eRP);
  }
  return true;
197}

199bool SvxRectCtl::KeyInput(const KeyEvent& rKeyEvt)
200{
  // CompletelyDisabled() added to have a disabled state for SvxRectCtl
  if (IsCompletelyDisabled())
      return false;

  RectPoint eNewRP = eRP;

  switch( rKeyEvt.GetKeyCode().GetCode() )
  {
      case KEY_DOWN:
      {
          if( !(m_nState & CTL_STATE::NOVERT) )
              switch( eNewRP )
              {
                  case RectPoint::LT: eNewRP = RectPoint::LM; break;
                  case RectPoint::MT: eNewRP = RectPoint::MM; break;
                  case RectPoint::RT: eNewRP = RectPoint::RM; break;
                  case RectPoint::LM: eNewRP = RectPoint::LB; break;
                  case RectPoint::MM: eNewRP = RectPoint::MB; break;
                  case RectPoint::RM: eNewRP = RectPoint::RB; break;
                  default: ; //prevent warning
              }
      }
      break;
      case KEY_UP:
      {
          if( !(m_nState & CTL_STATE::NOVERT) )
              switch( eNewRP )
              {
                  case RectPoint::LM: eNewRP = RectPoint::LT; break;
                  case RectPoint::MM: eNewRP = RectPoint::MT; break;
                  case RectPoint::RM: eNewRP = RectPoint::RT; break;
                  case RectPoint::LB: eNewRP = RectPoint::LM; break;
                  case RectPoint::MB: eNewRP = RectPoint::MM; break;
                  case RectPoint::RB: eNewRP = RectPoint::RM; break;
                  default: ; //prevent warning
              }
      }
      break;
      case KEY_LEFT:
      {
          if( !(m_nState & CTL_STATE::NOHORZ) )
              switch( eNewRP )
              {
                  case RectPoint::MT: eNewRP = RectPoint::LT; break;
                  case RectPoint::RT: eNewRP = RectPoint::MT; break;
                  case RectPoint::MM: eNewRP = RectPoint::LM; break;
                  case RectPoint::RM: eNewRP = RectPoint::MM; break;
                  case RectPoint::MB: eNewRP = RectPoint::LB; break;
                  case RectPoint::RB: eNewRP = RectPoint::MB; break;
                  default: ; //prevent warning
              }
      }
      break;
      case KEY_RIGHT:
      {
          if( !(m_nState & CTL_STATE::NOHORZ) )
              switch( eNewRP )
              {
                  case RectPoint::LT: eNewRP = RectPoint::MT; break;
                  case RectPoint::MT: eNewRP = RectPoint::RT; break;
                  case RectPoint::LM: eNewRP = RectPoint::MM; break;
                  case RectPoint::MM: eNewRP = RectPoint::RM; break;
                  case RectPoint::LB: eNewRP = RectPoint::MB; break;
                  case RectPoint::MB: eNewRP = RectPoint::RB; break;
                  default: ; //prevent warning
              }
      }
      break;
      default:
          return false;
  }
  if( eNewRP != eRP )
  {
      SetActualRP( eNewRP );

      if (m_pPage)
          m_pPage->PointChanged(GetDrawingArea(), eRP);
  }
  return true;
280}

282// the control (rectangle with 9 circles)
283void SvxRectCtl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
284{
  InitSettings(rRenderContext);

  Point aPtDiff(1, 1);

  const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();

  rRenderContext.SetLineColor(rStyles.GetDialogColor());
  rRenderContext.SetFillColor(rStyles.GetDialogColor());
  rRenderContext.DrawRect(tools::Rectangle(Point(0,0), rRenderContext.GetOutputSize()));

  if (IsEnabled())
      rRenderContext.SetLineColor(rStyles.GetLabelTextColor());
  else
      rRenderContext.SetLineColor(rStyles.GetShadowColor());

  rRenderContext.SetFillColor();

  if (!IsEnabled())
  {
      Color aOldCol = rRenderContext.GetLineColor();
      rRenderContext.SetLineColor(rStyles.GetLightColor());
      rRenderContext.DrawRect(tools::Rectangle(aPtLT + aPtDiff, aPtRB + aPtDiff));
      rRenderContext.SetLineColor(aOldCol);
  }
  rRenderContext.DrawRect(tools::Rectangle(aPtLT, aPtRB));

  rRenderContext.SetFillColor(rRenderContext.GetBackground().GetColor());

  Size aBtnSize(11, 11);
  Size aDstBtnSize(aBtnSize);
  Point aToCenter(aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1);
  Point aBtnPnt1(IsEnabled() ? 0 : 22, 0);
  Point aBtnPnt2(11, 0);
  Point aBtnPnt3(22, 0);

  bool bNoHorz = bool(m_nState & CTL_STATE::NOHORZ);
  bool bNoVert = bool(m_nState & CTL_STATE::NOVERT);

  BitmapEx& rBitmap = GetRectBitmap();

  // CompletelyDisabled() added to have a disabled state for SvxRectCtl
  if (IsCompletelyDisabled())
  {
      rRenderContext.DrawBitmapEx(aPtLT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtMT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtRT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtLM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtMM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtRM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtLB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtMB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtRB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap);
  }
  else
  {
      rRenderContext.DrawBitmapEx(aPtLT - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtMT - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtRT - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtLM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);

      // Center for rectangle and line
      rRenderContext.DrawBitmapEx(aPtMM - aToCenter, aDstBtnSize, aBtnPnt1, aBtnSize, rBitmap);

      rRenderContext.DrawBitmapEx(aPtRM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtLB - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtMB - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);
      rRenderContext.DrawBitmapEx(aPtRB - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap);
  }

  // draw active button, avoid center pos for angle
  // CompletelyDisabled() added to have a disabled state for SvxRectCtl
  if (!IsCompletelyDisabled())
  {
      if (IsEnabled())
      {
          Point aCenterPt(aPtNew);
          aCenterPt -= aToCenter;

          rRenderContext.DrawBitmapEx(aCenterPt, aDstBtnSize, aBtnPnt2, aBtnSize, rBitmap);
      }
  }
366}

368tools::Rectangle SvxRectCtl::GetFocusRect()
369{
  tools::Rectangle aRet;
  if (HasFocus())
      aRet = CalculateFocusRectangle();
  return aRet;
374}

376// Convert RectPoint Point

378const Point& SvxRectCtl::GetPointFromRP( RectPoint _eRP) const
379{
  switch( _eRP )
  {
      case RectPoint::LT: return aPtLT;
      case RectPoint::MT: return aPtMT;
      case RectPoint::RT: return aPtRT;
      case RectPoint::LM: return aPtLM;
      case RectPoint::MM: return aPtMM;
      case RectPoint::RM: return aPtRM;
      case RectPoint::LB: return aPtLB;
      case RectPoint::MB: return aPtMB;
      case RectPoint::RB: return aPtRB;
  }
  return aPtMM; // default
393}

395Point SvxRectCtl::SetActualRPWithoutInvalidate( RectPoint eNewRP )
396{
  Point aPtLast = aPtNew;
  aPtNew = GetPointFromRP( eNewRP );

  if( m_nState & CTL_STATE::NOHORZ )
      aPtNew.setX( aPtMM.X() );

  if( m_nState & CTL_STATE::NOVERT )
      aPtNew.setY( aPtMM.Y() );

  // fdo#74751 this fix reverse base point on RTL UI.
  bool bRTL = AllSettings::GetLayoutRTL();
  eNewRP = GetRPFromPoint( aPtNew, bRTL );

  eDefRP = eNewRP;
  eRP = eNewRP;

  return aPtLast;
414}

416void SvxRectCtl::GetFocus()
417{
  Invalidate();

  // Send accessibility event.
  if (pAccContext.is())
  {
      pAccContext->FireChildFocus(GetActualRP());
  }
425}

427void SvxRectCtl::LoseFocus()
428{
  Invalidate();
430}

432Point SvxRectCtl::GetApproxLogPtFromPixPt( const Point& rPt ) const
433{
  Point   aPt = rPt;
  long    x;
  long    y;

  Size aSize(GetOutputSizePixel());

  if( !( m_nState & CTL_STATE::NOHORZ ) )
  {
      if( aPt.X() < aSize.Width() / 3 )
          x = aPtLT.X();
      else if( aPt.X() < aSize.Width() * 2 / 3 )
          x = aPtMM.X();
      else
          x = aPtRB.X();
  }
  else
      x = aPtMM.X();

  if( !( m_nState & CTL_STATE::NOVERT ) )
  {
      if( aPt.Y() < aSize.Height() / 3 )
          y = aPtLT.Y();
      else if( aPt.Y() < aSize.Height() * 2 / 3 )
          y = aPtMM.Y();
      else
          y = aPtRB.Y();
  }
  else
          y = aPtMM.Y();

  return Point( x, y );
465}


468// Converts Point in RectPoint

470RectPoint SvxRectCtl::GetRPFromPoint( Point aPt, bool bRTL ) const
471{
  RectPoint rPoint = RectPoint::MM;  // default

  if (aPt == aPtLT) rPoint = bRTL ? RectPoint::RT : RectPoint::LT;
  else if( aPt == aPtMT) rPoint = RectPoint::MT;
  else if( aPt == aPtRT) rPoint = bRTL ? RectPoint::LT : RectPoint::RT;
  else if( aPt == aPtLM) rPoint = bRTL ? RectPoint::RM : RectPoint::LM;
  else if( aPt == aPtRM) rPoint = bRTL ? RectPoint::LM : RectPoint::RM;
  else if( aPt == aPtLB) rPoint = bRTL ? RectPoint::RB : RectPoint::LB;
  else if( aPt == aPtMB) rPoint = RectPoint::MB;
  else if( aPt == aPtRB) rPoint = bRTL ? RectPoint::LB : RectPoint::RB;

  return rPoint;
484}

486// Resets to the original state of the control

488void SvxRectCtl::Reset()
489{
  aPtNew = GetPointFromRP( eDefRP );
  eRP = eDefRP;
  Invalidate();
493}

495// Returns the currently selected RectPoint


498void SvxRectCtl::SetActualRP( RectPoint eNewRP )
499{
  SetActualRPWithoutInvalidate(eNewRP);

  Invalidate();

  // notify accessibility object about change
  if (pAccContext.is())
      pAccContext->selectChild( eNewRP /* MT, bFireFocus */ );
507}

509void SvxRectCtl::SetState( CTL_STATE nState )
510{
  m_nState = nState;

  Point aPtLast( GetPointFromRP( eRP ) );
  Point _aPtNew( aPtLast );

  if( m_nState & CTL_STATE::NOHORZ )
      _aPtNew.setX( aPtMM.X() );

  if( m_nState & CTL_STATE::NOVERT)
      _aPtNew.setY( aPtMM.Y() );

  eRP = GetRPFromPoint( _aPtNew );
  Invalidate();

  if (m_pPage)
      m_pPage->PointChanged(GetDrawingArea(), eRP);
527}

529tools::Rectangle SvxRectCtl::CalculateFocusRectangle() const
530{
  Size        aDstBtnSize(15, 15);
  return tools::Rectangle( aPtNew - Point( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1 ), aDstBtnSize );
533}

535tools::Rectangle SvxRectCtl::CalculateFocusRectangle( RectPoint eRectPoint ) const
536{
  tools::Rectangle   aRet;
  RectPoint  eOldRectPoint = GetActualRP();

  if( eOldRectPoint == eRectPoint )
      aRet = CalculateFocusRectangle();
  else
  {
      SvxRectCtl* pThis = const_cast<SvxRectCtl*>(this);

      pThis->SetActualRPWithoutInvalidate( eRectPoint );      // no invalidation because it's only temporary!
      aRet = CalculateFocusRectangle();

      pThis->SetActualRPWithoutInvalidate( eOldRectPoint );   // no invalidation because nothing has changed!
  }

  return aRet;
553}

555Reference< XAccessible > SvxRectCtl::CreateAccessible()
556{
  pAccContext = new SvxRectCtlAccessibleContext(this);
  return pAccContext.get();
559}

561RectPoint SvxRectCtl::GetApproxRPFromPixPt( const css::awt::Point& r ) const
562{
  return GetRPFromPoint( GetApproxLogPtFromPixPt( Point( r.X, r.Y ) ) );
564}

566// CompletelyDisabled() added to have a disabled state for SvxRectCtl
567void SvxRectCtl::DoCompletelyDisable(bool bNew)
568{
  mbCompleteDisable = bNew;
  Invalidate();
571}

573// Control for editing bitmaps

575css::uno::Reference< css::accessibility::XAccessible > SvxPixelCtl::CreateAccessible()
576{
  if (!m_xAccess.is())
      m_xAccess = new SvxPixelCtlAccessible(this);
  return m_xAccess.get();
580}

582long SvxPixelCtl::PointToIndex(const Point &aPt) const
583{
  long nX = aPt.X() * nLines / aRectSize.Width();
  long nY = aPt.Y() * nLines / aRectSize.Height();

  return nX + nY * nLines ;
588}

590Point SvxPixelCtl::IndexToPoint(long nIndex) const
591{
  DBG_ASSERT(nIndex >= 0 && nIndex < nSquares ," Check Index")do { if (true && (!(nIndex >= 0 && nIndex <
 nSquares))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/dialog/dlgctrl.cxx"
 ":" "592" ": "), "%s", " Check Index"); } } while (false);

  sal_Int32 nXIndex = nIndex % nLines;
  sal_Int32 nYIndex = nIndex / nLines;

  Point aPtTl;
  aPtTl.setY( aRectSize.Height() * nYIndex / nLines + 1 );
  aPtTl.setX( aRectSize.Width() * nXIndex / nLines + 1 );

  return aPtTl;
602}

604long SvxPixelCtl::GetFocusPosIndex() const
605{
  return aFocusPosition.getX() + aFocusPosition.getY() * nLines ;
607}

609long SvxPixelCtl::ShowPosition( const Point &rPt)
610{
  sal_Int32 nX = rPt.X() * nLines / aRectSize.Width();
  sal_Int32 nY = rPt.Y() * nLines / aRectSize.Height();

  ChangePixel( nX + nY * nLines );

  //Solution:Set new focus position and repaint
  aFocusPosition.setX(nX);
  aFocusPosition.setY(nY);
  Invalidate(tools::Rectangle(Point(0,0),aRectSize));

  if (m_pPage)
      m_pPage->PointChanged(GetDrawingArea(), RectPoint::MM ); // RectPoint is dummy

  return GetFocusPosIndex();

626}

628SvxPixelCtl::SvxPixelCtl(SvxTabPage* pPage)
  : m_pPage(pPage)
  , bPaintable(true)
  , aFocusPosition(0,0)
632{
  maPixelData.fill(0);
634}

636void SvxPixelCtl::Resize()
637{
  CustomWidgetController::Resize();
  aRectSize = GetOutputSizePixel();
640}

642void SvxPixelCtl::SetDrawingArea(weld::DrawingArea* pDrawingArea)
643{
  CustomWidgetController::SetDrawingArea(pDrawingArea);
  pDrawingArea->set_size_request(pDrawingArea->get_approximate_digit_width() * 25,
                                 pDrawingArea->get_text_height() * 10);
647}

649SvxPixelCtl::~SvxPixelCtl()
650{
651}

653// Changes the foreground or Background color

655void SvxPixelCtl::ChangePixel( sal_uInt16 nPixel )
656{
  if( maPixelData[nPixel] == 0 )
      maPixelData[nPixel] = 1; //  could be extended to more colors
  else
      maPixelData[nPixel] = 0;
661}

663// The clicked rectangle is identified, to change its color

665bool SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt )
666{
  if (!aRectSize.Width() || !aRectSize.Height())
      return true;

  //Grab focus when click in window
  if (!HasFocus())
  {
      GrabFocus();
  }

  long nIndex = ShowPosition(rMEvt.GetPosPixel());

  if(m_xAccess.is())
  {
      m_xAccess->NotifyChild(nIndex,true, true);
  }

  return true;
684}

686tools::Rectangle SvxPixelCtl::GetFocusRect()
687{
  tools::Rectangle aRet;
  //Draw visual focus when has focus
  if (HasFocus())
      aRet = implCalFocusRect(aFocusPosition);
  return aRet;
693}

695// Draws the Control (Rectangle with nine circles)
696void SvxPixelCtl::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& )
697{
  if (!aRectSize.Width() || !aRectSize.Height())
      return;

  sal_uInt16 i, j, nTmp;
  Point aPtTl, aPtBr;

  if (bPaintable)
  {
      // Draw lines
      rRenderContext.SetLineColor(Color());
      for (i = 1; i < nLines; i++)
      {
          // horizontal
          nTmp = static_cast<sal_uInt16>(aRectSize.Height() * i / nLines);
          rRenderContext.DrawLine(Point(0, nTmp), Point(aRectSize.Width(), nTmp));
          // vertically
          nTmp = static_cast<sal_uInt16>( aRectSize.Width() * i / nLines );
          rRenderContext.DrawLine(Point(nTmp, 0), Point(nTmp, aRectSize.Height()));
      }

      //Draw Rectangles (squares)
      rRenderContext.SetLineColor();
      sal_uInt16 nLastPixel = maPixelData[0] ? 0 : 1;

      for (i = 0; i < nLines; i++)
      {
          aPtTl.setY( aRectSize.Height() * i / nLines + 1 );
          aPtBr.setY( aRectSize.Height() * (i + 1) / nLines - 1 );

          for (j = 0; j < nLines; j++)
          {
              aPtTl.setX( aRectSize.Width() * j / nLines + 1 );
              aPtBr.setX( aRectSize.Width() * (j + 1) / nLines - 1 );

              if (maPixelData[i * nLines + j] != nLastPixel)
              {
                  nLastPixel = maPixelData[i * nLines + j];
                  // Change color: 0 -> Background color
                  rRenderContext.SetFillColor(nLastPixel ? aPixelColor : aBackgroundColor);
              }
              rRenderContext.DrawRect(tools::Rectangle(aPtTl, aPtBr));
          }
      }
  }
  else
  {
      rRenderContext.SetBackground(Wallpaper(COL_LIGHTGRAY));
      rRenderContext.SetLineColor(COL_LIGHTRED);
      rRenderContext.DrawLine(Point(0, 0), Point(aRectSize.Width(), aRectSize.Height()));
      rRenderContext.DrawLine(Point(0, aRectSize.Height()), Point(aRectSize.Width(), 0));
  }
749}

751//Calculate visual focus rectangle via focus position
752tools::Rectangle SvxPixelCtl::implCalFocusRect( const Point& aPosition )
753{
  long nLeft,nTop,nRight,nBottom;
  long i,j;
  i = aPosition.Y();
  j = aPosition.X();
  nLeft = aRectSize.Width() * j / nLines + 1;
  nRight = aRectSize.Width() * (j + 1) / nLines - 1;
  nTop = aRectSize.Height() * i / nLines + 1;
  nBottom = aRectSize.Height() * (i + 1) / nLines - 1;
  return tools::Rectangle(nLeft,nTop,nRight,nBottom);
763}

765//Solution:Keyboard function
766bool SvxPixelCtl::KeyInput( const KeyEvent& rKEvt )
767{
  vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
  sal_uInt16 nCode = aKeyCode.GetCode();
  bool bIsMod = aKeyCode.IsShift() || aKeyCode.IsMod1() || aKeyCode.IsMod2();

  if( !bIsMod )
  {
      Point aRepaintPoint( aRectSize.Width() *( aFocusPosition.getX() - 1)/ nLines - 1,
                           aRectSize.Height() *( aFocusPosition.getY() - 1)/ nLines -1
                          );
      Size  aRepaintSize( aRectSize.Width() *3/ nLines + 2,aRectSize.Height() *3/ nLines + 2);
      tools::Rectangle aRepaintRect( aRepaintPoint, aRepaintSize );
      bool bFocusPosChanged=false;
      switch(nCode)
      {
          case KEY_LEFT:
              if(aFocusPosition.getX() >= 1)
              {
                  aFocusPosition.setX( aFocusPosition.getX() - 1 );
                  Invalidate(aRepaintRect);
                  bFocusPosChanged=true;
              }
              break;
          case KEY_RIGHT:
              if( aFocusPosition.getX() < (nLines - 1) )
              {
                  aFocusPosition.setX( aFocusPosition.getX() + 1 );
                  Invalidate(aRepaintRect);
                  bFocusPosChanged=true;
              }
              break;
          case KEY_UP:
              if(aFocusPosition.getY() >= 1)
              {
                  aFocusPosition.setY( aFocusPosition.getY() - 1 );
                  Invalidate(aRepaintRect);
                  bFocusPosChanged=true;
              }
              break;
          case KEY_DOWN:
              if( aFocusPosition.getY() < ( nLines - 1 ) )
              {
                  aFocusPosition.setY( aFocusPosition.getY() + 1 );
                  Invalidate(aRepaintRect);
                  bFocusPosChanged=true;
              }
              break;
          case KEY_SPACE:
              ChangePixel( sal_uInt16(aFocusPosition.getX() + aFocusPosition.getY() * nLines) );
              Invalidate( implCalFocusRect(aFocusPosition) );
              break;
          default:
              return CustomWidgetController::KeyInput( rKEvt );
      }
      if(m_xAccess.is())
      {
          long nIndex = GetFocusPosIndex();
          switch(nCode)
          {
          case KEY_LEFT:
          case KEY_RIGHT:
          case KEY_UP:
          case KEY_DOWN:
              if (bFocusPosChanged)
              {
                  m_xAccess->NotifyChild(nIndex,false,false);
              }
              break;
          case KEY_SPACE:
              m_xAccess->NotifyChild(nIndex,false,true);
              break;
          default:
              break;
          }
      }
      return true;
  }
  else
  {
      return CustomWidgetController::KeyInput( rKEvt );
  }
848}

850//Draw focus when get focus
851void SvxPixelCtl::GetFocus()
852{
  Invalidate(implCalFocusRect(aFocusPosition));

  if (m_xAccess.is())
  {
      m_xAccess->NotifyChild(GetFocusPosIndex(),true,false);
  }
859}

861void SvxPixelCtl::LoseFocus()
862{
  Invalidate();
864}

866void SvxPixelCtl::SetXBitmap(const BitmapEx& rBitmapEx)
867{
  if (vcl::bitmap::isHistorical8x8(rBitmapEx, aBackgroundColor, aPixelColor))
  {
      for (sal_uInt16 i = 0; i < nSquares; i++)
      {
          Color aColor = rBitmapEx.GetPixelColor(i%8, i/8);
          maPixelData[i] = (aColor == aBackgroundColor) ? 0 : 1;
      }
  }
876}

878// Returns a specific pixel

880sal_uInt8 SvxPixelCtl::GetBitmapPixel( const sal_uInt16 nPixel ) const
881{
  return maPixelData[nPixel];
883}

885// Resets to the original state of the control

887void SvxPixelCtl::Reset()
888{
  // clear pixel area
  maPixelData.fill(0);
  Invalidate();
892}

894SvxLineLB::SvxLineLB(std::unique_ptr<weld::ComboBox> pControl)
  : m_xControl(std::move(pControl))
  , mbAddStandardFields(true)
897{
898}

900void SvxLineLB::setAddStandardFields(bool bNew)
901{
  if(getAddStandardFields() != bNew)
  {
      mbAddStandardFields = bNew;
  }
906}

908// Fills the listbox (provisional) with strings

910void SvxLineLB::Fill( const XDashListRef &pList )
911{
  m_xControl->clear();

  if( !pList.is() )
      return;

  ScopedVclPtrInstance< VirtualDevice > pVD;

  if(getAddStandardFields())
  {
      // entry for 'none'
      m_xControl->append_text(pList->GetStringForUiNoLine());

      // entry for solid line
      const BitmapEx aBitmap = pList->GetBitmapForUISolidLine();
      const Size aBmpSize(aBitmap.GetSizePixel());
      pVD->SetOutputSizePixel(aBmpSize, false);
      pVD->DrawBitmapEx(Point(), aBitmap);
      m_xControl->append("", pList->GetStringForUiSolidLine(), *pVD);
  }

  // entries for dashed lines

  long nCount = pList->Count();
  m_xControl->freeze();

  for( long i = 0; i < nCount; i++ )
  {
      const XDashEntry* pEntry = pList->GetDash(i);
      const BitmapEx aBitmap = pList->GetUiBitmap( i );
      if( !aBitmap.IsEmpty() )
      {
          const Size aBmpSize(aBitmap.GetSizePixel());
          pVD->SetOutputSizePixel(aBmpSize, false);
          pVD->DrawBitmapEx(Point(), aBitmap);
          m_xControl->append("", pEntry->GetName(), *pVD);
      }
      else
      {
          m_xControl->append_text(pEntry->GetName());
      }
  }

  m_xControl->thaw();
955}

957void SvxLineLB::Append( const XDashEntry& rEntry, const BitmapEx& rBitmap )
958{
  if (!rBitmap.IsEmpty())
  {
      ScopedVclPtrInstance< VirtualDevice > pVD;

      const Size aBmpSize(rBitmap.GetSizePixel());
      pVD->SetOutputSizePixel(aBmpSize, false);
      pVD->DrawBitmapEx(Point(), rBitmap);
      m_xControl->append("", rEntry.GetName(), *pVD);
  }
  else
  {
      m_xControl->append_text(rEntry.GetName());
  }
972}

974void SvxLineLB::Modify(const XDashEntry& rEntry, sal_Int32 nPos, const BitmapEx& rBitmap)
975{
  m_xControl->remove(nPos);

  if (!rBitmap.IsEmpty())
  {
      ScopedVclPtrInstance< VirtualDevice > pVD;

      const Size aBmpSize(rBitmap.GetSizePixel());
      pVD->SetOutputSizePixel(aBmpSize, false);
      pVD->DrawBitmapEx(Point(), rBitmap);
      m_xControl->insert(nPos, rEntry.GetName(), nullptr, nullptr, pVD);
  }
  else
  {
      m_xControl->insert_text(nPos, rEntry.GetName());
  }
991}

993SvxLineEndLB::SvxLineEndLB(std::unique_ptr<weld::ComboBox> pControl)
  : m_xControl(std::move(pControl))
995{
996}

998void SvxLineEndLB::Fill( const XLineEndListRef &pList, bool bStart )
999{
  if( !pList.is() )
      return;

  long nCount = pList->Count();
  ScopedVclPtrInstance< VirtualDevice > pVD;
  m_xControl->freeze();

  for( long i = 0; i < nCount; i++ )
  {
      const XLineEndEntry* pEntry = pList->GetLineEnd(i);
      const BitmapEx aBitmap = pList->GetUiBitmap( i );
      if( !aBitmap.IsEmpty() )
      {
          const Size aBmpSize(aBitmap.GetSizePixel());
          pVD->SetOutputSizePixel(Size(aBmpSize.Width() / 2, aBmpSize.Height()), false);
          pVD->DrawBitmapEx(bStart ? Point() : Point(-aBmpSize.Width() / 2, 0), aBitmap);
          m_xControl->append("", pEntry->GetName(), *pVD);
      }
      else
          m_xControl->append_text(pEntry->GetName());
  }

  m_xControl->thaw();
1023}

1025void SvxLineEndLB::Append( const XLineEndEntry& rEntry, const BitmapEx& rBitmap )
1026{
  if(!rBitmap.IsEmpty())
  {
      ScopedVclPtrInstance< VirtualDevice > pVD;

      const Size aBmpSize(rBitmap.GetSizePixel());
      pVD->SetOutputSizePixel(Size(aBmpSize.Width() / 2, aBmpSize.Height()), false);
      pVD->DrawBitmapEx(Point(-aBmpSize.Width() / 2, 0), rBitmap);
      m_xControl->append("", rEntry.GetName(), *pVD);
  }
  else
  {
      m_xControl->append_text(rEntry.GetName());
  }
1040}

1042void SvxLineEndLB::Modify( const XLineEndEntry& rEntry, sal_Int32 nPos, const BitmapEx& rBitmap )
1043{
  m_xControl->remove(nPos);

  if(!rBitmap.IsEmpty())
  {
      ScopedVclPtrInstance< VirtualDevice > pVD;

      const Size aBmpSize(rBitmap.GetSizePixel());
      pVD->SetOutputSizePixel(Size(aBmpSize.Width() / 2, aBmpSize.Height()), false);
      pVD->DrawBitmapEx(Point(-aBmpSize.Width() / 2, 0), rBitmap);
      m_xControl->insert(nPos, rEntry.GetName(), nullptr, nullptr, pVD);
  }
  else
  {
      m_xControl->insert_text(nPos, rEntry.GetName());
  }
1059}

1061void SvxXLinePreview::Resize()
1062{
  SvxPreviewBase::Resize();

  const Size aOutputSize(GetOutputSize());
  const sal_Int32 nDistance(500);
  const sal_Int32 nAvailableLength(aOutputSize.Width() - (4 * nDistance));

  // create DrawObjectA
  const sal_Int32 aYPosA(aOutputSize.Height() / 2);
  const basegfx::B2DPoint aPointA1( nDistance,  aYPosA);
  const basegfx::B2DPoint aPointA2( aPointA1.getX() + ((nAvailableLength * 14) / 20), aYPosA );
  basegfx::B2DPolygon aPolygonA;
  aPolygonA.append(aPointA1);
  aPolygonA.append(aPointA2);
  mpLineObjA->SetPathPoly(basegfx::B2DPolyPolygon(aPolygonA));

  // create DrawObjectB
  const sal_Int32 aYPosB1((aOutputSize.Height() * 3) / 4);
  const sal_Int32 aYPosB2((aOutputSize.Height() * 1) / 4);
  const basegfx::B2DPoint aPointB1( aPointA2.getX() + nDistance,  aYPosB1);
  const basegfx::B2DPoint aPointB2( aPointB1.getX() + ((nAvailableLength * 2) / 20), aYPosB2 );
  const basegfx::B2DPoint aPointB3( aPointB2.getX() + ((nAvailableLength * 2) / 20), aYPosB1 );
  basegfx::B2DPolygon aPolygonB;
  aPolygonB.append(aPointB1);
  aPolygonB.append(aPointB2);
  aPolygonB.append(aPointB3);
  mpLineObjB->SetPathPoly(basegfx::B2DPolyPolygon(aPolygonB));

  // create DrawObjectC
  basegfx::B2DPolygon aPolygonC;
  const basegfx::B2DPoint aPointC1( aPointB3.getX() + nDistance,  aYPosB1);
  const basegfx::B2DPoint aPointC2( aPointC1.getX() + ((nAvailableLength * 1) / 20), aYPosB2 );
  const basegfx::B2DPoint aPointC3( aPointC2.getX() + ((nAvailableLength * 1) / 20), aYPosB1 );
  aPolygonC.append(aPointC1);
  aPolygonC.append(aPointC2);
  aPolygonC.append(aPointC3);
  mpLineObjC->SetPathPoly(basegfx::B2DPolyPolygon(aPolygonC));
1099}

1101SvxXLinePreview::SvxXLinePreview()
  : mpLineObjA(nullptr)
  , mpLineObjB(nullptr)
  , mpLineObjC(nullptr)
  , mpGraphic(nullptr)
  , mbWithSymbol(false)
1107{
1108}

1110void SvxXLinePreview::SetDrawingArea(weld::DrawingArea* pDrawingArea)
1111{
  SvxPreviewBase::SetDrawingArea(pDrawingArea);

  mpLineObjA = new SdrPathObj(getModel(), OBJ_LINE);
  mpLineObjB = new SdrPathObj(getModel(), OBJ_PLIN);
  mpLineObjC = new SdrPathObj(getModel(), OBJ_PLIN);

  Resize();
  Invalidate();
1120}

1122SvxXLinePreview::~SvxXLinePreview()
1123{
  SdrObject *pFoo = mpLineObjA;
  SdrObject::Free( pFoo );
  pFoo = mpLineObjB;
  SdrObject::Free( pFoo );
  pFoo = mpLineObjC;
  SdrObject::Free( pFoo );
1130}

1132void SvxXLinePreview::SetSymbol(Graphic* p,const Size& s)
1133{
  mpGraphic = p;
  maSymbolSize = s;
1136}

1138void SvxXLinePreview::ResizeSymbol(const Size& s)
1139{
  if ( s != maSymbolSize )
  {
      maSymbolSize = s;
      Invalidate();
  }
1145}

1147void SvxXLinePreview::SetLineAttributes(const SfxItemSet& rItemSet)
1148{
  // Set ItemSet at objects
  mpLineObjA->SetMergedItemSet(rItemSet);

  // At line joints, do not use arrows
  SfxItemSet aTempSet(rItemSet);
  aTempSet.ClearItem(XATTR_LINESTART);
  aTempSet.ClearItem(XATTR_LINEEND);

  mpLineObjB->SetMergedItemSet(aTempSet);
  mpLineObjC->SetMergedItemSet(aTempSet);
1159}

1161void SvxXLinePreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
1162{
  LocalPrePaint(rRenderContext);

  // paint objects to buffer device
  sdr::contact::SdrObjectVector aObjectVector;
  aObjectVector.push_back(mpLineObjA);
  aObjectVector.push_back(mpLineObjB);
  aObjectVector.push_back(mpLineObjC);

  sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, nullptr);
  sdr::contact::DisplayInfo aDisplayInfo;

  // do processing
  aPainter.ProcessDisplay(aDisplayInfo);

  if ( mbWithSymbol && mpGraphic )
  {
      const Size aOutputSize(GetOutputSize());
      Point aPos( aOutputSize.Width() / 3, aOutputSize.Height() / 2 );
      aPos.AdjustX( -(maSymbolSize.Width() / 2) );
      aPos.AdjustY( -(maSymbolSize.Height() / 2) );
      mpGraphic->Draw(&getBufferDevice(), aPos, maSymbolSize);
  }

  LocalPostPaint(rRenderContext);
1187}

1189SvxXShadowPreview::SvxXShadowPreview()
  : mpRectangleObject(nullptr)
  , mpRectangleShadow(nullptr)
1192{
1193}

1195void SvxXShadowPreview::SetDrawingArea(weld::DrawingArea* pDrawingArea)
1196{
  SvxPreviewBase::SetDrawingArea(pDrawingArea);
  InitSettings();

  // prepare size
  Size aSize = GetPreviewSize().GetSize();
  aSize.setWidth( aSize.Width() / 3 );
  aSize.setHeight( aSize.Height() / 3 );

  // create RectangleObject
  const tools::Rectangle aObjectSize( Point( aSize.Width(), aSize.Height() ), aSize );
  mpRectangleObject = new SdrRectObj(
      getModel(),
      aObjectSize);

  // create ShadowObject
  const tools::Rectangle aShadowSize( Point( aSize.Width(), aSize.Height() ), aSize );
  mpRectangleShadow = new SdrRectObj(
      getModel(),
      aShadowSize);
1216}

1218SvxXShadowPreview::~SvxXShadowPreview()
1219{
  SdrObject::Free(mpRectangleObject);
  SdrObject::Free(mpRectangleShadow);
1222}

1224void SvxXShadowPreview::SetRectangleAttributes(const SfxItemSet& rItemSet)
1225{
  mpRectangleObject->SetMergedItemSet(rItemSet, true);
  mpRectangleObject->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1228}

1230void SvxXShadowPreview::SetShadowAttributes(const SfxItemSet& rItemSet)
1231{
  mpRectangleShadow->SetMergedItemSet(rItemSet, true);
  mpRectangleShadow->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1234}

1236void SvxXShadowPreview::SetShadowPosition(const Point& rPos)
1237{
  maShadowOffset = rPos;
1239}

1241void SvxXShadowPreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
1242{
  rRenderContext.Push(PushFlags::MAPMODE);
  rRenderContext.SetMapMode(MapMode(MapUnit::Map100thMM));

  LocalPrePaint(rRenderContext);

  // prepare size
  Size aSize = rRenderContext.GetOutputSize();
  aSize.setWidth( aSize.Width() / 3 );
  aSize.setHeight( aSize.Height() / 3 );

  tools::Rectangle aObjectRect(Point(aSize.Width(), aSize.Height()), aSize);
  mpRectangleObject->SetSnapRect(aObjectRect);
  aObjectRect.Move(maShadowOffset.X(), maShadowOffset.Y());
  mpRectangleShadow->SetSnapRect(aObjectRect);

  sdr::contact::SdrObjectVector aObjectVector;

  aObjectVector.push_back(mpRectangleShadow);
  aObjectVector.push_back(mpRectangleObject);

  sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, nullptr);
  sdr::contact::DisplayInfo aDisplayInfo;

  aPainter.ProcessDisplay(aDisplayInfo);

  LocalPostPaint(rRenderContext);

  rRenderContext.Pop();
1271}

1273void SvxPreviewBase::InitSettings()
1274{
  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();

  svtools::ColorConfig aColorConfig;
  Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor);
  getBufferDevice().SetTextColor(aTextColor);

  getBufferDevice().SetBackground(rStyleSettings.GetWindowColor());

  getBufferDevice().SetDrawMode(rStyleSettings.GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST(DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags
::SettingsText | DrawModeFlags::SettingsGradient) : OUTPUT_DRAWMODE_COLOR(DrawModeFlags::Default));

  Invalidate();
1286}

1288SvxPreviewBase::SvxPreviewBase()
  : mpModel(new SdrModel(nullptr, nullptr, true))
1290{
  // init model
  mpModel->GetItemPool().FreezeIdRanges();
1293}

1295void SvxPreviewBase::SetDrawingArea(weld::DrawingArea* pDrawingArea)
1296{
  CustomWidgetController::SetDrawingArea(pDrawingArea);
  Size aSize(getPreviewStripSize(pDrawingArea->get_ref_device()));
  pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
  SetOutputSizePixel(aSize);

  mpBufferDevice = VclPtr<VirtualDevice>::Create(pDrawingArea->get_ref_device());
  mpBufferDevice->SetMapMode(MapMode(MapUnit::Map100thMM));
1304}

1306SvxPreviewBase::~SvxPreviewBase()
1307{
  mpModel.reset();
  mpBufferDevice.disposeAndClear();
2
←
Calling 'VclPtr::disposeAndClear'→
1310}

1312void SvxPreviewBase::LocalPrePaint(vcl::RenderContext const & rRenderContext)
1313{
  // init BufferDevice
  if (mpBufferDevice->GetOutputSizePixel() != GetOutputSizePixel())
      mpBufferDevice->SetOutputSizePixel(GetOutputSizePixel());
  mpBufferDevice->SetAntialiasing(rRenderContext.GetAntialiasing());

  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();

  if (rStyleSettings.GetPreviewUsesCheckeredBackground())
  {
      const Point aNull(0, 0);
      static const sal_uInt32 nLen(8);
      static const Color aW(COL_WHITE);
      static const Color aG(0xef, 0xef, 0xef);
      const bool bWasEnabled(mpBufferDevice->IsMapModeEnabled());

      mpBufferDevice->EnableMapMode(false);
      mpBufferDevice->DrawCheckered(aNull, mpBufferDevice->GetOutputSizePixel(), nLen, aW, aG);
      mpBufferDevice->EnableMapMode(bWasEnabled);
  }
  else
  {
      mpBufferDevice->Erase();
  }
1337}

1339void SvxPreviewBase::LocalPostPaint(vcl::RenderContext& rRenderContext)
1340{
  // copy to front (in pixel mode)
  const bool bWasEnabledSrc(mpBufferDevice->IsMapModeEnabled());
  const bool bWasEnabledDst(rRenderContext.IsMapModeEnabled());
  const Point aEmptyPoint;

  mpBufferDevice->EnableMapMode(false);
  rRenderContext.EnableMapMode(false);

  rRenderContext.DrawOutDev(aEmptyPoint, GetOutputSizePixel(),
                            aEmptyPoint, GetOutputSizePixel(),
                            *mpBufferDevice);

  mpBufferDevice->EnableMapMode(bWasEnabledSrc);
  rRenderContext.EnableMapMode(bWasEnabledDst);
1355}

1357void SvxPreviewBase::StyleUpdated()
1358{
  InitSettings();
  CustomWidgetController::StyleUpdated();
1361}

1363SvxXRectPreview::SvxXRectPreview()
  : mpRectangleObject(nullptr)
1365{
1366}

1368tools::Rectangle SvxPreviewBase::GetPreviewSize() const
1369{
  tools::Rectangle aObjectSize(Point(), getBufferDevice().PixelToLogic(GetOutputSizePixel()));
  return aObjectSize;
1372}

1374void SvxXRectPreview::SetDrawingArea(weld::DrawingArea* pDrawingArea)
1375{
  SvxPreviewBase::SetDrawingArea(pDrawingArea);
  InitSettings();

  // create RectangleObject
  mpRectangleObject = new SdrRectObj(getModel(), GetPreviewSize());
1381}

1383void SvxXRectPreview::Resize()
1384{
  SdrObject *pOrigObject = mpRectangleObject;
  if (pOrigObject)
  {
      mpRectangleObject = new SdrRectObj(getModel(), GetPreviewSize());
      SetAttributes(pOrigObject->GetMergedItemSet());
      SdrObject::Free(pOrigObject);
  }
  SvxPreviewBase::Resize();
1393}

1395SvxXRectPreview::~SvxXRectPreview()
1396{
  SdrObject::Free(mpRectangleObject);
1398}
1
Calling '~SvxPreviewBase'→

1400void SvxXRectPreview::SetAttributes(const SfxItemSet& rItemSet)
1401{
  mpRectangleObject->SetMergedItemSet(rItemSet, true);
  mpRectangleObject->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
1404}

1406void SvxXRectPreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
1407{
  rRenderContext.Push(PushFlags::MAPMODE);
  rRenderContext.SetMapMode(MapMode(MapUnit::Map100thMM));
  LocalPrePaint(rRenderContext);

  sdr::contact::SdrObjectVector aObjectVector;

  aObjectVector.push_back(mpRectangleObject);

  sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, nullptr);
  sdr::contact::DisplayInfo aDisplayInfo;

  aPainter.ProcessDisplay(aDisplayInfo);

  LocalPostPaint(rRenderContext);
  rRenderContext.Pop();
1423}

1425void limitWidthForSidebar(weld::SpinButton& rSpinButton)
1426{
  // space is limited in the sidebar, so limit MetricSpinButtons to a width of 4 digits
  const int nMaxDigits = 4;
  rSpinButton.set_width_chars(std::min(rSpinButton.get_width_chars(), nMaxDigits));
1430}

1432void limitWidthForSidebar(SvxRelativeField& rMetricSpinButton)
1433{
  weld::SpinButton& rSpinButton = rMetricSpinButton.get_widget();
  limitWidthForSidebar(rSpinButton);
1436}

1438void padWidthForSidebar(weld::Toolbar& rToolbar, const css::uno::Reference<css::frame::XFrame>& rFrame)
1439{
  static int nColumnWidth = -1;
  static vcl::ImageType eSize;
  if (nColumnWidth != -1 && eSize != rToolbar.get_icon_size())
      nColumnWidth = -1;
  if (nColumnWidth == -1)
  {
      // use the, filled-in by dispatcher, width of measurewidth as the width
      // of a "standard" column in a two column panel
      std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(&rToolbar, "svx/ui/measurewidthbar.ui"));
      std::unique_ptr<weld::Toolbar> xToolbar1(xBuilder->weld_toolbar("measurewidth1"));
      std::unique_ptr<ToolbarUnoDispatcher> xDispatcher1(new ToolbarUnoDispatcher(*xToolbar1, *xBuilder, rFrame));
      std::unique_ptr<weld::Toolbar> xToolbar2(xBuilder->weld_toolbar("measurewidth2"));
      std::unique_ptr<ToolbarUnoDispatcher> xDispatcher2(new ToolbarUnoDispatcher(*xToolbar2, *xBuilder, rFrame));
      nColumnWidth = std::max(xToolbar1->get_preferred_size().Width(), xToolbar2->get_preferred_size().Width());
      eSize = rToolbar.get_icon_size();
  }
  rToolbar.set_size_request(nColumnWidth, -1);
1457}

1459/* 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);
3
←
Calling copy constructor for 'Reference<VirtualDevice>'→
6
←
Returning from copy constructor for 'Reference<VirtualDevice>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
7
←
Calling 'Reference::clear'→
14
←
Returning; memory was released→
      if (aTmp.get()) {
15
←
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)
4
←
Assuming field 'm_pBody' is non-null→
5
←
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_pBody7.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
)
8
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
9
←
Calling 'VclReferenceBase::release'→
13
←
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;
16
←
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)
10
←
Assuming the condition is true→
11
←
Taking true branch→
40            delete this;
12
←
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