?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid potential negative array index access to cached text.
[LibreOffice.git] / sc / source / core / data / documen4.cxx
blobe9a4fea132f246953f908646e0a9787c6de14a34
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <svl/numformat.hxx>
21 #include <svl/zforlist.hxx>
22 #include <svl/zformat.hxx>
23 #include <formula/token.hxx>
24 #include <sal/log.hxx>
25 #include <unotools/configmgr.hxx>
26 #include <osl/diagnose.h>
27 #include <o3tl/string_view.hxx>
28
29 #include <document.hxx>
30 #include <docsh.hxx>
31 #include <table.hxx>
32 #include <globstr.hrc>
33 #include <scresid.hxx>
34 #include <subtotal.hxx>
35 #include <docoptio.hxx>
36 #include <markdata.hxx>
37 #include <validat.hxx>
38 #include <scitems.hxx>
39 #include <stlpool.hxx>
40 #include <poolhelp.hxx>
41 #include <detdata.hxx>
42 #include <patattr.hxx>
43 #include <chgtrack.hxx>
44 #include <progress.hxx>
45 #include <paramisc.hxx>
46 #include <compiler.hxx>
47 #include <externalrefmgr.hxx>
48 #include <attrib.hxx>
49 #include <formulacell.hxx>
50 #include <tokenarray.hxx>
51 #include <tokenstringcontext.hxx>
52 #include <memory>
53
54 using namespace formula;
55
56 /** (Goal Seek) Find a value of x that is a root of f(x)
57
58 This function is used internally for the goal seek operation. It uses the
59 Regula Falsi (aka false position) algorithm to find a root of f(x). The
60 start value and the target value are to be given by the user in the
61 goal seek dialog. The f(x) in this case is defined as the formula in the
62 formula cell minus target value. This function may also perform additional
63 search in the horizontal directions when the f(x) is discrete in order to
64 ensure a non-zero slope necessary for deriving a subsequent x that is
65 reasonably close to the root of interest.
66
67 @change 24.10.2004 by Kohei Yoshida (kohei@openoffice.org)
68
69 @see #i28955#
70
71 @change 6 Aug 2013, fdo37341
72 */
73 bool ScDocument::Solver(SCCOL nFCol, SCROW nFRow, SCTAB nFTab,
74 SCCOL nVCol, SCROW nVRow, SCTAB nVTab,
75 const OUString& sValStr, double& nX)
76 {
77 bool bRet = false;
78 nX = 0.0;
79 if ( ValidColRow( nFCol, nFRow ) && ValidTab( nFTab ) &&
80 ValidColRow( nVCol, nVRow ) && ValidTab( nVTab ) &&
81 nFTab < GetTableCount() && maTabs[nFTab] &&
82 nVTab < GetTableCount() && maTabs[nVTab] )
83 {
84 CellType eFType = GetCellType(nFCol, nFRow, nFTab);
85 CellType eVType = GetCellType(nVCol, nVRow, nVTab);
86 // #i108005# convert target value to number using default format,
87 // as previously done in ScInterpreter::GetDouble
88 ScFormulaCell* pFormula = nullptr;
89 double fTargetVal = 0.0;
90 sal_uInt32 nFIndex = 0;
91 if ( eFType == CELLTYPE_FORMULA && eVType == CELLTYPE_VALUE &&
92 GetFormatTable()->IsNumberFormat( sValStr, nFIndex, fTargetVal ) )
93 {
94 ScAddress aFormulaAdr( nFCol, nFRow, nFTab );
95 pFormula = GetFormulaCell( aFormulaAdr );
96 }
97 if (pFormula)
98 {
99 bool bDoneIteration = false;
100 ScAddress aValueAdr( nVCol, nVRow, nVTab );
101 double* pVCell = GetValueCell( aValueAdr );
102
103 ScRange aVRange( aValueAdr, aValueAdr ); // for SetDirty
104 // Original value to be restored later if necessary
105 double fSaveVal = *pVCell;
106
107 const sal_uInt16 nMaxIter = 100;
108 const double fEps = 1E-10;
109 const double fDelta = 1E-6;
110
111 double fBestX, fXPrev;
112 double fBestF, fFPrev;
113 fBestX = fXPrev = fSaveVal;
114
115 pFormula->Interpret();
116 bool bError = ( pFormula->GetErrCode() != FormulaError::NONE );
117 // bError always corresponds with fF
118
119 fFPrev = pFormula->GetValue() - fTargetVal;
120
121 fBestF = fabs( fFPrev );
122 if ( fBestF < fDelta )
123 bDoneIteration = true;
124
125 double fX = fXPrev + fEps;
126 double fF = fFPrev;
127 double fSlope;
128
129 sal_uInt16 nIter = 0;
130
131 bool bHorMoveError = false;
132 // Conform Regula Falsi Method
133 while ( !bDoneIteration && ( nIter++ < nMaxIter ) )
134 {
135 *pVCell = fX;
136 SetDirty( aVRange, false );
137 pFormula->Interpret();
138 bError = ( pFormula->GetErrCode() != FormulaError::NONE );
139 fF = pFormula->GetValue() - fTargetVal;
140
141 if ( fF == fFPrev && !bError )
142 {
143 // HORIZONTAL SEARCH: Keep moving x in both directions until the f(x)
144 // becomes different from the previous f(x). This routine is needed
145 // when a given function is discrete, in which case the resulting slope
146 // may become zero which ultimately causes the goal seek operation
147 // to fail. #i28955#
148
149 sal_uInt16 nHorIter = 0;
150 const double fHorStepAngle = 5.0;
151 const double fHorMaxAngle = 80.0;
152 int const nHorMaxIter = static_cast<int>( fHorMaxAngle / fHorStepAngle );
153 bool bDoneHorMove = false;
154
155 while ( !bDoneHorMove && !bHorMoveError && nHorIter++ < nHorMaxIter )
156 {
157 double fHorAngle = fHorStepAngle * static_cast<double>( nHorIter );
158 double fHorTangent = std::tan(basegfx::deg2rad(fHorAngle));
159
160 sal_uInt16 nIdx = 0;
161 while( nIdx++ < 2 && !bDoneHorMove )
162 {
163 double fHorX;
164 if ( nIdx == 1 )
165 fHorX = fX + fabs( fF ) * fHorTangent;
166 else
167 fHorX = fX - fabs( fF ) * fHorTangent;
168
169 *pVCell = fHorX;
170 SetDirty( aVRange, false );
171 pFormula->Interpret();
172 bHorMoveError = ( pFormula->GetErrCode() != FormulaError::NONE );
173 if ( bHorMoveError )
174 break;
175
176 fF = pFormula->GetValue() - fTargetVal;
177 if ( fF != fFPrev )
178 {
179 fX = fHorX;
180 bDoneHorMove = true;
181 }
182 }
183 }
184 if ( !bDoneHorMove )
185 bHorMoveError = true;
186 }
187
188 if ( bError )
189 {
190 // move closer to last valid value (fXPrev), keep fXPrev & fFPrev
191 double fDiff = ( fXPrev - fX ) / 2;
192 if ( fabs( fDiff ) < fEps )
193 fDiff = ( fDiff < 0.0 ? - fEps : fEps );
194 fX += fDiff;
195 }
196 else if ( bHorMoveError )
197 break;
198 else if ( fabs(fF) < fDelta )
199 {
200 // converged to root
201 fBestX = fX;
202 bDoneIteration = true;
203 }
204 else
205 {
206 if ( fabs(fF) + fDelta < fBestF )
207 {
208 fBestX = fX;
209 fBestF = fabs( fF );
210 }
211
212 if ( ( fXPrev - fX ) != 0 )
213 {
214 fSlope = ( fFPrev - fF ) / ( fXPrev - fX );
215 if ( fabs( fSlope ) < fEps )
216 fSlope = fSlope < 0.0 ? -fEps : fEps;
217 }
218 else
219 fSlope = fEps;
220
221 fXPrev = fX;
222 fFPrev = fF;
223 fX = fX - ( fF / fSlope );
224 }
225 }
226
227 // Try a nice rounded input value if possible.
228 const double fNiceDelta = ( bDoneIteration && fabs( fBestX ) >= 1e-3 ? 1e-3 : fDelta );
229 nX = ::rtl::math::approxFloor( ( fBestX / fNiceDelta ) + 0.5 ) * fNiceDelta;
230
231 if ( bDoneIteration )
232 {
233 *pVCell = nX;
234 SetDirty( aVRange, false );
235 pFormula->Interpret();
236 if ( fabs( pFormula->GetValue() - fTargetVal ) > fabs( fF ) )
237 nX = fBestX;
238 bRet = true;
239 }
240 else if ( bError || bHorMoveError )
241 {
242 nX = fBestX;
243 }
244 *pVCell = fSaveVal;
245 SetDirty( aVRange, false );
246 pFormula->Interpret();
247 if ( !bDoneIteration )
248 {
249 SetError( nVCol, nVRow, nVTab, FormulaError::NotAvailable );
250 }
251 }
252 else
253 {
254 SetError( nVCol, nVRow, nVTab, FormulaError::NotAvailable );
255 }
256 }
257 return bRet;
258 }
259
260 void ScDocument::InsertMatrixFormula(SCCOL nCol1, SCROW nRow1,
261 SCCOL nCol2, SCROW nRow2,
262 const ScMarkData& rMark,
263 const OUString& rFormula,
264 const ScTokenArray* pArr,
265 const formula::FormulaGrammar::Grammar eGram )
266 {
267 PutInOrder(nCol1, nCol2);
268 PutInOrder(nRow1, nRow2);
269 nCol2 = std::min<SCCOL>(nCol2, MaxCol());
270 nRow2 = std::min<SCROW>(nRow2, MaxRow());
271 if (!rMark.GetSelectCount())
272 {
273 SAL_WARN("sc", "ScDocument::InsertMatrixFormula: No table marked");
274 return;
275 }
276 if (utl::ConfigManager::IsFuzzing())
277 {
278 // just too slow
279 if (nCol2 - nCol1 > 64)
280 return;
281 if (nRow2 - nRow1 > 64)
282 return;
283 }
284 assert( ValidColRow( nCol1, nRow1) && ValidColRow( nCol2, nRow2));
285
286 SCTAB nTab1 = *rMark.begin();
287
288 ScFormulaCell* pCell;
289 ScAddress aPos( nCol1, nRow1, nTab1 );
290 if (pArr)
291 pCell = new ScFormulaCell(*this, aPos, *pArr, eGram, ScMatrixMode::Formula);
292 else
293 pCell = new ScFormulaCell(*this, aPos, rFormula, eGram, ScMatrixMode::Formula);
294 pCell->SetMatColsRows( nCol2 - nCol1 + 1, nRow2 - nRow1 + 1 );
295 SCTAB nMax = GetTableCount();
296 for (const auto& rTab : rMark)
297 {
298 if (rTab >= nMax)
299 break;
300
301 if (!maTabs[rTab])
302 continue;
303
304 if (rTab == nTab1)
305 {
306 pCell = maTabs[rTab]->SetFormulaCell(nCol1, nRow1, pCell);
307 if (!pCell) //NULL if nCol1/nRow1 is invalid, which it can't be here
308 break;
309 }
310 else
311 maTabs[rTab]->SetFormulaCell(
312 nCol1, nRow1,
313 new ScFormulaCell(
314 *pCell, *this, ScAddress(nCol1, nRow1, rTab), ScCloneFlags::StartListening));
315 }
316
317 ScSingleRefData aRefData;
318 aRefData.InitFlags();
319 aRefData.SetRelCol(0);
320 aRefData.SetRelRow(0);
321 aRefData.SetRelTab(0); // 2D matrix, always same sheet
322
323 ScTokenArray aArr(*this); // consists only of one single reference token.
324 formula::FormulaToken* t = aArr.AddMatrixSingleReference(aRefData);
325
326 for (const SCTAB& nTab : rMark)
327 {
328 if (nTab >= nMax)
329 break;
330
331 ScTable* pTab = FetchTable(nTab);
332 if (!pTab)
333 continue;
334
335 for (SCCOL nCol : GetWritableColumnsRange(nTab, nCol1, nCol2))
336 {
337 aRefData.SetRelCol(nCol1 - nCol);
338 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
339 {
340 if (nCol == nCol1 && nRow == nRow1)
341 // Skip the base position.
342 continue;
343
344 // Reference in each cell must point to the origin cell relative to the current cell.
345 aRefData.SetRelRow(nRow1 - nRow);
346 *t->GetSingleRef() = aRefData;
347 // Token array must be cloned so that each formula cell receives its own copy.
348 ScTokenArray aTokArr(aArr.CloneValue());
349 aPos = ScAddress(nCol, nRow, nTab);
350 pCell = new ScFormulaCell(*this, aPos, aTokArr, eGram, ScMatrixMode::Reference);
351 pTab->SetFormulaCell(nCol, nRow, pCell);
352 }
353 }
354 }
355 }
356
357 void ScDocument::InsertTableOp(const ScTabOpParam& rParam, // multiple (repeated?) operation
358 SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
359 const ScMarkData& rMark)
360 {
361 PutInOrder(nCol1, nCol2);
362 PutInOrder(nRow1, nRow2);
363 assert( ValidColRow( nCol1, nRow1) && ValidColRow( nCol2, nRow2));
364 SCTAB i, nTab1;
365 SCCOL j;
366 SCROW k;
367 i = 0;
368 bool bStop = false;
369 SCTAB nMax = GetTableCount();
370 for (const auto& rTab : rMark)
371 {
372 if (rTab >= nMax)
373 break;
374
375 if (maTabs[rTab])
376 {
377 i = rTab;
378 bStop = true;
379 break;
380 }
381 }
382 nTab1 = i;
383 if (!bStop)
384 {
385 OSL_FAIL("ScDocument::InsertTableOp: No table marked");
386 return;
387 }
388
389 ScRefAddress aRef;
390 OUStringBuffer aForString("="
391 + ScCompiler::GetNativeSymbol(ocTableOp)
392 + ScCompiler::GetNativeSymbol( ocOpen));
393
394 const OUString& sSep = ScCompiler::GetNativeSymbol( ocSep);
395 if (rParam.meMode == ScTabOpParam::Column) // column only
396 {
397 aRef.Set( rParam.aRefFormulaCell.GetAddress(), true, false, false );
398 aForString.append(aRef.GetRefString(*this, nTab1)
399 + sSep
400 + rParam.aRefColCell.GetRefString(*this, nTab1)
401 + sSep);
402 aRef.Set( nCol1, nRow1, nTab1, false, true, true );
403 aForString.append(aRef.GetRefString(*this, nTab1));
404 nCol1++;
405 nCol2 = std::min( nCol2, static_cast<SCCOL>(rParam.aRefFormulaEnd.Col() -
406 rParam.aRefFormulaCell.Col() + nCol1 + 1));
407 }
408 else if (rParam.meMode == ScTabOpParam::Row) // row only
409 {
410 aRef.Set( rParam.aRefFormulaCell.GetAddress(), false, true, false );
411 aForString.append(aRef.GetRefString(*this, nTab1)
412 + sSep
413 + rParam.aRefRowCell.GetRefString(*this, nTab1)
414 + sSep);
415 aRef.Set( nCol1, nRow1, nTab1, true, false, true );
416 aForString.append(aRef.GetRefString(*this, nTab1));
417 nRow1++;
418 nRow2 = std::min( nRow2, static_cast<SCROW>(rParam.aRefFormulaEnd.Row() -
419 rParam.aRefFormulaCell.Row() + nRow1 + 1));
420 }
421 else // both
422 {
423 aForString.append(rParam.aRefFormulaCell.GetRefString(*this, nTab1)
424 + sSep
425 + rParam.aRefColCell.GetRefString(*this, nTab1)
426 + sSep);
427 aRef.Set( nCol1, nRow1 + 1, nTab1, false, true, true );
428 aForString.append(aRef.GetRefString(*this, nTab1)
429 + sSep
430 + rParam.aRefRowCell.GetRefString(*this, nTab1)
431 + sSep);
432 aRef.Set( nCol1 + 1, nRow1, nTab1, true, false, true );
433 aForString.append(aRef.GetRefString(*this, nTab1));
434 nCol1++; nRow1++;
435 }
436 aForString.append(ScCompiler::GetNativeSymbol( ocClose ));
437
438 ScFormulaCell aRefCell( *this, ScAddress( nCol1, nRow1, nTab1 ), aForString.makeStringAndClear(),
439 formula::FormulaGrammar::GRAM_NATIVE, ScMatrixMode::NONE );
440 for( j = nCol1; j <= nCol2; j++ )
441 for( k = nRow1; k <= nRow2; k++ )
442 for (i = 0; i < GetTableCount(); i++)
443 {
444 for (const auto& rTab : rMark)
445 {
446 if (rTab >= nMax)
447 break;
448 if( maTabs[rTab] )
449 maTabs[rTab]->SetFormulaCell(
450 j, k, new ScFormulaCell(aRefCell, *this, ScAddress(j, k, rTab), ScCloneFlags::StartListening));
451 }
452 }
453 }
454
455 namespace {
456
457 bool setCacheTableReferenced(const ScDocument& rDoc, formula::FormulaToken& rToken, ScExternalRefManager& rRefMgr, const ScAddress& rPos)
458 {
459 switch (rToken.GetType())
460 {
461 case svExternalSingleRef:
462 return rRefMgr.setCacheTableReferenced(
463 rToken.GetIndex(), rToken.GetString().getString(), 1);
464 case svExternalDoubleRef:
465 {
466 const ScComplexRefData& rRef = *rToken.GetDoubleRef();
467 ScRange aAbs = rRef.toAbs(rDoc, rPos);
468 size_t nSheets = aAbs.aEnd.Tab() - aAbs.aStart.Tab() + 1;
469 return rRefMgr.setCacheTableReferenced(
470 rToken.GetIndex(), rToken.GetString().getString(), nSheets);
471 }
472 case svExternalName:
473 /* TODO: external names aren't supported yet, but would
474 * have to be marked as well, if so. Mechanism would be
475 * different. */
476 OSL_FAIL("ScDocument::MarkUsedExternalReferences: implement the svExternalName case!");
477 break;
478 default:
479 break;
480 }
481 return false;
482 }
483
484 }
485
486 bool ScDocument::MarkUsedExternalReferences( const ScTokenArray& rArr, const ScAddress& rPos )
487 {
488 if (!rArr.GetLen())
489 return false;
490
491 ScExternalRefManager* pRefMgr = nullptr;
492 formula::FormulaTokenArrayPlainIterator aIter( rArr );
493 bool bAllMarked = false;
494 while (!bAllMarked)
495 {
496 formula::FormulaToken* t = aIter.GetNextReferenceOrName();
497 if (!t)
498 break;
499 if (t->IsExternalRef())
500 {
501 if (!pRefMgr)
502 pRefMgr = GetExternalRefManager();
503
504 bAllMarked = setCacheTableReferenced(*this, *t, *pRefMgr, rPos);
505 }
506 else if (t->GetType() == svIndex)
507 {
508 // this is a named range. Check if the range contains an external
509 // reference.
510 ScRangeData* pRangeData = GetRangeName()->findByIndex(t->GetIndex());
511 if (!pRangeData)
512 continue;
513
514 ScTokenArray* pArray = pRangeData->GetCode();
515 formula::FormulaTokenArrayPlainIterator aArrayIter(*pArray);
516 for (t = aArrayIter.First(); t; t = aArrayIter.Next())
517 {
518 if (!t->IsExternalRef())
519 continue;
520
521 if (!pRefMgr)
522 pRefMgr = GetExternalRefManager();
523
524 bAllMarked = setCacheTableReferenced(*this, *t, *pRefMgr, rPos);
525 }
526 }
527 }
528 return bAllMarked;
529 }
530
531 bool ScDocument::GetNextSpellingCell(SCCOL& nCol, SCROW& nRow, SCTAB nTab,
532 bool bInSel, const ScMarkData& rMark) const
533 {
534 if (const ScTable* pTable = FetchTable(nTab))
535 return pTable->GetNextSpellingCell( nCol, nRow, bInSel, rMark );
536 return false;
537 }
538
539 bool ScDocument::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, SCTAB nTab,
540 const ScMarkData& rMark )
541 {
542 if (ScTable* pTable = FetchTable(nTab))
543 return pTable->GetNextMarkedCell( rCol, rRow, rMark );
544 return false;
545 }
546
547 void ScDocument::ReplaceStyle(const SvxSearchItem& rSearchItem,
548 SCCOL nCol, SCROW nRow, SCTAB nTab,
549 const ScMarkData& rMark)
550 {
551 if (ScTable* pTable = FetchTable(nTab))
552 pTable->ReplaceStyle(rSearchItem, nCol, nRow, rMark, true/*bIsUndoP*/);
553 }
554
555 void ScDocument::CompileDBFormula()
556 {
557 sc::CompileFormulaContext aCxt(*this);
558 for (auto& rxTab : maTabs)
559 {
560 if (rxTab)
561 rxTab->CompileDBFormula(aCxt);
562 }
563 }
564
565 void ScDocument::CompileColRowNameFormula()
566 {
567 sc::CompileFormulaContext aCxt(*this);
568 for (auto& rxTab : maTabs)
569 {
570 if (rxTab)
571 rxTab->CompileColRowNameFormula(aCxt);
572 }
573 }
574
575 void ScDocument::InvalidateTableArea()
576 {
577 for (auto& rxTab : maTabs)
578 {
579 if (!rxTab)
580 break;
581 rxTab->InvalidateTableArea();
582 if ( rxTab->IsScenario() )
583 rxTab->InvalidateScenarioRanges();
584 }
585 }
586
587 sal_Int32 ScDocument::GetMaxStringLen( SCTAB nTab, SCCOL nCol,
588 SCROW nRowStart, SCROW nRowEnd, rtl_TextEncoding eCharSet ) const
589 {
590 if (const ScTable* pTable = FetchTable(nTab))
591 return pTable->GetMaxStringLen(nCol, nRowStart, nRowEnd, eCharSet);
592 return 0;
593 }
594
595 sal_Int32 ScDocument::GetMaxNumberStringLen( sal_uInt16& nPrecision, SCTAB nTab,
596 SCCOL nCol, SCROW nRowStart, SCROW nRowEnd ) const
597 {
598 if (const ScTable* pTable = FetchTable(nTab))
599 return pTable->GetMaxNumberStringLen(nPrecision, nCol, nRowStart, nRowEnd);
600 return 0;
601 }
602
603 bool ScDocument::GetSelectionFunction( ScSubTotalFunc eFunc,
604 const ScAddress& rCursor, const ScMarkData& rMark,
605 double& rResult )
606 {
607 ScFunctionData aData(eFunc);
608
609 ScMarkData aMark(rMark);
610 aMark.MarkToMulti();
611 if (!aMark.IsMultiMarked() && !aMark.IsCellMarked(rCursor.Col(), rCursor.Row()))
612 aMark.SetMarkArea(rCursor);
613
614 SCTAB nMax = GetTableCount();
615 ScMarkData::const_iterator itr = aMark.begin(), itrEnd = aMark.end();
616
617 for (; itr != itrEnd && *itr < nMax && !aData.getError(); ++itr)
618 if (maTabs[*itr])
619 maTabs[*itr]->UpdateSelectionFunction(aData, aMark);
620
621 rResult = aData.getResult();
622 if (aData.getError())
623 rResult = 0.0;
624
625 return !aData.getError();
626 }
627
628 double ScDocument::RoundValueAsShown( double fVal, sal_uInt32 nFormat, const ScInterpreterContext* pContext ) const
629 {
630 const SvNumberFormatter* pFormatter = pContext ? pContext->GetFormatTable() : GetFormatTable();
631 const SvNumberformat* pFormat = pFormatter->GetEntry( nFormat );
632 if (!pFormat)
633 return fVal;
634 SvNumFormatType nType = pFormat->GetMaskedType();
635 if (nType != SvNumFormatType::DATE && nType != SvNumFormatType::TIME && nType != SvNumFormatType::DATETIME )
636 {
637 // MSVC doesn't recognize all paths init nPrecision and wails about
638 // "potentially uninitialized local variable 'nPrecision' used"
639 // so init to some random sensible value preserving all decimals.
640 short nPrecision = 20;
641 bool bStdPrecision = ((nFormat % SV_COUNTRY_LANGUAGE_OFFSET) == 0);
642 if (!bStdPrecision)
643 {
644 sal_uInt16 nIdx = pFormat->GetSubformatIndex( fVal );
645 nPrecision = static_cast<short>(pFormat->GetFormatPrecision( nIdx ));
646 switch ( nType )
647 {
648 case SvNumFormatType::PERCENT: // 0.41% == 0.0041
649 nPrecision += 2;
650 break;
651 case SvNumFormatType::SCIENTIFIC: // 1.23e-3 == 0.00123
652 {
653 short nExp = 0;
654 if ( fVal > 0.0 )
655 nExp = static_cast<short>(floor( log10( fVal ) ));
656 else if ( fVal < 0.0 )
657 nExp = static_cast<short>(floor( log10( -fVal ) ));
658 nPrecision -= nExp;
659 short nInteger = static_cast<short>(pFormat->GetFormatIntegerDigits( nIdx ));
660 if ( nInteger > 1 ) // Engineering notation
661 {
662 short nIncrement = nExp % nInteger;
663 if ( nIncrement != 0 )
664 {
665 nPrecision += nIncrement;
666 if (nExp < 0 )
667 nPrecision += nInteger;
668 }
669 }
670 break;
671 }
672 case SvNumFormatType::FRACTION: // get value of fraction representation
673 {
674 return pFormat->GetRoundFractionValue( fVal );
675 }
676 case SvNumFormatType::NUMBER:
677 case SvNumFormatType::CURRENCY:
678 { // tdf#106253 Thousands divisors for format "0,"
679 const sal_uInt16 nTD = pFormat->GetThousandDivisorPrecision( nIdx );
680 if (nTD == SvNumberFormatter::UNLIMITED_PRECISION)
681 // Format contains General keyword, handled below.
682 bStdPrecision = true;
683 else
684 nPrecision -= nTD;
685 break;
686 }
687 default: break;
688 }
689 }
690 if (bStdPrecision)
691 {
692 nPrecision = static_cast<short>(GetDocOptions().GetStdPrecision());
693 // #i115512# no rounding for automatic decimals
694 if (nPrecision == static_cast<short>(SvNumberFormatter::UNLIMITED_PRECISION))
695 return fVal;
696 }
697 double fRound = ::rtl::math::round( fVal, nPrecision );
698 if ( ::rtl::math::approxEqual( fVal, fRound ) )
699 return fVal; // rounding might introduce some error
700 else
701 return fRound;
702 }
703 else
704 return fVal;
705 }
706
707 // conditional formats and validation ranges
708
709 sal_uLong ScDocument::AddCondFormat( std::unique_ptr<ScConditionalFormat> pNew, SCTAB nTab )
710 {
711 if(!pNew)
712 return 0;
713
714 if (ScTable* pTable = FetchTable(nTab))
715 return pTable->AddCondFormat(std::move(pNew));
716
717 return 0;
718 }
719
720 sal_uLong ScDocument::AddValidationEntry( const ScValidationData& rNew )
721 {
722 if (rNew.IsEmpty())
723 return 0; // empty is always 0
724
725 if (!pValidationList)
726 {
727 ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);
728 pValidationList.reset(new ScValidationDataList);
729 }
730
731 sal_uLong nMax = 0;
732 for( const auto& rxData : *pValidationList )
733 {
734 const ScValidationData* pData = rxData.get();
735 sal_uLong nKey = pData->GetKey();
736 if ( pData->EqualEntries( rNew ) )
737 return nKey;
738 if ( nKey > nMax )
739 nMax = nKey;
740 }
741
742 // might be called from ScPatternAttr::PutInPool; thus clone (real copy)
743
744 sal_uLong nNewKey = nMax + 1;
745 std::unique_ptr<ScValidationData> pInsert(rNew.Clone(this));
746 pInsert->SetKey( nNewKey );
747 ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);
748 pValidationList->InsertNew( std::move(pInsert) );
749 return nNewKey;
750 }
751
752 const SfxPoolItem* ScDocument::GetEffItem(
753 SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const
754 {
755 const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
756 if ( pPattern )
757 {
758 const SfxItemSet& rSet = pPattern->GetItemSet();
759 if ( rSet.GetItemState( ATTR_CONDITIONAL ) == SfxItemState::SET )
760 {
761 const ScCondFormatIndexes& rIndex = pPattern->GetItem(ATTR_CONDITIONAL).GetCondFormatData();
762 ScConditionalFormatList* pCondFormList = GetCondFormList( nTab );
763 if (!rIndex.empty() && pCondFormList)
764 {
765 for(const auto& rItem : rIndex)
766 {
767 const ScConditionalFormat* pForm = pCondFormList->GetFormat( rItem );
768 if ( pForm )
769 {
770 ScAddress aPos(nCol, nRow, nTab);
771 ScRefCellValue aCell(const_cast<ScDocument&>(*this), aPos);
772 const OUString& aStyle = pForm->GetCellStyle(aCell, aPos);
773 if (!aStyle.isEmpty())
774 {
775 SfxStyleSheetBase* pStyleSheet = mxPoolHelper->GetStylePool()->Find(
776 aStyle, SfxStyleFamily::Para );
777 const SfxPoolItem* pItem = nullptr;
778 if ( pStyleSheet && pStyleSheet->GetItemSet().GetItemState(
779 nWhich, true, &pItem ) == SfxItemState::SET )
780 return pItem;
781 }
782 }
783 }
784 }
785 }
786 return &rSet.Get( nWhich );
787 }
788 OSL_FAIL("no pattern");
789 return nullptr;
790 }
791
792 const SfxItemSet* ScDocument::GetCondResult( SCCOL nCol, SCROW nRow, SCTAB nTab, ScRefCellValue* pCell ) const
793 {
794 ScConditionalFormatList* pFormatList = GetCondFormList(nTab);
795 if (!pFormatList)
796 return nullptr;
797
798 ScAddress aPos(nCol, nRow, nTab);
799 ScRefCellValue aCell;
800 if( pCell == nullptr )
801 {
802 aCell.assign(const_cast<ScDocument&>(*this), aPos);
803 pCell = &aCell;
804 }
805 const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
806 const ScCondFormatIndexes& rIndex =
807 pPattern->GetItem(ATTR_CONDITIONAL).GetCondFormatData();
808
809 return GetCondResult(*pCell, aPos, *pFormatList, rIndex);
810 }
811
812 const SfxItemSet* ScDocument::GetCondResult(
813 ScRefCellValue& rCell, const ScAddress& rPos, const ScConditionalFormatList& rList,
814 const ScCondFormatIndexes& rIndex ) const
815 {
816 for (const auto& rItem : rIndex)
817 {
818 const ScConditionalFormat* pForm = rList.GetFormat(rItem);
819 if (!pForm)
820 continue;
821
822 const OUString& aStyle = pForm->GetCellStyle(rCell, rPos);
823 if (!aStyle.isEmpty())
824 {
825 SfxStyleSheetBase* pStyleSheet =
826 mxPoolHelper->GetStylePool()->Find(aStyle, SfxStyleFamily::Para);
827
828 if (pStyleSheet)
829 return &pStyleSheet->GetItemSet();
830
831 // if style is not there, treat like no condition
832 }
833 }
834
835 return nullptr;
836 }
837
838 ScConditionalFormat* ScDocument::GetCondFormat(
839 SCCOL nCol, SCROW nRow, SCTAB nTab ) const
840 {
841 sal_uInt32 nIndex = 0;
842 const ScCondFormatIndexes& rCondFormats = GetAttr(nCol, nRow, nTab, ATTR_CONDITIONAL)->GetCondFormatData();
843
844 if(!rCondFormats.empty())
845 nIndex = rCondFormats[0];
846
847 if (nIndex)
848 {
849 ScConditionalFormatList* pCondFormList = GetCondFormList(nTab);
850 if (pCondFormList)
851 return pCondFormList->GetFormat( nIndex );
852 else
853 {
854 OSL_FAIL("pCondFormList is 0");
855 }
856 }
857
858 return nullptr;
859 }
860
861 ScConditionalFormatList* ScDocument::GetCondFormList(SCTAB nTab) const
862 {
863 if (HasTable(nTab))
864 return maTabs[nTab]->GetCondFormList();
865 return nullptr;
866 }
867
868 void ScDocument::SetCondFormList( ScConditionalFormatList* pList, SCTAB nTab )
869 {
870 if (ScTable* pTable = FetchTable(nTab))
871 pTable->SetCondFormList(pList);
872 }
873
874 const ScValidationData* ScDocument::GetValidationEntry( sal_uInt32 nIndex ) const
875 {
876 if ( pValidationList )
877 return pValidationList->GetData( nIndex );
878 else
879 return nullptr;
880 }
881
882 void ScDocument::DeleteConditionalFormat(sal_uLong nOldIndex, SCTAB nTab)
883 {
884 if (ScTable* pTable = FetchTable(nTab))
885 pTable->DeleteConditionalFormat(nOldIndex);
886 }
887
888 bool ScDocument::HasDetectiveOperations() const
889 {
890 return pDetOpList && pDetOpList->Count();
891 }
892
893 void ScDocument::AddDetectiveOperation( const ScDetOpData& rData )
894 {
895 if (!pDetOpList)
896 pDetOpList.reset(new ScDetOpList);
897
898 pDetOpList->Append( rData );
899 }
900
901 void ScDocument::ClearDetectiveOperations()
902 {
903 pDetOpList.reset(); // deletes also the entries
904 }
905
906 void ScDocument::SetDetOpList(std::unique_ptr<ScDetOpList> pNew)
907 {
908 pDetOpList = std::move(pNew);
909 }
910
911 // Comparison of Documents
912
913 // Pfriemel-Factors
914 #define SC_DOCCOMP_MAXDIFF 256
915 #define SC_DOCCOMP_MINGOOD 128
916 #define SC_DOCCOMP_COLUMNS 10
917 #define SC_DOCCOMP_ROWS 100
918
919 sal_uInt16 ScDocument::RowDifferences( SCROW nThisRow, SCTAB nThisTab,
920 ScDocument& rOtherDoc, SCROW nOtherRow, SCTAB nOtherTab,
921 SCCOL nMaxCol, const SCCOLROW* pOtherCols )
922 {
923 sal_uLong nDif = 0;
924 sal_uLong nUsed = 0;
925 for (SCCOL nThisCol=0; nThisCol<=nMaxCol; nThisCol++)
926 {
927 SCCOL nOtherCol;
928 if ( pOtherCols )
929 nOtherCol = static_cast<SCCOL>(pOtherCols[nThisCol]);
930 else
931 nOtherCol = nThisCol;
932
933 if (ValidCol(nOtherCol)) // only compare columns that are common to both docs
934 {
935 ScRefCellValue aThisCell(*this, ScAddress(nThisCol, nThisRow, nThisTab));
936 ScRefCellValue aOtherCell(rOtherDoc, ScAddress(nOtherCol, nOtherRow, nOtherTab));
937 if (!aThisCell.equalsWithoutFormat(aOtherCell))
938 {
939 if (!aThisCell.isEmpty() && !aOtherCell.isEmpty())
940 nDif += 3;
941 else
942 nDif += 4; // content <-> empty counts more
943 }
944
945 if (!aThisCell.isEmpty() || !aOtherCell.isEmpty())
946 ++nUsed;
947 }
948 }
949
950 if (nUsed > 0)
951 return static_cast<sal_uInt16>((nDif*64)/nUsed); // max.256 (SC_DOCCOMP_MAXDIFF)
952
953 OSL_ENSURE(!nDif,"Diff without Used");
954 return 0;
955 }
956
957 sal_uInt16 ScDocument::ColDifferences( SCCOL nThisCol, SCTAB nThisTab,
958 ScDocument& rOtherDoc, SCCOL nOtherCol, SCTAB nOtherTab,
959 SCROW nMaxRow, const SCCOLROW* pOtherRows )
960 {
961
962 //TODO: optimize e.g. with iterator?
963
964 sal_uInt64 nDif = 0;
965 sal_uInt64 nUsed = 0;
966 for (SCROW nThisRow=0; nThisRow<=nMaxRow; nThisRow++)
967 {
968 SCROW nOtherRow;
969 if ( pOtherRows )
970 nOtherRow = pOtherRows[nThisRow];
971 else
972 nOtherRow = nThisRow;
973
974 if (ValidRow(nOtherRow)) // only compare rows that are common to both docs
975 {
976 ScRefCellValue aThisCell(*this, ScAddress(nThisCol, nThisRow, nThisTab));
977 ScRefCellValue aOtherCell(rOtherDoc, ScAddress(nOtherCol, nOtherRow, nOtherTab));
978 if (!aThisCell.equalsWithoutFormat(aOtherCell))
979 {
980 if (!aThisCell.isEmpty() && !aOtherCell.isEmpty())
981 nDif += 3;
982 else
983 nDif += 4; // content <-> empty counts more
984 }
985
986 if (!aThisCell.isEmpty() || !aOtherCell.isEmpty())
987 ++nUsed;
988 }
989 }
990
991 if (nUsed > 0)
992 return static_cast<sal_uInt16>((nDif*64)/nUsed); // max.256
993
994 OSL_ENSURE(!nDif,"Diff without Used");
995 return 0;
996 }
997
998 void ScDocument::FindOrder( SCCOLROW* pOtherRows, SCCOLROW nThisEndRow, SCCOLROW nOtherEndRow,
999 bool bColumns, ScDocument& rOtherDoc, SCTAB nThisTab, SCTAB nOtherTab,
1000 SCCOLROW nEndCol, const SCCOLROW* pTranslate, ScProgress* pProgress, sal_uInt64 nProAdd )
1001 {
1002 // bColumns=true: rows are columns and vice versa
1003
1004 SCCOLROW nMaxCont; // continue by how much
1005 SCCOLROW nMinGood; // what is a hit (incl.)
1006 if ( bColumns )
1007 {
1008 nMaxCont = SC_DOCCOMP_COLUMNS; // 10 columns
1009 nMinGood = SC_DOCCOMP_MINGOOD;
1010
1011 //TODO: additional pass with nMinGood = 0 ????
1012
1013 }
1014 else
1015 {
1016 nMaxCont = SC_DOCCOMP_ROWS; // 100 rows
1017 nMinGood = SC_DOCCOMP_MINGOOD;
1018 }
1019 bool bUseTotal = bColumns && !pTranslate; // only for the 1st pass
1020
1021 SCCOLROW nOtherRow = 0;
1022 sal_uInt16 nComp;
1023 SCCOLROW nThisRow;
1024 bool bTotal = false; // hold for several nThisRow
1025 SCCOLROW nUnknown = 0;
1026 for (nThisRow = 0; nThisRow <= nThisEndRow; nThisRow++)
1027 {
1028 SCCOLROW nTempOther = nOtherRow;
1029 bool bFound = false;
1030 sal_uInt16 nBest = SC_DOCCOMP_MAXDIFF;
1031 SCCOLROW nMax = std::min( nOtherEndRow, static_cast<SCCOLROW>(( nTempOther + nMaxCont + nUnknown )) );
1032 for (SCCOLROW i=nTempOther; i<=nMax && nBest>0; i++) // stop at 0
1033 {
1034 if (bColumns)
1035 nComp = ColDifferences( static_cast<SCCOL>(nThisRow), nThisTab, rOtherDoc, static_cast<SCCOL>(i), nOtherTab, nEndCol, pTranslate );
1036 else
1037 nComp = RowDifferences( nThisRow, nThisTab, rOtherDoc, i, nOtherTab, static_cast<SCCOL>(nEndCol), pTranslate );
1038 if ( nComp < nBest && ( nComp <= nMinGood || bTotal ) )
1039 {
1040 nTempOther = i;
1041 nBest = nComp;
1042 bFound = true;
1043 }
1044 if ( nComp < SC_DOCCOMP_MAXDIFF || bFound )
1045 bTotal = false;
1046 else if ( i == nTempOther && bUseTotal )
1047 bTotal = true; // only at the very top
1048 }
1049 if ( bFound )
1050 {
1051 pOtherRows[nThisRow] = nTempOther;
1052 nOtherRow = nTempOther + 1;
1053 nUnknown = 0;
1054 }
1055 else
1056 {
1057 pOtherRows[nThisRow] = SCROW_MAX;
1058 ++nUnknown;
1059 }
1060
1061 if (pProgress)
1062 pProgress->SetStateOnPercent(nProAdd+static_cast<sal_uLong>(nThisRow));
1063 }
1064
1065 // fill in blocks that don't match
1066
1067 SCROW nFillStart = 0;
1068 SCROW nFillPos = 0;
1069 bool bInFill = false;
1070 for (nThisRow = 0; nThisRow <= nThisEndRow+1; nThisRow++)
1071 {
1072 SCROW nThisOther = ( nThisRow <= nThisEndRow ) ? pOtherRows[nThisRow] : (nOtherEndRow+1);
1073 if ( ValidRow(nThisOther) )
1074 {
1075 if ( bInFill )
1076 {
1077 if ( nThisOther > nFillStart ) // is there something to distribute?
1078 {
1079 SCROW nDiff1 = nThisOther - nFillStart;
1080 SCROW nDiff2 = nThisRow - nFillPos;
1081 SCROW nMinDiff = std::min(nDiff1, nDiff2);
1082 for (SCROW i=0; i<nMinDiff; i++)
1083 pOtherRows[nFillPos+i] = nFillStart+i;
1084 }
1085
1086 bInFill = false;
1087 }
1088 nFillStart = nThisOther + 1;
1089 nFillPos = nThisRow + 1;
1090 }
1091 else
1092 bInFill = true;
1093 }
1094 }
1095
1096 void ScDocument::CompareDocument( ScDocument& rOtherDoc )
1097 {
1098 if (!pChangeTrack)
1099 return;
1100
1101 SCTAB nThisCount = GetTableCount();
1102 SCTAB nOtherCount = rOtherDoc.GetTableCount();
1103 std::unique_ptr<SCTAB[]> pOtherTabs(new SCTAB[nThisCount]);
1104 SCTAB nThisTab;
1105
1106 // compare tables with identical names
1107 OUString aThisName;
1108 OUString aOtherName;
1109 for (nThisTab=0; nThisTab<nThisCount; nThisTab++)
1110 {
1111 SCTAB nOtherTab = SCTAB_MAX;
1112 if (!IsScenario(nThisTab)) // skip scenarios
1113 {
1114 GetName( nThisTab, aThisName );
1115 for (SCTAB nTemp=0; nTemp<nOtherCount && nOtherTab>MAXTAB; nTemp++)
1116 if (!rOtherDoc.IsScenario(nTemp))
1117 {
1118 rOtherDoc.GetName( nTemp, aOtherName );
1119 if ( aThisName == aOtherName )
1120 nOtherTab = nTemp;
1121 }
1122 }
1123 pOtherTabs[nThisTab] = nOtherTab;
1124 }
1125 // fill in, so that un-named tables don't get lost
1126 SCTAB nFillStart = 0;
1127 SCTAB nFillPos = 0;
1128 bool bInFill = false;
1129 for (nThisTab = 0; nThisTab <= nThisCount; nThisTab++)
1130 {
1131 SCTAB nThisOther = ( nThisTab < nThisCount ) ? pOtherTabs[nThisTab] : nOtherCount;
1132 if ( ValidTab(nThisOther) )
1133 {
1134 if ( bInFill )
1135 {
1136 if ( nThisOther > nFillStart ) // is there something to distribute?
1137 {
1138 SCTAB nDiff1 = nThisOther - nFillStart;
1139 SCTAB nDiff2 = nThisTab - nFillPos;
1140 SCTAB nMinDiff = std::min(nDiff1, nDiff2);
1141 for (SCTAB i=0; i<nMinDiff; i++)
1142 if ( !IsScenario(nFillPos+i) && !rOtherDoc.IsScenario(nFillStart+i) )
1143 pOtherTabs[nFillPos+i] = nFillStart+i;
1144 }
1145
1146 bInFill = false;
1147 }
1148 nFillStart = nThisOther + 1;
1149 nFillPos = nThisTab + 1;
1150 }
1151 else
1152 bInFill = true;
1153 }
1154
1155 // compare tables in the original order
1156
1157 for (nThisTab=0; nThisTab<nThisCount; nThisTab++)
1158 {
1159 SCTAB nOtherTab = pOtherTabs[nThisTab];
1160 if ( ValidTab(nOtherTab) )
1161 {
1162 SCCOL nThisEndCol = 0;
1163 SCROW nThisEndRow = 0;
1164 SCCOL nOtherEndCol = 0;
1165 SCROW nOtherEndRow = 0;
1166 GetCellArea( nThisTab, nThisEndCol, nThisEndRow );
1167 rOtherDoc.GetCellArea( nOtherTab, nOtherEndCol, nOtherEndRow );
1168 SCCOL nEndCol = std::max(nThisEndCol, nOtherEndCol);
1169 SCROW nEndRow = std::max(nThisEndRow, nOtherEndRow);
1170 SCCOL nThisCol;
1171 SCROW nThisRow;
1172 sal_uLong n1,n2; // for AppendDeleteRange
1173
1174 //TODO: one Progress over all tables ???
1175
1176 OUString aTabName;
1177 GetName( nThisTab, aTabName );
1178 OUString aTemplate = ScResId(STR_PROGRESS_COMPARING);
1179 sal_Int32 nIndex = 0;
1180 OUString aProText = o3tl::getToken(aTemplate, 0, '#', nIndex ) +
1181 aTabName +
1182 o3tl::getToken(aTemplate, 0, '#', nIndex );
1183 ScProgress aProgress( GetDocumentShell(), aProText, 3*nThisEndRow, true ); // 2x FindOrder, 1x here
1184 tools::Long nProgressStart = 2*nThisEndRow; // start for here
1185
1186 std::unique_ptr<SCCOLROW[]> pTempRows(new SCCOLROW[nThisEndRow+1]);
1187 std::unique_ptr<SCCOLROW[]> pOtherRows(new SCCOLROW[nThisEndRow+1]);
1188 std::unique_ptr<SCCOLROW[]> pOtherCols(new SCCOLROW[nThisEndCol+1]);
1189
1190 // find inserted/deleted columns/rows:
1191 // Two attempts:
1192 // 1) compare original rows (pTempRows)
1193 // 2) compare original columns (pOtherCols)
1194 // with this column order compare rows (pOtherRows)
1195
1196 //TODO: compare columns twice with different nMinGood ???
1197
1198 // 1
1199 FindOrder( pTempRows.get(), nThisEndRow, nOtherEndRow, false,
1200 rOtherDoc, nThisTab, nOtherTab, nEndCol, nullptr, &aProgress, 0 );
1201 // 2
1202 FindOrder( pOtherCols.get(), nThisEndCol, nOtherEndCol, true,
1203 rOtherDoc, nThisTab, nOtherTab, nEndRow, nullptr, nullptr, 0 );
1204 FindOrder( pOtherRows.get(), nThisEndRow, nOtherEndRow, false,
1205 rOtherDoc, nThisTab, nOtherTab, nThisEndCol,
1206 pOtherCols.get(), &aProgress, nThisEndRow );
1207
1208 sal_uLong nMatch1 = 0; // pTempRows, no columns
1209 for (nThisRow = 0; nThisRow<=nThisEndRow; nThisRow++)
1210 if (ValidRow(pTempRows[nThisRow]))
1211 nMatch1 += SC_DOCCOMP_MAXDIFF -
1212 RowDifferences( nThisRow, nThisTab, rOtherDoc, pTempRows[nThisRow],
1213 nOtherTab, nEndCol, nullptr );
1214
1215 sal_uLong nMatch2 = 0; // pOtherRows, pOtherCols
1216 for (nThisRow = 0; nThisRow<=nThisEndRow; nThisRow++)
1217 if (ValidRow(pOtherRows[nThisRow]))
1218 nMatch2 += SC_DOCCOMP_MAXDIFF -
1219 RowDifferences( nThisRow, nThisTab, rOtherDoc, pOtherRows[nThisRow],
1220 nOtherTab, nThisEndCol, pOtherCols.get() );
1221
1222 if ( nMatch1 >= nMatch2 ) // without columns ?
1223 {
1224 // reset columns
1225 for (nThisCol = 0; nThisCol<=nThisEndCol; nThisCol++)
1226 pOtherCols[nThisCol] = nThisCol;
1227
1228 // swap row-arrays (they get both deleted anyway)
1229 pTempRows.swap(pOtherRows);
1230 }
1231 else
1232 {
1233 // remains for pOtherCols, pOtherRows
1234 }
1235
1236 // Generate Change-Actions
1237 // 1) columns from the right
1238 // 2) rows from below
1239 // 3) single cells in normal order
1240
1241 // Actions for inserted/deleted columns
1242
1243 SCCOL nLastOtherCol = static_cast<SCCOL>(nOtherEndCol + 1);
1244 // nThisEndCol ... 0
1245 for ( nThisCol = nThisEndCol+1; nThisCol > 0; )
1246 {
1247 --nThisCol;
1248 SCCOL nOtherCol = static_cast<SCCOL>(pOtherCols[nThisCol]);
1249 if ( ValidCol(nOtherCol) && nOtherCol+1 < nLastOtherCol )
1250 {
1251 // gap -> deleted
1252 ScRange aDelRange( nOtherCol+1, 0, nOtherTab,
1253 nLastOtherCol-1, MaxRow(), nOtherTab );
1254 pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
1255 }
1256 if ( nOtherCol > MaxCol() ) // inserted
1257 {
1258 // combine
1259 if ( nThisCol == nThisEndCol || ValidCol(static_cast<SCCOL>(pOtherCols[nThisCol+1])) )
1260 {
1261 SCCOL nFirstNew = nThisCol;
1262 while ( nFirstNew > 0 && pOtherCols[nFirstNew-1] > MaxCol() )
1263 --nFirstNew;
1264 SCCOL nDiff = nThisCol - nFirstNew;
1265 ScRange aRange( nLastOtherCol, 0, nOtherTab,
1266 nLastOtherCol+nDiff, MaxRow(), nOtherTab );
1267 pChangeTrack->AppendInsert( aRange );
1268 }
1269 }
1270 else
1271 nLastOtherCol = nOtherCol;
1272 }
1273 if ( nLastOtherCol > 0 ) // deleted at the very top
1274 {
1275 ScRange aDelRange( 0, 0, nOtherTab,
1276 nLastOtherCol-1, MaxRow(), nOtherTab );
1277 pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
1278 }
1279
1280 // Actions for inserted/deleted rows
1281
1282 SCROW nLastOtherRow = nOtherEndRow + 1;
1283 // nThisEndRow ... 0
1284 for ( nThisRow = nThisEndRow+1; nThisRow > 0; )
1285 {
1286 --nThisRow;
1287 SCROW nOtherRow = pOtherRows[nThisRow];
1288 if ( ValidRow(nOtherRow) && nOtherRow+1 < nLastOtherRow )
1289 {
1290 // gap -> deleted
1291 ScRange aDelRange( 0, nOtherRow+1, nOtherTab,
1292 MaxCol(), nLastOtherRow-1, nOtherTab );
1293 pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
1294 }
1295 if ( nOtherRow > MaxRow() ) // inserted
1296 {
1297 // combine
1298 if ( nThisRow == nThisEndRow || ValidRow(pOtherRows[nThisRow+1]) )
1299 {
1300 SCROW nFirstNew = nThisRow;
1301 while ( nFirstNew > 0 && pOtherRows[nFirstNew-1] > MaxRow() )
1302 --nFirstNew;
1303 SCROW nDiff = nThisRow - nFirstNew;
1304 ScRange aRange( 0, nLastOtherRow, nOtherTab,
1305 MaxCol(), nLastOtherRow+nDiff, nOtherTab );
1306 pChangeTrack->AppendInsert( aRange );
1307 }
1308 }
1309 else
1310 nLastOtherRow = nOtherRow;
1311 }
1312 if ( nLastOtherRow > 0 ) // deleted at the very top
1313 {
1314 ScRange aDelRange( 0, 0, nOtherTab,
1315 MaxCol(), nLastOtherRow-1, nOtherTab );
1316 pChangeTrack->AppendDeleteRange( aDelRange, &rOtherDoc, n1, n2 );
1317 }
1318
1319 // walk rows to find single cells
1320
1321 for (nThisRow = 0; nThisRow <= nThisEndRow; nThisRow++)
1322 {
1323 SCROW nOtherRow = pOtherRows[nThisRow];
1324 for (nThisCol = 0; nThisCol <= nThisEndCol; nThisCol++)
1325 {
1326 SCCOL nOtherCol = static_cast<SCCOL>(pOtherCols[nThisCol]);
1327 ScAddress aThisPos( nThisCol, nThisRow, nThisTab );
1328 ScCellValue aThisCell;
1329 aThisCell.assign(*this, aThisPos);
1330 ScCellValue aOtherCell; // start empty
1331 if ( ValidCol(nOtherCol) && ValidRow(nOtherRow) )
1332 {
1333 ScAddress aOtherPos( nOtherCol, nOtherRow, nOtherTab );
1334 aOtherCell.assign(rOtherDoc, aOtherPos);
1335 }
1336
1337 if (!aThisCell.equalsWithoutFormat(aOtherCell))
1338 {
1339 ScRange aRange( aThisPos );
1340 ScChangeActionContent* pAction = new ScChangeActionContent( aRange );
1341 pAction->SetOldValue(aOtherCell, &rOtherDoc, this);
1342 pAction->SetNewValue(aThisCell, this);
1343 pChangeTrack->Append( pAction );
1344 }
1345 }
1346 aProgress.SetStateOnPercent(nProgressStart+nThisRow);
1347 }
1348 }
1349 }
1350 }
1351
1352 sal_Unicode ScDocument::GetSheetSeparator() const
1353 {
1354 const ScCompiler::Convention* pConv = ScCompiler::GetRefConvention(
1355 FormulaGrammar::extractRefConvention( GetGrammar()));
1356 assert(pConv);
1357 return pConv ? pConv->getSpecialSymbol( ScCompiler::Convention::SHEET_SEPARATOR) : '.';
1358 }
1359
1360 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE