| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/LibreOffice/sc/source/core/data/ (Office von Apache Version 25.8.3.2©) Datei vom 5.10.2025 mit Größe 121 kB |
|
SSL table4.cxxSprache: C |
|||||||||||||||
|
/* -*- 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 <scitems.hxx> #include <comphelper/string.hxx> #include <editeng/boxitem.hxx> #include <editeng/editeng.hxx> #include <editeng/eeitem.hxx> #include <editeng/escapementitem.hxx> #include <editeng/brushitem.hxx> #include <svl/numformat.hxx> #include <svl/zforlist.hxx> #include <vcl/keycodes.hxx> #include <rtl/math.hxx> #include <unotools/charclass.hxx> #include <tools/duration.hxx> #include <osl/diagnose.h> #include <attrib.hxx> #include <patattr.hxx> #include <formulacell.hxx> #include <table.hxx> #include <global.hxx> #include <document.hxx> #include <autoform.hxx> #include <userlist.hxx> #include <zforauto.hxx> #include <subtotal.hxx> #include <formula/errorcodes.hxx> #include <docpool.hxx> #include <progress.hxx> #include <conditio.hxx> #include <editutil.hxx> #include <listenercontext.hxx> #include <scopetools.hxx> #include <o3tl/string_view.hxx> #include <math.h> #include <memory> #include <list> #include <string_view> #define D_MAX_LONG_ double(0x7fffffff) namespace { short lcl_DecompValueString( OUString& rValue, sal_Int32& nVal, sal_uInt16* pMi { if ( rValue.isEmpty() ) { nVal = 0; return 0; } const sal_Unicode* p = rValue.getStr(); sal_Int32 nSign = 0; sal_Int32 nNum = 0; if ( p[nNum] == '-' || p[nNum] == '+' ) nNum = nSign = 1; while ( p[nNum] && CharClass::isAsciiNumeric( std::u16string_view(&p[nNum], 1) ) ) nNum++; sal_Unicode cNext = p[nNum]; // 0 if at the end sal_Unicode cLast = p[rValue.getLength()-1]; // #i5550# If there are numbers at the beginning and the end, // prefer the one at the beginning only if it's followed by a space. // Otherwise, use the number at the end, to enable things like IP addresses. if ( nNum > nSign && ( cNext == 0 || cNext == ' ' || !CharClass::isAsciiNumeric(std::u16string_view { // number at the beginning nVal = o3tl::toInt32(rValue.subView( 0, nNum )); // any number with a leading zero sets the minimum number of digits if ( p[nSign] == '0' && pMinDigits && ( nNum - nSign > *pMinDigits ) ) *pMinDigits = nNum - nSign; rValue = rValue.copy(nNum); return -1; } else { nSign = 0; sal_Int32 nEnd = nNum = rValue.getLength() - 1; while ( nNum && CharClass::isAsciiNumeric( std::u16string_view(&p[nNum], 1) ) ) nNum--; if ( p[nNum] == '-' || p[nNum] == '+' ) { nNum--; nSign = 1; } if ( nNum < nEnd - nSign ) { // number at the end nVal = o3tl::toInt32(rValue.subView( nNum + 1 )); // any number with a leading zero sets the minimum number of digits if ( p[nNum+1+nSign] == '0' && pMinDigits && ( nEnd - nNum - nSign > *pMinDigits ) ) *pMinDigits = nEnd - nNum - nSign; rValue = rValue.copy(0, nNum + 1); if (nSign) // use the return value = 2 to put back the '+' return 2; else return 1; } } nVal = 0; return 0; } OUString lcl_ValueString( sal_Int32 nValue, sal_uInt16 nMinDigits ) { if ( nMinDigits <= 1 ) return OUString::number( nValue ); // simple case... else { OUString aStr = OUString::number( std::abs( nValue ) ); if ( aStr.getLength() < nMinDigits ) { OUStringBuffer aZero(nMinDigits); comphelper::string::padToLength(aZero, nMinDigits - aStr.getLength(), '0'); aStr = aZero.append(aStr).makeStringAndClear(); } // nMinDigits doesn't include the '-' sign -> add after inserting zeros if ( nValue < 0 ) aStr = "-" + aStr; return aStr; } } void setSuffixCell( ScColumn& rColumn, SCROW nRow, sal_Int32 nValue, sal_uInt16 nDigits, std::u16string_view rSuffix, CellType eCellType, bool bIsOrdinalSuffix ) { ScDocument& rDoc = rColumn.GetDoc(); OUString aValue = lcl_ValueString(nValue, nDigits); if (!bIsOrdinalSuffix) { aValue += rSuffix; rColumn.SetRawString(nRow, aValue); return; } OUString aOrdinalSuffix = ScGlobal::GetOrdinalSuffix(nValue); if (eCellType != CELLTYPE_EDIT) { aValue += aOrdinalSuffix; rColumn.SetRawString(nRow, aValue); return; } EditEngine aEngine(rDoc.GetEnginePool()); aEngine.SetEditTextObjectPool(rDoc.GetEditPool()); SfxItemSet aAttr = aEngine.GetEmptyItemSet(); aAttr.Put( SvxEscapementItem( SvxEscapement::Superscript, EE_CHAR_ESCAPEMENT)); aEngine.SetText( aValue ); aEngine.QuickInsertText( aOrdinalSuffix, ESelection(0, aValue.getLength(), 0, aValue.getLength() + aOrdinalSuffix.getLength()) aEngine.QuickSetAttribs( aAttr, ESelection(0, aValue.getLength(), 0, aValue.getLength() + aOrdinalSuffix.getLength()) // Text object instance will be owned by the cell. rColumn.SetEditText(nRow, aEngine.CreateTextObject()); } } namespace { /* TODO: move this to rtl::math::approxDiff() ? Though the name is funny, the * approx is expected to be more correct than the raw diff. */ /** Calculate a-b trying to diminish precision errors such as for 0.11-0.12 not return -0.009999999999999995 but -0.01 instead. */ double approxDiff( double a, double b ) { if (a == b) return 0.0; if (a == 0.0) return -b; if (b == 0.0) return a; const double c = a - b; const double aa = fabs(a); const double ab = fabs(b); if (aa < 1e-16 || aa > 1e+16 || ab < 1e-16 || ab > 1e+16) // This is going nowhere, live with the result. return c; const double q = aa < ab ? b / a : a / b; const double d = (a * q - b * q) / q; if (d == c) // No differing error, live with the result. return c; // We now have two subtractions with a similar but not equal error. Obtain // the exponent of the error magnitude and round accordingly. const double e = fabs(d - c); const int nExp = static_cast<int>(floor(log10(e))) + 1; // tdf#129606: Limit precision to the 16th significant digit of the least precise argument. // Cf. mnMaxGeneralPrecision in sc/source/core/data/column3.cxx. const int nExpArg = static_cast<int>(floor(log10(std::max(aa, ab)))) - 15; return rtl::math::round(c, -std::max(nExp, nExpArg)); } double approxTypedDiff( double a, double b, bool bTime, tools::Duration& rDuration ) { if (bTime) { rDuration = tools::Duration(a - b); return rDuration.GetInDays(); } return approxDiff( a, b); } } void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, FillCmd& rCmd, FillDateCmd& rDateCmd, double& rInc, tools::Duration& rDuration, sal_uInt16& rMinDigits, ScUserListData*& rListData, sal_uInt16& rListIndex, bool bHasFiltered, bool& rSkipOverlappedCells, std::vector<sal_Int32>& rNonOverlappedCellIdx) { OSL_ENSURE( nCol1==nCol2 || nRow1==nRow2, "FillAnalyse: invalid range" ); rInc = 0.0; rDuration = tools::Duration(); rMinDigits = 0; rListData = nullptr; rCmd = FILL_SIMPLE; rSkipOverlappedCells = false; if ( nScFillModeMouseModifier & KEY_MOD1 ) return ; // Ctrl-key: Copy SCCOL nAddX; SCROW nAddY; SCSIZE nCount; if (nCol1 == nCol2) { nAddX = 0; nAddY = 1; nCount = static_cast<SCSIZE>(nRow2 - nRow1 + 1); } else { nAddX = 1; nAddY = 0; nCount = static_cast<SCSIZE>(nCol2 - nCol1 + 1); } // Try to analyse the merged cells only if there are no filtered rows in the destination area // Else fallback to the old way to avoid regression. // Filling merged cells into an area with filtered (hidden) rows, is a very complex task // that is not implemented, but not even decided how to do, even excel can't handle that well if (!bHasFiltered) { bool bHasOverlappedCells = false; bool bSkipOverlappedCells = true; SCCOL nColCurr = nCol1; SCROW nRowCurr = nRow1; // collect cells that are not empty or not overlapped rNonOverlappedCellIdx.resize(nCount); SCSIZE nValueCount = 0; for (SCSIZE i = 0; i < nCount; ++i) { const ScPatternAttr* pPattern = GetPattern(nColCurr, nRowCurr); const ScMergeFlagAttr* pMergeFlagItem = nullptr; bool bOverlapped = pPattern->GetItemSet().GetItemState(ATTR_MERGE_FLAG, false, &pMergeFlagItem) == SfxItemState::S && pMergeFlagItem->IsOverlapped(); if (bOverlapped) bHasOverlappedCells = true; if (!bOverlapped || GetCellValue(nColCurr, nRowCurr).getType() != CELLTYPE_NONE) { rNonOverlappedCellIdx[nValueCount++] = i; // if there is at least 1 non empty overlapped cell, then no cell should be skipped if (bOverlapped) bSkipOverlappedCells = false; } nColCurr += nAddX; nRowCurr += nAddY; } rNonOverlappedCellIdx.resize(nValueCount); // if all the values are overlapped CELLTYPE_NONE, then there is no need to analyse it. if (nValueCount == 0) return; // if there is no overlapped cells, there is nothing to skip if (!bHasOverlappedCells) bSkipOverlappedCells = false; if (bSkipOverlappedCells) { nColCurr = nCol1 + rNonOverlappedCellIdx[0] * nAddX; nRowCurr = nRow1 + rNonOverlappedCellIdx[0] * nAddY; ScRefCellValue aPrevCell, aCurrCell; aCurrCell = GetCellValue(nColCurr, nRowCurr); CellType eCellType = aCurrCell.getType(); if (eCellType == CELLTYPE_VALUE) { bool bVal = true; double fVal; SvNumFormatType nCurrCellFormatType = rDocument.GetFormatTable()->GetType(GetNumberFormat(nColCurr, nRowCurr)); if (nCurrCellFormatType == SvNumFormatType::DATE) { if (nValueCount >= 2) { tools::Long nCmpInc = 0; FillDateCmd eType = FILL_YEAR; // just some temporary default values tools::Long nDDiff = 0, nMDiff = 0, nYDiff = 0; // to avoid warnings Date aNullDate = rDocument.GetFormatTable()->GetNullDate(); Date aCurrDate = aNullDate, aPrevDate = aNullDate; aCurrDate.AddDays(aCurrCell.getDouble()); for (SCSIZE i = 1; i < nValueCount && bVal; i++) { aPrevCell = aCurrCell; aPrevDate = aCurrDate; nColCurr = nCol1 + rNonOverlappedCellIdx[i] * nAddX; nRowCurr = nRow1 + rNonOverlappedCellIdx[i] * nAddY; aCurrCell = GetCellValue(nColCurr, nRowCurr); if (aCurrCell.getType() == CELLTYPE_VALUE) { aCurrDate = aNullDate + static_cast<sal_Int32>(aCurrCell.getDouble()); if (eType != FILL_DAY) { nDDiff = aCurrDate.GetDay() - static_cast<tools::Long>(aPrevDate.GetDay()); nMDiff = aCurrDate.GetMonth() - static_cast<tools::Long>(aPrevDate.GetMonth()); nYDiff = aCurrDate.GetYear() - static_cast<tools::Long>(aPrevDate.GetYear()); } if (i == 1) { if (nDDiff != 0) { eType = FILL_DAY; nCmpInc = aCurrDate - aPrevDate; } else { eType = FILL_MONTH; nCmpInc = nMDiff + 12 * nYDiff; } } else if (eType == FILL_DAY) { if (aCurrDate - aPrevDate != nCmpInc) bVal = false; } else { if (nDDiff || (nMDiff + 12 * nYDiff != nCmpInc)) bVal = false; } } else bVal = false; // No date is also not ok } if (bVal) { if (eType == FILL_MONTH && (nCmpInc % 12 == 0)) { eType = FILL_YEAR; nCmpInc /= 12; } rCmd = FILL_DATE; rDateCmd = eType; rInc = nCmpInc; rSkipOverlappedCells = true; return; } } else { rCmd = FILL_DATE; rDateCmd = FILL_DAY; rInc = 1.0; rSkipOverlappedCells = true; return; } } else if (nCurrCellFormatType == SvNumFormatType::LOGICAL && ((fVal = aCurrCell.getDouble()) == 0.0 || fVal == 1.0)) { } else if (nValueCount >= 2) { tools::Duration aDuration; for (SCSIZE i = 1; i < nValueCount && bVal; i++) { aPrevCell = aCurrCell; nColCurr = nCol1 + rNonOverlappedCellIdx[i] * nAddX; nRowCurr = nRow1 + rNonOverlappedCellIdx[i] * nAddY; aCurrCell = GetCellValue(nColCurr, nRowCurr); if (aCurrCell.getType() == CELLTYPE_VALUE) { const bool bTime = (nCurrCellFormatType == SvNumFormatType::TIME || nCurrCellFormatType == SvNumFormatType::DATETIME); double nDiff = approxTypedDiff(aCurrCell.getDouble(), aPrevCell.getDouble(), bTime, aDuration); if (i == 1) { rInc = nDiff; if (bTime) rDuration = aDuration; } if (!::rtl::math::approxEqual(nDiff, rInc, 13)) bVal = false; else if ((aCurrCell.getDouble() == 0.0 || aCurrCell.getDouble() == 1.0) && (rDocument.GetFormatTable()->GetType( GetNumberFormat(nColCurr, nRowCurr)) == SvNumFormatType::LOGICAL)) bVal = false; } else bVal = false; } if (bVal) { rCmd = FILL_LINEAR; rSkipOverlappedCells = true; return; } } } else if (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT) { OUString aStr = GetString(nColCurr, nRowCurr ); OUString aStr2; rListData = const_cast<ScUserListData*>(ScGlobal::GetUserList().GetData(aStr)); if (rListData) { bool bMatchCase = false; (void)rListData->GetSubIndex(aStr, rListIndex, bMatchCase); size_t nListStrCount = rListData->GetSubCount(); sal_uInt16 nPrevListIndex, nInc = 1; for (SCSIZE i = 1; i < nValueCount && rListData; i++) { nColCurr = nCol1 + rNonOverlappedCellIdx[i] * nAddX; nRowCurr = nRow1 + rNonOverlappedCellIdx[i] * nAddY; aStr2 = GetString(nColCurr, nRowCurr); nPrevListIndex = rListIndex; if (!rListData->GetSubIndex(aStr2, rListIndex, bMatchCase)) rListData = nullptr; else { sal_Int32 nIncCurr = rListIndex - nPrevListIndex; if (nIncCurr < 0) nIncCurr += nListStrCount; if (i == 1) nInc = nIncCurr; else if (nInc != nIncCurr) rListData = nullptr; } } if (rListData) { rInc = nInc; rSkipOverlappedCells = true; return; } } short nFlag1, nFlag2; sal_Int32 nVal1, nVal2; nFlag1 = lcl_DecompValueString(aStr, nVal1, &rMinDigits); if (nFlag1) { bool bVal = true; rInc = 1; for (SCSIZE i = 1; i < nValueCount && bVal; i++) { nColCurr = nCol1 + rNonOverlappedCellIdx[i] * nAddX; nRowCurr = nRow1 + rNonOverlappedCellIdx[i] * nAddY; ScRefCellValue aCell = GetCellValue(nColCurr, nRowCurr); CellType eType = aCell.getType(); if (eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT) { aStr2 = aCell.getString(rDocument); nFlag2 = lcl_DecompValueString(aStr2, nVal2, &rMinDigits); if (nFlag1 == nFlag2 && aStr == aStr2) { double nDiff = approxDiff(nVal2, nVal1); if (i == 1) rInc = nDiff; else if (!::rtl::math::approxEqual(nDiff, rInc, 13)) bVal = false; nVal1 = nVal2; } else bVal = false; } else bVal = false; } if (bVal) { rCmd = FILL_LINEAR; rSkipOverlappedCells = true; return; } } } } } //if it is not a FILL_LINEAR - CELLTYPE_VALUE - with merged cells [without hidden values] //then do it in the old way SCCOL nCol = nCol1; SCROW nRow = nRow1; ScRefCellValue aFirstCell = GetCellValue(nCol, nRow); CellType eCellType = aFirstCell.getType(); if (eCellType == CELLTYPE_VALUE) { double fVal; sal_uInt32 nFormat = GetAttr(nCol,nRow,ATTR_VALUE_FORMAT)->GetValue(); const SvNumFormatType nFormatType = rDocument.GetFormatTable()->GetType(nFormat); bool bDate = (nFormatType == SvNumFormatType::DATE); // date without time bool bTime = (nFormatType == SvNumFormatType::TIME || nFormatType == SvNumFormatType::DAT bool bBooleanCell = (nFormatType == SvNumFormatType::LOGICAL); if (bDate) { if (nCount > 1) { double nVal; Date aNullDate = rDocument.GetFormatTable()->GetNullDate(); Date aDate1 = aNullDate; nVal = aFirstCell.getDouble(); aDate1.AddDays(nVal); Date aDate2 = aNullDate; nVal = GetValue(nCol+nAddX, nRow+nAddY); aDate2.AddDays(nVal); if ( aDate1 != aDate2 ) { tools::Long nCmpInc = 0; FillDateCmd eType; tools::Long nDDiff = aDate2.GetDay() - static_cast<tools::Long>(aDate1.GetDay()); tools::Long nMDiff = aDate2.GetMonth() - static_cast<tools::Long>(aDate1.GetMonth()); tools::Long nYDiff = aDate2.GetYear() - static_cast<tools::Long>(aDate1.GetYear()); if (nMDiff && aDate1.IsEndOfMonth() && aDate2.IsEndOfMonth()) { eType = FILL_END_OF_MONTH; nCmpInc = nMDiff + 12 * nYDiff; } else if (nDDiff) { eType = FILL_DAY; nCmpInc = aDate2 - aDate1; } else { eType = FILL_MONTH; nCmpInc = nMDiff + 12 * nYDiff; } nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); bool bVal = true; for (SCSIZE i=1; i<nCount && bVal; i++) { ScRefCellValue aCell = GetCellValue(nCol,nRow); if (aCell.getType() == CELLTYPE_VALUE) { nVal = aCell.getDouble(); aDate2 = aNullDate + static_cast<sal_Int32>(nVal); if ( eType == FILL_DAY ) { if ( aDate2-aDate1 != nCmpInc ) bVal = false; } else { nDDiff = aDate2.GetDay() - static_cast<tools::Long>(aDate1.GetDay()); nMDiff = aDate2.GetMonth() - static_cast<tools::Long>(aDate1.GetMonth()); nYDiff = aDate2.GetYear() - static_cast<tools::Long>(aDate1.GetYear()); if ((nDDiff && !aDate1.IsEndOfMonth() && !aDate2.IsEndOfMonth()) || (nMDiff + 12 * nYDiff != nCmpInc)) bVal = false; } aDate1 = aDate2; nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); } else bVal = false; // No date is also not ok } if (bVal) { if ((eType == FILL_MONTH || eType == FILL_END_OF_MONTH) && (nCmpInc % 12 == 0)) { eType = FILL_YEAR; nCmpInc /= 12; } rCmd = FILL_DATE; rDateCmd = eType; rInc = nCmpInc; } } else { // tdf#89754 - don't increment non different consecutive date cells rCmd = FILL_DATE; rDateCmd = FILL_DAY; rInc = 0.0; } } else // single date -> increment by days { rCmd = FILL_DATE; rDateCmd = FILL_DAY; rInc = 1.0; } } else if (bBooleanCell && ((fVal = aFirstCell.getDouble()) == 0.0 || fVal == 1.0)) { // Nothing, rInc stays 0.0, no specific fill mode. } else { if (nCount > 1) { tools::Duration aDuration; double nVal1 = aFirstCell.getDouble(); double nVal2 = GetValue(nCol+nAddX, nRow+nAddY); rInc = approxTypedDiff( nVal2, nVal1, bTime, aDuration); nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); bool bVal = true; for (SCSIZE i=1; i<nCount && bVal; i++) { ScRefCellValue aCell = GetCellValue(nCol,nRow); if (aCell.getType() == CELLTYPE_VALUE) { nVal2 = aCell.getDouble(); double nDiff = approxTypedDiff( nVal2, nVal1, bTime, aDuration); if ( !::rtl::math::approxEqual( nDiff, rInc, 13 ) ) bVal = false; else if ((nVal2 == 0.0 || nVal2 == 1.0) && (rDocument.GetFormatTable()->GetType(GetNumberFormat(nCol,nRow)) == SvNumFormatType::LOGICAL)) bVal = false; nVal1 = nVal2; } else bVal = false; nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); if (bVal && bTime) rDuration = aDuration; } if (bVal) rCmd = FILL_LINEAR; } else if(nFormatType == SvNumFormatType::PERCENT) { rInc = 0.01; // tdf#89998 increment by 1% at a time } } } else if (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT) { OUString aStr = GetString(nCol, nRow); rListData = const_cast<ScUserListData*>(ScGlobal::GetUserList().GetData(aStr)); if (rListData) { bool bMatchCase = false; (void)rListData->GetSubIndex(aStr, rListIndex, bMatchCase); size_t nListStrCount = rListData->GetSubCount(); sal_uInt16 nPrevListIndex, nInc = 1; nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); for (SCSIZE i=1; i<nCount && rListData; i++) { nPrevListIndex = rListIndex; aStr = GetString(nCol, nRow); if (!rListData->GetSubIndex(aStr, rListIndex, bMatchCase)) rListData = nullptr; else { sal_Int32 nIncCurr = rListIndex - nPrevListIndex; if (nIncCurr < 0) nIncCurr += nListStrCount; if (i == 1) nInc = nIncCurr; else if (nInc != nIncCurr) rListData = nullptr; } nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); } if (rListData) rInc = nInc; } else if ( nCount > 1 ) { // pass rMinDigits to all DecompValueString calls // -> longest number defines rMinDigits sal_Int32 nVal1; short nFlag1 = lcl_DecompValueString( aStr, nVal1, &rMinDigits ); if ( nFlag1 ) { sal_Int32 nVal2; aStr = GetString( nCol+nAddX, nRow+nAddY ); short nFlag2 = lcl_DecompValueString( aStr, nVal2, &rMinDigits ); if ( nFlag1 == nFlag2 ) { rInc = approxDiff( nVal2, nVal1); nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); bool bVal = true; for (SCSIZE i=1; i<nCount && bVal; i++) { ScRefCellValue aCell = GetCellValue(nCol, nRow); CellType eType = aCell.getType(); if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT ) { aStr = aCell.getString(rDocument); nFlag2 = lcl_DecompValueString( aStr, nVal2, &rMinDigits ); if ( nFlag1 == nFlag2 ) { double nDiff = approxDiff( nVal2, nVal1); if ( !::rtl::math::approxEqual( nDiff, rInc, 13 ) ) bVal = false; nVal1 = nVal2; } else bVal = false; } else bVal = false; nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); } if (bVal) rCmd = FILL_LINEAR; } } } else { // call DecompValueString to set rMinDigits sal_Int32 nDummy; lcl_DecompValueString( aStr, nDummy, &rMinDigits ); } } } void ScTable::FillFormula( const ScFormulaCell* pSrcCell, SCCOL nDestCol, SCROW nDestRow, bool bLast ) { rDocument.SetNoListening( true ); // still the wrong reference ScAddress aAddr( nDestCol, nDestRow, nTab ); ScFormulaCell* pDestCell = new ScFormulaCell( *pSrcCell, rDocument, aAddr ); aCol[nDestCol].SetFormulaCell(nDestRow, pDestCell); if ( bLast && pDestCell->GetMatrixFlag() != ScMatrixMode::NONE ) { ScAddress aOrg; if ( pDestCell->GetMatrixOrigin( GetDoc(), aOrg ) ) { if ( nDestCol >= aOrg.Col() && nDestRow >= aOrg.Row() ) { ScFormulaCell* pOrgCell = rDocument.GetFormulaCell(aOrg); if (pOrgCell && pOrgCell->GetMatrixFlag() == ScMatrixMode::Formula) { pOrgCell->SetMatColsRows( nDestCol - aOrg.Col() + 1, nDestRow - aOrg.Row() + 1 ); } else { OSL_FAIL( "FillFormula: MatrixOrigin no formula cell with ScMatrixMode::Formula" ); } } else { OSL_FAIL( "FillFormula: MatrixOrigin bottom right" ); } } else { OSL_FAIL( "FillFormula: no MatrixOrigin" ); } } rDocument.SetNoListening( false ); pDestCell->StartListeningTo( rDocument ); } void ScTable::FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt64 nFillCount, FillDir eFillDir, ScProgress* pProgress ) { if ( (nFillCount == 0) || !ValidColRow(nCol1, nRow1) || !ValidColRow(nCol2, nRow2) ) return; // Detect direction bool bVertical = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP); bool bPositive = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_RIGHT); SCCOLROW nCol = 0; SCCOLROW nRow = 0; SCCOLROW& rInner = bVertical ? nRow : nCol; // loop variables SCCOLROW& rOuter = bVertical ? nCol : nRow; SCCOLROW nOStart; SCCOLROW nOEnd; SCCOLROW nIStart; SCCOLROW nIEnd; SCCOLROW nISrcStart; SCCOLROW nISrcEnd; ScRange aFillRange; if (bVertical) { nOStart = nCol1; nOEnd = nCol2; if (bPositive) { nISrcStart = nRow1; nISrcEnd = nRow2; nIStart = nRow2 + 1; nIEnd = nRow2 + nFillCount; aFillRange = ScRange(nCol1, nRow2+1, 0, nCol2, nRow2 + nFillCount, 0); } else { nISrcStart = nRow2; nISrcEnd = nRow1; nIStart = nRow1 - 1; nIEnd = nRow1 - nFillCount; aFillRange = ScRange(nCol1, nRow1-1, 0, nCol2, nRow2 - nFillCount, 0); } } else { nOStart = nRow1; nOEnd = nRow2; if (bPositive) { nISrcStart = nCol1; nISrcEnd = nCol2; nIStart = nCol2 + 1; nIEnd = nCol2 + nFillCount; aFillRange = ScRange(nCol2 + 1, nRow1, 0, nCol2 + nFillCount, nRow2, 0); } else { nISrcStart = nCol2; nISrcEnd = nCol1; nIStart = nCol1 - 1; nIEnd = nCol1 - nFillCount; aFillRange = ScRange(nCol1 - 1, nRow1, 0, nCol1 - nFillCount, nRow2, 0); } } sal_uInt64 nIMin = nIStart; sal_uInt64 nIMax = nIEnd; PutInOrder(nIMin,nIMax); bool bHasFiltered = IsDataFiltered(aFillRange); if (!bHasFiltered) { if (bVertical) DeleteArea(nCol1, static_cast<SCROW>(nIMin), nCol2, static_cast<SCROW>(nIMax), InsertDel else DeleteArea(static_cast<SCCOL>(nIMin), nRow1, static_cast<SCCOL>(nIMax), nRow2, InsertDel } sal_uInt64 nProgress = 0; if (pProgress) nProgress = pProgress->GetState(); // Avoid possible repeated calls to StartListeningFormulaCells() (tdf#132165). std::list< sc::DelayStartListeningFormulaCells > delayStartListening; SCCOL delayStartColumn, delayEndColumn; if(bVertical) { delayStartColumn = std::min( nOStart, nOEnd ); delayEndColumn = std::max( nOStart, nOEnd ); } else { delayStartColumn = std::min( nIStart, nIEnd ); delayEndColumn = std::max( nIStart, nIEnd ); } for( SCROW col = delayStartColumn; col <= delayEndColumn; ++col ) { if( ScColumn* column = FetchColumn( col )) delayStartListening.emplace_back( *column, true ); } // execute sal_uInt64 nActFormCnt = 0; for (rOuter = nOStart; rOuter <= nOEnd; rOuter++) { sal_uInt64 nMaxFormCnt = 0; // for formulas // transfer attributes const ScPatternAttr* pSrcPattern = nullptr; const ScStyleSheet* pStyleSheet = nullptr; SCCOLROW nAtSrc = nISrcStart; std::unique_ptr<ScPatternAttr> pNewPattern; bool bGetPattern = true; rInner = nIStart; while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes { if (!ColHidden(nCol) && !RowHidden(nRow)) { if ( bGetPattern ) { if (bVertical) // rInner&:=nRow, rOuter&:=nCol pSrcPattern = GetColumnData(nCol).GetPattern(static_cast<SCROW>(nAtSrc)); else // rInner&:=nCol, rOuter&:=nRow pSrcPattern = GetColumnData(nAtSrc).GetPattern(static_cast<SCROW>(nRow)); bGetPattern = false; pStyleSheet = pSrcPattern->GetStyleSheet(); // do transfer ATTR_MERGE / ATTR_MERGE_FLAG // // Note: ATTR_MERGE is an attribute of the top left cell of a merged area // containing the size of the area. ATTR_MERGE_FLAGs are attributes of the // other cells of a merged area, containing the information about also // overlapping, i.e. visibility of their content. // // TODO: extend the similar incomplete selections to a bounding rectangle to // avoid incomplete fill, where not all AUTO_MERGE_FLAGs are synchronized with // the copied ATTR_MERGE, resulting broken grid and visibility during run-time. // // +--+ +--+--+ // | | | | | // +--+--+ +--+--+ // | | -> | | // +--+--+ +--+--+ // | | | | | // +--+ +--+--+ // // TODO: protect incompatible merged cells of the destination area, for example // by skipping the fill operation. // // TODO: by dragging the fill handle select only the multiples of the height // of the originally selected area which is merged vertically to avoid of // incomplete fill. // // +--+ +--+ // |XX| |XX| // +XX+ +XX+ // |XX| -> |XX| // +--+ +--+ // | | | | // +--+ +--+ // | | // +--+ // // Other things stored in ATTR_MERGE_FLAG, like autofilter button, will be // deleted now, but may need to be repaired later, like at ScDocument::Fill. const SfxItemSet& rSet = pSrcPattern->GetItemSet(); if ( rSet.GetItemState(ATTR_MERGE_FLAG, false) == SfxItemState::SET ) { ScMF nOldValue = pSrcPattern->GetItem(ATTR_MERGE_FLAG).GetValue(); ScMF nOldValueMerge = nOldValue & (ScMF::Hor | ScMF::Ver); // keep only the merge flags if ( nOldValue != nOldValueMerge ) { pNewPattern.reset(new ScPatternAttr(*pSrcPattern)); SfxItemSet& rNewSet = pNewPattern->GetItemSet(); if ( nOldValueMerge == ScMF::NONE ) rNewSet.ClearItem(ATTR_MERGE_FLAG); else rNewSet.Put(ScMergeFlagAttr(nOldValueMerge)); } else pNewPattern.reset(); } else pNewPattern.reset(); } const ScCondFormatItem& rCondFormatItem = pSrcPattern->GetItem(ATTR_CONDITIONAL); const ScCondFormatIndexes& rCondFormatIndex = rCondFormatItem.GetCondFormatData( if ( bVertical && nISrcStart == nISrcEnd && !bHasFiltered ) { // set all attributes at once (en bloc) if (pNewPattern || !pSrcPattern->isDefault()) { // Default is already present (DeleteArea) SCROW nY1 = static_cast<SCROW>(std::min( nIStart, nIEnd )); SCROW nY2 = static_cast<SCROW>(std::max( nIStart, nIEnd )); if ( pStyleSheet ) aCol[nCol].ApplyStyleArea( nY1, nY2, *pStyleSheet ); if ( pNewPattern ) aCol[nCol].ApplyPatternArea( nY1, nY2, *pNewPattern ); else aCol[nCol].ApplyPatternArea( nY1, nY2, *pSrcPattern ); for(const auto& rIndex : rCondFormatIndex) { ScConditionalFormat* pCondFormat = mpCondFormatList->GetFormat(rIndex); if (pCondFormat) { ScRangeList aRange = pCondFormat->GetRange(); aRange.Join(ScRange(nCol, nY1, nTab, nCol, nY2, nTab)); pCondFormat->SetRange(aRange); } } } break; } if ( bHasFiltered ) DeleteArea(static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), InsertDeleteFlags::AUTOFILL); if ( !ScPatternAttr::areSame(pSrcPattern, aCol[nCol].GetPattern( static_cast<SCROW>(nR { // Transfer template too //TODO: Merge ApplyPattern to AttrArray ?? if ( pStyleSheet ) aCol[nCol].ApplyStyle( static_cast<SCROW>(nRow), pStyleSheet ); // Use ApplyPattern instead of SetPattern to keep old MergeFlags if ( pNewPattern ) aCol[nCol].ApplyPattern( static_cast<SCROW>(nRow), *pNewPattern ); else aCol[nCol].ApplyPattern( static_cast<SCROW>(nRow), *pSrcPattern ); for(const auto& rIndex : rCondFormatIndex) { ScConditionalFormat* pCondFormat = mpCondFormatList->GetFormat(rIndex); if (pCondFormat) { ScRangeList aRange = pCondFormat->GetRange(); aRange.Join(ScRange(nCol, nRow, nTab, nCol, nRow, nTab)); pCondFormat->SetRange(aRange); } } } if (nAtSrc==nISrcEnd) { if ( nAtSrc != nISrcStart ) { // More than one source cell nAtSrc = nISrcStart; bGetPattern = true; } } else if (bPositive) { ++nAtSrc; bGetPattern = true; } else { --nAtSrc; bGetPattern = true; } } if (rInner == nIEnd) break; if (bPositive) ++rInner; else --rInner; } pNewPattern.reset(); // Analyse FillCmd eFillCmd; FillDateCmd eDateCmd = {}; double nInc; tools::Duration aDurationInc; sal_uInt16 nMinDigits; ScUserListData* pListData = nullptr; sal_uInt16 nListIndex; bool bSkipOverlappedCells; std::vector<sal_Int32> aNonOverlappedCellIdx; if (bVertical) FillAnalyse(static_cast<SCCOL>(nCol),nRow1, static_cast<SCCOL>(nCol),nRow2, eFillCmd,eDateCmd, nInc, aDurationInc, nMinDigits, pListData, nListIndex, bHasFiltered, bSkipOverlappedCells, aNonOverlappedCellIdx); else FillAnalyse(nCol1,static_cast<SCROW>(nRow), nCol2,static_cast<SCROW>(nRow), eFillCmd,eDateCmd, nInc, aDurationInc, nMinDigits, pListData, nListIndex, bHasFiltered, bSkipOverlappedCells, aNonOverlappedCellIdx); if (pListData) { sal_uInt16 nListCount = pListData->GetSubCount(); if (bSkipOverlappedCells) { int nFillerCount = 1 + ( nISrcEnd - nISrcStart ) * (bPositive ? 1 : -1); std::vector<bool> aIsNonEmptyCell(nFillerCount, false); SCCOLROW nLastValueIdx; if (bPositive) { nLastValueIdx = nISrcEnd - (nFillerCount - 1 - aNonOverlappedCellIdx.back()); for (auto i : aNonOverlappedCellIdx) aIsNonEmptyCell[i] = true; } else { nLastValueIdx = nISrcEnd + aNonOverlappedCellIdx[0]; for (auto i : aNonOverlappedCellIdx) aIsNonEmptyCell[nFillerCount - 1 - i] = true; } OUString aStr; if (bVertical) aStr = GetString(rOuter, nLastValueIdx); else aStr = GetString(nLastValueIdx, rOuter); bool bMatchCase = false; (void)pListData->GetSubIndex(aStr, nListIndex, bMatchCase); sal_Int32 nFillerIdx = 0; rInner = nIStart; while (true) { if (aIsNonEmptyCell[nFillerIdx]) { if (bPositive) { nListIndex += nInc; if (nListIndex >= nListCount) nListIndex -= nListCount; } else { if (nListIndex < nInc) nListIndex += nListCount; nListIndex -= nInc; } aCol[nCol].SetRawString(static_cast<SCROW>(nRow), pListData->GetSubStr(nListIndex)); } if (rInner == nIEnd) break; nFillerIdx = (nFillerIdx + 1) % nFillerCount; if (bPositive) ++rInner; else --rInner; } } else { if (!bPositive) { // nListIndex of FillAnalyse points to the last entry -> adjust sal_Int64 nAdjust = nListIndex - (nISrcStart - nISrcEnd) * nInc; nAdjust = nAdjust % nListCount; if (nAdjust < 0) nAdjust += nListCount; nListIndex = nAdjust; } rInner = nIStart; while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes { if (!ColHidden(nCol) && !RowHidden(nRow)) { if (bPositive) { nListIndex += nInc; if (nListIndex >= nListCount) nListIndex -= nListCount; } else { if (nListIndex < nInc) nListIndex += nListCount; nListIndex -= nInc; } aCol[nCol].SetRawString(static_cast<SCROW>(nRow), pListData->GetSubStr(nListIndex)); } if (rInner == nIEnd) break; if (bPositive) ++rInner; else --rInner; } } if(pProgress) { nProgress += nIMax - nIMin + 1; pProgress->SetStateOnPercent( nProgress ); } } else if (eFillCmd == FILL_SIMPLE) // fill with pattern/sample { FillAutoSimple( nISrcStart, nISrcEnd, nIStart, nIEnd, rInner, nCol, nRow, nActFormCnt, nMaxFormCnt, bHasFiltered, bVertical, bPositive, pProgress, nProgress); } else { if (!bPositive) { nInc = -nInc; aDurationInc = -aDurationInc; } double nEndVal = (nInc>=0.0) ? MAXDOUBLE : -MAXDOUBLE; if (bVertical) FillSeries( static_cast<SCCOL>(nCol), nRow1, static_cast<SCCOL>(nCol), nRow2, nFillCount, eFillDir, eFillCmd, eDateCmd, nInc, aDurationInc, nEndVal, nMinDigits, false, pProgress, bSkipOverlappedCells, &aNonOverlappedCellIdx); else FillSeries( nCol1, static_cast<SCROW>(nRow), nCol2, static_cast<SCROW>(nRow), nFillCount, eFillDir, eFillCmd, eDateCmd, nInc, aDurationInc, nEndVal, nMinDigits, false, pProgress, bSkipOverlappedCells, &aNonOverlappedCellIdx); if (pProgress) nProgress = pProgress->GetState(); } if (bVertical) FillSparkline(bVertical, nCol, nRow1, nRow2, nIStart, nIEnd); else FillSparkline(bVertical, nRow, nCol1, nCol2, nIStart, nIEnd); nActFormCnt += nMaxFormCnt; } } void ScTable::FillSparkline(bool bVertical, SCCOLROW nFixed, SCCOLROW nStart, SCCOLROW nEnd, SCCOLROW nFillStart, SCCOLROW nFillEnd) { bool bHasSparklines = false; std::vector<std::shared_ptr<sc::Sparkline>> aSparklineSeries; for (SCROW nCurrent = nStart; nCurrent <= nEnd; nCurrent++) { auto pSparkline = bVertical ? GetSparkline(nFixed, nCurrent) : GetSparkline(nCurrent, nFi bHasSparklines = bHasSparklines || pSparkline; aSparklineSeries.push_back(pSparkline); } if (bHasSparklines) { for (SCCOLROW nCurrent = nFillStart; nCurrent <= nFillEnd; nCurrent++) { size_t nIndex = size_t(nFillStart - nCurrent) % aSparklineSeries.size(); if (auto& rpSparkline = aSparklineSeries[nIndex]) { auto pGroup = rpSparkline->getSparklineGroup(); auto* pNewSparkline = bVertical ? CreateSparkline(nFixed, nCurrent, pGroup) : CreateSparkline(nCurrent, nFixed, pGroup); if (pNewSparkline) { SCCOLROW nPosition = bVertical ? rpSparkline->getRow() : rpSparkline->getColumn(); SCCOLROW nDelta = nCurrent - nPosition; ScRangeList aRangeList(rpSparkline->getInputRange()); for (ScRange& rRange : aRangeList) { if (bVertical) { rRange.aStart.IncRow(nDelta); rRange.aEnd.IncRow(nDelta); } else { rRange.aStart.IncCol(nDelta); rRange.aEnd.IncCol(nDelta); } } pNewSparkline->setInputRange(aRangeList); } } } } } void ScTable::GetBackColorArea(SCCOL& rStartCol, SCROW& /*rStartRow*/, SCCOL& rEndCol, SCROW& rEndRow ) const { bool bExtend; const SvxBrushItem* pDefBackground = &rDocument.GetPool()->GetUserOrPoolDefaultItem(ATTR_BACKGROUND); rStartCol = std::min<SCCOL>(rStartCol, aCol.size() - 1); rEndCol = std::min<SCCOL>(rEndCol, aCol.size() - 1); do { bExtend = false; if (rEndRow < rDocument.MaxRow()) { for (SCCOL nCol = rStartCol; nCol <= rEndCol; ++nCol) { const ScPatternAttr* pPattern = GetColumnData(nCol).GetPattern(rEndRow + 1); const SvxBrushItem* pBackground = &pPattern->GetItem(ATTR_BACKGROUND); if (!pPattern->GetItem(ATTR_CONDITIONAL).GetCondFormatData().empty() || (pBackground->GetColor() != COL_TRANSPARENT && pBackground != pDefBackground)) { bExtend = true; break; } } if (bExtend) ++rEndRow; } } while (bExtend); } OUString ScTable::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEn { OUString aValue; SCCOL nCol1 = rSource.aStart.Col(); SCROW nRow1 = rSource.aStart.Row(); SCCOL nCol2 = rSource.aEnd.Col(); SCROW nRow2 = rSource.aEnd.Row(); bool bOk = true; tools::Long nIndex = 0; sal_uInt64 nSrcCount = 0; FillDir eFillDir = FILL_TO_BOTTOM; if ( nEndX == nCol2 && nEndY == nRow2 ) // empty bOk = false; else if ( nEndX == nCol2 ) // to up / down { nCol2 = nCol1; // use only first column nSrcCount = nRow2 - nRow1 + 1; nIndex = static_cast<tools::Long>(nEndY) - nRow1; // can be negative if ( nEndY >= nRow1 ) eFillDir = FILL_TO_BOTTOM; else eFillDir = FILL_TO_TOP; } else if ( nEndY == nRow2 ) // to left / right { nEndY = nRow2 = nRow1; // use only first row nSrcCount = nCol2 - nCol1 + 1; nIndex = static_cast<tools::Long>(nEndX) - nCol1; // can be negative if ( nEndX >= nCol1 ) eFillDir = FILL_TO_RIGHT; else eFillDir = FILL_TO_LEFT; } else // direction not clear bOk = false; if ( bOk ) { tools::Long nBegin = 0; tools::Long nEnd = 0; tools::Long nHidden = 0; if (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP) { if (nEndY > nRow1) { nBegin = nRow2+1; nEnd = nEndY; } else { nBegin = nEndY; nEnd = nRow1 -1; } tools::Long nVisible = CountVisibleRows(nBegin, nEnd); nHidden = nEnd + 1 - nBegin - nVisible; } else { if (nEndX > nCol1) { nBegin = nCol2+1; nEnd = nEndX; } else { nBegin = nEndX; nEnd = nCol1 -1; } tools::Long nVisible = CountVisibleCols(nBegin, nEnd); nHidden = nEnd + 1 - nBegin - nVisible; } if (nHidden) { if (nIndex > 0) nIndex = nIndex - nHidden; else nIndex = nIndex + nHidden; } FillCmd eFillCmd; FillDateCmd eDateCmd; double nInc; tools::Duration aDurationInc; sal_uInt16 nMinDigits; ScUserListData* pListData = nullptr; sal_uInt16 nListIndex; bool bSkipOverlappedCells; std::vector<sal_Int32> aNonOverlappedCellIdx; // Todo: update this function to calculate with merged cell fills, // after FillAnalyse / FillSeries fully handle them. // Now FillAnalyse called as if there are filtered rows, so it will work in the old way. FillAnalyse(nCol1, nRow1, nCol2, nRow2, eFillCmd, eDateCmd, nInc, aDurationInc, nMinDigits, pListData, nListIndex, true, bSkipOverlappedCells, aNonOverlappedCellIdx); if ( pListData ) // user defined list { sal_uInt16 nListCount = pListData->GetSubCount(); if ( nListCount ) { sal_uInt64 nSub = nSrcCount - 1; // nListIndex is from last source entry while ( nIndex < sal::static_int_cast<tools::Long>(nSub) ) nIndex += nListCount; sal_uInt64 nPos = ( nListIndex + nIndex - nSub ) % nListCount; aValue = pListData->GetSubStr(sal::static_int_cast<sal_uInt16>(nPos)); } } else if ( eFillCmd == FILL_SIMPLE ) // fill with pattern/sample { tools::Long nPosIndex = nIndex; while ( nPosIndex < 0 ) nPosIndex += nSrcCount; sal_uInt64 nPos = nPosIndex % nSrcCount; SCCOL nSrcX = nCol1; SCROW nSrcY = nRow1; if ( eFillDir == FILL_TO_TOP || eFillDir == FILL_TO_BOTTOM ) nSrcY = sal::static_int_cast<SCROW>( nSrcY + static_cast<SCROW>(nPos) ); else nSrcX = sal::static_int_cast<SCCOL>( nSrcX + static_cast<SCCOL>(nPos) ); ScRefCellValue aCell = GetCellValue(nSrcX, nSrcY); if (!aCell.isEmpty()) { sal_Int32 nDelta; if (nIndex >= 0) nDelta = nIndex / nSrcCount; else nDelta = ( nIndex - nSrcCount + 1 ) / nSrcCount; // -1 -> -1 CellType eType = aCell.getType(); switch ( eType ) { case CELLTYPE_STRING: case CELLTYPE_EDIT: { aValue = aCell.getString(rDocument); if ( !(nScFillModeMouseModifier & KEY_MOD1) ) { sal_Int32 nVal; sal_uInt16 nCellDigits = 0; // look at each source cell individually short nFlag = lcl_DecompValueString( aValue, nVal, &nCellDigits ); if ( nFlag < 0 ) { if (aValue == ScGlobal::GetOrdinalSuffix( nVal)) aValue = ScGlobal::GetOrdinalSuffix( nVal + nDelta); aValue = lcl_ValueString( nVal + nDelta, nCellDigits ) + aValue; } else if ( nFlag > 0 ) { sal_Int32 nNextValue; if ( nVal < 0 ) nNextValue = nVal - nDelta; else nNextValue = nVal + nDelta; if ( nFlag == 2 && nNextValue >= 0 ) // Put back the '+' aValue += "+"; aValue += lcl_ValueString( nNextValue, nCellDigits ); } } } break; case CELLTYPE_VALUE: { sal_uInt32 nNumFmt = GetNumberFormat( nSrcX, nSrcY ); // overflow is possible... double nVal = aCell.getDouble(); if ( !(nScFillModeMouseModifier & KEY_MOD1) ) { const SvNumFormatType nFormatType = rDocument.GetFormatTable()->GetType(nNumFmt); bool bPercentCell = (nFormatType == SvNumFormatType::PERCENT); if (bPercentCell) { // tdf#89998 increment by 1% at a time nVal += static_cast<double>(nDelta) * 0.01; } else if (nVal == 0.0 || nVal == 1.0) { bool bBooleanCell = (nFormatType == SvNumFormatType::LOGICAL); if (!bBooleanCell) nVal += static_cast<double>(nDelta); } else { nVal += static_cast<double>(nDelta); } } const Color* pColor; rDocument.GetFormatTable()->GetOutputString( nVal, nNumFmt, aValue, &pColor ); } break; // not for formulas default: { // added to avoid warnings } } } } else if ( eFillCmd == FILL_LINEAR || eFillCmd == FILL_DATE ) // values { bool bValueOk; double nStart; sal_Int32 nVal = 0; short nHeadNoneTail = 0; ScRefCellValue aCell = GetCellValue(nCol1, nRow1); if (!aCell.isEmpty()) { CellType eType = aCell.getType(); switch ( eType ) { case CELLTYPE_STRING: case CELLTYPE_EDIT: { aValue = aCell.getString(rDocument); nHeadNoneTail = lcl_DecompValueString( aValue, nVal ); if ( nHeadNoneTail ) nStart = static_cast<double>(nVal); else nStart = 0.0; } break; case CELLTYPE_VALUE: nStart = aCell.getDouble(); break; case CELLTYPE_FORMULA: nStart = aCell.getFormula()->GetValue(); break; default: nStart = 0.0; } } else nStart = 0.0; if ( eFillCmd == FILL_LINEAR ) { if (aDurationInc) { bool bOverflow; tools::Duration aDuration( aDurationInc.Mult( nIndex, bOverflow)); bValueOk = SubTotal::SafePlus( nStart, aDuration.GetInDays()) && !bOverflow; } else { double nAdd = nInc; bValueOk = ( SubTotal::SafeMult( nAdd, static_cast<double>(nIndex) ) && SubTotal::SafePlus( nStart, nAdd ) ); } } else // date { bValueOk = true; sal_uInt16 nDayOfMonth = 0; if ( nIndex < 0 ) { nIndex = -nIndex; nInc = -nInc; } for (tools::Long i=0; i<nIndex; i++) IncDate( nStart, nDayOfMonth, nInc, eDateCmd ); } if (bValueOk) { if ( nHeadNoneTail ) { if ( nHeadNoneTail < 0 ) { if (aValue == ScGlobal::GetOrdinalSuffix( nVal)) aValue = ScGlobal::GetOrdinalSuffix( static_cast<sal_Int32>(nStart) ); aValue = lcl_ValueString( static_cast<sal_Int32>(nStart), nMinDigits ) + aValue; } else { if ( nHeadNoneTail == 2 && nStart >= 0 ) // Put back the '+' aValue += "+"; aValue += lcl_ValueString( static_cast<sal_Int32>(nStart), nMinDigits ); } } else { //TODO: get number format according to Index? const Color* pColor; sal_uInt32 nNumFmt = GetNumberFormat( nCol1, nRow1 ); rDocument.GetFormatTable()->GetOutputString( nStart, nNumFmt, aValue, &pColor ); } } } else { OSL_FAIL("GetAutoFillPreview: invalid mode"); } } return aValue; } void ScTable::IncDate(double& rVal, sal_uInt16& nDayOfMonth, double nStep, Fill { if (eCmd == FILL_DAY) { rVal += nStep; return; } // class Date limits const sal_uInt16 nMinYear = 1583; const sal_uInt16 nMaxYear = 9956; tools::Long nInc = static_cast<tools::Long>(nStep); // upper/lower limits ? Date aNullDate = rDocument.GetFormatTable()->GetNullDate(); Date aDate = aNullDate; aDate.AddDays(rVal); switch (eCmd) { case FILL_WEEKDAY: { aDate.AddDays(nInc); DayOfWeek eWeekDay = aDate.GetDayOfWeek(); if (nInc >= 0) { if (eWeekDay == SATURDAY) aDate.AddDays(2); else if (eWeekDay == SUNDAY) aDate.AddDays(1); } else { if (eWeekDay == SATURDAY) aDate.AddDays(-1); else if (eWeekDay == SUNDAY) aDate.AddDays(-2); } } break; case FILL_MONTH: case FILL_END_OF_MONTH: { if ( nDayOfMonth == 0 ) nDayOfMonth = aDate.GetDay(); // init tools::Long nMonth = aDate.GetMonth(); tools::Long nYear = aDate.GetYear(); nMonth += nInc; if (nInc >= 0) { if (nMonth > 12) { tools::Long nYAdd = (nMonth-1) / 12; nMonth -= nYAdd * 12; nYear += nYAdd; } } else { if (nMonth < 1) { tools::Long nYAdd = 1 - nMonth / 12; // positive nMonth += nYAdd * 12; nYear -= nYAdd; } } if ( nYear < nMinYear ) aDate = Date( 1,1, nMinYear ); else if ( nYear > nMaxYear ) aDate = Date( 31,12, nMaxYear ); else { aDate.SetMonth(static_cast<sal_uInt16>(nMonth)); aDate.SetYear(static_cast<sal_uInt16>(nYear)); if (eCmd == FILL_END_OF_MONTH) { aDate.SetDay(Date::GetDaysInMonth(nMonth, nYear)); } else { aDate.SetDay(std::min(Date::GetDaysInMonth(nMonth, nYear), nDayOfMonth)); } } } break; case FILL_YEAR: { tools::Long nYear = aDate.GetYear(); nYear += nInc; if ( nYear < nMinYear ) aDate = Date( 1,1, nMinYear ); else if ( nYear > nMaxYear ) aDate = Date( 31,12, nMaxYear ); else aDate.SetYear(static_cast<sal_uInt16>(nYear)); } break; default: { // added to avoid warnings } } rVal = aDate - aNullDate; } namespace { bool HiddenRowColumn(const ScTable* pTable, SCCOLROW nRowColumn, bool bVertical, SCCOLRO { bool bHidden = false; if(bVertical) { SCROW nLast; bHidden = pTable->RowHidden(nRowColumn, nullptr, &nLast); rLastPos = nLast; } else { SCCOL nLast; bHidden = pTable->ColHidden(static_cast<SCCOL>(nRowColumn), nullptr, &nLast); rLastPos = nLast; } return bHidden; } } void ScTable::FillFormulaVertical( const ScFormulaCell& rSrcCell, SCCOLROW& rInner, SCCOL nCol, SCROW nRow1, SCROW nRow2, ScProgress* pProgress, sal_uInt64& rProgress ) { // rInner is the row position when filling vertically. Also, when filling // across hidden regions, it may create multiple dis-jointed spans of // formula cells. bool bHidden = false; SCCOLROW nHiddenLast = -1; SCCOLROW nRowStart = -1, nRowEnd = -1; std::vector<sc::RowSpan> aSpans; PutInOrder(nRow1, nRow2); for (rInner = nRow1; rInner <= nRow2; ++rInner) { if (rInner > nHiddenLast) bHidden = HiddenRowColumn(this, rInner, true, nHiddenLast); if (bHidden) { if (nRowStart >= 0) { nRowEnd = rInner - 1; aSpans.emplace_back(nRowStart, nRowEnd); nRowStart = -1; } rInner = nHiddenLast; continue; } if (nRowStart < 0) nRowStart = rInner; } if (nRowStart >= 0) { nRowEnd = rInner - 1; aSpans.emplace_back(nRowStart, nRowEnd); } if (aSpans.empty()) return; aCol[nCol].DeleteRanges(aSpans, InsertDeleteFlags::VALUE | InsertDeleteFlags::DATET aCol[nCol].CloneFormulaCell(rSrcCell, sc::CellTextAttr(), aSpans); const auto pSet = std::make_shared<sc::ColumnBlockPositionSet>(rDocument); sc::StartListeningContext aStartCxt(rDocument, pSet); sc::EndListeningContext aEndCxt(rDocument, pSet); SCROW nStartRow = aSpans.front().mnRow1; SCROW nEndRow = aSpans.back().mnRow2; aCol[nCol].EndListeningFormulaCells(aEndCxt, nStartRow, nEndRow, &nStartRow, &nEndRow); aCol[nCol].StartListeningFormulaCells(aStartCxt, aEndCxt, nStartRow, nEndRow); for (const auto& rSpan : aSpans) aCol[nCol].SetDirty(rSpan.mnRow1, rSpan.mnRow2, ScColumn::BROADCAST_NONE); rProgress += nRow2 - nRow1 + 1; if (pProgress) pProgress->SetStateOnPercent(rProgress); } void ScTable::FillSeriesSimple( const ScCellValue& rSrcCell, SCCOLROW& rInner, SCCOLROW nIMin, SCCOLROW nIMax, const SCCOLROW& rCol, const SCCOLROW& rRow, bool bVertical, ScProgress* pProgress { bool bHidden = false; SCCOLROW nHiddenLast = -1; if (bVertical) { switch (rSrcCell.getType()) { case CELLTYPE_FORMULA: { FillFormulaVertical( *rSrcCell.getFormula(), rInner, rCol, nIMin, nIMax, pProgress, rProgress); } break; default: { for (rInner = nIMin; rInner <= nIMax; ++rInner) { if (rInner > nHiddenLast) bHidden = HiddenRowColumn(this, rInner, bVertical, nHiddenLast); if (bHidden) { rInner = nHiddenLast; continue; } ScAddress aDestPos(rCol, rRow, nTab); rSrcCell.commit(aCol[rCol], aDestPos.Row()); } rProgress += nIMax - nIMin + 1; if (pProgress) pProgress->SetStateOnPercent(rProgress); } } } else { switch (rSrcCell.getType()) { case CELLTYPE_FORMULA: { for (rInner = nIMin; rInner <= nIMax; ++rInner) { if (rInner > nHiddenLast) bHidden = HiddenRowColumn(this, rInner, bVertical, nHiddenLast); if (bHidden) continue; FillFormula(rSrcCell.getFormula(), rCol, rRow, (rInner == nIMax)); if (pProgress) pProgress->SetStateOnPercent(++rProgress); } } break; default: { for (rInner = nIMin; rInner <= nIMax; ++rInner) { if (rInner > nHiddenLast) bHidden = HiddenRowColumn(this, rInner, bVertical, nHiddenLast); if (bHidden) continue; ScAddress aDestPos(rCol, rRow, nTab); rSrcCell.commit(aCol[rCol], aDestPos.Row()); } rProgress += nIMax - nIMin + 1; if (pProgress) pProgress->SetStateOnPercent(rProgress); } } } } void ScTable::FillAutoSimple( SCCOLROW nISrcStart, SCCOLROW nISrcEnd, SCCOLROW nIStart, SCCOLROW nIEnd, SCCOLROW& rInner, const SCCOLROW& rCol, const SCCOLROW& rRow, sal_uInt64 nAct sal_uInt64 nMaxFormCnt, bool bHasFiltered, bool bVertical, bool bPositive, ScProgress* pProgress, sal_uInt64& rProgress ) { SCCOLROW nSource = nISrcStart; double nDelta; if ( nScFillModeMouseModifier & KEY_MOD1 ) nDelta = 0.0; else if ( bPositive ) nDelta = 1.0; else nDelta = -1.0; sal_uInt64 nFormulaCounter = nActFormCnt; bool bGetCell = true; bool bBooleanCell = false; bool bPercentCell = false; sal_uInt16 nCellDigits = 0; short nHeadNoneTail = 0; sal_Int32 nStringValue = 0; OUString aValue; ScCellValue aSrcCell; bool bIsOrdinalSuffix = false; bool bColHidden = false, bRowHidden = false; SCCOL nColHiddenFirst = rDocument.MaxCol(); SCCOL nColHiddenLast = -1; SCROW nRowHiddenFirst = rDocument.MaxRow(); SCROW nRowHiddenLast = -1; rInner = nIStart; while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes { if (bPositive) { if (rCol > nColHiddenLast) bColHidden = ColHidden(rCol, nullptr, &nColHiddenLast); if (rRow > nRowHiddenLast) bRowHidden = RowHidden(rRow, nullptr, &nRowHiddenLast); } else { if (rCol < nColHiddenFirst) bColHidden = ColHidden(rCol, &nColHiddenFirst); if (rRow < nRowHiddenFirst) bRowHidden = RowHidden(rRow, &nRowHiddenFirst); } if (!bColHidden && !bRowHidden) { if ( bGetCell ) { if (bVertical) // rInner&:=nRow, rOuter&:=nCol { aSrcCell = GetCellValue(rCol, nSource); if (nISrcStart == nISrcEnd && aSrcCell.getType() == CELLTYPE_FORMULA) { FillFormulaVertical(*aSrcCell.getFormula(), rInner, rCol, nIStart, nIEnd, pProgress, r return; } const SvNumFormatType nFormatType = rDocument.GetFormatTable()->GetType( GetColumnData(rCol).GetNumberFormat( rDocument.GetNonThreadedContext(), nSource)); bBooleanCell = (nFormatType == SvNumFormatType::LOGICAL); bPercentCell = (nFormatType == SvNumFormatType::PERCENT); } else // rInner&:=nCol, rOuter&:=nRow { aSrcCell = GetCellValue(nSource, rRow); const SvNumFormatType nFormatType = rDocument.GetFormatTable()->GetType( GetColumnData(nSource).GetNumberFormat( rDocument.GetNonThreadedContext(), rRow)); bBooleanCell = (nFormatType == SvNumFormatType::LOGICAL); bPercentCell = (nFormatType == SvNumFormatType::PERCENT); } bGetCell = false; if (!aSrcCell.isEmpty()) { switch (aSrcCell.getType()) { case CELLTYPE_STRING: case CELLTYPE_EDIT: if (aSrcCell.getType() == CELLTYPE_STRING) aValue = aSrcCell.getSharedString()->getString(); else aValue = ScEditUtil::GetString(*aSrcCell.getEditText(), rDocument); if ( !(nScFillModeMouseModifier & KEY_MOD1) && !bHasFiltered ) { nCellDigits = 0; // look at each source cell individually nHeadNoneTail = lcl_DecompValueString( aValue, nStringValue, &nCellDigits ); bIsOrdinalSuffix = aValue == ScGlobal::GetOrdinalSuffix(nStringValue); } break; default: { // added to avoid warnings } } } } switch (aSrcCell.getType()) { case CELLTYPE_VALUE: { double fVal; if (bBooleanCell && ((fVal = aSrcCell.getDouble()) == 0.0 || fVal == 1.0)) aCol[rCol].SetValue(rRow, aSrcCell.getDouble()); else if(bPercentCell) aCol[rCol].SetValue(rRow, aSrcCell.getDouble() + nDelta * 0.01); // tdf#89998 increment b else aCol[rCol].SetValue(rRow, aSrcCell.getDouble() + nDelta); } break; case CELLTYPE_STRING: case CELLTYPE_EDIT: if ( nHeadNoneTail ) { sal_Int32 nNextValue; if (nStringValue < 0) nNextValue = nStringValue - static_cast<sal_Int32>(nDelta); else nNextValue = nStringValue + static_cast<sal_Int32>(nDelta); if ( nHeadNoneTail < 0 ) { setSuffixCell( aCol[rCol], rRow, nNextValue, nCellDigits, aValue, aSrcCell.getType(), bIsOrdinalSuffix); } else { OUString aStr; if (nHeadNoneTail == 2 && nNextValue >= 0) // Put back the '+' aStr = aValue + "+" + lcl_ValueString(nNextValue, nCellDigits); else aStr = aValue + lcl_ValueString(nNextValue, nCellDigits); aCol[rCol].SetRawString(rRow, aStr); } } else aSrcCell.commit(aCol[rCol], rRow); break; case CELLTYPE_FORMULA : FillFormula( aSrcCell.getFormula(), rCol, rRow, (rInner == nIEnd)); if (nFormulaCounter - nActFormCnt > nMaxFormCnt) nMaxFormCnt = nFormulaCounter - nActFormCnt; break; default: { // added to avoid warnings } } if (nSource == nISrcEnd) { if ( nSource != nISrcStart ) { // More than one source cell nSource = nISrcStart; bGetCell = true; } if ( !(nScFillModeMouseModifier & KEY_MOD1) ) { if ( bPositive ) nDelta += 1.0; else nDelta -= 1.0; } nFormulaCounter = nActFormCnt; } else if (bPositive) { ++nSource; bGetCell = true; } else { --nSource; bGetCell = true; } } if (rInner == nIEnd) break; if (bPositive) ++rInner; else --rInner; // Progress in inner loop only for expensive cells, // and even then not individually for each one ++rProgress; if ( pProgress && (aSrcCell.getType() == CELLTYPE_FORMULA || aSrcCell.getType() == CELLTYPE_ pProgress->SetStateOnPercent( rProgress ); } if (pProgress) pProgress->SetStateOnPercent( rProgress ); } namespace { // Target value exceeded? inline bool isOverflow( const double& rVal, const double& rMax, const double& r const double& rStartVal, FillCmd eFillCmd ) { switch (eFillCmd) { case FILL_LINEAR: case FILL_DATE: if (rStep >= 0.0) return rVal > rMax; else return rVal < rMax; case FILL_GROWTH: if (rStep > 0.0) { if (rStep >= 1.0) { // Growing away from zero, including zero growth (1.0). if (rVal >= 0.0) return rVal > rMax; else return rVal < rMax; } else { // Shrinking towards zero. if (rVal >= 0.0) return rVal < rMax; else return rVal > rMax; } } else if (rStep < 0.0) { // Alternating positive and negative values. if (rStep <= -1.0) { // Growing away from zero, including zero growth (-1.0). if (rVal >= 0.0) { if (rMax >= 0.0) return rVal > rMax; else // Regard negative rMax as lower limit, which will // be reached only by a negative rVal. return false; } else { if (rMax <= 0.0) return rVal < rMax; else // Regard positive rMax as upper limit, which will // be reached only by a positive rVal. return false; } } else { // Shrinking towards zero. if (rVal >= 0.0) return rVal < rMax; else return rVal > rMax; } } else // if (rStep == 0.0) { // All values become zero. // Corresponds with bEntireArea in FillSeries(). if (rMax > 0.0) return rMax < rStartVal; else if (rMax < 0.0) return rStartVal < rMax; } break; default: assert(!"eFillCmd"); } return false; } } void ScTable::FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt64 nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, double nStepValue, const tools::Duration& rDurationStep, double nMaxValue, sal_uInt16 nArgMinDigits, bool bAttribs, ScProgress* pProgress, bool bSkipOverlappedCells, std::vector<sal_Int32>* pNonOverlappedCellIdx ) { // The term 'inner' here refers to the loop in the filling direction i.e. // when filling vertically, the inner position is the row position whereas // when filling horizontally the column position becomes the inner // position. The term 'outer' refers to the column position when filling // vertically, or the row position when filling horizontally. The fill is // performed once in each 'outer' position e.g. when filling vertically, // we perform the fill once in each column. // Detect direction bool bVertical = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP); bool bPositive = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_RIGHT); SCCOLROW nCol = 0; SCCOLROW nRow = 0; SCCOLROW& rInner = bVertical ? nRow : nCol; // loop variables SCCOLROW& rOuter = bVertical ? nCol : nRow; SCCOLROW nOStart; SCCOLROW nOEnd; SCCOLROW nIStart; SCCOLROW nIEnd; SCCOLROW nISource; ScRange aFillRange; sal_uInt64 nFillerCount; std::vector<bool> aIsNonEmptyCell; if (bVertical) { nFillerCount = (nRow2 - nRow1) + 1; nFillCount += (nRow2 - nRow1); if (nFillCount == 0) return; nOStart = nCol1; nOEnd = nCol2; if (bPositive) { // downward fill nISource = nRow1; // top row of the source range. nIStart = nRow1 + 1; // first row where we start filling. nIEnd = nRow1 + nFillCount; aFillRange = ScRange(nCol1, nRow1 + 1, nTab, nCol2, nRow1 + nFillCount, nTab); } else { // upward fill nISource = nRow2; nIStart = nRow2 - 1; nIEnd = nRow2 - nFillCount; aFillRange = ScRange(nCol1, nRow2 -1, nTab, nCol2, nRow2 - nFillCount, nTab); } } else { nFillerCount = (nCol2 - nCol1) + 1; nFillCount += (nCol2 - nCol1); if (nFillCount == 0) return; nOStart = nRow1; nOEnd = nRow2; if (bPositive) { // to the right nISource = nCol1; nIStart = nCol1 + 1; nIEnd = nCol1 + nFillCount; aFillRange = ScRange(nCol1 + 1, nRow1, nTab, nCol1 + nFillCount, nRow2, nTab); } else { // to the left nISource = nCol2; nIStart = nCol2 - 1; nIEnd = nCol2 - nFillCount; aFillRange = ScRange(nCol2 - 1, nRow1, nTab, nCol2 - nFillCount, nRow2, nTab); } } SCCOLROW nIMin = nIStart; SCCOLROW nIMax = nIEnd; PutInOrder(nIMin,nIMax); const bool bIsFiltered = IsDataFiltered(aFillRange); bool bEntireArea = (!bIsFiltered && eFillCmd == FILL_SIMPLE); if (!bIsFiltered && !bEntireArea && (eFillCmd == FILL_LINEAR || eFillCmd == FILL_GROWTH) && (nOEnd - nOStart == 0)) { // For the usual case of one col/row determine if a numeric series is // at least as long as the area to be filled and does not end earlier, // so we can treat it as entire area for performance reasons at least // in the vertical case. // This is not exact in case of merged cell fills with skipping overlapped parts, but // it is still a good upper estimation. ScCellValue aSrcCell; if (bVertical) aSrcCell = GetCellValue(static_cast<SCCOL>(nOStart), static_cast<SCROW>(nISource)); else aSrcCell = GetCellValue(static_cast<SCCOL>(nISource), static_cast<SCROW>(nOStart)); // Same logic as for the actual series. if (!aSrcCell.isEmpty() && (aSrcCell.getType() == CELLTYPE_VALUE || aSrcCell.getType() == C { double nStartVal; if (aSrcCell.getType() == CELLTYPE_VALUE) nStartVal = aSrcCell.getDouble(); else nStartVal = aSrcCell.getFormula()->GetValue(); if (eFillCmd == FILL_LINEAR) { if (nStepValue == 0.0) bEntireArea = (nStartVal <= nMaxValue); // fill with same value else if (((nMaxValue - nStartVal) / nStepValue) >= nFillCount) bEntireArea = true; } else if (eFillCmd == FILL_GROWTH) { if (nStepValue == 1.0) bEntireArea = (nStartVal <= nMaxValue); // fill with same value else if (nStepValue == -1.0) bEntireArea = (fabs(nStartVal) <= fabs(nMaxValue)); // fill with alternating value else if (nStepValue == 0.0) bEntireArea = (nStartVal == 0.0 || (nStartVal < 0.0 && nMaxValue >= 0.0) || (nStartVal > 0.0 && nMaxValue <= 0.0)); // fill with 0.0 } } } if (bEntireArea) { InsertDeleteFlags nDel = (bAttribs ? InsertDeleteFlags::AUTOFILL : (InsertDeleteFlags::AUTOFILL & InsertDeleteFlags::CONTENTS)); if (bVertical) DeleteArea(nCol1, static_cast<SCROW>(nIMin), nCol2, static_cast<SCROW>(nIMax), nDel); else DeleteArea(static_cast<SCCOL>(nIMin), nRow1, static_cast<SCCOL>(nIMax), nRow2, nDel); } sal_uInt64 nProgress = 0; if (pProgress) nProgress = pProgress->GetState(); // Perform the fill once per each 'outer' position i.e. one per column // when filling vertically. for (rOuter = nOStart; rOuter <= nOEnd; rOuter++) { rInner = nISource; CreateColumnIfNotExists(nCol); // Source cell value. We need to clone the value since it may be inserted repeatedly. ScCellValue aSrcCell = GetCellValue(nCol, static_cast<SCROW>(nRow)); // Maybe another source cell need to be searched, if the fill is going through merged cells, // where overlapped parts does not contain any information, so they can be skipped. if (bSkipOverlappedCells) { // create a vector to make it easier to decide if a cell need to be filled, or skipped. aIsNonEmptyCell.resize(nFillerCount, false); SCCOLROW nFirstValueIdx; if (bPositive) { nFirstValueIdx = nISource + (*pNonOverlappedCellIdx)[0]; for (auto i : (*pNonOverlappedCellIdx)) aIsNonEmptyCell[i] = true; } else { nFirstValueIdx = nISource - (nFillerCount - 1 - (*pNonOverlappedCellIdx).back()); for (auto i : (*pNonOverlappedCellIdx)) aIsNonEmptyCell[nFillerCount - 1 - i] = true; } //Set the real source cell if (bVertical) aSrcCell = GetCellValue(nOStart, static_cast<SCROW>(nFirstValueIdx)); else aSrcCell = GetCellValue(nFirstValueIdx, static_cast<SCROW>(nOStart)); } const ScPatternAttr* pSrcPattern = aCol[nCol].GetPattern(static_cast<SCROW>(nRow)); const ScCondFormatItem& rCondFormatItem = pSrcPattern->GetItem(ATTR_CONDITIONAL); const ScCondFormatIndexes& rCondFormatIndex = rCondFormatItem.GetCondFormatData( if (bAttribs) { if (bVertical) { // If entire area (not filtered and simple fill) use the faster // method, else hidden cols/rows should be skipped and series // fill needs to determine the end row dynamically. if (bEntireArea) { SetPatternAreaCondFormat( nCol, static_cast<SCROW>(nIMin), static_cast<SCROW>(nIMax), *pSrcPattern, rCondFormatIndex); } else if (eFillCmd == FILL_SIMPLE) { assert(bIsFiltered); for(SCROW nAtRow = static_cast<SCROW>(nIMin); nAtRow <= static_cast<SCROW>(nIMax); ++nAtRow) { if(!RowHidden(nAtRow)) { SetPatternAreaCondFormat( nCol, nAtRow, nAtRow, *pSrcPattern, rCondFormatIndex); } } } } else if (bEntireArea || eFillCmd == FILL_SIMPLE) { for (SCCOL nAtCol = static_cast<SCCOL>(nIMin); nAtCol <= sal::static_int_cast<SCCOL>(nIMax); { if(!ColHidden(nAtCol)) { SetPatternAreaCondFormat( nAtCol, nRow, nRow, *pSrcPattern, rCondFormatIndex); } } } } if (!aSrcCell.isEmpty()) { CellType eCellType = aSrcCell.getType(); if (eFillCmd == FILL_SIMPLE) // copy { FillSeriesSimple(aSrcCell, rInner, nIMin, nIMax, nCol, nRow, bVertical, pProgress, nProg } else if (eCellType == CELLTYPE_VALUE || eCellType == CELLTYPE_FORMULA) { const double nStartVal = (eCellType == CELLTYPE_VALUE ? aSrcCell.getDouble() : aSrcCell.getFormula()->GetValue()); double nVal = nStartVal; tools::Long nIndex = 0; bool bError = false; bool bOverflow = false; bool bNonEmpty = true; sal_uInt16 nDayOfMonth = 0; sal_Int32 nFillerIdx = 0; if (bSkipOverlappedCells && !aIsNonEmptyCell[0]) --nIndex; rInner = nIStart; while (true) { if (bSkipOverlappedCells) { nFillerIdx = (nFillerIdx + 1) % nFillerCount; bNonEmpty = aIsNonEmptyCell[nFillerIdx]; } if(!ColHidden(nCol) && !RowHidden(nRow)) { if (!bError && bNonEmpty) { switch (eFillCmd) { case FILL_LINEAR: { // use multiplication instead of repeated addition // to avoid accumulating rounding errors nVal = nStartVal; if (rDurationStep) { tools::Duration aDuration( rDurationStep.Mult( ++nIndex, bError)); bError |= !SubTotal::SafePlus( nVal, aDuration.GetInDays()); } else { double nAdd = nStepValue; if ( !SubTotal::SafeMult( nAdd, static_cast<double>(++nIndex) ) || !SubTotal::SafePlus( nVal, nAdd ) ) bError = true; } } break; case FILL_GROWTH: if (!SubTotal::SafeMult(nVal, nStepValue)) bError = true; break; case FILL_DATE: if (fabs(nVal) > D_MAX_LONG_) bError = true; else IncDate(nVal, nDayOfMonth, nStepValue, eFillDateCmd); break; default: { // added to avoid warnings } } if (!bError) bOverflow = isOverflow( nVal, nMaxValue, nStepValue, nStartVal, eFillCmd); } CreateColumnIfNotExists(nCol); if (bError) aCol[nCol].SetError(static_cast<SCROW>(nRow), FormulaError::NoValue); else if (!bOverflow && bNonEmpty) aCol[nCol].SetValue(static_cast<SCROW>(nRow), nVal); if (bAttribs && !bEntireArea && !bOverflow) SetPatternAreaCondFormat( nCol, nRow, nRow, *pSrcPattern, rCondFormatIndex); } if (rInner == nIEnd || bOverflow) break; if (bPositive) { ++rInner; } else { --rInner; } } nProgress += nIMax - nIMin + 1; if(pProgress) pProgress->SetStateOnPercent( nProgress ); } else if (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT) { if ( nStepValue >= 0 ) { if ( nMaxValue >= double(LONG_MAX) ) nMaxValue = double(LONG_MAX) - 1; } else { if ( nMaxValue <= double(LONG_MIN) ) nMaxValue = double(LONG_MIN) + 1; } OUString aValue; if (eCellType == CELLTYPE_STRING) aValue = aSrcCell.getSharedString()->getString(); else aValue = ScEditUtil::GetString(*aSrcCell.getEditText(), rDocument); sal_Int32 nStringValue; sal_uInt16 nMinDigits = nArgMinDigits; short nHeadNoneTail = lcl_DecompValueString( aValue, nStringValue, &nMinDigits ); if ( nHeadNoneTail ) { const double nStartVal = static_cast<double>(nStringValue); double nVal = nStartVal; tools::Long nIndex = 0; bool bError = false; bool bOverflow = false; bool bNonEmpty = true; bool bIsOrdinalSuffix = aValue == ScGlobal::GetOrdinalSuffix( static_cast<sal_Int32>(nStartVal)); sal_Int32 nFillerIdx = 0; if (bSkipOverlappedCells && !aIsNonEmptyCell[0]) --nIndex; rInner = nIStart; while (true) { if (bSkipOverlappedCells) { nFillerIdx = (nFillerIdx + 1) % nFillerCount; bNonEmpty = aIsNonEmptyCell[nFillerIdx]; } if(!ColHidden(nCol) && !RowHidden(nRow)) { if (!bError && bNonEmpty) { switch (eFillCmd) { case FILL_LINEAR: { // use multiplication instead of repeated addition // to avoid accumulating rounding errors nVal = nStartVal; if (rDurationStep) { tools::Duration aDuration( rDurationStep.Mult( ++nIndex, bError)); bError |= !SubTotal::SafePlus( nVal, aDuration.GetInDays()); } else { double nAdd = nStepValue; if ( !SubTotal::SafeMult( nAdd, static_cast<double>(++nIndex) ) || !SubTotal::SafePlus( nVal, nAdd ) ) bError = true; } } break; case FILL_GROWTH: if (!SubTotal::SafeMult(nVal, nStepValue)) bError = true; break; default: { // added to avoid warnings } } if (!bError) bOverflow = isOverflow( nVal, nMaxValue, nStepValue, nStartVal, eFillCmd); } if (bError) aCol[nCol].SetError(static_cast<SCROW>(nRow), FormulaError::NoValue); else if (!bOverflow && bNonEmpty) { nStringValue = static_cast<sal_Int32>(nVal); if ( nHeadNoneTail < 0 ) { setSuffixCell( aCol[nCol], static_cast<SCROW>(nRow), nStringValue, nMinDigits, aValue, eCellType, bIsOrdinalSuffix); } else { OUString aStr; if (nHeadNoneTail == 2 && nStringValue >= 0) // Put back the '+' aStr = aValue + "+"; else aStr = aValue; aStr += lcl_ValueString( nStringValue, nMinDigits ); aCol[nCol].SetRawString(static_cast<SCROW>(nRow), aStr); } } if (bAttribs && !bEntireArea && !bOverflow) SetPatternAreaCondFormat( nCol, nRow, nRow, *pSrcPattern, rCondFormatIndex); } if (rInner == nIEnd || bOverflow) break; if (bPositive) ++rInner; else --rInner; } } if(pProgress) { nProgress += nIMax - nIMin + 1; pProgress->SetStateOnPercent( nProgress ); } } } else if(pProgress) { nProgress += nIMax - nIMin + 1; pProgress->SetStateOnPercent( nProgress ); } } } void ScTable::Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt64 nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, double nStepValue, const tools::Duration& rDurationStep, double nMaxValue, ScProgress* pProgress) { if (eFillCmd == FILL_AUTO) FillAuto(nCol1, nRow1, nCol2, nRow2, nFillCount, eFillDir, pProgress); else FillSeries(nCol1, nRow1, nCol2, nRow2, nFillCount, eFillDir, eFillCmd, eFillDateCmd, nStepValue, rDurationStep, nMaxValue, 0, true, pProgress); } void ScTable::AutoFormatArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEnd const ScPatternAttr& rAttr, sal_uInt16 nFormatNo) { ScAutoFormat& rFormat = *ScGlobal::GetOrCreateAutoFormat(); ScAutoFormatData* pData = rFormat.findByIndex(nFormatNo); if (pData) { ApplyPatternArea(nStartCol, nStartRow, nEndCol, nEndRow, rAttr); } } void ScTable::AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, sal_uInt16 nFormatNo, ScProgress* pProgress ) { if (!(ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))) return; ScAutoFormat& rFormat = *ScGlobal::GetOrCreateAutoFormat(); ScAutoFormatData* pData = rFormat.findByIndex(nFormatNo); if (!pData) return; std::unique_ptr<ScPatternAttr> pPatternAttrs[16]; for (sal_uInt8 i = 0; i < 16; ++i) { pPatternAttrs[i].reset(new ScPatternAttr(rDocument.getCellAttributeHelper())); pData->FillToItemSet(i, pPatternAttrs[i]->GetItemSet(), rDocument); } // Important special case: when the whole rows are selected. Then applying autoformat to right // column individually would create all columns. In this case, assume that right column isn't // needed, to allow "to the end of row" format optimization (which doesn't create columns). // Keep left column in this case, because it may be pre-formatted for categories. To enable the // optimization, apply uniform format row by row where possible, not column by column. const bool isWholeRows = nStartCol == 0 && nEndCol == rDocument.MaxCol(); //////////////////////////////////////////////////////////////////////////////// // Top row data indexes: // 0 - left corner style // 1 - odd columns style // 2 - even column style // 3 - right corner style //////////////////////////////////////////////////////////////////////////////// SCCOL startOffset = 1; // Left top corner if (pData->HasSameData(0, 1) && pData->HasSameData(0, 2)) startOffset = 0; // Left corner is same as the rest of the row else AutoFormatArea(nStartCol, nStartRow, nStartCol, nStartRow, *pPatternAttrs[0], nFormat SCCOL endOffset = 1; // Right top corner: ignore when whole rows selected if (isWholeRows || (pData->HasSameData(3, 1) && pData->HasSameData(3, 2))) endOffset = 0; // Right corner is same as the rest of the row (most important case) else AutoFormatArea(nEndCol, nStartRow, nEndCol, nStartRow, *pPatternAttrs[3], nFormatNo); // Top row if (pData->HasSameData(1, 2)) AutoFormatArea(nStartCol + startOffset, nStartRow, nEndCol - endOffset, nStartRow, *pPat else { sal_uInt16 nIndex = 1; for (SCCOL nCol = nStartCol + startOffset; nCol <= nEndCol - endOffset; nCol++) { AutoFormatArea(nCol, nStartRow, nCol, nStartRow, *pPatternAttrs[nIndex], nFormatNo); if (nIndex == 1) nIndex = 2; else nIndex = 1; } } //////////////////////////////////////////////////////////////////////////////// // Body data indexes: // 4 - left column odd row style // 8 - left column even row style // 7 - right column odd row style // 11 - right column even row style // 5 - body odd column odd row style // 6 - body even column odd row style // 9 - body odd column even row style // 10 - body even column even row style //////////////////////////////////////////////////////////////////////////////// startOffset = 1; // Left column if (pData->HasSameData(4, 5) && pData->HasSameData(4, 6) && pData->HasSameData(8, 9) && pData->HasSa startOffset = 0; // Left column is same as the lines of the body else { if (pData->HasSameData(4, 8)) // even and odd rows are same AutoFormatArea(nStartCol, nStartRow + 1, nStartCol, nEndRow - 1, *pPatternAttrs[4], nForm else { sal_uInt16 nIndex = 4; for (SCROW nRow = nStartRow + 1; nRow < nEndRow; nRow++) { AutoFormatArea(nStartCol, nRow, nStartCol, nRow, *pPatternAttrs[nIndex], nFormatNo); if (nIndex == 4) nIndex = 8; else nIndex = 4; } } } endOffset = 1; // Right column: ignore when whole rows selected if (isWholeRows || (pData->HasSameData(7, 5) && pData->HasSameData(7, 6) && pData->HasSameData(1 endOffset = 0; // Right column is same as the lines of the body (most important case) else { if (pData->HasSameData(7, 11)) // even and odd rows are same AutoFormatArea(nEndCol, nStartRow + 1, nEndCol, nEndRow - 1, *pPatternAttrs[7], nFormatNo else { sal_uInt16 nIndex = 7; for (SCROW nRow = nStartRow + 1; nRow < nEndRow; nRow++) { AutoFormatArea(nEndCol, nRow, nEndCol, nRow, *pPatternAttrs[nIndex], nFormatNo); if (nIndex == 7) nIndex = 11; else nIndex = 7; } } } // Body if (pData->HasSameData(5, 6) && pData->HasSameData(9, 10)) // Odd and even columns are same (most { if (pData->HasSameData(5, 9)) // Everything is the same AutoFormatArea(nStartCol + startOffset, nStartRow + 1, nEndCol - endOffset, nEndRow - 1, *pP else // Odd and even rows differ { if (pProgress) pProgress->SetState(1, nEndRow - nStartRow + 3); // account for elements outside the "Body" bl sal_uInt16 nIndex = 5; for (SCROW nRow = nStartRow + 1; nRow < nEndRow; nRow++) { AutoFormatArea(nStartCol + startOffset, nRow, nEndCol - endOffset, nRow, *pPatternAttrs[ if (nIndex == 5) nIndex = 9; else nIndex = 5; if (pProgress) pProgress->SetStateOnPercent(nRow - nStartRow + 1); } } } else if (pData->HasSameData(5, 9) && pData->HasSameData(6, 10)) // odd and even rows are same { if (pProgress) pProgress->SetState(1, nEndCol - nStartCol + 3); // account for elements outside the "Body" bl sal_uInt16 nIndex = 5; for (SCCOL nCol = nStartCol + startOffset; nCol <= nEndCol - endOffset; nCol++) { AutoFormatArea(nCol, nStartRow + 1, nCol, nEndRow - 1, *pPatternAttrs[nIndex], nFormatNo) if (nIndex == 5) nIndex = 6; else nIndex = 5; if (pProgress) pProgress->SetStateOnPercent(nCol - nStartCol + 1); } } else // Everything is different { if (pProgress) pProgress->SetState(1, nEndCol - nStartCol + 3); // account for elements outside the "Body" bl sal_uInt16 nIndex = 5; for (SCCOL nCol = nStartCol + startOffset; nCol <= nEndCol - endOffset; nCol++) { for (SCROW nRow = nStartRow + 1; nRow < nEndRow; nRow++) { AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); if ((nIndex == 5) || (nIndex == 9)) { if (nIndex == 5) nIndex = 9; else nIndex = 5; } else { if (nIndex == 6) nIndex = 10; else nIndex = 6; } } // for nRow if ((nIndex == 5) || (nIndex == 9)) nIndex = 6; else nIndex = 5; if (pProgress) pProgress->SetStateOnPercent(nCol - nStartCol + 1); } // for nCol } // if not all equal //////////////////////////////////////////////////////////////////////////////// // Bottom row data indexes: // 12 - left corner style // 13 - odd columns style // 14 - even column style // 15 - right corner style //////////////////////////////////////////////////////////////////////////////// startOffset = 1; // Left bottom corner if (pData->HasSameData(12, 13) && pData->HasSameData(12, 14)) startOffset = 0; else AutoFormatArea(nStartCol, nEndRow, nStartCol, nEndRow, *pPatternAttrs[12], nFormatNo) endOffset = 1; // Right bottom corner: ignore when whole rows selected if (isWholeRows || (pData->HasSameData(15, 13) && pData->HasSameData(15, 14))) endOffset = 0; else AutoFormatArea(nEndCol, nEndRow, nEndCol, nEndRow, *pPatternAttrs[15], nFormatNo); // Bottom row if (pData->HasSameData(13, 14)) AutoFormatArea(nStartCol + startOffset, nEndRow, nEndCol - endOffset, nEndRow, *pPattern else { sal_uInt16 nIndex = 13; for (SCCOL nCol = nStartCol + startOffset; nCol <= nEndCol - endOffset; nCol++) { AutoFormatArea(nCol, nEndRow, nCol, nEndRow, *pPatternAttrs[nIndex], nFormatNo); if (nIndex == 13) nIndex = 14; else nIndex = 13; } } } void ScTable::GetAutoFormatAttr(SCCOL nCol, SCROW nRow, sal_uInt16 nIndex, ScAutoFormat { sal_uInt32 nFormatIndex = GetNumberFormat( nCol, nRow ); ScNumFormatAbbrev aNumFormat( nFormatIndex, *rDocument.GetFormatTable() ); rData.GetFromItemSet( nIndex, GetPattern( nCol, nRow )->GetItemSet(), aNumFormat ); } #define LF_LEFT 1 #define LF_TOP 2 #define LF_RIGHT 4 #define LF_BOTTOM 8 #define LF_ALL (LF_LEFT | LF_TOP | LF_RIGHT | LF_BOTTOM) void ScTable::GetAutoFormatFrame(SCCOL nCol, SCROW nRow, sal_uInt16 nFlags, sal_uInt16 n { const SvxBoxItem* pTheBox = GetAttr(nCol, nRow, ATTR_BORDER); const SvxBoxItem* pLeftBox = GetAttr(nCol - 1, nRow, ATTR_BORDER); const SvxBoxItem* pTopBox = GetAttr(nCol, nRow - 1, ATTR_BORDER); const SvxBoxItem* pRightBox = GetAttr(nCol + 1, nRow, ATTR_BORDER); const SvxBoxItem* pBottomBox = GetAttr(nCol, nRow + 1, ATTR_BORDER); SvxBoxItem aBox( ATTR_BORDER ); if (nFlags & LF_LEFT) { if (pLeftBox) { if (ScHasPriority(pTheBox->GetLeft(), pLeftBox->GetRight())) aBox.SetLine(pTheBox->GetLeft(), SvxBoxItemLine::LEFT); else aBox.SetLine(pLeftBox->GetRight(), SvxBoxItemLine::LEFT); } else aBox.SetLine(pTheBox->GetLeft(), SvxBoxItemLine::LEFT); } if (nFlags & LF_TOP) { if (pTopBox) { if (ScHasPriority(pTheBox->GetTop(), pTopBox->GetBottom())) aBox.SetLine(pTheBox->GetTop(), SvxBoxItemLine::TOP); else aBox.SetLine(pTopBox->GetBottom(), SvxBoxItemLine::TOP); } else aBox.SetLine(pTheBox->GetTop(), SvxBoxItemLine::TOP); } if (nFlags & LF_RIGHT) { if (pRightBox) { if (ScHasPriority(pTheBox->GetRight(), pRightBox->GetLeft())) aBox.SetLine(pTheBox->GetRight(), SvxBoxItemLine::RIGHT); else aBox.SetLine(pRightBox->GetLeft(), SvxBoxItemLine::RIGHT); } else aBox.SetLine(pTheBox->GetRight(), SvxBoxItemLine::RIGHT); } if (nFlags & LF_BOTTOM) { if (pBottomBox) { if (ScHasPriority(pTheBox->GetBottom(), pBottomBox->GetTop())) aBox.SetLine(pTheBox->GetBottom(), SvxBoxItemLine::BOTTOM); else aBox.SetLine(pBottomBox->GetTop(), SvxBoxItemLine::BOTTOM); } else aBox.SetLine(pTheBox->GetBottom(), SvxBoxItemLine::BOTTOM); } rData.PutItem( nIndex, aBox ); } void ScTable::GetAutoFormatData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW n { if (!(ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))) return; if ((nEndCol - nStartCol < 3) || (nEndRow - nStartRow < 3)) return; // Left top corner GetAutoFormatAttr(nStartCol, nStartRow, 0, rData); GetAutoFormatFrame(nStartCol, nStartRow, LF_ALL, 0, rData); // Left column GetAutoFormatAttr(nStartCol, nStartRow + 1, 4, rData); GetAutoFormatAttr(nStartCol, nStartRow + 2, 8, rData); GetAutoFormatFrame(nStartCol, nStartRow + 1, LF_LEFT | LF_RIGHT | LF_BOTTOM, 4, rData); if (nEndRow - nStartRow >= 4) GetAutoFormatFrame(nStartCol, nStartRow + 2, LF_LEFT | LF_RIGHT | LF_BOTTOM, 8, rData); else rData.CopyItem( 8, 4, ATTR_BORDER ); // Left bottom corner GetAutoFormatAttr(nStartCol, nEndRow, 12, rData); GetAutoFormatFrame(nStartCol, nEndRow, LF_ALL, 12, rData); // Right top corner GetAutoFormatAttr(nEndCol, nStartRow, 3, rData); GetAutoFormatFrame(nEndCol, nStartRow, LF_ALL, 3, rData); // Right column GetAutoFormatAttr(nEndCol, nStartRow + 1, 7, rData); GetAutoFormatAttr(nEndCol, nStartRow + 2, 11, rData); GetAutoFormatFrame(nEndCol, nStartRow + 1, LF_LEFT | LF_RIGHT | LF_BOTTOM, 7, rData); if (nEndRow - nStartRow >= 4) GetAutoFormatFrame(nEndCol, nStartRow + 2, LF_LEFT | LF_RIGHT | LF_BOTTOM, 11, rData); else rData.CopyItem( 11, 7, ATTR_BORDER ); // Right bottom corner GetAutoFormatAttr(nEndCol, nEndRow, 15, rData); GetAutoFormatFrame(nEndCol, nEndRow, LF_ALL, 15, rData); // Top row GetAutoFormatAttr(nStartCol + 1, nStartRow, 1, rData); GetAutoFormatAttr(nStartCol + 2, nStartRow, 2, rData); GetAutoFormatFrame(nStartCol + 1, nStartRow, LF_TOP | LF_BOTTOM | LF_RIGHT, 1, rData); if (nEndCol - nStartCol >= 4) GetAutoFormatFrame(nStartCol + 2, nStartRow, LF_TOP | LF_BOTTOM | LF_RIGHT, 2, rData); else rData.CopyItem( 2, 1, ATTR_BORDER ); // Bottom row GetAutoFormatAttr(nStartCol + 1, nEndRow, 13, rData); GetAutoFormatAttr(nStartCol + 2, nEndRow, 14, rData); GetAutoFormatFrame(nStartCol + 1, nEndRow, LF_TOP | LF_BOTTOM | LF_RIGHT, 13, rData); if (nEndCol - nStartCol >= 4) GetAutoFormatFrame(nStartCol + 2, nEndRow, LF_TOP | LF_BOTTOM | LF_RIGHT, 14, rData); else rData.CopyItem( 14, 13, ATTR_BORDER ); // Body GetAutoFormatAttr(nStartCol + 1, nStartRow + 1, 5, rData); GetAutoFormatAttr(nStartCol + 2, nStartRow + 1, 6, rData); GetAutoFormatAttr(nStartCol + 1, nStartRow + 2, 9, rData); GetAutoFormatAttr(nStartCol + 2, nStartRow + 2, 10, rData); GetAutoFormatFrame(nStartCol + 1, nStartRow + 1, LF_RIGHT | LF_BOTTOM, 5, rData); if ((nEndCol - nStartCol >= 4) && (nEndRow - nStartRow >= 4)) { GetAutoFormatFrame(nStartCol + 2, nStartRow + 1, LF_RIGHT | LF_BOTTOM, 6, rData); GetAutoFormatFrame(nStartCol + 1, nStartRow + 2, LF_RIGHT | LF_BOTTOM, 9, rData); GetAutoFormatFrame(nStartCol + 2, nStartRow + 2, LF_RIGHT | LF_BOTTOM, 10, rData); } else { rData.CopyItem( 6, 5, ATTR_BORDER ); rData.CopyItem( 9, 5, ATTR_BORDER ); rData.CopyItem( 10, 5, ATTR_BORDER ); } } void ScTable::SetError( SCCOL nCol, SCROW nRow, FormulaError nError) { if (ValidColRow(nCol, nRow)) CreateColumnIfNotExists(nCol).SetError(nRow, nError); } void ScTable::UpdateInsertTabAbs(SCTAB nTable) { for (SCCOL i=0; i < aCol.size(); i++) aCol[i].UpdateInsertTabAbs(nTable); } bool ScTable::GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, bool bInSel, const ScMarkData& rMark) const { if (rRow == rDocument.MaxRow()+2) // end of table { rRow = 0; rCol = 0; } else { rRow++; if (rRow == rDocument.MaxRow()+1) { rCol++; rRow = 0; } } if (rCol == rDocument.MaxCol()+1) return true; for (;;) { if (!ValidCol(rCol)) return true; if (rCol >= GetAllocatedColumnsCount()) return true; if (aCol[rCol].GetNextSpellingCell(rRow, bInSel, rMark)) return true; /*else (rRow == rDocument.MaxRow()+1) */ rCol++; rRow = 0; } } void ScTable::TestTabRefAbs(SCTAB nTable) const { for (SCCOL i=0; i < aCol.size(); i++) if (aCol[i].TestTabRefAbs(nTable)) return; } void ScTable::CompileDBFormula( sc::CompileFormulaContext& rCxt ) { for (SCCOL i = 0; i < aCol.size(); ++i) aCol[i].CompileDBFormula(rCxt); } void ScTable::CompileColRowNameFormula( sc::CompileFormulaContext& rCxt ) { for (SCCOL i = 0; i < aCol.size(); ++i) aCol[i].CompileColRowNameFormula(rCxt); } SCSIZE ScTable::GetPatternCount( SCCOL nCol ) const { if( ValidCol( nCol ) ) return aCol[nCol].GetPatternCount(); else return 0; } SCSIZE ScTable::GetPatternCount( SCCOL nCol, SCROW nRow1, SCROW nRow2 ) const { if( ValidCol( nCol ) && ValidRow( nRow1 ) && ValidRow( nRow2 ) ) return aCol[nCol].GetPatternCount( nRow1, nRow2 ); else return 0; } bool ScTable::ReservePatternCount( SCCOL nCol, SCSIZE nReserve ) { if( ValidCol( nCol ) ) return aCol[nCol].ReservePatternCount( nReserve ); else return false; } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
¤ Dauer der Verarbeitung: 0.63 Sekunden (vorverarbeitet am 2026-04-26) ¤*© Formatika GbR, Deutschland |
|
||||||||||||||
2026-05-26