/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 tpline.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 CUI_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/qrcodegen/cpp/ -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/liborcus/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/liborcus/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/curl/include -I /home/maarten/src/libreoffice/core/external/clew/source/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/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/cui/inc -I /home/maarten/src/libreoffice/core/cui/source/inc -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 -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/cui/source/tabpages/tpline.cxx

/home/maarten/src/libreoffice/core/cui/source/tabpages/tpline.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 <memory>
21#include <editeng/sizeitem.hxx>
22#include <osl/file.hxx>
23#include <tools/urlobj.hxx>

25#include <strings.hrc>
26#include <svx/colorbox.hxx>
27#include <svx/dlgctrl.hxx>
28#include <svx/xlineit0.hxx>
29#include <svx/xlinjoit.hxx>
30#include <svx/xlncapit.hxx>
31#include <svx/xlndsit.hxx>
32#include <svx/xlnwtit.hxx>
33#include <svx/xlnstwit.hxx>
34#include <svx/xlnedwit.hxx>
35#include <svx/xlnclit.hxx>
36#include <svx/xlnstit.hxx>
37#include <svx/xlnedit.hxx>
38#include <svx/xlnstcit.hxx>
39#include <svx/xlnedcit.hxx>


42#include <svx/tabline.hxx>
43#include <svx/xtable.hxx>
44#include <svx/drawitem.hxx>
45#include <cuitabline.hxx>
46#include <dialmgr.hxx>
47#include <svx/dlgutil.hxx>
48#include <svx/svxgraphicitem.hxx>
49#include <svx/ofaitem.hxx>
50#include <svx/svdobj.hxx>
51#include <svx/svdpage.hxx>
52#include <svx/svdview.hxx>
53#include <svx/svdmodel.hxx>
54#include <svx/xlntrit.hxx>
55#include <svx/xfltrit.hxx>
56#include <editeng/numitem.hxx>
57#include <editeng/brushitem.hxx>
58#include <svx/gallery.hxx>
59#include <sfx2/opengrf.hxx>
60#include <svx/dialmgr.hxx>
61#include <svx/svxids.hrc>
62#include <svx/strings.hrc>
63#include <cuitabarea.hxx>
64#include <svtools/unitconv.hxx>
65#include <comphelper/lok.hxx>

67#define MAX_BMP_WIDTH16   16
68#define MAX_BMP_HEIGHT16  16

70using namespace com::sun::star;

72// static ----------------------------------------------------------------

74const sal_uInt16 SvxLineTabPage::pLineRanges[] =
75{
  XATTR_LINETRANSPARENCE,
  XATTR_LINETRANSPARENCE,
  SID_ATTR_LINE_STYLE( 10000 + 169 ),
  SID_ATTR_LINE_ENDCENTER( 10000 + 178 ),
  0
81};

83SvxLineTabPage::SvxLineTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs)
  : SfxTabPage(pPage, pController, "cui/ui/linetabpage.ui", "LineTabPage", &rInAttrs)
  , m_pSymbolList(nullptr)
  , m_bNewSize(false)
  , m_nSymbolType(SVX_SYMBOLTYPE_UNKNOWN(-100)) // unknown respectively unchanged
  , m_pSymbolAttr(nullptr)
  , m_bLastWidthModified(false)
  , m_aSymbolLastSize(Size(0,0))
  , m_bSymbols(false)
  , m_rOutAttrs(rInAttrs)
  , m_bObjSelected(false)
  , m_aXLineAttr(rInAttrs.GetPool())
  , m_rXLSet(m_aXLineAttr.GetItemSet())
  , m_pnLineEndListState(nullptr)
  , m_pnDashListState(nullptr)
  , m_pnColorListState(nullptr)
  , m_nPageType(PageType::Area)
  , m_nDlgType(0)
  , m_pPosDashLb(nullptr)
  , m_pPosLineEndLb(nullptr)
  , m_xBoxColor(m_xBuilder->weld_widget("boxCOLOR"))
  , m_xLbLineStyle(new SvxLineLB(m_xBuilder->weld_combo_box("LB_LINE_STYLE")))
  , m_xLbColor(new ColorListBox(m_xBuilder->weld_menu_button("LB_COLOR"), pController->getDialog()))
  , m_xBoxWidth(m_xBuilder->weld_widget("boxWIDTH"))
  , m_xMtrLineWidth(m_xBuilder->weld_metric_spin_button("MTR_FLD_LINE_WIDTH", FieldUnit::CM))
  , m_xBoxTransparency(m_xBuilder->weld_widget("boxTRANSPARENCY"))
  , m_xMtrTransparent(m_xBuilder->weld_metric_spin_button("MTR_LINE_TRANSPARENT", FieldUnit::PERCENT))
  , m_xFlLineEnds(m_xBuilder->weld_widget("FL_LINE_ENDS"))
  , m_xBoxArrowStyles(m_xBuilder->weld_widget("boxARROW_STYLES"))
  , m_xLbStartStyle(new SvxLineEndLB(m_xBuilder->weld_combo_box("LB_START_STYLE")))
  , m_xBoxStart(m_xBuilder->weld_widget("boxSTART"))
  , m_xMtrStartWidth(m_xBuilder->weld_metric_spin_button("MTR_FLD_START_WIDTH", FieldUnit::CM))
  , m_xTsbCenterStart(m_xBuilder->weld_check_button("TSB_CENTER_START"))
  , m_xBoxEnd(m_xBuilder->weld_widget("boxEND"))
  , m_xLbEndStyle(new SvxLineEndLB(m_xBuilder->weld_combo_box("LB_END_STYLE")))
  , m_xMtrEndWidth(m_xBuilder->weld_metric_spin_button("MTR_FLD_END_WIDTH", FieldUnit::CM))
  , m_xTsbCenterEnd(m_xBuilder->weld_check_button("TSB_CENTER_END"))
  , m_xCbxSynchronize(m_xBuilder->weld_check_button("CBX_SYNCHRONIZE"))
  , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "CTL_PREVIEW", m_aCtlPreview))
  , m_xFLEdgeStyle(m_xBuilder->weld_widget("FL_EDGE_STYLE"))
  , m_xGridEdgeCaps(m_xBuilder->weld_widget("gridEDGE_CAPS"))
  , m_xLBEdgeStyle(m_xBuilder->weld_combo_box("LB_EDGE_STYLE"))
  , m_xLBCapStyle(m_xBuilder->weld_combo_box("LB_CAP_STYLE")) // LineCaps
  , m_xFlSymbol(m_xBuilder->weld_widget("FL_SYMBOL_FORMAT")) //#58425# Symbols on a line (e.g. StarChart)
  , m_xGridIconSize(m_xBuilder->weld_widget("gridICON_SIZE"))
  , m_xSymbolMB(m_xBuilder->weld_menu_button("MB_SYMBOL_BITMAP"))
  , m_xSymbolWidthMF(m_xBuilder->weld_metric_spin_button("MF_SYMBOL_WIDTH", FieldUnit::CM))
  , m_xSymbolHeightMF(m_xBuilder->weld_metric_spin_button("MF_SYMBOL_HEIGHT", FieldUnit::CM))
  , m_xSymbolRatioCB(m_xBuilder->weld_check_button("CB_SYMBOL_RATIO"))
132{
  // This Page requires ExchangeSupport
  SetExchangeSupport();

  // Metric set
  FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs );

  switch ( eFUnit )
  {
      case FieldUnit::M:
      case FieldUnit::KM:
          eFUnit = FieldUnit::MM;
          [[fallthrough]]; // we now have mm
      case FieldUnit::MM:
          m_xMtrLineWidth->set_increments(50, 500, FieldUnit::NONE);
          m_xMtrStartWidth->set_increments(50, 500, FieldUnit::NONE);
          m_xMtrEndWidth->set_increments(50, 500, FieldUnit::NONE);
          break;

          case FieldUnit::INCH:
          m_xMtrLineWidth->set_increments(2, 20, FieldUnit::NONE);
          m_xMtrStartWidth->set_increments(2, 20, FieldUnit::NONE);
          m_xMtrEndWidth->set_increments(2, 20, FieldUnit::NONE);
          break;
          default: ;// prevent warning
  }
  SetFieldUnit( *m_xMtrLineWidth, eFUnit );
  SetFieldUnit( *m_xMtrStartWidth, eFUnit );
  SetFieldUnit( *m_xMtrEndWidth, eFUnit );

  // determine PoolUnit
  SfxItemPool* pPool = m_rOutAttrs.GetPool();
  DBG_ASSERT( pPool, "Where is the pool?" )do { if (true && (!(pPool))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/cui/source/tabpages/tpline.cxx"
 ":" "164" ": "), "%s", "Where is the pool?"); } } while (false
);
  m_ePoolUnit = pPool->GetMetric( SID_ATTR_LINE_WIDTH( 10000 + 171 ) );

  m_xLbLineStyle->connect_changed(LINK(this, SvxLineTabPage, ClickInvisibleHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubClickInvisibleHdl_Impl
));
  m_xLbColor->SetSelectHdl( LINK( this, SvxLineTabPage, ChangePreviewListBoxHdl_Impl )::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangePreviewListBoxHdl_Impl
) );
  m_xMtrLineWidth->connect_value_changed(LINK(this, SvxLineTabPage, ChangePreviewModifyHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangePreviewModifyHdl_Impl
));
  m_xMtrTransparent->connect_value_changed(LINK( this, SvxLineTabPage, ChangeTransparentHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeTransparentHdl_Impl
));

  m_xLbStartStyle->connect_changed(LINK(this, SvxLineTabPage, ChangeStartListBoxHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeStartListBoxHdl_Impl
));
  m_xLbEndStyle->connect_changed(LINK(this, SvxLineTabPage, ChangeEndListBoxHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeEndListBoxHdl_Impl
));
  m_xMtrStartWidth->connect_value_changed(LINK(this, SvxLineTabPage, ChangeStartModifyHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeStartModifyHdl_Impl
));
  m_xMtrEndWidth->connect_value_changed(LINK( this, SvxLineTabPage, ChangeEndModifyHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeEndModifyHdl_Impl
));
  m_xTsbCenterStart->connect_clicked(LINK(this, SvxLineTabPage, ChangeStartClickHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeStartClickHdl_Impl
));
  m_xTsbCenterEnd->connect_clicked(LINK(this, SvxLineTabPage, ChangeEndClickHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeEndClickHdl_Impl
));

  Link<weld::ComboBox&,void> aEdgeStyle = LINK(this, SvxLineTabPage, ChangeEdgeStyleHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeEdgeStyleHdl_Impl
);
  m_xLBEdgeStyle->connect_changed(aEdgeStyle);

  // LineCaps
  Link<weld::ComboBox&,void> aCapStyle = LINK(this, SvxLineTabPage, ChangeCapStyleHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubChangeCapStyleHdl_Impl
);
  m_xLBCapStyle->connect_changed(aCapStyle);

  // Symbols on a line (eg star charts), MB-handler set
  m_xSymbolMB->connect_selected(LINK(this, SvxLineTabPage, GraphicHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubGraphicHdl_Impl));
  m_xSymbolMB->connect_toggled(LINK(this, SvxLineTabPage, MenuCreateHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubMenuCreateHdl_Impl
));
  m_xSymbolWidthMF->connect_value_changed(LINK(this, SvxLineTabPage, SizeHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubSizeHdl_Impl));
  m_xSymbolHeightMF->connect_value_changed(LINK(this, SvxLineTabPage, SizeHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubSizeHdl_Impl));
  m_xSymbolRatioCB->connect_toggled(LINK(this, SvxLineTabPage, RatioHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SvxLineTabPage
 *>(this), &SvxLineTabPage::LinkStubRatioHdl_Impl));

  m_xSymbolRatioCB->set_active(true);
  ShowSymbolControls(false);

  m_nActLineWidth = -1;
197}

199void SvxLineTabPage::ShowSymbolControls(bool bOn)
200{
  // Symbols on a line (e.g. StarCharts), symbol-enable controls

  m_bSymbols=bOn;
  m_xFlSymbol->set_visible(bOn);
  m_aCtlPreview.ShowSymbol(bOn);
206}

208SvxLineTabPage::~SvxLineTabPage()
209{
  m_xCtlPreview.reset();
  m_xLbEndStyle.reset();
  m_xLbStartStyle.reset();
  m_xLbColor.reset();
  m_xLbLineStyle.reset();
  m_aGalleryBrushItems.clear();
  m_aSymbolBrushItems.clear();
217}

219void SvxLineTabPage::Construct()
220{
  FillListboxes();
222}

224void SvxLineTabPage::FillListboxes()
225{
  // Line styles
  auto nOldSelect = m_xLbLineStyle->get_active();
  // aLbLineStyle.FillStyles();
  m_xLbLineStyle->Fill( m_pDashList );
  m_xLbLineStyle->set_active( nOldSelect );

  // Line end style
  OUString sNone( comphelper::LibreOfficeKit::isActive() ? SvxResId( RID_SVXSTR_INVISIBLEreinterpret_cast<char const *>("RID_SVXSTR_INVISIBLE" "\004"
 u8"None") )
      : SvxResId( RID_SVXSTR_NONEreinterpret_cast<char const *>("RID_SVXSTR_NONE" "\004"
 u8"- none -") ) );
  nOldSelect = m_xLbStartStyle->get_active();
  m_xLbStartStyle->clear();
  m_xLbStartStyle->append_text(sNone);
  m_xLbStartStyle->Fill(m_pLineEndList);
  m_xLbStartStyle->set_active(nOldSelect);
  nOldSelect = m_xLbEndStyle->get_active();
  m_xLbEndStyle->clear();
  m_xLbEndStyle->append_text(sNone);
  m_xLbEndStyle->Fill(m_pLineEndList, false);
  m_xLbEndStyle->set_active(nOldSelect);
245}

247void SvxLineTabPage::ActivatePage( const SfxItemSet& rSet )
248{
  const CntUInt16Item* pPageTypeItem = rSet.GetItem<CntUInt16Item>(SID_PAGE_TYPE( 10000 + 1017 ), false);
  if (pPageTypeItem)
      SetPageType(static_cast<PageType>(pPageTypeItem->GetValue()));
  if( m_nDlgType == 0 && m_pDashList.is() )
  {
      sal_Int32 nPos;
      sal_Int32 nCount;

      // Dash list
      if( ( *m_pnDashListState & ChangeType::MODIFIED ) ||
          ( *m_pnDashListState & ChangeType::CHANGED ) )
      {
          if( *m_pnDashListState & ChangeType::CHANGED )
              m_pDashList = static_cast<SvxLineTabDialog*>(GetDialogController() )->GetNewDashList();

          *m_pnDashListState = ChangeType::NONE;

          // Style list
          nPos = m_xLbLineStyle->get_active();

          m_xLbLineStyle->clear();
          m_xLbLineStyle->append_text(SvxResId(RID_SVXSTR_INVISIBLEreinterpret_cast<char const *>("RID_SVXSTR_INVISIBLE" "\004"
 u8"None")));
          m_xLbLineStyle->append_text(SvxResId(RID_SVXSTR_SOLIDreinterpret_cast<char const *>("RID_SVXSTR_SOLID" "\004"
 u8"Continuous")));
          m_xLbLineStyle->Fill(m_pDashList);
          nCount = m_xLbLineStyle->get_count();

          if ( nCount == 0 )
              ; // This case should never occur
          else if( nCount <= nPos )
              m_xLbLineStyle->set_active(0);
          else
              m_xLbLineStyle->set_active(nPos);
      }

      INetURLObject   aDashURL( m_pDashList->GetPath() );

      aDashURL.Append( m_pDashList->GetName() );
      DBG_ASSERT( aDashURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" )do { if (true && (!(aDashURL.GetProtocol() != INetProtocol
::NotValid))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/cui/source/tabpages/tpline.cxx"
 ":" "286" ": "), "%s", "invalid URL"); } } while (false);
      // LineEnd list
      if( ( *m_pnLineEndListState & ChangeType::MODIFIED ) || ( *m_pnLineEndListState & ChangeType::CHANGED ) )
      {
          if( *m_pnLineEndListState & ChangeType::CHANGED )
              m_pLineEndList = static_cast<SvxLineTabDialog*>(GetDialogController())->GetNewLineEndList();

          *m_pnLineEndListState = ChangeType::NONE;

          nPos = m_xLbLineStyle->get_active();
          OUString sNone( comphelper::LibreOfficeKit::isActive() ? SvxResId( RID_SVXSTR_INVISIBLEreinterpret_cast<char const *>("RID_SVXSTR_INVISIBLE" "\004"
 u8"None") )
              : SvxResId( RID_SVXSTR_NONEreinterpret_cast<char const *>("RID_SVXSTR_NONE" "\004"
 u8"- none -") ) );

          m_xLbStartStyle->clear();
          m_xLbStartStyle->append_text(sNone);

          m_xLbStartStyle->Fill( m_pLineEndList );
          nCount = m_xLbStartStyle->get_count();
          if( nCount == 0 )
              ; // This case should never occur
          else if( nCount <= nPos )
              m_xLbStartStyle->set_active(0);
          else
              m_xLbStartStyle->set_active(nPos);

          m_xLbEndStyle->clear();
          m_xLbEndStyle->append_text(sNone);

          m_xLbEndStyle->Fill( m_pLineEndList, false );
          nCount = m_xLbEndStyle->get_count();

          if( nCount == 0 )
              ; // This case should never occur
          else if( nCount <= nPos )
              m_xLbEndStyle->set_active(0);
          else
              m_xLbEndStyle->set_active(nPos);
      }
      INetURLObject aLineURL( m_pLineEndList->GetPath() );

      aLineURL.Append( m_pLineEndList->GetName() );
      DBG_ASSERT( aLineURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" )do { if (true && (!(aLineURL.GetProtocol() != INetProtocol
::NotValid))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/cui/source/tabpages/tpline.cxx"
 ":" "327" ": "), "%s", "invalid URL"); } } while (false);
      // Evaluate if another TabPage set another fill type
      if( m_xLbLineStyle->get_active() != 0 )
      {
          if( m_nPageType == PageType::Hatch ) // 1
          {
              m_xLbLineStyle->set_active(*m_pPosDashLb + 2); // +2 due to SOLID and INVISIBLE
              ChangePreviewHdl_Impl( nullptr );
          }
          if( m_nPageType == PageType::Bitmap )
          {
              m_xLbStartStyle->set_active(*m_pPosLineEndLb + 1);// +1 due to SOLID
              m_xLbEndStyle->set_active(*m_pPosLineEndLb + 1);// +1 due to SOLID
              ChangePreviewHdl_Impl( nullptr );
          }
      }

          // ColorList
      if( *m_pnColorListState != ChangeType::NONE )
      {
          ChangePreviewHdl_Impl( nullptr );
      }

      m_nPageType = PageType::Area;
  }
  // Page does not yet exist in the ctor, that's why we do it here!

  else if (m_nDlgType == 1101) // nNoArrowNoShadowDlg from chart2/source/controller/dialogs/dlg_ObjectProperties.cxx
  {
      m_xFlLineEnds->hide();
      m_xFLEdgeStyle->hide();
  }
359}


362DeactivateRC SvxLineTabPage::DeactivatePage( SfxItemSet* _pSet )
363{
  if( m_nDlgType == 0 ) // Line dialog
  {
      m_nPageType = PageType::Gradient; // possibly for extensions
      *m_pPosDashLb = m_xLbLineStyle->get_active() - 2;// First entry SOLID!!!
      sal_Int32 nPos = m_xLbStartStyle->get_active();
      if (nPos != -1)
          nPos--;
      *m_pPosLineEndLb = nPos;
  }

  if( _pSet )
      FillItemSet( _pSet );

  return DeactivateRC::LeavePage;
378}


381bool SvxLineTabPage::FillItemSet( SfxItemSet* rAttrs )
382{
  const SfxPoolItem* pOld = nullptr;
  sal_Int32  nPos;
  bool    bModified = false;

  // To prevent modifications to the list, we do not set other page's items.
  if( m_nDlgType != 0 || m_nPageType != PageType::Hatch )
  {
      nPos = m_xLbLineStyle->get_active();
      if( nPos != -1 &&
          m_xLbLineStyle->get_value_changed_from_saved() )
      {
          std::unique_ptr<XLineStyleItem> pStyleItem;

          if( nPos == 0 )
              pStyleItem.reset(new XLineStyleItem( drawing::LineStyle_NONE ));
          else if( nPos == 1 )
              pStyleItem.reset(new XLineStyleItem( drawing::LineStyle_SOLID ));
          else
          {
              pStyleItem.reset(new XLineStyleItem( drawing::LineStyle_DASH ));

              // For added security
              if( m_pDashList->Count() > static_cast<long>( nPos - 2 ) )
              {
                  XLineDashItem aDashItem( m_xLbLineStyle->get_active_text(),
                                      m_pDashList->GetDash( nPos - 2 )->GetDash() );
                  pOld = GetOldItem( *rAttrs, XATTR_LINEDASH );
                  if ( !pOld || !( *static_cast<const XLineDashItem*>(pOld) == aDashItem ) )
                  {
                      rAttrs->Put( aDashItem );
                      bModified = true;
                  }
              }
          }
          pOld = GetOldItem( *rAttrs, XATTR_LINESTYLE );
          if ( !pOld || !( *static_cast<const XLineStyleItem*>(pOld) == *pStyleItem ) )
          {
              rAttrs->Put( *pStyleItem );
              bModified = true;
          }
      }
  }
  // Line width
  // GetSavedValue() returns OUString!
  if( m_xMtrLineWidth->get_value_changed_from_saved() )
  {
      XLineWidthItem aItem( GetCoreValue( *m_xMtrLineWidth, m_ePoolUnit ) );
      pOld = GetOldItem( *rAttrs, XATTR_LINEWIDTH );
      if ( !pOld || !( *static_cast<const XLineWidthItem*>(pOld) == aItem ) )
      {
          rAttrs->Put( aItem );
          bModified = true;
      }
  }
  // Width line start
  if( m_xMtrStartWidth->get_value_changed_from_saved() )
  {
      XLineStartWidthItem aItem( GetCoreValue( *m_xMtrStartWidth, m_ePoolUnit ) );
      pOld = GetOldItem( *rAttrs, XATTR_LINESTARTWIDTH );
      if ( !pOld || !( *static_cast<const XLineStartWidthItem*>(pOld) == aItem ) )
      {
          rAttrs->Put( aItem );
          bModified = true;
      }
  }
  // Width line end
  if( m_xMtrEndWidth->get_value_changed_from_saved() )
  {
      XLineEndWidthItem aItem( GetCoreValue( *m_xMtrEndWidth, m_ePoolUnit ) );
      pOld = GetOldItem( *rAttrs, XATTR_LINEENDWIDTH );
      if ( !pOld || !( *static_cast<const XLineEndWidthItem*>(pOld) == aItem ) )
      {
          rAttrs->Put( aItem );
          bModified = true;
      }
  }

  // Line color
  if (m_xLbColor->IsValueChangedFromSaved())
  {
      NamedColor aColor = m_xLbColor->GetSelectedEntry();
      XLineColorItem aItem(aColor.second, aColor.first);
      pOld = GetOldItem( *rAttrs, XATTR_LINECOLOR );
      if ( !pOld || !( *static_cast<const XLineColorItem*>(pOld) == aItem ) )
      {
          rAttrs->Put( aItem );
          bModified = true;
      }
  }

  if( m_nDlgType != 0 || m_nPageType != PageType::Bitmap )
  {
      // Line start
      nPos = m_xLbStartStyle->get_active();
      if( nPos != -1 && m_xLbStartStyle->get_value_changed_from_saved() )
      {
          std::unique_ptr<XLineStartItem> pItem;
          if( nPos == 0 )
              pItem.reset(new XLineStartItem());
          else if( m_pLineEndList->Count() > static_cast<long>( nPos - 1 ) )
              pItem.reset(new XLineStartItem( m_xLbStartStyle->get_active_text(), m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ));
          pOld = GetOldItem( *rAttrs, XATTR_LINESTART );
          if( pItem && ( !pOld || *pOld != *pItem ) )
          {
              rAttrs->Put( *pItem );
              bModified = true;
          }
      }
      // Line end
      nPos = m_xLbEndStyle->get_active();
      if( nPos != -1 && m_xLbEndStyle->get_value_changed_from_saved() )
      {
          std::unique_ptr<XLineEndItem> pItem;
          if( nPos == 0 )
              pItem.reset(new XLineEndItem());
          else if( m_pLineEndList->Count() > static_cast<long>( nPos - 1 ) )
              pItem.reset(new XLineEndItem( m_xLbEndStyle->get_active_text(), m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ));
          pOld = GetOldItem( *rAttrs, XATTR_LINEEND );
          if( pItem &&
              ( !pOld || !( *static_cast<const XLineEndItem*>(pOld) == *pItem ) ) )
          {
              rAttrs->Put( *pItem );
              bModified = true;
          }
      }
  }

  // Centered line end
  TriState eState = m_xTsbCenterStart->get_state();
  if( m_xTsbCenterStart->get_state_changed_from_saved() )
  {
      XLineStartCenterItem aItem( eState != TRISTATE_FALSE );
      pOld = GetOldItem( *rAttrs, XATTR_LINESTARTCENTER );
      if ( !pOld || !( *static_cast<const XLineStartCenterItem*>(pOld) == aItem ) )
      {
          rAttrs->Put( aItem );
          bModified = true;
      }
  }
  eState = m_xTsbCenterEnd->get_state();
  if( m_xTsbCenterEnd->get_state_changed_from_saved() )
  {
      XLineEndCenterItem aItem( eState != TRISTATE_FALSE );
      pOld = GetOldItem( *rAttrs, XATTR_LINEENDCENTER );
      if ( !pOld || !( *static_cast<const XLineEndCenterItem*>(pOld) == aItem ) )
      {
          rAttrs->Put( aItem );
          bModified = true;
      }
  }

  // Transparency
  sal_uInt16 nVal = m_xMtrTransparent->get_value(FieldUnit::PERCENT);
  if( m_xMtrTransparent->get_value_changed_from_saved() )
  {
      XLineTransparenceItem aItem( nVal );
      pOld = GetOldItem( *rAttrs, XATTR_LINETRANSPARENCE );
      if ( !pOld || !( *static_cast<const XLineTransparenceItem*>(pOld) == aItem ) )
      {
          rAttrs->Put( aItem );
          bModified = true;
      }
  }

  nPos = m_xLBEdgeStyle->get_active();
  if (nPos != -1 && m_xLBEdgeStyle->get_value_changed_from_saved())
  {
      std::unique_ptr<XLineJointItem> pNew;

      switch(nPos)
      {
          case 0: // Rounded, default
          {
              pNew.reset(new XLineJointItem(css::drawing::LineJoint_ROUND));
              break;
          }
          case 1: // - none -
          {
              pNew.reset(new XLineJointItem(css::drawing::LineJoint_NONE));
              break;
          }
          case 2: // Miter
          {
              pNew.reset(new XLineJointItem(css::drawing::LineJoint_MITER));
              break;
          }
          case 3: // Bevel
          {
              pNew.reset(new XLineJointItem(css::drawing::LineJoint_BEVEL));
              break;
          }
      }

      if(pNew)
      {
          pOld = GetOldItem( *rAttrs, XATTR_LINEJOINT );

          if(!pOld || !(*static_cast<const XLineJointItem*>(pOld) == *pNew))
          {
              rAttrs->Put( *pNew );
              bModified = true;
          }
      }
  }

  // LineCaps
  nPos = m_xLBCapStyle->get_active();
  if (nPos != -1 && m_xLBCapStyle->get_value_changed_from_saved())
  {
      std::unique_ptr<XLineCapItem> pNew;

      switch(nPos)
      {
          case 0: // Butt (=Flat), default
          {
              pNew.reset(new XLineCapItem(css::drawing::LineCap_BUTT));
              break;
          }
          case 1: // Round
          {
              pNew.reset(new XLineCapItem(css::drawing::LineCap_ROUND));
              break;
          }
          case 2: // Square
          {
              pNew.reset(new XLineCapItem(css::drawing::LineCap_SQUARE));
              break;
          }
      }

      if(pNew)
      {
          pOld = GetOldItem( *rAttrs, XATTR_LINECAP );

          if(!pOld || !(*static_cast<const XLineCapItem*>(pOld) == *pNew))
          {
              rAttrs->Put( *pNew );
              bModified = true;
          }
      }
  }

  if(m_nSymbolType!=SVX_SYMBOLTYPE_UNKNOWN(-100) || m_bNewSize)
  {
      // Was set by selection or the size is different
      SvxSizeItem  aSItem(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE(27000 +116)),m_aSymbolSize);
      const SfxPoolItem* pSOld = GetOldItem( *rAttrs, rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE(27000 +116)) );
      m_bNewSize  = pSOld ? *static_cast<const SvxSizeItem *>(pSOld) != aSItem : m_bNewSize ;
      if(m_bNewSize)
      {
          rAttrs->Put(aSItem);
          bModified=true;
      }

      SfxInt32Item aTItem(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE(27000 +115)),m_nSymbolType);
      const SfxPoolItem* pTOld = GetOldItem( *rAttrs, rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE(27000 +115)) );
      bool bNewType = pTOld == nullptr || *static_cast<const SfxInt32Item*>(pTOld) != aTItem;
      if(bNewType && m_nSymbolType==SVX_SYMBOLTYPE_UNKNOWN(-100))
          bNewType=false; // a small fix, type wasn't set -> don't create a type item after all!
      if(bNewType)
      {
          rAttrs->Put(aTItem);
          bModified=true;
      }

      if(m_nSymbolType!=SVX_SYMBOLTYPE_NONE(-3))
      {
          SvxBrushItem aBItem(m_aSymbolGraphic,GPOS_MM,rAttrs->GetPool()->GetWhich(SID_ATTR_BRUSH( 10000 + 1 )));
          const SfxPoolItem* pBOld = GetOldItem( *rAttrs, rAttrs->GetPool()->GetWhich(SID_ATTR_BRUSH( 10000 + 1 )) );
          bool bNewBrush =
              pBOld == nullptr || *static_cast<const SvxBrushItem*>(pBOld) != aBItem;
          if(bNewBrush)
          {
              rAttrs->Put(aBItem);
              bModified=true;
          }
      }
  }
  rAttrs->Put (CntUInt16Item(SID_PAGE_TYPE( 10000 + 1017 ), static_cast<sal_uInt16>(m_nPageType)));
  return bModified;
663}


666void SvxLineTabPage::FillXLSet_Impl()
667{
  sal_Int32 nPos;

  if (m_xLbLineStyle->get_active() == -1)
  {
      m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) );
  }
  else if (m_xLbLineStyle->get_active() == 0)
      m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) );
  else if (m_xLbLineStyle->get_active() == 1)
      m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_SOLID ) );
  else
  {
      m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_DASH ) );

      nPos = m_xLbLineStyle->get_active();
      if (nPos != -1)
      {
          m_rXLSet.Put( XLineDashItem( m_xLbLineStyle->get_active_text(),
                          m_pDashList->GetDash( nPos - 2 )->GetDash() ) );
      }
  }

  nPos = m_xLbStartStyle->get_active();
  if (nPos != -1)
  {
      if( nPos == 0 )
          m_rXLSet.Put( XLineStartItem() );
      else
          m_rXLSet.Put( XLineStartItem( m_xLbStartStyle->get_active_text(),
                      m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ) );
  }
  nPos = m_xLbEndStyle->get_active();
  if (nPos != -1)
  {
      if( nPos == 0 )
          m_rXLSet.Put( XLineEndItem() );
      else
          m_rXLSet.Put( XLineEndItem( m_xLbEndStyle->get_active_text(),
                      m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ) );
  }

  nPos = m_xLBEdgeStyle->get_active();
  if (nPos != -1)
  {
      switch(nPos)
      {
          case 0: // Rounded, default
          {
              m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_ROUND));
              break;
          }
          case 1: // - none -
          {
              m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_NONE));
              break;
          }
          case 2: // Miter
          {
              m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_MITER));
              break;
          }
          case 3: // Bevel
          {
              m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_BEVEL));
              break;
          }
      }
  }

  // LineCaps
  nPos = m_xLBCapStyle->get_active();
  if (nPos != -1)
  {
      switch(nPos)
      {
          case 0: // Butt (=Flat), default
          {
              m_rXLSet.Put(XLineCapItem(css::drawing::LineCap_BUTT));
              break;
          }
          case 1: // Round
          {
              m_rXLSet.Put(XLineCapItem(css::drawing::LineCap_ROUND));
              break;
          }
          case 2: // Square
          {
              m_rXLSet.Put(XLineCapItem(css::drawing::LineCap_SQUARE));
              break;
          }
      }
  }

  m_rXLSet.Put( XLineStartWidthItem( GetCoreValue( *m_xMtrStartWidth, m_ePoolUnit ) ) );
  m_rXLSet.Put( XLineEndWidthItem( GetCoreValue( *m_xMtrEndWidth, m_ePoolUnit ) ) );

  m_rXLSet.Put( XLineWidthItem( GetCoreValue( *m_xMtrLineWidth, m_ePoolUnit ) ) );
  NamedColor aColor = m_xLbColor->GetSelectedEntry();
  m_rXLSet.Put(XLineColorItem(aColor.second, aColor.first));

  // Centered line end
  if( m_xTsbCenterStart->get_state() == TRISTATE_TRUE )
      m_rXLSet.Put( XLineStartCenterItem( true ) );
  else if( m_xTsbCenterStart->get_state() == TRISTATE_FALSE )
      m_rXLSet.Put( XLineStartCenterItem( false ) );

  if( m_xTsbCenterEnd->get_state() == TRISTATE_TRUE )
      m_rXLSet.Put( XLineEndCenterItem( true ) );
  else if( m_xTsbCenterEnd->get_state() == TRISTATE_FALSE )
      m_rXLSet.Put( XLineEndCenterItem( false ) );

  // Transparency
  sal_uInt16 nVal = m_xMtrTransparent->get_value(FieldUnit::PERCENT);
  m_rXLSet.Put( XLineTransparenceItem( nVal ) );

  m_aCtlPreview.SetLineAttributes(m_aXLineAttr.GetItemSet());
784}


787void SvxLineTabPage::Reset( const SfxItemSet* rAttrs )
788{
  drawing::LineStyle  eXLS; // drawing::LineStyle_NONE, drawing::LineStyle_SOLID, drawing::LineStyle_DASH

  // Line style
  const SfxPoolItem *pPoolItem;
  long nSymType=SVX_SYMBOLTYPE_UNKNOWN(-100);
  bool bPrevSym=false;
  bool bEnable=true;
  bool bIgnoreGraphic=false;
  bool bIgnoreSize=false;
  if(rAttrs->GetItemState(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE(27000 +115)),true,&pPoolItem) == SfxItemState::SET)
  {
      nSymType=static_cast<const SfxInt32Item *>(pPoolItem)->GetValue();
  }

  if(nSymType == SVX_SYMBOLTYPE_AUTO(-2))
  {
      m_aSymbolGraphic=m_aAutoSymbolGraphic;
      m_aSymbolSize=m_aSymbolLastSize=m_aAutoSymbolGraphic.GetPrefSize();
      bPrevSym=true;
  }
  else if(nSymType == SVX_SYMBOLTYPE_NONE(-3))
  {
      bEnable=false;
      bIgnoreGraphic=true;
      bIgnoreSize=true;
  }
  else if(nSymType >= 0)
  {
      ScopedVclPtrInstance< VirtualDevice > pVDev;
      pVDev->SetMapMode(MapMode(MapUnit::Map100thMM));

      std::unique_ptr<SdrModel> pModel(
          new SdrModel(nullptr, nullptr, true));
      pModel->GetItemPool().FreezeIdRanges();
      SdrPage* pPage = new SdrPage( *pModel, false );
      pPage->SetSize(Size(1000,1000));
      pModel->InsertPage( pPage, 0 );
      {
      std::unique_ptr<SdrView> pView(new SdrView( *pModel, pVDev ));
      pView->hideMarkHandles();
      pView->ShowSdrPage(pPage);
      size_t nSymTmp = static_cast<size_t>(nSymType);
      if(m_pSymbolList)
      {
          if(m_pSymbolList->GetObjCount())
          {
              nSymTmp %= m_pSymbolList->GetObjCount(); // Treat list as cyclic!
              SdrObject *pObj=m_pSymbolList->GetObj(nSymTmp);
              if(pObj)
              {
                  // directly clone to target SdrModel
                  pObj = pObj->CloneSdrObject(*pModel);

                  if(m_pSymbolAttr)
                  {
                      pObj->SetMergedItemSet(*m_pSymbolAttr);
                  }
                  else
                  {
                      pObj->SetMergedItemSet(m_rOutAttrs);
                  }

                  pPage->NbcInsertObject(pObj);

                  // Generate invisible square to give all symbol types a
                  // bitmap size, which is independent from specific glyph
                  SdrObject* pInvisibleSquare(m_pSymbolList->GetObj(0));

                  // directly clone to target SdrModel
                  pInvisibleSquare = pInvisibleSquare->CloneSdrObject(*pModel);

                  pPage->NbcInsertObject(pInvisibleSquare);
                  pInvisibleSquare->SetMergedItem(XFillTransparenceItem(100));
                  pInvisibleSquare->SetMergedItem(XLineTransparenceItem(100));

                  pView->MarkAll();
                  GDIMetaFile aMeta(pView->GetMarkedObjMetaFile());

                  m_aSymbolGraphic=Graphic(aMeta);
                  m_aSymbolSize=pObj->GetSnapRect().GetSize();
                  m_aSymbolGraphic.SetPrefSize(pInvisibleSquare->GetSnapRect().GetSize());
                  m_aSymbolGraphic.SetPrefMapMode(MapMode(MapUnit::Map100thMM));
                  bPrevSym=true;
                  bEnable=true;
                  bIgnoreGraphic=true;

                  pView->UnmarkAll();
                  pInvisibleSquare=pPage->RemoveObject(1);
                  SdrObject::Free( pInvisibleSquare);
                  pObj=pPage->RemoveObject(0);
                  SdrObject::Free( pObj );
              }
          }
      }
      }
  }
  if(rAttrs->GetItemState(rAttrs->GetPool()->GetWhich(SID_ATTR_BRUSH( 10000 + 1 )),true,&pPoolItem) == SfxItemState::SET)
  {
      const Graphic* pGraphic = static_cast<const SvxBrushItem *>(pPoolItem)->GetGraphic();
      if( pGraphic )
      {
          if(!bIgnoreGraphic)
          {
              m_aSymbolGraphic=*pGraphic;
          }
          if(!bIgnoreSize)
          {
              m_aSymbolSize=OutputDevice::LogicToLogic( pGraphic->GetPrefSize(),
                                                      pGraphic->GetPrefMapMode(),
                                                      MapMode(MapUnit::Map100thMM));
          }
          bPrevSym=true;
      }
  }

  if(rAttrs->GetItemState(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE(27000 +116)),true,&pPoolItem) == SfxItemState::SET)
  {
      m_aSymbolSize = static_cast<const SvxSizeItem *>(pPoolItem)->GetSize();
  }

  m_xGridIconSize->set_sensitive(bEnable);

  if(bPrevSym)
  {
      SetMetricValue(*m_xSymbolWidthMF,  m_aSymbolSize.Width(), m_ePoolUnit);
      SetMetricValue(*m_xSymbolHeightMF, m_aSymbolSize.Height(),m_ePoolUnit);
      m_aCtlPreview.SetSymbol(&m_aSymbolGraphic,m_aSymbolSize);
      m_aSymbolLastSize=m_aSymbolSize;
  }

  if( rAttrs->GetItemState( XATTR_LINESTYLE ) != SfxItemState::DONTCARE )
  {
      eXLS = rAttrs->Get( XATTR_LINESTYLE ).GetValue();

      switch( eXLS )
      {
          case drawing::LineStyle_NONE:
              m_xLbLineStyle->set_active(0);
              break;
          case drawing::LineStyle_SOLID:
              m_xLbLineStyle->set_active(1);
              break;

          case drawing::LineStyle_DASH:
              m_xLbLineStyle->set_active(-1);
              m_xLbLineStyle->set_active_text(rAttrs->Get( XATTR_LINEDASH ).GetName());
              break;

          default:
              break;
      }
  }
  else
  {
      m_xLbLineStyle->set_active(-1);
  }

  // Line strength
  if( rAttrs->GetItemState( XATTR_LINEWIDTH ) != SfxItemState::DONTCARE )
  {
      SetMetricValue( *m_xMtrLineWidth, rAttrs->Get( XATTR_LINEWIDTH ).GetValue(), m_ePoolUnit );
  }
  else
      m_xMtrLineWidth->set_text("");

  // Line color
  m_xLbColor->SetNoSelection();

  if ( rAttrs->GetItemState( XATTR_LINECOLOR ) != SfxItemState::DONTCARE )
  {
      Color aCol = rAttrs->Get( XATTR_LINECOLOR ).GetColorValue();
      m_xLbColor->SelectEntry( aCol );
  }

  // Line start
  if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINESTART ) == SfxItemState::DEFAULT )
  {
      m_xLbStartStyle->set_sensitive(false);
  }
  else if( rAttrs->GetItemState( XATTR_LINESTART ) != SfxItemState::DONTCARE )
  {
      // #86265# select entry using list and polygon, not string
      bool bSelected(false);
      const basegfx::B2DPolyPolygon& rItemPolygon = rAttrs->Get(XATTR_LINESTART).GetLineStartValue();

      for(long a(0);!bSelected &&  a < m_pLineEndList->Count(); a++)
      {
          const XLineEndEntry* pEntry = m_pLineEndList->GetLineEnd(a);
          const basegfx::B2DPolyPolygon& rEntryPolygon = pEntry->GetLineEnd();

          if(rItemPolygon == rEntryPolygon)
          {
              // select this entry
              m_xLbStartStyle->set_active(a + 1);
              bSelected = true;
          }
      }

      if(!bSelected)
          m_xLbStartStyle->set_active(0);
  }
  else
  {
      m_xLbStartStyle->set_active(-1);
  }

  // Line end
  if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINEEND ) == SfxItemState::DEFAULT )
  {
      m_xLbEndStyle->set_sensitive(false);
  }
  else if( rAttrs->GetItemState( XATTR_LINEEND ) != SfxItemState::DONTCARE )
  {
      // #86265# select entry using list and polygon, not string
      bool bSelected(false);
      const basegfx::B2DPolyPolygon& rItemPolygon = rAttrs->Get(XATTR_LINEEND).GetLineEndValue();

      for(long a(0);!bSelected &&  a < m_pLineEndList->Count(); a++)
      {
          const XLineEndEntry* pEntry = m_pLineEndList->GetLineEnd(a);
          const basegfx::B2DPolyPolygon& rEntryPolygon = pEntry->GetLineEnd();

          if(rItemPolygon == rEntryPolygon)
          {
              // select this entry
              m_xLbEndStyle->set_active(a + 1);
              bSelected = true;
          }
      }

      if(!bSelected)
          m_xLbEndStyle->set_active(0);
  }
  else
  {
      m_xLbEndStyle->set_active(-1);
  }

  // Line start strength
  if( m_bObjSelected &&  rAttrs->GetItemState( XATTR_LINESTARTWIDTH ) == SfxItemState::DEFAULT )
  {
      m_xMtrStartWidth->set_sensitive(false);
  }
  else if( rAttrs->GetItemState( XATTR_LINESTARTWIDTH ) != SfxItemState::DONTCARE )
  {
      SetMetricValue( *m_xMtrStartWidth,
                      rAttrs->Get( XATTR_LINESTARTWIDTH ).GetValue(),
                      m_ePoolUnit );
  }
  else
      m_xMtrStartWidth->set_text( "" );

  // Line end strength
  if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINEENDWIDTH ) == SfxItemState::DEFAULT )
  {
      m_xMtrEndWidth->set_sensitive(false);
  }
  else if( rAttrs->GetItemState( XATTR_LINEENDWIDTH ) != SfxItemState::DONTCARE )
  {
      SetMetricValue( *m_xMtrEndWidth,
                      rAttrs->Get( XATTR_LINEENDWIDTH ).GetValue(),
                      m_ePoolUnit );
  }
  else
      m_xMtrEndWidth->set_text("");

  // Centered line end (start)
  if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINESTARTCENTER ) == SfxItemState::DEFAULT )
  {
      m_xTsbCenterStart->set_sensitive(false);
  }
  else if( rAttrs->GetItemState( XATTR_LINESTARTCENTER ) != SfxItemState::DONTCARE )
  {
      if( rAttrs->Get( XATTR_LINESTARTCENTER ).GetValue() )
          m_xTsbCenterStart->set_state(TRISTATE_TRUE);
      else
          m_xTsbCenterStart->set_state(TRISTATE_FALSE);
  }
  else
  {
      m_xTsbCenterStart->set_state(TRISTATE_INDET);
  }

  // Centered line end (end)
  if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINEENDCENTER ) == SfxItemState::DEFAULT )
  {
      m_xTsbCenterEnd->set_sensitive(false);
  }
  else if( rAttrs->GetItemState( XATTR_LINEENDCENTER ) != SfxItemState::DONTCARE )
  {
      if( rAttrs->Get( XATTR_LINEENDCENTER ).GetValue() )
          m_xTsbCenterEnd->set_state(TRISTATE_TRUE);
      else
          m_xTsbCenterEnd->set_state(TRISTATE_FALSE);
  }
  else
  {
      m_xTsbCenterEnd->set_state(TRISTATE_INDET);
  }

  // Transparency
  if( rAttrs->GetItemState( XATTR_LINETRANSPARENCE ) != SfxItemState::DONTCARE )
  {
      sal_uInt16 nTransp = rAttrs->Get( XATTR_LINETRANSPARENCE ).GetValue();
      m_xMtrTransparent->set_value(nTransp, FieldUnit::PERCENT);
      ChangeTransparentHdl_Impl(*m_xMtrTransparent);
  }
  else
      m_xMtrTransparent->set_text( "" );

  if( !m_xLbStartStyle->get_sensitive()  &&
      !m_xLbEndStyle->get_sensitive()    &&
      !m_xMtrStartWidth->get_sensitive() &&
      !m_xMtrEndWidth->get_sensitive()   &&
      !m_xTsbCenterStart->get_sensitive()&&
      !m_xTsbCenterEnd->get_sensitive() )
  {
      m_xCbxSynchronize->set_sensitive(false);
      m_xFlLineEnds->set_sensitive(false);
  }

  // Synchronize
  // We get the value from the INI file now
  OUString aStr = GetUserData();
  m_xCbxSynchronize->set_active(aStr.toInt32() != 0);

  if(m_bObjSelected && SfxItemState::DEFAULT == rAttrs->GetItemState(XATTR_LINEJOINT))
  {
1117//         maFTEdgeStyle.set_sensitive(false);
      m_xLBEdgeStyle->set_sensitive(false);
  }
  else if(SfxItemState::DONTCARE != rAttrs->GetItemState(XATTR_LINEJOINT))
  {
      const css::drawing::LineJoint eLineJoint = rAttrs->Get(XATTR_LINEJOINT).GetValue();

      switch(eLineJoint)
      {
          case css::drawing::LineJoint::LineJoint_MAKE_FIXED_SIZE: // fallback to round, unused value
          case css::drawing::LineJoint_ROUND : m_xLBEdgeStyle->set_active(0); break;
          case css::drawing::LineJoint_NONE : m_xLBEdgeStyle->set_active(1); break;
          case css::drawing::LineJoint_MIDDLE : // fallback to mitre, unused value
          case css::drawing::LineJoint_MITER : m_xLBEdgeStyle->set_active(2); break;
          case css::drawing::LineJoint_BEVEL : m_xLBEdgeStyle->set_active(3); break;
      }
  }
  else
  {
      m_xLBEdgeStyle->set_active(-1);
  }

  // fdo#43209
  if(m_bObjSelected && SfxItemState::DEFAULT == rAttrs->GetItemState(XATTR_LINECAP))
  {
      m_xLBCapStyle->set_sensitive(false);
  }
  else if(SfxItemState::DONTCARE != rAttrs->GetItemState(XATTR_LINECAP))
  {
      const css::drawing::LineCap eLineCap(rAttrs->Get(XATTR_LINECAP).GetValue());

      switch(eLineCap)
      {
          case css::drawing::LineCap_ROUND: m_xLBCapStyle->set_active(1); break;
          case css::drawing::LineCap_SQUARE : m_xLBCapStyle->set_active(2); break;
          default /*css::drawing::LineCap_BUTT*/: m_xLBCapStyle->set_active(0); break;
      }
  }
  else
  {
      m_xLBCapStyle->set_active(-1);
  }

  // Save values
  m_xLbLineStyle->save_value();
  m_xMtrLineWidth->save_value();
  m_xLbColor->SaveValue();
  m_xLbStartStyle->save_value();
  m_xLbEndStyle->save_value();
  m_xMtrStartWidth->save_value();
  m_xMtrEndWidth->save_value();
  m_xTsbCenterStart->save_state();
  m_xTsbCenterEnd->save_state();
  m_xMtrTransparent->save_value();

  m_xLBEdgeStyle->save_value();

  // LineCaps
  m_xLBCapStyle->save_value();

  ClickInvisibleHdl_Impl();

  ChangePreviewHdl_Impl( nullptr );
1180}

1182std::unique_ptr<SfxTabPage> SvxLineTabPage::Create(weld::Container* pPage, weld::DialogController* pController,
                                        const SfxItemSet* rAttrs)
1184{
  return std::make_unique<SvxLineTabPage>(pPage, pController, *rAttrs);
1186}

1188IMPL_LINK_NOARG(SvxLineTabPage, ChangePreviewListBoxHdl_Impl, ColorListBox&, void)void SvxLineTabPage::LinkStubChangePreviewListBoxHdl_Impl(void
 * instance, ColorListBox& data) { return static_cast<
SvxLineTabPage *>(instance)->ChangePreviewListBoxHdl_Impl
(data); } void SvxLineTabPage::ChangePreviewListBoxHdl_Impl(__attribute__
 ((unused)) ColorListBox&)
1189{
  ChangePreviewHdl_Impl(nullptr);
1191}

1193IMPL_LINK(SvxLineTabPage, ChangePreviewModifyHdl_Impl, weld::MetricSpinButton&, rEdit, void)void SvxLineTabPage::LinkStubChangePreviewModifyHdl_Impl(void
 * instance, weld::MetricSpinButton& data) { return static_cast
<SvxLineTabPage *>(instance)->ChangePreviewModifyHdl_Impl
(data); } void SvxLineTabPage::ChangePreviewModifyHdl_Impl(weld
::MetricSpinButton& rEdit)
1194{
  ChangePreviewHdl_Impl(&rEdit);
1196}

1198void SvxLineTabPage::ChangePreviewHdl_Impl(const weld::MetricSpinButton* pCntrl)
1199{
  if (pCntrl == m_xMtrLineWidth.get())
  {
      // Line width and start end width
      sal_Int32 nNewLineWidth = GetCoreValue( *m_xMtrLineWidth, m_ePoolUnit );
      if(m_nActLineWidth == -1)
      {
          // Don't initialize yet, get the start value
          const SfxPoolItem* pOld = GetOldItem( m_rXLSet, XATTR_LINEWIDTH );
          sal_Int32 nStartLineWidth = 0;
          if(pOld)
              nStartLineWidth = static_cast<const XLineWidthItem *>(pOld)->GetValue();
          m_nActLineWidth = nStartLineWidth;
      }

      if(m_nActLineWidth != nNewLineWidth)
      {
          // Adapt start/end width
          sal_Int32 nValAct = GetCoreValue( *m_xMtrStartWidth, m_ePoolUnit );
          sal_Int32 nValNew = nValAct + (((nNewLineWidth - m_nActLineWidth) * 15) / 10);
          if(nValNew < 0)
              nValNew = 0;
          SetMetricValue( *m_xMtrStartWidth, nValNew, m_ePoolUnit );

          nValAct = GetCoreValue( *m_xMtrEndWidth, m_ePoolUnit );
          nValNew = nValAct + (((nNewLineWidth - m_nActLineWidth) * 15) / 10);
          if(nValNew < 0)
              nValNew = 0;
          SetMetricValue( *m_xMtrEndWidth, nValNew, m_ePoolUnit );
      }

      // Remember current value
      m_nActLineWidth = nNewLineWidth;
  }

  FillXLSet_Impl();
  m_aCtlPreview.Invalidate();

  // Make transparency accessible accordingly
  if( m_xLbLineStyle->get_active() == 0 ) // invisible
  {
      m_xBoxTransparency->set_sensitive(false);
  }
  else
  {
      m_xBoxTransparency->set_sensitive(true);
  }

  const bool bHasLineStyle = m_xLbLineStyle->get_active() !=0;
  const bool bHasLineStart = m_xLbStartStyle->get_active() != 0;

  m_xBoxStart->set_sensitive(bHasLineStart && bHasLineStyle);

  const bool bHasLineEnd = m_xLbEndStyle->get_active() != 0;

  m_xBoxEnd->set_sensitive(bHasLineEnd && bHasLineStyle);
1255}

1257IMPL_LINK_NOARG(SvxLineTabPage, ChangeStartClickHdl_Impl, weld::Button&, void)void SvxLineTabPage::LinkStubChangeStartClickHdl_Impl(void * instance
, weld::Button& data) { return static_cast<SvxLineTabPage
 *>(instance)->ChangeStartClickHdl_Impl(data); } void SvxLineTabPage
::ChangeStartClickHdl_Impl(__attribute__ ((unused)) weld::Button
&)
1258{
  if (m_xCbxSynchronize->get_active())
      m_xTsbCenterEnd->set_state(m_xTsbCenterStart->get_state());
  ChangePreviewHdl_Impl(nullptr);
1262}

1264IMPL_LINK_NOARG(SvxLineTabPage, ChangeStartListBoxHdl_Impl, weld::ComboBox&, void)void SvxLineTabPage::LinkStubChangeStartListBoxHdl_Impl(void *
 instance, weld::ComboBox& data) { return static_cast<
SvxLineTabPage *>(instance)->ChangeStartListBoxHdl_Impl
(data); } void SvxLineTabPage::ChangeStartListBoxHdl_Impl(__attribute__
 ((unused)) weld::ComboBox&)
1265{
  if (m_xCbxSynchronize->get_active())
      m_xLbEndStyle->set_active(m_xLbStartStyle->get_active());

  ChangePreviewHdl_Impl(nullptr);
1270}

1272IMPL_LINK_NOARG(SvxLineTabPage, ChangeStartModifyHdl_Impl, weld::MetricSpinButton&, void)void SvxLineTabPage::LinkStubChangeStartModifyHdl_Impl(void *
 instance, weld::MetricSpinButton& data) { return static_cast
<SvxLineTabPage *>(instance)->ChangeStartModifyHdl_Impl
(data); } void SvxLineTabPage::ChangeStartModifyHdl_Impl(__attribute__
 ((unused)) weld::MetricSpinButton&)
1273{
  if (m_xCbxSynchronize->get_active())
      m_xMtrEndWidth->set_value(m_xMtrStartWidth->get_value(FieldUnit::NONE), FieldUnit::NONE);

  ChangePreviewHdl_Impl(nullptr);
1278}

1280IMPL_LINK_NOARG(SvxLineTabPage, ChangeEdgeStyleHdl_Impl, weld::ComboBox&, void)void SvxLineTabPage::LinkStubChangeEdgeStyleHdl_Impl(void * instance
, weld::ComboBox& data) { return static_cast<SvxLineTabPage
 *>(instance)->ChangeEdgeStyleHdl_Impl(data); } void SvxLineTabPage
::ChangeEdgeStyleHdl_Impl(__attribute__ ((unused)) weld::ComboBox
&)
1281{
  ChangePreviewHdl_Impl( nullptr );
1283}

1285// fdo#43209
1286IMPL_LINK_NOARG(SvxLineTabPage, ChangeCapStyleHdl_Impl, weld::ComboBox&, void)void SvxLineTabPage::LinkStubChangeCapStyleHdl_Impl(void * instance
, weld::ComboBox& data) { return static_cast<SvxLineTabPage
 *>(instance)->ChangeCapStyleHdl_Impl(data); } void SvxLineTabPage
::ChangeCapStyleHdl_Impl(__attribute__ ((unused)) weld::ComboBox
&)
1287{
  ChangePreviewHdl_Impl( nullptr );
1289}

1291IMPL_LINK_NOARG(SvxLineTabPage, ClickInvisibleHdl_Impl, weld::ComboBox&, void)void SvxLineTabPage::LinkStubClickInvisibleHdl_Impl(void * instance
, weld::ComboBox& data) { return static_cast<SvxLineTabPage
 *>(instance)->ClickInvisibleHdl_Impl(data); } void SvxLineTabPage
::ClickInvisibleHdl_Impl(__attribute__ ((unused)) weld::ComboBox
&)
1292{
  ClickInvisibleHdl_Impl();
1294}

1296void SvxLineTabPage::ClickInvisibleHdl_Impl()
1297{
  if( m_xLbLineStyle->get_active() == 0 ) // invisible
  {
      if(!m_bSymbols)
          m_xBoxColor->set_sensitive(false);

      m_xBoxWidth->set_sensitive(false);

      if( m_xFlLineEnds->get_sensitive() )
      {
          m_xBoxStart->set_sensitive(false);
          m_xBoxArrowStyles->set_sensitive(false);
          m_xGridEdgeCaps->set_sensitive(false);
      }
  }
  else
  {
      m_xBoxColor->set_sensitive(true);
      m_xBoxWidth->set_sensitive(true);

      if (m_xFlLineEnds->get_sensitive())
      {
          m_xBoxArrowStyles->set_sensitive(true);
          m_xGridEdgeCaps->set_sensitive(true);
      }
  }
  ChangePreviewHdl_Impl( nullptr );
1324}

1326IMPL_LINK_NOARG(SvxLineTabPage, ChangeEndClickHdl_Impl, weld::Button&, void)void SvxLineTabPage::LinkStubChangeEndClickHdl_Impl(void * instance
, weld::Button& data) { return static_cast<SvxLineTabPage
 *>(instance)->ChangeEndClickHdl_Impl(data); } void SvxLineTabPage
::ChangeEndClickHdl_Impl(__attribute__ ((unused)) weld::Button
&)
1327{
  if (m_xCbxSynchronize->get_active())
      m_xTsbCenterStart->set_state(m_xTsbCenterEnd->get_state());

  ChangePreviewHdl_Impl(nullptr);
1332}

1334IMPL_LINK_NOARG(SvxLineTabPage, ChangeEndListBoxHdl_Impl, weld::ComboBox&, void)void SvxLineTabPage::LinkStubChangeEndListBoxHdl_Impl(void * instance
, weld::ComboBox& data) { return static_cast<SvxLineTabPage
 *>(instance)->ChangeEndListBoxHdl_Impl(data); } void SvxLineTabPage
::ChangeEndListBoxHdl_Impl(__attribute__ ((unused)) weld::ComboBox
&)
1335{
  if (m_xCbxSynchronize->get_active())
      m_xLbStartStyle->set_active(m_xLbEndStyle->get_active());

  ChangePreviewHdl_Impl(nullptr);
1340}

1342IMPL_LINK_NOARG(SvxLineTabPage, ChangeEndModifyHdl_Impl, weld::MetricSpinButton&, void)void SvxLineTabPage::LinkStubChangeEndModifyHdl_Impl(void * instance
, weld::MetricSpinButton& data) { return static_cast<SvxLineTabPage
 *>(instance)->ChangeEndModifyHdl_Impl(data); } void SvxLineTabPage
::ChangeEndModifyHdl_Impl(__attribute__ ((unused)) weld::MetricSpinButton
&)
1343{
  if (m_xCbxSynchronize->get_active())
      m_xMtrStartWidth->set_value(m_xMtrEndWidth->get_value(FieldUnit::NONE), FieldUnit::NONE);

  ChangePreviewHdl_Impl(nullptr);
1348}

1350IMPL_LINK_NOARG(SvxLineTabPage, ChangeTransparentHdl_Impl, weld::MetricSpinButton&, void)void SvxLineTabPage::LinkStubChangeTransparentHdl_Impl(void *
 instance, weld::MetricSpinButton& data) { return static_cast
<SvxLineTabPage *>(instance)->ChangeTransparentHdl_Impl
(data); } void SvxLineTabPage::ChangeTransparentHdl_Impl(__attribute__
 ((unused)) weld::MetricSpinButton&)
1351{
  sal_uInt16 nVal = m_xMtrTransparent->get_value(FieldUnit::PERCENT);

  m_rXLSet.Put(XLineTransparenceItem(nVal));

  FillXLSet_Impl();

  m_aCtlPreview.Invalidate();
1359}

1361void SvxLineTabPage::FillUserData()
1362{
  // Write the synched value to the INI file
  OUString aStrUserData = OUString::boolean(m_xCbxSynchronize->get_active());
  SetUserData( aStrUserData );
1366}

1368// #58425# Symbols on a list (e.g. StarChart)
1369// Handler for the symbol selection's popup menu (NumMenueButton)
1370// The following link originates from SvxNumOptionsTabPage
1371IMPL_LINK_NOARG(SvxLineTabPage, MenuCreateHdl_Impl, weld::ToggleButton&, void)void SvxLineTabPage::LinkStubMenuCreateHdl_Impl(void * instance
, weld::ToggleButton& data) { return static_cast<SvxLineTabPage
 *>(instance)->MenuCreateHdl_Impl(data); } void SvxLineTabPage
::MenuCreateHdl_Impl(__attribute__ ((unused)) weld::ToggleButton
&)
1
Calling 'SvxLineTabPage::MenuCreateHdl_Impl'→
1372{
  ScopedVclPtrInstance< VirtualDevice > pVD;
2
←
Calling default constructor for 'ScopedVclPtrInstance<VirtualDevice>'→
4
←
Returning from default constructor for 'ScopedVclPtrInstance<VirtualDevice>'→

  // Initialize popup
  if (!m_xGalleryMenu)
5
←
Taking false branch→
  {
      m_xGalleryMenu = m_xBuilder->weld_menu("gallerysubmenu");
      weld::WaitObject aWait(GetFrameWeld());
      // Get gallery entries
      GalleryExplorer::FillObjList(GALLERY_THEME_BULLETS3, m_aGrfNames);

      sal_uInt32 i = 0;
      for (auto const& grfName : m_aGrfNames)
      {
          const OUString *pUIName = &grfName;

          // Convert URL encodings to UI characters (e.g. %20 for spaces)
          OUString aPhysicalName;
          if (osl::FileBase::getSystemPathFromFileURL(grfName, aPhysicalName)
              == osl::FileBase::E_None)
          {
              pUIName = &aPhysicalName;
          }

          SvxBmpItemInfo* pInfo = new SvxBmpItemInfo;
          pInfo->pBrushItem.reset(new SvxBrushItem(grfName, "", GPOS_AREA, SID_ATTR_BRUSH( 10000 + 1 )));
          pInfo->sItemId = "gallery" + OUString::number(i);
          m_aGalleryBrushItems.emplace_back(pInfo);
          const Graphic* pGraphic = pInfo->pBrushItem->GetGraphic();

          if(pGraphic)
          {
              BitmapEx aBitmap(pGraphic->GetBitmapEx());
              Size aSize(aBitmap.GetSizePixel());
              if(aSize.Width()  > MAX_BMP_WIDTH16 || aSize.Height() > MAX_BMP_HEIGHT16)
              {
                  bool bWidth = aSize.Width() > aSize.Height();
                  double nScale = bWidth ?
                                      double(MAX_BMP_WIDTH16) / static_cast<double>(aSize.Width()):
                                      double(MAX_BMP_HEIGHT16) / static_cast<double>(aSize.Height());
                  aBitmap.Scale(nScale, nScale);

              }
              pVD->SetOutputSizePixel(aBitmap.GetSizePixel());
              pVD->DrawBitmapEx(Point(), aBitmap);
              m_xGalleryMenu->append(pInfo->sItemId, *pUIName, *pVD);
          }
          else
          {
              m_xGalleryMenu->append(pInfo->sItemId, *pUIName);
          }
          ++i;
      }

      if (m_aGrfNames.empty())
          m_xSymbolMB->set_item_sensitive("gallery", false);
  }

  if (m_xSymbolsMenu || !m_pSymbolList)
      return;
6
←
Calling implicit destructor for 'ScopedVclPtrInstance<VirtualDevice>'→
7
←
Calling '~ScopedVclPtr'→

  m_xSymbolsMenu = m_xBuilder->weld_menu("symbolssubmenu");
  ScopedVclPtrInstance< VirtualDevice > pVDev;
  pVDev->SetMapMode(MapMode(MapUnit::Map100thMM));
  std::unique_ptr<SdrModel> pModel(
      new SdrModel(nullptr, nullptr, true));
  pModel->GetItemPool().FreezeIdRanges();
  // Page
  SdrPage* pPage = new SdrPage( *pModel, false );
  pPage->SetSize(Size(1000,1000));
  pModel->InsertPage( pPage, 0 );
  {
      // 3D View
      std::unique_ptr<SdrView> pView(new SdrView( *pModel, pVDev ));
      pView->hideMarkHandles();
      pView->ShowSdrPage(pPage);

      // Generate invisible square to give all symbols a
      // bitmap size, which is independent from specific glyph
      SdrObject *pInvisibleSquare=m_pSymbolList->GetObj(0);

      // directly clone to target SdrModel
      pInvisibleSquare = pInvisibleSquare->CloneSdrObject(*pModel);

      pPage->NbcInsertObject(pInvisibleSquare);
      pInvisibleSquare->SetMergedItem(XFillTransparenceItem(100));
      pInvisibleSquare->SetMergedItem(XLineTransparenceItem(100));

      for(size_t i=0; i < m_pSymbolList->GetObjCount(); ++i)
      {
          SdrObject *pObj=m_pSymbolList->GetObj(i);
          assert(pObj)(static_cast <bool> (pObj) ? void (0) : __assert_fail (
"pObj", "/home/maarten/src/libreoffice/core/cui/source/tabpages/tpline.cxx"
, 1463, __extension__ __PRETTY_FUNCTION__));

          // directly clone to target SdrModel
          pObj = pObj->CloneSdrObject(*pModel);

          m_aGrfNames.emplace_back("");
          pPage->NbcInsertObject(pObj);
          if(m_pSymbolAttr)
          {
              pObj->SetMergedItemSet(*m_pSymbolAttr);
          }
          else
          {
              pObj->SetMergedItemSet(m_rOutAttrs);
          }
          pView->MarkAll();
          BitmapEx aBitmapEx(pView->GetMarkedObjBitmapEx());
          GDIMetaFile aMeta(pView->GetMarkedObjMetaFile());
          pView->UnmarkAll();
          pObj=pPage->RemoveObject(1);
          SdrObject::Free(pObj);

          SvxBmpItemInfo* pInfo = new SvxBmpItemInfo;
          pInfo->pBrushItem.reset(new SvxBrushItem(Graphic(aMeta), GPOS_AREA, SID_ATTR_BRUSH( 10000 + 1 )));
          pInfo->sItemId = "symbol" + OUString::number(i);
          m_aSymbolBrushItems.emplace_back(pInfo);

          Size aSize(aBitmapEx.GetSizePixel());
          if(aSize.Width() > MAX_BMP_WIDTH16 || aSize.Height() > MAX_BMP_HEIGHT16)
          {
              bool bWidth = aSize.Width() > aSize.Height();
              double nScale = bWidth ?
                                  double(MAX_BMP_WIDTH16) / static_cast<double>(aSize.Width()):
                                  double(MAX_BMP_HEIGHT16) / static_cast<double>(aSize.Height());
              aBitmapEx.Scale(nScale, nScale);
          }
          pVD->SetOutputSizePixel(aBitmapEx.GetSizePixel());
          pVD->DrawBitmapEx(Point(), aBitmapEx);
          m_xSymbolsMenu->append(pInfo->sItemId, "", *pVD);
      }
      pInvisibleSquare=pPage->RemoveObject(0);
      SdrObject::Free(pInvisibleSquare);

      if (m_aGrfNames.empty())
          m_xSymbolMB->set_item_sensitive("symbols", false);
  }
1509}

1511// #58425# Symbols on a list (e.g. StarChart)
1512// Handler for menu button
1513IMPL_LINK(SvxLineTabPage, GraphicHdl_Impl, const OString&, rIdent, void)void SvxLineTabPage::LinkStubGraphicHdl_Impl(void * instance,
 const OString& data) { return static_cast<SvxLineTabPage
 *>(instance)->GraphicHdl_Impl(data); } void SvxLineTabPage
::GraphicHdl_Impl(const OString& rIdent)
1514{
  const Graphic* pGraphic = nullptr;
  Graphic aGraphic;
  bool bResetSize = false;
  bool bEnable = true;
  long nPreviousSymbolType = m_nSymbolType;

  OString sNumber;
  if (rIdent.startsWith("gallery", &sNumber))
  {
      SvxBmpItemInfo* pInfo = m_aGalleryBrushItems[sNumber.toUInt32()].get();
      pGraphic = pInfo->pBrushItem->GetGraphic();
      m_nSymbolType = SVX_SYMBOLTYPE_BRUSHITEM(-1);
  }
  else if (rIdent.startsWith("symbol", &sNumber))
  {
      m_nSymbolType = sNumber.toUInt32();
      SvxBmpItemInfo* pInfo = m_aSymbolBrushItems[m_nSymbolType].get();
      pGraphic = pInfo->pBrushItem->GetGraphic();
  }
  else if (rIdent == "automatic")
  {
      pGraphic=&m_aAutoSymbolGraphic;
      m_aAutoSymbolGraphic.SetPrefSize( Size(253,253) );
      m_nSymbolType=SVX_SYMBOLTYPE_AUTO(-2);
  }
  else if (rIdent == "none")
  {
      m_nSymbolType=SVX_SYMBOLTYPE_NONE(-3);
      pGraphic=nullptr;
      bEnable = false;
  }
  else if (rIdent == "file")
  {
      SvxOpenGraphicDialog aGrfDlg(CuiResId(RID_SVXSTR_EDIT_GRAPHICreinterpret_cast<char const *>("RID_SVXSTR_EDIT_GRAPHIC"
 "\004" u8"Link")), GetFrameWeld());
      aGrfDlg.EnableLink(false);
      aGrfDlg.AsLink(false);
      if( !aGrfDlg.Execute() )
      {
          // Remember selected filters
          if( !aGrfDlg.GetGraphic(aGraphic) )
          {
              m_nSymbolType=SVX_SYMBOLTYPE_BRUSHITEM(-1);
              pGraphic = &aGraphic;
              bResetSize = true;
          }
      }
      if( !pGraphic )
          return;
  }

  if (pGraphic)
  {
      Size aSize = SvxNumberFormat::GetGraphicSizeMM100(pGraphic);
      aSize = OutputDevice::LogicToLogic(aSize, MapMode(MapUnit::Map100thMM), MapMode(m_ePoolUnit));
      m_aSymbolGraphic=*pGraphic;
      if( bResetSize )
      {
          m_aSymbolSize=aSize;
      }
      else if( nPreviousSymbolType == SVX_SYMBOLTYPE_BRUSHITEM(-1) )
      {   //#i31097# Data Point Symbol size changes when a different symbol is chosen(maoyg)
          if( m_aSymbolSize.Width() != m_aSymbolSize.Height() )
          {
              aSize.setWidth( static_cast<long>( m_aSymbolSize.Width() + m_aSymbolSize.Height() )/2 );
              aSize.setHeight( static_cast<long>( m_aSymbolSize.Width() + m_aSymbolSize.Height() )/2 );
              m_aSymbolSize = aSize;
          }
      }
      m_aCtlPreview.SetSymbol(&m_aSymbolGraphic,m_aSymbolSize);
  }
  else
  {
      m_aSymbolGraphic=Graphic();
      m_aCtlPreview.SetSymbol(nullptr,m_aSymbolSize);
      bEnable = false;
  }
  m_aSymbolLastSize=m_aSymbolSize;
  SetMetricValue(*m_xSymbolWidthMF,  m_aSymbolSize.Width(), m_ePoolUnit);
  SetMetricValue(*m_xSymbolHeightMF, m_aSymbolSize.Height(), m_ePoolUnit);

  m_xGridIconSize->set_sensitive(bEnable);
  m_aCtlPreview.Invalidate();
1597}

1599IMPL_LINK( SvxLineTabPage, SizeHdl_Impl, weld::MetricSpinButton&, rField, void)void SvxLineTabPage::LinkStubSizeHdl_Impl(void * instance, weld
::MetricSpinButton& data) { return static_cast<SvxLineTabPage
 *>(instance)->SizeHdl_Impl(data); } void SvxLineTabPage
::SizeHdl_Impl(weld::MetricSpinButton& rField)
1600{
  m_bNewSize = true;
  bool bWidth = &rField == m_xSymbolWidthMF.get();
  m_bLastWidthModified = bWidth;
  bool bRatio = m_xSymbolRatioCB->get_active();
  long nWidthVal = static_cast<long>(m_xSymbolWidthMF->denormalize(m_xSymbolWidthMF->get_value(FieldUnit::MM_100TH)));
  long nHeightVal= static_cast<long>(m_xSymbolHeightMF->denormalize(m_xSymbolHeightMF->get_value(FieldUnit::MM_100TH)));
  nWidthVal = OutputDevice::LogicToLogic(nWidthVal,MapUnit::Map100thMM, m_ePoolUnit );
  nHeightVal = OutputDevice::LogicToLogic(nHeightVal,MapUnit::Map100thMM, m_ePoolUnit);
  m_aSymbolSize = Size(nWidthVal,nHeightVal);
  double fSizeRatio = double(1);

  if(bRatio)
  {
      if (m_aSymbolLastSize.Height() && m_aSymbolLastSize.Width())
          fSizeRatio = static_cast<double>(m_aSymbolLastSize.Width()) / m_aSymbolLastSize.Height();
  }

  if (bWidth)
  {
      long nDelta = nWidthVal - m_aSymbolLastSize.Width();
      m_aSymbolSize.setWidth( nWidthVal );
      if (bRatio)
      {
          m_aSymbolSize.setHeight( m_aSymbolLastSize.Height() + static_cast<long>(static_cast<double>(nDelta) / fSizeRatio) );
          m_aSymbolSize.setHeight( OutputDevice::LogicToLogic( m_aSymbolSize.Height(), m_ePoolUnit, MapUnit::Map100thMM ) );
1626//TODO            m_xSymbolHeightMF->SetUserValue(m_xSymbolHeightMF->normalize(m_aSymbolSize.Height()), FieldUnit::MM_100TH);
          m_xSymbolHeightMF->set_value(m_xSymbolHeightMF->normalize(m_aSymbolSize.Height()), FieldUnit::MM_100TH);
      }
  }
  else
  {
      long nDelta = nHeightVal - m_aSymbolLastSize.Height();
      m_aSymbolSize.setHeight( nHeightVal );
      if (bRatio)
      {
          m_aSymbolSize.setWidth( m_aSymbolLastSize.Width() + static_cast<long>(static_cast<double>(nDelta) * fSizeRatio) );
          m_aSymbolSize.setWidth( OutputDevice::LogicToLogic( m_aSymbolSize.Width(), m_ePoolUnit, MapUnit::Map100thMM ) );
1638//TODO            m_xSymbolWidthMF->SetUserValue(m_xSymbolWidthMF->normalize(m_aSymbolSize.Width()), FieldUnit::MM_100TH);
          m_xSymbolWidthMF->set_value(m_xSymbolWidthMF->normalize(m_aSymbolSize.Width()), FieldUnit::MM_100TH);
      }
  }
  m_aCtlPreview.ResizeSymbol(m_aSymbolSize);
  m_aSymbolLastSize=m_aSymbolSize;
1644}

1646IMPL_LINK(SvxLineTabPage, RatioHdl_Impl, weld::ToggleButton&, rBox, void)void SvxLineTabPage::LinkStubRatioHdl_Impl(void * instance, weld
::ToggleButton& data) { return static_cast<SvxLineTabPage
 *>(instance)->RatioHdl_Impl(data); } void SvxLineTabPage
::RatioHdl_Impl(weld::ToggleButton& rBox)
1647{
  if (rBox.get_active())
  {
      if (m_bLastWidthModified)
          SizeHdl_Impl(*m_xSymbolWidthMF);
      else
          SizeHdl_Impl(*m_xSymbolHeightMF);
  }
1655}

1657void SvxLineTabPage::PageCreated(const SfxAllItemSet& aSet)
1658{
  const SvxDashListItem* pDashListItem = aSet.GetItem<SvxDashListItem>(SID_DASH_LISTTypedWhichId<SvxDashListItem>( 10000 + 184 ), false);
  const SvxLineEndListItem* pLineEndListItem = aSet.GetItem<SvxLineEndListItem>(SID_LINEEND_LISTTypedWhichId<SvxLineEndListItem>( 10000 + 185 ), false);
  const SfxUInt16Item* pPageTypeItem = aSet.GetItem<SfxUInt16Item>(SID_PAGE_TYPE( 10000 + 1017 ), false);
  const SfxUInt16Item* pDlgTypeItem = aSet.GetItem<SfxUInt16Item>(SID_DLG_TYPE( 10000 + 1018 ), false);
  const OfaPtrItem* pSdrObjListItem = aSet.GetItem<OfaPtrItem>(SID_OBJECT_LIST( 10000 + 1021 ), false);
  const SfxTabDialogItem* pSymbolAttrItem = aSet.GetItem<SfxTabDialogItem>(SID_ATTR_SET( 10000 + 1022 ), false);
  const SvxGraphicItem* pGraphicItem = aSet.GetItem<SvxGraphicItem>(SID_GRAPHIC( 10000 + 1020 ), false);

  if (pDashListItem)
      SetDashList(pDashListItem->GetDashList());
  if (pLineEndListItem)
      SetLineEndList(pLineEndListItem->GetLineEndList());
  if (pPageTypeItem)
      SetPageType(static_cast<PageType>(pPageTypeItem->GetValue()));
  if (pDlgTypeItem)
      SetDlgType(pDlgTypeItem->GetValue());
  Construct();

  if(pSdrObjListItem) //symbols
  {
      ShowSymbolControls(true);
      m_pSymbolList = static_cast<SdrObjList*>(pSdrObjListItem->GetValue());
      if (pSymbolAttrItem)
          m_pSymbolAttr = new SfxItemSet(pSymbolAttrItem->GetItemSet());
      if(pGraphicItem)
          m_aAutoSymbolGraphic = pGraphicItem->GetGraphic();
  }
1686}

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

←

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

→

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

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

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

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

36class VclReferenceBase;

38namespace vcl::detail {

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

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

47} // namespace vcl::detail

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

  ::rtl::Reference<reference_type> m_rInnerRef;

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

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

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

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

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

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

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

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

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

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

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

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

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
9
←
Calling 'Reference::clear'→
16
←
Returning; memory was released→
      if (aTmp.get()) {
17
←
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();
8
←
Calling 'VclPtr::disposeAndClear'→
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

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

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

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

  /**
   * 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)
          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_pBody9.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
)
10
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
11
←
Calling 'VclReferenceBase::release'→
15
←
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;
18
←
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)
12
←
Assuming the condition is true→
13
←
Taking true branch→
40            delete this;
14
←
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