| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| // System - Includes ----------------------------------------------------- |
| |
| |
| |
| #ifdef _MSC_VER |
| #pragma optimize("",off) |
| // sonst Absturz Win beim Fuellen |
| #endif |
| |
| // INCLUDE --------------------------------------------------------------- |
| |
| #include "scitems.hxx" |
| #include <svx/algitem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/brshitem.hxx> |
| #include <editeng/cntritem.hxx> |
| #include <editeng/colritem.hxx> |
| #include <editeng/crsditem.hxx> |
| #include <editeng/fhgtitem.hxx> |
| #include <editeng/fontitem.hxx> |
| #include <editeng/langitem.hxx> |
| #include <editeng/postitem.hxx> |
| #include <editeng/shdditem.hxx> |
| #include <editeng/udlnitem.hxx> |
| #include <editeng/wghtitem.hxx> |
| #include <svx/rotmodit.hxx> |
| #include <editeng/editobj.hxx> |
| #include <editeng/editeng.hxx> |
| #include <editeng/eeitem.hxx> |
| #include <editeng/escpitem.hxx> |
| #include <svl/zforlist.hxx> |
| #include <vcl/keycodes.hxx> |
| #include <rtl/math.hxx> |
| #include <unotools/charclass.hxx> |
| |
| #include "attrib.hxx" |
| #include "patattr.hxx" |
| #include "cell.hxx" |
| #include "table.hxx" |
| #include "globstr.hrc" |
| #include "global.hxx" |
| #include "document.hxx" |
| #include "autoform.hxx" |
| #include "userlist.hxx" |
| #include "zforauto.hxx" |
| #include "subtotal.hxx" |
| #include "formula/errorcodes.hxx" |
| #include "rangenam.hxx" |
| #include "docpool.hxx" |
| #include "progress.hxx" |
| #include "segmenttree.hxx" |
| |
| #include <math.h> |
| |
| // STATIC DATA ----------------------------------------------------------- |
| |
| #define _D_MAX_LONG_ (double) 0x7fffffff |
| |
| extern sal_uInt16 nScFillModeMouseModifier; // global.cxx |
| |
| // ----------------------------------------------------------------------- |
| |
| short lcl_DecompValueString( String& aValue, sal_Int32& nVal, sal_uInt16* pMinDigits = NULL ) |
| { |
| if ( !aValue.Len() ) |
| { |
| nVal = 0; |
| return 0; |
| } |
| const sal_Unicode* p = aValue.GetBuffer(); |
| xub_StrLen nNeg = 0; |
| xub_StrLen nNum = 0; |
| if ( p[nNum] == '-' ) |
| nNum = nNeg = 1; |
| while ( p[nNum] && CharClass::isAsciiNumeric( p[nNum] ) ) |
| nNum++; |
| |
| sal_Unicode cNext = p[nNum]; // 0 if at the end |
| sal_Unicode cLast = p[aValue.Len()-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 > nNeg && ( cNext == 0 || cNext == ' ' || !CharClass::isAsciiNumeric(cLast) ) ) |
| { // number at the beginning |
| nVal = aValue.Copy( 0, nNum ).ToInt32(); |
| // #60893# any number with a leading zero sets the minimum number of digits |
| if ( p[nNeg] == '0' && pMinDigits && ( nNum - nNeg > *pMinDigits ) ) |
| *pMinDigits = nNum - nNeg; |
| aValue.Erase( 0, nNum ); |
| return -1; |
| } |
| else |
| { |
| nNeg = 0; |
| xub_StrLen nEnd = nNum = aValue.Len() - 1; |
| while ( nNum && CharClass::isAsciiNumeric( p[nNum] ) ) |
| nNum--; |
| if ( p[nNum] == '-' ) |
| { |
| nNum--; |
| nNeg = 1; |
| } |
| if ( nNum < nEnd - nNeg ) |
| { // number at the end |
| nVal = aValue.Copy( nNum + 1 ).ToInt32(); |
| // #60893# any number with a leading zero sets the minimum number of digits |
| if ( p[nNum+1+nNeg] == '0' && pMinDigits && ( nEnd - nNum - nNeg > *pMinDigits ) ) |
| *pMinDigits = nEnd - nNum - nNeg; |
| aValue.Erase( nNum + 1 ); |
| return 1; |
| } |
| } |
| nVal = 0; |
| return 0; |
| } |
| |
| String lcl_ValueString( sal_Int32 nValue, sal_uInt16 nMinDigits ) |
| { |
| if ( nMinDigits <= 1 ) |
| return String::CreateFromInt32( nValue ); // simple case... |
| else |
| { |
| String aStr = String::CreateFromInt32( Abs( nValue ) ); |
| if ( aStr.Len() < nMinDigits ) |
| { |
| String aZero; |
| aZero.Fill( nMinDigits - aStr.Len(), '0' ); |
| aStr.Insert( aZero, 0 ); |
| } |
| // nMinDigits doesn't include the '-' sign -> add after inserting zeros |
| if ( nValue < 0 ) |
| aStr.Insert( '-', 0 ); |
| return aStr; |
| } |
| } |
| |
| static ScBaseCell * lcl_getSuffixCell( ScDocument* pDocument, sal_Int32 nValue, |
| sal_uInt16 nDigits, const String& rSuffix, CellType eCellType, |
| sal_Bool bIsOrdinalSuffix ) |
| { |
| String aValue( lcl_ValueString( nValue, nDigits )); |
| if (!bIsOrdinalSuffix) |
| return new ScStringCell( aValue += rSuffix); |
| |
| String aOrdinalSuffix( ScGlobal::GetOrdinalSuffix( nValue)); |
| if (eCellType != CELLTYPE_EDIT) |
| return new ScStringCell( aValue += aOrdinalSuffix); |
| |
| EditEngine aEngine( pDocument->GetEnginePool() ); |
| SfxItemSet aAttr = aEngine.GetEmptyItemSet(); |
| aAttr.Put( SvxEscapementItem( SVX_ESCAPEMENT_SUPERSCRIPT, EE_CHAR_ESCAPEMENT)); |
| aEngine.SetText( aValue ); |
| aEngine.QuickInsertText( aOrdinalSuffix, ESelection( 0, aValue.Len(), 0, |
| aValue.Len() + aOrdinalSuffix.Len())); |
| aEngine.QuickSetAttribs( aAttr, ESelection( 0, aValue.Len(), 0, aValue.Len() + |
| aOrdinalSuffix.Len())); |
| return new ScEditCell( aEngine.CreateTextObject(), pDocument, NULL ); |
| } |
| |
| void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, |
| FillCmd& rCmd, FillDateCmd& rDateCmd, |
| double& rInc, sal_uInt16& rMinDigits, |
| ScUserListData*& rListData, sal_uInt16& rListIndex) |
| { |
| DBG_ASSERT( nCol1==nCol2 || nRow1==nRow2, "FillAnalyse: falscher Bereich" ); |
| |
| rInc = 0.0; |
| rMinDigits = 0; |
| rListData = NULL; |
| rCmd = FILL_SIMPLE; |
| if (( nScFillModeMouseModifier & KEY_MOD1 )||IsDataFiltered()) //i89232 |
| return ; // Ctrl-Taste: 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); |
| } |
| |
| SCCOL nCol = nCol1; |
| SCROW nRow = nRow1; |
| |
| ScBaseCell* pFirstCell = GetCell( nCol, nRow ); |
| CellType eCellType = pFirstCell ? pFirstCell->GetCellType() : CELLTYPE_NONE; |
| |
| if (eCellType == CELLTYPE_VALUE) |
| { |
| sal_uInt32 nFormat = ((const SfxUInt32Item*)GetAttr(nCol,nRow,ATTR_VALUE_FORMAT))->GetValue(); |
| sal_Bool bDate = ( pDocument->GetFormatTable()->GetType(nFormat) == NUMBERFORMAT_DATE ); |
| if (bDate) |
| { |
| if (nCount > 1) |
| { |
| long nCmpInc = 0; |
| double nVal; |
| Date aNullDate = *pDocument->GetFormatTable()->GetNullDate(); |
| Date aDate1 = aNullDate; |
| nVal = ((ScValueCell*)pFirstCell)->GetValue(); |
| aDate1 += (long)nVal; |
| Date aDate2 = aNullDate; |
| nVal = GetValue(nCol+nAddX, nRow+nAddY); |
| aDate2 += (long)nVal; |
| if ( aDate1 != aDate2 ) |
| { |
| FillDateCmd eType; |
| long nDDiff = aDate2.GetDay() - (long) aDate1.GetDay(); |
| long nMDiff = aDate2.GetMonth() - (long) aDate1.GetMonth(); |
| long nYDiff = aDate2.GetYear() - (long) aDate1.GetYear(); |
| 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 ); |
| sal_Bool bVal = sal_True; |
| for (sal_uInt16 i=1; i<nCount && bVal; i++) |
| { |
| ScBaseCell* pCell = GetCell(nCol,nRow); |
| if (pCell && pCell->GetCellType() == CELLTYPE_VALUE) |
| { |
| nVal = ((ScValueCell*)pCell)->GetValue(); |
| aDate2 = aNullDate + (long) nVal; |
| if ( eType == FILL_DAY ) |
| { |
| if ( aDate2-aDate1 != nCmpInc ) |
| bVal = sal_False; |
| } |
| else |
| { |
| nDDiff = aDate2.GetDay() - (long) aDate1.GetDay(); |
| nMDiff = aDate2.GetMonth() - (long) aDate1.GetMonth(); |
| nYDiff = aDate2.GetYear() - (long) aDate1.GetYear(); |
| if (nDDiff || ( nMDiff + 12 * nYDiff != nCmpInc )) |
| bVal = sal_False; |
| } |
| aDate1 = aDate2; |
| nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); |
| nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); |
| } |
| else |
| bVal = sal_False; // #50965# kein Datum passt auch nicht |
| } |
| if (bVal) |
| { |
| if ( eType == FILL_MONTH && ( nCmpInc % 12 == 0 ) ) |
| { |
| eType = FILL_YEAR; |
| nCmpInc /= 12; |
| } |
| rCmd = FILL_DATE; |
| rDateCmd = eType; |
| rInc = nCmpInc; |
| } |
| } |
| } |
| else // einzelnes Datum -> Tage hochzaehlen |
| { |
| rCmd = FILL_DATE; |
| rDateCmd = FILL_DAY; |
| rInc = 1.0; |
| } |
| } |
| else |
| { |
| if (nCount > 1) |
| { |
| double nVal1 = ((ScValueCell*)pFirstCell)->GetValue(); |
| double nVal2 = GetValue(nCol+nAddX, nRow+nAddY); |
| rInc = nVal2 - nVal1; |
| nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); |
| nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); |
| sal_Bool bVal = sal_True; |
| for (sal_uInt16 i=1; i<nCount && bVal; i++) |
| { |
| ScBaseCell* pCell = GetCell(nCol,nRow); |
| if (pCell && pCell->GetCellType() == CELLTYPE_VALUE) |
| { |
| nVal2 = ((ScValueCell*)pCell)->GetValue(); |
| double nDiff = nVal2 - nVal1; |
| if ( !::rtl::math::approxEqual( nDiff, rInc ) ) |
| bVal = sal_False; |
| nVal1 = nVal2; |
| } |
| else |
| bVal = sal_False; |
| nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); |
| nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); |
| } |
| if (bVal) |
| rCmd = FILL_LINEAR; |
| } |
| } |
| } |
| else if (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT) |
| { |
| String aStr; |
| GetString(nCol, nRow, aStr); |
| rListData = (ScUserListData*)(ScGlobal::GetUserList()->GetData(aStr)); |
| if (rListData) |
| { |
| rListData->GetSubIndex(aStr, rListIndex); |
| nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); |
| nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); |
| for (sal_uInt16 i=1; i<nCount && rListData; i++) |
| { |
| GetString(nCol, nRow, aStr); |
| if (!rListData->GetSubIndex(aStr, rListIndex)) |
| rListData = NULL; |
| nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); |
| nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); |
| } |
| } |
| 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; |
| GetString( nCol+nAddX, nRow+nAddY, aStr ); |
| short nFlag2 = lcl_DecompValueString( aStr, nVal2, &rMinDigits ); |
| if ( nFlag1 == nFlag2 ) |
| { |
| rInc = (double)nVal2 - (double)nVal1; |
| nCol = sal::static_int_cast<SCCOL>( nCol + nAddX ); |
| nRow = sal::static_int_cast<SCROW>( nRow + nAddY ); |
| sal_Bool bVal = sal_True; |
| for (sal_uInt16 i=1; i<nCount && bVal; i++) |
| { |
| ScBaseCell* pCell = GetCell(nCol,nRow); |
| CellType eType = pCell ? pCell->GetCellType() : CELLTYPE_NONE; |
| if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT ) |
| { |
| if ( eType == CELLTYPE_STRING ) |
| ((ScStringCell*)pCell)->GetString( aStr ); |
| else |
| ((ScEditCell*)pCell)->GetString( aStr ); |
| nFlag2 = lcl_DecompValueString( aStr, nVal2, &rMinDigits ); |
| if ( nFlag1 == nFlag2 ) |
| { |
| double nDiff = (double)nVal2 - (double)nVal1; |
| if ( !::rtl::math::approxEqual( nDiff, rInc ) ) |
| bVal = sal_False; |
| nVal1 = nVal2; |
| } |
| else |
| bVal = sal_False; |
| } |
| else |
| bVal = sal_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(sal_uLong& /* nFormulaCounter */, sal_Bool /* bFirst */, ScFormulaCell* pSrcCell, |
| SCCOL nDestCol, SCROW nDestRow, sal_Bool bLast ) |
| { |
| /* sal_uInt16 nTokArrLen = pSrcCell->GetTokenArrayLen(); |
| if ( nTokArrLen > 15 ) // mehr als =A1 oder =67 |
| { |
| ScRangeName* pRangeName = pDocument->GetRangeName(); |
| String aName("___SC_"); // Wird dieser String veraendert, |
| // auch in document2 EraseNonUsed... |
| // mitaendern!! |
| aName += pRangeName->GetSharedMaxIndex() + 1; |
| aName += '_'; |
| aName += nFormulaCounter; |
| nFormulaCounter++; |
| if (bFirst) |
| { |
| ScRangeData *pAktRange = new ScRangeData( |
| pDocument, aName, pSrcCell->GetTokenArray(), nTokArrLen, |
| pSrcCell->GetCol(), pSrcCell->GetRow(), nTab ,RT_SHARED); |
| if (!pRangeName->Insert( pAktRange )) |
| delete pAktRange; |
| else |
| bSharedNameInserted = sal_True; |
| } |
| sal_uInt16 nIndex; |
| pRangeName->SearchName(aName, nIndex); |
| if (!pRangeName) |
| { |
| DBG_ERROR("ScTable::FillFormula: Falscher Name"); |
| return; |
| } |
| nIndex = ((ScRangeData*) ((*pRangeName)[nIndex]))->GetIndex(); |
| ScTokenArray aArr; |
| aArr.AddName(nIndex); |
| aArr.AddOpCode(ocStop); |
| ScFormulaCell* pDestCell = new ScFormulaCell |
| (pDocument, ScAddress( nDestCol, nDestRow, nTab ), aArr ); |
| aCol[nDestCol].Insert(nDestRow, pDestCell); |
| } |
| else |
| */ { |
| pDocument->SetNoListening( sal_True ); // noch falsche Referenzen |
| ScAddress aAddr( nDestCol, nDestRow, nTab ); |
| ScFormulaCell* pDestCell = new ScFormulaCell( *pSrcCell, *pDocument, aAddr ); |
| aCol[nDestCol].Insert(nDestRow, pDestCell); |
| #if 0 |
| // mit RelRefs unnoetig |
| pDestCell->UpdateReference(URM_COPY, |
| ScRange( aAddr, aAddr ), |
| nDestCol - pSrcCell->aPos.Col(), |
| nDestRow - pSrcCell->aPos.Row(), 0); |
| #endif |
| if ( bLast && pDestCell->GetMatrixFlag() ) |
| { |
| ScAddress aOrg; |
| if ( pDestCell->GetMatrixOrigin( aOrg ) ) |
| { |
| if ( nDestCol >= aOrg.Col() && nDestRow >= aOrg.Row() ) |
| { |
| ScBaseCell* pOrgCell = pDocument->GetCell( aOrg ); |
| if ( pOrgCell && pOrgCell->GetCellType() == CELLTYPE_FORMULA |
| && ((ScFormulaCell*)pOrgCell)->GetMatrixFlag() == MM_FORMULA ) |
| { |
| ((ScFormulaCell*)pOrgCell)->SetMatColsRows( |
| nDestCol - aOrg.Col() + 1, |
| nDestRow - aOrg.Row() + 1 ); |
| } |
| else |
| { |
| DBG_ERRORFILE( "FillFormula: MatrixOrigin keine Formelzelle mit MM_FORMULA" ); |
| } |
| } |
| else |
| { |
| DBG_ERRORFILE( "FillFormula: MatrixOrigin rechts unten" ); |
| } |
| } |
| else |
| { |
| DBG_ERRORFILE( "FillFormula: kein MatrixOrigin" ); |
| } |
| } |
| pDocument->SetNoListening( sal_False ); |
| pDestCell->StartListeningTo( pDocument ); |
| } |
| } |
| |
| void ScTable::FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, |
| sal_uLong nFillCount, FillDir eFillDir, ScProgress& rProgress ) |
| { |
| if ( (nFillCount == 0) || !ValidColRow(nCol1, nRow1) || !ValidColRow(nCol2, nRow2) ) |
| return; |
| |
| // |
| // Richtung auswerten |
| // |
| |
| sal_Bool bVertical = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP); |
| sal_Bool bPositive = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_RIGHT); |
| |
| sal_uLong nCol = 0; |
| sal_uLong nRow = 0; |
| sal_uLong& rInner = bVertical ? nRow : nCol; // Schleifenvariablen |
| sal_uLong& rOuter = bVertical ? nCol : nRow; |
| sal_uLong nOStart; |
| sal_uLong nOEnd; |
| sal_uLong nIStart; |
| sal_uLong nIEnd; |
| sal_uLong nISrcStart; |
| sal_uLong nISrcEnd; |
| |
| if (bVertical) |
| { |
| nOStart = nCol1; |
| nOEnd = nCol2; |
| if (bPositive) |
| { |
| nISrcStart = nRow1; |
| nISrcEnd = nRow2; |
| nIStart = nRow2 + 1; |
| nIEnd = nRow2 + nFillCount; |
| } |
| else |
| { |
| nISrcStart = nRow2; |
| nISrcEnd = nRow1; |
| nIStart = nRow1 - 1; |
| nIEnd = nRow1 - nFillCount; |
| } |
| } |
| else |
| { |
| nOStart = nRow1; |
| nOEnd = nRow2; |
| if (bPositive) |
| { |
| nISrcStart = nCol1; |
| nISrcEnd = nCol2; |
| nIStart = nCol2 + 1; |
| nIEnd = nCol2 + nFillCount; |
| } |
| else |
| { |
| nISrcStart = nCol2; |
| nISrcEnd = nCol1; |
| nIStart = nCol1 - 1; |
| nIEnd = nCol1 - nFillCount; |
| } |
| } |
| sal_uLong nIMin = nIStart; |
| sal_uLong nIMax = nIEnd; |
| PutInOrder(nIMin,nIMax); |
| sal_Bool bHasFiltered = IsDataFiltered(); |
| if (!bHasFiltered) //modify for i89232 |
| { |
| if (bVertical) |
| DeleteArea(nCol1, static_cast<SCROW>(nIMin), nCol2, static_cast<SCROW>(nIMax), IDF_AUTOFILL); |
| else |
| DeleteArea(static_cast<SCCOL>(nIMin), nRow1, static_cast<SCCOL>(nIMax), nRow2, IDF_AUTOFILL); |
| } |
| sal_uLong nProgress = rProgress.GetState(); |
| |
| // |
| // ausfuehren |
| // |
| |
| sal_uLong nActFormCnt = 0; |
| for (rOuter = nOStart; rOuter <= nOEnd; rOuter++) |
| { |
| sal_uLong nMaxFormCnt = 0; // fuer Formeln |
| |
| // Attributierung uebertragen |
| |
| const ScPatternAttr* pSrcPattern = NULL; |
| const ScStyleSheet* pStyleSheet = NULL; |
| sal_uLong nAtSrc = nISrcStart; |
| ScPatternAttr* pNewPattern = NULL; |
| sal_Bool bGetPattern = sal_True; |
| rInner = nIStart; |
| while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes |
| { |
| if ( bGetPattern ) |
| { |
| if ( pNewPattern ) |
| delete pNewPattern; |
| if (bVertical) // rInner&:=nRow, rOuter&:=nCol |
| pSrcPattern = aCol[nCol].GetPattern(static_cast<SCROW>(nAtSrc)); |
| else // rInner&:=nCol, rOuter&:=nRow |
| pSrcPattern = aCol[nAtSrc].GetPattern(static_cast<SCROW>(nRow)); |
| bGetPattern = sal_False; |
| pStyleSheet = pSrcPattern->GetStyleSheet(); |
| // Merge/Mergeflag nicht uebernehmen, |
| const SfxItemSet& rSet = pSrcPattern->GetItemSet(); |
| if ( rSet.GetItemState(ATTR_MERGE, sal_False) == SFX_ITEM_SET |
| || rSet.GetItemState(ATTR_MERGE_FLAG, sal_False) == SFX_ITEM_SET ) |
| { |
| pNewPattern = new ScPatternAttr( *pSrcPattern ); |
| SfxItemSet& rNewSet = pNewPattern->GetItemSet(); |
| rNewSet.ClearItem(ATTR_MERGE); |
| rNewSet.ClearItem(ATTR_MERGE_FLAG); |
| } |
| else |
| pNewPattern = NULL; |
| } |
| |
| if ( bVertical && nISrcStart == nISrcEnd && !bHasFiltered ) |
| { |
| // Attribute komplett am Stueck setzen |
| if (pNewPattern || pSrcPattern != pDocument->GetDefPattern()) |
| { |
| // Default steht schon da (DeleteArea) |
| SCROW nY1 = static_cast<SCROW>(Min( nIStart, nIEnd )); |
| SCROW nY2 = static_cast<SCROW>(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 ); |
| } |
| break; // Schleife abbrechen |
| } |
| |
| if ( !RowFiltered(nRow) ) |
| { |
| if ( bHasFiltered ) |
| DeleteArea(static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), |
| static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), IDF_AUTOFILL); |
| |
| if ( pSrcPattern != aCol[nCol].GetPattern( static_cast<SCROW>(nRow) ) ) |
| { |
| // Vorlage auch uebernehmen |
| //! am AttrArray mit ApplyPattern zusammenfassen ?? |
| if ( pStyleSheet ) |
| aCol[nCol].ApplyStyle( static_cast<SCROW>(nRow), *pStyleSheet ); |
| |
| // ApplyPattern statt SetPattern um alte MergeFlags stehenzulassen |
| if ( pNewPattern ) |
| aCol[nCol].ApplyPattern( static_cast<SCROW>(nRow), *pNewPattern ); |
| else |
| aCol[nCol].ApplyPattern( static_cast<SCROW>(nRow), *pSrcPattern ); |
| } |
| |
| if (nAtSrc==nISrcEnd) |
| { |
| if ( nAtSrc != nISrcStart ) |
| { // mehr als eine Source-Zelle |
| nAtSrc = nISrcStart; |
| bGetPattern = sal_True; |
| } |
| } |
| else if (bPositive) |
| { |
| ++nAtSrc; |
| bGetPattern = sal_True; |
| } |
| else |
| { |
| --nAtSrc; |
| bGetPattern = sal_True; |
| } |
| } |
| |
| if (rInner == nIEnd) break; |
| if (bPositive) ++rInner; else --rInner; |
| } |
| if ( pNewPattern ) |
| delete pNewPattern; |
| |
| // Analyse |
| |
| FillCmd eFillCmd; |
| FillDateCmd eDateCmd; |
| double nInc; |
| sal_uInt16 nMinDigits; |
| ScUserListData* pListData = NULL; |
| sal_uInt16 nListIndex; |
| if (bVertical) |
| FillAnalyse(static_cast<SCCOL>(nCol),nRow1, |
| static_cast<SCCOL>(nCol),nRow2, eFillCmd,eDateCmd, |
| nInc,nMinDigits, pListData,nListIndex); |
| else |
| FillAnalyse(nCol1,static_cast<SCROW>(nRow), |
| nCol2,static_cast<SCROW>(nRow), eFillCmd,eDateCmd, |
| nInc,nMinDigits, pListData,nListIndex); |
| |
| if (bVertical) |
| aCol[nCol].Resize( aCol[nCol].GetCellCount() + nFillCount ); |
| |
| if (pListData) |
| { |
| sal_uInt16 nListCount = pListData->GetSubCount(); |
| if ( !bPositive ) |
| { |
| // nListIndex auf FillAnalyse zeigt auf den letzten Eintrag -> anpassen |
| sal_uLong nSub = nISrcStart - nISrcEnd; |
| for (sal_uLong i=0; i<nSub; i++) |
| { |
| if (nListIndex == 0) nListIndex = nListCount; |
| --nListIndex; |
| } |
| } |
| |
| rInner = nIStart; |
| while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes |
| { |
| if (bPositive) |
| { |
| ++nListIndex; |
| if (nListIndex >= nListCount) nListIndex = 0; |
| } |
| else |
| { |
| if (nListIndex == 0) nListIndex = nListCount; |
| --nListIndex; |
| } |
| aCol[nCol].Insert(static_cast<SCROW>(nRow), new ScStringCell(pListData->GetSubStr(nListIndex))); |
| |
| if (rInner == nIEnd) break; |
| if (bPositive) ++rInner; else --rInner; |
| } |
| nProgress += nIMax - nIMin + 1; |
| rProgress.SetStateOnPercent( nProgress ); |
| } |
| else if (eFillCmd == FILL_SIMPLE) // Auffuellen mit Muster |
| { |
| sal_uLong nSource = nISrcStart; |
| double nDelta; |
| if (( nScFillModeMouseModifier & KEY_MOD1 )||bHasFiltered) //i89232 |
| nDelta = 0.0; |
| else if ( bPositive ) |
| nDelta = 1.0; |
| else |
| nDelta = -1.0; |
| double nVal = 0.0; |
| sal_uLong nFormulaCounter = nActFormCnt; |
| sal_Bool bFirst = sal_True; |
| sal_Bool bGetCell = sal_True; |
| sal_uInt16 nCellDigits = 0; |
| short nHeadNoneTail = 0; |
| sal_Int32 nStringValue = 0; |
| String aValue; |
| ScBaseCell* pSrcCell = NULL; |
| CellType eCellType = CELLTYPE_NONE; |
| sal_Bool bIsOrdinalSuffix = sal_False; |
| sal_Bool bRowFiltered = sal_False; //i89232 |
| |
| rInner = nIStart; |
| while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes |
| { |
| if ( bGetCell ) |
| { |
| if (bVertical) // rInner&:=nRow, rOuter&:=nCol |
| pSrcCell = aCol[nCol].GetCell( static_cast<SCROW>(nSource) ); |
| else // rInner&:=nCol, rOuter&:=nRow |
| pSrcCell = aCol[nSource].GetCell( static_cast<SCROW>(nRow) ); |
| bGetCell = sal_False; |
| if ( pSrcCell ) |
| { |
| eCellType = pSrcCell->GetCellType(); |
| switch ( eCellType ) |
| { |
| case CELLTYPE_VALUE: |
| nVal = ((ScValueCell*)pSrcCell)->GetValue(); |
| break; |
| case CELLTYPE_STRING: |
| case CELLTYPE_EDIT: |
| if ( eCellType == CELLTYPE_STRING ) |
| ((ScStringCell*)pSrcCell)->GetString( aValue ); |
| else |
| ((ScEditCell*)pSrcCell)->GetString( aValue ); |
| if ( !(nScFillModeMouseModifier & KEY_MOD1) && !bHasFiltered) //i89232 |
| { |
| nCellDigits = 0; // look at each source cell individually |
| nHeadNoneTail = lcl_DecompValueString( |
| aValue, nStringValue, &nCellDigits ); |
| |
| bIsOrdinalSuffix = aValue.Equals( |
| ScGlobal::GetOrdinalSuffix( nStringValue)); |
| } |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| else |
| eCellType = CELLTYPE_NONE; |
| } |
| |
| //Modify for i89232 |
| bRowFiltered = mpFilteredRows->getValue(nRow); |
| |
| if (!bRowFiltered) |
| { |
| //End of i89232 |
| |
| switch (eCellType) |
| { |
| case CELLTYPE_VALUE: |
| aCol[nCol].Insert(static_cast<SCROW>(nRow), new ScValueCell(nVal + nDelta)); |
| break; |
| case CELLTYPE_STRING: |
| case CELLTYPE_EDIT: |
| if ( nHeadNoneTail ) |
| { |
| // #i48009# with the "nStringValue+(long)nDelta" expression within the |
| // lcl_ValueString calls, gcc 3.4.1 makes wrong optimizations (ok in 3.4.3), |
| // so nNextValue is now calculated ahead. |
| sal_Int32 nNextValue = nStringValue+(sal_Int32)nDelta; |
| |
| String aStr; |
| if ( nHeadNoneTail < 0 ) |
| { |
| aCol[nCol].Insert( static_cast<SCROW>(nRow), |
| lcl_getSuffixCell( pDocument, |
| nNextValue, nCellDigits, aValue, |
| eCellType, bIsOrdinalSuffix)); |
| } |
| else |
| { |
| aStr = aValue; |
| aStr += lcl_ValueString( nNextValue, nCellDigits ); |
| aCol[nCol].Insert( static_cast<SCROW>(nRow), |
| new ScStringCell( aStr)); |
| } |
| } |
| else |
| { |
| ScAddress aDestPos( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), nTab ); |
| switch ( eCellType ) |
| { |
| case CELLTYPE_STRING: |
| case CELLTYPE_EDIT: |
| aCol[nCol].Insert( aDestPos.Row(), pSrcCell->CloneWithoutNote( *pDocument ) ); |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| break; |
| case CELLTYPE_FORMULA : |
| FillFormula( nFormulaCounter, bFirst, |
| (ScFormulaCell*) pSrcCell, |
| static_cast<SCCOL>(nCol), |
| static_cast<SCROW>(nRow), (rInner == nIEnd) ); |
| if (nFormulaCounter - nActFormCnt > nMaxFormCnt) |
| nMaxFormCnt = nFormulaCounter - nActFormCnt; |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| |
| if (nSource==nISrcEnd) |
| { |
| if ( nSource != nISrcStart ) |
| { // mehr als eine Source-Zelle |
| nSource = nISrcStart; |
| bGetCell = sal_True; |
| } |
| if ( !(nScFillModeMouseModifier & KEY_MOD1) && !bHasFiltered ) //i89232 |
| { |
| if ( bPositive ) |
| nDelta += 1.0; |
| else |
| nDelta -= 1.0; |
| } |
| nFormulaCounter = nActFormCnt; |
| bFirst = sal_False; |
| } |
| else if (bPositive) |
| { |
| ++nSource; |
| bGetCell = sal_True; |
| } |
| else |
| { |
| --nSource; |
| bGetCell = sal_True; |
| } |
| } |
| |
| // Progress in der inneren Schleife nur bei teuren Zellen, |
| // und auch dann nicht fuer jede einzelne |
| |
| ++nProgress; |
| if ( eCellType == CELLTYPE_FORMULA || eCellType == CELLTYPE_EDIT ) |
| rProgress.SetStateOnPercent( nProgress ); |
| |
| if (rInner == nIEnd) break; |
| if (bPositive) ++rInner; else --rInner; |
| } |
| rProgress.SetStateOnPercent( nProgress ); |
| } |
| else |
| { |
| if (!bPositive) |
| nInc = -nInc; |
| 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, nEndVal, nMinDigits, sal_False, |
| rProgress ); |
| else |
| FillSeries( nCol1, static_cast<SCROW>(nRow), nCol2, |
| static_cast<SCROW>(nRow), nFillCount, eFillDir, |
| eFillCmd, eDateCmd, nInc, nEndVal, nMinDigits, sal_False, |
| rProgress ); |
| nProgress = rProgress.GetState(); |
| } |
| |
| nActFormCnt += nMaxFormCnt; |
| } |
| } |
| |
| String ScTable::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY ) |
| { |
| String aValue; |
| |
| SCCOL nCol1 = rSource.aStart.Col(); |
| SCROW nRow1 = rSource.aStart.Row(); |
| SCCOL nCol2 = rSource.aEnd.Col(); |
| SCROW nRow2 = rSource.aEnd.Row(); |
| sal_Bool bOk = sal_True; |
| long nIndex = 0; |
| sal_uLong nSrcCount = 0; |
| FillDir eFillDir = FILL_TO_BOTTOM; |
| if ( nEndX == nCol2 && nEndY == nRow2 ) // leer |
| bOk = sal_False; |
| else if ( nEndX == nCol2 ) // nach oben/unten |
| { |
| nEndX = nCol2 = nCol1; // nur erste Spalte ansehen |
| nSrcCount = nRow2 - nRow1 + 1; |
| nIndex = ((long)nEndY) - nRow1; // kann negativ werden |
| if ( nEndY >= nRow1 ) |
| eFillDir = FILL_TO_BOTTOM; |
| else |
| eFillDir = FILL_TO_TOP; |
| } |
| else if ( nEndY == nRow2 ) // nach links/rechts |
| { |
| nEndY = nRow2 = nRow1; // nur erste Zeile ansehen |
| nSrcCount = nCol2 - nCol1 + 1; |
| nIndex = ((long)nEndX) - nCol1; // kann negativ werden |
| if ( nEndX >= nCol1 ) |
| eFillDir = FILL_TO_RIGHT; |
| else |
| eFillDir = FILL_TO_LEFT; |
| } |
| else // Richtung nicht eindeutig |
| bOk = sal_False; |
| |
| if ( bOk ) |
| { |
| FillCmd eFillCmd; |
| FillDateCmd eDateCmd; |
| double nInc; |
| sal_uInt16 nMinDigits; |
| ScUserListData* pListData = NULL; |
| sal_uInt16 nListIndex; |
| |
| FillAnalyse(nCol1,nRow1, nCol2,nRow2, eFillCmd,eDateCmd, nInc,nMinDigits, pListData,nListIndex); |
| |
| if ( pListData ) // benutzerdefinierte Liste |
| { |
| sal_uInt16 nListCount = pListData->GetSubCount(); |
| if ( nListCount ) |
| { |
| sal_uLong nSub = nSrcCount - 1; // nListIndex ist vom letzten Source-Eintrag |
| while ( nIndex < sal::static_int_cast<long>(nSub) ) |
| nIndex += nListCount; |
| sal_uLong nPos = ( nListIndex + nIndex - nSub ) % nListCount; |
| aValue = pListData->GetSubStr(sal::static_int_cast<sal_uInt16>(nPos)); |
| } |
| } |
| else if ( eFillCmd == FILL_SIMPLE ) // Auffuellen mit Muster |
| { |
| //Add for i89232 |
| if ((eFillDir == FILL_TO_BOTTOM)||(eFillDir == FILL_TO_TOP)) |
| { |
| long nBegin = 0; |
| long nEnd = 0; |
| if (nEndY > nRow1) |
| { |
| nBegin = nRow2+1; |
| nEnd = nEndY; |
| } |
| else |
| { |
| nBegin = nEndY; |
| nEnd = nRow1 -1; |
| } |
| long nNonFiltered = CountNonFilteredRows(nBegin, nEnd); |
| long nFiltered = nEnd + 1 - nBegin - nNonFiltered; |
| if (nIndex >0) |
| nIndex = nIndex - nFiltered; |
| else |
| nIndex = nIndex + nFiltered; |
| } |
| //End of i89232 |
| |
| long nPosIndex = nIndex; |
| while ( nPosIndex < 0 ) |
| nPosIndex += nSrcCount; |
| sal_uLong 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) ); |
| |
| ScBaseCell* pCell = GetCell( nSrcX, nSrcY ); |
| if ( pCell ) |
| { |
| sal_Int32 nDelta; |
| if (nIndex >= 0) |
| nDelta = nIndex / nSrcCount; |
| else |
| nDelta = ( nIndex - nSrcCount + 1 ) / nSrcCount; // -1 -> -1 |
| |
| CellType eType = pCell->GetCellType(); |
| switch ( eType ) |
| { |
| case CELLTYPE_STRING: |
| case CELLTYPE_EDIT: |
| { |
| if ( eType == CELLTYPE_STRING ) |
| ((ScStringCell*)pCell)->GetString( aValue ); |
| else |
| ((ScEditCell*)pCell)->GetString( aValue ); |
| if ( !(nScFillModeMouseModifier & KEY_MOD1) && !IsDataFiltered() ) //i89232 |
| { |
| 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.Equals( ScGlobal::GetOrdinalSuffix( nVal))) |
| aValue = ScGlobal::GetOrdinalSuffix( nVal + nDelta); |
| |
| aValue.Insert( lcl_ValueString( nVal + nDelta, nCellDigits ), 0 ); |
| } |
| else if ( nFlag > 0 ) |
| aValue += lcl_ValueString( nVal + nDelta, nCellDigits ); |
| } |
| } |
| break; |
| case CELLTYPE_VALUE: |
| { |
| // dabei kann's keinen Ueberlauf geben... |
| double nVal = ((ScValueCell*)pCell)->GetValue(); |
| if ( !(nScFillModeMouseModifier & KEY_MOD1) && !IsDataFiltered() ) //i89232 |
| nVal += (double) nDelta; |
| |
| Color* pColor; |
| sal_uLong nNumFmt = GetNumberFormat( nSrcX, nSrcY ); |
| pDocument->GetFormatTable()-> |
| GetOutputString( nVal, nNumFmt, aValue, &pColor ); |
| } |
| break; |
| // Formeln nicht |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| } |
| else if ( eFillCmd == FILL_LINEAR || eFillCmd == FILL_DATE ) // Werte |
| { |
| sal_Bool bValueOk; |
| double nStart; |
| sal_Int32 nVal = 0; |
| short nHeadNoneTail = 0; |
| ScBaseCell* pCell = GetCell( nCol1, nRow1 ); |
| if ( pCell ) |
| { |
| CellType eType = pCell->GetCellType(); |
| switch ( eType ) |
| { |
| case CELLTYPE_STRING: |
| case CELLTYPE_EDIT: |
| { |
| if ( eType == CELLTYPE_STRING ) |
| ((ScStringCell*)pCell)->GetString( aValue ); |
| else |
| ((ScEditCell*)pCell)->GetString( aValue ); |
| nHeadNoneTail = lcl_DecompValueString( aValue, nVal ); |
| if ( nHeadNoneTail ) |
| nStart = (double)nVal; |
| else |
| nStart = 0.0; |
| } |
| break; |
| case CELLTYPE_VALUE: |
| nStart = ((ScValueCell*)pCell)->GetValue(); |
| break; |
| case CELLTYPE_FORMULA: |
| nStart = ((ScFormulaCell*)pCell)->GetValue(); |
| break; |
| default: |
| nStart = 0.0; |
| } |
| } |
| else |
| nStart = 0.0; |
| if ( eFillCmd == FILL_LINEAR ) |
| { |
| double nAdd = nInc; |
| bValueOk = ( SubTotal::SafeMult( nAdd, (double) nIndex ) && |
| SubTotal::SafePlus( nStart, nAdd ) ); |
| } |
| else // Datum |
| { |
| bValueOk = sal_True; |
| sal_uInt16 nDayOfMonth = 0; |
| if ( nIndex < 0 ) |
| { |
| nIndex = -nIndex; |
| nInc = -nInc; |
| } |
| for (long i=0; i<nIndex; i++) |
| IncDate( nStart, nDayOfMonth, nInc, eDateCmd ); |
| } |
| |
| if (bValueOk) |
| { |
| if ( nHeadNoneTail ) |
| { |
| if ( nHeadNoneTail < 0 ) |
| { |
| if (aValue.Equals( ScGlobal::GetOrdinalSuffix( nVal))) |
| aValue = ScGlobal::GetOrdinalSuffix( (sal_Int32)nStart ); |
| |
| aValue.Insert( lcl_ValueString( (sal_Int32)nStart, nMinDigits ), 0 ); |
| } |
| else |
| aValue += lcl_ValueString( (sal_Int32)nStart, nMinDigits ); |
| } |
| else |
| { |
| //! Zahlformat je nach Index holen? |
| Color* pColor; |
| sal_uLong nNumFmt = GetNumberFormat( nCol1, nRow1 ); |
| pDocument->GetFormatTable()-> |
| GetOutputString( nStart, nNumFmt, aValue, &pColor ); |
| } |
| } |
| } |
| else |
| { |
| DBG_ERROR("GetAutoFillPreview: falscher Modus"); |
| } |
| } |
| |
| return aValue; |
| } |
| |
| void ScTable::IncDate(double& rVal, sal_uInt16& nDayOfMonth, double nStep, FillDateCmd eCmd) |
| { |
| if (eCmd == FILL_DAY) |
| { |
| rVal += nStep; |
| return; |
| } |
| |
| // class Date Grenzen |
| const sal_uInt16 nMinYear = 1583; |
| const sal_uInt16 nMaxYear = 9956; |
| |
| long nInc = (long) nStep; // nach oben/unten begrenzen ? |
| Date aNullDate = *pDocument->GetFormatTable()->GetNullDate(); |
| Date aDate = aNullDate; |
| aDate += (long)rVal; |
| switch (eCmd) |
| { |
| case FILL_WEEKDAY: |
| { |
| aDate += nInc; |
| DayOfWeek eWeekDay = aDate.GetDayOfWeek(); |
| if (nInc >= 0) |
| { |
| if (eWeekDay == SATURDAY) |
| aDate += 2; |
| else if (eWeekDay == SUNDAY) |
| aDate += 1; |
| } |
| else |
| { |
| if (eWeekDay == SATURDAY) |
| aDate -= 1; |
| else if (eWeekDay == SUNDAY) |
| aDate -= 2; |
| } |
| } |
| break; |
| case FILL_MONTH: |
| { |
| if ( nDayOfMonth == 0 ) |
| nDayOfMonth = aDate.GetDay(); // init |
| long nMonth = aDate.GetMonth(); |
| long nYear = aDate.GetYear(); |
| |
| nMonth += nInc; |
| |
| if (nInc >= 0) |
| { |
| if (nMonth > 12) |
| { |
| long nYAdd = (nMonth-1) / 12; |
| nMonth -= nYAdd * 12; |
| nYear += nYAdd; |
| } |
| } |
| else |
| { |
| if (nMonth < 1) |
| { |
| long nYAdd = 1 - nMonth / 12; // positiv |
| 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((sal_uInt16) nMonth); |
| aDate.SetYear((sal_uInt16) nYear); |
| if ( nDayOfMonth > 28 ) |
| aDate.SetDay( Min( aDate.GetDaysInMonth(), nDayOfMonth ) ); |
| } |
| } |
| break; |
| case FILL_YEAR: |
| { |
| 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((sal_uInt16) nYear); |
| } |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| |
| rVal = aDate - aNullDate; |
| } |
| |
| void ScTable::FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, |
| sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, |
| double nStepValue, double nMaxValue, sal_uInt16 nArgMinDigits, |
| sal_Bool bAttribs, ScProgress& rProgress ) |
| { |
| // |
| // Richtung auswerten |
| // |
| |
| sal_Bool bVertical = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP); |
| sal_Bool bPositive = (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_RIGHT); |
| |
| sal_uLong nCol = 0; |
| sal_uLong nRow = 0; |
| sal_uLong& rInner = bVertical ? nRow : nCol; // Schleifenvariablen |
| sal_uLong& rOuter = bVertical ? nCol : nRow; |
| sal_uLong nOStart; |
| sal_uLong nOEnd; |
| sal_uLong nIStart; |
| sal_uLong nIEnd; |
| sal_uLong nISource; |
| |
| if (bVertical) |
| { |
| nFillCount += (nRow2 - nRow1); |
| if (nFillCount == 0) |
| return; |
| nOStart = nCol1; |
| nOEnd = nCol2; |
| if (bPositive) |
| { |
| nISource = nRow1; |
| nIStart = nRow1 + 1; |
| nIEnd = nRow1 + nFillCount; |
| } |
| else |
| { |
| nISource = nRow2; |
| nIStart = nRow2 - 1; |
| nIEnd = nRow2 - nFillCount; |
| } |
| } |
| else |
| { |
| nFillCount += (nCol2 - nCol1); |
| if (nFillCount == 0) |
| return; |
| nOStart = nRow1; |
| nOEnd = nRow2; |
| if (bPositive) |
| { |
| nISource = nCol1; |
| nIStart = nCol1 + 1; |
| nIEnd = nCol1 + nFillCount; |
| } |
| else |
| { |
| nISource = nCol2; |
| nIStart = nCol2 - 1; |
| nIEnd = nCol2 - nFillCount; |
| } |
| } |
| |
| sal_uLong nIMin = nIStart; |
| sal_uLong nIMax = nIEnd; |
| PutInOrder(nIMin,nIMax); |
| sal_uInt16 nDel = bAttribs ? IDF_AUTOFILL : (IDF_AUTOFILL & IDF_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_uLong nProgress = rProgress.GetState(); |
| |
| // |
| // ausfuehren |
| // |
| |
| sal_uLong nActFormCnt = 0; |
| for (rOuter = nOStart; rOuter <= nOEnd; rOuter++) |
| { |
| sal_Bool bFirst = sal_True; |
| rInner = nISource; |
| ScBaseCell* pSrcCell = aCol[nCol].GetCell(static_cast<SCROW>(nRow)); |
| |
| if (bVertical && bAttribs) |
| aCol[nCol].Resize( aCol[nCol].GetCellCount() + nFillCount ); |
| |
| if (bAttribs) |
| { |
| const ScPatternAttr* pSrcPattern = aCol[nCol].GetPattern(static_cast<SCROW>(nRow)); |
| if (bVertical) |
| aCol[nCol].SetPatternArea( static_cast<SCROW>(nIMin), |
| static_cast<SCROW>(nIMax), *pSrcPattern, sal_True ); |
| else |
| for (SCCOL nAtCol = static_cast<SCCOL>(nIMin); nAtCol <= sal::static_int_cast<SCCOL>(nIMax); nAtCol++) |
| aCol[nAtCol].SetPattern(static_cast<SCROW>(nRow), *pSrcPattern, sal_True); |
| } |
| |
| if (pSrcCell) |
| { |
| CellType eCellType = pSrcCell->GetCellType(); |
| |
| if (eFillCmd == FILL_SIMPLE) // kopieren |
| { |
| if (eCellType == CELLTYPE_FORMULA) |
| { |
| for (rInner = nIMin; rInner <= nIMax; rInner++) |
| { |
| sal_uLong nInd = nActFormCnt; |
| FillFormula(nInd, bFirst, (ScFormulaCell*)pSrcCell, |
| static_cast<SCCOL>(nCol), nRow, (rInner == nIEnd) ); |
| bFirst = sal_False; |
| rProgress.SetStateOnPercent( ++nProgress ); |
| } |
| } |
| else if (eCellType != CELLTYPE_NOTE) |
| { |
| for (rInner = nIMin; rInner <= nIMax; rInner++) |
| { |
| ScAddress aDestPos( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), nTab ); |
| aCol[nCol].Insert( aDestPos.Row(), pSrcCell->CloneWithoutNote( *pDocument ) ); |
| } |
| nProgress += nIMax - nIMin + 1; |
| rProgress.SetStateOnPercent( nProgress ); |
| } |
| } |
| else if (eCellType == CELLTYPE_VALUE || eCellType == CELLTYPE_FORMULA) |
| { |
| double nStartVal; |
| if (eCellType == CELLTYPE_VALUE) |
| nStartVal = ((ScValueCell*)pSrcCell)->GetValue(); |
| else |
| nStartVal = ((ScFormulaCell*)pSrcCell)->GetValue(); |
| double nVal = nStartVal; |
| long nIndex = 0; |
| |
| sal_Bool bError = sal_False; |
| sal_Bool bOverflow = sal_False; |
| |
| sal_uInt16 nDayOfMonth = 0; |
| rInner = nIStart; |
| while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes |
| { |
| if (!bError && !bOverflow) |
| { |
| switch (eFillCmd) |
| { |
| case FILL_LINEAR: |
| { |
| // #86365# use multiplication instead of repeated addition |
| // to avoid accumulating rounding errors |
| nVal = nStartVal; |
| double nAdd = nStepValue; |
| if ( !SubTotal::SafeMult( nAdd, (double) ++nIndex ) || |
| !SubTotal::SafePlus( nVal, nAdd ) ) |
| bError = sal_True; |
| } |
| break; |
| case FILL_GROWTH: |
| if (!SubTotal::SafeMult(nVal, nStepValue)) |
| bError = sal_True; |
| break; |
| case FILL_DATE: |
| if (fabs(nVal) > _D_MAX_LONG_) |
| bError = sal_True; |
| else |
| IncDate(nVal, nDayOfMonth, nStepValue, eFillDateCmd); |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| |
| if (nStepValue >= 0) |
| { |
| if (nVal > nMaxValue) // Zielwert erreicht? |
| { |
| nVal = nMaxValue; |
| bOverflow = sal_True; |
| } |
| } |
| else |
| { |
| if (nVal < nMaxValue) |
| { |
| nVal = nMaxValue; |
| bOverflow = sal_True; |
| } |
| } |
| } |
| |
| if (bError) |
| aCol[nCol].SetError(static_cast<SCROW>(nRow), errNoValue); |
| else if (!bOverflow) |
| aCol[nCol].SetValue(static_cast<SCROW>(nRow), nVal); |
| |
| if (rInner == nIEnd) break; |
| if (bPositive) ++rInner; else --rInner; |
| } |
| nProgress += nIMax - nIMin + 1; |
| rProgress.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; |
| } |
| String aValue; |
| if (eCellType == CELLTYPE_STRING) |
| ((ScStringCell*)pSrcCell)->GetString( aValue ); |
| else |
| ((ScEditCell*)pSrcCell)->GetString( aValue ); |
| sal_Int32 nStringValue; |
| sal_uInt16 nMinDigits = nArgMinDigits; |
| short nHeadNoneTail = lcl_DecompValueString( aValue, nStringValue, &nMinDigits ); |
| if ( nHeadNoneTail ) |
| { |
| double nStartVal = (double)nStringValue; |
| double nVal = nStartVal; |
| long nIndex = 0; |
| sal_Bool bError = sal_False; |
| sal_Bool bOverflow = sal_False; |
| |
| sal_Bool bIsOrdinalSuffix = aValue.Equals( ScGlobal::GetOrdinalSuffix( |
| (sal_Int32)nStartVal)); |
| |
| rInner = nIStart; |
| while (true) // #i53728# with "for (;;)" old solaris/x86 compiler mis-optimizes |
| { |
| if (!bError && !bOverflow) |
| { |
| switch (eFillCmd) |
| { |
| case FILL_LINEAR: |
| { |
| // #86365# use multiplication instead of repeated addition |
| // to avoid accumulating rounding errors |
| nVal = nStartVal; |
| double nAdd = nStepValue; |
| if ( !SubTotal::SafeMult( nAdd, (double) ++nIndex ) || |
| !SubTotal::SafePlus( nVal, nAdd ) ) |
| bError = sal_True; |
| } |
| break; |
| case FILL_GROWTH: |
| if (!SubTotal::SafeMult(nVal, nStepValue)) |
| bError = sal_True; |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| |
| if (nStepValue >= 0) |
| { |
| if (nVal > nMaxValue) // Zielwert erreicht? |
| { |
| nVal = nMaxValue; |
| bOverflow = sal_True; |
| } |
| } |
| else |
| { |
| if (nVal < nMaxValue) |
| { |
| nVal = nMaxValue; |
| bOverflow = sal_True; |
| } |
| } |
| } |
| |
| if (bError) |
| aCol[nCol].SetError(static_cast<SCROW>(nRow), errNoValue); |
| else if (!bOverflow) |
| { |
| nStringValue = (sal_Int32)nVal; |
| String aStr; |
| if ( nHeadNoneTail < 0 ) |
| { |
| aCol[nCol].Insert( static_cast<SCROW>(nRow), |
| lcl_getSuffixCell( pDocument, |
| nStringValue, nMinDigits, aValue, |
| eCellType, bIsOrdinalSuffix )); |
| } |
| else |
| { |
| aStr = aValue; |
| aStr += lcl_ValueString( nStringValue, nMinDigits ); |
| ScStringCell* pCell = new ScStringCell( aStr ); |
| aCol[nCol].Insert( static_cast<SCROW>(nRow), pCell ); |
| } |
| } |
| |
| if (rInner == nIEnd) break; |
| if (bPositive) ++rInner; else --rInner; |
| } |
| } |
| nProgress += nIMax - nIMin + 1; |
| rProgress.SetStateOnPercent( nProgress ); |
| } |
| } |
| else |
| { |
| nProgress += nIMax - nIMin + 1; |
| rProgress.SetStateOnPercent( nProgress ); |
| } |
| ++nActFormCnt; |
| } |
| } |
| |
| void ScTable::Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, |
| sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd, |
| double nStepValue, double nMaxValue) |
| { |
| sal_uLong nProgCount; |
| if (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP) |
| nProgCount = nCol2 - nCol1 + 1; |
| else |
| nProgCount = nRow2 - nRow1 + 1; |
| nProgCount *= nFillCount; |
| ScProgress aProgress( pDocument->GetDocumentShell(), |
| ScGlobal::GetRscString(STR_FILL_SERIES_PROGRESS), nProgCount ); |
| |
| bSharedNameInserted = sal_False; |
| |
| if (eFillCmd == FILL_AUTO) |
| FillAuto(nCol1, nRow1, nCol2, nRow2, nFillCount, eFillDir, aProgress); |
| else |
| FillSeries(nCol1, nRow1, nCol2, nRow2, nFillCount, eFillDir, |
| eFillCmd, eFillDateCmd, nStepValue, nMaxValue, 0, sal_True, aProgress); |
| |
| if (bSharedNameInserted) // Wurde Shared-Name eingefuegt? |
| pDocument->GetRangeName()->SetSharedMaxIndex( |
| pDocument->GetRangeName()->GetSharedMaxIndex()+1); // dann hochzaehlen |
| } |
| |
| |
| void ScTable::AutoFormatArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, |
| const ScPatternAttr& rAttr, sal_uInt16 nFormatNo) |
| { |
| ScAutoFormat* pAutoFormat = ScGlobal::GetAutoFormat(); |
| if (pAutoFormat) |
| { |
| ScAutoFormatData* pData = (*pAutoFormat)[nFormatNo]; |
| if (pData) |
| { |
| // ScPatternAttr aPattern(pDocument->GetPool()); |
| // pData->FillToItemSet(nIndex, aPattern.GetItemSet(), *pDocument); |
| ApplyPatternArea(nStartCol, nStartRow, nEndCol, nEndRow, rAttr); |
| } |
| } |
| } |
| |
| void ScTable::AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, |
| sal_uInt16 nFormatNo ) |
| { |
| if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow)) |
| { |
| ScAutoFormat* pAutoFormat = ScGlobal::GetAutoFormat(); |
| if (pAutoFormat) |
| { |
| ScAutoFormatData* pData = (*pAutoFormat)[nFormatNo]; |
| if (pData) |
| { |
| ScPatternAttr* pPatternAttrs[16]; |
| for (sal_uInt8 i = 0; i < 16; ++i) |
| { |
| pPatternAttrs[i] = new ScPatternAttr(pDocument->GetPool()); |
| pData->FillToItemSet(i, pPatternAttrs[i]->GetItemSet(), *pDocument); |
| } |
| |
| SCCOL nCol = nStartCol; |
| SCROW nRow = nStartRow; |
| sal_uInt16 nIndex = 0; |
| // Linke obere Ecke |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| // Linke Spalte |
| if (pData->IsEqualData(4, 8)) |
| AutoFormatArea(nStartCol, nStartRow + 1, nStartCol, nEndRow - 1, *pPatternAttrs[4], nFormatNo); |
| else |
| { |
| nIndex = 4; |
| for (nRow = nStartRow + 1; nRow < nEndRow; nRow++) |
| { |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| if (nIndex == 4) |
| nIndex = 8; |
| else |
| nIndex = 4; |
| } |
| } |
| // Linke untere Ecke |
| nRow = nEndRow; |
| nIndex = 12; |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| // Rechte obere Ecke |
| nCol = nEndCol; |
| nRow = nStartRow; |
| nIndex = 3; |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| // Rechte Spalte |
| if (pData->IsEqualData(7, 11)) |
| AutoFormatArea(nEndCol, nStartRow + 1, nEndCol, nEndRow - 1, *pPatternAttrs[7], nFormatNo); |
| else |
| { |
| nIndex = 7; |
| for (nRow = nStartRow + 1; nRow < nEndRow; nRow++) |
| { |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| if (nIndex == 7) |
| nIndex = 11; |
| else |
| nIndex = 7; |
| } |
| } |
| // Rechte untere Ecke |
| nRow = nEndRow; |
| nIndex = 15; |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| nRow = nStartRow; |
| nIndex = 1; |
| for (nCol = nStartCol + 1; nCol < nEndCol; nCol++) |
| { |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| if (nIndex == 1) |
| nIndex = 2; |
| else |
| nIndex = 1; |
| } |
| // Untere Zeile |
| nRow = nEndRow; |
| nIndex = 13; |
| for (nCol = nStartCol + 1; nCol < nEndCol; nCol++) |
| { |
| AutoFormatArea(nCol, nRow, nCol, nRow, *pPatternAttrs[nIndex], nFormatNo); |
| if (nIndex == 13) |
| nIndex = 14; |
| else |
| nIndex = 13; |
| } |
| // Boddy |
| if ((pData->IsEqualData(5, 6)) && (pData->IsEqualData(9, 10)) && (pData->IsEqualData(5, 9))) |
| AutoFormatArea(nStartCol + 1, nStartRow + 1, nEndCol-1, nEndRow - 1, *pPatternAttrs[5], nFormatNo); |
| else |
| { |
| if ((pData->IsEqualData(5, 9)) && (pData->IsEqualData(6, 10))) |
| { |
| nIndex = 5; |
| for (nCol = nStartCol + 1; nCol < nEndCol; nCol++) |
| { |
| AutoFormatArea(nCol, nStartRow + 1, nCol, nEndRow - 1, *pPatternAttrs[nIndex], nFormatNo); |
| if (nIndex == 5) |
| nIndex = 6; |
| else |
| nIndex = 5; |
| } |
| } |
| else |
| { |
| nIndex = 5; |
| for (nCol = nStartCol + 1; nCol < nEndCol; nCol++) |
| { |
| for (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; |
| } // for nCol |
| } // if not equal Column |
| } // if not all equal |
| |
| for (sal_uInt8 j = 0; j < 16; ++j) |
| delete pPatternAttrs[j]; |
| } // if AutoFormatData != NULL |
| } // if AutoFormat != NULL |
| } // if ValidColRow |
| } |
| |
| void ScTable::GetAutoFormatAttr(SCCOL nCol, SCROW nRow, sal_uInt16 nIndex, ScAutoFormatData& rData) |
| { |
| sal_uInt32 nFormatIndex = GetNumberFormat( nCol, nRow ); |
| ScNumFormatAbbrev aNumFormat( nFormatIndex, *pDocument->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 nIndex, ScAutoFormatData& rData) |
| { |
| const SvxBoxItem* pTheBox = (SvxBoxItem*)GetAttr(nCol, nRow, ATTR_BORDER); |
| const SvxBoxItem* pLeftBox = (SvxBoxItem*)GetAttr(nCol - 1, nRow, ATTR_BORDER); |
| const SvxBoxItem* pTopBox = (SvxBoxItem*)GetAttr(nCol, nRow - 1, ATTR_BORDER); |
| const SvxBoxItem* pRightBox = (SvxBoxItem*)GetAttr(nCol + 1, nRow, ATTR_BORDER); |
| const SvxBoxItem* pBottomBox = (SvxBoxItem*)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(), BOX_LINE_LEFT); |
| else |
| aBox.SetLine(pLeftBox->GetRight(), BOX_LINE_LEFT); |
| } |
| else |
| aBox.SetLine(pTheBox->GetLeft(), BOX_LINE_LEFT); |
| } |
| if (nFlags & LF_TOP) |
| { |
| if (pTopBox) |
| { |
| if (ScHasPriority(pTheBox->GetTop(), pTopBox->GetBottom())) |
| aBox.SetLine(pTheBox->GetTop(), BOX_LINE_TOP); |
| else |
| aBox.SetLine(pTopBox->GetBottom(), BOX_LINE_TOP); |
| } |
| else |
| aBox.SetLine(pTheBox->GetTop(), BOX_LINE_TOP); |
| } |
| if (nFlags & LF_RIGHT) |
| { |
| if (pRightBox) |
| { |
| if (ScHasPriority(pTheBox->GetRight(), pRightBox->GetLeft())) |
| aBox.SetLine(pTheBox->GetRight(), BOX_LINE_RIGHT); |
| else |
| aBox.SetLine(pRightBox->GetLeft(), BOX_LINE_RIGHT); |
| } |
| else |
| aBox.SetLine(pTheBox->GetRight(), BOX_LINE_RIGHT); |
| } |
| if (nFlags & LF_BOTTOM) |
| { |
| if (pBottomBox) |
| { |
| if (ScHasPriority(pTheBox->GetBottom(), pBottomBox->GetTop())) |
| aBox.SetLine(pTheBox->GetBottom(), BOX_LINE_BOTTOM); |
| else |
| aBox.SetLine(pBottomBox->GetTop(), BOX_LINE_BOTTOM); |
| } |
| else |
| aBox.SetLine(pTheBox->GetBottom(), BOX_LINE_BOTTOM); |
| } |
| rData.PutItem( nIndex, aBox ); |
| } |
| |
| void ScTable::GetAutoFormatData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScAutoFormatData& rData) |
| { |
| if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow)) |
| { |
| if ((nEndCol - nStartCol >= 3) && (nEndRow - nStartRow >= 3)) |
| { |
| // Linke obere Ecke |
| GetAutoFormatAttr(nStartCol, nStartRow, 0, rData); |
| GetAutoFormatFrame(nStartCol, nStartRow, LF_ALL, 0, rData); |
| // Linke Spalte |
| 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 ); |
| // Linke untere Ecke |
| GetAutoFormatAttr(nStartCol, nEndRow, 12, rData); |
| GetAutoFormatFrame(nStartCol, nEndRow, LF_ALL, 12, rData); |
| // Rechte obere Ecke |
| GetAutoFormatAttr(nEndCol, nStartRow, 3, rData); |
| GetAutoFormatFrame(nEndCol, nStartRow, LF_ALL, 3, rData); |
| // Rechte Spalte |
| 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 ); |
| // Rechte untere Ecke |
| GetAutoFormatAttr(nEndCol, nEndRow, 15, rData); |
| GetAutoFormatFrame(nEndCol, nEndRow, LF_ALL, 15, rData); |
| // Ober Zeile |
| 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 ); |
| // Untere Zeile |
| 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, sal_uInt16 nError) |
| { |
| if (ValidColRow(nCol, nRow)) |
| aCol[nCol].SetError( nRow, nError ); |
| } |
| |
| void ScTable::UpdateInsertTabAbs(SCTAB nTable) |
| { |
| for (SCCOL i=0; i <= MAXCOL; i++) |
| aCol[i].UpdateInsertTabAbs(nTable); |
| } |
| |
| //UNUSED2008-05 sal_uInt16 ScTable::GetErrorData( SCCOL nCol, SCROW nRow ) const |
| //UNUSED2008-05 { |
| //UNUSED2008-05 if (ValidColRow(nCol,nRow)) |
| //UNUSED2008-05 return aCol[nCol].GetErrorData( nRow ); |
| //UNUSED2008-05 else |
| //UNUSED2008-05 return 0; |
| //UNUSED2008-05 } |
| |
| sal_Bool ScTable::GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, sal_Bool bInSel, |
| const ScMarkData& rMark) const |
| { |
| if (rRow == MAXROW+2) // Tabellenende |
| { |
| rRow = 0; |
| rCol = 0; |
| } |
| else |
| { |
| rRow++; |
| if (rRow == MAXROW+1) |
| { |
| rCol++; |
| rRow = 0; |
| } |
| } |
| if (rCol == MAXCOL+1) |
| return sal_True; |
| else |
| { |
| sal_Bool bStop = sal_False; |
| while (!bStop) |
| { |
| if (ValidCol(rCol)) |
| { |
| bStop = aCol[rCol].GetNextSpellingCell(rRow, bInSel, rMark); |
| if (bStop) |
| return sal_True; |
| else /*if (rRow == MAXROW+1) */ |
| { |
| rCol++; |
| rRow = 0; |
| } |
| } |
| else |
| return sal_True; |
| } |
| } |
| return sal_False; |
| } |
| |
| void ScTable::RemoveAutoSpellObj() |
| { |
| for (SCCOL i=0; i <= MAXCOL; i++) |
| aCol[i].RemoveAutoSpellObj(); |
| } |
| |
| sal_Bool ScTable::TestTabRefAbs(SCTAB nTable) |
| { |
| sal_Bool bRet = sal_False; |
| for (SCCOL i=0; i <= MAXCOL; i++) |
| if (aCol[i].TestTabRefAbs(nTable)) |
| bRet = sal_True; |
| return bRet; |
| } |
| |
| void ScTable::CompileDBFormula() |
| { |
| for (SCCOL i=0; i<=MAXCOL; i++) aCol[i].CompileDBFormula(); |
| } |
| |
| void ScTable::CompileDBFormula( sal_Bool bCreateFormulaString ) |
| { |
| for (SCCOL i=0; i<=MAXCOL; i++) aCol[i].CompileDBFormula( bCreateFormulaString ); |
| } |
| |
| void ScTable::CompileNameFormula( sal_Bool bCreateFormulaString ) |
| { |
| for (SCCOL i=0; i<=MAXCOL; i++) aCol[i].CompileNameFormula( bCreateFormulaString ); |
| } |
| |
| void ScTable::CompileColRowNameFormula() |
| { |
| for (SCCOL i=0; i<=MAXCOL; i++) aCol[i].CompileColRowNameFormula(); |
| } |
| |
| SCSIZE ScTable::GetPatternCount( SCCOL nCol ) |
| { |
| if( ValidCol( nCol ) ) |
| return aCol[nCol].GetPatternCount(); |
| else |
| return 0; |
| } |
| |
| SCSIZE ScTable::GetPatternCount( SCCOL nCol, SCROW nRw1, SCROW nRw2 ) |
| { |
| if( ValidCol( nCol ) && ValidRow( nRw1 ) && ValidRow( nRw2 ) ) |
| return aCol[nCol].GetPatternCount( nRw1, nRw2 ); |
| else |
| return 0; |
| } |
| |
| bool ScTable::ReservedPatternCount( SCCOL nCol, SCSIZE nReserved ) |
| { |
| if( ValidCol( nCol ) ) |
| return aCol[nCol].ReservedPatternCount( nReserved ); |
| else |
| return false; |
| } |
