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

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 113, column 13 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 ChartController.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 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/chart2/source/controller/inc -I /home/maarten/src/libreoffice/core/chart2/source/inc -I /home/maarten/src/libreoffice/core/chart2/inc -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/CustomTarget/officecfg/registry -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/chart2/source/controller/main/ChartController.cxx

/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx

→

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

20#include <memory>
21#include <sal/config.h>

23#include <set>

25#include <ChartController.hxx>
26#include <servicenames.hxx>
27#include <ResId.hxx>
28#include <dlg_DataSource.hxx>
29#include <ChartModel.hxx>
30#include <ChartModelHelper.hxx>
31#include "ControllerCommandDispatch.hxx"
32#include <strings.hrc>
33#include <chartview/ExplicitValueProvider.hxx>
34#include <ChartViewHelper.hxx>

36#include <ChartWindow.hxx>
37#include <chartview/DrawModelWrapper.hxx>
38#include <DrawViewWrapper.hxx>
39#include <ObjectIdentifier.hxx>
40#include <DiagramHelper.hxx>
41#include <ControllerLockGuard.hxx>
42#include "UndoGuard.hxx"
43#include "ChartDropTargetHelper.hxx"

45#include <dlg_ChartType.hxx>
46#include <AccessibleChartView.hxx>
47#include "DrawCommandDispatch.hxx"
48#include "ShapeController.hxx"
49#include "UndoActions.hxx"
50#include <ViewElementListProvider.hxx>

52#include <cppuhelper/supportsservice.hxx>

54#include <com/sun/star/chart2/XChartDocument.hpp>
55#include <com/sun/star/chart2/data/XDataReceiver.hpp>
56#include <com/sun/star/frame/XController2.hpp>
57#include <com/sun/star/util/CloseVetoException.hpp>
58#include <com/sun/star/util/XModeChangeBroadcaster.hpp>
59#include <com/sun/star/util/XModifyBroadcaster.hpp>
60#include <com/sun/star/frame/LayoutManagerEvents.hpp>
61#include <com/sun/star/frame/XLayoutManagerEventBroadcaster.hpp>
62#include <com/sun/star/document/XUndoManagerSupplier.hpp>
63#include <com/sun/star/ui/XSidebar.hpp>
64#include <com/sun/star/chart2/XChartTypeContainer.hpp>
65#include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
66#include <com/sun/star/chart2/XDataProviderAccess.hpp>

68#include <sal/log.hxx>
69#include <tools/debug.hxx>
70#include <svx/sidebar/SelectionChangeHandler.hxx>
71#include <toolkit/awt/vclxwindow.hxx>
72#include <toolkit/helper/vclunohelper.hxx>
73#include <vcl/svapp.hxx>
74#include <vcl/weld.hxx>
75#include <osl/mutex.hxx>

77#include <sfx2/sidebar/SidebarController.hxx>

79#include <com/sun/star/frame/XLayoutManager.hpp>

81// this is needed to properly destroy the unique_ptr to the AcceleratorExecute
82// object in the DTOR
83#include <svtools/acceleratorexecute.hxx>
84#include <svx/ActionDescriptionProvider.hxx>
85#include <tools/diagnose_ex.h>

87// enable the following define to let the controller listen to model changes and
88// react on this by rebuilding the view
89#define TEST_ENABLE_MODIFY_LISTENER

91namespace chart
92{

94using namespace ::com::sun::star;
95using namespace ::com::sun::star::accessibility;
96using namespace ::com::sun::star::chart2;
97using ::com::sun::star::uno::Reference;
98using ::com::sun::star::uno::Sequence;

100ChartController::ChartController(uno::Reference<uno::XComponentContext> const & xContext) :
  m_aLifeTimeManager( nullptr ),
  m_bSuspended( false ),
  m_xCC(xContext), //@todo is it allowed to hold this context??
  m_aModelMutex(),
  m_aModel( nullptr, m_aModelMutex ),
  m_xViewWindow(),
  m_xChartView(),
  m_pDrawModelWrapper(),
  m_eDragMode(SdrDragMode::Move),
  m_bWaitingForDoubleClick(false),
  m_bWaitingForMouseUp(false),
  m_bFieldButtonDown(false),
  m_bConnectingToView(false),
  m_bDisposed(false),
  m_aDispatchContainer( m_xCC ),
  m_eDrawMode( CHARTDRAW_SELECT ),
  mpSelectionChangeHandler(new svx::sidebar::SelectionChangeHandler(
          [this]() { return this->GetContextName(); },
              this, vcl::EnumContext::Context::Cell))
120{
  m_aDoubleClickTimer.SetInvokeHandler( LINK( this, ChartController, DoubleClickWaitingHdl )::tools::detail::makeLink( ::tools::detail::castTo<ChartController
 *>(this), &ChartController::LinkStubDoubleClickWaitingHdl
) );
122}

124ChartController::~ChartController()
125{
  stopDoubleClickWaiting();
127}

129ChartController::TheModel::TheModel( const uno::Reference< frame::XModel > & xModel ) :
  m_xModel( xModel ),
  m_bOwnership( true )
132{
  m_xCloseable =
      uno::Reference< util::XCloseable >( xModel, uno::UNO_QUERY );
135}

137ChartController::TheModel::~TheModel()
138{
139}

141void ChartController::TheModel::addListener( ChartController* pController )
142{
  if(m_xCloseable.is())
  {
      //if you need to be able to veto against the destruction of the model
      // you must add as a close listener

      //otherwise you 'can' add as closelistener or 'must' add as dispose event listener

      m_xCloseable->addCloseListener(
          static_cast<util::XCloseListener*>(pController) );
  }
  else if( m_xModel.is() )
  {
      //we need to add as dispose event listener
      m_xModel->addEventListener(
          static_cast<util::XCloseListener*>(pController) );
  }

160}

162void ChartController::TheModel::removeListener(  ChartController* pController )
163{
  if(m_xCloseable.is())
      m_xCloseable->removeCloseListener(
          static_cast<util::XCloseListener*>(pController) );

  else if( m_xModel.is() )
      m_xModel->removeEventListener(
          static_cast<util::XCloseListener*>(pController) );
171}

173void ChartController::TheModel::tryTermination()
174{
  if(!m_bOwnership)
      return;

  try
  {
      if(m_xCloseable.is())
      {
          try
          {
              //@todo ? are we allowed to use sal_True here if we have the explicit ownership?
              //I think yes, because there might be other CloseListeners later in the list which might be interested still
              //but make sure that we do not throw the CloseVetoException here ourselves
              //so stop listening before trying to terminate or check the source of queryclosing event
              m_xCloseable->close(true);

              m_bOwnership                = false;
          }
          catch( const util::CloseVetoException& )
          {
              //since we have indicated to give up the ownership with parameter true in close call
              //the one who has thrown the CloseVetoException is the new owner

              SAL_WARN_IF( m_bOwnership, "chart2.main", "a well known owner has caught a CloseVetoException after calling close(true)")do { if (true && (m_bOwnership)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "chart2.main")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "a well known owner has caught a CloseVetoException after calling close(true)"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"
), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "197" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "a well known owner has caught a CloseVetoException after calling close(true)"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "a well known owner has caught a CloseVetoException after calling close(true)"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"
), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "197" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "a well known owner has caught a CloseVetoException after calling close(true)"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"
), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "197" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "a well known owner has caught a CloseVetoException after calling close(true)"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "a well known owner has caught a CloseVetoException after calling close(true)"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"
), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "197" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
              m_bOwnership                = false;
              return;
          }

      }
      else if( m_xModel.is() )
      {
          //@todo correct??
          m_xModel->dispose();
          return;
      }
  }
  catch(const uno::Exception&)
  {
      DBG_UNHANDLED_EXCEPTION( "chart2", "Termination of model failed" )DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "212" ": ", "chart2", "Termination of model failed" );;
  }
214}

216ChartController::TheModelRef::TheModelRef( TheModel* pTheModel, osl::Mutex& rMutex ) :
  m_rModelMutex(rMutex)
218{
  osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
  m_xTheModel = pTheModel;
221}
222ChartController::TheModelRef::TheModelRef( const TheModelRef& rTheModel, ::osl::Mutex& rMutex ) :
  m_rModelMutex(rMutex)
224{
  osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
  m_xTheModel = rTheModel.m_xTheModel;
227}
228ChartController::TheModelRef& ChartController::TheModelRef::operator=(TheModel* pTheModel)
229{
  osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
  m_xTheModel = pTheModel;
  return *this;
233}
234ChartController::TheModelRef& ChartController::TheModelRef::operator=(const TheModelRef& rTheModel)
235{
  osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
  m_xTheModel = rTheModel.operator->();
  return *this;
239}
240ChartController::TheModelRef::~TheModelRef()
241{
  osl::Guard< osl::Mutex > aGuard( m_rModelMutex );
  m_xTheModel.clear();
244}
245bool ChartController::TheModelRef::is() const
246{
  return m_xTheModel.is();
248}

250namespace {

252css::uno::Reference<css::chart2::XChartType> getChartType(
      const css::uno::Reference<css::chart2::XChartDocument>& xChartDoc)
254{
  Reference <chart2::XDiagram > xDiagram = xChartDoc->getFirstDiagram();
  if (!xDiagram.is()) {
      return css::uno::Reference<css::chart2::XChartType>();
  }

  Reference< chart2::XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY_THROW );

  Sequence< Reference< chart2::XCoordinateSystem > > xCooSysSequence( xCooSysContainer->getCoordinateSystems());
  if (!xCooSysSequence.hasElements()) {
      return css::uno::Reference<css::chart2::XChartType>();
  }

  Reference< chart2::XChartTypeContainer > xChartTypeContainer( xCooSysSequence[0], uno::UNO_QUERY_THROW );

  Sequence< Reference< chart2::XChartType > > xChartTypeSequence( xChartTypeContainer->getChartTypes() );

  return xChartTypeSequence[0];
272}

274}

276OUString ChartController::GetContextName()
277{
  if (m_bDisposed)
      return OUString();

  uno::Any aAny = getSelection();
  if (!aAny.hasValue())
      return "Chart";

  OUString aCID;
  aAny >>= aCID;

  if (aCID.isEmpty())
      return "Chart";

  ObjectType eObjectID = ObjectIdentifier::getObjectType(aCID);
  switch (eObjectID)
  {
      case OBJECTTYPE_DATA_SERIES:
          return "Series";
      break;
      case OBJECTTYPE_DATA_ERRORS_X:
      case OBJECTTYPE_DATA_ERRORS_Y:
      case OBJECTTYPE_DATA_ERRORS_Z:
          return "ErrorBar";
      case OBJECTTYPE_AXIS:
          return "Axis";
      case OBJECTTYPE_GRID:
          return "Grid";
      case OBJECTTYPE_DIAGRAM:
          {
              css::uno::Reference<css::chart2::XChartType> xChartType = getChartType(css::uno::Reference<css::chart2::XChartDocument>(getModel(), uno::UNO_QUERY));
              if (xChartType.is() && xChartType->getChartType() == "com.sun.star.chart2.PieChartType")
                  return "ChartElements";
              break;
          }
      case OBJECTTYPE_DATA_CURVE:
      case OBJECTTYPE_DATA_AVERAGE_LINE:
          return "Trendline";
      default:
      break;
  }

  return "Chart";
320}

322// private methods

324bool ChartController::impl_isDisposedOrSuspended() const
325{
  if( m_aLifeTimeManager.impl_isDisposed() )
      return true;

  if( m_bSuspended )
  {
      OSL_FAIL( "This Controller is suspended" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "331" ": "), "%s", "This Controller is suspended"); } } while
 (false);
      return true;
  }
  return false;
335}

337// lang::XServiceInfo

339OUString SAL_CALL ChartController::getImplementationName()
340{
  return CHART_CONTROLLER_SERVICE_IMPLEMENTATION_NAME"com.sun.star.comp.chart2.ChartController";
342}

344sal_Bool SAL_CALL ChartController::supportsService( const OUString& rServiceName )
345{
  return cppu::supportsService(this, rServiceName);
347}

349css::uno::Sequence< OUString > SAL_CALL ChartController::getSupportedServiceNames()
350{
  return {
      CHART_CONTROLLER_SERVICE_NAME"com.sun.star.chart2.ChartController",
      "com.sun.star.frame.Controller"
      //// @todo : add additional services if you support any further
  };
356}

358namespace {

360uno::Reference<ui::XSidebar> getSidebarFromModel(const uno::Reference<frame::XModel>& xModel)
361{
  uno::Reference<container::XChild> xChild(xModel, uno::UNO_QUERY);
  if (!xChild.is())
      return nullptr;

  uno::Reference<frame::XModel> xParent (xChild->getParent(), uno::UNO_QUERY);
  if (!xParent.is())
      return nullptr;

  uno::Reference<frame::XController2> xController(xParent->getCurrentController(), uno::UNO_QUERY);
  if (!xController.is())
      return nullptr;

  uno::Reference<ui::XSidebarProvider> xSidebarProvider  = xController->getSidebar();
  if (!xSidebarProvider.is())
      return nullptr;

  return xSidebarProvider->getSidebar();
379}

381}

383// XController

385void SAL_CALL ChartController::attachFrame(
  const uno::Reference<frame::XFrame>& xFrame )
387{
  SolarMutexGuard aGuard;

  if( impl_isDisposedOrSuspended() ) //@todo? allow attaching the frame while suspended?
      return; //behave passive if already disposed or suspended

  mpSelectionChangeHandler->Connect();

  uno::Reference<ui::XSidebar> xSidebar = getSidebarFromModel(getModel());
  if (xSidebar.is())
  {
      auto pSidebar = dynamic_cast<sfx2::sidebar::SidebarController*>(xSidebar.get());
      assert(pSidebar)(static_cast <bool> (pSidebar) ? void (0) : __assert_fail
 ("pSidebar", "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
, 399, __extension__ __PRETTY_FUNCTION__));
      sfx2::sidebar::SidebarController::registerSidebarForFrame(pSidebar, this);
      pSidebar->updateModel(getModel());
      css::lang::EventObject aEvent;
      mpSelectionChangeHandler->selectionChanged(aEvent);
  }

  if(m_xFrame.is()) //what happens, if we do have a Frame already??
  {
      //@todo? throw exception?
      OSL_FAIL( "there is already a frame attached to the controller" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "409" ": "), "%s", "there is already a frame attached to the controller"
); } } while (false);
      return;
  }

  //--attach frame
  m_xFrame = xFrame; //the frameloader is responsible to call xFrame->setComponent

  //add as disposelistener to the frame (due to persistent reference) ??...:

  //the frame is considered to be owner of this controller and will live longer than we do
  //the frame or the disposer of the frame has the duty to call suspend and dispose on this object
  //so we do not need to add as lang::XEventListener for DisposingEvents right?

  //@todo nothing right???

  //create view @todo is this the correct place here??

  vcl::Window* pParent = nullptr;
  //get the window parent from the frame to use as parent for our new window
  if(xFrame.is())
  {
      uno::Reference< awt::XWindow > xContainerWindow = xFrame->getContainerWindow();
      VCLXWindow* pParentComponent = comphelper::getUnoTunnelImplementation<VCLXWindow>(xContainerWindow);
      assert(pParentComponent)(static_cast <bool> (pParentComponent) ? void (0) : __assert_fail
 ("pParentComponent", "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
, 432, __extension__ __PRETTY_FUNCTION__));
      if (pParentComponent)
          pParentComponent->setVisible(true);

      pParent = VCLUnoHelper::GetWindow( xContainerWindow ).get();
  }

  {
      // calls to VCL
      SolarMutexGuard aSolarGuard;
      auto pChartWindow = VclPtr<ChartWindow>::Create(this,pParent,pParent?pParent->GetStyle():0);
      pChartWindow->SetBackground();//no Background
      m_xViewWindow.set( pChartWindow->GetComponentInterface(), uno::UNO_QUERY );
      pChartWindow->Show();
      m_apDropTargetHelper.reset(
          new ChartDropTargetHelper( pChartWindow->GetDropTarget(),
                                     uno::Reference< chart2::XChartDocument >( getModel(), uno::UNO_QUERY )));

      impl_createDrawViewController();
  }

  //create the menu
  {
      uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
      if( xPropSet.is() )
      {
          try
          {
              uno::Reference< css::frame::XLayoutManager > xLayoutManager;
              xPropSet->getPropertyValue( "LayoutManager" ) >>= xLayoutManager;
              if ( xLayoutManager.is() )
              {
                  xLayoutManager->lock();
                  xLayoutManager->requestElement( "private:resource/menubar/menubar" );
                  //@todo: createElement should become unnecessary, remove when #i79198# is fixed
                  xLayoutManager->createElement( "private:resource/toolbar/standardbar" );
                  xLayoutManager->requestElement( "private:resource/toolbar/standardbar" );
                  //@todo: createElement should become unnecessary, remove when #i79198# is fixed
                  xLayoutManager->createElement( "private:resource/toolbar/toolbar" );
                  xLayoutManager->requestElement( "private:resource/toolbar/toolbar" );

                  // #i12587# support for shapes in chart
                  xLayoutManager->createElement( "private:resource/toolbar/drawbar" );
                  xLayoutManager->requestElement( "private:resource/toolbar/drawbar" );

                  xLayoutManager->requestElement( "private:resource/statusbar/statusbar" );
                  xLayoutManager->unlock();

                  // add as listener to get notified when
                  m_xLayoutManagerEventBroadcaster.set( xLayoutManager, uno::UNO_QUERY );
                  if( m_xLayoutManagerEventBroadcaster.is())
                      m_xLayoutManagerEventBroadcaster->addLayoutManagerEventListener( this );
              }
          }
          catch( const uno::Exception & )
          {
              DBG_UNHANDLED_EXCEPTION("chart2")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "488" ": ", "chart2" );;
          }
      }
  }
492}

494//XModeChangeListener
495void SAL_CALL ChartController::modeChanged( const util::ModeChangeEvent& rEvent )
496{
  SolarMutexGuard aGuard;
  auto pChartWindow(GetChartWindow());
1
Calling 'ChartController::GetChartWindow'→
20
←
Returning; memory was released→
  //adjust controller to view status changes

  if( rEvent.NewMode == "dirty" )
21
←
Taking false branch→
  {
      //the view has become dirty, we should repaint it if we have a window
      if( pChartWindow )
          pChartWindow->ForceInvalidate();
  }
  else if( rEvent.NewMode == "invalid" )
22
←
Taking false branch→
  {
      //the view is about to become invalid so end all actions on it
      impl_invalidateAccessible();
      if( m_pDrawViewWrapper && m_pDrawViewWrapper->IsTextEdit() )
          this->EndTextEdit();
      if( m_pDrawViewWrapper )
      {
          m_pDrawViewWrapper->UnmarkAll();
          m_pDrawViewWrapper->HideSdrPage();
      }
  }
  else
  {
      //the view was rebuild so we can start some actions on it again
      if( !m_bConnectingToView )
23
←
Assuming field 'm_bConnectingToView' is true→
24
←
Taking false branch→
      {
          if(pChartWindow && m_aModel.is() )
          {
              m_bConnectingToView = true;

              GetDrawModelWrapper();
              if(m_pDrawModelWrapper)
              {
                  {
                      if( m_pDrawViewWrapper )
                          m_pDrawViewWrapper->ReInit();
                  }

                  //reselect object
                  if( m_aSelection.hasSelection() )
                      this->impl_selectObjectAndNotiy();
                  else
                      ChartModelHelper::triggerRangeHighlighting( getModel() );

                  impl_initializeAccessible();

                  {
                      if( pChartWindow )
                          pChartWindow->Invalidate();
                  }
              }

              m_bConnectingToView = false;
          }
      }
  }
554}
25
←
Calling implicit destructor for 'VclPtr<chart::ChartWindow>'→
26
←
Calling '~Reference'→

556sal_Bool SAL_CALL ChartController::attachModel( const uno::Reference< frame::XModel > & xModel )
557{
  impl_invalidateAccessible();

  //is called to attach the controller to a new model.
  //return true if attach was successfully, false otherwise (e.g. if you do not work with a model)

  SolarMutexResettableGuard aGuard;
  if( impl_isDisposedOrSuspended() ) //@todo? allow attaching a new model while suspended?
      return false; //behave passive if already disposed or suspended
  aGuard.clear();

  TheModelRef aNewModelRef( new TheModel( xModel), m_aModelMutex);
  TheModelRef aOldModelRef(m_aModel,m_aModelMutex);
  m_aModel = aNewModelRef;

  //--handle relations to the old model if any
  if( aOldModelRef.is() )
  {
      uno::Reference< util::XModeChangeBroadcaster > xViewBroadcaster( m_xChartView, uno::UNO_QUERY );
      if( xViewBroadcaster.is() )
          xViewBroadcaster->removeModeChangeListener(this);
      m_pDrawModelWrapper.reset();

      aOldModelRef->removeListener( this );
#ifdef TEST_ENABLE_MODIFY_LISTENER
      uno::Reference< util::XModifyBroadcaster > xMBroadcaster( aOldModelRef->getModel(),uno::UNO_QUERY );
      if( xMBroadcaster.is())
          xMBroadcaster->removeModifyListener( this );
585#endif
  }

  //--handle relations to the new model
  aNewModelRef->addListener( this );

  aGuard.reset(); // lock for m_aDispatchContainer access
  // set new model at dispatchers
  m_aDispatchContainer.setModel( aNewModelRef->getModel());
  ControllerCommandDispatch * pDispatch = new ControllerCommandDispatch( m_xCC, this, &m_aDispatchContainer );
  pDispatch->initialize();

  // the dispatch container will return "this" for all commands returned by
  // impl_getAvailableCommands().  That means, for those commands dispatch()
  // is called here at the ChartController.
  m_aDispatchContainer.setChartDispatch( pDispatch, impl_getAvailableCommands() );

  DrawCommandDispatch* pDrawDispatch = new DrawCommandDispatch( m_xCC, this );
  pDrawDispatch->initialize();
  m_aDispatchContainer.setDrawCommandDispatch( pDrawDispatch );

  ShapeController* pShapeController = new ShapeController( m_xCC, this );
  pShapeController->initialize();
  m_aDispatchContainer.setShapeController( pShapeController );
  aGuard.clear();

611#ifdef TEST_ENABLE_MODIFY_LISTENER
  uno::Reference< util::XModifyBroadcaster > xMBroadcaster( aNewModelRef->getModel(),uno::UNO_QUERY );
  if( xMBroadcaster.is())
      xMBroadcaster->addModifyListener( this );
615#endif

  // #i119999# Do not do this per default to allow the user to deselect the chart OLE with a single press to ESC
  // select chart area per default:
  // select( uno::Any( ObjectIdentifier::createClassifiedIdentifier( OBJECTTYPE_PAGE, OUString() ) ) );

  uno::Reference< lang::XMultiServiceFactory > xFact( getModel(), uno::UNO_QUERY );
  if( xFact.is())
  {
      m_xChartView = xFact->createInstance( CHART_VIEW_SERVICE_NAME"com.sun.star.chart2.ChartView" );
      GetDrawModelWrapper();
      uno::Reference< util::XModeChangeBroadcaster > xViewBroadcaster( m_xChartView, uno::UNO_QUERY );
      if( xViewBroadcaster.is() )
          xViewBroadcaster->addModeChangeListener(this);
  }

  //the frameloader is responsible to call xModel->connectController
  {
      SolarMutexGuard aGuard2;
      auto pChartWindow(GetChartWindow());
      if( pChartWindow )
          pChartWindow->Invalidate();
  }

  uno::Reference< document::XUndoManagerSupplier > xSuppUndo( getModel(), uno::UNO_QUERY_THROW );
  m_xUndoManager.set( xSuppUndo->getUndoManager(), uno::UNO_SET_THROW );

  return true;
643}

645uno::Reference< frame::XFrame > SAL_CALL ChartController::getFrame()
646{
  //provides access to owner frame of this controller
  //return the frame containing this controller

  return m_xFrame;
651}

653uno::Reference< frame::XModel > SAL_CALL ChartController::getModel()
654{
  //provides access to currently attached model
  //returns the currently attached model

  //return nothing, if you do not have a model
  TheModelRef aModelRef( m_aModel, m_aModelMutex);
  if(aModelRef.is())
      return aModelRef->getModel();

  return uno::Reference< frame::XModel > ();
664}

666uno::Any SAL_CALL ChartController::getViewData()
667{
  //provides access to current view status
  //set of data that can be used to restore the current view status at later time
  //  by using XController::restoreViewData()

  SolarMutexGuard aGuard;
  if( impl_isDisposedOrSuspended() )
      return uno::Any(); //behave passive if already disposed or suspended //@todo? or throw an exception??

  //-- collect current view state
  uno::Any aRet;
  //// @todo integrate specialized implementation

  return aRet;
681}

683void SAL_CALL ChartController::restoreViewData(
  const uno::Any& /* Value */ )
685{
  //restores the view status using the data gotten from a previous call to XController::getViewData()

  SolarMutexGuard aGuard;
  if( impl_isDisposedOrSuspended() )
      return; //behave passive if already disposed or suspended //@todo? or throw an exception??

  //// @todo integrate specialized implementation
693}

695sal_Bool SAL_CALL ChartController::suspend( sal_Bool bSuspend )
696{
  //is called to prepare the controller for closing the view
  //bSuspend==true: force the controller to suspend his work
  //bSuspend==false try to reactivate the controller
  //returns true if request was accepted and of course successfully finished, false otherwise

  //we may show dialogs here to ask the user for saving changes ... @todo?

  SolarMutexGuard aGuard;
  if( m_aLifeTimeManager.impl_isDisposed() )
      return false; //behave passive if already disposed, return false because request was not accepted //@todo? correct

  if(bool(bSuspend) == m_bSuspended)
  {
      OSL_FAIL( "new suspend mode equals old suspend mode" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "710" ": "), "%s", "new suspend mode equals old suspend mode"
); } } while (false);
      return true;
  }

  //change suspend mode
  m_bSuspended = bSuspend;
  return true;
717}

719void ChartController::impl_createDrawViewController()
720{
  SolarMutexGuard aGuard;
  if(!m_pDrawViewWrapper)
  {
      if( m_pDrawModelWrapper )
      {
          m_pDrawViewWrapper.reset( new DrawViewWrapper(m_pDrawModelWrapper->getSdrModel(),GetChartWindow()) );
          m_pDrawViewWrapper->attachParentReferenceDevice( getModel() );
      }
  }
730}

732void ChartController::impl_deleteDrawViewController()
733{
  if( m_pDrawViewWrapper )
  {
      SolarMutexGuard aGuard;
      if( m_pDrawViewWrapper->IsTextEdit() )
          this->EndTextEdit();
      m_pDrawViewWrapper.reset();
  }
741}

743// XComponent (base of XController)

745void SAL_CALL ChartController::dispose()
746{
  m_bDisposed = true;

  if (getModel().is())
  {
      uno::Reference<ui::XSidebar> xSidebar = getSidebarFromModel(getModel());
      if (sfx2::sidebar::SidebarController* pSidebar = dynamic_cast<sfx2::sidebar::SidebarController*>(xSidebar.get()))
      {
          sfx2::sidebar::SidebarController::unregisterSidebarForFrame(pSidebar, this);
      }
  }
  mpSelectionChangeHandler->selectionChanged(css::lang::EventObject());
  mpSelectionChangeHandler->Disconnect();

  try
  {
      //This object should release all resources and references in the
      //easiest possible manner
      //This object must notify all registered listeners using the method
      //<member>XEventListener::disposing</member>

      //hold no mutex
      if( !m_aLifeTimeManager.dispose() )
          return;

771//  OSL_ENSURE( m_bSuspended, "dispose was called but controller is not suspended" );

      this->stopDoubleClickWaiting();

      //end range highlighting
      if( m_aModel.is())
      {
          uno::Reference< view::XSelectionChangeListener > xSelectionChangeListener;
          uno::Reference< chart2::data::XDataReceiver > xDataReceiver( getModel(), uno::UNO_QUERY );
          if( xDataReceiver.is() )
              xSelectionChangeListener.set( xDataReceiver->getRangeHighlighter(), uno::UNO_QUERY );
          if( xSelectionChangeListener.is() )
          {
              uno::Reference< frame::XController > xController( this );
              lang::EventObject aEvent( xController );
              xSelectionChangeListener->disposing( aEvent );
          }
      }

      //--release all resources and references
      {
          uno::Reference< util::XModeChangeBroadcaster > xViewBroadcaster( m_xChartView, uno::UNO_QUERY );
          if( xViewBroadcaster.is() )
              xViewBroadcaster->removeModeChangeListener(this);

          impl_invalidateAccessible();
          SolarMutexGuard aSolarGuard;
          impl_deleteDrawViewController();
          m_pDrawModelWrapper.reset();

          m_apDropTargetHelper.reset();

          //the accessible view is disposed within window destructor of m_pChartWindow
          if(m_xViewWindow.is())
              m_xViewWindow->dispose(); //ChartWindow is deleted via UNO due to dispose of m_xViewWindow (triggered by Framework (Controller pretends to be XWindow also))
          m_xChartView.clear();
      }

      // remove as listener to layout manager events
      if( m_xLayoutManagerEventBroadcaster.is())
      {
          m_xLayoutManagerEventBroadcaster->removeLayoutManagerEventListener( this );
          m_xLayoutManagerEventBroadcaster.set( nullptr );
      }

      m_xFrame.clear();
      m_xUndoManager.clear();

      TheModelRef aModelRef( m_aModel, m_aModelMutex);
      m_aModel = nullptr;

      if( aModelRef.is())
      {
          uno::Reference< frame::XModel > xModel( aModelRef->getModel() );
          if(xModel.is())
              xModel->disconnectController( uno::Reference< frame::XController >( this ));

          aModelRef->removeListener( this );
829#ifdef TEST_ENABLE_MODIFY_LISTENER
          try
          {
              uno::Reference< util::XModifyBroadcaster > xMBroadcaster( aModelRef->getModel(),uno::UNO_QUERY );
              if( xMBroadcaster.is())
                  xMBroadcaster->removeModifyListener( this );
          }
          catch( const uno::Exception & )
          {
              DBG_UNHANDLED_EXCEPTION("chart2")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "838" ": ", "chart2" );;
          }
840#endif
          aModelRef->tryTermination();
      }

      //// @todo integrate specialized implementation
      //e.g. release further resources and references

      SolarMutexGuard g;
      m_aDispatchContainer.DisposeAndClear();
  }
  catch( const uno::Exception & )
  {
      DBG_UNHANDLED_EXCEPTION("chart2")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "852" ": ", "chart2" );;
      assert(!m_xChartView.is())(static_cast <bool> (!m_xChartView.is()) ? void (0) : __assert_fail
 ("!m_xChartView.is()", "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
, 853, __extension__ __PRETTY_FUNCTION__));
  }
}

857void SAL_CALL ChartController::addEventListener(
  const uno::Reference<lang::XEventListener>& xListener )
859{
  SolarMutexGuard aGuard;
  if( impl_isDisposedOrSuspended() )//@todo? allow adding of listeners in suspend mode?
      return; //behave passive if already disposed or suspended

  //--add listener
  m_aLifeTimeManager.m_aListenerContainer.addInterface( cppu::UnoType<lang::XEventListener>::get(), xListener );
866}

868void SAL_CALL ChartController::removeEventListener(
  const uno::Reference<lang::XEventListener>& xListener )
870{
  SolarMutexGuard aGuard;
  if( m_aLifeTimeManager.impl_isDisposed(false) )
      return; //behave passive if already disposed or suspended

  //--remove listener
  m_aLifeTimeManager.m_aListenerContainer.removeInterface( cppu::UnoType<lang::XEventListener>::get(), xListener );
877}

879// util::XCloseListener
880void SAL_CALL ChartController::queryClosing(
  const lang::EventObject& rSource,
  sal_Bool /*bGetsOwnership*/ )
883{
  //do not use the m_aControllerMutex here because this call is not allowed to block

  TheModelRef aModelRef( m_aModel, m_aModelMutex);

  if( !aModelRef.is() )
      return;

  if( aModelRef->getModel() != rSource.Source )
  {
      OSL_FAIL( "queryClosing was called on a controller from an unknown source" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "893" ": "), "%s", "queryClosing was called on a controller from an unknown source"
); } } while (false);
      return;
  }

  //@ todo prepare to closing model -> don't start any further hindering actions
898}

900void SAL_CALL ChartController::notifyClosing(
  const lang::EventObject& rSource )
902{
  //Listener should deregister himself and release all references to the closing object.

  TheModelRef aModelRef( m_aModel, m_aModelMutex);
  if( !impl_releaseThisModel( rSource.Source ) )
      return;

  //--stop listening to the closing model
  aModelRef->removeListener( this );

  // #i79087# If the model using this controller is closed, the frame is
  // expected to be closed as well
  Reference< util::XCloseable > xFrameCloseable( m_xFrame, uno::UNO_QUERY );
  if( xFrameCloseable.is())
  {
      try
      {
          xFrameCloseable->close( false /* DeliverOwnership */ );
          m_xFrame.clear();
      }
      catch( const util::CloseVetoException & )
      {
          // closing was vetoed
      }
  }
927}

929bool ChartController::impl_releaseThisModel(
  const uno::Reference< uno::XInterface > & xModel )
931{
  bool bReleaseModel = false;
  {
      ::osl::Guard< ::osl::Mutex > aGuard( m_aModelMutex );
      if( m_aModel.is() && m_aModel->getModel() == xModel )
      {
          m_aModel = nullptr;
          m_xUndoManager.clear();
          bReleaseModel = true;
      }
  }
  if( bReleaseModel )
  {
      SolarMutexGuard g;
      m_aDispatchContainer.setModel( nullptr );
  }
  return bReleaseModel;
948}

950// util::XEventListener (base of XCloseListener)
951void SAL_CALL ChartController::disposing(
  const lang::EventObject& rSource )
953{
  if( !impl_releaseThisModel( rSource.Source ))
  {
      if( rSource.Source == m_xLayoutManagerEventBroadcaster )
          m_xLayoutManagerEventBroadcaster.set( nullptr );
  }
959}

961void SAL_CALL ChartController::layoutEvent(
  const lang::EventObject& aSource,
  sal_Int16 eLayoutEvent,
  const uno::Any& /* aInfo */ )
965{
  if( eLayoutEvent == frame::LayoutManagerEvents::MERGEDMENUBAR )
  {
      Reference< frame::XLayoutManager > xLM( aSource.Source, uno::UNO_QUERY );
      if( xLM.is())
      {
          xLM->createElement(  "private:resource/statusbar/statusbar" );
          xLM->requestElement( "private:resource/statusbar/statusbar" );
      }
  }
975}

977// XDispatchProvider (required interface)

979namespace
980{

982bool lcl_isFormatObjectCommand( const OUString& aCommand )
983{
  return aCommand == "MainTitle"
      || aCommand == "SubTitle"
      || aCommand == "XTitle"
      || aCommand == "YTitle"
      || aCommand == "ZTitle"
      || aCommand == "SecondaryXTitle"
      || aCommand == "SecondaryYTitle"
      || aCommand == "AllTitles"
      || aCommand == "DiagramAxisX"
      || aCommand == "DiagramAxisY"
      || aCommand == "DiagramAxisZ"
      || aCommand == "DiagramAxisA"
      || aCommand == "DiagramAxisB"
      || aCommand == "DiagramAxisAll"
      || aCommand == "DiagramGridXMain"
      || aCommand == "DiagramGridYMain"
      || aCommand == "DiagramGridZMain"
      || aCommand == "DiagramGridXHelp"
      || aCommand == "DiagramGridYHelp"
      || aCommand == "DiagramGridZHelp"
      || aCommand == "DiagramGridAll"

      || aCommand == "DiagramWall"
      || aCommand == "DiagramFloor"
      || aCommand == "DiagramArea"
      || aCommand == "Legend"

      || aCommand == "FormatWall"
      || aCommand == "FormatFloor"
      || aCommand == "FormatChartArea"
      || aCommand == "FormatLegend"

      || aCommand == "FormatTitle"
      || aCommand == "FormatAxis"
      || aCommand == "FormatDataSeries"
      || aCommand == "FormatDataPoint"
      || aCommand == "FormatDataLabels"
      || aCommand == "FormatDataLabel"
      || aCommand == "FormatXErrorBars"
      || aCommand == "FormatYErrorBars"
      || aCommand == "FormatMeanValue"
      || aCommand == "FormatTrendline"
      || aCommand == "FormatTrendlineEquation"
      || aCommand == "FormatStockLoss"
      || aCommand == "FormatStockGain"
      || aCommand == "FormatMajorGrid"
      || aCommand == "FormatMinorGrid";
1031}

1033} // anonymous namespace

1035uno::Reference<frame::XDispatch> SAL_CALL
  ChartController::queryDispatch(
      const util::URL& rURL,
      const OUString& rTargetFrameName,
      sal_Int32 /* nSearchFlags */)
1040{
  SolarMutexGuard aGuard;

  if ( !m_aLifeTimeManager.impl_isDisposed() && getModel().is() )
  {
      if( !rTargetFrameName.isEmpty() && rTargetFrameName == "_self" )
          return m_aDispatchContainer.getDispatchForURL( rURL );
  }
  return uno::Reference< frame::XDispatch > ();
1049}

1051uno::Sequence<uno::Reference<frame::XDispatch > >
  ChartController::queryDispatches(
      const uno::Sequence<frame::DispatchDescriptor>& xDescripts )
1054{
  SolarMutexGuard g;

  if ( !m_aLifeTimeManager.impl_isDisposed() )
  {
      return m_aDispatchContainer.getDispatchesForURLs( xDescripts );
  }
  return uno::Sequence<uno::Reference<frame::XDispatch > > ();
1062}

1064// frame::XDispatch

1066void SAL_CALL ChartController::dispatch(
  const util::URL& rURL,
  const uno::Sequence< beans::PropertyValue >& rArgs )
1069{
  OUString aCommand = rURL.Path;

  if(aCommand == "LOKSetTextSelection")
  {
      if (rArgs.getLength() == 3)
      {
          sal_Int32 nType = -1;
          rArgs[0].Value >>= nType;
          sal_Int32 nX = 0;
          rArgs[1].Value >>= nX;
          sal_Int32 nY = 0;
          rArgs[2].Value >>= nY;
          executeDispatch_LOKSetTextSelection(nType, nX, nY);
      }
  }
  else if (aCommand == "LOKTransform")
  {
      if (rArgs[0].Name == "Action")
      {
          OUString sAction;
          if ((rArgs[0].Value >>= sAction) && sAction == "PieSegmentDragging")
          {
              if (rArgs[1].Name == "Offset")
              {
                  sal_Int32 nOffset;
                  if (rArgs[1].Value >>= nOffset)
                  {
                      this->executeDispatch_LOKPieSegmentDragging(nOffset);
                  }
              }
          }
      }
      else
      {
          this->executeDispatch_PositionAndSize(&rArgs);
      }
  }
  else if(aCommand == "FillColor")
  {
      if (rArgs.getLength() > 0)
      {
          sal_uInt32 nColor;
          rArgs[0].Value >>= nColor;
          this->executeDispatch_FillColor(nColor);
      }
  }
  else if(aCommand == "Paste")
      this->executeDispatch_Paste();
  else if(aCommand == "Copy" )
      this->executeDispatch_Copy();
  else if(aCommand == "Cut" )
      this->executeDispatch_Cut();
  else if(aCommand == "DataRanges" )
      this->executeDispatch_SourceData();
  else if(aCommand == "Update" ) //Update Chart
  {
      ChartViewHelper::setViewToDirtyState( getModel() );
      SolarMutexGuard aGuard;
      auto pChartWindow(GetChartWindow());
      if( pChartWindow )
          pChartWindow->Invalidate();
  }
  else if(aCommand == "DiagramData" )
      this->executeDispatch_EditData();
  //insert objects
  else if( aCommand == "InsertTitles"
      || aCommand == "InsertMenuTitles")
      this->executeDispatch_InsertTitles();
  else if( aCommand == "InsertMenuLegend" )
      this->executeDispatch_OpenLegendDialog();
  else if( aCommand == "InsertLegend" )
      this->executeDispatch_InsertLegend();
  else if( aCommand == "DeleteLegend" )
      this->executeDispatch_DeleteLegend();
  else if( aCommand == "InsertMenuDataLabels" )
      this->executeDispatch_InsertMenu_DataLabels();
  else if( aCommand == "InsertMenuAxes"
      || aCommand == "InsertRemoveAxes" )
      this->executeDispatch_InsertAxes();
  else if( aCommand == "InsertMenuGrids" )
      this->executeDispatch_InsertGrid();
  else if( aCommand == "InsertMenuTrendlines" )
      this->executeDispatch_InsertMenu_Trendlines();
  else if( aCommand == "InsertMenuMeanValues" )
      this->executeDispatch_InsertMenu_MeanValues();
  else if( aCommand == "InsertMenuXErrorBars" )
      this->executeDispatch_InsertErrorBars(false);
  else if( aCommand == "InsertMenuYErrorBars" )
      this->executeDispatch_InsertErrorBars(true);
  else if( aCommand == "InsertSymbol" )
       this->executeDispatch_InsertSpecialCharacter();
  else if( aCommand == "InsertTrendline" )
       this->executeDispatch_InsertTrendline();
  else if( aCommand == "DeleteTrendline" )
       this->executeDispatch_DeleteTrendline();
  else if( aCommand == "InsertMeanValue" )
      this->executeDispatch_InsertMeanValue();
  else if( aCommand == "DeleteMeanValue" )
      this->executeDispatch_DeleteMeanValue();
  else if( aCommand == "InsertXErrorBars" )
      this->executeDispatch_InsertErrorBars(false);
  else if( aCommand == "InsertYErrorBars" )
      this->executeDispatch_InsertErrorBars(true);
  else if( aCommand == "DeleteXErrorBars" )
      this->executeDispatch_DeleteErrorBars(false);
  else if( aCommand == "DeleteYErrorBars" )
      this->executeDispatch_DeleteErrorBars(true);
  else if( aCommand == "InsertTrendlineEquation" )
       this->executeDispatch_InsertTrendlineEquation();
  else if( aCommand == "DeleteTrendlineEquation" )
       this->executeDispatch_DeleteTrendlineEquation();
  else if( aCommand == "InsertTrendlineEquationAndR2" )
       this->executeDispatch_InsertTrendlineEquation( true );
  else if( aCommand == "InsertR2Value" )
       this->executeDispatch_InsertR2Value();
  else if( aCommand == "DeleteR2Value")
       this->executeDispatch_DeleteR2Value();
  else if( aCommand == "InsertDataLabels" )
      this->executeDispatch_InsertDataLabels();
  else if( aCommand == "InsertDataLabel" )
      this->executeDispatch_InsertDataLabel();
  else if( aCommand == "DeleteDataLabels")
      this->executeDispatch_DeleteDataLabels();
  else if( aCommand == "DeleteDataLabel" )
      this->executeDispatch_DeleteDataLabel();
  else if( aCommand == "ResetAllDataPoints" )
      this->executeDispatch_ResetAllDataPoints();
  else if( aCommand == "ResetDataPoint" )
      this->executeDispatch_ResetDataPoint();
  else if( aCommand == "InsertAxis" )
      this->executeDispatch_InsertAxis();
  else if( aCommand == "InsertMajorGrid" )
      this->executeDispatch_InsertMajorGrid();
  else if( aCommand == "InsertMinorGrid" )
      this->executeDispatch_InsertMinorGrid();
  else if( aCommand == "InsertAxisTitle" )
      this->executeDispatch_InsertAxisTitle();
  else if( aCommand == "DeleteAxis" )
      this->executeDispatch_DeleteAxis();
  else if( aCommand == "DeleteMajorGrid")
      this->executeDispatch_DeleteMajorGrid();
  else if( aCommand == "DeleteMinorGrid" )
      this->executeDispatch_DeleteMinorGrid();
  //format objects
  else if( aCommand == "FormatSelection" )
      this->executeDispatch_ObjectProperties();
  else if( aCommand == "TransformDialog" )
  {
      if ( isShapeContext() )
      {
          this->impl_ShapeControllerDispatch( rURL, rArgs );
      }
      else
      {
          this->executeDispatch_PositionAndSize();
      }
  }
  else if( lcl_isFormatObjectCommand(aCommand) )
      this->executeDispatch_FormatObject(rURL.Path);
  //more format
  else if( aCommand == "DiagramType" )
      this->executeDispatch_ChartType();
  else if( aCommand == "View3D" )
      this->executeDispatch_View3D();
  else if ( aCommand == "Forward" )
  {
      if ( isShapeContext() )
      {
          this->impl_ShapeControllerDispatch( rURL, rArgs );
      }
      else
      {
          this->executeDispatch_MoveSeries( true );
      }
  }
  else if ( aCommand == "Backward" )
  {
      if ( isShapeContext() )
      {
          this->impl_ShapeControllerDispatch( rURL, rArgs );
      }
      else
      {
          this->executeDispatch_MoveSeries( false );
      }
  }
  else if( aCommand == "NewArrangement")
      this->executeDispatch_NewArrangement();
  else if( aCommand == "ToggleLegend" )
      this->executeDispatch_ToggleLegend();
  else if( aCommand == "ToggleGridHorizontal" )
      this->executeDispatch_ToggleGridHorizontal();
  else if( aCommand == "ToggleGridVertical" )
      this->executeDispatch_ToggleGridVertical();
  else if( aCommand == "ScaleText" )
      this->executeDispatch_ScaleText();
  else if( aCommand == "StatusBarVisible" )
  {
      // workaround: this should not be necessary.
      uno::Reference< beans::XPropertySet > xPropSet( m_xFrame, uno::UNO_QUERY );
      if( xPropSet.is() )
      {
          uno::Reference< css::frame::XLayoutManager > xLayoutManager;
          xPropSet->getPropertyValue( "LayoutManager" ) >>= xLayoutManager;
          if ( xLayoutManager.is() )
          {
              bool bIsVisible( xLayoutManager->isElementVisible( "private:resource/statusbar/statusbar" ));
              if( bIsVisible )
              {
                  xLayoutManager->hideElement( "private:resource/statusbar/statusbar" );
                  xLayoutManager->destroyElement( "private:resource/statusbar/statusbar" );
              }
              else
              {
                  xLayoutManager->createElement( "private:resource/statusbar/statusbar" );
                  xLayoutManager->showElement( "private:resource/statusbar/statusbar" );
              }
              // @todo: update menu state (checkmark next to "Statusbar").
          }
      }
  }
1291}

1293void SAL_CALL ChartController::addStatusListener(
  const uno::Reference<frame::XStatusListener >& /* xControl */,
  const util::URL& /* aURL */ )
1296{
  //@todo
1298}

1300void SAL_CALL ChartController::removeStatusListener(
  const uno::Reference<frame::XStatusListener >& /* xControl */,
  const util::URL& /* aURL */ )
1303{
  //@todo
1305}

1307// XContextMenuInterception (optional interface)
1308void SAL_CALL ChartController::registerContextMenuInterceptor(
  const uno::Reference< ui::XContextMenuInterceptor >& /* xInterceptor */)
1310{
  //@todo
1312}

1314void SAL_CALL ChartController::releaseContextMenuInterceptor(
  const uno::Reference< ui::XContextMenuInterceptor > & /* xInterceptor */)
1316{
  //@todo
1318}

1320// ____ XEmbeddedClient ____
1321// implementation see: ChartController_EditData.cxx

1323void ChartController::executeDispatch_ChartType()
1324{
  UndoLiveUpdateGuard aUndoGuard(
      SchResId( STR_ACTION_EDIT_CHARTTYPEreinterpret_cast<char const *>("STR_ACTION_EDIT_CHARTTYPE"
 "\004" u8"Edit chart type") ), m_xUndoManager );

  SolarMutexGuard aSolarGuard;
  //prepare and open dialog
  ChartTypeDialog aDlg(GetChartFrame(), getModel());
  if (aDlg.run() == RET_OK)
  {
      impl_adaptDataSeriesAutoResize();
      aUndoGuard.commit();
  }
1336}

1338void ChartController::executeDispatch_SourceData()
1339{
  //convert properties to ItemSet
  uno::Reference< XChartDocument >   xChartDoc( getModel(), uno::UNO_QUERY );
  OSL_ENSURE( xChartDoc.is(), "Invalid XChartDocument" )do { if (true && (!(xChartDoc.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "1342" ": "), "%s", "Invalid XChartDocument"); } } while
 (false);
  if( !xChartDoc.is() )
      return;

  // If there is a data table we should ask user if we really want to destroy it
  // and switch to data ranges.
  ChartModel& rModel = dynamic_cast<ChartModel&>(*xChartDoc);
  if ( rModel.hasInternalDataProvider() )
  {
      // Check if we will able to create data provider later
      css::uno::Reference< com::sun::star::chart2::XDataProviderAccess > xCreatorDoc(
          rModel.getParent(), uno::UNO_QUERY);
      if (!xCreatorDoc.is())
          return;

      SolarMutexGuard aSolarGuard;

      std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(GetChartFrame(),
                                                     VclMessageType::Question, VclButtonsType::YesNo, SchResId(STR_DLG_REMOVE_DATA_TABLEreinterpret_cast<char const *>("STR_DLG_REMOVE_DATA_TABLE"
 "\004" u8"This chart currently contains an internal data table. Do you want to proceed, deleting the internal data table, and set a new data range?"
))));
      // If "No" then just return
      if (xQueryBox->run() == RET_NO)
          return;

      // Remove data table
      rModel.removeDataProviders();

      // Ask parent document to create new data provider

      uno::Reference< data::XDataProvider > xDataProvider = xCreatorDoc->createDataProvider();
      SAL_WARN_IF( !xDataProvider.is(), "chart2.main", "Data provider was not created" )do { if (true && (!xDataProvider.is())) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "chart2.main")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "Data provider was not created"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"
), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "1371" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Data provider was not created"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Data provider was not created"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "1371" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Data provider was not created") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "1371" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Data provider was not created"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Data provider was not created"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("chart2.main"), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "1371" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      if (xDataProvider.is())
      {
          rModel.attachDataProvider(xDataProvider);
      }
  }

  UndoLiveUpdateGuard aUndoGuard(
      SchResId(STR_ACTION_EDIT_DATA_RANGESreinterpret_cast<char const *>("STR_ACTION_EDIT_DATA_RANGES"
 "\004" u8"Edit data ranges")), m_xUndoManager);

  SolarMutexGuard aSolarGuard;
  ::chart::DataSourceDialog aDlg(GetChartFrame(), xChartDoc, m_xCC);
  if (aDlg.run() == RET_OK)
  {
      impl_adaptDataSeriesAutoResize();
      aUndoGuard.commit();
  }
1388}

1390void ChartController::executeDispatch_MoveSeries( bool bForward )
1391{
  ControllerLockGuardUNO aCLGuard( getModel() );

  //get selected series
  OUString aObjectCID(m_aSelection.getSelectedCID());
  uno::Reference< XDataSeries > xGivenDataSeries( ObjectIdentifier::getDataSeriesForCID( //yyy todo also legend entries and labels?
          aObjectCID, getModel() ) );

  UndoGuardWithSelection aUndoGuard(
      ActionDescriptionProvider::createDescription(
          (bForward ? ActionDescriptionProvider::ActionType::MoveToTop : ActionDescriptionProvider::ActionType::MoveToBottom),
          SchResId(STR_OBJECT_DATASERIESreinterpret_cast<char const *>("STR_OBJECT_DATASERIES" "\004"
 u8"Data Series"))),
      m_xUndoManager );

  bool bChanged = DiagramHelper::moveSeries( ChartModelHelper::findDiagram( getModel() ), xGivenDataSeries, bForward );
  if( bChanged )
  {
      m_aSelection.setSelection( ObjectIdentifier::getMovedSeriesCID( aObjectCID, bForward ) );
      aUndoGuard.commit();
  }
1411}

1413// ____ XMultiServiceFactory ____
1414uno::Reference< uno::XInterface > SAL_CALL
  ChartController::createInstance( const OUString& aServiceSpecifier )
1416{
  uno::Reference< uno::XInterface > xResult;

  if( aServiceSpecifier == CHART_ACCESSIBLE_TEXT_SERVICE_NAME"com.sun.star.accessibility.AccessibleTextComponent" )
      xResult.set( impl_createAccessibleTextContext());
  return xResult;
1422}

1424uno::Reference< uno::XInterface > SAL_CALL
  ChartController::createInstanceWithArguments(
      const OUString& ServiceSpecifier,
      const uno::Sequence< uno::Any >& /* Arguments */ )
1428{
  // ignore Arguments
  return createInstance( ServiceSpecifier );
1431}

1433uno::Sequence< OUString > SAL_CALL
  ChartController::getAvailableServiceNames()
1435{
  uno::Sequence< OUString > aServiceNames { CHART_ACCESSIBLE_TEXT_SERVICE_NAME"com.sun.star.accessibility.AccessibleTextComponent" };
  return aServiceNames;
1438}

1440// ____ XModifyListener ____
1441void SAL_CALL ChartController::modified(
  const lang::EventObject& /* aEvent */ )
1443{
  // the source can also be a subobject of the ChartModel
  // @todo: change the source in ChartModel to always be the model itself ?
  //todo? update menu states ?
1447}

1449void ChartController::NotifyUndoActionHdl( std::unique_ptr<SdrUndoAction> pUndoAction )
1450{
  ENSURE_OR_RETURN_VOID( pUndoAction, "invalid Undo action" )if( !(pUndoAction) ) { do { if (true && (!(pUndoAction
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "1451" ": "), "%s", "invalid Undo action"); } } while (false
); return; };

  OUString aObjectCID = m_aSelection.getSelectedCID();
  if ( !aObjectCID.isEmpty() )
      return;

  try
  {
      const Reference< document::XUndoManagerSupplier > xSuppUndo( getModel(), uno::UNO_QUERY_THROW );
      const Reference< document::XUndoManager > xUndoManager( xSuppUndo->getUndoManager(), uno::UNO_SET_THROW );
      const Reference< document::XUndoAction > xAction( new impl::ShapeUndoElement( std::move(pUndoAction) ) );
      xUndoManager->addUndoAction( xAction );
  }
  catch( const uno::Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("chart2")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/chart2/source/controller/main/ChartController.cxx"
 ":" "1466" ": ", "chart2" );;
  }
1468}

1470DrawModelWrapper* ChartController::GetDrawModelWrapper()
1471{
  if( !m_pDrawModelWrapper )
  {
      ExplicitValueProvider* pProvider = comphelper::getUnoTunnelImplementation<ExplicitValueProvider>( m_xChartView );
      if( pProvider )
          m_pDrawModelWrapper = pProvider->getDrawModelWrapper();
      if ( m_pDrawModelWrapper )
      {
          m_pDrawModelWrapper->getSdrModel().SetNotifyUndoActionHdl(
              std::bind(&ChartController::NotifyUndoActionHdl, this, std::placeholders::_1) );
      }
  }
  return m_pDrawModelWrapper.get();
1484}

1486DrawViewWrapper* ChartController::GetDrawViewWrapper()
1487{
  if ( !m_pDrawViewWrapper )
  {
      impl_createDrawViewController();
  }
  return m_pDrawViewWrapper.get();
1493}


1496VclPtr<ChartWindow> ChartController::GetChartWindow() const
1497{
  // clients getting the naked VCL Window from UNO should always have the
  // solar mutex (and keep it over the lifetime of this ptr), as VCL might
  // might deinit otherwise
  DBG_TESTSOLARMUTEX()do { DbgTestSolarMutex(); } while(false);
2
←
Loop condition is false.  Exiting loop→
  if(!m_xViewWindow.is())
3
←
Taking false branch→
      return nullptr;
  return dynamic_cast<ChartWindow*>(VCLUnoHelper::GetWindow(m_xViewWindow).get());
4
←
Calling constructor for 'VclPtr<chart::ChartWindow>'→
9
←
Returning from constructor for 'VclPtr<chart::ChartWindow>'→
10
←
Calling implicit destructor for 'VclPtr<vcl::Window>'→
11
←
Calling '~Reference'→
18
←
Returning from '~Reference'→
19
←
Returning from destructor for 'VclPtr<vcl::Window>'→
1505}

1507weld::Window* ChartController::GetChartFrame()
1508{
  // clients getting the naked VCL Window from UNO should always have the
  // solar mutex (and keep it over the lifetime of this ptr), as VCL might
  // might deinit otherwise
  DBG_TESTSOLARMUTEX()do { DbgTestSolarMutex(); } while(false);
  return Application::GetFrameWeld(m_xViewWindow);
1514}

1516bool ChartController::isAdditionalShapeSelected() const
1517{
  return m_aSelection.isAdditionalShapeSelected();
1519}

1521void ChartController::SetAndApplySelection(const Reference<drawing::XShape>& rxShape)
1522{
  if(rxShape.is())
  {
      m_aSelection.setSelection(rxShape);
      m_aSelection.applySelection(GetDrawViewWrapper());
  }
1528}



1532uno::Reference< XAccessible > ChartController::CreateAccessible()
1533{
  uno::Reference< XAccessible > xResult = new AccessibleChartView( GetDrawViewWrapper() );
  impl_initializeAccessible( uno::Reference< lang::XInitialization >( xResult, uno::UNO_QUERY ) );
  return xResult;
1537}

1539void ChartController::impl_invalidateAccessible()
1540{
  SolarMutexGuard aGuard;
  auto pChartWindow(GetChartWindow());
  if( pChartWindow )
  {
      Reference< lang::XInitialization > xInit( pChartWindow->GetAccessible(false), uno::UNO_QUERY );
      if(xInit.is())
      {
          uno::Sequence< uno::Any > aArguments(3);//empty arguments -> invalid accessible
          xInit->initialize(aArguments);
      }
  }
1552}
1553void ChartController::impl_initializeAccessible()
1554{
  SolarMutexGuard aGuard;
  auto pChartWindow(GetChartWindow());
  if( pChartWindow )
      this->impl_initializeAccessible( Reference< lang::XInitialization >( pChartWindow->GetAccessible(false), uno::UNO_QUERY ) );
1559}
1560void ChartController::impl_initializeAccessible( const uno::Reference< lang::XInitialization >& xInit )
1561{
  if(!xInit.is())
      return;

  uno::Sequence< uno::Any > aArguments(5);
  aArguments[0] <<= uno::Reference<view::XSelectionSupplier>(this);
  aArguments[1] <<= getModel();
  aArguments[2] <<= m_xChartView;
  uno::Reference< XAccessible > xParent;
  {
      SolarMutexGuard aGuard;
      auto pChartWindow(GetChartWindow());
      if( pChartWindow )
      {
          vcl::Window* pParentWin( pChartWindow->GetAccessibleParentWindow());
          if( pParentWin )
              xParent.set( pParentWin->GetAccessible());
      }
  }
  aArguments[3] <<= xParent;
  aArguments[4] <<= m_xViewWindow;

  xInit->initialize(aArguments);
1584}

1586const o3tl::sorted_vector< OUString >& ChartController::impl_getAvailableCommands()
1587{
  static const o3tl::sorted_vector< OUString > s_AvailableCommands {
      // commands for container forward
      "AddDirect",           "NewDoc",                "Open",
      "Save",                "SaveAs",                "SendMail",
      "EditDoc",             "ExportDirectToPDF",     "PrintDefault",

      // own commands
      "Cut",                "Copy",                 "Paste",
      "DataRanges",         "DiagramData",
      // insert objects
      "InsertMenuTitles",   "InsertTitles",
      "InsertMenuLegend",   "InsertLegend",         "DeleteLegend",
      "InsertMenuDataLabels",
      "InsertMenuAxes",     "InsertRemoveAxes",         "InsertMenuGrids",
      "InsertSymbol",
      "InsertTrendlineEquation",  "InsertTrendlineEquationAndR2",
      "InsertR2Value",      "DeleteR2Value",
      "InsertMenuTrendlines",  "InsertTrendline",
      "InsertMenuMeanValues", "InsertMeanValue",
      "InsertMenuXErrorBars",  "InsertXErrorBars",
      "InsertMenuYErrorBars",   "InsertYErrorBars",
      "InsertDataLabels",   "InsertDataLabel",
      "DeleteTrendline",    "DeleteMeanValue",      "DeleteTrendlineEquation",
      "DeleteXErrorBars",   "DeleteYErrorBars",
      "DeleteDataLabels",   "DeleteDataLabel",
      //format objects
      "FormatSelection",     "TransformDialog",
      "DiagramType",        "View3D",
      "Forward",            "Backward",
      "MainTitle",          "SubTitle",
      "XTitle",             "YTitle",               "ZTitle",
      "SecondaryXTitle",    "SecondaryYTitle",
      "AllTitles",          "Legend",
      "DiagramAxisX",       "DiagramAxisY",         "DiagramAxisZ",
      "DiagramAxisA",       "DiagramAxisB",         "DiagramAxisAll",
      "DiagramGridXMain",   "DiagramGridYMain",     "DiagramGridZMain",
      "DiagramGridXHelp",   "DiagramGridYHelp",     "DiagramGridZHelp",
      "DiagramGridAll",
      "DiagramWall",        "DiagramFloor",         "DiagramArea",

      //context menu - format objects entries
      "FormatWall",        "FormatFloor",         "FormatChartArea",
      "FormatLegend",

      "FormatAxis",           "FormatTitle",
      "FormatDataSeries",     "FormatDataPoint",
      "ResetAllDataPoints",   "ResetDataPoint",
      "FormatDataLabels",     "FormatDataLabel",
      "FormatMeanValue",      "FormatTrendline",      "FormatTrendlineEquation",
      "FormatXErrorBars",     "FormatYErrorBars",
      "FormatStockLoss",      "FormatStockGain",

      "FormatMajorGrid",      "InsertMajorGrid",      "DeleteMajorGrid",
      "FormatMinorGrid",      "InsertMinorGrid",      "DeleteMinorGrid",
      "InsertAxis",           "DeleteAxis",           "InsertAxisTitle",

      // toolbar commands
      "ToggleGridHorizontal", "ToggleGridVertical", "ToggleLegend",         "ScaleText",
      "NewArrangement",     "Update",
      "DefaultColors",      "BarWidth",             "NumberOfLines",
      "ArrangeRow",
      "StatusBarVisible",
      "ChartElementSelector"};
  return s_AvailableCommands;
1652}

1654ViewElementListProvider ChartController::getViewElementListProvider()
1655{
  return ViewElementListProvider(m_pDrawModelWrapper.get());
1657}

1659} //namespace chart

1661extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface *
1662com_sun_star_comp_chart2_ChartController_get_implementation(css::uno::XComponentContext *context,
                                                          css::uno::Sequence<css::uno::Any> const &)
1664{
  return cppu::acquire(new chart::ChartController(context));
1666}

1668/* 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)
5
←
Calling constructor for 'Reference<chart::ChartWindow>'→
8
←
Returning from constructor for 'Reference<chart::ChartWindow>'→
  {}

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

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

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

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

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

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

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

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

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

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

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
      if (aTmp.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)
6
←
Assuming field 'm_pBody' is non-null→
7
←
Taking true branch→
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

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

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

      Does not work for up-casts to ambiguous bases.

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

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody11.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
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
)
12
←
Taking true branch→
27
←
Taking true branch→
          m_pBody->release();
13
←
Calling 'VclReferenceBase::release'→
17
←
Returning; memory was released→
28
←
Use of memory after it is freed
  }

  /** 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_pBody)
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
      }
      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;
  }


  /** 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)
14
←
Assuming the condition is true→
15
←
Taking true branch→
40            delete this;
16
←
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