/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 SidebarController.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 SFX2_DLLIMPLEMENTATION -D ENABLE_CUPS -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/liborcus/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/sfx2/inc -I /home/maarten/src/libreoffice/core/sfx2/source/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sfx2/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 -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/sfx2/source/sidebar/SidebarController.cxx

/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.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 .
*/
19#include <sfx2/sidebar/SidebarController.hxx>
20#include <sfx2/sidebar/Deck.hxx>
21#include <sidebar/DeckDescriptor.hxx>
22#include <sidebar/DeckTitleBar.hxx>
23#include <sfx2/sidebar/Panel.hxx>
24#include <sidebar/PanelDescriptor.hxx>
25#include <sidebar/PanelTitleBar.hxx>
26#include <sfx2/sidebar/TabBar.hxx>
27#include <sfx2/sidebar/Theme.hxx>
28#include <sfx2/sidebar/SidebarChildWindow.hxx>
29#include <sidebar/Tools.hxx>
30#include <sfx2/sidebar/SidebarDockingWindow.hxx>
31#include <sfx2/sidebar/Context.hxx>


34#include <sfx2/lokhelper.hxx>
35#include <sfx2/sfxresid.hxx>
36#include <sfx2/strings.hrc>
37#include <framework/ContextChangeEventMultiplexerTunnel.hxx>
38#include <vcl/floatwin.hxx>
39#include <vcl/fixed.hxx>
40#include <vcl/uitest/logger.hxx>
41#include <vcl/uitest/eventdescription.hxx>
42#include <vcl/svapp.hxx>
43#include <splitwin.hxx>
44#include <tools/diagnose_ex.h>
45#include <tools/link.hxx>
46#include <toolkit/helper/vclunohelper.hxx>
47#include <comphelper/processfactory.hxx>
48#include <comphelper/namedvaluecollection.hxx>
49#include <comphelper/lok.hxx>
50#include <sal/log.hxx>
51#include <officecfg/Office/UI/Sidebar.hxx>
52#include <LibreOfficeKit/LibreOfficeKitEnums.h>
53#include <boost/property_tree/ptree.hpp>
54#include <boost/property_tree/json_parser.hpp>

56#include <com/sun/star/awt/XWindowPeer.hpp>
57#include <com/sun/star/frame/XDispatch.hpp>
58#include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp>
59#include <com/sun/star/ui/ContextChangeEventObject.hpp>
60#include <com/sun/star/ui/theUIElementFactoryManager.hpp>
61#include <com/sun/star/util/URL.hpp>
62#include <com/sun/star/rendering/XSpriteCanvas.hpp>


65using namespace css;
66using namespace css::uno;

68namespace
69{
  const char gsReadOnlyCommandName[] = ".uno:EditDoc";
  const sal_Int32 gnWidthCloseThreshold (70);
  const sal_Int32 gnWidthOpenThreshold (40);

  std::string UnoNameFromDeckId(const OUString& rsDeckId, bool isImpress = false)
  {
      if (rsDeckId == "SdCustomAnimationDeck")
          return ".uno:CustomAnimation";

      if (rsDeckId == "PropertyDeck")
          return isImpress ? ".uno:ModifyPage" : ".uno:Sidebar";

      if (rsDeckId == "SdLayoutsDeck")
          return ".uno:ModifyPage";

      if (rsDeckId == "SdSlideTransitionDeck")
          return ".uno:SlideChangeWindow";

      if (rsDeckId == "SdAllMasterPagesDeck")
          return ".uno:MasterSlidesPanel";

      if (rsDeckId == "SdMasterPagesDeck")
          return ".uno:MasterSlidesPanel";

      if (rsDeckId == "GalleryDeck")
          return ".uno:Gallery";

      return "";
  }
99}

101namespace sfx2::sidebar {

103namespace {
  enum MenuId
  {
      MID_UNLOCK_TASK_PANEL = 1,
      MID_LOCK_TASK_PANEL,
      MID_HIDE_SIDEBAR,
      MID_CUSTOMIZATION,
      MID_RESTORE_DEFAULT,
      MID_FIRST_PANEL,
      MID_FIRST_HIDE = 1000
  };

  /** When in doubt, show this deck.
  */
  const char gsDefaultDeckId[] = "PropertyDeck";
118}

120SidebarController::SidebarController (
  SidebarDockingWindow* pParentWindow,
  const SfxViewFrame* pViewFrame)
  : SidebarControllerInterfaceBase(m_aMutex),
    mpCurrentDeck(),
    mpParentWindow(pParentWindow),
    mpViewFrame(pViewFrame),
    mxFrame(pViewFrame->GetFrame().GetFrameInterface()),
    mpTabBar(VclPtr<TabBar>::Create(
            mpParentWindow,
            mxFrame,
            [this](const OUString& rsDeckId) { return this->OpenThenToggleDeck(rsDeckId); },
            [this](const tools::Rectangle& rButtonBox,const ::std::vector<TabBar::DeckMenuData>& rMenuData) { return this->ShowPopupMenu(rButtonBox,rMenuData); },
            this)),
    maCurrentContext(OUString(), OUString()),
    maRequestedContext(),
    mnRequestedForceFlags(SwitchFlag_NoForce),
    mnMaximumSidebarWidth(officecfg::Office::UI::Sidebar::General::MaximumWidth::get()),
    msCurrentDeckId(gsDefaultDeckId),
    maPropertyChangeForwarder([this](){ return this->BroadcastPropertyChange(); }),
    maContextChangeUpdate([this](){ return this->UpdateConfigurations(); }),
    mbIsDeckRequestedOpen(),
    mbIsDeckOpen(),
    mbFloatingDeckClosed(!pParentWindow->IsFloatingMode()),
    mnSavedSidebarWidth(pParentWindow->GetSizePixel().Width()),
    maFocusManager([this](const Panel& rPanel){ return this->ShowPanel(rPanel); },
                   [this](const sal_Int32 nIndex){ return this->IsDeckOpen(nIndex); }),
    mxReadOnlyModeDispatch(),
    mbIsDocumentReadOnly(false),
    mpSplitWindow(nullptr),
    mnWidthOnSplitterButtonDown(0),
    mpResourceManager()
152{
  // Decks and panel collections for this sidebar
  mpResourceManager = std::make_unique<ResourceManager>();
155}

157rtl::Reference<SidebarController> SidebarController::create(SidebarDockingWindow* pParentWindow,
                                                          const SfxViewFrame* pViewFrame)
159{
  rtl::Reference<SidebarController> instance(new SidebarController(pParentWindow, pViewFrame));

  const css::uno::Reference<css::frame::XFrame>& rxFrame = pViewFrame->GetFrame().GetFrameInterface();
  registerSidebarForFrame(instance.get(), rxFrame->getController());
  rxFrame->addFrameActionListener(instance.get());
  // Listen for window events.
  instance->mpParentWindow->AddEventListener(LINK(instance.get(), SidebarController, WindowEventHandler)::tools::detail::makeLink( ::tools::detail::castTo<SidebarController
 *>(instance.get()), &SidebarController::LinkStubWindowEventHandler
));

  // Listen for theme property changes.
  Theme::GetPropertySet()->addPropertyChangeListener(
      "",
      static_cast<css::beans::XPropertyChangeListener*>(instance.get()));

  // Get the dispatch object as preparation to listen for changes of
  // the read-only state.
  const util::URL aURL (Tools::GetURL(gsReadOnlyCommandName));
  instance->mxReadOnlyModeDispatch = Tools::GetDispatch(rxFrame, aURL);
  if (instance->mxReadOnlyModeDispatch.is())
      instance->mxReadOnlyModeDispatch->addStatusListener(instance.get(), aURL);

  //first UpdateConfigurations call will SwitchToDeck

  return instance;
183}

185SidebarController::~SidebarController()
186{
187}

189SidebarController* SidebarController::GetSidebarControllerForFrame (
  const css::uno::Reference<css::frame::XFrame>& rxFrame)
191{
  uno::Reference<frame::XController> const xController(rxFrame->getController());
  if (!xController.is()) // this may happen during dispose of Draw controller but perhaps it's a bug
  {
      SAL_WARN("sfx.sidebar", "GetSidebarControllerForFrame: frame has no XController")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sfx.sidebar")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "GetSidebarControllerForFrame: frame has no XController"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sfx.sidebar"
), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "195" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "GetSidebarControllerForFrame: frame has no XController"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "GetSidebarControllerForFrame: frame has no XController"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sfx.sidebar"
), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "195" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "GetSidebarControllerForFrame: frame has no XController"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sfx.sidebar"
), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "195" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "GetSidebarControllerForFrame: frame has no XController"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "GetSidebarControllerForFrame: frame has no XController"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sfx.sidebar"
), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "195" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return nullptr;
  }
  uno::Reference<ui::XContextChangeEventListener> const xListener(
      framework::GetFirstListenerWith(xController,
          [] (uno::Reference<uno::XInterface> const& xRef)
          { return nullptr != dynamic_cast<SidebarController*>(xRef.get()); }
      ));

  return dynamic_cast<SidebarController*>(xListener.get());
205}

207void SidebarController::registerSidebarForFrame(SidebarController* pController, const css::uno::Reference<css::frame::XController>& xController)
208{
  // Listen for context change events.
  css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer (
      css::ui::ContextChangeEventMultiplexer::get(
          ::comphelper::getProcessComponentContext()));
  xMultiplexer->addContextChangeEventListener(
      static_cast<css::ui::XContextChangeEventListener*>(pController),
      xController);
216}

218void SidebarController::unregisterSidebarForFrame(SidebarController* pController, const css::uno::Reference<css::frame::XController>& xController)
219{
  pController->saveDeckState();
  pController->disposeDecks();

  css::uno::Reference<css::ui::XContextChangeEventMultiplexer> xMultiplexer (
      css::ui::ContextChangeEventMultiplexer::get(
          ::comphelper::getProcessComponentContext()));
  xMultiplexer->removeContextChangeEventListener(
      static_cast<css::ui::XContextChangeEventListener*>(pController),
      xController);
229}

231void SidebarController::disposeDecks()
232{
  SolarMutexGuard aSolarMutexGuard;

  if (comphelper::LibreOfficeKit::isActive())
  {
      if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
      {
          const std::string hide = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication));
          if (!hide.empty())
              pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
                                                     (hide + "=false").c_str());
      }

      mpParentWindow->ReleaseLOKNotifier();
  }

  mpCurrentDeck.clear();
  maFocusManager.Clear();
  mpResourceManager->disposeDecks();
251}

253void SAL_CALL SidebarController::disposing()
254{
  mpCloseIndicator.disposeAndClear();

  maFocusManager.Clear();
  mpTabBar.disposeAndClear();
1
Calling 'VclPtr::disposeAndClear'→

  saveDeckState();

  // clear decks
  ResourceManager::DeckContextDescriptorContainer aDecks;

  mpResourceManager->GetMatchingDecks (
          aDecks,
          GetCurrentContext(),
          IsDocumentReadOnly(),
          mxFrame->getController());

  for (const auto& rDeck : aDecks)
  {
      std::shared_ptr<DeckDescriptor> deckDesc = mpResourceManager->GetDeckDescriptor(rDeck.msId);

      VclPtr<Deck> aDeck = deckDesc->mpDeck;
      if (aDeck)
          aDeck.disposeAndClear();
  }

  uno::Reference<css::frame::XController> xController = mxFrame->getController();
  if (!xController.is())
      xController = mxCurrentController;

  mxFrame->removeFrameActionListener(this);
  unregisterSidebarForFrame(this, xController);

  if (mxReadOnlyModeDispatch.is())
      mxReadOnlyModeDispatch->removeStatusListener(this, Tools::GetURL(gsReadOnlyCommandName));
  if (mpSplitWindow != nullptr)
  {
      mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler)::tools::detail::makeLink( ::tools::detail::castTo<SidebarController
 *>(this), &SidebarController::LinkStubWindowEventHandler
));
      mpSplitWindow = nullptr;
  }

  if (mpParentWindow != nullptr)
  {
      mpParentWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler)::tools::detail::makeLink( ::tools::detail::castTo<SidebarController
 *>(this), &SidebarController::LinkStubWindowEventHandler
));
      mpParentWindow = nullptr;
  }

  Theme::GetPropertySet()->removePropertyChangeListener(
      "",
      static_cast<css::beans::XPropertyChangeListener*>(this));

  maContextChangeUpdate.CancelRequest();
306}

308void SAL_CALL SidebarController::notifyContextChangeEvent (const css::ui::ContextChangeEventObject& rEvent)
309{
  // Update to the requested new context asynchronously to avoid
  // subtle errors caused by SFX2 which in rare cases can not
  // properly handle a synchronous update.

  maRequestedContext = Context(
      rEvent.ApplicationName,
      rEvent.ContextName);

  if (maRequestedContext != maCurrentContext)
  {
      mxCurrentController.set(rEvent.Source, css::uno::UNO_QUERY);
      maContextChangeUpdate.RequestCall();
      // TODO: this call is redundant but mandatory for unit test to update context on document loading
      UpdateConfigurations();
  }
325}

327void SAL_CALL SidebarController::disposing (const css::lang::EventObject& )
328{
  dispose();
330}

332void SAL_CALL SidebarController::propertyChange (const css::beans::PropertyChangeEvent& )
333{
  maPropertyChangeForwarder.RequestCall();
335}

337void SAL_CALL SidebarController::statusChanged (const css::frame::FeatureStateEvent& rEvent)
338{
  bool bIsReadWrite (true);
  if (rEvent.IsEnabled)
      rEvent.State >>= bIsReadWrite;

  if (mbIsDocumentReadOnly != !bIsReadWrite)
  {
      mbIsDocumentReadOnly = !bIsReadWrite;

      // Force the current deck to update its panel list.
      if ( ! mbIsDocumentReadOnly)
          SwitchToDefaultDeck();

      mnRequestedForceFlags |= SwitchFlag_ForceSwitch;
      maContextChangeUpdate.RequestCall();
  }
354}

356void SAL_CALL SidebarController::requestLayout()
357{
  sal_Int32 nMinimalWidth = 0;
  if (mpCurrentDeck && !mpCurrentDeck->isDisposed())
  {
      mpCurrentDeck->RequestLayout();
      nMinimalWidth = mpCurrentDeck->GetMinimalWidth();
  }
  RestrictWidth(nMinimalWidth);
365}

367void SidebarController::BroadcastPropertyChange()
368{
  mpParentWindow->Invalidate(InvalidateFlags::Children);
370}

372void SidebarController::NotifyResize()
373{
  if (!mpTabBar)
  {
      OSL_ASSERT(mpTabBar!=nullptr)do { if (true && (!(mpTabBar!=nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "376" ": "), "OSL_ASSERT: %s", "mpTabBar!=nullptr"); } }
 while (false);
      return;
  }

  vcl::Window* pParentWindow = mpTabBar->GetParent();
  const sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor();

  const sal_Int32 nWidth (pParentWindow->GetSizePixel().Width());
  const sal_Int32 nHeight (pParentWindow->GetSizePixel().Height());

  mbIsDeckOpen = (nWidth > nTabBarDefaultWidth);

  if (mnSavedSidebarWidth <= 0)
      mnSavedSidebarWidth = nWidth;

  bool bIsDeckVisible;
  const bool bIsOpening (nWidth > mnWidthOnSplitterButtonDown);
  if (bIsOpening)
      bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthOpenThreshold;
  else
      bIsDeckVisible = nWidth >= nTabBarDefaultWidth + gnWidthCloseThreshold;
  mbIsDeckRequestedOpen = bIsDeckVisible;
  UpdateCloseIndicator(!bIsDeckVisible);

  if (mpCurrentDeck && !mpCurrentDeck->isDisposed())
  {
      SfxSplitWindow* pSplitWindow = GetSplitWindow();
      WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WindowAlign::Right;
      long nDeckX, nTabX;
      if (eAlign == WindowAlign::Left)     // attach the Sidebar towards the left-side of screen
      {
          nDeckX = nTabBarDefaultWidth;
          nTabX = 0;
      }
      else   // attach the Sidebar towards the right-side of screen
      {
          nDeckX = 0;
          nTabX = nWidth - nTabBarDefaultWidth;
      }

      // Place the deck first.
      if (bIsDeckVisible)
      {
          if (comphelper::LibreOfficeKit::isActive())
          {
              // We want to let the layouter use up as much of the
              // height as necessary to make sure no scrollbar is
              // visible. This only works when there are no greedy
              // panes that fill up all available area. So we only
              // use this for the PropertyDeck, which has no such
              // panes, while most other do. This is fine, since
              // it's the PropertyDeck that really has many panes
              // that can collapse or expand. For others, limit
              // the height to something sensible.
              // tdf#130348: Add special case for ChartDeck, too.
              const sal_Int32 nExtHeight = (msCurrentDeckId == "PropertyDeck" ? 2000 :
                                            (msCurrentDeckId == "ChartDeck" ? 1200 : 600));
              // No TabBar in LOK (use nWidth in full).
              mpCurrentDeck->setPosSizePixel(nDeckX, 0, nWidth, nExtHeight);
          }
          else
              mpCurrentDeck->setPosSizePixel(nDeckX, 0, nWidth - nTabBarDefaultWidth, nHeight);
          mpCurrentDeck->Show();
          mpCurrentDeck->RequestLayout();
      }
      else
          mpCurrentDeck->Hide();

      // Now place the tab bar.
      mpTabBar->setPosSizePixel(nTabX, 0, nTabBarDefaultWidth, nHeight);
      if (!comphelper::LibreOfficeKit::isActive())
          mpTabBar->Show(); // Don't show TabBar in LOK.
  }

  // Determine if the closer of the deck can be shown.
  sal_Int32 nMinimalWidth = 0;
  if (mpCurrentDeck && !mpCurrentDeck->isDisposed())
  {
      VclPtr<DeckTitleBar> pTitleBar = mpCurrentDeck->GetTitleBar();
      if (pTitleBar && pTitleBar->IsVisible())
          pTitleBar->SetCloserVisible(CanModifyChildWindowWidth());
      nMinimalWidth = mpCurrentDeck->GetMinimalWidth();
  }

  RestrictWidth(nMinimalWidth);

  mpParentWindow->NotifyResize();
463}

465void SidebarController::ProcessNewWidth (const sal_Int32 nNewWidth)
466{
  if ( ! mbIsDeckRequestedOpen)
      return;

  if (*mbIsDeckRequestedOpen)
  {
      // Deck became large enough to be shown.  Show it.
      mnSavedSidebarWidth = nNewWidth;
      if (!*mbIsDeckOpen)
          RequestOpenDeck();
  }
  else
  {
      // Deck became too small.  Close it completely.
      // If window is wider than the tab bar then mark the deck as being visible, even when it is not.
      // This is to trigger an adjustment of the width to the width of the tab bar.
      mbIsDeckOpen = true;
      RequestCloseDeck();

      if (mnWidthOnSplitterButtonDown > TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor())
          mnSavedSidebarWidth = mnWidthOnSplitterButtonDown;
  }
488}

490void SidebarController::SyncUpdate()
491{
  maPropertyChangeForwarder.Sync();
  maContextChangeUpdate.Sync();
494}

496void SidebarController::UpdateConfigurations()
497{
  if (maCurrentContext == maRequestedContext
      && mnRequestedForceFlags == SwitchFlag_NoForce)
      return;

  if ((maCurrentContext.msApplication != "none") &&
          !maCurrentContext.msApplication.isEmpty())
  {
      mpResourceManager->SaveDecksSettings(maCurrentContext);
      mpResourceManager->SetLastActiveDeck(maCurrentContext, msCurrentDeckId);
  }

  // get last active deck for this application on first update
  if (!maRequestedContext.msApplication.isEmpty() &&
          (maCurrentContext.msApplication != maRequestedContext.msApplication))
  {
      OUString sLastActiveDeck = mpResourceManager->GetLastActiveDeck( maRequestedContext );
      if (!sLastActiveDeck.isEmpty())
          msCurrentDeckId = sLastActiveDeck;
  }

  maCurrentContext = maRequestedContext;

  mpResourceManager->InitDeckContext(GetCurrentContext());

  // Find the set of decks that could be displayed for the new context.
  ResourceManager::DeckContextDescriptorContainer aDecks;

  css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController();

  mpResourceManager->GetMatchingDecks (
      aDecks,
      maCurrentContext,
      mbIsDocumentReadOnly,
      xController);

  // Notify the tab bar about the updated set of decks.
  mpTabBar->SetDecks(aDecks);

  // Find the new deck.  By default that is the same as the old
  // one.  If that is not set or not enabled, then choose the
  // first enabled deck (which is PropertyDeck).
  OUString sNewDeckId;
  for (const auto& rDeck : aDecks)
  {
      if (rDeck.mbIsEnabled)
      {
          if (rDeck.msId == msCurrentDeckId)
          {
              sNewDeckId = msCurrentDeckId;
              break;
          }
          else if (sNewDeckId.getLength() == 0)
              sNewDeckId = rDeck.msId;
      }
  }

  if (sNewDeckId.getLength() == 0)
  {
      // We did not find a valid deck.
      RequestCloseDeck();
      return;
  }

  // Tell the tab bar to highlight the button associated
  // with the deck.
  mpTabBar->HighlightDeck(sNewDeckId);

  std::shared_ptr<DeckDescriptor> xDescriptor = mpResourceManager->GetDeckDescriptor(sNewDeckId);

  if (xDescriptor)
  {
      SwitchToDeck(*xDescriptor, maCurrentContext);
  }
571}

573namespace {

575void collectUIInformation(const OUString& rDeckId)
576{
  EventDescription aDescription;
  aDescription.aAction = "SIDEBAR";
  aDescription.aParent = "MainWindow";
  aDescription.aParameters = {{"PANEL", rDeckId}};
  aDescription.aKeyWord = "CurrentApp";

  UITestLogger::getInstance().logEvent(aDescription);
584}

586}

588void SidebarController::OpenThenToggleDeck (
  const OUString& rsDeckId)
590{
  SfxSplitWindow* pSplitWindow = GetSplitWindow();
  if ( pSplitWindow && !pSplitWindow->IsFadeIn() )
      // tdf#83546 Collapsed sidebar should expand first
      pSplitWindow->FadeIn();
  else if ( IsDeckVisible( rsDeckId ) )
  {
      if( !WasFloatingDeckClosed() )
      {
          // tdf#88241 Summoning an undocked sidebar a second time should close sidebar
          mpParentWindow->Close();
          return;
      }
      else
      {
          // tdf#67627 Clicking a second time on a Deck icon will close the Deck
          RequestCloseDeck();
          return;
      }
  }
  RequestOpenDeck();
  SwitchToDeck(rsDeckId);

  // Make sure the sidebar is wide enough to fit the requested content
  sal_Int32 nRequestedWidth = (mpCurrentDeck->GetMinimalWidth() + TabBar::GetDefaultWidth())
                              * mpTabBar->GetDPIScaleFactor();
  if (mnSavedSidebarWidth < nRequestedWidth)
      SetChildWindowWidth(nRequestedWidth);

  collectUIInformation(rsDeckId);
620}

622void SidebarController::OpenThenSwitchToDeck (
  const OUString& rsDeckId)
624{
  RequestOpenDeck();
  SwitchToDeck(rsDeckId);

628}

630void SidebarController::SwitchToDefaultDeck()
631{
  SwitchToDeck(gsDefaultDeckId);
633}

635void SidebarController::SwitchToDeck (
  const OUString& rsDeckId)
637{
  if (  msCurrentDeckId != rsDeckId
      || ! mbIsDeckOpen
      || mnRequestedForceFlags!=SwitchFlag_NoForce)
  {
      std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rsDeckId);

      if (xDeckDescriptor)
          SwitchToDeck(*xDeckDescriptor, maCurrentContext);
  }
647}

649void SidebarController::CreateDeck(const OUString& rDeckId) {
  CreateDeck(rDeckId, maCurrentContext);
651}

653void SidebarController::CreateDeck(const OUString& rDeckId, const Context& rContext, bool bForceCreate)
654{
  std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rDeckId);

  if (!xDeckDescriptor)
      return;

  VclPtr<Deck> aDeck = xDeckDescriptor->mpDeck;
  if (!aDeck || bForceCreate)
  {
      if (aDeck)
          aDeck.disposeAndClear();

      aDeck = VclPtr<Deck>::Create(
                      *xDeckDescriptor,
                      mpParentWindow,
                      [this]() { return this->RequestCloseDeck(); });
  }
  xDeckDescriptor->mpDeck = aDeck;
  CreatePanels(rDeckId, rContext);
673}

675void SidebarController::CreatePanels(const OUString& rDeckId, const Context& rContext)
676{
  std::shared_ptr<DeckDescriptor> xDeckDescriptor = mpResourceManager->GetDeckDescriptor(rDeckId);

  // init panels bounded to that deck, do not wait them being displayed as may be accessed through API

  VclPtr<Deck> pDeck = xDeckDescriptor->mpDeck;

  ResourceManager::PanelContextDescriptorContainer aPanelContextDescriptors;

  css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController();

  mpResourceManager->GetMatchingPanels(
                                      aPanelContextDescriptors,
                                      rContext,
                                      rDeckId,
                                      xController);

  // Update the panel list.
  const sal_Int32 nNewPanelCount (aPanelContextDescriptors.size());
  SharedPanelContainer aNewPanels;
  sal_Int32 nWriteIndex (0);

  aNewPanels.resize(nNewPanelCount);

  for (sal_Int32 nReadIndex=0; nReadIndex<nNewPanelCount; ++nReadIndex)
  {
      const ResourceManager::PanelContextDescriptor& rPanelContexDescriptor (
          aPanelContextDescriptors[nReadIndex]);

      // Determine if the panel can be displayed.
      const bool bIsPanelVisible (!mbIsDocumentReadOnly || rPanelContexDescriptor.mbShowForReadOnlyDocuments);
      if ( ! bIsPanelVisible)
          continue;

      Panel *const pPanel(pDeck->GetPanel(rPanelContexDescriptor.msId));
      if (pPanel != nullptr)
      {
          pPanel->SetLurkMode(false);
          aNewPanels[nWriteIndex] = pPanel;
          pPanel->SetExpanded( rPanelContexDescriptor.mbIsInitiallyVisible );
          ++nWriteIndex;
      }
      else
      {
              VclPtr<Panel>  aPanel = CreatePanel(
                                          rPanelContexDescriptor.msId,
                                          pDeck->GetPanelParentWindow(),
                                          rPanelContexDescriptor.mbIsInitiallyVisible,
                                          rContext,
                                          pDeck);
              if (aPanel )
              {
                  aNewPanels[nWriteIndex] = aPanel;

                  // Depending on the context we have to change the command
                  // for the "more options" dialog.
                  VclPtr<PanelTitleBar> pTitleBar = aNewPanels[nWriteIndex]->GetTitleBar();
                  if (pTitleBar)
                  {
                      pTitleBar->SetMoreOptionsCommand(
                          rPanelContexDescriptor.msMenuCommand,
                          mxFrame, xController);
                  }
                  ++nWriteIndex;
              }
      }
  }

  // mpCurrentPanels - may miss stuff (?)
  aNewPanels.resize(nWriteIndex);
  pDeck->ResetPanels(aNewPanels);
747}

749void SidebarController::SwitchToDeck (
  const DeckDescriptor& rDeckDescriptor,
  const Context& rContext)
752{
  if (comphelper::LibreOfficeKit::isActive())
  {
      if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
      {
          if (msCurrentDeckId != rDeckDescriptor.msId)
          {
              const std::string hide = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication));
              if (!hide.empty())
                  pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
                                                         (hide + "=false").c_str());
          }

          const std::string show = UnoNameFromDeckId(rDeckDescriptor.msId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication));
          if (!show.empty())
              pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
                                                     (show + "=true").c_str());
      }
  }

  maFocusManager.Clear();

  const bool bForceNewDeck ((mnRequestedForceFlags&SwitchFlag_ForceNewDeck)!=0);
  const bool bForceNewPanels ((mnRequestedForceFlags&SwitchFlag_ForceNewPanels)!=0);
  mnRequestedForceFlags = SwitchFlag_NoForce;

  if (   msCurrentDeckId != rDeckDescriptor.msId
      || bForceNewDeck)
  {
      if (mpCurrentDeck)
          mpCurrentDeck->Hide();

      msCurrentDeckId = rDeckDescriptor.msId;
  }
  mpTabBar->Invalidate();
  mpTabBar->HighlightDeck(msCurrentDeckId);

  // Determine the panels to display in the deck.
  ResourceManager::PanelContextDescriptorContainer aPanelContextDescriptors;

  css::uno::Reference<css::frame::XController> xController = mxCurrentController.is() ? mxCurrentController : mxFrame->getController();

  mpResourceManager->GetMatchingPanels(
      aPanelContextDescriptors,
      rContext,
      rDeckDescriptor.msId,
      xController);

  if (aPanelContextDescriptors.empty())
  {
      // There are no panels to be displayed in the current context.
      if (vcl::EnumContext::GetContextEnum(rContext.msContext) != vcl::EnumContext::Context::Empty)
      {
          // Switch to the "empty" context and try again.
          SwitchToDeck(
              rDeckDescriptor,
              Context(
                  rContext.msApplication,
                  vcl::EnumContext::GetContextName(vcl::EnumContext::Context::Empty)));
          return;
      }
      else
      {
          // This is already the "empty" context. Looks like we have
          // to live with an empty deck.
      }
  }

  // Provide a configuration and Deck object.

  CreateDeck(rDeckDescriptor.msId, rContext, bForceNewDeck);

  if (bForceNewPanels && !bForceNewDeck) // already forced if bForceNewDeck
      CreatePanels(rDeckDescriptor.msId, rContext);

  if (mpCurrentDeck && mpCurrentDeck != rDeckDescriptor.mpDeck)
      mpCurrentDeck->Hide();
  mpCurrentDeck.reset(rDeckDescriptor.mpDeck);

  if ( ! mpCurrentDeck)
      return;

834#ifdef DEBUG
  // Show the context name in the deck title bar.
  VclPtr<DeckTitleBar> pDebugTitleBar = mpCurrentDeck->GetTitleBar();
  if (pDebugTitleBar)
      pDebugTitleBar->SetTitle(rDeckDescriptor.msTitle + " (" + maCurrentContext.msContext + ")");
839#endif

  SfxSplitWindow* pSplitWindow = GetSplitWindow();
  sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor();
  WindowAlign eAlign = pSplitWindow ? pSplitWindow->GetAlign() : WindowAlign::Right;
  long nDeckX;
  if (eAlign == WindowAlign::Left)     // attach the Sidebar towards the left-side of screen
  {
      nDeckX = nTabBarDefaultWidth;
  }
  else   // attach the Sidebar towards the right-side of screen
  {
      nDeckX = 0;
  }

  // Activate the deck and the new set of panels.
  mpCurrentDeck->setPosSizePixel(
      nDeckX,
      0,
      mpParentWindow->GetSizePixel().Width() - nTabBarDefaultWidth,
      mpParentWindow->GetSizePixel().Height());

  mpCurrentDeck->Show();

  mpParentWindow->SetText(rDeckDescriptor.msTitle);

  NotifyResize();

  // Tell the focus manager about the new panels and tab bar
  // buttons.
  maFocusManager.SetDeckTitle(mpCurrentDeck->GetTitleBar());
  maFocusManager.SetPanels(mpCurrentDeck->GetPanels());

  mpTabBar->UpdateFocusManager(maFocusManager);
  UpdateTitleBarIcons();
874}

876void SidebarController::notifyDeckTitle(const OUString& targetDeckId)
877{
  if (msCurrentDeckId == targetDeckId)
  {
      maFocusManager.SetDeckTitle(mpCurrentDeck->GetTitleBar());
      mpTabBar->UpdateFocusManager(maFocusManager);
      UpdateTitleBarIcons();
  }
884}

886VclPtr<Panel> SidebarController::CreatePanel (
  const OUString& rsPanelId,
  vcl::Window* pParentWindow,
  const bool bIsInitiallyExpanded,
  const Context& rContext,
  const VclPtr<Deck>& pDeck)
892{
  std::shared_ptr<PanelDescriptor> xPanelDescriptor = mpResourceManager->GetPanelDescriptor(rsPanelId);

  if (!xPanelDescriptor)
      return nullptr;

  // Create the panel which is the parent window of the UIElement.
  VclPtr<Panel> pPanel = VclPtr<Panel>::Create(
      *xPanelDescriptor,
      pParentWindow,
      bIsInitiallyExpanded,
      [pDeck]() { return pDeck->RequestLayout(); },
      [this]() { return this->GetCurrentContext(); },
      mxFrame);

  // Create the XUIElement.
  Reference<ui::XUIElement> xUIElement (CreateUIElement(
          pPanel->GetComponentInterface(),
          xPanelDescriptor->msImplementationURL,
          xPanelDescriptor->mbWantsCanvas,
          rContext));
  if (xUIElement.is())
  {
      // Initialize the panel and add it to the active deck.
      pPanel->SetUIElement(xUIElement);
  }
  else
  {
      pPanel.disposeAndClear();
  }

  return pPanel;
924}

926Reference<ui::XUIElement> SidebarController::CreateUIElement (
  const Reference<awt::XWindowPeer>& rxWindow,
  const OUString& rsImplementationURL,
  const bool bWantsCanvas,
  const Context& rContext)
931{
  try
  {
      const Reference<XComponentContext> xComponentContext (::comphelper::getProcessComponentContext() );
      const Reference<ui::XUIElementFactory> xUIElementFactory =
             ui::theUIElementFactoryManager::get( xComponentContext );

     // Create the XUIElement.
      ::comphelper::NamedValueCollection aCreationArguments;
      aCreationArguments.put("Frame", makeAny(mxFrame));
      aCreationArguments.put("ParentWindow", makeAny(rxWindow));
      SfxDockingWindow* pSfxDockingWindow = dynamic_cast<SfxDockingWindow*>(mpParentWindow.get());
      if (pSfxDockingWindow != nullptr)
          aCreationArguments.put("SfxBindings", makeAny(reinterpret_cast<sal_uInt64>(&pSfxDockingWindow->GetBindings())));
      aCreationArguments.put("Theme", Theme::GetPropertySet());
      aCreationArguments.put("Sidebar", makeAny(Reference<ui::XSidebar>(static_cast<ui::XSidebar*>(this))));
      if (bWantsCanvas)
      {
          Reference<rendering::XSpriteCanvas> xCanvas (VCLUnoHelper::GetWindow(rxWindow)->GetSpriteCanvas());
          aCreationArguments.put("Canvas", makeAny(xCanvas));
      }

      if (mxCurrentController.is())
      {
          OUString aModule = Tools::GetModuleName(mxCurrentController);
          if (!aModule.isEmpty())
          {
              aCreationArguments.put("Module", makeAny(aModule));
          }
          aCreationArguments.put("Controller", makeAny(mxCurrentController));
      }

      aCreationArguments.put("ApplicationName", makeAny(rContext.msApplication));
      aCreationArguments.put("ContextName", makeAny(rContext.msContext));

      Reference<ui::XUIElement> xUIElement(
          xUIElementFactory->createUIElement(
              rsImplementationURL,
              aCreationArguments.getPropertyValues()),
          UNO_SET_THROW);

      return xUIElement;
  }
  catch(const Exception&)
  {
      TOOLS_WARN_EXCEPTION("sfx.sidebar", "Cannot create panel " << rsImplementationURL)do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sfx.sidebar")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Cannot create panel "
 << rsImplementationURL << " " << exceptionToString
(tools_warn_exception)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sfx.sidebar"), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "976" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Cannot create panel " << rsImplementationURL
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Cannot create panel " << rsImplementationURL
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sfx.sidebar"
), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "976" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Cannot create panel " << rsImplementationURL
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"sfx.sidebar"), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "976" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Cannot create panel " << rsImplementationURL
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Cannot create panel " << rsImplementationURL
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sfx.sidebar"
), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "976" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
      return nullptr;
  }
979}

981IMPL_LINK(SidebarController, WindowEventHandler, VclWindowEvent&, rEvent, void)void SidebarController::LinkStubWindowEventHandler(void * instance
, VclWindowEvent& data) { return static_cast<SidebarController
 *>(instance)->WindowEventHandler(data); } void SidebarController
::WindowEventHandler(VclWindowEvent& rEvent)
982{
  if (rEvent.GetWindow() == mpParentWindow)
  {
      switch (rEvent.GetId())
      {
          case VclEventId::WindowShow:
          case VclEventId::WindowResize:
              NotifyResize();
              break;

          case VclEventId::WindowDataChanged:
              // Force an update of deck and tab bar to reflect
              // changes in theme (high contrast mode).
              Theme::HandleDataChange();
              UpdateTitleBarIcons();
              mpParentWindow->Invalidate();
              mnRequestedForceFlags |= SwitchFlag_ForceNewDeck | SwitchFlag_ForceNewPanels;
              maContextChangeUpdate.RequestCall();
              break;

          case VclEventId::ObjectDying:
              dispose();
              break;

          case VclEventId::WindowPaint:
              SAL_INFO("sfx.sidebar", "Paint")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sfx.sidebar")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break;
 case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Paint") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sfx.sidebar"), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "1007" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Paint"), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "Paint"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sfx.sidebar")
, ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "1007" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Paint") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sfx.sidebar"), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "1007" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Paint"), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "Paint"; ::sal
::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sfx.sidebar")
, ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "1007" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
              break;

          default:
              break;
      }
  }
  else if (rEvent.GetWindow()==mpSplitWindow && mpSplitWindow!=nullptr)
  {
      switch (rEvent.GetId())
      {
          case VclEventId::WindowMouseButtonDown:
              mnWidthOnSplitterButtonDown = mpParentWindow->GetSizePixel().Width();
              break;

          case VclEventId::WindowMouseButtonUp:
          {
              ProcessNewWidth(mpParentWindow->GetSizePixel().Width());
              mnWidthOnSplitterButtonDown = 0;
              break;
          }

          case VclEventId::ObjectDying:
              dispose();
              break;

          default: break;
       }
  }
1036}

1038void SidebarController::ShowPopupMenu (
  const tools::Rectangle& rButtonBox,
  const ::std::vector<TabBar::DeckMenuData>& rMenuData) const
1041{
  VclPtr<PopupMenu> pMenu = CreatePopupMenu(rMenuData);
  pMenu->SetSelectHdl(LINK(const_cast<SidebarController*>(this), SidebarController, OnMenuItemSelected)::tools::detail::makeLink( ::tools::detail::castTo<SidebarController
 *>(const_cast<SidebarController*>(this)), &SidebarController
::LinkStubOnMenuItemSelected));

  // pass toolbox button rect so the menu can stay open on button up
  tools::Rectangle aBox (rButtonBox);
  aBox.Move(mpTabBar->GetPosPixel().X(), 0);
  const PopupMenuFlags aMenuDirection
      = (comphelper::LibreOfficeKit::isActive() ? PopupMenuFlags::ExecuteLeft
                                                : PopupMenuFlags::ExecuteDown);
  pMenu->Execute(mpParentWindow, aBox, aMenuDirection);
  pMenu.disposeAndClear();
1053}

1055VclPtr<PopupMenu>
1056SidebarController::CreatePopupMenu(const ::std::vector<TabBar::DeckMenuData>& rMenuData) const
1057{
  // Create the top level popup menu.
  auto pMenu = VclPtr<PopupMenu>::Create();
  FloatingWindow* pMenuWindow = dynamic_cast<FloatingWindow*>(pMenu->GetWindow());
  if (pMenuWindow != nullptr)
  {
      pMenuWindow->SetPopupModeFlags(pMenuWindow->GetPopupModeFlags()
                                     | FloatWinPopupFlags::NoMouseUpClose);
  }

  // Create sub menu for customization (hiding of deck tabs), only on desktop.
  VclPtr<PopupMenu> pCustomizationMenu
      = (comphelper::LibreOfficeKit::isActive() ? nullptr : VclPtr<PopupMenu>::Create());

  // Add one entry for every tool panel element to individually make
  // them visible or hide them.
  sal_Int32 nIndex (0);
  for (const auto& rItem : rMenuData)
  {
      const sal_Int32 nMenuIndex (nIndex+MID_FIRST_PANEL);
      pMenu->InsertItem(nMenuIndex, rItem.msDisplayName, MenuItemBits::RADIOCHECK);
      pMenu->CheckItem(nMenuIndex, rItem.mbIsCurrentDeck);
      pMenu->EnableItem(nMenuIndex, rItem.mbIsEnabled && rItem.mbIsActive);

      if (!comphelper::LibreOfficeKit::isActive())
      {
          const sal_Int32 nSubMenuIndex(nIndex + MID_FIRST_HIDE);
          if (rItem.mbIsCurrentDeck)
          {
              // Don't allow the currently visible deck to be disabled.
              pCustomizationMenu->InsertItem(nSubMenuIndex, rItem.msDisplayName,
                                             MenuItemBits::RADIOCHECK);
              pCustomizationMenu->CheckItem(nSubMenuIndex);
          }
          else
          {
              pCustomizationMenu->InsertItem(nSubMenuIndex, rItem.msDisplayName,
                                             MenuItemBits::CHECKABLE);
              pCustomizationMenu->CheckItem(nSubMenuIndex, rItem.mbIsEnabled && rItem.mbIsActive);
          }
      }

      ++nIndex;
  }

  pMenu->InsertSeparator();

  // LOK doesn't support docked/undocked; Sidebar is floating but rendered docked in browser.
  if (!comphelper::LibreOfficeKit::isActive())
  {
      // Add entry for docking or un-docking the tool panel.
      if (mpParentWindow->IsFloatingMode())
      {
          pMenu->InsertItem(MID_LOCK_TASK_PANEL, SfxResId(STR_SFX_DOCKreinterpret_cast<char const *>("STR_SFX_DOCK" "\004" u8"Dock"
)));
          pMenu->SetAccelKey(MID_LOCK_TASK_PANEL, vcl::KeyCode(KEY_F10, true, true, false, false));
      }
      else
      {
          pMenu->InsertItem(MID_UNLOCK_TASK_PANEL, SfxResId(STR_SFX_UNDOCKreinterpret_cast<char const *>("STR_SFX_UNDOCK" "\004" u8"Undock"
)));
          pMenu->SetAccelKey(MID_UNLOCK_TASK_PANEL, vcl::KeyCode(KEY_F10, true, true, false, false));
      }
  }

  pMenu->InsertItem(MID_HIDE_SIDEBAR, SfxResId(SFX_STR_SIDEBAR_HIDE_SIDEBARreinterpret_cast<char const *>("SFX_STR_SIDEBAR_HIDE_SIDEBAR"
 "\004" u8"Close Sidebar")));

  // No Restore or Customize options for LoKit.
  if (!comphelper::LibreOfficeKit::isActive())
  {
      pCustomizationMenu->InsertSeparator();
      pCustomizationMenu->InsertItem(MID_RESTORE_DEFAULT, SfxResId(SFX_STR_SIDEBAR_RESTOREreinterpret_cast<char const *>("SFX_STR_SIDEBAR_RESTORE"
 "\004" u8"Restore Default")));

      pMenu->InsertItem(MID_CUSTOMIZATION, SfxResId(SFX_STR_SIDEBAR_CUSTOMIZATIONreinterpret_cast<char const *>("SFX_STR_SIDEBAR_CUSTOMIZATION"
 "\004" u8"Customization")));
      pMenu->SetPopupMenu(MID_CUSTOMIZATION, pCustomizationMenu);
  }

  pMenu->RemoveDisabledEntries(false);

  return pMenu;
1135}

1137IMPL_LINK(SidebarController, OnMenuItemSelected, Menu*, pMenu, bool)bool SidebarController::LinkStubOnMenuItemSelected(void * instance
, Menu* data) { return static_cast<SidebarController *>
(instance)->OnMenuItemSelected(data); } bool SidebarController
::OnMenuItemSelected(Menu* pMenu)
1138{
  if (pMenu == nullptr)
  {
      OSL_ENSURE(pMenu!=nullptr, "sfx2::sidebar::SidebarController::OnMenuItemSelected: illegal menu!")do { if (true && (!(pMenu!=nullptr))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sfx2/source/sidebar/SidebarController.cxx"
 ":" "1141" ": "), "%s", "sfx2::sidebar::SidebarController::OnMenuItemSelected: illegal menu!"
); } } while (false);
      return false;
  }

  pMenu->Deactivate();
  const sal_Int32 nIndex (pMenu->GetCurItemId());
  switch (nIndex)
  {
      case MID_UNLOCK_TASK_PANEL:
          mpParentWindow->SetFloatingMode(true);
          if (mpParentWindow->IsFloatingMode())
              mpParentWindow->ToTop(ToTopFlags::GrabFocusOnly);
          break;

      case MID_LOCK_TASK_PANEL:
          mpParentWindow->SetFloatingMode(false);
          break;

      case MID_RESTORE_DEFAULT:
          mpTabBar->RestoreHideFlags();
          break;

      case MID_HIDE_SIDEBAR:
      {
          if (!comphelper::LibreOfficeKit::isActive())
          {
              const util::URL aURL(Tools::GetURL(".uno:Sidebar"));
              Reference<frame::XDispatch> xDispatch(Tools::GetDispatch(mxFrame, aURL));
              if (xDispatch.is())
                  xDispatch->dispatch(aURL, Sequence<beans::PropertyValue>());
          }
          else
          {
              // In LOK we don't really destroy the sidebar when "closing";
              // we simply hide it. This is because recreating it is problematic
              // See notes in SidebarDockingWindow::NotifyResize().
              RequestCloseDeck();
          }
          break;
      }
      default:
      {
          try
          {
              if (nIndex >= MID_FIRST_PANEL && nIndex<MID_FIRST_HIDE)
              {
                  RequestOpenDeck();
                  SwitchToDeck(mpTabBar->GetDeckIdForIndex(nIndex - MID_FIRST_PANEL));
              }
              else if (nIndex >=MID_FIRST_HIDE)
                  if (pMenu->GetItemBits(nIndex) == MenuItemBits::CHECKABLE)
                  {
                      mpTabBar->ToggleHideFlag(nIndex-MID_FIRST_HIDE);

                      // Find the set of decks that could be displayed for the new context.
                      ResourceManager::DeckContextDescriptorContainer aDecks;
                      mpResourceManager->GetMatchingDecks (
                                                  aDecks,
                                                  GetCurrentContext(),
                                                  IsDocumentReadOnly(),
                                                  mxFrame->getController());
                      // Notify the tab bar about the updated set of decks.
                      mpTabBar->SetDecks(aDecks);
                      mpTabBar->HighlightDeck(mpCurrentDeck->GetId());
                      mpTabBar->UpdateFocusManager(maFocusManager);
                  }
              mpParentWindow->GrabFocusToDocument();
          }
          catch (RuntimeException&)
          {
          }
      }
      break;
  }

  return true;
1217}

1219void SidebarController::RequestCloseDeck()
1220{
  if (comphelper::LibreOfficeKit::isActive() && mpCurrentDeck)
  {
      const vcl::ILibreOfficeKitNotifier* pNotifier = mpCurrentDeck->GetLOKNotifier();
      auto pMobileNotifier = SfxViewShell::Current();
      const SfxViewShell* pViewShell = SfxViewShell::Current();
      if (pMobileNotifier && pViewShell && pViewShell->isLOKMobilePhone())
      {
          // Mobile phone.
          std::stringstream aStream;
          boost::property_tree::ptree aTree;
          aTree.put("id", mpParentWindow->get_id()); // TODO could be missing - sort out
          aTree.put("type", "dockingwindow");
          aTree.put("text", mpParentWindow->GetText());
          aTree.put("enabled", false);
          boost::property_tree::write_json(aStream, aTree);
          const std::string message = aStream.str();
          pMobileNotifier->libreOfficeKitViewCallback(LOK_CALLBACK_JSDIALOG, message.c_str());
      }
      else if (pNotifier)
          pNotifier->notifyWindow(mpCurrentDeck->GetLOKWindowId(), "close");
  }

  mbIsDeckRequestedOpen = false;
  UpdateDeckOpenState();

  if (!mpCurrentDeck)
      mpTabBar->RemoveDeckHighlight();
1248}

1250void SidebarController::RequestOpenDeck()
1251{
  SfxSplitWindow* pSplitWindow = GetSplitWindow();
  if ( pSplitWindow && !pSplitWindow->IsFadeIn() )
      // tdf#83546 Collapsed sidebar should expand first
      pSplitWindow->FadeIn();

  mbIsDeckRequestedOpen = true;
  UpdateDeckOpenState();
1259}

1261bool SidebarController::IsDeckOpen(const sal_Int32 nIndex)
1262{
  if (nIndex >= 0)
  {
      OUString asDeckId(mpTabBar->GetDeckIdForIndex(nIndex));
      return IsDeckVisible(asDeckId);
  }
  return mbIsDeckOpen && *mbIsDeckOpen;
1269}

1271bool SidebarController::IsDeckVisible(const OUString& rsDeckId)
1272{
  return mbIsDeckOpen && *mbIsDeckOpen && msCurrentDeckId == rsDeckId;
1274}

1276void SidebarController::UpdateDeckOpenState()
1277{
  if ( ! mbIsDeckRequestedOpen)
      // No state requested.
      return;

  const sal_Int32 nTabBarDefaultWidth = TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor();

  // Update (change) the open state when it either has not yet been initialized
  // or when its value differs from the requested state.
  if ( mbIsDeckOpen && *mbIsDeckOpen == *mbIsDeckRequestedOpen )
      return;

  if (*mbIsDeckRequestedOpen)
  {
      if (!mpParentWindow->IsFloatingMode())
      {
          if (mnSavedSidebarWidth <= nTabBarDefaultWidth)
              SetChildWindowWidth(SidebarChildWindow::GetDefaultWidth(mpParentWindow));
          else
              SetChildWindowWidth(mnSavedSidebarWidth);
      }
      else
      {
          // Show the Deck by resizing back to the original size (before hiding).
          Size aNewSize(mpParentWindow->GetFloatingWindow()->GetSizePixel());
          Point aNewPos(mpParentWindow->GetFloatingWindow()->GetPosPixel());

          aNewPos.setX(aNewPos.X() - mnSavedSidebarWidth + nTabBarDefaultWidth);
          aNewSize.setWidth(mnSavedSidebarWidth);

          mpParentWindow->GetFloatingWindow()->SetPosSizePixel(aNewPos, aNewSize);

          if (comphelper::LibreOfficeKit::isActive())
          {
              // Sidebar wide enough to render the menu; enable it.
              mpTabBar->EnableMenuButton(true);

              if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
              {
                  const std::string uno = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication));
                  if (!uno.empty())
                      pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
                                                              (uno + "=true").c_str());
              }
          }
      }
  }
  else
  {
      if ( ! mpParentWindow->IsFloatingMode())
          mnSavedSidebarWidth = SetChildWindowWidth(nTabBarDefaultWidth);
      else
      {
          // Hide the Deck by resizing to the width of the TabBar.
          Size aNewSize(mpParentWindow->GetFloatingWindow()->GetSizePixel());
          Point aNewPos(mpParentWindow->GetFloatingWindow()->GetPosPixel());
          mnSavedSidebarWidth = aNewSize.Width(); // Save the current width to restore.

          aNewPos.setX(aNewPos.X() + mnSavedSidebarWidth - nTabBarDefaultWidth);
          if (comphelper::LibreOfficeKit::isActive())
          {
              // Hide by collapsing, otherwise with 0x0 the client might expect
              // to get valid dimensions on rendering and not collapse the sidebar.
              aNewSize.setWidth(1);
          }
          else
              aNewSize.setWidth(nTabBarDefaultWidth);

          mpParentWindow->GetFloatingWindow()->SetPosSizePixel(aNewPos, aNewSize);

          if (comphelper::LibreOfficeKit::isActive())
          {
              // Sidebar too narrow to render the menu; disable it.
              mpTabBar->EnableMenuButton(false);

              if (const SfxViewShell* pViewShell = mpViewFrame->GetViewShell())
              {
                  const std::string uno = UnoNameFromDeckId(msCurrentDeckId, vcl::EnumContext::Application::Impress == vcl::EnumContext::GetApplicationEnum(GetCurrentContext().msApplication));
                  if (!uno.empty())
                      pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED,
                                                              (uno + "=false").c_str());
              }
          }
      }

      if (mnWidthOnSplitterButtonDown > nTabBarDefaultWidth)
          mnSavedSidebarWidth = mnWidthOnSplitterButtonDown;
      mpParentWindow->SetStyle(mpParentWindow->GetStyle() & ~WB_SIZEABLE);
  }

  mbIsDeckOpen = *mbIsDeckRequestedOpen;
  if (*mbIsDeckOpen && mpCurrentDeck)
      mpCurrentDeck->Show(*mbIsDeckOpen);
  NotifyResize();
1371}

1373bool SidebarController::CanModifyChildWindowWidth()
1374{
  SfxSplitWindow* pSplitWindow = GetSplitWindow();
  if (pSplitWindow == nullptr)
      return false;

  sal_uInt16 nRow (0xffff);
  sal_uInt16 nColumn (0xffff);
  if (pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow))
  {
      sal_uInt16 nRowCount (pSplitWindow->GetWindowCount(nColumn));
      return nRowCount==1;
  }
  else
      return false;
1388}

1390sal_Int32 SidebarController::SetChildWindowWidth (const sal_Int32 nNewWidth)
1391{
  SfxSplitWindow* pSplitWindow = GetSplitWindow();
  if (pSplitWindow == nullptr)
      return 0;

  sal_uInt16 nRow (0xffff);
  sal_uInt16 nColumn (0xffff);
  pSplitWindow->GetWindowPos(mpParentWindow, nColumn, nRow);
  const long nColumnWidth (pSplitWindow->GetLineSize(nColumn));

  vcl::Window* pWindow = mpParentWindow;
  const Size aWindowSize (pWindow->GetSizePixel());

  pSplitWindow->MoveWindow(
      mpParentWindow,
      Size(nNewWidth, aWindowSize.Height()),
      nColumn,
      nRow,
      false);
  static_cast<SplitWindow*>(pSplitWindow)->Split();

  return static_cast<sal_Int32>(nColumnWidth);
1413}

1415void SidebarController::RestrictWidth (sal_Int32 nWidth)
1416{
  SfxSplitWindow* pSplitWindow = GetSplitWindow();
  if (pSplitWindow != nullptr)
  {
      const sal_uInt16 nId (pSplitWindow->GetItemId(mpParentWindow.get()));
      const sal_uInt16 nSetId (pSplitWindow->GetSet(nId));
      const sal_Int32 nRequestedWidth
          = (TabBar::GetDefaultWidth() + nWidth) * mpTabBar->GetDPIScaleFactor();

      pSplitWindow->SetItemSizeRange(
          nSetId,
          Range(nRequestedWidth,
                getMaximumWidth() * mpTabBar->GetDPIScaleFactor()));
  }
1430}

1432SfxSplitWindow* SidebarController::GetSplitWindow()
1433{
  if (mpParentWindow != nullptr)
  {
      SfxSplitWindow* pSplitWindow = dynamic_cast<SfxSplitWindow*>(mpParentWindow->GetParent());
      if (pSplitWindow != mpSplitWindow)
      {
          if (mpSplitWindow != nullptr)
              mpSplitWindow->RemoveEventListener(LINK(this, SidebarController, WindowEventHandler)::tools::detail::makeLink( ::tools::detail::castTo<SidebarController
 *>(this), &SidebarController::LinkStubWindowEventHandler
));

          mpSplitWindow = pSplitWindow;

          if (mpSplitWindow != nullptr)
              mpSplitWindow->AddEventListener(LINK(this, SidebarController, WindowEventHandler)::tools::detail::makeLink( ::tools::detail::castTo<SidebarController
 *>(this), &SidebarController::LinkStubWindowEventHandler
));
      }
      return mpSplitWindow;
  }
  else
      return nullptr;
1451}

1453void SidebarController::UpdateCloseIndicator (const bool bCloseAfterDrag)
1454{
  if (mpParentWindow == nullptr)
      return;

  if (bCloseAfterDrag)
  {
      // Make sure that the indicator exists.
      if ( ! mpCloseIndicator)
      {
          mpCloseIndicator.reset(VclPtr<FixedImage>::Create(mpParentWindow));
          FixedImage* pFixedImage = static_cast<FixedImage*>(mpCloseIndicator.get());
          const Image aImage (Theme::GetImage(Theme::Image_CloseIndicator));
          pFixedImage->SetImage(aImage);
          pFixedImage->SetSizePixel(aImage.GetSizePixel());
          pFixedImage->SetBackground(Theme::GetWallpaper(Theme::Paint_DeckBackground));
      }

      // Place and show the indicator.
      const Size aWindowSize (mpParentWindow->GetSizePixel());
      const Size aImageSize (mpCloseIndicator->GetSizePixel());
      mpCloseIndicator->SetPosPixel(
          Point(
              aWindowSize.Width() - TabBar::GetDefaultWidth() * mpTabBar->GetDPIScaleFactor() - aImageSize.Width(),
              (aWindowSize.Height() - aImageSize.Height())/2));
      mpCloseIndicator->Show();
  }
  else
  {
      // Hide but don't delete the indicator.
      if (mpCloseIndicator)
          mpCloseIndicator->Hide();
  }
1486}

1488void SidebarController::UpdateTitleBarIcons()
1489{
  if ( ! mpCurrentDeck)
      return;

  const bool bIsHighContrastModeActive (Theme::IsHighContrastMode());

  const ResourceManager& rResourceManager = *mpResourceManager;

  // Update the deck icon.
  std::shared_ptr<DeckDescriptor> xDeckDescriptor = rResourceManager.GetDeckDescriptor(mpCurrentDeck->GetId());
  if (xDeckDescriptor && mpCurrentDeck->GetTitleBar())
  {
      const OUString sIconURL(
          bIsHighContrastModeActive
              ? xDeckDescriptor->msHighContrastTitleBarIconURL
              : xDeckDescriptor->msTitleBarIconURL);
      mpCurrentDeck->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame));
  }

  // Update the panel icons.
  const SharedPanelContainer& rPanels (mpCurrentDeck->GetPanels());
  for (const auto& rxPanel : rPanels)
  {
      if ( ! rxPanel)
          continue;
      if (!rxPanel->GetTitleBar())
          continue;
      std::shared_ptr<PanelDescriptor> xPanelDescriptor = rResourceManager.GetPanelDescriptor(rxPanel->GetId());
      if (!xPanelDescriptor)
          continue;
      const OUString sIconURL (
          bIsHighContrastModeActive
             ? xPanelDescriptor->msHighContrastTitleBarIconURL
             : xPanelDescriptor->msTitleBarIconURL);
      rxPanel->GetTitleBar()->SetIcon(Tools::GetImage(sIconURL, mxFrame));
  }
1525}

1527void SidebarController::ShowPanel (const Panel& rPanel)
1528{
  if (mpCurrentDeck)
  {
      if (!IsDeckOpen())
          RequestOpenDeck();
      mpCurrentDeck->ShowPanel(rPanel);
  }
1535}

1537ResourceManager::DeckContextDescriptorContainer SidebarController::GetMatchingDecks()
1538{
  ResourceManager::DeckContextDescriptorContainer aDecks;
  mpResourceManager->GetMatchingDecks (aDecks,
                                      GetCurrentContext(),
                                      IsDocumentReadOnly(),
                                      mxFrame->getController());
  return aDecks;
1545}

1547ResourceManager::PanelContextDescriptorContainer SidebarController::GetMatchingPanels(const OUString& rDeckId)
1548{
  ResourceManager::PanelContextDescriptorContainer aPanels;

  mpResourceManager->GetMatchingPanels(aPanels,
                                      GetCurrentContext(),
                                      rDeckId,
                                      mxFrame->getController());
  return aPanels;
1556}

1558void SidebarController::updateModel(const css::uno::Reference<css::frame::XModel>& xModel)
1559{
  mpResourceManager->UpdateModel(xModel);
1561}

1563void SidebarController::FadeOut()
1564{
  if (mpSplitWindow)
      mpSplitWindow->FadeOut();
1567}

1569void SidebarController::FadeIn()
1570{
  if (mpSplitWindow)
      mpSplitWindow->FadeIn();
1573}

1575tools::Rectangle SidebarController::GetDeckDragArea() const
1576{
  tools::Rectangle aRect;

  if(mpCurrentDeck)
  {
      VclPtr<DeckTitleBar> pTitleBar(mpCurrentDeck->GetTitleBar());

      if(pTitleBar)
      {
          aRect = DeckTitleBar::GetDragArea();
      }
  }

  return aRect;
1590}

1592void SidebarController::frameAction(const css::frame::FrameActionEvent& rEvent)
1593{
  if (rEvent.Frame == mxFrame)
  {
      if (rEvent.Action == css::frame::FrameAction_COMPONENT_DETACHING)
          unregisterSidebarForFrame(this, mxFrame->getController());
      else if (rEvent.Action == css::frame::FrameAction_COMPONENT_REATTACHED)
          registerSidebarForFrame(this, mxFrame->getController());
  }
1601}

1603void SidebarController::saveDeckState()
1604{
  // Impress shutdown : context (frame) is disposed before sidebar disposing
  // calc writer : context (frame) is disposed after sidebar disposing
  // so need to test if GetCurrentContext is still valid regarding msApplication
  if (GetCurrentContext().msApplication != "none")
  {
      mpResourceManager->SaveDecksSettings(GetCurrentContext());
      mpResourceManager->SaveLastActiveDeck(GetCurrentContext(), msCurrentDeckId);
  }
1613}

1615} // end of namespace sfx2::sidebar

1617/* 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<sfx2::sidebar::TabBar>'→
5
←
Returning from copy constructor for 'Reference<sfx2::sidebar::TabBar>'→
      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