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

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 192, column 9 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name fmshell.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SVXCORE_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium/public -D COMPONENT_BUILD -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/svx/sdi -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/svx/source/form/fmshell.cxx

/home/maarten/src/libreoffice/core/svx/source/form/fmshell.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 <fmvwimp.hxx>
21#include <svx/fmshell.hxx>
22#include <svx/fmtools.hxx>
23#include <fmprop.hxx>
24#include <fmundo.hxx>
25#include <com/sun/star/beans/XPropertySet.hpp>
26#include <com/sun/star/awt/XTabControllerModel.hpp>
27#include <sfx2/viewfrm.hxx>
28#include <vcl/svapp.hxx>
29#include <vcl/weld.hxx>
30#include <svl/whiter.hxx>
31#include <sfx2/app.hxx>
32#include <svl/intitem.hxx>
33#include <svl/stritem.hxx>
34#include <svl/visitem.hxx>
35#include <unotools/moduleoptions.hxx>
36#include <sfx2/objface.hxx>
37#include <sfx2/request.hxx>
38#include <sfx2/dispatch.hxx>
39#include <svx/svdobj.hxx>
40#include <svx/fmpage.hxx>
41#include <svx/svditer.hxx>

43#include <svx/svxids.hrc>

45#include <svx/fmglob.hxx>
46#include <svl/eitem.hxx>
47#include <tools/diagnose_ex.h>
48#include <svx/svdpage.hxx>
49#include <svx/fmmodel.hxx>
50#include <fmshimp.hxx>
51#include <svx/svdpagv.hxx>
52#include <sfx2/objitem.hxx>
53#include <sfx2/viewsh.hxx>
54#include <fmexpl.hxx>
55#include <formcontrolling.hxx>
56#include <comphelper/types.hxx>
57#include <fmdocumentclassification.hxx>
58#include <formtoolbars.hxx>

60#include <svx/svxdlg.hxx>

62#include <svx/sdrobjectfilter.hxx>

64#define ShellClass_FmFormShell
65#include <svxslots.hxx>

67#include <memory>

69// is used for Invalidate -> maintain it as well
70// sort ascending !!!!!!
71sal_uInt16 const ControllerSlotMap[] =    // slots of the controller
72{
  SID_FM_CONFIG( 10000 + 593 ),
  SID_FM_PUSHBUTTON( 10000 + 594 ),
  SID_FM_RADIOBUTTON( 10000 + 595 ),
  SID_FM_CHECKBOX( 10000 + 596 ),
  SID_FM_FIXEDTEXT( 10000 + 597 ),
  SID_FM_GROUPBOX( 10000 + 598 ),
  SID_FM_EDIT( 10000 + 599 ),
  SID_FM_LISTBOX( 10000 + 600 ),
  SID_FM_COMBOBOX( 10000 + 601 ),
  SID_FM_DBGRID( 10000 + 603 ),
  SID_FM_IMAGEBUTTON( 10000 + 604 ),
  SID_FM_FILECONTROL( 10000 + 605 ),
  SID_FM_NAVIGATIONBAR( 10000 + 607 ),
  SID_FM_CTL_PROPERTIES( 10000 + 613 ),
  SID_FM_PROPERTIES( 10000 + 614 ),
  SID_FM_TAB_DIALOG( 10000 + 615 ),
  SID_FM_ADD_FIELD( 10000 + 623 ),
  SID_FM_DESIGN_MODE( 10000 + 629 ),
  SID_FM_SHOW_FMEXPLORER( 10000 + 633 ),
  SID_FM_SHOW_PROPERTIES( 10000 + 635 ),
  SID_FM_FMEXPLORER_CONTROL( 10000 + 637 ),
  SID_FM_DATEFIELD( 10000 + 704 ),
  SID_FM_TIMEFIELD( 10000 + 705 ),
  SID_FM_NUMERICFIELD( 10000 + 706 ),
  SID_FM_CURRENCYFIELD( 10000 + 707 ),
  SID_FM_PATTERNFIELD( 10000 + 708 ),
  SID_FM_OPEN_READONLY( 10000 + 709 ),
  SID_FM_IMAGECONTROL( 10000 + 710 ),
  SID_FM_USE_WIZARDS( 10000 + 727 ),
  SID_FM_FORMATTEDFIELD( 10000 + 728 ),
  SID_FM_FILTER_NAVIGATOR( 10000 + 732 ),
  SID_FM_AUTOCONTROLFOCUS( 10000 + 763 ),
  SID_FM_SCROLLBAR( 10000 + 768 ),
  SID_FM_SPINBUTTON( 10000 + 769 ),
  SID_FM_SHOW_DATANAVIGATOR( 10000 + 773 ),
  SID_FM_DATANAVIGATOR_CONTROL( 10000 + 774 ),

  0
111};

113using namespace ::com::sun::star::uno;
114using namespace ::com::sun::star::awt;
115using namespace ::com::sun::star::sdbc;
116using namespace ::com::sun::star::sdbcx;
117using namespace ::com::sun::star::beans;
118using namespace ::com::sun::star::form;
119using namespace ::com::sun::star::form::runtime;
120using namespace ::svxform;

122FmDesignModeChangedHint::FmDesignModeChangedHint( bool bDesMode )
  :m_bDesignMode( bDesMode )
124{
125}


128FmDesignModeChangedHint::~FmDesignModeChangedHint()
129{
130}

132SFX_IMPL_INTERFACE(FmFormShell, SfxShell)SfxInterface* FmFormShell::pInterface = nullptr; SfxInterface
* FmFormShell::GetStaticInterface() { if ( !pInterface ) { pInterface
 = new SfxInterface( "FmFormShell", false, GetInterfaceId(), SfxShell
::GetStaticInterface(), aFmFormShellSlots_Impl[0], sal_uInt16
(sizeof(aFmFormShellSlots_Impl) / sizeof(SfxSlot) ) ); InitInterface_Impl
(); } return pInterface; } SfxInterface* FmFormShell::GetInterface
() const { return GetStaticInterface(); } void FmFormShell::RegisterInterface
(const SfxModule* pMod) { GetStaticInterface()->Register(pMod
); }

134void FmFormShell::InitInterface_Impl()
135{
  GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION12, SfxVisibilityFlags::Standard|SfxVisibilityFlags::ReadonlyDoc,
                                          ToolbarId::SvxTbx_Form_Navigation,
                                          SfxShellFeature::FormShowDatabaseBar);

  GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION12, SfxVisibilityFlags::Standard|SfxVisibilityFlags::ReadonlyDoc,
                                          ToolbarId::SvxTbx_Form_Filter,
                                          SfxShellFeature::FormShowFilterBar);

  GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT1, SfxVisibilityFlags::Standard | SfxVisibilityFlags::ReadonlyDoc,
                                          ToolbarId::SvxTbx_Text_Control_Attributes,
                                          SfxShellFeature::FormShowTextControlBar);

  GetStaticInterface()->RegisterChildWindow(SID_FM_ADD_FIELD( 10000 + 623 ), false, SfxShellFeature::FormShowField);
  GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_PROPERTIES( 10000 + 635 ), false, SfxShellFeature::FormShowProperties);
  GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_FMEXPLORER( 10000 + 633 ), false, SfxShellFeature::FormShowExplorer);
  GetStaticInterface()->RegisterChildWindow(SID_FM_FILTER_NAVIGATOR( 10000 + 732 ), false, SfxShellFeature::FormShowFilterNavigator);
  GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_DATANAVIGATOR( 10000 + 773 ), false, SfxShellFeature::FormShowDataNavigator);

  GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT1, SfxVisibilityFlags::Standard,
                                          ToolbarId::SvxTbx_Controls,
                                          SfxShellFeature::FormTBControls);

  GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT1, SfxVisibilityFlags::Standard,
                                          ToolbarId::SvxTbx_FormDesign,
                                          SfxShellFeature::FormTBDesign);
161}


164FmFormShell::FmFormShell( SfxViewShell* _pParent, FmFormView* pView )
          :SfxShell(_pParent)
          ,m_pImpl(new FmXFormShell(*this, _pParent->GetViewFrame()))
          ,m_pFormView( pView )
          ,m_pFormModel( nullptr )
          ,m_nLastSlot( 0 )
          ,m_bDesignMode( true )
          ,m_bHasForms(false)
172{
  SetPool( &SfxGetpApp()->GetPool() );
  SetName( "Form" );

  SetView(m_pFormView);
177}


180FmFormShell::~FmFormShell()
181{
  if ( m_pFormView )
      SetView( nullptr );

  m_pImpl->dispose();
186}


189void FmFormShell::NotifyMarkListChanged(FmFormView* pWhichView)
190{
  FmNavViewMarksChanged aChangeNotification(pWhichView);
  Broadcast(aChangeNotification);
193}


196bool FmFormShell::PrepareClose(bool bUI)
197{
  if (GetImpl()->didPrepareClose_Lock())
      // we already made a PrepareClose for the current modifications of the current form
      return true;

  bool bResult = true;
  // Save the data records, not in DesignMode and FilterMode
  if (!m_bDesignMode && !GetImpl()->isInFilterMode_Lock() &&
      m_pFormView && m_pFormView->GetActualOutDev() &&
      m_pFormView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW)
  {
      SdrPageView* pCurPageView = m_pFormView->GetSdrPageView();

      // sal_uInt16 nPos = pCurPageView ? pCurPageView->GetWinList().Find((OutputDevice*)m_pFormView->GetActualOutDev()) : SDRPAGEVIEWWIN_NOTFOUND;
      SdrPageWindow* pWindow = pCurPageView ? pCurPageView->FindPageWindow(*const_cast<OutputDevice*>(m_pFormView->GetActualOutDev())) : nullptr;

      if(pWindow)
      {
          // First, the current contents of the controls are stored.
          // If everything has gone smoothly, the modified records are stored.
          if (GetImpl()->getActiveController_Lock().is())
          {
              const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures_Lock();
              if ( rController->commitCurrentControl() )
              {
                  const bool bModified = rController->isModifiedRow();

                  if ( bModified && bUI )
                  {
                      SfxViewShell* pShell = GetViewShell();
                      vcl::Window* pShellWnd = pShell ? pShell->GetWindow() : nullptr;
                      weld::Widget* pFrameWeld = pShellWnd ? pShellWnd->GetFrameWeld() : nullptr;
                      std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pFrameWeld, "svx/ui/savemodifieddialog.ui"));
                      std::unique_ptr<weld::MessageDialog> xQry(xBuilder->weld_message_dialog("SaveModifiedDialog"));
                      switch (xQry->run())
                      {
                          case RET_YES:
                              bResult = rController->commitCurrentRecord( );
                              [[fallthrough]];
                          case RET_NO:
                              GetImpl()->didPrepareClose_Lock(true);
                              break;

                          case RET_CANCEL:
                              return false;
                      }
                  }
              }
          }
      }
  }
  return bResult;
249}


252void FmFormShell::impl_setDesignMode(bool bDesign)
253{
  if (m_pFormView)
  {
      if (!bDesign)
          m_nLastSlot = SID_FM_DESIGN_MODE( 10000 + 629 );

      GetImpl()->SetDesignMode_Lock(bDesign);
      // my m_bDesignMode is also set by the Impl ...
  }
  else
  {
      m_bHasForms = false;
      m_bDesignMode = bDesign;
      UIFeatureChanged();
  }

  GetViewShell()->GetViewFrame()->GetBindings().Invalidate(ControllerSlotMap);
270}


273bool FmFormShell::HasUIFeature(SfxShellFeature nFeature) const
274{
  assert((nFeature & ~SfxShellFeature::FormMask) == SfxShellFeature::NONE)(static_cast <bool> ((nFeature & ~SfxShellFeature::
FormMask) == SfxShellFeature::NONE) ? void (0) : __assert_fail
 ("(nFeature & ~SfxShellFeature::FormMask) == SfxShellFeature::NONE"
, "/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
, 275, __extension__ __PRETTY_FUNCTION__));
  bool bResult = false;
  if (nFeature & SfxShellFeature::FormShowDatabaseBar)
  {
      // only if forms are also available
      bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && !GetImpl()->isInFilterMode_Lock();
  }
  else if (nFeature & SfxShellFeature::FormShowFilterBar)
  {
      // only if forms are also available
      bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && GetImpl()->isInFilterMode_Lock();
  }
  else if (nFeature & SfxShellFeature::FormShowFilterNavigator)
  {
      bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && GetImpl()->isInFilterMode_Lock();
  }
  else if (nFeature & SfxShellFeature::FormShowField)
  {
      bResult = m_bDesignMode && m_pFormView && m_bHasForms;
  }
  else if (nFeature & SfxShellFeature::FormShowProperties)
  {
      bResult = m_bDesignMode && m_pFormView && m_bHasForms;
  }
  else if (nFeature & SfxShellFeature::FormShowExplorer)
  {
      bResult = m_bDesignMode; // OJ #101593# && m_pFormView && m_bHasForms;
  }
  else if (nFeature & SfxShellFeature::FormShowTextControlBar)
  {
      bResult = !GetImpl()->IsReadonlyDoc_Lock() && m_pImpl->IsActiveControl_Lock(true);
  }
  else if (nFeature & SfxShellFeature::FormShowDataNavigator)
  {
      bResult = GetImpl()->isEnhancedForm_Lock();
  }
  else if (  (nFeature & SfxShellFeature::FormTBControls)
          || (nFeature & SfxShellFeature::FormTBDesign)
          )
  {
      bResult = true;
  }

  return bResult;
319}


322void FmFormShell::Execute(SfxRequest &rReq)
323{
  sal_uInt16 nSlot = rReq.GetSlot();


  // set MasterSlot
  switch( nSlot )
1
'Default' branch taken. Execution continues on line 357→
  {
      case SID_FM_PUSHBUTTON( 10000 + 594 ):
      case SID_FM_RADIOBUTTON( 10000 + 595 ):
      case SID_FM_CHECKBOX( 10000 + 596 ):
      case SID_FM_FIXEDTEXT( 10000 + 597 ):
      case SID_FM_GROUPBOX( 10000 + 598 ):
      case SID_FM_LISTBOX( 10000 + 600 ):
      case SID_FM_COMBOBOX( 10000 + 601 ):
      case SID_FM_NAVIGATIONBAR( 10000 + 607 ):
      case SID_FM_EDIT( 10000 + 599 ):
      case SID_FM_DBGRID( 10000 + 603 ):
      case SID_FM_IMAGEBUTTON( 10000 + 604 ):
      case SID_FM_IMAGECONTROL( 10000 + 710 ):
      case SID_FM_FILECONTROL( 10000 + 605 ):
      case SID_FM_DATEFIELD( 10000 + 704 ):
      case SID_FM_TIMEFIELD( 10000 + 705 ):
      case SID_FM_NUMERICFIELD( 10000 + 706 ):
      case SID_FM_CURRENCYFIELD( 10000 + 707 ):
      case SID_FM_PATTERNFIELD( 10000 + 708 ):
      case SID_FM_FORMATTEDFIELD( 10000 + 728 ):
      case SID_FM_SCROLLBAR( 10000 + 768 ):
      case SID_FM_SPINBUTTON( 10000 + 769 ):
          m_nLastSlot = nSlot;
          break;
  }


  // set the Identifier and Inventor of the Uno control
  sal_uInt16 nIdentifier = 0;
  switch( nSlot )
2
←
'Default' branch taken. Execution continues on line 425→
  {
      case SID_FM_CHECKBOX( 10000 + 596 ):
          nIdentifier = OBJ_FM_CHECKBOX;
          break;
      case SID_FM_PUSHBUTTON( 10000 + 594 ):
          nIdentifier = OBJ_FM_BUTTON;
          break;
      case SID_FM_FIXEDTEXT( 10000 + 597 ):
          nIdentifier = OBJ_FM_FIXEDTEXT;
          break;
      case SID_FM_LISTBOX( 10000 + 600 ):
          nIdentifier = OBJ_FM_LISTBOX;
          break;
      case SID_FM_EDIT( 10000 + 599 ):
          nIdentifier = OBJ_FM_EDIT;
          break;
      case SID_FM_RADIOBUTTON( 10000 + 595 ):
          nIdentifier = OBJ_FM_RADIOBUTTON;
          break;
      case SID_FM_GROUPBOX( 10000 + 598 ):
          nIdentifier = OBJ_FM_GROUPBOX;
          break;
      case SID_FM_COMBOBOX( 10000 + 601 ):
          nIdentifier = OBJ_FM_COMBOBOX;
          break;
      case SID_FM_NAVIGATIONBAR( 10000 + 607 ):
          nIdentifier = OBJ_FM_NAVIGATIONBAR;
          break;
      case SID_FM_DBGRID( 10000 + 603 ):
          nIdentifier = OBJ_FM_GRID;
          break;
      case SID_FM_IMAGEBUTTON( 10000 + 604 ):
          nIdentifier = OBJ_FM_IMAGEBUTTON;
          break;
      case SID_FM_IMAGECONTROL( 10000 + 710 ):
          nIdentifier = OBJ_FM_IMAGECONTROL;
          break;
      case SID_FM_FILECONTROL( 10000 + 605 ):
          nIdentifier = OBJ_FM_FILECONTROL;
          break;
      case SID_FM_DATEFIELD( 10000 + 704 ):
          nIdentifier = OBJ_FM_DATEFIELD;
          break;
      case SID_FM_TIMEFIELD( 10000 + 705 ):
          nIdentifier = OBJ_FM_TIMEFIELD;
          break;
      case SID_FM_NUMERICFIELD( 10000 + 706 ):
          nIdentifier = OBJ_FM_NUMERICFIELD;
          break;
      case SID_FM_CURRENCYFIELD( 10000 + 707 ):
          nIdentifier = OBJ_FM_CURRENCYFIELD;
          break;
      case SID_FM_PATTERNFIELD( 10000 + 708 ):
          nIdentifier = OBJ_FM_PATTERNFIELD;
          break;
      case SID_FM_FORMATTEDFIELD( 10000 + 728 ):
          nIdentifier = OBJ_FM_FORMATTEDFIELD;
          break;
      case SID_FM_SCROLLBAR( 10000 + 768 ):
          nIdentifier = OBJ_FM_SCROLLBAR;
          break;
      case SID_FM_SPINBUTTON( 10000 + 769 ):
          nIdentifier = OBJ_FM_SPINBUTTON;
          break;
  }

  switch ( nSlot )
3
←
'Default' branch taken. Execution continues on line 490→
  {
      case SID_FM_CHECKBOX( 10000 + 596 ):
      case SID_FM_PUSHBUTTON( 10000 + 594 ):
      case SID_FM_FIXEDTEXT( 10000 + 597 ):
      case SID_FM_LISTBOX( 10000 + 600 ):
      case SID_FM_EDIT( 10000 + 599 ):
      case SID_FM_RADIOBUTTON( 10000 + 595 ):
      case SID_FM_COMBOBOX( 10000 + 601 ):
      case SID_FM_NAVIGATIONBAR( 10000 + 607 ):
      case SID_FM_GROUPBOX( 10000 + 598 ):
      case SID_FM_DBGRID( 10000 + 603 ):
      case SID_FM_IMAGEBUTTON( 10000 + 604 ):
      case SID_FM_IMAGECONTROL( 10000 + 710 ):
      case SID_FM_FILECONTROL( 10000 + 605 ):
      case SID_FM_DATEFIELD( 10000 + 704 ):
      case SID_FM_TIMEFIELD( 10000 + 705 ):
      case SID_FM_NUMERICFIELD( 10000 + 706 ):
      case SID_FM_CURRENCYFIELD( 10000 + 707 ):
      case SID_FM_PATTERNFIELD( 10000 + 708 ):
      case SID_FM_FORMATTEDFIELD( 10000 + 728 ):
      case SID_FM_SCROLLBAR( 10000 + 768 ):
      case SID_FM_SPINBUTTON( 10000 + 769 ):
      {
          const SfxBoolItem* pGrabFocusItem = rReq.GetArg<SfxBoolItem>(SID_FM_TOGGLECONTROLFOCUS( 10000 + 767 ));
          if ( pGrabFocusItem && pGrabFocusItem->GetValue() )
          {   // see below
              SfxViewShell* pShell = GetViewShell();
              vcl::Window* pShellWnd = pShell ? pShell->GetWindow() : nullptr;
              if ( pShellWnd )
                  pShellWnd->GrabFocus();
              break;
          }

          SfxUInt16Item aIdentifierItem( SID_FM_CONTROL_IDENTIFIER( 10000 + 631 ), nIdentifier );
          SfxUInt32Item aInventorItem( SID_FM_CONTROL_INVENTOR( 10000 + 632 ), sal_uInt32(SdrInventor::FmForm) );
          const SfxPoolItem* pArgs[] =
          {
              &aIdentifierItem, &aInventorItem, nullptr
          };
          const SfxPoolItem* pInternalArgs[] =
          {
              nullptr
          };

          GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_CREATE_CONTROL( 10000 + 628 ), SfxCallMode::ASYNCHRON,
                                    pArgs, rReq.GetModifier(), pInternalArgs );

          if ( rReq.GetModifier() & KEY_MOD1 )
          {
              //  #99013# if selected with control key, return focus to current view
              // do this asynchron, so that the creation can be finished first
              // reusing the SID_FM_TOGGLECONTROLFOCUS is somewhat hacky... which it wouldn't if it would have another
              // name, so I do not really have a big problem with this...
              SfxBoolItem aGrabFocusIndicatorItem( SID_FM_TOGGLECONTROLFOCUS( 10000 + 767 ), true );
              GetViewShell()->GetViewFrame()->GetDispatcher()->ExecuteList(
                      nSlot, SfxCallMode::ASYNCHRON,
                      { &aGrabFocusIndicatorItem });
          }

          rReq.Done();
      }   break;
  }

  // individual actions
  switch( nSlot )
4
←
Control jumps to 'case 10622:'  at line 690→
  {
      case SID_FM_FORM_DESIGN_TOOLS( 10000 + 1046 ):
      {
          FormToolboxes aToolboxAccess(GetImpl()->getHostFrame_Lock());
          aToolboxAccess.toggleToolbox( nSlot );
          rReq.Done();
      }
      break;

      case SID_FM_TOGGLECONTROLFOCUS( 10000 + 767 ):
      {
          FmFormView* pFormView = GetFormView();
          if ( !pFormView )
              break;

          // if we execute this ourself, then either the application does not implement an own handling for this,
          // of we're on the top of the dispatcher stack, which means a control has the focus.
          // In the latter case, we put the focus to the document window, otherwise, we focus the first control
          const bool bHasControlFocus = GetImpl()->HasControlFocus_Lock();
          if ( bHasControlFocus )
          {
              if (m_pFormView)
              {
                  const OutputDevice* pDevice = m_pFormView->GetActualOutDev();
                  vcl::Window* pWindow = dynamic_cast< vcl::Window* >( const_cast< OutputDevice* >( pDevice ) );
                  if ( pWindow )
                      pWindow->GrabFocus();
              }
          }
          else
          {
              pFormView->GrabFirstControlFocus( );
          }
      }
      break;

      case SID_FM_VIEW_AS_GRID( 10000 + 761 ):
          GetImpl()->CreateExternalView_Lock();
          break;
      case SID_FM_CONVERTTO_EDIT( 10000 + 734 )          :
      case SID_FM_CONVERTTO_BUTTON( 10000 + 735 )            :
      case SID_FM_CONVERTTO_FIXEDTEXT( 10000 + 736 )     :
      case SID_FM_CONVERTTO_LISTBOX( 10000 + 737 )       :
      case SID_FM_CONVERTTO_CHECKBOX( 10000 + 738 )      :
      case SID_FM_CONVERTTO_RADIOBUTTON( 10000 + 739 )   :
      case SID_FM_CONVERTTO_GROUPBOX( 10000 + 740 )      :
      case SID_FM_CONVERTTO_COMBOBOX( 10000 + 741 )      :
      case SID_FM_CONVERTTO_IMAGEBUTTON( 10000 + 743 )   :
      case SID_FM_CONVERTTO_FILECONTROL( 10000 + 744 )   :
      case SID_FM_CONVERTTO_DATE( 10000 + 745 )          :
      case SID_FM_CONVERTTO_TIME( 10000 + 746 )          :
      case SID_FM_CONVERTTO_NUMERIC( 10000 + 747 )       :
      case SID_FM_CONVERTTO_CURRENCY( 10000 + 748 )      :
      case SID_FM_CONVERTTO_PATTERN( 10000 + 749 )       :
      case SID_FM_CONVERTTO_IMAGECONTROL( 10000 + 750 )  :
      case SID_FM_CONVERTTO_FORMATTED( 10000 + 751 )     :
      case SID_FM_CONVERTTO_SCROLLBAR( 10000 + 770 )     :
      case SID_FM_CONVERTTO_SPINBUTTON( 10000 + 771 )    :
      case SID_FM_CONVERTTO_NAVIGATIONBAR( 10000 + 772 ) :
          GetImpl()->executeControlConversionSlot_Lock(FmXFormShell::SlotToIdent(nSlot));
          // after the conversion, re-determine the selection, since the
          // selected object has changed
          GetImpl()->SetSelection_Lock(GetFormView()->GetMarkedObjectList());
          break;
      case SID_FM_LEAVE_CREATE( 10000 + 726 ):
          m_nLastSlot = 0;
          rReq.Done();
          break;
      case SID_FM_SHOW_PROPERTY_BROWSER( 10000 + 703 ):
      {
          const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(SID_FM_SHOW_PROPERTIES( 10000 + 635 ));
          bool bShow = true;
          if ( pShowItem )
              bShow = pShowItem->GetValue();
          GetImpl()->ShowSelectionProperties_Lock(bShow);

          rReq.Done();
      } break;

      case SID_FM_PROPERTIES( 10000 + 614 ):
      {
          // display the PropertyBrowser
          const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(nSlot);
          bool bShow = pShowItem == nullptr || pShowItem->GetValue();

          InterfaceBag aOnlyTheForm;
          aOnlyTheForm.insert(Reference<XInterface>(GetImpl()->getCurrentForm_Lock(), UNO_QUERY));
          GetImpl()->setCurrentSelection_Lock(aOnlyTheForm);

          GetImpl()->ShowSelectionProperties_Lock(bShow);

          rReq.Done();
      }   break;

      case SID_FM_CTL_PROPERTIES( 10000 + 613 ):
      {
          const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(nSlot);
          bool bShow = pShowItem == nullptr || pShowItem->GetValue();

          OSL_ENSURE( GetImpl()->onlyControlsAreMarked_Lock(), "FmFormShell::Execute: ControlProperties should be disabled!" )do { if (true && (!(GetImpl()->onlyControlsAreMarked_Lock
()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "590" ": "), "%s", "FmFormShell::Execute: ControlProperties should be disabled!"
); } } while (false);
          if ( bShow )
              GetImpl()->selectLastMarkedControls_Lock();
          GetImpl()->ShowSelectionProperties_Lock(bShow);

          rReq.Done();
      }   break;
      case SID_FM_SHOW_PROPERTIES( 10000 + 635 ):
      case SID_FM_ADD_FIELD( 10000 + 623 ):
      case SID_FM_FILTER_NAVIGATOR( 10000 + 732 ):
      case SID_FM_SHOW_DATANAVIGATOR( 10000 + 773 ) :
      {
          GetViewShell()->GetViewFrame()->ToggleChildWindow(nSlot);
          rReq.Done();
      }   break;
      case SID_FM_SHOW_FMEXPLORER( 10000 + 633 ):
      {
          if (!m_pFormView)   // force setting the view
              GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_CREATE_SW_DRAWVIEW( 10000 + 860 ));

          GetViewShell()->GetViewFrame()->ChildWindowExecute(rReq);
          rReq.Done();
      }
      break;

      case SID_FM_TAB_DIALOG( 10000 + 615 ):
      {
          GetImpl()->ExecuteTabOrderDialog_Lock(
              Reference<XTabControllerModel>(GetImpl()->getCurrentForm_Lock(), UNO_QUERY));
          rReq.Done();
      }
      break;

      case SID_FM_DESIGN_MODE( 10000 + 629 ):
      {
          const SfxBoolItem* pDesignItem = rReq.GetArg<SfxBoolItem>(nSlot);
          bool bDesignMode = pDesignItem ? pDesignItem->GetValue() : !m_bDesignMode;
          SetDesignMode( bDesignMode );
          if ( m_bDesignMode == bDesignMode )
              rReq.Done();

          m_nLastSlot = SID_FM_DESIGN_MODE( 10000 + 629 );
      }
      break;

      case SID_FM_AUTOCONTROLFOCUS( 10000 + 763 ):
      {
          FmFormModel* pModel = GetFormModel();
          DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !")do { if (true && (!(pModel))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "638" ": "), "%s", "FmFormShell::Execute : invalid call !"
); } } while (false);
              // should have been disabled in GetState if we don't have a FormModel
          pModel->SetAutoControlFocus( !pModel->GetAutoControlFocus() );
          GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_AUTOCONTROLFOCUS( 10000 + 763 ));
      }
      break;
      case SID_FM_OPEN_READONLY( 10000 + 709 ):
      {
          FmFormModel* pModel = GetFormModel();
          DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !")do { if (true && (!(pModel))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "647" ": "), "%s", "FmFormShell::Execute : invalid call !"
); } } while (false);
              // should have been disabled in GetState if we don't have a FormModel
          pModel->SetOpenInDesignMode( !pModel->GetOpenInDesignMode() );
          GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_OPEN_READONLY( 10000 + 709 ));
      }
      break;
      case SID_FM_USE_WIZARDS( 10000 + 727 ):
      {
          GetImpl()->SetWizardUsing_Lock(!GetImpl()->GetWizardUsing_Lock());
          GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_USE_WIZARDS( 10000 + 727 ));
      }
      break;
      case SID_FM_SEARCH( 10000 + 725 ):
      {
          const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures_Lock();
          if ( rController->commitCurrentControl() && rController->commitCurrentRecord() )
              GetImpl()->ExecuteSearch_Lock();
          rReq.Done();
      }
      break;

      case SID_FM_RECORD_FIRST( 10000 + 616 ):
      case SID_FM_RECORD_PREV( 10000 + 618 ):
      case SID_FM_RECORD_NEXT( 10000 + 617 ):
      case SID_FM_RECORD_LAST( 10000 + 619 ):
      case SID_FM_RECORD_NEW( 10000 + 620 ):
      case SID_FM_REFRESH( 10000 + 724 ):
      case SID_FM_REFRESH_FORM_CONTROL( 10000 + 775 ):
      case SID_FM_RECORD_DELETE( 10000 + 621 ):
      case SID_FM_RECORD_UNDO( 10000 + 630 ):
      case SID_FM_RECORD_SAVE( 10000 + 627 ):
      case SID_FM_REMOVE_FILTER_SORT( 10000 + 711 ):
      case SID_FM_SORTDOWN( 10000 + 713 ):
      case SID_FM_SORTUP( 10000 + 712 ):
      case SID_FM_AUTOFILTER( 10000 + 716 ):
      case SID_FM_ORDERCRIT( 10000 + 714 ):
      case SID_FM_FORM_FILTERED( 10000 + 723 ):
      {
          GetImpl()->ExecuteFormSlot_Lock(nSlot);
          rReq.Done();
      }
      break;

      case SID_FM_RECORD_ABSOLUTE( 10000 + 622 ):
      {
          const svx::ControllerFeatures& rController = GetImpl()->getNavControllerFeatures_Lock();
          sal_Int32 nRecord = -1;

          const SfxItemSet* pArgs = rReq.GetArgs();
          if ( pArgs )
5
←
Assuming 'pArgs' is null→
6
←
Taking false branch→
          {
              const SfxPoolItem* pItem;
              if ( ( pArgs->GetItemState( FN_PARAM_1((20000 + 1100)+60), true, &pItem ) ) == SfxItemState::SET )
              {
                  const SfxInt32Item* pTypedItem = dynamic_cast<const SfxInt32Item* >( pItem );
                  if ( pTypedItem )
                      nRecord = std::max( pTypedItem->GetValue(), sal_Int32(0) );
              }
          }
          else
          {
              SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
              ScopedVclPtr<AbstractFmInputRecordNoDialog> dlg(pFact->CreateFmInputRecordNoDialog(rReq.GetFrameWeld()));
7
←
Calling constructor for 'ScopedVclPtr<AbstractFmInputRecordNoDialog>'→
14
←
Returning from constructor for 'ScopedVclPtr<AbstractFmInputRecordNoDialog>'→
15
←
Calling implicit destructor for 'VclPtr<AbstractFmInputRecordNoDialog>'→
16
←
Calling '~Reference'→
23
←
Returning from '~Reference'→
24
←
Returning from destructor for 'VclPtr<AbstractFmInputRecordNoDialog>'→
              dlg->SetValue( rController->getCursor()->getRow() );
25
←
Calling 'VclPtr::operator->'→
              if ( dlg->Execute() == RET_OK )
                  nRecord = dlg->GetValue();

              rReq.AppendItem( SfxInt32Item( FN_PARAM_1((20000 + 1100)+60), nRecord ) );
          }

          if ( nRecord != -1 )
              rController->execute( nSlot, "Position", makeAny( nRecord ) );

          rReq.Done();
      }   break;
      case SID_FM_FILTER_EXECUTE( 10000 + 731 ):
      case SID_FM_FILTER_EXIT( 10000 + 730 ):
      {
          bool bCancelled = ( SID_FM_FILTER_EXIT( 10000 + 730 ) == nSlot );
          bool bReopenNavigator = false;

          if ( !bCancelled )
          {
              // if the filter navigator is still open, we need to close it, so it can possibly
              // commit it's most recent changes
              if ( GetViewShell() && GetViewShell()->GetViewFrame() )
                  if ( GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR( 10000 + 732 ) ) )
                  {
                      GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR( 10000 + 732 ) );
                      bReopenNavigator = true;
                  }

              Reference<runtime::XFormController> const xController(GetImpl()->getActiveController_Lock());

              if  (   GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR( 10000 + 732 ) )
                      // closing the window was denied, for instance because of an invalid criterion

                  ||  (   xController.is()
                      &&  !GetImpl()->getActiveControllerFeatures_Lock()->commitCurrentControl()
                      )
                      // committing the controller was denied
                  )
              {
                  rReq.Done();
                  break;
              }
          }

          GetImpl()->stopFiltering_Lock(!bCancelled);
          rReq.Done();

          if ( bReopenNavigator )
              // we closed the navigator only to implicitly commit it (as we do not have another
              // direct wire to it), but to the user, it should look as it was always open
              GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR( 10000 + 732 ) );
      }
      break;

      case SID_FM_FILTER_START( 10000 + 729 ):
      {
          GetImpl()->startFiltering_Lock();
          rReq.Done();

          // initially open the filter navigator, the whole form based filter is pretty useless without it
          SfxBoolItem aIdentifierItem( SID_FM_FILTER_NAVIGATOR( 10000 + 732 ), true );
          GetViewShell()->GetViewFrame()->GetDispatcher()->ExecuteList(
                  SID_FM_FILTER_NAVIGATOR( 10000 + 732 ), SfxCallMode::ASYNCHRON,
                  { &aIdentifierItem });
      }   break;
  }
777}


780void FmFormShell::GetState(SfxItemSet &rSet)
781{
  SfxWhichIter aIter( rSet );
  sal_uInt16 nWhich = aIter.FirstWhich();
  while ( nWhich )
  {
      switch( nWhich )
      {
          case SID_FM_FORM_DESIGN_TOOLS( 10000 + 1046 ):
          {
              FormToolboxes aToolboxAccess(GetImpl()->getHostFrame_Lock());
              rSet.Put( SfxBoolItem( nWhich, aToolboxAccess.isToolboxVisible( nWhich ) ) );
          }
          break;

          case SID_FM_FILTER_EXECUTE( 10000 + 731 ):
          case SID_FM_FILTER_EXIT( 10000 + 730 ):
              if (!GetImpl()->isInFilterMode_Lock())
                  rSet.DisableItem( nWhich );
              break;

          case SID_FM_USE_WIZARDS( 10000 + 727 ):
              if  ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) )
                  rSet.Put( SfxVisibilityItem( nWhich, false ) );
              else if (!GetFormModel())
                  rSet.DisableItem( nWhich );
              else
                  rSet.Put(SfxBoolItem(nWhich, GetImpl()->GetWizardUsing_Lock()));
              break;
          case SID_FM_AUTOCONTROLFOCUS( 10000 + 763 ):
              if (!GetFormModel())
                  rSet.DisableItem( nWhich );
              else
                  rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetAutoControlFocus() ) );
              break;
          case SID_FM_OPEN_READONLY( 10000 + 709 ):
              if (!GetFormModel())
                  rSet.DisableItem( nWhich );
              else
                  rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetOpenInDesignMode() ) );
              break;

          case SID_FM_NAVIGATIONBAR( 10000 + 607 ):
          case SID_FM_DBGRID( 10000 + 603 ):
              if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) )
              {
                  rSet.Put( SfxVisibilityItem( nWhich, false ) );
                  break;
              }
              [[fallthrough]];

          case SID_FM_SCROLLBAR( 10000 + 768 ):
          case SID_FM_IMAGECONTROL( 10000 + 710 ):
          case SID_FM_FILECONTROL( 10000 + 605 ):
          case SID_FM_CURRENCYFIELD( 10000 + 707 ):
          case SID_FM_PATTERNFIELD( 10000 + 708 ):
          case SID_FM_IMAGEBUTTON( 10000 + 604 ):
          case SID_FM_RADIOBUTTON( 10000 + 595 ):
          case SID_FM_COMBOBOX( 10000 + 601 ):
          case SID_FM_GROUPBOX( 10000 + 598 ):
          case SID_FM_CHECKBOX( 10000 + 596 ):
          case SID_FM_PUSHBUTTON( 10000 + 594 ):
          case SID_FM_FIXEDTEXT( 10000 + 597 ):
          case SID_FM_LISTBOX( 10000 + 600 ):
          case SID_FM_EDIT( 10000 + 599 ):
          case SID_FM_DATEFIELD( 10000 + 704 ):
          case SID_FM_TIMEFIELD( 10000 + 705 ):
          case SID_FM_NUMERICFIELD( 10000 + 706 ):
          case SID_FM_FORMATTEDFIELD( 10000 + 728 ):
          case SID_FM_SPINBUTTON( 10000 + 769 ):
              if (!m_bDesignMode)
                  rSet.DisableItem( nWhich );
              else
              {
                  bool bLayerLocked = false;
                  if (m_pFormView)
                  {
                      // If the css::drawing::Layer is locked, the slots must be disabled. #36897
                      SdrPageView* pPV = m_pFormView->GetSdrPageView();
                      if (pPV != nullptr)
                          bLayerLocked = pPV->IsLayerLocked(m_pFormView->GetActiveLayer());
                  }
                  if (bLayerLocked)
                      rSet.DisableItem( nWhich );
                  else
                      rSet.Put( SfxBoolItem(nWhich, (nWhich==m_nLastSlot)) );
              }
              break;
          case SID_FM_FILTER_NAVIGATOR_CONTROL( 10000 + 752 ):
          {
              if (GetImpl()->isInFilterMode_Lock())
                  rSet.Put(SfxObjectItem(nWhich, this));
              else
                  rSet.Put(SfxObjectItem(nWhich));
          }   break;
          case SID_FM_FIELDS_CONTROL( 10000 + 634 ):
          case SID_FM_PROPERTY_CONTROL( 10000 + 636 ):
          {
              if (!m_bDesignMode || !m_pFormView || !m_bHasForms)
                  rSet.Put(SfxObjectItem(nWhich));
              else
                  rSet.Put(SfxObjectItem(nWhich, this));

          }   break;
          case SID_FM_FMEXPLORER_CONTROL( 10000 + 637 ):
          case SID_FM_DATANAVIGATOR_CONTROL( 10000 + 774 ) :
          {
              if (!m_bDesignMode || !m_pFormView)
                  rSet.Put(SfxObjectItem(nWhich));
              else
                  rSet.Put(SfxObjectItem(nWhich, this));

          }   break;
          case SID_FM_ADD_FIELD( 10000 + 623 ):
          case SID_FM_SHOW_FMEXPLORER( 10000 + 633 ):
          case SID_FM_SHOW_PROPERTIES( 10000 + 635 ):
          case SID_FM_FILTER_NAVIGATOR( 10000 + 732 ):
          case SID_FM_SHOW_DATANAVIGATOR( 10000 + 773 ):
          {
              if ( GetViewShell()->GetViewFrame()->KnowsChildWindow(nWhich) )
                  rSet.Put( SfxBoolItem( nWhich, GetViewShell()->GetViewFrame()->HasChildWindow(nWhich)) );
              else
                  rSet.DisableItem(nWhich);
          }   break;

          case SID_FM_SHOW_PROPERTY_BROWSER( 10000 + 703 ):
          {
              rSet.Put(SfxBoolItem(nWhich, GetImpl()->IsPropBrwOpen_Lock()));
          }
          break;

          case SID_FM_CTL_PROPERTIES( 10000 + 613 ):
          {
              // potentially, give the Impl the opportunity to update its
              // current objects which are aligned with the current MarkList
              if (GetImpl()->IsSelectionUpdatePending_Lock())
                  GetImpl()->ForceUpdateSelection_Lock();

              if (!m_pFormView || !m_bDesignMode || !GetImpl()->onlyControlsAreMarked_Lock())
                  rSet.DisableItem( nWhich );
              else
              {
                  bool const bChecked = GetImpl()->IsPropBrwOpen_Lock() && !GetImpl()->isSolelySelected_Lock(GetImpl()->getCurrentForm_Lock());
                      // if the property browser is open, and only controls are marked, and the current selection
                      // does not consist of only the current form, then the current selection is the (composition of)
                      // the currently marked controls
                  rSet.Put( SfxBoolItem( nWhich, bChecked ) );
              }
          }   break;

          case SID_FM_PROPERTIES( 10000 + 614 ):
          {
              // potentially, give the Impl the opportunity to update its
              // current objects which are aligned with the current MarkList
              if (GetImpl()->IsSelectionUpdatePending_Lock())
                  GetImpl()->ForceUpdateSelection_Lock();

              if (!m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm_Lock().is())
                  rSet.DisableItem( nWhich );
              else
              {
                  bool const bChecked = GetImpl()->IsPropBrwOpen_Lock() && GetImpl()->isSolelySelected_Lock(GetImpl()->getCurrentForm_Lock());
                  rSet.Put(SfxBoolItem(nWhich, bChecked));
              }
          }   break;
          case SID_FM_TAB_DIALOG( 10000 + 615 ):
              // potentially, give the Impl the opportunity to update its
              // current objects which are aligned with the current MarkList
              if (GetImpl()->IsSelectionUpdatePending_Lock())
                  GetImpl()->ForceUpdateSelection_Lock();

              if (!m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm_Lock().is() )
                  rSet.DisableItem( nWhich );
              break;
          case SID_FM_DESIGN_MODE( 10000 + 629 ):
              if (!m_pFormView || GetImpl()->IsReadonlyDoc_Lock())
                  rSet.DisableItem( nWhich );
              else
                  rSet.Put( SfxBoolItem(nWhich, m_bDesignMode) );
              break;
          case SID_FM_SEARCH( 10000 + 725 ):
          case SID_FM_RECORD_FIRST( 10000 + 616 ):
          case SID_FM_RECORD_NEXT( 10000 + 617 ):
          case SID_FM_RECORD_PREV( 10000 + 618 ):
          case SID_FM_RECORD_LAST( 10000 + 619 ):
          case SID_FM_RECORD_NEW( 10000 + 620 ):
          case SID_FM_RECORD_DELETE( 10000 + 621 ):
          case SID_FM_RECORD_ABSOLUTE( 10000 + 622 ):
          case SID_FM_RECORD_TOTAL( 10000 + 626 ):
          case SID_FM_RECORD_SAVE( 10000 + 627 ):
          case SID_FM_RECORD_UNDO( 10000 + 630 ):
          case SID_FM_FORM_FILTERED( 10000 + 723 ):
          case SID_FM_REMOVE_FILTER_SORT( 10000 + 711 ):
          case SID_FM_SORTUP( 10000 + 712 ):
          case SID_FM_SORTDOWN( 10000 + 713 ):
          case SID_FM_ORDERCRIT( 10000 + 714 ):
          case SID_FM_FILTER_START( 10000 + 729 ):
          case SID_FM_AUTOFILTER( 10000 + 716 ):
          case SID_FM_REFRESH( 10000 + 724 ):
          case SID_FM_REFRESH_FORM_CONTROL( 10000 + 775 ):
          case SID_FM_VIEW_AS_GRID( 10000 + 761 ):
              GetFormState(rSet,nWhich);
              break;

          case SID_FM_CHANGECONTROLTYPE( 10000 + 733 ):
          {
              if ( !m_pFormView || !m_bDesignMode )
                  rSet.DisableItem( nWhich );
              else
              {
                  if (!GetImpl()->canConvertCurrentSelectionToControl_Lock("ConvertToFixed"))
                      // if it cannot be converted to a fixed text, it is no single control
                      rSet.DisableItem( nWhich );
              }
          } break;

          case SID_FM_CONVERTTO_FILECONTROL( 10000 + 744 )   :
          case SID_FM_CONVERTTO_CURRENCY( 10000 + 748 )      :
          case SID_FM_CONVERTTO_PATTERN( 10000 + 749 )       :
          case SID_FM_CONVERTTO_IMAGECONTROL( 10000 + 750 )  :
          case SID_FM_CONVERTTO_SCROLLBAR( 10000 + 770 )     :
          case SID_FM_CONVERTTO_NAVIGATIONBAR( 10000 + 772 ) :
          case SID_FM_CONVERTTO_IMAGEBUTTON( 10000 + 743 )   :
          case SID_FM_CONVERTTO_EDIT( 10000 + 734 )          :
          case SID_FM_CONVERTTO_BUTTON( 10000 + 735 )        :
          case SID_FM_CONVERTTO_FIXEDTEXT( 10000 + 736 )     :
          case SID_FM_CONVERTTO_LISTBOX( 10000 + 737 )       :
          case SID_FM_CONVERTTO_CHECKBOX( 10000 + 738 )      :
          case SID_FM_CONVERTTO_RADIOBUTTON( 10000 + 739 )   :
          case SID_FM_CONVERTTO_GROUPBOX( 10000 + 740 )      :
          case SID_FM_CONVERTTO_COMBOBOX( 10000 + 741 )      :
          case SID_FM_CONVERTTO_DATE( 10000 + 745 )          :
          case SID_FM_CONVERTTO_TIME( 10000 + 746 )          :
          case SID_FM_CONVERTTO_NUMERIC( 10000 + 747 )       :
          case SID_FM_CONVERTTO_FORMATTED( 10000 + 751 )     :
          case SID_FM_CONVERTTO_SPINBUTTON( 10000 + 771 )    :
          {
              if (!m_pFormView || !m_bDesignMode || !GetImpl()->canConvertCurrentSelectionToControl_Lock(FmXFormShell::SlotToIdent(nWhich)))
                  rSet.DisableItem( nWhich );
              else
              {
                  rSet.Put( SfxBoolItem( nWhich, false ) );
                  // just to have a defined state (available and not checked)
              }
          }
          break;
      }
      nWhich = aIter.NextWhich();
  }
1029}


1032void FmFormShell::GetFormState(SfxItemSet &rSet, sal_uInt16 nWhich)
1033{
  if  (   !GetImpl()->getNavController_Lock().is()
      ||  !isRowSetAlive(GetImpl()->getNavController_Lock()->getModel())
      ||  !m_pFormView
      ||  m_bDesignMode
      ||  !GetImpl()->getActiveForm_Lock().is()
      ||  GetImpl()->isInFilterMode_Lock()
      )
      rSet.DisableItem(nWhich);
  else
  {
      bool bEnable = false;
      try
      {
          switch (nWhich)
          {
          case SID_FM_VIEW_AS_GRID( 10000 + 761 ):
              if (GetImpl()->getHostFrame_Lock().is() && GetImpl()->getNavController_Lock().is())
              {
                  bEnable = true;
                  bool bDisplayingCurrent =
                      GetImpl()->getInternalForm_Lock(
                          Reference<XForm>(GetImpl()->getNavController_Lock()->getModel(), UNO_QUERY)
                      ) == GetImpl()->getExternallyDisplayedForm_Lock();
                  rSet.Put(SfxBoolItem(nWhich, bDisplayingCurrent));
              }
              break;

          case SID_FM_SEARCH( 10000 + 725 ):
          {
              Reference<css::beans::XPropertySet> const xNavSet(GetImpl()->getActiveForm_Lock(), UNO_QUERY);
              sal_Int32 nCount = ::comphelper::getINT32(xNavSet->getPropertyValue(FM_PROP_ROWCOUNT"RowCount"));
              bEnable = nCount != 0;
          }   break;
          case SID_FM_RECORD_ABSOLUTE( 10000 + 622 ):
          case SID_FM_RECORD_TOTAL( 10000 + 626 ):
          {
              FeatureState aState;
              GetImpl()->getNavControllerFeatures_Lock()->getState( nWhich, aState );
              if ( SID_FM_RECORD_ABSOLUTE( 10000 + 622 ) == nWhich )
              {
                  sal_Int32 nPosition = 0;
                  aState.State >>= nPosition;
                  rSet.Put( SfxInt32Item( nWhich, nPosition ) );
              }
              else if ( SID_FM_RECORD_TOTAL( 10000 + 626 ) == nWhich )
              {
                  OUString sTotalCount;
                  aState.State >>= sTotalCount;
                  rSet.Put( SfxStringItem( nWhich, sTotalCount ) );
              }
              bEnable = aState.Enabled;
          }
          break;

          // first, prev, next, last, and absolute affect the nav controller, not the
          // active controller
          case SID_FM_RECORD_FIRST( 10000 + 616 ):
          case SID_FM_RECORD_PREV( 10000 + 618 ):
          case SID_FM_RECORD_NEXT( 10000 + 617 ):
          case SID_FM_RECORD_LAST( 10000 + 619 ):
          case SID_FM_RECORD_NEW( 10000 + 620 ):
          case SID_FM_RECORD_SAVE( 10000 + 627 ):
          case SID_FM_RECORD_UNDO( 10000 + 630 ):
          case SID_FM_RECORD_DELETE( 10000 + 621 ):
          case SID_FM_REFRESH( 10000 + 724 ):
          case SID_FM_REFRESH_FORM_CONTROL( 10000 + 775 ):
          case SID_FM_REMOVE_FILTER_SORT( 10000 + 711 ):
          case SID_FM_SORTUP( 10000 + 712 ):
          case SID_FM_SORTDOWN( 10000 + 713 ):
          case SID_FM_AUTOFILTER( 10000 + 716 ):
          case SID_FM_ORDERCRIT( 10000 + 714 ):
              bEnable = GetImpl()->IsFormSlotEnabled( nWhich, nullptr );
              break;

          case SID_FM_FORM_FILTERED( 10000 + 723 ):
          {
              FeatureState aState;
              bEnable = GetImpl()->IsFormSlotEnabled( nWhich, &aState );

              rSet.Put( SfxBoolItem( nWhich, ::comphelper::getBOOL( aState.State ) ) );
          }
          break;

          case SID_FM_FILTER_START( 10000 + 729 ):
              bEnable = GetImpl()->getActiveControllerFeatures_Lock()->canDoFormFilter();
              break;
          }
      }
      catch( const Exception& )
      {
          TOOLS_WARN_EXCEPTION("svx.form", "caught an exception while determining the state!")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "svx.form")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "caught an exception while determining the state!"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"svx.form"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1124" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "caught an exception while determining the state!"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "caught an exception while determining the state!" <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.form"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1124" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "caught an exception while determining the state!"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"svx.form"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1124" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "caught an exception while determining the state!"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "caught an exception while determining the state!" <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("svx.form"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1124" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
      }
      if (!bEnable)
          rSet.DisableItem(nWhich);
  }
1129}


1132FmFormPage* FmFormShell::GetCurPage() const
1133{
  FmFormPage* pP = nullptr;
  if (m_pFormView && m_pFormView->GetSdrPageView())
      pP = dynamic_cast<FmFormPage*>( m_pFormView->GetSdrPageView()->GetPage() );
  return pP;
1138}


1141void FmFormShell::SetView( FmFormView* _pView )
1142{
  if ( m_pFormView )
  {
      if ( IsActive() )
          GetImpl()->viewDeactivated_Lock(*m_pFormView);

      m_pFormView->SetFormShell( nullptr, FmFormView::FormShellAccess() );
      m_pFormView = nullptr;
      m_pFormModel = nullptr;
  }

  if ( !_pView )
      return;

  m_pFormView = _pView;
  m_pFormView->SetFormShell( this, FmFormView::FormShellAccess() );
  m_pFormModel = static_cast<FmFormModel*>(m_pFormView->GetModel());

  impl_setDesignMode( m_pFormView->IsDesignMode() );

  // We activate our view if we are activated ourself, but sometimes the Activate precedes the SetView.
  // But here we know both the view and our activation state so we at least are able to pass the latter
  // to the former.
  // FS - 30.06.99 - 67308
  if ( IsActive() )
      GetImpl()->viewActivated_Lock(*m_pFormView);
1168}


1171void FmFormShell::DetermineForms(bool bInvalidate)
1172{
  // are there forms on the current page
  bool bForms = GetImpl()->hasForms_Lock();
  if (bForms != m_bHasForms)
  {
      m_bHasForms = bForms;
      if (bInvalidate)
          UIFeatureChanged();
  }
1181}


1184bool FmFormShell::GetY2KState(sal_uInt16& nReturn)
1185{
  return GetImpl()->GetY2KState_Lock(nReturn);
1187}


1190void FmFormShell::SetY2KState(sal_uInt16 n)
1191{
  GetImpl()->SetY2KState_Lock(n);
1193}


1196void FmFormShell::Activate(bool bMDI)
1197{
  SfxShell::Activate(bMDI);

  if ( m_pFormView )
      GetImpl()->viewActivated_Lock(*m_pFormView, true);
1202}


1205void FmFormShell::Deactivate(bool bMDI)
1206{
  SfxShell::Deactivate(bMDI);

  if ( m_pFormView )
      GetImpl()->viewDeactivated_Lock(*m_pFormView, false);
1211}


1214void FmFormShell::ExecuteTextAttribute( SfxRequest& _rReq )
1215{
  m_pImpl->ExecuteTextAttribute_Lock(_rReq);
1217}


1220void FmFormShell::GetTextAttributeState( SfxItemSet& _rSet )
1221{
  m_pImpl->GetTextAttributeState_Lock(_rSet);
1223}


1226bool FmFormShell::IsActiveControl() const
1227{
  return m_pImpl->IsActiveControl_Lock(false);
1229}


1232void FmFormShell::ForgetActiveControl()
1233{
  m_pImpl->ForgetActiveControl_Lock();
1235}


1238void FmFormShell::SetControlActivationHandler( const Link<LinkParamNone*,void>& _rHdl )
1239{
  m_pImpl->SetControlActivationHandler_Lock(_rHdl);
1241}


1244namespace
1245{
  SdrUnoObj* lcl_findUnoObject( const SdrObjList& _rObjList, const Reference< XControlModel >& _rxModel )
  {
      SdrObjListIter aIter( &_rObjList );
      while ( aIter.IsMore() )
      {
          SdrObject* pObject = aIter.Next();
          SdrUnoObj* pUnoObject = dynamic_cast<SdrUnoObj*>( pObject  );
          if ( !pUnoObject )
              continue;

          Reference< XControlModel > xControlModel = pUnoObject->GetUnoControlModel();
          if ( !xControlModel.is() )
              continue;

          if ( _rxModel == xControlModel )
              return pUnoObject;
      }
      return nullptr;
  }
1265}


1268void FmFormShell::ToggleControlFocus( const SdrUnoObj& i_rUnoObject, const SdrView& i_rView, OutputDevice& i_rDevice ) const
1269{
  try
  {
      // check if the focus currently is in a control
      // Well, okay, do it the other way 'round: Check whether the current control of the active controller
      // actually has the focus. This should be equivalent.
      const bool bHasControlFocus = GetImpl()->HasControlFocus_Lock();

      if ( bHasControlFocus )
      {
          vcl::Window* pWindow( dynamic_cast< vcl::Window* >( &i_rDevice ) );
          OSL_ENSURE( pWindow, "FmFormShell::ToggleControlFocus: I need a Window, really!" )do { if (true && (!(pWindow))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1280" ": "), "%s", "FmFormShell::ToggleControlFocus: I need a Window, really!"
); } } while (false);
          if ( pWindow )
              pWindow->GrabFocus();
      }
      else
      {
          Reference< XControl > xControl;
          GetFormControl( i_rUnoObject.GetUnoControlModel(), i_rView, i_rDevice, xControl );
          Reference< XWindow > xControlWindow( xControl, UNO_QUERY );
          if ( xControlWindow.is() )
              xControlWindow->setFocus();
      }
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("svx")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1295" ": ", "svx" );;
  }
1297}


1300namespace
1301{
  class FocusableControlsFilter : public svx::ISdrObjectFilter
  {
  public:
      FocusableControlsFilter( const SdrView& i_rView, const OutputDevice& i_rDevice )
          :m_rView( i_rView )
          ,m_rDevice( i_rDevice )
      {
      }

  public:
      virtual bool    includeObject( const SdrObject& i_rObject ) const override
      {
          const SdrUnoObj* pUnoObj = dynamic_cast< const SdrUnoObj* >( &i_rObject );
          if ( !pUnoObj )
              return false;

          Reference< XControl > xControl = pUnoObj->GetUnoControl( m_rView, m_rDevice );
          return FmXFormView::isFocusable( xControl );
      }

  private:
      const SdrView&      m_rView;
      const OutputDevice& m_rDevice;
  };
1326}


:std::unique_ptr< svx::ISdrObjectFilter > FmFormShell::CreateFocusableControlFilter( const SdrView& i_rView, const OutputDevice& i_rDevice )
1330{
  ::std::unique_ptr< svx::ISdrObjectFilter > pFilter;

  if ( !i_rView.IsDesignMode() )
      pFilter.reset( new FocusableControlsFilter( i_rView, i_rDevice ) );

  return pFilter;
1337}


1340SdrUnoObj* FmFormShell::GetFormControl( const Reference< XControlModel >& _rxModel, const SdrView& _rView, const OutputDevice& _rDevice, Reference< XControl >& _out_rxControl ) const
1341{
  if ( !_rxModel.is() )
      return nullptr;

  // we can only retrieve controls for SdrObjects which belong to page which is actually displayed in the given view
  SdrPageView* pPageView = _rView.GetSdrPageView();
  SdrPage* pPage = pPageView ? pPageView->GetPage() : nullptr;
  OSL_ENSURE( pPage, "FmFormShell::GetFormControl: no page displayed in the given view!" )do { if (true && (!(pPage))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1348" ": "), "%s", "FmFormShell::GetFormControl: no page displayed in the given view!"
); } } while (false);
  if ( !pPage )
      return nullptr;

  SdrUnoObj* pUnoObject = lcl_findUnoObject( *pPage, _rxModel );
  if ( pUnoObject )
  {
      _out_rxControl = pUnoObject->GetUnoControl( _rView, _rDevice );
      return pUnoObject;
  }

1359#if OSL_DEBUG_LEVEL1 > 0
  // perhaps we are fed with a control model which lives on a page other than the one displayed
  // in the given view. This is worth being reported as error, in non-product builds.
  FmFormModel* pModel = GetFormModel();
  if ( pModel )
  {
      sal_uInt16 pageCount = pModel->GetPageCount();
      for ( sal_uInt16 page = 0; page < pageCount; ++page )
      {
          pPage = pModel->GetPage( page );
          OSL_ENSURE( pPage, "FmFormShell::GetFormControl: NULL page encountered!" )do { if (true && (!(pPage))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1369" ": "), "%s", "FmFormShell::GetFormControl: NULL page encountered!"
); } } while (false);
          if  ( !pPage )
              continue;

          pUnoObject = lcl_findUnoObject( *pPage, _rxModel );
          OSL_ENSURE( !pUnoObject, "FmFormShell::GetFormControl: the given control model belongs to a wrong page (displayed elsewhere)!" )do { if (true && (!(!pUnoObject))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/form/fmshell.cxx"
 ":" "1374" ": "), "%s", "FmFormShell::GetFormControl: the given control model belongs to a wrong page (displayed elsewhere)!"
); } } while (false);
      }
  }
1377#else
  (void) this; // avoid loplugin:staticmethods
1379#endif

  return nullptr;
1382}


1385Reference< runtime::XFormController > FmFormShell::GetFormController( const Reference< XForm >& _rxForm, const SdrView& _rView, const OutputDevice& _rDevice )
1386{
  const FmFormView* pFormView = dynamic_cast< const FmFormView* >( &_rView );
  if ( !pFormView )
      return nullptr;

  return pFormView->GetFormController( _rxForm, _rDevice );
1392}


1395void FmFormShell::SetDesignMode( bool _bDesignMode )
1396{
  if ( _bDesignMode == m_bDesignMode )
      return;

  FmFormModel* pModel = GetFormModel();
  if (pModel)
      // Switch off the undo environment for the time of the transition. This ensures that
      // one can also change non-transient properties there. (It should be done with
      // caution, however, and it should always be reversed when one switches the mode back.
      // An example is the setting of the maximum text length by the OEditModel on its control.)
      pModel->GetUndoEnv().Lock();

  // then the actual switch
  if ( m_bDesignMode || PrepareClose() )
      impl_setDesignMode(!m_bDesignMode );

  // and my undo environment back on
  if ( pModel )
      pModel->GetUndoEnv().UnLock();
1415}

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

←

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

→

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

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

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

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

36class VclReferenceBase;

38namespace vcl::detail {

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

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

47} // namespace vcl::detail

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

  ::rtl::Reference<reference_type> m_rInnerRef;

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

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

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

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

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

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

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

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

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
26
←
Calling 'Reference::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)
8
←
Calling implicit copy constructor for 'VclPtr<AbstractFmInputRecordNoDialog>'→
9
←
Calling copy constructor for 'Reference<AbstractFmInputRecordNoDialog>'→
12
←
Returning from copy constructor for 'Reference<AbstractFmInputRecordNoDialog>'→
13
←
Returning from copy constructor for 'VclPtr<AbstractFmInputRecordNoDialog>'→
  {}

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

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

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

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

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

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

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

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

440#endif // INCLUDED_VCL_PTR_HXX

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

←

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

→

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

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

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

32#include "sal/types.h"

34namespace rtl
35{

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


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


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

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

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

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

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

      Does not work for up-casts to ambiguous bases.

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

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody16.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
)
17
←
Taking true branch→
          m_pBody->release();
18
←
Calling 'VclReferenceBase::release'→
22
←
Returning; memory was released→
  }

  /** 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;
27
←
Use of memory after it is freed
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

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

←

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

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 *   Licensed to the Apache Software Foundation (ASF) under one or more
12 *   contributor license agreements. See the NOTICE file distributed
13 *   with this work for additional information regarding copyright
14 *   ownership. The ASF licenses this file to you under the Apache
15 *   License, Version 2.0 (the "License"); you may not use this file
16 *   except in compliance with the License. You may obtain a copy of
17 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
19
←
Assuming the condition is true→
20
←
Taking true branch→
40            delete this;
21
←
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