/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 vclxaccessibletoolbox.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/vclxaccessibletoolbox.cxx

/home/maarten/src/libreoffice/core/accessibility/source/standard/vclxaccessibletoolbox.cxx

→

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

21#include <standard/vclxaccessibletoolbox.hxx>
22#include <standard/vclxaccessibletoolboxitem.hxx>
23#include <toolkit/helper/convert.hxx>

25#include <unotools/accessiblestatesethelper.hxx>
26#include <com/sun/star/accessibility/AccessibleEventId.hpp>
27#include <com/sun/star/accessibility/AccessibleStateType.hpp>
28#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
29#include <com/sun/star/lang/XUnoTunnel.hpp>
30#include <o3tl/safeint.hxx>
31#include <vcl/toolbox.hxx>
32#include <vcl/vclevent.hxx>
33#include <comphelper/accessiblewrapper.hxx>
34#include <comphelper/processfactory.hxx>
35#include <comphelper/servicehelper.hxx>
36#include <comphelper/types.hxx>
37#include <cppuhelper/typeprovider.hxx>

39using namespace ::comphelper;
40using namespace ::com::sun::star;
41using namespace ::com::sun::star::uno;
42using namespace ::com::sun::star::lang;
43using namespace ::com::sun::star::accessibility;

45namespace
46{

  // = OToolBoxWindowItemContext

  /** XAccessibleContext implementation for a toolbox item which is represented by a VCL Window
  */
  class OToolBoxWindowItemContext final : public OAccessibleContextWrapper
  {
      sal_Int32 m_nIndexInParent;
  public:
      OToolBoxWindowItemContext(sal_Int32 _nIndexInParent,
          const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
          const css::uno::Reference< css::accessibility::XAccessibleContext >& _rxInnerAccessibleContext,
          const css::uno::Reference< css::accessibility::XAccessible >& _rxOwningAccessible,
          const css::uno::Reference< css::accessibility::XAccessible >& _rxParentAccessible
          ) : OAccessibleContextWrapper(
          _rxContext,
          _rxInnerAccessibleContext,
          _rxOwningAccessible,
          _rxParentAccessible     )
          ,m_nIndexInParent(_nIndexInParent)
      {
      }
      virtual sal_Int32 SAL_CALL getAccessibleIndexInParent(  ) override;
  };


  sal_Int32 SAL_CALL OToolBoxWindowItemContext::getAccessibleIndexInParent(  )
  {
      ::osl::MutexGuard aGuard( m_aMutex );
      return m_nIndexInParent;
  }


  // = OToolBoxWindowItem

  typedef ::cppu::ImplHelper1 <   XUnoTunnel
                              >   OToolBoxWindowItem_Base;

  /** XAccessible implementation for a toolbox item which is represented by a VCL Window
  */
  class OToolBoxWindowItem
          :public OAccessibleWrapper
          ,public OToolBoxWindowItem_Base
  {
  private:
      sal_Int32 m_nIndexInParent;

  public:
      sal_Int32    getIndexInParent() const                    { return m_nIndexInParent; }
      void         setIndexInParent( sal_Int32 _nNewIndex )    { m_nIndexInParent = _nNewIndex; }

      static Sequence< sal_Int8 > getUnoTunnelId();

  public:
      OToolBoxWindowItem(sal_Int32 _nIndexInParent,
          const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
          const css::uno::Reference< css::accessibility::XAccessible >& _rxInnerAccessible,
          const css::uno::Reference< css::accessibility::XAccessible >& _rxParentAccessible
          ) : OAccessibleWrapper(
          _rxContext,
          _rxInnerAccessible,
          _rxParentAccessible)
          ,m_nIndexInParent(_nIndexInParent)
      {
      }

  protected:
      // XInterface
      DECLARE_XINTERFACE( )virtual css::uno::Any queryInterface( const css::uno::Type&
 aType ) override; virtual void acquire() throw() override; virtual
 void release() throw() override;
      DECLARE_XTYPEPROVIDER( )virtual css::uno::Sequence< css::uno::Type > getTypes( )
 override; virtual css::uno::Sequence< sal_Int8 > getImplementationId
( ) override;

      // OAccessibleWrapper
      virtual OAccessibleContextWrapper* createAccessibleContext(
              const css::uno::Reference< css::accessibility::XAccessibleContext >& _rxInnerContext
          ) override;

      // XUnoTunnel
      virtual sal_Int64 SAL_CALL getSomething( const Sequence< sal_Int8 >& aIdentifier ) override;
  };

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

  OAccessibleContextWrapper* OToolBoxWindowItem::createAccessibleContext(
          const Reference< XAccessibleContext >& _rxInnerContext )
  {
      return new OToolBoxWindowItemContext( m_nIndexInParent, getComponentContext(), _rxInnerContext, this, getParent() );
  }

  Sequence< sal_Int8 > OToolBoxWindowItem::getUnoTunnelId()
  {
      static ::cppu::OImplementationId implId;

      return implId.getImplementationId();
  }

  sal_Int64 SAL_CALL OToolBoxWindowItem::getSomething( const Sequence< sal_Int8 >& _rId )
  {
      if (isUnoTunnelId<OToolBoxWindowItem>(_rId))
          return reinterpret_cast< sal_Int64>( this );

      return 0;
  }
150}

152// VCLXAccessibleToolBox

154VCLXAccessibleToolBox::VCLXAccessibleToolBox( VCLXWindow* pVCLXWindow ) :

  VCLXAccessibleComponent( pVCLXWindow )

158{
159}

161VCLXAccessibleToolBox::~VCLXAccessibleToolBox()
162{
163}

165VCLXAccessibleToolBoxItem* VCLXAccessibleToolBox::GetItem_Impl( ToolBox::ImplToolItems::size_type _nPos )
166{
  VCLXAccessibleToolBoxItem* pItem = nullptr;
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( pToolBox )
  {
      ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
          //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
      // returns only toolbox buttons, not windows
      if ( aIter != m_aAccessibleChildren.end()  && aIter->second.is())
          pItem = static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
  }

  return pItem;
179}

181void VCLXAccessibleToolBox::UpdateFocus_Impl()
182{
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if( !pToolBox )
      return;

  // submit events only if toolbox has the focus to avoid sending events due to mouse move
  bool bHasFocus = false;
  if ( pToolBox->HasFocus() )
      bHasFocus = true;
  else
  {
      // check for subtoolbar, i.e. check if our parent is a toolbar
      ToolBox* pToolBoxParent = dynamic_cast< ToolBox* >( pToolBox->GetParent() );
      // subtoolbars never get the focus as key input is just forwarded, so check if the parent toolbar has it
      if ( pToolBoxParent && pToolBoxParent->HasFocus() )
          bHasFocus = true;
  }

  if ( !bHasFocus )
      return;

  sal_uInt16 nHighlightItemId = pToolBox->GetHighlightItemId();
  sal_uInt16 nFocusCount = 0;
  for ( const auto& [rPos, rxChild] : m_aAccessibleChildren )
  {
      sal_uInt16 nItemId = pToolBox->GetItemId( rPos );

      if ( rxChild.is() )
      {
          VCLXAccessibleToolBoxItem* pItem =
              static_cast< VCLXAccessibleToolBoxItem* >( rxChild.get() );
          if ( pItem->HasFocus() && nItemId != nHighlightItemId )
          {
              // reset the old focused item
              pItem->SetFocus( false );
              nFocusCount++;
          }
          if ( nItemId == nHighlightItemId )
          {
              // set the new focused item
              pItem->SetFocus( true );
              nFocusCount++;
          }
      }
      // both items changed?
      if ( nFocusCount > 1 )
          break;
  }
230}

232void VCLXAccessibleToolBox::ReleaseFocus_Impl( ToolBox::ImplToolItems::size_type _nPos )
233{
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( pToolBox ) // #107124#, do not check for focus because this message is also handled in losefocus
  {
      ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
          //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
      if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
      {
          VCLXAccessibleToolBoxItem* pItem =
              static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
          if ( pItem->HasFocus() )
              pItem->SetFocus( false );
      }
  }
247}

249void VCLXAccessibleToolBox::UpdateChecked_Impl( ToolBox::ImplToolItems::size_type _nPos )
250{
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( !pToolBox )
      return;

  sal_uInt16 nFocusId = pToolBox->GetItemId( _nPos );
  VCLXAccessibleToolBoxItem* pFocusItem = nullptr;

  for ( const auto& [rPos, rxChild] : m_aAccessibleChildren )
  {
          sal_uInt16 nItemId = pToolBox->GetItemId( rPos );

          VCLXAccessibleToolBoxItem* pItem =
              static_cast< VCLXAccessibleToolBoxItem* >( rxChild.get() );
          pItem->SetChecked( pToolBox->IsItemChecked( nItemId ) );
          if ( nItemId == nFocusId )
              pFocusItem = pItem;
  }
  //Solution:If the position is not a child item,the focus should not be called
  if ( pFocusItem && _nPos != ToolBox::ITEM_NOTFOUND )
      pFocusItem->SetFocus( true );
271}

273void VCLXAccessibleToolBox::UpdateIndeterminate_Impl( ToolBox::ImplToolItems::size_type _nPos )
274{
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( !pToolBox )
      return;

  sal_uInt16 nItemId = pToolBox->GetItemId( _nPos );

  ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
      //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
  if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
  {
      VCLXAccessibleToolBoxItem* pItem =
          static_cast< VCLXAccessibleToolBoxItem* >( aIter->second.get() );
      if ( pItem )
          pItem->SetIndeterminate( pToolBox->GetItemState( nItemId ) == TRISTATE_INDET );
  }
290}

292void VCLXAccessibleToolBox::implReleaseToolboxItem( ToolBoxItemsMap::iterator const & _rMapPos,
      bool _bNotifyRemoval )
294{
  Reference< XAccessible > xItemAcc( _rMapPos->second );
  if ( !xItemAcc.is() )
      return;

  if ( _bNotifyRemoval )
  {
      NotifyAccessibleEvent( AccessibleEventId::CHILD, Any( xItemAcc ), Any() );
  }

  auto pWindowItem = comphelper::getUnoTunnelImplementation<OToolBoxWindowItem>(xItemAcc);
  if ( !pWindowItem )
  {
      static_cast< VCLXAccessibleToolBoxItem* >( xItemAcc.get() )->ReleaseToolBox();
      ::comphelper::disposeComponent( xItemAcc );
  }
  else
  {
      Reference< XAccessibleContext > xContext( pWindowItem->getContextNoCreate() );
      ::comphelper::disposeComponent( xContext );
  }
315}

317void VCLXAccessibleToolBox::UpdateItem_Impl( ToolBox::ImplToolItems::size_type _nPos)
318{
  if ( _nPos < m_aAccessibleChildren.size() )
  {
      UpdateAllItems_Impl();
      return;
  }

  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( !pToolBox )
      return;

  // adjust the "index-in-parent"s
  ToolBoxItemsMap::iterator aIndexAdjust = m_aAccessibleChildren.upper_bound( _nPos );
      //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
  while ( m_aAccessibleChildren.end() != aIndexAdjust )
  {
      Reference< XAccessible > xItemAcc( aIndexAdjust->second );

      auto pWindowItem = comphelper::getUnoTunnelImplementation<OToolBoxWindowItem>(xItemAcc);
      if ( !pWindowItem )
      {
          VCLXAccessibleToolBoxItem* pItem = static_cast< VCLXAccessibleToolBoxItem* >( xItemAcc.get() );
          if ( pItem )
          {
              sal_Int32 nIndex = pItem->getIndexInParent( );
              nIndex++;
              pItem->setIndexInParent( nIndex );
          }
      }
      else
      {
          sal_Int32 nIndex = pWindowItem->getIndexInParent( );
          nIndex++;
          pWindowItem->setIndexInParent( nIndex );
      }

      ++aIndexAdjust;
  }

  // TODO: we should make this dependent on the existence of event listeners
  // with the current implementation, we always create accessible object
  Any aNewChild( getAccessibleChild( static_cast<sal_Int32>(_nPos) ) );
      //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
  NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewChild );
362}

364void VCLXAccessibleToolBox::UpdateAllItems_Impl()
365{
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( !pToolBox )
      return;

  // deregister the old items
  for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
          aIter != m_aAccessibleChildren.end(); ++aIter )
  {
      implReleaseToolboxItem( aIter, true );
  }
  m_aAccessibleChildren.clear();

  // register the new items
  ToolBox::ImplToolItems::size_type i, nCount = pToolBox->GetItemCount();
  for ( i = 0; i < nCount; ++i )
  {
      Any aNewValue;
      aNewValue <<= getAccessibleChild( static_cast<sal_Int32>(i) );
          //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
      NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
  }
387}

389void VCLXAccessibleToolBox::UpdateCustomPopupItemp_Impl( vcl::Window* pWindow, bool bOpen )
390{
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if( !(pWindow && pToolBox) )
      return;

  const sal_uInt16 nDownItem = pToolBox->GetDownItemId();
  if ( !nDownItem )
      // No item is currently in down state.
      // Moreover, calling GetItemPos with 0 will find a separator if there is any.
      return;

  Reference< XAccessible > xChild( pWindow->GetAccessible() );
  if( xChild.is() )
  {
      Reference< XAccessible > xChildItem( getAccessibleChild( static_cast< sal_Int32 >( pToolBox->GetItemPos( nDownItem ) ) ) );
          //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
      VCLXAccessibleToolBoxItem* pItem = static_cast< VCLXAccessibleToolBoxItem* >( xChildItem.get() );

      pItem->SetChild( xChild );
      pItem->NotifyChildEvent( xChild, bOpen );
  }
411}

413void VCLXAccessibleToolBox::UpdateItemName_Impl( ToolBox::ImplToolItems::size_type _nPos )
414{
  VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos );
  if ( pItem )
      pItem->NameChanged();
418}

420void VCLXAccessibleToolBox::UpdateItemEnabled_Impl( ToolBox::ImplToolItems::size_type _nPos )
421{
  VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos );
  if ( pItem )
      pItem->ToggleEnableState();
425}

427void VCLXAccessibleToolBox::HandleSubToolBarEvent( const VclWindowEvent& rVclWindowEvent )
428{
  vcl::Window* pChildWindow = static_cast<vcl::Window *>(rVclWindowEvent.GetData());
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( !(pChildWindow
      && pToolBox
      && pToolBox == pChildWindow->GetParent()
      && pChildWindow->GetType() == WindowType::TOOLBOX) )
      return;

  const sal_uInt16 nCurItemId( pToolBox->GetCurItemId() );
  if ( !nCurItemId )
      // No item is currently active (might happen when opening the overflow popup).
      // Moreover, calling GetItemPos with 0 will find a separator if there is any.
      return;

  ToolBox::ImplToolItems::size_type nIndex = pToolBox->GetItemPos( nCurItemId );
  Reference< XAccessible > xItem = getAccessibleChild( nIndex );
      //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
  if ( xItem.is() )
  {
      Reference< XAccessible > xChild = pChildWindow->GetAccessible();
      VCLXAccessibleToolBoxItem* pItem =
          static_cast< VCLXAccessibleToolBoxItem* >( xItem.get() );
      pItem->SetChild( xChild );
      pItem->NotifyChildEvent( xChild, true/*_bShow*/ );
  }
454}

456void VCLXAccessibleToolBox::ReleaseSubToolBox( ToolBox* _pSubToolBox )
457{
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( !pToolBox )
      return;

  ToolBox::ImplToolItems::size_type nIndex = pToolBox->GetItemPos( pToolBox->GetCurItemId() );
  if ( nIndex == ToolBox::ITEM_NOTFOUND )
      return; // not found

  Reference< XAccessible > xItem = getAccessibleChild( nIndex );
      //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
  if ( !xItem.is() )
      return;

  Reference< XAccessible > xChild = _pSubToolBox->GetAccessible();
  VCLXAccessibleToolBoxItem* pItem =
      static_cast< VCLXAccessibleToolBoxItem* >( xItem.get() );
  if ( pItem->GetChild() == xChild )
  {
      pItem->SetChild( Reference< XAccessible >() );
      pItem->NotifyChildEvent( xChild, false );
  }
479}

481void VCLXAccessibleToolBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
482{
  VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );

  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( pToolBox )
  {
      rStateSet.AddState( AccessibleStateType::FOCUSABLE );
      if ( pToolBox->IsHorizontal() )
          rStateSet.AddState( AccessibleStateType::HORIZONTAL );
      else
          rStateSet.AddState( AccessibleStateType::VERTICAL );
  }
494}

496void VCLXAccessibleToolBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
497{
  // to prevent an early release of the toolbox (VclEventId::ObjectDying)
  Reference< XAccessibleContext > xHoldAlive = this;

  switch ( rVclWindowEvent.GetId() )
  {
      case VclEventId::ToolboxClick:
      case VclEventId::ToolboxSelect:
      {
          VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
          if ( rVclWindowEvent.GetData() )
          {
              UpdateChecked_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
              UpdateIndeterminate_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
          }
          else if( pToolBox->GetItemPos(pToolBox->GetCurItemId()) != ToolBox::ITEM_NOTFOUND )
          {
              UpdateChecked_Impl( pToolBox->GetItemPos(pToolBox->GetCurItemId()) );
              UpdateIndeterminate_Impl( pToolBox->GetItemPos(pToolBox->GetCurItemId()) );
          }
          break;
      }
      case VclEventId::ToolboxDoubleClick:
      case VclEventId::ToolboxActivate:
      case VclEventId::ToolboxDeactivate:
      //case VclEventId::ToolboxSelect:
          break;

      case VclEventId::ToolboxItemUpdated:
      {
          if ( rVclWindowEvent.GetData() )
          {
              UpdateChecked_Impl( ToolBox::ITEM_NOTFOUND );
              UpdateIndeterminate_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
          }
          break;
      }

      case VclEventId::ToolboxHighlight:
          UpdateFocus_Impl();
          break;

      case VclEventId::ToolboxHighlightOff:
          ReleaseFocus_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
          break;

      case VclEventId::ToolboxItemAdded :
          UpdateItem_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
          break;

      case VclEventId::ToolboxItemRemoved :
      case VclEventId::ToolboxAllItemsChanged :
      {
          UpdateAllItems_Impl();
          break;
      }

      case VclEventId::ToolboxItemWindowChanged:
      {
          auto nPos = static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData()));
          ToolBoxItemsMap::iterator aAccessiblePos( m_aAccessibleChildren.find( nPos ) );
              //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
          if ( m_aAccessibleChildren.end() != aAccessiblePos )
          {
              implReleaseToolboxItem( aAccessiblePos, false );
              m_aAccessibleChildren.erase (aAccessiblePos);
          }

          Any aNewValue;
          aNewValue <<= getAccessibleChild(nPos);
              //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
          NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
          break;
      }
      case VclEventId::ToolboxItemTextChanged :
          UpdateItemName_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
          break;

      case VclEventId::ToolboxItemEnabled :
      case VclEventId::ToolboxItemDisabled :
      {
          UpdateItemEnabled_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
          break;
      }

      case VclEventId::DropdownOpen:
      case VclEventId::DropdownClose:
      {
          UpdateCustomPopupItemp_Impl( static_cast< vcl::Window* >( rVclWindowEvent.GetData() ), rVclWindowEvent.GetId() == VclEventId::DropdownOpen );
          break;
      }

      case VclEventId::ObjectDying :
      {
          // if this toolbox is a subtoolbox, we have to release it from its parent
          VclPtr< vcl::Window > pWin = GetAs< vcl::Window >();
          if ( pWin && pWin->GetParent() &&
               pWin->GetParent()->GetType() == WindowType::TOOLBOX )
          {
              VCLXAccessibleToolBox* pParent = static_cast< VCLXAccessibleToolBox* >(
                  pWin->GetParent()->GetAccessible()->getAccessibleContext().get() );
              if ( pParent )
                  pParent->ReleaseSubToolBox(static_cast<ToolBox *>(pWin.get()));
          }

          // dispose all items
          for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
                aIter != m_aAccessibleChildren.end(); ++aIter )
          {
              implReleaseToolboxItem( aIter, false );
          }
          m_aAccessibleChildren.clear();

          [[fallthrough]]; // call base class
      }

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

618void VCLXAccessibleToolBox::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
619{
  switch ( rVclWindowEvent.GetId() )
  {
      case VclEventId::WindowShow:  // send create on show for direct accessible children
      {
          Reference< XAccessible > xReturn = GetItemWindowAccessible(rVclWindowEvent);
          if ( xReturn.is() )
              NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), Any(xReturn) );
          else
              HandleSubToolBarEvent( rVclWindowEvent );
      }
      break;

      default:
         VCLXAccessibleComponent::ProcessWindowChildEvent( rVclWindowEvent );

  }
636}

638// XInterface
639IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleToolBox, VCLXAccessibleComponent, VCLXAccessibleToolBox_BASE )void VCLXAccessibleToolBox::acquire() throw() { VCLXAccessibleComponent
::acquire(); } void VCLXAccessibleToolBox::release() throw() {
 VCLXAccessibleComponent::release(); } css::uno::Any VCLXAccessibleToolBox
::queryInterface( const css::uno::Type& _rType ) { css::uno
::Any aReturn = VCLXAccessibleComponent::queryInterface( _rType
 ); if ( !aReturn.hasValue() ) aReturn = VCLXAccessibleToolBox_BASE
::queryInterface( _rType ); return aReturn; }

641// XTypeProvider
642IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleToolBox, VCLXAccessibleComponent, VCLXAccessibleToolBox_BASE )css::uno::Sequence< css::uno::Type > VCLXAccessibleToolBox
::getTypes( ) { return ::comphelper::concatSequences( VCLXAccessibleComponent
::getTypes(), VCLXAccessibleToolBox_BASE::getTypes() ); } css
::uno::Sequence< sal_Int8 > VCLXAccessibleToolBox::getImplementationId
( ) { return css::uno::Sequence<sal_Int8>(); }

644// XComponent
645void SAL_CALL VCLXAccessibleToolBox::disposing()
646{
  VCLXAccessibleComponent::disposing();

  // release the items
  for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
        aIter != m_aAccessibleChildren.end(); ++aIter )
  {
      implReleaseToolboxItem( aIter, false );
  }
  m_aAccessibleChildren.clear();
656}

658// XServiceInfo
659OUString VCLXAccessibleToolBox::getImplementationName()
660{
  return "com.sun.star.comp.toolkit.AccessibleToolBox";
662}

664Sequence< OUString > VCLXAccessibleToolBox::getSupportedServiceNames()
665{
  return comphelper::concatSequences(VCLXAccessibleComponent::getSupportedServiceNames(),
                                     Sequence<OUString>{"com.sun.star.accessibility.AccessibleToolBox"});
668}

670// XAccessibleContext
671sal_Int32 SAL_CALL VCLXAccessibleToolBox::getAccessibleChildCount(  )
672{
  comphelper::OExternalLockGuard aGuard( this );
  return implGetAccessibleChildCount();
675}

sal_Int32 VCLXAccessibleToolBox::implGetAccessibleChildCount(  )
{
  sal_Int32 nCount = 0;
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( pToolBox )
      nCount = pToolBox->GetItemCount();
          //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!

  return nCount;
686}

688Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleChild( sal_Int32 i )
689{
  comphelper::OExternalLockGuard aGuard( this );

  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( (!pToolBox) || i < 0 || o3tl::make_unsigned(i) >= pToolBox->GetItemCount() )
      throw IndexOutOfBoundsException();

  Reference< XAccessible > xChild;
  // search for the child
  ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find(i);
  if ( m_aAccessibleChildren.end() == aIter )
  {
      sal_uInt16 nItemId = pToolBox->GetItemId( i );
      sal_uInt16 nHighlightItemId = pToolBox->GetHighlightItemId();
      vcl::Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
      // not found -> create a new child
      VCLXAccessibleToolBoxItem* pChild = new VCLXAccessibleToolBoxItem( pToolBox, i );
      Reference< XAccessible> xParent = pChild;
      if ( pItemWindow )
      {
          xChild = new OToolBoxWindowItem(0,::comphelper::getProcessComponentContext(),pItemWindow->GetAccessible(),xParent);
          pItemWindow->SetAccessible(xChild);
          pChild->SetChild( xChild );
      }
      xChild = pChild;
      if ( nHighlightItemId > 0 && nItemId == nHighlightItemId )
          pChild->SetFocus( true );
      if ( pToolBox->IsItemChecked( nItemId ) )
          pChild->SetChecked( true );
      if ( pToolBox->GetItemState( nItemId ) == TRISTATE_INDET )
          pChild->SetIndeterminate( true );
      m_aAccessibleChildren.emplace( i, xChild );
  }
  else
  {
      // found it
      xChild = aIter->second;
  }
  return xChild;
728}

730Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleAtPoint( const awt::Point& _rPoint )
731{
  comphelper::OExternalLockGuard aGuard( this );

  Reference< XAccessible > xAccessible;
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( pToolBox )
  {
      ToolBox::ImplToolItems::size_type nItemPos = pToolBox->GetItemPos( VCLPoint( _rPoint ) );
      if ( nItemPos != ToolBox::ITEM_NOTFOUND )
          xAccessible = getAccessibleChild( nItemPos );
              //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
  }

  return xAccessible;
745}

747Reference< XAccessible > VCLXAccessibleToolBox::GetItemWindowAccessible( const VclWindowEvent& rVclWindowEvent )
748{
  Reference< XAccessible > xReturn;
  vcl::Window* pChildWindow = static_cast<vcl::Window *>(rVclWindowEvent.GetData());
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
2
←
Calling 'VCLXAccessibleComponent::GetAs'→
19
←
Returning; memory was released→
  if ( pChildWindow && pToolBox )
20
←
Assuming 'pChildWindow' is null→
  {
      ToolBox::ImplToolItems::size_type nCount = pToolBox->GetItemCount();
      for (ToolBox::ImplToolItems::size_type i = 0 ; i < nCount && !xReturn.is() ; ++i)
      {
          sal_uInt16 nItemId = pToolBox->GetItemId( i );
          vcl::Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
          if ( pItemWindow == pChildWindow )
              xReturn = getAccessibleChild(i);
                  //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
      }
  }
  return xReturn;
21
←
Calling implicit destructor for 'VclPtr<ToolBox>'→
22
←
Calling '~Reference'→
765}

767Reference< XAccessible > VCLXAccessibleToolBox::GetChildAccessible( const VclWindowEvent& rVclWindowEvent )
768{
  Reference< XAccessible > xReturn = GetItemWindowAccessible(rVclWindowEvent);
1
Calling 'VCLXAccessibleToolBox::GetItemWindowAccessible'→

  if ( !xReturn.is() )
      xReturn = VCLXAccessibleComponent::GetChildAccessible(rVclWindowEvent);
  return xReturn;
774}

776// XAccessibleSelection
777void VCLXAccessibleToolBox::selectAccessibleChild( sal_Int32 nChildIndex )
778{
  OExternalLockGuard aGuard( this );

  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( (!pToolBox) || nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= pToolBox->GetItemCount() )
      throw IndexOutOfBoundsException();

  pToolBox->ChangeHighlight( nChildIndex );
786}

788sal_Bool VCLXAccessibleToolBox::isAccessibleChildSelected( sal_Int32 nChildIndex )
789{
  OExternalLockGuard aGuard( this );
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if ( (!pToolBox) || nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= pToolBox->GetItemCount() )
      throw IndexOutOfBoundsException();

  if ( pToolBox->GetHighlightItemId() == pToolBox->GetItemId( nChildIndex ) )
      return true;
  else
      return false;
799}

801void VCLXAccessibleToolBox::clearAccessibleSelection(  )
802{
  OExternalLockGuard aGuard( this );
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  pToolBox -> LoseFocus();
806}

808void VCLXAccessibleToolBox::selectAllAccessibleChildren(  )
809{
  OExternalLockGuard aGuard( this );
  // intentionally empty. makes no sense for a toolbox
812}

814sal_Int32 VCLXAccessibleToolBox::getSelectedAccessibleChildCount(  )
815{
  OExternalLockGuard aGuard( this );

  sal_Int32 nRet = 0;
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if (pToolBox)
  {
      sal_uInt16 nHighlightItemId = pToolBox->GetHighlightItemId();
      for ( size_t i = 0, nCount = pToolBox->GetItemCount(); i < nCount; i++ )
      {
          if ( nHighlightItemId == pToolBox->GetItemId( i ) )
          {
              nRet = 1;
              break; // a toolbox can only have (n)one selected child
          }
      }
  }

  return nRet;
834}

836Reference< XAccessible > VCLXAccessibleToolBox::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
837{
  OExternalLockGuard aGuard( this );
  if ( nSelectedChildIndex != 0 )
      throw IndexOutOfBoundsException();

  Reference< XAccessible > xChild;
  VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
  if (pToolBox)
  {
      sal_uInt16 nHighlightItemId = pToolBox->GetHighlightItemId();
      for ( sal_Int32 i = 0, nCount = pToolBox->GetItemCount(); i < nCount; i++ )
      {
          if ( nHighlightItemId == pToolBox->GetItemId( i ) )
          {
              xChild = getAccessibleChild( i );
              break;
          }
      }
  }

  if (!xChild)
      throw IndexOutOfBoundsException();

  return xChild;
861}

863void VCLXAccessibleToolBox::deselectAccessibleChild( sal_Int32 nChildIndex )
864{
  OExternalLockGuard aGuard( this );
  if ( nChildIndex < 0 || nChildIndex >= implGetAccessibleChildCount() )
      throw IndexOutOfBoundsException();
  clearAccessibleSelection(); // a toolbox can only have (n)one selected child
869}

871/* 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() ) ); }
3
←
Calling constructor for 'VclPtr<ToolBox>'→
8
←
Returning from constructor for 'VclPtr<ToolBox>'→
9
←
Calling implicit destructor for 'VclPtr<vcl::Window>'→
10
←
Calling '~Reference'→
17
←
Returning from '~Reference'→
18
←
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)
4
←
Calling constructor for 'Reference<ToolBox>'→
7
←
Returning from constructor for 'Reference<ToolBox>'→
  {}

  /** 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)
5
←
Assuming field 'm_pBody' is non-null→
6
←
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_pBody10.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
)
11
←
Taking true branch→
23
←
Taking true branch→
          m_pBody->release();
12
←
Calling 'VclReferenceBase::release'→
16
←
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)
13
←
Assuming the condition is true→
14
←
Taking true branch→
40            delete this;
15
←
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