xref: /aoo41x/main/sc/source/core/data/column.cxx (revision 3a02adb1)
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 
28 
29 // INCLUDE ---------------------------------------------------------------
30 
31 #include <map>
32 
33 #include <svl/poolcach.hxx>
34 #include <svl/zforlist.hxx>
35 #include <editeng/scripttypeitem.hxx>
36 #include <string.h>
37 
38 #include "scitems.hxx"
39 #include "column.hxx"
40 #include "cell.hxx"
41 #include "document.hxx"
42 #include "docpool.hxx"
43 #include "attarray.hxx"
44 #include "patattr.hxx"
45 #include "compiler.hxx"
46 #include "brdcst.hxx"
47 #include "markdata.hxx"
48 #include "detfunc.hxx"			// for Notes in Sort/Swap
49 #include "postit.hxx"
50 
51 //#pragma optimize ( "", off )
52 //	nur Search ohne Optimierung!
53 
54 // STATIC DATA -----------------------------------------------------------
55 using namespace formula;
56 
IsAmbiguousScriptNonZero(sal_uInt8 nScript)57 inline sal_Bool IsAmbiguousScriptNonZero( sal_uInt8 nScript )
58 {
59 	//!	move to a header file
60 	return ( nScript != SCRIPTTYPE_LATIN &&
61 			 nScript != SCRIPTTYPE_ASIAN &&
62 			 nScript != SCRIPTTYPE_COMPLEX &&
63 			 nScript != 0 );
64 }
65 
66 // -----------------------------------------------------------------------------------------
67 
68 
ScColumn()69 ScColumn::ScColumn() :
70 	nCol( 0 ),
71 	nCount( 0 ),
72 	nLimit( 0 ),
73 	pItems( NULL ),
74     pAttrArray( NULL ),
75     pDocument( NULL )
76 {
77 }
78 
79 
~ScColumn()80 ScColumn::~ScColumn()
81 {
82 	FreeAll();
83 	if (pAttrArray) delete pAttrArray;
84 }
85 
86 
Init(SCCOL nNewCol,SCTAB nNewTab,ScDocument * pDoc)87 void ScColumn::Init(SCCOL nNewCol, SCTAB nNewTab, ScDocument* pDoc)
88 {
89 	nCol = nNewCol;
90 	nTab = nNewTab;
91 	pDocument = pDoc;
92 	pAttrArray = new ScAttrArray( nCol, nTab, pDocument );
93 }
94 
95 
GetNextUnprotected(SCROW nRow,sal_Bool bUp) const96 SCsROW ScColumn::GetNextUnprotected( SCROW nRow, sal_Bool bUp ) const
97 {
98 	return pAttrArray->GetNextUnprotected(nRow, bUp);
99 }
100 
101 
GetBlockMatrixEdges(SCROW nRow1,SCROW nRow2,sal_uInt16 nMask) const102 sal_uInt16 ScColumn::GetBlockMatrixEdges( SCROW nRow1, SCROW nRow2, sal_uInt16 nMask ) const
103 {
104 	// nix:0, mitte:1, unten:2, links:4, oben:8, rechts:16, offen:32
105 	if ( !pItems )
106 		return 0;
107 	if ( nRow1 == nRow2 )
108 	{
109 		SCSIZE nIndex;
110 		if ( Search( nRow1, nIndex ) )
111 		{
112 			ScBaseCell* pCell = pItems[nIndex].pCell;
113 			if ( pCell->GetCellType() == CELLTYPE_FORMULA
114 				&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
115 			{
116 				ScAddress aOrg( ScAddress::INITIALIZE_INVALID );
117 				return ((ScFormulaCell*)pCell)->GetMatrixEdge( aOrg );
118 			}
119 		}
120 		return 0;
121 	}
122 	else
123 	{
124 		ScAddress aOrg( ScAddress::INITIALIZE_INVALID );
125 		sal_Bool bOpen = sal_False;
126 		sal_uInt16 nEdges = 0;
127 		SCSIZE nIndex;
128 		Search( nRow1, nIndex );
129 		while ( nIndex < nCount && pItems[nIndex].nRow <= nRow2 )
130 		{
131 			ScBaseCell* pCell = pItems[nIndex].pCell;
132 			if ( pCell->GetCellType() == CELLTYPE_FORMULA
133 				&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
134 			{
135 				nEdges = ((ScFormulaCell*)pCell)->GetMatrixEdge( aOrg );
136 				if ( nEdges )
137 				{
138 					if ( nEdges & 8 )
139 						bOpen = sal_True;	// obere Kante oeffnet, weitersehen
140 					else if ( !bOpen )
141 						return nEdges | 32;	// es gibt was, was nicht geoeffnet wurde
142 					else if ( nEdges & 1 )
143 						return nEdges;	// mittendrin
144 					// (nMask & 16 und  (4 und nicht 16)) oder
145 					// (nMask & 4  und (16 und nicht 4))
146 					if ( ((nMask & 16) && (nEdges & 4)  && !(nEdges & 16))
147 						|| ((nMask & 4)  && (nEdges & 16) && !(nEdges & 4)) )
148 						return nEdges;	// nur linke/rechte Kante
149 					if ( nEdges & 2 )
150 						bOpen = sal_False;	// untere Kante schliesst
151 				}
152 			}
153 			nIndex++;
154 		}
155 		if ( bOpen )
156 			nEdges |= 32;			// es geht noch weiter
157 		return nEdges;
158 	}
159 }
160 
161 
HasSelectionMatrixFragment(const ScMarkData & rMark) const162 sal_Bool ScColumn::HasSelectionMatrixFragment(const ScMarkData& rMark) const
163 {
164 	if ( rMark.IsMultiMarked() )
165 	{
166 		sal_Bool bFound = sal_False;
167 
168 		ScAddress aOrg( ScAddress::INITIALIZE_INVALID );
169 		ScAddress aCurOrg( ScAddress::INITIALIZE_INVALID );
170 		SCROW nTop, nBottom;
171 		ScMarkArrayIter aMarkIter( rMark.GetArray()+nCol );
172 		while ( !bFound && aMarkIter.Next( nTop, nBottom ) )
173 		{
174 			sal_Bool bOpen = sal_False;
175 			sal_uInt16 nEdges;
176 			SCSIZE nIndex;
177 			Search( nTop, nIndex );
178 			while ( !bFound && nIndex < nCount && pItems[nIndex].nRow <= nBottom )
179 			{
180 				ScBaseCell* pCell = pItems[nIndex].pCell;
181 				if ( pCell->GetCellType() == CELLTYPE_FORMULA
182 					&& ((ScFormulaCell*)pCell)->GetMatrixFlag() )
183 				{
184 					nEdges = ((ScFormulaCell*)pCell)->GetMatrixEdge( aOrg );
185 					if ( nEdges )
186 					{
187 						if ( nEdges & 8 )
188 							bOpen = sal_True;	// obere Kante oeffnet, weitersehen
189 						else if ( !bOpen )
190 							return sal_True;	// es gibt was, was nicht geoeffnet wurde
191 						else if ( nEdges & 1 )
192 							bFound = sal_True;	// mittendrin, alles selektiert?
193 						// (4 und nicht 16) oder (16 und nicht 4)
194 						if ( (((nEdges & 4) | 16) ^ ((nEdges & 16) | 4)) )
195 							bFound = sal_True;	// nur linke/rechte Kante, alles selektiert?
196 						if ( nEdges & 2 )
197 							bOpen = sal_False;	// untere Kante schliesst
198 
199 						if ( bFound )
200 						{	// alles selektiert?
201 							if ( aCurOrg != aOrg )
202 							{	// neue Matrix zu pruefen?
203 								aCurOrg = aOrg;
204 								ScFormulaCell* pFCell;
205 								if ( ((ScFormulaCell*)pCell)->GetMatrixFlag()
206 										== MM_REFERENCE )
207 									pFCell = (ScFormulaCell*) pDocument->GetCell( aOrg );
208 								else
209 									pFCell = (ScFormulaCell*)pCell;
210                                 SCCOL nC;
211                                 SCROW nR;
212                                 pFCell->GetMatColsRows( nC, nR );
213 								ScRange aRange( aOrg, ScAddress(
214 									aOrg.Col() + nC - 1, aOrg.Row() + nR - 1,
215 									aOrg.Tab() ) );
216 								if ( rMark.IsAllMarked( aRange ) )
217 									bFound = sal_False;
218 							}
219 							else
220 								bFound = sal_False;		// war schon
221 						}
222 					}
223 				}
224 				nIndex++;
225 			}
226 			if ( bOpen )
227 				return sal_True;
228 		}
229 		return bFound;
230 	}
231 	else
232 		return sal_False;
233 }
234 
235 
236 //UNUSED2009-05 sal_Bool ScColumn::HasLines( SCROW nRow1, SCROW nRow2, Rectangle& rSizes,
237 //UNUSED2009-05                             sal_Bool bLeft, sal_Bool bRight ) const
238 //UNUSED2009-05 {
239 //UNUSED2009-05     return pAttrArray->HasLines( nRow1, nRow2, rSizes, bLeft, bRight );
240 //UNUSED2009-05 }
241 
242 
HasAttrib(SCROW nRow1,SCROW nRow2,sal_uInt16 nMask) const243 bool ScColumn::HasAttrib( SCROW nRow1, SCROW nRow2, sal_uInt16 nMask ) const
244 {
245 	return pAttrArray->HasAttrib( nRow1, nRow2, nMask );
246 }
247 
248 
HasAttribSelection(const ScMarkData & rMark,sal_uInt16 nMask) const249 sal_Bool ScColumn::HasAttribSelection( const ScMarkData& rMark, sal_uInt16 nMask ) const
250 {
251 	sal_Bool bFound = sal_False;
252 
253 	SCROW nTop;
254 	SCROW nBottom;
255 
256 	if (rMark.IsMultiMarked())
257 	{
258 		ScMarkArrayIter aMarkIter( rMark.GetArray()+nCol );
259 		while (aMarkIter.Next( nTop, nBottom ) && !bFound)
260 		{
261 			if (pAttrArray->HasAttrib( nTop, nBottom, nMask ))
262 				bFound = sal_True;
263 		}
264 	}
265 
266 	return bFound;
267 }
268 
269 
ExtendMerge(SCCOL nThisCol,SCROW nStartRow,SCROW nEndRow,SCCOL & rPaintCol,SCROW & rPaintRow,sal_Bool bRefresh,sal_Bool bAttrs)270 sal_Bool ScColumn::ExtendMerge( SCCOL nThisCol, SCROW nStartRow, SCROW nEndRow,
271 							SCCOL& rPaintCol, SCROW& rPaintRow,
272 							sal_Bool bRefresh, sal_Bool bAttrs )
273 {
274 	return pAttrArray->ExtendMerge( nThisCol, nStartRow, nEndRow, rPaintCol, rPaintRow, bRefresh, bAttrs );
275 }
276 
277 
MergeSelectionPattern(ScMergePatternState & rState,const ScMarkData & rMark,sal_Bool bDeep) const278 void ScColumn::MergeSelectionPattern( ScMergePatternState& rState, const ScMarkData& rMark, sal_Bool bDeep ) const
279 {
280 	SCROW nTop;
281 	SCROW nBottom;
282 
283 	if ( rMark.IsMultiMarked() )
284 	{
285         const ScMarkArray* pArray = rMark.GetArray() + nCol;
286         if ( pArray->HasMarks() )
287         {
288             ScMarkArrayIter aMarkIter( pArray );
289             while (aMarkIter.Next( nTop, nBottom ))
290                 pAttrArray->MergePatternArea( nTop, nBottom, rState, bDeep );
291         }
292 	}
293 }
294 
295 
MergePatternArea(ScMergePatternState & rState,SCROW nRow1,SCROW nRow2,sal_Bool bDeep) const296 void ScColumn::MergePatternArea( ScMergePatternState& rState, SCROW nRow1, SCROW nRow2, sal_Bool bDeep ) const
297 {
298 	pAttrArray->MergePatternArea( nRow1, nRow2, rState, bDeep );
299 }
300 
301 
MergeBlockFrame(SvxBoxItem * pLineOuter,SvxBoxInfoItem * pLineInner,ScLineFlags & rFlags,SCROW nStartRow,SCROW nEndRow,sal_Bool bLeft,SCCOL nDistRight) const302 void ScColumn::MergeBlockFrame( SvxBoxItem* pLineOuter, SvxBoxInfoItem* pLineInner,
303 							ScLineFlags& rFlags,
304 							SCROW nStartRow, SCROW nEndRow, sal_Bool bLeft, SCCOL nDistRight ) const
305 {
306 	pAttrArray->MergeBlockFrame( pLineOuter, pLineInner, rFlags, nStartRow, nEndRow, bLeft, nDistRight );
307 }
308 
309 
ApplyBlockFrame(const SvxBoxItem * pLineOuter,const SvxBoxInfoItem * pLineInner,SCROW nStartRow,SCROW nEndRow,sal_Bool bLeft,SCCOL nDistRight)310 void ScColumn::ApplyBlockFrame( const SvxBoxItem* pLineOuter, const SvxBoxInfoItem* pLineInner,
311 							SCROW nStartRow, SCROW nEndRow, sal_Bool bLeft, SCCOL nDistRight )
312 {
313 	pAttrArray->ApplyBlockFrame( pLineOuter, pLineInner, nStartRow, nEndRow, bLeft, nDistRight );
314 }
315 
316 
GetPattern(SCROW nRow) const317 const ScPatternAttr* ScColumn::GetPattern( SCROW nRow ) const
318 {
319 	return pAttrArray->GetPattern( nRow );
320 }
321 
GetPatternRange(SCROW & rStartRow,SCROW & rEndRow,SCROW nRow) const322 const ScPatternAttr* ScColumn::GetPatternRange( SCROW& rStartRow, SCROW& rEndRow, SCROW nRow ) const
323 {
324 	return pAttrArray->GetPatternRange( rStartRow, rEndRow, nRow );
325 }
326 
GetAttr(SCROW nRow,sal_uInt16 nWhich) const327 const SfxPoolItem* ScColumn::GetAttr( SCROW nRow, sal_uInt16 nWhich ) const
328 {
329 	return &pAttrArray->GetPattern( nRow )->GetItemSet().Get(nWhich);
330 }
331 
332 
GetMostUsedPattern(SCROW nStartRow,SCROW nEndRow) const333 const ScPatternAttr* ScColumn::GetMostUsedPattern( SCROW nStartRow, SCROW nEndRow ) const
334 {
335     ::std::map< const ScPatternAttr*, size_t > aAttrMap;
336     const ScPatternAttr* pMaxPattern = 0;
337     size_t nMaxCount = 0;
338 
339     ScAttrIterator aAttrIter( pAttrArray, nStartRow, nEndRow );
340     const ScPatternAttr* pPattern;
341     SCROW nAttrRow1 = 0, nAttrRow2 = 0;
342 
343     while( (pPattern = aAttrIter.Next( nAttrRow1, nAttrRow2 )) != 0 )
344     {
345         size_t& rnCount = aAttrMap[ pPattern ];
346         rnCount += (nAttrRow2 - nAttrRow1 + 1);
347         if( rnCount > nMaxCount )
348         {
349             pMaxPattern = pPattern;
350             nMaxCount = rnCount;
351         }
352     }
353 
354     return pMaxPattern;
355 }
356 
357 
GetNumberFormat(SCROW nRow) const358 sal_uLong ScColumn::GetNumberFormat( SCROW nRow ) const
359 {
360 	return pAttrArray->GetPattern( nRow )->GetNumberFormat( pDocument->GetFormatTable() );
361 }
362 
363 
ApplySelectionCache(SfxItemPoolCache * pCache,const ScMarkData & rMark)364 SCsROW ScColumn::ApplySelectionCache( SfxItemPoolCache* pCache, const ScMarkData& rMark )
365 {
366     SCROW nTop = 0;
367     SCROW nBottom = 0;
368 	sal_Bool bFound = sal_False;
369 
370 	if ( rMark.IsMultiMarked() )
371 	{
372 		ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol );
373 		while (aMarkIter.Next( nTop, nBottom ))
374 		{
375 			pAttrArray->ApplyCacheArea( nTop, nBottom, pCache );
376 			bFound = sal_True;
377 		}
378 	}
379 
380 	if (!bFound)
381 		return -1;
382 	else if (nTop==0 && nBottom==MAXROW)
383 		return 0;
384 	else
385 		return nBottom;
386 }
387 
388 
ChangeSelectionIndent(sal_Bool bIncrement,const ScMarkData & rMark)389 void ScColumn::ChangeSelectionIndent( sal_Bool bIncrement, const ScMarkData& rMark )
390 {
391 	SCROW nTop;
392 	SCROW nBottom;
393 
394 	if ( pAttrArray && rMark.IsMultiMarked() )
395 	{
396 		ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol );
397 		while (aMarkIter.Next( nTop, nBottom ))
398 			pAttrArray->ChangeIndent(nTop, nBottom, bIncrement);
399 	}
400 }
401 
402 
ClearSelectionItems(const sal_uInt16 * pWhich,const ScMarkData & rMark)403 void ScColumn::ClearSelectionItems( const sal_uInt16* pWhich,const ScMarkData& rMark )
404 {
405 	SCROW nTop;
406 	SCROW nBottom;
407 
408 	if ( pAttrArray && rMark.IsMultiMarked() )
409 	{
410 		ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol );
411 		while (aMarkIter.Next( nTop, nBottom ))
412 			pAttrArray->ClearItems(nTop, nBottom, pWhich);
413 	}
414 }
415 
416 
DeleteSelection(sal_uInt16 nDelFlag,const ScMarkData & rMark)417 void ScColumn::DeleteSelection( sal_uInt16 nDelFlag, const ScMarkData& rMark )
418 {
419 	SCROW nTop;
420 	SCROW nBottom;
421 
422 	if ( rMark.IsMultiMarked() )
423 	{
424 		ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol );
425 		while (aMarkIter.Next( nTop, nBottom ))
426             DeleteArea(nTop, nBottom, nDelFlag);
427 	}
428 }
429 
430 
ApplyPattern(SCROW nRow,const ScPatternAttr & rPatAttr)431 void ScColumn::ApplyPattern( SCROW nRow, const ScPatternAttr& rPatAttr )
432 {
433 	const SfxItemSet* pSet = &rPatAttr.GetItemSet();
434 	SfxItemPoolCache aCache( pDocument->GetPool(), pSet );
435 
436 	const ScPatternAttr* pPattern = pAttrArray->GetPattern( nRow );
437 
438 	//	sal_True = alten Eintrag behalten
439 
440 	ScPatternAttr* pNewPattern = (ScPatternAttr*) &aCache.ApplyTo( *pPattern, sal_True );
441 	ScDocumentPool::CheckRef( *pPattern );
442 	ScDocumentPool::CheckRef( *pNewPattern );
443 
444 	if (pNewPattern != pPattern)
445 	  pAttrArray->SetPattern( nRow, pNewPattern );
446 }
447 
448 
ApplyPatternArea(SCROW nStartRow,SCROW nEndRow,const ScPatternAttr & rPatAttr)449 void ScColumn::ApplyPatternArea( SCROW nStartRow, SCROW nEndRow, const ScPatternAttr& rPatAttr )
450 {
451 	const SfxItemSet* pSet = &rPatAttr.GetItemSet();
452 	SfxItemPoolCache aCache( pDocument->GetPool(), pSet );
453 	pAttrArray->ApplyCacheArea( nStartRow, nEndRow, &aCache );
454 }
455 
456 
ApplyPatternIfNumberformatIncompatible(const ScRange & rRange,const ScPatternAttr & rPattern,short nNewType)457 void ScColumn::ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,
458 		const ScPatternAttr& rPattern, short nNewType )
459 {
460 	const SfxItemSet* pSet = &rPattern.GetItemSet();
461 	SfxItemPoolCache aCache( pDocument->GetPool(), pSet );
462 	SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
463 	SCROW nEndRow = rRange.aEnd.Row();
464 	for ( SCROW nRow = rRange.aStart.Row(); nRow <= nEndRow; nRow++ )
465 	{
466 		SCROW nRow1, nRow2;
467 		const ScPatternAttr* pPattern = pAttrArray->GetPatternRange(
468 			nRow1, nRow2, nRow );
469 		sal_uLong nFormat = pPattern->GetNumberFormat( pFormatter );
470 		short nOldType = pFormatter->GetType( nFormat );
471 		if ( nOldType == nNewType || pFormatter->IsCompatible( nOldType, nNewType ) )
472 			nRow = nRow2;
473 		else
474 		{
475 			SCROW nNewRow1 = Max( nRow1, nRow );
476 			SCROW nNewRow2 = Min( nRow2, nEndRow );
477 			pAttrArray->ApplyCacheArea( nNewRow1, nNewRow2, &aCache );
478 			nRow = nNewRow2;
479 		}
480 	}
481 }
482 
483 
ApplyStyle(SCROW nRow,const ScStyleSheet & rStyle)484 void ScColumn::ApplyStyle( SCROW nRow, const ScStyleSheet& rStyle )
485 {
486 	const ScPatternAttr* pPattern = pAttrArray->GetPattern(nRow);
487 	ScPatternAttr* pNewPattern = new ScPatternAttr(*pPattern);
488 	if (pNewPattern)
489 	{
490 		pNewPattern->SetStyleSheet((ScStyleSheet*)&rStyle);
491 		pAttrArray->SetPattern(nRow, pNewPattern, sal_True);
492 		delete pNewPattern;
493 	}
494 }
495 
496 
ApplyStyleArea(SCROW nStartRow,SCROW nEndRow,const ScStyleSheet & rStyle)497 void ScColumn::ApplyStyleArea( SCROW nStartRow, SCROW nEndRow, const ScStyleSheet& rStyle )
498 {
499 	pAttrArray->ApplyStyleArea(nStartRow, nEndRow, (ScStyleSheet*)&rStyle);
500 }
501 
502 
ApplySelectionStyle(const ScStyleSheet & rStyle,const ScMarkData & rMark)503 void ScColumn::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark)
504 {
505 	SCROW nTop;
506 	SCROW nBottom;
507 
508 	if ( rMark.IsMultiMarked() )
509 	{
510 		ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol );
511 		while (aMarkIter.Next( nTop, nBottom ))
512 			pAttrArray->ApplyStyleArea(nTop, nBottom, (ScStyleSheet*)&rStyle);
513 	}
514 }
515 
516 
ApplySelectionLineStyle(const ScMarkData & rMark,const SvxBorderLine * pLine,sal_Bool bColorOnly)517 void ScColumn::ApplySelectionLineStyle( const ScMarkData& rMark,
518 									const SvxBorderLine* pLine, sal_Bool bColorOnly )
519 {
520 	if ( bColorOnly && !pLine )
521 		return;
522 
523 	SCROW nTop;
524 	SCROW nBottom;
525 
526 	if (rMark.IsMultiMarked())
527 	{
528 		ScMarkArrayIter aMarkIter( rMark.GetArray()+nCol );
529 		while (aMarkIter.Next( nTop, nBottom ))
530 			pAttrArray->ApplyLineStyleArea(nTop, nBottom, pLine, bColorOnly );
531 	}
532 }
533 
534 
GetStyle(SCROW nRow) const535 const ScStyleSheet* ScColumn::GetStyle( SCROW nRow ) const
536 {
537 	return pAttrArray->GetPattern( nRow )->GetStyleSheet();
538 }
539 
540 
GetSelectionStyle(const ScMarkData & rMark,sal_Bool & rFound) const541 const ScStyleSheet* ScColumn::GetSelectionStyle( const ScMarkData& rMark, sal_Bool& rFound ) const
542 {
543 	rFound = sal_False;
544 	if (!rMark.IsMultiMarked())
545 	{
546 		DBG_ERROR("ScColumn::GetSelectionStyle ohne Selektion");
547 		return NULL;
548 	}
549 
550 	sal_Bool bEqual = sal_True;
551 
552 	const ScStyleSheet* pStyle = NULL;
553 	const ScStyleSheet* pNewStyle;
554 
555 	ScMarkArrayIter aMarkIter( rMark.GetArray() + nCol );
556 	SCROW nTop;
557 	SCROW nBottom;
558 	while (bEqual && aMarkIter.Next( nTop, nBottom ))
559 	{
560 		ScAttrIterator aAttrIter( pAttrArray, nTop, nBottom );
561 		SCROW nRow;
562 		SCROW nDummy;
563 		const ScPatternAttr* pPattern;
564         while (bEqual && ( pPattern = aAttrIter.Next( nRow, nDummy ) ) != NULL)
565 		{
566 			pNewStyle = pPattern->GetStyleSheet();
567 			rFound = sal_True;
568 			if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
569 				bEqual = sal_False;												// unterschiedliche
570 			pStyle = pNewStyle;
571 		}
572 	}
573 
574 	return bEqual ? pStyle : NULL;
575 }
576 
577 
GetAreaStyle(sal_Bool & rFound,SCROW nRow1,SCROW nRow2) const578 const ScStyleSheet*	ScColumn::GetAreaStyle( sal_Bool& rFound, SCROW nRow1, SCROW nRow2 ) const
579 {
580 	rFound = sal_False;
581 
582 	sal_Bool bEqual = sal_True;
583 
584 	const ScStyleSheet* pStyle = NULL;
585 	const ScStyleSheet* pNewStyle;
586 
587 	ScAttrIterator aAttrIter( pAttrArray, nRow1, nRow2 );
588 	SCROW nRow;
589 	SCROW nDummy;
590 	const ScPatternAttr* pPattern;
591     while (bEqual && ( pPattern = aAttrIter.Next( nRow, nDummy ) ) != NULL)
592 	{
593 		pNewStyle = pPattern->GetStyleSheet();
594 		rFound = sal_True;
595 		if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
596 			bEqual = sal_False;												// unterschiedliche
597 		pStyle = pNewStyle;
598 	}
599 
600 	return bEqual ? pStyle : NULL;
601 }
602 
FindStyleSheet(const SfxStyleSheetBase * pStyleSheet,ScFlatBoolRowSegments & rUsedRows,bool bReset)603 void ScColumn::FindStyleSheet( const SfxStyleSheetBase* pStyleSheet, ScFlatBoolRowSegments& rUsedRows, bool bReset )
604 {
605     pAttrArray->FindStyleSheet( pStyleSheet, rUsedRows, bReset );
606 }
607 
IsStyleSheetUsed(const ScStyleSheet & rStyle,sal_Bool bGatherAllStyles) const608 sal_Bool ScColumn::IsStyleSheetUsed( const ScStyleSheet& rStyle, sal_Bool bGatherAllStyles ) const
609 {
610 	return pAttrArray->IsStyleSheetUsed( rStyle, bGatherAllStyles );
611 }
612 
613 
ApplyFlags(SCROW nStartRow,SCROW nEndRow,sal_Int16 nFlags)614 sal_Bool ScColumn::ApplyFlags( SCROW nStartRow, SCROW nEndRow, sal_Int16 nFlags )
615 {
616 	return pAttrArray->ApplyFlags( nStartRow, nEndRow, nFlags );
617 }
618 
619 
RemoveFlags(SCROW nStartRow,SCROW nEndRow,sal_Int16 nFlags)620 sal_Bool ScColumn::RemoveFlags( SCROW nStartRow, SCROW nEndRow, sal_Int16 nFlags )
621 {
622 	return pAttrArray->RemoveFlags( nStartRow, nEndRow, nFlags );
623 }
624 
625 
ClearItems(SCROW nStartRow,SCROW nEndRow,const sal_uInt16 * pWhich)626 void ScColumn::ClearItems( SCROW nStartRow, SCROW nEndRow, const sal_uInt16* pWhich )
627 {
628 	pAttrArray->ClearItems( nStartRow, nEndRow, pWhich );
629 }
630 
631 
SetPattern(SCROW nRow,const ScPatternAttr & rPatAttr,sal_Bool bPutToPool)632 void ScColumn::SetPattern( SCROW nRow, const ScPatternAttr& rPatAttr, sal_Bool bPutToPool )
633 {
634 	pAttrArray->SetPattern( nRow, &rPatAttr, bPutToPool );
635 }
636 
637 
SetPatternArea(SCROW nStartRow,SCROW nEndRow,const ScPatternAttr & rPatAttr,sal_Bool bPutToPool)638 void ScColumn::SetPatternArea( SCROW nStartRow, SCROW nEndRow,
639 								const ScPatternAttr& rPatAttr, sal_Bool bPutToPool )
640 {
641 	pAttrArray->SetPatternArea( nStartRow, nEndRow, &rPatAttr, bPutToPool );
642 }
643 
644 
ApplyAttr(SCROW nRow,const SfxPoolItem & rAttr)645 void ScColumn::ApplyAttr( SCROW nRow, const SfxPoolItem& rAttr )
646 {
647 	//	um nur ein neues SetItem zu erzeugen, brauchen wir keinen SfxItemPoolCache.
648 	//!	Achtung: der SfxItemPoolCache scheint zuviele Refs fuer das neue SetItem zu erzeugen ??
649 
650 	ScDocumentPool* pDocPool = pDocument->GetPool();
651 
652 	const ScPatternAttr* pOldPattern = pAttrArray->GetPattern( nRow );
653 	ScPatternAttr* pTemp = new ScPatternAttr(*pOldPattern);
654 	pTemp->GetItemSet().Put(rAttr);
655 	const ScPatternAttr* pNewPattern = (const ScPatternAttr*) &pDocPool->Put( *pTemp );
656 
657 	if ( pNewPattern != pOldPattern )
658 		pAttrArray->SetPattern( nRow, pNewPattern );
659 	else
660 		pDocPool->Remove( *pNewPattern );		// ausser Spesen nichts gewesen
661 
662 	delete pTemp;
663 
664 		// alte Version mit SfxItemPoolCache:
665 #if 0
666 	SfxItemPoolCache aCache( pDocument->GetPool(), &rAttr );
667 
668 	const ScPatternAttr* pPattern = pAttrArray->GetPattern( nRow );
669 
670 	//	sal_True = alten Eintrag behalten
671 
672 	ScPatternAttr* pNewPattern = (ScPatternAttr*) &aCache.ApplyTo( *pPattern, sal_True );
673 	ScDocumentPool::CheckRef( *pPattern );
674 	ScDocumentPool::CheckRef( *pNewPattern );
675 
676 	if (pNewPattern != pPattern)
677 	  pAttrArray->SetPattern( nRow, pNewPattern );
678 #endif
679 }
680 
681 #ifdef _MSC_VER
682 #pragma optimize ( "", off )
683 #endif
684 
685 
Search(SCROW nRow,SCSIZE & nIndex) const686 sal_Bool ScColumn::Search( SCROW nRow, SCSIZE& nIndex ) const
687 {
688 	if ( !pItems || !nCount )
689 	{
690 		nIndex = 0;
691 		return sal_False;
692 	}
693 	SCROW nMinRow = pItems[0].nRow;
694 	if ( nRow <= nMinRow )
695 	{
696 		nIndex = 0;
697 		return nRow == nMinRow;
698 	}
699 	SCROW nMaxRow = pItems[nCount-1].nRow;
700 	if ( nRow >= nMaxRow )
701 	{
702 		if ( nRow == nMaxRow )
703 		{
704 			nIndex = nCount - 1;
705 			return sal_True;
706 		}
707 		else
708 		{
709 			nIndex = nCount;
710 			return sal_False;
711 		}
712 	}
713 
714 	long nOldLo, nOldHi;
715 	long	nLo 	= nOldLo = 0;
716     long	nHi 	= nOldHi = Min(static_cast<long>(nCount)-1, static_cast<long>(nRow) );
717 	long	i		= 0;
718 	sal_Bool	bFound	= sal_False;
719 	// quite continuous distribution? => interpolating search
720 	sal_Bool	bInterpol = (static_cast<SCSIZE>(nMaxRow - nMinRow) < nCount * 2);
721 	SCROW	nR;
722 
723 	while ( !bFound && nLo <= nHi )
724 	{
725 		if ( !bInterpol || nHi - nLo < 3 )
726 			i = (nLo+nHi) / 2;			// no effort, no division by zero
727 		else
728 		{	// interpolating search
729 			long nLoRow = pItems[nLo].nRow;		// no unsigned underflow upon substraction
730 			i = nLo + (long)((long)(nRow - nLoRow) * (nHi - nLo)
731 				/ (pItems[nHi].nRow - nLoRow));
732 			if ( i < 0 || static_cast<SCSIZE>(i) >= nCount )
733 			{	// oops ...
734 				i = (nLo+nHi) / 2;
735 				bInterpol = sal_False;
736 			}
737 		}
738 		nR = pItems[i].nRow;
739 		if ( nR < nRow )
740 		{
741 			nLo = i+1;
742 			if ( bInterpol )
743 			{
744 				if ( nLo <= nOldLo )
745 					bInterpol = sal_False;
746 				else
747 					nOldLo = nLo;
748 			}
749 		}
750 		else
751 		{
752 			if ( nR > nRow )
753 			{
754 				nHi = i-1;
755 				if ( bInterpol )
756 				{
757 					if ( nHi >= nOldHi )
758 						bInterpol = sal_False;
759 					else
760 						nOldHi = nHi;
761 				}
762 			}
763 			else
764 				bFound = sal_True;
765 		}
766 	}
767 	if (bFound)
768 		nIndex = static_cast<SCSIZE>(i);
769 	else
770 		nIndex = static_cast<SCSIZE>(nLo); // rear index
771 	return bFound;
772 }
773 
774 #ifdef _MSC_VER
775 #pragma optimize ( "", on )
776 #endif
777 
778 
GetCell(SCROW nRow) const779 ScBaseCell* ScColumn::GetCell( SCROW nRow ) const
780 {
781 	SCSIZE nIndex;
782 	if (Search(nRow, nIndex))
783 		return pItems[nIndex].pCell;
784 	return NULL;
785 }
786 
787 
Resize(SCSIZE nSize)788 void ScColumn::Resize( SCSIZE nSize )
789 {
790     if (nSize > sal::static_int_cast<SCSIZE>(MAXROWCOUNT))
791 		nSize = MAXROWCOUNT;
792 	if (nSize < nCount)
793 		nSize = nCount;
794 
795 	ColEntry* pNewItems;
796 	if (nSize)
797 	{
798 		SCSIZE nNewSize = nSize + COLUMN_DELTA - 1;
799 		nNewSize -= nNewSize % COLUMN_DELTA;
800 		nLimit = nNewSize;
801 		pNewItems = new ColEntry[nLimit];
802 	}
803 	else
804 	{
805 		nLimit = 0;
806 		pNewItems = NULL;
807 	}
808 	if (pItems)
809 	{
810 		if (pNewItems)
811 			memmove( pNewItems, pItems, nCount * sizeof(ColEntry) );
812 		delete[] pItems;
813 	}
814 	pItems = pNewItems;
815 }
816 
817 //	SwapRow zum Sortieren
818 
819 namespace {
820 
821 /** Moves broadcaster from old cell to new cell if exists, otherwise creates a new note cell. */
lclTakeBroadcaster(ScBaseCell * & rpCell,SvtBroadcaster * pBC)822 void lclTakeBroadcaster( ScBaseCell*& rpCell, SvtBroadcaster* pBC )
823 {
824     if( pBC )
825     {
826         if( rpCell )
827             rpCell->TakeBroadcaster( pBC );
828         else
829             rpCell = new ScNoteCell( pBC );
830     }
831 }
832 
833 } // namespace
834 
SwapRow(SCROW nRow1,SCROW nRow2)835 void ScColumn::SwapRow(SCROW nRow1, SCROW nRow2)
836 {
837     /*  Simple swap of cell pointers does not work if broadcasters exist (crash
838         if cell broadcasts directly or indirectly to itself). While swapping
839         the cells, broadcasters have to remain at old positions! */
840 
841     /*  While cloning cells, do not clone notes, but move note pointers to new
842         cells. This prevents creation of new caption drawing objects for every
843         swap operation while sorting. */
844 
845 	ScBaseCell* pCell1 = 0;
846 	SCSIZE nIndex1;
847 	if ( Search( nRow1, nIndex1 ) )
848 		pCell1 = pItems[nIndex1].pCell;
849 
850     ScBaseCell* pCell2 = 0;
851 	SCSIZE nIndex2;
852 	if ( Search( nRow2, nIndex2 ) )
853 		pCell2 = pItems[nIndex2].pCell;
854 
855     // no cells found, nothing to do
856 	if ( !pCell1 && !pCell2 )
857 		return ;
858 
859     // swap variables if first cell is empty, to save some code below
860     if ( !pCell1 )
861     {
862         ::std::swap( nRow1, nRow2 );
863         ::std::swap( nIndex1, nIndex2 );
864         ::std::swap( pCell1, pCell2 );
865     }
866 
867     // from here: first cell (pCell1, nIndex1) exists always
868 
869     ScAddress aPos1( nCol, nRow1, nTab );
870     ScAddress aPos2( nCol, nRow2, nTab );
871 
872 	CellType eType1 = pCell1->GetCellType();
873 	CellType eType2 = pCell2 ? pCell2->GetCellType() : CELLTYPE_NONE;
874 
875     ScFormulaCell* pFmlaCell1 = (eType1 == CELLTYPE_FORMULA) ? static_cast< ScFormulaCell* >( pCell1 ) : 0;
876     ScFormulaCell* pFmlaCell2 = (eType2 == CELLTYPE_FORMULA) ? static_cast< ScFormulaCell* >( pCell2 ) : 0;
877 
878     // simple swap if no formula cells present
879 	if ( !pFmlaCell1 && !pFmlaCell2 )
880 	{
881         // remember cell broadcasters, must remain at old position
882         SvtBroadcaster* pBC1 = pCell1->ReleaseBroadcaster();
883 
884 		if ( pCell2 )
885 		{
886             /*  Both cells exist, no formula cells involved, a simple swap can
887                 be performed (but keep broadcasters and notes at old position). */
888 			pItems[nIndex1].pCell = pCell2;
889 			pItems[nIndex2].pCell = pCell1;
890 
891             SvtBroadcaster* pBC2 = pCell2->ReleaseBroadcaster();
892             pCell1->TakeBroadcaster( pBC2 );
893             pCell2->TakeBroadcaster( pBC1 );
894 		}
895 		else
896 		{
897 			ScNoteCell* pDummyCell = pBC1 ? new ScNoteCell( pBC1 ) : 0;
898 			if ( pDummyCell )
899 			{
900                 // insert dummy note cell (without note) containing old broadcaster
901 				pItems[nIndex1].pCell = pDummyCell;
902 			}
903 			else
904 			{
905                 // remove ColEntry at old position
906 				--nCount;
907 				memmove( &pItems[nIndex1], &pItems[nIndex1 + 1], (nCount - nIndex1) * sizeof(ColEntry) );
908 				pItems[nCount].nRow = 0;
909 				pItems[nCount].pCell = 0;
910 			}
911 
912             // insert ColEntry at new position
913 			Insert( nRow2, pCell1 );
914 		}
915 
916 		return;
917 	}
918 
919 	// from here: at least one of the cells is a formula cell
920 
921     /*  Never move any array formulas. Disabling sort if parts of array
922         formulas are contained is done at UI. */
923     if ( (pFmlaCell1 && (pFmlaCell1->GetMatrixFlag() != 0)) || (pFmlaCell2 && (pFmlaCell2->GetMatrixFlag() != 0)) )
924         return;
925 
926     // do not swap, if formulas are equal
927 	if ( pFmlaCell1 && pFmlaCell2 )
928 	{
929 		ScTokenArray* pCode1 = pFmlaCell1->GetCode();
930 		ScTokenArray* pCode2 = pFmlaCell2->GetCode();
931 
932 		if (pCode1->GetLen() == pCode2->GetLen())		// nicht-UPN
933 		{
934 			sal_Bool bEqual = sal_True;
935 			sal_uInt16 nLen = pCode1->GetLen();
936 			FormulaToken** ppToken1 = pCode1->GetArray();
937 			FormulaToken** ppToken2 = pCode2->GetArray();
938 			for (sal_uInt16 i=0; i<nLen; i++)
939             {
940                 if ( !ppToken1[i]->TextEqual(*(ppToken2[i])) ||
941                         ppToken1[i]->Is3DRef() || ppToken2[i]->Is3DRef() )
942 				{
943 					bEqual = sal_False;
944 					break;
945 				}
946             }
947 
948             // do not swap formula cells with equal formulas, but swap notes
949 			if (bEqual)
950             {
951                 ScPostIt* pNote1 = pCell1->ReleaseNote();
952                 pCell1->TakeNote( pCell2->ReleaseNote() );
953                 pCell2->TakeNote( pNote1 );
954 				return;
955             }
956 		}
957 	}
958 
959 	//	hier kein UpdateReference wegen #30529# - mitsortiert werden nur noch relative Referenzen
960 //	long dy = (long)nRow2 - (long)nRow1;
961 
962     /*  Create clone of pCell1 at position of pCell2 (pCell1 exists always, see
963         variable swapping above). Do not clone the note, but move pointer of
964         old note to new cell. */
965     ScBaseCell* pNew2 = pCell1->CloneWithoutNote( *pDocument, aPos2, SC_CLONECELL_ADJUST3DREL );
966     pNew2->TakeNote( pCell1->ReleaseNote() );
967 
968     /*  Create clone of pCell2 at position of pCell1. Do not clone the note,
969         but move pointer of old note to new cell. */
970 	ScBaseCell* pNew1 = 0;
971 	if ( pCell2 )
972 	{
973         pNew1 = pCell2->CloneWithoutNote( *pDocument, aPos1, SC_CLONECELL_ADJUST3DREL );
974         pNew1->TakeNote( pCell2->ReleaseNote() );
975 	}
976 
977     // move old broadcasters new cells at the same old position
978     SvtBroadcaster* pBC1 = pCell1->ReleaseBroadcaster();
979     lclTakeBroadcaster( pNew1, pBC1 );
980     SvtBroadcaster* pBC2 = pCell2 ? pCell2->ReleaseBroadcaster() : 0;
981     lclTakeBroadcaster( pNew2, pBC2 );
982 
983 	/*  Insert the new cells. Old cell has to be deleted, if there is no new
984         cell (call to Insert deletes old cell by itself). */
985 	if ( !pNew1 )
986 		Delete( nRow1 );            // deletes pCell1
987 	else
988         Insert( nRow1, pNew1 );     // deletes pCell1, inserts pNew1
989 
990 	if ( pCell2 && !pNew2 )
991 		Delete( nRow2 );            // deletes pCell2
992 	else if ( pNew2 )
993 		Insert( nRow2, pNew2 );     // deletes pCell2 (if existing), inserts pNew2
994 }
995 
996 
SwapCell(SCROW nRow,ScColumn & rCol)997 void ScColumn::SwapCell( SCROW nRow, ScColumn& rCol)
998 {
999 	ScBaseCell* pCell1 = 0;
1000 	SCSIZE nIndex1;
1001 	if ( Search( nRow, nIndex1 ) )
1002 		pCell1 = pItems[nIndex1].pCell;
1003 
1004     ScBaseCell* pCell2 = 0;
1005 	SCSIZE nIndex2;
1006 	if ( rCol.Search( nRow, nIndex2 ) )
1007 		pCell2 = rCol.pItems[nIndex2].pCell;
1008 
1009     // reverse call if own cell is missing (ensures own existing cell in following code)
1010     if( !pCell1 )
1011     {
1012         if( pCell2 )
1013             rCol.SwapCell( nRow, *this );
1014         return;
1015     }
1016 
1017     // from here: own cell (pCell1, nIndex1) exists always
1018 
1019     ScFormulaCell* pFmlaCell1 = (pCell1->GetCellType() == CELLTYPE_FORMULA) ? static_cast< ScFormulaCell* >( pCell1 ) : 0;
1020 	ScFormulaCell* pFmlaCell2 = (pCell2 && (pCell2->GetCellType() == CELLTYPE_FORMULA)) ? static_cast< ScFormulaCell* >( pCell2 ) : 0;
1021 
1022 	if ( pCell2 )
1023 	{
1024 		// Tauschen
1025 		pItems[nIndex1].pCell = pCell2;
1026 		rCol.pItems[nIndex2].pCell = pCell1;
1027 		// Referenzen aktualisieren
1028 		SCsCOL dx = rCol.nCol - nCol;
1029 		if ( pFmlaCell1 )
1030 		{
1031 			ScRange aRange( ScAddress( rCol.nCol, 0, nTab ),
1032 							ScAddress( rCol.nCol, MAXROW, nTab ) );
1033 			pFmlaCell1->aPos.SetCol( rCol.nCol );
1034 			pFmlaCell1->UpdateReference(URM_MOVE, aRange, dx, 0, 0);
1035 		}
1036 		if ( pFmlaCell2 )
1037 		{
1038 			ScRange aRange( ScAddress( nCol, 0, nTab ),
1039 							ScAddress( nCol, MAXROW, nTab ) );
1040 			pFmlaCell2->aPos.SetCol( nCol );
1041 			pFmlaCell2->UpdateReference(URM_MOVE, aRange, -dx, 0, 0);
1042 		}
1043 	}
1044 	else
1045     {
1046         // Loeschen
1047         --nCount;
1048         memmove( &pItems[nIndex1], &pItems[nIndex1 + 1], (nCount - nIndex1) * sizeof(ColEntry) );
1049         pItems[nCount].nRow = 0;
1050         pItems[nCount].pCell = 0;
1051         // Referenzen aktualisieren
1052         SCsCOL dx = rCol.nCol - nCol;
1053         if ( pFmlaCell1 )
1054         {
1055             ScRange aRange( ScAddress( rCol.nCol, 0, nTab ),
1056                             ScAddress( rCol.nCol, MAXROW, nTab ) );
1057             pFmlaCell1->aPos.SetCol( rCol.nCol );
1058             pFmlaCell1->UpdateReference(URM_MOVE, aRange, dx, 0, 0);
1059         }
1060         // Einfuegen
1061         rCol.Insert(nRow, pCell1);
1062     }
1063 }
1064 
1065 
TestInsertCol(SCROW nStartRow,SCROW nEndRow) const1066 sal_Bool ScColumn::TestInsertCol( SCROW nStartRow, SCROW nEndRow) const
1067 {
1068 	if (!IsEmpty())
1069 	{
1070 		sal_Bool bTest = sal_True;
1071 		if (pItems)
1072 			for (SCSIZE i=0; (i<nCount) && bTest; i++)
1073 				bTest = (pItems[i].nRow < nStartRow) || (pItems[i].nRow > nEndRow)
1074                         || pItems[i].pCell->IsBlank();
1075 
1076 		//	AttrArray testet nur zusammengefasste
1077 
1078 		if ((bTest) && (pAttrArray))
1079 			bTest = pAttrArray->TestInsertCol(nStartRow, nEndRow);
1080 
1081 		//!		rausgeschobene Attribute bei Undo beruecksichtigen
1082 
1083 		return bTest;
1084 	}
1085 	else
1086 		return sal_True;
1087 }
1088 
1089 
TestInsertRow(SCSIZE nSize) const1090 sal_Bool ScColumn::TestInsertRow( SCSIZE nSize ) const
1091 {
1092     //  AttrArray only looks for merged cells
1093 
1094 	if ( pItems && nCount )
1095         return ( nSize <= sal::static_int_cast<SCSIZE>(MAXROW) &&
1096                  pItems[nCount-1].nRow <= MAXROW-(SCROW)nSize && pAttrArray->TestInsertRow( nSize ) );
1097 	else
1098 		return pAttrArray->TestInsertRow( nSize );
1099 
1100 #if 0
1101 	//!		rausgeschobene Attribute bei Undo beruecksichtigen
1102 
1103 	if ( nSize > static_cast<SCSIZE>(MAXROW) )
1104 		return sal_False;
1105 
1106 	SCSIZE nVis = nCount;
1107     while ( nVis && pItems[nVis-1].pCell->IsBlank() )
1108 		--nVis;
1109 
1110 	if ( nVis )
1111 		return ( pItems[nVis-1].nRow <= MAXROW-nSize );
1112 	else
1113 		return sal_True;
1114 #endif
1115 }
1116 
1117 
InsertRow(SCROW nStartRow,SCSIZE nSize)1118 void ScColumn::InsertRow( SCROW nStartRow, SCSIZE nSize )
1119 {
1120 	pAttrArray->InsertRow( nStartRow, nSize );
1121 
1122 	//!	Search
1123 
1124 	if ( !pItems || !nCount )
1125 		return;
1126 
1127 	SCSIZE i;
1128 	Search( nStartRow, i );
1129 	if ( i >= nCount )
1130 		return ;
1131 
1132 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1133 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1134 
1135 	SCSIZE nNewCount = nCount;
1136 	sal_Bool bCountChanged = sal_False;
1137 	ScAddress aAdr( nCol, 0, nTab );
1138     ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL );    // only areas (ScBaseCell* == NULL)
1139     ScAddress& rAddress = aHint.GetAddress();
1140     // for sparse occupation use single broadcasts, not ranges
1141     sal_Bool bSingleBroadcasts = (((pItems[nCount-1].nRow - pItems[i].nRow) /
1142                 (nCount - i)) > 1);
1143     if ( bSingleBroadcasts )
1144     {
1145         SCROW nLastBroadcast = MAXROW+1;
1146         for ( ; i < nCount; i++)
1147         {
1148             SCROW nOldRow = pItems[i].nRow;
1149             // #43940# Aenderung Quelle broadcasten
1150             if ( nLastBroadcast != nOldRow )
1151             {   // direkt aufeinanderfolgende nicht doppelt broadcasten
1152                 rAddress.SetRow( nOldRow );
1153                 pDocument->AreaBroadcast( aHint );
1154             }
1155             SCROW nNewRow = (pItems[i].nRow += nSize);
1156             // #43940# Aenderung Ziel broadcasten
1157             rAddress.SetRow( nNewRow );
1158             pDocument->AreaBroadcast( aHint );
1159             nLastBroadcast = nNewRow;
1160             ScBaseCell* pCell = pItems[i].pCell;
1161             if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1162                 ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
1163             if ( nNewRow > MAXROW && !bCountChanged )
1164             {
1165                 nNewCount = i;
1166                 bCountChanged = sal_True;
1167             }
1168         }
1169     }
1170     else
1171     {
1172         rAddress.SetRow( pItems[i].nRow );
1173         ScRange aRange( rAddress );
1174         for ( ; i < nCount; i++)
1175         {
1176             SCROW nNewRow = (pItems[i].nRow += nSize);
1177             ScBaseCell* pCell = pItems[i].pCell;
1178             if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1179                 ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
1180             if ( nNewRow > MAXROW && !bCountChanged )
1181             {
1182                 nNewCount = i;
1183                 bCountChanged = sal_True;
1184                 aRange.aEnd.SetRow( MAXROW );
1185             }
1186         }
1187         if ( !bCountChanged )
1188             aRange.aEnd.SetRow( pItems[nCount-1].nRow );
1189         pDocument->AreaBroadcastInRange( aRange, aHint );
1190     }
1191 
1192 	if (bCountChanged)
1193 	{
1194 		SCSIZE nDelCount = nCount - nNewCount;
1195 		ScBaseCell** ppDelCells = new ScBaseCell*[nDelCount];
1196 		SCROW* pDelRows = new SCROW[nDelCount];
1197 		for (i = 0; i < nDelCount; i++)
1198 		{
1199 			ppDelCells[i] = pItems[nNewCount+i].pCell;
1200 			pDelRows[i] = pItems[nNewCount+i].nRow;
1201 		}
1202 		nCount = nNewCount;
1203 
1204 		for (i = 0; i < nDelCount; i++)
1205 		{
1206 			ScBaseCell* pCell = ppDelCells[i];
1207             DBG_ASSERT( pCell->IsBlank(), "sichtbare Zelle weggeschoben" );
1208 			SvtBroadcaster* pBC = pCell->GetBroadcaster();
1209 			if (pBC)
1210 			{
1211 				MoveListeners( *pBC, pDelRows[i] - nSize );
1212                 pCell->DeleteBroadcaster();
1213 				pCell->Delete();
1214 			}
1215 		}
1216 
1217 		delete [] pDelRows;
1218 		delete [] ppDelCells;
1219 	}
1220 
1221 	pDocument->SetAutoCalc( bOldAutoCalc );
1222 }
1223 
1224 
CopyToClip(SCROW nRow1,SCROW nRow2,ScColumn & rColumn,sal_Bool bKeepScenarioFlags,sal_Bool bCloneNoteCaptions)1225 void ScColumn::CopyToClip(SCROW nRow1, SCROW nRow2, ScColumn& rColumn, sal_Bool bKeepScenarioFlags, sal_Bool bCloneNoteCaptions)
1226 {
1227 	pAttrArray->CopyArea( nRow1, nRow2, 0, *rColumn.pAttrArray,
1228 							bKeepScenarioFlags ? (SC_MF_ALL & ~SC_MF_SCENARIO) : SC_MF_ALL );
1229 
1230 	SCSIZE i;
1231 	SCSIZE nBlockCount = 0;
1232     SCSIZE nStartIndex = 0, nEndIndex = 0;
1233 	for (i = 0; i < nCount; i++)
1234 		if ((pItems[i].nRow >= nRow1) && (pItems[i].nRow <= nRow2))
1235 		{
1236 			if (!nBlockCount)
1237 				nStartIndex = i;
1238 			nEndIndex = i;
1239 			++nBlockCount;
1240 
1241 			//	im Clipboard muessen interpretierte Zellen stehen, um andere Formate
1242 			//	(Text, Grafik...) erzueugen zu koennen
1243 
1244 			if ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
1245 			{
1246 				ScFormulaCell* pFCell = (ScFormulaCell*) pItems[i].pCell;
1247 				if (pFCell->GetDirty() && pDocument->GetAutoCalc())
1248 					pFCell->Interpret();
1249 			}
1250 		}
1251 
1252 	if (nBlockCount)
1253 	{
1254         int nCloneFlags = bCloneNoteCaptions ? SC_CLONECELL_DEFAULT : SC_CLONECELL_NOCAPTION;
1255 		rColumn.Resize( rColumn.GetCellCount() + nBlockCount );
1256         ScAddress aOwnPos( nCol, 0, nTab );
1257         ScAddress aDestPos( rColumn.nCol, 0, rColumn.nTab );
1258 		for (i = nStartIndex; i <= nEndIndex; i++)
1259         {
1260             aOwnPos.SetRow( pItems[i].nRow );
1261             aDestPos.SetRow( pItems[i].nRow );
1262             ScBaseCell* pNewCell = pItems[i].pCell->CloneWithNote( aOwnPos, *rColumn.pDocument, aDestPos, nCloneFlags );
1263             rColumn.Append( aDestPos.Row(), pNewCell );
1264         }
1265 	}
1266 }
1267 
1268 
CopyToColumn(SCROW nRow1,SCROW nRow2,sal_uInt16 nFlags,sal_Bool bMarked,ScColumn & rColumn,const ScMarkData * pMarkData,sal_Bool bAsLink)1269 void ScColumn::CopyToColumn(SCROW nRow1, SCROW nRow2, sal_uInt16 nFlags, sal_Bool bMarked,
1270 								ScColumn& rColumn, const ScMarkData* pMarkData, sal_Bool bAsLink )
1271 {
1272 	if (bMarked)
1273 	{
1274 		SCROW nStart, nEnd;
1275 		if (pMarkData && pMarkData->IsMultiMarked())
1276 		{
1277 			ScMarkArrayIter aIter( pMarkData->GetArray()+nCol );
1278 
1279 			while ( aIter.Next( nStart, nEnd ) && nStart <= nRow2 )
1280 			{
1281 				if ( nEnd >= nRow1 )
1282 					CopyToColumn( Max(nRow1,nStart), Min(nRow2,nEnd),
1283 									nFlags, sal_False, rColumn, pMarkData, bAsLink );
1284 			}
1285 		}
1286 		else
1287 		{
1288 			DBG_ERROR("CopyToColumn: bMarked, aber keine Markierung");
1289 		}
1290 		return;
1291 	}
1292 
1293 	if ( (nFlags & IDF_ATTRIB) != 0 )
1294 	{
1295 		if ( (nFlags & IDF_STYLES) != IDF_STYLES )
1296 		{	// StyleSheets im Zieldokument bleiben erhalten
1297 			// z.B. DIF und RTF Clipboard-Import
1298 			for ( SCROW nRow = nRow1; nRow <= nRow2; nRow++ )
1299 			{
1300 				const ScStyleSheet* pStyle =
1301 					rColumn.pAttrArray->GetPattern( nRow )->GetStyleSheet();
1302 				const ScPatternAttr* pPattern = pAttrArray->GetPattern( nRow );
1303 				ScPatternAttr* pNewPattern = new ScPatternAttr( *pPattern );
1304 				pNewPattern->SetStyleSheet( (ScStyleSheet*)pStyle );
1305 				rColumn.pAttrArray->SetPattern( nRow, pNewPattern, sal_True );
1306 				delete pNewPattern;
1307 			}
1308 		}
1309 		else
1310 			pAttrArray->CopyArea( nRow1, nRow2, 0, *rColumn.pAttrArray);
1311 	}
1312 
1313 
1314 	if ((nFlags & IDF_CONTENTS) != 0)
1315 	{
1316 		SCSIZE i;
1317 		SCSIZE nBlockCount = 0;
1318         SCSIZE nStartIndex = 0, nEndIndex = 0;
1319 		for (i = 0; i < nCount; i++)
1320 			if ((pItems[i].nRow >= nRow1) && (pItems[i].nRow <= nRow2))
1321 			{
1322 				if (!nBlockCount)
1323 					nStartIndex = i;
1324 				nEndIndex = i;
1325 				++nBlockCount;
1326 			}
1327 
1328 		if (nBlockCount)
1329 		{
1330 			rColumn.Resize( rColumn.GetCellCount() + nBlockCount );
1331 			ScAddress aDestPos( rColumn.nCol, 0, rColumn.nTab );
1332 			for (i = nStartIndex; i <= nEndIndex; i++)
1333 			{
1334 				aDestPos.SetRow( pItems[i].nRow );
1335 				ScBaseCell* pNew = bAsLink ?
1336                     CreateRefCell( rColumn.pDocument, aDestPos, i, nFlags ) :
1337                     CloneCell( i, nFlags, *rColumn.pDocument, aDestPos );
1338 
1339 				if (pNew)
1340 					rColumn.Insert(pItems[i].nRow, pNew);
1341 			}
1342 		}
1343 	}
1344 }
1345 
1346 
UndoToColumn(SCROW nRow1,SCROW nRow2,sal_uInt16 nFlags,sal_Bool bMarked,ScColumn & rColumn,const ScMarkData * pMarkData)1347 void ScColumn::UndoToColumn(SCROW nRow1, SCROW nRow2, sal_uInt16 nFlags, sal_Bool bMarked,
1348 								ScColumn& rColumn, const ScMarkData* pMarkData )
1349 {
1350 	if (nRow1 > 0)
1351 		CopyToColumn( 0, nRow1-1, IDF_FORMULA, sal_False, rColumn );
1352 
1353 	CopyToColumn( nRow1, nRow2, nFlags, bMarked, rColumn, pMarkData );		//! bMarked ????
1354 
1355 	if (nRow2 < MAXROW)
1356 		CopyToColumn( nRow2+1, MAXROW, IDF_FORMULA, sal_False, rColumn );
1357 }
1358 
1359 
CopyUpdated(const ScColumn & rPosCol,ScColumn & rDestCol) const1360 void ScColumn::CopyUpdated( const ScColumn& rPosCol, ScColumn& rDestCol ) const
1361 {
1362 	ScDocument& rDestDoc = *rDestCol.pDocument;
1363     ScAddress aOwnPos( nCol, 0, nTab );
1364     ScAddress aDestPos( rDestCol.nCol, 0, rDestCol.nTab );
1365 
1366 	SCSIZE nPosCount = rPosCol.nCount;
1367 	for (SCSIZE nPosIndex = 0; nPosIndex < nPosCount; nPosIndex++)
1368 	{
1369         aOwnPos.SetRow( rPosCol.pItems[nPosIndex].nRow );
1370         aDestPos.SetRow( aOwnPos.Row() );
1371 		SCSIZE nThisIndex;
1372 		if ( Search( aDestPos.Row(), nThisIndex ) )
1373 		{
1374             ScBaseCell* pNew = pItems[nThisIndex].pCell->CloneWithNote( aOwnPos, rDestDoc, aDestPos );
1375 			rDestCol.Insert( aDestPos.Row(), pNew );
1376 		}
1377 	}
1378 
1379 	//	Dummy:
1380 	//	CopyToColumn( 0,MAXROW, IDF_FORMULA, sal_False, rDestCol, NULL, sal_False );
1381 }
1382 
1383 
CopyScenarioFrom(const ScColumn & rSrcCol)1384 void ScColumn::CopyScenarioFrom( const ScColumn& rSrcCol )
1385 {
1386 	//	Dies ist die Szenario-Tabelle, die Daten werden hineinkopiert
1387 
1388 	ScAttrIterator aAttrIter( pAttrArray, 0, MAXROW );
1389 	SCROW nStart = -1, nEnd = -1;
1390 	const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1391 	while (pPattern)
1392 	{
1393 		if ( ((ScMergeFlagAttr&)pPattern->GetItem( ATTR_MERGE_FLAG )).IsScenario() )
1394 		{
1395 			DeleteArea( nStart, nEnd, IDF_CONTENTS );
1396 			((ScColumn&)rSrcCol).
1397 				CopyToColumn( nStart, nEnd, IDF_CONTENTS, sal_False, *this );
1398 
1399 			//	UpdateUsed nicht noetig, schon in TestCopyScenario passiert
1400 
1401 			SCsTAB nDz = nTab - rSrcCol.nTab;
1402 			UpdateReference(URM_COPY, nCol, nStart, nTab,
1403 									  nCol, nEnd,   nTab,
1404 									  0, 0, nDz, NULL);
1405 			UpdateCompile();
1406 		}
1407 
1408 		//!	CopyToColumn "const" machen !!!
1409 
1410 		pPattern = aAttrIter.Next( nStart, nEnd );
1411 	}
1412 }
1413 
1414 
CopyScenarioTo(ScColumn & rDestCol) const1415 void ScColumn::CopyScenarioTo( ScColumn& rDestCol ) const
1416 {
1417 	//	Dies ist die Szenario-Tabelle, die Daten werden in die andere kopiert
1418 
1419 	ScAttrIterator aAttrIter( pAttrArray, 0, MAXROW );
1420 	SCROW nStart = -1, nEnd = -1;
1421 	const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1422 	while (pPattern)
1423 	{
1424 		if ( ((ScMergeFlagAttr&)pPattern->GetItem( ATTR_MERGE_FLAG )).IsScenario() )
1425 		{
1426 			rDestCol.DeleteArea( nStart, nEnd, IDF_CONTENTS );
1427 			((ScColumn*)this)->
1428 				CopyToColumn( nStart, nEnd, IDF_CONTENTS, sal_False, rDestCol );
1429 
1430 			//	UpdateUsed nicht noetig, schon in TestCopyScenario passiert
1431 
1432 			SCsTAB nDz = rDestCol.nTab - nTab;
1433 			rDestCol.UpdateReference(URM_COPY, rDestCol.nCol, nStart, rDestCol.nTab,
1434 											   rDestCol.nCol, nEnd,   rDestCol.nTab,
1435 											   0, 0, nDz, NULL);
1436 			rDestCol.UpdateCompile();
1437 		}
1438 
1439 		//!	CopyToColumn "const" machen !!!
1440 
1441 		pPattern = aAttrIter.Next( nStart, nEnd );
1442 	}
1443 }
1444 
1445 
TestCopyScenarioTo(const ScColumn & rDestCol) const1446 sal_Bool ScColumn::TestCopyScenarioTo( const ScColumn& rDestCol ) const
1447 {
1448 	sal_Bool bOk = sal_True;
1449 	ScAttrIterator aAttrIter( pAttrArray, 0, MAXROW );
1450 	SCROW nStart = 0, nEnd = 0;
1451 	const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1452 	while (pPattern && bOk)
1453 	{
1454 		if ( ((ScMergeFlagAttr&)pPattern->GetItem( ATTR_MERGE_FLAG )).IsScenario() )
1455 			if ( rDestCol.pAttrArray->HasAttrib( nStart, nEnd, HASATTR_PROTECTED ) )
1456 				bOk = sal_False;
1457 
1458 		pPattern = aAttrIter.Next( nStart, nEnd );
1459 	}
1460 	return bOk;
1461 }
1462 
1463 
MarkScenarioIn(ScMarkData & rDestMark) const1464 void ScColumn::MarkScenarioIn( ScMarkData& rDestMark ) const
1465 {
1466 	ScRange aRange( nCol, 0, nTab );
1467 
1468 	ScAttrIterator aAttrIter( pAttrArray, 0, MAXROW );
1469 	SCROW nStart = -1, nEnd = -1;
1470 	const ScPatternAttr* pPattern = aAttrIter.Next( nStart, nEnd );
1471 	while (pPattern)
1472 	{
1473 		if ( ((ScMergeFlagAttr&)pPattern->GetItem( ATTR_MERGE_FLAG )).IsScenario() )
1474 		{
1475 			aRange.aStart.SetRow( nStart );
1476 			aRange.aEnd.SetRow( nEnd );
1477 			rDestMark.SetMultiMarkArea( aRange, sal_True );
1478 		}
1479 
1480 		pPattern = aAttrIter.Next( nStart, nEnd );
1481 	}
1482 }
1483 
1484 
SwapCol(ScColumn & rCol)1485 void ScColumn::SwapCol(ScColumn& rCol)
1486 {
1487 	SCSIZE nTemp;
1488 
1489 	nTemp = rCol.nCount;
1490 	rCol.nCount  = nCount;
1491 	nCount = nTemp;
1492 
1493 	nTemp = rCol.nLimit;
1494 	rCol.nLimit = nLimit;
1495 	nLimit = nTemp;
1496 
1497 	ColEntry* pTempItems = rCol.pItems;
1498 	rCol.pItems = pItems;
1499 	pItems = pTempItems;
1500 
1501 	ScAttrArray* pTempAttr = rCol.pAttrArray;
1502 	rCol.pAttrArray = pAttrArray;
1503 	pAttrArray = pTempAttr;
1504 
1505 	// #38415# AttrArray muss richtige Spaltennummer haben
1506 	pAttrArray->SetCol(nCol);
1507 	rCol.pAttrArray->SetCol(rCol.nCol);
1508 
1509 	SCSIZE i;
1510 	if (pItems)
1511 		for (i = 0; i < nCount; i++)
1512 		{
1513 			ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
1514 			if( pCell->GetCellType() == CELLTYPE_FORMULA)
1515 				pCell->aPos.SetCol(nCol);
1516 		}
1517 	if (rCol.pItems)
1518 		for (i = 0; i < rCol.nCount; i++)
1519 		{
1520 			ScFormulaCell* pCell = (ScFormulaCell*) rCol.pItems[i].pCell;
1521 			if( pCell->GetCellType() == CELLTYPE_FORMULA)
1522 				pCell->aPos.SetCol(rCol.nCol);
1523 		}
1524 }
1525 
1526 
MoveTo(SCROW nStartRow,SCROW nEndRow,ScColumn & rCol)1527 void ScColumn::MoveTo(SCROW nStartRow, SCROW nEndRow, ScColumn& rCol)
1528 {
1529 	pAttrArray->MoveTo(nStartRow, nEndRow, *rCol.pAttrArray);
1530 
1531 	if (pItems)
1532 	{
1533         ::std::vector<SCROW> aRows;
1534         bool bConsecutive = true;
1535 		SCSIZE i;
1536         Search( nStartRow, i);  // i points to start row or position thereafter
1537 		SCSIZE nStartPos = i;
1538 		for ( ; i < nCount && pItems[i].nRow <= nEndRow; ++i)
1539 		{
1540             SCROW nRow = pItems[i].nRow;
1541             aRows.push_back( nRow);
1542             rCol.Insert( nRow, pItems[i].pCell);
1543             if (nRow != pItems[i].nRow)
1544             {   // Listener inserted
1545                 bConsecutive = false;
1546                 Search( nRow, i);
1547             }
1548 		}
1549         SCSIZE nStopPos = i;
1550 		if (nStartPos < nStopPos)
1551 		{
1552             // Create list of ranges of cell entry positions
1553             typedef ::std::pair<SCSIZE,SCSIZE> PosPair;
1554             typedef ::std::vector<PosPair> EntryPosPairs;
1555             EntryPosPairs aEntries;
1556             if (bConsecutive)
1557                 aEntries.push_back( PosPair(nStartPos, nStopPos));
1558             else
1559             {
1560                 bool bFirst = true;
1561                 nStopPos = 0;
1562                 for (::std::vector<SCROW>::const_iterator it( aRows.begin());
1563                         it != aRows.end() && nStopPos < nCount; ++it,
1564                         ++nStopPos)
1565                 {
1566                     if (!bFirst && *it != pItems[nStopPos].nRow)
1567                     {
1568                         aEntries.push_back( PosPair(nStartPos, nStopPos));
1569                         bFirst = true;
1570                     }
1571                     if (bFirst && Search( *it, nStartPos))
1572                     {
1573                         bFirst = false;
1574                         nStopPos = nStartPos;
1575                     }
1576                 }
1577                 if (!bFirst && nStartPos < nStopPos)
1578                     aEntries.push_back( PosPair(nStartPos, nStopPos));
1579             }
1580 			// Broadcast changes
1581             ScAddress aAdr( nCol, 0, nTab );
1582             ScHint aHint( SC_HINT_DYING, aAdr, NULL );  // areas only
1583             ScAddress& rAddress = aHint.GetAddress();
1584             ScNoteCell* pNoteCell = new ScNoteCell;		// Dummy like in DeleteRange
1585 
1586             // #121990# must iterate backwards, because indexes of following cells become invalid
1587             for (EntryPosPairs::reverse_iterator it( aEntries.rbegin());
1588                     it != aEntries.rend(); ++it)
1589             {
1590                 nStartPos = (*it).first;
1591                 nStopPos = (*it).second;
1592                 for (i=nStartPos; i<nStopPos; ++i)
1593                     pItems[i].pCell = pNoteCell;
1594                 for (i=nStartPos; i<nStopPos; ++i)
1595                 {
1596                     rAddress.SetRow( pItems[i].nRow );
1597                     pDocument->AreaBroadcast( aHint );
1598                 }
1599                 nCount -= nStopPos - nStartPos;
1600                 memmove( &pItems[nStartPos], &pItems[nStopPos],
1601                         (nCount - nStartPos) * sizeof(ColEntry) );
1602             }
1603             delete pNoteCell;
1604             pItems[nCount].nRow = 0;
1605             pItems[nCount].pCell = NULL;
1606 		}
1607 	}
1608 }
1609 
1610 
UpdateReference(UpdateRefMode eUpdateRefMode,SCCOL nCol1,SCROW nRow1,SCTAB nTab1,SCCOL nCol2,SCROW nRow2,SCTAB nTab2,SCsCOL nDx,SCsROW nDy,SCsTAB nDz,ScDocument * pUndoDoc)1611 void ScColumn::UpdateReference( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1612 			 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
1613 			 ScDocument* pUndoDoc )
1614 {
1615 	if (pItems)
1616 	{
1617 		ScRange aRange( ScAddress( nCol1, nRow1, nTab1 ),
1618 						ScAddress( nCol2, nRow2, nTab2 ) );
1619 		if ( eUpdateRefMode == URM_COPY && nRow1 == nRow2 )
1620 		{	// z.B. eine einzelne Zelle aus dem Clipboard eingefuegt
1621 			SCSIZE nIndex;
1622 			if ( Search( nRow1, nIndex ) )
1623 			{
1624 				ScFormulaCell* pCell = (ScFormulaCell*) pItems[nIndex].pCell;
1625 				if( pCell->GetCellType() == CELLTYPE_FORMULA)
1626 					pCell->UpdateReference(	eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc );
1627 			}
1628 		}
1629 		else
1630 		{
1631             // #90279# For performance reasons two loop bodies instead of
1632             // testing for update mode in each iteration.
1633             // Anyways, this is still a bottleneck on large arrays with few
1634             // formulas cells.
1635             if ( eUpdateRefMode == URM_COPY )
1636             {
1637                 SCSIZE i;
1638                 Search( nRow1, i );
1639                 for ( ; i < nCount; i++ )
1640                 {
1641                     SCROW nRow = pItems[i].nRow;
1642                     if ( nRow > nRow2 )
1643                         break;
1644                     ScBaseCell* pCell = pItems[i].pCell;
1645                     if( pCell->GetCellType() == CELLTYPE_FORMULA)
1646                     {
1647                         ((ScFormulaCell*)pCell)->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc );
1648                         if ( nRow != pItems[i].nRow )
1649                             Search( nRow, i );  // Listener removed/inserted?
1650                     }
1651                 }
1652             }
1653             else
1654             {
1655                 SCSIZE i = 0;
1656                 for ( ; i < nCount; i++ )
1657                 {
1658                     ScBaseCell* pCell = pItems[i].pCell;
1659                     if( pCell->GetCellType() == CELLTYPE_FORMULA)
1660                     {
1661                         SCROW nRow = pItems[i].nRow;
1662                         // When deleting rows on several sheets, the formula's position may be updated with the first call,
1663                         // so the undo position must be passed from here.
1664                         ScAddress aUndoPos( nCol, nRow, nTab );
1665                         ((ScFormulaCell*)pCell)->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz, pUndoDoc, &aUndoPos );
1666                         if ( nRow != pItems[i].nRow )
1667                             Search( nRow, i );  // Listener removed/inserted?
1668                     }
1669                 }
1670             }
1671 		}
1672 	}
1673 }
1674 
1675 
UpdateTranspose(const ScRange & rSource,const ScAddress & rDest,ScDocument * pUndoDoc)1676 void ScColumn::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
1677 									ScDocument* pUndoDoc )
1678 {
1679 	if (pItems)
1680 		for (SCSIZE i=0; i<nCount; i++)
1681 		{
1682 			ScBaseCell* pCell = pItems[i].pCell;
1683 			if (pCell->GetCellType() == CELLTYPE_FORMULA)
1684 			{
1685 				SCROW nRow = pItems[i].nRow;
1686 				((ScFormulaCell*)pCell)->UpdateTranspose( rSource, rDest, pUndoDoc );
1687 				if ( nRow != pItems[i].nRow )
1688 					Search( nRow, i );				// Listener geloescht/eingefuegt?
1689 			}
1690 		}
1691 }
1692 
1693 
UpdateGrow(const ScRange & rArea,SCCOL nGrowX,SCROW nGrowY)1694 void ScColumn::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
1695 {
1696 	if (pItems)
1697 		for (SCSIZE i=0; i<nCount; i++)
1698 		{
1699 			ScBaseCell* pCell = pItems[i].pCell;
1700 			if (pCell->GetCellType() == CELLTYPE_FORMULA)
1701 			{
1702 				SCROW nRow = pItems[i].nRow;
1703 				((ScFormulaCell*)pCell)->UpdateGrow( rArea, nGrowX, nGrowY );
1704 				if ( nRow != pItems[i].nRow )
1705 					Search( nRow, i );				// Listener geloescht/eingefuegt?
1706 			}
1707 		}
1708 }
1709 
1710 
UpdateInsertTab(SCTAB nTable)1711 void ScColumn::UpdateInsertTab( SCTAB nTable)
1712 {
1713     if (nTab >= nTable)
1714         pAttrArray->SetTab(++nTab);
1715 	if( pItems )
1716 		UpdateInsertTabOnlyCells( nTable );
1717 }
1718 
1719 
UpdateInsertTabOnlyCells(SCTAB nTable)1720 void ScColumn::UpdateInsertTabOnlyCells( SCTAB nTable)
1721 {
1722 	if (pItems)
1723 		for (SCSIZE i = 0; i < nCount; i++)
1724 		{
1725 			ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
1726 			if( pCell->GetCellType() == CELLTYPE_FORMULA)
1727 			{
1728 				SCROW nRow = pItems[i].nRow;
1729 				pCell->UpdateInsertTab(nTable);
1730 				if ( nRow != pItems[i].nRow )
1731 					Search( nRow, i );		// Listener geloescht/eingefuegt?
1732 			}
1733 		}
1734 }
1735 
1736 
UpdateInsertTabAbs(SCTAB nTable)1737 void ScColumn::UpdateInsertTabAbs(SCTAB nTable)
1738 {
1739 	if (pItems)
1740 		for (SCSIZE i = 0; i < nCount; i++)
1741 		{
1742 			ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
1743 			if( pCell->GetCellType() == CELLTYPE_FORMULA)
1744 			{
1745 				SCROW nRow = pItems[i].nRow;
1746 				pCell->UpdateInsertTabAbs(nTable);
1747 				if ( nRow != pItems[i].nRow )
1748 					Search( nRow, i );		// Listener geloescht/eingefuegt?
1749 			}
1750 		}
1751 }
1752 
1753 
UpdateDeleteTab(SCTAB nTable,sal_Bool bIsMove,ScColumn * pRefUndo)1754 void ScColumn::UpdateDeleteTab( SCTAB nTable, sal_Bool bIsMove, ScColumn* pRefUndo )
1755 {
1756 	if (nTab > nTable)
1757 		pAttrArray->SetTab(--nTab);
1758 
1759 	if (pItems)
1760 		for (SCSIZE i = 0; i < nCount; i++)
1761 			if ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
1762 			{
1763 				SCROW nRow = pItems[i].nRow;
1764 				ScFormulaCell* pOld = (ScFormulaCell*)pItems[i].pCell;
1765 
1766                 /*  Do not copy cell note to the undo document. Undo will copy
1767                     back the formula cell while keeping the original note. */
1768                 ScBaseCell* pSave = pRefUndo ? pOld->CloneWithoutNote( *pDocument ) : 0;
1769 
1770 				sal_Bool bChanged = pOld->UpdateDeleteTab(nTable, bIsMove);
1771 				if ( nRow != pItems[i].nRow )
1772 					Search( nRow, i );		// Listener geloescht/eingefuegt?
1773 
1774 				if (pRefUndo)
1775 				{
1776 					if (bChanged)
1777 						pRefUndo->Insert( nRow, pSave );
1778 					else if(pSave)
1779 						pSave->Delete();
1780 				}
1781 			}
1782 }
1783 
1784 
UpdateMoveTab(SCTAB nOldPos,SCTAB nNewPos,SCTAB nTabNo)1785 void ScColumn::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos, SCTAB nTabNo )
1786 {
1787 	nTab = nTabNo;
1788 	pAttrArray->SetTab( nTabNo );
1789 	if (pItems)
1790 		for (SCSIZE i = 0; i < nCount; i++)
1791 		{
1792 			ScFormulaCell* pCell = (ScFormulaCell*) pItems[i].pCell;
1793 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1794 			{
1795 				SCROW nRow = pItems[i].nRow;
1796 				pCell->UpdateMoveTab( nOldPos, nNewPos, nTabNo );
1797 				if ( nRow != pItems[i].nRow )
1798 					Search( nRow, i );		// Listener geloescht/eingefuegt?
1799 			}
1800 		}
1801 }
1802 
1803 
UpdateCompile(sal_Bool bForceIfNameInUse)1804 void ScColumn::UpdateCompile( sal_Bool bForceIfNameInUse )
1805 {
1806 	if (pItems)
1807 		for (SCSIZE i = 0; i < nCount; i++)
1808 		{
1809 			ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
1810 			if( p->GetCellType() == CELLTYPE_FORMULA )
1811 			{
1812 				SCROW nRow = pItems[i].nRow;
1813 				p->UpdateCompile( bForceIfNameInUse );
1814 				if ( nRow != pItems[i].nRow )
1815 					Search( nRow, i );		// Listener geloescht/eingefuegt?
1816 			}
1817 		}
1818 }
1819 
1820 
SetTabNo(SCTAB nNewTab)1821 void ScColumn::SetTabNo(SCTAB nNewTab)
1822 {
1823 	nTab = nNewTab;
1824 	pAttrArray->SetTab( nNewTab );
1825 	if (pItems)
1826 		for (SCSIZE i = 0; i < nCount; i++)
1827 		{
1828 			ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
1829 			if( p->GetCellType() == CELLTYPE_FORMULA )
1830 				p->aPos.SetTab( nNewTab );
1831 		}
1832 }
1833 
1834 
IsRangeNameInUse(SCROW nRow1,SCROW nRow2,sal_uInt16 nIndex) const1835 sal_Bool ScColumn::IsRangeNameInUse(SCROW nRow1, SCROW nRow2, sal_uInt16 nIndex) const
1836 {
1837 	sal_Bool bInUse = sal_False;
1838 	if (pItems)
1839 		for (SCSIZE i = 0; !bInUse && (i < nCount); i++)
1840 			if ((pItems[i].nRow >= nRow1) &&
1841 				(pItems[i].nRow <= nRow2) &&
1842 				(pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
1843 					bInUse = ((ScFormulaCell*)pItems[i].pCell)->IsRangeNameInUse(nIndex);
1844 	return bInUse;
1845 }
1846 
FindRangeNamesInUse(SCROW nRow1,SCROW nRow2,std::set<sal_uInt16> & rIndexes) const1847 void ScColumn::FindRangeNamesInUse(SCROW nRow1, SCROW nRow2, std::set<sal_uInt16>& rIndexes) const
1848 {
1849     if (pItems)
1850         for (SCSIZE i = 0; i < nCount; i++)
1851             if ((pItems[i].nRow >= nRow1) &&
1852                 (pItems[i].nRow <= nRow2) &&
1853                 (pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
1854                     ((ScFormulaCell*)pItems[i].pCell)->FindRangeNamesInUse(rIndexes);
1855 }
1856 
ReplaceRangeNamesInUse(SCROW nRow1,SCROW nRow2,const ScRangeData::IndexMap & rMap)1857 void ScColumn::ReplaceRangeNamesInUse(SCROW nRow1, SCROW nRow2,
1858                                      const ScRangeData::IndexMap& rMap )
1859 {
1860     if (pItems)
1861         for (SCSIZE i = 0; i < nCount; i++)
1862         {
1863             if ((pItems[i].nRow >= nRow1) &&
1864                 (pItems[i].nRow <= nRow2) &&
1865                 (pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA))
1866             {
1867                 SCROW nRow = pItems[i].nRow;
1868                 ((ScFormulaCell*)pItems[i].pCell)->ReplaceRangeNamesInUse( rMap );
1869                 if ( nRow != pItems[i].nRow )
1870                     Search( nRow, i );      // Listener geloescht/eingefuegt?
1871             }
1872         }
1873 }
1874 
SetDirtyVar()1875 void ScColumn::SetDirtyVar()
1876 {
1877 	for (SCSIZE i=0; i<nCount; i++)
1878 	{
1879 		ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
1880 		if( p->GetCellType() == CELLTYPE_FORMULA )
1881 			p->SetDirtyVar();
1882 	}
1883 }
1884 
1885 
SetDirty()1886 void ScColumn::SetDirty()
1887 {
1888 	// wird nur dokumentweit verwendet, kein FormulaTrack
1889 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1890 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1891 	for (SCSIZE i=0; i<nCount; i++)
1892 	{
1893 		ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
1894 		if( p->GetCellType() == CELLTYPE_FORMULA )
1895 		{
1896 			p->SetDirtyVar();
1897 			if ( !pDocument->IsInFormulaTree( p ) )
1898 				pDocument->PutInFormulaTree( p );
1899 		}
1900 	}
1901 	pDocument->SetAutoCalc( bOldAutoCalc );
1902 }
1903 
1904 
SetDirty(const ScRange & rRange)1905 void ScColumn::SetDirty( const ScRange& rRange )
1906 {	// broadcastet alles innerhalb eines Range, mit FormulaTrack
1907 	if ( !pItems || !nCount )
1908 		return ;
1909 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1910 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1911 	SCROW nRow2 = rRange.aEnd.Row();
1912 	ScAddress aPos( nCol, 0, nTab );
1913     ScHint aHint( SC_HINT_DATACHANGED, aPos, NULL );
1914 	SCROW nRow;
1915 	SCSIZE nIndex;
1916 	Search( rRange.aStart.Row(), nIndex );
1917 	while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
1918 	{
1919 		ScBaseCell* pCell = pItems[nIndex].pCell;
1920 		if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1921 			((ScFormulaCell*)pCell)->SetDirty();
1922 		else
1923 		{
1924 			aHint.GetAddress().SetRow( nRow );
1925             aHint.SetCell( pCell );
1926 			pDocument->Broadcast( aHint );
1927 		}
1928 		nIndex++;
1929 	}
1930 	pDocument->SetAutoCalc( bOldAutoCalc );
1931 }
1932 
1933 
SetTableOpDirty(const ScRange & rRange)1934 void ScColumn::SetTableOpDirty( const ScRange& rRange )
1935 {
1936 	if ( !pItems || !nCount )
1937 		return ;
1938 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1939 	pDocument->SetAutoCalc( sal_False );	// no multiple recalculation
1940 	SCROW nRow2 = rRange.aEnd.Row();
1941 	ScAddress aPos( nCol, 0, nTab );
1942     ScHint aHint( SC_HINT_TABLEOPDIRTY, aPos, NULL );
1943 	SCROW nRow;
1944 	SCSIZE nIndex;
1945 	Search( rRange.aStart.Row(), nIndex );
1946 	while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
1947 	{
1948 		ScBaseCell* pCell = pItems[nIndex].pCell;
1949 		if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1950 			((ScFormulaCell*)pCell)->SetTableOpDirty();
1951 		else
1952 		{
1953 			aHint.GetAddress().SetRow( nRow );
1954             aHint.SetCell( pCell );
1955 			pDocument->Broadcast( aHint );
1956 		}
1957 		nIndex++;
1958 	}
1959 	pDocument->SetAutoCalc( bOldAutoCalc );
1960 }
1961 
1962 
SetDirtyAfterLoad()1963 void ScColumn::SetDirtyAfterLoad()
1964 {
1965 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1966 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
1967 	for (SCSIZE i=0; i<nCount; i++)
1968 	{
1969 		ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
1970 #if 1
1971         // Simply set dirty and append to FormulaTree, without broadcasting,
1972         // which is a magnitude faster. This is used to calculate the entire
1973         // document, e.g. when loading alien file formats.
1974         if ( p->GetCellType() == CELLTYPE_FORMULA )
1975             p->SetDirtyAfterLoad();
1976 #else
1977 /* This was used with the binary file format that stored results, where only
1978  * newly compiled and volatile functions and their dependents had to be
1979  * recalculated, which was faster then. Since that was moved to 'binfilter' to
1980  * convert to an XML file this isn't needed anymore, and not used for other
1981  * file formats. Kept for reference in case mechanism needs to be reactivated
1982  * for some file formats, we'd have to introduce a controlling parameter to
1983  * this method here then.
1984 */
1985 
1986         // If the cell was alsready dirty because of CalcAfterLoad,
1987         // FormulaTracking has to take place.
1988         if ( p->GetCellType() == CELLTYPE_FORMULA && p->GetDirty() )
1989             p->SetDirty();
1990 #endif
1991 	}
1992 	pDocument->SetAutoCalc( bOldAutoCalc );
1993 }
1994 
1995 
SetRelNameDirty()1996 void ScColumn::SetRelNameDirty()
1997 {
1998 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
1999 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
2000 	for (SCSIZE i=0; i<nCount; i++)
2001 	{
2002 		ScFormulaCell* p = (ScFormulaCell*) pItems[i].pCell;
2003 		if( p->GetCellType() == CELLTYPE_FORMULA && p->HasRelNameReference() )
2004 			p->SetDirty();
2005 	}
2006 	pDocument->SetAutoCalc( bOldAutoCalc );
2007 }
2008 
2009 
CalcAll()2010 void ScColumn::CalcAll()
2011 {
2012 	if (pItems)
2013 		for (SCSIZE i=0; i<nCount; i++)
2014 		{
2015 			ScBaseCell* pCell = pItems[i].pCell;
2016 			if (pCell->GetCellType() == CELLTYPE_FORMULA)
2017 			{
2018 #if OSL_DEBUG_LEVEL > 1
2019 				// nach F9 ctrl-F9: ueberprueft die Berechnung per FormulaTree
2020 				ScFormulaCell* pFCell = (ScFormulaCell*)pCell;
2021 				double nOldVal, nNewVal;
2022 				nOldVal = pFCell->GetValue();
2023 #endif
2024 				((ScFormulaCell*)pCell)->Interpret();
2025 #if OSL_DEBUG_LEVEL > 1
2026 				if ( pFCell->GetCode()->IsRecalcModeNormal() )
2027 					nNewVal = pFCell->GetValue();
2028 				else
2029 					nNewVal = nOldVal;	// random(), jetzt() etc.
2030 				DBG_ASSERT( nOldVal==nNewVal, "CalcAll: nOldVal != nNewVal" );
2031 #endif
2032 			}
2033 		}
2034 }
2035 
2036 
CompileAll()2037 void ScColumn::CompileAll()
2038 {
2039 	if (pItems)
2040 		for (SCSIZE i = 0; i < nCount; i++)
2041 		{
2042 			ScBaseCell* pCell = pItems[i].pCell;
2043 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
2044 			{
2045 				SCROW nRow = pItems[i].nRow;
2046 				// fuer unbedingtes kompilieren
2047 				// bCompile=sal_True und pCode->nError=0
2048 				((ScFormulaCell*)pCell)->GetCode()->SetCodeError( 0 );
2049 				((ScFormulaCell*)pCell)->SetCompile( sal_True );
2050 				((ScFormulaCell*)pCell)->CompileTokenArray();
2051 				if ( nRow != pItems[i].nRow )
2052 					Search( nRow, i );		// Listener geloescht/eingefuegt?
2053 			}
2054 		}
2055 }
2056 
2057 
CompileXML(ScProgress & rProgress)2058 void ScColumn::CompileXML( ScProgress& rProgress )
2059 {
2060 	if (pItems)
2061 		for (SCSIZE i = 0; i < nCount; i++)
2062 		{
2063 			ScBaseCell* pCell = pItems[i].pCell;
2064 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
2065 			{
2066 				SCROW nRow = pItems[i].nRow;
2067 				((ScFormulaCell*)pCell)->CompileXML( rProgress );
2068 				if ( nRow != pItems[i].nRow )
2069 					Search( nRow, i );		// Listener geloescht/eingefuegt?
2070 			}
2071 		}
2072 }
2073 
2074 
CalcAfterLoad()2075 void ScColumn::CalcAfterLoad()
2076 {
2077 	if (pItems)
2078 		for (SCSIZE i = 0; i < nCount; i++)
2079 		{
2080 			ScBaseCell* pCell = pItems[i].pCell;
2081 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
2082 				((ScFormulaCell*)pCell)->CalcAfterLoad();
2083 		}
2084 }
2085 
2086 
ResetChanged(SCROW nStartRow,SCROW nEndRow)2087 void ScColumn::ResetChanged( SCROW nStartRow, SCROW nEndRow )
2088 {
2089 	if (pItems)
2090 	{
2091 		SCSIZE nIndex;
2092 		Search(nStartRow,nIndex);
2093 		while (nIndex<nCount && pItems[nIndex].nRow <= nEndRow)
2094 		{
2095 			ScBaseCell* pCell = pItems[nIndex].pCell;
2096 			if (pCell->GetCellType() == CELLTYPE_FORMULA)
2097 				((ScFormulaCell*)pCell)->ResetChanged();
2098 			++nIndex;
2099 		}
2100 	}
2101 }
2102 
2103 
HasEditCells(SCROW nStartRow,SCROW nEndRow,SCROW & rFirst) const2104 sal_Bool ScColumn::HasEditCells(SCROW nStartRow, SCROW nEndRow, SCROW& rFirst) const
2105 {
2106 	//	used in GetOptimalHeight - ambiguous script type counts as edit cell
2107 
2108     SCROW nRow = 0;
2109 	SCSIZE nIndex;
2110 	Search(nStartRow,nIndex);
2111 	while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : sal_False )
2112 	{
2113 		ScBaseCell* pCell = pItems[nIndex].pCell;
2114         CellType eCellType = pCell->GetCellType();
2115 		if ( eCellType == CELLTYPE_EDIT ||
2116 			 IsAmbiguousScriptNonZero( pDocument->GetScriptType(nCol, nRow, nTab, pCell) ) ||
2117              ((eCellType == CELLTYPE_FORMULA) && ((ScFormulaCell*)pCell)->IsMultilineResult()) )
2118 		{
2119 			rFirst = nRow;
2120 			return sal_True;
2121 		}
2122 		++nIndex;
2123 	}
2124 
2125 	return sal_False;
2126 }
2127 
2128 
SearchStyle(SCsROW nRow,const ScStyleSheet * pSearchStyle,sal_Bool bUp,sal_Bool bInSelection,const ScMarkData & rMark)2129 SCsROW ScColumn::SearchStyle( SCsROW nRow, const ScStyleSheet* pSearchStyle,
2130 								sal_Bool bUp, sal_Bool bInSelection, const ScMarkData& rMark )
2131 {
2132 	if (bInSelection)
2133 	{
2134 		if (rMark.IsMultiMarked())
2135 			return pAttrArray->SearchStyle( nRow, pSearchStyle, bUp,
2136 									(ScMarkArray*) rMark.GetArray()+nCol );		//! const
2137 		else
2138 			return -1;
2139 	}
2140 	else
2141 		return pAttrArray->SearchStyle( nRow, pSearchStyle, bUp, NULL );
2142 }
2143 
2144 
SearchStyleRange(SCsROW & rRow,SCsROW & rEndRow,const ScStyleSheet * pSearchStyle,sal_Bool bUp,sal_Bool bInSelection,const ScMarkData & rMark)2145 sal_Bool ScColumn::SearchStyleRange( SCsROW& rRow, SCsROW& rEndRow, const ScStyleSheet* pSearchStyle,
2146 									sal_Bool bUp, sal_Bool bInSelection, const ScMarkData& rMark )
2147 {
2148 	if (bInSelection)
2149 	{
2150 		if (rMark.IsMultiMarked())
2151 			return pAttrArray->SearchStyleRange( rRow, rEndRow, pSearchStyle, bUp,
2152 									(ScMarkArray*) rMark.GetArray()+nCol );		//! const
2153 		else
2154 			return sal_False;
2155 	}
2156 	else
2157 		return pAttrArray->SearchStyleRange( rRow, rEndRow, pSearchStyle, bUp, NULL );
2158 }
2159 
2160 
2161