/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 documen8.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 -isystem /usr/include/libxml2 -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 SC_DLLIMPLEMENTATION -D SC_INFO_OSVERSION="LINUX" -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/liborcus/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/mdds/include -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/clew/source/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sc/source/core/inc -I /home/maarten/src/libreoffice/core/sc/source/filter/inc -I /home/maarten/src/libreoffice/core/sc/source/ui/inc -I /home/maarten/src/libreoffice/core/sc/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sc/sdi -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/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx

/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.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 <scitems.hxx>
21#include <comphelper/fileformat.h>
22#include <comphelper/processfactory.hxx>
23#include <comphelper/servicehelper.hxx>
24#include <officecfg/Office/Common.hxx>
25#include <tools/urlobj.hxx>
26#include <editeng/editobj.hxx>
27#include <editeng/frmdiritem.hxx>
28#include <editeng/langitem.hxx>
29#include <sfx2/linkmgr.hxx>
30#include <sfx2/bindings.hxx>
31#include <sfx2/objsh.hxx>
32#include <sfx2/printer.hxx>
33#include <sfx2/viewfrm.hxx>
34#include <sfx2/viewsh.hxx>
35#include <svl/flagitem.hxx>
36#include <svl/intitem.hxx>
37#include <svl/zforlist.hxx>
38#include <svl/zformat.hxx>
39#include <unotools/transliterationwrapper.hxx>
40#include <sal/log.hxx>

42#include <vcl/svapp.hxx>
43#include <vcl/virdev.hxx>
44#include <vcl/weld.hxx>
45#include <vcl/TaskStopwatch.hxx>

47#include <inputopt.hxx>
48#include <global.hxx>
49#include <table.hxx>
50#include <column.hxx>
51#include <poolhelp.hxx>
52#include <docpool.hxx>
53#include <stlpool.hxx>
54#include <stlsheet.hxx>
55#include <docoptio.hxx>
56#include <viewopti.hxx>
57#include <scextopt.hxx>
58#include <rechead.hxx>
59#include <ddelink.hxx>
60#include <scmatrix.hxx>
61#include <arealink.hxx>
62#include <patattr.hxx>
63#include <editutil.hxx>
64#include <progress.hxx>
65#include <document.hxx>
66#include <chartlis.hxx>
67#include <chartlock.hxx>
68#include <refupdat.hxx>
69#include <markdata.hxx>
70#include <scmod.hxx>
71#include <externalrefmgr.hxx>
72#include <globstr.hrc>
73#include <strings.hrc>
74#include <sc.hrc>
75#include <charthelper.hxx>
76#include <macromgr.hxx>
77#include <docuno.hxx>
78#include <scresid.hxx>
79#include <columniterator.hxx>
80#include <globalnames.hxx>
81#include <stringutil.hxx>
82#include <documentlinkmgr.hxx>
83#include <scopetools.hxx>
84#include <tokenarray.hxx>

86#include <memory>
87#include <utility>

89using namespace com::sun::star;

91namespace {

93sal_uInt16 getScaleValue(SfxStyleSheetBase& rStyle, sal_uInt16 nWhich)
94{
  return static_cast<const SfxUInt16Item&>(rStyle.GetItemSet().Get(nWhich)).GetValue();
96}

98}

100void ScDocument::ImplCreateOptions()
101{
  pDocOptions.reset( new ScDocOptions() );
  pViewOptions.reset( new ScViewOptions() );
104}

106void ScDocument::ImplDeleteOptions()
107{
  pDocOptions.reset();
  pViewOptions.reset();
  pExtDocOptions.reset();
111}

113SfxPrinter* ScDocument::GetPrinter(bool bCreateIfNotExist)
114{
  if ( !mpPrinter && bCreateIfNotExist )
  {
      auto pSet =
          std::make_unique<SfxItemSet>( *mxPoolHelper->GetDocPool(),
                          svl::Items<SID_PRINTER_NOTFOUND_WARN(5000 + 320),  SID_PRINTER_NOTFOUND_WARN(5000 + 320),
                          SID_PRINTER_CHANGESTODOC(5000 + 324),   SID_PRINTER_CHANGESTODOC(5000 + 324),
                          SID_PRINT_SELECTEDSHEET(5000 + 1712),    SID_PRINT_SELECTEDSHEET(5000 + 1712),
                          SID_SCPRINTOPTIONS((26000) + 68),         SID_SCPRINTOPTIONS((26000) + 68)>{} );

      SfxPrinterChangeFlags nFlags = SfxPrinterChangeFlags::NONE;
      if (officecfg::Office::Common::Print::Warning::PaperOrientation::get())
          nFlags |= SfxPrinterChangeFlags::CHG_ORIENTATION;
      if (officecfg::Office::Common::Print::Warning::PaperSize::get())
          nFlags |= SfxPrinterChangeFlags::CHG_SIZE;
      pSet->Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC(5000 + 324), static_cast<int>(nFlags) ) );
      pSet->Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN(5000 + 320), officecfg::Office::Common::Print::Warning::NotFound::get() ) );

      mpPrinter = VclPtr<SfxPrinter>::Create( std::move(pSet) );
      mpPrinter->SetMapMode(MapMode(MapUnit::Map100thMM));
      UpdateDrawPrinter();
      mpPrinter->SetDigitLanguage( SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetOptDigitLanguage() );
  }

  return mpPrinter;
139}

141void ScDocument::SetPrinter( VclPtr<SfxPrinter> const & pNewPrinter )
142{
  if ( pNewPrinter == mpPrinter.get() )
1
Taking false branch→
  {
      //  #i6706# SetPrinter is called with the same printer again if
      //  the JobSetup has changed. In that case just call UpdateDrawPrinter
      //  (SetRefDevice for drawing layer) because of changed text sizes.
      UpdateDrawPrinter();
  }
  else
  {
      ScopedVclPtr<SfxPrinter> xKeepAlive( mpPrinter );
2
←
Calling constructor for 'ScopedVclPtr<SfxPrinter>'→
9
←
Returning from constructor for 'ScopedVclPtr<SfxPrinter>'→
      mpPrinter = pNewPrinter;
      UpdateDrawPrinter();
      mpPrinter->SetDigitLanguage( SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetOptDigitLanguage() );
  }
10
←
Calling '~ScopedVclPtr'→
  InvalidateTextWidth(nullptr, nullptr, false);     // in both cases
158}

160void ScDocument::SetPrintOptions()
161{
  if ( !mpPrinter ) GetPrinter(); // this sets mpPrinter
  OSL_ENSURE( mpPrinter, "Error in printer creation :-/" )do { if (true && (!(mpPrinter))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "163" ": "), "%s", "Error in printer creation :-/"); } }
 while (false);

  if ( !mpPrinter )
      return;

  SfxItemSet aOptSet( mpPrinter->GetOptions() );

  SfxPrinterChangeFlags nFlags = SfxPrinterChangeFlags::NONE;
  if (officecfg::Office::Common::Print::Warning::PaperOrientation::get())
      nFlags |= SfxPrinterChangeFlags::CHG_ORIENTATION;
  if (officecfg::Office::Common::Print::Warning::PaperSize::get())
      nFlags |= SfxPrinterChangeFlags::CHG_SIZE;
  aOptSet.Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC(5000 + 324), static_cast<int>(nFlags) ) );
  aOptSet.Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN(5000 + 320), officecfg::Office::Common::Print::Warning::NotFound::get() ) );

  mpPrinter->SetOptions( aOptSet );
179}

181VirtualDevice* ScDocument::GetVirtualDevice_100th_mm()
182{
  if (!mpVirtualDevice_100th_mm)
  {
185#ifdef IOS
      mpVirtualDevice_100th_mm = VclPtr<VirtualDevice>::Create(DeviceFormat::GRAYSCALE);
187#else
      mpVirtualDevice_100th_mm = VclPtr<VirtualDevice>::Create(DeviceFormat::BITMASK);
189#endif
      mpVirtualDevice_100th_mm->SetReferenceDevice(VirtualDevice::RefDevMode::MSO1);
      MapMode aMapMode( mpVirtualDevice_100th_mm->GetMapMode() );
      aMapMode.SetMapUnit( MapUnit::Map100thMM );
      mpVirtualDevice_100th_mm->SetMapMode( aMapMode );
  }
  return mpVirtualDevice_100th_mm;
196}

198OutputDevice* ScDocument::GetRefDevice()
199{
  // Create printer like ref device, see Writer...
  OutputDevice* pRefDevice = nullptr;
  if ( SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetInputOptions().GetTextWysiwyg() )
      pRefDevice = GetPrinter();
  else
      pRefDevice = GetVirtualDevice_100th_mm();
  return pRefDevice;
207}

209void ScDocument::ModifyStyleSheet( SfxStyleSheetBase& rStyleSheet,
                                 const SfxItemSet&  rChanges )
211{
  SfxItemSet& rSet = rStyleSheet.GetItemSet();

  switch ( rStyleSheet.GetFamily() )
  {
      case SfxStyleFamily::Page:
          {
              const sal_uInt16 nOldScale = getScaleValue(rStyleSheet, ATTR_PAGE_SCALE);
              const sal_uInt16 nOldScaleToPages = getScaleValue(rStyleSheet, ATTR_PAGE_SCALETOPAGES);
              rSet.Put( rChanges );
              const sal_uInt16 nNewScale        = getScaleValue(rStyleSheet, ATTR_PAGE_SCALE);
              const sal_uInt16 nNewScaleToPages = getScaleValue(rStyleSheet, ATTR_PAGE_SCALETOPAGES);

              if ( (nOldScale != nNewScale) || (nOldScaleToPages != nNewScaleToPages) )
                  InvalidateTextWidth( rStyleSheet.GetName() );

              if( SvtLanguageOptions().IsCTLFontEnabled() )
              {
                  const SfxPoolItem *pItem = nullptr;
                  if( rChanges.GetItemState(ATTR_WRITINGDIR, true, &pItem ) == SfxItemState::SET )
                      ScChartHelper::DoUpdateAllCharts( *this );
              }
          }
          break;

      case SfxStyleFamily::Para:
          {
              bool bNumFormatChanged;
              if ( ScGlobal::CheckWidthInvalidate( bNumFormatChanged,
                      rSet, rChanges ) )
                  InvalidateTextWidth( nullptr, nullptr, bNumFormatChanged );

              for (SCTAB nTab=0; nTab<=MAXTAB; ++nTab)
                  if (maTabs[nTab])
                      maTabs[nTab]->SetStreamValid( false );

              sal_uLong nOldFormat =
                  rSet.Get( ATTR_VALUE_FORMAT ).GetValue();
              sal_uLong nNewFormat =
                  rChanges.Get( ATTR_VALUE_FORMAT ).GetValue();
              LanguageType eNewLang, eOldLang;
              eNewLang = eOldLang = LANGUAGE_DONTKNOWLanguageType(0x03FF);
              if ( nNewFormat != nOldFormat )
              {
                  SvNumberFormatter* pFormatter = GetFormatTable();
                  eOldLang = pFormatter->GetEntry( nOldFormat )->GetLanguage();
                  eNewLang = pFormatter->GetEntry( nNewFormat )->GetLanguage();
              }

              // Explanation to Items in rChanges:
              //  Set Item        - take over change
              //  Dontcare        - Set Default
              //  Default         - No change
              // ("no change" is not possible with PutExtended, thus the loop)
              for (sal_uInt16 nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; nWhich++)
              {
                  const SfxPoolItem* pItem;
                  SfxItemState eState = rChanges.GetItemState( nWhich, false, &pItem );
                  if ( eState == SfxItemState::SET )
                      rSet.Put( *pItem );
                  else if ( eState == SfxItemState::DONTCARE )
                      rSet.ClearItem( nWhich );
                  // when Default nothing
              }

              if ( eNewLang != eOldLang )
                  rSet.Put(
                      SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
          }
          break;
      default:
      {
          // added to avoid warnings
      }
  }
286}

288void ScDocument::CopyStdStylesFrom( const ScDocument& rSrcDoc )
289{
  // number format exchange list has to be handled here, too
  NumFmtMergeHandler aNumFmtMergeHdl(*this, rSrcDoc);
  mxPoolHelper->GetStylePool()->CopyStdStylesFrom( rSrcDoc.mxPoolHelper->GetStylePool() );
293}

295void ScDocument::InvalidateTextWidth( const OUString& rStyleName )
296{
  const SCTAB nCount = GetTableCount();
  for ( SCTAB i=0; i<nCount && maTabs[i]; i++ )
      if ( maTabs[i]->GetPageStyle() == rStyleName )
          InvalidateTextWidth( i );
301}

303void ScDocument::InvalidateTextWidth( SCTAB nTab )
304{
  ScAddress aAdrFrom( 0,    0,        nTab );
  ScAddress aAdrTo  ( MaxCol(), MaxRow(), nTab );
  InvalidateTextWidth( &aAdrFrom, &aAdrTo, false );
308}

310bool ScDocument::IsPageStyleInUse( const OUString& rStrPageStyle, SCTAB* pInTab )
311{
  bool         bInUse = false;
  const SCTAB nCount = GetTableCount();
  SCTAB i;

  for ( i = 0; !bInUse && i < nCount && maTabs[i]; i++ )
      bInUse = ( maTabs[i]->GetPageStyle() == rStrPageStyle );

  if ( pInTab )
      *pInTab = i-1;

  return bInUse;
323}

325bool ScDocument::RemovePageStyleInUse( const OUString& rStyle )
326{
  bool bWasInUse = false;
  const SCTAB nCount = GetTableCount();

  for ( SCTAB i=0; i<nCount && maTabs[i]; i++ )
      if ( maTabs[i]->GetPageStyle() == rStyle )
      {
          bWasInUse = true;
          maTabs[i]->SetPageStyle( ScResId(STR_STYLENAME_STANDARD_PAGEreinterpret_cast<char const *>("STR_STYLENAME_STANDARD"
 "\004" u8"Default Page Style")) );
      }

  return bWasInUse;
338}

340bool ScDocument::RenamePageStyleInUse( const OUString& rOld, const OUString& rNew )
341{
  bool bWasInUse = false;
  const SCTAB nCount = GetTableCount();

  for ( SCTAB i=0; i<nCount && maTabs[i]; i++ )
      if ( maTabs[i]->GetPageStyle() == rOld )
      {
          bWasInUse = true;
          maTabs[i]->SetPageStyle( rNew );
      }

  return bWasInUse;
353}

355EEHorizontalTextDirection ScDocument::GetEditTextDirection(SCTAB nTab) const
356{
  EEHorizontalTextDirection eRet = EEHorizontalTextDirection::Default;

  OUString aStyleName = GetPageStyle( nTab );
  SfxStyleSheetBase* pStyle = mxPoolHelper->GetStylePool()->Find( aStyleName, SfxStyleFamily::Page );
  if ( pStyle )
  {
      SfxItemSet& rStyleSet = pStyle->GetItemSet();
      SvxFrameDirection eDirection =
          rStyleSet.Get( ATTR_WRITINGDIR ).GetValue();

      if ( eDirection == SvxFrameDirection::Horizontal_LR_TB )
          eRet = EEHorizontalTextDirection::L2R;
      else if ( eDirection == SvxFrameDirection::Horizontal_RL_TB )
          eRet = EEHorizontalTextDirection::R2L;
      // else (invalid for EditEngine): keep "default"
  }

  return eRet;
375}

377ScMacroManager* ScDocument::GetMacroManager()
378{
  if (!mpMacroMgr)
      mpMacroMgr.reset(new ScMacroManager(*this));
  return mpMacroMgr.get();
382}

384void ScDocument::FillMatrix(
  ScMatrix& rMat, SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, svl::SharedStringPool* pPool ) const
386{
  const ScTable* pTab = FetchTable(nTab);
  if (!pTab)
      return;

  if (nCol1 > nCol2 || nRow1 > nRow2)
      return;

  SCSIZE nC, nR;
  rMat.GetDimensions(nC, nR);
  if (static_cast<SCROW>(nR) != nRow2 - nRow1 + 1 || static_cast<SCCOL>(nC) != nCol2 - nCol1 + 1)
      return;

  pTab->FillMatrix(rMat, nCol1, nRow1, nCol2, nRow2, pPool);
400}

402void ScDocument::SetFormulaResults( const ScAddress& rTopPos, const double* pResults, size_t nLen )
403{
  ScTable* pTab = FetchTable(rTopPos.Tab());
  if (!pTab)
      return;

  pTab->SetFormulaResults(rTopPos.Col(), rTopPos.Row(), pResults, nLen);
409}

411const ScDocumentThreadSpecific& ScDocument::CalculateInColumnInThread( ScInterpreterContext& rContext, const ScRange& rCalcRange, unsigned nThisThread, unsigned nThreadsTotal)
412{
  ScTable* pTab = FetchTable(rCalcRange.aStart.Tab());
  if (!pTab)
      return maNonThreaded;

  assert(IsThreadedGroupCalcInProgress())(static_cast <bool> (IsThreadedGroupCalcInProgress()) ?
 void (0) : __assert_fail ("IsThreadedGroupCalcInProgress()",
 "/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
, 417, __extension__ __PRETTY_FUNCTION__));

  maThreadSpecific.pContext = &rContext;
  ScDocumentThreadSpecific::SetupFromNonThreadedData(maNonThreaded);
  pTab->CalculateInColumnInThread(rContext, rCalcRange.aStart.Col(), rCalcRange.aEnd.Col(), rCalcRange.aStart.Row(), rCalcRange.aEnd.Row(), nThisThread, nThreadsTotal);

  assert(IsThreadedGroupCalcInProgress())(static_cast <bool> (IsThreadedGroupCalcInProgress()) ?
 void (0) : __assert_fail ("IsThreadedGroupCalcInProgress()",
 "/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
, 423, __extension__ __PRETTY_FUNCTION__));
  maThreadSpecific.pContext = nullptr;

  return maThreadSpecific;
427}

429void ScDocument::HandleStuffAfterParallelCalculation( SCCOL nColStart, SCCOL nColEnd, SCROW nRow, size_t nLen, SCTAB nTab, ScInterpreter* pInterpreter )
430{
  assert(!IsThreadedGroupCalcInProgress())(static_cast <bool> (!IsThreadedGroupCalcInProgress()) ?
 void (0) : __assert_fail ("!IsThreadedGroupCalcInProgress()"
, "/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
, 431, __extension__ __PRETTY_FUNCTION__));
  for( const DelayedSetNumberFormat& data : GetNonThreadedContext().maDelayedSetNumberFormat)
      SetNumberFormat( ScAddress( data.mCol, data.mRow, nTab ), data.mnNumberFormat );
  GetNonThreadedContext().maDelayedSetNumberFormat.clear();

  ScTable* pTab = FetchTable(nTab);
  if (!pTab)
      return;

  pTab->HandleStuffAfterParallelCalculation(nColStart, nColEnd, nRow, nLen, pInterpreter);
441}

443void ScDocument::InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
                                    bool bNumFormatChanged )
445{
  bool bBroadcast = (bNumFormatChanged && GetDocOptions().IsCalcAsShown() && !IsImportingXML() && !IsClipboard());
  if ( pAdrFrom && !pAdrTo )
  {
      const SCTAB nTab = pAdrFrom->Tab();

      if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
          maTabs[nTab]->InvalidateTextWidth( pAdrFrom, nullptr, bNumFormatChanged, bBroadcast );
  }
  else
  {
      const SCTAB nTabStart = pAdrFrom ? pAdrFrom->Tab() : 0;
      const SCTAB nTabEnd   = pAdrTo   ? pAdrTo->Tab()   : MAXTAB;

      for ( SCTAB nTab=nTabStart; nTab<=nTabEnd && nTab < static_cast<SCTAB>(maTabs.size()); nTab++ )
          if ( maTabs[nTab] )
              maTabs[nTab]->InvalidateTextWidth( pAdrFrom, pAdrTo, bNumFormatChanged, bBroadcast );
  }
463}

465#define CALCMAX1000                 1000    // Calculations

467namespace {

469class IdleCalcTextWidthScope : public TaskStopwatch
470{
  ScDocument& mrDoc;
  ScAddress& mrCalcPos;
  MapMode maOldMapMode;
  ScStyleSheetPool* mpStylePool;
  bool mbNeedMore;
  bool mbProgress;

478public:
  IdleCalcTextWidthScope(ScDocument& rDoc, ScAddress& rCalcPos) :
      mrDoc(rDoc),
      mrCalcPos(rCalcPos),
      mpStylePool(rDoc.GetStyleSheetPool()),
      mbNeedMore(false),
      mbProgress(false)
  {
      mrDoc.EnableIdle(false);
  }

  ~IdleCalcTextWidthScope() COVERITY_NOEXCEPT_FALSE
  {
      SfxPrinter* pDev = mrDoc.GetPrinter();
      if (pDev)
          pDev->SetMapMode(maOldMapMode);

      if (mbProgress)
          ScProgress::DeleteInterpretProgress();

      mrDoc.EnableIdle(true);
  }

  SCTAB Tab() const { return mrCalcPos.Tab(); }
  SCCOL Col() const { return mrCalcPos.Col(); }
  SCROW Row() const { return mrCalcPos.Row(); }

  void setTab(SCTAB nTab) { mrCalcPos.SetTab(nTab); }
  void setCol(SCCOL nCol) { mrCalcPos.SetCol(nCol); }
  void setRow(SCROW nRow) { mrCalcPos.SetRow(nRow); }

  void incTab() { mrCalcPos.IncTab(); }
  void incCol(SCCOL nInc) { mrCalcPos.IncCol(nInc); }

  void setOldMapMode(const MapMode& rOldMapMode) { maOldMapMode = rOldMapMode; }

  void setNeedMore(bool b) { mbNeedMore = b; }
  bool getNeedMore() const { return mbNeedMore; }

  void createProgressBar()
  {
      ScProgress::CreateInterpretProgress(&mrDoc, false);
      mbProgress = true;
  }

  bool hasProgressBar() const { return mbProgress; }

  ScStyleSheetPool* getStylePool() { return mpStylePool; }
526};

528}

530bool ScDocument::IdleCalcTextWidth()            // true = try next again
531{
  // #i75610# if a printer hasn't been set or created yet, don't create one for this
  if (!mbIdleEnabled || IsInLinkUpdate() || GetPrinter(false) == nullptr)
      return false;

  IdleCalcTextWidthScope aScope(*this, aCurTextWidthCalcPos);

  if (!ValidRow(aScope.Row()))
  {
      aScope.setRow(0);
      aScope.incCol(-1);
  }

  if (aScope.Col() < 0)
  {
      aScope.setCol(MaxCol());
      aScope.incTab();
  }

  if (!ValidTab(aScope.Tab()) || aScope.Tab() >= static_cast<SCTAB>(maTabs.size()) || !maTabs[aScope.Tab()])
      aScope.setTab(0);

  ScTable* pTab = maTabs[aScope.Tab()].get();
  ScStyleSheet* pStyle = static_cast<ScStyleSheet*>(aScope.getStylePool()->Find(pTab->aPageStyle, SfxStyleFamily::Page));
  OSL_ENSURE( pStyle, "Missing StyleSheet :-/" )do { if (true && (!(pStyle))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "555" ": "), "%s", "Missing StyleSheet :-/"); } } while (
false);

  if (!pStyle || getScaleValue(*pStyle, ATTR_PAGE_SCALETOPAGES) == 0)
  {
      // Move to the next sheet as the current one has scale-to-pages set,
      // and bail out.
      aScope.incTab();
      return false;
  }

  sal_uInt16 nZoom = getScaleValue(*pStyle, ATTR_PAGE_SCALE);
  Fraction aZoomFract(nZoom, 100);

  aScope.setCol(pTab->ClampToAllocatedColumns(aScope.Col()));
  // Start at specified cell position (nCol, nRow, nTab).
  ScColumn* pCol  = &pTab->aCol[aScope.Col()];
  std::unique_ptr<ScColumnTextWidthIterator> pColIter(new ScColumnTextWidthIterator(*this, *pCol, aScope.Row(), MaxRow()));

  OutputDevice* pDev = nullptr;
  sal_uInt16 nRestart = 0;
  sal_uInt16 nCount = 0;
  while ( (nZoom > 0) && (nCount < CALCMAX1000) && (nRestart < 2) )
  {
      if (pColIter->hasCell())
      {
          // More cell in this column.
          SCROW nRow = pColIter->getPos();
          aScope.setRow(nRow);

          if (pColIter->getValue() == TEXTWIDTH_DIRTY0xffff)
          {
              // Calculate text width for this cell.
              double nPPTX = 0.0;
              double nPPTY = 0.0;
              if (!pDev)
              {
                  pDev = GetPrinter();
                  aScope.setOldMapMode(pDev->GetMapMode());
                  pDev->SetMapMode(MapMode(MapUnit::MapPixel)); // Important for GetNeededSize

                  Point aPix1000 = pDev->LogicToPixel(Point(1000,1000), MapMode(MapUnit::MapTwip));
                  nPPTX = aPix1000.X() / 1000.0;
                  nPPTY = aPix1000.Y() / 1000.0;
              }

              if (!aScope.hasProgressBar() && pCol->IsFormulaDirty(nRow))
                  aScope.createProgressBar();

              sal_uInt16 nNewWidth = static_cast<sal_uInt16>(GetNeededSize(
                  aScope.Col(), aScope.Row(), aScope.Tab(),
                  pDev, nPPTX, nPPTY, aZoomFract,aZoomFract, true, true));   // bTotalSize

              pColIter->setValue(nNewWidth);
              aScope.setNeedMore(true);
          }
          pColIter->next();
      }
      else
      {
          // No more cell in this column.  Move to the left column and start at row 0.

          bool bNewTab = false;

          aScope.setRow(0);
          aScope.incCol(-1);

          if (aScope.Col() < 0)
          {
              // No more column to the left.  Move to the right-most column of the next sheet.
              aScope.setCol(MaxCol());
              aScope.incTab();
              bNewTab = true;
          }

          if (!ValidTab(aScope.Tab()) || aScope.Tab() >= static_cast<SCTAB>(maTabs.size()) || !maTabs[aScope.Tab()] )
          {
              // Sheet doesn't exist at specified sheet position.  Restart at sheet 0.
              aScope.setTab(0);
              nRestart++;
              bNewTab = true;
          }

          if ( nRestart < 2 )
          {
              if ( bNewTab )
              {
                  pTab = maTabs[aScope.Tab()].get();
                  aScope.setCol(pTab->ClampToAllocatedColumns(aScope.Col()));
                  pStyle = static_cast<ScStyleSheet*>(aScope.getStylePool()->Find(
                      pTab->aPageStyle, SfxStyleFamily::Page));

                  if ( pStyle )
                  {
                      // Check if the scale-to-pages setting is set. If
                      // set, we exit the loop.  If not, get the page
                      // scale factor of the new sheet.
                      if (getScaleValue(*pStyle, ATTR_PAGE_SCALETOPAGES) == 0)
                      {
                          nZoom = getScaleValue(*pStyle, ATTR_PAGE_SCALE);
                          aZoomFract = Fraction(nZoom, 100);
                      }
                      else
                          nZoom = 0;
                  }
                  else
                  {
                      OSL_FAIL( "Missing StyleSheet :-/" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "661" ": "), "%s", "Missing StyleSheet :-/"); } } while (
false);
                  }
              }

              if ( nZoom > 0 )
              {
                  pCol  = &pTab->aCol[aScope.Col()];
                  pColIter.reset(new ScColumnTextWidthIterator(*this, *pCol, aScope.Row(), MaxRow()));
              }
              else
              {
                  aScope.incTab(); // Move to the next sheet as the current one has scale-to-pages set.
                  return false;
              }
          }
      }

      ++nCount;

      if (!aScope.continueIter())
          break;
  }

  return aScope.getNeedMore();
685}

687void ScDocument::RepaintRange( const ScRange& rRange )
688{
  if ( bIsVisible && mpShell )
  {
      ScModelObj* pModel = comphelper::getUnoTunnelImplementation<ScModelObj>( mpShell->GetModel() );
      if ( pModel )
          pModel->RepaintRange( rRange );     // locked repaints are checked there
  }
695}

697void ScDocument::RepaintRange( const ScRangeList& rRange )
698{
  if ( bIsVisible && mpShell )
  {
      ScModelObj* pModel = comphelper::getUnoTunnelImplementation<ScModelObj>( mpShell->GetModel() );
      if ( pModel )
          pModel->RepaintRange( rRange );     // locked repaints are checked there
  }
705}

707void ScDocument::SaveDdeLinks(SvStream& rStream) const
708{
  //  when 4.0-Export, remove all with mode != DEFAULT
  bool bExport40 = ( rStream.GetVersion() <= SOFFICE_FILEFORMAT_403580 );

  const ::sfx2::SvBaseLinks& rLinks = GetLinkManager()->GetLinks();
  sal_uInt16 nCount = rLinks.size();

  // Count them first

  sal_uInt16 nDdeCount = 0;
  sal_uInt16 i;
  for (i=0; i<nCount; i++)
  {
      ::sfx2::SvBaseLink* pBase = rLinks[i].get();
      if (ScDdeLink* pLink = dynamic_cast<ScDdeLink*>(pBase))
          if ( !bExport40 || pLink->GetMode() == SC_DDE_DEFAULT )
              ++nDdeCount;
  }

  //  Header

  ScMultipleWriteHeader aHdr( rStream );
  rStream.WriteUInt16( nDdeCount );

  // Save links

  for (i=0; i<nCount; i++)
  {
      ::sfx2::SvBaseLink* pBase = rLinks[i].get();
      if (ScDdeLink* pLink = dynamic_cast<ScDdeLink*>(pBase))
      {
          if ( !bExport40 || pLink->GetMode() == SC_DDE_DEFAULT )
              pLink->Store( rStream, aHdr );
      }
  }
743}

745void ScDocument::LoadDdeLinks(SvStream& rStream)
746{
  sfx2::LinkManager* pMgr = GetDocLinkManager().getLinkManager(bAutoCalc);
  if (!pMgr)
      return;

  ScMultipleReadHeader aHdr( rStream );

  sal_uInt16 nCount(0);
  rStream.ReadUInt16( nCount );

  const rtl_TextEncoding eCharSet = rStream.GetStreamCharSet();
  const size_t nMinStringSize = eCharSet == RTL_TEXTENCODING_UNICODE(((rtl_TextEncoding) 0xFFFF)) ? sizeof(sal_uInt32) : sizeof(sal_uInt16);
  const size_t nMinRecordSize = 1 + nMinStringSize*3;
  const size_t nMaxRecords = rStream.remainingSize() / nMinRecordSize;
  if (nCount > nMaxRecords)
  {
      SAL_WARN("sc", "Parsing error: " << nMaxRecords <<do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Parsing error: " << nMaxRecords << " max possible entries, but "
 << nCount << " claimed, truncating") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Parsing error: " << nMaxRecords << " max possible entries, but "
 << nCount << " claimed, truncating") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false)
               " max possible entries, but " << nCount << " claimed, truncating")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Parsing error: " << nMaxRecords << " max possible entries, but "
 << nCount << " claimed, truncating") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Parsing error: " << nMaxRecords << " max possible entries, but "
 << nCount << " claimed, truncating") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "Parsing error: " << nMaxRecords
 << " max possible entries, but " << nCount <<
 " claimed, truncating"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "763" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      nCount = nMaxRecords;
  }

  for (sal_uInt16 i=0; i<nCount; ++i)
  {
      ScDdeLink* pLink = new ScDdeLink( *this, rStream, aHdr );
      pMgr->InsertDDELink(pLink, pLink->GetAppl(), pLink->GetTopic(), pLink->GetItem());
  }
772}

774void ScDocument::SetInLinkUpdate(bool bSet)
775{
  //  called from TableLink and AreaLink

  OSL_ENSURE( bInLinkUpdate != bSet, "SetInLinkUpdate twice" )do { if (true && (!(bInLinkUpdate != bSet))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "778" ": "), "%s", "SetInLinkUpdate twice"); } } while (
false);
  bInLinkUpdate = bSet;
780}

782bool ScDocument::IsInLinkUpdate() const
783{
  return bInLinkUpdate || IsInDdeLinkUpdate();
785}

787void ScDocument::UpdateExternalRefLinks(weld::Window* pWin)
788{
  if (!pExternalRefMgr)
      return;

  sfx2::LinkManager* pMgr = GetDocLinkManager().getLinkManager(bAutoCalc);
  if (!pMgr)
      return;

  const ::sfx2::SvBaseLinks& rLinks = pMgr->GetLinks();
  sal_uInt16 nCount = rLinks.size();

  bool bAny = false;

  // Collect all the external ref links first.
  std::vector<ScExternalRefLink*> aRefLinks;
  for (sal_uInt16 i = 0; i < nCount; ++i)
  {
      ::sfx2::SvBaseLink* pBase = rLinks[i].get();
      ScExternalRefLink* pRefLink = dynamic_cast<ScExternalRefLink*>(pBase);
      if (pRefLink)
          aRefLinks.push_back(pRefLink);
  }

  weld::WaitObject aWaitSwitch(pWin);

  pExternalRefMgr->enableDocTimer(false);
  ScProgress aProgress(GetDocumentShell(), ScResId(SCSTR_UPDATE_EXTDOCSreinterpret_cast<char const *>("SCSTR_UPDATE_EXTDOCS" "\004"
 u8"Updating external links.")), aRefLinks.size(), true);
  for (size_t i = 0, n = aRefLinks.size(); i < n; ++i)
  {
      aProgress.SetState(i+1);

      ScExternalRefLink* pRefLink = aRefLinks[i];
      if (pRefLink->Update())
      {
          bAny = true;
          continue;
      }

      // Update failed.  Notify the user.

      OUString aFile;
      sfx2::LinkManager::GetDisplayNames(pRefLink, nullptr, &aFile);
      // Decode encoded URL for display friendliness.
      INetURLObject aUrl(aFile,INetURLObject::EncodeMechanism::WasEncoded);
      aFile = aUrl.GetMainURL(INetURLObject::DecodeMechanism::Unambiguous);

      OUString sMessage = ScResId(SCSTR_EXTDOC_NOT_LOADEDreinterpret_cast<char const *>("SCSTR_EXTDOC_NOT_LOADED"
 "\004" u8"The following external file could not be loaded. Data linked from this file did not get updated."
)) +
          "\n\n" +
          aFile;
      std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pWin,
                                                VclMessageType::Warning, VclButtonsType::Ok,
                                                sMessage));
      xBox->run();
  }

  pExternalRefMgr->enableDocTimer(true);

  if (!bAny)
      return;

  TrackFormulas();
  mpShell->Broadcast( SfxHint(SfxHintId::ScDataChanged) );

  // #i101960# set document modified, as in TrackTimeHdl for DDE links
  if (!mpShell->IsModified())
  {
      mpShell->SetModified();
      SfxBindings* pBindings = GetViewBindings();
      if (pBindings)
      {
          pBindings->Invalidate( SID_SAVEDOC(5000 + 505) );
          pBindings->Invalidate( SID_DOC_MODIFIED(5000 + 584) );
      }
  }
862}

864void ScDocument::CopyDdeLinks( ScDocument& rDestDoc ) const
865{
  if (bIsClip)        // Create from Stream
  {
      if (pClipData)
      {
          pClipData->Seek(0);
          rDestDoc.LoadDdeLinks(*pClipData);
      }

      return;
  }

  const sfx2::LinkManager* pMgr = GetDocLinkManager().getExistingLinkManager();
  if (!pMgr)
      return;

  sfx2::LinkManager* pDestMgr = rDestDoc.GetDocLinkManager().getLinkManager(rDestDoc.bAutoCalc);
  if (!pDestMgr)
      return;

  const sfx2::SvBaseLinks& rLinks = pMgr->GetLinks();
  for (const auto & rLink : rLinks)
  {
      const sfx2::SvBaseLink* pBase = rLink.get();
      if (const ScDdeLink* p = dynamic_cast<const ScDdeLink*>(pBase))
      {
          ScDdeLink* pNew = new ScDdeLink(rDestDoc, *p);
          pDestMgr->InsertDDELink(
              pNew, pNew->GetAppl(), pNew->GetTopic(), pNew->GetItem());
      }
  }
896}

898namespace {

900/** Tries to find the specified DDE link.
  @param pnDdePos  (out-param) if not 0, the index of the DDE link is returned here
                   (does not include other links from link manager).
  @return  The DDE link, if it exists, otherwise 0. */
904ScDdeLink* lclGetDdeLink(
      const sfx2::LinkManager* pLinkManager,
      const OUString& rAppl, const OUString& rTopic, const OUString& rItem, sal_uInt8 nMode,
      size_t* pnDdePos = nullptr )
908{
  if( pLinkManager )
  {
      const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
      size_t nCount = rLinks.size();
      if( pnDdePos ) *pnDdePos = 0;
      for( size_t nIndex = 0; nIndex < nCount; ++nIndex )
      {
          ::sfx2::SvBaseLink* pLink = rLinks[ nIndex ].get();
          if( ScDdeLink* pDdeLink = dynamic_cast<ScDdeLink*>( pLink )  )
          {
              if( (pDdeLink->GetAppl() == rAppl) &&
                  (pDdeLink->GetTopic() == rTopic) &&
                  (pDdeLink->GetItem() == rItem) &&
                  ((nMode == SC_DDE_IGNOREMODE) || (nMode == pDdeLink->GetMode())) )
                  return pDdeLink;
              if( pnDdePos ) ++*pnDdePos;
          }
      }
  }
  return nullptr;
929}

931/** Returns a pointer to the specified DDE link.
  @param nDdePos  Index of the DDE link (does not include other links from link manager).
  @return  The DDE link, if it exists, otherwise 0. */
934ScDdeLink* lclGetDdeLink( const sfx2::LinkManager* pLinkManager, size_t nDdePos )
935{
  if( pLinkManager )
  {
      const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
      size_t nCount = rLinks.size();
      size_t nDdeIndex = 0;       // counts only the DDE links
      for( size_t nIndex = 0; nIndex < nCount; ++nIndex )
      {
          ::sfx2::SvBaseLink* pLink = rLinks[ nIndex ].get();
          if( ScDdeLink* pDdeLink = dynamic_cast<ScDdeLink*>( pLink )  )
          {
              if( nDdeIndex == nDdePos )
                  return pDdeLink;
              ++nDdeIndex;
          }
      }
  }
  return nullptr;
953}

955} // namespace

957bool ScDocument::FindDdeLink( const OUString& rAppl, const OUString& rTopic, const OUString& rItem,
      sal_uInt8 nMode, size_t& rnDdePos )
959{
  return lclGetDdeLink( GetLinkManager(), rAppl, rTopic, rItem, nMode, &rnDdePos ) != nullptr;
961}

963bool ScDocument::GetDdeLinkData( size_t nDdePos, OUString& rAppl, OUString& rTopic, OUString& rItem ) const
964{
  if( const ScDdeLink* pDdeLink = lclGetDdeLink( GetLinkManager(), nDdePos ) )
  {
      rAppl  = pDdeLink->GetAppl();
      rTopic = pDdeLink->GetTopic();
      rItem  = pDdeLink->GetItem();
      return true;
  }
  return false;
973}

975bool ScDocument::GetDdeLinkMode( size_t nDdePos, sal_uInt8& rnMode ) const
976{
  if( const ScDdeLink* pDdeLink = lclGetDdeLink( GetLinkManager(), nDdePos ) )
  {
      rnMode = pDdeLink->GetMode();
      return true;
  }
  return false;
983}

985const ScMatrix* ScDocument::GetDdeLinkResultMatrix( size_t nDdePos ) const
986{
  const ScDdeLink* pDdeLink = lclGetDdeLink( GetLinkManager(), nDdePos );
  return pDdeLink ? pDdeLink->GetResult() : nullptr;
989}

991bool ScDocument::CreateDdeLink( const OUString& rAppl, const OUString& rTopic, const OUString& rItem, sal_uInt8 nMode, const ScMatrixRef& pResults )
992{
  /*  Create a DDE link without updating it (i.e. for Excel import), to prevent
      unwanted connections. First try to find existing link. Set result array
      on existing and new links. */
  //TODO: store DDE links additionally at document (for efficiency)?
  OSL_ENSURE( nMode != SC_DDE_IGNOREMODE, "ScDocument::CreateDdeLink - SC_DDE_IGNOREMODE not allowed here" )do { if (true && (!(nMode != SC_DDE_IGNOREMODE))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "997" ": "), "%s", "ScDocument::CreateDdeLink - SC_DDE_IGNOREMODE not allowed here"
); } } while (false);

  sfx2::LinkManager* pMgr = GetDocLinkManager().getLinkManager(bAutoCalc);
  if (!pMgr)
      return false;

  if (nMode != SC_DDE_IGNOREMODE)
  {
      ScDdeLink* pDdeLink = lclGetDdeLink(pMgr, rAppl, rTopic, rItem, nMode);
      if( !pDdeLink )
      {
          // create a new DDE link, but without TryUpdate
          pDdeLink = new ScDdeLink( *this, rAppl, rTopic, rItem, nMode );
          pMgr->InsertDDELink(pDdeLink, rAppl, rTopic, rItem);
      }

      // insert link results
      if( pResults )
          pDdeLink->SetResult( pResults );

      return true;
  }
  return false;
1020}

1022bool ScDocument::SetDdeLinkResultMatrix( size_t nDdePos, const ScMatrixRef& pResults )
1023{
  if( ScDdeLink* pDdeLink = lclGetDdeLink( GetLinkManager(), nDdePos ) )
  {
      pDdeLink->SetResult( pResults );
      return true;
  }
  return false;
1030}

1032bool ScDocument::HasAreaLinks() const
1033{
  const sfx2::LinkManager* pMgr = GetDocLinkManager().getExistingLinkManager();
  if (!pMgr)
      return false;

  const ::sfx2::SvBaseLinks& rLinks = pMgr->GetLinks();
  sal_uInt16 nCount = rLinks.size();
  for (sal_uInt16 i=0; i<nCount; i++)
      if (nullptr != dynamic_cast<const ScAreaLink* >(rLinks[i].get()))
          return true;

  return false;
1045}

1047void ScDocument::UpdateAreaLinks()
1048{
  sfx2::LinkManager* pMgr = GetDocLinkManager().getLinkManager(false);
  if (!pMgr)
      return;

  const ::sfx2::SvBaseLinks& rLinks = pMgr->GetLinks();
  for (const auto & rLink : rLinks)
  {
      ::sfx2::SvBaseLink* pBase = rLink.get();
      if (dynamic_cast<const ScAreaLink*>( pBase) !=  nullptr)
          pBase->Update();
  }
1060}

1062void ScDocument::DeleteAreaLinksOnTab( SCTAB nTab )
1063{
  sfx2::LinkManager* pMgr = GetDocLinkManager().getLinkManager(false);
  if (!pMgr)
      return;

  const ::sfx2::SvBaseLinks& rLinks = pMgr->GetLinks();
  sfx2::SvBaseLinks::size_type nPos = 0;
  while ( nPos < rLinks.size() )
  {
      const ::sfx2::SvBaseLink* pBase = rLinks[nPos].get();
      const ScAreaLink* pLink = dynamic_cast<const ScAreaLink*>(pBase);
      if (pLink && pLink->GetDestArea().aStart.Tab() == nTab)
          pMgr->Remove(nPos);
      else
          ++nPos;
  }
1079}

1081void ScDocument::UpdateRefAreaLinks( UpdateRefMode eUpdateRefMode,
                           const ScRange& rRange, SCCOL nDx, SCROW nDy, SCTAB nDz )
1083{
  sfx2::LinkManager* pMgr = GetDocLinkManager().getLinkManager(false);
  if (!pMgr)
      return;

  bool bAnyUpdate = false;

  const ::sfx2::SvBaseLinks& rLinks = pMgr->GetLinks();
  sal_uInt16 nCount = rLinks.size();
  for (sal_uInt16 i=0; i<nCount; i++)
  {
      ::sfx2::SvBaseLink* pBase = rLinks[i].get();
      if (ScAreaLink* pLink = dynamic_cast<ScAreaLink*>(pBase))
      {
          ScRange aOutRange = pLink->GetDestArea();

          SCCOL nCol1 = aOutRange.aStart.Col();
          SCROW nRow1 = aOutRange.aStart.Row();
          SCTAB nTab1 = aOutRange.aStart.Tab();
          SCCOL nCol2 = aOutRange.aEnd.Col();
          SCROW nRow2 = aOutRange.aEnd.Row();
          SCTAB nTab2 = aOutRange.aEnd.Tab();

          ScRefUpdateRes eRes =
              ScRefUpdate::Update( this, eUpdateRefMode,
                  rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(),
                  rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(), nDx, nDy, nDz,
                  nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
          if ( eRes != UR_NOTHING )
          {
              pLink->SetDestArea( ScRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ) );
              bAnyUpdate = true;
          }
      }
  }

  if ( !bAnyUpdate )
      return;

  // #i52120# Look for duplicates (after updating all positions).
  // If several links start at the same cell, the one with the lower index is removed
  // (file format specifies only one link definition for a cell).

  sal_uInt16 nFirstIndex = 0;
  while ( nFirstIndex < nCount )
  {
      bool bFound = false;
      ::sfx2::SvBaseLink* pFirst = rLinks[nFirstIndex].get();
      if (ScAreaLink* pFirstLink = dynamic_cast<ScAreaLink*>(pFirst))
      {
          ScAddress aFirstPos = pFirstLink->GetDestArea().aStart;
          for ( sal_uInt16 nSecondIndex = nFirstIndex + 1; nSecondIndex < nCount && !bFound; ++nSecondIndex )
          {
              ::sfx2::SvBaseLink* pSecond = rLinks[nSecondIndex].get();
              ScAreaLink* pSecondLink = dynamic_cast<ScAreaLink*>(pSecond);
              if (pSecondLink && pSecondLink->GetDestArea().aStart == aFirstPos)
              {
                  // remove the first link, exit the inner loop, don't increment nFirstIndex
                  pMgr->Remove(pFirst);
                  nCount = rLinks.size();
                  bFound = true;
              }
          }
      }
      if (!bFound)
          ++nFirstIndex;
  }
1150}

1152void ScDocument::CheckLinkFormulaNeedingCheck( const ScTokenArray& rCode )
1153{
  if (HasLinkFormulaNeedingCheck())
      return;

  // Prefer RPN over tokenized formula if available.
  if (rCode.GetCodeLen())
  {
      if (rCode.HasOpCodeRPN(ocDde) || rCode.HasOpCodeRPN(ocWebservice))
          SetLinkFormulaNeedingCheck(true);
  }
  else if (rCode.GetLen())
  {
      if (rCode.HasOpCode(ocDde) || rCode.HasOpCode(ocWebservice))
          SetLinkFormulaNeedingCheck(true);
  }
  else
  {
      // Possible with named expression without expression like Excel
      // internal print ranges, obscure user define names, ... formula error
      // cells without formula ...
      SAL_WARN("sc.core","ScDocument::CheckLinkFormulaNeedingCheck - called with empty ScTokenArray")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.core")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "ScDocument::CheckLinkFormulaNeedingCheck - called with empty ScTokenArray"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "1173" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScDocument::CheckLinkFormulaNeedingCheck - called with empty ScTokenArray"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScDocument::CheckLinkFormulaNeedingCheck - called with empty ScTokenArray"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "1173" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScDocument::CheckLinkFormulaNeedingCheck - called with empty ScTokenArray"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "1173" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScDocument::CheckLinkFormulaNeedingCheck - called with empty ScTokenArray"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScDocument::CheckLinkFormulaNeedingCheck - called with empty ScTokenArray"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "1173" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
1175}

1177// TimerDelays etc.
1178void ScDocument::KeyInput()
1179{
  if ( pChartListenerCollection->hasListeners() )
      pChartListenerCollection->StartTimer();
  if (apTemporaryChartLock)
      apTemporaryChartLock->StartOrContinueLocking();
1184}

1186SfxBindings* ScDocument::GetViewBindings()
1187{
  //  used to invalidate slots after changes to this document

  if ( !mpShell )
      return nullptr;        // no ObjShell -> no view

  //  first check current view
  SfxViewFrame* pViewFrame = SfxViewFrame::Current();
  if ( pViewFrame && pViewFrame->GetObjectShell() != mpShell )     // wrong document?
      pViewFrame = nullptr;

  //  otherwise use first view for this doc
  if ( !pViewFrame )
      pViewFrame = SfxViewFrame::GetFirst( mpShell );

  if (pViewFrame)
      return &pViewFrame->GetBindings();
  else
      return nullptr;
1206}

1208void ScDocument::TransliterateText( const ScMarkData& rMultiMark, TransliterationFlags nType )
1209{
  OSL_ENSURE( rMultiMark.IsMultiMarked(), "TransliterateText: no selection" )do { if (true && (!(rMultiMark.IsMultiMarked()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen8.cxx"
 ":" "1210" ": "), "%s", "TransliterateText: no selection"); }
 } while (false);

  utl::TransliterationWrapper aTransliterationWrapper( comphelper::getProcessComponentContext(), nType );
  bool bConsiderLanguage = aTransliterationWrapper.needLanguageForTheMode();
  LanguageType nLanguage = LANGUAGE_SYSTEMLanguageType(0x0000);

  std::unique_ptr<ScEditEngineDefaulter> pEngine;        // not using mpEditEngine member because of defaults

  SCTAB nCount = GetTableCount();
  for (const SCTAB& nTab : rMultiMark)
  {
      if (nTab >= nCount)
          break;

      if ( maTabs[nTab] )
      {
          SCCOL nCol = 0;
          SCROW nRow = 0;

          bool bFound = rMultiMark.IsCellMarked( nCol, nRow );
          if (!bFound)
              bFound = GetNextMarkedCell( nCol, nRow, nTab, rMultiMark );

          while (bFound)
          {
              ScRefCellValue aCell(*this, ScAddress(nCol, nRow, nTab));

              // fdo#32786 TITLE_CASE/SENTENCE_CASE need the extra handling in EditEngine (loop over words/sentences).
              // Still use TransliterationWrapper directly for text cells with other transliteration types,
              // for performance reasons.
              if (aCell.meType == CELLTYPE_EDIT ||
                  (aCell.meType == CELLTYPE_STRING &&
                   ( nType == TransliterationFlags::SENTENCE_CASE || nType == TransliterationFlags::TITLE_CASE)))
              {
                  if (!pEngine)
                      pEngine.reset(new ScFieldEditEngine(this, GetEnginePool(), GetEditPool()));

                  // defaults from cell attributes must be set so right language is used
                  const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
                  std::unique_ptr<SfxItemSet> pDefaults(new SfxItemSet( pEngine->GetEmptyItemSet() ));
                  if ( ScStyleSheet* pPreviewStyle = GetPreviewCellStyle( nCol, nRow, nTab ) )
                  {
                      std::unique_ptr<ScPatternAttr> pPreviewPattern(new ScPatternAttr( *pPattern ));
                      pPreviewPattern->SetStyleSheet(pPreviewStyle);
                      pPreviewPattern->FillEditItemSet( pDefaults.get() );
                  }
                  else
                  {
                      SfxItemSet* pFontSet = GetPreviewFont( nCol, nRow, nTab );
                      pPattern->FillEditItemSet( pDefaults.get(), pFontSet );
                  }
                  pEngine->SetDefaults( std::move(pDefaults) );
                  if (aCell.meType == CELLTYPE_STRING)
                      pEngine->SetTextCurrentDefaults(aCell.mpString->getString());
                  else if (aCell.mpEditText)
                      pEngine->SetTextCurrentDefaults(*aCell.mpEditText);

                  pEngine->ClearModifyFlag();

                  sal_Int32 nLastPar = pEngine->GetParagraphCount();
                  if (nLastPar)
                      --nLastPar;
                  sal_Int32 nTxtLen = pEngine->GetTextLen(nLastPar);
                  ESelection aSelAll( 0, 0, nLastPar, nTxtLen );

                  pEngine->TransliterateText( aSelAll, nType );

                  if ( pEngine->IsModified() )
                  {
                      ScEditAttrTester aTester( pEngine.get() );
                      if ( aTester.NeedsObject() )
                      {
                          // remove defaults (paragraph attributes) before creating text object
                          pEngine->SetDefaults( std::make_unique<SfxItemSet>( pEngine->GetEmptyItemSet() ) );

                          // The cell will take ownership of the text object instance.
                          SetEditText(ScAddress(nCol,nRow,nTab), pEngine->CreateTextObject());
                      }
                      else
                      {
                          ScSetStringParam aParam;
                          aParam.setTextInput();
                          SetString(ScAddress(nCol,nRow,nTab), pEngine->GetText(), &aParam);
                      }
                  }
              }

              else if (aCell.meType == CELLTYPE_STRING)
              {
                  OUString aOldStr = aCell.mpString->getString();
                  sal_Int32 nOldLen = aOldStr.getLength();

                  if ( bConsiderLanguage )
                  {
                      SvtScriptType nScript = GetStringScriptType( aOldStr );        //TODO: cell script type?
                      sal_uInt16 nWhich = ( nScript == SvtScriptType::ASIAN ) ? ATTR_CJK_FONT_LANGUAGE :
                                      ( ( nScript == SvtScriptType::COMPLEX ) ? ATTR_CTL_FONT_LANGUAGE :
                                                                              ATTR_FONT_LANGUAGE );
                      nLanguage = static_cast<const SvxLanguageItem*>(GetAttr( nCol, nRow, nTab, nWhich ))->GetValue();
                  }

                  uno::Sequence<sal_Int32> aOffsets;
                  OUString aNewStr = aTransliterationWrapper.transliterate( aOldStr, nLanguage, 0, nOldLen, &aOffsets );

                  if ( aNewStr != aOldStr )
                  {
                      ScSetStringParam aParam;
                      aParam.setTextInput();
                      SetString(ScAddress(nCol,nRow,nTab), aNewStr, &aParam);
                  }
              }
              bFound = GetNextMarkedCell( nCol, nRow, nTab, rMultiMark );
          }
      }
  }
1325}

1327/* 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);
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
12
←
Calling 'Reference::clear'→
19
←
Returning; memory was released→
      if (aTmp.get()) {
20
←
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)
3
←
Calling implicit copy constructor for 'VclPtr<SfxPrinter>'→
4
←
Calling copy constructor for 'Reference<SfxPrinter>'→
7
←
Returning from copy constructor for 'Reference<SfxPrinter>'→
8
←
Returning from copy constructor for 'VclPtr<SfxPrinter>'→
  {}

  /**
     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();
11
←
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)
5
←
Assuming field 'm_pBody' is non-null→
6
←
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_pBody12.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
)
13
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
14
←
Calling 'VclReferenceBase::release'→
18
←
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;
21
←
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)
15
←
Assuming the condition is true→
16
←
Taking true branch→
40            delete this;
17
←
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