/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 TEditControl.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 DBACCESS_DLLIMPLEMENTATION -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/unixODBC/inc -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/dbaccess/inc -I /home/maarten/src/libreoffice/core/dbaccess/source/inc -I /home/maarten/src/libreoffice/core/dbaccess/source/ui/inc -I /home/maarten/src/libreoffice/core/workdir/YaccTarget/connectivity/source/parse -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 -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/dbaccess/source/ui/tabledesign/TEditControl.cxx

/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.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 "TEditControl.hxx"
21#include <com/sun/star/sdbc/ColumnValue.hpp>
22#include <com/sun/star/sdbc/SQLException.hpp>
23#include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
24#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
25#include <com/sun/star/util/XNumberFormatTypes.hpp>
26#include <core_resource.hxx>
27#include <strings.hrc>
28#include <strings.hxx>
29#include <helpids.h>
30#include <comphelper/types.hxx>
31#include <FieldDescControl.hxx>
32#include <FieldDescriptions.hxx>
33#include "TableUndo.hxx"
34#include <TableController.hxx>
35#include <connectivity/dbmetadata.hxx>
36#include <connectivity/dbtools.hxx>
37#include <SqlNameEdit.hxx>
38#include <TableRowExchange.hxx>
39#include <sot/storage.hxx>
40#include <svx/svxids.hrc>
41#include <UITools.hxx>
42#include "TableFieldControl.hxx"
43#include <dsntypes.hxx>
44#include <vcl/builder.hxx>
45#include <vcl/commandevent.hxx>
46#include <vcl/menu.hxx>
47#include <vcl/svapp.hxx>

49using namespace ::dbaui;
50using namespace ::comphelper;
51using namespace ::svt;
52using namespace ::com::sun::star::uno;
53using namespace ::com::sun::star::container;
54using namespace ::com::sun::star::io;
55using namespace ::com::sun::star::beans;
56using namespace ::com::sun::star::util;
57using namespace ::com::sun::star::lang;
58using namespace ::com::sun::star::sdbc;
59using namespace ::com::sun::star::sdbcx;
60using namespace ::com::sun::star::sdb;


63#define HANDLE_ID0       0

65// default field widths
66#define FIELDNAME_WIDTH100     100
67#define FIELDTYPE_WIDTH150     150
68#define FIELDDESCR_WIDTH300    300

70// Maximum length in description field
71#define MAX_DESCR_LEN256       256

73OTableEditorCtrl::ClipboardInvalidator::ClipboardInvalidator(OTableEditorCtrl* _pOwner)
m_pOwner(_pOwner)
75{

  m_aInvalidateTimer.SetTimeout(500);
  m_aInvalidateTimer.SetInvokeHandler(LINK(this, OTableEditorCtrl::ClipboardInvalidator, OnInvalidate)::tools::detail::makeLink( ::tools::detail::castTo<OTableEditorCtrl
::ClipboardInvalidator *>(this), &OTableEditorCtrl::ClipboardInvalidator
::LinkStubOnInvalidate));
  m_aInvalidateTimer.Start();
80}

82OTableEditorCtrl::ClipboardInvalidator::~ClipboardInvalidator()
83{
  m_aInvalidateTimer.Stop();
85}

87void OTableEditorCtrl::ClipboardInvalidator::Stop()
88{
  m_aInvalidateTimer.Stop();
90}

92IMPL_LINK_NOARG(OTableEditorCtrl::ClipboardInvalidator, OnInvalidate, Timer *, void)void OTableEditorCtrl::ClipboardInvalidator::LinkStubOnInvalidate
(void * instance, Timer * data) { return static_cast<OTableEditorCtrl
::ClipboardInvalidator *>(instance)->OnInvalidate(data)
; } void OTableEditorCtrl::ClipboardInvalidator::OnInvalidate
(__attribute__ ((unused)) Timer *)
93{
  m_pOwner->GetView()->getController().InvalidateFeature(SID_CUT(5000 + 710));
  m_pOwner->GetView()->getController().InvalidateFeature(SID_COPY(5000 + 711));
  m_pOwner->GetView()->getController().InvalidateFeature(SID_PASTE(5000 + 712));
97}

99void OTableEditorCtrl::Init()
100{
  OTableRowView::Init();

  // Should it be opened ReadOnly?
  bool bRead(GetView()->getController().isReadOnly());

  SetReadOnly( bRead );

  // Insert the columns
  InsertDataColumn( FIELD_NAME1, DBA_RES(STR_TAB_FIELD_COLUMN_NAME)::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_TAB_FIELD_COLUMN_NAME" "\004" u8"Field Name"
) ), FIELDNAME_WIDTH100 );

  InsertDataColumn( FIELD_TYPE2, DBA_RES(STR_TAB_FIELD_COLUMN_DATATYPE)::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_TAB_FIELD_COLUMN_DATATYPE" "\004" u8"Field Type"
) ), FIELDTYPE_WIDTH150 );

  ::dbaccess::ODsnTypeCollection aDsnTypes(GetView()->getController().getORB());
  bool bShowColumnDescription = aDsnTypes.supportsColumnDescription(::comphelper::getString(GetView()->getController().getDataSource()->getPropertyValue(PROPERTY_URL"URL")));
  InsertDataColumn( HELP_TEXT3, DBA_RES(STR_TAB_HELP_TEXT)::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_TAB_HELP_TEXT" "\004" u8"Description") ), bShowColumnDescription ? FIELDTYPE_WIDTH150 : FIELDDESCR_WIDTH300 );

  if ( bShowColumnDescription )
  {
      InsertDataColumn( COLUMN_DESCRIPTION4, DBA_RES(STR_COLUMN_DESCRIPTION)::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_COLUMN_DESCRIPTION" "\004" u8"Column Description"
) ), FIELDTYPE_WIDTH150 );
  }

  InitCellController();

  // Insert the rows
  RowInserted(0, m_pRowList->size());
126}

128OTableEditorCtrl::OTableEditorCtrl(vcl::Window* pWindow, OTableDesignView* pView)
  :OTableRowView(pWindow)
  ,m_pView(pView)
  ,pNameCell(nullptr)
  ,pTypeCell(nullptr)
  ,pHelpTextCell(nullptr)
  ,pDescrCell(nullptr)
  ,pDescrWin(nullptr)
  ,nCutEvent(nullptr)
  ,nPasteEvent(nullptr)
  ,nDeleteEvent(nullptr)
  ,nInsNewRowsEvent(nullptr)
  ,nInvalidateTypeEvent(nullptr)
  ,m_eChildFocus(NONE)
  ,nOldDataPos(-1)
  ,bReadOnly(true)
  ,m_aInvalidate(this)
145{
  SetHelpId(HID_TABDESIGN_BACKGROUND"DBACCESS_HID_TABDESIGN_BACKGROUND");
  GetDataWindow().SetHelpId(HID_CTL_TABLEEDIT"DBACCESS_HID_CTL_TABLEEDIT");

  m_pRowList = &GetView()->getController().getRows();
  m_nDataPos = 0;
151}

153SfxUndoManager& OTableEditorCtrl::GetUndoManager() const
154{
  return GetView()->getController().GetUndoManager();
156}


159void OTableEditorCtrl::SetReadOnly( bool bRead )
160{
  // nothing to do?
  if (bRead == IsReadOnly())
      // This check is important, as the underlying Def may be unnecessarily locked or unlocked
      // or worse, this action may not be reversed afterwards
      return;

  bReadOnly = bRead;

  // Disable active cells
  long nRow(GetCurRow());
  sal_uInt16 nCol(GetCurColumnId());
  DeactivateCell();

  // Select the correct Browsers cursor
  BrowserMode nMode(BrowserMode::COLUMNSELECTION | BrowserMode::MULTISELECTION | BrowserMode::KEEPHIGHLIGHT |
                    BrowserMode::HLINES      | BrowserMode::VLINES|BrowserMode::AUTOSIZE_LASTCOL);
  if( !bReadOnly )
      nMode |= BrowserMode::HIDECURSOR;
  SetMode(nMode);

  if( !bReadOnly )
      ActivateCell( nRow, nCol );
183}

185void OTableEditorCtrl::InitCellController()
186{
  // Cell Field name
  sal_Int32 nMaxTextLen = 0;
  OUString sExtraNameChars;
  Reference<XConnection> xCon;
  try
  {
      xCon = GetView()->getController().getConnection();
      Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();

      // length 0 is treated by Entry::set_max_length as unlimited
      nMaxTextLen = xMetaData.is() ? xMetaData->getMaxColumnNameLength() : 0;

      sExtraNameChars = xMetaData.is() ? xMetaData->getExtraNameCharacters() : OUString();

  }
  catch(SQLException&)
  {
      OSL_FAIL("getMaxColumnNameLength")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "204" ": "), "%s", "getMaxColumnNameLength"); } } while (
false);
  }

  pNameCell = VclPtr<OSQLNameEditControl>::Create(&GetDataWindow(), sExtraNameChars);
  pNameCell->get_widget().set_max_length(nMaxTextLen);
  pNameCell->setCheck( isSQL92CheckEnabled(xCon) );

  // Cell type
  pTypeCell = VclPtr<ListBoxControl>::Create( &GetDataWindow() );

  // Cell description
  pDescrCell = VclPtr<EditControl>::Create(&GetDataWindow());
  pDescrCell->get_widget().set_max_length(MAX_DESCR_LEN256);

  pHelpTextCell = VclPtr<EditControl>::Create(&GetDataWindow());
  pHelpTextCell->get_widget().set_max_length(MAX_DESCR_LEN256);

  pNameCell->SetHelpId(HID_TABDESIGN_NAMECELL"DBACCESS_HID_TABDESIGN_NAMECELL");
  pTypeCell->SetHelpId(HID_TABDESIGN_TYPECELL"DBACCESS_HID_TABDESIGN_TYPECELL");
  pDescrCell->SetHelpId(HID_TABDESIGN_COMMENTCELL"DBACCESS_HID_TABDESIGN_COMMENTCELL");
  pHelpTextCell->SetHelpId(HID_TABDESIGN_HELPTEXT"DBACCESS_HID_TABDESIGN_HELPTEXT");

  Size aHeight;
  const Control* pControls[] = { pTypeCell,pDescrCell,pNameCell,pHelpTextCell};
  for(const Control* pControl : pControls)
  {
      const Size aTemp(pControl->GetOptimalSize());
      if ( aTemp.Height() > aHeight.Height() )
          aHeight.setHeight( aTemp.Height() );
  }
  SetDataRowHeight(aHeight.Height());

  ClearModified();
237}

239void OTableEditorCtrl::ClearModified()
240{
  pNameCell->get_widget().save_value();
  pDescrCell->get_widget().save_value();
  pHelpTextCell->get_widget().save_value();
  pTypeCell->get_widget().save_value();
245}

247OTableEditorCtrl::~OTableEditorCtrl()
248{
  disposeOnce();
250}

252void OTableEditorCtrl::dispose()
253{
  // Reset the Undo-Manager
  GetUndoManager().Clear();

  m_aInvalidate.Stop();

  // Take possible Events from the queue
  if( nCutEvent )
1
Assuming field 'nCutEvent' is null→
2
←
Taking false branch→
      Application::RemoveUserEvent( nCutEvent );
  if( nPasteEvent )
3
←
Assuming field 'nPasteEvent' is null→
4
←
Taking false branch→
      Application::RemoveUserEvent( nPasteEvent );
  if( nDeleteEvent )
5
←
Assuming field 'nDeleteEvent' is null→
6
←
Taking false branch→
      Application::RemoveUserEvent( nDeleteEvent );
  if( nInsNewRowsEvent )
7
←
Assuming field 'nInsNewRowsEvent' is null→
8
←
Taking false branch→
      Application::RemoveUserEvent( nInsNewRowsEvent );
  if( nInvalidateTypeEvent )
9
←
Assuming field 'nInvalidateTypeEvent' is null→
10
←
Taking false branch→
      Application::RemoveUserEvent( nInvalidateTypeEvent );

  // Delete the control types
  pNameCell.disposeAndClear();
  pTypeCell.disposeAndClear();
  pDescrCell.disposeAndClear();
11
←
Calling 'VclPtr::disposeAndClear'→
  pHelpTextCell.disposeAndClear();
  pDescrWin = nullptr;
  m_pView.clear();
  OTableRowView::dispose();
279}

281bool OTableEditorCtrl::SetDataPtr( long nRow )
282{
  if(nRow == -1)
      return false;

  OSL_ENSURE(nRow < static_cast<long>(m_pRowList->size()),"Row is greater than size!")do { if (true && (!(nRow < static_cast<long>
(m_pRowList->size())))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "286" ": "), "%s", "Row is greater than size!"); } } while
 (false);
  if(nRow >= static_cast<long>(m_pRowList->size()))
      return false;
  pActRow = (*m_pRowList)[nRow];
  return pActRow != nullptr;
291}

293bool OTableEditorCtrl::SeekRow(long _nRow)
294{
  // Call the Base class to remember which row must be repainted
  EditBrowseBox::SeekRow(_nRow);

  m_nCurrentPos = _nRow;
  return SetDataPtr(_nRow);
300}

302void OTableEditorCtrl::PaintCell(OutputDevice& rDev, const tools::Rectangle& rRect,
                                 sal_uInt16 nColumnId ) const
304{
  const OUString aText( GetCellText( m_nCurrentPos, nColumnId ));

  rDev.Push( PushFlags::CLIPREGION );
  rDev.SetClipRegion(vcl::Region(rRect));
  rDev.DrawText( rRect, aText, DrawTextFlags::Left | DrawTextFlags::VCenter );
  rDev.Pop();
311}

313CellController* OTableEditorCtrl::GetController(long nRow, sal_uInt16 nColumnId)
314{
  // If EditorCtrl is ReadOnly, editing is forbidden
  Reference<XPropertySet> xTable = GetView()->getController().getTable();
  if (IsReadOnly() || (   xTable.is() &&
                          xTable->getPropertySetInfo()->hasPropertyByName(PROPERTY_TYPE"Type") &&
                          ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE"Type")) == "VIEW"))
      return nullptr;

  // If the row is ReadOnly, editing is forbidden
  SetDataPtr( nRow );
  if( pActRow->IsReadOnly() )
      return nullptr;

  OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
  switch (nColumnId)
  {
      case FIELD_NAME1:
          return new EditCellController( pNameCell );
      case FIELD_TYPE2:
          if (pActFieldDescr && !pActFieldDescr->GetName().isEmpty())
              return new ListBoxCellController( pTypeCell );
          else return nullptr;
      case HELP_TEXT3:
          if (pActFieldDescr && !pActFieldDescr->GetName().isEmpty())
              return new EditCellController( pHelpTextCell );
          else
              return nullptr;
      case COLUMN_DESCRIPTION4:
          if (pActFieldDescr && !pActFieldDescr->GetName().isEmpty())
              return new EditCellController( pDescrCell );
          else
              return nullptr;
      default:
          return nullptr;
  }
349}

351void OTableEditorCtrl::InitController(CellControllerRef&, long nRow, sal_uInt16 nColumnId)
352{
  SeekRow( nRow == -1 ? GetCurRow() : nRow);
  OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
  OUString aInitString;

  switch (nColumnId)
  {
      case FIELD_NAME1:
      {
          if( pActFieldDescr )
              aInitString = pActFieldDescr->GetName();

          weld::Entry& rEntry = pNameCell->get_widget();
          rEntry.set_text(aInitString);
          rEntry.save_value();
          break;
      }
      case FIELD_TYPE2:
          {
              if ( pActFieldDescr && pActFieldDescr->getTypeInfo() )
                  aInitString = pActFieldDescr->getTypeInfo()->aUIName;

              // Set the ComboBox contents
              weld::ComboBox& rTypeList = pTypeCell->get_widget();
              rTypeList.clear();
              if( !pActFieldDescr )
                  break;

              const OTypeInfoMap& rTypeInfo = GetView()->getController().getTypeInfo();
              for (auto const& elem : rTypeInfo)
                  rTypeList.append_text(elem.second->aUIName);
              rTypeList.set_active_text(aInitString);
          }

          break;
      case HELP_TEXT3:
      {
          if( pActFieldDescr )
              aInitString = pActFieldDescr->GetHelpText();
          weld::Entry& rEntry = pHelpTextCell->get_widget();
          rEntry.set_text(aInitString);
          rEntry.save_value();
          break;
      }
      case COLUMN_DESCRIPTION4:
      {
          if( pActFieldDescr )
              aInitString = pActFieldDescr->GetDescription();
          weld::Entry& rEntry = pDescrCell->get_widget();
          rEntry.set_text(aInitString);
          rEntry.save_value();
          break;
      }
  }
406}

408EditBrowseBox::RowStatus OTableEditorCtrl::GetRowStatus(long nRow) const
409{
  const_cast<OTableEditorCtrl*>(this)->SetDataPtr( nRow );
  if( !pActRow )
      return EditBrowseBox::CLEAN;
  if (nRow >= 0 && nRow == m_nDataPos)
  {
      if( pActRow->IsPrimaryKey() )
          return EditBrowseBox::CURRENT_PRIMARYKEY;
      return EditBrowseBox::CURRENT;
  }
  else
  {
      if( pActRow->IsPrimaryKey() )
          return EditBrowseBox::PRIMARYKEY;
      return EditBrowseBox::CLEAN;
  }
425}

427void OTableEditorCtrl::SaveCurRow()
428{
  if (GetFieldDescr(GetCurRow()) == nullptr)
      // there is no data in the current row
      return;
  if (!SaveModified())
      return;

  SetDataPtr(GetCurRow());
  pDescrWin->SaveData( pActRow->GetActFieldDescr() );
437}

439void OTableEditorCtrl::DisplayData(long nRow)
440{
  // go to the correct cell
  SetDataPtr(nRow);

  // Disable Edit-Mode temporarily
  bool bWasEditing = IsEditing();
  if (bWasEditing)
      DeactivateCell();

  CellControllerRef aTemp;
  InitController(aTemp, nRow, FIELD_NAME1);
  InitController(aTemp, nRow, FIELD_TYPE2);
  InitController(aTemp, nRow, COLUMN_DESCRIPTION4);
  InitController(aTemp, nRow, HELP_TEXT3);

  GoToRow(nRow);
  // Update the Description-Window
  GetView()->GetDescWin()->DisplayData(GetFieldDescr(nRow));
  // redraw the row
  RowModified(nRow);

  // and re-enable edit mode
  ActivateCell(nRow, GetCurColumnId());
463}

465void OTableEditorCtrl::CursorMoved()
466{
  // New line?
  m_nDataPos = GetCurRow();
  if( m_nDataPos != nOldDataPos && m_nDataPos != -1)
  {
      CellControllerRef aTemp;
      InitController(aTemp,m_nDataPos,FIELD_NAME1);
      InitController(aTemp,m_nDataPos,FIELD_TYPE2);
      InitController(aTemp,m_nDataPos,COLUMN_DESCRIPTION4);
      InitController(aTemp,m_nDataPos,HELP_TEXT3);
  }

  OTableRowView::CursorMoved();
479}

481sal_Int32 OTableEditorCtrl::HasFieldName( const OUString& rFieldName )
482{

  Reference<XConnection> xCon = GetView()->getController().getConnection();
  Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();

  ::comphelper::UStringMixEqual bCase(!xMetaData.is() || xMetaData->supportsMixedCaseQuotedIdentifiers());

  sal_Int32 nCount(0);
  for (auto const& row : *m_pRowList)
  {
      OFieldDescription* pFieldDescr = row->GetActFieldDescr();
      if( pFieldDescr && bCase(rFieldName,pFieldDescr->GetName()))
          nCount++;
  }
  return nCount;
497}

499void OTableEditorCtrl::SaveData(long nRow, sal_uInt16 nColId)
500{
  // Store the cell content
  SetDataPtr( nRow == -1 ? GetCurRow() : nRow);
  OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();

  switch( nColId)
  {
      // Store NameCell
      case FIELD_NAME1:
      {
          // If there is no name, do nothing
          weld::Entry& rEntry = pNameCell->get_widget();
          const OUString aName(rEntry.get_text());

          if( aName.isEmpty() )
          {
              // If FieldDescr exists, the field is deleted and the old content restored
              if (pActFieldDescr)
              {
                  GetUndoManager().AddUndoAction(std::make_unique<OTableEditorTypeSelUndoAct>(this, nRow, FIELD_TYPE2, pActFieldDescr->getTypeInfo()));
                  SwitchType(TOTypeInfoSP());
                  pActFieldDescr = pActRow->GetActFieldDescr();
              }
              else
                  return;
          }
          if(pActFieldDescr)
              pActFieldDescr->SetName( aName );
          rEntry.save_value();

          break;
      }

      // Store the field type
      case FIELD_TYPE2:
          break;

      // Store DescrCell
      case HELP_TEXT3:
      {
          // if the current field description is NULL, set Default
          weld::Entry& rEntry = pHelpTextCell->get_widget();
          if( !pActFieldDescr )
          {
              rEntry.set_text(OUString());
              rEntry.save_value();
          }
          else
              pActFieldDescr->SetHelpText(rEntry.get_text());
          break;
      }
      case COLUMN_DESCRIPTION4:
      {
          // Set the default if the field description is null
          weld::Entry& rEntry = pDescrCell->get_widget();
          if( !pActFieldDescr )
          {
              rEntry.set_text(OUString());
              rEntry.save_value();
          }
          else
              pActFieldDescr->SetDescription(rEntry.get_text());
          break;
      }
      case FIELD_PROPERTY_DEFAULT8:
      case FIELD_PROPERTY_REQUIRED5:
      case FIELD_PROPERTY_TEXTLEN9:
      case FIELD_PROPERTY_NUMTYPE6:
      case FIELD_PROPERTY_AUTOINC7:
      case FIELD_PROPERTY_LENGTH10:
      case FIELD_PROPERTY_SCALE11:
      case FIELD_PROPERTY_BOOL_DEFAULT12:
          pDescrWin->SaveData(pActFieldDescr);

          if ( FIELD_PROPERTY_AUTOINC7 == nColId && pActFieldDescr->IsAutoIncrement() )
          {
              OTableController& rController = GetView()->getController();
              if ( rController.isAutoIncrementPrimaryKey() )
              {
                  pActFieldDescr->SetPrimaryKey( true );
                  InvalidateHandleColumn();
                  Invalidate();
              }
          }
          break;
  }
586}

588bool OTableEditorCtrl::SaveModified()
589{
  sal_uInt16 nColId = GetCurColumnId();

  switch( nColId )
  {
      // Field type
      case FIELD_TYPE2:
      {
          // Reset the type
          resetType();
      } break;
  }

  return true;
603}

605bool OTableEditorCtrl::CursorMoving(long nNewRow, sal_uInt16 nNewCol)
606{

  if (!EditBrowseBox::CursorMoving(nNewRow, nNewCol))
      return false;

  // Called after SaveModified(), current row is still the old one
  m_nDataPos = nNewRow;
  nOldDataPos = GetCurRow();

  // Reset the markers
  InvalidateStatusCell( nOldDataPos );
  InvalidateStatusCell( m_nDataPos );

  // Store the data from the Property window
  if( SetDataPtr(nOldDataPos) && pDescrWin)
      pDescrWin->SaveData( pActRow->GetActFieldDescr() );

  // Show new data in the Property window
  if( SetDataPtr(m_nDataPos) && pDescrWin)
      pDescrWin->DisplayData( pActRow->GetActFieldDescr() );

  return true;
628}

630IMPL_LINK_NOARG( OTableEditorCtrl, InvalidateFieldType, void*, void )void OTableEditorCtrl::LinkStubInvalidateFieldType(void * instance
, void* data) { return static_cast<OTableEditorCtrl *>(
instance)->InvalidateFieldType(data); } void OTableEditorCtrl
::InvalidateFieldType(__attribute__ ((unused)) void*)
631{
  nInvalidateTypeEvent = nullptr;
  Invalidate( GetFieldRectPixel(nOldDataPos, FIELD_TYPE2) );
634}

636void OTableEditorCtrl::CellModified( long nRow, sal_uInt16 nColId )
637{

  // If the description is null, use the default
  if(nRow == -1)
      nRow = GetCurRow();
  SetDataPtr( nRow );
  OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();

  OUString sActionDescription;
  switch ( nColId )
  {
  case FIELD_NAME1:    sActionDescription = DBA_RES( STR_CHANGE_COLUMN_NAME )::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_CHANGE_COLUMN_NAME" "\004" u8"change field name"
) ); break;
  case FIELD_TYPE2:    sActionDescription = DBA_RES( STR_CHANGE_COLUMN_TYPE )::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_CHANGE_COLUMN_TYPE" "\004" u8"change field type"
) ); break;
  case HELP_TEXT3:
  case COLUMN_DESCRIPTION4:   sActionDescription = DBA_RES( STR_CHANGE_COLUMN_DESCRIPTION )::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_CHANGE_COLUMN_DESCRIPTION" "\004" u8"change field description"
) ); break;
  default:            sActionDescription = DBA_RES( STR_CHANGE_COLUMN_ATTRIBUTE )::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_CHANGE_COLUMN_ATTRIBUTE" "\004" u8"change field attribute"
) ); break;
  }

  GetUndoManager().EnterListAction( sActionDescription, OUString(), 0, ViewShellId(-1) );
  if (!pActFieldDescr)
  {
      const OTypeInfoMap& rTypeInfoMap = GetView()->getController().getTypeInfo();
      if ( !rTypeInfoMap.empty() )
      {
          OTypeInfoMap::const_iterator aTypeIter = rTypeInfoMap.find(DataType::VARCHAR);
          if ( aTypeIter == rTypeInfoMap.end() )
              aTypeIter = rTypeInfoMap.begin();
          pActRow->SetFieldType( aTypeIter->second );
      }
      else
          pActRow->SetFieldType( GetView()->getController().getTypeInfoFallBack() );

      nInvalidateTypeEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, InvalidateFieldType)::tools::detail::makeLink( ::tools::detail::castTo<OTableEditorCtrl
 *>(this), &OTableEditorCtrl::LinkStubInvalidateFieldType
), nullptr, true );
      pActFieldDescr = pActRow->GetActFieldDescr();
      pDescrWin->DisplayData( pActFieldDescr );
      GetUndoManager().AddUndoAction( std::make_unique<OTableEditorTypeSelUndoAct>(this, nRow, nColId+1, TOTypeInfoSP()) );
  }

  if( nColId != FIELD_TYPE2 )
      GetUndoManager().AddUndoAction( std::make_unique<OTableDesignCellUndoAct>(this, nRow, nColId) );
  else
  {
      GetUndoManager().AddUndoAction(std::make_unique<OTableEditorTypeSelUndoAct>(this, GetCurRow(), nColId, GetFieldDescr(GetCurRow())->getTypeInfo()));
      resetType();
  }

  SaveData(nRow,nColId);
  // SaveData could create an undo action as well
  GetUndoManager().LeaveListAction();
  RowModified(nRow);

  // Set the Modify flag
  GetView()->getController().setModified( true );
  InvalidateFeatures();
691}

693void OTableEditorCtrl::resetType()
694{
  sal_Int32 nPos = pTypeCell->get_widget().get_active();
  if(nPos != -1)
      SwitchType( GetView()->getController().getTypeInfo(nPos) );
  else
      SwitchType(TOTypeInfoSP());
700}

702void OTableEditorCtrl::CellModified()
703{
  CellModified( GetCurRow(), GetCurColumnId() );
705}

707void OTableEditorCtrl::InvalidateFeatures()
708{
  GetView()->getController().InvalidateFeature(SID_UNDO(5000 + 701));
  GetView()->getController().InvalidateFeature(SID_REDO(5000 + 700));
  GetView()->getController().InvalidateFeature(SID_SAVEDOC(5000 + 505));
712}

714void OTableEditorCtrl::CopyRows()
715{
  // set to the right row and save it
  if( SetDataPtr(m_nDataPos) )
      pDescrWin->SaveData( pActRow->GetActFieldDescr() );

  // Copy selected rows to the ClipboardList
  std::shared_ptr<OTableRow>  pClipboardRow;
  std::shared_ptr<OTableRow>  pRow;
  std::vector< std::shared_ptr<OTableRow> > vClipboardList;
  vClipboardList.reserve(GetSelectRowCount());

  for( long nIndex=FirstSelectedRow(); nIndex != SFX_ENDOFSELECTION(-1); nIndex=NextSelectedRow() )
  {
      pRow = (*m_pRowList)[nIndex];
      OSL_ENSURE(pRow,"OTableEditorCtrl::CopyRows: Row is NULL!")do { if (true && (!(pRow))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "729" ": "), "%s", "OTableEditorCtrl::CopyRows: Row is NULL!"
); } } while (false);
      if ( pRow && pRow->GetActFieldDescr() )
      {
          pClipboardRow = std::make_shared<OTableRow>( *pRow );
          vClipboardList.push_back( pClipboardRow);
      }
  }
  if(!vClipboardList.empty())
  {
      rtl::Reference<OTableRowExchange> pData = new OTableRowExchange(vClipboardList);
      pData->CopyToClipboard(GetParent());
  }
741}

743OUString OTableEditorCtrl::GenerateName( const OUString& rName )
744{
  // Create a base name for appending numbers to
  OUString aBaseName;
  Reference<XConnection> xCon = GetView()->getController().getConnection();
  Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();

  sal_Int32 nMaxTextLen(xMetaData.is() ? xMetaData->getMaxColumnNameLength() : 0);

  if( (rName.getLength()+2) >nMaxTextLen )
      aBaseName = rName.copy( 0, nMaxTextLen-2 );
  else
      aBaseName = rName;

  // append a sequential number to the base name (up to 99)
  OUString aFieldName( rName);
  sal_Int32 i=1;
  while( HasFieldName(aFieldName) )
  {
      aFieldName = aBaseName + OUString::number(i);
      i++;
  }

  return aFieldName;
767}

769void OTableEditorCtrl::InsertRows( long nRow )
770{

  std::vector<  std::shared_ptr<OTableRow> > vInsertedUndoRedoRows; // need for undo/redo handling
  // get rows from clipboard
  TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
  if(aTransferData.HasFormat(SotClipboardFormatId::SBA_TABED))
  {
      ::tools::SvRef<SotStorageStream> aStreamRef;
      bool bOk = aTransferData.GetSotStorageStream(SotClipboardFormatId::SBA_TABED,aStreamRef);
      if (bOk && aStreamRef.is())
      {
          aStreamRef->Seek(STREAM_SEEK_TO_BEGIN0L);
          aStreamRef->ResetError();
          long nInsertRow = nRow;
          std::shared_ptr<OTableRow>  pRow;
          sal_Int32 nSize = 0;
          (*aStreamRef).ReadInt32( nSize );
          vInsertedUndoRedoRows.reserve(nSize);
          for(sal_Int32 i=0;i < nSize;++i)
          {
              pRow = std::make_shared<OTableRow>();
              ReadOTableRow( *aStreamRef, *pRow );
              pRow->SetReadOnly( false );
              sal_Int32 nType = pRow->GetActFieldDescr()->GetType();
              if ( pRow->GetActFieldDescr() )
                  pRow->GetActFieldDescr()->SetType(GetView()->getController().getTypeInfoByType(nType));
              // Adjust the field names
              pRow->GetActFieldDescr()->SetName( GenerateName( pRow->GetActFieldDescr()->GetName() ) );
              pRow->SetPos(nInsertRow);
              m_pRowList->insert( m_pRowList->begin()+nInsertRow,pRow );
              vInsertedUndoRedoRows.push_back(std::make_shared<OTableRow>(*pRow));
              nInsertRow++;
          }
      }
  }
  // RowInserted calls CursorMoved.
  // The UI data should not be stored here.
  RowInserted( nRow,vInsertedUndoRedoRows.size() );

  // Create the Undo-Action
  GetUndoManager().AddUndoAction( std::make_unique<OTableEditorInsUndoAct>(this, nRow,vInsertedUndoRedoRows) );
  GetView()->getController().setModified( true );
  InvalidateFeatures();
813}

815void OTableEditorCtrl::DeleteRows()
816{
  OSL_ENSURE(GetView()->getController().isDropAllowed(),"Call of DeleteRows not valid here. Please check isDropAllowed!")do { if (true && (!(GetView()->getController().isDropAllowed
()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "817" ": "), "%s", "Call of DeleteRows not valid here. Please check isDropAllowed!"
); } } while (false);
  // Create the Undo-Action
  GetUndoManager().AddUndoAction( std::make_unique<OTableEditorDelUndoAct>(this) );

  // Delete all marked rows
  long nIndex = FirstSelectedRow();
  nOldDataPos = nIndex;

  while( nIndex != SFX_ENDOFSELECTION(-1) )
  {
      // Remove rows
      m_pRowList->erase( m_pRowList->begin()+nIndex );
      RowRemoved( nIndex );

      // Insert the empty row at the end
      m_pRowList->push_back( std::make_shared<OTableRow>());
      RowInserted( GetRowCount()-1 );

      nIndex = FirstSelectedRow();
  }

  // Force the current record to be displayed
  m_nDataPos = GetCurRow();
  InvalidateStatusCell( nOldDataPos );
  InvalidateStatusCell( m_nDataPos );
  SetDataPtr( m_nDataPos );
  ActivateCell();
  pDescrWin->DisplayData( pActRow->GetActFieldDescr() );
  GetView()->getController().setModified( true );
  InvalidateFeatures();
847}

849void OTableEditorCtrl::InsertNewRows( long nRow )
850{
  OSL_ENSURE(GetView()->getController().isAddAllowed(),"Call of InsertNewRows not valid here. Please check isAppendAllowed!")do { if (true && (!(GetView()->getController().isAddAllowed
()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "851" ": "), "%s", "Call of InsertNewRows not valid here. Please check isAppendAllowed!"
); } } while (false);
  // Create Undo-Action
  long nInsertRows = GetSelectRowCount();
  if( !nInsertRows )
      nInsertRows = 1;
  GetUndoManager().AddUndoAction( std::make_unique<OTableEditorInsNewUndoAct>(this, nRow, nInsertRows) );
  // Insert the number of selected rows
  for( long i=nRow; i<(nRow+nInsertRows); i++ )
      m_pRowList->insert( m_pRowList->begin()+i ,std::make_shared<OTableRow>());
  RowInserted( nRow, nInsertRows );

  GetView()->getController().setModified( true );
  InvalidateFeatures();
864}

866void OTableEditorCtrl::SetControlText( long nRow, sal_uInt16 nColId, const OUString& rText )
867{
  // Set the Browser Controls
  if( nColId < FIELD_FIRST_VIRTUAL_COLUMN5 )
  {
      GoToRow( nRow );
      GoToColumnId( nColId );
      CellControllerRef xController = Controller();
      if(xController.is())
          xController->GetWindow().SetText( rText );
      else
          RowModified(nRow,nColId);
  }

  // Set the Tabpage controls
  else
  {
      pDescrWin->SetControlText( nColId, rText );
  }
885}

887void OTableEditorCtrl::SetCellData( long nRow, sal_uInt16 nColId, const TOTypeInfoSP& _pTypeInfo )
888{
  // Relocate the current pointer
  if( nRow == -1 )
      nRow = GetCurRow();
  OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
  if( !pFieldDescr && nColId != FIELD_TYPE2)
      return;

  // Set individual fields
  switch( nColId )
  {
      case FIELD_TYPE2:
          SwitchType( _pTypeInfo );
          break;
      default:
          OSL_FAIL("OTableEditorCtrl::SetCellData: invalid column!")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "903" ": "), "%s", "OTableEditorCtrl::SetCellData: invalid column!"
); } } while (false);
  }
  SetControlText(nRow,nColId,_pTypeInfo ? _pTypeInfo->aUIName : OUString());
906}

908void OTableEditorCtrl::SetCellData( long nRow, sal_uInt16 nColId, const css::uno::Any& _rNewData )
909{
  // Relocate the current pointer
  if( nRow == -1 )
      nRow = GetCurRow();
  OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
  if( !pFieldDescr && nColId != FIELD_TYPE2)
      return;

  OUString sValue;
  // Set individual fields
  switch( nColId )
  {
      case FIELD_NAME1:
          sValue = ::comphelper::getString(_rNewData);
          pFieldDescr->SetName( sValue );
          break;

      case FIELD_TYPE2:
          OSL_FAIL("OTableEditorCtrl::SetCellData: invalid column!")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "927" ": "), "%s", "OTableEditorCtrl::SetCellData: invalid column!"
); } } while (false);
          break;

      case COLUMN_DESCRIPTION4:
          sValue = ::comphelper::getString(_rNewData);
          pFieldDescr->SetDescription( sValue );
          break;

      case FIELD_PROPERTY_DEFAULT8:
          pFieldDescr->SetControlDefault( _rNewData );
          sValue = GetView()->GetDescWin()->getGenPage()->getControlDefault(pFieldDescr);
          break;

      case FIELD_PROPERTY_REQUIRED5:
          {
              sValue = ::comphelper::getString(_rNewData);
              pFieldDescr->SetIsNullable( sValue.toInt32() );
          }
          break;

      case FIELD_PROPERTY_TEXTLEN9:
      case FIELD_PROPERTY_LENGTH10:
          {
              sValue = ::comphelper::getString(_rNewData);
              pFieldDescr->SetPrecision( sValue.toInt32() );
          }
          break;

      case FIELD_PROPERTY_NUMTYPE6:
          OSL_FAIL("OTableEditorCtrl::SetCellData: invalid column!")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "956" ": "), "%s", "OTableEditorCtrl::SetCellData: invalid column!"
); } } while (false);
          break;

      case FIELD_PROPERTY_AUTOINC7:
          {
              sValue = ::comphelper::getString(_rNewData);
              pFieldDescr->SetAutoIncrement(sValue == DBA_RES(STR_VALUE_YES)::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_VALUE_YES" "\004" u8"Yes") ));
          }
          break;
      case FIELD_PROPERTY_SCALE11:
          {
              sValue = ::comphelper::getString(_rNewData);
              pFieldDescr->SetScale(sValue.toInt32());
          }
          break;

      case FIELD_PROPERTY_BOOL_DEFAULT12:
          sValue = GetView()->GetDescWin()->BoolStringPersistent(::comphelper::getString(_rNewData));
          pFieldDescr->SetControlDefault(makeAny(sValue));
          break;

      case FIELD_PROPERTY_FORMAT13:
          {
              sValue = ::comphelper::getString(_rNewData);
              pFieldDescr->SetFormatKey(sValue.toInt32());
          }
          break;
  }

  SetControlText(nRow,nColId,sValue);
986}

988Any OTableEditorCtrl::GetCellData( long nRow, sal_uInt16 nColId )
989{
  OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
  if( !pFieldDescr )
      return Any();

  // Relocate the current pointer
  if( nRow==-1 )
      nRow = GetCurRow();
  SetDataPtr( nRow );

  static const OUString strYes(DBA_RES(STR_VALUE_YES)::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_VALUE_YES" "\004" u8"Yes") ));
  static const OUString strNo(DBA_RES(STR_VALUE_NO)::dbaccess::ResourceManager::loadString( reinterpret_cast<
char const *>("STR_VALUE_NO" "\004" u8"No") ));
  OUString sValue;
  // Read out the fields
  switch( nColId )
  {
      case FIELD_NAME1:
          sValue = pFieldDescr->GetName();
          break;

      case FIELD_TYPE2:
          if ( pFieldDescr->getTypeInfo() )
              sValue = pFieldDescr->getTypeInfo()->aUIName;
          break;

      case COLUMN_DESCRIPTION4:
          sValue = pFieldDescr->GetDescription();
          break;
      case HELP_TEXT3:
          sValue = pFieldDescr->GetHelpText();
          break;

      case FIELD_PROPERTY_DEFAULT8:
          return pFieldDescr->GetControlDefault();

      case FIELD_PROPERTY_REQUIRED5:
          sValue = pFieldDescr->GetIsNullable() == ColumnValue::NULLABLE ? strYes : strNo;
          break;

      case FIELD_PROPERTY_TEXTLEN9:
      case FIELD_PROPERTY_LENGTH10:
          sValue = OUString::number(pFieldDescr->GetPrecision());
          break;

      case FIELD_PROPERTY_NUMTYPE6:
          OSL_FAIL("OTableEditorCtrl::GetCellData: invalid column!")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "1034" ": "), "%s", "OTableEditorCtrl::GetCellData: invalid column!"
); } } while (false);
          break;

      case FIELD_PROPERTY_AUTOINC7:
          sValue = pFieldDescr->IsAutoIncrement() ? strYes : strNo;
          break;

      case FIELD_PROPERTY_SCALE11:
          sValue = OUString::number(pFieldDescr->GetScale());
          break;

      case FIELD_PROPERTY_BOOL_DEFAULT12:
          sValue = GetView()->GetDescWin()->BoolStringUI(::comphelper::getString(pFieldDescr->GetControlDefault()));
          break;

      case FIELD_PROPERTY_FORMAT13:
          sValue = OUString::number(pFieldDescr->GetFormatKey());
          break;
  }

  return makeAny(sValue);
1055}

1057OUString OTableEditorCtrl::GetCellText( long nRow, sal_uInt16 nColId ) const
1058{
  OUString sCellText;
  const_cast< OTableEditorCtrl* >( this )->GetCellData( nRow, nColId ) >>= sCellText;
  return sCellText;
1062}

1064sal_uInt32 OTableEditorCtrl::GetTotalCellWidth(long nRow, sal_uInt16 nColId)
1065{
  return GetTextWidth(GetCellText(nRow, nColId)) + 2 * GetTextWidth("0");
1067}

1069OFieldDescription* OTableEditorCtrl::GetFieldDescr( long nRow )
1070{
  std::vector< std::shared_ptr<OTableRow> >::size_type nListCount(
      m_pRowList->size());
  if( (nRow<0) || (sal::static_int_cast< unsigned long >(nRow)>=nListCount) )
  {
      OSL_FAIL("(nRow<0) || (nRow>=nListCount)")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/ui/tabledesign/TEditControl.cxx"
 ":" "1075" ": "), "%s", "(nRow<0) || (nRow>=nListCount)"
); } } while (false);
      return nullptr;
  }
  std::shared_ptr<OTableRow>  pRow = (*m_pRowList)[ nRow ];
  if( !pRow )
      return nullptr;
  return pRow->GetActFieldDescr();
1082}

1084bool OTableEditorCtrl::IsCutAllowed()
1085{
  bool bIsCutAllowed = (GetView()->getController().isAddAllowed() && GetView()->getController().isDropAllowed()) ||
                          GetView()->getController().isAlterAllowed();

  if (bIsCutAllowed)
  {
      int nStartPos, nEndPos;
      switch(m_eChildFocus)
      {
          case DESCRIPTION:
          {
              weld::Entry& rEntry = pDescrCell->get_widget();
              bIsCutAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
              break;
          }
          case HELPTEXT:
          {
              weld::Entry& rEntry = pHelpTextCell->get_widget();
              bIsCutAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
              break;
          }
          case NAME:
          {
              weld::Entry& rEntry = pNameCell->get_widget();
              bIsCutAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
              break;
          }
          case ROW:
              bIsCutAllowed = IsCopyAllowed();
              break;
          default:
              bIsCutAllowed = false;
              break;
      }
  }

  return bIsCutAllowed;
1122}

1124bool OTableEditorCtrl::IsCopyAllowed()
1125{
  bool bIsCopyAllowed = false;
  int nStartPos, nEndPos;
  if (m_eChildFocus == DESCRIPTION )
  {
      weld::Entry& rEntry = pDescrCell->get_widget();
      bIsCopyAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
  }
  else if(HELPTEXT == m_eChildFocus )
  {
      weld::Entry& rEntry = pHelpTextCell->get_widget();
      bIsCopyAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
  }
  else if(m_eChildFocus == NAME)
  {
      weld::Entry& rEntry = pNameCell->get_widget();
      bIsCopyAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
  }
  else if(m_eChildFocus == ROW)
  {
      Reference<XPropertySet> xTable = GetView()->getController().getTable();
      if( !GetSelectRowCount() || (xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE"Type")) == "VIEW"))
          return false;

      // If one of the selected rows is empty, Copy is not possible
      std::shared_ptr<OTableRow>  pRow;
      long nIndex = FirstSelectedRow();
      while( nIndex != SFX_ENDOFSELECTION(-1) )
      {
          pRow = (*m_pRowList)[nIndex];
          if( !pRow->GetActFieldDescr() )
              return false;

          nIndex = NextSelectedRow();
      }

      bIsCopyAllowed = true;
  }

  return bIsCopyAllowed;
1165}

1167bool OTableEditorCtrl::IsPasteAllowed() const
1168{
  bool bAllowed = GetView()->getController().isAddAllowed();
  if ( bAllowed )
  {
      TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
      bool bRowFormat = aTransferData.HasFormat(SotClipboardFormatId::SBA_TABED);
      if ( m_eChildFocus == ROW )
          bAllowed = bRowFormat;
      else
          bAllowed = !bRowFormat && aTransferData.HasFormat(SotClipboardFormatId::STRING);
  }

  return bAllowed;
1181}

1183void OTableEditorCtrl::cut()
1184{
  if(m_eChildFocus == NAME)
  {
      if(GetView()->getController().isAlterAllowed())
      {
          SaveData(-1,FIELD_NAME1);
          pNameCell->get_widget().cut_clipboard();
          CellModified(-1,FIELD_NAME1);
      }
  }
  else if(m_eChildFocus == DESCRIPTION)
  {
      if(GetView()->getController().isAlterAllowed())
      {
          SaveData(-1,COLUMN_DESCRIPTION4);
          pDescrCell->get_widget().cut_clipboard();
          CellModified(-1,COLUMN_DESCRIPTION4);
      }
  }
  else if(HELPTEXT == m_eChildFocus )
  {
      if(GetView()->getController().isAlterAllowed())
      {
          SaveData(-1,HELP_TEXT3);
          pHelpTextCell->get_widget().cut_clipboard();
          CellModified(-1,HELP_TEXT3);
      }
  }
  else if(m_eChildFocus == ROW)
  {
      if (nCutEvent)
          Application::RemoveUserEvent(nCutEvent);
      nCutEvent = Application::PostUserEvent(LINK(this, OTableEditorCtrl, DelayedCut)::tools::detail::makeLink( ::tools::detail::castTo<OTableEditorCtrl
 *>(this), &OTableEditorCtrl::LinkStubDelayedCut), nullptr, true);
  }
1218}

1220void OTableEditorCtrl::copy()
1221{
  if (GetSelectRowCount())
      OTableRowView::copy();
  else if(m_eChildFocus == NAME)
  {
      weld::Entry& rEntry = pNameCell->get_widget();
      rEntry.copy_clipboard();
  }
  else if(HELPTEXT == m_eChildFocus )
  {
      weld::Entry& rEntry = pHelpTextCell->get_widget();
      rEntry.copy_clipboard();
  }
  else if(m_eChildFocus == DESCRIPTION )
  {
      weld::Entry& rEntry = pDescrCell->get_widget();
      rEntry.copy_clipboard();
  }
1239}

1241void OTableEditorCtrl::paste()
1242{
  TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
  if(aTransferData.HasFormat(SotClipboardFormatId::SBA_TABED))
  {
      if( nPasteEvent )
          Application::RemoveUserEvent( nPasteEvent );
      nPasteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedPaste)::tools::detail::makeLink( ::tools::detail::castTo<OTableEditorCtrl
 *>(this), &OTableEditorCtrl::LinkStubDelayedPaste), nullptr, true );
  }
  else if(m_eChildFocus == NAME)
  {
      if(GetView()->getController().isAlterAllowed())
      {
          pNameCell->get_widget().paste_clipboard();
          CellModified();
      }
  }
  else if(HELPTEXT == m_eChildFocus )
  {
      if(GetView()->getController().isAlterAllowed())
      {
          pHelpTextCell->get_widget().paste_clipboard();
          CellModified();
      }
  }
  else if(m_eChildFocus == DESCRIPTION)
  {
      if(GetView()->getController().isAlterAllowed())
      {
          pDescrCell->get_widget().paste_clipboard();
          CellModified();
      }
  }
1274}

1276bool OTableEditorCtrl::IsDeleteAllowed()
1277{

  return GetSelectRowCount() != 0 && GetView()->getController().isDropAllowed();
1280}

1282bool OTableEditorCtrl::IsInsertNewAllowed( long nRow )
1283{

  bool bInsertNewAllowed = GetView()->getController().isAddAllowed();
  // If fields can be added, Paste in the new fields
  if (bInsertNewAllowed && !GetView()->getController().isDropAllowed())
  {
      SetDataPtr(nRow);
      if( GetActRow()->IsReadOnly() )
          return false;
  }

  return bInsertNewAllowed;
1295}

1297bool OTableEditorCtrl::IsPrimaryKeyAllowed()
1298{
  if( !GetSelectRowCount() )
      return false;

  OTableController& rController = GetView()->getController();
  if ( !rController.getSdbMetaData().supportsPrimaryKeys() )
      return false;

  Reference<XPropertySet> xTable = rController.getTable();
  // Key must not be changed
  // This applies only if the table is not new and not a  css::sdbcx::View. Otherwise no DROP is executed

  if(xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE"Type")) == "VIEW")
      return false;
  // If there is an empty field, no primary key
  // The entry is only permitted if
  // - there are no empty entries in the selection
  // - No Memo or Image entries
  // - DROP is not permitted (see above) and the column is not Required (not null flag is not set).
  long nIndex = FirstSelectedRow();
  std::shared_ptr<OTableRow>  pRow;
  while( nIndex != SFX_ENDOFSELECTION(-1) )
  {
      pRow = (*m_pRowList)[nIndex];
      OFieldDescription* pFieldDescr = pRow->GetActFieldDescr();
      if(!pFieldDescr)
          return false;
      else
      {
          // Memo and Image fields cannot be primary keys
          // or if the column cannot be dropped and the Required flag is not set
          // or if a css::sdbcx::View is available and the Required flag is not set
          const TOTypeInfoSP& pTypeInfo = pFieldDescr->getTypeInfo();
          if(     pTypeInfo->nSearchType == ColumnSearch::NONE
              || (pFieldDescr->IsNullable() && pRow->IsReadOnly())
            )
              return false;
      }

      nIndex = NextSelectedRow();
  }

  return true;
1341}

1343void OTableEditorCtrl::Command(const CommandEvent& rEvt)
1344{
  switch (rEvt.GetCommand())
  {
      case CommandEventId::ContextMenu:
      {
          Point aMenuPos( rEvt.GetMousePosPixel() );
          if (!rEvt.IsMouseEvent())
          {
              if  ( 1 == GetSelectColumnCount() )
              {
                  sal_uInt16 nSelId = GetColumnId(
                      sal::static_int_cast< sal_uInt16 >(
                          FirstSelectedColumn() ) );
                  ::tools::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, false ) );

                  aMenuPos = aColRect.TopCenter();
              }
              else if ( GetSelectRowCount() > 0 )
              {
                  ::tools::Rectangle aColRect( GetFieldRectPixel( FirstSelectedRow(), HANDLE_ID0 ) );

                  aMenuPos = aColRect.TopCenter();
              }
              else
              {
                  OTableRowView::Command(rEvt);
                  return;
              }
          }

          // Show the Context menu
          if( !IsReadOnly() )
          {
              sal_uInt16 nColId = GetColumnId(GetColumnAtXPosPixel(aMenuPos.X()));
              long   nRow = GetRowAtYPosPixel(aMenuPos.Y());

              if ( HANDLE_ID0 != nColId )
              {
                  if ( nRow < 0 && nColId != BROWSER_INVALIDID((sal_uInt16) 0xFFFF) )
                  {   // hit the header
                      if ( 3 != nColId )
                      {   // 3 would mean the last column, and this last column is auto-sized
                          if ( !IsColumnSelected( nColId ) )
                              SelectColumnId( nColId );

                          VclBuilder aBuilder(nullptr, AllSettings::GetUIRootDir(), "dbaccess/ui/querycolmenu.ui", "");
                          VclPtr<PopupMenu> aContextMenu(aBuilder.get_menu("menu"));
                          aContextMenu->EnableItem(aContextMenu->GetItemId("delete"), false);
                          aContextMenu->RemoveDisabledEntries(true, true);
                          if (aContextMenu->Execute(this, aMenuPos) == aContextMenu->GetItemId("width"))
                              adjustBrowseBoxColumnWidth( this, nColId );
                      }
                  }
              }
              else
              {
                  VclBuilder aBuilder(nullptr, AllSettings::GetUIRootDir(), "dbaccess/ui/tabledesignrowmenu.ui", "");
                  VclPtr<PopupMenu> aContextMenu(aBuilder.get_menu("menu"));

                  aContextMenu->EnableItem(aContextMenu->GetItemId("cut"), IsCutAllowed());
                  aContextMenu->EnableItem(aContextMenu->GetItemId("copy"), IsCopyAllowed());
                  aContextMenu->EnableItem(aContextMenu->GetItemId("paste"), IsPasteAllowed());
                  aContextMenu->EnableItem(aContextMenu->GetItemId("delete"), IsDeleteAllowed());
                  aContextMenu->EnableItem(aContextMenu->GetItemId("primarykey"), IsPrimaryKeyAllowed());
                  aContextMenu->EnableItem(aContextMenu->GetItemId("insert"), IsInsertNewAllowed(nRow));
                  aContextMenu->CheckItem("primarykey", IsRowSelected(GetCurRow()) && IsPrimaryKey());

                  // remove all the disable entries
                  aContextMenu->RemoveDisabledEntries(true, true);

                  if( SetDataPtr(m_nDataPos) )
                      pDescrWin->SaveData( pActRow->GetActFieldDescr() );

                  // All actions which change the number of rows must be run asynchronously
                  // otherwise there may be problems between the Context menu and the Browser
                  m_nDataPos = GetCurRow();
                  aContextMenu->Execute(this, aMenuPos);
                  OString sIdent = aContextMenu->GetCurItemIdent();
                  if (sIdent == "cut")
                      cut();
                  else if (sIdent == "copy")
                      copy();
                  else if (sIdent == "paste")
                      paste();
                  else if (sIdent == "delete")
                  {
                      if( nDeleteEvent )
                          Application::RemoveUserEvent( nDeleteEvent );
                      nDeleteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedDelete)::tools::detail::makeLink( ::tools::detail::castTo<OTableEditorCtrl
 *>(this), &OTableEditorCtrl::LinkStubDelayedDelete), nullptr, true );
                  }
                  else if (sIdent == "insert")
                  {
                      if( nInsNewRowsEvent )
                          Application::RemoveUserEvent( nInsNewRowsEvent );
                      nInsNewRowsEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedInsNewRows)::tools::detail::makeLink( ::tools::detail::castTo<OTableEditorCtrl
 *>(this), &OTableEditorCtrl::LinkStubDelayedInsNewRows
), nullptr, true );
                  }
                  else if (sIdent == "primarykey")
                  {
                      SetPrimaryKey( !IsPrimaryKey() );
                  }
              }
          }
      }
      break;
      default:
          OTableRowView::Command(rEvt);
  }

1452}

1454IMPL_LINK_NOARG( OTableEditorCtrl, DelayedCut, void*, void )void OTableEditorCtrl::LinkStubDelayedCut(void * instance, void
* data) { return static_cast<OTableEditorCtrl *>(instance
)->DelayedCut(data); } void OTableEditorCtrl::DelayedCut(__attribute__
 ((unused)) void*)
1455{
  nCutEvent = nullptr;
  OTableRowView::cut();
1458}

1460IMPL_LINK_NOARG( OTableEditorCtrl, DelayedPaste, void*, void )void OTableEditorCtrl::LinkStubDelayedPaste(void * instance, void
* data) { return static_cast<OTableEditorCtrl *>(instance
)->DelayedPaste(data); } void OTableEditorCtrl::DelayedPaste
(__attribute__ ((unused)) void*)
1461{
  nPasteEvent = nullptr;

  sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition();
  if ( !GetView()->getController().getTable().is() )
      nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : GetCurRow();

  if (!IsInsertNewAllowed(nPastePosition))
  {   // Insertion is not allowed, only appending, so test if there are full cells after the PastePosition

      auto aIter = std::find_if(m_pRowList->rbegin(), m_pRowList->rend(), [](const std::shared_ptr<OTableRow>& rxRow) {
          return rxRow && rxRow->GetActFieldDescr() && !rxRow->GetActFieldDescr()->GetName().isEmpty(); });
      auto nFreeFromPos = static_cast<sal_Int32>(std::distance(aIter, m_pRowList->rend())); // from here on there are only empty rows
      if (nPastePosition < nFreeFromPos)  // if at least one PastePosition is full, go right to the end
          nPastePosition = nFreeFromPos;
  }

  OTableRowView::Paste( nPastePosition );
  SetNoSelection();
  GoToRow( nPastePosition );
1481}

1483IMPL_LINK_NOARG( OTableEditorCtrl, DelayedDelete, void*, void )void OTableEditorCtrl::LinkStubDelayedDelete(void * instance,
 void* data) { return static_cast<OTableEditorCtrl *>(instance
)->DelayedDelete(data); } void OTableEditorCtrl::DelayedDelete
(__attribute__ ((unused)) void*)
1484{
  nDeleteEvent = nullptr;
  DeleteRows();
1487}

1489IMPL_LINK_NOARG( OTableEditorCtrl, DelayedInsNewRows, void*, void )void OTableEditorCtrl::LinkStubDelayedInsNewRows(void * instance
, void* data) { return static_cast<OTableEditorCtrl *>(
instance)->DelayedInsNewRows(data); } void OTableEditorCtrl
::DelayedInsNewRows(__attribute__ ((unused)) void*)
1490{
  nInsNewRowsEvent = nullptr;
  sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition();
  if ( !GetView()->getController().getTable().is() )
      nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : m_nDataPos;

  InsertNewRows( nPastePosition );
  SetNoSelection();
  GoToRow( nPastePosition );
1499}

1501void OTableEditorCtrl::AdjustFieldDescription(OFieldDescription* _pFieldDesc,
                                       MultiSelection& _rMultiSel,
                                       sal_Int32 _nPos,
                                       bool _bSet,
                                       bool _bPrimaryKey)
1506{
  _pFieldDesc->SetPrimaryKey( _bPrimaryKey );
  if(!_bSet && _pFieldDesc->getTypeInfo()->bNullable)
  {
      _pFieldDesc->SetIsNullable(ColumnValue::NO_NULLS);
      _pFieldDesc->SetControlDefault(Any());
  }
  if ( _pFieldDesc->IsAutoIncrement() && !_bPrimaryKey )
  {
      OTableController& rController = GetView()->getController();
      if ( rController.isAutoIncrementPrimaryKey() )
      {
          _pFieldDesc->SetAutoIncrement(false);
      }
  }
  // update field description
  pDescrWin->DisplayData(_pFieldDesc);

  _rMultiSel.Insert( _nPos );
  _rMultiSel.Select( _nPos );
1526}

1528void OTableEditorCtrl::SetPrimaryKey( bool bSet )
1529{
  // Delete any existing Primary Keys
  MultiSelection aDeletedPrimKeys;
  aDeletedPrimKeys.SetTotalRange( Range(0,GetRowCount()) );

  sal_Int32 nRow = 0;
  for (auto const& row : *m_pRowList)
  {
      OFieldDescription* pFieldDescr = row->GetActFieldDescr();
      if( pFieldDescr && row->IsPrimaryKey() && (!bSet || !IsRowSelected(nRow)) )
      {
          AdjustFieldDescription(pFieldDescr,aDeletedPrimKeys,nRow,bSet,false);
      }
      ++nRow;
  }

  // Set the primary keys of the marked rows
  MultiSelection aInsertedPrimKeys;
  aInsertedPrimKeys.SetTotalRange( Range(0,GetRowCount()) );
  if( bSet )
  {
      long nIndex = FirstSelectedRow();
      while( nIndex != SFX_ENDOFSELECTION(-1) )
      {
          // Set the key
          std::shared_ptr<OTableRow>  pRow = (*m_pRowList)[nIndex];
          OFieldDescription* pFieldDescr = pRow->GetActFieldDescr();
          if(pFieldDescr)
              AdjustFieldDescription(pFieldDescr,aInsertedPrimKeys,nIndex,false,true);

          nIndex = NextSelectedRow();
      }
  }

  GetUndoManager().AddUndoAction( std::make_unique<OPrimKeyUndoAct>(this, aDeletedPrimKeys, aInsertedPrimKeys) );

  // Invalidate the handle-columns
  InvalidateHandleColumn();

  // Set the TableDocSh's ModifyFlag
  GetView()->getController().setModified( true );
  InvalidateFeatures();
1571}

1573bool OTableEditorCtrl::IsPrimaryKey()
1574{
  // Are all marked fields part of the Primary Key ?
  long nPrimaryKeys = 0;
  sal_Int32 nRow=0;
  for (auto const& row : *m_pRowList)
  {
      if( IsRowSelected(nRow) && !row->IsPrimaryKey() )
          return false;
      if( row->IsPrimaryKey() )
          ++nPrimaryKeys;
      ++nRow;
  }

  // Are there any unselected fields that are part of the Key ?
  return GetSelectRowCount() == nPrimaryKeys;
1589}

1591void OTableEditorCtrl::SwitchType( const TOTypeInfoSP& _pType )
1592{
  // if there is no assigned field name
  long nRow(GetCurRow());
  OFieldDescription* pActFieldDescr = GetFieldDescr( nRow );
  if( pActFieldDescr )
      // Store the old description
      pDescrWin->SaveData( pActFieldDescr );

  if ( nRow < 0 || nRow > static_cast<long>(m_pRowList->size()) )
      return;
  // Show the new description
  std::shared_ptr<OTableRow>  pRow = (*m_pRowList)[nRow];
  pRow->SetFieldType( _pType, true );
  if ( _pType )
  {
      weld::ComboBox& rTypeList = pTypeCell->get_widget();
      const sal_Int32 nCurrentlySelected = rTypeList.get_active();

      if  (   ( nCurrentlySelected == -1 )
          ||  ( GetView()->getController().getTypeInfo( nCurrentlySelected ) != _pType )
          )
      {
          sal_Int32 nEntryPos = 0;
          const OTypeInfoMap& rTypeInfo = GetView()->getController().getTypeInfo();
          for (auto const& elem : rTypeInfo)
          {
              if(elem.second == _pType)
                  break;
              ++nEntryPos;
          }
          if (nEntryPos < rTypeList.get_count())
              rTypeList.set_active(nEntryPos);
      }
  }

  pActFieldDescr = pRow->GetActFieldDescr();
  if (pActFieldDescr != nullptr && !pActFieldDescr->GetFormatKey())
  {
      sal_Int32 nFormatKey = ::dbtools::getDefaultNumberFormat( pActFieldDescr->GetType(),
          pActFieldDescr->GetScale(),
          pActFieldDescr->IsCurrency(),
          Reference< XNumberFormatTypes>(GetView()->getController().getNumberFormatter()->getNumberFormatsSupplier()->getNumberFormats(),UNO_QUERY),
          GetView()->getLocale());

      pActFieldDescr->SetFormatKey(nFormatKey);
  }

  pDescrWin->DisplayData( pActFieldDescr );
1640}

1642OTableDesignView* OTableEditorCtrl::GetView() const
1643{
  return m_pView;
1645}

1647void OTableEditorCtrl::DeactivateCell(bool bUpdate)
1648{
  OTableRowView::DeactivateCell(bUpdate);
  // now we have to deactivate the field description
  long nRow(GetCurRow());
  if (pDescrWin)
      pDescrWin->SetReadOnly(bReadOnly || !SetDataPtr(nRow) || GetActRow()->IsReadOnly());
1654}

1656bool OTableEditorCtrl::PreNotify( NotifyEvent& rNEvt )
1657{
  if (rNEvt.GetType() == MouseNotifyEvent::GETFOCUS)
  {
      if( pHelpTextCell && pHelpTextCell->HasChildPathFocus() )
          m_eChildFocus = HELPTEXT;
      else if( pDescrCell && pDescrCell->HasChildPathFocus() )
          m_eChildFocus = DESCRIPTION;
      else if(pNameCell && pNameCell->HasChildPathFocus() )
          m_eChildFocus = NAME;
      else
          m_eChildFocus = ROW;
  }

  return OTableRowView::PreNotify(rNEvt);
1671}

1673/* 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);
12
←
Calling copy constructor for 'Reference<svt::EditControl>'→
15
←
Returning from copy constructor for 'Reference<svt::EditControl>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
16
←
Calling 'Reference::clear'→
23
←
Returning; memory was released→
      if (aTmp.get()) {
24
←
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)
13
←
Assuming field 'm_pBody' is non-null→
14
←
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_pBody16.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
17
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
18
←
Calling 'VclReferenceBase::release'→
22
←
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;
25
←
Use of memory after it is freed
  }


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


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


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

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

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


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


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


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


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

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

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

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

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

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

←

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

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 *   Licensed to the Apache Software Foundation (ASF) under one or more
12 *   contributor license agreements. See the NOTICE file distributed
13 *   with this work for additional information regarding copyright
14 *   ownership. The ASF licenses this file to you under the Apache
15 *   License, Version 2.0 (the "License"); you may not use this file
16 *   except in compliance with the License. You may obtain a copy of
17 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
19
←
Assuming the condition is true→
20
←
Taking true branch→
40            delete this;
21
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif