/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 optpage.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 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/sw/inc -I /home/maarten/src/libreoffice/core/sw/source/uibase/inc -I /home/maarten/src/libreoffice/core/sw/source/ui/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sw/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/sw/source/ui/config/optpage.cxx

/home/maarten/src/libreoffice/core/sw/source/ui/config/optpage.cxx

→

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

20#include <sal/config.h>

22#include <utility>

24#include <optpage.hxx>
25#include <doc.hxx>
26#include <hintids.hxx>
27#include <cmdid.h>
28#include <fmtcol.hxx>
29#include <charatr.hxx>
30#include <swtypes.hxx>
31#include <view.hxx>
32#include <docsh.hxx>
33#include <IDocumentDeviceAccess.hxx>
34#include <IDocumentSettingAccess.hxx>

36#include <swmodule.hxx>
37#include <wrtsh.hxx>
38#include <cfgitems.hxx>
39#include <poolfmt.hxx>
40#include <uiitems.hxx>
41#include <printdata.hxx>
42#include <modcfg.hxx>
43#include <crstate.hxx>
44#include <viewopt.hxx>
45#include <globals.hrc>
46#include <strings.hrc>
47#include <swwrtshitem.hxx>

49#include <editeng/fhgtitem.hxx>
50#include <editeng/fontitem.hxx>
51#include <editeng/langitem.hxx>
52#include <editeng/svxenum.hxx>
53#include <sal/macros.h>
54#include <sfx2/dialoghelper.hxx>
55#include <sfx2/dispatch.hxx>
56#include <sfx2/printer.hxx>
57#include <sfx2/bindings.hxx>
58#include <sfx2/viewfrm.hxx>
59#include <svl/ctloptions.hxx>
60#include <svl/eitem.hxx>
61#include <svl/cjkoptions.hxx>
62#include <svtools/ctrltool.hxx>
63#include <svtools/unitconv.hxx>
64#include <sfx2/htmlmode.hxx>

66#include <vcl/settings.hxx>
67#include <vcl/svapp.hxx>

69#include <optload.hxx>

71#include <svtools/miscopt.hxx>

73using namespace ::com::sun::star;

75namespace {

77void drawRect(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect, const Color &rFillColor, const Color &rLineColor)
78{
  rRenderContext.SetFillColor(rFillColor);
  rRenderContext.SetLineColor(rLineColor);
  rRenderContext.DrawRect(rRect);
82}

84}

86// Tools->Options->Writer->View
87// Tools->Options->Writer/Web->View
88SwContentOptPage::SwContentOptPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rCoreSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/viewoptionspage.ui", "ViewOptionsPage", &rCoreSet)
  , m_xCrossCB(m_xBuilder->weld_check_button("helplines"))
  , m_xHMetric(m_xBuilder->weld_combo_box("hrulercombobox"))
  , m_xVRulerCBox(m_xBuilder->weld_check_button("vruler"))
  , m_xVRulerRightCBox(m_xBuilder->weld_check_button("vrulerright"))
  , m_xVMetric(m_xBuilder->weld_combo_box("vrulercombobox"))
  , m_xSmoothCBox(m_xBuilder->weld_check_button("smoothscroll"))
  , m_xGrfCB(m_xBuilder->weld_check_button("graphics"))
  , m_xTableCB(m_xBuilder->weld_check_button("tables"))
  , m_xDrwCB(m_xBuilder->weld_check_button("drawings"))
  , m_xPostItCB(m_xBuilder->weld_check_button("comments"))
  , m_xSettingsFrame(m_xBuilder->weld_frame("settingsframe"))
  , m_xSettingsLabel(m_xBuilder->weld_label("settingslabel"))
  , m_xMetricLabel(m_xBuilder->weld_label("measureunitlabel"))
  , m_xMetricLB(m_xBuilder->weld_combo_box("measureunit"))
  , m_xShowInlineTooltips(m_xBuilder->weld_check_button("changestooltip"))
  , m_xShowOutlineContentVisibilityButton(m_xBuilder->weld_check_button("outlinecontentvisibilitybutton"))
  , m_xFieldHiddenCB(m_xBuilder->weld_check_button("hiddentextfield"))
  , m_xFieldHiddenParaCB(m_xBuilder->weld_check_button("hiddenparafield"))
108{
  SvtMiscOptions aMiscOptions;
  if (!aMiscOptions.IsExperimentalMode())
      m_xShowOutlineContentVisibilityButton->hide();

  /* This part is visible only with Writer/Web->View dialogue. */
  const SfxPoolItem* pItem;
  if (! (SfxItemState::SET == rCoreSet.GetItemState(SID_HTML_MODE(10000 + 414), false, &pItem )
         && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON))
  {
      m_xSettingsFrame->hide();
      m_xSettingsLabel->hide();
      m_xMetricLabel->hide();
      m_xMetricLB->hide();
  }

  SvtCJKOptions aCJKOptions;
  if(!aCJKOptions.IsVerticalTextEnabled() )
      m_xVRulerRightCBox->hide();
  m_xVRulerCBox->connect_toggled(LINK(this, SwContentOptPage, VertRulerHdl )::tools::detail::makeLink( ::tools::detail::castTo<SwContentOptPage
 *>(this), &SwContentOptPage::LinkStubVertRulerHdl));

  for (size_t i = 0; i < SwFieldUnitTable::Count(); ++i)
  {
      const OUString sMetric = SwFieldUnitTable::GetString(i);
      FieldUnit eFUnit = SwFieldUnitTable::GetValue(i);

      switch ( eFUnit )
      {
          case FieldUnit::MM:
          case FieldUnit::CM:
          case FieldUnit::POINT:
          case FieldUnit::PICA:
          case FieldUnit::INCH:
          case FieldUnit::CHAR:    // add two units , 'character' and 'line' , their ticks are not fixed
          case FieldUnit::LINE:
          {
              // only use these metrics
              // a horizontal ruler has not the 'line' unit
              // there isn't 'line' unit in HTML format
              if (eFUnit != FieldUnit::LINE)
              {
                 m_xMetricLB->append(OUString::number(static_cast<sal_uInt32>(eFUnit)), sMetric);
                 m_xHMetric->append(OUString::number(static_cast<sal_uInt32>(eFUnit)), sMetric);
              }
              // a vertical ruler has not the 'character' unit
              if (eFUnit != FieldUnit::CHAR)
              {
                 m_xVMetric->append(OUString::number(static_cast<sal_uInt32>(eFUnit)), sMetric);
              }
              break;
          }
          default:;//prevent warning
      }
  }
162}

164SwContentOptPage::~SwContentOptPage()
165{
166}

168std::unique_ptr<SfxTabPage> SwContentOptPage::Create( weld::Container* pPage, weld::DialogController* pController,
                                           const SfxItemSet* rAttrSet)
170{
  return std::make_unique<SwContentOptPage>(pPage, pController, *rAttrSet);
172}

174static void lcl_SelectMetricLB(weld::ComboBox& rMetric, sal_uInt16 nSID, const SfxItemSet& rSet)
175{
  const SfxPoolItem* pItem;
  if( rSet.GetItemState( nSID, false, &pItem ) >= SfxItemState::DEFAULT )
  {
      FieldUnit eFieldUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
      for (sal_Int32 i = 0, nEntryCount = rMetric.get_count(); i < nEntryCount; ++i)
      {
          if (rMetric.get_id(i).toUInt32() == static_cast<sal_uInt32>(eFieldUnit))
          {
              rMetric.set_active(i);
              break;
          }
      }
  }
  rMetric.save_value();
190}

192void SwContentOptPage::Reset(const SfxItemSet* rSet)
193{
  const SwElemItem* pElemAttr = nullptr;

  rSet->GetItemState( FN_PARAM_ELEM((20000 + 1100)+21) , false,
                                  reinterpret_cast<const SfxPoolItem**>(&pElemAttr) );
  if(pElemAttr)
  {
      m_xTableCB->set_active(pElemAttr->m_bTable);
      m_xGrfCB->set_active(pElemAttr->m_bGraphic);
      m_xDrwCB->set_active(pElemAttr->m_bDrawing);
      m_xPostItCB->set_active(pElemAttr->m_bNotes);
      m_xCrossCB->set_active(pElemAttr->m_bCrosshair);
      m_xVRulerCBox->set_active(pElemAttr->m_bVertRuler);
      m_xVRulerRightCBox->set_active(pElemAttr->m_bVertRulerRight);
      m_xSmoothCBox->set_active(pElemAttr->m_bSmoothScroll);
      m_xShowInlineTooltips->set_active(pElemAttr->m_bShowInlineTooltips);
      m_xShowOutlineContentVisibilityButton->set_active(pElemAttr->m_bShowOutlineContentVisibilityButton);
      m_xFieldHiddenCB->set_active( pElemAttr->m_bFieldHiddenText );
      m_xFieldHiddenParaCB->set_active( pElemAttr->m_bShowHiddenPara );
      if (GetActiveWrtShell()->GetViewOptions()->IsShowOutlineContentVisibilityButton() != pElemAttr->m_bShowOutlineContentVisibilityButton)
          GetActiveWrtShell()->GetView().GetDocShell()->GetDispatcher()->Execute(FN_SHOW_OUTLINECONTENTVISIBILITYBUTTON((20000 + 200) + 63));
  }
  m_xMetricLB->set_active(-1);
  lcl_SelectMetricLB(*m_xMetricLB, SID_ATTR_METRICTypedWhichId<SfxUInt16Item>(((((10000 + 1499) + 1) + 499
) + 1) + 8), *rSet);
  lcl_SelectMetricLB(*m_xHMetric, FN_HSCROLL_METRIC((20000 + 200) + 53), *rSet);
  lcl_SelectMetricLB(*m_xVMetric, FN_VSCROLL_METRIC((20000 + 200) + 54), *rSet);
219}

221bool SwContentOptPage::FillItemSet(SfxItemSet* rSet)
222{
  const SwElemItem*   pOldAttr = static_cast<const SwElemItem*>(
                      GetOldItem(GetItemSet(), FN_PARAM_ELEM((20000 + 1100)+21)));

  SwElemItem aElem;
  aElem.m_bTable                = m_xTableCB->get_active();
  aElem.m_bGraphic              = m_xGrfCB->get_active();
  aElem.m_bDrawing              = m_xDrwCB->get_active();
  aElem.m_bNotes                = m_xPostItCB->get_active();
  aElem.m_bCrosshair            = m_xCrossCB->get_active();
  aElem.m_bVertRuler            = m_xVRulerCBox->get_active();
  aElem.m_bVertRulerRight       = m_xVRulerRightCBox->get_active();
  aElem.m_bSmoothScroll         = m_xSmoothCBox->get_active();
  aElem.m_bShowInlineTooltips   = m_xShowInlineTooltips->get_active();
  aElem.m_bShowOutlineContentVisibilityButton = m_xShowOutlineContentVisibilityButton->get_active();
  aElem.m_bFieldHiddenText      = m_xFieldHiddenCB->get_active();
  aElem.m_bShowHiddenPara       = m_xFieldHiddenParaCB->get_active();

  if (GetActiveWrtShell()->GetViewOptions()->IsShowOutlineContentVisibilityButton() != aElem.m_bShowOutlineContentVisibilityButton)
      GetActiveWrtShell()->GetView().GetDocShell()->GetDispatcher()->Execute(FN_SHOW_OUTLINECONTENTVISIBILITYBUTTON((20000 + 200) + 63));

  bool bRet = !pOldAttr || aElem != *pOldAttr;
  if(bRet)
      bRet = nullptr != rSet->Put(aElem);

  sal_Int32 nMPos = m_xMetricLB->get_active();
  sal_Int32 nGlobalMetricPos = nMPos;
  if ( m_xMetricLB->get_value_changed_from_saved() )
  {
      const sal_uInt16 nFieldUnit = m_xMetricLB->get_id(nMPos).toUInt32();
      rSet->Put( SfxUInt16Item( SID_ATTR_METRICTypedWhichId<SfxUInt16Item>(((((10000 + 1499) + 1) + 499
) + 1) + 8), nFieldUnit ) );
      bRet = true;
  }

  nMPos = m_xHMetric->get_active();
  if ( m_xHMetric->get_value_changed_from_saved() || nMPos != nGlobalMetricPos )
  {
      const sal_uInt16 nFieldUnit = m_xHMetric->get_id(nMPos).toUInt32();
      rSet->Put( SfxUInt16Item( FN_HSCROLL_METRIC((20000 + 200) + 53), nFieldUnit ) );
      bRet = true;
  }
  nMPos = m_xVMetric->get_active();
  if ( m_xVMetric->get_value_changed_from_saved() || nMPos != nGlobalMetricPos )
  {
      const sal_uInt16 nFieldUnit = m_xVMetric->get_id(nMPos).toUInt32();
      rSet->Put( SfxUInt16Item( FN_VSCROLL_METRIC((20000 + 200) + 54), nFieldUnit ) );
      bRet = true;
  }

  return bRet;
272}

274IMPL_LINK(SwContentOptPage, VertRulerHdl, weld::ToggleButton&, rBox, void)void SwContentOptPage::LinkStubVertRulerHdl(void * instance, weld
::ToggleButton& data) { return static_cast<SwContentOptPage
 *>(instance)->VertRulerHdl(data); } void SwContentOptPage
::VertRulerHdl(weld::ToggleButton& rBox)
275{
  m_xVRulerRightCBox->set_sensitive(rBox.get_sensitive() && rBox.get_active());
277}

279// TabPage Printer additional settings
280SwAddPrinterTabPage::SwAddPrinterTabPage(weld::Container* pPage, weld::DialogController* pController,
  const SfxItemSet& rCoreSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/printoptionspage.ui", "PrintOptionsPage", &rCoreSet)
  , sNone(SwResId(SW_STR_NONEreinterpret_cast<char const *>("SW_STR_NONE" "\004" u8"[None]"
)))
  , bAttrModified(false)
  , bPreview(false)
  , m_xGrfCB(m_xBuilder->weld_check_button("graphics"))
  , m_xCtrlFieldCB(m_xBuilder->weld_check_button("formcontrols"))
  , m_xBackgroundCB(m_xBuilder->weld_check_button("background"))
  , m_xBlackFontCB(m_xBuilder->weld_check_button("inblack"))
  , m_xPrintHiddenTextCB(m_xBuilder->weld_check_button("hiddentext"))
  , m_xPrintTextPlaceholderCB(m_xBuilder->weld_check_button("textplaceholder"))
  , m_xPagesFrame(m_xBuilder->weld_widget("pagesframe"))
  , m_xLeftPageCB(m_xBuilder->weld_check_button("leftpages"))
  , m_xRightPageCB(m_xBuilder->weld_check_button("rightpages"))
  , m_xProspectCB(m_xBuilder->weld_check_button("brochure"))
  , m_xProspectCB_RTL(m_xBuilder->weld_check_button("rtl"))
  , m_xCommentsFrame(m_xBuilder->weld_widget("commentsframe"))
  , m_xNoRB(m_xBuilder->weld_radio_button("none"))
  , m_xOnlyRB(m_xBuilder->weld_radio_button("only"))
  , m_xEndRB(m_xBuilder->weld_radio_button("end"))
  , m_xEndPageRB(m_xBuilder->weld_radio_button("endpage"))
  , m_xInMarginsRB(m_xBuilder->weld_radio_button("inmargins"))
  , m_xPrintEmptyPagesCB(m_xBuilder->weld_check_button("blankpages"))
  , m_xPaperFromSetupCB(m_xBuilder->weld_check_button("papertray"))
  , m_xFaxLB(m_xBuilder->weld_combo_box("fax"))
306{
  Link<weld::ToggleButton&,void> aLk = LINK( this, SwAddPrinterTabPage, AutoClickHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwAddPrinterTabPage
 *>(this), &SwAddPrinterTabPage::LinkStubAutoClickHdl);
  m_xGrfCB->connect_toggled( aLk );
  m_xRightPageCB->connect_toggled( aLk );
  m_xLeftPageCB->connect_toggled( aLk );
  m_xCtrlFieldCB->connect_toggled( aLk );
  m_xBackgroundCB->connect_toggled( aLk );
  m_xBlackFontCB->connect_toggled( aLk );
  m_xPrintHiddenTextCB->connect_toggled( aLk );
  m_xPrintTextPlaceholderCB->connect_toggled( aLk );
  m_xProspectCB->connect_toggled( aLk );
  m_xProspectCB_RTL->connect_toggled( aLk );
  m_xPaperFromSetupCB->connect_toggled( aLk );
  m_xPrintEmptyPagesCB->connect_toggled( aLk );
  m_xEndPageRB->connect_toggled( aLk );
  m_xInMarginsRB->connect_toggled( aLk );
  m_xEndRB->connect_toggled( aLk );
  m_xOnlyRB->connect_toggled( aLk );
  m_xNoRB->connect_toggled( aLk );
  m_xFaxLB->connect_changed( LINK( this, SwAddPrinterTabPage, SelectHdl )::tools::detail::makeLink( ::tools::detail::castTo<SwAddPrinterTabPage
 *>(this), &SwAddPrinterTabPage::LinkStubSelectHdl) );

  const SfxPoolItem* pItem;
  if(SfxItemState::SET == rCoreSet.GetItemState(SID_HTML_MODE(10000 + 414), false, &pItem )
      && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON)
  {
      m_xLeftPageCB->hide();
      m_xRightPageCB->hide();
      m_xPrintHiddenTextCB->hide();
      m_xPrintTextPlaceholderCB->hide();
      m_xPrintEmptyPagesCB->hide();
  }
  m_xProspectCB_RTL->set_sensitive(false);
  SvtCTLOptions aCTLOptions;
  m_xProspectCB_RTL->set_visible(aCTLOptions.IsCTLFontEnabled());
340}

342SwAddPrinterTabPage::~SwAddPrinterTabPage()
343{
344}

346void SwAddPrinterTabPage::SetPreview(bool bPrev)
347{
  bPreview = bPrev;
  m_xCommentsFrame->set_sensitive(!bPreview);
  m_xPagesFrame->set_sensitive(!bPreview);
351}

353std::unique_ptr<SfxTabPage> SwAddPrinterTabPage::Create( weld::Container* pPage, weld::DialogController* pController,
                                              const SfxItemSet* rAttrSet )
355{
  return std::make_unique<SwAddPrinterTabPage>(pPage, pController, *rAttrSet);
357}

359bool    SwAddPrinterTabPage::FillItemSet( SfxItemSet* rCoreSet )
360{
  if ( bAttrModified )
  {
      SwAddPrinterItem aAddPrinterAttr;
      aAddPrinterAttr.m_bPrintGraphic   = m_xGrfCB->get_active();
      aAddPrinterAttr.m_bPrintTable     = true; // always enabled since CWS printerpullgpages /*m_xTabCB->get_active();*/
      aAddPrinterAttr.m_bPrintDraw      = m_xGrfCB->get_active(); // UI merged with m_xGrfCB in CWS printerpullgpages
      aAddPrinterAttr.m_bPrintControl   = m_xCtrlFieldCB->get_active();
      aAddPrinterAttr.m_bPrintPageBackground = m_xBackgroundCB->get_active();
      aAddPrinterAttr.m_bPrintBlackFont = m_xBlackFontCB->get_active();
      aAddPrinterAttr.m_bPrintHiddenText = m_xPrintHiddenTextCB->get_active();
      aAddPrinterAttr.m_bPrintTextPlaceholder = m_xPrintTextPlaceholderCB->get_active();

      aAddPrinterAttr.m_bPrintLeftPages     = m_xLeftPageCB->get_active();
      aAddPrinterAttr.m_bPrintRightPages    = m_xRightPageCB->get_active();
      aAddPrinterAttr.m_bPrintReverse       = false; // handled by vcl itself since CWS printerpullpages /*m_xReverseCB->get_active()*/;
      aAddPrinterAttr.m_bPrintProspect      = m_xProspectCB->get_active();
      aAddPrinterAttr.m_bPrintProspectRTL   = m_xProspectCB_RTL->get_active();
      aAddPrinterAttr.m_bPaperFromSetup     = m_xPaperFromSetupCB->get_active();
      aAddPrinterAttr.m_bPrintEmptyPages    = m_xPrintEmptyPagesCB->get_active();
      aAddPrinterAttr.m_bPrintSingleJobs    = true; // handled by vcl in new print dialog since CWS printerpullpages /*m_xSingleJobsCB->get_active()*/;

      if (m_xNoRB->get_active())  aAddPrinterAttr.m_nPrintPostIts =
                                                      SwPostItMode::NONE;
      if (m_xOnlyRB->get_active()) aAddPrinterAttr.m_nPrintPostIts =
                                                      SwPostItMode::Only;
      if (m_xEndRB->get_active()) aAddPrinterAttr.m_nPrintPostIts =
                                                      SwPostItMode::EndDoc;
      if (m_xEndPageRB->get_active()) aAddPrinterAttr.m_nPrintPostIts =
                                                      SwPostItMode::EndPage;
      if (m_xInMarginsRB->get_active()) aAddPrinterAttr.m_nPrintPostIts =
                                                      SwPostItMode::InMargins;

      const OUString sFax = m_xFaxLB->get_active_text();
      aAddPrinterAttr.m_sFaxName = sNone == sFax ? OUString() : sFax;
      rCoreSet->Put(aAddPrinterAttr);
  }
  return bAttrModified;
398}

400void    SwAddPrinterTabPage::Reset( const SfxItemSet*  )
401{
  const   SfxItemSet&         rSet = GetItemSet();
  const   SwAddPrinterItem*   pAddPrinterAttr = nullptr;

  if( SfxItemState::SET == rSet.GetItemState( FN_PARAM_ADDPRINTER((20000 + 1100)+18) , false,
                                  reinterpret_cast<const SfxPoolItem**>(&pAddPrinterAttr) ))
  {
      m_xGrfCB->set_active(pAddPrinterAttr->m_bPrintGraphic || pAddPrinterAttr->m_bPrintDraw);
      m_xCtrlFieldCB->set_active(       pAddPrinterAttr->m_bPrintControl);
      m_xBackgroundCB->set_active(    pAddPrinterAttr->m_bPrintPageBackground);
      m_xBlackFontCB->set_active(     pAddPrinterAttr->m_bPrintBlackFont);
      m_xPrintHiddenTextCB->set_active( pAddPrinterAttr->m_bPrintHiddenText);
      m_xPrintTextPlaceholderCB->set_active(pAddPrinterAttr->m_bPrintTextPlaceholder);
      m_xLeftPageCB->set_active(      pAddPrinterAttr->m_bPrintLeftPages);
      m_xRightPageCB->set_active(     pAddPrinterAttr->m_bPrintRightPages);
      m_xPaperFromSetupCB->set_active(pAddPrinterAttr->m_bPaperFromSetup);
      m_xPrintEmptyPagesCB->set_active(pAddPrinterAttr->m_bPrintEmptyPages);
      m_xProspectCB->set_active(      pAddPrinterAttr->m_bPrintProspect);
      m_xProspectCB_RTL->set_active(      pAddPrinterAttr->m_bPrintProspectRTL);

      m_xNoRB->set_active(pAddPrinterAttr->m_nPrintPostIts== SwPostItMode::NONE ) ;
      m_xOnlyRB->set_active(pAddPrinterAttr->m_nPrintPostIts== SwPostItMode::Only ) ;
      m_xEndRB->set_active(pAddPrinterAttr->m_nPrintPostIts== SwPostItMode::EndDoc ) ;
      m_xEndPageRB->set_active(pAddPrinterAttr->m_nPrintPostIts== SwPostItMode::EndPage ) ;
      m_xInMarginsRB->set_active(pAddPrinterAttr->m_nPrintPostIts== SwPostItMode::InMargins ) ;
      auto nFound = m_xFaxLB->find_text(pAddPrinterAttr->m_sFaxName);
      if (nFound != -1)
          m_xFaxLB->set_active(nFound);
      else
          m_xFaxLB->set_active(0);
  }
  if (m_xProspectCB->get_active())
  {
      m_xProspectCB_RTL->set_sensitive(true);
      m_xNoRB->set_sensitive( false );
      m_xOnlyRB->set_sensitive( false );
      m_xEndRB->set_sensitive( false );
      m_xEndPageRB->set_sensitive( false );
  }
  else
      m_xProspectCB_RTL->set_sensitive( false );
442}

444IMPL_LINK_NOARG(SwAddPrinterTabPage, AutoClickHdl, weld::ToggleButton&, void)void SwAddPrinterTabPage::LinkStubAutoClickHdl(void * instance
, weld::ToggleButton& data) { return static_cast<SwAddPrinterTabPage
 *>(instance)->AutoClickHdl(data); } void SwAddPrinterTabPage
::AutoClickHdl(__attribute__ ((unused)) weld::ToggleButton&
)
445{
  bAttrModified = true;
  bool bIsProspect = m_xProspectCB->get_active();
  if (!bIsProspect)
      m_xProspectCB_RTL->set_active( false );
  m_xProspectCB_RTL->set_sensitive( bIsProspect );
  m_xNoRB->set_sensitive( !bIsProspect );
  m_xOnlyRB->set_sensitive( !bIsProspect );
  m_xEndRB->set_sensitive( !bIsProspect );
  m_xEndPageRB->set_sensitive( !bIsProspect );
  m_xInMarginsRB->set_sensitive( !bIsProspect );
456}

458void  SwAddPrinterTabPage::SetFax( const std::vector<OUString>& rFaxLst )
459{
  m_xFaxLB->append_text(sNone);
  for(const auto & i : rFaxLst)
  {
      m_xFaxLB->append_text(i);
  }
  m_xFaxLB->set_active(0);
466}

468IMPL_LINK_NOARG(SwAddPrinterTabPage, SelectHdl, weld::ComboBox&, void)void SwAddPrinterTabPage::LinkStubSelectHdl(void * instance, weld
::ComboBox& data) { return static_cast<SwAddPrinterTabPage
 *>(instance)->SelectHdl(data); } void SwAddPrinterTabPage
::SelectHdl(__attribute__ ((unused)) weld::ComboBox&)
469{
  bAttrModified=true;
471}

473void SwAddPrinterTabPage::PageCreated( const SfxAllItemSet& aSet)
474{
  const SfxBoolItem* pListItem = aSet.GetItem<SfxBoolItem>(SID_FAX_LIST(((20000) + 800) + 116), false);
  const SfxBoolItem* pPreviewItem = aSet.GetItem<SfxBoolItem>(SID_PREVIEWFLAG_TYPE(((20000) + 800) + 114), false);
  if (pPreviewItem)
  {
      SetPreview(pPreviewItem->GetValue());
      Reset(&aSet);
  }
  if (pListItem && pListItem->GetValue())
  {
      std::vector<OUString> aFaxList;
      const std::vector<OUString>& rPrinters = Printer::GetPrinterQueues();
      for (const auto & rPrinter : rPrinters)
          aFaxList.insert(aFaxList.begin(), rPrinter);
      SetFax( aFaxList );
  }
490}

492// Tabpage Standardfonts
493SwStdFontTabPage::SwStdFontTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/optfonttabpage.ui", "OptFontTabPage", &rSet)
  , m_pPrt(nullptr)
  , m_pFontConfig(nullptr)
  , m_pWrtShell(nullptr)
  , m_eLanguage( GetAppLanguage() )
  , m_bListDefault(false)
  , m_bSetListDefault(true)
  , m_bLabelDefault(false)
  , m_bSetLabelDefault(true)
  , m_bIdxDefault(false)
  , m_bSetIdxDefault(true)
  , m_bDisposePrinter(false)
  , m_bListHeightDefault(false)
  , m_bLabelHeightDefault(false)
  , m_bIndexHeightDefault(false)
  , m_nFontGroup(FONT_GROUP_DEFAULT0)
  , m_sScriptWestern(SwResId(ST_SCRIPT_WESTERNreinterpret_cast<char const *>("ST_SCRIPT_WESTERN" "\004"
 u8"Western")))
  , m_sScriptAsian(SwResId(ST_SCRIPT_ASIANreinterpret_cast<char const *>("ST_SCRIPT_ASIAN" "\004"
 u8"Asian")))
  , m_sScriptComplex(SwResId(ST_SCRIPT_CTLreinterpret_cast<char const *>("ST_SCRIPT_CTL" "\004" u8"CTL"
)))
  , m_xLabelFT(m_xBuilder->weld_label("label1"))
  , m_xStandardBox(m_xBuilder->weld_combo_box("standardbox"))
  , m_xStandardHeightLB(new FontSizeBox(m_xBuilder->weld_combo_box("standardheight")))
  , m_xTitleBox(m_xBuilder->weld_combo_box("titlebox"))
  , m_xTitleHeightLB(new FontSizeBox(m_xBuilder->weld_combo_box("titleheight")))
  , m_xListBox(m_xBuilder->weld_combo_box("listbox"))
  , m_xListHeightLB(new FontSizeBox(m_xBuilder->weld_combo_box("listheight")))
  , m_xLabelBox(m_xBuilder->weld_combo_box("labelbox"))
  , m_xLabelHeightLB(new FontSizeBox(m_xBuilder->weld_combo_box("labelheight")))
  , m_xIdxBox(m_xBuilder->weld_combo_box("idxbox"))
  , m_xIndexHeightLB(new FontSizeBox(m_xBuilder->weld_combo_box("indexheight")))
  , m_xStandardPB(m_xBuilder->weld_button("standard"))
525{
  m_xStandardBox->make_sorted();
  m_xTitleBox->make_sorted();
  m_xListBox->make_sorted();
  m_xLabelBox->make_sorted();
  m_xIdxBox->make_sorted();

  m_xStandardPB->connect_clicked(LINK(this, SwStdFontTabPage, StandardHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwStdFontTabPage
 *>(this), &SwStdFontTabPage::LinkStubStandardHdl));
  m_xStandardBox->connect_changed( LINK(this, SwStdFontTabPage, ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwStdFontTabPage
 *>(this), &SwStdFontTabPage::LinkStubModifyHdl));
  m_xListBox->connect_changed( LINK(this, SwStdFontTabPage, ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwStdFontTabPage
 *>(this), &SwStdFontTabPage::LinkStubModifyHdl));
  m_xLabelBox->connect_changed( LINK(this, SwStdFontTabPage, ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwStdFontTabPage
 *>(this), &SwStdFontTabPage::LinkStubModifyHdl));
  m_xIdxBox->connect_changed( LINK(this, SwStdFontTabPage, ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwStdFontTabPage
 *>(this), &SwStdFontTabPage::LinkStubModifyHdl));
  Link<weld::Widget&,void> aFocusLink = LINK( this, SwStdFontTabPage, LoseFocusHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwStdFontTabPage
 *>(this), &SwStdFontTabPage::LinkStubLoseFocusHdl);
  m_xStandardBox->connect_focus_out( aFocusLink );
  m_xTitleBox->connect_focus_out( aFocusLink );
  m_xListBox->connect_focus_out( aFocusLink );
  m_xLabelBox->connect_focus_out( aFocusLink );
  m_xIdxBox->connect_focus_out( aFocusLink );
543}

545SwStdFontTabPage::~SwStdFontTabPage()
546{
  m_xIndexHeightLB.reset();
  m_xLabelHeightLB.reset();
  m_xListHeightLB.reset();
  m_xTitleHeightLB.reset();
  m_xStandardHeightLB.reset();
  m_pFontList.reset();
  if (m_bDisposePrinter)
1
Assuming field 'm_bDisposePrinter' is true→
2
←
Taking true branch→
      m_pPrt.disposeAndClear();
3
←
Calling 'VclPtr::disposeAndClear'→
  else
      m_pPrt.clear();
557}

559std::unique_ptr<SfxTabPage> SwStdFontTabPage::Create( weld::Container* pPage, weld::DialogController* pController,
                                           const SfxItemSet* rAttrSet )
561{
  return std::make_unique<SwStdFontTabPage>(pPage, pController, *rAttrSet);
563}

565static void lcl_SetColl(SwWrtShell* pWrtShell, sal_uInt16 nType,
                  SfxPrinter const * pPrt, const OUString& rStyle,
                  sal_uInt16 nFontWhich)
568{
  vcl::Font aFont( rStyle, Size( 0, 10 ) );
  if( pPrt )
      aFont = pPrt->GetFontMetric( aFont );
  SwTextFormatColl *pColl = pWrtShell->GetTextCollFromPool(nType);
  pColl->SetFormatAttr(SvxFontItem(aFont.GetFamilyType(), aFont.GetFamilyName(),
              OUString(), aFont.GetPitch(), aFont.GetCharSet(), nFontWhich));
575}

577static void lcl_SetColl(SwWrtShell* pWrtShell, sal_uInt16 nType,
                  sal_Int32 nHeight, sal_uInt16 nFontHeightWhich)
579{
  float fSize = static_cast<float>(nHeight) / 10;
  nHeight = CalcToUnit( fSize, MapUnit::MapTwip );
  SwTextFormatColl *pColl = pWrtShell->GetTextCollFromPool(nType);
  pColl->SetFormatAttr(SvxFontHeightItem(nHeight, 100, nFontHeightWhich));
584}

586bool SwStdFontTabPage::FillItemSet( SfxItemSet* )
587{
  SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetModuleConfig()->SetDefaultFontInCurrDocOnly(false);

  const OUString sStandard    = m_xStandardBox->get_active_text();
  const OUString sTitle       = m_xTitleBox->get_active_text();
  const OUString sList        = m_xListBox->get_active_text();
  const OUString sLabel       = m_xLabelBox->get_active_text();
  const OUString sIdx         = m_xIdxBox->get_active_text();

  bool bStandardHeightChanged = m_xStandardHeightLB->get_value_changed_from_saved();
  bool bTitleHeightChanged = m_xTitleHeightLB->get_value_changed_from_saved();
  bool bListHeightChanged = m_xListHeightLB->get_value_changed_from_saved() && !m_bListHeightDefault;
  bool bLabelHeightChanged = m_xLabelHeightLB->get_value_changed_from_saved() && !m_bLabelHeightDefault;
  bool bIndexHeightChanged = m_xIndexHeightLB->get_value_changed_from_saved() && !m_bIndexHeightDefault;

  m_pFontConfig->SetFontStandard(sStandard, m_nFontGroup);
  m_pFontConfig->SetFontOutline(sTitle, m_nFontGroup);
  m_pFontConfig->SetFontList(sList, m_nFontGroup);
  m_pFontConfig->SetFontCaption(sLabel, m_nFontGroup);
  m_pFontConfig->SetFontIndex(sIdx, m_nFontGroup);
  if(bStandardHeightChanged)
  {
      float fSize = static_cast<float>(m_xStandardHeightLB->get_value()) / 10;
      m_pFontConfig->SetFontHeight( CalcToUnit( fSize, MapUnit::MapTwip ), FONT_STANDARD0, m_nFontGroup );
  }
  if(bTitleHeightChanged)
  {
      float fSize = static_cast<float>(m_xTitleHeightLB->get_value()) / 10;
      m_pFontConfig->SetFontHeight( CalcToUnit( fSize, MapUnit::MapTwip ), FONT_OUTLINE1, m_nFontGroup );
  }
  if(bListHeightChanged)
  {
      float fSize = static_cast<float>(m_xListHeightLB->get_value()) / 10;
      m_pFontConfig->SetFontHeight( CalcToUnit( fSize, MapUnit::MapTwip ), FONT_LIST2, m_nFontGroup );
  }
  if(bLabelHeightChanged)
  {
      float fSize = static_cast<float>(m_xLabelHeightLB->get_value()) / 10;
      m_pFontConfig->SetFontHeight( CalcToUnit( fSize, MapUnit::MapTwip ), FONT_CAPTION3, m_nFontGroup );
  }
  if(bIndexHeightChanged)
  {
      float fSize = static_cast<float>(m_xIndexHeightLB->get_value()) / 10;
      m_pFontConfig->SetFontHeight( CalcToUnit( fSize, MapUnit::MapTwip ), FONT_INDEX4, m_nFontGroup );
  }

  if(m_pWrtShell)
  {
      m_pWrtShell->StartAllAction();
      SfxPrinter* pPrinter = m_pWrtShell->getIDocumentDeviceAccess().getPrinter( false );
      bool bMod = false;
      const sal_uInt16 nFontWhich =
          m_nFontGroup == FONT_GROUP_DEFAULT0  ? RES_CHRATR_FONT :
          FONT_GROUP_CJK1 == m_nFontGroup ? RES_CHRATR_CJK_FONT : RES_CHRATR_CTL_FONT;
      const sal_uInt16 nFontHeightWhich =
          m_nFontGroup == FONT_GROUP_DEFAULT0  ? RES_CHRATR_FONTSIZE :
          FONT_GROUP_CJK1 == m_nFontGroup ? RES_CHRATR_CJK_FONTSIZE : RES_CHRATR_CTL_FONTSIZE;
      if(sStandard != m_sShellStd)
      {
          vcl::Font aFont( sStandard, Size( 0, 10 ) );
          if( pPrinter )
              aFont = pPrinter->GetFontMetric( aFont );
          m_pWrtShell->SetDefault(SvxFontItem(aFont.GetFamilyType(), aFont.GetFamilyName(),
                                OUString(), aFont.GetPitch(), aFont.GetCharSet(), nFontWhich));
          SwTextFormatColl *pColl = m_pWrtShell->GetTextCollFromPool(RES_POOLCOLL_STANDARD);
          pColl->ResetFormatAttr(nFontWhich);
          bMod = true;
      }
      if(bStandardHeightChanged)
      {
          float fSize = static_cast<float>(m_xStandardHeightLB->get_value()) / 10;
          m_pWrtShell->SetDefault(SvxFontHeightItem( CalcToUnit( fSize, MapUnit::MapTwip ), 100, nFontHeightWhich ) );
          SwTextFormatColl *pColl = m_pWrtShell->GetTextCollFromPool(RES_POOLCOLL_STANDARD);
          pColl->ResetFormatAttr(nFontHeightWhich);
          bMod = true;
      }

      if(sTitle != m_sShellTitle )
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_HEADLINE_BASE, pPrinter, sTitle, nFontWhich);
          bMod = true;
      }
      if(bTitleHeightChanged)
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_HEADLINE_BASE,
              sal::static_int_cast< sal_uInt16, sal_Int64 >(m_xTitleHeightLB->get_value()), nFontHeightWhich);
          bMod = true;
      }
      if(sList != m_sShellList && (!m_bListDefault || !m_bSetListDefault ))
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_NUMBER_BULLET_BASE, pPrinter, sList, nFontWhich);
          bMod = true;
      }
      if(bListHeightChanged)
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_NUMBER_BULLET_BASE,
              sal::static_int_cast< sal_uInt16, sal_Int64 >(m_xListHeightLB->get_value()), nFontHeightWhich);
          bMod = true;
      }
      if(sLabel != m_sShellLabel && (!m_bLabelDefault || !m_bSetLabelDefault))
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_LABEL, pPrinter, sLabel, nFontWhich);
          bMod = true;
      }
      if(bLabelHeightChanged)
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_LABEL,
              sal::static_int_cast< sal_uInt16, sal_Int64 >(m_xLabelHeightLB->get_value()), nFontHeightWhich);
          bMod = true;
      }
      if(sIdx != m_sShellIndex && (!m_bIdxDefault || !m_bSetIdxDefault))
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_REGISTER_BASE, pPrinter, sIdx, nFontWhich);
          bMod = true;
      }
      if(bIndexHeightChanged)
      {
          lcl_SetColl(m_pWrtShell, RES_POOLCOLL_REGISTER_BASE,
              sal::static_int_cast< sal_uInt16, sal_Int64 >(m_xIndexHeightLB->get_value()), nFontHeightWhich);
          bMod = true;
      }
      if ( bMod )
          m_pWrtShell->SetModified();
      m_pWrtShell->EndAllAction();
  }
  return false;
713}

715void SwStdFontTabPage::Reset( const SfxItemSet* rSet)
716{
  const SfxPoolItem* pLang;
  const sal_uInt16 nLangSlot = m_nFontGroup == FONT_GROUP_DEFAULT0  ? SID_ATTR_LANGUAGE(((((10000 + 1499) + 1) + 499) + 1) + 7) :
      FONT_GROUP_CJK1 == m_nFontGroup ? SID_ATTR_CHAR_CJK_LANGUAGE( 10000 + 889 ) : SID_ATTR_CHAR_CTL_LANGUAGE( 10000 + 894 );

  if( SfxItemState::SET == rSet->GetItemState(nLangSlot, false, &pLang))
      m_eLanguage = static_cast<const SvxLanguageItem*>(pLang)->GetValue();

  OUString sToReplace = m_sScriptWestern;
  if(FONT_GROUP_CJK1 == m_nFontGroup )
      sToReplace = m_sScriptAsian;
  else if(FONT_GROUP_CTL2 == m_nFontGroup )
      sToReplace = m_sScriptComplex;
  m_xLabelFT->set_label(m_xLabelFT->get_label().replaceFirst("%1", sToReplace));

  const SfxPoolItem* pItem;

  if (m_bDisposePrinter)
  {
      m_pPrt.disposeAndClear();
      m_bDisposePrinter = false;
  }

  if(SfxItemState::SET == rSet->GetItemState(FN_PARAM_PRINTER((20000 + 1100)+78), false, &pItem))
  {
      m_pPrt = static_cast<SfxPrinter*>(static_cast<const SwPtrItem*>(pItem)->GetValue());
  }
  else
  {
      auto pPrinterSet = std::make_unique<SfxItemSet>( *rSet->GetPool(),
                  svl::Items<SID_PRINTER_NOTFOUND_WARN(5000 + 320), SID_PRINTER_NOTFOUND_WARN(5000 + 320),
                  SID_PRINTER_CHANGESTODOC(5000 + 324), SID_PRINTER_CHANGESTODOC(5000 + 324)>{} );
      m_pPrt = VclPtr<SfxPrinter>::Create(std::move(pPrinterSet));
      m_bDisposePrinter = true;
  }
  m_pFontList.reset(new FontList( m_pPrt ));
  // #i94536# prevent duplication of font entries when 'reset' button is pressed
  if( !m_xStandardBox->get_count() )
  {
      // get the set of distinct available family names
      std::set< OUString > aFontNames;
      int nFontNames = m_pPrt->GetDevFontCount();
      for( int i = 0; i < nFontNames; i++ )
      {
          FontMetric aFontMetric( m_pPrt->GetDevFont( i ) );
          aFontNames.insert( aFontMetric.GetFamilyName() );
      }

      // insert to listboxes
      for( const auto& rFontName : aFontNames )
      {
          m_xStandardBox->append_text( rFontName );
          m_xTitleBox->append_text( rFontName );
          m_xListBox->append_text( rFontName );
          m_xLabelBox->append_text( rFontName );
          m_xIdxBox->append_text( rFontName );
      }
  }
  if(SfxItemState::SET == rSet->GetItemState(FN_PARAM_STDFONTS((20000 + 1100)+79), false, &pItem))
  {
       m_pFontConfig = static_cast<SwStdFontConfig*>(static_cast<const SwPtrItem*>(pItem)->GetValue());
  }

  if(SfxItemState::SET == rSet->GetItemState(FN_PARAM_WRTSHELL((20000 + 2400)), false, &pItem))
  {
      m_pWrtShell = static_cast<SwWrtShell*>(static_cast<const SwPtrItem*>(pItem)->GetValue());
  }
  OUString sStdBackup;
  OUString sOutBackup;
  OUString sListBackup;
  OUString sCapBackup;
  OUString sIdxBackup;
  sal_Int32 nStandardHeight = -1;
  sal_Int32 nTitleHeight = -1;
  sal_Int32 nListHeight = -1;
  sal_Int32 nLabelHeight = -1;
  sal_Int32 nIndexHeight = -1;

  if(!m_pWrtShell)
  {
      sStdBackup = m_pFontConfig->GetFontStandard(m_nFontGroup);
      sOutBackup = m_pFontConfig->GetFontOutline(m_nFontGroup);
      sListBackup= m_pFontConfig->GetFontList(m_nFontGroup);
      sCapBackup = m_pFontConfig->GetFontCaption(m_nFontGroup);
      sIdxBackup = m_pFontConfig->GetFontIndex(m_nFontGroup);
      nStandardHeight = m_pFontConfig->GetFontHeight( FONT_STANDARD0, m_nFontGroup, m_eLanguage );
      nTitleHeight =    m_pFontConfig->GetFontHeight( FONT_OUTLINE1 , m_nFontGroup, m_eLanguage );
      nListHeight =     m_pFontConfig->GetFontHeight( FONT_LIST2    , m_nFontGroup, m_eLanguage );
      nLabelHeight =    m_pFontConfig->GetFontHeight( FONT_CAPTION3 , m_nFontGroup, m_eLanguage );
      nIndexHeight =    m_pFontConfig->GetFontHeight( FONT_INDEX4   , m_nFontGroup, m_eLanguage );
      if( nStandardHeight <= 0)
          nStandardHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_STANDARD0 + m_nFontGroup * FONT_PER_GROUP5, m_eLanguage);
      if( nTitleHeight <= 0)
          nTitleHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_OUTLINE1 + m_nFontGroup * FONT_PER_GROUP5, m_eLanguage);
      if( nListHeight <= 0)
          nListHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_LIST2 + m_nFontGroup * FONT_PER_GROUP5, m_eLanguage);
      if( nLabelHeight <= 0)
          nLabelHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_CAPTION3 + m_nFontGroup * FONT_PER_GROUP5, m_eLanguage);
      if( nIndexHeight <= 0)
          nIndexHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_INDEX4 + m_nFontGroup * FONT_PER_GROUP5, m_eLanguage);
  }
  else
  {
      SwTextFormatColl *pColl = m_pWrtShell->GetTextCollFromPool(RES_POOLCOLL_STANDARD);
      const SvxFontItem& rFont = !m_nFontGroup ? pColl->GetFont() :
              FONT_GROUP_CJK1 == m_nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
      m_sShellStd = sStdBackup =  rFont.GetFamilyName();

      const sal_uInt16 nFontHeightWhich =
          m_nFontGroup == FONT_GROUP_DEFAULT0  ? RES_CHRATR_FONTSIZE :
          FONT_GROUP_CJK1 == m_nFontGroup ? RES_CHRATR_CJK_FONTSIZE : RES_CHRATR_CTL_FONTSIZE;
      const SvxFontHeightItem& rFontHeightStandard = static_cast<const SvxFontHeightItem& >(pColl->GetFormatAttr(nFontHeightWhich));
      nStandardHeight = static_cast<sal_Int32>(rFontHeightStandard.GetHeight());

      pColl = m_pWrtShell->GetTextCollFromPool(RES_POOLCOLL_HEADLINE_BASE);
      const SvxFontItem& rFontHL = !m_nFontGroup ? pColl->GetFont() :
              FONT_GROUP_CJK1 == m_nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
      m_sShellTitle = sOutBackup = rFontHL.GetFamilyName();

      const SvxFontHeightItem& rFontHeightTitle = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr( nFontHeightWhich ));
      nTitleHeight = static_cast<sal_Int32>(rFontHeightTitle.GetHeight());

      const sal_uInt16 nFontWhich =
          m_nFontGroup == FONT_GROUP_DEFAULT0  ? RES_CHRATR_FONT :
          FONT_GROUP_CJK1 == m_nFontGroup ? RES_CHRATR_CJK_FONT : RES_CHRATR_CTL_FONT;
      pColl = m_pWrtShell->GetTextCollFromPool(RES_POOLCOLL_NUMBER_BULLET_BASE);
      const SvxFontItem& rFontLS = !m_nFontGroup ? pColl->GetFont() :
              FONT_GROUP_CJK1 == m_nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
      m_bListDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
      m_sShellList = sListBackup = rFontLS.GetFamilyName();

      const SvxFontHeightItem& rFontHeightList = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr(nFontHeightWhich));
      nListHeight = static_cast<sal_Int32>(rFontHeightList.GetHeight());
      m_bListHeightDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);

      pColl = m_pWrtShell->GetTextCollFromPool(RES_POOLCOLL_LABEL);
      m_bLabelDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
      const SvxFontItem& rFontCP = !m_nFontGroup ? pColl->GetFont() :
              FONT_GROUP_CJK1 == m_nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
      m_sShellLabel = sCapBackup = rFontCP.GetFamilyName();
      const SvxFontHeightItem& rFontHeightLabel = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr(nFontHeightWhich));
      nLabelHeight = static_cast<sal_Int32>(rFontHeightLabel.GetHeight());
      m_bLabelHeightDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);

      pColl = m_pWrtShell->GetTextCollFromPool(RES_POOLCOLL_REGISTER_BASE);
      m_bIdxDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
      const SvxFontItem& rFontIDX = !m_nFontGroup ? pColl->GetFont() :
              FONT_GROUP_CJK1 == m_nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
      m_sShellIndex = sIdxBackup = rFontIDX.GetFamilyName();
      const SvxFontHeightItem& rFontHeightIndex = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr(nFontHeightWhich));
      nIndexHeight = static_cast<sal_Int32>(rFontHeightIndex.GetHeight());
      m_bIndexHeightDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
  }
  m_xStandardBox->set_entry_text(sStdBackup );
  m_xTitleBox->set_entry_text(sOutBackup );
  m_xListBox->set_entry_text(sListBackup);
  m_xLabelBox->set_entry_text(sCapBackup );
  m_xIdxBox->set_entry_text(sIdxBackup );

  FontMetric aFontMetric( m_pFontList->Get(sStdBackup, sStdBackup) );
  m_xStandardHeightLB->Fill( &aFontMetric, m_pFontList.get() );
  aFontMetric = m_pFontList->Get(sOutBackup, sOutBackup );
  m_xTitleHeightLB->Fill( &aFontMetric, m_pFontList.get() );
  aFontMetric = m_pFontList->Get(sListBackup,sListBackup);
  m_xListHeightLB->Fill( &aFontMetric, m_pFontList.get() );
  aFontMetric = m_pFontList->Get(sCapBackup, sCapBackup );
  m_xLabelHeightLB->Fill( &aFontMetric, m_pFontList.get() );
  aFontMetric = m_pFontList->Get(sIdxBackup, sIdxBackup );
  m_xIndexHeightLB->Fill( &aFontMetric, m_pFontList.get() );

  m_xStandardHeightLB->set_value( CalcToPoint( nStandardHeight, MapUnit::MapTwip, 10 ) );
  m_xTitleHeightLB->set_value( CalcToPoint( nTitleHeight   , MapUnit::MapTwip, 10 ) );
  m_xListHeightLB->set_value( CalcToPoint( nListHeight    , MapUnit::MapTwip, 10 ) );
  m_xLabelHeightLB->set_value( CalcToPoint( nLabelHeight   , MapUnit::MapTwip, 10 ));
  m_xIndexHeightLB->set_value( CalcToPoint( nIndexHeight   , MapUnit::MapTwip, 10 ));

  m_xStandardBox->save_value();
  m_xTitleBox->save_value();
  m_xListBox->save_value();
  m_xLabelBox->save_value();
  m_xIdxBox->save_value();

  m_xStandardHeightLB->save_value();
  m_xTitleHeightLB->save_value();
  m_xListHeightLB->save_value();
  m_xLabelHeightLB->save_value();
  m_xIndexHeightLB->save_value();
903}

905IMPL_LINK_NOARG(SwStdFontTabPage, StandardHdl, weld::Button&, void)void SwStdFontTabPage::LinkStubStandardHdl(void * instance, weld
::Button& data) { return static_cast<SwStdFontTabPage *
>(instance)->StandardHdl(data); } void SwStdFontTabPage
::StandardHdl(__attribute__ ((unused)) weld::Button&)
906{
  sal_uInt8 nFontOffset = m_nFontGroup * FONT_PER_GROUP5;
  m_xStandardBox->set_entry_text(SwStdFontConfig::GetDefaultFor(FONT_STANDARD0 + nFontOffset, m_eLanguage));
  m_xTitleBox->set_entry_text(SwStdFontConfig::GetDefaultFor(FONT_OUTLINE1  + nFontOffset, m_eLanguage));
  m_xListBox->set_entry_text(SwStdFontConfig::GetDefaultFor(FONT_LIST2     + nFontOffset, m_eLanguage));
  m_xLabelBox->set_entry_text(SwStdFontConfig::GetDefaultFor(FONT_CAPTION3  + nFontOffset, m_eLanguage));
  m_xIdxBox->set_entry_text(SwStdFontConfig::GetDefaultFor(FONT_INDEX4    + nFontOffset, m_eLanguage));

  m_xStandardBox->save_value();
  m_xTitleBox->save_value();
  m_xListBox->save_value();
  m_xLabelBox->save_value();
  m_xIdxBox->save_value();

  m_xStandardHeightLB->set_value( CalcToPoint(
      SwStdFontConfig::GetDefaultHeightFor(FONT_STANDARD0 + nFontOffset, m_eLanguage),
          MapUnit::MapTwip, 10 ));
  m_xTitleHeightLB->set_value(CalcToPoint(
      SwStdFontConfig::GetDefaultHeightFor(FONT_OUTLINE1  +
          nFontOffset, m_eLanguage), MapUnit::MapTwip, 10 ));
  m_xListHeightLB->set_value(CalcToPoint(
      SwStdFontConfig::GetDefaultHeightFor(FONT_LIST2 + nFontOffset, m_eLanguage),
          MapUnit::MapTwip, 10 ));
  m_xLabelHeightLB->set_value(CalcToPoint(
      SwStdFontConfig::GetDefaultHeightFor(FONT_CAPTION3  + nFontOffset, m_eLanguage),
          MapUnit::MapTwip, 10 ));
  m_xIndexHeightLB->set_value(CalcToPoint(
      SwStdFontConfig::GetDefaultHeightFor(FONT_INDEX4    + nFontOffset, m_eLanguage),
          MapUnit::MapTwip, 10 ));
935}

937IMPL_LINK( SwStdFontTabPage, ModifyHdl, weld::ComboBox&, rBox, void )void SwStdFontTabPage::LinkStubModifyHdl(void * instance, weld
::ComboBox& data) { return static_cast<SwStdFontTabPage
 *>(instance)->ModifyHdl(data); } void SwStdFontTabPage
::ModifyHdl(weld::ComboBox& rBox)
938{
  if (&rBox == m_xStandardBox.get())
  {
      const OUString sEntry = rBox.get_active_text();
      if(m_bSetListDefault && m_bListDefault)
          m_xListBox->set_entry_text(sEntry);
      if(m_bSetLabelDefault && m_bLabelDefault)
          m_xLabelBox->set_entry_text(sEntry);
      if(m_bSetIdxDefault && m_bIdxDefault)
          m_xIdxBox->set_entry_text(sEntry);
  }
  else if (&rBox == m_xListBox.get())
  {
      m_bSetListDefault = false;
  }
  else if (&rBox == m_xLabelBox.get())
  {
      m_bSetLabelDefault = false;
  }
  else if (&rBox == m_xIdxBox.get())
  {
      m_bSetIdxDefault = false;
  }
961}

963IMPL_LINK( SwStdFontTabPage, LoseFocusHdl, weld::Widget&, rControl, void )void SwStdFontTabPage::LinkStubLoseFocusHdl(void * instance, weld
::Widget& data) { return static_cast<SwStdFontTabPage *
>(instance)->LoseFocusHdl(data); } void SwStdFontTabPage
::LoseFocusHdl(weld::Widget& rControl)
964{
  weld::ComboBox& rBox = dynamic_cast<weld::ComboBox&>(rControl);
  FontSizeBox* pHeightLB = nullptr;
  const OUString sEntry = rBox.get_active_text();
  if (&rBox == m_xStandardBox.get())
  {
      pHeightLB = m_xStandardHeightLB.get();
  }
  else if (&rBox == m_xTitleBox.get())
  {
      pHeightLB = m_xTitleHeightLB.get();
  }
  else if (&rBox == m_xListBox.get())
  {
      pHeightLB = m_xListHeightLB.get();
  }
  else if (&rBox == m_xLabelBox.get())
  {
      pHeightLB = m_xLabelHeightLB.get();
  }
  else /*if (&rBox == m_xIndexHeightLB.get())*/
  {
      pHeightLB = m_xIndexHeightLB.get();
  }
  FontMetric aFontMetric( m_pFontList->Get(sEntry, sEntry) );
  pHeightLB->Fill( &aFontMetric, m_pFontList.get() );
990}

992void SwStdFontTabPage::PageCreated( const SfxAllItemSet& aSet)
993{
  const SfxUInt16Item* pFlagItem = aSet.GetItem<SfxUInt16Item>(SID_FONTMODE_TYPE(((20000) + 800) + 115), false);
  if (pFlagItem)
      m_nFontGroup = sal::static_int_cast< sal_uInt8, sal_uInt16>( pFlagItem->GetValue() );
997}

999SwTableOptionsTabPage::SwTableOptionsTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/opttablepage.ui", "OptTablePage", &rSet)
  , m_pWrtShell(nullptr)
  , m_bHTMLMode(false)
  , m_xHeaderCB(m_xBuilder->weld_check_button("header"))
  , m_xRepeatHeaderCB(m_xBuilder->weld_check_button("repeatheader"))
  , m_xDontSplitCB(m_xBuilder->weld_check_button("dontsplit"))
  , m_xBorderCB(m_xBuilder->weld_check_button("border"))
  , m_xNumFormattingCB(m_xBuilder->weld_check_button("numformatting"))
  , m_xNumFormatFormattingCB(m_xBuilder->weld_check_button("numfmtformatting"))
  , m_xNumAlignmentCB(m_xBuilder->weld_check_button("numalignment"))
  , m_xRowMoveMF(m_xBuilder->weld_metric_spin_button("rowmove", FieldUnit::CM))
  , m_xColMoveMF(m_xBuilder->weld_metric_spin_button("colmove", FieldUnit::CM))
  , m_xRowInsertMF(m_xBuilder->weld_metric_spin_button("rowinsert", FieldUnit::CM))
  , m_xColInsertMF(m_xBuilder->weld_metric_spin_button("colinsert", FieldUnit::CM))
  , m_xFixRB(m_xBuilder->weld_radio_button("fix"))
  , m_xFixPropRB(m_xBuilder->weld_radio_button("fixprop"))
  , m_xVarRB(m_xBuilder->weld_radio_button("var"))
1017{
  Link<weld::Button&,void> aLnk(LINK(this, SwTableOptionsTabPage, CheckBoxHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwTableOptionsTabPage
 *>(this), &SwTableOptionsTabPage::LinkStubCheckBoxHdl
));
  m_xNumFormattingCB->connect_clicked(aLnk);
  m_xNumFormatFormattingCB->connect_clicked(aLnk);
  m_xHeaderCB->connect_clicked(aLnk);
1022}

1024SwTableOptionsTabPage::~SwTableOptionsTabPage()
1025{
1026}

1028std::unique_ptr<SfxTabPage> SwTableOptionsTabPage::Create( weld::Container* pPage, weld::DialogController* pController,
                                                const SfxItemSet* rAttrSet )
1030{
  return std::make_unique<SwTableOptionsTabPage>(pPage, pController, *rAttrSet);
1032}

1034bool SwTableOptionsTabPage::FillItemSet( SfxItemSet* )
1035{
  bool bRet = false;
  SwModuleOptions* pModOpt = SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetModuleConfig();

  if (m_xRowMoveMF->get_value_changed_from_saved())
      pModOpt->SetTableHMove( static_cast<sal_uInt16>(m_xRowMoveMF->denormalize( m_xRowMoveMF->get_value(FieldUnit::TWIP))));

  if (m_xColMoveMF->get_value_changed_from_saved())
      pModOpt->SetTableVMove( static_cast<sal_uInt16>(m_xColMoveMF->denormalize( m_xColMoveMF->get_value(FieldUnit::TWIP))));

  if (m_xRowInsertMF->get_value_changed_from_saved())
      pModOpt->SetTableHInsert(static_cast<sal_uInt16>(m_xRowInsertMF->denormalize( m_xRowInsertMF->get_value(FieldUnit::TWIP))));

  if (m_xColInsertMF->get_value_changed_from_saved())
      pModOpt->SetTableVInsert(static_cast<sal_uInt16>(m_xColInsertMF->denormalize( m_xColInsertMF->get_value(FieldUnit::TWIP))));

  TableChgMode eMode;
  if (m_xFixRB->get_active())
      eMode = TableChgMode::FixedWidthChangeAbs;
  else if(m_xFixPropRB->get_active())
      eMode = TableChgMode::FixedWidthChangeProp;
  else
      eMode = TableChgMode::VarWidthChangeAbs;
  if(eMode != pModOpt->GetTableMode())
  {
      pModOpt->SetTableMode(eMode);
      // the table-keyboard-mode has changed, now the current
      // table should know about that too.
      if(m_pWrtShell && SelectionType::Table & m_pWrtShell->GetSelectionType())
      {
          m_pWrtShell->SetTableChgMode(eMode);
          static sal_uInt16 aInva[] =
                              {   FN_TABLE_MODE_FIX((20000 + 400) + 189),
                                  FN_TABLE_MODE_FIX_PROP((20000 + 400) + 190),
                                  FN_TABLE_MODE_VARIABLE((20000 + 400) + 191),
                                  0
                              };
          m_pWrtShell->GetView().GetViewFrame()->GetBindings().Invalidate( aInva );
      }

      bRet = true;
  }

  SwInsertTableOptions aInsOpts( SwInsertTableFlags::NONE, 0 );

  if (m_xHeaderCB->get_active())
      aInsOpts.mnInsMode |= SwInsertTableFlags::Headline;

  if (m_xRepeatHeaderCB->get_sensitive())
      aInsOpts.mnRowsToRepeat = m_xRepeatHeaderCB->get_active() ? 1 : 0;

  if (!m_xDontSplitCB->get_active())
      aInsOpts.mnInsMode |= SwInsertTableFlags::SplitLayout;

  if (m_xBorderCB->get_active())
      aInsOpts.mnInsMode |= SwInsertTableFlags::DefaultBorder;

  if (m_xHeaderCB->get_state_changed_from_saved() ||
      m_xRepeatHeaderCB->get_state_changed_from_saved() ||
      m_xDontSplitCB->get_state_changed_from_saved() ||
      m_xBorderCB->get_state_changed_from_saved())
  {
      pModOpt->SetInsTableFlags(m_bHTMLMode, aInsOpts);
  }

  if (m_xNumFormattingCB->get_state_changed_from_saved())
  {
      pModOpt->SetInsTableFormatNum(m_bHTMLMode, m_xNumFormattingCB->get_active());
      bRet = true;
  }

  if (m_xNumFormatFormattingCB->get_state_changed_from_saved())
  {
      pModOpt->SetInsTableChangeNumFormat(m_bHTMLMode, m_xNumFormatFormattingCB->get_active());
      bRet = true;
  }

  if (m_xNumAlignmentCB->get_state_changed_from_saved())
  {
      pModOpt->SetInsTableAlignNum(m_bHTMLMode, m_xNumAlignmentCB->get_active());
      bRet = true;
  }

  return bRet;
1119}

1121void SwTableOptionsTabPage::Reset( const SfxItemSet* rSet)
1122{
  const SwModuleOptions* pModOpt = SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetModuleConfig();
  if ( rSet->GetItemState( SID_ATTR_METRICTypedWhichId<SfxUInt16Item>(((((10000 + 1499) + 1) + 499
) + 1) + 8) ) >= SfxItemState::DEFAULT )
  {
      const SfxUInt16Item& rItem = rSet->Get( SID_ATTR_METRICTypedWhichId<SfxUInt16Item>(((((10000 + 1499) + 1) + 499
) + 1) + 8) );
      FieldUnit eFieldUnit = static_cast<FieldUnit>(rItem.GetValue());
      ::SetFieldUnit( *m_xRowMoveMF, eFieldUnit );
      ::SetFieldUnit( *m_xColMoveMF, eFieldUnit );
      ::SetFieldUnit( *m_xRowInsertMF, eFieldUnit );
      ::SetFieldUnit( *m_xColInsertMF, eFieldUnit );
  }

  m_xRowMoveMF->set_value(m_xRowMoveMF->normalize(pModOpt->GetTableHMove()), FieldUnit::TWIP);
  m_xColMoveMF->set_value(m_xColMoveMF->normalize(pModOpt->GetTableVMove()), FieldUnit::TWIP);
  m_xRowInsertMF->set_value(m_xRowInsertMF->normalize(pModOpt->GetTableHInsert()), FieldUnit::TWIP);
  m_xColInsertMF->set_value(m_xColInsertMF->normalize(pModOpt->GetTableVInsert()), FieldUnit::TWIP);

  switch(pModOpt->GetTableMode())
  {
      case TableChgMode::FixedWidthChangeAbs:   m_xFixRB->set_active(true);     break;
      case TableChgMode::FixedWidthChangeProp:  m_xFixPropRB->set_active(true); break;
      case TableChgMode::VarWidthChangeAbs:     m_xVarRB->set_active(true); break;
  }
  const SfxPoolItem* pItem;
  if(SfxItemState::SET == rSet->GetItemState(SID_HTML_MODE(10000 + 414), false, &pItem))
  {
      m_bHTMLMode = 0 != (static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON);
  }

  // hide certain controls for html
  if (m_bHTMLMode)
  {
      m_xRepeatHeaderCB->hide();
      m_xDontSplitCB->hide();
  }

  SwInsertTableOptions aInsOpts = pModOpt->GetInsTableFlags(m_bHTMLMode);
  const SwInsertTableFlags nInsTableFlags = aInsOpts.mnInsMode;

  m_xHeaderCB->set_active(bool(nInsTableFlags & SwInsertTableFlags::Headline));
  m_xRepeatHeaderCB->set_active((!m_bHTMLMode) && (aInsOpts.mnRowsToRepeat > 0));
  m_xDontSplitCB->set_active(!(nInsTableFlags & SwInsertTableFlags::SplitLayout));
  m_xBorderCB->set_active(bool(nInsTableFlags & SwInsertTableFlags::DefaultBorder));

  m_xNumFormattingCB->set_active(pModOpt->IsInsTableFormatNum(m_bHTMLMode));
  m_xNumFormatFormattingCB->set_active(pModOpt->IsInsTableChangeNumFormat(m_bHTMLMode));
  m_xNumAlignmentCB->set_active(pModOpt->IsInsTableAlignNum(m_bHTMLMode));

  m_xHeaderCB->save_state();
  m_xRepeatHeaderCB->save_state();
  m_xDontSplitCB->save_state();
  m_xBorderCB->save_state();
  m_xNumFormattingCB->save_state();
  m_xNumFormatFormattingCB->save_state();
  m_xNumAlignmentCB->save_state();
  m_xRowMoveMF->save_value();
  m_xColMoveMF->save_value();
  m_xRowInsertMF->save_value();
  m_xColInsertMF->save_value();

  CheckBoxHdl(*m_xHeaderCB);
1183}

1185IMPL_LINK_NOARG(SwTableOptionsTabPage, CheckBoxHdl, weld::Button&, void)void SwTableOptionsTabPage::LinkStubCheckBoxHdl(void * instance
, weld::Button& data) { return static_cast<SwTableOptionsTabPage
 *>(instance)->CheckBoxHdl(data); } void SwTableOptionsTabPage
::CheckBoxHdl(__attribute__ ((unused)) weld::Button&)
1186{
  m_xNumFormatFormattingCB->set_sensitive(m_xNumFormattingCB->get_active());
  m_xNumAlignmentCB->set_sensitive(m_xNumFormattingCB->get_active());
  m_xRepeatHeaderCB->set_sensitive(m_xHeaderCB->get_active());
1190}

1192void SwTableOptionsTabPage::PageCreated( const SfxAllItemSet& aSet)
1193{
  const SwWrtShellItem* pWrtSh = aSet.GetItem<SwWrtShellItem>(SID_WRT_SHELL(((20000) + 800) + 117), false);
  if (pWrtSh)
      m_pWrtShell = pWrtSh->GetValue();
1197}

1199SwShdwCursorOptionsTabPage::SwShdwCursorOptionsTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/optformataidspage.ui", "OptFormatAidsPage", &rSet)
  , m_pWrtShell(nullptr)
  , m_xParaCB(m_xBuilder->weld_check_button("paragraph"))
  , m_xSHyphCB(m_xBuilder->weld_check_button("hyphens"))
  , m_xSpacesCB(m_xBuilder->weld_check_button("spaces"))
  , m_xHSpacesCB(m_xBuilder->weld_check_button("nonbreak"))
  , m_xTabCB(m_xBuilder->weld_check_button("tabs"))
  , m_xTabLabel(m_xBuilder->weld_label("tabs_label"))
  , m_xBreakCB(m_xBuilder->weld_check_button("break"))
  , m_xCharHiddenCB(m_xBuilder->weld_check_button("hiddentext"))
  , m_xBookmarkCB(m_xBuilder->weld_check_button("bookmarks"))
  , m_xBookmarkLabel(m_xBuilder->weld_label("bookmarks_label"))
  , m_xDirectCursorFrame(m_xBuilder->weld_frame("directcrsrframe"))
  , m_xOnOffCB(m_xBuilder->weld_check_button("cursoronoff"))
  , m_xDirectCursorFillMode(m_xBuilder->weld_combo_box("cxDirectCursorFillMode"))
  , m_xCursorProtFrame(m_xBuilder->weld_frame("crsrprotframe"))
  , m_xCursorInProtCB(m_xBuilder->weld_check_button("cursorinprot"))
  , m_xMathBaselineAlignmentCB(m_xBuilder->weld_check_button("mathbaseline"))
1218{
  const SfxPoolItem* pItem = nullptr;
  SwFillMode eMode = SwFillMode::Tab;
  bool bIsOn = false;

  if( SfxItemState::SET == rSet.GetItemState( FN_PARAM_SHADOWCURSOR((20000 + 2400)+8), false, &pItem ))
  {
      auto& aOpt = *static_cast<const SwShadowCursorItem*>(pItem);
      eMode = aOpt.GetMode();
      bIsOn = aOpt.IsOn();
  }
  m_xOnOffCB->set_active( bIsOn );

  m_xDirectCursorFillMode->set_active( static_cast<int>(eMode) );
  if(SfxItemState::SET != rSet.GetItemState(SID_HTML_MODE(10000 + 414), false, &pItem )
      || !(static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON))
      return;

  m_xTabCB->hide();
  m_xTabLabel->hide();
  m_xCharHiddenCB->hide();
  m_xBookmarkCB->hide();
  m_xBookmarkLabel->hide();

  m_xDirectCursorFrame->hide();
  m_xOnOffCB->hide();
  m_xDirectCursorFillMode->hide();
  m_xCursorProtFrame->hide();
  m_xCursorInProtCB->hide();
1247}

1249SwShdwCursorOptionsTabPage::~SwShdwCursorOptionsTabPage()
1250{
1251}

1253std::unique_ptr<SfxTabPage> SwShdwCursorOptionsTabPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet )
1254{
  return std::make_unique<SwShdwCursorOptionsTabPage>(pPage, pController, *rSet);
1256}

1258void SwShdwCursorOptionsTabPage::PageCreated( const SfxAllItemSet& aSet )
1259{
  const SwWrtShellItem* pWrtSh = aSet.GetItem<SwWrtShellItem>(SID_WRT_SHELL(((20000) + 800) + 117), false);
  if (pWrtSh)
      m_pWrtShell = pWrtSh->GetValue();
1263}

1265bool SwShdwCursorOptionsTabPage::FillItemSet( SfxItemSet* rSet )
1266{
  SwShadowCursorItem aOpt;
  aOpt.SetOn( m_xOnOffCB->get_active() );

  SwFillMode eMode = static_cast<SwFillMode>(m_xDirectCursorFillMode->get_active());
  aOpt.SetMode( eMode );

  bool bRet = false;
  const SfxPoolItem* pItem = nullptr;
  if( SfxItemState::SET != rSet->GetItemState( FN_PARAM_SHADOWCURSOR((20000 + 2400)+8), false, &pItem )
      ||  static_cast<const SwShadowCursorItem&>(*pItem) != aOpt )
  {
      rSet->Put( aOpt );
      bRet = true;
  }

  if (m_pWrtShell) {
      m_pWrtShell->GetDoc()->getIDocumentSettingAccess().set( DocumentSettingId::MATH_BASELINE_ALIGNMENT,
                                  m_xMathBaselineAlignmentCB->get_active() );
      bRet |= m_xMathBaselineAlignmentCB->get_state_changed_from_saved();
  }

  if( m_xCursorInProtCB->get_state_changed_from_saved())
  {
      rSet->Put(SfxBoolItem(FN_PARAM_CRSR_IN_PROTECTED((20000 + 2400)+13), m_xCursorInProtCB->get_active()));
      bRet = true;
  }

  const SwDocDisplayItem* pOldAttr = static_cast<const SwDocDisplayItem*>(
                      GetOldItem(GetItemSet(), FN_PARAM_DOCDISP((20000 + 1100)+20)));

  SwDocDisplayItem aDisp;

  aDisp.m_bParagraphEnd         = m_xParaCB->get_active();
  aDisp.m_bTab                  = m_xTabCB->get_active();
  aDisp.m_bSpace                = m_xSpacesCB->get_active();
  aDisp.m_bNonbreakingSpace     = m_xHSpacesCB->get_active();
  aDisp.m_bSoftHyphen           = m_xSHyphCB->get_active();
  aDisp.m_bCharHiddenText       = m_xCharHiddenCB->get_active();
  aDisp.m_bBookmarks            = m_xBookmarkCB->get_active();
  aDisp.m_bManualBreak          = m_xBreakCB->get_active();

  bRet |= (!pOldAttr || aDisp != *pOldAttr);
  if(bRet)
      bRet = nullptr != rSet->Put(aDisp);

  return bRet;
1313}

1315void SwShdwCursorOptionsTabPage::Reset( const SfxItemSet* rSet )
1316{
  const SfxPoolItem* pItem = nullptr;
  SwFillMode eMode = SwFillMode::Tab;
  bool bIsOn = false;

  if( SfxItemState::SET == rSet->GetItemState( FN_PARAM_SHADOWCURSOR((20000 + 2400)+8), false, &pItem ))
  {
      auto& aOpt = *static_cast<const SwShadowCursorItem*>(pItem);
      eMode = aOpt.GetMode();
      bIsOn = aOpt.IsOn();
  }
  m_xOnOffCB->set_active( bIsOn );

  m_xDirectCursorFillMode->set_active( static_cast<int>(eMode) );
  if (m_pWrtShell) {
      m_xMathBaselineAlignmentCB->set_active( m_pWrtShell->GetDoc()->getIDocumentSettingAccess().get( DocumentSettingId::MATH_BASELINE_ALIGNMENT ) );
      m_xMathBaselineAlignmentCB->save_state();
  } else {
      m_xMathBaselineAlignmentCB->hide();
  }

  if( SfxItemState::SET == rSet->GetItemState( FN_PARAM_CRSR_IN_PROTECTED((20000 + 2400)+13), false, &pItem ))
      m_xCursorInProtCB->set_active(static_cast<const SfxBoolItem*>(pItem)->GetValue());
  m_xCursorInProtCB->save_state();

  const SwDocDisplayItem* pDocDisplayAttr = nullptr;

  rSet->GetItemState( FN_PARAM_DOCDISP((20000 + 1100)+20), false,
                                  reinterpret_cast<const SfxPoolItem**>(&pDocDisplayAttr) );
  if(pDocDisplayAttr)
  {
      m_xParaCB->set_active( pDocDisplayAttr->m_bParagraphEnd );
      m_xTabCB->set_active( pDocDisplayAttr->m_bTab );
      m_xSpacesCB->set_active( pDocDisplayAttr->m_bSpace );
      m_xHSpacesCB->set_active( pDocDisplayAttr->m_bNonbreakingSpace );
      m_xSHyphCB->set_active( pDocDisplayAttr->m_bSoftHyphen );
      m_xCharHiddenCB->set_active( pDocDisplayAttr->m_bCharHiddenText );
      m_xBookmarkCB->set_active(pDocDisplayAttr->m_bBookmarks);
      m_xBreakCB->set_active( pDocDisplayAttr->m_bManualBreak );
  }
1356}

1358namespace {

1360// TabPage for Redlining
1361struct CharAttr
1362{
  sal_uInt16 nItemId;
  sal_uInt16 nAttr;
1365};

1367}

1369// Edit corresponds to Paste-attributes
1370CharAttr const aRedlineAttr[] =
1371{
  { SID_ATTR_CHAR_CASEMAP( 10000 + 19 ),        sal_uInt16(SvxCaseMap::NotMapped) },
  { SID_ATTR_CHAR_WEIGHT( 10000 + 9 ),         WEIGHT_BOLD },
  { SID_ATTR_CHAR_POSTURE( 10000 + 8 ),        ITALIC_NORMAL },
  { SID_ATTR_CHAR_UNDERLINE( 10000 + 14 ),      LINESTYLE_SINGLE },
  { SID_ATTR_CHAR_UNDERLINE( 10000 + 14 ),      LINESTYLE_DOUBLE },
  { SID_ATTR_CHAR_STRIKEOUT( 10000 + 13 ),      STRIKEOUT_SINGLE },
  { SID_ATTR_CHAR_CASEMAP( 10000 + 19 ),        sal_uInt16(SvxCaseMap::Uppercase) },
  { SID_ATTR_CHAR_CASEMAP( 10000 + 19 ),        sal_uInt16(SvxCaseMap::Lowercase) },
  { SID_ATTR_CHAR_CASEMAP( 10000 + 19 ),        sal_uInt16(SvxCaseMap::SmallCaps) },
  { SID_ATTR_CHAR_CASEMAP( 10000 + 19 ),        sal_uInt16(SvxCaseMap::Capitalize) },
  { SID_ATTR_BRUSH( 10000 + 1 ),               0 }
1383};
1384// Items from aRedlineAttr relevant for InsertAttr: strikethrough is
1385// not used
1386static sal_uInt16 aInsertAttrMap[] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10 };

1388// Items from aRedlineAttr relevant for DeleteAttr: underline and
1389// double underline is not used
1390static sal_uInt16 aDeletedAttrMap[] = { 0, 1, 2, 5, 6, 7, 8, 9, 10 };

1392// Items from aRedlineAttr relevant for ChangeAttr: strikethrough is
1393// not used
1394static sal_uInt16 aChangedAttrMap[] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10 };

1396// Preview of selection
1397SwMarkPreview::SwMarkPreview()
  : m_aTransCol(COL_TRANSPARENT)
  , m_aMarkCol(COL_LIGHTRED)
  , nMarkPos(0)

1402{
  InitColors();
1404}

1406SwMarkPreview::~SwMarkPreview()
1407{
1408}

1410void SwMarkPreview::InitColors()
1411{
  // m_aTransCol and m_aMarkCol are _not_ changed because they are set from outside!

  const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
  m_aBgCol = rSettings.GetWindowColor();

  bool bHC = rSettings.GetHighContrastMode();
  m_aLineCol = bHC? SwViewOption::GetFontColor() : COL_BLACK;
  m_aShadowCol = bHC? m_aBgCol : rSettings.GetShadowColor();
  m_aTextCol = bHC? SwViewOption::GetFontColor() : COL_GRAY;
  m_aPrintAreaCol = m_aTextCol;
1422}

1424void SwMarkPreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle &/*rRect*/)
1425{
  const Size aSz(GetOutputSizePixel());

  // Page
  aPage.SetSize(Size(aSz.Width() - 3, aSz.Height() - 3));

  const long nOutWPix = aPage.GetWidth();
  const long nOutHPix = aPage.GetHeight();

  // PrintArea
  const long nLBorder = 8;
  const long nRBorder = 8;
  const long nTBorder = 4;
  const long nBBorder = 4;

  aLeftPagePrtArea = tools::Rectangle(Point(nLBorder, nTBorder), Point((nOutWPix - 1) - nRBorder, (nOutHPix - 1) - nBBorder));
  const long nWidth = aLeftPagePrtArea.GetWidth();
  const long nCorr = (nWidth & 1) != 0 ? 0 : 1;
  aLeftPagePrtArea.SetSize(Size(nWidth / 2 - (nLBorder + nRBorder) / 2 + nCorr, aLeftPagePrtArea.GetHeight()));

  aRightPagePrtArea = aLeftPagePrtArea;
  aRightPagePrtArea.Move(aLeftPagePrtArea.GetWidth() + nLBorder + nRBorder + 1, 0);

  // draw shadow
  tools::Rectangle aShadow(aPage);
  aShadow += Point(3, 3);
  drawRect(rRenderContext, aShadow, m_aShadowCol, m_aTransCol);

  // draw page
  drawRect(rRenderContext, aPage, m_aBgCol, m_aLineCol);

  // draw separator
  tools::Rectangle aPageSeparator(aPage);
  aPageSeparator.SetSize(Size(2, aPageSeparator.GetHeight()));
  aPageSeparator.Move(aPage.GetWidth() / 2 - 1, 0);
  drawRect(rRenderContext, aPageSeparator, m_aLineCol, m_aTransCol);

  PaintPage(rRenderContext, aLeftPagePrtArea);
  PaintPage(rRenderContext, aRightPagePrtArea);

  tools::Rectangle aLeftMark(Point(aPage.Left() + 2, aLeftPagePrtArea.Top() + 4), Size(aLeftPagePrtArea.Left() - 4, 2));
  tools::Rectangle aRightMark(Point(aRightPagePrtArea.Right() + 2, aRightPagePrtArea.Bottom() - 6), Size(aLeftPagePrtArea.Left() - 4, 2));

  switch (nMarkPos)
  {
      case 1:     // left
          aRightMark.SetPos(Point(aRightPagePrtArea.Left() - 2 - aRightMark.GetWidth(), aRightMark.Top()));
          break;

      case 2:     // right
          aLeftMark.SetPos(Point(aLeftPagePrtArea.Right() + 2, aLeftMark.Top()));
          break;

      case 3:     // outside
          break;

      case 4:     // inside
          aLeftMark.SetPos(Point(aLeftPagePrtArea.Right() + 2, aLeftMark.Top()));
          aRightMark.SetPos(Point(aRightPagePrtArea.Left() - 2 - aRightMark.GetWidth(), aRightMark.Top()));
          break;

      case 0:     // none
      default:
          return;
  }
  drawRect(rRenderContext, aLeftMark, m_aMarkCol, m_aTransCol);
  drawRect(rRenderContext, aRightMark, m_aMarkCol, m_aTransCol);
1492}

1494void SwMarkPreview::PaintPage(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect)
1495{
  // draw PrintArea
  drawRect(rRenderContext, rRect, m_aTransCol, m_aPrintAreaCol);

  // draw Testparagraph

  tools::Rectangle aTextLine = rRect;
  aTextLine.SetSize(Size(aTextLine.GetWidth(), 2));
  aTextLine.AdjustLeft(4 );
  aTextLine.AdjustRight( -4 );
  aTextLine.Move(0, 4);

  const long nStep = aTextLine.GetHeight() + 2;
  const long nLines = rRect.GetHeight() / (aTextLine.GetHeight() + 2) - 1;

  // simulate text
  for (long i = 0; i < nLines; ++i)
  {
      if (i == (nLines - 1))
          aTextLine.SetSize(Size(aTextLine.GetWidth() / 2, aTextLine.GetHeight()));

      if (aPage.IsInside(aTextLine))
          drawRect(rRenderContext, aTextLine, m_aTextCol, m_aTransCol);

      aTextLine.Move(0, nStep);
  }
  aTextLine.Move(0, -nStep);
1522}

1524void SwMarkPreview::SetDrawingArea(weld::DrawingArea* pDrawingArea)
1525{
  Size aInitialSize = getPreviewOptionsSize(pDrawingArea->get_ref_device());
  pDrawingArea->set_size_request(aInitialSize.Width(), aInitialSize.Height());
  weld::CustomWidgetController::SetDrawingArea(pDrawingArea);
  SetOutputSizePixel(aInitialSize);
1530}

1532namespace
1533{
  void lcl_FillRedlineAttrListBox(
          weld::ComboBox& rLB, const AuthorCharAttr& rAttrToSelect,
          const sal_uInt16* pAttrMap, const size_t nAttrMapSize)
  {
      for (size_t i = 0; i != nAttrMapSize; ++i)
      {
          CharAttr const & rAttr(aRedlineAttr[pAttrMap[i]]);
          rLB.set_id(i, OUString::number(reinterpret_cast<sal_Int64>(&rAttr)));
          if (rAttr.nItemId == rAttrToSelect.m_nItemId &&
              rAttr.nAttr == rAttrToSelect.m_nAttr)
              rLB.set_active(i);
      }
  }
1547}

1549SwRedlineOptionsTabPage::SwRedlineOptionsTabPage(weld::Container* pPage, weld::DialogController* pController,
                                               const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/optredlinepage.ui", "OptRedLinePage", &rSet)
  , m_xInsertLB(m_xBuilder->weld_combo_box("insert"))
  , m_xInsertColorLB(new ColorListBox(m_xBuilder->weld_menu_button("insertcolor"), pController->getDialog()))
  , m_xInsertedPreviewWN(new SvxFontPrevWindow)
  , m_xInsertedPreview(new weld::CustomWeld(*m_xBuilder, "insertedpreview", *m_xInsertedPreviewWN))
  , m_xDeletedLB(m_xBuilder->weld_combo_box("deleted"))
  , m_xDeletedColorLB(new ColorListBox(m_xBuilder->weld_menu_button("deletedcolor"), pController->getDialog()))
  , m_xDeletedPreviewWN(new SvxFontPrevWindow)
  , m_xDeletedPreview(new weld::CustomWeld(*m_xBuilder, "deletedpreview", *m_xDeletedPreviewWN))
  , m_xChangedLB(m_xBuilder->weld_combo_box("changed"))
  , m_xChangedColorLB(new ColorListBox(m_xBuilder->weld_menu_button("changedcolor"), pController->getDialog()))
  , m_xChangedPreviewWN(new SvxFontPrevWindow)
  , m_xChangedPreview(new weld::CustomWeld(*m_xBuilder, "changedpreview", *m_xChangedPreviewWN))
  , m_xMarkPosLB(m_xBuilder->weld_combo_box("markpos"))
  , m_xMarkColorLB(new ColorListBox(m_xBuilder->weld_menu_button("markcolor"), pController->getDialog()))
  , m_xMarkPreviewWN(new SwMarkPreview)
  , m_xMarkPreview(new weld::CustomWeld(*m_xBuilder, "markpreview", *m_xMarkPreviewWN))
1568{
  Size aPreviewSize(getPreviewOptionsSize(m_xMarkPreviewWN->GetDrawingArea()->get_ref_device()));

  m_xInsertColorLB->SetSlotId(SID_AUTHOR_COLOR( 10000 + 1168 ), true);
  m_xDeletedColorLB->SetSlotId(SID_AUTHOR_COLOR( 10000 + 1168 ), true);
  m_xChangedColorLB->SetSlotId(SID_AUTHOR_COLOR( 10000 + 1168 ), true);

  m_xInsertedPreviewWN->set_size_request(aPreviewSize.Width(), aPreviewSize.Height());
  m_xDeletedPreviewWN->set_size_request(aPreviewSize.Width(), aPreviewSize.Height());
  m_xChangedPreviewWN->set_size_request(aPreviewSize.Width(), aPreviewSize.Height());
  m_xMarkPreviewWN->set_size_request(aPreviewSize.Width(), aPreviewSize.Height());

  for (sal_Int32 i = 0, nEntryCount = m_xInsertLB->get_count(); i < nEntryCount; ++i)
  {
      const OUString sEntry(m_xInsertLB->get_text(i));
      m_xDeletedLB->append_text(sEntry);
      m_xChangedLB->append_text(sEntry);
  };

  // remove strikethrough from insert and change and underline + double
  // underline from delete
  m_xInsertLB->remove(5);
  m_xChangedLB->remove(5);
  m_xDeletedLB->remove(4);
  m_xDeletedLB->remove(3);

  Link<weld::ComboBox&,void> aLk = LINK(this, SwRedlineOptionsTabPage, AttribHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwRedlineOptionsTabPage
 *>(this), &SwRedlineOptionsTabPage::LinkStubAttribHdl
);
  m_xInsertLB->connect_changed( aLk );
  m_xDeletedLB->connect_changed( aLk );
  m_xChangedLB->connect_changed( aLk );

  Link<ColorListBox&,void> aLk2 = LINK(this, SwRedlineOptionsTabPage, ColorHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwRedlineOptionsTabPage
 *>(this), &SwRedlineOptionsTabPage::LinkStubColorHdl);
  m_xInsertColorLB->SetSelectHdl( aLk2 );
  m_xDeletedColorLB->SetSelectHdl( aLk2 );
  m_xChangedColorLB->SetSelectHdl( aLk2 );

  m_xMarkPosLB->connect_changed(LINK(this, SwRedlineOptionsTabPage, ChangedMaskPrevHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwRedlineOptionsTabPage
 *>(this), &SwRedlineOptionsTabPage::LinkStubChangedMaskPrevHdl
));
  m_xMarkColorLB->SetSelectHdl(LINK(this, SwRedlineOptionsTabPage, ChangedMaskColorPrevHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwRedlineOptionsTabPage
 *>(this), &SwRedlineOptionsTabPage::LinkStubChangedMaskColorPrevHdl
));
1606}

1608SwRedlineOptionsTabPage::~SwRedlineOptionsTabPage()
1609{
  m_xInsertColorLB.reset();
  m_xInsertedPreview.reset();
  m_xInsertedPreviewWN.reset();
  m_xDeletedColorLB.reset();
  m_xDeletedPreview.reset();
  m_xDeletedPreviewWN.reset();
  m_xChangedColorLB.reset();
  m_xChangedPreview.reset();
  m_xChangedPreviewWN.reset();
  m_xMarkColorLB.reset();
  m_xMarkPreview.reset();
  m_xMarkPreviewWN.reset();
1622}

1624std::unique_ptr<SfxTabPage> SwRedlineOptionsTabPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet)
1625{
  return std::make_unique<SwRedlineOptionsTabPage>(pPage, pController, *rSet);
1627}

1629bool SwRedlineOptionsTabPage::FillItemSet( SfxItemSet* )
1630{
  CharAttr *pAttr;
  SwModuleOptions *pOpt = SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetModuleConfig();

  AuthorCharAttr aInsertedAttr;
  AuthorCharAttr aDeletedAttr;
  AuthorCharAttr aChangedAttr;

  AuthorCharAttr aOldInsertAttr(pOpt->GetInsertAuthorAttr());
  AuthorCharAttr aOldDeletedAttr(pOpt->GetDeletedAuthorAttr());
  AuthorCharAttr aOldChangedAttr(pOpt->GetFormatAuthorAttr());

  Color nOldMarkColor = pOpt->GetMarkAlignColor();
  sal_uInt16 nOldMarkMode = pOpt->GetMarkAlignMode();

  sal_Int32 nPos = m_xInsertLB->get_active();
  if (nPos != -1)
  {
      pAttr = reinterpret_cast<CharAttr*>(m_xInsertLB->get_id(nPos).toInt64());
      aInsertedAttr.m_nItemId = pAttr->nItemId;
      aInsertedAttr.m_nAttr = pAttr->nAttr;
      aInsertedAttr.m_nColor = m_xInsertColorLB->GetSelectEntryColor();
      pOpt->SetInsertAuthorAttr(aInsertedAttr);
  }

  nPos = m_xDeletedLB->get_active();
  if (nPos != -1)
  {
      pAttr = reinterpret_cast<CharAttr*>(m_xDeletedLB->get_id(nPos).toInt64());
      aDeletedAttr.m_nItemId = pAttr->nItemId;
      aDeletedAttr.m_nAttr = pAttr->nAttr;
      aDeletedAttr.m_nColor = m_xDeletedColorLB->GetSelectEntryColor();
      pOpt->SetDeletedAuthorAttr(aDeletedAttr);
  }

  nPos = m_xChangedLB->get_active();
  if (nPos != -1)
  {
      pAttr = reinterpret_cast<CharAttr*>(m_xChangedLB->get_id(nPos).toInt64());
      aChangedAttr.m_nItemId = pAttr->nItemId;
      aChangedAttr.m_nAttr = pAttr->nAttr;
      aChangedAttr.m_nColor = m_xChangedColorLB->GetSelectEntryColor();
      pOpt->SetFormatAuthorAttr(aChangedAttr);
  }

  nPos = 0;
  switch (m_xMarkPosLB->get_active())
  {
      case 0: nPos = text::HoriOrientation::NONE;       break;
      case 1: nPos = text::HoriOrientation::LEFT;       break;
      case 2: nPos = text::HoriOrientation::RIGHT;      break;
      case 3: nPos = text::HoriOrientation::OUTSIDE;    break;
      case 4: nPos = text::HoriOrientation::INSIDE;     break;
  }
  pOpt->SetMarkAlignMode(nPos);
  pOpt->SetMarkAlignColor(m_xMarkColorLB->GetSelectEntryColor());

  if (!(aInsertedAttr == aOldInsertAttr) ||
      !(aDeletedAttr == aOldDeletedAttr) ||
      !(aChangedAttr == aOldChangedAttr) ||
     nOldMarkColor != pOpt->GetMarkAlignColor() ||
     nOldMarkMode != pOpt->GetMarkAlignMode() )
  {
      // update all documents
      SwDocShell* pDocShell = static_cast<SwDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<SwDocShell>));

      while( pDocShell )
      {
          pDocShell->GetWrtShell()->UpdateRedlineAttr();
          pDocShell = static_cast<SwDocShell*>(SfxObjectShell::GetNext(*pDocShell, checkSfxObjectShell<SwDocShell>));
      }
  }

  return false;
1704}

1706void SwRedlineOptionsTabPage::Reset( const SfxItemSet*  )
1707{
  const SwModuleOptions *pOpt = SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetModuleConfig();

  const AuthorCharAttr &rInsertAttr = pOpt->GetInsertAuthorAttr();
  const AuthorCharAttr &rDeletedAttr = pOpt->GetDeletedAuthorAttr();
  const AuthorCharAttr &rChangedAttr = pOpt->GetFormatAuthorAttr();

  // initialise preview
  InitFontStyle(*m_xInsertedPreviewWN, SwResId(STR_OPT_PREVIEW_INSERTEDreinterpret_cast<char const *>("optredlinepage|insertedpreview"
 "\004" u8"Insert")));
  InitFontStyle(*m_xDeletedPreviewWN, SwResId(STR_OPT_PREVIEW_DELETEDreinterpret_cast<char const *>("optredlinepage|deletedpreview"
 "\004" u8"Delete")));
  InitFontStyle(*m_xChangedPreviewWN, SwResId(STR_OPT_PREVIEW_CHANGEDreinterpret_cast<char const *>("optredlinepage|changedpreview"
 "\004" u8"Attributes")));

  Color nColor = rInsertAttr.m_nColor;
  m_xInsertColorLB->SelectEntry(nColor);

  nColor = rDeletedAttr.m_nColor;
  m_xDeletedColorLB->SelectEntry(nColor);

  nColor = rChangedAttr.m_nColor;
  m_xChangedColorLB->SelectEntry(nColor);

  m_xMarkColorLB->SelectEntry(pOpt->GetMarkAlignColor());

  m_xInsertLB->set_active(0);
  m_xDeletedLB->set_active(0);
  m_xChangedLB->set_active(0);

  lcl_FillRedlineAttrListBox(*m_xInsertLB, rInsertAttr, aInsertAttrMap, SAL_N_ELEMENTS(aInsertAttrMap)(sizeof(sal_n_array_size(aInsertAttrMap))));
  lcl_FillRedlineAttrListBox(*m_xDeletedLB, rDeletedAttr, aDeletedAttrMap, SAL_N_ELEMENTS(aDeletedAttrMap)(sizeof(sal_n_array_size(aDeletedAttrMap))));
  lcl_FillRedlineAttrListBox(*m_xChangedLB, rChangedAttr, aChangedAttrMap, SAL_N_ELEMENTS(aChangedAttrMap)(sizeof(sal_n_array_size(aChangedAttrMap))));

  sal_Int32 nPos = 0;
  switch (pOpt->GetMarkAlignMode())
  {
      case text::HoriOrientation::NONE:     nPos = 0;   break;
      case text::HoriOrientation::LEFT:     nPos = 1;   break;
      case text::HoriOrientation::RIGHT:    nPos = 2;   break;
      case text::HoriOrientation::OUTSIDE:  nPos = 3;   break;
      case text::HoriOrientation::INSIDE:   nPos = 4;   break;
  }
  m_xMarkPosLB->set_active(nPos);

  // show settings in preview
  AttribHdl(*m_xInsertLB);
  ColorHdl(*m_xInsertColorLB);
  AttribHdl(*m_xDeletedLB);
  ColorHdl(*m_xInsertColorLB);
  AttribHdl(*m_xChangedLB);
  ColorHdl(*m_xChangedColorLB);

  ChangedMaskPrev();
1758}

1760IMPL_LINK( SwRedlineOptionsTabPage, AttribHdl, weld::ComboBox&, rLB, void )void SwRedlineOptionsTabPage::LinkStubAttribHdl(void * instance
, weld::ComboBox& data) { return static_cast<SwRedlineOptionsTabPage
 *>(instance)->AttribHdl(data); } void SwRedlineOptionsTabPage
::AttribHdl(weld::ComboBox& rLB)
1761{
  SvxFontPrevWindow *pPrev = nullptr;
  ColorListBox *pColorLB;

  if (&rLB == m_xInsertLB.get())
  {
      pColorLB = m_xInsertColorLB.get();
      pPrev = m_xInsertedPreviewWN.get();
  }
  else if (&rLB == m_xDeletedLB.get())
  {
      pColorLB = m_xDeletedColorLB.get();
      pPrev = m_xDeletedPreviewWN.get();
  }
  else
  {
      pColorLB = m_xChangedColorLB.get();
      pPrev = m_xChangedPreviewWN.get();
  }

  SvxFont&    rFont = pPrev->GetFont();
  SvxFont&    rCJKFont = pPrev->GetCJKFont();

  rFont.SetWeight(WEIGHT_NORMAL);
  rCJKFont.SetWeight(WEIGHT_NORMAL);
  rFont.SetItalic(ITALIC_NONE);
  rCJKFont.SetItalic(ITALIC_NONE);
  rFont.SetUnderline(LINESTYLE_NONE);
  rCJKFont.SetUnderline(LINESTYLE_NONE);
  rFont.SetStrikeout(STRIKEOUT_NONE);
  rCJKFont.SetStrikeout(STRIKEOUT_NONE);
  rFont.SetCaseMap(SvxCaseMap::NotMapped);
  rCJKFont.SetCaseMap(SvxCaseMap::NotMapped);

  Color aColor = pColorLB->GetSelectEntryColor();

  if (aColor == COL_NONE_COLOR::Color(0x80, 0xFF, 0xFF, 0xFF))
  {
      rFont.SetColor( COL_BLACK );
      rCJKFont.SetColor( COL_BLACK );
  }
  else if (aColor == COL_TRANSPARENT)
  {
      rFont.SetColor( COL_RED );
      rCJKFont.SetColor( COL_RED );
  }
  else
  {
      rFont.SetColor(aColor);
      rCJKFont.SetColor(aColor);
  }

  sal_Int32 nPos = rLB.get_active();
  if( nPos == -1)
      nPos = 0;

  CharAttr* pAttr = reinterpret_cast<CharAttr*>(rLB.get_id(nPos).toInt64());
  //switch off preview background color
  pPrev->ResetColor();
  switch (pAttr->nItemId)
  {
      case SID_ATTR_CHAR_WEIGHT( 10000 + 9 ):
          rFont.SetWeight( static_cast<FontWeight>(pAttr->nAttr) );
          rCJKFont.SetWeight( static_cast<FontWeight>(pAttr->nAttr) );
          break;

      case SID_ATTR_CHAR_POSTURE( 10000 + 8 ):
          rFont.SetItalic( static_cast<FontItalic>(pAttr->nAttr) );
          rCJKFont.SetItalic( static_cast<FontItalic>(pAttr->nAttr) );
          break;

      case SID_ATTR_CHAR_UNDERLINE( 10000 + 14 ):
          rFont.SetUnderline( static_cast<FontLineStyle>(pAttr->nAttr) );
          rCJKFont.SetUnderline( static_cast<FontLineStyle>(pAttr->nAttr) );
          break;

      case SID_ATTR_CHAR_STRIKEOUT( 10000 + 13 ):
          rFont.SetStrikeout( static_cast<FontStrikeout>(pAttr->nAttr) );
          rCJKFont.SetStrikeout( static_cast<FontStrikeout>(pAttr->nAttr) );
          break;

      case SID_ATTR_CHAR_CASEMAP( 10000 + 19 ):
          rFont.SetCaseMap( static_cast<SvxCaseMap>(pAttr->nAttr) );
          rCJKFont.SetCaseMap( static_cast<SvxCaseMap>(pAttr->nAttr) );
          break;

      case SID_ATTR_BRUSH( 10000 + 1 ):
      {
          Color aBgColor = pColorLB->GetSelectEntryColor();
          if (aBgColor != COL_NONE_COLOR::Color(0x80, 0xFF, 0xFF, 0xFF))
              pPrev->SetColor(aBgColor);
          else
              pPrev->SetColor(COL_LIGHTGRAY);
          rFont.SetColor( COL_BLACK );
          rCJKFont.SetColor( COL_BLACK );
      }
      break;
  }

  pPrev->Invalidate();
1861}

1863IMPL_LINK(SwRedlineOptionsTabPage, ColorHdl, ColorListBox&, rListBox, void)void SwRedlineOptionsTabPage::LinkStubColorHdl(void * instance
, ColorListBox& data) { return static_cast<SwRedlineOptionsTabPage
 *>(instance)->ColorHdl(data); } void SwRedlineOptionsTabPage
::ColorHdl(ColorListBox& rListBox)
1864{
  ColorListBox* pColorLB = &rListBox;
  SvxFontPrevWindow *pPrev = nullptr;
  weld::ComboBox* pLB;

  if (pColorLB == m_xInsertColorLB.get())
  {
      pLB = m_xInsertLB.get();
      pPrev = m_xInsertedPreviewWN.get();
  }
  else if (pColorLB == m_xDeletedColorLB.get())
  {
      pLB = m_xDeletedLB.get();
      pPrev = m_xDeletedPreviewWN.get();
  }
  else
  {
      pLB = m_xChangedLB.get();
      pPrev = m_xChangedPreviewWN.get();
  }

  SvxFont&    rFont = pPrev->GetFont();
  SvxFont&    rCJKFont = pPrev->GetCJKFont();
  sal_Int32      nPos = pLB->get_active();
  if( nPos == -1)
      nPos = 0;

  CharAttr* pAttr = reinterpret_cast<CharAttr*>(pLB->get_id(nPos).toInt64());

  if( pAttr->nItemId == SID_ATTR_BRUSH( 10000 + 1 ) )
  {
      rFont.SetColor( COL_BLACK );
      rCJKFont.SetColor( COL_BLACK );

      Color aBgColor = pColorLB->GetSelectEntryColor();
      if (aBgColor != COL_NONE_COLOR::Color(0x80, 0xFF, 0xFF, 0xFF))
          pPrev->SetColor(aBgColor);
      else
          pPrev->SetColor(COL_LIGHTGRAY);
  }
  else
  {
      Color aColor = pColorLB->GetSelectEntryColor();

      if (aColor == COL_NONE_COLOR::Color(0x80, 0xFF, 0xFF, 0xFF))
      {
          rFont.SetColor( COL_BLACK );
          rCJKFont.SetColor( COL_BLACK );
      }
      else if (aColor == COL_TRANSPARENT)
      {
          rFont.SetColor( COL_RED );
          rCJKFont.SetColor( COL_RED );
      }
      else
      {
          rFont.SetColor(aColor);
          rCJKFont.SetColor(aColor);
      }
  }

  pPrev->Invalidate();
1926}

1928void SwRedlineOptionsTabPage::ChangedMaskPrev()
1929{
  m_xMarkPreviewWN->SetMarkPos(m_xMarkPosLB->get_active());
  m_xMarkPreviewWN->SetColor(m_xMarkColorLB->GetSelectEntryColor());

  m_xMarkPreviewWN->Invalidate();
1934}

1936IMPL_LINK_NOARG(SwRedlineOptionsTabPage, ChangedMaskPrevHdl, weld::ComboBox&, void)void SwRedlineOptionsTabPage::LinkStubChangedMaskPrevHdl(void
 * instance, weld::ComboBox& data) { return static_cast<
SwRedlineOptionsTabPage *>(instance)->ChangedMaskPrevHdl
(data); } void SwRedlineOptionsTabPage::ChangedMaskPrevHdl(__attribute__
 ((unused)) weld::ComboBox&)
1937{
  ChangedMaskPrev();
1939}

1941IMPL_LINK_NOARG(SwRedlineOptionsTabPage, ChangedMaskColorPrevHdl, ColorListBox&, void)void SwRedlineOptionsTabPage::LinkStubChangedMaskColorPrevHdl
(void * instance, ColorListBox& data) { return static_cast
<SwRedlineOptionsTabPage *>(instance)->ChangedMaskColorPrevHdl
(data); } void SwRedlineOptionsTabPage::ChangedMaskColorPrevHdl
(__attribute__ ((unused)) ColorListBox&)
1942{
  ChangedMaskPrev();
1944}

1946void SwRedlineOptionsTabPage::InitFontStyle(SvxFontPrevWindow& rExampleWin, const OUString& rText)
1947{
  const AllSettings&  rAllSettings = Application::GetSettings();
  LanguageType        eLangType = rAllSettings.GetUILanguageTag().getLanguageType();
  Color               aBackCol( rAllSettings.GetStyleSettings().GetWindowColor() );
  SvxFont&            rFont = rExampleWin.GetFont();
  SvxFont&            rCJKFont = rExampleWin.GetCJKFont();
  SvxFont&            rCTLFont = rExampleWin.GetCTLFont();

  OutputDevice& rDevice = rExampleWin.GetDrawingArea()->get_ref_device();

  vcl::Font           aFont( OutputDevice::GetDefaultFont( DefaultFontType::SERIF, eLangType,
                                                      GetDefaultFontFlags::OnlyOne, &rDevice ) );
  vcl::Font           aCJKFont( OutputDevice::GetDefaultFont( DefaultFontType::CJK_TEXT, eLangType,
                                                      GetDefaultFontFlags::OnlyOne, &rDevice ) );
  vcl::Font           aCTLFont( OutputDevice::GetDefaultFont( DefaultFontType::CTL_TEXT, eLangType,
                                                      GetDefaultFontFlags::OnlyOne, &rDevice ) );
  const Size          aDefSize( 0, 12 );
  aFont.SetFontSize( aDefSize );
  aCJKFont.SetFontSize( aDefSize );
  aCTLFont.SetFontSize( aDefSize );

  aFont.SetFillColor( aBackCol );
  aCJKFont.SetFillColor( aBackCol );
  aCTLFont.SetFillColor( aBackCol );

  aFont.SetWeight( WEIGHT_NORMAL );
  aCJKFont.SetWeight( WEIGHT_NORMAL );
  aCTLFont.SetWeight( WEIGHT_NORMAL );

  rFont = aFont;
  rCJKFont = aCJKFont;
  rCTLFont = aCTLFont;

  const Size aNewSize( 0, rExampleWin.GetOutputSizePixel().Height() * 2 / 3 );
  rFont.SetFontSize( aNewSize );
  rCJKFont.SetFontSize( aNewSize );

  rExampleWin.SetFont( rFont, rCJKFont,rCTLFont );
  rExampleWin.SetPreviewText(rText);

  rExampleWin.SetBackColor(aBackCol);
1988}

1990SwCompareOptionsTabPage::SwCompareOptionsTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/optcomparison.ui", "OptComparison", &rSet)
  , m_xAutoRB(m_xBuilder->weld_radio_button("auto"))
  , m_xWordRB(m_xBuilder->weld_radio_button("byword"))
  , m_xCharRB(m_xBuilder->weld_radio_button("bycharacter"))
  , m_xRsidCB(m_xBuilder->weld_check_button("useRSID"))
  , m_xIgnoreCB(m_xBuilder->weld_check_button("ignore"))
  , m_xLenNF(m_xBuilder->weld_spin_button("ignorelen"))
  , m_xStoreRsidCB(m_xBuilder->weld_check_button("storeRSID"))
1999{
  Link<weld::Button&,void> aLnk( LINK( this, SwCompareOptionsTabPage, ComparisonHdl )::tools::detail::makeLink( ::tools::detail::castTo<SwCompareOptionsTabPage
 *>(this), &SwCompareOptionsTabPage::LinkStubComparisonHdl
) );
  m_xAutoRB->connect_clicked( aLnk );
  m_xWordRB->connect_clicked( aLnk );
  m_xCharRB->connect_clicked( aLnk );

  m_xIgnoreCB->connect_clicked( LINK( this, SwCompareOptionsTabPage, IgnoreHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwCompareOptionsTabPage
 *>(this), &SwCompareOptionsTabPage::LinkStubIgnoreHdl
) );
2006}

2008SwCompareOptionsTabPage::~SwCompareOptionsTabPage()
2009{
2010}

2012std::unique_ptr<SfxTabPage> SwCompareOptionsTabPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet )
2013{
  return std::make_unique<SwCompareOptionsTabPage>(pPage, pController, *rAttrSet);
2015}

2017bool SwCompareOptionsTabPage::FillItemSet( SfxItemSet* )
2018{
  bool bRet = false;
  SwModuleOptions *pOpt = SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetModuleConfig();

  if( m_xAutoRB->get_state_changed_from_saved() ||
      m_xWordRB->get_state_changed_from_saved() ||
      m_xCharRB->get_state_changed_from_saved() )
  {
      SwCompareMode eCmpMode = SwCompareMode::Auto;

      if ( m_xAutoRB->get_active() ) eCmpMode = SwCompareMode::Auto;
      if ( m_xWordRB->get_active() ) eCmpMode = SwCompareMode::ByWord;
      if ( m_xCharRB->get_active() ) eCmpMode = SwCompareMode::ByChar;

      pOpt->SetCompareMode( eCmpMode );
      bRet = true;
  }

  if( m_xRsidCB->get_state_changed_from_saved() )
  {
      pOpt->SetUseRsid( m_xRsidCB->get_active() );
      bRet = true;
  }

  if( m_xIgnoreCB->get_state_changed_from_saved() )
  {
      pOpt->SetIgnorePieces( m_xIgnoreCB->get_active() );
      bRet = true;
  }

  if( m_xLenNF->get_value_changed_from_saved() )
  {
      pOpt->SetPieceLen( m_xLenNF->get_value() );
      bRet = true;
  }

  if (m_xStoreRsidCB->get_state_changed_from_saved())
  {
      pOpt->SetStoreRsid(m_xStoreRsidCB->get_active());
      bRet = true;
  }

  return bRet;
2061}

2063void SwCompareOptionsTabPage::Reset( const SfxItemSet* )
2064{
  SwModuleOptions *pOpt = SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetModuleConfig();

  SwCompareMode eCmpMode = pOpt->GetCompareMode();
  if( eCmpMode == SwCompareMode::Auto )
  {
      m_xAutoRB->set_active(true);
      m_xRsidCB->set_sensitive(false);
      m_xIgnoreCB->set_sensitive(false);
      m_xLenNF->set_sensitive(false);
  }
  else if( eCmpMode == SwCompareMode::ByWord )
  {
      m_xWordRB->set_active(true);
      m_xRsidCB->set_sensitive(true);
      m_xIgnoreCB->set_sensitive(true);
      m_xLenNF->set_sensitive(true);
  }
  else if( eCmpMode == SwCompareMode::ByChar)
  {
      m_xCharRB->set_active(true);
      m_xRsidCB->set_sensitive(true);
      m_xIgnoreCB->set_sensitive(true);
      m_xLenNF->set_sensitive(true);
  }
  m_xAutoRB->save_state();
  m_xWordRB->save_state();
  m_xCharRB->save_state();

  m_xRsidCB->set_active( pOpt->IsUseRsid() );
  m_xRsidCB->save_state();

  m_xIgnoreCB->set_active( pOpt->IsIgnorePieces() );
  m_xIgnoreCB->save_state();

  m_xLenNF->set_sensitive( m_xIgnoreCB->get_active() && eCmpMode != SwCompareMode::Auto );

  m_xLenNF->set_value( pOpt->GetPieceLen() );
  m_xLenNF->save_value();

  m_xStoreRsidCB->set_active(pOpt->IsStoreRsid());
  m_xStoreRsidCB->save_state();
2106}

2108IMPL_LINK_NOARG(SwCompareOptionsTabPage, ComparisonHdl, weld::Button&, void)void SwCompareOptionsTabPage::LinkStubComparisonHdl(void * instance
, weld::Button& data) { return static_cast<SwCompareOptionsTabPage
 *>(instance)->ComparisonHdl(data); } void SwCompareOptionsTabPage
::ComparisonHdl(__attribute__ ((unused)) weld::Button&)
2109{
  bool bChecked = !m_xAutoRB->get_active();
  m_xRsidCB->set_sensitive( bChecked );
  m_xIgnoreCB->set_sensitive( bChecked );
  m_xLenNF->set_sensitive( bChecked && m_xIgnoreCB->get_active() );
2114}

2116IMPL_LINK_NOARG(SwCompareOptionsTabPage, IgnoreHdl, weld::Button&, void)void SwCompareOptionsTabPage::LinkStubIgnoreHdl(void * instance
, weld::Button& data) { return static_cast<SwCompareOptionsTabPage
 *>(instance)->IgnoreHdl(data); } void SwCompareOptionsTabPage
::IgnoreHdl(__attribute__ ((unused)) weld::Button&)
2117{
  m_xLenNF->set_sensitive(m_xIgnoreCB->get_active());
2119}

2121#ifdef DBG_UTIL

2123SwTestTabPage::SwTestTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rCoreSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/opttestpage.ui", "OptTestPage", &rCoreSet)
  , bAttrModified( false )
  , m_xTest1CBox(m_xBuilder->weld_check_button("unused"))
  , m_xTest2CBox(m_xBuilder->weld_check_button("dynamic"))
  , m_xTest3CBox(m_xBuilder->weld_check_button("nocalm"))
  , m_xTest4CBox(m_xBuilder->weld_check_button("wysiwygdbg"))
  , m_xTest5CBox(m_xBuilder->weld_check_button("noidle"))
  , m_xTest6CBox(m_xBuilder->weld_check_button("noscreenadj"))
  , m_xTest7CBox(m_xBuilder->weld_check_button("winformat"))
  , m_xTest8CBox(m_xBuilder->weld_check_button("noscroll"))
  , m_xTest9CBox(m_xBuilder->weld_check_button("DrawingLayerNotLoading"))
  , m_xTest10CBox(m_xBuilder->weld_check_button("AutoFormatByInput"))
2136{
  Init();
2138}

2140SwTestTabPage::~SwTestTabPage()
2141{
2142}

2144std::unique_ptr<SfxTabPage> SwTestTabPage::Create( weld::Container* pPage, weld::DialogController* pController,
                                        const SfxItemSet* rAttrSet )
2146{
  return std::make_unique<SwTestTabPage>(pPage, pController, *rAttrSet);
2148}

2150bool    SwTestTabPage::FillItemSet( SfxItemSet* rCoreSet )
2151{

  if ( bAttrModified )
  {
      SwTestItem aTestItem;
      aTestItem.m_bTest1=m_xTest1CBox->get_active();
      aTestItem.m_bTest2=m_xTest2CBox->get_active();
      aTestItem.m_bTest3=m_xTest3CBox->get_active();
      aTestItem.m_bTest4=m_xTest4CBox->get_active();
      aTestItem.m_bTest5=m_xTest5CBox->get_active();
      aTestItem.m_bTest6=m_xTest6CBox->get_active();
      aTestItem.m_bTest7=m_xTest7CBox->get_active();
      aTestItem.m_bTest8=m_xTest8CBox->get_active();
      aTestItem.m_bTest9=m_xTest9CBox->get_active();
      aTestItem.m_bTest10=m_xTest10CBox->get_active();
      rCoreSet->Put(aTestItem);
  }
  return bAttrModified;
2169}

2171void SwTestTabPage::Reset( const SfxItemSet* )
2172{
  const SfxItemSet& rSet = GetItemSet();
  const SwTestItem* pTestAttr = nullptr;

  if( SfxItemState::SET != rSet.GetItemState( FN_PARAM_SWTEST((20000 + 1100)+22) , false,
                                  reinterpret_cast<const SfxPoolItem**>(&pTestAttr) ))
      return;

  m_xTest1CBox->set_active(pTestAttr->m_bTest1);
  m_xTest2CBox->set_active(pTestAttr->m_bTest2);
  m_xTest3CBox->set_active(pTestAttr->m_bTest3);
  m_xTest4CBox->set_active(pTestAttr->m_bTest4);
  m_xTest5CBox->set_active(pTestAttr->m_bTest5);
  m_xTest6CBox->set_active(pTestAttr->m_bTest6);
  m_xTest7CBox->set_active(pTestAttr->m_bTest7);
  m_xTest8CBox->set_active(pTestAttr->m_bTest8);
  m_xTest9CBox->set_active(pTestAttr->m_bTest9);
  m_xTest10CBox->set_active(pTestAttr->m_bTest10);
2190}

2192void SwTestTabPage::Init()
2193{
  // handler
  Link<weld::Button&,void> aLk = LINK( this, SwTestTabPage, AutoClickHdl )::tools::detail::makeLink( ::tools::detail::castTo<SwTestTabPage
 *>(this), &SwTestTabPage::LinkStubAutoClickHdl);
  m_xTest1CBox->connect_clicked( aLk );
  m_xTest2CBox->connect_clicked( aLk );
  m_xTest3CBox->connect_clicked( aLk );
  m_xTest4CBox->connect_clicked( aLk );
  m_xTest5CBox->connect_clicked( aLk );
  m_xTest6CBox->connect_clicked( aLk );
  m_xTest7CBox->connect_clicked( aLk );
  m_xTest8CBox->connect_clicked( aLk );
  m_xTest9CBox->connect_clicked( aLk );
  m_xTest10CBox->connect_clicked( aLk );
2206}

2208IMPL_LINK_NOARG(SwTestTabPage, AutoClickHdl, weld::Button&, void)void SwTestTabPage::LinkStubAutoClickHdl(void * instance, weld
::Button& data) { return static_cast<SwTestTabPage *>
(instance)->AutoClickHdl(data); } void SwTestTabPage::AutoClickHdl
(__attribute__ ((unused)) weld::Button&)
2209{
  bAttrModified = true;
2211}

2213#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

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

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

440#endif // INCLUDED_VCL_PTR_HXX

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

←

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

→

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

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

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

32#include "sal/types.h"

34namespace rtl
35{

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


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


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

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

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
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_pBody8.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
)
9
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
10
←
Calling 'VclReferenceBase::release'→
14
←
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;
17
←
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)
11
←
Assuming the condition is true→
12
←
Taking true branch→
40            delete this;
13
←
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