diff options
Diffstat (limited to 'sc/source/core/tool/dbdata.cxx')
| -rw-r--r-- | sc/source/core/tool/dbdata.cxx | 1637 |
1 files changed, 1637 insertions, 0 deletions
diff --git a/sc/source/core/tool/dbdata.cxx b/sc/source/core/tool/dbdata.cxx new file mode 100644 index 000000000..0e36eb960 --- /dev/null +++ b/sc/source/core/tool/dbdata.cxx @@ -0,0 +1,1637 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <sal/config.h> +#include <sal/log.hxx> + +#include <o3tl/safeint.hxx> +#include <unotools/transliterationwrapper.hxx> +#include <unotools/charclass.hxx> + +#include <dbdata.hxx> +#include <globalnames.hxx> +#include <refupdat.hxx> +#include <document.hxx> +#include <queryparam.hxx> +#include <queryentry.hxx> +#include <globstr.hrc> +#include <scresid.hxx> +#include <subtotalparam.hxx> +#include <sortparam.hxx> +#include <dociter.hxx> +#include <brdcst.hxx> + +#include <comphelper/stl_types.hxx> + +#include <memory> +#include <utility> + +using ::std::unique_ptr; +using ::std::for_each; +using ::std::find_if; +using ::std::remove_if; +using ::std::pair; + +bool ScDBData::less::operator() (const std::unique_ptr<ScDBData>& left, const std::unique_ptr<ScDBData>& right) const +{ + return ScGlobal::GetTransliteration().compareString(left->GetUpperName(), right->GetUpperName()) < 0; +} + +ScDBData::ScDBData( const OUString& rName, + SCTAB nTab, + SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, + bool bByR, bool bHasH, bool bTotals) : + // Listeners are to be setup by the "parent" container. + mpSortParam(new ScSortParam), + mpQueryParam(new ScQueryParam), + mpSubTotal(new ScSubTotalParam), + mpImportParam(new ScImportParam), + mpContainer (nullptr), + aName (rName), + aUpper (rName), + nTable (nTab), + nStartCol (nCol1), + nStartRow (nRow1), + nEndCol (nCol2), + nEndRow (nRow2), + bByRow (bByR), + bHasHeader (bHasH), + bHasTotals (bTotals), + bDoSize (false), + bKeepFmt (false), + bStripData (false), + bIsAdvanced (false), + bDBSelection(false), + nIndex (0), + bAutoFilter (false), + bModified (false), + mbTableColumnNamesDirty(true), + nFilteredRowCount(SCSIZE_MAX) +{ + aUpper = ScGlobal::getCharClass().uppercase(aUpper); +} + +ScDBData::ScDBData( const ScDBData& rData ) : + // Listeners are to be setup by the "parent" container. + SvtListener (), + ScRefreshTimer ( rData ), + mpSortParam(new ScSortParam(*rData.mpSortParam)), + mpQueryParam(new ScQueryParam(*rData.mpQueryParam)), + mpSubTotal(new ScSubTotalParam(*rData.mpSubTotal)), + mpImportParam(new ScImportParam(*rData.mpImportParam)), + mpContainer (nullptr), + aName (rData.aName), + aUpper (rData.aUpper), + nTable (rData.nTable), + nStartCol (rData.nStartCol), + nStartRow (rData.nStartRow), + nEndCol (rData.nEndCol), + nEndRow (rData.nEndRow), + bByRow (rData.bByRow), + bHasHeader (rData.bHasHeader), + bHasTotals (rData.bHasTotals), + bDoSize (rData.bDoSize), + bKeepFmt (rData.bKeepFmt), + bStripData (rData.bStripData), + bIsAdvanced (rData.bIsAdvanced), + aAdvSource (rData.aAdvSource), + bDBSelection (rData.bDBSelection), + nIndex (rData.nIndex), + bAutoFilter (rData.bAutoFilter), + bModified (rData.bModified), + maTableColumnNames (rData.maTableColumnNames), + mbTableColumnNamesDirty(rData.mbTableColumnNamesDirty), + nFilteredRowCount (rData.nFilteredRowCount) +{ +} + +ScDBData::ScDBData( const OUString& rName, const ScDBData& rData ) : + // Listeners are to be setup by the "parent" container. + SvtListener (), + ScRefreshTimer ( rData ), + mpSortParam(new ScSortParam(*rData.mpSortParam)), + mpQueryParam(new ScQueryParam(*rData.mpQueryParam)), + mpSubTotal(new ScSubTotalParam(*rData.mpSubTotal)), + mpImportParam(new ScImportParam(*rData.mpImportParam)), + mpContainer (nullptr), + aName (rName), + aUpper (rName), + nTable (rData.nTable), + nStartCol (rData.nStartCol), + nStartRow (rData.nStartRow), + nEndCol (rData.nEndCol), + nEndRow (rData.nEndRow), + bByRow (rData.bByRow), + bHasHeader (rData.bHasHeader), + bHasTotals (rData.bHasTotals), + bDoSize (rData.bDoSize), + bKeepFmt (rData.bKeepFmt), + bStripData (rData.bStripData), + bIsAdvanced (rData.bIsAdvanced), + aAdvSource (rData.aAdvSource), + bDBSelection (rData.bDBSelection), + nIndex (rData.nIndex), + bAutoFilter (rData.bAutoFilter), + bModified (rData.bModified), + maTableColumnNames (rData.maTableColumnNames), + mbTableColumnNamesDirty (rData.mbTableColumnNamesDirty), + nFilteredRowCount (rData.nFilteredRowCount) +{ + aUpper = ScGlobal::getCharClass().uppercase(aUpper); +} + +ScDBData& ScDBData::operator= (const ScDBData& rData) +{ + if (this != &rData) + { + // Don't modify the name. The name is not mutable as it is used as a key + // in the container to keep the db ranges sorted by the name. + + bool bHeaderRangeDiffers = (nTable != rData.nTable || nStartCol != rData.nStartCol || + nEndCol != rData.nEndCol || nStartRow != rData.nStartRow); + bool bNeedsListening = ((bHasHeader && bHeaderRangeDiffers) || (!bHasHeader && rData.bHasHeader)); + if (bHasHeader && (!rData.bHasHeader || bHeaderRangeDiffers)) + { + EndTableColumnNamesListener(); + } + ScRefreshTimer::operator=( rData ); + mpSortParam.reset(new ScSortParam(*rData.mpSortParam)); + mpQueryParam.reset(new ScQueryParam(*rData.mpQueryParam)); + mpSubTotal.reset(new ScSubTotalParam(*rData.mpSubTotal)); + mpImportParam.reset(new ScImportParam(*rData.mpImportParam)); + // Keep mpContainer. + nTable = rData.nTable; + nStartCol = rData.nStartCol; + nStartRow = rData.nStartRow; + nEndCol = rData.nEndCol; + nEndRow = rData.nEndRow; + bByRow = rData.bByRow; + bHasHeader = rData.bHasHeader; + bHasTotals = rData.bHasTotals; + bDoSize = rData.bDoSize; + bKeepFmt = rData.bKeepFmt; + bStripData = rData.bStripData; + bIsAdvanced = rData.bIsAdvanced; + aAdvSource = rData.aAdvSource; + bDBSelection = rData.bDBSelection; + nIndex = rData.nIndex; + bAutoFilter = rData.bAutoFilter; + nFilteredRowCount = rData.nFilteredRowCount; + + if (bHeaderRangeDiffers) + InvalidateTableColumnNames( true); + else + { + maTableColumnNames = rData.maTableColumnNames; + mbTableColumnNamesDirty = rData.mbTableColumnNamesDirty; + } + + if (bNeedsListening) + StartTableColumnNamesListener(); + } + return *this; +} + +bool ScDBData::operator== (const ScDBData& rData) const +{ + // Data that is not in sort or query params. + + if ( nTable != rData.nTable || + bDoSize != rData.bDoSize || + bKeepFmt != rData.bKeepFmt || + bIsAdvanced!= rData.bIsAdvanced|| + bStripData != rData.bStripData || +// SAB: I think this should be here, but I don't want to break something +// bAutoFilter!= rData.bAutoFilter|| + ScRefreshTimer::operator!=( rData ) + ) + return false; + + if ( bIsAdvanced && aAdvSource != rData.aAdvSource ) + return false; + + ScSortParam aSort1, aSort2; + GetSortParam(aSort1); + rData.GetSortParam(aSort2); + if (!(aSort1 == aSort2)) + return false; + + ScQueryParam aQuery1, aQuery2; + GetQueryParam(aQuery1); + rData.GetQueryParam(aQuery2); + if (!(aQuery1 == aQuery2)) + return false; + + ScSubTotalParam aSubTotal1, aSubTotal2; + GetSubTotalParam(aSubTotal1); + rData.GetSubTotalParam(aSubTotal2); + if (!(aSubTotal1 == aSubTotal2)) + return false; + + ScImportParam aImport1, aImport2; + GetImportParam(aImport1); + rData.GetImportParam(aImport2); + return aImport1 == aImport2; +} + +ScDBData::~ScDBData() +{ + StopRefreshTimer(); +} + +OUString ScDBData::GetSourceString() const +{ + OUStringBuffer aBuf; + if (mpImportParam->bImport) + { + aBuf.append(mpImportParam->aDBName); + aBuf.append('/'); + aBuf.append(mpImportParam->aStatement); + } + return aBuf.makeStringAndClear(); +} + +OUString ScDBData::GetOperations() const +{ + OUStringBuffer aBuf; + if (mpQueryParam->GetEntryCount()) + { + const ScQueryEntry& rEntry = mpQueryParam->GetEntry(0); + if (rEntry.bDoQuery) + aBuf.append(ScResId(STR_OPERATION_FILTER)); + } + + if (mpSortParam->maKeyState[0].bDoSort) + { + if (!aBuf.isEmpty()) + aBuf.append(", "); + aBuf.append(ScResId(STR_OPERATION_SORT)); + } + + if (mpSubTotal->bGroupActive[0] && !mpSubTotal->bRemoveOnly) + { + if (!aBuf.isEmpty()) + aBuf.append(", "); + aBuf.append(ScResId(STR_OPERATION_SUBTOTAL)); + } + + if (aBuf.isEmpty()) + aBuf.append(ScResId(STR_OPERATION_NONE)); + + return aBuf.makeStringAndClear(); +} + +void ScDBData::GetArea(SCTAB& rTab, SCCOL& rCol1, SCROW& rRow1, SCCOL& rCol2, SCROW& rRow2) const +{ + rTab = nTable; + rCol1 = nStartCol; + rRow1 = nStartRow; + rCol2 = nEndCol; + rRow2 = nEndRow; +} + +void ScDBData::GetArea(ScRange& rRange) const +{ + SCROW nNewEndRow = nEndRow; + rRange = ScRange( nStartCol, nStartRow, nTable, nEndCol, nNewEndRow, nTable ); +} + +ScRange ScDBData::GetHeaderArea() const +{ + if (HasHeader()) + return ScRange( nStartCol, nStartRow, nTable, nEndCol, nStartRow, nTable); + return ScRange( ScAddress::INITIALIZE_INVALID); +} + +void ScDBData::SetArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) +{ + bool bHeaderRangeChange = (nTab != nTable || nCol1 != nStartCol || nCol2 != nEndCol || nRow1 != nStartRow); + if (bHeaderRangeChange) + EndTableColumnNamesListener(); + + nTable = nTab; + nStartCol = nCol1; + nStartRow = nRow1; + nEndCol = nCol2; + nEndRow = nRow2; + + if (bHeaderRangeChange) + { + SAL_WARN_IF( !maTableColumnNames.empty(), "sc.core", "ScDBData::SetArea - invalidating column names/offsets"); + // Invalidate *after* new area has been set above to add the proper + // header range to dirty list. + InvalidateTableColumnNames( true); + StartTableColumnNamesListener(); + } +} + +void ScDBData::MoveTo(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, + SCCOL nUpdateCol) +{ + tools::Long nDifX = static_cast<tools::Long>(nCol1) - static_cast<tools::Long>(nStartCol); + tools::Long nDifY = static_cast<tools::Long>(nRow1) - static_cast<tools::Long>(nStartRow); + + tools::Long nSortDif = bByRow ? nDifX : nDifY; + tools::Long nSortEnd = bByRow ? static_cast<tools::Long>(nCol2) : static_cast<tools::Long>(nRow2); + + for (sal_uInt16 i=0; i<mpSortParam->GetSortKeyCount(); i++) + { + mpSortParam->maKeyState[i].nField += nSortDif; + if (mpSortParam->maKeyState[i].nField > nSortEnd) + { + mpSortParam->maKeyState[i].nField = 0; + mpSortParam->maKeyState[i].bDoSort = false; + } + } + + SCSIZE nCount = mpQueryParam->GetEntryCount(); + for (SCSIZE i = 0; i < nCount; ++i) + { + ScQueryEntry& rEntry = mpQueryParam->GetEntry(i); + rEntry.nField += nDifX; + + // tdf#48025, tdf#141946: update the column index of the filter criteria, + // when the deleted/inserted columns are inside the data range + if (nUpdateCol != -1) + { + nUpdateCol += nDifX; + tools::Long nDifX2 + = static_cast<tools::Long>(nCol2) - static_cast<tools::Long>(nEndCol); + if (rEntry.nField >= nUpdateCol) + rEntry.nField += nDifX2; + else if (rEntry.nField >= nUpdateCol + nDifX2) + rEntry.Clear(); + } + + if (rEntry.nField > nCol2) + { + rEntry.nField = 0; + rEntry.bDoQuery = false; + } + } + for (sal_uInt16 i=0; i<MAXSUBTOTAL; i++) + { + mpSubTotal->nField[i] = sal::static_int_cast<SCCOL>( mpSubTotal->nField[i] + nDifX ); + if (mpSubTotal->nField[i] > nCol2) + { + mpSubTotal->nField[i] = 0; + mpSubTotal->bGroupActive[i] = false; + } + } + + SetArea( nTab, nCol1, nRow1, nCol2, nRow2 ); +} + +void ScDBData::GetSortParam( ScSortParam& rSortParam ) const +{ + rSortParam = *mpSortParam; + rSortParam.nCol1 = nStartCol; + rSortParam.nRow1 = nStartRow; + rSortParam.nCol2 = nEndCol; + rSortParam.nRow2 = nEndRow; + rSortParam.bByRow = bByRow; + rSortParam.bHasHeader = bHasHeader; + /* TODO: add Totals to ScSortParam? */ +} + +void ScDBData::SetSortParam( const ScSortParam& rSortParam ) +{ + mpSortParam.reset(new ScSortParam(rSortParam)); + bByRow = rSortParam.bByRow; +} + +void ScDBData::UpdateFromSortParam( const ScSortParam& rSortParam ) +{ + bHasHeader = rSortParam.bHasHeader; +} + +void ScDBData::GetQueryParam( ScQueryParam& rQueryParam ) const +{ + rQueryParam = *mpQueryParam; + rQueryParam.nCol1 = nStartCol; + rQueryParam.nRow1 = nStartRow; + rQueryParam.nCol2 = nEndCol; + rQueryParam.nRow2 = nEndRow; + rQueryParam.nTab = nTable; + rQueryParam.bByRow = bByRow; + rQueryParam.bHasHeader = bHasHeader; + /* TODO: add Totals to ScQueryParam? */ +} + +void ScDBData::SetQueryParam(const ScQueryParam& rQueryParam) +{ + mpQueryParam.reset(new ScQueryParam(rQueryParam)); + + // set bIsAdvanced to false for everything that is not from the + // advanced filter dialog + bIsAdvanced = false; +} + +void ScDBData::SetAdvancedQuerySource(const ScRange* pSource) +{ + if (pSource) + { + aAdvSource = *pSource; + bIsAdvanced = true; + } + else + bIsAdvanced = false; +} + +bool ScDBData::GetAdvancedQuerySource(ScRange& rSource) const +{ + rSource = aAdvSource; + return bIsAdvanced; +} + +void ScDBData::GetSubTotalParam(ScSubTotalParam& rSubTotalParam) const +{ + rSubTotalParam = *mpSubTotal; + + // Share the data range with the parent db data. The range in the subtotal + // param struct is not used. + rSubTotalParam.nCol1 = nStartCol; + rSubTotalParam.nRow1 = nStartRow; + rSubTotalParam.nCol2 = nEndCol; + rSubTotalParam.nRow2 = nEndRow; +} + +void ScDBData::SetSubTotalParam(const ScSubTotalParam& rSubTotalParam) +{ + mpSubTotal.reset(new ScSubTotalParam(rSubTotalParam)); +} + +void ScDBData::GetImportParam(ScImportParam& rImportParam) const +{ + rImportParam = *mpImportParam; + // set the range. + rImportParam.nCol1 = nStartCol; + rImportParam.nRow1 = nStartRow; + rImportParam.nCol2 = nEndCol; + rImportParam.nRow2 = nEndRow; +} + +void ScDBData::SetImportParam(const ScImportParam& rImportParam) +{ + // the range is ignored. + mpImportParam.reset(new ScImportParam(rImportParam)); +} + +bool ScDBData::IsDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const +{ + if (nTab == nTable) + { + switch (ePortion) + { + case ScDBDataPortion::TOP_LEFT: + return nCol == nStartCol && nRow == nStartRow; + case ScDBDataPortion::AREA: + return nCol >= nStartCol && nCol <= nEndCol && nRow >= nStartRow && nRow <= nEndRow; + } + } + + return false; +} + +bool ScDBData::IsDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const +{ + return (nTab == nTable) + && (nCol1 == nStartCol) && (nRow1 == nStartRow) + && (nCol2 == nEndCol) && (nRow2 == nEndRow); +} + +bool ScDBData::HasImportParam() const +{ + return mpImportParam && mpImportParam->bImport; +} + +bool ScDBData::HasQueryParam() const +{ + if (!mpQueryParam) + return false; + + if (!mpQueryParam->GetEntryCount()) + return false; + + return mpQueryParam->GetEntry(0).bDoQuery; +} + +bool ScDBData::HasSortParam() const +{ + return mpSortParam && + !mpSortParam->maKeyState.empty() && + mpSortParam->maKeyState[0].bDoSort; +} + +bool ScDBData::HasSubTotalParam() const +{ + return mpSubTotal && mpSubTotal->bGroupActive[0]; +} + +void ScDBData::UpdateMoveTab(SCTAB nOldPos, SCTAB nNewPos) +{ + ScRange aRange; + GetArea(aRange); + SCTAB nTab = aRange.aStart.Tab(); // a database range is only on one sheet + + // customize as the current table as ScTablesHint (tabvwsh5.cxx) + + if (nTab == nOldPos) // moved sheet + nTab = nNewPos; + else if (nOldPos < nNewPos) // moved to the back + { + if (nTab > nOldPos && nTab <= nNewPos) // move this sheet + --nTab; + } + else // moved to the front + { + if (nTab >= nNewPos && nTab < nOldPos) // move this sheet + ++nTab; + } + + bool bChanged = (nTab != aRange.aStart.Tab()); + if (bChanged) + { + // SetArea() invalidates column names, but it is the same column range + // just on a different sheet; remember and set new. + ::std::vector<OUString> aNames(maTableColumnNames); + bool bTableColumnNamesDirty = mbTableColumnNamesDirty; + // Same column range. + SetArea(nTab, aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), + aRange.aEnd.Row()); + // Do not use SetTableColumnNames() because that resets mbTableColumnNamesDirty. + maTableColumnNames = aNames; + mbTableColumnNamesDirty = bTableColumnNamesDirty; + } + + // MoveTo() is not necessary if only the sheet changed. + + SetModified(bChanged); +} + +bool ScDBData::UpdateReference(const ScDocument* pDoc, UpdateRefMode eUpdateRefMode, + SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2, + SCCOL nDx, SCROW nDy, SCTAB nDz) +{ + SCCOL theCol1; + SCROW theRow1; + SCTAB theTab1; + SCCOL theCol2; + SCROW theRow2; + SCTAB theTab2; + GetArea( theTab1, theCol1, theRow1, theCol2, theRow2 ); + theTab2 = theTab1; + SCCOL nOldCol1 = theCol1, nOldCol2 = theCol2; + + ScRefUpdateRes eRet + = ScRefUpdate::Update(pDoc, eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, + nDy, nDz, theCol1, theRow1, theTab1, theCol2, theRow2, theTab2); + + bool bDoUpdate = eRet != UR_NOTHING; + + if (bDoUpdate && eRet != UR_INVALID) + { + // MoveTo() invalidates column names via SetArea(); adjust, remember and set new. + AdjustTableColumnNames( eUpdateRefMode, nDx, nCol1, nOldCol1, nOldCol2, theCol1, theCol2); + ::std::vector<OUString> aNames( maTableColumnNames); + bool bTableColumnNamesDirty = mbTableColumnNamesDirty; + // tdf#48025, tdf#141946: update the column index of the filter criteria, + // when the deleted/inserted columns are inside the data range + if (HasAutoFilter() && theCol1 - nOldCol1 != theCol2 - nOldCol2) + MoveTo(theTab1, theCol1, theRow1, theCol2, theRow2, nCol1); + else + MoveTo( theTab1, theCol1, theRow1, theCol2, theRow2 ); + // Do not use SetTableColumnNames() because that resets mbTableColumnNamesDirty. + maTableColumnNames = aNames; + mbTableColumnNamesDirty = bTableColumnNamesDirty; + } + + ScRange aRangeAdvSource; + if ( GetAdvancedQuerySource(aRangeAdvSource) ) + { + aRangeAdvSource.GetVars( theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ); + if ( ScRefUpdate::Update( pDoc, eUpdateRefMode, + nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz, + theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) ) + { + aRangeAdvSource.aStart.Set( theCol1,theRow1,theTab1 ); + aRangeAdvSource.aEnd.Set( theCol2,theRow2,theTab2 ); + SetAdvancedQuerySource( &aRangeAdvSource ); + + bDoUpdate = true; // DBData is modified + } + } + + SetModified(bDoUpdate); + + return eRet == UR_INVALID; + + //TODO: check if something was deleted/inserted with-in the range !!! +} + +void ScDBData::ExtendDataArea(const ScDocument& rDoc) +{ + // Extend the DB area to include data rows immediately below. + SCCOL nOldCol1 = nStartCol, nOldCol2 = nEndCol; + SCROW nOldEndRow = nEndRow; + rDoc.GetDataArea(nTable, nStartCol, nStartRow, nEndCol, nEndRow, false, true); + // nOldEndRow==rDoc.MaxRow() may easily happen when selecting whole columns and + // setting an AutoFilter (i.e. creating an anonymous database-range). We + // certainly don't want to iterate over nearly a million empty cells, but + // keep only an intentionally user selected range. + if (nOldEndRow < rDoc.MaxRow() && nEndRow < nOldEndRow) + nEndRow = nOldEndRow; + if (nStartCol != nOldCol1 || nEndCol != nOldCol2) + { + SAL_WARN_IF( !maTableColumnNames.empty(), "sc.core", "ScDBData::ExtendDataArea - invalidating column names/offsets"); + InvalidateTableColumnNames( true); + } +} + +void ScDBData::StartTableColumnNamesListener() +{ + if (mpContainer && bHasHeader) + { + ScDocument& rDoc = mpContainer->GetDocument(); + if (!rDoc.IsClipOrUndo()) + rDoc.StartListeningArea( GetHeaderArea(), false, this); + } +} + +void ScDBData::EndTableColumnNamesListener() +{ + EndListeningAll(); +} + +void ScDBData::SetTableColumnNames( ::std::vector< OUString >&& rNames ) +{ + maTableColumnNames = std::move(rNames); + mbTableColumnNamesDirty = false; +} + +void ScDBData::AdjustTableColumnNames( UpdateRefMode eUpdateRefMode, SCCOL nDx, SCCOL nCol1, + SCCOL nOldCol1, SCCOL nOldCol2, SCCOL nNewCol1, SCCOL nNewCol2 ) +{ + if (maTableColumnNames.empty()) + return; + + SCCOL nDiff1 = nNewCol1 - nOldCol1; + SCCOL nDiff2 = nNewCol2 - nOldCol2; + if (nDiff1 == nDiff2) + return; // not moved or entirely moved, nothing to do + + ::std::vector<OUString> aNewNames; + if (eUpdateRefMode == URM_INSDEL) + { + if (nDx > 0) + mbTableColumnNamesDirty = true; // inserted columns will have empty names + + // nCol1 is the first column of the block that gets shifted, determine + // the head and tail elements that are to be copied for deletion or + // insertion. + size_t nHead = static_cast<size_t>(::std::max( nCol1 + std::min<SCCOL>(nDx, 0) - nOldCol1, 0)); + size_t nTail = static_cast<size_t>(::std::max( nOldCol2 - nCol1 + 1, 0)); + size_t n = nHead + nTail; + if (0 < n && n <= maTableColumnNames.size()) + { + if (nDx > 0) + n += nDx; + aNewNames.resize(n); + // Copy head. + for (size_t i = 0; i < nHead; ++i) + { + aNewNames[i] = maTableColumnNames[i]; + } + // Copy tail, inserted middle range, if any, stays empty. + for (size_t i = n - nTail, j = maTableColumnNames.size() - nTail; i < n; ++i, ++j) + { + aNewNames[i] = maTableColumnNames[j]; + } + } + } // else empty aNewNames invalidates names/offsets + + SAL_WARN_IF( !maTableColumnNames.empty() && aNewNames.empty(), + "sc.core", "ScDBData::AdjustTableColumnNames - invalidating column names/offsets"); + aNewNames.swap( maTableColumnNames); + if (maTableColumnNames.empty()) + mbTableColumnNamesDirty = true; + if (mbTableColumnNamesDirty) + InvalidateTableColumnNames( false); // preserve new column names array +} + +void ScDBData::InvalidateTableColumnNames( bool bSwapToEmptyNames ) +{ + mbTableColumnNamesDirty = true; + if (bSwapToEmptyNames && !maTableColumnNames.empty()) + ::std::vector<OUString>().swap( maTableColumnNames); + if (mpContainer) + { + // Add header range to dirty list. + if (HasHeader()) + mpContainer->GetDirtyTableColumnNames().Join( GetHeaderArea()); + else + { + // We need *some* range in the dirty list even without header area, + // otherwise the container would not attempt to call a refresh. + mpContainer->GetDirtyTableColumnNames().Join( ScRange( nStartCol, nStartRow, nTable)); + } + } +} + +namespace { +class TableColumnNameSearch +{ +public: + explicit TableColumnNameSearch( const OUString& rSearchName ) : + maSearchName( rSearchName ) + { + } + + bool operator()( const OUString& rName ) const + { + return ScGlobal::GetTransliteration().isEqual( maSearchName, rName); + } + +private: + OUString maSearchName; +}; + +/** Set a numbered table column name at given nIndex, preventing duplicates, + numbering starting at nCount. If nCount==0 then the first attempt is made + with an unnumbered name and if already present the next attempt with + nCount=2, so "Original" and "Original2". No check whether nIndex is valid. */ +void SetTableColumnName( ::std::vector<OUString>& rVec, size_t nIndex, const OUString& rName, size_t nCount ) +{ + OUString aStr; + do + { + if (nCount) + aStr = rName + OUString::number( nCount); + else + { + aStr = rName; + ++nCount; + } + + if (std::none_of( rVec.begin(), rVec.end(), TableColumnNameSearch( aStr))) + { + rVec[nIndex] = aStr; + break; // do while + } + ++nCount; + } while(true); +} +} + +void ScDBData::RefreshTableColumnNames( ScDocument* pDoc ) +{ + ::std::vector<OUString> aNewNames; + aNewNames.resize( nEndCol - nStartCol + 1); + bool bHaveEmpty = false; + if (!HasHeader() || !pDoc) + bHaveEmpty = true; // Assume we have empty ones and fill below. + else + { + ScHorizontalCellIterator aIter(*pDoc, nTable, nStartCol, nStartRow, nEndCol, nStartRow); // header row only + ScRefCellValue* pCell; + SCCOL nCol, nLastColFilled = nStartCol - 1; + SCROW nRow; + while ((pCell = aIter.GetNext( nCol, nRow)) != nullptr) + { + if (pCell->hasString()) + { + const OUString& rStr = pCell->getString( pDoc); + if (rStr.isEmpty()) + bHaveEmpty = true; + else + { + SetTableColumnName( aNewNames, nCol-nStartCol, rStr, 0); + if (nLastColFilled < nCol-1) + bHaveEmpty = true; + } + nLastColFilled = nCol; + } + else + bHaveEmpty = true; + } + } + + // Never leave us with empty names, try to remember previous name that + // might had been used to compile formulas, but only if same number of + // columns and no duplicates. + if (bHaveEmpty && aNewNames.size() == maTableColumnNames.size()) + { + bHaveEmpty = false; + for (size_t i=0, n=aNewNames.size(); i < n; ++i) + { + if (aNewNames[i].isEmpty()) + { + const OUString& rStr = maTableColumnNames[i]; + if (rStr.isEmpty()) + bHaveEmpty = true; + else + SetTableColumnName( aNewNames, i, rStr, 0); + } + } + } + + // If we still have empty ones then fill those with "Column#" with # + // starting at the column offset number. Still no duplicates of course. + if (bHaveEmpty) + { + OUString aColumn( ScResId(STR_COLUMN)); + for (size_t i=0, n=aNewNames.size(); i < n; ++i) + { + if (aNewNames[i].isEmpty()) + SetTableColumnName( aNewNames, i, aColumn, i+1); + } + } + + aNewNames.swap( maTableColumnNames); + mbTableColumnNamesDirty = false; +} + +void ScDBData::RefreshTableColumnNames( ScDocument* pDoc, const ScRange& rRange ) +{ + // Header-less tables get names generated, completely empty a full refresh. + if (mbTableColumnNamesDirty && (!HasHeader() || maTableColumnNames.empty())) + { + RefreshTableColumnNames( pDoc); + return; + } + + // Check if this is affected for the range requested. + ScRange aIntersection( GetHeaderArea().Intersection( rRange)); + if (!aIntersection.IsValid()) + return; + + // Always fully refresh, only one cell of a range was broadcasted per area + // listener if multiple cells were affected. We don't know if there were + // more. Also, we need the full check anyway in case a duplicated name was + // entered. + RefreshTableColumnNames( pDoc); +} + +sal_Int32 ScDBData::GetColumnNameOffset( const OUString& rName ) const +{ + if (maTableColumnNames.empty()) + return -1; + + ::std::vector<OUString>::const_iterator it( + ::std::find_if( maTableColumnNames.begin(), maTableColumnNames.end(), TableColumnNameSearch( rName))); + if (it != maTableColumnNames.end()) + return it - maTableColumnNames.begin(); + + return -1; +} + +OUString ScDBData::GetTableColumnName( SCCOL nCol ) const +{ + if (maTableColumnNames.empty()) + return OUString(); + + SCCOL nOffset = nCol - nStartCol; + if (nOffset < 0 || maTableColumnNames.size() <= o3tl::make_unsigned(nOffset)) + return OUString(); + + return maTableColumnNames[nOffset]; +} + +void ScDBData::Notify( const SfxHint& rHint ) +{ + const ScHint* pScHint = dynamic_cast<const ScHint*>(&rHint); + if (!pScHint) + return; + + if (pScHint->GetId() != SfxHintId::ScDataChanged) + return; + + mbTableColumnNamesDirty = true; + if (!mpContainer) + assert(!"ScDBData::Notify - how did we end up here without container?"); + else + { + // Only one cell of a range is broadcasted per area listener if + // multiple cells are affected. Expand the range to what this is + // listening to. Broadcasted address outside should not happen, + // but... let it trigger a refresh if. + const ScRange aHeaderRange( GetHeaderArea()); + ScAddress aHintAddress( pScHint->GetStartAddress()); + if (aHeaderRange.IsValid()) + { + mpContainer->GetDirtyTableColumnNames().Join( aHeaderRange); + // Header range is one row. + // The ScHint's "range" is an address with row count. + // Though broadcasted is usually only one cell, check for the + // possible case of row block and for one cell in the same row. + if (aHintAddress.Row() <= aHeaderRange.aStart.Row() + && aHeaderRange.aStart.Row() < aHintAddress.Row() + pScHint->GetRowCount()) + { + aHintAddress.SetRow( aHeaderRange.aStart.Row()); + if (!aHeaderRange.Contains( aHintAddress)) + mpContainer->GetDirtyTableColumnNames().Join( aHintAddress); + } + } + else + { + // We need *some* range in the dirty list even without header area, + // otherwise the container would not attempt to call a refresh. + aHintAddress.SetRow( nStartRow); + mpContainer->GetDirtyTableColumnNames().Join( aHintAddress); + } + } + + // Do not refresh column names here, which might trigger unwanted + // recalculation. +} + +void ScDBData::CalcSaveFilteredCount( SCSIZE nNonFilteredRowCount ) +{ + SCSIZE nTotal = nEndRow - nStartRow + 1; + if ( bHasHeader ) + nTotal -= 1; + nFilteredRowCount = nTotal - nNonFilteredRowCount; +} + +void ScDBData::GetFilterSelCount( SCSIZE& nSelected, SCSIZE& nTotal ) +{ + nTotal = nEndRow - nStartRow + 1; + if ( bHasHeader ) + nTotal -= 1; + if( nFilteredRowCount != SCSIZE_MAX ) + nSelected = nTotal - nFilteredRowCount; + else + nSelected = nFilteredRowCount; +} + +namespace { + +class FindByTable +{ + SCTAB mnTab; +public: + explicit FindByTable(SCTAB nTab) : mnTab(nTab) {} + + bool operator() (std::unique_ptr<ScDBData> const& p) const + { + ScRange aRange; + p->GetArea(aRange); + return aRange.aStart.Tab() == mnTab; + } +}; + +class UpdateMoveTabFunc +{ + SCTAB mnOldTab; + SCTAB mnNewTab; +public: + UpdateMoveTabFunc(SCTAB nOld, SCTAB nNew) : mnOldTab(nOld), mnNewTab(nNew) {} + void operator() (std::unique_ptr<ScDBData> const& p) + { + p->UpdateMoveTab(mnOldTab, mnNewTab); + } +}; + +OUString lcl_IncrementNumberInNamedRange(ScDBCollection::NamedDBs& namedDBs, + std::u16string_view rOldName) +{ + // Append or increment a numeric suffix and do not generate names that + // could result in a cell reference by ensuring at least one underscore is + // present. + // "aa" => "aa_2" + // "aaaa1" => "aaaa1_2" + // "aa_a" => "aa_a_2" + // "aa_a_" => "aa_a__2" + // "aa_a1" => "aa_a1_2" + // "aa_1a" => "aa_1a_2" + // "aa_1" => "aa_2" + // "aa_2" => "aa_3" + + size_t nLastIndex = rOldName.rfind('_'); + sal_Int32 nOldNumber = 1; + OUString aPrefix; + if (nLastIndex != std::u16string_view::npos) + { + ++nLastIndex; + std::u16string_view sLastPart(rOldName.substr(nLastIndex)); + nOldNumber = o3tl::toInt32(sLastPart); + + // If that number is exactly at the end then increment the number; else + // append "_" and number. + // toInt32() returns 0 on failure and also stops at trailing non-digit + // characters (toInt32("1a")==1). + if (OUString::number(nOldNumber) == sLastPart) + aPrefix = rOldName.substr(0, nLastIndex); + else + { + aPrefix = OUString::Concat(rOldName) + "_"; + nOldNumber = 1; + } + } + else // No "_" found, append "_" and number. + aPrefix = OUString::Concat(rOldName) + "_"; + OUString sNewName; + do + { + sNewName = aPrefix + OUString::number(++nOldNumber); + } while (namedDBs.findByName(sNewName) != nullptr); + return sNewName; +} + +class FindByCursor +{ + SCCOL mnCol; + SCROW mnRow; + SCTAB mnTab; + ScDBDataPortion mePortion; +public: + FindByCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) : + mnCol(nCol), mnRow(nRow), mnTab(nTab), mePortion(ePortion) {} + + bool operator() (std::unique_ptr<ScDBData> const& p) + { + return p->IsDBAtCursor(mnCol, mnRow, mnTab, mePortion); + } +}; + +class FindByRange +{ + const ScRange& mrRange; +public: + explicit FindByRange(const ScRange& rRange) : mrRange(rRange) {} + + bool operator() (std::unique_ptr<ScDBData> const& p) + { + return p->IsDBAtArea( + mrRange.aStart.Tab(), mrRange.aStart.Col(), mrRange.aStart.Row(), mrRange.aEnd.Col(), mrRange.aEnd.Row()); + } +}; + +class FindByIndex +{ + sal_uInt16 mnIndex; +public: + explicit FindByIndex(sal_uInt16 nIndex) : mnIndex(nIndex) {} + bool operator() (std::unique_ptr<ScDBData> const& p) const + { + return p->GetIndex() == mnIndex; + } +}; + +class FindByUpperName +{ + const OUString& mrName; +public: + explicit FindByUpperName(const OUString& rName) : mrName(rName) {} + bool operator() (std::unique_ptr<ScDBData> const& p) const + { + return p->GetUpperName() == mrName; + } +}; + +class FindByName +{ + const OUString& mrName; +public: + explicit FindByName(const OUString& rName) : mrName(rName) {} + bool operator() (std::unique_ptr<ScDBData> const& p) const + { + return p->GetName() == mrName; + } +}; + +class FindByPointer +{ + const ScDBData* mpDBData; +public: + explicit FindByPointer(const ScDBData* pDBData) : mpDBData(pDBData) {} + bool operator() (std::unique_ptr<ScDBData> const& p) const + { + return p.get() == mpDBData; + } +}; + +} + +ScDocument& ScDBDataContainerBase::GetDocument() const +{ + return mrDoc; +} + +ScRangeList& ScDBDataContainerBase::GetDirtyTableColumnNames() +{ + return maDirtyTableColumnNames; +} + +ScDBCollection::NamedDBs::NamedDBs(ScDBCollection& rParent, ScDocument& rDoc) : + ScDBDataContainerBase(rDoc), mrParent(rParent) {} + +ScDBCollection::NamedDBs::NamedDBs(const NamedDBs& r, ScDBCollection& rParent) + : ScDBDataContainerBase(r.mrDoc) + , mrParent(rParent) +{ + for (auto const& it : r.m_DBs) + { + ScDBData* p = new ScDBData(*it); + std::unique_ptr<ScDBData> pData(p); + if (m_DBs.insert( std::move(pData)).second) + initInserted(p); + } +} + +ScDBCollection::NamedDBs::~NamedDBs() +{ +} + +void ScDBCollection::NamedDBs::initInserted( ScDBData* p ) +{ + p->SetContainer( this); + if (mrDoc.IsClipOrUndo()) + return; + + p->StartTableColumnNamesListener(); // needs the container be set already + if (!p->AreTableColumnNamesDirty()) + return; + + if (p->HasHeader()) + { + // Refresh table column names in next round. + maDirtyTableColumnNames.Join( p->GetHeaderArea()); + } + else + { + // Header-less table can generate its column names + // already without accessing the document. + p->RefreshTableColumnNames( nullptr); + } +} + +ScDBCollection::NamedDBs::iterator ScDBCollection::NamedDBs::begin() +{ + return m_DBs.begin(); +} + +ScDBCollection::NamedDBs::iterator ScDBCollection::NamedDBs::end() +{ + return m_DBs.end(); +} + +ScDBCollection::NamedDBs::const_iterator ScDBCollection::NamedDBs::begin() const +{ + return m_DBs.begin(); +} + +ScDBCollection::NamedDBs::const_iterator ScDBCollection::NamedDBs::end() const +{ + return m_DBs.end(); +} + +ScDBData* ScDBCollection::NamedDBs::findByIndex(sal_uInt16 nIndex) +{ + DBsType::iterator itr = find_if( + m_DBs.begin(), m_DBs.end(), FindByIndex(nIndex)); + return itr == m_DBs.end() ? nullptr : itr->get(); +} + +ScDBData* ScDBCollection::NamedDBs::findByUpperName(const OUString& rName) +{ + DBsType::iterator itr = find_if( + m_DBs.begin(), m_DBs.end(), FindByUpperName(rName)); + return itr == m_DBs.end() ? nullptr : itr->get(); +} + +auto ScDBCollection::NamedDBs::findByUpperName2(const OUString& rName) -> iterator +{ + return find_if( + m_DBs.begin(), m_DBs.end(), FindByUpperName(rName)); +} + +ScDBData* ScDBCollection::NamedDBs::findByName(const OUString& rName) +{ + DBsType::iterator itr = find_if(m_DBs.begin(), m_DBs.end(), FindByName(rName)); + return itr == m_DBs.end() ? nullptr : itr->get(); +} + +bool ScDBCollection::NamedDBs::insert(std::unique_ptr<ScDBData> pData) +{ + auto p = pData.get(); + if (!pData->GetIndex()) + pData->SetIndex(mrParent.nEntryIndex++); + + pair<DBsType::iterator, bool> r = m_DBs.insert(std::move(pData)); + + if (r.second) + { + initInserted(p); + + /* TODO: shouldn't the import refresh not be setup for + * clipboard/undo documents? It was already like this before... */ + if (p->HasImportParam() && !p->HasImportSelection()) + { + p->SetRefreshHandler(mrParent.GetRefreshHandler()); + p->SetRefreshControl(&mrDoc.GetRefreshTimerControlAddress()); + } + } + return r.second; +} + +ScDBCollection::NamedDBs::iterator ScDBCollection::NamedDBs::erase(const iterator& itr) +{ + return m_DBs.erase(itr); +} + +bool ScDBCollection::NamedDBs::empty() const +{ + return m_DBs.empty(); +} + +size_t ScDBCollection::NamedDBs::size() const +{ + return m_DBs.size(); +} + +bool ScDBCollection::NamedDBs::operator== (const NamedDBs& r) const +{ + return ::comphelper::ContainerUniquePtrEquals(m_DBs, r.m_DBs); +} + +ScDBCollection::AnonDBs::iterator ScDBCollection::AnonDBs::begin() +{ + return m_DBs.begin(); +} + +ScDBCollection::AnonDBs::iterator ScDBCollection::AnonDBs::end() +{ + return m_DBs.end(); +} + +ScDBCollection::AnonDBs::const_iterator ScDBCollection::AnonDBs::begin() const +{ + return m_DBs.begin(); +} + +ScDBCollection::AnonDBs::const_iterator ScDBCollection::AnonDBs::end() const +{ + return m_DBs.end(); +} + +const ScDBData* ScDBCollection::AnonDBs::findAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, + ScDBDataPortion ePortion) const +{ + DBsType::const_iterator itr = find_if( + m_DBs.begin(), m_DBs.end(), FindByCursor(nCol, nRow, nTab, ePortion)); + return itr == m_DBs.end() ? nullptr : itr->get(); +} + +const ScDBData* ScDBCollection::AnonDBs::findByRange(const ScRange& rRange) const +{ + DBsType::const_iterator itr = find_if( + m_DBs.begin(), m_DBs.end(), FindByRange(rRange)); + return itr == m_DBs.end() ? nullptr : itr->get(); +} + +void ScDBCollection::AnonDBs::deleteOnTab(SCTAB nTab) +{ + FindByTable func(nTab); + m_DBs.erase(std::remove_if(m_DBs.begin(), m_DBs.end(), func), m_DBs.end()); +} + +ScDBData* ScDBCollection::AnonDBs::getByRange(const ScRange& rRange) +{ + const ScDBData* pData = findByRange(rRange); + if (!pData) + { + // Insert a new db data. They all have identical names. + ::std::unique_ptr<ScDBData> pNew(new ScDBData( + STR_DB_GLOBAL_NONAME, rRange.aStart.Tab(), rRange.aStart.Col(), rRange.aStart.Row(), + rRange.aEnd.Col(), rRange.aEnd.Row(), true, false, false)); + pData = pNew.get(); + m_DBs.push_back(std::move(pNew)); + } + return const_cast<ScDBData*>(pData); +} + +void ScDBCollection::AnonDBs::insert(ScDBData* p) +{ + m_DBs.push_back(std::unique_ptr<ScDBData>(p)); +} + +ScDBCollection::AnonDBs::iterator ScDBCollection::AnonDBs::erase(const iterator& itr) +{ + return m_DBs.erase(itr); +} + +bool ScDBCollection::AnonDBs::empty() const +{ + return m_DBs.empty(); +} + +bool ScDBCollection::AnonDBs::has( const ScDBData* p ) const +{ + return any_of(m_DBs.begin(), m_DBs.end(), FindByPointer(p)); +} + +bool ScDBCollection::AnonDBs::operator== (const AnonDBs& r) const +{ + return ::comphelper::ContainerUniquePtrEquals(m_DBs, r.m_DBs); +} + +ScDBCollection::AnonDBs::AnonDBs() +{ +} + +ScDBCollection::AnonDBs::AnonDBs(AnonDBs const& r) +{ + m_DBs.reserve(r.m_DBs.size()); + for (auto const& it : r.m_DBs) + { + m_DBs.push_back(std::make_unique<ScDBData>(*it)); + } +} + +ScDBCollection::ScDBCollection(ScDocument& rDocument) : + rDoc(rDocument), nEntryIndex(1), maNamedDBs(*this, rDocument) {} + +ScDBCollection::ScDBCollection(const ScDBCollection& r) : + rDoc(r.rDoc), nEntryIndex(r.nEntryIndex), maNamedDBs(r.maNamedDBs, *this), maAnonDBs(r.maAnonDBs) {} + +const ScDBData* ScDBCollection::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const +{ + // First, search the global named db ranges. + NamedDBs::DBsType::const_iterator itr = find_if( + maNamedDBs.begin(), maNamedDBs.end(), FindByCursor(nCol, nRow, nTab, ePortion)); + if (itr != maNamedDBs.end()) + return itr->get(); + + // Check for the sheet-local anonymous db range. + const ScDBData* pNoNameData = rDoc.GetAnonymousDBData(nTab); + if (pNoNameData) + if (pNoNameData->IsDBAtCursor(nCol,nRow,nTab,ePortion)) + return pNoNameData; + + // Check the global anonymous db ranges. + const ScDBData* pData = getAnonDBs().findAtCursor(nCol, nRow, nTab, ePortion); + if (pData) + return pData; + + // Do NOT check for the document global temporary anonymous db range here. + + return nullptr; +} + +ScDBData* ScDBCollection::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) +{ + // First, search the global named db ranges. + NamedDBs::DBsType::iterator itr = find_if( + maNamedDBs.begin(), maNamedDBs.end(), FindByCursor(nCol, nRow, nTab, ePortion)); + if (itr != maNamedDBs.end()) + return itr->get(); + + // Check for the sheet-local anonymous db range. + ScDBData* pNoNameData = rDoc.GetAnonymousDBData(nTab); + if (pNoNameData) + if (pNoNameData->IsDBAtCursor(nCol,nRow,nTab,ePortion)) + return pNoNameData; + + // Check the global anonymous db ranges. + const ScDBData* pData = getAnonDBs().findAtCursor(nCol, nRow, nTab, ePortion); + if (pData) + return const_cast<ScDBData*>(pData); + + // Do NOT check for the document global temporary anonymous db range here. + + return nullptr; +} + +const ScDBData* ScDBCollection::GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const +{ + // First, search the global named db ranges. + ScRange aRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab); + NamedDBs::DBsType::const_iterator itr = find_if( + maNamedDBs.begin(), maNamedDBs.end(), FindByRange(aRange)); + if (itr != maNamedDBs.end()) + return itr->get(); + + // Check for the sheet-local anonymous db range. + ScDBData* pNoNameData = rDoc.GetAnonymousDBData(nTab); + if (pNoNameData) + if (pNoNameData->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2)) + return pNoNameData; + + // Lastly, check the global anonymous db ranges. + const ScDBData* pData = maAnonDBs.findByRange(aRange); + if (pData) + return pData; + + // As a last resort, check for the document global temporary anonymous db range. + pNoNameData = rDoc.GetAnonymousDBData(); + if (pNoNameData) + if (pNoNameData->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2)) + return pNoNameData; + + return nullptr; +} + +ScDBData* ScDBCollection::GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) +{ + // First, search the global named db ranges. + ScRange aRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab); + NamedDBs::DBsType::iterator itr = find_if( + maNamedDBs.begin(), maNamedDBs.end(), FindByRange(aRange)); + if (itr != maNamedDBs.end()) + return itr->get(); + + // Check for the sheet-local anonymous db range. + ScDBData* pNoNameData = rDoc.GetAnonymousDBData(nTab); + if (pNoNameData) + if (pNoNameData->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2)) + return pNoNameData; + + // Lastly, check the global anonymous db ranges. + const ScDBData* pData = getAnonDBs().findByRange(aRange); + if (pData) + return const_cast<ScDBData*>(pData); + + // As a last resort, check for the document global temporary anonymous db range. + pNoNameData = rDoc.GetAnonymousDBData(); + if (pNoNameData) + if (pNoNameData->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2)) + return pNoNameData; + + return nullptr; +} + +void ScDBCollection::RefreshDirtyTableColumnNames() +{ + for (size_t i=0; i < maNamedDBs.maDirtyTableColumnNames.size(); ++i) + { + const ScRange & rRange = maNamedDBs.maDirtyTableColumnNames[i]; + for (auto const& it : maNamedDBs) + { + if (it->AreTableColumnNamesDirty()) + it->RefreshTableColumnNames( &maNamedDBs.mrDoc, rRange); + } + } + maNamedDBs.maDirtyTableColumnNames.RemoveAll(); +} + +void ScDBCollection::DeleteOnTab( SCTAB nTab ) +{ + FindByTable func(nTab); + // First, collect the positions of all items that need to be deleted. + ::std::vector<NamedDBs::DBsType::iterator> v; + { + NamedDBs::DBsType::iterator itr = maNamedDBs.begin(), itrEnd = maNamedDBs.end(); + for (; itr != itrEnd; ++itr) + { + if (func(*itr)) + v.push_back(itr); + } + } + + // Delete them all. + for (const auto& rIter : v) + maNamedDBs.erase(rIter); + + maAnonDBs.deleteOnTab(nTab); +} + +void ScDBCollection::UpdateReference(UpdateRefMode eUpdateRefMode, + SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2, + SCCOL nDx, SCROW nDy, SCTAB nDz ) +{ + ScDBData* pData = rDoc.GetAnonymousDBData(nTab1); + if (pData) + { + if (nTab1 == nTab2 && nDz == 0) + { + // Delete the database range, if some part of the reference became invalid. + if (pData->UpdateReference(&rDoc, eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, + nTab2, nDx, nDy, nDz)) + rDoc.SetAnonymousDBData(nTab1, nullptr); + } + else + { + //this will perhaps break undo + } + } + + for (auto it = maNamedDBs.begin(); it != maNamedDBs.end(); ) + { + // Delete the database range, if some part of the reference became invalid. + if (it->get()->UpdateReference(&rDoc, eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, + nTab2, nDx, nDy, nDz)) + it = maNamedDBs.erase(it); + else + ++it; + } + for (auto it = maAnonDBs.begin(); it != maAnonDBs.end(); ) + { + // Delete the database range, if some part of the reference became invalid. + if (it->get()->UpdateReference(&rDoc, eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, + nTab2, nDx, nDy, nDz)) + it = maAnonDBs.erase(it); + else + ++it; + } +} + +void ScDBCollection::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos ) +{ + UpdateMoveTabFunc func(nOldPos, nNewPos); + for_each(maNamedDBs.begin(), maNamedDBs.end(), func); + for_each(maAnonDBs.begin(), maAnonDBs.end(), func); +} + +void ScDBCollection::CopyToTable(SCTAB nOldPos, SCTAB nNewPos) +{ + // Create temporary copy of pointers to not insert in a set we are + // iterating over. + std::vector<const ScDBData*> aTemp; + aTemp.reserve( maNamedDBs.size()); + for (const auto& rxNamedDB : maNamedDBs) + { + if (rxNamedDB->GetTab() != nOldPos) + continue; + aTemp.emplace_back( rxNamedDB.get()); + } + for (const auto& rxNamedDB : aTemp) + { + const OUString newName( lcl_IncrementNumberInNamedRange( maNamedDBs, rxNamedDB->GetName())); + std::unique_ptr<ScDBData> pDataCopy = std::make_unique<ScDBData>(newName, *rxNamedDB); + pDataCopy->UpdateMoveTab(nOldPos, nNewPos); + pDataCopy->SetIndex(0); + maNamedDBs.insert(std::move(pDataCopy)); + } +} + +ScDBData* ScDBCollection::GetDBNearCursor(SCCOL nCol, SCROW nRow, SCTAB nTab ) +{ + ScDBData* pNearData = nullptr; + for (const auto& rxNamedDB : maNamedDBs) + { + SCTAB nAreaTab; + SCCOL nStartCol, nEndCol; + SCROW nStartRow, nEndRow; + rxNamedDB->GetArea( nAreaTab, nStartCol, nStartRow, nEndCol, nEndRow ); + if ( nTab == nAreaTab && nCol+1 >= nStartCol && nCol <= nEndCol+1 && + nRow+1 >= nStartRow && nRow <= nEndRow+1 ) + { + if ( nCol < nStartCol || nCol > nEndCol || nRow < nStartRow || nRow > nEndRow ) + { + if (!pNearData) + pNearData = rxNamedDB.get(); // remember first adjacent area + } + else + return rxNamedDB.get(); // not "unbenannt"/"unnamed" and cursor within + } + } + if (pNearData) + return pNearData; // adjacent, if no direct hit + return rDoc.GetAnonymousDBData(nTab); // "unbenannt"/"unnamed" only if nothing else +} + +std::vector<ScDBData*> ScDBCollection::GetAllDBsFromTab(SCTAB nTab) +{ + std::vector<ScDBData*> pTabData; + for (const auto& rxNamedDB : maNamedDBs) + { + if (rxNamedDB->GetTab() == nTab) + pTabData.emplace_back(rxNamedDB.get()); + } + auto pAnonDBData = rDoc.GetAnonymousDBData(nTab); + if (pAnonDBData) + pTabData.emplace_back(pAnonDBData); + return pTabData; +} + +bool ScDBCollection::empty() const +{ + return maNamedDBs.empty() && maAnonDBs.empty(); +} + +bool ScDBCollection::operator== (const ScDBCollection& r) const +{ + return maNamedDBs == r.maNamedDBs && maAnonDBs == r.maAnonDBs && + nEntryIndex == r.nEntryIndex && &rDoc == &r.rDoc && aRefreshHandler == r.aRefreshHandler; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |