/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 GroupsSorting.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/reportdesign/inc -I /home/maarten/src/libreoffice/core/reportdesign/source/inc -I /home/maarten/src/libreoffice/core/reportdesign/source/ui/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/reportdesign/source/ui/dlg/GroupsSorting.cxx

/home/maarten/src/libreoffice/core/reportdesign/source/ui/dlg/GroupsSorting.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 <GroupsSorting.hxx>
20#include <svtools/editbrowsebox.hxx>
21#include <toolkit/helper/vclunohelper.hxx>
22#include <com/sun/star/beans/XPropertySet.hpp>
23#include <com/sun/star/container/XContainerListener.hpp>
24#include <com/sun/star/report/GroupOn.hpp>
25#include <com/sun/star/sdbc/DataType.hpp>

27#include <strings.hrc>
28#include <rptui_slotid.hrc>
29#include <core_resource.hxx>
30#include <helpids.h>
31#include "GroupExchange.hxx"
32#include <UITools.hxx>
33#include <UndoActions.hxx>
34#include <strings.hxx>
35#include <ReportController.hxx>
36#include <ColumnInfo.hxx>

38#include <cppuhelper/implbase.hxx>
39#include <vcl/commandevent.hxx>
40#include <vcl/svapp.hxx>

42#include <algorithm>

44#define HANDLE_ID0           0
45#define FIELD_EXPRESSION1    1
46#define GROUPS_START_LEN5    5
47#define NO_GROUP-1            -1

49namespace rptui
50{
51using namespace ::com::sun::star;
52using namespace svt;
53using namespace ::comphelper;

  static void lcl_addToList_throw( weld::ComboBox& _rListBox, ::std::vector<ColumnInfo>& o_aColumnList,const uno::Reference< container::XNameAccess>& i_xColumns )
  {
      const uno::Sequence< OUString > aEntries = i_xColumns->getElementNames();
      for ( const OUString& rEntry : aEntries )
      {
          uno::Reference< beans::XPropertySet> xColumn(i_xColumns->getByName(rEntry),uno::UNO_QUERY_THROW);
          OUString sLabel;
          if ( xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_LABEL"Label") )
              xColumn->getPropertyValue(PROPERTY_LABEL"Label") >>= sLabel;
          o_aColumnList.emplace_back(rEntry,sLabel );
          if ( !sLabel.isEmpty() )
              _rListBox.append_text( sLabel );
          else
              _rListBox.append_text( rEntry );
      }
  }

72/**
* Separated out from OFieldExpressionControl to prevent collision of ref-counted base classes
*/
75class OFieldExpressionControl;

77namespace {

79class OFieldExpressionControlContainerListener : public ::cppu::WeakImplHelper< container::XContainerListener >
80{
  VclPtr<OFieldExpressionControl> mpParent;
82public:
  explicit OFieldExpressionControlContainerListener(OFieldExpressionControl* pParent) : mpParent(pParent) {}

  // XEventListener
  virtual void SAL_CALL disposing(const css::lang::EventObject& Source) override;
  // XContainerListener
  virtual void SAL_CALL elementInserted(const css::container::ContainerEvent& rEvent) override;
  virtual void SAL_CALL elementReplaced(const css::container::ContainerEvent& rEvent) override;
  virtual void SAL_CALL elementRemoved(const css::container::ContainerEvent& rEvent) override;
91};

93}

95class OFieldExpressionControl : public ::svt::EditBrowseBox
96{
  ::osl::Mutex                    m_aMutex;
  ::std::vector<sal_Int32>        m_aGroupPositions;
  ::std::vector<ColumnInfo>       m_aColumnInfo;
  VclPtr< ::svt::ComboBoxControl>  m_pComboCell;
  sal_Int32                       m_nDataPos;
  sal_Int32                       m_nCurrentPos;
  ImplSVEvent *                   m_nDeleteEvent;
  OGroupsSortingDialog*           m_pParent;
  bool                            m_bIgnoreEvent;
  rtl::Reference<OFieldExpressionControlContainerListener> aContainerListener;

108public:
  OFieldExpressionControl(OGroupsSortingDialog* pParentDialog, const css::uno::Reference<css::awt::XWindow> &rParent);
  virtual ~OFieldExpressionControl() override;
  virtual void dispose() override;

  // XContainerListener
  /// @throws css::uno::RuntimeException
  void elementInserted(const css::container::ContainerEvent& rEvent);
  /// @throws css::uno::RuntimeException
  void elementRemoved(const css::container::ContainerEvent& rEvent);

  virtual Size GetOptimalSize() const override;

  void        fillColumns(const uno::Reference< container::XNameAccess>& _xColumns);
  void        lateInit();
  bool    IsDeleteAllowed( ) const;
  void        DeleteRows();

  sal_Int32   getGroupPosition(sal_Int32 _nRow) const { return _nRow != BROWSER_ENDOFSELECTION(static_cast<long>((-1))) ? m_aGroupPositions[_nRow] : sal_Int32(NO_GROUP-1); }

  /** returns the sequence with the selected groups
  */
  uno::Sequence<uno::Any> fillSelectedGroups();

  /** move groups given by _aGroups
  */
  void moveGroups(const uno::Sequence<uno::Any>& _aGroups,sal_Int32 _nRow,bool _bSelect = true);

  virtual bool CursorMoving(long nNewRow, sal_uInt16 nNewCol) override;
  using ::svt::EditBrowseBox::GetRowCount;
138protected:
  virtual bool IsTabAllowed(bool bForward) const override;

  virtual void InitController( ::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol ) override;
  virtual ::svt::CellController* GetController( long nRow, sal_uInt16 nCol ) override;
  virtual void PaintCell( OutputDevice& rDev, const tools::Rectangle& rRect, sal_uInt16 nColId ) const override;
  virtual bool SeekRow( long nRow ) override;
  virtual bool SaveModified() override;
  virtual OUString GetCellText( long nRow, sal_uInt16 nColId ) const override;
  virtual RowStatus GetRowStatus(long nRow) const override;

  virtual void KeyInput(const KeyEvent& rEvt) override;
  virtual void Command( const CommandEvent& rEvt ) override;

  // D&D
  virtual void     StartDrag( sal_Int8 nAction, const Point& rPosPixel ) override;
  virtual sal_Int8 AcceptDrop( const BrowserAcceptDropEvent& rEvt ) override;
  virtual sal_Int8 ExecuteDrop( const BrowserExecuteDropEvent& rEvt ) override;

  using BrowseBox::AcceptDrop;
  using BrowseBox::ExecuteDrop;

160private:

  DECL_LINK( CBChangeHdl, weld::ComboBox&, void)static void LinkStubCBChangeHdl(void *, weld::ComboBox&);
 void CBChangeHdl(weld::ComboBox&);

164public:
  DECL_LINK( DelayedDelete, void*, void )static void LinkStubDelayedDelete(void *, void*); void DelayedDelete
(void*);

167};


170void OFieldExpressionControlContainerListener::disposing(const css::lang::EventObject& )
171{}

173void OFieldExpressionControlContainerListener::elementInserted(const css::container::ContainerEvent& rEvent)
174{ mpParent->elementInserted(rEvent); }

176void OFieldExpressionControlContainerListener::elementReplaced(const css::container::ContainerEvent& )
177{}

179void OFieldExpressionControlContainerListener::elementRemoved(const css::container::ContainerEvent& rEvent)
180{ mpParent->elementRemoved(rEvent); }

182OFieldExpressionControl::OFieldExpressionControl(OGroupsSortingDialog* pParentDialog, const css::uno::Reference<css::awt::XWindow> &rParent)
  :EditBrowseBox( VCLUnoHelper::GetWindow(rParent), EditBrowseBoxFlags::NONE, WB_TABSTOP,
                  BrowserMode::COLUMNSELECTION | BrowserMode::MULTISELECTION | BrowserMode::AUTOSIZE_LASTCOL |
                            BrowserMode::KEEPHIGHLIGHT | BrowserMode::HLINES | BrowserMode::VLINES)
  ,m_aGroupPositions(GROUPS_START_LEN5,-1)
  ,m_pComboCell(nullptr)
  ,m_nDataPos(-1)
  ,m_nCurrentPos(-1)
  ,m_nDeleteEvent(nullptr)
  ,m_pParent(pParentDialog)
  ,m_bIgnoreEvent(false)
  ,aContainerListener(new OFieldExpressionControlContainerListener(this))
194{
  SetBorderStyle(WindowBorderStyle::MONO);
196}

198OFieldExpressionControl::~OFieldExpressionControl()
199{
  disposeOnce();
201}

203void OFieldExpressionControl::dispose()
204{
  uno::Reference< report::XGroups > xGroups = m_pParent->getGroups();
  xGroups->removeContainerListener(aContainerListener.get());

  // delete events from queue
  if( m_nDeleteEvent )
      Application::RemoveUserEvent( m_nDeleteEvent );

  m_pComboCell.disposeAndClear();
  m_pParent = nullptr;
  ::svt::EditBrowseBox::dispose();
215}

217uno::Sequence<uno::Any> OFieldExpressionControl::fillSelectedGroups()
218{
  uno::Sequence<uno::Any> aList;
  ::std::vector<uno::Any> vClipboardList;
  vClipboardList.reserve(GetSelectRowCount());

  uno::Reference<report::XGroups> xGroups = m_pParent->getGroups();
  sal_Int32 nCount = xGroups->getCount();
  if ( nCount >= 1 )
  {
      for( long nIndex=FirstSelectedRow(); nIndex != SFX_ENDOFSELECTION(-1); nIndex=NextSelectedRow() )
      {
          try
          {
              if ( m_aGroupPositions[nIndex] != NO_GROUP-1 )
              {
                  uno::Reference< report::XGroup> xOrgGroup(xGroups->getByIndex(m_aGroupPositions[nIndex]),uno::UNO_QUERY);
                  /*uno::Reference< report::XGroup> xCopy = xGroups->createGroup();
                  ::comphelper::copyProperties(xOrgGroup.get(),xCopy.get());*/
                  vClipboardList.push_back( uno::makeAny(xOrgGroup) );
              }
          }
          catch(uno::Exception&)
          {
              OSL_FAIL("Can not access group!")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/reportdesign/source/ui/dlg/GroupsSorting.cxx"
 ":" "241" ": "), "%s", "Can not access group!"); } } while (
false);
          }
      }
      if ( !vClipboardList.empty() )
          aList = uno::Sequence< uno::Any >(vClipboardList.data(), vClipboardList.size());
  }
  return aList;
248}

250void OFieldExpressionControl::StartDrag( sal_Int8 /*_nAction*/ , const Point& /*_rPosPixel*/ )
251{
  if ( m_pParent && !m_pParent->isReadOnly( ) )
  {
      uno::Sequence<uno::Any> aClipboardList = fillSelectedGroups();

      if( aClipboardList.hasElements() )
      {
          rtl::Reference<OGroupExchange> pData = new OGroupExchange(aClipboardList);
          pData->StartDrag(this, DND_ACTION_MOVEcss::datatransfer::dnd::DNDConstants::ACTION_MOVE );
      }
  }
262}

264sal_Int8 OFieldExpressionControl::AcceptDrop( const BrowserAcceptDropEvent& rEvt )
265{
  sal_Int8 nAction = DND_ACTION_NONEcss::datatransfer::dnd::DNDConstants::ACTION_NONE;
  if ( IsEditing() )
  {
      weld::ComboBox& rComboBox = m_pComboCell->get_widget();
      sal_Int32 nPos = rComboBox.get_active();
      if (nPos != -1 || !rComboBox.get_active_text().isEmpty())
          SaveModified();
      DeactivateCell();
  }
  if ( IsDropFormatSupported( OGroupExchange::getReportGroupId() ) && m_pParent->getGroups()->getCount() > 1 && rEvt.GetWindow() == &GetDataWindow() )
  {
      nAction = DND_ACTION_MOVEcss::datatransfer::dnd::DNDConstants::ACTION_MOVE;
  }
  return nAction;
280}

282sal_Int8 OFieldExpressionControl::ExecuteDrop( const BrowserExecuteDropEvent& rEvt )
283{
  sal_Int8 nAction = DND_ACTION_NONEcss::datatransfer::dnd::DNDConstants::ACTION_NONE;
  if ( IsDropFormatSupported( OGroupExchange::getReportGroupId() ) )
  {
      sal_Int32   nRow = GetRowAtYPosPixel(rEvt.maPosPixel.Y(), false);
      SetNoSelection();

      TransferableDataHelper aDropped( rEvt.maDropEvent.Transferable );
      uno::Any aDrop = aDropped.GetAny(OGroupExchange::getReportGroupId(), OUString());
      uno::Sequence< uno::Any > aGroups;
      aDrop >>= aGroups;
      if ( aGroups.hasElements() )
      {
          moveGroups(aGroups,nRow);
          nAction = DND_ACTION_MOVEcss::datatransfer::dnd::DNDConstants::ACTION_MOVE;
      }
  }
  return nAction;
301}

303void OFieldExpressionControl::moveGroups(const uno::Sequence<uno::Any>& _aGroups,sal_Int32 _nRow,bool _bSelect)
304{
  if ( !_aGroups.hasElements() )
      return;

  m_bIgnoreEvent = true;
  {
      sal_Int32 nRow = _nRow;
      const OUString sUndoAction(RptResId(RID_STR_UNDO_MOVE_GROUPreinterpret_cast<char const *>("RID_STR_UNDO_MOVE_GROUP"
 "\004" u8"Move Group(s)")));
      const UndoContext aUndoContext( m_pParent->m_pController->getUndoManager(), sUndoAction );

      uno::Reference< report::XGroups> xGroups = m_pParent->getGroups();
      for(const uno::Any& rGroup : _aGroups)
      {
          uno::Reference< report::XGroup> xGroup(rGroup,uno::UNO_QUERY);
          if ( xGroup.is() )
          {
              uno::Sequence< beans::PropertyValue > aArgs(1);
              aArgs[0].Name = PROPERTY_GROUP"Group";
              aArgs[0].Value <<= xGroup;
              // we use this way to create undo actions
              m_pParent->m_pController->executeChecked(SID_GROUP_REMOVE( ((((((((((10000 + 1499) + 1) + 499) + 1) + 100) + 1) + 149)
 + 1) + 200) + 1) + 17 ),aArgs);
              aArgs.realloc(2);
              if ( nRow > xGroups->getCount() )
                  nRow = xGroups->getCount();
              if ( _bSelect )
                  SelectRow(nRow);
              aArgs[1].Name = PROPERTY_POSITIONY"PositionY";
              aArgs[1].Value <<= nRow;
              m_pParent->m_pController->executeChecked(SID_GROUP_APPEND( ((((((((((10000 + 1499) + 1) + 499) + 1) + 100) + 1) + 149)
 + 1) + 200) + 1) + 18 ),aArgs);
              ++nRow;
          }
      }
  }
  m_bIgnoreEvent = false;
  Invalidate();
339}

341void OFieldExpressionControl::fillColumns(const uno::Reference< container::XNameAccess>& _xColumns)
342{
  weld::ComboBox& rComboBox = m_pComboCell->get_widget();
  rComboBox.clear();
  if ( _xColumns.is() )
      lcl_addToList_throw(rComboBox, m_aColumnInfo, _xColumns);
347}

349void OFieldExpressionControl::lateInit()
350{
  uno::Reference< report::XGroups > xGroups = m_pParent->getGroups();
  sal_Int32 nGroupsCount = xGroups->getCount();
  m_aGroupPositions.resize(::std::max<sal_Int32>(nGroupsCount,sal_Int32(GROUPS_START_LEN5)),NO_GROUP-1);
  ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
  for (sal_Int32 i = 0; i < nGroupsCount; ++i,++aIter)
      *aIter = i;

  if ( ColCount() == 0 )
  {
      vcl::Font aFont( GetDataWindow().GetFont() );
      aFont.SetWeight( WEIGHT_NORMAL );
      GetDataWindow().SetFont( aFont );

      // Set font of the headline to light
      aFont = GetFont();
      aFont.SetWeight( WEIGHT_LIGHT );
      SetFont(aFont);

      InsertHandleColumn(static_cast<sal_uInt16>(GetTextWidth(OUString('0')) * 4)/*, sal_True */);
      InsertDataColumn( FIELD_EXPRESSION1, RptResId(STR_RPT_EXPRESSIONreinterpret_cast<char const *>("STR_RPT_EXPRESSION" "\004"
 u8"Field/Expression")), 100);

      m_pComboCell = VclPtr<ComboBoxControl>::Create( &GetDataWindow() );
      weld::ComboBox& rComboBox = m_pComboCell->get_widget();
      rComboBox.connect_changed(LINK(this,OFieldExpressionControl,CBChangeHdl)::tools::detail::makeLink( ::tools::detail::castTo<OFieldExpressionControl
 *>(this), &OFieldExpressionControl::LinkStubCBChangeHdl
));
      m_pComboCell->SetHelpId(HID_RPT_FIELDEXPRESSION"REPORTDESIGN_HID_RPT_FIELDEXPRESSION");

      rComboBox.connect_focus_in(LINK(m_pParent, OGroupsSortingDialog, OnControlFocusGot)::tools::detail::makeLink( ::tools::detail::castTo<OGroupsSortingDialog
 *>(m_pParent), &OGroupsSortingDialog::LinkStubOnControlFocusGot
));


      // set browse mode
      BrowserMode nMode(BrowserMode::COLUMNSELECTION | BrowserMode::MULTISELECTION  | BrowserMode::KEEPHIGHLIGHT |
                        BrowserMode::HLINES | BrowserMode::VLINES       | BrowserMode::AUTOSIZE_LASTCOL | BrowserMode::AUTO_VSCROLL | BrowserMode::AUTO_HSCROLL);
      if( m_pParent->isReadOnly() )
          nMode |= BrowserMode::HIDECURSOR;
      SetMode(nMode);
      xGroups->addContainerListener(aContainerListener.get());
  }
  else
      // not the first call
      RowRemoved(0, GetRowCount());

  RowInserted(0, m_aGroupPositions.size());
393}

395IMPL_LINK_NOARG( OFieldExpressionControl, CBChangeHdl, weld::ComboBox&, void )void OFieldExpressionControl::LinkStubCBChangeHdl(void * instance
, weld::ComboBox& data) { return static_cast<OFieldExpressionControl
 *>(instance)->CBChangeHdl(data); } void OFieldExpressionControl
::CBChangeHdl(__attribute__ ((unused)) weld::ComboBox&)
396{
  SaveModified();
398}

400bool OFieldExpressionControl::IsTabAllowed(bool /*bForward*/) const
401{
  return false;
403}

405bool OFieldExpressionControl::SaveModified()
406{
  sal_Int32 nRow = GetCurRow();
  if ( nRow != BROWSER_ENDOFSELECTION(static_cast<long>((-1))) )
  {
      try
      {
          bool bAppend = false;
          uno::Reference< report::XGroup> xGroup;
          if ( m_aGroupPositions[nRow] == NO_GROUP-1 )
          {
              bAppend = true;
              OUString sUndoAction(RptResId(RID_STR_UNDO_APPEND_GROUPreinterpret_cast<char const *>("RID_STR_UNDO_APPEND_GROUP"
 "\004" u8"Add Group")));
              m_pParent->m_pController->getUndoManager().EnterListAction( sUndoAction, OUString(), 0, ViewShellId(-1) );
              xGroup = m_pParent->getGroups()->createGroup();
              xGroup->setHeaderOn(true);

              uno::Sequence< beans::PropertyValue > aArgs(2);
              aArgs[0].Name = PROPERTY_GROUP"Group";
              aArgs[0].Value <<= xGroup;
              // find position where to insert the new group
              sal_Int32 nGroupPos = 0;
              ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
              ::std::vector<sal_Int32>::const_iterator aEnd  = m_aGroupPositions.begin() + nRow;
              for(;aIter != aEnd;++aIter)
                  if ( *aIter != NO_GROUP-1 )
                      nGroupPos = *aIter + 1;
              aArgs[1].Name = PROPERTY_POSITIONY"PositionY";
              aArgs[1].Value <<= nGroupPos;
              m_bIgnoreEvent = true;
              m_pParent->m_pController->executeChecked(SID_GROUP_APPEND( ((((((((((10000 + 1499) + 1) + 499) + 1) + 100) + 1) + 149)
 + 1) + 200) + 1) + 18 ),aArgs);
              m_bIgnoreEvent = false;
              OSL_ENSURE(*aIter == NO_GROUP ,"Illegal iterator!")do { if (true && (!(*aIter == -1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/reportdesign/source/ui/dlg/GroupsSorting.cxx"
 ":" "437" ": "), "%s", "Illegal iterator!"); } } while (false
);
              *aIter++ = nGroupPos;

              aEnd  = m_aGroupPositions.end();
              for(;aIter != aEnd;++aIter)
                  if ( *aIter != NO_GROUP-1 )
                      ++*aIter;
          }
          else
              xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
          if ( xGroup.is() )
          {
              weld::ComboBox& rComboBox = m_pComboCell->get_widget();
              sal_Int32 nPos = rComboBox.get_active();
              OUString sExpression;
              if (nPos == -1)
                  sExpression = rComboBox.get_active_text();
              else
              {
                  sExpression = m_aColumnInfo[nPos].sColumnName;
              }
              xGroup->setExpression( sExpression );

              ::rptui::adjustSectionName(xGroup,nPos);

              if ( bAppend )
                  m_pParent->m_pController->getUndoManager().LeaveListAction();
          }

          if (Controller().is())
              Controller()->SaveValue();
          if ( GetRowCount() == m_pParent->getGroups()->getCount() )
          {
              RowInserted( GetRowCount()-1);
              m_aGroupPositions.push_back(NO_GROUP-1);
          }

          GoToRow(nRow);
          m_pParent->DisplayData(nRow);
      }
      catch(uno::Exception&)
      {
          OSL_FAIL("OFieldExpressionControl::SaveModified: Exception caught!")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/reportdesign/source/ui/dlg/GroupsSorting.cxx"
 ":" "479" ": "), "%s", "OFieldExpressionControl::SaveModified: Exception caught!"
); } } while (false);
      }
  }

  return true;
484}

486OUString OFieldExpressionControl::GetCellText( long nRow, sal_uInt16 /*nColId*/ ) const
487{
  OUString sText;
  if ( nRow != BROWSER_ENDOFSELECTION(static_cast<long>((-1))) && m_aGroupPositions[nRow] != NO_GROUP-1 )
  {
      try
      {
          uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
          OUString sExpression = xGroup->getExpression();

          auto aIter = std::find_if(m_aColumnInfo.begin(), m_aColumnInfo.end(),
              [&sExpression](const ColumnInfo& rColumnInfo) { return rColumnInfo.sColumnName == sExpression; });
          if (aIter != m_aColumnInfo.end() && !aIter->sLabel.isEmpty())
              sExpression = aIter->sLabel;
          sText = sExpression;
      }
      catch (const uno::Exception&)
      {
          OSL_FAIL("Exception caught while getting expression value from the group")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/reportdesign/source/ui/dlg/GroupsSorting.cxx"
 ":" "504" ": "), "%s", "Exception caught while getting expression value from the group"
); } } while (false);
      }
  }
  return sText;
508}

510void OFieldExpressionControl::InitController( CellControllerRef& /*rController*/, long nRow, sal_uInt16 nColumnId )
511{
  weld::ComboBox& rComboBox = m_pComboCell->get_widget();
  rComboBox.set_entry_text(GetCellText(nRow, nColumnId));
514}

516bool OFieldExpressionControl::CursorMoving(long nNewRow, sal_uInt16 nNewCol)
517{

  if (!EditBrowseBox::CursorMoving(nNewRow, nNewCol))
      return false;
  m_nDataPos = nNewRow;
  long nOldDataPos = GetCurRow();
  InvalidateStatusCell( m_nDataPos );
  InvalidateStatusCell( nOldDataPos );

  m_pParent->SaveData( nOldDataPos );
  m_pParent->DisplayData( m_nDataPos );
  return true;
529}

531CellController* OFieldExpressionControl::GetController( long /*nRow*/, sal_uInt16 /*nColumnId*/ )
532{
  ComboBoxCellController* pCellController = new ComboBoxCellController( m_pComboCell );
  pCellController->GetComboBox().set_entry_editable(m_pParent->m_pController->isEditable());
  return pCellController;
536}

538bool OFieldExpressionControl::SeekRow( long _nRow )
539{
  // the basis class needs the call, because that's how the class knows which line will be painted
  EditBrowseBox::SeekRow(_nRow);
  m_nCurrentPos = _nRow;
  return true;
544}

546void OFieldExpressionControl::PaintCell( OutputDevice& rDev, const tools::Rectangle& rRect, sal_uInt16 nColumnId ) const
547{
  OUString aText  =GetCellText( m_nCurrentPos, nColumnId );

  Point aPos( rRect.TopLeft() );
  Size aTextSize( GetDataWindow().GetTextWidth( aText ), GetDataWindow().GetTextHeight() );

  if( aPos.X() < rRect.Left() || aPos.X() + aTextSize.Width() > rRect.Right() ||
      aPos.Y() < rRect.Top() || aPos.Y() + aTextSize.Height() > rRect.Bottom() )
      rDev.SetClipRegion(vcl::Region(rRect));

  rDev.DrawText( aPos, aText );

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

563EditBrowseBox::RowStatus OFieldExpressionControl::GetRowStatus(long nRow) const
564{
  if (nRow >= 0 && nRow == m_nDataPos)
      return EditBrowseBox::CURRENT;
  if ( nRow != BROWSER_ENDOFSELECTION(static_cast<long>((-1))) && nRow < static_cast<long>(m_aGroupPositions.size()) && m_aGroupPositions[nRow] != NO_GROUP-1 )
  {
      try
      {
          uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
          return (xGroup->getHeaderOn() || xGroup->getFooterOn())? EditBrowseBox::HEADERFOOTER : EditBrowseBox::CLEAN;
      }
      catch(uno::Exception&)
      {
          OSL_FAIL("Exception caught while try to get a group!")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/reportdesign/source/ui/dlg/GroupsSorting.cxx"
 ":" "576" ": "), "%s", "Exception caught while try to get a group!"
); } } while (false);
      }
  }
  return EditBrowseBox::CLEAN;
580}

582// XContainerListener

584void OFieldExpressionControl::elementInserted(const container::ContainerEvent& evt)
585{
  if ( m_bIgnoreEvent )
      return;
  SolarMutexGuard aSolarGuard;
  ::osl::MutexGuard aGuard( m_aMutex );
  sal_Int32 nGroupPos = 0;
  if ( !(evt.Accessor >>= nGroupPos) )
      return;

  if ( nGroupPos >= GetRowCount() )
  {
      sal_Int32 nAddedRows = nGroupPos - GetRowCount();
      RowInserted(nAddedRows);
      for (sal_Int32 i = 0; i < nAddedRows; ++i)
          m_aGroupPositions.push_back(NO_GROUP-1);
      m_aGroupPositions[nGroupPos] = nGroupPos;
  }
  else
  {
      ::std::vector<sal_Int32>::iterator aFind = m_aGroupPositions.begin()+ nGroupPos;
      if ( aFind == m_aGroupPositions.end() )
          aFind = ::std::find(m_aGroupPositions.begin(),m_aGroupPositions.end(),NO_GROUP-1);

      if ( aFind != m_aGroupPositions.end() )
      {
          if ( *aFind != NO_GROUP-1 )
              aFind = m_aGroupPositions.insert(aFind,nGroupPos);
          else
              *aFind = nGroupPos;

          ::std::vector<sal_Int32>::const_iterator aEnd  = m_aGroupPositions.end();
          for(++aFind;aFind != aEnd;++aFind)
              if ( *aFind != NO_GROUP-1 )
                  ++*aFind;
      }
  }
  Invalidate();
622}

624void OFieldExpressionControl::elementRemoved(const container::ContainerEvent& evt)
625{
  SolarMutexGuard aSolarGuard;
  ::osl::MutexGuard aGuard( m_aMutex );

  if ( m_bIgnoreEvent )
      return;

  sal_Int32 nGroupPos = 0;
  if ( !(evt.Accessor >>= nGroupPos) )
      return;

  std::vector<sal_Int32>::iterator aEnd = m_aGroupPositions.end();
  std::vector<sal_Int32>::iterator aFind = std::find(m_aGroupPositions.begin(), aEnd, nGroupPos);
  if (aFind != aEnd)
  {
      *aFind = NO_GROUP-1;
      for(++aFind;aFind != aEnd;++aFind)
          if ( *aFind != NO_GROUP-1 )
              --*aFind;
      Invalidate();
  }
646}

648bool OFieldExpressionControl::IsDeleteAllowed( ) const
649{
  return !m_pParent->isReadOnly() && GetSelectRowCount() > 0;
651}

653void OFieldExpressionControl::KeyInput( const KeyEvent& rEvt )
654{
  if (IsDeleteAllowed())
  {
      if (rEvt.GetKeyCode().GetCode() == KEY_DELETE &&    // Delete rows
          !rEvt.GetKeyCode().IsShift() &&
          !rEvt.GetKeyCode().IsMod1())
      {
          DeleteRows();
          return;
      }
  }
  EditBrowseBox::KeyInput(rEvt);
666}

668void OFieldExpressionControl::Command(const CommandEvent& rEvt)
669{
  switch (rEvt.GetCommand())
  {
      case CommandEventId::ContextMenu:
      {
          if (!rEvt.IsMouseEvent())
          {
              EditBrowseBox::Command(rEvt);
              return;
          }

          sal_uInt16 nColId = GetColumnId(GetColumnAtXPosPixel(rEvt.GetMousePosPixel().X()));

          if ( nColId == HANDLE_ID0 )
          {
              bool bEnable = false;
              long nIndex = FirstSelectedRow();
              while( nIndex != SFX_ENDOFSELECTION(-1) && !bEnable )
              {
                  if ( m_aGroupPositions[nIndex] != NO_GROUP-1 )
                      bEnable = true;
                  nIndex = NextSelectedRow();
              }
              VclBuilder aBuilder(nullptr, AllSettings::GetUIRootDir(), "modules/dbreport/ui/groupsortmenu.ui", "");
              VclPtr<PopupMenu> aContextMenu(aBuilder.get_menu("menu"));
              aContextMenu->EnableItem(aContextMenu->GetItemId("delete"), IsDeleteAllowed() && bEnable);
              if (aContextMenu->Execute(this, rEvt.GetMousePosPixel()))
              {
                  if( m_nDeleteEvent )
                      Application::RemoveUserEvent( m_nDeleteEvent );
                  m_nDeleteEvent = Application::PostUserEvent( LINK(this, OFieldExpressionControl, DelayedDelete)::tools::detail::makeLink( ::tools::detail::castTo<OFieldExpressionControl
 *>(this), &OFieldExpressionControl::LinkStubDelayedDelete
), nullptr, true );
              }
          }
          [[fallthrough]];
      }
      default:
          EditBrowseBox::Command(rEvt);
  }

708}

710void OFieldExpressionControl::DeleteRows()
711{

  bool bIsEditing = IsEditing();
  if (bIsEditing)
  {
      DeactivateCell();
  }
  long nIndex = FirstSelectedRow();
  if (nIndex == SFX_ENDOFSELECTION(-1))
  {
      nIndex = GetCurRow();
  }
  bool bFirstTime = true;

  long nOldDataPos = nIndex;
  uno::Sequence< beans::PropertyValue > aArgs(1);
  aArgs[0].Name = PROPERTY_GROUP"Group";
  m_bIgnoreEvent = true;
  while( nIndex >= 0 )
  {
      if ( m_aGroupPositions[nIndex] != NO_GROUP-1 )
      {
          if ( bFirstTime )
          {
              bFirstTime = false;
              OUString sUndoAction(RptResId(RID_STR_UNDO_REMOVE_SELECTIONreinterpret_cast<char const *>("RID_STR_UNDO_REMOVE_SELECTION"
 "\004" u8"Delete Selection")));
              m_pParent->m_pController->getUndoManager().EnterListAction( sUndoAction, OUString(), 0, ViewShellId(-1) );
          }

          sal_Int32 nGroupPos = m_aGroupPositions[nIndex];
          uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(nGroupPos);
          aArgs[0].Value <<= xGroup;
          // we use this way to create undo actions
          m_pParent->m_pController->executeChecked(SID_GROUP_REMOVE( ((((((((((10000 + 1499) + 1) + 499) + 1) + 100) + 1) + 149)
 + 1) + 200) + 1) + 17 ),aArgs);

          std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
          std::vector<sal_Int32>::iterator aFind = std::find(m_aGroupPositions.begin(), aEnd, nGroupPos);
          if (aFind != aEnd)
          {
              *aFind = NO_GROUP-1;
              for(++aFind;aFind != aEnd;++aFind)
                  if ( *aFind != NO_GROUP-1 )
                      --*aFind;
          }
      }
      nIndex = NextSelectedRow();
  }

  if ( !bFirstTime )
      m_pParent->m_pController->getUndoManager().LeaveListAction();

  m_nDataPos = GetCurRow();
  InvalidateStatusCell( nOldDataPos );
  InvalidateStatusCell( m_nDataPos );
  ActivateCell();
  m_pParent->DisplayData( m_nDataPos );
  m_bIgnoreEvent = false;
  Invalidate();
769}

771IMPL_LINK_NOARG( OFieldExpressionControl, DelayedDelete, void*, void )void OFieldExpressionControl::LinkStubDelayedDelete(void * instance
, void* data) { return static_cast<OFieldExpressionControl
 *>(instance)->DelayedDelete(data); } void OFieldExpressionControl
::DelayedDelete(__attribute__ ((unused)) void*)
772{
  m_nDeleteEvent = nullptr;
  DeleteRows();
775}

777Size OFieldExpressionControl::GetOptimalSize() const
778{
  return LogicToPixel(Size(106, 75), MapMode(MapUnit::MapAppFont));
780}

782OGroupsSortingDialog::OGroupsSortingDialog(weld::Window* pParent, bool bReadOnly,
                                         OReportController* pController)
  : GenericDialogController(pParent, "modules/dbreport/ui/floatingsort.ui", "FloatingSort")
  , OPropertyChangeListener(m_aMutex)
  , m_pController(pController)
  , m_xGroups(m_pController->getReportDefinition()->getGroups())
  , m_bReadOnly(bReadOnly)
  , m_xToolBox(m_xBuilder->weld_toolbar("toolbox"))
  , m_xProperties(m_xBuilder->weld_widget("properties"))
  , m_xOrderLst(m_xBuilder->weld_combo_box("sorting"))
  , m_xHeaderLst(m_xBuilder->weld_combo_box("header"))
  , m_xFooterLst(m_xBuilder->weld_combo_box("footer"))
  , m_xGroupOnLst(m_xBuilder->weld_combo_box("group"))
  , m_xGroupIntervalEd(m_xBuilder->weld_spin_button("interval"))
  , m_xKeepTogetherLst(m_xBuilder->weld_combo_box("keep"))
  , m_xHelpWindow(m_xBuilder->weld_label("helptext"))
  , m_xBox(m_xBuilder->weld_container("box"))
  , m_xTableCtrlParent(m_xBox->CreateChildFrame())
  , m_xFieldExpression(VclPtr<OFieldExpressionControl>::Create(this, m_xTableCtrlParent))
801{
  m_xHelpWindow->set_size_request(-1, m_xHelpWindow->get_text_height() * 4);
  m_xFieldExpression->set_hexpand(true);
  m_xFieldExpression->set_vexpand(true);

  weld::Widget* pControlsLst[] = { m_xHeaderLst.get(), m_xFooterLst.get(), m_xGroupOnLst.get(),
                                   m_xKeepTogetherLst.get(), m_xOrderLst.get(), m_xGroupIntervalEd.get() };
  for (weld::Widget* i : pControlsLst)
  {
      i->connect_focus_in(LINK(this, OGroupsSortingDialog, OnWidgetFocusGot)::tools::detail::makeLink( ::tools::detail::castTo<OGroupsSortingDialog
 *>(this), &OGroupsSortingDialog::LinkStubOnWidgetFocusGot
));
      i->show();
  }

  m_xGroupIntervalEd->connect_focus_out(LINK(this, OGroupsSortingDialog, OnWidgetFocusLost)::tools::detail::makeLink( ::tools::detail::castTo<OGroupsSortingDialog
 *>(this), &OGroupsSortingDialog::LinkStubOnWidgetFocusLost
));

  for (size_t i = 0; i < SAL_N_ELEMENTS(pControlsLst)(sizeof(sal_n_array_size(pControlsLst))) - 1; ++i)
      dynamic_cast<weld::ComboBox&>(*pControlsLst[i]).connect_changed(LINK(this,OGroupsSortingDialog,LBChangeHdl)::tools::detail::makeLink( ::tools::detail::castTo<OGroupsSortingDialog
 *>(this), &OGroupsSortingDialog::LinkStubLBChangeHdl));

  m_pReportListener = new OPropertyChangeMultiplexer(this,m_pController->getReportDefinition().get());
  m_pReportListener->addProperty(PROPERTY_COMMAND"Command");
  m_pReportListener->addProperty(PROPERTY_COMMANDTYPE"CommandType");

  m_xFieldExpression->lateInit();
  fillColumns();
  Size aPrefSize = m_xFieldExpression->GetOptimalSize();
  m_xBox->set_size_request(aPrefSize.Width(), aPrefSize.Height());
  m_xFieldExpression->Show();

  m_xToolBox->connect_clicked(LINK(this, OGroupsSortingDialog, OnFormatAction)::tools::detail::makeLink( ::tools::detail::castTo<OGroupsSortingDialog
 *>(this), &OGroupsSortingDialog::LinkStubOnFormatAction
));

  checkButtons(0);
832}

834OGroupsSortingDialog::~OGroupsSortingDialog()
835{
  m_pReportListener->dispose();
  if ( m_pCurrentGroupListener.is() )
1
Taking false branch→
      m_pCurrentGroupListener->dispose();
  m_xFieldExpression.disposeAndClear();
2
←
Calling 'VclPtr::disposeAndClear'→
  m_xTableCtrlParent->dispose();
  m_xTableCtrlParent.clear();
842}

844void OGroupsSortingDialog::UpdateData( )
845{
  m_xFieldExpression->Invalidate();
  long nCurRow = m_xFieldExpression->GetCurRow();
  m_xFieldExpression->DeactivateCell();
  m_xFieldExpression->ActivateCell(nCurRow, m_xFieldExpression->GetCurColumnId());
  DisplayData(nCurRow);
851}

853void OGroupsSortingDialog::DisplayData( sal_Int32 _nRow )
854{
  const sal_Int32 nGroupPos = m_xFieldExpression->getGroupPosition(_nRow);
  const bool bEmpty = nGroupPos == NO_GROUP-1;
  m_xProperties->set_sensitive(!bEmpty);

  checkButtons(_nRow);

  if ( m_pCurrentGroupListener.is() )
      m_pCurrentGroupListener->dispose();
  m_pCurrentGroupListener = nullptr;
  if (!bEmpty)
  {
      uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);

      m_pCurrentGroupListener = new OPropertyChangeMultiplexer(this,xGroup.get());
      m_pCurrentGroupListener->addProperty(PROPERTY_HEADERON"HeaderOn");
      m_pCurrentGroupListener->addProperty(PROPERTY_FOOTERON"FooterOn");

      displayGroup(xGroup);
  }
874}

876void OGroupsSortingDialog::SaveData( sal_Int32 _nRow)
877{
  sal_Int32 nGroupPos = m_xFieldExpression->getGroupPosition(_nRow);
  if ( nGroupPos == NO_GROUP-1 )
      return;

  uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
  if (m_xHeaderLst->get_value_changed_from_saved())
      xGroup->setHeaderOn( m_xHeaderLst->get_active() == 0 );
  if (m_xFooterLst->get_value_changed_from_saved())
      xGroup->setFooterOn( m_xFooterLst->get_active() == 0 );
  if (m_xKeepTogetherLst->get_value_changed_from_saved())
      xGroup->setKeepTogether( m_xKeepTogetherLst->get_active() );
  if (m_xGroupOnLst->get_value_changed_from_saved())
  {
      auto nGroupOn = m_xGroupOnLst->get_active_id().toInt32();
      xGroup->setGroupOn( nGroupOn );
  }
  if (m_xGroupIntervalEd->get_value_changed_from_saved())
  {
      xGroup->setGroupInterval(m_xGroupIntervalEd->get_value());
      m_xGroupIntervalEd->save_value();
  }
  if ( m_xOrderLst->get_value_changed_from_saved() )
      xGroup->setSortAscending( m_xOrderLst->get_active() == 0 );

  weld::ComboBox* pControls[] = { m_xHeaderLst.get(), m_xFooterLst.get(), m_xGroupOnLst.get(),
                                  m_xKeepTogetherLst.get(), m_xOrderLst.get() };
  for (weld::ComboBox* pControl : pControls)
      pControl->save_value();
906}

908sal_Int32 OGroupsSortingDialog::getColumnDataType(const OUString& _sColumnName)
909{
  sal_Int32 nDataType = sdbc::DataType::VARCHAR;
  try
  {
      if ( !m_xColumns.is() )
          fillColumns();
      if ( m_xColumns.is() && m_xColumns->hasByName(_sColumnName) )
      {
          uno::Reference< beans::XPropertySet> xColumn(m_xColumns->getByName(_sColumnName),uno::UNO_QUERY);
          if ( xColumn.is() )
              xColumn->getPropertyValue(PROPERTY_TYPE"Type") >>= nDataType;
      }
  }
  catch(uno::Exception&)
  {
      OSL_FAIL("Exception caught while getting the type of a column")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/reportdesign/source/ui/dlg/GroupsSorting.cxx"
 ":" "924" ": "), "%s", "Exception caught while getting the type of a column"
); } } while (false);
  }

  return nDataType;
928}

930IMPL_LINK_NOARG(OGroupsSortingDialog, OnControlFocusGot, weld::Widget&, void )void OGroupsSortingDialog::LinkStubOnControlFocusGot(void * instance
, weld::Widget& data) { return static_cast<OGroupsSortingDialog
 *>(instance)->OnControlFocusGot(data); } void OGroupsSortingDialog
::OnControlFocusGot(__attribute__ ((unused)) weld::Widget&
)
931{
  m_xHelpWindow->set_label(RptResId(STR_RPT_HELP_FIELDreinterpret_cast<char const *>("STR_RPT_HELP_FIELD" "\004"
 u8"Select a field or type an expression to sort or group on."
)));
933}

935IMPL_LINK(OGroupsSortingDialog, OnWidgetFocusGot, weld::Widget&, rControl, void )void OGroupsSortingDialog::LinkStubOnWidgetFocusGot(void * instance
, weld::Widget& data) { return static_cast<OGroupsSortingDialog
 *>(instance)->OnWidgetFocusGot(data); } void OGroupsSortingDialog
::OnWidgetFocusGot(weld::Widget& rControl)
936{
  const std::pair<weld::Widget*, const char*> pControls[] = {
      { m_xHeaderLst.get(), STR_RPT_HELP_HEADERreinterpret_cast<char const *>("STR_RPT_HELP_HEADER" "\004"
 u8"Display a header for this group?") },
      { m_xFooterLst.get(), STR_RPT_HELP_FOOTERreinterpret_cast<char const *>("STR_RPT_HELP_FOOTER" "\004"
 u8"Display a footer for this group?") },
      { m_xGroupOnLst.get(), STR_RPT_HELP_GROUPONreinterpret_cast<char const *>("STR_RPT_HELP_GROUPON" "\004"
 u8"Select the value or range of values that starts a new group."
) },
      { m_xGroupIntervalEd.get(), STR_RPT_HELP_INTERVALreinterpret_cast<char const *>("STR_RPT_HELP_INTERVAL" "\004"
 u8"Interval or number of characters to group on.") },
      { m_xKeepTogetherLst.get(), STR_RPT_HELP_KEEPreinterpret_cast<char const *>("STR_RPT_HELP_KEEP" "\004"
 u8"Keep group together on one page?") },
      { m_xOrderLst.get(), STR_RPT_HELP_SORTreinterpret_cast<char const *>("STR_RPT_HELP_SORT" "\004"
 u8"Select ascending or descending sort order. Ascending means from A to Z or 0 to 9"
) }
  };
  for (size_t i = 0; i < SAL_N_ELEMENTS(pControls)(sizeof(sal_n_array_size(pControls))); ++i)
  {
      if (&rControl == pControls[i].first)
      {
          weld::ComboBox* pListBox = dynamic_cast<weld::ComboBox*>( &rControl );
          if ( pListBox )
              pListBox->save_value();
          weld::SpinButton* pNumericField = dynamic_cast<weld::SpinButton*>(&rControl);
          if ( pNumericField )
              pNumericField->save_value();
          //shows the text given by the id in the multiline edit
          m_xHelpWindow->set_label(RptResId(pControls[i].second));
          break;
      }
  }
960}

962IMPL_LINK_NOARG(OGroupsSortingDialog, OnWidgetFocusLost, weld::Widget&, void)void OGroupsSortingDialog::LinkStubOnWidgetFocusLost(void * instance
, weld::Widget& data) { return static_cast<OGroupsSortingDialog
 *>(instance)->OnWidgetFocusLost(data); } void OGroupsSortingDialog
::OnWidgetFocusLost(__attribute__ ((unused)) weld::Widget&
)
963{
  if (m_xFieldExpression)
  {
      if (m_xGroupIntervalEd->get_value_changed_from_saved())
          SaveData(m_xFieldExpression->GetCurRow());
  }
969}

971IMPL_LINK(OGroupsSortingDialog, OnFormatAction, const OString&, rCommand, void)void OGroupsSortingDialog::LinkStubOnFormatAction(void * instance
, const OString& data) { return static_cast<OGroupsSortingDialog
 *>(instance)->OnFormatAction(data); } void OGroupsSortingDialog
::OnFormatAction(const OString& rCommand)
972{
  if ( !m_xFieldExpression )
      return;

  long nIndex = m_xFieldExpression->GetCurrRow();
  sal_Int32 nGroupPos = m_xFieldExpression->getGroupPosition(nIndex);
  uno::Sequence<uno::Any> aClipboardList;
  if ( nIndex >= 0 && nGroupPos != NO_GROUP-1 )
  {
      aClipboardList.realloc(1);
      aClipboardList[0] = m_xGroups->getByIndex(nGroupPos);
  }
  if (rCommand == "up")
  {
      --nIndex;
  }
  if (rCommand == "down")
  {
      ++nIndex;
  }
  if (rCommand == "delete")
  {
      Application::PostUserEvent(LINK(m_xFieldExpression, OFieldExpressionControl, DelayedDelete)::tools::detail::makeLink( ::tools::detail::castTo<OFieldExpressionControl
 *>(m_xFieldExpression), &OFieldExpressionControl::LinkStubDelayedDelete
));
  }
  else
  {
      if ( nIndex >= 0 && aClipboardList.hasElements() )
      {
          m_xFieldExpression->SetNoSelection();
          m_xFieldExpression->moveGroups(aClipboardList,nIndex,false);
          m_xFieldExpression->DeactivateCell();
          m_xFieldExpression->GoToRow(nIndex);
          m_xFieldExpression->ActivateCell(nIndex, m_xFieldExpression->GetCurColumnId());
          DisplayData(nIndex);
      }
  }
1008}

1010IMPL_LINK( OGroupsSortingDialog, LBChangeHdl, weld::ComboBox&, rListBox, void )void OGroupsSortingDialog::LinkStubLBChangeHdl(void * instance
, weld::ComboBox& data) { return static_cast<OGroupsSortingDialog
 *>(instance)->LBChangeHdl(data); } void OGroupsSortingDialog
::LBChangeHdl(weld::ComboBox& rListBox)
1011{
  if ( !rListBox.get_value_changed_from_saved() )
      return;

  sal_Int32 nRow = m_xFieldExpression->GetCurRow();
  sal_Int32 nGroupPos = m_xFieldExpression->getGroupPosition(nRow);
  if (&rListBox != m_xHeaderLst.get() && &rListBox != m_xFooterLst.get())
  {
      if ( rListBox.get_value_changed_from_saved() )
          SaveData(nRow);
      if ( &rListBox == m_xGroupOnLst.get() )
          m_xGroupIntervalEd->set_sensitive(rListBox.get_active() != 0);
  }
  else if ( nGroupPos != NO_GROUP-1 )
  {
      uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
      uno::Sequence< beans::PropertyValue > aArgs(2);
      aArgs[1].Name = PROPERTY_GROUP"Group";
      aArgs[1].Value <<= xGroup;

      if ( m_xHeaderLst.get() == &rListBox )
          aArgs[0].Name = PROPERTY_HEADERON"HeaderOn";
      else
          aArgs[0].Name = PROPERTY_FOOTERON"FooterOn";

      aArgs[0].Value <<= rListBox.get_active() == 0;
      m_pController->executeChecked(m_xHeaderLst.get() == &rListBox ? SID_GROUPHEADER( ((((((((((10000 + 1499) + 1) + 499) + 1) + 100) + 1) + 149)
 + 1) + 200) + 1) + 14 ) : SID_GROUPFOOTER( ((((((((((10000 + 1499) + 1) + 499) + 1) + 100) + 1) + 149)
 + 1) + 200) + 1) + 16 ), aArgs);
      m_xFieldExpression->InvalidateHandleColumn();
  }
1040}

1042void OGroupsSortingDialog::_propertyChanged(const beans::PropertyChangeEvent& _rEvent)
1043{
  uno::Reference< report::XGroup > xGroup(_rEvent.Source,uno::UNO_QUERY);
  if ( xGroup.is() )
      displayGroup(xGroup);
  else
      fillColumns();
1049}

1051void OGroupsSortingDialog::fillColumns()
1052{
  m_xColumns = m_pController->getColumns();
  m_xFieldExpression->fillColumns(m_xColumns);
1055}

1057void OGroupsSortingDialog::displayGroup(const uno::Reference<report::XGroup>& _xGroup)
1058{
  m_xHeaderLst->set_active(_xGroup->getHeaderOn() ? 0 : 1 );
  m_xFooterLst->set_active(_xGroup->getFooterOn() ? 0 : 1 );
  sal_Int32 nDataType = getColumnDataType(_xGroup->getExpression());

  // first clear whole group on list
  while (m_xGroupOnLst->get_count() > 1 )
  {
      m_xGroupOnLst->remove(1);
  }

  switch(nDataType)
  {
      case sdbc::DataType::LONGVARCHAR:
      case sdbc::DataType::VARCHAR:
      case sdbc::DataType::CHAR:
          m_xGroupOnLst->append(OUString::number(report::GroupOn::PREFIX_CHARACTERS), RptResId(STR_RPT_PREFIXCHARSreinterpret_cast<char const *>("STR_RPT_PREFIXCHARS" "\004"
 u8"Prefix Characters")));
          break;
      case sdbc::DataType::DATE:
      case sdbc::DataType::TIME:
      case sdbc::DataType::TIMESTAMP:
          {
              const char* aIds[] = { STR_RPT_YEARreinterpret_cast<char const *>("STR_RPT_YEAR" "\004" u8"Year"
), STR_RPT_QUARTERreinterpret_cast<char const *>("STR_RPT_QUARTER" "\004"
 u8"Quarter"),STR_RPT_MONTHreinterpret_cast<char const *>("STR_RPT_MONTH" "\004" u8"Month"
),STR_RPT_WEEKreinterpret_cast<char const *>("STR_RPT_WEEK" "\004" u8"Week"
),STR_RPT_DAYreinterpret_cast<char const *>("STR_RPT_DAY" "\004" u8"Day"
),STR_RPT_HOURreinterpret_cast<char const *>("STR_RPT_HOUR" "\004" u8"Hour"
),STR_RPT_MINUTEreinterpret_cast<char const *>("STR_RPT_MINUTE" "\004" u8"Minute"
) };
              for (size_t i = 0; i < SAL_N_ELEMENTS(aIds)(sizeof(sal_n_array_size(aIds))); ++i)
              {
                  m_xGroupOnLst->append(OUString::number(i+2), RptResId(aIds[i]));
              }
          }
          break;
      default:
          m_xGroupOnLst->append(OUString::number(report::GroupOn::INTERVAL), RptResId(STR_RPT_INTERVALreinterpret_cast<char const *>("STR_RPT_INTERVAL" "\004"
 u8"Interval")));
          break;
  }
  sal_Int32 nPos = 0;
  switch(_xGroup->getGroupOn())
  {
      case report::GroupOn::DEFAULT:
          nPos = 0;
          break;
      case report::GroupOn::PREFIX_CHARACTERS:
          nPos = 1;
          break;
      case report::GroupOn::YEAR:
          nPos = 1;
          break;
      case report::GroupOn::QUARTAL:
          nPos = 2;
          break;
      case report::GroupOn::MONTH:
          nPos = 3;
          break;
      case report::GroupOn::WEEK:
          nPos = 4;
          break;
      case report::GroupOn::DAY:
          nPos = 5;
          break;
      case report::GroupOn::HOUR:
          nPos = 6;
          break;
      case report::GroupOn::MINUTE:
          nPos = 7;
          break;
      case report::GroupOn::INTERVAL:
          nPos = 1;
          break;
      default:
          nPos = 0;
  }
  m_xGroupOnLst->set_active(nPos);
  m_xGroupIntervalEd->set_value(_xGroup->getGroupInterval());
  m_xGroupIntervalEd->save_value();
  m_xGroupIntervalEd->set_sensitive( nPos != 0 );
  m_xKeepTogetherLst->set_active(_xGroup->getKeepTogether());
  m_xOrderLst->set_active(_xGroup->getSortAscending() ? 0 : 1);

  weld::ComboBox* pControls[] = { m_xHeaderLst.get(), m_xFooterLst.get(), m_xGroupOnLst.get(),
                                  m_xKeepTogetherLst.get(), m_xOrderLst.get() };
  for (weld::ComboBox* pControl : pControls)
      pControl->save_value();

  bool bReadOnly = !m_pController->isEditable();
  for (weld::ComboBox* pControl : pControls)
      pControl->set_sensitive(!bReadOnly);
  m_xGroupIntervalEd->set_editable(!bReadOnly);
1143}

1145void OGroupsSortingDialog::checkButtons(sal_Int32 _nRow)
1146{
  sal_Int32 nGroupCount = m_xGroups->getCount();
  sal_Int32 nRowCount = m_xFieldExpression->GetRowCount();
  bool bEnabled = nGroupCount > 1;

  if (bEnabled && _nRow > 0 )
  {
      m_xToolBox->set_item_sensitive("up", true);
  }
  else
  {
      m_xToolBox->set_item_sensitive("up", false);
  }
  if (bEnabled && _nRow < (nRowCount - 1) )
  {
      m_xToolBox->set_item_sensitive("down", true);
  }
  else
  {
      m_xToolBox->set_item_sensitive("down", false);
  }

  sal_Int32 nGroupPos = m_xFieldExpression->getGroupPosition(_nRow);
  if ( nGroupPos != NO_GROUP-1 )
  {
      bool bEnableDelete = nGroupCount > 0;
      m_xToolBox->set_item_sensitive("delete", bEnableDelete);
  }
  else
  {
      m_xToolBox->set_item_sensitive("delete", false);
  }
1178}

1180} // rptui

1182/* 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);
3
←
Calling copy constructor for 'Reference<rptui::OFieldExpressionControl>'→
6
←
Returning from copy constructor for 'Reference<rptui::OFieldExpressionControl>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
7
←
Calling 'Reference::clear'→
14
←
Returning; memory was released→
      if (aTmp.get()) {
15
←
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)
4
←
Assuming field 'm_pBody' is non-null→
5
←
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_pBody7.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
)
8
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
9
←
Calling 'VclReferenceBase::release'→
13
←
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;
16
←
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)
10
←
Assuming the condition is true→
11
←
Taking true branch→
40            delete this;
12
←
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