?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Stop leaking all ScPostIt instances.
[LibreOffice.git] / sc / source / core / data / table1.cxx
blob4eed3b05ab6c51394d82c20507d6b7e964a4015e
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 "scitems.hxx"
21 #include <svx/algitem.hxx>
22 #include <editeng/justifyitem.hxx>
23 #include <unotools/textsearch.hxx>
24 #include <sfx2/objsh.hxx>
25
26 #include "attrib.hxx"
27 #include "patattr.hxx"
28 #include "formulacell.hxx"
29 #include "table.hxx"
30 #include "document.hxx"
31 #include "drwlayer.hxx"
32 #include "olinetab.hxx"
33 #include "stlsheet.hxx"
34 #include "global.hxx"
35 #include "globstr.hrc"
36 #include "refupdat.hxx"
37 #include "markdata.hxx"
38 #include "progress.hxx"
39 #include "hints.hxx"
40 #include "prnsave.hxx"
41 #include "tabprotection.hxx"
42 #include "sheetevents.hxx"
43 #include "segmenttree.hxx"
44 #include "dbdata.hxx"
45 #include "colorscale.hxx"
46 #include "conditio.hxx"
47 #include "globalnames.hxx"
48 #include "cellvalue.hxx"
49 #include "scmatrix.hxx"
50 #include "refupdatecontext.hxx"
51
52 #include "formula/vectortoken.hxx"
53
54 #include <vector>
55
56 using ::std::vector;
57
58 namespace {
59
60 ScProgress* GetProgressBar(
61 SCSIZE nCount, SCSIZE nTotalCount, ScProgress* pOuterProgress, ScDocument* pDoc)
62 {
63 if (nTotalCount < 1000)
64 {
65 // if the total number of rows is less than 1000, don't even bother
66 // with the progress bar because drawing progress bar can be very
67 // expensive especially in GTK.
68 return NULL;
69 }
70
71 if (pOuterProgress)
72 return pOuterProgress;
73
74 if (nCount > 1)
75 return new ScProgress(
76 pDoc->GetDocumentShell(), ScGlobal::GetRscString(STR_PROGRESS_HEIGHTING), nTotalCount);
77
78 return NULL;
79 }
80
81 void GetOptimalHeightsInColumn(
82 ScColumn* pCol, SCROW nStartRow, SCROW nEndRow, vector<sal_uInt16>& aHeights,
83 OutputDevice* pDev, double nPPTX, double nPPTY, const Fraction& rZoomX, const Fraction& rZoomY, bool bForce,
84 ScProgress* pProgress, sal_uInt32 nProgressStart)
85 {
86 SCSIZE nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
87
88 // zuerst einmal ueber den ganzen Bereich
89 // (mit der letzten Spalte in der Hoffnung, dass die am ehesten noch auf
90 // Standard formatiert ist)
91
92 pCol[MAXCOL].GetOptimalHeight(
93 nStartRow, nEndRow, &aHeights[0], pDev, nPPTX, nPPTY, rZoomX, rZoomY, bForce, 0, 0 );
94
95 // daraus Standardhoehe suchen, die im unteren Bereich gilt
96
97 sal_uInt16 nMinHeight = aHeights[nCount-1];
98 SCSIZE nPos = nCount-1;
99 while ( nPos && aHeights[nPos-1] >= nMinHeight )
100 --nPos;
101 SCROW nMinStart = nStartRow + nPos;
102
103 sal_uLong nWeightedCount = 0;
104 for (SCCOL nCol=0; nCol<MAXCOL; nCol++) // MAXCOL schon oben
105 {
106 pCol[nCol].GetOptimalHeight(
107 nStartRow, nEndRow, &aHeights[0], pDev, nPPTX, nPPTY, rZoomX, rZoomY, bForce,
108 nMinHeight, nMinStart );
109
110 if (pProgress)
111 {
112 sal_uLong nWeight = pCol[nCol].GetWeightedCount();
113 if (nWeight) // nochmal denselben Status muss auch nicht sein
114 {
115 nWeightedCount += nWeight;
116 pProgress->SetState( nWeightedCount + nProgressStart );
117 }
118 }
119 }
120 }
121
122 struct OptimalHeightsFuncObjBase
123 {
124 virtual ~OptimalHeightsFuncObjBase() {}
125 virtual bool operator() (SCROW nStartRow, SCROW nEndRow, sal_uInt16 nHeight) = 0;
126 };
127
128 struct SetRowHeightOnlyFunc : public OptimalHeightsFuncObjBase
129 {
130 ScTable* mpTab;
131 SetRowHeightOnlyFunc(ScTable* pTab) :
132 mpTab(pTab)
133 {}
134
135 virtual bool operator() (SCROW nStartRow, SCROW nEndRow, sal_uInt16 nHeight)
136 {
137 mpTab->SetRowHeightOnly(nStartRow, nEndRow, nHeight);
138 return false;
139 }
140 };
141
142 struct SetRowHeightRangeFunc : public OptimalHeightsFuncObjBase
143 {
144 ScTable* mpTab;
145 double mnPPTX;
146 double mnPPTY;
147
148 SetRowHeightRangeFunc(ScTable* pTab, double nPPTX, double nPPTY) :
149 mpTab(pTab),
150 mnPPTX(nPPTX),
151 mnPPTY(nPPTY)
152 {}
153
154 virtual bool operator() (SCROW nStartRow, SCROW nEndRow, sal_uInt16 nHeight)
155 {
156 return mpTab->SetRowHeightRange(nStartRow, nEndRow, nHeight, mnPPTX, mnPPTY);
157 }
158 };
159
160 bool SetOptimalHeightsToRows(OptimalHeightsFuncObjBase& rFuncObj,
161 ScBitMaskCompressedArray<SCROW, sal_uInt8>* pRowFlags, SCROW nStartRow, SCROW nEndRow, sal_uInt16 nExtra,
162 const vector<sal_uInt16>& aHeights, bool bForce)
163 {
164 SCSIZE nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
165 bool bChanged = false;
166 SCROW nRngStart = 0;
167 SCROW nRngEnd = 0;
168 sal_uInt16 nLast = 0;
169 for (SCSIZE i=0; i<nCount; i++)
170 {
171 size_t nIndex;
172 SCROW nRegionEndRow;
173 sal_uInt8 nRowFlag = pRowFlags->GetValue( nStartRow+i, nIndex, nRegionEndRow );
174 if ( nRegionEndRow > nEndRow )
175 nRegionEndRow = nEndRow;
176 SCSIZE nMoreRows = nRegionEndRow - ( nStartRow+i ); // additional equal rows after first
177
178 bool bAutoSize = ((nRowFlag & CR_MANUALSIZE) == 0);
179 if ( bAutoSize || bForce )
180 {
181 if (nExtra)
182 {
183 if (bAutoSize)
184 pRowFlags->SetValue( nStartRow+i, nRegionEndRow, nRowFlag | CR_MANUALSIZE);
185 }
186 else if (!bAutoSize)
187 pRowFlags->SetValue( nStartRow+i, nRegionEndRow, nRowFlag & ~CR_MANUALSIZE);
188
189 for (SCSIZE nInner = i; nInner <= i + nMoreRows; ++nInner)
190 {
191 if (nLast)
192 {
193 if (aHeights[nInner]+nExtra == nLast)
194 nRngEnd = nStartRow+nInner;
195 else
196 {
197 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast);
198 nLast = 0;
199 }
200 }
201 if (!nLast)
202 {
203 nLast = aHeights[nInner]+nExtra;
204 nRngStart = nStartRow+nInner;
205 nRngEnd = nStartRow+nInner;
206 }
207 }
208 }
209 else
210 {
211 if (nLast)
212 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast);
213 nLast = 0;
214 }
215 i += nMoreRows; // already handled - skip
216 }
217 if (nLast)
218 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast);
219
220 return bChanged;
221 }
222
223 }
224
225 // -----------------------------------------------------------------------
226
227 ScTable::ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
228 bool bColInfo, bool bRowInfo ) :
229 aName( rNewName ),
230 aCodeName( rNewName ),
231 nLinkMode( 0 ),
232 aPageStyle( ScGlobal::GetRscString(STR_STYLENAME_STANDARD) ),
233 nRepeatStartX( SCCOL_REPEAT_NONE ),
234 nRepeatEndX( SCCOL_REPEAT_NONE ),
235 nRepeatStartY( SCROW_REPEAT_NONE ),
236 nRepeatEndY( SCROW_REPEAT_NONE ),
237 pTabProtection( NULL ),
238 pColWidth( NULL ),
239 mpRowHeights( static_cast<ScFlatUInt16RowSegments*>(NULL) ),
240 pColFlags( NULL ),
241 pRowFlags( NULL ),
242 mpHiddenCols(new ScFlatBoolColSegments),
243 mpHiddenRows(new ScFlatBoolRowSegments),
244 mpFilteredCols(new ScFlatBoolColSegments),
245 mpFilteredRows(new ScFlatBoolRowSegments),
246 pOutlineTable( NULL ),
247 pSheetEvents( NULL ),
248 nTab( nNewTab ),
249 pDocument( pDoc ),
250 pSearchText ( NULL ),
251 pSortCollator( NULL ),
252 pRepeatColRange( NULL ),
253 pRepeatRowRange( NULL ),
254 nLockCount( 0 ),
255 pScenarioRanges( NULL ),
256 aScenarioColor( COL_LIGHTGRAY ),
257 aTabBgColor( COL_AUTO ),
258 nScenarioFlags( 0 ),
259 pDBDataNoName(NULL),
260 mpRangeName(NULL),
261 mpCondFormatList( new ScConditionalFormatList() ),
262 bScenario(false),
263 bLayoutRTL(false),
264 bLoadingRTL(false),
265 bPageSizeValid(false),
266 bTableAreaValid(false),
267 bVisible(true),
268 bStreamValid(false),
269 bPendingRowHeights(false),
270 bCalcNotification(false),
271 bGlobalKeepQuery(false),
272 bPrintEntireSheet(true),
273 bActiveScenario(false),
274 mbPageBreaksValid(false),
275 mbForceBreaks(false)
276 {
277
278 if (bColInfo)
279 {
280 pColWidth = new sal_uInt16[ MAXCOL+1 ];
281 pColFlags = new sal_uInt8[ MAXCOL+1 ];
282
283 for (SCCOL i=0; i<=MAXCOL; i++)
284 {
285 pColWidth[i] = STD_COL_WIDTH;
286 pColFlags[i] = 0;
287 }
288 }
289
290 if (bRowInfo)
291 {
292 mpRowHeights.reset(new ScFlatUInt16RowSegments(ScGlobal::nStdRowHeight));
293 pRowFlags = new ScBitMaskCompressedArray< SCROW, sal_uInt8>( MAXROW, 0);
294 }
295
296 if ( pDocument->IsDocVisible() )
297 {
298 // when a sheet is added to a visible document,
299 // initialize its RTL flag from the system locale
300 bLayoutRTL = ScGlobal::IsSystemRTL();
301 }
302
303 ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
304 if (pDrawLayer)
305 {
306 if ( pDrawLayer->ScAddPage( nTab ) ) // sal_False (not inserted) during Undo
307 {
308 pDrawLayer->ScRenamePage( nTab, aName );
309 sal_uLong nx = (sal_uLong) ((double) (MAXCOL+1) * STD_COL_WIDTH * HMM_PER_TWIPS );
310 sal_uLong ny = (sal_uLong) ((double) (MAXROW+1) * ScGlobal::nStdRowHeight * HMM_PER_TWIPS );
311 pDrawLayer->SetPageSize( static_cast<sal_uInt16>(nTab), Size( nx, ny ), false );
312 }
313 }
314
315 for (SCCOL k=0; k<=MAXCOL; k++)
316 aCol[k].Init( k, nTab, pDocument );
317 }
318
319 ScTable::~ScTable()
320 {
321 if (!pDocument->IsInDtorClear())
322 {
323 // nicht im dtor die Pages in der falschen Reihenfolge loeschen
324 // (nTab stimmt dann als Page-Number nicht!)
325 // In ScDocument::Clear wird hinterher per Clear am Draw Layer alles geloescht.
326
327 ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
328 if (pDrawLayer)
329 pDrawLayer->ScRemovePage( nTab );
330 }
331
332 delete[] pColWidth;
333 delete[] pColFlags;
334 delete pRowFlags;
335 delete pSheetEvents;
336 delete pOutlineTable;
337 delete pSearchText;
338 delete pRepeatColRange;
339 delete pRepeatRowRange;
340 delete pScenarioRanges;
341 delete mpRangeName;
342 delete pDBDataNoName;
343 DestroySortCollator();
344 }
345
346 void ScTable::GetName( OUString& rName ) const
347 {
348 rName = aName;
349 }
350
351 void ScTable::SetName( const OUString& rNewName )
352 {
353 aName = rNewName;
354 aUpperName = OUString(); // invalidated if the name is changed
355
356 // SetStreamValid is handled in ScDocument::RenameTab
357 }
358
359 const OUString& ScTable::GetUpperName() const
360 {
361 if (aUpperName.isEmpty() && !aName.isEmpty())
362 aUpperName = ScGlobal::pCharClass->uppercase(aName);
363 return aUpperName;
364 }
365
366 void ScTable::SetVisible( bool bVis )
367 {
368 if (bVisible != bVis && IsStreamValid())
369 SetStreamValid(false);
370
371 bVisible = bVis;
372 }
373
374 void ScTable::SetStreamValid( bool bSet, bool bIgnoreLock )
375 {
376 if ( bIgnoreLock || !pDocument->IsStreamValidLocked() )
377 bStreamValid = bSet;
378 }
379
380 void ScTable::SetPendingRowHeights( bool bSet )
381 {
382 bPendingRowHeights = bSet;
383 }
384
385 void ScTable::SetLayoutRTL( bool bSet )
386 {
387 bLayoutRTL = bSet;
388 }
389
390 void ScTable::SetLoadingRTL( bool bSet )
391 {
392 bLoadingRTL = bSet;
393 }
394
395 const Color& ScTable::GetTabBgColor() const
396 {
397 return aTabBgColor;
398 }
399
400 void ScTable::SetTabBgColor(const Color& rColor)
401 {
402 if (aTabBgColor != rColor)
403 {
404 // The tab color has changed. Set this table 'modified'.
405 aTabBgColor = rColor;
406 if (IsStreamValid())
407 SetStreamValid(false);
408 }
409 }
410
411 void ScTable::SetScenario( bool bFlag )
412 {
413 bScenario = bFlag;
414 }
415
416 void ScTable::SetLink( sal_uInt8 nMode,
417 const OUString& rDoc, const OUString& rFlt, const OUString& rOpt,
418 const OUString& rTab, sal_uLong nRefreshDelay )
419 {
420 nLinkMode = nMode;
421 aLinkDoc = rDoc; // Datei
422 aLinkFlt = rFlt; // Filter
423 aLinkOpt = rOpt; // Filter-Optionen
424 aLinkTab = rTab; // Tabellenname in Quelldatei
425 nLinkRefreshDelay = nRefreshDelay; // refresh delay in seconds, 0==off
426
427 if (IsStreamValid())
428 SetStreamValid(false);
429 }
430
431 sal_uInt16 ScTable::GetOptimalColWidth( SCCOL nCol, OutputDevice* pDev,
432 double nPPTX, double nPPTY,
433 const Fraction& rZoomX, const Fraction& rZoomY,
434 bool bFormula, const ScMarkData* pMarkData,
435 const ScColWidthParam* pParam )
436 {
437 return aCol[nCol].GetOptimalColWidth( pDev, nPPTX, nPPTY, rZoomX, rZoomY,
438 bFormula, STD_COL_WIDTH - STD_EXTRA_WIDTH, pMarkData, pParam );
439 }
440
441 long ScTable::GetNeededSize( SCCOL nCol, SCROW nRow,
442 OutputDevice* pDev,
443 double nPPTX, double nPPTY,
444 const Fraction& rZoomX, const Fraction& rZoomY,
445 bool bWidth, bool bTotalSize )
446 {
447 ScNeededSizeOptions aOptions;
448 aOptions.bSkipMerged = false; // zusammengefasste mitzaehlen
449 aOptions.bTotalSize = bTotalSize;
450
451 return aCol[nCol].GetNeededSize
452 ( nRow, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bWidth, aOptions );
453 }
454
455 bool ScTable::SetOptimalHeight( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nExtra,
456 OutputDevice* pDev,
457 double nPPTX, double nPPTY,
458 const Fraction& rZoomX, const Fraction& rZoomY,
459 bool bForce, ScProgress* pOuterProgress, sal_uLong nProgressStart )
460 {
461 OSL_ENSURE( nExtra==0 || bForce, "automatic OptimalHeight with Extra" );
462
463 if ( !pDocument->IsAdjustHeightEnabled() )
464 {
465 return false;
466 }
467
468 SCSIZE nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
469
470 ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, pDocument);
471
472 vector<sal_uInt16> aHeights(nCount, 0);
473
474 GetOptimalHeightsInColumn(
475 aCol, nStartRow, nEndRow, aHeights, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bForce,
476 pProgress, nProgressStart);
477
478 SetRowHeightRangeFunc aFunc(this, nPPTX, nPPTY);
479 bool bChanged = SetOptimalHeightsToRows(
480 aFunc, pRowFlags, nStartRow, nEndRow, nExtra, aHeights, bForce);
481
482 if ( pProgress != pOuterProgress )
483 delete pProgress;
484
485 return bChanged;
486 }
487
488 void ScTable::SetOptimalHeightOnly( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nExtra,
489 OutputDevice* pDev,
490 double nPPTX, double nPPTY,
491 const Fraction& rZoomX, const Fraction& rZoomY,
492 bool bForce, ScProgress* pOuterProgress, sal_uLong nProgressStart )
493 {
494 OSL_ENSURE( nExtra==0 || bForce, "automatic OptimalHeight with Extra" );
495
496 if ( !pDocument->IsAdjustHeightEnabled() )
497 return;
498
499 SCSIZE nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
500
501 ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, pDocument);
502
503 vector<sal_uInt16> aHeights(nCount, 0);
504
505 GetOptimalHeightsInColumn(
506 aCol, nStartRow, nEndRow, aHeights, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bForce,
507 pProgress, nProgressStart);
508
509 SetRowHeightOnlyFunc aFunc(this);
510 SetOptimalHeightsToRows(
511 aFunc, pRowFlags, nStartRow, nEndRow, nExtra, aHeights, bForce);
512
513 if ( pProgress != pOuterProgress )
514 delete pProgress;
515 }
516
517 bool ScTable::GetCellArea( SCCOL& rEndCol, SCROW& rEndRow ) const
518 {
519 bool bFound = false;
520 SCCOL nMaxX = 0;
521 SCROW nMaxY = 0;
522 for (SCCOL i=0; i<=MAXCOL; i++)
523 {
524 if (!aCol[i].IsEmptyData())
525 {
526 bFound = true;
527 nMaxX = i;
528 SCROW nRow = aCol[i].GetLastDataPos();
529 if (nRow > nMaxY)
530 nMaxY = nRow;
531 }
532 if ( aCol[i].HasCellNotes() )
533 {
534 SCROW maxNoteRow = aCol[i].GetCellNotesMaxRow();
535 if (maxNoteRow >= nMaxY)
536 {
537 bFound = true;
538 nMaxY = maxNoteRow;
539 }
540 if (i>nMaxX)
541 {
542 bFound = true;
543 nMaxX = i;
544 }
545 }
546 }
547
548 rEndCol = nMaxX;
549 rEndRow = nMaxY;
550 return bFound;
551 }
552
553 bool ScTable::GetTableArea( SCCOL& rEndCol, SCROW& rEndRow ) const
554 {
555 bool bRet = true; //! merken?
556 if (!bTableAreaValid)
557 {
558 bRet = GetPrintArea(nTableAreaX, nTableAreaY, true);
559 bTableAreaValid = true;
560 }
561 rEndCol = nTableAreaX;
562 rEndRow = nTableAreaY;
563 return bRet;
564 }
565
566 const SCCOL SC_COLUMNS_STOP = 30;
567
568 bool ScTable::GetPrintArea( SCCOL& rEndCol, SCROW& rEndRow, bool bNotes, bool bFullFormattedArea ) const
569 {
570 bool bFound = false;
571 SCCOL nMaxX = 0;
572 SCROW nMaxY = 0;
573 SCCOL i;
574
575 for (i=0; i<=MAXCOL; i++) // Daten testen
576 {
577 if (!aCol[i].IsEmptyData())
578 {
579 bFound = true;
580 if (i>nMaxX)
581 nMaxX = i;
582 SCROW nColY = aCol[i].GetLastDataPos();
583 if (nColY > nMaxY)
584 nMaxY = nColY;
585 }
586 if (bNotes)
587 {
588 if ( aCol[i].HasCellNotes() )
589 {
590 SCROW maxNoteRow = aCol[i].GetCellNotesMaxRow();
591 if (maxNoteRow >= nMaxY)
592 {
593 bFound = true;
594 nMaxY = maxNoteRow;
595 }
596 if (i>nMaxX)
597 {
598 bFound = true;
599 nMaxX = i;
600 }
601 }
602 }
603 }
604
605 SCCOL nMaxDataX = nMaxX;
606
607 for (i=0; i<=MAXCOL; i++) // Attribute testen
608 {
609 SCROW nLastRow;
610 if (aCol[i].GetLastVisibleAttr( nLastRow, bFullFormattedArea ))
611 {
612 bFound = true;
613 nMaxX = i;
614 if (nLastRow > nMaxY)
615 nMaxY = nLastRow;
616 }
617 }
618
619 if (nMaxX == MAXCOL) // Attribute rechts weglassen
620 {
621 --nMaxX;
622 while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1]) )
623 --nMaxX;
624 }
625
626 if ( nMaxX < nMaxDataX )
627 {
628 nMaxX = nMaxDataX;
629 }
630 else if ( nMaxX > nMaxDataX )
631 {
632 SCCOL nAttrStartX = nMaxDataX + 1;
633 while ( nAttrStartX < MAXCOL )
634 {
635 SCCOL nAttrEndX = nAttrStartX;
636 while ( nAttrEndX < MAXCOL && aCol[nAttrStartX].IsVisibleAttrEqual(aCol[nAttrEndX+1]) )
637 ++nAttrEndX;
638 if ( nAttrEndX + 1 - nAttrStartX >= SC_COLUMNS_STOP )
639 {
640 // found equally-formatted columns behind data -> stop before these columns
641 nMaxX = nAttrStartX - 1;
642
643 // also don't include default-formatted columns before that
644 SCROW nDummyRow;
645 while ( nMaxX > nMaxDataX && !aCol[nMaxX].GetLastVisibleAttr( nDummyRow ) )
646 --nMaxX;
647 break;
648 }
649 nAttrStartX = nAttrEndX + 1;
650 }
651 }
652
653 rEndCol = nMaxX;
654 rEndRow = nMaxY;
655 return bFound;
656 }
657
658 bool ScTable::GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow,
659 SCCOL& rEndCol, bool /* bNotes */ ) const
660 {
661 bool bFound = false;
662 SCCOL nMaxX = 0;
663 SCCOL i;
664
665 for (i=0; i<=MAXCOL; i++) // Attribute testen
666 {
667 if (aCol[i].HasVisibleAttrIn( nStartRow, nEndRow ))
668 {
669 bFound = true;
670 nMaxX = i;
671 }
672 }
673
674 if (nMaxX == MAXCOL) // Attribute rechts weglassen
675 {
676 --nMaxX;
677 while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1], nStartRow, nEndRow) )
678 --nMaxX;
679 }
680
681 for (i=0; i<=MAXCOL; i++) // Daten testen
682 {
683 if (!aCol[i].IsEmptyBlock( nStartRow, nEndRow )) //! bNotes ??????
684 {
685 bFound = true;
686 if (i>nMaxX)
687 nMaxX = i;
688 }
689 }
690
691 rEndCol = nMaxX;
692 return bFound;
693 }
694
695 bool ScTable::GetPrintAreaVer( SCCOL nStartCol, SCCOL nEndCol,
696 SCROW& rEndRow, bool bNotes ) const
697 {
698 bool bFound = false;
699 SCROW nMaxY = 0;
700 SCCOL i;
701
702 for (i=nStartCol; i<=nEndCol; i++) // Attribute testen
703 {
704 SCROW nLastRow;
705 if (aCol[i].GetLastVisibleAttr( nLastRow ))
706 {
707 bFound = true;
708 if (nLastRow > nMaxY)
709 nMaxY = nLastRow;
710 }
711 }
712
713 for (i=nStartCol; i<=nEndCol; i++) // Daten testen
714 {
715 if (!aCol[i].IsEmptyData())
716 {
717 bFound = true;
718 SCROW nColY = aCol[i].GetLastDataPos();
719 if (nColY > nMaxY)
720 nMaxY = nColY;
721 }
722 if (bNotes)
723 {
724 if ( aCol[i].HasCellNotes() )
725 {
726 SCROW maxNoteRow =aCol[i].GetCellNotesMaxRow();
727 if (maxNoteRow > nMaxY)
728 {
729 bFound = true;
730 nMaxY = maxNoteRow;
731 }
732 }
733 }
734 }
735
736 rEndRow = nMaxY;
737 return bFound;
738 }
739
740 bool ScTable::GetDataStart( SCCOL& rStartCol, SCROW& rStartRow ) const
741 {
742 bool bFound = false;
743 SCCOL nMinX = MAXCOL;
744 SCROW nMinY = MAXROW;
745 SCCOL i;
746
747 for (i=0; i<=MAXCOL; i++) // Attribute testen
748 {
749 SCROW nFirstRow;
750 if (aCol[i].GetFirstVisibleAttr( nFirstRow ))
751 {
752 if (!bFound)
753 nMinX = i;
754 bFound = true;
755 if (nFirstRow < nMinY)
756 nMinY = nFirstRow;
757 }
758 }
759
760 if (nMinX == 0) // Attribute links weglassen
761 {
762 if ( aCol[0].IsVisibleAttrEqual(aCol[1]) ) // keine einzelnen
763 {
764 ++nMinX;
765 while ( nMinX<MAXCOL && aCol[nMinX].IsVisibleAttrEqual(aCol[nMinX-1]) )
766 ++nMinX;
767 }
768 }
769
770 bool bDatFound = false;
771 for (i=0; i<=MAXCOL; i++) // Daten testen
772 {
773 if (!aCol[i].IsEmptyData())
774 {
775 if (!bDatFound && i<nMinX)
776 nMinX = i;
777 bFound = bDatFound = true;
778 SCROW nRow = aCol[i].GetFirstDataPos();
779 if (nRow < nMinY)
780 nMinY = nRow;
781 }
782 if ( aCol[i].HasCellNotes() )
783 {
784 SCROW minNoteRow = aCol[i].GetCellNotesMinRow();
785 if (minNoteRow <= nMinY)
786 {
787 bFound = true;
788 nMinY = minNoteRow;
789 }
790 if (i<nMinX)
791 {
792 bFound = true;
793 nMinX = i;
794 }
795 }
796 }
797 rStartCol = nMinX;
798 rStartRow = nMinY;
799 return bFound;
800 }
801
802 void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow,
803 bool bIncludeOld, bool bOnlyDown ) const
804 {
805 // return the smallest area containing at least all contiguous cells having data. This area
806 // is a square containing also empty cells. It may shrink or extend the area given as input
807 // Flags as modifiers:
808 //
809 // bIncludeOld = true ensure that the returned area contains at least the initial area,
810 // independently of the emptniess of rows / columns (i.e. does not allow shrinking)
811 // bOnlyDown = true means extend / shrink the inputed area only down, i.e modifiy only rEndRow
812
813 bool bLeft = false;
814 bool bRight = false;
815 bool bTop = false;
816 bool bBottom = false;
817 bool bChanged = false;
818
819 do
820 {
821 bChanged = false;
822
823 if (!bOnlyDown)
824 {
825 SCROW nStart = rStartRow;
826 SCROW nEnd = rEndRow;
827 if (nStart>0) --nStart;
828 if (nEnd<MAXROW) ++nEnd;
829
830 if (rEndCol < MAXCOL)
831 if (!aCol[rEndCol+1].IsEmptyBlock(nStart,nEnd))
832 {
833 ++rEndCol;
834 bChanged = true;
835 bRight = true;
836 }
837
838 if (rStartCol > 0)
839 if (!aCol[rStartCol-1].IsEmptyBlock(nStart,nEnd))
840 {
841 --rStartCol;
842 bChanged = true;
843 bLeft = true;
844 }
845
846 if (rStartRow > 0)
847 {
848 SCROW nTest = rStartRow-1;
849 bool needExtend = false;
850 for ( SCCOL i = rStartCol; i<=rEndCol && !needExtend; i++)
851 if (aCol[i].HasDataAt(nTest))
852 needExtend = true;
853 if (needExtend)
854 {
855 --rStartRow;
856 bChanged = true;
857 bTop = true;
858 }
859 }
860 }
861
862 if (rEndRow < MAXROW)
863 {
864 SCROW nTest = rEndRow+1;
865 bool needExtend = false;
866 for ( SCCOL i = rStartCol; i<=rEndCol && !needExtend; i++)
867 if (aCol[i].HasDataAt(nTest))
868 needExtend = true;
869 if (needExtend)
870 {
871 ++rEndRow;
872 bChanged = true;
873 bBottom = true;
874 }
875 }
876 }
877 while( bChanged );
878
879 if ( !bIncludeOld && !bOnlyDown )
880 {
881 if ( !bLeft )
882 while ( aCol[rStartCol].IsEmptyBlock(rStartRow,rEndRow) && rStartCol < MAXCOL && rStartCol < rEndCol)
883 ++rStartCol;
884
885 if ( !bRight )
886 while ( aCol[rEndCol].IsEmptyBlock(rStartRow,rEndRow) && rEndCol > 0 && rStartCol < rEndCol)
887 --rEndCol;
888
889 if ( !bTop && rStartRow < MAXROW && rStartRow < rEndRow )
890 {
891 bool shrink = true;
892 do
893 {
894 for ( SCCOL i = rStartCol; i<=rEndCol && shrink; i++)
895 if (aCol[i].HasDataAt(rStartRow))
896 shrink = false;
897 if (shrink)
898 ++rStartRow;
899 }while( shrink && rStartRow < MAXROW && rStartRow < rEndRow);
900 }
901 }
902
903 if ( !bIncludeOld )
904 {
905 if ( !bBottom && rEndRow > 0 && rStartRow < rEndRow )
906 {
907 bool shrink = true;
908 do
909 {
910 for ( SCCOL i = rStartCol; i<=rEndCol && shrink; i++)
911 if (aCol[i].HasDataAt(rEndRow))
912 shrink = false;
913 if (shrink)
914 --rEndRow;
915 }while( shrink && rEndRow > 0 && rStartRow < rEndRow );
916 }
917 }
918 }
919
920
921 bool ScTable::ShrinkToUsedDataArea( bool& o_bShrunk, SCCOL& rStartCol, SCROW& rStartRow,
922 SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly ) const
923 {
924 o_bShrunk = false;
925
926 PutInOrder( rStartCol, rEndCol);
927 PutInOrder( rStartRow, rEndRow);
928 if (rStartCol < 0)
929 rStartCol = 0, o_bShrunk = true;
930 if (rStartRow < 0)
931 rStartRow = 0, o_bShrunk = true;
932 if (rEndCol > MAXCOL)
933 rEndCol = MAXCOL, o_bShrunk = true;
934 if (rEndRow > MAXROW)
935 rEndRow = MAXROW, o_bShrunk = true;
936
937 bool bChanged;
938 do
939 {
940 bChanged = false;
941
942 while (rStartCol < rEndCol)
943 {
944 if (aCol[rEndCol].IsEmptyBlock( rStartRow, rEndRow))
945 {
946 --rEndCol;
947 bChanged = true;
948 }
949 else
950 break; // while
951 }
952
953 while (rStartCol < rEndCol)
954 {
955 if (aCol[rStartCol].IsEmptyBlock( rStartRow, rEndRow))
956 {
957 ++rStartCol;
958 bChanged = true;
959 }
960 else
961 break; // while
962 }
963
964 if (!bColumnsOnly)
965 {
966 if (rStartRow < rEndRow)
967 {
968 bool bFound = false;
969 for (SCCOL i=rStartCol; i<=rEndCol && !bFound; i++)
970 if (aCol[i].HasDataAt( rStartRow))
971 bFound = true;
972 if (!bFound)
973 {
974 ++rStartRow;
975 bChanged = true;
976 }
977 }
978
979 if (rStartRow < rEndRow)
980 {
981 bool bFound = false;
982 for (SCCOL i=rStartCol; i<=rEndCol && !bFound; i++)
983 if (aCol[i].HasDataAt( rEndRow))
984 bFound = true;
985 if (!bFound)
986 {
987 --rEndRow;
988 bChanged = true;
989 }
990 }
991 }
992
993 if (bChanged)
994 o_bShrunk = true;
995 } while( bChanged );
996
997 return rStartCol != rEndCol || (bColumnsOnly ?
998 !aCol[rStartCol].IsEmptyBlock( rStartRow, rEndRow) :
999 (rStartRow != rEndRow || aCol[rStartCol].HasDataAt( rStartRow)));
1000 }
1001
1002 SCROW ScTable::GetLastDataRow( SCCOL nCol1, SCCOL nCol2, SCROW nLastRow ) const
1003 {
1004 if (!ValidCol(nCol1) || !ValidCol(nCol2))
1005 return -1;
1006
1007 SCROW nNewLastRow = 0;
1008 for (SCCOL i = nCol1; i <= nCol2; ++i)
1009 {
1010 SCROW nThis = aCol[i].GetLastDataPos(nLastRow);
1011 if (nNewLastRow < nThis)
1012 nNewLastRow = nThis;
1013 }
1014
1015 return nNewLastRow;
1016 }
1017
1018 SCSIZE ScTable::GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow,
1019 SCCOL nEndCol, SCROW nEndRow, ScDirection eDir ) const
1020 {
1021 SCSIZE nCount = 0;
1022 SCCOL nCol;
1023 if ((eDir == DIR_BOTTOM) || (eDir == DIR_TOP))
1024 {
1025 nCount = static_cast<SCSIZE>(nEndRow - nStartRow + 1);
1026 for (nCol = nStartCol; nCol <= nEndCol; nCol++)
1027 nCount = std::min(nCount, aCol[nCol].GetEmptyLinesInBlock(nStartRow, nEndRow, eDir));
1028 }
1029 else if (eDir == DIR_RIGHT)
1030 {
1031 nCol = nEndCol;
1032 while (((SCsCOL)nCol >= (SCsCOL)nStartCol) &&
1033 aCol[nCol].IsEmptyBlock(nStartRow, nEndRow))
1034 {
1035 nCount++;
1036 nCol--;
1037 }
1038 }
1039 else
1040 {
1041 nCol = nStartCol;
1042 while ((nCol <= nEndCol) && aCol[nCol].IsEmptyBlock(nStartRow, nEndRow))
1043 {
1044 nCount++;
1045 nCol++;
1046 }
1047 }
1048 return nCount;
1049 }
1050
1051 bool ScTable::IsEmptyLine( SCROW nRow, SCCOL nStartCol, SCCOL nEndCol ) const
1052 {
1053 bool bFound = false;
1054 for (SCCOL i=nStartCol; i<=nEndCol && !bFound; i++)
1055 if (aCol[i].HasDataAt(nRow))
1056 bFound = true;
1057 return !bFound;
1058 }
1059
1060 void ScTable::LimitChartArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ) const
1061 {
1062 while ( rStartCol<rEndCol && aCol[rStartCol].IsEmptyBlock(rStartRow,rEndRow) )
1063 ++rStartCol;
1064
1065 while ( rStartCol<rEndCol && aCol[rEndCol].IsEmptyBlock(rStartRow,rEndRow) )
1066 --rEndCol;
1067
1068 while ( rStartRow<rEndRow && IsEmptyLine(rStartRow, rStartCol, rEndCol) )
1069 ++rStartRow;
1070
1071 while ( rStartRow<rEndRow && IsEmptyLine(rEndRow, rStartCol, rEndCol) )
1072 --rEndRow;
1073 }
1074
1075 SCCOL ScTable::FindNextVisibleCol( SCCOL nCol, bool bRight ) const
1076 {
1077 if(bRight)
1078 {
1079 nCol++;
1080 SCCOL nEnd = 0;
1081 bool bHidden = pDocument->ColHidden(nCol, nTab, NULL, &nEnd);
1082 if(bHidden)
1083 nCol = nEnd +1;
1084
1085 return std::min<SCCOL>(MAXCOL, nCol);
1086 }
1087 else
1088 {
1089 nCol--;
1090 SCCOL nStart = MAXCOL;
1091 bool bHidden = pDocument->ColHidden(nCol, nTab, &nStart, NULL);
1092 if(bHidden)
1093 nCol = nStart - 1;
1094
1095 return std::max<SCCOL>(0, nCol);
1096 }
1097 }
1098
1099 SCCOL ScTable::FindNextVisibleColWithContent( SCCOL nCol, bool bRight, SCROW nRow ) const
1100 {
1101 if(bRight)
1102 {
1103 if(nCol == MAXCOL)
1104 return MAXCOL;
1105
1106 do
1107 {
1108 nCol++;
1109 SCCOL nEndCol = 0;
1110 bool bHidden = pDocument->ColHidden( nCol, nTab, NULL, &nEndCol );
1111 if(bHidden)
1112 {
1113 nCol = nEndCol +1;
1114 if(nEndCol >= MAXCOL)
1115 return MAXCOL;
1116 }
1117
1118 if(aCol[nCol].HasVisibleDataAt(nRow))
1119 return nCol;
1120 }
1121 while(nCol < MAXCOL);
1122
1123 return MAXCOL;
1124 }
1125 else
1126 {
1127 if(nCol == 0)
1128 return 0;
1129
1130 do
1131 {
1132 nCol--;
1133 SCCOL nStartCol = MAXCOL;
1134 bool bHidden = pDocument->ColHidden( nCol, nTab, &nStartCol, NULL );
1135 if(bHidden)
1136 {
1137 nCol = nStartCol -1;
1138 if(nCol <= 0)
1139 return 0;
1140 }
1141
1142 if(aCol[nCol].HasVisibleDataAt(nRow))
1143 return nCol;
1144 }
1145 while(nCol > 0);
1146
1147 return 0;
1148 }
1149 }
1150
1151 void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection ) const
1152 {
1153 if (eDirection == SC_MOVE_LEFT || eDirection == SC_MOVE_RIGHT)
1154 {
1155 SCCOL nNewCol = rCol;
1156 bool bThere = aCol[nNewCol].HasVisibleDataAt(rRow);
1157 bool bRight = (eDirection == SC_MOVE_RIGHT);
1158 if (bThere)
1159 {
1160 if(nNewCol >= MAXCOL && eDirection == SC_MOVE_RIGHT)
1161 return;
1162 else if(nNewCol == 0 && eDirection == SC_MOVE_LEFT)
1163 return;
1164
1165 SCCOL nNextCol = FindNextVisibleCol( nNewCol, bRight );
1166
1167 if(aCol[nNextCol].HasVisibleDataAt(rRow))
1168 {
1169 bool bFound = false;
1170 nNewCol = nNextCol;
1171 do
1172 {
1173 nNextCol = FindNextVisibleCol( nNewCol, bRight );
1174 if(aCol[nNextCol].HasVisibleDataAt(rRow))
1175 nNewCol = nNextCol;
1176 else
1177 bFound = true;
1178 }
1179 while(!bFound && nNextCol > 0 && nNextCol < MAXCOL);
1180 }
1181 else
1182 {
1183 nNewCol = FindNextVisibleColWithContent(nNewCol, bRight, rRow);
1184 }
1185 }
1186 else
1187 {
1188 nNewCol = FindNextVisibleColWithContent(nNewCol, bRight, rRow);
1189 }
1190
1191 if (nNewCol<0)
1192 nNewCol=0;
1193 if (nNewCol>MAXCOL)
1194 nNewCol=MAXCOL;
1195 rCol = nNewCol;
1196 }
1197 else
1198 {
1199 aCol[rCol].FindDataAreaPos(rRow,eDirection == SC_MOVE_DOWN);
1200 }
1201 }
1202
1203 bool ScTable::ValidNextPos( SCCOL nCol, SCROW nRow, const ScMarkData& rMark,
1204 bool bMarked, bool bUnprotected ) const
1205 {
1206 if (!ValidCol(nCol) || !ValidRow(nRow))
1207 return false;
1208
1209 if (pDocument->HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_OVERLAPPED))
1210 // Skip an overlapped cell.
1211 return false;
1212
1213 if (bMarked && !rMark.IsCellMarked(nCol,nRow))
1214 return false;
1215
1216 if (bUnprotected && ((const ScProtectionAttr*)
1217 GetAttr(nCol,nRow,ATTR_PROTECTION))->GetProtection())
1218 return false;
1219
1220 if (bMarked || bUnprotected) //! auch sonst ???
1221 {
1222 // ausgeblendete muessen uebersprungen werden, weil der Cursor sonst
1223 // auf der naechsten Zelle landet, auch wenn die geschuetzt/nicht markiert ist.
1224 //! per Extra-Parameter steuern, nur fuer Cursor-Bewegung ???
1225
1226 if (RowHidden(nRow))
1227 return false;
1228
1229 if (ColHidden(nCol))
1230 return false;
1231 }
1232
1233 return true;
1234 }
1235
1236 void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY,
1237 bool bMarked, bool bUnprotected, const ScMarkData& rMark ) const
1238 {
1239 if (bUnprotected && !IsProtected()) // Tabelle ueberhaupt geschuetzt?
1240 bUnprotected = false;
1241
1242 sal_uInt16 nWrap = 0;
1243 SCsCOL nCol = rCol;
1244 SCsROW nRow = rRow;
1245
1246 nCol = sal::static_int_cast<SCsCOL>( nCol + nMovX );
1247 nRow = sal::static_int_cast<SCsROW>( nRow + nMovY );
1248
1249 OSL_ENSURE( !nMovY || !bUnprotected,
1250 "GetNextPos mit bUnprotected horizontal nicht implementiert" );
1251
1252 if ( nMovY && bMarked )
1253 {
1254 bool bUp = ( nMovY < 0 );
1255 nRow = rMark.GetNextMarked( nCol, nRow, bUp );
1256 while ( ValidRow(nRow) &&
1257 (RowHidden(nRow) || pDocument->HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_OVERLAPPED)) )
1258 {
1259 // ausgeblendete ueberspringen (s.o.)
1260 nRow += nMovY;
1261 nRow = rMark.GetNextMarked( nCol, nRow, bUp );
1262 }
1263
1264 while ( nRow < 0 || nRow > MAXROW )
1265 {
1266 nCol = sal::static_int_cast<SCsCOL>( nCol + static_cast<SCsCOL>(nMovY) );
1267 while ( ValidCol(nCol) && ColHidden(nCol) )
1268 nCol = sal::static_int_cast<SCsCOL>( nCol + static_cast<SCsCOL>(nMovY) ); // skip hidden rows (see above)
1269 if (nCol < 0)
1270 {
1271 nCol = MAXCOL;
1272 if (++nWrap >= 2)
1273 return;
1274 }
1275 else if (nCol > MAXCOL)
1276 {
1277 nCol = 0;
1278 if (++nWrap >= 2)
1279 return;
1280 }
1281 if (nRow < 0)
1282 nRow = MAXROW;
1283 else if (nRow > MAXROW)
1284 nRow = 0;
1285 nRow = rMark.GetNextMarked( nCol, nRow, bUp );
1286 while ( ValidRow(nRow) &&
1287 (RowHidden(nRow) || pDocument->HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_OVERLAPPED)) )
1288 {
1289 // ausgeblendete ueberspringen (s.o.)
1290 nRow += nMovY;
1291 nRow = rMark.GetNextMarked( nCol, nRow, bUp );
1292 }
1293 }
1294 }
1295
1296 if ( nMovX && ( bMarked || bUnprotected ) )
1297 {
1298 // initiales Weiterzaehlen wrappen:
1299 if (nCol<0)
1300 {
1301 nCol = MAXCOL;
1302 --nRow;
1303 if (nRow<0)
1304 nRow = MAXROW;
1305 }
1306 if (nCol>MAXCOL)
1307 {
1308 nCol = 0;
1309 ++nRow;
1310 if (nRow>MAXROW)
1311 nRow = 0;
1312 }
1313
1314 if ( !ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) )
1315 {
1316 SCsROW* pNextRows = new SCsROW[MAXCOL+1];
1317 SCCOL i;
1318
1319 if ( nMovX > 0 ) // vorwaerts
1320 {
1321 for (i=0; i<=MAXCOL; i++)
1322 pNextRows[i] = (i<nCol) ? (nRow+1) : nRow;
1323 do
1324 {
1325 SCsROW nNextRow = pNextRows[nCol] + 1;
1326 if ( bMarked )
1327 nNextRow = rMark.GetNextMarked( nCol, nNextRow, false );
1328 if ( bUnprotected )
1329 nNextRow = aCol[nCol].GetNextUnprotected( nNextRow, false );
1330 pNextRows[nCol] = nNextRow;
1331
1332 SCsROW nMinRow = MAXROW+1;
1333 for (i=0; i<=MAXCOL; i++)
1334 if (pNextRows[i] < nMinRow) // bei gleichen den linken
1335 {
1336 nMinRow = pNextRows[i];
1337 nCol = i;
1338 }
1339 nRow = nMinRow;
1340
1341 if ( nRow > MAXROW )
1342 {
1343 if (++nWrap >= 2) break; // ungueltigen Wert behalten
1344 nCol = 0;
1345 nRow = 0;
1346 for (i=0; i<=MAXCOL; i++)
1347 pNextRows[i] = 0; // alles ganz von vorne
1348 }
1349 }
1350 while ( !ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) );
1351 }
1352 else // rueckwaerts
1353 {
1354 for (i=0; i<=MAXCOL; i++)
1355 pNextRows[i] = (i>nCol) ? (nRow-1) : nRow;
1356 do
1357 {
1358 SCsROW nNextRow = pNextRows[nCol] - 1;
1359 if ( bMarked )
1360 nNextRow = rMark.GetNextMarked( nCol, nNextRow, true );
1361 if ( bUnprotected )
1362 nNextRow = aCol[nCol].GetNextUnprotected( nNextRow, true );
1363 pNextRows[nCol] = nNextRow;
1364
1365 SCsROW nMaxRow = -1;
1366 for (i=0; i<=MAXCOL; i++)
1367 if (pNextRows[i] >= nMaxRow) // bei gleichen den rechten
1368 {
1369 nMaxRow = pNextRows[i];
1370 nCol = i;
1371 }
1372 nRow = nMaxRow;
1373
1374 if ( nRow < 0 )
1375 {
1376 if (++nWrap >= 2) break; // ungueltigen Wert behalten
1377 nCol = MAXCOL;
1378 nRow = MAXROW;
1379 for (i=0; i<=MAXCOL; i++)
1380 pNextRows[i] = MAXROW; // alles ganz von vorne
1381 }
1382 }
1383 while ( !ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) );
1384 }
1385
1386 delete[] pNextRows;
1387 }
1388 }
1389
1390 // ungueltige Werte kommen z.b. bei Tab heraus,
1391 // wenn nicht markiert und nicht geschuetzt ist (linker / rechter Rand),
1392 // dann Werte unveraendert lassen
1393
1394 if (ValidColRow(nCol,nRow))
1395 {
1396 rCol = nCol;
1397 rRow = nRow;
1398 }
1399 }
1400
1401 bool ScTable::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMark ) const
1402 {
1403 const ScMarkArray* pMarkArray = rMark.GetArray();
1404 OSL_ENSURE(pMarkArray,"GetNextMarkedCell without MarkArray");
1405 if ( !pMarkArray )
1406 return false;
1407
1408 ++rRow; // naechste Zelle ist gesucht
1409
1410 while ( rCol <= MAXCOL )
1411 {
1412 const ScMarkArray& rArray = pMarkArray[rCol];
1413 while ( rRow <= MAXROW )
1414 {
1415 SCROW nStart = (SCROW) rArray.GetNextMarked( (SCsROW) rRow, false );
1416 if ( nStart <= MAXROW )
1417 {
1418 SCROW nEnd = rArray.GetMarkEnd( nStart, false );
1419
1420 const sc::CellStoreType& rCells = aCol[rCol].maCells;
1421 std::pair<sc::CellStoreType::const_iterator,size_t> aPos = rCells.position(nStart);
1422 sc::CellStoreType::const_iterator it = aPos.first;
1423 SCROW nTestRow = nStart;
1424 if (it->type == sc::element_type_empty)
1425 {
1426 // Skip the empty block.
1427 nTestRow += it->size - aPos.second;
1428 ++it;
1429 if (it == rCells.end())
1430 {
1431 // No more block.
1432 rRow = MAXROW + 1;
1433 return false;
1434 }
1435 }
1436
1437 if (nTestRow < nEnd)
1438 {
1439 // Cell found.
1440 rRow = nTestRow;
1441 return true;
1442 }
1443
1444 rRow = nEnd + 1; // naechsten markierten Bereich suchen
1445 }
1446 else
1447 rRow = MAXROW + 1; // Ende der Spalte
1448 }
1449 rRow = 0;
1450 ++rCol; // naechste Spalte testen
1451 }
1452
1453 return false; // alle Spalten durch
1454 }
1455
1456 void ScTable::UpdateDrawRef( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1457 SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
1458 SCsCOL nDx, SCsROW nDy, SCsTAB nDz, bool bUpdateNoteCaptionPos )
1459 {
1460 if ( nTab >= nTab1 && nTab <= nTab2 && nDz == 0 ) // only within the table
1461 {
1462 ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
1463 if ( eUpdateRefMode != URM_COPY && pDrawLayer )
1464 {
1465 if ( eUpdateRefMode == URM_MOVE )
1466 { // source range
1467 nCol1 = sal::static_int_cast<SCCOL>( nCol1 - nDx );
1468 nRow1 = sal::static_int_cast<SCROW>( nRow1 - nDy );
1469 nCol2 = sal::static_int_cast<SCCOL>( nCol2 - nDx );
1470 nRow2 = sal::static_int_cast<SCROW>( nRow2 - nDy );
1471 }
1472 pDrawLayer->MoveArea( nTab, nCol1,nRow1, nCol2,nRow2, nDx,nDy,
1473 (eUpdateRefMode == URM_INSDEL), bUpdateNoteCaptionPos );
1474 }
1475 }
1476 }
1477
1478 void ScTable::UpdateReference(
1479 sc::RefUpdateContext& rCxt, ScDocument* pUndoDoc, bool bIncludeDraw, bool bUpdateNoteCaptionPos )
1480 {
1481 bool bUpdated = false;
1482 SCCOL i;
1483 SCCOL iMax;
1484 if (rCxt.meMode == URM_COPY )
1485 {
1486 i = rCxt.maRange.aStart.Col();
1487 iMax = rCxt.maRange.aEnd.Col();
1488 }
1489 else
1490 {
1491 i = 0;
1492 iMax = MAXCOL;
1493 }
1494
1495 UpdateRefMode eUpdateRefMode = rCxt.meMode;
1496 SCCOL nDx = rCxt.mnColDelta;
1497 SCROW nDy = rCxt.mnRowDelta;
1498 SCTAB nDz = rCxt.mnTabDelta;
1499 SCCOL nCol1 = rCxt.maRange.aStart.Col(), nCol2 = rCxt.maRange.aEnd.Col();
1500 SCROW nRow1 = rCxt.maRange.aStart.Row(), nRow2 = rCxt.maRange.aEnd.Row();
1501 SCTAB nTab1 = rCxt.maRange.aStart.Tab(), nTab2 = rCxt.maRange.aEnd.Tab();
1502
1503 // Named expressions need to be updated before formulas acessing them.
1504 if (mpRangeName)
1505 mpRangeName->UpdateReference(rCxt, nTab);
1506
1507 for ( ; i<=iMax; i++)
1508 bUpdated |= aCol[i].UpdateReference(rCxt, pUndoDoc);
1509
1510 if ( bIncludeDraw )
1511 UpdateDrawRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz, bUpdateNoteCaptionPos );
1512
1513 if ( nTab >= nTab1 && nTab <= nTab2 && nDz == 0 ) // print ranges: only within the table
1514 {
1515 SCTAB nSTab = nTab;
1516 SCTAB nETab = nTab;
1517 SCCOL nSCol = 0;
1518 SCROW nSRow = 0;
1519 SCCOL nECol = 0;
1520 SCROW nERow = 0;
1521 bool bRecalcPages = false;
1522
1523 for ( ScRangeVec::iterator aIt = aPrintRanges.begin(), aEnd = aPrintRanges.end(); aIt != aEnd; ++aIt )
1524 {
1525 nSCol = aIt->aStart.Col();
1526 nSRow = aIt->aStart.Row();
1527 nECol = aIt->aEnd.Col();
1528 nERow = aIt->aEnd.Row();
1529
1530 // do not try to modify sheet index of print range
1531 if ( ScRefUpdate::Update( pDocument, eUpdateRefMode,
1532 nCol1,nRow1,nTab, nCol2,nRow2,nTab,
1533 nDx,nDy,0,
1534 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1535 {
1536 *aIt = ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1537 bRecalcPages = true;
1538 }
1539 }
1540
1541 if ( pRepeatColRange )
1542 {
1543 nSCol = pRepeatColRange->aStart.Col();
1544 nSRow = pRepeatColRange->aStart.Row();
1545 nECol = pRepeatColRange->aEnd.Col();
1546 nERow = pRepeatColRange->aEnd.Row();
1547
1548 // do not try to modify sheet index of repeat range
1549 if ( ScRefUpdate::Update( pDocument, eUpdateRefMode,
1550 nCol1,nRow1,nTab, nCol2,nRow2,nTab,
1551 nDx,nDy,0,
1552 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1553 {
1554 *pRepeatColRange = ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1555 bRecalcPages = true;
1556 nRepeatStartX = nSCol; // fuer UpdatePageBreaks
1557 nRepeatEndX = nECol;
1558 }
1559 }
1560
1561 if ( pRepeatRowRange )
1562 {
1563 nSCol = pRepeatRowRange->aStart.Col();
1564 nSRow = pRepeatRowRange->aStart.Row();
1565 nECol = pRepeatRowRange->aEnd.Col();
1566 nERow = pRepeatRowRange->aEnd.Row();
1567
1568 // do not try to modify sheet index of repeat range
1569 if ( ScRefUpdate::Update( pDocument, eUpdateRefMode,
1570 nCol1,nRow1,nTab, nCol2,nRow2,nTab,
1571 nDx,nDy,0,
1572 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1573 {
1574 *pRepeatRowRange = ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1575 bRecalcPages = true;
1576 nRepeatStartY = nSRow; // fuer UpdatePageBreaks
1577 nRepeatEndY = nERow;
1578 }
1579 }
1580
1581 // updating print ranges is not necessary with multiple print ranges
1582 if ( bRecalcPages && GetPrintRangeCount() <= 1 )
1583 {
1584 UpdatePageBreaks(NULL);
1585
1586 pDocument->RepaintRange( ScRange(0,0,nTab,MAXCOL,MAXROW,nTab) );
1587 }
1588 }
1589
1590 if (bUpdated && IsStreamValid())
1591 SetStreamValid(false);
1592
1593 if(mpCondFormatList)
1594 mpCondFormatList->UpdateReference(rCxt);
1595 }
1596
1597 void ScTable::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
1598 ScDocument* pUndoDoc )
1599 {
1600 for ( SCCOL i=0; i<=MAXCOL; i++ )
1601 aCol[i].UpdateTranspose( rSource, rDest, pUndoDoc );
1602 }
1603
1604 void ScTable::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
1605 {
1606 for ( SCCOL i=0; i<=MAXCOL; i++ )
1607 aCol[i].UpdateGrow( rArea, nGrowX, nGrowY );
1608 }
1609
1610 void ScTable::UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt )
1611 {
1612 if (nTab >= rCxt.mnInsertPos)
1613 {
1614 nTab += rCxt.mnSheets;
1615 if (pDBDataNoName)
1616 pDBDataNoName->UpdateMoveTab(nTab - 1 ,nTab);
1617 }
1618
1619 if (mpRangeName)
1620 mpRangeName->UpdateInsertTab(rCxt, nTab);
1621
1622 if (mpCondFormatList)
1623 mpCondFormatList->UpdateInsertTab(rCxt);
1624
1625 for (SCCOL i=0; i <= MAXCOL; i++) aCol[i].UpdateInsertTab(rCxt);
1626
1627 if (IsStreamValid())
1628 SetStreamValid(false);
1629 }
1630
1631 void ScTable::UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt )
1632 {
1633 if (nTab > rCxt.mnDeletePos)
1634 {
1635 nTab -= rCxt.mnSheets;
1636 if (pDBDataNoName)
1637 pDBDataNoName->UpdateMoveTab(nTab + 1,nTab);
1638 }
1639
1640 if (mpRangeName)
1641 mpRangeName->UpdateDeleteTab(rCxt, nTab);
1642
1643 if (mpCondFormatList)
1644 mpCondFormatList->UpdateDeleteTab(rCxt);
1645
1646 for (SCCOL i = 0; i <= MAXCOL; ++i)
1647 aCol[i].UpdateDeleteTab(rCxt);
1648
1649 if (IsStreamValid())
1650 SetStreamValid(false);
1651 }
1652
1653 void ScTable::UpdateMoveTab(
1654 sc::RefUpdateMoveTabContext& rCxt, SCTAB nTabNo, ScProgress* pProgress )
1655 {
1656 nTab = nTabNo;
1657 if (mpRangeName)
1658 mpRangeName->UpdateMoveTab(rCxt, nTab);
1659
1660 if (pDBDataNoName)
1661 pDBDataNoName->UpdateMoveTab(rCxt.mnOldPos, rCxt.mnNewPos);
1662
1663 if(mpCondFormatList)
1664 mpCondFormatList->UpdateMoveTab(rCxt);
1665
1666 for ( SCCOL i=0; i <= MAXCOL; i++ )
1667 {
1668 aCol[i].UpdateMoveTab(rCxt, nTabNo);
1669 if (pProgress)
1670 pProgress->SetState(pProgress->GetState() + aCol[i].GetCodeCount());
1671 }
1672
1673 if (IsStreamValid())
1674 SetStreamValid(false);
1675 }
1676
1677 void ScTable::UpdateCompile( bool bForceIfNameInUse )
1678 {
1679 for (SCCOL i=0; i <= MAXCOL; i++)
1680 {
1681 aCol[i].UpdateCompile( bForceIfNameInUse );
1682 }
1683 }
1684
1685 void ScTable::SetTabNo(SCTAB nNewTab)
1686 {
1687 nTab = nNewTab;
1688 for (SCCOL i=0; i <= MAXCOL; i++) aCol[i].SetTabNo(nNewTab);
1689 }
1690
1691 void ScTable::FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
1692 std::set<sal_uInt16>& rIndexes) const
1693 {
1694 for (SCCOL i = nCol1; i <= nCol2 && ValidCol(i); i++)
1695 aCol[i].FindRangeNamesInUse(nRow1, nRow2, rIndexes);
1696 }
1697
1698 void ScTable::ExtendPrintArea( OutputDevice* pDev,
1699 SCCOL /* nStartCol */, SCROW nStartRow, SCCOL& rEndCol, SCROW nEndRow )
1700 {
1701 if ( !pColFlags || !pRowFlags )
1702 {
1703 OSL_FAIL("ExtendPrintArea: No ColInfo or RowInfo");
1704 return;
1705 }
1706
1707 Point aPix1000 = pDev->LogicToPixel( Point(1000,1000), MAP_TWIP );
1708 double nPPTX = aPix1000.X() / 1000.0;
1709 double nPPTY = aPix1000.Y() / 1000.0;
1710
1711 // First, mark those columns that we need to skip i.e. hidden and empty columns.
1712
1713 ScFlatBoolColSegments aSkipCols;
1714 aSkipCols.setFalse(0, MAXCOL);
1715 for (SCCOL i = 0; i <= MAXCOL; ++i)
1716 {
1717 SCCOL nLastCol = i;
1718 if (ColHidden(i, NULL, &nLastCol))
1719 {
1720 // Columns are hidden in this range.
1721 aSkipCols.setTrue(i, nLastCol);
1722 }
1723 else
1724 {
1725 // These columns are visible. Check for empty columns.
1726 for (SCCOL j = i; j <= nLastCol; ++j)
1727 {
1728 if (aCol[j].GetCellCount() == 0)
1729 // empty
1730 aSkipCols.setTrue(j,j);
1731 }
1732 }
1733 i = nLastCol;
1734 }
1735
1736 ScFlatBoolColSegments::RangeData aColData;
1737 for (SCCOL nCol = rEndCol; nCol >= 0; --nCol)
1738 {
1739 if (!aSkipCols.getRangeData(nCol, aColData))
1740 // Failed to get the data. This should never happen!
1741 return;
1742
1743 if (aColData.mbValue)
1744 {
1745 // Skip these columns.
1746 nCol = aColData.mnCol1; // move toward 0.
1747 continue;
1748 }
1749
1750 // These are visible and non-empty columns.
1751 for (SCCOL nDataCol = nCol; 0 <= nDataCol && nDataCol >= aColData.mnCol1; --nDataCol)
1752 {
1753 SCCOL nPrintCol = nDataCol;
1754 VisibleDataCellIterator aIter(*mpHiddenRows, aCol[nDataCol]);
1755 ScRefCellValue aCell = aIter.reset(nStartRow);
1756 if (aCell.isEmpty())
1757 // No visible cells found in this column. Skip it.
1758 continue;
1759
1760 while (!aCell.isEmpty())
1761 {
1762 SCCOL nNewCol = nDataCol;
1763 SCROW nRow = aIter.getRow();
1764 if (nRow > nEndRow)
1765 // Went past the last row position. Bail out.
1766 break;
1767
1768 MaybeAddExtraColumn(nNewCol, nRow, pDev, nPPTX, nPPTY);
1769 if (nNewCol > nPrintCol)
1770 nPrintCol = nNewCol;
1771 aCell = aIter.next();
1772 }
1773
1774 if (nPrintCol > rEndCol)
1775 // Make sure we don't shrink the print area.
1776 rEndCol = nPrintCol;
1777 }
1778 nCol = aColData.mnCol1; // move toward 0.
1779 }
1780 }
1781
1782 void ScTable::MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, double nPPTX, double nPPTY)
1783 {
1784 ScRefCellValue aCell = aCol[rCol].GetCellValue(nRow);
1785 if (!aCell.hasString())
1786 return;
1787
1788 bool bFormula = false; //! ueberge
1789 long nPixel = aCol[rCol].GetTextWidth(nRow);
1790
1791 // Breite bereits im Idle-Handler berechnet?
1792 if ( TEXTWIDTH_DIRTY == nPixel )
1793 {
1794 ScNeededSizeOptions aOptions;
1795 aOptions.bTotalSize = true;
1796 aOptions.bFormula = bFormula;
1797 aOptions.bSkipMerged = false;
1798
1799 Fraction aZoom(1,1);
1800 nPixel = aCol[rCol].GetNeededSize(
1801 nRow, pDev, nPPTX, nPPTY, aZoom, aZoom, true, aOptions );
1802
1803 aCol[rCol].SetTextWidth(nRow, static_cast<sal_uInt16>(nPixel));
1804 }
1805
1806 long nTwips = (long) (nPixel / nPPTX);
1807 long nDocW = GetColWidth( rCol );
1808
1809 long nMissing = nTwips - nDocW;
1810 if ( nMissing > 0 )
1811 {
1812 // look at alignment
1813
1814 const ScPatternAttr* pPattern = GetPattern( rCol, nRow );
1815 const SfxItemSet* pCondSet = pDocument->GetCondResult( rCol, nRow, nTab );
1816
1817 SvxCellHorJustify eHorJust = (SvxCellHorJustify)((const SvxHorJustifyItem&)
1818 pPattern->GetItem( ATTR_HOR_JUSTIFY, pCondSet )).GetValue();
1819 if ( eHorJust == SVX_HOR_JUSTIFY_CENTER )
1820 nMissing /= 2; // distributed into both directions
1821 else
1822 {
1823 // STANDARD is LEFT (only text is handled here)
1824 bool bRight = ( eHorJust == SVX_HOR_JUSTIFY_RIGHT );
1825 if ( IsLayoutRTL() )
1826 bRight = !bRight;
1827 if ( bRight )
1828 nMissing = 0; // extended only to the left (logical)
1829 }
1830 }
1831
1832 SCCOL nNewCol = rCol;
1833 while (nMissing > 0 && nNewCol < MAXCOL)
1834 {
1835 ScRefCellValue aNextCell = aCol[nNewCol+1].GetCellValue(nRow);
1836 if (!aNextCell.isEmpty())
1837 // Cell content in a next column ends display of this string.
1838 nMissing = 0;
1839 else
1840 nMissing -= GetColWidth(++nNewCol);
1841 }
1842 rCol = nNewCol;
1843 }
1844
1845 namespace {
1846
1847 class SetTableIndex : public ::std::unary_function<ScRange, void>
1848 {
1849 SCTAB mnTab;
1850 public:
1851 SetTableIndex(SCTAB nTab) : mnTab(nTab) {}
1852
1853 void operator() (ScRange& rRange) const
1854 {
1855 rRange.aStart.SetTab(mnTab);
1856 rRange.aEnd.SetTab(mnTab);
1857 }
1858 };
1859
1860 void setPrintRange(ScRange*& pRange1, const ScRange* pRange2)
1861 {
1862 if (pRange2)
1863 {
1864 if (pRange1)
1865 *pRange1 = *pRange2;
1866 else
1867 pRange1 = new ScRange(*pRange2);
1868 }
1869 else
1870 DELETEZ(pRange1);
1871 }
1872
1873 }
1874
1875 void ScTable::CopyPrintRange(const ScTable& rTable)
1876 {
1877 // The table index shouldn't be used when the print range is used, but
1878 // just in case set the correct table index.
1879
1880 aPrintRanges = rTable.aPrintRanges;
1881 ::std::for_each(aPrintRanges.begin(), aPrintRanges.end(), SetTableIndex(nTab));
1882
1883 bPrintEntireSheet = rTable.bPrintEntireSheet;
1884
1885 delete pRepeatColRange;
1886 pRepeatColRange = NULL;
1887 if (rTable.pRepeatColRange)
1888 {
1889 pRepeatColRange = new ScRange(*rTable.pRepeatColRange);
1890 pRepeatColRange->aStart.SetTab(nTab);
1891 pRepeatColRange->aEnd.SetTab(nTab);
1892 }
1893
1894 delete pRepeatRowRange;
1895 pRepeatRowRange = NULL;
1896 if (rTable.pRepeatRowRange)
1897 {
1898 pRepeatRowRange = new ScRange(*rTable.pRepeatRowRange);
1899 pRepeatRowRange->aStart.SetTab(nTab);
1900 pRepeatRowRange->aEnd.SetTab(nTab);
1901 }
1902 }
1903
1904 void ScTable::SetRepeatColRange( const ScRange* pNew )
1905 {
1906 setPrintRange( pRepeatColRange, pNew );
1907
1908 if (IsStreamValid())
1909 SetStreamValid(false);
1910
1911 InvalidatePageBreaks();
1912 }
1913
1914 void ScTable::SetRepeatRowRange( const ScRange* pNew )
1915 {
1916 setPrintRange( pRepeatRowRange, pNew );
1917
1918 if (IsStreamValid())
1919 SetStreamValid(false);
1920
1921 InvalidatePageBreaks();
1922 }
1923
1924 void ScTable::ClearPrintRanges()
1925 {
1926 aPrintRanges.clear();
1927 bPrintEntireSheet = false;
1928
1929 if (IsStreamValid())
1930 SetStreamValid(false);
1931
1932 InvalidatePageBreaks(); // #i117952# forget page breaks for an old print range
1933 }
1934
1935 void ScTable::AddPrintRange( const ScRange& rNew )
1936 {
1937 bPrintEntireSheet = false;
1938 if( aPrintRanges.size() < 0xFFFF )
1939 aPrintRanges.push_back( rNew );
1940
1941 if (IsStreamValid())
1942 SetStreamValid(false);
1943
1944 InvalidatePageBreaks();
1945 }
1946
1947
1948 void ScTable::SetPrintEntireSheet()
1949 {
1950 if( !IsPrintEntireSheet() )
1951 {
1952 ClearPrintRanges();
1953 bPrintEntireSheet = true;
1954 }
1955 }
1956
1957 const ScRange* ScTable::GetPrintRange(sal_uInt16 nPos) const
1958 {
1959 return (nPos < GetPrintRangeCount()) ? &aPrintRanges[ nPos ] : NULL;
1960 }
1961
1962 void ScTable::FillPrintSaver( ScPrintSaverTab& rSaveTab ) const
1963 {
1964 rSaveTab.SetAreas( aPrintRanges, bPrintEntireSheet );
1965 rSaveTab.SetRepeat( pRepeatColRange, pRepeatRowRange );
1966 }
1967
1968 void ScTable::RestorePrintRanges( const ScPrintSaverTab& rSaveTab )
1969 {
1970 aPrintRanges = rSaveTab.GetPrintRanges();
1971 bPrintEntireSheet = rSaveTab.IsEntireSheet();
1972 SetRepeatColRange( rSaveTab.GetRepeatCol() );
1973 SetRepeatRowRange( rSaveTab.GetRepeatRow() );
1974
1975 InvalidatePageBreaks(); // #i117952# forget page breaks for an old print range
1976 UpdatePageBreaks(NULL);
1977 }
1978
1979 SCROW ScTable::VisibleDataCellIterator::ROW_NOT_FOUND = -1;
1980
1981 ScTable::VisibleDataCellIterator::VisibleDataCellIterator(ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn) :
1982 mrRowSegs(rRowSegs),
1983 mrColumn(rColumn),
1984 mnCurRow(ROW_NOT_FOUND),
1985 mnUBound(ROW_NOT_FOUND)
1986 {
1987 }
1988
1989 ScTable::VisibleDataCellIterator::~VisibleDataCellIterator()
1990 {
1991 }
1992
1993 ScRefCellValue ScTable::VisibleDataCellIterator::reset(SCROW nRow)
1994 {
1995 if (nRow > MAXROW)
1996 {
1997 mnCurRow = ROW_NOT_FOUND;
1998 return ScRefCellValue();
1999 }
2000
2001 ScFlatBoolRowSegments::RangeData aData;
2002 if (!mrRowSegs.getRangeData(nRow, aData))
2003 {
2004 mnCurRow = ROW_NOT_FOUND;
2005 return ScRefCellValue();
2006 }
2007
2008 if (!aData.mbValue)
2009 {
2010 // specified row is visible. Take it.
2011 mnCurRow = nRow;
2012 mnUBound = aData.mnRow2;
2013 }
2014 else
2015 {
2016 // specified row is not-visible. The first visible row is the start of
2017 // the next segment.
2018 mnCurRow = aData.mnRow2 + 1;
2019 mnUBound = mnCurRow; // get range data on the next iteration.
2020 if (mnCurRow > MAXROW)
2021 {
2022 // Make sure the row doesn't exceed our current limit.
2023 mnCurRow = ROW_NOT_FOUND;
2024 return ScRefCellValue();
2025 }
2026 }
2027
2028 maCell = mrColumn.GetCellValue(mnCurRow);
2029 if (!maCell.isEmpty())
2030 // First visible cell found.
2031 return maCell;
2032
2033 // Find a first visible cell below this row (if any).
2034 return next();
2035 }
2036
2037 ScRefCellValue ScTable::VisibleDataCellIterator::next()
2038 {
2039 if (mnCurRow == ROW_NOT_FOUND)
2040 return ScRefCellValue();
2041
2042 while (mrColumn.GetNextDataPos(mnCurRow))
2043 {
2044 if (mnCurRow > mnUBound)
2045 {
2046 // We don't know the visibility of this row range. Query it.
2047 ScFlatBoolRowSegments::RangeData aData;
2048 if (!mrRowSegs.getRangeData(mnCurRow, aData))
2049 {
2050 mnCurRow = ROW_NOT_FOUND;
2051 return ScRefCellValue();
2052 }
2053
2054 if (aData.mbValue)
2055 {
2056 // This row is invisible. Skip to the last invisible row and
2057 // try again.
2058 mnCurRow = mnUBound = aData.mnRow2;
2059 continue;
2060 }
2061
2062 // This row is visible.
2063 mnUBound = aData.mnRow2;
2064 }
2065
2066 maCell = mrColumn.GetCellValue(mnCurRow);
2067 if (!maCell.isEmpty())
2068 return maCell;
2069 }
2070
2071 mnCurRow = ROW_NOT_FOUND;
2072 return ScRefCellValue();
2073 }
2074
2075 SCROW ScTable::VisibleDataCellIterator::getRow() const
2076 {
2077 return mnCurRow;
2078 }
2079
2080 void ScTable::SetAnonymousDBData(ScDBData* pDBData)
2081 {
2082 delete pDBDataNoName;
2083 pDBDataNoName = pDBData;
2084 }
2085
2086 ScDBData* ScTable::GetAnonymousDBData()
2087 {
2088 return pDBDataNoName;
2089 }
2090
2091 sal_uLong ScTable::AddCondFormat( ScConditionalFormat* pNew )
2092 {
2093 if(!mpCondFormatList)
2094 mpCondFormatList.reset(new ScConditionalFormatList());
2095
2096 sal_uLong nMax = 0;
2097 for(ScConditionalFormatList::const_iterator itr = mpCondFormatList->begin();
2098 itr != mpCondFormatList->end(); ++itr)
2099 {
2100 sal_uLong nKey = itr->GetKey();
2101 if(nKey > nMax)
2102 nMax = nKey;
2103 }
2104
2105 pNew->SetKey(nMax+1);
2106 mpCondFormatList->InsertNew(pNew);
2107
2108 return nMax + 1;
2109 }
2110
2111 sal_uInt8 ScTable::GetScriptType( SCCOL nCol, SCROW nRow ) const
2112 {
2113 if (!ValidCol(nCol))
2114 return 0;
2115
2116 return aCol[nCol].GetScriptType(nRow);
2117 }
2118
2119 void ScTable::SetScriptType( SCCOL nCol, SCROW nRow, sal_uInt8 nType )
2120 {
2121 if (!ValidCol(nCol))
2122 return;
2123
2124 aCol[nCol].SetScriptType(nRow, nType);
2125 }
2126
2127 sal_uInt8 ScTable::GetRangeScriptType(
2128 sc::ColumnBlockPosition& rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2 )
2129 {
2130 if (!ValidCol(nCol))
2131 return 0;
2132
2133 sc::CellStoreType::iterator itr = aCol[nCol].maCells.begin();
2134 return aCol[nCol].GetRangeScriptType(rBlockPos.miCellTextAttrPos, nRow1, nRow2, itr);
2135 }
2136
2137 size_t ScTable::GetFormulaHash( SCCOL nCol, SCROW nRow ) const
2138 {
2139 if (!ValidCol(nCol))
2140 return 0;
2141
2142 return aCol[nCol].GetFormulaHash(nRow);
2143 }
2144
2145 ScFormulaVectorState ScTable::GetFormulaVectorState( SCCOL nCol, SCROW nRow ) const
2146 {
2147 if (!ValidCol(nCol))
2148 return FormulaVectorUnknown;
2149
2150 return aCol[nCol].GetFormulaVectorState(nRow);
2151 }
2152
2153 formula::FormulaTokenRef ScTable::ResolveStaticReference( SCCOL nCol, SCROW nRow )
2154 {
2155 if (!ValidCol(nCol) || !ValidRow(nRow))
2156 return formula::FormulaTokenRef();
2157
2158 return aCol[nCol].ResolveStaticReference(nRow);
2159 }
2160
2161 formula::FormulaTokenRef ScTable::ResolveStaticReference( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
2162 {
2163 if (nCol2 < nCol1 || nRow2 < nRow1)
2164 return formula::FormulaTokenRef();
2165
2166 if (!ValidCol(nCol1) || !ValidCol(nCol2) || !ValidRow(nRow1) || !ValidRow(nRow2))
2167 return formula::FormulaTokenRef();
2168
2169 ScMatrixRef pMat(new ScMatrix(nCol2-nCol1+1, nRow2-nRow1+1, 0.0));
2170 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2171 {
2172 if (!aCol[nCol].ResolveStaticReference(*pMat, nCol2-nCol1, nRow1, nRow2))
2173 // Column contains non-static cell. Failed.
2174 return formula::FormulaTokenRef();
2175 }
2176
2177 return formula::FormulaTokenRef(new ScMatrixToken(pMat));
2178 }
2179
2180 formula::VectorRefArray ScTable::FetchVectorRefArray( SCCOL nCol, SCROW nRow1, SCROW nRow2 )
2181 {
2182 if (nRow2 < nRow1)
2183 return formula::VectorRefArray();
2184
2185 if (!ValidCol(nCol) || !ValidRow(nRow1) || !ValidRow(nRow2))
2186 return formula::VectorRefArray();
2187
2188 return aCol[nCol].FetchVectorRefArray(nRow1, nRow2);
2189 }
2190
2191 ScRefCellValue ScTable::GetRefCellValue( SCCOL nCol, SCROW nRow )
2192 {
2193 if (!ValidColRow(nCol, nRow))
2194 return ScRefCellValue();
2195
2196 return aCol[nCol].GetCellValue(nRow);
2197 }
2198
2199 SvtBroadcaster* ScTable::GetBroadcaster( SCCOL nCol, SCROW nRow )
2200 {
2201 if (!ValidColRow(nCol, nRow))
2202 return NULL;
2203
2204 return aCol[nCol].GetBroadcaster(nRow);
2205 }
2206
2207 void ScTable::DeleteBroadcasters(
2208 sc::ColumnBlockPosition& rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2 )
2209 {
2210 if (!ValidCol(nCol))
2211 return;
2212
2213 aCol[nCol].DeleteBroadcasters(rBlockPos, nRow1, nRow2);
2214 }
2215
2216 bool ScTable::HasBroadcaster( SCCOL nCol ) const
2217 {
2218 if (!ValidCol(nCol))
2219 return false;
2220
2221 return aCol[nCol].HasBroadcaster();
2222 }
2223
2224 void ScTable::FillMatrix( ScMatrix& rMat, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const
2225 {
2226 size_t nMatCol = 0;
2227 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol, ++nMatCol)
2228 aCol[nCol].FillMatrix(rMat, nMatCol, nRow1, nRow2);
2229 }
2230
2231 void ScTable::InterpretDirtyCells( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
2232 {
2233 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2234 aCol[nCol].InterpretDirtyCells(nRow1, nRow2);
2235 }
2236
2237 void ScTable::SetFormulaResults( SCCOL nCol, SCROW nRow, const double* pResults, size_t nLen )
2238 {
2239 if (!ValidCol(nCol))
2240 return;
2241
2242 aCol[nCol].SetFormulaResults(nRow, pResults, nLen);
2243 }
2244
2245 void ScTable::SetFormulaResults(
2246 SCCOL nCol, SCROW nRow, const formula::FormulaTokenRef* pResults, size_t nLen )
2247 {
2248 if (!ValidCol(nCol))
2249 return;
2250
2251 aCol[nCol].SetFormulaResults(nRow, pResults, nLen);
2252 }
2253
2254 #if DEBUG_COLUMN_STORAGE
2255 void ScTable::DumpFormulaGroups( SCCOL nCol ) const
2256 {
2257 if (!ValidCol(nCol))
2258 return;
2259
2260 aCol[nCol].DumpFormulaGroups();
2261 }
2262 #endif
2263
2264 const SvtBroadcaster* ScTable::GetBroadcaster( SCCOL nCol, SCROW nRow ) const
2265 {
2266 if (!ValidColRow(nCol, nRow))
2267 return NULL;
2268
2269 return aCol[nCol].GetBroadcaster(nRow);
2270 }
2271
2272 void ScTable::DeleteConditionalFormat( sal_uLong nIndex )
2273 {
2274 mpCondFormatList->erase(nIndex);
2275 }
2276
2277 void ScTable::SetCondFormList( ScConditionalFormatList* pNew )
2278 {
2279 mpCondFormatList.reset( pNew );
2280 }
2281
2282 ScConditionalFormatList* ScTable::GetCondFormList()
2283 {
2284 if(!mpCondFormatList)
2285 mpCondFormatList.reset( new ScConditionalFormatList() );
2286
2287 return mpCondFormatList.get();
2288 }
2289
2290 const ScConditionalFormatList* ScTable::GetCondFormList() const
2291 {
2292 return mpCondFormatList.get();
2293 }
2294
2295 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE