/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 checklistmenu.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SC_DLLIMPLEMENTATION -D SC_INFO_OSVERSION="LINUX" -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/liborcus/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/mdds/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/clew/source/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sc/source/core/inc -I /home/maarten/src/libreoffice/core/sc/source/filter/inc -I /home/maarten/src/libreoffice/core/sc/source/ui/inc -I /home/maarten/src/libreoffice/core/sc/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sc/sdi -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sc/source/ui/cctrl/checklistmenu.cxx

/home/maarten/src/libreoffice/core/sc/source/ui/cctrl/checklistmenu.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 <checklistmenu.hxx>
21#include <globstr.hrc>
22#include <scresid.hxx>
23#include <strings.hrc>
24#include <bitmaps.hlst>

26#include <vcl/decoview.hxx>
27#include <vcl/event.hxx>
28#include <vcl/dockwin.hxx>
29#include <vcl/settings.hxx>
30#include <vcl/svapp.hxx>
31#include <vcl/virdev.hxx>
32#include <rtl/math.hxx>
33#include <tools/wintypes.hxx>
34#include <unotools/charclass.hxx>

36#include <document.hxx>

38using namespace com::sun::star;
39using ::com::sun::star::uno::Reference;

41ScCheckListMenuControl::MenuItemData::MenuItemData()
  : mbEnabled(true)
43{
44}

46ScCheckListMenuControl::SubMenuItemData::SubMenuItemData(ScCheckListMenuControl* pParent)
  : mpSubMenu(nullptr)
  , mnMenuPos(MENU_NOT_SELECTED)
  , mpParent(pParent)
50{
  maTimer.SetInvokeHandler(LINK(this, ScCheckListMenuControl::SubMenuItemData, TimeoutHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
::SubMenuItemData *>(this), &ScCheckListMenuControl::SubMenuItemData
::LinkStubTimeoutHdl));
  maTimer.SetTimeout(Application::GetSettings().GetMouseSettings().GetMenuDelay());
53}

55void ScCheckListMenuControl::SubMenuItemData::reset()
56{
  mpSubMenu = nullptr;
  mnMenuPos = MENU_NOT_SELECTED;
  maTimer.Stop();
60}

62IMPL_LINK_NOARG(ScCheckListMenuControl::SubMenuItemData, TimeoutHdl, Timer *, void)void ScCheckListMenuControl::SubMenuItemData::LinkStubTimeoutHdl
(void * instance, Timer * data) { return static_cast<ScCheckListMenuControl
::SubMenuItemData *>(instance)->TimeoutHdl(data); } void
 ScCheckListMenuControl::SubMenuItemData::TimeoutHdl(__attribute__
 ((unused)) Timer *)
63{
  mpParent->handleMenuTimeout(this);
65}

67IMPL_LINK_NOARG(ScCheckListMenuControl, RowActivatedHdl, weld::TreeView&, bool)bool ScCheckListMenuControl::LinkStubRowActivatedHdl(void * instance
, weld::TreeView& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->RowActivatedHdl(data); } bool ScCheckListMenuControl
::RowActivatedHdl(__attribute__ ((unused)) weld::TreeView&
)
68{
  executeMenuItem(mxMenu->get_selected_index());
  return true;
71}

73IMPL_LINK(ScCheckListMenuControl, MenuKeyInputHdl, const KeyEvent&, rKEvt, bool)bool ScCheckListMenuControl::LinkStubMenuKeyInputHdl(void * instance
, const KeyEvent& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->MenuKeyInputHdl(data); } bool ScCheckListMenuControl
::MenuKeyInputHdl(const KeyEvent& rKEvt)
74{
  const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();

  switch (rKeyCode.GetCode())
  {
      case KEY_LEFT:
      {
          ScCheckListMenuWindow* pParentMenu = mxFrame->GetParentMenu();
          if (pParentMenu)
              pParentMenu->get_widget().endSubMenu(*this);
          break;
      }
      case KEY_RIGHT:
      {
          if (mnSelectedMenu >= maMenuItems.size() || mnSelectedMenu == MENU_NOT_SELECTED)
              break;

          const MenuItemData& rMenu = maMenuItems[mnSelectedMenu];
          if (!rMenu.mbEnabled || !rMenu.mxSubMenuWin)
              break;

          maOpenTimer.mnMenuPos = mnSelectedMenu;
          maOpenTimer.mpSubMenu = rMenu.mxSubMenuWin.get();
          launchSubMenu(true);
      }
  }

  return false;
102}

104IMPL_LINK_NOARG(ScCheckListMenuControl, SelectHdl, weld::TreeView&, void)void ScCheckListMenuControl::LinkStubSelectHdl(void * instance
, weld::TreeView& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->SelectHdl(data); } void ScCheckListMenuControl
::SelectHdl(__attribute__ ((unused)) weld::TreeView&)
105{
  sal_uInt32 nSelectedMenu = MENU_NOT_SELECTED;
  if (!mxMenu->get_selected(mxScratchIter.get()))
  {
      // reselect current item if its submenu is up and the launching item
      // became unselected
      if (mnSelectedMenu < maMenuItems.size() &&
          maMenuItems[mnSelectedMenu].mxSubMenuWin &&
          maMenuItems[mnSelectedMenu].mxSubMenuWin->IsVisible())
      {
          mxMenu->select(mnSelectedMenu);
          return;
      }
  }
  else
      nSelectedMenu = mxMenu->get_iter_index_in_parent(*mxScratchIter);

  setSelectedMenuItem(nSelectedMenu, true);
123}

125void ScCheckListMenuControl::addMenuItem(const OUString& rText, Action* pAction)
126{
  MenuItemData aItem;
  aItem.mbEnabled = true;
  aItem.mxAction.reset(pAction);
  maMenuItems.emplace_back(std::move(aItem));

  mxMenu->append_text(rText);
  if (mbCanHaveSubMenu)
      mxMenu->set_image(mxMenu->n_children() - 1, css::uno::Reference<css::graphic::XGraphic>(), 1);
135}

137void ScCheckListMenuControl::addSeparator()
138{
  MenuItemData aItem;
  maMenuItems.emplace_back(std::move(aItem));

  mxMenu->append_separator("separator" + OUString::number(maMenuItems.size()));
143}

145IMPL_LINK(ScCheckListMenuControl, TreeSizeAllocHdl, const Size&, rSize, void)void ScCheckListMenuControl::LinkStubTreeSizeAllocHdl(void * instance
, const Size& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->TreeSizeAllocHdl(data); } void ScCheckListMenuControl
::TreeSizeAllocHdl(const Size& rSize)
146{
  assert(mbCanHaveSubMenu)(static_cast <bool> (mbCanHaveSubMenu) ? void (0) : __assert_fail
 ("mbCanHaveSubMenu", "/home/maarten/src/libreoffice/core/sc/source/ui/cctrl/checklistmenu.cxx"
, 147, __extension__ __PRETTY_FUNCTION__));
  std::vector<int> aWidths;
  aWidths.push_back(rSize.Width() - (mxMenu->get_text_height() * 3) / 4 - 6);
  mxMenu->set_column_fixed_widths(aWidths);
151}

153void ScCheckListMenuControl::CreateDropDown()
154{
  int nWidth = (mxMenu->get_text_height() * 3) / 4;
  mxDropDown->SetOutputSizePixel(Size(nWidth, nWidth));
  DecorationView aDecoView(mxDropDown.get());
  aDecoView.DrawSymbol(tools::Rectangle(Point(0, 0), Size(nWidth, nWidth)),
                       SymbolType::SPIN_RIGHT, mxDropDown->GetTextColor(),
                       DrawSymbolFlags::NONE);
161}

163ScCheckListMenuWindow* ScCheckListMenuControl::addSubMenuItem(const OUString& rText, bool bEnabled)
164{
  assert(mbCanHaveSubMenu)(static_cast <bool> (mbCanHaveSubMenu) ? void (0) : __assert_fail
 ("mbCanHaveSubMenu", "/home/maarten/src/libreoffice/core/sc/source/ui/cctrl/checklistmenu.cxx"
, 165, __extension__ __PRETTY_FUNCTION__));

  MenuItemData aItem;
  aItem.mbEnabled = bEnabled;
  vcl::Window *pContainer = mxFrame->GetWindow(GetWindowType::FirstChild);
  aItem.mxSubMenuWin.reset(VclPtr<ScCheckListMenuWindow>::Create(pContainer, mpDoc, false,
                                                                 false, -1, mxFrame.get()));
  maMenuItems.emplace_back(std::move(aItem));

  mxMenu->append_text(rText);
  if (mbCanHaveSubMenu)
      mxMenu->set_image(mxMenu->n_children() - 1, *mxDropDown, 1);

  return maMenuItems.back().mxSubMenuWin.get();
179}

181void ScCheckListMenuControl::executeMenuItem(size_t nPos)
182{
  if (nPos >= maMenuItems.size())
      return;

  if (!maMenuItems[nPos].mxAction)
      // no action is defined.
      return;

  terminateAllPopupMenus();

  maMenuItems[nPos].mxAction->execute();
193}

195void ScCheckListMenuControl::setSelectedMenuItem(size_t nPos, bool bSubMenuTimer)
196{
  if (mnSelectedMenu == nPos)
      // nothing to do.
      return;

  selectMenuItem(nPos, bSubMenuTimer);
202}

204void ScCheckListMenuControl::handleMenuTimeout(const SubMenuItemData* pTimer)
205{
  if (pTimer == &maOpenTimer)
  {
      // Close any open submenu immediately.
      if (maCloseTimer.mpSubMenu)
      {
          vcl::Window::GetDockingManager()->EndPopupMode(maCloseTimer.mpSubMenu);
          maCloseTimer.mpSubMenu = nullptr;
          maCloseTimer.maTimer.Stop();
      }

      launchSubMenu(false);
  }
  else if (pTimer == &maCloseTimer)
  {
      // end submenu.
      if (maCloseTimer.mpSubMenu)
      {
          maOpenTimer.mpSubMenu = nullptr;

          vcl::Window::GetDockingManager()->EndPopupMode(maCloseTimer.mpSubMenu);
          maCloseTimer.mpSubMenu = nullptr;

          maOpenTimer.mnMenuPos = MENU_NOT_SELECTED;
      }
  }
231}

233void ScCheckListMenuControl::queueLaunchSubMenu(size_t nPos, ScCheckListMenuWindow* pMenu)
234{
  if (!pMenu)
      return;

  // Set the submenu on launch queue.
  if (maOpenTimer.mpSubMenu)
  {
      if (maOpenTimer.mpSubMenu == pMenu)
      {
          if (pMenu == maCloseTimer.mpSubMenu)
              maCloseTimer.reset();
          return;
      }

      // new submenu is being requested.
      queueCloseSubMenu();
  }

  maOpenTimer.mpSubMenu = pMenu;
  maOpenTimer.mnMenuPos = nPos;
  maOpenTimer.maTimer.Start();
255}

257void ScCheckListMenuControl::queueCloseSubMenu()
258{
  if (!maOpenTimer.mpSubMenu)
      // There is no submenu to close.
      return;

  // Stop any submenu on queue for opening.
  maOpenTimer.maTimer.Stop();

  maCloseTimer.mpSubMenu = maOpenTimer.mpSubMenu;
  maCloseTimer.mnMenuPos = maOpenTimer.mnMenuPos;
  maCloseTimer.maTimer.Start();
269}

271void ScCheckListMenuControl::launchSubMenu(bool bSetMenuPos)
272{
  ScCheckListMenuWindow* pSubMenu = maOpenTimer.mpSubMenu;
  if (!pSubMenu)
      return;

  if (!mxMenu->get_selected(mxScratchIter.get()))
      return;

  tools::Rectangle aRect = mxMenu->get_row_area(*mxScratchIter);
  ScCheckListMenuControl& rSubMenuControl = pSubMenu->get_widget();
  rSubMenuControl.StartPopupMode(aRect, FloatWinPopupFlags::Right);
  if (bSetMenuPos)
      rSubMenuControl.setSelectedMenuItem(0, false); // select menu item after the popup becomes fully visible.

  mxMenu->select(*mxScratchIter);
  rSubMenuControl.GrabFocus();
288}

290IMPL_LINK_NOARG(ScCheckListMenuControl, PostPopdownHdl, void*, void)void ScCheckListMenuControl::LinkStubPostPopdownHdl(void * instance
, void* data) { return static_cast<ScCheckListMenuControl *
>(instance)->PostPopdownHdl(data); } void ScCheckListMenuControl
::PostPopdownHdl(__attribute__ ((unused)) void*)
291{
  mnAsyncPostPopdownId = nullptr;
  mxMenu->grab_focus();
294}

296void ScCheckListMenuControl::endSubMenu(ScCheckListMenuControl& rSubMenu)
297{
  rSubMenu.EndPopupMode();
  maOpenTimer.reset();

  // EndPopup sends a user event, and we want this focus to be set after that has done its conflicting focus-setting work
  if (!mnAsyncPostPopdownId)
      mnAsyncPostPopdownId = Application::PostUserEvent(LINK(this, ScCheckListMenuControl, PostPopdownHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubPostPopdownHdl
));

  size_t nMenuPos = getSubMenuPos(&rSubMenu);
  if (nMenuPos != MENU_NOT_SELECTED)
  {
      mnSelectedMenu = nMenuPos;
      mxMenu->select(mnSelectedMenu);
  }
311}

313void ScCheckListMenuControl::resizeToFitMenuItems()
314{
  mxMenu->set_size_request(-1, mxMenu->get_preferred_size().Height() + 2);
316}

318void ScCheckListMenuControl::selectMenuItem(size_t nPos, bool bSubMenuTimer)
319{
  mxMenu->select(nPos == MENU_NOT_SELECTED ? -1 : nPos);
  mnSelectedMenu = nPos;

  if (nPos >= maMenuItems.size() || nPos == MENU_NOT_SELECTED)
  {
      queueCloseSubMenu();
      return;
  }

  if (!maMenuItems[nPos].mbEnabled)
  {
      queueCloseSubMenu();
      return;
  }

  ScCheckListMenuWindow* pParentMenu = mxFrame->GetParentMenu();
  if (pParentMenu)
      pParentMenu->get_widget().setSubMenuFocused(this);

  if (bSubMenuTimer)
  {
      if (maMenuItems[nPos].mxSubMenuWin)
      {
          ScCheckListMenuWindow* pSubMenu = maMenuItems[nPos].mxSubMenuWin.get();
          queueLaunchSubMenu(nPos, pSubMenu);
      }
      else
          queueCloseSubMenu();
  }
349}

351void ScCheckListMenuControl::clearSelectedMenuItem()
352{
  selectMenuItem(MENU_NOT_SELECTED, false);
354}

356size_t ScCheckListMenuControl::getSubMenuPos(const ScCheckListMenuControl* pSubMenu)
357{
  size_t n = maMenuItems.size();
  for (size_t i = 0; i < n; ++i)
  {
      if (!maMenuItems[i].mxSubMenuWin)
          continue;
      if (&maMenuItems[i].mxSubMenuWin->get_widget() == pSubMenu)
          return i;
  }
  return MENU_NOT_SELECTED;
367}

369void ScCheckListMenuControl::setSubMenuFocused(const ScCheckListMenuControl* pSubMenu)
370{
  maCloseTimer.reset();
  size_t nMenuPos = getSubMenuPos(pSubMenu);
  if (mnSelectedMenu != nMenuPos)
  {
      mnSelectedMenu = nMenuPos;
      mxMenu->select(mnSelectedMenu);
  }
378}

380void ScCheckListMenuControl::EndPopupMode()
381{
  vcl::Window::GetDockingManager()->EndPopupMode(mxFrame);
  mxFrame->EnableDocking(false);
384}

386void ScCheckListMenuControl::StartPopupMode(const tools::Rectangle& rRect, FloatWinPopupFlags eFlags)
387{
  mxFrame->EnableDocking(true);
  DockingManager* pDockingManager = vcl::Window::GetDockingManager();
  pDockingManager->SetPopupModeEndHdl(mxFrame, LINK(this, ScCheckListMenuControl, PopupModeEndHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubPopupModeEndHdl
));
  pDockingManager->StartPopupMode(mxFrame, rRect, (eFlags | FloatWinPopupFlags::GrabFocus));
392}

394void ScCheckListMenuControl::terminateAllPopupMenus()
395{
  EndPopupMode();
  ScCheckListMenuWindow* pParentMenu = mxFrame->GetParentMenu();
  if (pParentMenu)
      pParentMenu->get_widget().terminateAllPopupMenus();
400}

402ScCheckListMenuControl::Config::Config() :
  mbAllowEmptySet(true), mbRTL(false)
404{
405}

407ScCheckListMember::ScCheckListMember()
  : mbVisible(true)
  , mbDate(false)
  , mbLeaf(false)
  , meDatePartType(YEAR)
412{
413}

415ScCheckListMenuControl::ScCheckListMenuControl(ScCheckListMenuWindow* pParent, vcl::Window* pContainer,
                                             ScDocument* pDoc, bool bCanHaveSubMenu,
                                             bool bHasDates, int nWidth)
  : mxFrame(pParent)
  , mxBuilder(Application::CreateInterimBuilder(pContainer, "modules/scalc/ui/filterdropdown.ui", false))
  , mxContainer(mxBuilder->weld_container("FilterDropDown"))
  , mxMenu(mxBuilder->weld_tree_view("menu"))
  , mxScratchIter(mxMenu->make_iterator())
  , mxEdSearch(mxBuilder->weld_entry("search_edit"))
  , mxBox(mxBuilder->weld_widget("box"))
  , mxListChecks(mxBuilder->weld_tree_view("check_list_box"))
  , mxTreeChecks(mxBuilder->weld_tree_view("check_tree_box"))
  , mxChkToggleAll(mxBuilder->weld_check_button("toggle_all"))
  , mxBtnSelectSingle(mxBuilder->weld_button("select_current"))
  , mxBtnUnselectSingle(mxBuilder->weld_button("unselect_current"))
  , mxButtonBox(mxBuilder->weld_box("buttonbox"))
  , mxBtnOk(mxBuilder->weld_button("ok"))
  , mxBtnCancel(mxBuilder->weld_button("cancel"))
  , mxDropDown(mxMenu->create_virtual_device())
  , mnCheckWidthReq(-1)
  , mnWndWidth(0)
  , mePrevToggleAllState(TRISTATE_INDET)
  , mnSelectedMenu(MENU_NOT_SELECTED)
  , mpDoc(pDoc)
  , mnAsyncPostPopdownId(nullptr)
  , mbHasDates(bHasDates)
  , mbCanHaveSubMenu(bCanHaveSubMenu)
  , maOpenTimer(this)
  , maCloseTimer(this)
444{
  /*
     tdf#136559 If we have no dates we don't need a tree
     structure, just a list. GtkListStore can be then
     used which is much faster than a GtkTreeStore, so
     with no dates switch to the treeview which uses the
     faster GtkListStore
  */
  if (mbHasDates)
      mpChecks = mxTreeChecks.get();
  else
  {
      mxTreeChecks->hide();
      mxListChecks->show();
      mpChecks = mxListChecks.get();
  }

  bool bIsSubMenu = pParent->GetParentMenu();

  int nChecksHeight = mxTreeChecks->get_height_rows(9);
  if (!bIsSubMenu && nWidth != -1)
  {
      mnCheckWidthReq = nWidth - mxFrame->get_border_width() * 2 - 4;
      mxTreeChecks->set_size_request(mnCheckWidthReq, nChecksHeight);
      mxListChecks->set_size_request(mnCheckWidthReq, nChecksHeight);
  }

  // sort ok/cancel into native order, if this was a dialog they would be auto-sorted, but this
  // popup isn't a true dialog
  mxButtonBox->sort_native_button_order();

  if (!bIsSubMenu)
  {
      mxTreeChecks->enable_toggle_buttons(weld::ColumnToggleType::Check);
      mxListChecks->enable_toggle_buttons(weld::ColumnToggleType::Check);

      mxBox->show();
      mxEdSearch->show();
      mxButtonBox->show();
  }

  mxContainer->connect_focus_in(LINK(this, ScCheckListMenuControl, FocusHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubFocusHdl));
  mxMenu->connect_row_activated(LINK(this, ScCheckListMenuControl, RowActivatedHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubRowActivatedHdl
));
  mxMenu->connect_changed(LINK(this, ScCheckListMenuControl, SelectHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubSelectHdl));
  mxMenu->connect_key_press(LINK(this, ScCheckListMenuControl, MenuKeyInputHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubMenuKeyInputHdl
));

  if (!bIsSubMenu)
  {
      mxBtnOk->connect_clicked(LINK(this, ScCheckListMenuControl, ButtonHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubButtonHdl));
      mxBtnCancel->connect_clicked(LINK(this, ScCheckListMenuControl, ButtonHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubButtonHdl));
      mxEdSearch->connect_changed(LINK(this, ScCheckListMenuControl, EdModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubEdModifyHdl
));
      mxEdSearch->connect_activate(LINK(this, ScCheckListMenuControl, EdActivateHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubEdActivateHdl
));
      mxTreeChecks->connect_toggled(LINK(this, ScCheckListMenuControl, CheckHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubCheckHdl));
      mxTreeChecks->connect_key_press(LINK(this, ScCheckListMenuControl, KeyInputHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubKeyInputHdl
));
      mxListChecks->connect_toggled(LINK(this, ScCheckListMenuControl, CheckHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubCheckHdl));
      mxListChecks->connect_key_press(LINK(this, ScCheckListMenuControl, KeyInputHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubKeyInputHdl
));
      mxChkToggleAll->connect_toggled(LINK(this, ScCheckListMenuControl, TriStateHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubTriStateHdl
));
      mxBtnSelectSingle->connect_clicked(LINK(this, ScCheckListMenuControl, ButtonHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubButtonHdl));
      mxBtnUnselectSingle->connect_clicked(LINK(this, ScCheckListMenuControl, ButtonHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubButtonHdl));
  }

  if (mbCanHaveSubMenu)
  {
      CreateDropDown();
      mxMenu->connect_size_allocate(LINK(this, ScCheckListMenuControl, TreeSizeAllocHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScCheckListMenuControl
 *>(this), &ScCheckListMenuControl::LinkStubTreeSizeAllocHdl
));
  }

  if (!bIsSubMenu)
  {
      // determine what width the checklist will end up with
      mnCheckWidthReq = mxContainer->get_preferred_size().Width();
      // make that size fixed now, we can now use mnCheckWidthReq to speed up
      // bulk_insert_for_each
      mxTreeChecks->set_size_request(mnCheckWidthReq, nChecksHeight);
      mxListChecks->set_size_request(mnCheckWidthReq, nChecksHeight);
  }
520}

522IMPL_LINK_NOARG(ScCheckListMenuControl, FocusHdl, weld::Widget&, void)void ScCheckListMenuControl::LinkStubFocusHdl(void * instance
, weld::Widget& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->FocusHdl(data); } void ScCheckListMenuControl
::FocusHdl(__attribute__ ((unused)) weld::Widget&)
523{
  GrabFocus();
525}

527void ScCheckListMenuControl::GrabFocus()
528{
  if (mxEdSearch->get_visible())
      mxEdSearch->grab_focus();
  else
  {
      mxMenu->set_cursor(0);
      mxMenu->grab_focus();
  }
536}

538ScCheckListMenuControl::~ScCheckListMenuControl()
539{
  EndPopupMode();
  for (auto& rMenuItem : maMenuItems)
      rMenuItem.mxSubMenuWin.disposeAndClear();
  if (mnAsyncPostPopdownId)
  {
      Application::RemoveUserEvent(mnAsyncPostPopdownId);
      mnAsyncPostPopdownId = nullptr;
  }
548}

550ScCheckListMenuWindow::ScCheckListMenuWindow(vcl::Window* pParent, ScDocument* pDoc, bool bCanHaveSubMenu,
                                           bool bTreeMode, int nWidth, ScCheckListMenuWindow* pParentMenu)
  : DockingWindow(pParent, "InterimDockParent", "svx/ui/interimdockparent.ui")
  , mxParentMenu(pParentMenu)
  , mxBox(get("box"))
555{
  setDeferredProperties();
  mxControl.reset(new ScCheckListMenuControl(this, mxBox.get(), pDoc, bCanHaveSubMenu, bTreeMode, nWidth));
  SetBackground(Application::GetSettings().GetStyleSettings().GetMenuColor());
  set_id("check_list_menu");
560}

562bool ScCheckListMenuWindow::EventNotify(NotifyEvent& rNEvt)
563{
  if (rNEvt.GetType() == MouseNotifyEvent::MOUSEMOVE)
  {
      ScCheckListMenuControl& rMenuControl = get_widget();
      rMenuControl.queueCloseSubMenu();
      rMenuControl.clearSelectedMenuItem();
  }
  return DockingWindow::EventNotify(rNEvt);
571}

573ScCheckListMenuWindow::~ScCheckListMenuWindow()
574{
  disposeOnce();
576}

578void ScCheckListMenuWindow::dispose()
579{
  mxControl.reset();
  mxBox.disposeAndClear();
1
Calling 'VclPtr::disposeAndClear'→
  mxParentMenu.clear();
  DockingWindow::dispose();
584}

586void ScCheckListMenuWindow::GetFocus()
587{
  DockingWindow::GetFocus();
  if (!mxControl)
      return;
  mxControl->GrabFocus();
592}

594void ScCheckListMenuControl::prepWindow()
595{
  mxMenu->set_size_request(-1, mxMenu->get_preferred_size().Height() + 2);
  mnSelectedMenu = 0;
  mxMenu->set_cursor(mnSelectedMenu);
  mxMenu->unselect_all();

  mnWndWidth = mxContainer->get_preferred_size().Width() + mxFrame->get_border_width() * 2 + 4;
602}

604void ScCheckListMenuControl::setAllMemberState(bool bSet)
605{
  mpChecks->all_foreach([this, bSet](weld::TreeIter& rEntry){
      mpChecks->set_toggle(rEntry, bSet ? TRISTATE_TRUE : TRISTATE_FALSE);
      return false;
  });

  if (!maConfig.mbAllowEmptySet)
  {
      // We need to have at least one member selected.
      mxBtnOk->set_sensitive(GetCheckedEntryCount() != 0);
  }
616}

618void ScCheckListMenuControl::selectCurrentMemberOnly(bool bSet)
619{
  setAllMemberState(!bSet);
  std::unique_ptr<weld::TreeIter> xEntry = mpChecks->make_iterator();
  if (!mpChecks->get_cursor(xEntry.get()))
      return;
  mpChecks->set_toggle(*xEntry, bSet ? TRISTATE_TRUE : TRISTATE_FALSE);
625}

627IMPL_LINK(ScCheckListMenuControl, ButtonHdl, weld::Button&, rBtn, void)void ScCheckListMenuControl::LinkStubButtonHdl(void * instance
, weld::Button& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->ButtonHdl(data); } void ScCheckListMenuControl
::ButtonHdl(weld::Button& rBtn)
628{
  if (&rBtn == mxBtnOk.get())
      close(true);
  else if (&rBtn == mxBtnCancel.get())
      close(false);
  else if (&rBtn == mxBtnSelectSingle.get() || &rBtn == mxBtnUnselectSingle.get())
  {
      selectCurrentMemberOnly(&rBtn == mxBtnSelectSingle.get());
      std::unique_ptr<weld::TreeIter> xEntry = mpChecks->make_iterator();
      if (!mpChecks->get_cursor(xEntry.get()))
          xEntry.reset();
      Check(xEntry.get());
  }
641}

643IMPL_LINK_NOARG(ScCheckListMenuControl, TriStateHdl, weld::ToggleButton&, void)void ScCheckListMenuControl::LinkStubTriStateHdl(void * instance
, weld::ToggleButton& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->TriStateHdl(data); } void ScCheckListMenuControl
::TriStateHdl(__attribute__ ((unused)) weld::ToggleButton&
)
644{
  switch (mePrevToggleAllState)
  {
      case TRISTATE_FALSE:
          mxChkToggleAll->set_state(TRISTATE_TRUE);
          setAllMemberState(true);
      break;
      case TRISTATE_TRUE:
          mxChkToggleAll->set_state(TRISTATE_FALSE);
          setAllMemberState(false);
      break;
      case TRISTATE_INDET:
      default:
          mxChkToggleAll->set_state(TRISTATE_TRUE);
          setAllMemberState(true);
      break;
  }

  mePrevToggleAllState = mxChkToggleAll->get_state();
663}

665IMPL_LINK_NOARG(ScCheckListMenuControl, EdModifyHdl, weld::Entry&, void)void ScCheckListMenuControl::LinkStubEdModifyHdl(void * instance
, weld::Entry& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->EdModifyHdl(data); } void ScCheckListMenuControl
::EdModifyHdl(__attribute__ ((unused)) weld::Entry&)
666{
  OUString aSearchText = mxEdSearch->get_text();
  aSearchText = ScGlobal::getCharClassPtr()->lowercase( aSearchText );
  bool bSearchTextEmpty = aSearchText.isEmpty();
  size_t n = maMembers.size();
  size_t nSelCount = 0;
  bool bSomeDateDeletes = false;

  mpChecks->freeze();

  if (bSearchTextEmpty && !mbHasDates)
  {
      // when there are a lot of rows, it is cheaper to simply clear the tree and re-initialise
      mpChecks->clear();
      nSelCount = initMembers();
  }
  else
  {
      for (size_t i = 0; i < n; ++i)
      {
          bool bIsDate = maMembers[i].mbDate;
          bool bPartialMatch = false;

          OUString aLabelDisp = maMembers[i].maName;
          if ( aLabelDisp.isEmpty() )
              aLabelDisp = ScResId( STR_EMPTYDATAreinterpret_cast<char const *>("STR_EMPTYDATA" "\004" u8"(empty)"
) );

          if ( !bSearchTextEmpty )
          {
              if ( !bIsDate )
                  bPartialMatch = ( ScGlobal::getCharClassPtr()->lowercase( aLabelDisp ).indexOf( aSearchText ) != -1 );
              else if ( maMembers[i].meDatePartType == ScCheckListMember::DAY ) // Match with both numerical and text version of month
                  bPartialMatch = (ScGlobal::getCharClassPtr()->lowercase( OUString(
                                  maMembers[i].maRealName + maMembers[i].maDateParts[1] )).indexOf( aSearchText ) != -1);
              else
                  continue;
          }
          else if ( bIsDate && maMembers[i].meDatePartType != ScCheckListMember::DAY )
              continue;

          if ( bSearchTextEmpty )
          {
              auto xLeaf = ShowCheckEntry(aLabelDisp, maMembers[i], true, maMembers[i].mbVisible);
              updateMemberParents(xLeaf.get(), i);
              if ( maMembers[i].mbVisible )
                  ++nSelCount;
              continue;
          }

          if ( bPartialMatch )
          {
              auto xLeaf = ShowCheckEntry(aLabelDisp, maMembers[i]);
              updateMemberParents(xLeaf.get(), i);
              ++nSelCount;
          }
          else
          {
              ShowCheckEntry(aLabelDisp, maMembers[i], false, false);
              if( bIsDate )
                  bSomeDateDeletes = true;
          }
      }
  }

  if ( bSomeDateDeletes )
  {
      for (size_t i = 0; i < n; ++i)
      {
          if (!maMembers[i].mbDate)
              continue;
          if (maMembers[i].meDatePartType != ScCheckListMember::DAY)
              continue;
          updateMemberParents(nullptr, i);
      }
  }

  mpChecks->thaw();

  if ( nSelCount == n )
      mxChkToggleAll->set_state( TRISTATE_TRUE );
  else if ( nSelCount == 0 )
      mxChkToggleAll->set_state( TRISTATE_FALSE );
  else
      mxChkToggleAll->set_state( TRISTATE_INDET );

  if ( !maConfig.mbAllowEmptySet )
  {
      const bool bEmptySet( nSelCount == 0 );
      mpChecks->set_sensitive(!bEmptySet);
      mxChkToggleAll->set_sensitive(!bEmptySet);
      mxBtnSelectSingle->set_sensitive(!bEmptySet);
      mxBtnUnselectSingle->set_sensitive(!bEmptySet);
      mxBtnOk->set_sensitive(!bEmptySet);
  }
760}

762IMPL_LINK_NOARG(ScCheckListMenuControl, EdActivateHdl, weld::Entry&, bool)bool ScCheckListMenuControl::LinkStubEdActivateHdl(void * instance
, weld::Entry& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->EdActivateHdl(data); } bool ScCheckListMenuControl
::EdActivateHdl(__attribute__ ((unused)) weld::Entry&)
763{
  if (mxBtnOk->get_sensitive())
      close(true);
  return true;
767}

769IMPL_LINK( ScCheckListMenuControl, CheckHdl, const weld::TreeView::iter_col&, rRowCol, void )void ScCheckListMenuControl::LinkStubCheckHdl(void * instance
, const weld::TreeView::iter_col& data) { return static_cast
<ScCheckListMenuControl *>(instance)->CheckHdl(data)
; } void ScCheckListMenuControl::CheckHdl(const weld::TreeView
::iter_col& rRowCol)
770{
  Check(&rRowCol.first);
772}

774void ScCheckListMenuControl::Check(const weld::TreeIter* pEntry)
775{
  if (pEntry)
      CheckEntry(*pEntry, mpChecks->get_toggle(*pEntry) == TRISTATE_TRUE);
  size_t nNumChecked = GetCheckedEntryCount();
  if (nNumChecked == maMembers.size())
      // all members visible
      mxChkToggleAll->set_state(TRISTATE_TRUE);
  else if (nNumChecked == 0)
      // no members visible
      mxChkToggleAll->set_state(TRISTATE_FALSE);
  else
      mxChkToggleAll->set_state(TRISTATE_INDET);

  if (!maConfig.mbAllowEmptySet)
      // We need to have at least one member selected.
      mxBtnOk->set_sensitive(nNumChecked != 0);

  mePrevToggleAllState = mxChkToggleAll->get_state();
793}

795void ScCheckListMenuControl::updateMemberParents(const weld::TreeIter* pLeaf, size_t nIdx)
796{
  if ( !maMembers[nIdx].mbDate || maMembers[nIdx].meDatePartType != ScCheckListMember::DAY )
      return;

  OUString aYearName  = maMembers[nIdx].maDateParts[0];
  OUString aMonthName = maMembers[nIdx].maDateParts[1];
  auto aItr = maYearMonthMap.find(aYearName + aMonthName);

  if ( pLeaf )
  {
      std::unique_ptr<weld::TreeIter> xYearEntry;
      std::unique_ptr<weld::TreeIter> xMonthEntry = mpChecks->make_iterator(pLeaf);
      if (!mpChecks->iter_parent(*xMonthEntry))
          xMonthEntry.reset();
      else
      {
          xYearEntry = mpChecks->make_iterator(xMonthEntry.get());
          if (!mpChecks->iter_parent(*xYearEntry))
              xYearEntry.reset();
      }

      maMembers[nIdx].mxParent = std::move(xMonthEntry);
      if ( aItr != maYearMonthMap.end() )
      {
          size_t nMonthIdx = aItr->second;
          maMembers[nMonthIdx].mxParent = std::move(xYearEntry);
      }
  }
  else
  {
      std::unique_ptr<weld::TreeIter> xYearEntry = FindEntry(nullptr, aYearName);
      if (aItr != maYearMonthMap.end() && !xYearEntry)
      {
          size_t nMonthIdx = aItr->second;
          maMembers[nMonthIdx].mxParent.reset();
          maMembers[nIdx].mxParent.reset();
      }
      else if (xYearEntry && !FindEntry(xYearEntry.get(), aMonthName))
          maMembers[nIdx].mxParent.reset();
  }
836}

838void ScCheckListMenuControl::setMemberSize(size_t n)
839{
  maMembers.reserve(n);
841}

843void ScCheckListMenuControl::addDateMember(const OUString& rsName, double nVal, bool bVisible)
844{
  SvNumberFormatter* pFormatter = mpDoc->GetFormatTable();

  // Convert the numeric date value to a date object.
  Date aDate = pFormatter->GetNullDate();
  aDate.AddDays(rtl::math::approxFloor(nVal));

  sal_Int16 nYear = aDate.GetYear();
  sal_uInt16 nMonth = aDate.GetMonth();
  sal_uInt16 nDay = aDate.GetDay();

  // Get the localized month name list.
  CalendarWrapper* pCalendar = ScGlobal::GetCalendar();
  uno::Sequence<i18n::CalendarItem2> aMonths = pCalendar->getMonths();
  if (aMonths.getLength() < nMonth)
      return;

  OUString aYearName = OUString::number(nYear);
  OUString aMonthName = aMonths[nMonth-1].FullName;
  OUString aDayName = OUString::number(nDay);

  if ( aDayName.getLength() == 1 )
      aDayName = "0" + aDayName;

  mpChecks->freeze();

  std::unique_ptr<weld::TreeIter> xYearEntry = FindEntry(nullptr, aYearName);
  if (!xYearEntry)
  {
      xYearEntry = mpChecks->make_iterator();
      mpChecks->insert(nullptr, -1, nullptr, nullptr, nullptr, nullptr, false, xYearEntry.get());
      mpChecks->set_toggle(*xYearEntry, TRISTATE_FALSE);
      mpChecks->set_text(*xYearEntry, aYearName, 0);
      ScCheckListMember aMemYear;
      aMemYear.maName = aYearName;
      aMemYear.maRealName = rsName;
      aMemYear.mbDate = true;
      aMemYear.mbLeaf = false;
      aMemYear.mbVisible = bVisible;
      aMemYear.mxParent.reset();
      aMemYear.meDatePartType = ScCheckListMember::YEAR;
      maMembers.emplace_back(std::move(aMemYear));
  }

  std::unique_ptr<weld::TreeIter> xMonthEntry = FindEntry(xYearEntry.get(), aMonthName);
  if (!xMonthEntry)
  {
      xMonthEntry = mpChecks->make_iterator();
      mpChecks->insert(xYearEntry.get(), -1, nullptr, nullptr, nullptr, nullptr, false, xMonthEntry.get());
      mpChecks->set_toggle(*xMonthEntry, TRISTATE_FALSE);
      mpChecks->set_text(*xMonthEntry, aMonthName, 0);
      ScCheckListMember aMemMonth;
      aMemMonth.maName = aMonthName;
      aMemMonth.maRealName = rsName;
      aMemMonth.mbDate = true;
      aMemMonth.mbLeaf = false;
      aMemMonth.mbVisible = bVisible;
      aMemMonth.mxParent = std::move(xYearEntry);
      aMemMonth.meDatePartType = ScCheckListMember::MONTH;
      maMembers.emplace_back(std::move(aMemMonth));
      maYearMonthMap[aYearName + aMonthName] = maMembers.size() - 1;
  }

  std::unique_ptr<weld::TreeIter> xDayEntry = FindEntry(xMonthEntry.get(), aDayName);
  if (!xDayEntry)
  {
      xDayEntry = mpChecks->make_iterator();
      mpChecks->insert(xMonthEntry.get(), -1, nullptr, nullptr, nullptr, nullptr, false, xDayEntry.get());
      mpChecks->set_toggle(*xDayEntry, TRISTATE_FALSE);
      mpChecks->set_text(*xDayEntry, aDayName, 0);
      ScCheckListMember aMemDay;
      aMemDay.maName = aDayName;
      aMemDay.maRealName = rsName;
      aMemDay.maDateParts.resize(2);
      aMemDay.maDateParts[0] = aYearName;
      aMemDay.maDateParts[1] = aMonthName;
      aMemDay.mbDate = true;
      aMemDay.mbLeaf = true;
      aMemDay.mbVisible = bVisible;
      aMemDay.mxParent = std::move(xMonthEntry);
      aMemDay.meDatePartType = ScCheckListMember::DAY;
      maMembers.emplace_back(std::move(aMemDay));
  }

  mpChecks->thaw();
929}

931void ScCheckListMenuControl::addMember(const OUString& rName, bool bVisible)
932{
  ScCheckListMember aMember;
  aMember.maName = rName;
  aMember.mbDate = false;
  aMember.mbLeaf = true;
  aMember.mbVisible = bVisible;
  aMember.mxParent.reset();
  maMembers.emplace_back(std::move(aMember));
940}

942std::unique_ptr<weld::TreeIter> ScCheckListMenuControl::FindEntry(const weld::TreeIter* pParent, const OUString& sNode)
943{
  std::unique_ptr<weld::TreeIter> xEntry = mpChecks->make_iterator(pParent);
  bool bEntry = pParent ? mpChecks->iter_children(*xEntry) : mpChecks->get_iter_first(*xEntry);
  while (bEntry)
  {
      if (sNode == mpChecks->get_text(*xEntry, 0))
          return xEntry;
      bEntry = mpChecks->iter_next_sibling(*xEntry);
  }
  return nullptr;
953}

955void ScCheckListMenuControl::GetRecursiveChecked(const weld::TreeIter* pEntry, std::unordered_set<OUString>& vOut,
                                               OUString& rLabel)
957{
  if (mpChecks->get_toggle(*pEntry) != TRISTATE_TRUE)
      return;

  // We have to hash parents and children together.
  // Per convention for easy access in getResult()
  // "child;parent;grandparent" while descending.
  if (rLabel.isEmpty())
      rLabel = mpChecks->get_text(*pEntry, 0);
  else
      rLabel = mpChecks->get_text(*pEntry, 0) + ";" + rLabel;

  // Prerequisite: the selection mechanism guarantees that if a child is
  // selected then also the parent is selected, so we only have to
  // inspect the children in case the parent is selected.
  if (!mpChecks->iter_has_child(*pEntry))
      return;

  std::unique_ptr<weld::TreeIter> xChild(mpChecks->make_iterator(pEntry));
  bool bChild = mpChecks->iter_children(*xChild);
  while (bChild)
  {
      OUString aLabel = rLabel;
      GetRecursiveChecked(xChild.get(), vOut, aLabel);
      if (!aLabel.isEmpty() && aLabel != rLabel)
          vOut.insert(aLabel);
      bChild = mpChecks->iter_next_sibling(*xChild);
  }
  // Let the caller not add the parent alone.
  rLabel.clear();
987}

989std::unordered_set<OUString> ScCheckListMenuControl::GetAllChecked()
990{
  std::unordered_set<OUString> vResults(0);

  std::unique_ptr<weld::TreeIter> xEntry = mpChecks->make_iterator();
  bool bEntry = mpChecks->get_iter_first(*xEntry);
  while (bEntry)
  {
      OUString aLabel;
      GetRecursiveChecked(xEntry.get(), vResults, aLabel);
      if (!aLabel.isEmpty())
          vResults.insert(aLabel);
      bEntry = mpChecks->iter_next_sibling(*xEntry);
  }

  return vResults;
1005}

1007bool ScCheckListMenuControl::IsChecked(const OUString& sName, const weld::TreeIter* pParent)
1008{
  std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pParent, sName);
  return xEntry && mpChecks->get_toggle(*xEntry) == TRISTATE_TRUE;
1011}

1013void ScCheckListMenuControl::CheckEntry(const OUString& sName, const weld::TreeIter* pParent, bool bCheck)
1014{
  std::unique_ptr<weld::TreeIter> xEntry = FindEntry(pParent, sName);
  if (xEntry)
      CheckEntry(*xEntry, bCheck);
1018}

1020// Recursively check all children of rParent
1021void ScCheckListMenuControl::CheckAllChildren(const weld::TreeIter& rParent, bool bCheck)
1022{
  mpChecks->set_toggle(rParent, bCheck ? TRISTATE_TRUE : TRISTATE_FALSE);
  std::unique_ptr<weld::TreeIter> xEntry = mpChecks->make_iterator(&rParent);
  bool bEntry = mpChecks->iter_children(*xEntry);
  while (bEntry)
  {
      CheckAllChildren(*xEntry, bCheck);
      bEntry = mpChecks->iter_next_sibling(*xEntry);
  }
1031}

1033void ScCheckListMenuControl::CheckEntry(const weld::TreeIter& rParent, bool bCheck)
1034{
  // recursively check all items below rParent
  CheckAllChildren(rParent, bCheck);
  // checking rParent can affect ancestors, e.g. if ancestor is unchecked and rParent is
  // now checked then the ancestor needs to be checked also
  if (!mpChecks->get_iter_depth(rParent))
      return;

  std::unique_ptr<weld::TreeIter> xAncestor(mpChecks->make_iterator(&rParent));
  bool bAncestor = mpChecks->iter_parent(*xAncestor);
  while (bAncestor)
  {
      // if any first level children checked then ancestor
      // needs to be checked, similarly if no first level children
      // checked then ancestor needs to be unchecked
      std::unique_ptr<weld::TreeIter> xChild(mpChecks->make_iterator(xAncestor.get()));
      bool bChild = mpChecks->iter_children(*xChild);
      bool bChildChecked = false;

      while (bChild)
      {
          if (mpChecks->get_toggle(*xChild) == TRISTATE_TRUE)
          {
              bChildChecked = true;
              break;
          }
          bChild = mpChecks->iter_next_sibling(*xChild);
      }
      mpChecks->set_toggle(*xAncestor, bChildChecked ? TRISTATE_TRUE : TRISTATE_FALSE);
      bAncestor = mpChecks->iter_parent(*xAncestor);
  }
1065}

1067std::unique_ptr<weld::TreeIter> ScCheckListMenuControl::ShowCheckEntry(const OUString& sName, ScCheckListMember& rMember, bool bShow, bool bCheck)
1068{
  std::unique_ptr<weld::TreeIter> xEntry;
  if (!rMember.mbDate || rMember.mxParent)
      xEntry = FindEntry(rMember.mxParent.get(), sName);

  if ( bShow )
  {
      if (!xEntry)
      {
          if (rMember.mbDate)
          {
              if (rMember.maDateParts.empty())
                  return nullptr;

              std::unique_ptr<weld::TreeIter> xYearEntry = FindEntry(nullptr, rMember.maDateParts[0]);
              if (!xYearEntry)
              {
                  xYearEntry = mpChecks->make_iterator();
                  mpChecks->insert(nullptr, -1, nullptr, nullptr, nullptr, nullptr, false, xYearEntry.get());
                  mpChecks->set_toggle(*xYearEntry, TRISTATE_FALSE);
                  mpChecks->set_text(*xYearEntry, rMember.maDateParts[0], 0);
              }
              std::unique_ptr<weld::TreeIter> xMonthEntry = FindEntry(xYearEntry.get(), rMember.maDateParts[1]);
              if (!xMonthEntry)
              {
                  xMonthEntry = mpChecks->make_iterator();
                  mpChecks->insert(xYearEntry.get(), -1, nullptr, nullptr, nullptr, nullptr, false, xMonthEntry.get());
                  mpChecks->set_toggle(*xMonthEntry, TRISTATE_FALSE);
                  mpChecks->set_text(*xMonthEntry, rMember.maDateParts[1], 0);
              }
              std::unique_ptr<weld::TreeIter> xDayEntry = FindEntry(xMonthEntry.get(), rMember.maName);
              if (!xDayEntry)
              {
                  xDayEntry = mpChecks->make_iterator();
                  mpChecks->insert(xMonthEntry.get(), -1, nullptr, nullptr, nullptr, nullptr, false, xDayEntry.get());
                  mpChecks->set_toggle(*xDayEntry, TRISTATE_FALSE);
                  mpChecks->set_text(*xDayEntry, rMember.maName, 0);
              }
              return xDayEntry; // Return leaf node
          }

          xEntry = mpChecks->make_iterator();
          mpChecks->append(xEntry.get());
          mpChecks->set_toggle(*xEntry, bCheck ? TRISTATE_TRUE : TRISTATE_FALSE);
          mpChecks->set_text(*xEntry, sName, 0);
      }
      else
          CheckEntry(*xEntry, bCheck);
  }
  else if (xEntry)
  {
      mpChecks->remove(*xEntry);
      if (rMember.mxParent)
      {
          std::unique_ptr<weld::TreeIter> xParent(mpChecks->make_iterator(rMember.mxParent.get()));
          while (xParent && !mpChecks->iter_has_child(*xParent))
          {
              std::unique_ptr<weld::TreeIter> xTmp(mpChecks->make_iterator(xParent.get()));
              if (!mpChecks->iter_parent(*xParent))
                  xParent.reset();
              mpChecks->remove(*xTmp);
          }
      }
  }
  return nullptr;
1133}

1135int ScCheckListMenuControl::GetCheckedEntryCount() const
1136{
  int nRet = 0;

  mpChecks->all_foreach([this, &nRet](weld::TreeIter& rEntry){
      if (mpChecks->get_toggle(rEntry) == TRISTATE_TRUE)
          ++nRet;
      return false;
  });

  return nRet;
1146}

1148IMPL_LINK(ScCheckListMenuControl, KeyInputHdl, const KeyEvent&, rKEvt, bool)bool ScCheckListMenuControl::LinkStubKeyInputHdl(void * instance
, const KeyEvent& data) { return static_cast<ScCheckListMenuControl
 *>(instance)->KeyInputHdl(data); } bool ScCheckListMenuControl
::KeyInputHdl(const KeyEvent& rKEvt)
1149{
  const vcl::KeyCode& rKey = rKEvt.GetKeyCode();

  if ( rKey.GetCode() == KEY_RETURN || rKey.GetCode() == KEY_SPACE )
  {
      std::unique_ptr<weld::TreeIter> xEntry = mpChecks->make_iterator();
      bool bEntry = mpChecks->get_cursor(xEntry.get());
      if (bEntry)
      {
          bool bOldCheck = mpChecks->get_toggle(*xEntry) == TRISTATE_TRUE;
          CheckEntry(*xEntry, !bOldCheck);
          bool bNewCheck = mpChecks->get_toggle(*xEntry) == TRISTATE_TRUE;
          if (bOldCheck != bNewCheck)
              Check(xEntry.get());
      }
      return true;
  }

  return false;
1168}

1170namespace
1171{
  void insertMember(weld::TreeView& rView, const weld::TreeIter& rIter, const ScCheckListMember& rMember)
  {
      OUString aLabel = rMember.maName;
      if (aLabel.isEmpty())
          aLabel = ScResId(STR_EMPTYDATAreinterpret_cast<char const *>("STR_EMPTYDATA" "\004" u8"(empty)"
));
      rView.set_toggle(rIter, rMember.mbVisible ? TRISTATE_TRUE : TRISTATE_FALSE);
      rView.set_text(rIter, aLabel, 0);
  }
1180}

1182size_t ScCheckListMenuControl::initMembers(int nMaxMemberWidth)
1183{
  size_t n = maMembers.size();
  size_t nVisMemCount = 0;

  if (nMaxMemberWidth == -1)
      nMaxMemberWidth = mnCheckWidthReq;

  if (!mpChecks->n_children() && !mbHasDates)
  {
      std::vector<int> aFixedWidths { nMaxMemberWidth };
      // tdf#134038 insert in the fastest order, this might be backwards so only do it for
      // the !mbHasDates case where no entry depends on another to exist before getting
      // inserted. We cannot retain pre-existing treeview content, only clear and fill it.
      mpChecks->bulk_insert_for_each(n, [this, &nVisMemCount](weld::TreeIter& rIter, int i) {
          assert(!maMembers[i].mbDate)(static_cast <bool> (!maMembers[i].mbDate) ? void (0) :
 __assert_fail ("!maMembers[i].mbDate", "/home/maarten/src/libreoffice/core/sc/source/ui/cctrl/checklistmenu.cxx"
, 1197, __extension__ __PRETTY_FUNCTION__));
          insertMember(*mpChecks, rIter, maMembers[i]);
          if (maMembers[i].mbVisible)
              ++nVisMemCount;
      }, &aFixedWidths);
  }
  else
  {
      mpChecks->freeze();

      std::unique_ptr<weld::TreeIter> xEntry = mpChecks->make_iterator();
      std::vector<std::unique_ptr<weld::TreeIter>> aExpandRows;

      for (size_t i = 0; i < n; ++i)
      {
          if (maMembers[i].mbDate)
          {
              CheckEntry(maMembers[i].maName, maMembers[i].mxParent.get(), maMembers[i].mbVisible);
              // Expand first node of checked dates
              if (!maMembers[i].mxParent && IsChecked(maMembers[i].maName, maMembers[i].mxParent.get()))
              {
                  std::unique_ptr<weld::TreeIter> xDateEntry = FindEntry(nullptr, maMembers[i].maName);
                  if (xDateEntry)
                      aExpandRows.emplace_back(std::move(xDateEntry));
              }
          }
          else
          {
              mpChecks->append(xEntry.get());
              insertMember(*mpChecks, *xEntry, maMembers[i]);
          }

          if (maMembers[i].mbVisible)
              ++nVisMemCount;
      }

      mpChecks->thaw();

      for (auto& rRow : aExpandRows)
          mpChecks->expand_row(*rRow);
  }

  if (nVisMemCount == n)
  {
      // all members visible
      mxChkToggleAll->set_state(TRISTATE_TRUE);
      mePrevToggleAllState = TRISTATE_TRUE;
  }
  else if (nVisMemCount == 0)
  {
      // no members visible
      mxChkToggleAll->set_state(TRISTATE_FALSE);
      mePrevToggleAllState = TRISTATE_FALSE;
  }
  else
  {
      mxChkToggleAll->set_state(TRISTATE_INDET);
      mePrevToggleAllState = TRISTATE_INDET;
  }

  if (nVisMemCount)
      mpChecks->select(0);

  return nVisMemCount;
1261}

1263void ScCheckListMenuControl::setConfig(const Config& rConfig)
1264{
  maConfig = rConfig;
1266}

1268bool ScCheckListMenuControl::isAllSelected() const
1269{
  return mxChkToggleAll->get_state() == TRISTATE_TRUE;
1271}

1273void ScCheckListMenuControl::getResult(ResultType& rResult)
1274{
  ResultType aResult;
  std::unordered_set<OUString> vCheckeds = GetAllChecked();
  size_t n = maMembers.size();
  for (size_t i = 0; i < n; ++i)
  {
      if ( maMembers[i].mbLeaf )
      {
          OUStringBuffer aLabel = maMembers[i].maName;
          if (aLabel.isEmpty())
              aLabel = ScResId(STR_EMPTYDATAreinterpret_cast<char const *>("STR_EMPTYDATA" "\004" u8"(empty)"
));

          /* TODO: performance-wise this looks suspicious, concatenating to
           * do the lookup for each leaf item seems wasteful. */
          // Checked labels are in the form "child;parent;grandparent".
          if (maMembers[i].mxParent)
          {
              std::unique_ptr<weld::TreeIter> xIter(mpChecks->make_iterator(maMembers[i].mxParent.get()));
              do
              {
                  aLabel.append(";").append(mpChecks->get_text(*xIter));
              }
              while (mpChecks->iter_parent(*xIter));
          }

          bool bState = vCheckeds.find(aLabel.makeStringAndClear()) != vCheckeds.end();

          ResultEntry aResultEntry;
          aResultEntry.bValid = bState;
          if ( maMembers[i].mbDate )
              aResultEntry.aName = maMembers[i].maRealName;
          else
              aResultEntry.aName = maMembers[i].maName;
          aResultEntry.bDate = maMembers[i].mbDate;
          aResult.insert(aResultEntry);
      }
  }
  rResult.swap(aResult);
1312}

1314void ScCheckListMenuControl::launch(const tools::Rectangle& rRect)
1315{
  prepWindow();
  if (!maConfig.mbAllowEmptySet)
      // We need to have at least one member selected.
      mxBtnOk->set_sensitive(GetCheckedEntryCount() != 0);

  tools::Rectangle aRect(rRect);
  if (maConfig.mbRTL)
  {
      // In RTL mode, the logical "left" is visual "right".
      long nLeft = aRect.Left() - aRect.GetWidth();
      aRect.SetLeft( nLeft );
  }
  else if (mnWndWidth < aRect.GetWidth())
  {
      // Target rectangle (i.e. cell width) is wider than the window.
      // Simulate right-aligned launch by modifying the target rectangle
      // size.
      long nDiff = aRect.GetWidth() - mnWndWidth;
      aRect.AdjustLeft(nDiff );
  }

  StartPopupMode(aRect, FloatWinPopupFlags::Down);
1338}

1340void ScCheckListMenuControl::close(bool bOK)
1341{
  if (bOK && mxOKAction)
      mxOKAction->execute();
  EndPopupMode();
1345}

1347void ScCheckListMenuControl::setExtendedData(std::unique_ptr<ExtendedData> p)
1348{
  mxExtendedData = std::move(p);
1350}

1352ScCheckListMenuControl::ExtendedData* ScCheckListMenuControl::getExtendedData()
1353{
  return mxExtendedData.get();
1355}

1357void ScCheckListMenuControl::setOKAction(Action* p)
1358{
  mxOKAction.reset(p);
1360}

1362void ScCheckListMenuControl::setPopupEndAction(Action* p)
1363{
  mxPopupEndAction.reset(p);
1365}

1367IMPL_LINK_NOARG(ScCheckListMenuControl, PopupModeEndHdl, FloatingWindow*, void)void ScCheckListMenuControl::LinkStubPopupModeEndHdl(void * instance
, FloatingWindow* data) { return static_cast<ScCheckListMenuControl
 *>(instance)->PopupModeEndHdl(data); } void ScCheckListMenuControl
::PopupModeEndHdl(__attribute__ ((unused)) FloatingWindow*)
1368{
  clearSelectedMenuItem();
  if (mxPopupEndAction)
      mxPopupEndAction->execute();
1372}

1374int ScCheckListMenuControl::GetTextWidth(const OUString& rsName) const
1375{
  return mxDropDown->GetTextWidth(rsName);
1377}

1379int ScCheckListMenuControl::IncreaseWindowWidthToFitText(int nMaxTextWidth)
1380{
  int nBorder = mxFrame->get_border_width() * 2 + 4;
  int nNewWidth = nMaxTextWidth - nBorder;
  if (nNewWidth > mnCheckWidthReq)
  {
      mnCheckWidthReq = nNewWidth;
      int nChecksHeight = mpChecks->get_height_rows(9);
      mpChecks->set_size_request(mnCheckWidthReq, nChecksHeight);
  }
  return mnCheckWidthReq + nBorder;
1390}

1392/* 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);
2
←
Calling copy constructor for 'Reference<vcl::Window>'→
5
←
Returning from copy constructor for 'Reference<vcl::Window>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
6
←
Calling 'Reference::clear'→
13
←
Returning; memory was released→
      if (aTmp.get()) {
14
←
Calling 'Reference::get'→
          aTmp->disposeOnce();
      }
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

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

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

440#endif // INCLUDED_VCL_PTR_HXX

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

←

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

→

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

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

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

32#include "sal/types.h"

34namespace rtl
35{

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


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


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

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

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
3
←
Assuming field 'm_pBody' is non-null→
4
←
Taking true branch→
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody6.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
)
7
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
8
←
Calling 'VclReferenceBase::release'→
12
←
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;
15
←
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)
9
←
Assuming the condition is true→
10
←
Taking true branch→
40            delete this;
11
←
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