xref: /aoo41x/main/sc/source/core/data/table2.cxx (revision 3ce8cab8)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sc.hxx"
26 
27 // INCLUDE ---------------------------------------------------------------
28 
29 #include "scitems.hxx"
30 #include <editeng/boxitem.hxx>
31 #include <tools/urlobj.hxx>
32 #include <svl/poolcach.hxx>
33 #include <unotools/charclass.hxx>
34 #include <math.h>
35 #include <svl/PasswordHelper.hxx>
36 #include <unotools/transliterationwrapper.hxx>
37 
38 #include "patattr.hxx"
39 #include "docpool.hxx"
40 #include "cell.hxx"
41 #include "document.hxx"
42 #include "drwlayer.hxx"
43 #include "olinetab.hxx"
44 #include "rechead.hxx"
45 #include "stlpool.hxx"
46 #include "attarray.hxx"		// Iterator
47 #include "markdata.hxx"
48 #include "progress.hxx"
49 #include "dociter.hxx"
50 #include "conditio.hxx"
51 #include "chartlis.hxx"
52 #include "fillinfo.hxx"
53 #include "bcaslot.hxx"
54 #include "postit.hxx"
55 #include "sheetevents.hxx"
56 #include "globstr.hrc"
57 #include "segmenttree.hxx"
58 #include "dbcolect.hxx"
59 
60 #include <math.h>
61 
62 // STATIC DATA -----------------------------------------------------------
63 
64 
65 sal_Bool ScTable::SetOutlineTable( const ScOutlineTable* pNewOutline )
66 {
67 	sal_uInt16 nOldSizeX = 0;
68 	sal_uInt16 nOldSizeY = 0;
69 	sal_uInt16 nNewSizeX = 0;
70 	sal_uInt16 nNewSizeY = 0;
71 
72 	if (pOutlineTable)
73 	{
74 		nOldSizeX = pOutlineTable->GetColArray()->GetDepth();
75 		nOldSizeY = pOutlineTable->GetRowArray()->GetDepth();
76 		delete pOutlineTable;
77 	}
78 
79 	if (pNewOutline)
80 	{
81 		pOutlineTable = new ScOutlineTable( *pNewOutline );
82 		nNewSizeX = pOutlineTable->GetColArray()->GetDepth();
83 		nNewSizeY = pOutlineTable->GetRowArray()->GetDepth();
84 	}
85 	else
86 		pOutlineTable = NULL;
87 
88 	return ( nNewSizeX != nOldSizeX || nNewSizeY != nOldSizeY );		// Groesse geaendert ?
89 }
90 
91 
92 void ScTable::StartOutlineTable()
93 {
94 	if (!pOutlineTable)
95 		pOutlineTable = new ScOutlineTable;
96 }
97 
98 
99 void ScTable::SetSheetEvents( const ScSheetEvents* pNew )
100 {
101     delete pSheetEvents;
102     if (pNew)
103         pSheetEvents = new ScSheetEvents(*pNew);
104     else
105         pSheetEvents = NULL;
106 
107     SetCalcNotification( sal_False );       // discard notifications before the events were set
108 
109     if (IsStreamValid())
110         SetStreamValid(sal_False);
111 }
112 
113 
114 void ScTable::SetCalcNotification( sal_Bool bSet )
115 {
116     bCalcNotification = bSet;
117 }
118 
119 
120 sal_Bool ScTable::TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCSIZE nSize )
121 {
122 	sal_Bool bTest = sal_True;
123 
124 	if ( nStartCol==0 && nEndCol==MAXCOL && pOutlineTable )
125 		bTest = pOutlineTable->TestInsertRow(nSize);
126 
127 	for (SCCOL i=nStartCol; (i<=nEndCol) && bTest; i++)
128 		bTest = aCol[i].TestInsertRow( nSize );
129 
130 	return bTest;
131 }
132 
133 
134 void ScTable::InsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize )
135 {
136 	IncRecalcLevel();
137     InitializeNoteCaptions();
138 	if (nStartCol==0 && nEndCol==MAXCOL)
139 	{
140         if (mpRowHeights && pRowFlags)
141 		{
142             mpRowHeights->insertSegment(nStartRow, nSize, false);
143             sal_uInt8 nNewFlags = pRowFlags->Insert( nStartRow, nSize);
144             // only copy manual size flag, clear all others
145             if (nNewFlags && (nNewFlags != CR_MANUALSIZE))
146                 pRowFlags->SetValue( nStartRow, nStartRow + nSize - 1,
147                         nNewFlags & CR_MANUALSIZE);
148 		}
149 
150 		if (pOutlineTable)
151 			pOutlineTable->InsertRow( nStartRow, nSize );
152 
153         mpFilteredRows->insertSegment(nStartRow, nSize, true);
154         mpHiddenRows->insertSegment(nStartRow, nSize, true);
155 
156         if (!maRowManualBreaks.empty())
157         {
158             std::set<SCROW>::reverse_iterator rit = maRowManualBreaks.rbegin();
159             while (rit != maRowManualBreaks.rend())
160             {
161                 SCROW nRow = *rit;
162                 if (nRow < nStartRow)
163                     break;  // while
164                 else
165                 {
166                     maRowManualBreaks.erase( (++rit).base());
167                     maRowManualBreaks.insert( static_cast<SCROW>( nRow + nSize));
168                 }
169             }
170         }
171 	}
172 
173 	for (SCCOL j=nStartCol; j<=nEndCol; j++)
174 		aCol[j].InsertRow( nStartRow, nSize );
175 	DecRecalcLevel( false );
176 
177     InvalidatePageBreaks();
178 }
179 
180 
181 void ScTable::DeleteRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize,
182 							sal_Bool* pUndoOutline )
183 {
184 	IncRecalcLevel();
185     InitializeNoteCaptions();
186 	if (nStartCol==0 && nEndCol==MAXCOL)
187 	{
188         if (pRowFlags)
189             pRowFlags->Remove( nStartRow, nSize);
190 
191         if (mpRowHeights)
192             mpRowHeights->removeSegment(nStartRow, nStartRow+nSize);
193 
194 		if (pOutlineTable)
195 			if (pOutlineTable->DeleteRow( nStartRow, nSize ))
196 				if (pUndoOutline)
197 					*pUndoOutline = sal_True;
198 
199         mpFilteredRows->removeSegment(nStartRow, nStartRow+nSize);
200         mpHiddenRows->removeSegment(nStartRow, nStartRow+nSize);
201 
202         if (!maRowManualBreaks.empty())
203         {
204             std::set<SCROW>::iterator it = maRowManualBreaks.upper_bound( static_cast<SCROW>( nStartRow + nSize - 1));
205             maRowManualBreaks.erase( maRowManualBreaks.lower_bound( nStartRow), it);
206             while (it != maRowManualBreaks.end())
207             {
208                 SCROW nRow = *it;
209                 maRowManualBreaks.erase( it++);
210                 maRowManualBreaks.insert( static_cast<SCROW>( nRow - nSize));
211             }
212         }
213 	}
214 
215     {   // scope for bulk broadcast
216         ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM());
217         for (SCCOL j=nStartCol; j<=nEndCol; j++)
218             aCol[j].DeleteRow( nStartRow, nSize );
219     }
220 	DecRecalcLevel();
221 
222     InvalidatePageBreaks();
223 }
224 
225 
226 sal_Bool ScTable::TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize )
227 {
228 	sal_Bool bTest = sal_True;
229 
230 	if ( nStartRow==0 && nEndRow==MAXROW && pOutlineTable )
231 		bTest = pOutlineTable->TestInsertCol(nSize);
232 
233 	if ( nSize > static_cast<SCSIZE>(MAXCOL) )
234 		bTest = sal_False;
235 
236 	for (SCCOL i=MAXCOL; (i+static_cast<SCCOL>(nSize)>MAXCOL) && bTest; i--)
237 		bTest = aCol[i].TestInsertCol(nStartRow, nEndRow);
238 
239 	return bTest;
240 }
241 
242 
243 void ScTable::InsertCol( SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize )
244 {
245 	IncRecalcLevel();
246     InitializeNoteCaptions();
247 	if (nStartRow==0 && nEndRow==MAXROW)
248 	{
249 		if (pColWidth && pColFlags)
250         {
251             memmove( &pColWidth[nStartCol+nSize], &pColWidth[nStartCol],
252                     (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColWidth[0]) );
253             memmove( &pColFlags[nStartCol+nSize], &pColFlags[nStartCol],
254                     (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColFlags[0]) );
255         }
256 		if (pOutlineTable)
257 			pOutlineTable->InsertCol( nStartCol, nSize );
258 
259         mpHiddenCols->insertSegment(nStartCol, static_cast<SCCOL>(nSize), true);
260         mpFilteredCols->insertSegment(nStartCol, static_cast<SCCOL>(nSize), true);
261 
262         if (!maColManualBreaks.empty())
263         {
264             std::set<SCCOL>::reverse_iterator rit = maColManualBreaks.rbegin();
265             while (rit != maColManualBreaks.rend())
266             {
267                 SCCOL nCol = *rit;
268                 if (nCol < nStartCol)
269                     break;  // while
270                 else
271                 {
272                     maColManualBreaks.erase( (++rit).base());
273                     maColManualBreaks.insert( static_cast<SCCOL>( nCol + nSize));
274                 }
275             }
276         }
277 	}
278 
279 
280 	if ((nStartRow == 0) && (nEndRow == MAXROW))
281 	{
282 		for (SCSIZE i=0; i < nSize; i++)
283 			for (SCCOL nCol = MAXCOL; nCol > nStartCol; nCol--)
284 				aCol[nCol].SwapCol(aCol[nCol-1]);
285 	}
286 	else
287 	{
288 		for (SCSIZE i=0; static_cast<SCCOL>(i+nSize)+nStartCol <= MAXCOL; i++)
289 			aCol[MAXCOL - nSize - i].MoveTo(nStartRow, nEndRow, aCol[MAXCOL - i]);
290 	}
291 
292 	if (nStartCol>0)						// copy old attributes
293 	{
294 		sal_uInt16 nWhichArray[2];
295 		nWhichArray[0] = ATTR_MERGE;
296 		nWhichArray[1] = 0;
297 
298 		for (SCSIZE i=0; i<nSize; i++)
299 		{
300 			aCol[nStartCol-1].CopyToColumn( nStartRow, nEndRow, IDF_ATTRIB,
301 												sal_False, aCol[nStartCol+i] );
302 			aCol[nStartCol+i].RemoveFlags( nStartRow, nEndRow,
303 												SC_MF_HOR | SC_MF_VER | SC_MF_AUTO );
304 			aCol[nStartCol+i].ClearItems( nStartRow, nEndRow, nWhichArray );
305 		}
306 	}
307 	DecRecalcLevel();
308 
309     InvalidatePageBreaks();
310 }
311 
312 
313 void ScTable::DeleteCol( SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize,
314 							sal_Bool* pUndoOutline )
315 {
316 	IncRecalcLevel();
317     InitializeNoteCaptions();
318 	if (nStartRow==0 && nEndRow==MAXROW)
319 	{
320 		if (pColWidth && pColFlags)
321         {
322             memmove( &pColWidth[nStartCol], &pColWidth[nStartCol+nSize],
323                     (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColWidth[0]) );
324             memmove( &pColFlags[nStartCol], &pColFlags[nStartCol+nSize],
325                     (MAXCOL - nStartCol + 1 - nSize) * sizeof(pColFlags[0]) );
326         }
327 		if (pOutlineTable)
328 			if (pOutlineTable->DeleteCol( nStartCol, nSize ))
329 				if (pUndoOutline)
330 					*pUndoOutline = sal_True;
331 
332         SCCOL nRmSize = nStartCol + static_cast<SCCOL>(nSize);
333         mpHiddenCols->removeSegment(nStartCol, nRmSize);
334         mpFilteredCols->removeSegment(nStartCol, nRmSize);
335 
336         if (!maColManualBreaks.empty())
337         {
338             std::set<SCCOL>::iterator it = maColManualBreaks.upper_bound( static_cast<SCCOL>( nStartCol + nSize - 1));
339             maColManualBreaks.erase( maColManualBreaks.lower_bound( nStartCol), it);
340             while (it != maColManualBreaks.end())
341             {
342                 SCCOL nCol = *it;
343                 maColManualBreaks.erase( it++);
344                 maColManualBreaks.insert( static_cast<SCCOL>( nCol - nSize));
345             }
346         }
347 	}
348 
349 
350     {   // scope for bulk broadcast
351         ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM());
352         for (SCSIZE i = 0; i < nSize; i++)
353             aCol[nStartCol + i].DeleteArea(nStartRow, nEndRow, IDF_ALL);
354     }
355 
356 	if ((nStartRow == 0) && (nEndRow == MAXROW))
357 	{
358 		for (SCSIZE i=0; i < nSize; i++)
359 			for (SCCOL nCol = nStartCol; nCol < MAXCOL; nCol++)
360 				aCol[nCol].SwapCol(aCol[nCol+1]);
361 	}
362 	else
363 	{
364 		for (SCSIZE i=0; static_cast<SCCOL>(i+nSize)+nStartCol <= MAXCOL; i++)
365 			aCol[nStartCol + nSize + i].MoveTo(nStartRow, nEndRow, aCol[nStartCol + i]);
366 	}
367 	DecRecalcLevel();
368 
369     InvalidatePageBreaks();
370 }
371 
372 
373 void ScTable::DeleteArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt16 nDelFlag)
374 {
375 	if (nCol2 > MAXCOL) nCol2 = MAXCOL;
376 	if (nRow2 > MAXROW) nRow2 = MAXROW;
377 	if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
378 	{
379 //		IncRecalcLevel();
380 
381         {   // scope for bulk broadcast
382             ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM());
383             for (SCCOL i = nCol1; i <= nCol2; i++)
384                 aCol[i].DeleteArea(nRow1, nRow2, nDelFlag);
385         }
386 
387 			//
388 			// Zellschutz auf geschuetzter Tabelle nicht setzen
389 			//
390 
391 		if ( IsProtected() && (nDelFlag & IDF_ATTRIB) )
392 		{
393 			ScPatternAttr aPattern(pDocument->GetPool());
394 			aPattern.GetItemSet().Put( ScProtectionAttr( sal_False ) );
395 			ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern );
396 		}
397 
398 //		DecRecalcLevel();
399 	}
400 }
401 
402 
403 void ScTable::DeleteSelection( sal_uInt16 nDelFlag, const ScMarkData& rMark )
404 {
405     {   // scope for bulk broadcast
406         ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM());
407         for (SCCOL i=0; i<=MAXCOL; i++)
408             aCol[i].DeleteSelection( nDelFlag, rMark );
409     }
410 
411 		//
412 		// Zellschutz auf geschuetzter Tabelle nicht setzen
413 		//
414 
415 	if ( IsProtected() && (nDelFlag & IDF_ATTRIB) )
416 	{
417 		ScDocumentPool* pPool = pDocument->GetPool();
418 		SfxItemSet aSet( *pPool, ATTR_PATTERN_START, ATTR_PATTERN_END );
419 		aSet.Put( ScProtectionAttr( sal_False ) );
420 		SfxItemPoolCache aCache( pPool, &aSet );
421 		ApplySelectionCache( &aCache, rMark );
422 	}
423 }
424 
425 
426 //	pTable = Clipboard
427 void ScTable::CopyToClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
428                         ScTable* pTable, sal_Bool bKeepScenarioFlags, sal_Bool bCloneNoteCaptions)
429 {
430 	if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
431 	{
432 		//	Inhalte kopieren
433 		SCCOL i;
434 
435 		for ( i = nCol1; i <= nCol2; i++)
436             aCol[i].CopyToClip(nRow1, nRow2, pTable->aCol[i], bKeepScenarioFlags, bCloneNoteCaptions);
437 
438 		//	copy widths/heights, and only "hidden", "filtered" and "manual" flags
439 		//	also for all preceding columns/rows, to have valid positions for drawing objects
440 
441 		if (pColWidth && pTable->pColWidth)
442 			for (i=0; i<=nCol2; i++)
443 				pTable->pColWidth[i] = pColWidth[i];
444 
445         pTable->CopyColHidden(*this, 0, nCol2);
446         pTable->CopyColFiltered(*this, 0, nCol2);
447 
448         if (pRowFlags && pTable->pRowFlags && mpRowHeights && pTable->mpRowHeights)
449         {
450             pTable->pRowFlags->CopyFromAnded( *pRowFlags, 0, nRow2, CR_MANUALSIZE);
451             pTable->CopyRowHeight(*this, 0, nRow2, 0);
452         }
453 
454         pTable->CopyRowHidden(*this, 0, nRow2);
455         pTable->CopyRowFiltered(*this, 0, nRow2);
456 
457 		//	ggf. Formeln durch Werte ersetzen
458 
459 		if ( IsProtected() )
460 			for (i = nCol1; i <= nCol2; i++)
461 				pTable->aCol[i].RemoveProtected(nRow1, nRow2);
462 	}
463 }
464 
465 void ScTable::CopyToClip(const ScRangeList& rRanges, ScTable* pTable,
466                          bool bKeepScenarioFlags, bool bCloneNoteCaptions)
467 {
468     ScRangeList aRanges(rRanges);
469     for (ScRangePtr p = aRanges.First(); p; p = aRanges.Next())
470     {
471         CopyToClip(p->aStart.Col(), p->aStart.Row(), p->aEnd.Col(), p->aEnd.Row(),
472                    pTable, bKeepScenarioFlags, bCloneNoteCaptions);
473     }
474 }
475 
476 void ScTable::CopyFromClip(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
477 							SCsCOL nDx, SCsROW nDy, sal_uInt16 nInsFlag,
478 							sal_Bool bAsLink, sal_Bool bSkipAttrForEmpty, ScTable* pTable)
479 {
480 	SCCOL i;
481 
482 	if (nCol2 > MAXCOL) nCol2 = MAXCOL;
483 	if (nRow2 > MAXROW) nRow2 = MAXROW;
484 	if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
485 	{
486 		IncRecalcLevel();
487 		for ( i = nCol1; i <= nCol2; i++)
488 			aCol[i].CopyFromClip(nRow1, nRow2, nDy, nInsFlag, bAsLink, bSkipAttrForEmpty, pTable->aCol[i - nDx]);
489 
490 		if ((nInsFlag & IDF_ATTRIB) != 0)
491 		{
492 			if (nRow1==0 && nRow2==MAXROW && pColWidth && pTable->pColWidth)
493 				for (i=nCol1; i<=nCol2; i++)
494 					pColWidth[i] = pTable->pColWidth[i-nDx];
495 
496             if (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pTable->mpRowHeights &&
497 											 pRowFlags && pTable->pRowFlags)
498             {
499                 CopyRowHeight(*pTable, nRow1, nRow2, -nDy);
500                 // Must copy CR_MANUALSIZE bit too, otherwise pRowHeight doesn't make sense
501 				for (SCROW j=nRow1; j<=nRow2; j++)
502 				{
503 					if ( pTable->pRowFlags->GetValue(j-nDy) & CR_MANUALSIZE )
504 						pRowFlags->OrValue( j, CR_MANUALSIZE);
505 					else
506                         pRowFlags->AndValue( j, sal::static_int_cast<sal_uInt8>(~CR_MANUALSIZE));
507 				}
508             }
509 
510 				//
511 				// Zellschutz auf geschuetzter Tabelle nicht setzen
512 				//
513 
514 			if ( IsProtected() && (nInsFlag & IDF_ATTRIB) )
515 			{
516 				ScPatternAttr aPattern(pDocument->GetPool());
517 				aPattern.GetItemSet().Put( ScProtectionAttr( sal_False ) );
518 				ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern );
519 			}
520 		}
521 		DecRecalcLevel();
522 	}
523 }
524 
525 
526 void ScTable::MixData( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
527 							sal_uInt16 nFunction, sal_Bool bSkipEmpty, ScTable* pSrcTab )
528 {
529 	for (SCCOL i=nCol1; i<=nCol2; i++)
530 		aCol[i].MixData( nRow1, nRow2, nFunction, bSkipEmpty, pSrcTab->aCol[i] );
531 }
532 
533 
534 //	Markierung von diesem Dokument
535 void ScTable::MixMarked( const ScMarkData& rMark, sal_uInt16 nFunction,
536 						sal_Bool bSkipEmpty, ScTable* pSrcTab )
537 {
538 	for (SCCOL i=0; i<=MAXCOL; i++)
539 		aCol[i].MixMarked( rMark, nFunction, bSkipEmpty, pSrcTab->aCol[i] );
540 }
541 
542 
543 void ScTable::TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
544 								ScTable* pTransClip, sal_uInt16 nFlags, sal_Bool bAsLink )
545 {
546 	sal_Bool bWasCut = pDocument->IsCutMode();
547 
548 	ScDocument* pDestDoc = pTransClip->pDocument;
549 
550 	for (SCCOL nCol=nCol1; nCol<=nCol2; nCol++)
551 	{
552 		SCROW nRow;
553 		ScBaseCell* pCell;
554 
555 		if ( bAsLink && nFlags == IDF_ALL )
556 		{
557 			//	#68989# with IDF_ALL, also create links (formulas) for empty cells
558 
559 			for ( nRow=nRow1; nRow<=nRow2; nRow++ )
560 			{
561 				//	create simple formula, as in ScColumn::CreateRefCell
562 
563 				ScAddress aDestPos( static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
564 				ScSingleRefData aRef;
565 				aRef.nCol = nCol;
566 				aRef.nRow = nRow;
567 				aRef.nTab = nTab;
568 				aRef.InitFlags();							// -> all absolute
569 				aRef.SetFlag3D(sal_True);
570 				aRef.CalcRelFromAbs( aDestPos );
571 				ScTokenArray aArr;
572 				aArr.AddSingleReference( aRef );
573 
574 				ScBaseCell* pNew = new ScFormulaCell( pDestDoc, aDestPos, &aArr );
575 				pTransClip->PutCell( static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1), pNew );
576 			}
577 		}
578 		else
579 		{
580 			ScColumnIterator aIter( &aCol[nCol], nRow1, nRow2 );
581 			while (aIter.Next( nRow, pCell ))
582 			{
583                 ScAddress aDestPos( static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
584 				ScBaseCell* pNew;
585 				if ( bAsLink )					// Referenz erzeugen ?
586 				{
587 					pNew = aCol[nCol].CreateRefCell( pDestDoc, aDestPos, aIter.GetIndex(), nFlags );
588 				}
589 				else							// kopieren
590 				{
591                     ScAddress aOwnPos( nCol, nRow, nTab );
592 					if (pCell->GetCellType() == CELLTYPE_FORMULA)
593 					{
594                         pNew = pCell->CloneWithNote( aOwnPos, *pDestDoc, aDestPos, SC_CLONECELL_STARTLISTENING );
595 
596 						//	Referenzen drehen
597 						//	bei Cut werden Referenzen spaeter per UpdateTranspose angepasst
598 
599 						if (!bWasCut)
600 							((ScFormulaCell*)pNew)->TransposeReference();
601 					}
602 					else
603                     {
604                         pNew = pCell->CloneWithNote( aOwnPos, *pDestDoc, aDestPos );
605                     }
606 				}
607 				pTransClip->PutCell( static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1), pNew );
608 			}
609 		}
610 
611 		//	Attribute
612 
613 		SCROW nAttrRow1;
614 		SCROW nAttrRow2;
615 		const ScPatternAttr* pPattern;
616 		ScAttrIterator* pAttrIter = aCol[nCol].CreateAttrIterator( nRow1, nRow2 );
617 		while ( (pPattern = pAttrIter->Next( nAttrRow1, nAttrRow2 )) != 0 )
618 		{
619 			if ( !IsDefaultItem( pPattern ) )
620 			{
621 				const SfxItemSet& rSet = pPattern->GetItemSet();
622 				if ( rSet.GetItemState( ATTR_MERGE, sal_False ) == SFX_ITEM_DEFAULT &&
623 					 rSet.GetItemState( ATTR_MERGE_FLAG, sal_False ) == SFX_ITEM_DEFAULT &&
624 					 rSet.GetItemState( ATTR_BORDER, sal_False ) == SFX_ITEM_DEFAULT )
625 				{
626 					// no borders or merge items involved - use pattern as-is
627 					for (nRow = nAttrRow1; nRow<=nAttrRow2; nRow++)
628 						pTransClip->SetPattern( static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1), *pPattern, sal_True );
629 				}
630 				else
631 				{
632 					// transpose borders and merge values, remove merge flags (refreshed after pasting)
633 					ScPatternAttr aNewPattern( *pPattern );
634 					SfxItemSet& rNewSet = aNewPattern.GetItemSet();
635 
636 					const SvxBoxItem& rOldBox = (const SvxBoxItem&)rSet.Get(ATTR_BORDER);
637 					if ( rOldBox.GetTop() || rOldBox.GetBottom() || rOldBox.GetLeft() || rOldBox.GetRight() )
638 					{
639 						SvxBoxItem aNew( ATTR_BORDER );
640 						aNew.SetLine( rOldBox.GetLine( BOX_LINE_TOP ), BOX_LINE_LEFT );
641 						aNew.SetLine( rOldBox.GetLine( BOX_LINE_LEFT ), BOX_LINE_TOP );
642 						aNew.SetLine( rOldBox.GetLine( BOX_LINE_BOTTOM ), BOX_LINE_RIGHT );
643 						aNew.SetLine( rOldBox.GetLine( BOX_LINE_RIGHT ), BOX_LINE_BOTTOM );
644 						aNew.SetDistance( rOldBox.GetDistance( BOX_LINE_TOP ), BOX_LINE_LEFT );
645 						aNew.SetDistance( rOldBox.GetDistance( BOX_LINE_LEFT ), BOX_LINE_TOP );
646 						aNew.SetDistance( rOldBox.GetDistance( BOX_LINE_BOTTOM ), BOX_LINE_RIGHT );
647 						aNew.SetDistance( rOldBox.GetDistance( BOX_LINE_RIGHT ), BOX_LINE_BOTTOM );
648 						rNewSet.Put( aNew );
649 					}
650 
651 					const ScMergeAttr& rOldMerge = (const ScMergeAttr&)rSet.Get(ATTR_MERGE);
652 					if (rOldMerge.IsMerged())
653                         rNewSet.Put( ScMergeAttr( Min(
654                                         static_cast<SCsCOL>(rOldMerge.GetRowMerge()),
655                                         static_cast<SCsCOL>(MAXCOL+1 - (nAttrRow2-nRow1))),
656                                     Min(
657                                         static_cast<SCsROW>(rOldMerge.GetColMerge()),
658                                         static_cast<SCsROW>(MAXROW+1 - (nCol-nCol1)))));
659 					const ScMergeFlagAttr& rOldFlag = (const ScMergeFlagAttr&)rSet.Get(ATTR_MERGE_FLAG);
660 					if (rOldFlag.IsOverlapped())
661 					{
662 						sal_Int16 nNewFlags = rOldFlag.GetValue() & ~( SC_MF_HOR | SC_MF_VER );
663 						if ( nNewFlags )
664 							rNewSet.Put( ScMergeFlagAttr( nNewFlags ) );
665 						else
666 							rNewSet.ClearItem( ATTR_MERGE_FLAG );
667 					}
668 
669 					for (nRow = nAttrRow1; nRow<=nAttrRow2; nRow++)
670                         pTransClip->SetPattern( static_cast<SCCOL>(nRow-nRow1),
671                                 static_cast<SCROW>(nCol-nCol1), aNewPattern, sal_True);
672 				}
673 			}
674 		}
675 
676 		delete pAttrIter;
677 	}
678 }
679 
680 
681 void ScTable::StartAllListeners()
682 {
683 	for (SCCOL i=0; i<=MAXCOL; i++)
684 		aCol[i].StartAllListeners();
685 }
686 
687 
688 void ScTable::StartNeededListeners()
689 {
690 	for (SCCOL i=0; i<=MAXCOL; i++)
691         aCol[i].StartNeededListeners();
692 }
693 
694 
695 void ScTable::BroadcastInArea( SCCOL nCol1, SCROW nRow1,
696 		SCCOL nCol2, SCROW nRow2 )
697 {
698 	if (nCol2 > MAXCOL) nCol2 = MAXCOL;
699 	if (nRow2 > MAXROW) nRow2 = MAXROW;
700 	if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
701 		for (SCCOL i = nCol1; i <= nCol2; i++)
702 			aCol[i].BroadcastInArea( nRow1, nRow2 );
703 }
704 
705 
706 void ScTable::StartListeningInArea( SCCOL nCol1, SCROW nRow1,
707 		SCCOL nCol2, SCROW nRow2 )
708 {
709 	if (nCol2 > MAXCOL) nCol2 = MAXCOL;
710 	if (nRow2 > MAXROW) nRow2 = MAXROW;
711 	if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
712 		for (SCCOL i = nCol1; i <= nCol2; i++)
713 			aCol[i].StartListeningInArea( nRow1, nRow2 );
714 }
715 
716 
717 void ScTable::CopyToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
718 							sal_uInt16 nFlags, sal_Bool bMarked, ScTable* pDestTab,
719 							const ScMarkData* pMarkData,
720 							sal_Bool bAsLink, sal_Bool bColRowFlags)
721 {
722 	if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
723 	{
724 		if (nFlags)
725 			for (SCCOL i = nCol1; i <= nCol2; i++)
726 				aCol[i].CopyToColumn(nRow1, nRow2, nFlags, bMarked,
727 								pDestTab->aCol[i], pMarkData, bAsLink);
728 
729 		if (bColRowFlags)		// Spaltenbreiten/Zeilenhoehen/Flags
730 		{
731 			//	Charts muessen beim Ein-/Ausblenden angepasst werden
732 			ScChartListenerCollection* pCharts = pDestTab->pDocument->GetChartListenerCollection();
733 
734             bool bFlagChange = false;
735 
736 			sal_Bool bWidth  = (nRow1==0 && nRow2==MAXROW && pColWidth && pDestTab->pColWidth);
737             sal_Bool bHeight = (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pDestTab->mpRowHeights);
738 
739 			if (bWidth||bHeight)
740 			{
741 				pDestTab->IncRecalcLevel();
742 
743 				if (bWidth)
744                 {
745 					for (SCCOL i=nCol1; i<=nCol2; i++)
746 					{
747                         bool bThisHidden = ColHidden(i);
748                         bool bHiddenChange = (pDestTab->ColHidden(i) != bThisHidden);
749                         bool bChange = bHiddenChange || (pDestTab->pColWidth[i] != pColWidth[i]);
750 						pDestTab->pColWidth[i] = pColWidth[i];
751 						pDestTab->pColFlags[i] = pColFlags[i];
752                         pDestTab->SetColHidden(i, i, bThisHidden);
753 						//!	Aenderungen zusammenfassen?
754                         if (bHiddenChange && pCharts)
755                             pCharts->SetRangeDirty(ScRange( i, 0, nTab, i, MAXROW, nTab ));
756 
757                         if (bChange)
758                             bFlagChange = true;
759 					}
760                     pDestTab->SetColManualBreaks( maColManualBreaks);
761                 }
762 
763 				if (bHeight)
764 				{
765                     bool bChange = pDestTab->GetRowHeight(nRow1, nRow2) != GetRowHeight(nRow1, nRow2);
766 
767                     if (bChange)
768                         bFlagChange = true;
769 
770                     pDestTab->CopyRowHeight(*this, nRow1, nRow2, 0);
771                     pDestTab->pRowFlags->CopyFrom(*pRowFlags, nRow1, nRow2);
772 
773                     // Hidden flags.
774                     // #i116164# Collect information first, then apply the changes,
775                     // so RowHidden doesn't rebuild the tree for each row range.
776                     std::vector<ScShowRowsEntry> aEntries;
777                     for (SCROW i = nRow1; i <= nRow2; ++i)
778                     {
779                         SCROW nThisLastRow, nDestLastRow;
780                         bool bThisHidden = RowHidden(i, NULL, &nThisLastRow);
781                         bool bDestHidden = pDestTab->RowHidden(i, NULL, &nDestLastRow);
782 
783                         // If the segment sizes differ, we take the shorter segment of the two.
784                         SCROW nLastRow = ::std::min(nThisLastRow, nDestLastRow);
785                         if (nLastRow >= nRow2)
786                             // the last row shouldn't exceed the upper bound the caller specified.
787                             nLastRow = nRow2;
788 
789                         //pDestTab->SetRowHidden(i, nLastRow, bThisHidden);
790                         aEntries.push_back(ScShowRowsEntry(i, nLastRow, !bThisHidden));
791 
792                         bool bThisHiddenChange = (bThisHidden != bDestHidden);
793                         if (bThisHiddenChange && pCharts)
794                         {
795                             // Hidden flags differ.
796                             pCharts->SetRangeDirty(ScRange(0, i, nTab, MAXCOL, nLastRow, nTab));
797                         }
798 
799                         if (bThisHiddenChange)
800                             bFlagChange = true;
801 
802                         // Jump to the last row of the identical flag segment.
803                         i = nLastRow;
804 					}
805 
806                     std::vector<ScShowRowsEntry>::const_iterator aEnd = aEntries.end();
807                     std::vector<ScShowRowsEntry>::const_iterator aIter = aEntries.begin();
808                     if ( aIter != aEnd )
809                     {
810                         pDestTab->mpHiddenRows->setInsertFromBack(true);    // important for undo document
811                         while (aIter != aEnd)
812                         {
813                             pDestTab->SetRowHidden(aIter->mnRow1, aIter->mnRow2, !aIter->mbShow);
814                             ++aIter;
815                         }
816                         pDestTab->mpHiddenRows->setInsertFromBack(false);
817                     }
818 
819                     // Filtered flags.
820                     for (SCROW i = nRow1; i <= nRow2; ++i)
821                     {
822                         SCROW nLastRow;
823                         bool bFiltered = RowFiltered(i, NULL, &nLastRow);
824                         if (nLastRow >= nRow2)
825                             // the last row shouldn't exceed the upper bound the caller specified.
826                             nLastRow = nRow2;
827                         pDestTab->SetRowFiltered(i, nLastRow, bFiltered);
828                         i = nLastRow;
829                     }
830                     pDestTab->SetRowManualBreaks( maRowManualBreaks);
831 				}
832 				pDestTab->DecRecalcLevel();
833 			}
834 
835             if (bFlagChange)
836                 pDestTab->InvalidatePageBreaks();
837 
838 			pDestTab->SetOutlineTable( pOutlineTable );		// auch nur wenn bColRowFlags
839 		}
840 	}
841 }
842 
843 
844 void ScTable::UndoToTable(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
845 							sal_uInt16 nFlags, sal_Bool bMarked, ScTable* pDestTab,
846 							const ScMarkData* pMarkData)
847 {
848 	if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
849 	{
850 		sal_Bool bWidth  = (nRow1==0 && nRow2==MAXROW && pColWidth && pDestTab->pColWidth);
851         sal_Bool bHeight = (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pDestTab->mpRowHeights);
852 
853 		if (bWidth||bHeight)
854 			IncRecalcLevel();
855 
856 		for ( SCCOL i = 0; i <= MAXCOL; i++)
857 		{
858 			if ( i >= nCol1 && i <= nCol2 )
859 				aCol[i].UndoToColumn(nRow1, nRow2, nFlags, bMarked, pDestTab->aCol[i],
860 										pMarkData);
861 			else
862 				aCol[i].CopyToColumn(0, MAXROW, IDF_FORMULA, sal_False, pDestTab->aCol[i]);
863 		}
864 
865 		if (bWidth||bHeight)
866 		{
867             if (bWidth)
868             {
869                 for (SCCOL i=nCol1; i<=nCol2; i++)
870                     pDestTab->pColWidth[i] = pColWidth[i];
871                 pDestTab->SetColManualBreaks( maColManualBreaks);
872             }
873             if (bHeight)
874             {
875                 pDestTab->CopyRowHeight(*this, nRow1, nRow2, 0);
876                 pDestTab->SetRowManualBreaks( maRowManualBreaks);
877             }
878             DecRecalcLevel();
879 		}
880 	}
881 }
882 
883 
884 void ScTable::CopyUpdated( const ScTable* pPosTab, ScTable* pDestTab ) const
885 {
886 	for (SCCOL i=0; i<=MAXCOL; i++)
887 		aCol[i].CopyUpdated( pPosTab->aCol[i], pDestTab->aCol[i] );
888 }
889 
890 void ScTable::InvalidateTableArea()
891 {
892     bTableAreaValid = sal_False;
893 }
894 
895 void ScTable::InvalidatePageBreaks()
896 {
897     mbPageBreaksValid = false;
898 }
899 
900 void ScTable::CopyScenarioTo( ScTable* pDestTab ) const
901 {
902 	DBG_ASSERT( bScenario, "bScenario == FALSE" );
903 
904 	for (SCCOL i=0; i<=MAXCOL; i++)
905 		aCol[i].CopyScenarioTo( pDestTab->aCol[i] );
906 }
907 
908 void ScTable::CopyScenarioFrom( const ScTable* pSrcTab )
909 {
910 	DBG_ASSERT( bScenario, "bScenario == FALSE" );
911 
912 	for (SCCOL i=0; i<=MAXCOL; i++)
913 		aCol[i].CopyScenarioFrom( pSrcTab->aCol[i] );
914 }
915 
916 void ScTable::MarkScenarioIn( ScMarkData& rDestMark, sal_uInt16 nNeededBits ) const
917 {
918 	DBG_ASSERT( bScenario, "bScenario == FALSE" );
919 
920 	if ( ( nScenarioFlags & nNeededBits ) != nNeededBits )	// alle Bits gesetzt?
921 		return;
922 
923 	for (SCCOL i=0; i<=MAXCOL; i++)
924 		aCol[i].MarkScenarioIn( rDestMark );
925 }
926 
927 sal_Bool ScTable::HasScenarioRange( const ScRange& rRange ) const
928 {
929 	DBG_ASSERT( bScenario, "bScenario == FALSE" );
930 
931 //	ScMarkData aMark;
932 //	MarkScenarioIn( aMark, 0 );				//! Bits als Parameter von HasScenarioRange?
933 //	return aMark.IsAllMarked( rRange );
934 
935 	ScRange aTabRange = rRange;
936 	aTabRange.aStart.SetTab( nTab );
937 	aTabRange.aEnd.SetTab( nTab );
938 
939 	const ScRangeList* pList = GetScenarioRanges();
940 //	return ( pList && pList->Find( aTabRange ) );
941 
942 	if (pList)
943 	{
944 		sal_uLong nCount = pList->Count();
945 		for ( sal_uLong j = 0; j < nCount; j++ )
946 		{
947 			ScRange* pR = pList->GetObject( j );
948 			if ( pR->Intersects( aTabRange ) )
949 				return sal_True;
950 		}
951 	}
952 
953 	return sal_False;
954 }
955 
956 void ScTable::InvalidateScenarioRanges()
957 {
958 	delete pScenarioRanges;
959 	pScenarioRanges = NULL;
960 }
961 
962 const ScRangeList* ScTable::GetScenarioRanges() const
963 {
964 	DBG_ASSERT( bScenario, "bScenario == FALSE" );
965 
966 	if (!pScenarioRanges)
967 	{
968 		((ScTable*)this)->pScenarioRanges = new ScRangeList;
969 		ScMarkData aMark;
970 		MarkScenarioIn( aMark, 0 );		// immer
971 		aMark.FillRangeListWithMarks( pScenarioRanges, sal_False );
972 	}
973 	return pScenarioRanges;
974 }
975 
976 sal_Bool ScTable::TestCopyScenarioTo( const ScTable* pDestTab ) const
977 {
978 	DBG_ASSERT( bScenario, "bScenario == FALSE" );
979 
980 	if (!pDestTab->IsProtected())
981 		return sal_True;
982 
983 	sal_Bool bOk = sal_True;
984 	for (SCCOL i=0; i<=MAXCOL && bOk; i++)
985 		bOk = aCol[i].TestCopyScenarioTo( pDestTab->aCol[i] );
986 	return bOk;
987 }
988 
989 void ScTable::PutCell( SCCOL nCol, SCROW nRow, ScBaseCell* pCell )
990 {
991 	if (ValidColRow(nCol,nRow))
992 	{
993 		if (pCell)
994 			aCol[nCol].Insert( nRow, pCell );
995 		else
996 			aCol[nCol].Delete( nRow );
997 	}
998 }
999 
1000 
1001 void ScTable::PutCell( SCCOL nCol, SCROW nRow, sal_uLong nFormatIndex, ScBaseCell* pCell )
1002 {
1003 	if (ValidColRow(nCol,nRow))
1004 	{
1005 		if (pCell)
1006 			aCol[nCol].Insert( nRow, nFormatIndex, pCell );
1007 		else
1008 			aCol[nCol].Delete( nRow );
1009 	}
1010 }
1011 
1012 
1013 void ScTable::PutCell( const ScAddress& rPos, ScBaseCell* pCell )
1014 {
1015 	if (pCell)
1016 		aCol[rPos.Col()].Insert( rPos.Row(), pCell );
1017 	else
1018 		aCol[rPos.Col()].Delete( rPos.Row() );
1019 }
1020 
1021 
1022 //UNUSED2009-05 void ScTable::PutCell( const ScAddress& rPos, sal_uLong nFormatIndex, ScBaseCell* pCell )
1023 //UNUSED2009-05 {
1024 //UNUSED2009-05     if (pCell)
1025 //UNUSED2009-05         aCol[rPos.Col()].Insert( rPos.Row(), nFormatIndex, pCell );
1026 //UNUSED2009-05     else
1027 //UNUSED2009-05         aCol[rPos.Col()].Delete( rPos.Row() );
1028 //UNUSED2009-05 }
1029 
1030 
1031 sal_Bool ScTable::SetString( SCCOL nCol, SCROW nRow, SCTAB nTabP, const String& rString,
1032                          SvNumberFormatter* pFormatter, bool bDetectNumberFormat )
1033 {
1034 	if (ValidColRow(nCol,nRow))
1035         return aCol[nCol].SetString(
1036             nRow, nTabP, rString, pDocument->GetAddressConvention(), pFormatter, bDetectNumberFormat );
1037 	else
1038 		return sal_False;
1039 }
1040 
1041 
1042 void ScTable::SetValue( SCCOL nCol, SCROW nRow, const double& rVal )
1043 {
1044 	if (ValidColRow(nCol, nRow))
1045 		aCol[nCol].SetValue( nRow, rVal );
1046 }
1047 
1048 
1049 void ScTable::GetString( SCCOL nCol, SCROW nRow, String& rString )
1050 {
1051 	if (ValidColRow(nCol,nRow))
1052 		aCol[nCol].GetString( nRow, rString );
1053 	else
1054 		rString.Erase();
1055 }
1056 
1057 void  ScTable::FillDPCache( ScDPTableDataCache * pCache, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow )
1058 {
1059     for ( sal_uInt16 nCol = nStartCol; nCol <= nEndCol; nCol++ )
1060         if( ValidCol( nCol ) )
1061             aCol[nCol].FillDPCache( pCache, nCol - nStartCol, nStartRow, nEndRow );
1062 }
1063 
1064 
1065 void ScTable::GetInputString( SCCOL nCol, SCROW nRow, String& rString )
1066 {
1067 	if (ValidColRow(nCol,nRow))
1068 		aCol[nCol].GetInputString( nRow, rString );
1069 	else
1070 		rString.Erase();
1071 }
1072 
1073 
1074 double ScTable::GetValue( SCCOL nCol, SCROW nRow )
1075 {
1076 	if (ValidColRow( nCol, nRow ))
1077 		return aCol[nCol].GetValue( nRow );
1078 	return 0.0;
1079 }
1080 
1081 
1082 void ScTable::GetFormula( SCCOL nCol, SCROW nRow, String& rFormula,
1083 						  sal_Bool bAsciiExport )
1084 {
1085 	if (ValidColRow(nCol,nRow))
1086 		aCol[nCol].GetFormula( nRow, rFormula, bAsciiExport );
1087 	else
1088 		rFormula.Erase();
1089 }
1090 
1091 
1092 ScPostIt* ScTable::GetNote( SCCOL nCol, SCROW nRow )
1093 {
1094 	return ValidColRow( nCol, nRow ) ? aCol[ nCol ].GetNote( nRow ) : 0;
1095 }
1096 
1097 
1098 void ScTable::TakeNote( SCCOL nCol, SCROW nRow, ScPostIt*& rpNote )
1099 {
1100 	if( ValidColRow( nCol, nRow ) )
1101     {
1102         aCol[ nCol ].TakeNote( nRow, rpNote );
1103         if( rpNote && rpNote->GetNoteData().mxInitData.get() )
1104         {
1105             if( !mxUninitNotes.get() )
1106                 mxUninitNotes.reset( new ScAddress2DVec );
1107             mxUninitNotes->push_back( ScAddress2D( nCol, nRow ) );
1108         }
1109     }
1110     else
1111         DELETEZ( rpNote );
1112 }
1113 
1114 
1115 ScPostIt* ScTable::ReleaseNote( SCCOL nCol, SCROW nRow )
1116 {
1117 	return ValidColRow( nCol, nRow ) ? aCol[ nCol ].ReleaseNote( nRow ) : 0;
1118 }
1119 
1120 
1121 void ScTable::DeleteNote( SCCOL nCol, SCROW nRow )
1122 {
1123 	if( ValidColRow( nCol, nRow ) )
1124         aCol[ nCol ].DeleteNote( nRow );
1125 }
1126 
1127 
1128 void ScTable::InitializeNoteCaptions( bool bForced )
1129 {
1130     if( mxUninitNotes.get() && (bForced || pDocument->IsUndoEnabled()) )
1131     {
1132         for( ScAddress2DVec::iterator aIt = mxUninitNotes->begin(), aEnd = mxUninitNotes->end(); aIt != aEnd; ++aIt )
1133             if( ScPostIt* pNote = GetNote( aIt->first, aIt->second ) )
1134                 pNote->GetOrCreateCaption( ScAddress( aIt->first, aIt->second, nTab ) );
1135         mxUninitNotes.reset();
1136     }
1137 }
1138 
1139 CellType ScTable::GetCellType( SCCOL nCol, SCROW nRow ) const
1140 {
1141 	if (ValidColRow( nCol, nRow ))
1142 		return aCol[nCol].GetCellType( nRow );
1143 	return CELLTYPE_NONE;
1144 }
1145 
1146 
1147 ScBaseCell* ScTable::GetCell( SCCOL nCol, SCROW nRow ) const
1148 {
1149 	if (ValidColRow( nCol, nRow ))
1150 		return aCol[nCol].GetCell( nRow );
1151 
1152 	DBG_ERROR("GetCell ausserhalb");
1153 	return NULL;
1154 }
1155 
1156 void ScTable::GetFirstDataPos(SCCOL& rCol, SCROW& rRow) const
1157 {
1158     rCol = 0;
1159     rRow = MAXROW+1;
1160     while (aCol[rCol].IsEmptyData() && rCol < MAXCOL)
1161         ++rCol;
1162     SCCOL nCol = rCol;
1163     while (nCol <= MAXCOL && rRow > 0)
1164     {
1165         if (!aCol[nCol].IsEmptyData())
1166             rRow = ::std::min( rRow, aCol[nCol].GetFirstDataPos());
1167         ++nCol;
1168     }
1169 }
1170 
1171 void ScTable::GetLastDataPos(SCCOL& rCol, SCROW& rRow) const
1172 {
1173     rCol = MAXCOL;
1174     rRow = 0;
1175     while (aCol[rCol].IsEmptyData() && (rCol > 0))
1176         rCol--;
1177     SCCOL nCol = rCol;
1178     while (nCol >= 0 && rRow < MAXROW)
1179         rRow = ::std::max( rRow, aCol[nCol--].GetLastDataPos());
1180 }
1181 
1182 
1183 sal_Bool ScTable::HasData( SCCOL nCol, SCROW nRow )
1184 {
1185 	if (ValidColRow(nCol,nRow))
1186 		return aCol[nCol].HasDataAt( nRow );
1187 	else
1188 		return sal_False;
1189 }
1190 
1191 
1192 sal_Bool ScTable::HasStringData( SCCOL nCol, SCROW nRow )
1193 {
1194 	if (ValidColRow(nCol,nRow))
1195 		return aCol[nCol].HasStringData( nRow );
1196 	else
1197 		return sal_False;
1198 }
1199 
1200 
1201 sal_Bool ScTable::HasValueData( SCCOL nCol, SCROW nRow )
1202 {
1203 	if (ValidColRow(nCol,nRow))
1204 		return aCol[nCol].HasValueData( nRow );
1205 	else
1206 		return sal_False;
1207 }
1208 
1209 
1210 sal_Bool ScTable::HasStringCells( SCCOL nStartCol, SCROW nStartRow,
1211 								SCCOL nEndCol, SCROW nEndRow ) const
1212 {
1213 	if ( ValidCol(nEndCol) )
1214 		for ( SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++ )
1215 			if (aCol[nCol].HasStringCells(nStartRow, nEndRow))
1216 				return sal_True;
1217 
1218 	return sal_False;
1219 }
1220 
1221 
1222 //UNUSED2008-05  sal_uInt16 ScTable::GetErrCode( SCCOL nCol, SCROW nRow ) const
1223 //UNUSED2008-05  {
1224 //UNUSED2008-05      if (ValidColRow( nCol, nRow ))
1225 //UNUSED2008-05          return aCol[nCol].GetErrCode( nRow );
1226 //UNUSED2008-05      return 0;
1227 //UNUSED2008-05  }
1228 
1229 
1230 void ScTable::SetDirtyVar()
1231 {
1232 	for (SCCOL i=0; i<=MAXCOL; i++)
1233 		aCol[i].SetDirtyVar();
1234 }
1235 
1236 
1237 void ScTable::SetDirty()
1238 {
1239 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1240 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1241 	for (SCCOL i=0; i<=MAXCOL; i++)
1242 		aCol[i].SetDirty();
1243 	pDocument->SetAutoCalc( bOldAutoCalc );
1244 }
1245 
1246 
1247 void ScTable::SetDirty( const ScRange& rRange )
1248 {
1249 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1250 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1251 	SCCOL nCol2 = rRange.aEnd.Col();
1252 	for (SCCOL i=rRange.aStart.Col(); i<=nCol2; i++)
1253 		aCol[i].SetDirty( rRange );
1254 	pDocument->SetAutoCalc( bOldAutoCalc );
1255 }
1256 
1257 
1258 void ScTable::SetTableOpDirty( const ScRange& rRange )
1259 {
1260 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1261 	pDocument->SetAutoCalc( sal_False );	// no multiple recalculation
1262 	SCCOL nCol2 = rRange.aEnd.Col();
1263 	for (SCCOL i=rRange.aStart.Col(); i<=nCol2; i++)
1264 		aCol[i].SetTableOpDirty( rRange );
1265 	pDocument->SetAutoCalc( bOldAutoCalc );
1266 }
1267 
1268 
1269 void ScTable::SetDirtyAfterLoad()
1270 {
1271 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1272 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1273 	for (SCCOL i=0; i<=MAXCOL; i++)
1274 		aCol[i].SetDirtyAfterLoad();
1275 	pDocument->SetAutoCalc( bOldAutoCalc );
1276 }
1277 
1278 
1279 void ScTable::SetRelNameDirty()
1280 {
1281 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1282 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1283 	for (SCCOL i=0; i<=MAXCOL; i++)
1284 		aCol[i].SetRelNameDirty();
1285 	pDocument->SetAutoCalc( bOldAutoCalc );
1286 }
1287 
1288 
1289 void ScTable::SetLoadingMedium(bool bLoading)
1290 {
1291     mpRowHeights->enableTreeSearch(!bLoading);
1292 
1293     // When loading a medium, prefer inserting row heights from the back
1294     // position since the row heights are stored and read in ascending order
1295     // during import.
1296     mpRowHeights->setInsertFromBack(bLoading);
1297 }
1298 
1299 
1300 void ScTable::CalcAll()
1301 {
1302 	for (SCCOL i=0; i<=MAXCOL; i++) aCol[i].CalcAll();
1303 }
1304 
1305 
1306 void ScTable::CompileAll()
1307 {
1308 	for (SCCOL i=0; i <= MAXCOL; i++) aCol[i].CompileAll();
1309 }
1310 
1311 
1312 void ScTable::CompileXML( ScProgress& rProgress )
1313 {
1314 	for (SCCOL i=0; i <= MAXCOL; i++)
1315 	{
1316 		aCol[i].CompileXML( rProgress );
1317 	}
1318 }
1319 
1320 void ScTable::CalcAfterLoad()
1321 {
1322 	for (SCCOL i=0; i <= MAXCOL; i++) aCol[i].CalcAfterLoad();
1323 }
1324 
1325 
1326 void ScTable::ResetChanged( const ScRange& rRange )
1327 {
1328 	SCCOL nStartCol = rRange.aStart.Col();
1329 	SCROW nStartRow = rRange.aStart.Row();
1330 	SCCOL nEndCol = rRange.aEnd.Col();
1331 	SCROW nEndRow = rRange.aEnd.Row();
1332 
1333 	for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
1334 		aCol[nCol].ResetChanged(nStartRow, nEndRow);
1335 }
1336 
1337 //	Attribute
1338 
1339 const SfxPoolItem* ScTable::GetAttr( SCCOL nCol, SCROW nRow, sal_uInt16 nWhich ) const
1340 {
1341 	if (ValidColRow(nCol,nRow))
1342 		return aCol[nCol].GetAttr( nRow, nWhich );
1343 	else
1344 		return NULL;
1345 }
1346 
1347 
1348 sal_uLong ScTable::GetNumberFormat( SCCOL nCol, SCROW nRow ) const
1349 {
1350 	if (ValidColRow(nCol,nRow))
1351 		return aCol[nCol].GetNumberFormat( nRow );
1352 	else
1353 		return 0;
1354 }
1355 
1356 
1357 const ScPatternAttr* ScTable::GetPattern( SCCOL nCol, SCROW nRow ) const
1358 {
1359 	if (ValidColRow(nCol,nRow))
1360 		return aCol[nCol].GetPattern( nRow );
1361 	else
1362     {
1363         DBG_ERROR("wrong column or row");
1364         return pDocument->GetDefPattern();      // for safety
1365     }
1366 }
1367 
1368 
1369 const ScPatternAttr* ScTable::GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow ) const
1370 {
1371     if ( ValidColRow( nCol, nStartRow ) && ValidRow( nEndRow ) && (nStartRow <= nEndRow) )
1372         return aCol[nCol].GetMostUsedPattern( nStartRow, nEndRow );
1373     else
1374         return NULL;
1375 }
1376 
1377 
1378 bool ScTable::HasAttrib( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sal_uInt16 nMask ) const
1379 {
1380 	bool bFound = false;
1381 	for (SCCOL i=nCol1; i<=nCol2 && !bFound; i++)
1382 		bFound |= aCol[i].HasAttrib( nRow1, nRow2, nMask );
1383 	return bFound;
1384 }
1385 
1386 
1387 //UNUSED2009-05 sal_Bool ScTable::HasLines( const ScRange& rRange, Rectangle& rSizes ) const
1388 //UNUSED2009-05 {
1389 //UNUSED2009-05     SCCOL nCol1 = rRange.aStart.Col();
1390 //UNUSED2009-05     SCROW nRow1 = rRange.aStart.Row();
1391 //UNUSED2009-05     SCCOL nCol2 = rRange.aEnd.Col();
1392 //UNUSED2009-05     SCROW nRow2 = rRange.aEnd.Row();
1393 //UNUSED2009-05     PutInOrder( nCol1, nCol2 );
1394 //UNUSED2009-05     PutInOrder( nRow1, nRow2 );
1395 //UNUSED2009-05
1396 //UNUSED2009-05     sal_Bool bFound = sal_False;
1397 //UNUSED2009-05     for (SCCOL i=nCol1; i<=nCol2; i++)
1398 //UNUSED2009-05         if (aCol[i].HasLines( nRow1, nRow2, rSizes, (i==nCol1), (i==nCol2) ))
1399 //UNUSED2009-05             bFound = sal_True;
1400 //UNUSED2009-05
1401 //UNUSED2009-05     return bFound;
1402 //UNUSED2009-05 }
1403 
1404 
1405 sal_Bool ScTable::HasAttribSelection( const ScMarkData& rMark, sal_uInt16 nMask ) const
1406 {
1407 	sal_Bool bFound=sal_False;
1408 	for (SCCOL i=0; i<=MAXCOL && !bFound; i++)
1409 		bFound |= aCol[i].HasAttribSelection( rMark, nMask );
1410 	return bFound;
1411 }
1412 
1413 
1414 sal_Bool ScTable::ExtendMerge( SCCOL nStartCol, SCROW nStartRow,
1415 						   SCCOL& rEndCol, SCROW& rEndRow,
1416 						   sal_Bool bRefresh, sal_Bool bAttrs )
1417 {
1418     if (!(ValidCol(nStartCol) && ValidCol(rEndCol)))
1419     {
1420         DBG_ERRORFILE("ScTable::ExtendMerge: invalid column number");
1421         return sal_False;
1422     }
1423 	sal_Bool bFound=sal_False;
1424 	SCCOL nOldEndX = rEndCol;
1425 	SCROW nOldEndY = rEndRow;
1426 	for (SCCOL i=nStartCol; i<=nOldEndX; i++)
1427 		bFound |= aCol[i].ExtendMerge( i, nStartRow, nOldEndY, rEndCol, rEndRow, bRefresh, bAttrs );
1428 	return bFound;
1429 }
1430 
1431 
1432 sal_Bool ScTable::IsBlockEmpty( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bIgnoreNotes ) const
1433 {
1434     if (!(ValidCol(nCol1) && ValidCol(nCol2)))
1435     {
1436         DBG_ERRORFILE("ScTable::IsBlockEmpty: invalid column number");
1437         return sal_False;
1438     }
1439 	sal_Bool bEmpty = sal_True;
1440 	for (SCCOL i=nCol1; i<=nCol2 && bEmpty; i++)
1441 		bEmpty = aCol[i].IsEmptyBlock( nRow1, nRow2, bIgnoreNotes );
1442 	return bEmpty;
1443 }
1444 
1445 SCSIZE ScTable::FillMaxRot( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2,
1446 							SCCOL nCol, SCROW nAttrRow1, SCROW nAttrRow2, SCSIZE nArrY,
1447 							const ScPatternAttr* pPattern, const SfxItemSet* pCondSet )
1448 {
1449 	//	Rueckgabe = neues nArrY
1450 
1451 	sal_uInt8 nRotDir = pPattern->GetRotateDir( pCondSet );
1452 	if ( nRotDir != SC_ROTDIR_NONE )
1453 	{
1454 		sal_Bool bHit = sal_True;
1455 		if ( nCol+1 < nX1 )								// column to the left
1456 			bHit = ( nRotDir != SC_ROTDIR_LEFT );
1457 		else if ( nCol > nX2+1 )						// column to the right
1458 			bHit = ( nRotDir != SC_ROTDIR_RIGHT );		// SC_ROTDIR_STANDARD may now also be extended to the left
1459 
1460 		if ( bHit )
1461 		{
1462 			double nFactor = 0.0;
1463 			if ( nCol > nX2+1 )
1464 			{
1465 				long nRotVal = ((const SfxInt32Item&) pPattern->
1466 						GetItem( ATTR_ROTATE_VALUE, pCondSet )).GetValue();
1467 				double nRealOrient = nRotVal * F_PI18000;	// 1/100 Grad
1468 				double nCos = cos( nRealOrient );
1469 				double nSin = sin( nRealOrient );
1470 				//!	begrenzen !!!
1471 				//!	zusaetzlich Faktor fuer unterschiedliche PPT X/Y !!!
1472 
1473 				//	bei SC_ROTDIR_LEFT kommt immer ein negativer Wert heraus,
1474 				//	wenn der Modus beruecksichtigt wird
1475 				nFactor = -fabs( nCos / nSin );
1476 			}
1477 
1478 			for ( SCROW nRow = nAttrRow1; nRow <= nAttrRow2; nRow++ )
1479 			{
1480                 if (!RowHidden(nRow))
1481 				{
1482 					sal_Bool bHitOne = sal_True;
1483 					if ( nCol > nX2+1 )
1484 					{
1485 						// reicht die gedrehte Zelle bis in den sichtbaren Bereich?
1486 
1487 						SCCOL nTouchedCol = nCol;
1488                         long nWidth = static_cast<long>(mpRowHeights->getValue(nRow) * nFactor);
1489 						DBG_ASSERT(nWidth <= 0, "Richtung falsch");
1490 						while ( nWidth < 0 && nTouchedCol > 0 )
1491 						{
1492 							--nTouchedCol;
1493 							nWidth += GetColWidth( nTouchedCol );
1494 						}
1495 						if ( nTouchedCol > nX2 )
1496 							bHitOne = sal_False;
1497 					}
1498 
1499 					if (bHitOne)
1500 					{
1501 						while ( nArrY<nArrCount && pRowInfo[nArrY].nRowNo < nRow )
1502 							++nArrY;
1503 						if ( nArrY<nArrCount && pRowInfo[nArrY].nRowNo == nRow )
1504 							pRowInfo[nArrY].nRotMaxCol = nCol;
1505 					}
1506 				}
1507 			}
1508 		}
1509 	}
1510 
1511 	return nArrY;
1512 }
1513 
1514 void ScTable::FindMaxRotCol( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCCOL nX2 )
1515 {
1516     if ( !pColWidth || !mpRowHeights || !pColFlags || !pRowFlags )
1517 	{
1518 		DBG_ERROR( "Spalten-/Zeileninfo fehlt" );
1519 		return;
1520 	}
1521 
1522 	//	nRotMaxCol ist auf SC_ROTMAX_NONE initialisiert, nRowNo ist schon gesetzt
1523 
1524 	SCROW nY1 = pRowInfo[0].nRowNo;
1525 	SCROW nY2 = pRowInfo[nArrCount-1].nRowNo;
1526 
1527 	for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
1528 	{
1529         if (!ColHidden(nCol))
1530 		{
1531 			SCSIZE nArrY = 0;
1532 			ScDocAttrIterator aIter( pDocument, nTab, nCol, nY1, nCol, nY2 );
1533 			SCCOL nAttrCol;
1534             SCROW nAttrRow1, nAttrRow2;
1535 			const ScPatternAttr* pPattern = aIter.GetNext( nAttrCol, nAttrRow1, nAttrRow2 );
1536 			while ( pPattern )
1537 			{
1538 				const SfxPoolItem* pCondItem;
1539 				if ( pPattern->GetItemSet().GetItemState( ATTR_CONDITIONAL, sal_True, &pCondItem )
1540 						== SFX_ITEM_SET )
1541 				{
1542 					//	alle Formate durchgehen, damit die Zellen nicht einzeln
1543 					//	angeschaut werden muessen
1544 
1545 					sal_uLong nIndex = ((const SfxUInt32Item*)pCondItem)->GetValue();
1546 					ScConditionalFormatList* pList = pDocument->GetCondFormList();
1547 					ScStyleSheetPool* pStylePool = pDocument->GetStyleSheetPool();
1548 					if (pList && pStylePool && nIndex)
1549 					{
1550 						const ScConditionalFormat* pFormat = pList->GetFormat(nIndex);
1551 						if ( pFormat )
1552 						{
1553 							sal_uInt16 nEntryCount = pFormat->Count();
1554 							for (sal_uInt16 nEntry=0; nEntry<nEntryCount; nEntry++)
1555 							{
1556                                 String aStyleName = pFormat->GetEntry(nEntry)->GetStyle();
1557                                 if (aStyleName.Len())
1558 								{
1559 									SfxStyleSheetBase* pStyleSheet =
1560                                             pStylePool->Find( aStyleName, SFX_STYLE_FAMILY_PARA );
1561 									if ( pStyleSheet )
1562 									{
1563 										FillMaxRot( pRowInfo, nArrCount, nX1, nX2,
1564 													nCol, nAttrRow1, nAttrRow2,
1565 													nArrY, pPattern, &pStyleSheet->GetItemSet() );
1566 										//	nArrY nicht veraendern
1567 									}
1568 								}
1569 							}
1570 						}
1571 					}
1572 				}
1573 
1574 				nArrY = FillMaxRot( pRowInfo, nArrCount, nX1, nX2,
1575 									nCol, nAttrRow1, nAttrRow2,
1576 									nArrY, pPattern, NULL );
1577 
1578 				pPattern = aIter.GetNext( nAttrCol, nAttrRow1, nAttrRow2 );
1579 			}
1580 		}
1581 	}
1582 }
1583 
1584 sal_Bool ScTable::HasBlockMatrixFragment( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) const
1585 {
1586 	// nix:0, mitte:1, unten:2, links:4, oben:8, rechts:16, offen:32
1587 	sal_uInt16 nEdges;
1588 
1589 	if ( nCol1 == nCol2 )
1590 	{	// linke und rechte Spalte
1591 		const sal_uInt16 n = 4 | 16;
1592 		nEdges = aCol[nCol1].GetBlockMatrixEdges( nRow1, nRow2, n );
1593 		// nicht (4 und 16) oder 1 oder 32
1594 		if ( nEdges && (((nEdges & n) != n) || (nEdges & 33)) )
1595 			return sal_True;		// linke oder rechte Kante fehlt oder offen
1596 	}
1597 	else
1598 	{	// linke Spalte
1599 		nEdges = aCol[nCol1].GetBlockMatrixEdges( nRow1, nRow2, 4 );
1600 		// nicht 4 oder 1 oder 32
1601 		if ( nEdges && (((nEdges & 4) != 4) || (nEdges & 33)) )
1602 			return sal_True;		// linke Kante fehlt oder offen
1603 		// rechte Spalte
1604 		nEdges = aCol[nCol2].GetBlockMatrixEdges( nRow1, nRow2, 16 );
1605 		// nicht 16 oder 1 oder 32
1606 		if ( nEdges && (((nEdges & 16) != 16) || (nEdges & 33)) )
1607 			return sal_True;		// rechte Kante fehlt oder offen
1608 	}
1609 
1610 	if ( nRow1 == nRow2 )
1611 	{	// obere und untere Zeile
1612 		sal_Bool bOpen = sal_False;
1613 		const sal_uInt16 n = 2 | 8;
1614 		for ( SCCOL i=nCol1; i<=nCol2; i++)
1615 		{
1616 			nEdges = aCol[i].GetBlockMatrixEdges( nRow1, nRow1, n );
1617 			if ( nEdges )
1618 			{
1619 				if ( (nEdges & n) != n )
1620 					return sal_True;		// obere oder untere Kante fehlt
1621 				if ( nEdges & 4 )
1622 					bOpen = sal_True;		// linke Kante oeffnet, weitersehen
1623 				else if ( !bOpen )
1624 					return sal_True;		// es gibt was, was nicht geoeffnet wurde
1625 				if ( nEdges & 16 )
1626 					bOpen = sal_False;		// rechte Kante schliesst
1627 			}
1628 		}
1629 		if ( bOpen )
1630 			return sal_True;				// es geht noch weiter
1631 	}
1632 	else
1633 	{
1634 		sal_uInt16 j, n;
1635         SCROW nR;
1636 		// erst obere Zeile, dann untere Zeile
1637 		for ( j=0, nR=nRow1, n=8; j<2; j++, nR=nRow2, n=2 )
1638 		{
1639 			sal_Bool bOpen = sal_False;
1640 			for ( SCCOL i=nCol1; i<=nCol2; i++)
1641 			{
1642 				nEdges = aCol[i].GetBlockMatrixEdges( nR, nR, n );
1643 				if ( nEdges )
1644 				{
1645 					// in oberere Zeile keine obere Kante bzw.
1646 					// in unterer Zeile keine untere Kante
1647 					if ( (nEdges & n) != n )
1648 						return sal_True;
1649 					if ( nEdges & 4 )
1650 						bOpen = sal_True;		// linke Kante oeffnet, weitersehen
1651 					else if ( !bOpen )
1652 						return sal_True;		// es gibt was, was nicht geoeffnet wurde
1653 					if ( nEdges & 16 )
1654 						bOpen = sal_False;		// rechte Kante schliesst
1655 				}
1656 			}
1657 			if ( bOpen )
1658 				return sal_True;				// es geht noch weiter
1659 		}
1660 	}
1661 	return sal_False;
1662 }
1663 
1664 
1665 sal_Bool ScTable::HasSelectionMatrixFragment( const ScMarkData& rMark ) const
1666 {
1667 	sal_Bool bFound=sal_False;
1668 	for (SCCOL i=0; i<=MAXCOL && !bFound; i++)
1669 		bFound |= aCol[i].HasSelectionMatrixFragment(rMark);
1670 	return bFound;
1671 }
1672 
1673 
1674 sal_Bool ScTable::IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,
1675 			SCROW nRow2, sal_Bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
1676 {
1677     if ( !ValidColRow( nCol2, nRow2 ) )
1678     {
1679         DBG_ERRORFILE("IsBlockEditable: invalid column or row");
1680         if (pOnlyNotBecauseOfMatrix)
1681             *pOnlyNotBecauseOfMatrix = sal_False;
1682         return sal_False;
1683     }
1684 
1685 	sal_Bool bIsEditable = sal_True;
1686 	if ( nLockCount )
1687 		bIsEditable = sal_False;
1688     else if ( IsProtected() && !pDocument->IsScenario(nTab) )
1689     {
1690         if((bIsEditable = !HasAttrib( nCol1, nRow1, nCol2, nRow2, HASATTR_PROTECTED )) != sal_False)
1691         {
1692             // If Sheet is protected and cells are not protected then
1693             // check the active scenario protect flag if this range is
1694             // on the active scenario range. Note the 'copy back' must also
1695             // be set to apply protection.
1696             sal_uInt16 nScenTab = nTab+1;
1697             while(pDocument->IsScenario(nScenTab))
1698             {
1699                 ScRange aEditRange(nCol1, nRow1, nScenTab, nCol2, nRow2, nScenTab);
1700                 if(pDocument->IsActiveScenario(nScenTab) && pDocument->HasScenarioRange(nScenTab, aEditRange))
1701                 {
1702                     sal_uInt16 nFlags;
1703                     pDocument->GetScenarioFlags(nScenTab,nFlags);
1704                     bIsEditable = !((nFlags & SC_SCENARIO_PROTECT) && (nFlags & SC_SCENARIO_TWOWAY));
1705                     break;
1706                 }
1707                 nScenTab++;
1708             }
1709         }
1710     }
1711     else if (pDocument->IsScenario(nTab))
1712     {
1713         // Determine if the preceding sheet is protected
1714         SCTAB nActualTab = nTab;
1715         do
1716         {
1717             nActualTab--;
1718         }
1719         while(pDocument->IsScenario(nActualTab));
1720 
1721         if(pDocument->IsTabProtected(nActualTab))
1722         {
1723             ScRange aEditRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab);
1724             if(pDocument->HasScenarioRange(nTab, aEditRange))
1725             {
1726                 sal_uInt16 nFlags;
1727                 pDocument->GetScenarioFlags(nTab,nFlags);
1728                 bIsEditable = !(nFlags & SC_SCENARIO_PROTECT);
1729             }
1730         }
1731     }
1732 	if ( bIsEditable )
1733 	{
1734 		if ( HasBlockMatrixFragment( nCol1, nRow1, nCol2, nRow2 ) )
1735 		{
1736 			bIsEditable = sal_False;
1737 			if ( pOnlyNotBecauseOfMatrix )
1738 				*pOnlyNotBecauseOfMatrix = sal_True;
1739 		}
1740 		else if ( pOnlyNotBecauseOfMatrix )
1741 			*pOnlyNotBecauseOfMatrix = sal_False;
1742 	}
1743 	else if ( pOnlyNotBecauseOfMatrix )
1744 		*pOnlyNotBecauseOfMatrix = sal_False;
1745 	return bIsEditable;
1746 }
1747 
1748 
1749 sal_Bool ScTable::IsSelectionEditable( const ScMarkData& rMark,
1750 			sal_Bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
1751 {
1752 	sal_Bool bIsEditable = sal_True;
1753 	if ( nLockCount )
1754 		bIsEditable = sal_False;
1755     else if ( IsProtected() && !pDocument->IsScenario(nTab) )
1756     {
1757         if((bIsEditable = !HasAttribSelection( rMark, HASATTR_PROTECTED )) != sal_False)
1758         {
1759             // If Sheet is protected and cells are not protected then
1760             // check the active scenario protect flag if this area is
1761             // in the active scenario range.
1762             ScRangeList aRanges;
1763             rMark.FillRangeListWithMarks( &aRanges, sal_False );
1764             sal_uLong nRangeCount = aRanges.Count();
1765             SCTAB nScenTab = nTab+1;
1766             while(pDocument->IsScenario(nScenTab) && bIsEditable)
1767             {
1768                 if(pDocument->IsActiveScenario(nScenTab))
1769                 {
1770                     for (sal_uLong i=0; i<nRangeCount && bIsEditable; i++)
1771                     {
1772                         ScRange aRange = *aRanges.GetObject(i);
1773                         if(pDocument->HasScenarioRange(nScenTab, aRange))
1774                         {
1775                             sal_uInt16 nFlags;
1776                             pDocument->GetScenarioFlags(nScenTab,nFlags);
1777                             bIsEditable = !((nFlags & SC_SCENARIO_PROTECT) && (nFlags & SC_SCENARIO_TWOWAY));
1778                         }
1779                     }
1780                 }
1781                 nScenTab++;
1782             }
1783         }
1784     }
1785     else if (pDocument->IsScenario(nTab))
1786     {
1787         // Determine if the preceding sheet is protected
1788         SCTAB nActualTab = nTab;
1789         do
1790         {
1791             nActualTab--;
1792         }
1793         while(pDocument->IsScenario(nActualTab));
1794 
1795         if(pDocument->IsTabProtected(nActualTab))
1796         {
1797             ScRangeList aRanges;
1798             rMark.FillRangeListWithMarks( &aRanges, sal_False );
1799             sal_uLong nRangeCount = aRanges.Count();
1800             for (sal_uLong i=0; i<nRangeCount && bIsEditable; i++)
1801             {
1802                 ScRange aRange = *aRanges.GetObject(i);
1803                 if(pDocument->HasScenarioRange(nTab, aRange))
1804                 {
1805                     sal_uInt16 nFlags;
1806                     pDocument->GetScenarioFlags(nTab,nFlags);
1807                     bIsEditable = !(nFlags & SC_SCENARIO_PROTECT);
1808                 }
1809             }
1810         }
1811     }
1812 	if ( bIsEditable )
1813 	{
1814 		if ( HasSelectionMatrixFragment( rMark ) )
1815 		{
1816 			bIsEditable = sal_False;
1817 			if ( pOnlyNotBecauseOfMatrix )
1818 				*pOnlyNotBecauseOfMatrix = sal_True;
1819 		}
1820 		else if ( pOnlyNotBecauseOfMatrix )
1821 			*pOnlyNotBecauseOfMatrix = sal_False;
1822 	}
1823 	else if ( pOnlyNotBecauseOfMatrix )
1824 		*pOnlyNotBecauseOfMatrix = sal_False;
1825 	return bIsEditable;
1826 }
1827 
1828 
1829 
1830 void ScTable::LockTable()
1831 {
1832 	++nLockCount;
1833 }
1834 
1835 
1836 void ScTable::UnlockTable()
1837 {
1838 	if (nLockCount)
1839 		--nLockCount;
1840 	else
1841 	{
1842 		DBG_ERROR("UnlockTable ohne LockTable");
1843 	}
1844 }
1845 
1846 
1847 void ScTable::MergeSelectionPattern( ScMergePatternState& rState, const ScMarkData& rMark, sal_Bool bDeep ) const
1848 {
1849 	for (SCCOL i=0; i<=MAXCOL; i++)
1850 		aCol[i].MergeSelectionPattern( rState, rMark, bDeep );
1851 }
1852 
1853 
1854 void ScTable::MergePatternArea( ScMergePatternState& rState, SCCOL nCol1, SCROW nRow1,
1855 													SCCOL nCol2, SCROW nRow2, sal_Bool bDeep ) const
1856 {
1857 	for (SCCOL i=nCol1; i<=nCol2; i++)
1858 		aCol[i].MergePatternArea( rState, nRow1, nRow2, bDeep );
1859 }
1860 
1861 
1862 void ScTable::MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner, ScLineFlags& rFlags,
1863 					SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) const
1864 {
1865 	if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
1866 	{
1867 		PutInOrder(nStartCol, nEndCol);
1868 		PutInOrder(nStartRow, nEndRow);
1869 		for (SCCOL i=nStartCol; i<=nEndCol; i++)
1870 			aCol[i].MergeBlockFrame( pLineOuter, pLineInner, rFlags,
1871 									nStartRow, nEndRow, (i==nStartCol), nEndCol-i );
1872 	}
1873 }
1874 
1875 
1876 void ScTable::ApplyBlockFrame( const SvxBoxItem* pLineOuter, const SvxBoxInfoItem* pLineInner,
1877 					SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow )
1878 {
1879 	if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
1880 	{
1881 		PutInOrder(nStartCol, nEndCol);
1882 		PutInOrder(nStartRow, nEndRow);
1883 		for (SCCOL i=nStartCol; i<=nEndCol; i++)
1884 			aCol[i].ApplyBlockFrame( pLineOuter, pLineInner,
1885 									nStartRow, nEndRow, (i==nStartCol), nEndCol-i );
1886 	}
1887 }
1888 
1889 
1890 void ScTable::ApplyPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr )
1891 {
1892 	if (ValidColRow(nCol,nRow))
1893 		aCol[nCol].ApplyPattern( nRow, rAttr );
1894 }
1895 
1896 
1897 void ScTable::ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1898 									 const ScPatternAttr& rAttr )
1899 {
1900 	if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
1901 	{
1902 		PutInOrder(nStartCol, nEndCol);
1903 		PutInOrder(nStartRow, nEndRow);
1904 		for (SCCOL i = nStartCol; i <= nEndCol; i++)
1905 			aCol[i].ApplyPatternArea(nStartRow, nEndRow, rAttr);
1906 	}
1907 }
1908 
1909 void ScTable::ApplyPooledPatternArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1910 									 const ScPatternAttr& rPooledAttr, const ScPatternAttr& rAttr )
1911 {
1912 	if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
1913 	{
1914 		PutInOrder(nStartCol, nEndCol);
1915 		PutInOrder(nStartRow, nEndRow);
1916 		for (SCCOL i = nStartCol; i <= nEndCol; i++)
1917 		{
1918 			sal_Bool bSet = sal_True;
1919 			SCROW nStar, nEnd;
1920 			const ScPatternAttr* pAttr = aCol[i].GetPatternRange(nStar, nEnd, nStartRow);
1921 			if (nStar >nStartRow || nEnd < nEndRow || pAttr!=pDocument->GetDefPattern())
1922 				bSet = sal_False;
1923 
1924 			if (bSet)
1925 				aCol[i].SetPatternArea(nStartRow, nEndRow, rPooledAttr);
1926 			else
1927 				aCol[i].ApplyPatternArea(nStartRow, nEndRow, rAttr);
1928 		}
1929 	}
1930 }
1931 
1932 void ScTable::ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,
1933 		const ScPatternAttr& rPattern, short nNewType )
1934 {
1935 	SCCOL nEndCol = rRange.aEnd.Col();
1936 	for ( SCCOL nCol = rRange.aStart.Col(); nCol <= nEndCol; nCol++ )
1937 	{
1938 		aCol[nCol].ApplyPatternIfNumberformatIncompatible( rRange, rPattern, nNewType );
1939 	}
1940 }
1941 
1942 
1943 
1944 void ScTable::ApplyStyle( SCCOL nCol, SCROW nRow, const ScStyleSheet& rStyle )
1945 {
1946 	if (ValidColRow(nCol,nRow))
1947 		aCol[nCol].ApplyStyle( nRow, rStyle );
1948 }
1949 
1950 
1951 void ScTable::ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, const ScStyleSheet& rStyle )
1952 {
1953 	if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
1954 	{
1955 		PutInOrder(nStartCol, nEndCol);
1956 		PutInOrder(nStartRow, nEndRow);
1957 		for (SCCOL i = nStartCol; i <= nEndCol; i++)
1958 			aCol[i].ApplyStyleArea(nStartRow, nEndRow, rStyle);
1959 	}
1960 }
1961 
1962 
1963 void ScTable::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark)
1964 {
1965 	for (SCCOL i=0; i<=MAXCOL; i++)
1966 		aCol[i].ApplySelectionStyle( rStyle, rMark );
1967 }
1968 
1969 
1970 void ScTable::ApplySelectionLineStyle( const ScMarkData& rMark,
1971 							const SvxBorderLine* pLine, sal_Bool bColorOnly )
1972 {
1973 	if ( bColorOnly && !pLine )
1974 		return;
1975 
1976 	for (SCCOL i=0; i<=MAXCOL; i++)
1977 		aCol[i].ApplySelectionLineStyle( rMark, pLine, bColorOnly );
1978 }
1979 
1980 
1981 const ScStyleSheet* ScTable::GetStyle( SCCOL nCol, SCROW nRow ) const
1982 {
1983 	if (ValidColRow(nCol, nRow))
1984 		return aCol[nCol].GetStyle(nRow);
1985 	else
1986 		return NULL;
1987 }
1988 
1989 
1990 const ScStyleSheet* ScTable::GetSelectionStyle( const ScMarkData& rMark, sal_Bool& rFound ) const
1991 {
1992 	rFound = sal_False;
1993 
1994 	sal_Bool	bEqual = sal_True;
1995 	sal_Bool	bColFound;
1996 
1997 	const ScStyleSheet* pStyle = NULL;
1998 	const ScStyleSheet* pNewStyle;
1999 
2000 	for (SCCOL i=0; i<=MAXCOL && bEqual; i++)
2001 		if (rMark.HasMultiMarks(i))
2002 		{
2003 			pNewStyle = aCol[i].GetSelectionStyle( rMark, bColFound );
2004 			if (bColFound)
2005 			{
2006 				rFound = sal_True;
2007 				if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
2008 					bEqual = sal_False;												// unterschiedliche
2009 				pStyle = pNewStyle;
2010 			}
2011 		}
2012 
2013 	return bEqual ? pStyle : NULL;
2014 }
2015 
2016 
2017 const ScStyleSheet*	ScTable::GetAreaStyle( sal_Bool& rFound, SCCOL nCol1, SCROW nRow1,
2018 													SCCOL nCol2, SCROW nRow2 ) const
2019 {
2020 	rFound = sal_False;
2021 
2022 	sal_Bool	bEqual = sal_True;
2023 	sal_Bool	bColFound;
2024 
2025 	const ScStyleSheet* pStyle = NULL;
2026 	const ScStyleSheet* pNewStyle;
2027 
2028 	for (SCCOL i=nCol1; i<=nCol2 && bEqual; i++)
2029 	{
2030 		pNewStyle = aCol[i].GetAreaStyle(bColFound, nRow1, nRow2);
2031 		if (bColFound)
2032 		{
2033 			rFound = sal_True;
2034 			if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
2035 				bEqual = sal_False;												// unterschiedliche
2036 			pStyle = pNewStyle;
2037 		}
2038 	}
2039 
2040 	return bEqual ? pStyle : NULL;
2041 }
2042 
2043 
2044 sal_Bool ScTable::IsStyleSheetUsed( const ScStyleSheet& rStyle, sal_Bool bGatherAllStyles ) const
2045 {
2046 	sal_Bool bIsUsed = sal_False;
2047 
2048 	for ( SCCOL i=0; i<=MAXCOL; i++ )
2049     {
2050 		if ( aCol[i].IsStyleSheetUsed( rStyle, bGatherAllStyles ) )
2051         {
2052             if ( !bGatherAllStyles )
2053                 return sal_True;
2054             bIsUsed = sal_True;
2055         }
2056     }
2057 
2058 	return bIsUsed;
2059 }
2060 
2061 
2062 void ScTable::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, sal_Bool bRemoved,
2063 								OutputDevice* pDev,
2064 								double nPPTX, double nPPTY,
2065 								const Fraction& rZoomX, const Fraction& rZoomY )
2066 {
2067     ScFlatBoolRowSegments aUsedRows;
2068     for (SCCOL i = 0; i <= MAXCOL; ++i)
2069         aCol[i].FindStyleSheet(pStyleSheet, aUsedRows, bRemoved);
2070 
2071     SCROW nRow = 0;
2072     while (nRow <= MAXROW)
2073     {
2074         ScFlatBoolRowSegments::RangeData aData;
2075         if (!aUsedRows.getRangeData(nRow, aData))
2076             // search failed!
2077             return;
2078 
2079         SCROW nEndRow = aData.mnRow2;
2080         if (aData.mbValue)
2081             SetOptimalHeight(nRow, nEndRow, 0, pDev, nPPTX, nPPTY, rZoomX, rZoomY, sal_False);
2082 
2083         nRow = nEndRow + 1;
2084     }
2085 }
2086 
2087 
2088 sal_Bool ScTable::ApplyFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
2089 									sal_Int16 nFlags )
2090 {
2091 	sal_Bool bChanged = sal_False;
2092 	if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
2093 		for (SCCOL i = nStartCol; i <= nEndCol; i++)
2094 			bChanged |= aCol[i].ApplyFlags(nStartRow, nEndRow, nFlags);
2095 	return bChanged;
2096 }
2097 
2098 
2099 sal_Bool ScTable::RemoveFlags( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
2100 									sal_Int16 nFlags )
2101 {
2102 	sal_Bool bChanged = sal_False;
2103 	if (ValidColRow(nStartCol, nStartRow) && ValidColRow(nEndCol, nEndRow))
2104 		for (SCCOL i = nStartCol; i <= nEndCol; i++)
2105 			bChanged |= aCol[i].RemoveFlags(nStartRow, nEndRow, nFlags);
2106 	return bChanged;
2107 }
2108 
2109 
2110 void ScTable::SetPattern( SCCOL nCol, SCROW nRow, const ScPatternAttr& rAttr, sal_Bool bPutToPool )
2111 {
2112 	if (ValidColRow(nCol,nRow))
2113 		aCol[nCol].SetPattern( nRow, rAttr, bPutToPool );
2114 }
2115 
2116 
2117 void ScTable::ApplyAttr( SCCOL nCol, SCROW nRow, const SfxPoolItem& rAttr )
2118 {
2119 	if (ValidColRow(nCol,nRow))
2120 		aCol[nCol].ApplyAttr( nRow, rAttr );
2121 }
2122 
2123 
2124 void ScTable::ApplySelectionCache( SfxItemPoolCache* pCache, const ScMarkData& rMark )
2125 {
2126 	for (SCCOL i=0; i<=MAXCOL; i++)
2127 		aCol[i].ApplySelectionCache( pCache, rMark );
2128 }
2129 
2130 
2131 void ScTable::ChangeSelectionIndent( sal_Bool bIncrement, const ScMarkData& rMark )
2132 {
2133 	for (SCCOL i=0; i<=MAXCOL; i++)
2134 		aCol[i].ChangeSelectionIndent( bIncrement, rMark );
2135 }
2136 
2137 
2138 void ScTable::ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark )
2139 {
2140 	for (SCCOL i=0; i<=MAXCOL; i++)
2141 		aCol[i].ClearSelectionItems( pWhich, rMark );
2142 }
2143 
2144 
2145 //	Spaltenbreiten / Zeilenhoehen
2146 
2147 void ScTable::SetColWidth( SCCOL nCol, sal_uInt16 nNewWidth )
2148 {
2149 	if (VALIDCOL(nCol) && pColWidth)
2150 	{
2151 		if (!nNewWidth)
2152 		{
2153 //			DBG_ERROR("Spaltenbreite 0 in SetColWidth");
2154 			nNewWidth = STD_COL_WIDTH;
2155 		}
2156 
2157 		if ( nNewWidth != pColWidth[nCol] )
2158 		{
2159 			IncRecalcLevel();
2160             InitializeNoteCaptions();
2161 			ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2162 			if (pDrawLayer)
2163 				pDrawLayer->WidthChanged( nTab, nCol, ((long) nNewWidth) - (long) pColWidth[nCol] );
2164 			pColWidth[nCol] = nNewWidth;
2165 			DecRecalcLevel();
2166 
2167             InvalidatePageBreaks();
2168 		}
2169 	}
2170 	else
2171 	{
2172 		DBG_ERROR("Falsche Spaltennummer oder keine Breiten");
2173 	}
2174 }
2175 
2176 
2177 void ScTable::SetRowHeight( SCROW nRow, sal_uInt16 nNewHeight )
2178 {
2179     if (VALIDROW(nRow) && mpRowHeights)
2180 	{
2181 		if (!nNewHeight)
2182 		{
2183 			DBG_ERROR("Zeilenhoehe 0 in SetRowHeight");
2184 			nNewHeight = ScGlobal::nStdRowHeight;
2185 		}
2186 
2187         sal_uInt16 nOldHeight = mpRowHeights->getValue(nRow);
2188 		if ( nNewHeight != nOldHeight )
2189 		{
2190 			IncRecalcLevel();
2191             InitializeNoteCaptions();
2192 			ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2193 			if (pDrawLayer)
2194 				pDrawLayer->HeightChanged( nTab, nRow, ((long) nNewHeight) - (long) nOldHeight );
2195             mpRowHeights->setValue(nRow, nRow, nNewHeight);
2196 			DecRecalcLevel();
2197 
2198             InvalidatePageBreaks();
2199 		}
2200 	}
2201 	else
2202 	{
2203 		DBG_ERROR("Falsche Zeilennummer oder keine Hoehen");
2204 	}
2205 }
2206 
2207 namespace {
2208 
2209 /**
2210  * Check if the new pixel size is different from the old size between
2211  * specified ranges.
2212  */
2213 bool lcl_pixelSizeChanged(
2214     ScFlatUInt16RowSegments& rRowHeights, SCROW nStartRow, SCROW nEndRow,
2215     sal_uInt16 nNewHeight, double nPPTY)
2216 {
2217     long nNewPix = static_cast<long>(nNewHeight * nPPTY);
2218 
2219     ScFlatUInt16RowSegments::ForwardIterator aFwdIter(rRowHeights);
2220     for (SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow)
2221     {
2222         sal_uInt16 nHeight;
2223         if (!aFwdIter.getValue(nRow, nHeight))
2224             break;
2225 
2226         if (nHeight != nNewHeight)
2227         {
2228             bool bChanged = (nNewPix != static_cast<long>(nHeight * nPPTY));
2229             if (bChanged)
2230                 return true;
2231         }
2232 
2233         // Skip ahead to the last position of the current range.
2234         nRow = aFwdIter.getLastPos();
2235     }
2236     return false;
2237 }
2238 
2239 }
2240 
2241 sal_Bool ScTable::SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight,
2242                                     double /* nPPTX */, double nPPTY )
2243 {
2244 	sal_Bool bChanged = sal_False;
2245     if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && mpRowHeights)
2246 	{
2247 		IncRecalcLevel();
2248         InitializeNoteCaptions();
2249 		if (!nNewHeight)
2250 		{
2251 			DBG_ERROR("Zeilenhoehe 0 in SetRowHeight");
2252 			nNewHeight = ScGlobal::nStdRowHeight;
2253 		}
2254 
2255         sal_Bool bSingle = sal_False;   // sal_True = process every row for its own
2256 		ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2257 		if (pDrawLayer)
2258 			if (pDrawLayer->HasObjectsInRows( nTab, nStartRow, nEndRow ))
2259 				bSingle = sal_True;
2260 
2261 		if (bSingle)
2262 		{
2263             ScFlatUInt16RowSegments::RangeData aData;
2264             mpRowHeights->getRangeData(nStartRow, aData);
2265             if (nNewHeight == aData.mnValue && nEndRow <= aData.mnRow2)
2266                 bSingle = sal_False;    // no difference in this range
2267 		}
2268 		if (bSingle)
2269 		{
2270 			if (nEndRow-nStartRow < 20)
2271             {
2272                 if (!bChanged)
2273                     bChanged = lcl_pixelSizeChanged(*mpRowHeights, nStartRow, nEndRow, nNewHeight, nPPTY);
2274 
2275                 /*  #i94028# #i94991# If drawing objects are involved, each row
2276                     has to be changed for its own, because each call to
2277                     ScDrawLayer::HeightChanged expects correct row heights
2278                     above passed row in the document. Cannot use array iterator
2279                     because array changes in every cycle. */
2280                 if( pDrawLayer )
2281                 {
2282                     for( SCROW nRow = nStartRow; nRow <= nEndRow ; ++nRow )
2283                     {
2284                         pDrawLayer->HeightChanged( nTab, nRow,
2285                              static_cast<long>(nNewHeight) - static_cast<long>(mpRowHeights->getValue(nRow)));
2286                         mpRowHeights->setValue(nRow, nRow, nNewHeight);
2287                     }
2288                 }
2289                 else
2290                     mpRowHeights->setValue(nStartRow, nEndRow, nNewHeight);
2291             }
2292 			else
2293 			{
2294 				SCROW nMid = (nStartRow+nEndRow) / 2;
2295 				if (SetRowHeightRange( nStartRow, nMid, nNewHeight, 1.0, 1.0 ))
2296 					bChanged = sal_True;
2297 				if (SetRowHeightRange( nMid+1, nEndRow, nNewHeight, 1.0, 1.0 ))
2298 					bChanged = sal_True;
2299 			}
2300 		}
2301 		else
2302 		{
2303 			if (pDrawLayer)
2304 			{
2305                 // #i115025# When comparing to nNewHeight for the whole range, the height
2306                 // including hidden rows has to be used (same behavior as 3.2).
2307                 unsigned long nOldHeights = mpRowHeights->getSumValue(nStartRow, nEndRow);
2308                 // FIXME: should we test for overflows?
2309 				long nHeightDif = (long) (unsigned long) nNewHeight *
2310                     (nEndRow - nStartRow + 1) - nOldHeights;
2311 				pDrawLayer->HeightChanged( nTab, nEndRow, nHeightDif );
2312 			}
2313 
2314             if (!bChanged)
2315                 bChanged = lcl_pixelSizeChanged(*mpRowHeights, nStartRow, nEndRow, nNewHeight, nPPTY);
2316 
2317             mpRowHeights->setValue(nStartRow, nEndRow, nNewHeight);
2318 		}
2319 		DecRecalcLevel();
2320 
2321         if (bChanged)
2322             InvalidatePageBreaks();
2323 	}
2324 	else
2325 	{
2326 		DBG_ERROR("Falsche Zeilennummer oder keine Hoehen");
2327 	}
2328 
2329 	return bChanged;
2330 }
2331 
2332 void ScTable::SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight )
2333 {
2334     if (!ValidRow(nStartRow) || !ValidRow(nEndRow) || !mpRowHeights)
2335         return;
2336 
2337     if (!nNewHeight)
2338         nNewHeight = ScGlobal::nStdRowHeight;
2339 
2340     mpRowHeights->setValue(nStartRow, nEndRow, nNewHeight);
2341 }
2342 
2343 void ScTable::SetColWidthOnly( SCCOL nCol, sal_uInt16 nNewWidth )
2344 {
2345 	if (!VALIDCOL(nCol) || !pColWidth)
2346         return;
2347 
2348     if (!nNewWidth)
2349         nNewWidth = STD_COL_WIDTH;
2350 
2351     pColWidth[nCol] = nNewWidth;
2352 }
2353 void ScTable::SetManualHeight( SCROW nStartRow, SCROW nEndRow, sal_Bool bManual )
2354 {
2355 	if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && pRowFlags)
2356 	{
2357 		if (bManual)
2358             pRowFlags->OrValue( nStartRow, nEndRow, CR_MANUALSIZE);
2359 		else
2360             pRowFlags->AndValue( nStartRow, nEndRow, sal::static_int_cast<sal_uInt8>(~CR_MANUALSIZE));
2361 	}
2362 	else
2363 	{
2364 		DBG_ERROR("Falsche Zeilennummer oder keine Zeilenflags");
2365 	}
2366 }
2367 
2368 
2369 sal_uInt16 ScTable::GetColWidth( SCCOL nCol ) const
2370 {
2371 	DBG_ASSERT(VALIDCOL(nCol),"Falsche Spaltennummer");
2372 
2373 	if (VALIDCOL(nCol) && pColFlags && pColWidth)
2374 	{
2375         if (ColHidden(nCol))
2376 			return 0;
2377 		else
2378 			return pColWidth[nCol];
2379 	}
2380 	else
2381 		return (sal_uInt16) STD_COL_WIDTH;
2382 }
2383 
2384 
2385 sal_uInt16 ScTable::GetOriginalWidth( SCCOL nCol ) const		// immer die eingestellte
2386 {
2387 	DBG_ASSERT(VALIDCOL(nCol),"Falsche Spaltennummer");
2388 
2389 	if (VALIDCOL(nCol) && pColWidth)
2390 		return pColWidth[nCol];
2391 	else
2392 		return (sal_uInt16) STD_COL_WIDTH;
2393 }
2394 
2395 
2396 sal_uInt16 ScTable::GetCommonWidth( SCCOL nEndCol )
2397 {
2398 	//	get the width that is used in the largest continuous column range (up to nEndCol)
2399 
2400 	if ( !ValidCol(nEndCol) )
2401 	{
2402 		DBG_ERROR("wrong column");
2403 		nEndCol = MAXCOL;
2404 	}
2405 
2406 	sal_uInt16 nMaxWidth = 0;
2407 	sal_uInt16 nMaxCount = 0;
2408 	SCCOL nRangeStart = 0;
2409 	while ( nRangeStart <= nEndCol )
2410 	{
2411 		//	skip hidden columns
2412 		while ( nRangeStart <= nEndCol && ColHidden(nRangeStart) )
2413 			++nRangeStart;
2414 		if ( nRangeStart <= nEndCol )
2415 		{
2416 			sal_uInt16 nThisCount = 0;
2417 			sal_uInt16 nThisWidth = pColWidth[nRangeStart];
2418 			SCCOL nRangeEnd = nRangeStart;
2419 			while ( nRangeEnd <= nEndCol && pColWidth[nRangeEnd] == nThisWidth )
2420 			{
2421 				++nThisCount;
2422 				++nRangeEnd;
2423 
2424 				//	skip hidden columns
2425 				while ( nRangeEnd <= nEndCol && ColHidden(nRangeEnd) )
2426 					++nRangeEnd;
2427 			}
2428 
2429 			if ( nThisCount > nMaxCount )
2430 			{
2431 				nMaxCount = nThisCount;
2432 				nMaxWidth = nThisWidth;
2433 			}
2434 
2435 			nRangeStart = nRangeEnd;		// next range
2436 		}
2437 	}
2438 
2439 	return nMaxWidth;
2440 }
2441 
2442 
2443 sal_uInt16 ScTable::GetRowHeight( SCROW nRow, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero ) const
2444 {
2445     DBG_ASSERT(VALIDROW(nRow),"Invalid row number");
2446 
2447     if (VALIDROW(nRow) && mpRowHeights)
2448     {
2449         if (bHiddenAsZero && RowHidden( nRow, pStartRow, pEndRow))
2450             return 0;
2451         else
2452         {
2453             ScFlatUInt16RowSegments::RangeData aData;
2454             if (!mpRowHeights->getRangeData(nRow, aData))
2455             {
2456                 if (pStartRow)
2457                     *pStartRow = nRow;
2458                 if (pEndRow)
2459                     *pEndRow = nRow;
2460                 // TODO: What should we return in case the search fails?
2461                 return 0;
2462             }
2463 
2464             // If bHiddenAsZero, pStartRow and pEndRow were initialized to
2465             // boundaries of a non-hidden segment. Assume that the previous and
2466             // next segment are hidden then and limit the current height
2467             // segment.
2468             if (pStartRow)
2469                 *pStartRow = (bHiddenAsZero ? std::max( *pStartRow, aData.mnRow1) : aData.mnRow1);
2470             if (pEndRow)
2471                 *pEndRow = (bHiddenAsZero ? std::min( *pEndRow, aData.mnRow2) : aData.mnRow2);
2472             return aData.mnValue;
2473         }
2474     }
2475     else
2476     {
2477         if (pStartRow)
2478             *pStartRow = nRow;
2479         if (pEndRow)
2480             *pEndRow = nRow;
2481         return (sal_uInt16) ScGlobal::nStdRowHeight;
2482     }
2483 }
2484 
2485 
2486 sal_uLong ScTable::GetRowHeight( SCROW nStartRow, SCROW nEndRow ) const
2487 {
2488 	DBG_ASSERT(VALIDROW(nStartRow) && VALIDROW(nEndRow),"Falsche Zeilennummer");
2489 
2490 	if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && mpRowHeights)
2491 	{
2492         sal_uLong nHeight = 0;
2493         SCROW nRow = nStartRow;
2494         while (nRow <= nEndRow)
2495         {
2496             SCROW nLastRow = -1;
2497             if (!RowHidden(nRow, nLastRow))
2498             {
2499                 if (nLastRow > nEndRow)
2500                     nLastRow = nEndRow;
2501                 nHeight += mpRowHeights->getSumValue(nRow, nLastRow);
2502             }
2503             nRow = nLastRow + 1;
2504         }
2505         return nHeight;
2506 	}
2507 	else
2508 		return (sal_uLong) ((nEndRow - nStartRow + 1) * ScGlobal::nStdRowHeight);
2509 }
2510 
2511 
2512 sal_uLong ScTable::GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow, double fScale ) const
2513 {
2514 	DBG_ASSERT(VALIDROW(nStartRow) && VALIDROW(nEndRow),"Falsche Zeilennummer");
2515 
2516 	if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && mpRowHeights)
2517 	{
2518         sal_uLong nHeight = 0;
2519         SCROW nRow = nStartRow;
2520         while (nRow <= nEndRow)
2521         {
2522             SCROW nLastRow = -1;
2523             if (!RowHidden(nRow, nLastRow))
2524             {
2525                 if (nLastRow > nEndRow)
2526                     nLastRow = nEndRow;
2527 
2528                 // #i117315# can't use getSumValue, because individual values must be rounded
2529                 while (nRow <= nLastRow)
2530                 {
2531                     ScFlatUInt16RowSegments::RangeData aData;
2532                     if (!mpRowHeights->getRangeData(nRow, aData))
2533                         return nHeight;   // shouldn't happen
2534 
2535                     SCROW nSegmentEnd = std::min( nLastRow, aData.mnRow2 );
2536 
2537                     // round-down a single height value, multiply resulting (pixel) values
2538                     sal_uLong nOneHeight = static_cast<sal_uLong>( aData.mnValue * fScale );
2539                     nHeight += nOneHeight * ( nSegmentEnd + 1 - nRow );
2540 
2541                     nRow = nSegmentEnd + 1;
2542                 }
2543             }
2544             nRow = nLastRow + 1;
2545         }
2546         return nHeight;
2547 	}
2548 	else
2549 		return (sal_uLong) ((nEndRow - nStartRow + 1) * ScGlobal::nStdRowHeight * fScale);
2550 }
2551 
2552 
2553 sal_uInt16 ScTable::GetOriginalHeight( SCROW nRow ) const		// non-0 even if hidden
2554 {
2555 	DBG_ASSERT(VALIDROW(nRow),"wrong row number");
2556 
2557     if (VALIDROW(nRow) && mpRowHeights)
2558         return mpRowHeights->getValue(nRow);
2559 	else
2560 		return (sal_uInt16) ScGlobal::nStdRowHeight;
2561 }
2562 
2563 
2564 //	Spalten-/Zeilen-Flags
2565 
2566 
2567 SCROW ScTable::GetHiddenRowCount( SCROW nRow )
2568 {
2569     if (!ValidRow(nRow))
2570         return 0;
2571 
2572     SCROW nLastRow = -1;
2573     if (!RowHidden(nRow, nLastRow) || !ValidRow(nLastRow))
2574         return 0;
2575 
2576     return nLastRow - nRow + 1;
2577 }
2578 
2579 
2580 //!		ShowRows / DBShowRows zusammenfassen
2581 
2582 void ScTable::ShowCol(SCCOL nCol, bool bShow)
2583 {
2584 	if (VALIDCOL(nCol))
2585 	{
2586         bool bWasVis = !ColHidden(nCol);
2587 		if (bWasVis != bShow)
2588 		{
2589 			IncRecalcLevel();
2590             InitializeNoteCaptions();
2591 			ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2592 			if (pDrawLayer)
2593 			{
2594 				if (bShow)
2595 					pDrawLayer->WidthChanged( nTab, nCol, (long) pColWidth[nCol] );
2596 				else
2597 					pDrawLayer->WidthChanged( nTab, nCol, -(long) pColWidth[nCol] );
2598 			}
2599 
2600             SetColHidden(nCol, nCol, !bShow);
2601 	    DecRecalcLevel();
2602 
2603 			ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
2604 			if ( pCharts )
2605 				pCharts->SetRangeDirty(ScRange( nCol, 0, nTab, nCol, MAXROW, nTab ));
2606 		}
2607 	}
2608 	else
2609 	{
2610 		DBG_ERROR("Falsche Spaltennummer oder keine Flags");
2611 	}
2612 }
2613 
2614 
2615 void ScTable::ShowRow(SCROW nRow, bool bShow)
2616 {
2617 	if (VALIDROW(nRow) && pRowFlags)
2618 	{
2619         bool bWasVis = !RowHidden(nRow);
2620 		if (bWasVis != bShow)
2621 		{
2622 			IncRecalcLevel();
2623             InitializeNoteCaptions();
2624 			ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2625 			if (pDrawLayer)
2626 			{
2627 				if (bShow)
2628                     pDrawLayer->HeightChanged(
2629                         nTab, nRow, static_cast<long>(mpRowHeights->getValue(nRow)));
2630 				else
2631                     pDrawLayer->HeightChanged(
2632                         nTab, nRow, -static_cast<long>(mpRowHeights->getValue(nRow)));
2633 			}
2634 
2635             SetRowHidden(nRow, nRow, !bShow);
2636 			if (bShow)
2637                 SetRowFiltered(nRow, nRow, false);
2638 		DecRecalcLevel();
2639 
2640 			ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
2641 			if ( pCharts )
2642 				pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, MAXCOL, nRow, nTab ));
2643 
2644             InvalidatePageBreaks();
2645 		}
2646 	}
2647 	else
2648 	{
2649 		DBG_ERROR("Falsche Zeilennummer oder keine Flags");
2650 	}
2651 }
2652 
2653 
2654 void ScTable::DBShowRow(SCROW nRow, bool bShow)
2655 {
2656 	if (VALIDROW(nRow) && pRowFlags)
2657 	{
2658         bool bWasVis = !RowHidden(nRow);
2659 		IncRecalcLevel();
2660         InitializeNoteCaptions();
2661 		if (bWasVis != bShow)
2662 		{
2663 			ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2664 			if (pDrawLayer)
2665 			{
2666 				if (bShow)
2667                     pDrawLayer->HeightChanged(
2668                         nTab, nRow, static_cast<long>(mpRowHeights->getValue(nRow)));
2669 				else
2670                     pDrawLayer->HeightChanged(
2671                         nTab, nRow, -static_cast<long>(mpRowHeights->getValue(nRow)));
2672 			}
2673 		}
2674 
2675 		//	Filter-Flag immer setzen, auch wenn Hidden unveraendert
2676         SetRowHidden(nRow, nRow, !bShow);
2677         SetRowFiltered(nRow, nRow, !bShow);
2678 	DecRecalcLevel();
2679 
2680 		if (bWasVis != bShow)
2681 		{
2682 			ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
2683 			if ( pCharts )
2684 				pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, MAXCOL, nRow, nTab ));
2685 
2686 			if (pOutlineTable)
2687 				UpdateOutlineRow( nRow, nRow, bShow );
2688 
2689             InvalidatePageBreaks();
2690 		}
2691 	}
2692 	else
2693 	{
2694 		DBG_ERROR("Falsche Zeilennummer oder keine Flags");
2695 	}
2696 }
2697 
2698 
2699 void ScTable::DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow, bool bSetFlags)
2700 {
2701     // #i116164# IncRecalcLevel/DecRecalcLevel is in ScTable::Query
2702 	SCROW nStartRow = nRow1;
2703     InitializeNoteCaptions();
2704 	while (nStartRow <= nRow2)
2705 	{
2706         SCROW nEndRow = -1;
2707         bool bWasVis = !RowHidden(nStartRow, nEndRow);
2708         if (nEndRow > nRow2)
2709             nEndRow = nRow2;
2710 
2711 		sal_Bool bChanged = ( bWasVis != bShow );
2712 		if ( bChanged && bSetFlags )
2713 		{
2714 			ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2715 			if (pDrawLayer)
2716 			{
2717                 long nHeight = static_cast<long>(mpRowHeights->getSumValue(nStartRow, nEndRow));
2718 				if (bShow)
2719 					pDrawLayer->HeightChanged( nTab, nStartRow, nHeight );
2720 				else
2721 					pDrawLayer->HeightChanged( nTab, nStartRow, -nHeight );
2722 			}
2723 		}
2724 
2725         // #i116164# Directly modify the flags only if there are drawing objects within the area.
2726         // Otherwise, all modifications are made together in ScTable::Query, so the tree isn't constantly rebuilt.
2727         if ( bSetFlags )
2728         {
2729             SetRowHidden(nStartRow, nEndRow, !bShow);
2730             SetRowFiltered(nStartRow, nEndRow, !bShow);
2731         }
2732 
2733 		if ( bChanged )
2734 		{
2735 			ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
2736 			if ( pCharts )
2737 				pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ));
2738 		}
2739 
2740 		nStartRow = nEndRow + 1;
2741 	}
2742 
2743 	//	#i12341# For Show/Hide rows, the outlines are updated separately from the outside.
2744 	//	For filtering, the changes aren't visible to the caller, so UpdateOutlineRow has
2745 	//	to be done here.
2746 	if (pOutlineTable)
2747 		UpdateOutlineRow( nRow1, nRow2, bShow );
2748 }
2749 
2750 
2751 void ScTable::ShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
2752 {
2753 	SCROW nStartRow = nRow1;
2754 	IncRecalcLevel();
2755     InitializeNoteCaptions();
2756 
2757     // #i116164# if there are no drawing objects within the row range, a single HeightChanged call is enough
2758     ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
2759     bool bHasObjects = pDrawLayer && pDrawLayer->HasObjectsInRows( nTab, nRow1, nRow2, false );
2760     long nOldHeight = 0;
2761     if ( pDrawLayer && !bHasObjects )
2762         nOldHeight = static_cast<long>(GetRowHeight(nRow1, nRow2));
2763 
2764 	while (nStartRow <= nRow2)
2765 	{
2766         SCROW nEndRow = -1;
2767         bool bWasVis = !RowHidden(nStartRow, nEndRow);
2768         if (nEndRow > nRow2)
2769             nEndRow = nRow2;
2770 
2771 		sal_Bool bChanged = ( bWasVis != bShow );
2772         if ( bChanged && bHasObjects )
2773 		{
2774 			if (pDrawLayer)
2775 			{
2776                 long nHeight = static_cast<long>(mpRowHeights->getSumValue(nStartRow, nEndRow));
2777 				if (bShow)
2778 					pDrawLayer->HeightChanged( nTab, nStartRow, nHeight );
2779 				else
2780 					pDrawLayer->HeightChanged( nTab, nStartRow, -nHeight );
2781 			}
2782 		}
2783 
2784         // #i116164# Directly modify the flags only if there are drawing objects within the area.
2785         // Otherwise, all rows are modified together after the loop, so the tree isn't constantly rebuilt.
2786         if ( bHasObjects )
2787         {
2788             SetRowHidden(nStartRow, nEndRow, !bShow);
2789             if (bShow)
2790                 SetRowFiltered(nStartRow, nEndRow, false);
2791         }
2792 
2793 		if ( bChanged )
2794 		{
2795 			ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
2796 			if ( pCharts )
2797 				pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ));
2798 
2799             InvalidatePageBreaks();
2800 		}
2801 
2802 		nStartRow = nEndRow + 1;
2803 	}
2804 
2805     if ( !bHasObjects )
2806     {
2807         // #i116164# set the flags for the whole range at once
2808         SetRowHidden(nRow1, nRow2, !bShow);
2809         if (bShow)
2810             SetRowFiltered(nRow1, nRow2, false);
2811 
2812         if ( pDrawLayer )
2813         {
2814             // if there are no objects in the range, a single HeightChanged call is enough
2815             long nNewHeight = 0;
2816             if ( bShow )
2817                 nNewHeight = static_cast<long>(GetRowHeight(nRow1, nRow2));
2818             if ( nNewHeight != nOldHeight )
2819                 pDrawLayer->HeightChanged( nTab, nRow1, nNewHeight - nOldHeight );
2820         }
2821     }
2822 
2823 	DecRecalcLevel();
2824 }
2825 
2826 sal_Bool ScTable::IsDataFiltered() const
2827 {
2828 	sal_Bool bAnyQuery = sal_False;
2829 	ScDBData* pDBData = pDocument->GetFilterDBAtTable(nTab);
2830 	if ( pDBData )
2831 	{
2832 		ScQueryParam aParam;
2833 		pDBData->GetQueryParam( aParam );
2834 		if ( aParam.GetEntry(0).bDoQuery )
2835 			bAnyQuery = sal_True;
2836 	}
2837 	return bAnyQuery;
2838 }
2839 
2840 void ScTable::SetColFlags( SCCOL nCol, sal_uInt8 nNewFlags )
2841 {
2842 	if (VALIDCOL(nCol) && pColFlags)
2843 		pColFlags[nCol] = nNewFlags;
2844 	else
2845 	{
2846 		DBG_ERROR("Falsche Spaltennummer oder keine Flags");
2847 	}
2848 }
2849 
2850 
2851 void ScTable::SetRowFlags( SCROW nRow, sal_uInt8 nNewFlags )
2852 {
2853 	if (VALIDROW(nRow) && pRowFlags)
2854 		pRowFlags->SetValue( nRow, nNewFlags);
2855 	else
2856 	{
2857 		DBG_ERROR("Falsche Zeilennummer oder keine Flags");
2858 	}
2859 }
2860 
2861 
2862 void ScTable::SetRowFlags( SCROW nStartRow, SCROW nEndRow, sal_uInt8 nNewFlags )
2863 {
2864 	if (VALIDROW(nStartRow) && VALIDROW(nEndRow) && pRowFlags)
2865 		pRowFlags->SetValue( nStartRow, nEndRow, nNewFlags);
2866 	else
2867 	{
2868 		DBG_ERROR("Falsche Zeilennummer(n) oder keine Flags");
2869 	}
2870 }
2871 
2872 
2873 sal_uInt8 ScTable::GetColFlags( SCCOL nCol ) const
2874 {
2875 	if (VALIDCOL(nCol) && pColFlags)
2876 		return pColFlags[nCol];
2877 	else
2878 		return 0;
2879 }
2880 
2881 
2882 sal_uInt8 ScTable::GetRowFlags( SCROW nRow ) const
2883 {
2884 	if (VALIDROW(nRow) && pRowFlags)
2885 		return pRowFlags->GetValue(nRow);
2886 	else
2887 		return 0;
2888 }
2889 
2890 
2891 SCROW ScTable::GetLastFlaggedRow() const
2892 {
2893     SCROW nLastFound = 0;
2894     if (pRowFlags)
2895     {
2896         SCROW nRow = pRowFlags->GetLastAnyBitAccess( 0, sal::static_int_cast<sal_uInt8>(CR_ALL) );
2897         if (ValidRow(nRow))
2898             nLastFound = nRow;
2899     }
2900 
2901     if (!maRowManualBreaks.empty())
2902         nLastFound = ::std::max(nLastFound, *maRowManualBreaks.rbegin());
2903 
2904     if (mpHiddenRows)
2905     {
2906         SCROW nRow = mpHiddenRows->findLastNotOf(false);
2907         if (ValidRow(nRow))
2908             nLastFound = ::std::max(nLastFound, nRow);
2909     }
2910 
2911     if (mpFilteredRows)
2912     {
2913         SCROW nRow = mpFilteredRows->findLastNotOf(false);
2914         if (ValidRow(nRow))
2915             nLastFound = ::std::max(nLastFound, nRow);
2916     }
2917 
2918     return nLastFound;
2919 }
2920 
2921 
2922 SCCOL ScTable::GetLastChangedCol() const
2923 {
2924 	if ( !pColFlags )
2925 		return 0;
2926 
2927 	SCCOL nLastFound = 0;
2928 	for (SCCOL nCol = 1; nCol <= MAXCOL; nCol++)
2929         if ((pColFlags[nCol] & CR_ALL) || (pColWidth[nCol] != STD_COL_WIDTH))
2930 			nLastFound = nCol;
2931 
2932 	return nLastFound;
2933 }
2934 
2935 
2936 SCROW ScTable::GetLastChangedRow() const
2937 {
2938 	if ( !pRowFlags )
2939 		return 0;
2940 
2941     SCROW nLastFlags = GetLastFlaggedRow();
2942 
2943     // Find the last row position where the height is NOT the standard row
2944     // height.
2945     // KOHEI: Test this to make sure it does what it's supposed to.
2946     SCROW nLastHeight = mpRowHeights->findLastNotOf(ScGlobal::nStdRowHeight);
2947     if (!ValidRow(nLastHeight))
2948         nLastHeight = 0;
2949 
2950 	return std::max( nLastFlags, nLastHeight);
2951 }
2952 
2953 
2954 sal_Bool ScTable::UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, sal_Bool bShow )
2955 {
2956 	if (pOutlineTable && pColFlags)
2957     {
2958         ScBitMaskCompressedArray< SCCOLROW, sal_uInt8> aArray( MAXCOL, pColFlags, MAXCOLCOUNT);
2959 		return pOutlineTable->GetColArray()->ManualAction( nStartCol, nEndCol, bShow, *this, true );
2960     }
2961 	else
2962 		return sal_False;
2963 }
2964 
2965 
2966 sal_Bool ScTable::UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, sal_Bool bShow )
2967 {
2968 	if (pOutlineTable && pRowFlags)
2969 		return pOutlineTable->GetRowArray()->ManualAction( nStartRow, nEndRow, bShow, *this, false );
2970 	else
2971 		return sal_False;
2972 }
2973 
2974 
2975 void ScTable::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
2976 {
2977     // Column-wise expansion
2978 
2979     while (rX1 > 0 && ColHidden(rX1-1))
2980         --rX1;
2981 
2982     while (rX2 < MAXCOL && ColHidden(rX2+1))
2983         ++rX2;
2984 
2985     // Row-wise expansion
2986 
2987     if (rY1 > 0)
2988 	{
2989         ScFlatBoolRowSegments::RangeData aData;
2990         if (mpHiddenRows->getRangeData(rY1-1, aData) && aData.mbValue)
2991         {
2992             SCROW nStartRow = aData.mnRow1;
2993             if (ValidRow(nStartRow))
2994                 rY1 = nStartRow;
2995         }
2996     }
2997     if (rY2 < MAXROW)
2998     {
2999         SCROW nEndRow = -1;
3000         if (RowHidden(rY2+1, nEndRow) && ValidRow(nEndRow))
3001             rY2 = nEndRow;
3002 	}
3003 }
3004 
3005 
3006 void ScTable::StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
3007 {
3008     while ( rX2>rX1 && ColHidden(rX2) )
3009         --rX2;
3010     while ( rX2>rX1 && ColHidden(rX1) )
3011         ++rX1;
3012 
3013     if (rY1 < rY2)
3014 	{
3015         ScFlatBoolRowSegments::RangeData aData;
3016         if (mpHiddenRows->getRangeData(rY2, aData) && aData.mbValue)
3017         {
3018             SCROW nStartRow = aData.mnRow1;
3019             if (ValidRow(nStartRow) && nStartRow >= rY1)
3020                 rY2 = nStartRow;
3021         }
3022     }
3023 
3024     if (rY1 < rY2)
3025     {
3026         SCROW nEndRow = -1;
3027         if (RowHidden(rY1, nEndRow) && ValidRow(nEndRow) && nEndRow <= rY2)
3028             rY1 = nEndRow;
3029 	}
3030 }
3031 
3032 
3033 //	Auto-Outline
3034 
3035 template< typename T >
3036 short DiffSign( T a, T b )
3037 {
3038 	return (a<b) ? -1 :
3039 			(a>b) ? 1 : 0;
3040 }
3041 
3042 
3043 void ScTable::DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow )
3044 {
3045 	sal_Bool bSizeChanged = sal_False;
3046 	sal_Bool bMissed	  = sal_False;
3047 
3048 	SCCOL nCol;
3049 	SCROW nRow;
3050 	SCROW i;
3051 	sal_Bool bFound;
3052 	ScOutlineArray* pArray;
3053 	ScBaseCell* pCell;
3054 	ScRange aRef;
3055 /*	ScPatternAttr aBoldPattern( pDocument->GetPool() );				//!	spezielle Format-Vorlage
3056 	aBoldPattern.GetItemSet().Put( SvxWeightItem( WEIGHT_BOLD ) );
3057 */
3058 
3059 	StartOutlineTable();
3060 
3061 							// Zeilen
3062 
3063 	SCROW	nCount = nEndRow-nStartRow+1;
3064 	sal_Bool*	pUsed = new sal_Bool[nCount];
3065 	for (i=0; i<nCount; i++)
3066 		pUsed[i] = sal_False;
3067 	for (nCol=nStartCol; nCol<=nEndCol; nCol++)
3068 		if (!aCol[nCol].IsEmptyData())
3069 			aCol[nCol].FindUsed( nStartRow, nEndRow, pUsed );
3070 
3071 	pArray = pOutlineTable->GetRowArray();
3072 	for (nRow=nStartRow; nRow<=nEndRow; nRow++)
3073 		if (pUsed[nRow-nStartRow])
3074 		{
3075 			bFound = sal_False;
3076 			for (nCol=nStartCol; nCol<=nEndCol && !bFound; nCol++)
3077 				if (!aCol[nCol].IsEmptyData())
3078 				{
3079 					pCell = aCol[nCol].GetCell( nRow );
3080 					if (pCell)
3081 						if ( pCell->GetCellType() == CELLTYPE_FORMULA )
3082 							if (((ScFormulaCell*)pCell)->HasRefListExpressibleAsOneReference( aRef ))
3083 								if ( aRef.aStart.Col() == nCol && aRef.aEnd.Col() == nCol &&
3084 									 aRef.aStart.Tab() == nTab && aRef.aEnd.Tab() == nTab &&
3085 									 DiffSign( aRef.aStart.Row(), nRow ) ==
3086 										DiffSign( aRef.aEnd.Row(), nRow ) )
3087 								{
3088 									if (pArray->Insert( aRef.aStart.Row(), aRef.aEnd.Row(), bSizeChanged ))
3089 									{
3090 //										ApplyPatternArea( nStartCol, nRow, nEndCol, nRow, aBoldPattern );
3091 										bFound = sal_True;
3092 									}
3093 									else
3094 										bMissed = sal_True;
3095 								}
3096 				}
3097 		}
3098 
3099 	delete[] pUsed;
3100 
3101 							// Spalten
3102 
3103 	pArray = pOutlineTable->GetColArray();
3104 	for (nCol=nStartCol; nCol<=nEndCol; nCol++)
3105 	{
3106 		if (!aCol[nCol].IsEmptyData())
3107 		{
3108 			bFound = sal_False;
3109 			ScColumnIterator aIter( &aCol[nCol], nStartRow, nEndRow );
3110 			while ( aIter.Next( nRow, pCell ) && !bFound )
3111 			{
3112 				if ( pCell->GetCellType() == CELLTYPE_FORMULA )
3113 					if (((ScFormulaCell*)pCell)->HasRefListExpressibleAsOneReference( aRef ))
3114 						if ( aRef.aStart.Row() == nRow && aRef.aEnd.Row() == nRow &&
3115 							 aRef.aStart.Tab() == nTab && aRef.aEnd.Tab() == nTab &&
3116 							 DiffSign( aRef.aStart.Col(), nCol ) ==
3117 								DiffSign( aRef.aEnd.Col(), nCol ) )
3118 						{
3119 							if (pArray->Insert( aRef.aStart.Col(), aRef.aEnd.Col(), bSizeChanged ))
3120 							{
3121 //								ApplyPatternArea( nCol, nStartRow, nCol, nEndRow, aBoldPattern );
3122 								bFound = sal_True;
3123 							}
3124 							else
3125 								bMissed = sal_True;
3126 						}
3127 			}
3128 		}
3129 	}
3130 }
3131 
3132 									//	CopyData - fuer Query in anderen Bereich
3133 
3134 void ScTable::CopyData( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
3135 							SCCOL nDestCol, SCROW nDestRow, SCTAB nDestTab )
3136 {
3137 	//!		wenn fuer mehrere Zeilen benutzt, nach Spalten optimieren!
3138 
3139 	ScAddress aSrc( nStartCol, nStartRow, nTab );
3140 	ScAddress aDest( nDestCol, nDestRow, nDestTab );
3141 	ScRange aRange( aSrc, aDest );
3142 	sal_Bool bThisTab = ( nDestTab == nTab );
3143 	SCROW nDestY = nDestRow;
3144 	for (SCROW nRow=nStartRow; nRow<=nEndRow; nRow++)
3145 	{
3146 		aSrc.SetRow( nRow );
3147 		aDest.SetRow( nDestY );
3148 		SCCOL nDestX = nDestCol;
3149 		for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
3150 		{
3151 			aSrc.SetCol( nCol );
3152 			aDest.SetCol( nDestX );
3153 			ScBaseCell* pCell = GetCell( nCol, nRow );
3154 			if (pCell)
3155 			{
3156                 pCell = pCell->CloneWithoutNote( *pDocument );
3157 				if (pCell->GetCellType() == CELLTYPE_FORMULA)
3158 				{
3159 					((ScFormulaCell*)pCell)->UpdateReference( URM_COPY, aRange,
3160 									((SCsCOL) nDestCol) - ((SCsCOL) nStartCol),
3161 									((SCsROW) nDestRow) - ((SCsROW) nStartRow),
3162 									((SCsTAB) nDestTab) - ((SCsTAB) nTab) );
3163 					((ScFormulaCell*)pCell)->aPos = aDest;
3164 				}
3165 			}
3166 			if (bThisTab)
3167 			{
3168 				PutCell( nDestX, nDestY, pCell );
3169 				SetPattern( nDestX, nDestY, *GetPattern( nCol, nRow ), sal_True );
3170 			}
3171 			else
3172 			{
3173 				pDocument->PutCell( aDest, pCell );
3174 				pDocument->SetPattern( aDest, *GetPattern( nCol, nRow ), sal_True );
3175 			}
3176 
3177 			++nDestX;
3178 		}
3179 		++nDestY;
3180 	}
3181 }
3182 
3183 
3184 sal_Bool ScTable::RefVisible(ScFormulaCell* pCell)
3185 {
3186 	ScRange aRef;
3187 
3188 	if (pCell->HasOneReference(aRef))
3189 	{
3190 		if (aRef.aStart.Col()==aRef.aEnd.Col() && aRef.aStart.Tab()==aRef.aEnd.Tab())
3191 		{
3192             SCROW nEndRow;
3193             if (!RowFiltered(aRef.aStart.Row(), NULL, &nEndRow))
3194                 // row not filtered.
3195                 nEndRow = ::std::numeric_limits<SCROW>::max();
3196 
3197             if (!ValidRow(nEndRow) || nEndRow < aRef.aEnd.Row())
3198                 return sal_True;    // at least partly visible
3199             return sal_False;       // completely invisible
3200 		}
3201 	}
3202 
3203 	return sal_True;						// irgendwie anders
3204 }
3205 
3206 
3207 void ScTable::GetUpperCellString(SCCOL nCol, SCROW nRow, String& rStr)
3208 {
3209 	GetInputString(nCol, nRow, rStr);
3210 	rStr.EraseTrailingChars();
3211 	rStr.EraseLeadingChars();
3212 	ScGlobal::pCharClass->toUpper(rStr);
3213 }
3214 
3215 
3216 // Berechnen der Groesse der Tabelle und setzen der Groesse an der DrawPage
3217 
3218 void ScTable::SetDrawPageSize(bool bResetStreamValid, bool bUpdateNoteCaptionPos)
3219 {
3220 	ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
3221 	if( pDrawLayer )
3222 	{
3223         double fValX = GetColOffset( MAXCOL + 1 ) * HMM_PER_TWIPS;
3224         double fValY = GetRowOffset( MAXROW + 1 ) * HMM_PER_TWIPS;
3225         const long nMax = ::std::numeric_limits<long>::max();
3226         // #i113884# Avoid int32 overflow with possible negative results than can cause bad effects.
3227         // If the draw page size is smaller than all rows, only the bottom of the sheet is affected.
3228         long x = ( fValX > (double)nMax ) ? nMax : (long) fValX;
3229         long y = ( fValY > (double)nMax ) ? nMax : (long) fValY;
3230 
3231 		if ( IsLayoutRTL() )		// IsNegativePage
3232 			x = -x;
3233 
3234 		pDrawLayer->SetPageSize( static_cast<sal_uInt16>(nTab), Size( x, y ), bUpdateNoteCaptionPos );
3235 	}
3236 
3237     // #i102616# actions that modify the draw page size count as sheet modification
3238     // (exception: InitDrawLayer)
3239     if (bResetStreamValid && IsStreamValid())
3240         SetStreamValid(sal_False);
3241 }
3242 
3243 
3244 sal_uLong ScTable::GetRowOffset( SCROW nRow ) const
3245 {
3246 	sal_uLong n = 0;
3247     if ( mpHiddenRows && mpRowHeights )
3248 	{
3249         if (nRow == 0)
3250             return 0;
3251         else if (nRow == 1)
3252             return GetRowHeight(0);
3253 
3254         n = GetTotalRowHeight(0, nRow-1);
3255 #ifdef DBG_UTIL
3256         if (n == ::std::numeric_limits<unsigned long>::max())
3257             DBG_ERRORFILE("ScTable::GetRowOffset: row heights overflow");
3258 #endif
3259 	}
3260 	else
3261 	{
3262 		DBG_ERROR("GetRowOffset: Daten fehlen");
3263 	}
3264 	return n;
3265 }
3266 
3267 SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
3268 {
3269     sal_uInt32 nSum = 0;
3270 
3271     ScFlatBoolRowSegments::RangeData aData;
3272     for (SCROW nRow = 0; nRow <= MAXROW; ++nRow)
3273     {
3274         if (!mpHiddenRows->getRangeData(nRow, aData))
3275             break;
3276 
3277         if (aData.mbValue)
3278         {
3279             nRow = aData.mnRow2;
3280             continue;
3281         }
3282 
3283         sal_uInt32 nNew = mpRowHeights->getValue(nRow);
3284         nSum += nNew;
3285         if (nSum > nHeight)
3286         {
3287             return nRow < MAXROW ? nRow + 1 : MAXROW;
3288         }
3289     }
3290     return -1;
3291 }
3292 
3293 
3294 sal_uLong ScTable::GetColOffset( SCCOL nCol ) const
3295 {
3296 	sal_uLong n = 0;
3297 	if ( pColWidth )
3298 	{
3299 		SCCOL i;
3300 		for( i = 0; i < nCol; i++ )
3301             if (!ColHidden(i))
3302 				n += pColWidth[i];
3303 	}
3304 	else
3305 	{
3306 		DBG_ERROR("GetColumnOffset: Daten fehlen");
3307 	}
3308 	return n;
3309 }
3310 
3311