/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 ctrlbox.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 SVT_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/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/CustomTarget/officecfg/registry -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/svtools/source/inc -I /home/maarten/src/libreoffice/core/svtools/inc -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/svtools/source/control/ctrlbox.cxx

/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.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 <config_folders.h>

22#include <comphelper/lok.hxx>
23#include <i18nutil/unicode.hxx>
24#include <officecfg/Office/Common.hxx>
25#include <tools/stream.hxx>
26#include <vcl/customweld.hxx>
27#include <vcl/event.hxx>
28#include <vcl/svapp.hxx>
29#include <vcl/fieldvalues.hxx>
30#include <vcl/settings.hxx>
31#include <vcl/image.hxx>
32#include <vcl/virdev.hxx>
33#include <rtl/math.hxx>
34#include <sal/macros.h>
35#include <sal/log.hxx>
36#include <comphelper/processfactory.hxx>
37#include <comphelper/string.hxx>
38#include <unotools/charclass.hxx>
39#include <unotools/localedatawrapper.hxx>
40#include <unotools/syslocale.hxx>

42#include <svtools/borderline.hxx>
43#include <svtools/sampletext.hxx>
44#include <svtools/svtresid.hxx>
45#include <svtools/strings.hrc>
46#include <svtools/ctrlbox.hxx>
47#include <svtools/ctrltool.hxx>
48#include <svtools/borderhelper.hxx>
49#include <svtools/valueset.hxx>

51#include <basegfx/polygon/b2dpolygon.hxx>
52#include <basegfx/polygon/b2dpolygontools.hxx>
53#include <editeng/borderline.hxx>

55#include <rtl/bootstrap.hxx>

57#include <boost/property_tree/ptree.hpp>

59#include <borderline.hrc>

61#include <stdio.h>

63#define IMGOUTERTEXTSPACE5 5
64#define EXTRAFONTSIZE5 5
65#define GAPTOEXTRAPREVIEW10 10
66#define MINGAPWIDTH2 2

68#define FONTNAMEBOXMRUENTRIESFILE"/user/config/fontnameboxmruentries" "/user/config/fontnameboxmruentries"


71BorderWidthImpl::BorderWidthImpl( BorderWidthImplFlags nFlags, double nRate1, double nRate2, double nRateGap ):
  m_nFlags( nFlags ),
  m_nRate1( nRate1 ),
  m_nRate2( nRate2 ),
  m_nRateGap( nRateGap )
76{
77}

79bool BorderWidthImpl::operator== ( const BorderWidthImpl& r ) const
80{
  return ( m_nFlags == r.m_nFlags ) &&
         ( m_nRate1 == r.m_nRate1 ) &&
         ( m_nRate2 == r.m_nRate2 ) &&
         ( m_nRateGap == r.m_nRateGap );
85}

87long BorderWidthImpl::GetLine1( long nWidth ) const
88{
  long result = static_cast<long>(m_nRate1);
  if ( m_nFlags & BorderWidthImplFlags::CHANGE_LINE1 )
  {
      long const nConstant2 = (m_nFlags & BorderWidthImplFlags::CHANGE_LINE2) ? 0 : m_nRate2;
      long const nConstantD = (m_nFlags & BorderWidthImplFlags::CHANGE_DIST ) ? 0 : m_nRateGap;
      result = std::max<long>(0,
                  static_cast<long>((m_nRate1 * nWidth) + 0.5)
                      - (nConstant2 + nConstantD));
      if (result == 0 && m_nRate1 > 0.0 && nWidth > 0)
      {   // fdo#51777: hack to essentially treat 1 twip DOUBLE border
          result = 1;  // as 1 twip SINGLE border
      }
  }
  return result;
103}

105long BorderWidthImpl::GetLine2( long nWidth ) const
106{
  long result = static_cast<long>(m_nRate2);
  if ( m_nFlags & BorderWidthImplFlags::CHANGE_LINE2)
  {
      long const nConstant1 = (m_nFlags & BorderWidthImplFlags::CHANGE_LINE1) ? 0 : m_nRate1;
      long const nConstantD = (m_nFlags & BorderWidthImplFlags::CHANGE_DIST ) ? 0 : m_nRateGap;
      result = std::max<long>(0,
                  static_cast<long>((m_nRate2 * nWidth) + 0.5)
                      - (nConstant1 + nConstantD));
  }
  return result;
117}

119long BorderWidthImpl::GetGap( long nWidth ) const
120{
  long result = static_cast<long>(m_nRateGap);
  if ( m_nFlags & BorderWidthImplFlags::CHANGE_DIST )
  {
      long const nConstant1 = (m_nFlags & BorderWidthImplFlags::CHANGE_LINE1) ? 0 : m_nRate1;
      long const nConstant2 = (m_nFlags & BorderWidthImplFlags::CHANGE_LINE2) ? 0 : m_nRate2;
      result = std::max<long>(0,
                  static_cast<long>((m_nRateGap * nWidth) + 0.5)
                      - (nConstant1 + nConstant2));
  }

  // Avoid having too small distances (less than 0.1pt)
  if ( result < MINGAPWIDTH2 && m_nRate1 > 0 && m_nRate2 > 0 )
      result = MINGAPWIDTH2;

  return result;
136}

138static double lcl_getGuessedWidth( long nTested, double nRate, bool bChanging )
139{
  double nWidth = -1.0;
  if ( bChanging )
      nWidth = double( nTested ) / nRate;
  else
  {
      if ( rtl::math::approxEqual(double( nTested ), nRate) )
          nWidth = nRate;
  }

  return nWidth;
150}

152long BorderWidthImpl::GuessWidth( long nLine1, long nLine2, long nGap )
153{
  std::vector< double > aToCompare;
  bool bInvalid = false;

  bool bLine1Change = bool( m_nFlags & BorderWidthImplFlags::CHANGE_LINE1 );
  double nWidth1 = lcl_getGuessedWidth( nLine1, m_nRate1, bLine1Change );
  if ( bLine1Change )
      aToCompare.push_back( nWidth1 );
  else if (nWidth1 < 0)
      bInvalid = true;

  bool bLine2Change = bool( m_nFlags & BorderWidthImplFlags::CHANGE_LINE2 );
  double nWidth2 = lcl_getGuessedWidth( nLine2, m_nRate2, bLine2Change );
  if ( bLine2Change )
      aToCompare.push_back( nWidth2 );
  else if (nWidth2 < 0)
      bInvalid = true;

  bool bGapChange = bool( m_nFlags & BorderWidthImplFlags::CHANGE_DIST );
  double nWidthGap = lcl_getGuessedWidth( nGap, m_nRateGap, bGapChange );
  if ( bGapChange && nGap >= MINGAPWIDTH2 )
      aToCompare.push_back( nWidthGap );
  else if ( !bGapChange && nWidthGap < 0 )
      bInvalid = true;

  // non-constant line width factors must sum to 1
  assert((((bLine1Change) ? m_nRate1 : 0) +(static_cast <bool> ((((bLine1Change) ? m_nRate1 : 0) +
 ((bLine2Change) ? m_nRate2 : 0) + ((bGapChange) ? m_nRateGap
 : 0)) - 1.0 < 0.00001) ? void (0) : __assert_fail ("(((bLine1Change) ? m_nRate1 : 0) + ((bLine2Change) ? m_nRate2 : 0) + ((bGapChange) ? m_nRateGap : 0)) - 1.0 < 0.00001"
, "/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
, 181, __extension__ __PRETTY_FUNCTION__))
          ((bLine2Change) ? m_nRate2 : 0) +(static_cast <bool> ((((bLine1Change) ? m_nRate1 : 0) +
 ((bLine2Change) ? m_nRate2 : 0) + ((bGapChange) ? m_nRateGap
 : 0)) - 1.0 < 0.00001) ? void (0) : __assert_fail ("(((bLine1Change) ? m_nRate1 : 0) + ((bLine2Change) ? m_nRate2 : 0) + ((bGapChange) ? m_nRateGap : 0)) - 1.0 < 0.00001"
, "/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
, 181, __extension__ __PRETTY_FUNCTION__))
          ((bGapChange) ? m_nRateGap : 0)) - 1.0 < 0.00001 )(static_cast <bool> ((((bLine1Change) ? m_nRate1 : 0) +
 ((bLine2Change) ? m_nRate2 : 0) + ((bGapChange) ? m_nRateGap
 : 0)) - 1.0 < 0.00001) ? void (0) : __assert_fail ("(((bLine1Change) ? m_nRate1 : 0) + ((bLine2Change) ? m_nRate2 : 0) + ((bGapChange) ? m_nRateGap : 0)) - 1.0 < 0.00001"
, "/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
, 181, __extension__ __PRETTY_FUNCTION__));

  double nWidth = 0.0;
  if ( (!bInvalid) && (!aToCompare.empty()) )
  {
      nWidth = *aToCompare.begin();
      for (auto const& elem : aToCompare)
      {
          bInvalid = ( nWidth != elem );
          if (bInvalid)
              break;
      }
      nWidth = bInvalid ?  0.0 : nLine1 + nLine2 + nGap;
  }

  return nWidth;
197}

199static void lclDrawPolygon( OutputDevice& rDev, const basegfx::B2DPolygon& rPolygon, long nWidth, SvxBorderLineStyle nDashing )
200{
  AntialiasingFlags nOldAA = rDev.GetAntialiasing();
  rDev.SetAntialiasing( nOldAA & ~AntialiasingFlags::Enable );

  long nPix = rDev.PixelToLogic(Size(1, 1)).Width();
  basegfx::B2DPolyPolygon aPolygons = svtools::ApplyLineDashing(rPolygon, nDashing, nPix);

  // Handle problems of width 1px in Pixel mode: 0.5px gives a 1px line
  if (rDev.GetMapMode().GetMapUnit() == MapUnit::MapPixel && nWidth == nPix)
      nWidth = 0;

  for ( sal_uInt32 i = 0; i < aPolygons.count( ); i++ )
  {
      const basegfx::B2DPolygon& aDash = aPolygons.getB2DPolygon( i );
      basegfx::B2DPoint aStart = aDash.getB2DPoint( 0 );
      basegfx::B2DPoint aEnd = aDash.getB2DPoint( aDash.count() - 1 );

      basegfx::B2DVector aVector( aEnd - aStart );
      aVector.normalize( );
      const basegfx::B2DVector aPerpendicular(basegfx::getPerpendicular(aVector));

      const basegfx::B2DVector aWidthOffset( double( nWidth ) / 2 * aPerpendicular);
      basegfx::B2DPolygon aDashPolygon;
      aDashPolygon.append( aStart + aWidthOffset );
      aDashPolygon.append( aEnd + aWidthOffset );
      aDashPolygon.append( aEnd - aWidthOffset );
      aDashPolygon.append( aStart - aWidthOffset );
      aDashPolygon.setClosed( true );

      rDev.DrawPolygon( aDashPolygon );
  }

  rDev.SetAntialiasing( nOldAA );
233}

235namespace svtools {

237/**
* Dashing array must start with a line width and end with a blank width.
*/
240static std::vector<double> GetDashing( SvxBorderLineStyle nDashing )
241{
  std::vector<double> aPattern;
  switch (nDashing)
  {
      case SvxBorderLineStyle::DOTTED:
          aPattern.push_back( 1.0 ); // line
          aPattern.push_back( 2.0 ); // blank
      break;
      case SvxBorderLineStyle::DASHED:
          aPattern.push_back( 16.0 ); // line
          aPattern.push_back( 5.0 );  // blank
      break;
      case SvxBorderLineStyle::FINE_DASHED:
          aPattern.push_back( 6.0 ); // line
          aPattern.push_back( 2.0 ); // blank
      break;
      case SvxBorderLineStyle::DASH_DOT:
          aPattern.push_back( 16.0 ); // line
          aPattern.push_back( 5.0 );  // blank
          aPattern.push_back( 5.0 );  // line
          aPattern.push_back( 5.0 );  // blank
      break;
      case SvxBorderLineStyle::DASH_DOT_DOT:
          aPattern.push_back( 16.0 ); // line
          aPattern.push_back( 5.0 );  // blank
          aPattern.push_back( 5.0 );  // line
          aPattern.push_back( 5.0 );  // blank
          aPattern.push_back( 5.0 );  // line
          aPattern.push_back( 5.0 );  // blank
      break;
      default:
          ;
  }

  return aPattern;
276}

278namespace {

280class ApplyScale
281{
  double mfScale;
283public:
  explicit ApplyScale( double fScale ) : mfScale(fScale) {}
  void operator() ( double& rVal )
  {
      rVal *= mfScale;
  }
289};

291}

293std::vector<double> GetLineDashing( SvxBorderLineStyle nDashing, double fScale )
294{
  std::vector<double> aPattern = GetDashing(nDashing);
  std::for_each(aPattern.begin(), aPattern.end(), ApplyScale(fScale));
  return aPattern;
298}

300basegfx::B2DPolyPolygon ApplyLineDashing( const basegfx::B2DPolygon& rPolygon, SvxBorderLineStyle nDashing, double fScale )
301{
  std::vector<double> aPattern = GetDashing(nDashing);
  std::for_each(aPattern.begin(), aPattern.end(), ApplyScale(fScale));

  basegfx::B2DPolyPolygon aPolygons;

  if (aPattern.empty())
      aPolygons.append(rPolygon);
  else
      basegfx::utils::applyLineDashing(rPolygon, aPattern, &aPolygons);

  return aPolygons;
313}

315void DrawLine( OutputDevice& rDev, const Point& rP1, const Point& rP2,
  sal_uInt32 nWidth, SvxBorderLineStyle nDashing )
317{
  DrawLine( rDev, basegfx::B2DPoint( rP1.X(), rP1.Y() ),
          basegfx::B2DPoint( rP2.X(), rP2.Y( ) ), nWidth, nDashing );
320}

322void DrawLine( OutputDevice& rDev, const basegfx::B2DPoint& rP1, const basegfx::B2DPoint& rP2,
  sal_uInt32 nWidth, SvxBorderLineStyle nDashing )
324{
  basegfx::B2DPolygon aPolygon;
  aPolygon.append( rP1 );
  aPolygon.append( rP2 );
  lclDrawPolygon( rDev, aPolygon, nWidth, nDashing );
329}

331}

333static Size gUserItemSz;
334static int gFontNameBoxes;
335static size_t gPreviewsPerDevice;
336static std::vector<VclPtr<VirtualDevice>> gFontPreviewVirDevs;
337static std::vector<OUString> gRenderedFontNames;

339namespace
340{
  void calcCustomItemSize(const weld::ComboBox& rComboBox)
  {
      gUserItemSz = Size(rComboBox.get_approximate_digit_width() * 52, rComboBox.get_text_height());
      gUserItemSz.setHeight(gUserItemSz.Height() * 16);
      gUserItemSz.setHeight(gUserItemSz.Height() / 10);

      size_t nMaxDeviceHeight = SAL_MAX_INT16((sal_Int16) 0x7FFF) / 2; // see limitXCreatePixmap
      gPreviewsPerDevice = nMaxDeviceHeight / gUserItemSz.Height();
  }
350}

352IMPL_LINK(FontNameBox, SettingsChangedHdl, VclSimpleEvent&, rEvent, void)void FontNameBox::LinkStubSettingsChangedHdl(void * instance,
 VclSimpleEvent& data) { return static_cast<FontNameBox
 *>(instance)->SettingsChangedHdl(data); } void FontNameBox
::SettingsChangedHdl(VclSimpleEvent& rEvent)
353{
  if (rEvent.GetId() != VclEventId::ApplicationDataChanged)
      return;

  DataChangedEvent* pData = static_cast<DataChangedEvent*>(static_cast<VclWindowEvent&>(rEvent).GetData());
  if (pData->GetType() == DataChangedEventType::SETTINGS)
  {
      gFontPreviewVirDevs.clear();
      gRenderedFontNames.clear();
      calcCustomItemSize(*m_xComboBox);
      if (mbWYSIWYG)
          maUpdateIdle.Start();
  }
366}

368FontNameBox::FontNameBox(std::unique_ptr<weld::ComboBox> p)
  : m_xComboBox(std::move(p))
  , mnPreviewProgress(0)
  , mbWYSIWYG(false)
  , maUpdateIdle("FontNameBox Preview Update")
373{
  ++gFontNameBoxes;
  InitFontMRUEntriesFile();

  maUpdateIdle.SetPriority(TaskPriority::LOWEST);
  maUpdateIdle.SetInvokeHandler(LINK(this, FontNameBox, UpdateHdl)::tools::detail::makeLink( ::tools::detail::castTo<FontNameBox
 *>(this), &FontNameBox::LinkStubUpdateHdl));

  Application::AddEventListener(LINK(this, FontNameBox, SettingsChangedHdl)::tools::detail::makeLink( ::tools::detail::castTo<FontNameBox
 *>(this), &FontNameBox::LinkStubSettingsChangedHdl));
381}

383FontNameBox::~FontNameBox()
384{
  Application::RemoveEventListener(LINK(this, FontNameBox, SettingsChangedHdl)::tools::detail::makeLink( ::tools::detail::castTo<FontNameBox
 *>(this), &FontNameBox::LinkStubSettingsChangedHdl));

  if (mpFontList)
  {
      SaveMRUEntries (maFontMRUEntriesFile);
      ImplDestroyFontList();
  }
  --gFontNameBoxes;
  if (!gFontNameBoxes)
  {
      gFontPreviewVirDevs.clear();
      gRenderedFontNames.clear();
  }
398}

400void FontNameBox::SaveMRUEntries(const OUString& aFontMRUEntriesFile) const
401{
  OString aEntries(OUStringToOString(m_xComboBox->get_mru_entries(),
      RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76))));

  if (aEntries.isEmpty() || aFontMRUEntriesFile.isEmpty())
      return;

  SvFileStream aStream;
  aStream.Open( aFontMRUEntriesFile, StreamMode::WRITE | StreamMode::TRUNC );
  if( ! (aStream.IsOpen() && aStream.IsWritable()) )
  {
      SAL_INFO("svtools.control", "FontNameBox::SaveMRUEntries: opening mru entries file " << aFontMRUEntriesFile << " failed")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "svtools.control")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "FontNameBox::SaveMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "412" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "FontNameBox::SaveMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FontNameBox::SaveMRUEntries: opening mru entries file " <<
 aFontMRUEntriesFile << " failed"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "412" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "FontNameBox::SaveMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "412" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "FontNameBox::SaveMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FontNameBox::SaveMRUEntries: opening mru entries file " <<
 aFontMRUEntriesFile << " failed"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "412" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return;
  }

  aStream.SetLineDelimiter( LINEEND_LF );
  aStream.WriteLine( aEntries );
  aStream.WriteLine( OString() );
419}

421void FontNameBox::LoadMRUEntries( const OUString& aFontMRUEntriesFile )
422{
  if (aFontMRUEntriesFile.isEmpty())
      return;

  if (!officecfg::Office::Common::Font::View::ShowFontBoxWYSIWYG::get())
      return;

  SvFileStream aStream( aFontMRUEntriesFile, StreamMode::READ );
  if( ! aStream.IsOpen() )
  {
      SAL_INFO("svtools.control", "FontNameBox::LoadMRUEntries: opening mru entries file " << aFontMRUEntriesFile << " failed")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "svtools.control")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "FontNameBox::LoadMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "432" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "FontNameBox::LoadMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FontNameBox::LoadMRUEntries: opening mru entries file " <<
 aFontMRUEntriesFile << " failed"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "432" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "FontNameBox::LoadMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "432" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "FontNameBox::LoadMRUEntries: opening mru entries file "
 << aFontMRUEntriesFile << " failed"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FontNameBox::LoadMRUEntries: opening mru entries file " <<
 aFontMRUEntriesFile << " failed"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools.control"), ("/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
 ":" "432" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return;
  }

  OString aLine;
  aStream.ReadLine( aLine );
  OUString aEntries = OStringToOUString(aLine,
      RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76)));
  m_xComboBox->set_mru_entries(aEntries);
441}

443void FontNameBox::InitFontMRUEntriesFile()
444{
  OUString sUserConfigDir("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER"program" "/" SAL_CONFIGFILE( "bootstrap")"bootstrap" "rc" "::UserInstallation}");
  rtl::Bootstrap::expandMacros(sUserConfigDir);

  maFontMRUEntriesFile = sUserConfigDir;
  if( !maFontMRUEntriesFile.isEmpty() )
  {
      maFontMRUEntriesFile += FONTNAMEBOXMRUENTRIESFILE"/user/config/fontnameboxmruentries";
  }
453}

455void FontNameBox::ImplDestroyFontList()
456{
  mpFontList.reset();
  mnPreviewProgress = 0;
  maUpdateIdle.Stop();
460}

462void FontNameBox::Fill( const FontList* pList )
463{
  // store old text and clear box
  OUString aOldText = m_xComboBox->get_active_text();
  OUString rEntries = m_xComboBox->get_mru_entries();
  bool bLoadFromFile = rEntries.isEmpty();
  m_xComboBox->freeze();
  m_xComboBox->clear();

  ImplDestroyFontList();
  mpFontList.reset(new ImplFontList);

  // insert fonts
  size_t nFontCount = pList->GetFontNameCount();
  for (size_t i = 0; i < nFontCount; ++i)
  {
      const FontMetric& rFontMetric = pList->GetFontName(i);
      m_xComboBox->append(OUString::number(i), rFontMetric.GetFamilyName());
      mpFontList->push_back(rFontMetric);
  }

  if (bLoadFromFile)
      LoadMRUEntries(maFontMRUEntriesFile);
  else
      m_xComboBox->set_mru_entries(rEntries);

  m_xComboBox->thaw();

  if (mbWYSIWYG && nFontCount)
  {
      assert(mnPreviewProgress == 0 && "ImplDestroyFontList wasn't called")(static_cast <bool> (mnPreviewProgress == 0 && "ImplDestroyFontList wasn't called"
) ? void (0) : __assert_fail ("mnPreviewProgress == 0 && \"ImplDestroyFontList wasn't called\""
, "/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
, 492, __extension__ __PRETTY_FUNCTION__));
      maUpdateIdle.Start();
  }

  // restore text
  if (!aOldText.isEmpty())
      set_active_or_entry_text(aOldText);
499}

501void FontNameBox::EnableWYSIWYG(bool bEnable)
502{
  if (comphelper::LibreOfficeKit::isActive())
      return;
  if (mbWYSIWYG == bEnable)
      return;
  mbWYSIWYG = bEnable;

  if (mbWYSIWYG)
  {
      calcCustomItemSize(*m_xComboBox);
      m_xComboBox->connect_custom_get_size(LINK(this, FontNameBox, CustomGetSizeHdl)::tools::detail::makeLink( ::tools::detail::castTo<FontNameBox
 *>(this), &FontNameBox::LinkStubCustomGetSizeHdl));
      m_xComboBox->connect_custom_render(LINK(this, FontNameBox, CustomRenderHdl)::tools::detail::makeLink( ::tools::detail::castTo<FontNameBox
 *>(this), &FontNameBox::LinkStubCustomRenderHdl));
  }
  else
  {
      m_xComboBox->connect_custom_get_size(Link<OutputDevice&, Size>());
      m_xComboBox->connect_custom_render(Link<weld::ComboBox::render_args, void>());
  }
  m_xComboBox->set_custom_renderer(mbWYSIWYG);
521}

523IMPL_LINK_NOARG(FontNameBox, CustomGetSizeHdl, OutputDevice&, Size)Size FontNameBox::LinkStubCustomGetSizeHdl(void * instance, OutputDevice
& data) { return static_cast<FontNameBox *>(instance
)->CustomGetSizeHdl(data); } Size FontNameBox::CustomGetSizeHdl
(__attribute__ ((unused)) OutputDevice&)
524{
  return mbWYSIWYG ? gUserItemSz : Size();
526}

528namespace
529{
  long shrinkFontToFit(OUString const &rSampleText, long nH, vcl::Font &rFont, OutputDevice &rDevice, tools::Rectangle &rTextRect)
  {
      long nWidth = 0;

      Size aSize( rFont.GetFontSize() );

      //Make sure it fits in the available height
      while (aSize.Height() > 0)
      {
          if (!rDevice.GetTextBoundRect(rTextRect, rSampleText))
              break;
          if (rTextRect.GetHeight() <= nH)
          {
              nWidth = rTextRect.GetWidth();
              break;
          }

          aSize.AdjustHeight( -(EXTRAFONTSIZE5) );
          rFont.SetFontSize(aSize);
          rDevice.SetFont(rFont);
      }

      return nWidth;
  }
554}

556IMPL_LINK_NOARG(FontNameBox, UpdateHdl, Timer*, void)void FontNameBox::LinkStubUpdateHdl(void * instance, Timer* data
) { return static_cast<FontNameBox *>(instance)->UpdateHdl
(data); } void FontNameBox::UpdateHdl(__attribute__ ((unused)
) Timer*)
557{
  CachePreview(mnPreviewProgress++, nullptr);
  // tdf#132536 limit to ~25 pre-rendered for now. The font caches look
  // b0rked, the massive charmaps are ~never swapped out, and don't count
  // towards the size of a font in the font cache and if the freetype font
  // cache size is set experimentally very low then we crash, so there's an
  // awful lot to consider there.
  if (mnPreviewProgress < std::min<size_t>(25, mpFontList->size()))
      maUpdateIdle.Start();
566}

568static void DrawPreview(const FontMetric& rFontMetric, const Point& rTopLeft, OutputDevice& rDevice, bool bSelected)
569{
  rDevice.Push(PushFlags::TEXTCOLOR);

  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  if (bSelected)
      rDevice.SetTextColor(rStyleSettings.GetHighlightTextColor());
  else
      rDevice.SetTextColor(rStyleSettings.GetDialogTextColor());

  long nX = rTopLeft.X();
  long nH = gUserItemSz.Height();

  nX += IMGOUTERTEXTSPACE5;

  const bool bSymbolFont = isSymbolFont(rFontMetric);

  vcl::Font aOldFont(rDevice.GetFont());
  Size aSize( aOldFont.GetFontSize() );
  aSize.AdjustHeight(EXTRAFONTSIZE5 );
  vcl::Font aFont( rFontMetric );
  aFont.SetFontSize( aSize );
  rDevice.SetFont(aFont);

  bool bUsingCorrectFont = true;
  tools::Rectangle aTextRect;

  // Preview the font name
  const OUString& sFontName = rFontMetric.GetFamilyName();

  //If it shouldn't or can't draw its own name because it doesn't have the glyphs
  if (!canRenderNameOfSelectedFont(rDevice))
      bUsingCorrectFont = false;
  else
  {
      //Make sure it fits in the available height, shrinking the font if necessary
      bUsingCorrectFont = shrinkFontToFit(sFontName, nH, aFont, rDevice, aTextRect) != 0;
  }

  if (!bUsingCorrectFont)
  {
      rDevice.SetFont(aOldFont);
      rDevice.GetTextBoundRect(aTextRect, sFontName);
  }

  long nTextHeight = aTextRect.GetHeight();
  long nDesiredGap = (nH-nTextHeight)/2;
  long nVertAdjust = nDesiredGap - aTextRect.Top();
  Point aPos( nX, rTopLeft.Y() + nVertAdjust );
  rDevice.DrawText(aPos, sFontName);
  long nTextX = aPos.X() + aTextRect.GetWidth() + GAPTOEXTRAPREVIEW10;

  if (!bUsingCorrectFont)
      rDevice.SetFont(aFont);

  OUString sSampleText;

  if (!bSymbolFont)
  {
      const bool bNameBeginsWithLatinText = rFontMetric.GetFamilyName()[0] <= 'z';

      if (bNameBeginsWithLatinText || !bUsingCorrectFont)
          sSampleText = makeShortRepresentativeTextForSelectedFont(rDevice);
  }

  //If we're not a symbol font, but could neither render our own name and
  //we can't determine what script it would like to render, then try a
  //few well known scripts
  if (sSampleText.isEmpty() && !bUsingCorrectFont)
  {
      static const UScriptCode aScripts[] =
      {
          USCRIPT_ARABIC,
          USCRIPT_HEBREW,

          USCRIPT_BENGALI,
          USCRIPT_GURMUKHI,
          USCRIPT_GUJARATI,
          USCRIPT_ORIYA,
          USCRIPT_TAMIL,
          USCRIPT_TELUGU,
          USCRIPT_KANNADA,
          USCRIPT_MALAYALAM,
          USCRIPT_SINHALA,
          USCRIPT_DEVANAGARI,

          USCRIPT_THAI,
          USCRIPT_LAO,
          USCRIPT_GEORGIAN,
          USCRIPT_TIBETAN,
          USCRIPT_SYRIAC,
          USCRIPT_MYANMAR,
          USCRIPT_ETHIOPIC,
          USCRIPT_KHMER,
          USCRIPT_MONGOLIAN,

          USCRIPT_KOREAN,
          USCRIPT_JAPANESE,
          USCRIPT_HAN,
          USCRIPT_SIMPLIFIED_HAN,
          USCRIPT_TRADITIONAL_HAN,

          USCRIPT_GREEK
      };

      for (const UScriptCode& rScript : aScripts)
      {
          OUString sText = makeShortRepresentativeTextForScript(rScript);
          if (!sText.isEmpty())
          {
              bool bHasSampleTextGlyphs = (-1 == rDevice.HasGlyphs(aFont, sText));
              if (bHasSampleTextGlyphs)
              {
                  sSampleText = sText;
                  break;
              }
          }
      }

      static const UScriptCode aMinimalScripts[] =
      {
          USCRIPT_HEBREW, //e.g. biblical hebrew
          USCRIPT_GREEK
      };

      for (const UScriptCode& rMinimalScript : aMinimalScripts)
      {
          OUString sText = makeShortMinimalTextForScript(rMinimalScript);
          if (!sText.isEmpty())
          {
              bool bHasSampleTextGlyphs = (-1 == rDevice.HasGlyphs(aFont, sText));
              if (bHasSampleTextGlyphs)
              {
                  sSampleText = sText;
                  break;
              }
          }
      }
  }

  //If we're a symbol font, or for some reason the font still couldn't
  //render something representative of what it would like to render then
  //make up some semi-random text that it *can* display
  if (bSymbolFont || (!bUsingCorrectFont && sSampleText.isEmpty()))
      sSampleText = makeShortRepresentativeSymbolTextForSelectedFont(rDevice);

  if (!sSampleText.isEmpty())
  {
      const Size &rItemSize = gUserItemSz;

      //leave a little border at the edge
      long nSpace = rItemSize.Width() - nTextX - IMGOUTERTEXTSPACE5;
      if (nSpace >= 0)
      {
          //Make sure it fits in the available height, and get how wide that would be
          long nWidth = shrinkFontToFit(sSampleText, nH, aFont, rDevice, aTextRect);
          //Chop letters off until it fits in the available width
          while (nWidth > nSpace || nWidth > gUserItemSz.Width())
          {
              sSampleText = sSampleText.copy(0, sSampleText.getLength()-1);
              nWidth = rDevice.GetTextBoundRect(aTextRect, sSampleText) ?
                       aTextRect.GetWidth() : 0;
          }

          //center the text on the line
          if (!sSampleText.isEmpty() && nWidth)
          {
              nTextHeight = aTextRect.GetHeight();
              nDesiredGap = (nH-nTextHeight)/2;
              nVertAdjust = nDesiredGap - aTextRect.Top();
              aPos = Point(nTextX + nSpace - nWidth, rTopLeft.Y() + nVertAdjust);
              rDevice.DrawText(aPos, sSampleText);
          }
      }
  }

  rDevice.SetFont(aOldFont);
  rDevice.Pop();
746}

748OutputDevice& FontNameBox::CachePreview(size_t nIndex, Point* pTopLeft)
749{
  SolarMutexGuard aGuard;
  const FontMetric& rFontMetric = (*mpFontList)[nIndex];
  const OUString& rFontName = rFontMetric.GetFamilyName();

  size_t nPreviewIndex;
  auto xFind = std::find(gRenderedFontNames.begin(), gRenderedFontNames.end(), rFontName);
  bool bPreviewAvailable = xFind != gRenderedFontNames.end();
  if (!bPreviewAvailable)
  {
      nPreviewIndex = gRenderedFontNames.size();
      gRenderedFontNames.push_back(rFontName);
  }
  else
      nPreviewIndex = std::distance(gRenderedFontNames.begin(), xFind);

  size_t nPage = nPreviewIndex / gPreviewsPerDevice;
  size_t nIndexInPage = nPreviewIndex - (nPage * gPreviewsPerDevice);

  Point aTopLeft(0, gUserItemSz.Height() * nIndexInPage);

  if (!bPreviewAvailable)
  {
      if (nPage >= gFontPreviewVirDevs.size())
      {
          gFontPreviewVirDevs.emplace_back(m_xComboBox->create_render_virtual_device());
          VirtualDevice& rDevice = *gFontPreviewVirDevs.back();
          rDevice.SetOutputSizePixel(Size(gUserItemSz.Width(), gUserItemSz.Height() * gPreviewsPerDevice));
          if (vcl::Window* pDefaultDevice = dynamic_cast<vcl::Window*>(Application::GetDefaultDevice()))
              pDefaultDevice->SetPointFont(rDevice, m_xComboBox->get_font());
          assert(gFontPreviewVirDevs.size() == nPage + 1)(static_cast <bool> (gFontPreviewVirDevs.size() == nPage
 + 1) ? void (0) : __assert_fail ("gFontPreviewVirDevs.size() == nPage + 1"
, "/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
, 779, __extension__ __PRETTY_FUNCTION__));
      }

      DrawPreview(rFontMetric, aTopLeft, *gFontPreviewVirDevs.back(), false);
  }

  if (pTopLeft)
      *pTopLeft = aTopLeft;

  return *gFontPreviewVirDevs[nPage];
789}

791IMPL_LINK(FontNameBox, CustomRenderHdl, weld::ComboBox::render_args, aPayload, void)void FontNameBox::LinkStubCustomRenderHdl(void * instance, weld
::ComboBox::render_args data) { return static_cast<FontNameBox
 *>(instance)->CustomRenderHdl(data); } void FontNameBox
::CustomRenderHdl(weld::ComboBox::render_args aPayload)
792{
  vcl::RenderContext& rRenderContext = std::get<0>(aPayload);
  const ::tools::Rectangle& rRect = std::get<1>(aPayload);
  bool bSelected = std::get<2>(aPayload);
  const OUString& rId = std::get<3>(aPayload);

  sal_uInt32 nIndex = rId.toUInt32();

  Point aDestPoint(rRect.TopLeft());
  auto nMargin = (rRect.GetHeight() - gUserItemSz.Height()) / 2;
  aDestPoint.AdjustY(nMargin);

  if (bSelected)
  {
      const FontMetric& rFontMetric = (*mpFontList)[nIndex];
      DrawPreview(rFontMetric, aDestPoint, rRenderContext, true);
  }
  else
  {
      // use cache of unselected entries
      Point aTopLeft;
      OutputDevice& rDevice = CachePreview(nIndex, &aTopLeft);

      rRenderContext.DrawOutDev(aDestPoint, gUserItemSz,
                                aTopLeft, gUserItemSz,
                                rDevice);
  }
819}

821void FontNameBox::set_active_or_entry_text(const OUString& rText)
822{
  const int nFound = m_xComboBox->find_text(rText);
  if (nFound != -1)
      m_xComboBox->set_active(nFound);
  m_xComboBox->set_entry_text(rText);
827}

829FontStyleBox::FontStyleBox(std::unique_ptr<weld::ComboBox> p)
  : m_xComboBox(std::move(p))
831{
  //Use the standard texts to get an optimal size and stick to that size.
  //That should stop the character dialog dancing around.
  auto nMaxLen = m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_LIGHTreinterpret_cast<char const *>("STR_SVT_STYLE_LIGHT" "\004"
 u8"Light"))).Width();
  nMaxLen = std::max(nMaxLen, m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_LIGHT_ITALICreinterpret_cast<char const *>("STR_SVT_STYLE_LIGHT_ITALIC"
 "\004" u8"Light Italic"))).Width());
  nMaxLen = std::max(nMaxLen, m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_NORMALreinterpret_cast<char const *>("STR_SVT_STYLE_NORMAL" "\004"
 u8"Regular"))).Width());
  nMaxLen = std::max(nMaxLen, m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_NORMAL_ITALICreinterpret_cast<char const *>("STR_SVT_STYLE_NORMAL_ITALIC"
 "\004" u8"Italic"))).Width());
  nMaxLen = std::max(nMaxLen, m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_BOLDreinterpret_cast<char const *>("STR_SVT_STYLE_BOLD" "\004"
 u8"Bold"))).Width());
  nMaxLen = std::max(nMaxLen, m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_BOLD_ITALICreinterpret_cast<char const *>("STR_SVT_STYLE_BOLD_ITALIC"
 "\004" u8"Bold Italic"))).Width());
  nMaxLen = std::max(nMaxLen, m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_BLACKreinterpret_cast<char const *>("STR_SVT_STYLE_BLACK" "\004"
 u8"Black"))).Width());
  nMaxLen = std::max(nMaxLen, m_xComboBox->get_pixel_size(SvtResId(STR_SVT_STYLE_BLACK_ITALICreinterpret_cast<char const *>("STR_SVT_STYLE_BLACK_ITALIC"
 "\004" u8"Black Italic"))).Width());
  m_xComboBox->set_entry_width_chars(std::ceil(nMaxLen / m_xComboBox->get_approximate_digit_width()));
843}

845void FontStyleBox::Fill( const OUString& rName, const FontList* pList )
846{
  m_xComboBox->freeze();
  OUString aOldText = m_xComboBox->get_active_text();
  int nPos = m_xComboBox->get_active();
  m_xComboBox->clear();

  // does a font with this name already exist?
  sal_Handle hFontMetric = pList->GetFirstFontMetric( rName );
  if ( hFontMetric )
  {
      OUString aStyleText;
      FontWeight  eLastWeight = WEIGHT_DONTKNOW;
      FontItalic  eLastItalic = ITALIC_NONE;
      FontWidth   eLastWidth = WIDTH_DONTKNOW;
      bool        bNormal = false;
      bool        bItalic = false;
      bool        bBold = false;
      bool        bBoldItalic = false;
      bool        bInsert = false;
      FontMetric    aFontMetric;
      while ( hFontMetric )
      {
          aFontMetric = FontList::GetFontMetric( hFontMetric );

          FontWeight  eWeight = aFontMetric.GetWeight();
          FontItalic  eItalic = aFontMetric.GetItalic();
          FontWidth   eWidth = aFontMetric.GetWidthType();
          // Only if the attributes are different, we insert the
          // Font to avoid double Entries in different languages
          if ( (eWeight != eLastWeight) || (eItalic != eLastItalic) ||
               (eWidth != eLastWidth) )
          {
              if ( bInsert )
                  m_xComboBox->append_text(aStyleText);

              if ( eWeight <= WEIGHT_NORMAL )
              {
                  if ( eItalic != ITALIC_NONE )
                      bItalic = true;
                  else
                      bNormal = true;
              }
              else
              {
                  if ( eItalic != ITALIC_NONE )
                      bBoldItalic = true;
                  else
                      bBold = true;
              }

              // For wrong StyleNames we replace this with the correct once
              aStyleText = pList->GetStyleName( aFontMetric );
              bInsert = m_xComboBox->find_text(aStyleText) == -1;
              if ( !bInsert )
              {
                  aStyleText = pList->GetStyleName( eWeight, eItalic );
                  bInsert = m_xComboBox->find_text(aStyleText) == -1;
              }

              eLastWeight = eWeight;
              eLastItalic = eItalic;
              eLastWidth = eWidth;
          }
          else
          {
              if ( bInsert )
              {
                  // If we have two names for the same attributes
                  // we prefer the translated standard names
                  const OUString& rAttrStyleText = pList->GetStyleName( eWeight, eItalic );
                  if (rAttrStyleText != aStyleText)
                  {
                      OUString aTempStyleText = pList->GetStyleName( aFontMetric );
                      if (rAttrStyleText == aTempStyleText)
                          aStyleText = rAttrStyleText;
                      bInsert = m_xComboBox->find_text(aStyleText) == -1;
                  }
              }
          }

          if ( !bItalic && (aStyleText == pList->GetItalicStr()) )
              bItalic = true;
          else if ( !bBold && (aStyleText == pList->GetBoldStr()) )
              bBold = true;
          else if ( !bBoldItalic && (aStyleText == pList->GetBoldItalicStr()) )
              bBoldItalic = true;

          hFontMetric = FontList::GetNextFontMetric( hFontMetric );
      }

      if ( bInsert )
          m_xComboBox->append_text(aStyleText);

      // certain style as copy
      if ( bNormal )
      {
          if ( !bItalic )
              m_xComboBox->append_text(pList->GetItalicStr());
          if ( !bBold )
              m_xComboBox->append_text(pList->GetBoldStr());
      }
      if ( !bBoldItalic )
      {
          if ( bNormal || bItalic || bBold )
              m_xComboBox->append_text(pList->GetBoldItalicStr());
      }
      if (!aOldText.isEmpty())
      {
          int nFound = m_xComboBox->find_text(aOldText);
          if (nFound != -1)
              m_xComboBox->set_active(nFound);
          else
          {
              if (nPos >= m_xComboBox->get_count())
                  m_xComboBox->set_active(0);
              else
                  m_xComboBox->set_active(nPos);
          }
      }
  }
  else
  {
      // insert standard styles if no font
      m_xComboBox->append_text(pList->GetNormalStr());
      m_xComboBox->append_text(pList->GetItalicStr());
      m_xComboBox->append_text(pList->GetBoldStr());
      m_xComboBox->append_text(pList->GetBoldItalicStr());
      if (!aOldText.isEmpty())
      {
          if (nPos >= m_xComboBox->get_count())
              m_xComboBox->set_active(0);
          else
              m_xComboBox->set_active(nPos);
      }
  }
  m_xComboBox->thaw();
982}

984FontSizeBox::FontSizeBox(std::unique_ptr<weld::ComboBox> p)
  : pFontList(nullptr)
  , nSavedValue(0)
  , nMin(20)
  , nMax(9999)
  , eUnit(FieldUnit::POINT)
  , nDecimalDigits(1)
  , nRelMin(0)
  , nRelMax(0)
  , nRelStep(0)
  , nPtRelMin(0)
  , nPtRelMax(0)
  , nPtRelStep(0)
  , bRelativeMode(false)
  , bRelative(false)
  , bPtRelative(false)
  , bStdSize(false)
  , m_xComboBox(std::move(p))
1002{
  m_xComboBox->set_entry_width_chars(std::ceil(m_xComboBox->get_pixel_size(format_number(105)).Width() /
                                               m_xComboBox->get_approximate_digit_width()));
  m_xComboBox->connect_focus_out(LINK(this, FontSizeBox, ReformatHdl)::tools::detail::makeLink( ::tools::detail::castTo<FontSizeBox
 *>(this), &FontSizeBox::LinkStubReformatHdl));
  m_xComboBox->connect_changed(LINK(this, FontSizeBox, ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<FontSizeBox
 *>(this), &FontSizeBox::LinkStubModifyHdl));
1007}

1009void FontSizeBox::set_active_or_entry_text(const OUString& rText)
1010{
  const int nFound = m_xComboBox->find_text(rText);
  if (nFound != -1)
      m_xComboBox->set_active(nFound);
  m_xComboBox->set_entry_text(rText);
1015}

1017IMPL_LINK(FontSizeBox, ReformatHdl, weld::Widget&, rWidget, void)void FontSizeBox::LinkStubReformatHdl(void * instance, weld::
Widget& data) { return static_cast<FontSizeBox *>(instance
)->ReformatHdl(data); } void FontSizeBox::ReformatHdl(weld
::Widget& rWidget)
1018{
  FontSizeNames aFontSizeNames(Application::GetSettings().GetUILanguageTag().getLanguageType());
  if (!bRelativeMode || !aFontSizeNames.IsEmpty())
  {
      if (aFontSizeNames.Name2Size(m_xComboBox->get_active_text()) != 0)
          return;
  }

  set_value(get_value());

  m_aFocusOutHdl.Call(rWidget);
1029}

1031IMPL_LINK(FontSizeBox, ModifyHdl, weld::ComboBox&, rBox, void)void FontSizeBox::LinkStubModifyHdl(void * instance, weld::ComboBox
& data) { return static_cast<FontSizeBox *>(instance
)->ModifyHdl(data); } void FontSizeBox::ModifyHdl(weld::ComboBox
& rBox)
1032{
  if (bRelativeMode)
  {
      OUString aStr = comphelper::string::stripStart(rBox.get_active_text(), ' ');

      bool bNewMode = bRelative;
      bool bOldPtRelMode = bPtRelative;

      if ( bRelative )
      {
          bPtRelative = false;
          const sal_Unicode* pStr = aStr.getStr();
          while ( *pStr )
          {
              if ( ((*pStr < '0') || (*pStr > '9')) && (*pStr != '%') && !unicode::isSpace(*pStr) )
              {
                  if ( ('-' == *pStr || '+' == *pStr) && !bPtRelative )
                      bPtRelative = true;
                  else if ( bPtRelative && 'p' == *pStr && 't' == *++pStr )
                      ;
                  else
                  {
                      bNewMode = false;
                      break;
                  }
              }
              pStr++;
          }
      }
      else if (!aStr.isEmpty())
      {
          if ( -1 != aStr.indexOf('%') )
          {
              bNewMode = true;
              bPtRelative = false;
          }

          if ( '-' == aStr[0] || '+' == aStr[0] )
          {
              bNewMode = true;
              bPtRelative = true;
          }
      }

      if ( bNewMode != bRelative || bPtRelative != bOldPtRelMode )
          SetRelative( bNewMode );
  }
  m_aChangeHdl.Call(rBox);
1080}

1082void FontSizeBox::Fill( const FontMetric* pFontMetric, const FontList* pList )
1083{
  // remember for relative mode
  pFontList = pList;

  // no font sizes need to be set for relative mode
  if ( bRelative )
      return;

  // query font sizes
  const int* pTempAry;
  const int* pAry = nullptr;

  if( pFontMetric )
  {
      aFontMetric = *pFontMetric;
      pAry = pList->GetSizeAry( *pFontMetric );
  }
  else
  {
      pAry = FontList::GetStdSizeAry();
  }

  // first insert font size names (for simplified/traditional chinese)
  FontSizeNames aFontSizeNames( Application::GetSettings().GetUILanguageTag().getLanguageType() );
  if ( pAry == FontList::GetStdSizeAry() )
  {
      // for standard sizes we don't need to bother
      if (bStdSize && m_xComboBox->get_count() && aFontSizeNames.IsEmpty())
          return;
      bStdSize = true;
  }
  else
      bStdSize = false;

  int nSelectionStart, nSelectionEnd;
  m_xComboBox->get_entry_selection_bounds(nSelectionStart, nSelectionEnd);
  OUString aStr = m_xComboBox->get_active_text();

  m_xComboBox->freeze();
  m_xComboBox->clear();
  int nPos = 0;

  if ( !aFontSizeNames.IsEmpty() )
  {
      if ( pAry == FontList::GetStdSizeAry() )
      {
          // for scalable fonts all font size names
          sal_uLong nCount = aFontSizeNames.Count();
          for( sal_uLong i = 0; i < nCount; i++ )
          {
              OUString aSizeName = aFontSizeNames.GetIndexName( i );
              int nSize = aFontSizeNames.GetIndexSize( i );
              OUString sId(OUString::number(-nSize)); // mark as special
              m_xComboBox->insert(nPos, aSizeName, &sId, nullptr, nullptr);
              nPos++;
          }
      }
      else
      {
          // for fixed size fonts only selectable font size names
          pTempAry = pAry;
          while ( *pTempAry )
          {
              OUString aSizeName = aFontSizeNames.Size2Name( *pTempAry );
              if ( !aSizeName.isEmpty() )
              {
                  OUString sId(OUString::number(-(*pTempAry))); // mark as special
                  m_xComboBox->insert(nPos, aSizeName, &sId, nullptr, nullptr);
                  nPos++;
              }
              pTempAry++;
          }
      }
  }

  // then insert numerical font size values
  pTempAry = pAry;
  while (*pTempAry)
  {
      InsertValue(*pTempAry);
      ++pTempAry;
  }

  set_active_or_entry_text(aStr);
  m_xComboBox->select_entry_region(nSelectionStart, nSelectionEnd);
  m_xComboBox->thaw();
1169}

1171void FontSizeBox::EnableRelativeMode( sal_uInt16 nNewMin, sal_uInt16 nNewMax, sal_uInt16 nStep )
1172{
  bRelativeMode = true;
  nRelMin       = nNewMin;
  nRelMax       = nNewMax;
  nRelStep      = nStep;
  SetUnit(FieldUnit::POINT);
1178}

1180void FontSizeBox::EnablePtRelativeMode( short nNewMin, short nNewMax, short nStep )
1181{
  bRelativeMode = true;
  nPtRelMin     = nNewMin;
  nPtRelMax     = nNewMax;
  nPtRelStep    = nStep;
  SetUnit(FieldUnit::POINT);
1187}

1189void FontSizeBox::InsertValue(int i)
1190{
  OUString sNumber(OUString::number(i));
  m_xComboBox->append(sNumber, format_number(i));
1193}

1195void FontSizeBox::SetRelative( bool bNewRelative )
1196{
  if ( !bRelativeMode )
      return;

  int nSelectionStart, nSelectionEnd;
  m_xComboBox->get_entry_selection_bounds(nSelectionStart, nSelectionEnd);
  OUString aStr = comphelper::string::stripStart(m_xComboBox->get_active_text(), ' ');

  if (bNewRelative)
  {
      bRelative = true;
      bStdSize = false;

      m_xComboBox->clear();

      if (bPtRelative)
      {
          SetDecimalDigits( 1 );
          SetRange(nPtRelMin, nPtRelMax);
          SetUnit(FieldUnit::POINT);

          short i = nPtRelMin, n = 0;
          // JP 30.06.98: more than 100 values are not useful
          while ( i <= nPtRelMax && n++ < 100 )
          {
              InsertValue( i );
              i = i + nPtRelStep;
          }
      }
      else
      {
          SetDecimalDigits(0);
          SetRange(nRelMin, nRelMax);
          SetUnit(FieldUnit::PERCENT);

          sal_uInt16 i = nRelMin;
          while ( i <= nRelMax )
          {
              InsertValue( i );
              i = i + nRelStep;
          }
      }
  }
  else
  {
      if (pFontList)
          m_xComboBox->clear();
      bRelative = bPtRelative = false;
      SetDecimalDigits(1);
      SetRange(20, 9999);
      SetUnit(FieldUnit::POINT);
      if ( pFontList)
          Fill( &aFontMetric, pFontList );
  }

  set_active_or_entry_text(aStr);
  m_xComboBox->select_entry_region(nSelectionStart, nSelectionEnd);
1253}

1255OUString FontSizeBox::format_number(int nValue) const
1256{
  OUString sRet;

  //pawn percent off to icu to decide whether percent is separated from its number for this locale
  if (eUnit == FieldUnit::PERCENT)
  {
      double fValue = nValue;
      fValue /= weld::SpinButton::Power10(nDecimalDigits);
      sRet = unicode::formatPercent(fValue, Application::GetSettings().GetUILanguageTag());
  }
  else
  {
      const SvtSysLocale aSysLocale;
      const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
      sRet = rLocaleData.getNum(nValue, nDecimalDigits, true, false);
      if (eUnit != FieldUnit::NONE && eUnit != FieldUnit::DEGREE)
          sRet += " ";
      assert(eUnit != FieldUnit::PERCENT)(static_cast <bool> (eUnit != FieldUnit::PERCENT) ? void
 (0) : __assert_fail ("eUnit != FieldUnit::PERCENT", "/home/maarten/src/libreoffice/core/svtools/source/control/ctrlbox.cxx"
, 1273, __extension__ __PRETTY_FUNCTION__));
      sRet += weld::MetricSpinButton::MetricToString(eUnit);
  }

  if (bRelativeMode && bPtRelative && (0 <= nValue) && !sRet.isEmpty())
      sRet = "+" + sRet;

  return sRet;
1281}

1283void FontSizeBox::SetValue(int nNewValue, FieldUnit eInUnit)
1284{
  auto nTempValue = vcl::ConvertValue(nNewValue, 0, GetDecimalDigits(), eInUnit, GetUnit());
  if (nTempValue < nMin)
      nTempValue = nMin;
  else if (nTempValue > nMax)
      nTempValue = nMax;
  if (!bRelative)
  {
      FontSizeNames aFontSizeNames(Application::GetSettings().GetUILanguageTag().getLanguageType());
      // conversion loses precision; however font sizes should
      // never have a problem with that
      OUString aName = aFontSizeNames.Size2Name(nTempValue);
      if (!aName.isEmpty() && m_xComboBox->find_text(aName) != -1)
      {
          m_xComboBox->set_active_text(aName);
          return;
      }
  }
  OUString aResult = format_number(nTempValue);
  set_active_or_entry_text(aResult);
1304}

1306void FontSizeBox::set_value(int nNewValue)
1307{
  SetValue(nNewValue, eUnit);
1309}

1311int FontSizeBox::get_value() const
1312{
  OUString aStr = m_xComboBox->get_active_text();
  if (!bRelative)
  {
      FontSizeNames aFontSizeNames(Application::GetSettings().GetUILanguageTag().getLanguageType());
      auto nValue = aFontSizeNames.Name2Size(aStr);
      if (nValue)
          return vcl::ConvertValue(nValue, 0, GetDecimalDigits(), GetUnit(), GetUnit());
  }

  const SvtSysLocale aSysLocale;
  const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
  double fResult(0.0);
  (void)vcl::TextToValue(aStr, fResult, 0, GetDecimalDigits(), rLocaleData, GetUnit());
  if (!aStr.isEmpty())
  {
      if (fResult < nMin)
          fResult = nMin;
      else if (fResult > nMax)
          fResult = nMax;
  }
  return fResult;
1334}

1336SvxBorderLineStyle SvtLineListBox::GetSelectEntryStyle() const
1337{
  if (m_xLineSet->IsNoSelection())
      return SvxBorderLineStyle::NONE;
  auto nId = m_xLineSet->GetSelectedItemId();
  return static_cast<SvxBorderLineStyle>(nId - 1);
1342}

1344namespace
1345{
  Size getPreviewSize(const weld::Widget& rControl)
  {
      return Size(rControl.get_approximate_digit_width() * 15, rControl.get_text_height());
  }
1350}

1352void SvtLineListBox::ImpGetLine( long nLine1, long nLine2, long nDistance,
                          Color aColor1, Color aColor2, Color aColorDist,
                          SvxBorderLineStyle nStyle, BitmapEx& rBmp )
1355{
  Size aSize(getPreviewSize(*m_xControl));

  // SourceUnit to Twips
  if ( eSourceUnit == FieldUnit::POINT )
  {
      nLine1      /= 5;
      nLine2      /= 5;
      nDistance   /= 5;
  }

  // Paint the lines
  aSize = aVirDev->PixelToLogic( aSize );
  long nPix = aVirDev->PixelToLogic( Size( 0, 1 ) ).Height();
  sal_uInt32 n1 = nLine1;
  sal_uInt32 n2 = nLine2;
  long nDist  = nDistance;
  n1 += nPix-1;
  n1 -= n1%nPix;
  if ( n2 )
  {
      nDist += nPix-1;
      nDist -= nDist%nPix;
      n2    += nPix-1;
      n2    -= n2%nPix;
  }
  long nVirHeight = n1+nDist+n2;
  if ( nVirHeight > aSize.Height() )
      aSize.setHeight( nVirHeight );
  // negative width should not be drawn
  if ( aSize.Width() <= 0 )
      return;

  Size aVirSize = aVirDev->LogicToPixel( aSize );
  if ( aVirDev->GetOutputSizePixel() != aVirSize )
      aVirDev->SetOutputSizePixel( aVirSize );
  aVirDev->SetFillColor( aColorDist );
  aVirDev->DrawRect( tools::Rectangle( Point(), aSize ) );

  aVirDev->SetFillColor( aColor1 );

  double y1 = double( n1 ) / 2;
  svtools::DrawLine( *aVirDev, basegfx::B2DPoint( 0, y1 ), basegfx::B2DPoint( aSize.Width( ), y1 ), n1, nStyle );

  if ( n2 )
  {
      double y2 =  n1 + nDist + double( n2 ) / 2;
      aVirDev->SetFillColor( aColor2 );
      svtools::DrawLine( *aVirDev, basegfx::B2DPoint( 0, y2 ), basegfx::B2DPoint( aSize.Width(), y2 ), n2, SvxBorderLineStyle::SOLID );
  }
  rBmp = aVirDev->GetBitmapEx( Point(), Size( aSize.Width(), n1+nDist+n2 ) );
1406}

1408namespace
1409{
  OUString GetLineStyleName(SvxBorderLineStyle eStyle)
  {
      OUString sRet;
      for (sal_uInt32 i = 0; i < SAL_N_ELEMENTS(RID_SVXSTR_BORDERLINE)(sizeof(sal_n_array_size(RID_SVXSTR_BORDERLINE))); ++i)
      {
          if (eStyle == RID_SVXSTR_BORDERLINE[i].second)
          {
              sRet = SvtResId(RID_SVXSTR_BORDERLINE[i].first);
              break;
          }
      }
      return sRet;
  }
1423}

1425SvtLineListBox::SvtLineListBox(std::unique_ptr<weld::MenuButton> pControl)
  : m_xControl(std::move(pControl))
  , m_xBuilder(Application::CreateBuilder(m_xControl.get(), "svt/ui/linewindow.ui"))
  , m_xTopLevel(m_xBuilder->weld_widget("line_popup_window"))
  , m_xNoneButton(m_xBuilder->weld_button("none_line_button"))
  , m_xLineSet(new ValueSet(nullptr))
  , m_xLineSetWin(new weld::CustomWeld(*m_xBuilder, "lineset", *m_xLineSet))
  , m_nWidth( 5 )
  , aVirDev(VclPtr<VirtualDevice>::Create())
  , aColor(COL_BLACK)
  , maPaintCol(COL_BLACK)
1436{
  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  m_xLineSet->SetStyle(WinBits(WB_FLATVALUESET(WinBits(0x02000000)) | WB_NO_DIRECTSELECT(WinBits(0x04000000)) | WB_TABSTOP));
  m_xLineSet->SetItemHeight(rStyleSettings.GetListBoxPreviewDefaultPixelSize().Height() + 1);
  m_xLineSet->SetColCount(1);
  m_xLineSet->SetSelectHdl(LINK(this, SvtLineListBox, ValueSelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvtLineListBox
 *>(this), &SvtLineListBox::LinkStubValueSelectHdl));

  m_xNoneButton->connect_clicked(LINK(this, SvtLineListBox, NoneHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvtLineListBox
 *>(this), &SvtLineListBox::LinkStubNoneHdl));

  m_xTopLevel->connect_focus_in(LINK(this, SvtLineListBox, FocusHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvtLineListBox
 *>(this), &SvtLineListBox::LinkStubFocusHdl));
  m_xControl->set_popover(m_xTopLevel.get());
  m_xControl->connect_toggled(LINK(this, SvtLineListBox, ToggleHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvtLineListBox
 *>(this), &SvtLineListBox::LinkStubToggleHdl));

  // lock size to these maxes height/width so it doesn't jump around in size
  m_xControl->set_label(GetLineStyleName(SvxBorderLineStyle::NONE));
  Size aNonePrefSize = m_xControl->get_preferred_size();
  m_xControl->set_label("");
  aVirDev->SetOutputSizePixel(getPreviewSize(*m_xControl));
  m_xControl->set_image(aVirDev);
  Size aSolidPrefSize = m_xControl->get_preferred_size();
  m_xControl->set_size_request(std::max(aNonePrefSize.Width(), aSolidPrefSize.Width()),
                               std::max(aNonePrefSize.Height(), aSolidPrefSize.Height()));

  eSourceUnit = FieldUnit::POINT;

  aVirDev->SetLineColor();
  aVirDev->SetMapMode(MapMode(MapUnit::MapTwip));

  UpdatePaintLineColor();
1465}

1467IMPL_LINK_NOARG(SvtLineListBox, FocusHdl, weld::Widget&, void)void SvtLineListBox::LinkStubFocusHdl(void * instance, weld::
Widget& data) { return static_cast<SvtLineListBox *>
(instance)->FocusHdl(data); } void SvtLineListBox::FocusHdl
(__attribute__ ((unused)) weld::Widget&)
1468{
  if (GetSelectEntryStyle() == SvxBorderLineStyle::NONE)
      m_xNoneButton->grab_focus();
  else
      m_xLineSet->GrabFocus();
1473}

1475IMPL_LINK(SvtLineListBox, ToggleHdl, weld::ToggleButton&, rButton, void)void SvtLineListBox::LinkStubToggleHdl(void * instance, weld::
ToggleButton& data) { return static_cast<SvtLineListBox
 *>(instance)->ToggleHdl(data); } void SvtLineListBox::
ToggleHdl(weld::ToggleButton& rButton)
1476{
  if (rButton.get_active())
      FocusHdl(*m_xTopLevel);
1479}

1481IMPL_LINK_NOARG(SvtLineListBox, NoneHdl, weld::Button&, void)void SvtLineListBox::LinkStubNoneHdl(void * instance, weld::Button
& data) { return static_cast<SvtLineListBox *>(instance
)->NoneHdl(data); } void SvtLineListBox::NoneHdl(__attribute__
 ((unused)) weld::Button&)
1482{
  SelectEntry(SvxBorderLineStyle::NONE);
  ValueSelectHdl(nullptr);
1485}

1487SvtLineListBox::~SvtLineListBox()
1488{
1489}
1
Calling '~ScopedVclPtr'→

1491sal_Int32 SvtLineListBox::GetStylePos( sal_Int32 nListPos )
1492{
  sal_Int32 nPos = -1;
  --nListPos;

  sal_Int32 n = 0;
  size_t i = 0;
  size_t nCount = m_vLineList.size();
  while ( nPos == -1 && i < nCount )
  {
      if ( nListPos == n )
          nPos = static_cast<sal_Int32>(i);
      n++;
      i++;
  }

  return nPos;
1508}

1510void SvtLineListBox::SelectEntry(SvxBorderLineStyle nStyle)
1511{
  if (nStyle == SvxBorderLineStyle::NONE)
      m_xLineSet->SetNoSelection();
  else
      m_xLineSet->SelectItem(static_cast<sal_Int16>(nStyle) + 1);
  UpdatePreview();
1517}

1519void SvtLineListBox::InsertEntry(
  const BorderWidthImpl& rWidthImpl, SvxBorderLineStyle nStyle, long nMinWidth,
  ColorFunc pColor1Fn, ColorFunc pColor2Fn, ColorDistFunc pColorDistFn )
1522{
  m_vLineList.emplace_back(new ImpLineListData(
      rWidthImpl, nStyle, nMinWidth, pColor1Fn, pColor2Fn, pColorDistFn));
1525}

1527void SvtLineListBox::UpdatePaintLineColor()
1528{
  const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
  Color aNewCol(rSettings.GetWindowColor().IsDark() ? rSettings.GetLabelTextColor() : aColor);

  bool bRet = aNewCol != maPaintCol;

  if( bRet )
      maPaintCol = aNewCol;
1536}

1538void SvtLineListBox::UpdateEntries()
1539{
  UpdatePaintLineColor( );

  SvxBorderLineStyle eSelected = GetSelectEntryStyle();

  // Remove the old entries
  m_xLineSet->Clear();

  // Add the new entries based on the defined width

  sal_uInt16 n = 0;
  sal_uInt16 nCount = m_vLineList.size( );
  while ( n < nCount )
  {
      auto& pData = m_vLineList[ n ];
      BitmapEx aBmp;
      ImpGetLine( pData->GetLine1ForWidth( m_nWidth ),
              pData->GetLine2ForWidth( m_nWidth ),
              pData->GetDistForWidth( m_nWidth ),
              GetColorLine1(m_xLineSet->GetItemCount()),
              GetColorLine2(m_xLineSet->GetItemCount()),
              GetColorDist(m_xLineSet->GetItemCount()),
              pData->GetStyle(), aBmp );
      sal_Int16 nItemId = static_cast<sal_Int16>(pData->GetStyle()) + 1;
      m_xLineSet->InsertItem(nItemId, Image(aBmp), GetLineStyleName(pData->GetStyle()));
      if (pData->GetStyle() == eSelected)
          m_xLineSet->SelectItem(nItemId);
      n++;
  }

  m_xLineSet->SetOptimalSize();
1570}

1572Color SvtLineListBox::GetColorLine1( sal_Int32 nPos )
1573{
  sal_Int32 nStyle = GetStylePos( nPos );
  if (nStyle == -1)
      return GetPaintColor( );
  auto& pData = m_vLineList[ nStyle ];
  return pData->GetColorLine1( GetColor( ) );
1579}

1581Color SvtLineListBox::GetColorLine2( sal_Int32 nPos )
1582{
  sal_Int32 nStyle = GetStylePos(nPos);
  if (nStyle == -1)
      return GetPaintColor( );
  auto& pData = m_vLineList[ nStyle ];
  return pData->GetColorLine2( GetColor( ) );
1588}

1590Color SvtLineListBox::GetColorDist( sal_Int32 nPos )
1591{
  const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
  Color rResult = rSettings.GetFieldColor();

  sal_Int32 nStyle = GetStylePos( nPos );
  if (nStyle == -1)
      return rResult;
  auto& pData = m_vLineList[ nStyle ];
  return pData->GetColorDist( GetColor( ), rResult );
1600}

1602IMPL_LINK_NOARG(SvtLineListBox, ValueSelectHdl, ValueSet*, void)void SvtLineListBox::LinkStubValueSelectHdl(void * instance, ValueSet
* data) { return static_cast<SvtLineListBox *>(instance
)->ValueSelectHdl(data); } void SvtLineListBox::ValueSelectHdl
(__attribute__ ((unused)) ValueSet*)
1603{
  maSelectHdl.Call(*this);
  UpdatePreview();
  if (m_xControl->get_active())
      m_xControl->set_active(false);
1608}

1610void SvtLineListBox::UpdatePreview()
1611{
  SvxBorderLineStyle eStyle = GetSelectEntryStyle();
  for (sal_uInt32 i = 0; i < SAL_N_ELEMENTS(RID_SVXSTR_BORDERLINE)(sizeof(sal_n_array_size(RID_SVXSTR_BORDERLINE))); ++i)
  {
      if (eStyle == RID_SVXSTR_BORDERLINE[i].second)
      {
          m_xControl->set_label(SvtResId(RID_SVXSTR_BORDERLINE[i].first));
          break;
      }
  }

  if (eStyle == SvxBorderLineStyle::NONE)
  {
      m_xControl->set_image(nullptr);
      m_xControl->set_label(GetLineStyleName(SvxBorderLineStyle::NONE));
  }
  else
  {
      Image aImage(m_xLineSet->GetItemImage(m_xLineSet->GetSelectedItemId()));
      m_xControl->set_label("");
      const auto nPos = (aVirDev->GetOutputSizePixel().Height() - aImage.GetSizePixel().Height()) / 2;
      aVirDev->Push(PushFlags::MAPMODE);
      aVirDev->SetMapMode(MapMode(MapUnit::MapPixel));
      aVirDev->Erase();
      aVirDev->DrawImage(Point(0, nPos), aImage);
      m_xControl->set_image(aVirDev.get());
      aVirDev->Pop();
  }
1639}

1641SvtCalendarBox::SvtCalendarBox(std::unique_ptr<weld::MenuButton> pControl)
  : m_xControl(std::move(pControl))
  , m_xBuilder(Application::CreateBuilder(m_xControl.get(), "svt/ui/datewindow.ui"))
  , m_xTopLevel(m_xBuilder->weld_widget("date_popup_window"))
  , m_xCalendar(m_xBuilder->weld_calendar("date"))
1646{
  m_xControl->set_popover(m_xTopLevel.get());
  m_xCalendar->connect_selected(LINK(this, SvtCalendarBox, SelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvtCalendarBox
 *>(this), &SvtCalendarBox::LinkStubSelectHdl));
  m_xCalendar->connect_activated(LINK(this, SvtCalendarBox, ActivateHdl)::tools::detail::makeLink( ::tools::detail::castTo<SvtCalendarBox
 *>(this), &SvtCalendarBox::LinkStubActivateHdl));
1650}

1652void SvtCalendarBox::set_date(const Date& rDate)
1653{
  m_xCalendar->set_date(rDate);
  set_label_from_date();
1656}

1658void SvtCalendarBox::set_label_from_date()
1659{
  const LocaleDataWrapper& rLocaleData = Application::GetSettings().GetLocaleDataWrapper();
  m_xControl->set_label(rLocaleData.getDate(m_xCalendar->get_date()));
1662}

1664IMPL_LINK_NOARG(SvtCalendarBox, SelectHdl, weld::Calendar&, void)void SvtCalendarBox::LinkStubSelectHdl(void * instance, weld::
Calendar& data) { return static_cast<SvtCalendarBox *>
(instance)->SelectHdl(data); } void SvtCalendarBox::SelectHdl
(__attribute__ ((unused)) weld::Calendar&)
1665{
  set_label_from_date();
  m_aSelectHdl.Call(*this);
1668}

1670IMPL_LINK_NOARG(SvtCalendarBox, ActivateHdl, weld::Calendar&, void)void SvtCalendarBox::LinkStubActivateHdl(void * instance, weld
::Calendar& data) { return static_cast<SvtCalendarBox *
>(instance)->ActivateHdl(data); } void SvtCalendarBox::
ActivateHdl(__attribute__ ((unused)) weld::Calendar&)
1671{
  if (m_xControl->get_active())
      m_xControl->set_active(false);
  m_aActivatedHdl.Call(*this);
1675}

1677SvtCalendarBox::~SvtCalendarBox()
1678{
1679}

1681/* 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();
2
←
Calling 'VclPtr::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