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

Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name editbrowsebox.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 SVT_DLLIMPLEMENTATION -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/svtools/source/inc -I /home/maarten/src/libreoffice/core/svtools/inc -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/svtools/source/brwbox/editbrowsebox.cxx

/home/maarten/src/libreoffice/core/svtools/source/brwbox/editbrowsebox.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 <svtools/editbrowsebox.hxx>

22#include <tools/debug.hxx>
23#include <vcl/image.hxx>
24#include <vcl/settings.hxx>
25#include <vcl/window.hxx>
26#include <vcl/svapp.hxx>

28#include <bitmaps.hlst>

30#include <algorithm>
31#include "editbrowseboximpl.hxx"
32#include <com/sun/star/accessibility/AccessibleEventId.hpp>


35namespace svt
36{

  namespace
  {

      GetFocusFlags getRealGetFocusFlags( vcl::Window* _pWindow )
      {
          GetFocusFlags nFlags = GetFocusFlags::NONE;
          while ( _pWindow && nFlags == GetFocusFlags::NONE )
          {
              nFlags = _pWindow->GetGetFocusFlags( );
              _pWindow = _pWindow->GetParent();
          }
          return nFlags;
      }
  }

  using namespace ::com::sun::star::uno;
  using namespace com::sun::star::accessibility::AccessibleEventId;


  IEditImplementation::~IEditImplementation()
  {
  }

  //= EditBrowserHeader

  void EditBrowserHeader::DoubleClick()
  {
      sal_uInt16 nColId = GetCurItemId();
      if (nColId)
      {
          sal_uInt32 nAutoWidth = static_cast<EditBrowseBox*>(GetParent())->GetAutoColumnWidth(nColId);
          if (nAutoWidth != static_cast<EditBrowseBox*>(GetParent())->GetColumnWidth(nColId))
          {
              static_cast<EditBrowseBox*>(GetParent())->SetColumnWidth(nColId, nAutoWidth);
              static_cast<EditBrowseBox*>(GetParent())->ColumnResized(nColId);
          }
      }
  }

  //= EditBrowseBox

  void EditBrowseBox::BrowserMouseEventPtr::Clear()
  {
      pEvent.reset();
  }

  void EditBrowseBox::BrowserMouseEventPtr::Set(const BrowserMouseEvent* pEvt, bool bIsDown)
  {
      if (pEvt == pEvent.get())
      {
          bDown = bIsDown;
          return;
      }
      pEvent.reset();
      if (pEvt)
      {
          pEvent.reset(new BrowserMouseEvent(pEvt->GetWindow(),
                                         *pEvt,
                                         pEvt->GetRow(),
                                         pEvt->GetColumn(),
                                         pEvt->GetColumnId(),
                                         pEvt->GetRect()));
          bDown = bIsDown;
      }
  }

  EditBrowseBox::EditBrowseBox( vcl::Window* pParent, EditBrowseBoxFlags nBrowserFlags, WinBits nBits, BrowserMode _nMode )
                :BrowseBox( pParent, nBits, _nMode )
                ,nStartEvent(nullptr)
                ,nEndEvent(nullptr)
                ,nCellModifiedEvent(nullptr)
                ,m_pFocusWhileRequest(nullptr)
                ,nPaintRow(-1)
                ,nEditRow(-1)
                ,nEditCol(0)
                ,bHasFocus(false)
                ,bPaintStatus(true)
                ,bActiveBeforeTracking( false )
                ,m_nBrowserFlags(nBrowserFlags)
                ,pHeader(nullptr)
  {
      m_aImpl.reset(new EditBrowseBoxImpl);

      SetCompoundControl(true);

      ImplInitSettings(true, true, true);

      pCheckBoxPaint = VclPtr<CheckBoxControl>::Create(&GetDataWindow());
      pCheckBoxPaint->SetPaintTransparent( true );
      pCheckBoxPaint->SetBackground();
  }

  void EditBrowseBox::Init()
  {
      // late construction
  }

  EditBrowseBox::~EditBrowseBox()
  {
      disposeOnce();
  }

  void EditBrowseBox::dispose()
  {
      if (nStartEvent)
1
Assuming field 'nStartEvent' is null→
2
←
Taking false branch→
          Application::RemoveUserEvent(nStartEvent);
      if (nEndEvent)
3
←
Assuming field 'nEndEvent' is null→
4
←
Taking false branch→
          Application::RemoveUserEvent(nEndEvent);
      if (nCellModifiedEvent)
5
←
Assuming field 'nCellModifiedEvent' is null→
6
←
Taking false branch→
          Application::RemoveUserEvent(nCellModifiedEvent);

      pCheckBoxPaint.disposeAndClear();
7
←
Calling 'VclPtr::disposeAndClear'→
      m_pFocusWhileRequest.clear();
      pHeader.clear();
      BrowseBox::dispose();
  }


  void EditBrowseBox::RemoveRows()
  {
      BrowseBox::Clear();
      nEditRow = nPaintRow = -1;
      nEditCol = 0;
  }


  VclPtr<BrowserHeader> EditBrowseBox::CreateHeaderBar(BrowseBox* pParent)
  {
      pHeader = imp_CreateHeaderBar(pParent);
      if (!IsUpdateMode())
          pHeader->SetUpdateMode(false);
      return pHeader;
  }


  VclPtr<BrowserHeader> EditBrowseBox::imp_CreateHeaderBar(BrowseBox* pParent)
  {
      return VclPtr<EditBrowserHeader>::Create(pParent);
  }


  void EditBrowseBox::LoseFocus()
  {
      BrowseBox::LoseFocus();
      DetermineFocus();
  }


  void EditBrowseBox::GetFocus()
  {
      BrowseBox::GetFocus();

      // This should handle the case that the BrowseBox (or one of its children)
      // gets the focus from outside by pressing Tab
      if (IsEditing() && Controller()->GetWindow().IsVisible())
          Controller()->GetWindow().GrabFocus();

      DetermineFocus( getRealGetFocusFlags( this ) );
  }


  bool EditBrowseBox::SeekRow(long nRow)
  {
      nPaintRow = nRow;
      return true;
  }


  IMPL_LINK_NOARG(EditBrowseBox, StartEditHdl, void*, void)void EditBrowseBox::LinkStubStartEditHdl(void * instance, void
* data) { return static_cast<EditBrowseBox *>(instance)
->StartEditHdl(data); } void EditBrowseBox::StartEditHdl(__attribute__
 ((unused)) void*)
  {
      nStartEvent = nullptr;
      if (IsEditing())
      {
          EnableAndShow();
          if (!ControlHasFocus() && (m_pFocusWhileRequest.get() == Application::GetFocusWindow()))
              aController->GetWindow().GrabFocus();
      }
  }

  void EditBrowseBox::PaintField( vcl::RenderContext& rDev, const tools::Rectangle& rRect,
                                  sal_uInt16 nColumnId ) const
  {
      if (nColumnId == HandleColumnId)
      {
           if (bPaintStatus)
              PaintStatusCell(rDev, rRect);
      }
      else
      {
          // don't paint the current cell
          if (&rDev == &GetDataWindow())
              // but only if we're painting onto our data win (which is the usual painting)
              if (nPaintRow == nEditRow)
              {
                  if (IsEditing() && nEditCol == nColumnId && aController->GetWindow().IsVisible())
                      return;
              }
          PaintCell(rDev, rRect, nColumnId);
      }
  }

  Image EditBrowseBox::GetImage(RowStatus eStatus) const
  {
      BitmapEx aBitmap;
      bool bNeedMirror = IsRTLEnabled();
      switch (eStatus)
      {
          case CURRENT:
              aBitmap = BitmapEx(BMP_CURRENT"svtools/res/ed01.png");
              break;
          case CURRENTNEW:
              aBitmap = BitmapEx(BMP_CURRENTNEW"svtools/res/ed05.png");
              break;
          case MODIFIED:
              aBitmap = BitmapEx(BMP_MODIFIED"svtools/res/ed02.png");
              bNeedMirror = false;    // the pen is not mirrored
              break;
          case NEW:
              aBitmap = BitmapEx(BMP_NEW"svtools/res/ed03.png");
              break;
          case DELETED:
              aBitmap = BitmapEx(BMP_DELETED"svtools/res/ed04.png");
              break;
          case PRIMARYKEY:
              aBitmap = BitmapEx(BMP_PRIMARYKEY"svtools/res/ed06.png");
              break;
          case CURRENT_PRIMARYKEY:
              aBitmap = BitmapEx(BMP_CURRENT_PRIMARYKEY"svtools/res/ed07.png");
              break;
          case FILTER:
              aBitmap = BitmapEx(BMP_FILTER"svtools/res/ed08.png");
              break;
          case HEADERFOOTER:
              aBitmap = BitmapEx(BMP_HEADERFOOTER"svtools/res/ed09.png");
              break;
          case CLEAN:
              break;
      }
      if ( bNeedMirror )
      {
          aBitmap.Mirror( BmpMirrorFlags::Horizontal );
      }
      return Image(aBitmap);
  }

  void EditBrowseBox::PaintStatusCell(OutputDevice& rDev, const tools::Rectangle& rRect) const
  {
      if (nPaintRow < 0)
          return;

      RowStatus eStatus = GetRowStatus( nPaintRow );
      EditBrowseBoxFlags nBrowserFlags = GetBrowserFlags();

      if (nBrowserFlags & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT)
          return;

      // draw the text of the header column
      if (nBrowserFlags & EditBrowseBoxFlags::HANDLE_COLUMN_TEXT )
      {
          rDev.DrawText( rRect, GetCellText( nPaintRow, 0 ),
                         DrawTextFlags::Center | DrawTextFlags::VCenter | DrawTextFlags::Clip );
      }
      // draw an image
      else if (eStatus != CLEAN && rDev.GetOutDevType() == OUTDEV_WINDOW)
      {
          Image aImage(GetImage(eStatus));
          // calc the image position
          Size aImageSize(aImage.GetSizePixel());
          aImageSize.setWidth( CalcZoom(aImageSize.Width()) );
          aImageSize.setHeight( CalcZoom(aImageSize.Height()) );
          Point aPos( rRect.TopLeft() );

          if ( ( aImageSize.Width() > rRect.GetWidth() ) || ( aImageSize.Height() > rRect.GetHeight() ) )
              rDev.SetClipRegion(vcl::Region(rRect));

          if ( aImageSize.Width() < rRect.GetWidth() )
              aPos.AdjustX(( rRect.GetWidth() - aImageSize.Width() ) / 2 );

          if ( aImageSize.Height() < rRect.GetHeight() )
              aPos.AdjustY(( rRect.GetHeight() - aImageSize.Height() ) / 2 );

          if ( IsZoom() )
              rDev.DrawImage( aPos, aImageSize, aImage );
          else
              rDev.DrawImage( aPos, aImage );

          if (rDev.IsClipRegion())
              rDev.SetClipRegion();
      }
  }


  void EditBrowseBox::ImplStartTracking()
  {
      bActiveBeforeTracking = IsEditing();
      if ( bActiveBeforeTracking )
      {
          DeactivateCell();
          PaintImmediately();
      }

      BrowseBox::ImplStartTracking();
  }


  void EditBrowseBox::ImplEndTracking()
  {
      if ( bActiveBeforeTracking )
          ActivateCell();
      bActiveBeforeTracking = false;

      BrowseBox::ImplEndTracking();
  }


  void EditBrowseBox::RowHeightChanged()
  {
      if ( IsEditing() )
      {
          tools::Rectangle aRect( GetCellRect( nEditRow, nEditCol, false ) );
          CellControllerRef aCellController( Controller() );
          ResizeController( aCellController, aRect );
          aCellController->GetWindow().GrabFocus();
      }

      BrowseBox::RowHeightChanged();
  }


  EditBrowseBox::RowStatus EditBrowseBox::GetRowStatus(long) const
  {
      return CLEAN;
  }


  void EditBrowseBox::KeyInput( const KeyEvent& rEvt )
  {
      sal_uInt16 nCode = rEvt.GetKeyCode().GetCode();
      bool   bShift = rEvt.GetKeyCode().IsShift();
      bool   bCtrl = rEvt.GetKeyCode().IsMod1();

      switch (nCode)
      {
          case KEY_RETURN:
              if (!bCtrl && !bShift && IsTabAllowed(true))
              {
                  Dispatch(BROWSER_CURSORRIGHT734);
              }
              else
                  BrowseBox::KeyInput(rEvt);
              return;
          case KEY_TAB:
              if (!bCtrl && !bShift)
              {
                  if (IsTabAllowed(true))
                      Dispatch(BROWSER_CURSORRIGHT734);
                  else
                      // do NOT call BrowseBox::KeyInput : this would handle the tab, but we already now
                      // that tab isn't allowed here. So give the Control class a chance
                      Control::KeyInput(rEvt);
                  return;
              }
              else if (!bCtrl && bShift)
              {
                  if (IsTabAllowed(false))
                      Dispatch(BROWSER_CURSORLEFT733);
                  else
                      // do NOT call BrowseBox::KeyInput : this would handle the tab, but we already now
                      // that tab isn't allowed here. So give the Control class a chance
                      Control::KeyInput(rEvt);
                  return;
              }
              [[fallthrough]];
          default:
              BrowseBox::KeyInput(rEvt);
      }
  }


  void EditBrowseBox::MouseButtonDown(const BrowserMouseEvent& rEvt)
  {
      // absorb double clicks
      if (rEvt.GetClicks() > 1 && rEvt.GetRow() >= 0)
          return;

      // we are about to leave the current cell. If there is a "this cell has been modified" notification
      // pending (asynchronously), this may be deadly -> do it synchronously
      if ( nCellModifiedEvent )
      {
          Application::RemoveUserEvent( nCellModifiedEvent );
          nCellModifiedEvent = nullptr;
          LINK( this, EditBrowseBox, CellModifiedHdl )::tools::detail::makeLink( ::tools::detail::castTo<EditBrowseBox
 *>(this), &EditBrowseBox::LinkStubCellModifiedHdl).Call( nullptr );
      }

      if (rEvt.GetColumnId() == HandleColumnId)
      {   // it was the handle column. save the current cell content if necessary
          // (clicking on the handle column results in selecting the current row)
          if (IsEditing() && aController->IsValueChangedFromSaved())
              SaveModified();
      }

      aMouseEvent.Set(&rEvt,true);
      BrowseBox::MouseButtonDown(rEvt);
      aMouseEvent.Clear();

      if (m_nBrowserFlags & EditBrowseBoxFlags::ACTIVATE_ON_BUTTONDOWN)
      {
          // the base class does not travel upon MouseButtonDown, but implActivateCellOnMouseEvent assumes we traveled ...
          GoToRowColumnId( rEvt.GetRow(), rEvt.GetColumnId() );
          if (rEvt.GetRow() >= 0)
              implActivateCellOnMouseEvent(rEvt, false);
      }
  }

  void EditBrowseBox::MouseButtonUp( const BrowserMouseEvent& rEvt )
  {
      // absorb double clicks
      if (rEvt.GetClicks() > 1 && rEvt.GetRow() >= 0)
          return;

      aMouseEvent.Set(&rEvt,false);
      BrowseBox::MouseButtonUp(rEvt);
      aMouseEvent.Clear();

      if (!(m_nBrowserFlags & EditBrowseBoxFlags::ACTIVATE_ON_BUTTONDOWN))
          if (rEvt.GetRow() >= 0)
              implActivateCellOnMouseEvent(rEvt, true);
  }

  bool EditBrowseBox::ControlHasFocus() const
  {
      Window* pControlWindow = aController ? &aController->GetWindow() : nullptr;
      if (ControlBase* pControlBase = dynamic_cast<ControlBase*>(pControlWindow))
          return pControlBase->ControlHasFocus();
      return pControlWindow && pControlWindow->HasChildPathFocus();
  }

  void EditBrowseBox::implActivateCellOnMouseEvent(const BrowserMouseEvent& _rEvt, bool _bUp)
  {
      if (!IsEditing())
          ActivateCell();
      else if (IsEditing() && !aController->GetWindow().IsEnabled())
          DeactivateCell();
      else if (IsEditing() && !ControlHasFocus())
          AsynchGetFocus();

      if (!IsEditing() || !aController->GetWindow().IsEnabled())
          return;

      // forwards the event to the control
      aController->ActivatingMouseEvent(_rEvt, _bUp);
  }

  void EditBrowseBox::Dispatch( sal_uInt16 _nId )
  {
      if ( _nId == BROWSER_ENHANCESELECTION722 )
      {   // this is a workaround for the bug in the base class:
          // if the row selection is to be extended (which is what BROWSER_ENHANCESELECTION tells us)
          // then the base class does not revert any column selections, while, for doing a "simple"
          // selection (BROWSER_SELECT), it does. In fact, it does not only revert the col selection then,
          // but also any current row selections.
          // This clearly tells me that the both ids are for row selection only - there this behaviour does
          // make sense.
          // But here, where we have column selection, too, we take care of this ourself.
          if ( GetSelectColumnCount( ) )
          {
              while ( GetSelectColumnCount( ) )
                  SelectColumnPos(
                      sal::static_int_cast< sal_uInt16 >(FirstSelectedColumn()),
                      false );
              Select();
          }
      }
      BrowseBox::Dispatch( _nId );
  }

  bool EditBrowseBox::ProcessKey(const KeyEvent& rKeyEvent)
  {
      sal_uInt16 nCode  = rKeyEvent.GetKeyCode().GetCode();
      bool       bShift = rKeyEvent.GetKeyCode().IsShift();
      bool       bCtrl  = rKeyEvent.GetKeyCode().IsMod1();
      bool       bAlt =   rKeyEvent.GetKeyCode().IsMod2();
      bool       bLocalSelect = false;
      bool       bNonEditOnly = false;
      sal_uInt16 nId = BROWSER_NONE0;

      if (!bAlt && !bCtrl && !bShift )
          switch ( nCode )
          {
              case KEY_DOWN:          nId = BROWSER_CURSORDOWN731; break;
              case KEY_UP:            nId = BROWSER_CURSORUP732; break;
              case KEY_PAGEDOWN:      nId = BROWSER_CURSORPAGEDOWN735; break;
              case KEY_PAGEUP:        nId = BROWSER_CURSORPAGEUP736; break;
              case KEY_HOME:          nId = BROWSER_CURSORHOME745; break;
              case KEY_END:           nId = BROWSER_CURSOREND746; break;

              case KEY_TAB:
                  // ask if traveling to the next cell is allowed
                  if (IsTabAllowed(true))
                      nId = BROWSER_CURSORRIGHT734;
                  break;

              case KEY_RETURN:
                  // save the cell content (if necessary)
                  if (IsEditing() && aController->IsValueChangedFromSaved() && !SaveModified())
                  {
                      // maybe we're not visible ...
                      EnableAndShow();
                      aController->GetWindow().GrabFocus();
                      return true;
                  }
                  // ask if traveling to the next cell is allowed
                  if (IsTabAllowed(true))
                      nId = BROWSER_CURSORRIGHT734;

                  break;
              case KEY_RIGHT:         nId = BROWSER_CURSORRIGHT734; break;
              case KEY_LEFT:          nId = BROWSER_CURSORLEFT733; break;
              case KEY_SPACE:         nId = BROWSER_SELECT720; bNonEditOnly = bLocalSelect = true; break;
          }

      if ( !bAlt && !bCtrl && bShift )
          switch ( nCode )
          {
              case KEY_DOWN:          nId = BROWSER_SELECTDOWN724; bLocalSelect = true; break;
              case KEY_UP:            nId = BROWSER_SELECTUP725; bLocalSelect = true; break;
              case KEY_HOME:          nId = BROWSER_SELECTHOME753; bLocalSelect = true; break;
              case KEY_END:           nId = BROWSER_SELECTEND754; bLocalSelect = true; break;
              case KEY_TAB:
                  if (IsTabAllowed(false))
                      nId = BROWSER_CURSORLEFT733;
                  break;
          }

      if ( !bAlt && bCtrl && bShift )
          switch ( nCode )
          {
              case KEY_SPACE:         nId = BROWSER_SELECTCOLUMN755; bLocalSelect = true; break;
          }


      if ( !bAlt && bCtrl && !bShift )
          switch ( nCode )
          {
              case KEY_DOWN:          nId = BROWSER_SCROLLUP752; break;
              case KEY_UP:            nId = BROWSER_SCROLLDOWN751; break;
              case KEY_PAGEDOWN:      nId = BROWSER_CURSORENDOFFILE741; break;
              case KEY_PAGEUP:        nId = BROWSER_CURSORTOPOFFILE742; break;
              case KEY_HOME:          nId = BROWSER_CURSORTOPOFSCREEN744; break;
              case KEY_END:           nId = BROWSER_CURSORENDOFSCREEN743; break;
              case KEY_SPACE:         nId = BROWSER_ENHANCESELECTION722; bLocalSelect = true; break;
          }


      if  (   ( nId != BROWSER_NONE0 )
          &&  (   !IsEditing()
              ||  (   !bNonEditOnly
                  &&  aController->MoveAllowed(rKeyEvent)
                  )
              )
          )
      {
          if (nId == BROWSER_SELECT720 || BROWSER_SELECTCOLUMN755 == nId )
          {
              // save the cell content (if necessary)
              if (IsEditing() && aController->IsValueChangedFromSaved() && !SaveModified())
              {
                  // maybe we're not visible ...
                  EnableAndShow();
                  aController->GetWindow().GrabFocus();
                  return true;
              }
          }

          Dispatch(nId);

          if (bLocalSelect && (GetSelectRowCount() || GetSelection() != nullptr))
              DeactivateCell();
          return true;
      }
      return false;
  }

  bool EditBrowseBox::PreNotify(NotifyEvent& rEvt)
  {
      if (rEvt.GetType() == MouseNotifyEvent::KEYINPUT)
      {
          if  (   (IsEditing() && ControlHasFocus())
              ||  rEvt.GetWindow() == &GetDataWindow()
              ||  (!IsEditing() && HasChildPathFocus())
              )
          {
              if (ProcessKey(*rEvt.GetKeyEvent()))
                  return true;
          }
      }
      return BrowseBox::PreNotify(rEvt);
  }

  bool EditBrowseBox::IsTabAllowed(bool) const
  {
      return true;
  }


  bool EditBrowseBox::EventNotify(NotifyEvent& rEvt)
  {
      switch (rEvt.GetType())
      {
          case MouseNotifyEvent::GETFOCUS:
              DetermineFocus( getRealGetFocusFlags( this ) );
              break;

          case MouseNotifyEvent::LOSEFOCUS:
              DetermineFocus();
              break;

          default:
              break;
      }
      return BrowseBox::EventNotify(rEvt);
  }


  void EditBrowseBox::StateChanged( StateChangedType nType )
  {
      BrowseBox::StateChanged( nType );

      bool bNeedCellReActivation = false;
      if ( nType == StateChangedType::Mirroring )
      {
          bNeedCellReActivation = true;
      }
      else if ( nType == StateChangedType::Zoom )
      {
          ImplInitSettings( true, false, false );
          bNeedCellReActivation = true;
      }
      else if ( nType == StateChangedType::ControlFont )
      {
          ImplInitSettings( true, false, false );
          Invalidate();
      }
      else if ( nType == StateChangedType::ControlForeground )
      {
          ImplInitSettings( false, true, false );
          Invalidate();
      }
      else if ( nType == StateChangedType::ControlBackground )
      {
          ImplInitSettings( false, false, true );
          Invalidate();
      }
      else if (nType == StateChangedType::Style)
      {
          WinBits nStyle = GetStyle();
          if (!(nStyle & WB_NOTABSTOP) )
              nStyle |= WB_TABSTOP;

          SetStyle(nStyle);
      }
      if ( bNeedCellReActivation )
      {
          if ( IsEditing() )
          {
              DeactivateCell();
              ActivateCell();
          }
      }
  }


  void EditBrowseBox::DataChanged( const DataChangedEvent& rDCEvt )
  {
      BrowseBox::DataChanged( rDCEvt );

      if ((( rDCEvt.GetType() == DataChangedEventType::SETTINGS )   ||
          ( rDCEvt.GetType() == DataChangedEventType::DISPLAY   ))  &&
          ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE        ))
      {
          ImplInitSettings( true, true, true );
          Invalidate();
      }
  }

  void EditBrowseBox::ImplInitSettings( bool bFont, bool bForeground, bool bBackground )
  {
      const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

      if (bFont)
      {
          vcl::Font aFont = rStyleSettings.GetFieldFont();
          if (IsControlFont())
          {
              GetDataWindow().SetControlFont(GetControlFont());
              aFont.Merge(GetControlFont());
          }
          else
              GetDataWindow().SetControlFont();

          GetDataWindow().SetZoomedPointFont(GetDataWindow(), aFont);
      }

      if (bFont || bForeground)
      {
          Color aTextColor = rStyleSettings.GetFieldTextColor();
          if (IsControlForeground())
          {
              aTextColor = GetControlForeground();
              GetDataWindow().SetControlForeground(aTextColor);
          }
          else
              GetDataWindow().SetControlForeground();

          GetDataWindow().SetTextColor( aTextColor );
      }

      if (!bBackground) // FIXME: Outside of Paint Hierarchy
          return;

      if (GetDataWindow().IsControlBackground())
      {
          GetDataWindow().SetControlBackground(GetControlBackground());
          GetDataWindow().SetBackground(GetDataWindow().GetControlBackground());
          GetDataWindow().SetFillColor(GetDataWindow().GetControlBackground());
      }
      else
      {
          GetDataWindow().SetControlBackground();
          GetDataWindow().SetBackground(rStyleSettings.GetFieldColor());
          GetDataWindow().SetFillColor(rStyleSettings.GetFieldColor());
      }
  }


  bool EditBrowseBox::IsCursorMoveAllowed(long nNewRow, sal_uInt16 nNewColId) const
  {
      sal_uInt16 nInfo = 0;

      if (GetSelectColumnCount() || (aMouseEvent.Is() && aMouseEvent->GetRow() < 0))
          nInfo |= COLSELECT;
      if ((GetSelection() != nullptr && GetSelectRowCount()) ||
          (aMouseEvent.Is() && aMouseEvent->GetColumnId() == HandleColumnId))
          nInfo |= ROWSELECT;
      if (!nInfo && nNewRow != nEditRow)
          nInfo |= ROWCHANGE;
      if (!nInfo && nNewColId != nEditCol)
          nInfo |= COLCHANGE;

      if (nInfo == 0)   // nothing happened
          return true;

      // save the cell content
      if (IsEditing() && aController->IsValueChangedFromSaved() && !const_cast<EditBrowseBox *>(this)->SaveModified())
      {
          // maybe we're not visible ...
          EnableAndShow();
          aController->GetWindow().GrabFocus();
          return false;
      }

      EditBrowseBox * pTHIS = const_cast<EditBrowseBox *> (this);

      // save the cell content if
      // a) a selection is being made
      // b) the row is changing
      if (IsModified() && (nInfo & (ROWCHANGE | COLSELECT | ROWSELECT)) &&
          !pTHIS->SaveRow())
      {
          if (nInfo & COLSELECT ||
              nInfo & ROWSELECT)
          {
              // cancel selected
              pTHIS->SetNoSelection();
          }

          if (IsEditing())
          {
              if (!Controller()->GetWindow().IsVisible())
              {
                  EnableAndShow();
              }
              aController->GetWindow().GrabFocus();
          }
          return false;
      }

      if (nNewRow != nEditRow)
      {
          vcl::Window& rWindow = GetDataWindow();
          if ((nEditRow >= 0) && !(GetBrowserFlags() & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT))
          {
              tools::Rectangle aRect = GetFieldRectPixel(nEditRow, 0, false );
              // status cell should be painted if and only if text is displayed
              pTHIS->bPaintStatus = ( GetBrowserFlags() & EditBrowseBoxFlags::HANDLE_COLUMN_TEXT ) == EditBrowseBoxFlags::HANDLE_COLUMN_TEXT;
              rWindow.Invalidate(aRect);
              pTHIS->bPaintStatus = true;
          }

          // don't paint during row change
          rWindow.EnablePaint(false);

          // the last veto chance for derived classes
          if (!pTHIS->CursorMoving(nNewRow, nNewColId))
          {
              pTHIS->InvalidateStatusCell(nEditRow);
              rWindow.EnablePaint(true);
              return false;
          }
          else
          {
              rWindow.EnablePaint(true);
              return true;
          }
      }
      else
          return pTHIS->CursorMoving(nNewRow, nNewColId);
  }


  void EditBrowseBox::ColumnMoved(sal_uInt16 nId)
  {
      BrowseBox::ColumnMoved(nId);
      if (IsEditing())
      {
          tools::Rectangle aRect( GetCellRect(nEditRow, nEditCol, false));
          CellControllerRef aControllerRef = Controller();
          ResizeController(aControllerRef, aRect);
          Controller()->GetWindow().GrabFocus();
      }
  }


  bool EditBrowseBox::SaveRow()
  {
      return true;
  }


  bool EditBrowseBox::CursorMoving(long, sal_uInt16)
  {
      DeactivateCell(false);
      return true;
  }


  void EditBrowseBox::CursorMoved()
  {
      long nNewRow = GetCurRow();
      if (nEditRow != nNewRow)
      {
          if (!(GetBrowserFlags() & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT))
              InvalidateStatusCell(nNewRow);
          nEditRow = nNewRow;
      }
      ActivateCell();
      GetDataWindow().EnablePaint(true);
      // should not be called here because the descant event is not needed here
      //BrowseBox::CursorMoved();
  }


  void EditBrowseBox::EndScroll()
  {
      if (IsEditing())
      {
          tools::Rectangle aRect = GetCellRect(nEditRow, nEditCol, false);
          ResizeController(aController,aRect);
          AsynchGetFocus();
      }
      BrowseBox::EndScroll();
  }


  void EditBrowseBox::ActivateCell(long nRow, sal_uInt16 nCol, bool bCellFocus)
  {
      if (IsEditing())
          return;

      nEditCol = nCol;

      if ((GetSelectRowCount() && GetSelection() != nullptr) || GetSelectColumnCount() ||
          (aMouseEvent.Is() && (aMouseEvent.IsDown() || aMouseEvent->GetClicks() > 1))) // nothing happens on MouseDown
      {
          return;
      }

      if (nEditRow < 0 || nEditCol <= HandleColumnId)
          return;

      aController = GetController(nRow, nCol);
      if (aController.is())
      {
          tools::Rectangle aRect( GetCellRect(nEditRow, nEditCol, false));
          ResizeController(aController, aRect);

          InitController(aController, nEditRow, nEditCol);

          aController->SaveValue();
          aController->SetModifyHdl(LINK(this,EditBrowseBox,ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<EditBrowseBox
 *>(this), &EditBrowseBox::LinkStubModifyHdl));
          EnableAndShow();

          if ( isAccessibleAlive() )
              implCreateActiveAccessible();

          // activate the cell only of the browser has the focus
          if ( bHasFocus && bCellFocus )
              AsynchGetFocus();
      }
      else
      {
          // no controller -> we have a new "active descendant"
          if ( isAccessibleAlive() && HasFocus() )
          {
              commitTableEvent(
                  ACTIVE_DESCENDANT_CHANGED,
                  makeAny( CreateAccessibleCell( nRow, GetColumnPos( nCol -1) ) ),
                  Any()
              );
          }
      }
  }


  void EditBrowseBox::DeactivateCell(bool bUpdate)
  {
      if (!IsEditing())
          return;

      if ( isAccessibleAlive() )
      {
          commitBrowseBoxEvent( CHILD, Any(), makeAny( m_aImpl->m_xActiveCell ) );
          m_aImpl->clearActiveCell();
      }

      aOldController = aController;
      aController.clear();

      // reset the modify handler
      aOldController->SetModifyHdl(Link<LinkParamNone*,void>());

      if (bHasFocus)
          GrabFocus(); // ensure that we have (and keep) the focus

      aOldController->suspend();

      // update if requested
      if (bUpdate)
          PaintImmediately();

      // release the controller (asynchronously)
      if (nEndEvent)
          Application::RemoveUserEvent(nEndEvent);
      nEndEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,EndEditHdl)::tools::detail::makeLink( ::tools::detail::castTo<EditBrowseBox
 *>(this), &EditBrowseBox::LinkStubEndEditHdl), nullptr, true);
  }


  tools::Rectangle EditBrowseBox::GetCellRect(long nRow, sal_uInt16 nColId, bool bRel) const
  {
      tools::Rectangle aRect( GetFieldRectPixel(nRow, nColId, bRel));
      if ((GetMode()  & BrowserMode::CURSOR_WO_FOCUS) == BrowserMode::CURSOR_WO_FOCUS)
      {
          aRect.AdjustTop(1 );
          aRect.AdjustBottom( -1 );
      }
      return aRect;
  }


  IMPL_LINK_NOARG(EditBrowseBox, EndEditHdl, void*, void)void EditBrowseBox::LinkStubEndEditHdl(void * instance, void*
 data) { return static_cast<EditBrowseBox *>(instance)->
EndEditHdl(data); } void EditBrowseBox::EndEditHdl(__attribute__
 ((unused)) void*)
  {
      nEndEvent = nullptr;

      aOldController  = CellControllerRef();
  }


  IMPL_LINK_NOARG(EditBrowseBox, ModifyHdl, LinkParamNone*, void)void EditBrowseBox::LinkStubModifyHdl(void * instance, LinkParamNone
* data) { return static_cast<EditBrowseBox *>(instance)
->ModifyHdl(data); } void EditBrowseBox::ModifyHdl(__attribute__
 ((unused)) LinkParamNone*)
  {
      if (nCellModifiedEvent)
          Application::RemoveUserEvent(nCellModifiedEvent);
      nCellModifiedEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,CellModifiedHdl)::tools::detail::makeLink( ::tools::detail::castTo<EditBrowseBox
 *>(this), &EditBrowseBox::LinkStubCellModifiedHdl), nullptr, true);
  }


  IMPL_LINK_NOARG(EditBrowseBox, CellModifiedHdl, void*, void)void EditBrowseBox::LinkStubCellModifiedHdl(void * instance, void
* data) { return static_cast<EditBrowseBox *>(instance)
->CellModifiedHdl(data); } void EditBrowseBox::CellModifiedHdl
(__attribute__ ((unused)) void*)
  {
      nCellModifiedEvent = nullptr;
      CellModified();
  }

  void EditBrowseBox::ColumnResized( sal_uInt16 )
  {
      if (IsEditing())
      {
          tools::Rectangle aRect( GetCellRect(nEditRow, nEditCol, false));
          CellControllerRef aControllerRef = Controller();
          ResizeController(aControllerRef, aRect);
          // don't grab focus if Field Properties panel is being
          // resized by split pane drag resizing
          if (Application::IsUICaptured())
              return;
          Controller()->GetWindow().GrabFocus();
      }
  }

  sal_uInt16 EditBrowseBox::AppendColumn(const OUString& rName, sal_uInt16 nWidth, sal_uInt16 nPos, sal_uInt16 nId)
  {
      if (nId == BROWSER_INVALIDID((sal_uInt16) 0xFFFF))
      {
          // look for the next free id
          for (nId = ColCount(); nId > 0 && GetColumnPos(nId) != BROWSER_INVALIDID((sal_uInt16) 0xFFFF); nId--)
              ;

          if (!nId)
          {
              // if there is no handle column
              // increment the id
              if ( ColCount() == 0 || GetColumnId(0) != HandleColumnId )
                  nId = ColCount() + 1;
          }
      }

      DBG_ASSERT(nId, "EditBrowseBox::AppendColumn: invalid id!")do { if (true && (!(nId))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/brwbox/editbrowsebox.cxx"
 ":" "1061" ": "), "%s", "EditBrowseBox::AppendColumn: invalid id!"
); } } while (false);

      long w = nWidth;
      if (!w)
          w = GetDefaultColumnWidth(rName);

      InsertDataColumn(nId, rName, w, (HeaderBarItemBits::CENTER | HeaderBarItemBits::CLICKABLE), nPos);
      return nId;
  }

  void EditBrowseBox::Resize()
  {
      BrowseBox::Resize();

      // if the window is smaller than "title line height" + "control area",
      // do nothing
      if (GetOutputSizePixel().Height() <
         (GetControlArea().GetHeight() + GetDataWindow().GetPosPixel().Y()))
          return;

      // the size of the control area
      Point aPoint(GetControlArea().TopLeft());
      sal_uInt16 nX = static_cast<sal_uInt16>(aPoint.X());

      ArrangeControls(nX, static_cast<sal_uInt16>(aPoint.Y()));

      if (!nX)
          nX = USHRT_MAX(32767 *2 +1);

      bool bChanged = ReserveControlArea(nX);

      //tdf#97731 if the reserved area changed size, give the controls a
      //chance to adapt to the new size
      if (bChanged)
      {
          nX = static_cast<sal_uInt16>(aPoint.X());
          ArrangeControls(nX, static_cast<sal_uInt16>(aPoint.Y()));
      }
  }

  void EditBrowseBox::ArrangeControls(sal_uInt16&, sal_uInt16)
  {
  }

  CellController* EditBrowseBox::GetController(long, sal_uInt16)
  {
      return nullptr;
  }

  void EditBrowseBox::ResizeController(CellControllerRef const & rController, const tools::Rectangle& rRect)
  {
      Point aPoint(rRect.TopLeft());
      Size aSize(rRect.GetSize());
      Control& rControl = rController->GetWindow();
      auto nMinHeight = rControl.get_preferred_size().Height();
      if (nMinHeight > aSize.Height())
      {
          auto nOffset = (nMinHeight - aSize.Height()) / 2;
          aPoint.AdjustY(-nOffset);
          aSize.setHeight(nMinHeight);
      }
      rControl.SetPosSizePixel(aPoint, aSize);
  }

  void EditBrowseBox::InitController(CellControllerRef&, long, sal_uInt16)
  {
  }


  void EditBrowseBox::CellModified()
  {
  }


  bool EditBrowseBox::SaveModified()
  {
      return true;
  }


  void EditBrowseBox::DoubleClick(const BrowserMouseEvent& rEvt)
  {
      // when double clicking on the column, the optimum size will be calculated
      sal_uInt16 nColId = rEvt.GetColumnId();
      if (nColId != HandleColumnId)
          SetColumnWidth(nColId, GetAutoColumnWidth(nColId));
  }


  sal_uInt32 EditBrowseBox::GetAutoColumnWidth(sal_uInt16 nColId)
  {
      sal_uInt32 nCurColWidth  = GetColumnWidth(nColId);
      sal_uInt32 nMinColWidth = CalcZoom(20); // minimum
      sal_uInt32 nNewColWidth = nMinColWidth;
      long nMaxRows      = std::min(long(GetVisibleRows()), GetRowCount());
      long nLastVisRow   = GetTopRow() + nMaxRows - 1;

      if (GetTopRow() <= nLastVisRow) // calc the column with using the cell contents
      {
          for (long i = GetTopRow(); i <= nLastVisRow; ++i)
              nNewColWidth = std::max(nNewColWidth,GetTotalCellWidth(i,nColId) + 12);

          if (nNewColWidth == nCurColWidth)   // size has not changed
              nNewColWidth = GetDefaultColumnWidth(GetColumnTitle(nColId));
      }
      else
          nNewColWidth = GetDefaultColumnWidth(GetColumnTitle(nColId));
      return nNewColWidth;
  }

  sal_uInt32 EditBrowseBox::GetTotalCellWidth(long, sal_uInt16)
  {
      return 0;
  }

  void EditBrowseBox::InvalidateHandleColumn()
  {
      tools::Rectangle aHdlFieldRect( GetFieldRectPixel( 0, 0 ));
      tools::Rectangle aInvalidRect( Point(0,0), GetOutputSizePixel() );
      aInvalidRect.SetRight( aHdlFieldRect.Right() );
      Invalidate( aInvalidRect );
  }

  void EditBrowseBox::PaintTristate(const tools::Rectangle& rRect, const TriState& eState, bool _bEnabled) const
  {
      pCheckBoxPaint->SetState(eState);

      pCheckBoxPaint->GetBox().set_sensitive(_bEnabled);

      Size aBoxSize = pCheckBoxPaint->GetBox().get_preferred_size();
      tools::Rectangle aRect(Point(rRect.Left() + ((rRect.GetWidth() - aBoxSize.Width()) / 2),
                                   rRect.Top() + ((rRect.GetHeight() - aBoxSize.Height()) / 2)),
                             aBoxSize);
      pCheckBoxPaint->SetPosSizePixel(aRect.TopLeft(), aRect.GetSize());

      pCheckBoxPaint->Draw(&GetDataWindow(), aRect.TopLeft(), DrawFlags::NONE);
  }

  void EditBrowseBox::AsynchGetFocus()
  {
      if (nStartEvent)
          Application::RemoveUserEvent(nStartEvent);

      m_pFocusWhileRequest = Application::GetFocusWindow();
      nStartEvent = Application::PostUserEvent(LINK(this,EditBrowseBox,StartEditHdl)::tools::detail::makeLink( ::tools::detail::castTo<EditBrowseBox
 *>(this), &EditBrowseBox::LinkStubStartEditHdl), nullptr, true);
  }


  void EditBrowseBox::SetBrowserFlags(EditBrowseBoxFlags nFlags)
  {
      if (m_nBrowserFlags == nFlags)
          return;

      bool RowPicturesChanges = ((m_nBrowserFlags & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT) !=
                                     (nFlags & EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT));
      m_nBrowserFlags = nFlags;

      if (RowPicturesChanges)
          InvalidateStatusCell(GetCurRow());
  }

  inline void EditBrowseBox::EnableAndShow() const
  {
      Controller()->resume();
  }


  CellController::CellController(Control* pW)
                 :pWindow( pW )
                 ,bSuspended( true )
  {

      DBG_ASSERT(pWindow, "CellController::CellController: missing the window!")do { if (true && (!(pWindow))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/brwbox/editbrowsebox.cxx"
 ":" "1233" ": "), "%s", "CellController::CellController: missing the window!"
); } } while (false);
      DBG_ASSERT(!pWindow->IsVisible(), "CellController::CellController: window should not be visible!")do { if (true && (!(!pWindow->IsVisible()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/brwbox/editbrowsebox.cxx"
 ":" "1234" ": "), "%s", "CellController::CellController: window should not be visible!"
); } } while (false);
  }


  CellController::~CellController()
  {

  }


  void CellController::suspend( )
  {
      DBG_ASSERT( bSuspended == !GetWindow().IsVisible(), "CellController::suspend: inconsistence!" )do { if (true && (!(bSuspended == !GetWindow().IsVisible
()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/svtools/source/brwbox/editbrowsebox.cxx"
 ":" "1246" ": "), "%s", "CellController::suspend: inconsistence!"
); } } while (false);
      if ( !isSuspended( ) )
      {
          CommitModifications();
          GetWindow().Hide( );
          GetWindow().Disable( );
          bSuspended = true;
      }
  }

  void CellController::resume( )
  {
      DBG_ASSERT( bSuspended == !GetWindow().IsVisible(), "CellController::resume: inconsistence!" )do { if (true && (!(bSuspended == !GetWindow().IsVisible
()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"
), ("/home/maarten/src/libreoffice/core/svtools/source/brwbox/editbrowsebox.cxx"
 ":" "1258" ": "), "%s", "CellController::resume: inconsistence!"
); } } while (false);
      if ( isSuspended( ) )
      {
          GetWindow().Enable( );
          GetWindow().Show( );
          bSuspended = false;
      }
  }

  void CellController::CommitModifications()
  {
      // nothing to do in this base class
  }

  void CellController::ActivatingMouseEvent(const BrowserMouseEvent& /*rEvt*/, bool /*bUp*/)
  {
      // nothing to do in this base class
  }

  bool CellController::MoveAllowed(const KeyEvent&) const
  {
      return true;
  }

1282}   // namespace svt


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

←

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

→

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

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

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

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

36class VclReferenceBase;

38namespace vcl::detail {

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

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

47} // namespace vcl::detail

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

  ::rtl::Reference<reference_type> m_rInnerRef;

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

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

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

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

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

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

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

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

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

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

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

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

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
8
←
Calling copy constructor for 'Reference<svt::CheckBoxControl>'→
11
←
Returning from copy constructor for 'Reference<svt::CheckBoxControl>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
12
←
Calling 'Reference::clear'→
19
←
Returning; memory was released→
      if (aTmp.get()) {
20
←
Calling 'Reference::get'→
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

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

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

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

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

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

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

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

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

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

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

440#endif // INCLUDED_VCL_PTR_HXX

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

←

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

→

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

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

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

32#include "sal/types.h"

34namespace rtl
35{

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


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


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

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

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

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

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

      Does not work for up-casts to ambiguous bases.

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

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody12.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
)
13
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
14
←
Calling 'VclReferenceBase::release'→
18
←
Returning; memory was released→
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
21
←
Use of memory after it is freed
  }


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


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


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

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

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


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


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


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


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

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

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

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

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

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

←

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

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