/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 vclxaccessiblelist.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 VCL_INTERNALS -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/accessibility/inc -I /home/maarten/src/libreoffice/core/accessibility/source/inc -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/accessibility/source/standard/vclxaccessiblelist.cxx

/home/maarten/src/libreoffice/core/accessibility/source/standard/vclxaccessiblelist.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 <standard/vclxaccessiblelist.hxx>
21#include <standard/vclxaccessiblelistitem.hxx>
22#include <helper/listboxhelper.hxx>

24#include <unotools/accessiblerelationsethelper.hxx>
25#include <unotools/accessiblestatesethelper.hxx>
26#include <com/sun/star/accessibility/AccessibleStateType.hpp>
27#include <com/sun/star/accessibility/AccessibleEventId.hpp>
28#include <com/sun/star/accessibility/AccessibleRelationType.hpp>
29#include <com/sun/star/accessibility/AccessibleRole.hpp>
30#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
31#include <o3tl/safeint.hxx>
32#include <vcl/svapp.hxx>
33#include <vcl/toolkit/combobox.hxx>
34#include <vcl/toolkit/lstbox.hxx>
35#include <toolkit/helper/convert.hxx>

37using namespace ::com::sun::star;
38using namespace ::com::sun::star::uno;
39using namespace ::com::sun::star::lang;
40using namespace ::com::sun::star::beans;
41using namespace ::com::sun::star::accessibility;
42using namespace ::accessibility;

44namespace
45{
  /// @throws css::lang::IndexOutOfBoundsException
  void checkSelection_Impl( sal_Int32 _nIndex, const IComboListBoxHelper& _rListBox, bool bSelected )
  {
      sal_Int32 nCount = bSelected ? _rListBox.GetSelectedEntryCount()
                                   : _rListBox.GetEntryCount();
      if ( _nIndex < 0 || _nIndex >= nCount )
          throw css::lang::IndexOutOfBoundsException();
  }
54}

56VCLXAccessibleList::VCLXAccessibleList (VCLXWindow* pVCLWindow, BoxType aBoxType,
                                      const Reference< XAccessible >& _xParent)
  : VCLXAccessibleComponent   (pVCLWindow),
    m_aBoxType                (aBoxType),
    m_nVisibleLineCount       (0),
    m_nIndexInParent          (DEFAULT_INDEX_IN_PARENT),
    m_nLastTopEntry           ( 0 ),
    m_nLastSelectedPos        ( LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) ),
    m_bDisableProcessEvent    ( false ),
    m_bVisible                ( true ),
    m_nCurSelectedPos         ( LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) ),
    m_xParent                 ( _xParent )
68{
  // Because combo boxes and list boxes don't have a common interface for
  // methods with identical signature we have to write down twice the
  // same code.
  switch (m_aBoxType)
  {
      case COMBOBOX:
      {
          VclPtr< ComboBox > pBox = GetAs< ComboBox >();
          if ( pBox )
              m_pListBoxHelper.reset( new VCLListBoxHelper<ComboBox> (*pBox) );
          break;
      }

      case LISTBOX:
      {
          VclPtr< ListBox > pBox = GetAs< ListBox >();
          if ( pBox )
              m_pListBoxHelper.reset( new VCLListBoxHelper<ListBox> (*pBox) );
          break;
      }
  }
  UpdateVisibleLineCount();
  if(m_pListBoxHelper)
  {
      m_nCurSelectedPos=m_pListBoxHelper->GetSelectedEntryPos(0);
  }
  sal_uInt16 nCount = static_cast<sal_uInt16>(getAccessibleChildCount());
  m_aAccessibleChildren.reserve(nCount);
97}


100void VCLXAccessibleList::SetIndexInParent (sal_Int32 nIndex)
101{
  m_nIndexInParent = nIndex;
103}


106void SAL_CALL VCLXAccessibleList::disposing()
107{
  VCLXAccessibleComponent::disposing();

  // Dispose all items in the list.
  m_aAccessibleChildren.clear();

  m_pListBoxHelper.reset();
114}


117void VCLXAccessibleList::FillAccessibleStateSet (utl::AccessibleStateSetHelper& rStateSet)
118{
  SolarMutexGuard aSolarGuard;

  VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
  // check if our list should be visible
  if (    m_pListBoxHelper
      && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN
      && !m_pListBoxHelper->IsInDropDown() )
  {
      rStateSet.RemoveState (AccessibleStateType::VISIBLE);
      rStateSet.RemoveState (AccessibleStateType::SHOWING);
      m_bVisible = false;
  }

  // Both the combo box and list box are handled identical in the
  // following but for some reason they don't have a common interface for
  // the methods used.
  if ( m_pListBoxHelper )
  {
      if ( m_pListBoxHelper->IsMultiSelectionEnabled() )
          rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE);
      rStateSet.AddState (AccessibleStateType::FOCUSABLE);
      // All children are transient.
      rStateSet.AddState (AccessibleStateType::MANAGES_DESCENDANTS);
  }
143}

145void VCLXAccessibleList::notifyVisibleStates(bool _bSetNew )
146{
  m_bVisible = _bSetNew;
  Any aOldValue, aNewValue;
  (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::VISIBLE;
  NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
  (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::SHOWING;
  NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );

  ListItems::iterator aIter = m_aAccessibleChildren.begin();
  UpdateVisibleLineCount();
  // adjust the index inside the VCLXAccessibleListItem
  for ( ; aIter != m_aAccessibleChildren.end(); )
  {
      Reference< XAccessible > xHold = *aIter;
      if (!xHold.is())
      {
          aIter = m_aAccessibleChildren.erase(aIter);
      }
      else
      {
          VCLXAccessibleListItem* pItem = static_cast<VCLXAccessibleListItem*>(xHold.get());
          const sal_Int32 nTopEntry = m_pListBoxHelper ? m_pListBoxHelper->GetTopEntry() : 0;
          const sal_Int32 nPos = static_cast<sal_Int32>(aIter - m_aAccessibleChildren.begin());
          bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) );
          pItem->SetVisible( m_bVisible && bVisible );
          ++aIter;
      }

  }
175}

177void VCLXAccessibleList::UpdateSelection_Acc (const OUString& /*sTextOfSelectedItem*/, bool b_IsDropDownList)
178{
  if ( m_aBoxType != COMBOBOX )
      return;

  /* FIXME: is there something missing here? nIndex is unused. Looks like
   * copy-paste from VCLXAccessibleList::UpdateSelection() */
  // VclPtr< ComboBox > pBox = GetAs< ComboBox >();
  // if ( pBox )
  // {
  //     // Find the index of the selected item inside the VCL control...
  //     sal_Int32 nIndex = pBox->GetEntryPos(sTextOfSelectedItem);
  //     // ...and then find the associated accessibility object.
  //     if ( nIndex == LISTBOX_ENTRY_NOTFOUND )
  //         nIndex = 0;
  UpdateSelection_Impl_Acc(b_IsDropDownList);
  // }
194}


197void VCLXAccessibleList::UpdateSelection_Impl_Acc(bool bHasDropDownList)
198{
  uno::Any aOldValue, aNewValue;

  {
      SolarMutexGuard aSolarGuard;
      ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
      Reference< XAccessible > xNewAcc;
      if ( m_pListBoxHelper )
      {
          sal_Int32 i=0;
          m_nCurSelectedPos = LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF));
          for ( const auto& rChild : m_aAccessibleChildren )
          {
              Reference< XAccessible > xHold = rChild;
              if ( xHold.is() )
              {
                  VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >( xHold.get() );
                  // Retrieve the item's index from the list entry.
                  bool bNowSelected = m_pListBoxHelper->IsEntryPosSelected (i);
                  if (bNowSelected)
                      m_nCurSelectedPos = i;

                  if ( bNowSelected && !pItem->IsSelected() )
                  {
                      xNewAcc = rChild;
                      aNewValue <<= xNewAcc;
                  }
                  else if ( pItem->IsSelected() )
                      m_nLastSelectedPos = i;

                  pItem->SetSelected( bNowSelected );
              }
              else
              { // it could happen that a child was not created before
                  checkEntrySelected(i,aNewValue,xNewAcc);
              }
              ++i;
          }
          const sal_Int32 nCount = m_pListBoxHelper->GetEntryCount();
          if ( i < nCount ) // here we have to check the if any other listbox entry is selected
          {
              for (; i < nCount && !checkEntrySelected(i,aNewValue,xNewAcc) ;++i )
                  ;
          }
          if ( xNewAcc.is() && GetWindow()->HasFocus() )
          {
              if ( m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) )
                  aOldValue <<= getAccessibleChild( m_nLastSelectedPos );
              aNewValue <<= xNewAcc;
          }
      }
  }

  if (m_aBoxType == COMBOBOX)
  {
      //VCLXAccessibleDropDownComboBox
      //when in list is dropped down, xText = NULL
      if (bHasDropDownList && m_pListBoxHelper && m_pListBoxHelper->IsInDropDown())
      {
          if ( aNewValue.hasValue() || aOldValue.hasValue() )
          {
              NotifyAccessibleEvent(
                  AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
                  aOldValue,
                  aNewValue );

              NotifyListItem(aNewValue);
          }
      }
      else
      {
          //VCLXAccessibleComboBox
          NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, uno::Any(), uno::Any() );
      }
  }
  else if (m_aBoxType == LISTBOX)
  {
      if ( aNewValue.hasValue() || aOldValue.hasValue() )
      {
          NotifyAccessibleEvent(
                  AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
                  aOldValue,
                  aNewValue );

          NotifyListItem(aNewValue);
      }
  }
285}

287void VCLXAccessibleList::NotifyListItem(css::uno::Any const & val)
288{
  Reference< XAccessible > xCurItem;
  val >>= xCurItem;
  if (xCurItem.is())
  {
      VCLXAccessibleListItem* pCurItem = static_cast< VCLXAccessibleListItem* >(xCurItem.get());
      if (pCurItem)
      {
          pCurItem->NotifyAccessibleEvent(AccessibleEventId::SELECTION_CHANGED,Any(),Any());
      }
  }
299}

301void VCLXAccessibleList::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent,  bool b_IsDropDownList)
302{
  switch ( rVclWindowEvent.GetId() )
    {
      case VclEventId::DropdownSelect:
      case VclEventId::ListboxSelect:
          if ( !m_bDisableProcessEvent )
              UpdateSelection_Impl_Acc(b_IsDropDownList);
          break;
      case VclEventId::WindowGetFocus:
          break;
      case VclEventId::ControlGetFocus:
          {
              VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
              if (m_aBoxType == COMBOBOX && b_IsDropDownList)
              {
                  //VCLXAccessibleDropDownComboBox
              }
              else if (m_aBoxType == LISTBOX && b_IsDropDownList)
              {
              }
              else if ( m_aBoxType == LISTBOX && !b_IsDropDownList)
              {
                  if ( m_pListBoxHelper )
                  {
                      uno::Any    aOldValue,
                                  aNewValue;
                      sal_Int32 nPos = m_nCurSelectedPos; //m_pListBoxHelper->GetSelectedEntryPos();

                      if ( nPos == LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) )
                          nPos = m_pListBoxHelper->GetTopEntry();
                      if ( nPos != LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) )
                          aNewValue <<= CreateChild(nPos);
                      NotifyAccessibleEvent(  AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
                                              aOldValue,
                                              aNewValue );
                  }
              }
          }
          break;
      default:
          break;
  }

345}

347void VCLXAccessibleList::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent)
348{
  // Create a reference to this object to prevent an early release of the
  // listbox (VclEventId::ObjectDying).
  Reference< XAccessible > xHoldAlive = this;

  switch ( rVclWindowEvent.GetId() )
  {
      case VclEventId::DropdownOpen:
          notifyVisibleStates(true);
          break;
      case VclEventId::DropdownClose:
          notifyVisibleStates(false);
          break;
      case VclEventId::ListboxScrolled:
          UpdateEntryRange_Impl();
          break;

      // The selection events VclEventId::ComboboxSelect and
      // VclEventId::ComboboxDeselect are not handled here because here we
      // have no access to the edit field.  Its text is necessary to
      // identify the currently selected item.

      case VclEventId::ObjectDying:
      {
          dispose();

          VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
          break;
      }

      case VclEventId::ListboxItemRemoved:
      case VclEventId::ComboboxItemRemoved:
      case VclEventId::ListboxItemAdded:
      case VclEventId::ComboboxItemAdded:
          HandleChangedItemList();
          break;
      case VclEventId::ControlGetFocus:
          {
              VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
              // Added by IBM Symphony Acc team to handle the list item focus when List control get focus
              bool b_IsDropDownList = true;
              if (m_pListBoxHelper)
                  b_IsDropDownList = ((m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN);
              if ( m_aBoxType == LISTBOX && !b_IsDropDownList )
              {
                  if ( m_pListBoxHelper )
                  {
                      uno::Any    aOldValue,
                                  aNewValue;
                      sal_Int32 nPos = m_nCurSelectedPos;

                      if ( nPos == LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) )
                          nPos = m_pListBoxHelper->GetTopEntry();
                      if ( nPos != LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) )
                          aNewValue <<= CreateChild(nPos);
                      NotifyAccessibleEvent(  AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
                                              aOldValue,
                                              aNewValue );
                  }
              }
          }
          break;

      default:
          VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
  }
414}

void VCLXAccessibleList::FillAccessibleRelationSet( utl::AccessibleRelationSetHelper& rRelationSet )
417{
  VclPtr< ListBox > pBox = GetAs< ListBox >();
1
Calling 'VCLXAccessibleComponent::GetAs'→
18
←
Returning; memory was released→
  if( m_aBoxType == LISTBOX  )
19
←
Assuming field 'm_aBoxType' is not equal to LISTBOX→
20
←
Taking false branch→
  {
      if (m_pListBoxHelper && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) != WB_DROPDOWN)
      {
          uno::Sequence< uno::Reference< uno::XInterface > > aSequence { pBox->GetAccessible() };
          rRelationSet.AddRelation( com::sun::star::accessibility::AccessibleRelation( com::sun::star::accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) );
      }
  }
  else
  {
      VCLXAccessibleComponent::FillAccessibleRelationSet(rRelationSet);
  }
431}
21
←
Calling implicit destructor for 'VclPtr<ListBox>'→
22
←
Calling '~Reference'→


434/** To find out which item is currently selected and to update the SELECTED
  state of the associated accessibility objects accordingly we exploit the
  fact that the
437*/
438void VCLXAccessibleList::UpdateSelection (const OUString& sTextOfSelectedItem)
439{
  if ( m_aBoxType != COMBOBOX )
      return;

  VclPtr< ComboBox > pBox = GetAs< ComboBox >();
  if ( pBox )
  {
      // Find the index of the selected item inside the VCL control...
      sal_Int32 nIndex = pBox->GetEntryPos(sTextOfSelectedItem);
      // ...and then find the associated accessibility object.
      if ( nIndex == LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) )
          nIndex = 0;
      UpdateSelection_Impl(nIndex);
  }
453}


456Reference<XAccessible> VCLXAccessibleList::CreateChild (sal_Int32 nPos)
457{
  Reference<XAccessible> xChild;

  if ( o3tl::make_unsigned(nPos) >= m_aAccessibleChildren.size() )
  {
      m_aAccessibleChildren.resize(nPos + 1);

      // insert into the container
      xChild = new VCLXAccessibleListItem(nPos, this);
      m_aAccessibleChildren[nPos] = xChild;
  }
  else
  {
      xChild = m_aAccessibleChildren[nPos];
      // check if position is empty and can be used else we have to adjust all entries behind this
      if (!xChild.is())
      {
          xChild = new VCLXAccessibleListItem(nPos, this);
          m_aAccessibleChildren[nPos] = xChild;
      }
  }

  if ( xChild.is() )
  {
      // Just add the SELECTED state.
      bool bNowSelected = false;
      if ( m_pListBoxHelper )
          bNowSelected = m_pListBoxHelper->IsEntryPosSelected(nPos);
      if (bNowSelected)
          m_nCurSelectedPos = nPos;
      VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >(xChild.get());
      pItem->SetSelected( bNowSelected );

      // Set the child's VISIBLE state.
      UpdateVisibleLineCount();
      const sal_Int32 nTopEntry = m_pListBoxHelper ? m_pListBoxHelper->GetTopEntry() : 0;
      bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) );
      pItem->SetVisible( m_bVisible && bVisible );
  }

  return xChild;
498}


501void VCLXAccessibleList::HandleChangedItemList()
502{
  m_aAccessibleChildren.clear();
  NotifyAccessibleEvent (
      AccessibleEventId::INVALIDATE_ALL_CHILDREN,
      Any(), Any());
507}


510IMPLEMENT_FORWARD_XINTERFACE2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE)void VCLXAccessibleList::acquire() throw() { VCLXAccessibleComponent
::acquire(); } void VCLXAccessibleList::release() throw() { VCLXAccessibleComponent
::release(); } css::uno::Any VCLXAccessibleList::queryInterface
( const css::uno::Type& _rType ) { css::uno::Any aReturn =
 VCLXAccessibleComponent::queryInterface( _rType ); if ( !aReturn
.hasValue() ) aReturn = VCLXAccessibleList_BASE::queryInterface
( _rType ); return aReturn; }
511IMPLEMENT_FORWARD_XTYPEPROVIDER2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE)css::uno::Sequence< css::uno::Type > VCLXAccessibleList
::getTypes( ) { return ::comphelper::concatSequences( VCLXAccessibleComponent
::getTypes(), VCLXAccessibleList_BASE::getTypes() ); } css::uno
::Sequence< sal_Int8 > VCLXAccessibleList::getImplementationId
( ) { return css::uno::Sequence<sal_Int8>(); }

513// XAccessible

515Reference<XAccessibleContext> SAL_CALL
  VCLXAccessibleList::getAccessibleContext()
517{
  return this;
519}


522// XAccessibleContext

524sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleChildCount()
525{
  SolarMutexGuard aSolarGuard;
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
  return implGetAccessibleChildCount();
529}

531sal_Int32 VCLXAccessibleList::implGetAccessibleChildCount()
532{
  sal_Int32 nCount = 0;
  if ( m_pListBoxHelper )
      nCount = m_pListBoxHelper->GetEntryCount();

  return nCount;
538}

540Reference<XAccessible> SAL_CALL VCLXAccessibleList::getAccessibleChild (sal_Int32 i)
541{
  SolarMutexGuard aSolarGuard;
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  if ( i < 0 || i >= getAccessibleChildCount() )
      throw IndexOutOfBoundsException();

  Reference< XAccessible > xChild;
  // search for the child
  if ( i >= static_cast<sal_Int32>(m_aAccessibleChildren.size()) )
      xChild = CreateChild (i);
  else
  {
      xChild = m_aAccessibleChildren[i];
      if ( !xChild.is() )
          xChild = CreateChild (i);
  }
  OSL_ENSURE( xChild.is(), "VCLXAccessibleList::getAccessibleChild: returning empty child!" )do { if (true && (!(xChild.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/accessibility/source/standard/vclxaccessiblelist.cxx"
 ":" "558" ": "), "%s", "VCLXAccessibleList::getAccessibleChild: returning empty child!"
); } } while (false);
  return xChild;
560}

562Reference< XAccessible > SAL_CALL VCLXAccessibleList::getAccessibleParent(  )
563{
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  return m_xParent;
567}

569sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleIndexInParent()
570{
  if (m_nIndexInParent != DEFAULT_INDEX_IN_PARENT)
      return m_nIndexInParent;
  else
      return VCLXAccessibleComponent::getAccessibleIndexInParent();
575}

577sal_Int16 SAL_CALL VCLXAccessibleList::getAccessibleRole()
578{
  return AccessibleRole::LIST;
580}

582// XServiceInfo
583OUString VCLXAccessibleList::getImplementationName()
584{
  return "com.sun.star.comp.toolkit.AccessibleList";
586}

588Sequence< OUString > VCLXAccessibleList::getSupportedServiceNames()
589{
  return comphelper::concatSequences(VCLXAccessibleComponent::getSupportedServiceNames(),
                                     Sequence<OUString>{"com.sun.star.accessibility.AccessibleList"});
592}

594void VCLXAccessibleList::UpdateVisibleLineCount()
595{
  if ( m_pListBoxHelper )
  {
      if ( (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
          m_nVisibleLineCount = m_pListBoxHelper->GetDisplayLineCount();
      else
      {
          sal_uInt16 nCols = 0,
              nLines = 0;
          m_pListBoxHelper->GetMaxVisColumnsAndLines (nCols, nLines);
          m_nVisibleLineCount = nLines;
      }
  }
608}

610void VCLXAccessibleList::UpdateEntryRange_Impl()
611{
  SolarMutexGuard aSolarGuard;
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  sal_Int32 nTop = m_nLastTopEntry;

  if ( m_pListBoxHelper )
      nTop = m_pListBoxHelper->GetTopEntry();
  if ( nTop != m_nLastTopEntry )
  {
      UpdateVisibleLineCount();
      sal_Int32 nBegin = std::min( m_nLastTopEntry, nTop );
      sal_Int32 nEnd = std::max( m_nLastTopEntry + m_nVisibleLineCount, nTop + m_nVisibleLineCount );
      for (sal_Int32 i = nBegin; (i <= nEnd); ++i)
      {
          bool bVisible = ( i >= nTop && i < ( nTop + m_nVisibleLineCount ) );
          Reference< XAccessible > xHold;
          if ( o3tl::make_unsigned(i) < m_aAccessibleChildren.size() )
              xHold = m_aAccessibleChildren[i];
          else if ( bVisible )
              xHold = CreateChild(i);

          if ( xHold.is() )
              static_cast< VCLXAccessibleListItem* >( xHold.get() )->SetVisible( m_bVisible && bVisible );
      }
  }

  m_nLastTopEntry = nTop;
639}

641bool VCLXAccessibleList::checkEntrySelected(sal_Int32 _nPos,Any& _rNewValue,Reference< XAccessible >& _rxNewAcc)
642{
  OSL_ENSURE(m_pListBoxHelper,"Helper is not valid!")do { if (true && (!(m_pListBoxHelper))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/accessibility/source/standard/vclxaccessiblelist.cxx"
 ":" "643" ": "), "%s", "Helper is not valid!"); } } while (false
);
  bool bNowSelected = false;
  if ( m_pListBoxHelper )
  {
      bNowSelected = m_pListBoxHelper->IsEntryPosSelected (_nPos);
      if ( bNowSelected )
      {
          _rxNewAcc = CreateChild(_nPos);
          _rNewValue <<= _rxNewAcc;
      }
  }
  return bNowSelected;
655}


658void VCLXAccessibleList::UpdateSelection_Impl(sal_Int32)
659{
  uno::Any aOldValue, aNewValue;

  {
      SolarMutexGuard aSolarGuard;
      ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
      Reference< XAccessible > xNewAcc;

      if ( m_pListBoxHelper )
      {
          sal_Int32 i=0;
          m_nCurSelectedPos = LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF));
          for ( const auto& rChild : m_aAccessibleChildren )
          {
              Reference< XAccessible > xHold = rChild;
              if ( xHold.is() )
              {
                  VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >( xHold.get() );
                  // Retrieve the item's index from the list entry.
                  bool bNowSelected = m_pListBoxHelper->IsEntryPosSelected (i);
                  if (bNowSelected)
                      m_nCurSelectedPos = i;

                  if ( bNowSelected && !pItem->IsSelected() )
                  {
                      xNewAcc = rChild;
                      aNewValue <<= xNewAcc;
                  }
                  else if ( pItem->IsSelected() )
                      m_nLastSelectedPos = i;

                  pItem->SetSelected( bNowSelected );
              }
              else
              { // it could happen that a child was not created before
                  checkEntrySelected(i,aNewValue,xNewAcc);
              }
              ++i;
          }
          const sal_Int32 nCount = m_pListBoxHelper->GetEntryCount();
          if ( i < nCount ) // here we have to check the if any other listbox entry is selected
          {
              for (; i < nCount && !checkEntrySelected(i,aNewValue,xNewAcc) ;++i )
                  ;
          }
          if ( xNewAcc.is() && GetWindow()->HasFocus() )
          {
              if ( m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) )
                  aOldValue <<= getAccessibleChild( m_nLastSelectedPos );
              aNewValue <<= xNewAcc;
          }
          if (m_pListBoxHelper->IsInDropDown())
          {
              if ( aNewValue.hasValue() || aOldValue.hasValue() )
                  NotifyAccessibleEvent(
                          AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
                          aOldValue,
                          aNewValue );
              //the SELECTION_CHANGED is not necessary
              //NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
          }
      }
  }
722}


725// XAccessibleSelection

727void SAL_CALL VCLXAccessibleList::selectAccessibleChild( sal_Int32 nChildIndex )
728{
  bool bNotify = false;

  {
      SolarMutexGuard aSolarGuard;
      ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

      if ( m_pListBoxHelper )
      {
          checkSelection_Impl(nChildIndex,*m_pListBoxHelper,false);

          m_pListBoxHelper->SelectEntryPos( static_cast<sal_uInt16>(nChildIndex) );
          // call the select handler, don't handle events in this time
          m_bDisableProcessEvent = true;
          m_pListBoxHelper->Select();
          m_bDisableProcessEvent = false;
          bNotify = true;
      }
  }

  if ( bNotify )
      UpdateSelection_Impl();
750}

752sal_Bool SAL_CALL VCLXAccessibleList::isAccessibleChildSelected( sal_Int32 nChildIndex )
753{
  SolarMutexGuard aSolarGuard;
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  bool bRet = false;
  if ( m_pListBoxHelper )
  {
      checkSelection_Impl(nChildIndex,*m_pListBoxHelper,false);

      bRet = m_pListBoxHelper->IsEntryPosSelected( static_cast<sal_uInt16>(nChildIndex) );
  }
  return bRet;
765}

767void SAL_CALL VCLXAccessibleList::clearAccessibleSelection(  )
768{
  bool bNotify = false;

  {
      SolarMutexGuard aSolarGuard;
      ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

      if ( m_pListBoxHelper )
      {
          m_pListBoxHelper->SetNoSelection();
          bNotify = true;
      }
  }

  if ( bNotify )
      UpdateSelection_Impl();
784}

786void SAL_CALL VCLXAccessibleList::selectAllAccessibleChildren(  )
787{
  bool bNotify = false;

  {
      SolarMutexGuard aSolarGuard;
      ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

      if ( m_pListBoxHelper )
      {
          const sal_Int32 nCount = m_pListBoxHelper->GetEntryCount();
          for ( sal_Int32 i = 0; i < nCount; ++i )
              m_pListBoxHelper->SelectEntryPos( i );
          // call the select handler, don't handle events in this time
          m_bDisableProcessEvent = true;
          m_pListBoxHelper->Select();
          m_bDisableProcessEvent = false;
          bNotify = true;
      }
  }

  if ( bNotify )
      UpdateSelection_Impl();
809}

811sal_Int32 SAL_CALL VCLXAccessibleList::getSelectedAccessibleChildCount(  )
812{
  SolarMutexGuard aSolarGuard;
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  sal_Int32 nCount = 0;
  if ( m_pListBoxHelper )
         nCount = m_pListBoxHelper->GetSelectedEntryCount();
  return nCount;
820}

822Reference< XAccessible > SAL_CALL VCLXAccessibleList::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
823{
  SolarMutexGuard aSolarGuard;
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  if ( m_pListBoxHelper )
  {
      checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,true);
      return getAccessibleChild( m_pListBoxHelper->GetSelectedEntryPos( static_cast<sal_uInt16>(nSelectedChildIndex) ) );
  }

  return nullptr;
834}

836void SAL_CALL VCLXAccessibleList::deselectAccessibleChild( sal_Int32 nSelectedChildIndex )
837{
  bool bNotify = false;

  {
      SolarMutexGuard aSolarGuard;
      ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

      if ( m_pListBoxHelper )
      {
          checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,false);

          m_pListBoxHelper->SelectEntryPos( static_cast<sal_uInt16>(nSelectedChildIndex), false );
          // call the select handler, don't handle events in this time
          m_bDisableProcessEvent = true;
          m_pListBoxHelper->Select();
          m_bDisableProcessEvent = false;
          bNotify = true;
      }
  }

  if ( bNotify )
      UpdateSelection_Impl();
859}

861awt::Rectangle VCLXAccessibleList::implGetBounds()
862{
  awt::Rectangle aBounds ( 0, 0, 0, 0 );
  if ( m_pListBoxHelper
      && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
  {
      if ( m_pListBoxHelper->IsInDropDown() )
          aBounds = AWTRectangle(m_pListBoxHelper->GetDropDownPosSizePixel());
  }
  else
  {
      // a list has the same bounds as his parent but starts at (0,0)
      aBounds = VCLXAccessibleComponent::implGetBounds();
      aBounds.X = 0;
      aBounds.Y = 0;
      if ( m_aBoxType == COMBOBOX )
      {
          VclPtr< ComboBox > pBox = GetAs< ComboBox >();
          if ( pBox )
          {
              Size aSize = pBox->GetSubEdit()->GetSizePixel();
              aBounds.Y += aSize.Height();
              aBounds.Height -= aSize.Height();
          }
      }
  }
  return aBounds;
888}


891awt::Point VCLXAccessibleList::getLocationOnScreen(  )
892{
  SolarMutexGuard aSolarGuard;
  ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );

  awt::Point aPos;
  if ( m_pListBoxHelper
      && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
  {
      if ( m_pListBoxHelper->IsInDropDown() )
          aPos = AWTPoint(m_pListBoxHelper->GetDropDownPosSizePixel().TopLeft());
  }
  else
  {
      aPos = VCLXAccessibleComponent::getLocationOnScreen();
      if ( m_aBoxType == COMBOBOX )
      {
          VclPtr< ComboBox > pBox = GetAs< ComboBox >();
          if ( pBox )
          {
              aPos.Y += pBox->GetSubEdit()->GetSizePixel().Height();
          }
      }
  }
  return aPos;
916}


919bool VCLXAccessibleList::IsInDropDown() const
920{
  return m_pListBoxHelper->IsInDropDown();
922}


925void VCLXAccessibleList::HandleDropOpen()
926{
  if ( !m_bDisableProcessEvent )
      UpdateSelection_Impl();
  if (m_nCurSelectedPos != LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)) &&
      m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND(((sal_Int32) 0x7FFFFFFF)))
  {
      Reference< XAccessible > xChild = getAccessibleChild(m_nCurSelectedPos);
      if(xChild.is())
      {
          uno::Any aNewValue;
          aNewValue <<= xChild;
          NotifyAccessibleEvent(AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, uno::Any(), aNewValue );
      }
  }
940}

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

←

/home/maarten/src/libreoffice/core/include/toolkit/awt/vclxaccessiblecomponent.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 
20#ifndef INCLUDED_TOOLKIT_AWT_VCLXACCESSIBLECOMPONENT_HXX
21#define INCLUDED_TOOLKIT_AWT_VCLXACCESSIBLECOMPONENT_HXX
22 
23#include <toolkit/dllapi.h>
24#include <com/sun/star/lang/XServiceInfo.hpp>
25#include <cppuhelper/implbase1.hxx>
26#include <comphelper/accimplaccess.hxx>
27#include <comphelper/accessiblecomponenthelper.hxx>
28 
29 
30#include <tools/link.hxx>
31#include <vcl/vclptr.hxx>
32 
33namespace com::sun::star::accessibility { class XAccessible; }
34 
35namespace vcl { class Window; }
36class VCLXWindow;
37class VclWindowEvent;
38 
39namespace utl {
40class AccessibleRelationSetHelper;
41class AccessibleStateSetHelper;
42}
43 
44 
45 
46typedef ::cppu::ImplHelper1<
47    css::lang::XServiceInfo > VCLXAccessibleComponent_BASE;
48 
49class TOOLKIT_DLLPUBLIC__attribute__ ((visibility("default"))) VCLXAccessibleComponent
50        :public comphelper::OAccessibleExtendedComponentHelper
51        ,public ::comphelper::OAccessibleImplementationAccess
52        ,public VCLXAccessibleComponent_BASE
53{
54private:
55    rtl::Reference<VCLXWindow>      m_xVCLXWindow;
56    VclPtr<vcl::Window>             m_xEventSource;
57 
58    DECL_LINK( WindowEventListener, VclWindowEvent&, void )static void LinkStubWindowEventListener(void *, VclWindowEvent
&); void WindowEventListener(VclWindowEvent&);
59    DECL_LINK( WindowChildEventListener, VclWindowEvent&, void )static void LinkStubWindowChildEventListener(void *, VclWindowEvent
&); void WindowChildEventListener(VclWindowEvent&);
60    void            DisconnectEvents();
61 
62protected:
63    virtual void    ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent );
64    virtual void    ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent );
65    virtual void    FillAccessibleRelationSet( utl::AccessibleRelationSetHelper& rRelationSet );
66    virtual void    FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet );
67 
68    virtual css::uno::Reference< css::accessibility::XAccessible > GetChildAccessible( const VclWindowEvent& rVclWindowEvent );
69 
70public:
71    VCLXAccessibleComponent( VCLXWindow* pVCLXWindow );
72    virtual ~VCLXAccessibleComponent() override;
73 
74    VCLXWindow*    GetVCLXWindow() const;
75    VclPtr<vcl::Window> GetWindow() const;
76    template< class derived_type > VclPtr< derived_type > GetAs() const {
77        return VclPtr< derived_type >( static_cast< derived_type * >( GetWindow().get() ) ); }
2
←
Calling constructor for 'VclPtr<ListBox>'→
7
←
Returning from constructor for 'VclPtr<ListBox>'→
8
←
Calling implicit destructor for 'VclPtr<vcl::Window>'→
9
←
Calling '~Reference'→
16
←
Returning from '~Reference'→
17
←
Returning from destructor for 'VclPtr<vcl::Window>'→
78    template< class derived_type > VclPtr< derived_type > GetAsDynamic() const {
79        return VclPtr< derived_type >( dynamic_cast< derived_type * >( GetWindow().get() ) ); }
80 
81    virtual void SAL_CALL disposing() override;
82 
83    // css::uno::XInterface
84    DECLARE_XINTERFACE()virtual css::uno::Any queryInterface( const css::uno::Type&
 aType ) override; virtual void acquire() throw() override; virtual
 void release() throw() override;
85    // css::lang::XTypeProvider
86    DECLARE_XTYPEPROVIDER()virtual css::uno::Sequence< css::uno::Type > getTypes( )
 override; virtual css::uno::Sequence< sal_Int8 > getImplementationId
( ) override;
87 
88    // XServiceInfo
89    virtual OUString SAL_CALL getImplementationName() override;
90    virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) override;
91    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
92 
93    // css::accessibility::XAccessibleContext
94    sal_Int32 SAL_CALL getAccessibleChildCount(  ) override;
95    css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleChild( sal_Int32 i ) override;
96    css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleParent(  ) override;
97    sal_Int32 SAL_CALL getAccessibleIndexInParent(  ) override;
98    sal_Int16 SAL_CALL getAccessibleRole(  ) override;
99    OUString SAL_CALL getAccessibleDescription(  ) override;
100    OUString SAL_CALL getAccessibleName(  ) override;
101    OUString SAL_CALL getAccessibleId(  ) override;
102    css::uno::Reference< css::accessibility::XAccessibleRelationSet > SAL_CALL getAccessibleRelationSet(  ) override;
103    css::uno::Reference< css::accessibility::XAccessibleStateSet > SAL_CALL getAccessibleStateSet(  ) override;
104    css::lang::Locale SAL_CALL getLocale(  ) override;
105 
106    // css::accessibility::XAccessibleComponent
107    css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleAtPoint( const css::awt::Point& aPoint ) override;
108    css::awt::Point SAL_CALL getLocationOnScreen(  ) override;
109    void SAL_CALL grabFocus(  ) override;
110    virtual sal_Int32 SAL_CALL getForeground(  ) override;
111    virtual sal_Int32 SAL_CALL getBackground(  ) override;
112 
113    // css::accessibility::XAccessibleExtendedComponent
114    virtual css::uno::Reference< css::awt::XFont > SAL_CALL getFont(  ) override;
115    virtual OUString SAL_CALL getTitledBorderText(  ) override;
116    virtual OUString SAL_CALL getToolTipText(  ) override;
117 
118protected:
119    // base class overridables
120    css::awt::Rectangle implGetBounds(  ) override;
121 
122private:
123    /** we may be reparented (if external components use OAccessibleImplementationAccess base class),
124        so this method here returns the parent in the VCL world, in opposite to the parent
125        an external component gave us
126    @precond
127        the caller must ensure thread safety, i.e. our mutex must be locked
128    */
129    css::uno::Reference< css::accessibility::XAccessible >
130            getVclParent() const;
131};
132 
133/* ----------------------------------------------------------
134  Accessibility only for the Window hierarchy!
135  Maybe derived classes must overwrite these Accessibility interfaces:
136 
137    // XAccessibleContext:
138    sal_Int16 getAccessibleRole() => VCL Window::GetAccessibleRole()
139    OUString getAccessibleDescription() => VCL Window::GetAccessibleDescription
140    OUString getAccessibleName() => VCL Window::GetAccessibleText() => Most windows return Window::GetText()
141    OUString getAccessibleId() => VCL Window::get_id()
142    Reference< XAccessibleRelationSet > getAccessibleRelationSet()
143    Reference< XAccessibleStateSet > getAccessibleStateSet() => override FillAccessibleStateSet( ... )
144 
145---------------------------------------------------------- */
146 
147 
148#endif // INCLUDED_TOOLKIT_AWT_VCLXACCESSIBLECOMPONENT_HXX
149 
150/* 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)
3
←
Calling constructor for 'Reference<ListBox>'→
6
←
Returning from constructor for 'Reference<ListBox>'→
  {}

  /** 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)
4
←
Assuming field 'm_pBody' is non-null→
5
←
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_pBody9.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
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
)
10
←
Taking true branch→
23
←
Taking true branch→
          m_pBody->release();
11
←
Calling 'VclReferenceBase::release'→
15
←
Returning; memory was released→
24
←
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)
12
←
Assuming the condition is true→
13
←
Taking true branch→
40            delete this;
14
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif