xref: /aoo41x/main/sc/source/core/data/column3.cxx (revision 7a6646f1)
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 // INCLUDE ---------------------------------------------------------------
27 
28 
29 
30 #include <sfx2/objsh.hxx>
31 #include <svl/zforlist.hxx>
32 #include <svl/zformat.hxx>
33 
34 #include "boost/tuple/tuple.hpp"
35 #include <boost/function.hpp>
36 #include "boost/lambda/bind.hpp"
37 #include "boost/bind.hpp"
38 #include "boost/lambda/lambda.hpp"
39 #include "scitems.hxx"
40 #include "column.hxx"
41 #include "cell.hxx"
42 #include "document.hxx"
43 #include "attarray.hxx"
44 #include "patattr.hxx"
45 #include "cellform.hxx"
46 #include "collect.hxx"
47 #include "formula/errorcodes.hxx"
48 #include "formula/token.hxx"
49 #include "brdcst.hxx"
50 #include "docoptio.hxx"			// GetStdPrecision fuer GetMaxNumberStringLen
51 #include "subtotal.hxx"
52 #include "markdata.hxx"
53 #include "detfunc.hxx"			// fuer Notizen bei DeleteRange
54 #include "postit.hxx"
55 #include "stringutil.hxx"
56 #include "dpglobal.hxx"
57 #include <dptablecache.hxx>
58 #include <com/sun/star/i18n/LocaleDataItem.hpp>
59 using ::com::sun::star::i18n::LocaleDataItem;
60 using ::rtl::OUString;
61 using ::rtl::OUStringBuffer;
62 
63 // Err527 Workaround
64 extern const ScFormulaCell* pLastFormulaTreeTop;	// in cellform.cxx
65 using namespace formula;
66 // STATIC DATA -----------------------------------------------------------
67 
68 sal_Bool ScColumn::bDoubleAlloc = sal_False;	// fuer Import: Groesse beim Allozieren verdoppeln
69 
70 
Insert(SCROW nRow,ScBaseCell * pNewCell)71 void ScColumn::Insert( SCROW nRow, ScBaseCell* pNewCell )
72 {
73 	sal_Bool bIsAppended = sal_False;
74 	if (pItems && nCount>0)
75 	{
76 		if (pItems[nCount-1].nRow < nRow)
77 		{
78 			Append(nRow, pNewCell );
79 			bIsAppended = sal_True;
80 		}
81 	}
82 	if ( !bIsAppended )
83 	{
84 		SCSIZE	nIndex;
85 		if (Search(nRow, nIndex))
86 		{
87 			ScBaseCell* pOldCell = pItems[nIndex].pCell;
88 
89             // move broadcaster and note to new cell, if not existing in new cell
90             if (pOldCell->HasBroadcaster() && !pNewCell->HasBroadcaster())
91                 pNewCell->TakeBroadcaster( pOldCell->ReleaseBroadcaster() );
92             if (pOldCell->HasNote() && !pNewCell->HasNote())
93 				pNewCell->TakeNote( pOldCell->ReleaseNote() );
94 
95             if ( pOldCell->GetCellType() == CELLTYPE_FORMULA && !pDocument->IsClipOrUndo() )
96 			{
97 				pOldCell->EndListeningTo( pDocument );
98 				// falls in EndListening NoteCell in gleicher Col zerstoert
99 				if ( nIndex >= nCount || pItems[nIndex].nRow != nRow )
100 					Search(nRow, nIndex);
101 			}
102 			pOldCell->Delete();
103 			pItems[nIndex].pCell = pNewCell;
104 		}
105 		else
106 		{
107 			if (nCount + 1 > nLimit)
108 			{
109 				if (bDoubleAlloc)
110 				{
111 					if (nLimit < COLUMN_DELTA)
112 						nLimit = COLUMN_DELTA;
113 					else
114 					{
115 						nLimit *= 2;
116                         if ( nLimit > sal::static_int_cast<SCSIZE>(MAXROWCOUNT) )
117 							nLimit = MAXROWCOUNT;
118 					}
119 				}
120 				else
121 					nLimit += COLUMN_DELTA;
122 
123 				ColEntry* pNewItems = new ColEntry[nLimit];
124 				if (pItems)
125 				{
126 					memmove( pNewItems, pItems, nCount * sizeof(ColEntry) );
127 					delete[] pItems;
128 				}
129 				pItems = pNewItems;
130 			}
131 			memmove( &pItems[nIndex + 1], &pItems[nIndex], (nCount - nIndex) * sizeof(ColEntry) );
132 			pItems[nIndex].pCell = pNewCell;
133 			pItems[nIndex].nRow  = nRow;
134 			++nCount;
135 		}
136 	}
137 	// Bei aus Clipboard sind hier noch falsche (alte) Referenzen!
138 	// Werden in CopyBlockFromClip per UpdateReference umgesetzt,
139 	// danach StartListeningFromClip und BroadcastFromClip gerufen.
140 	// Wird ins Clipboard/UndoDoc gestellt, wird kein Broadcast gebraucht.
141 	// Nach Import wird CalcAfterLoad gerufen, dort Listening.
142 	if ( !(pDocument->IsClipOrUndo() || pDocument->IsInsertingFromOtherDoc()) )
143 	{
144 		pNewCell->StartListeningTo( pDocument );
145 		CellType eCellType = pNewCell->GetCellType();
146 		// Notizzelle entsteht beim Laden nur durch StartListeningCell,
147 		// ausloesende Formelzelle muss sowieso dirty sein.
148 		if ( !(pDocument->IsCalcingAfterLoad() && eCellType == CELLTYPE_NOTE) )
149 		{
150 			if ( eCellType == CELLTYPE_FORMULA )
151 				((ScFormulaCell*)pNewCell)->SetDirty();
152 			else
153 				pDocument->Broadcast( ScHint( SC_HINT_DATACHANGED,
154 					ScAddress( nCol, nRow, nTab ), pNewCell ) );
155 		}
156 	}
157 }
158 
159 
Insert(SCROW nRow,sal_uLong nNumberFormat,ScBaseCell * pCell)160 void ScColumn::Insert( SCROW nRow, sal_uLong nNumberFormat, ScBaseCell* pCell )
161 {
162 	Insert(nRow, pCell);
163 	short eOldType = pDocument->GetFormatTable()->
164 						GetType( (sal_uLong)
165 							((SfxUInt32Item*)GetAttr( nRow, ATTR_VALUE_FORMAT ))->
166 								GetValue() );
167 	short eNewType = pDocument->GetFormatTable()->GetType(nNumberFormat);
168 	if (!pDocument->GetFormatTable()->IsCompatible(eOldType, eNewType))
169 		ApplyAttr( nRow, SfxUInt32Item( ATTR_VALUE_FORMAT, (sal_uInt32) nNumberFormat) );
170 }
171 
172 
Append(SCROW nRow,ScBaseCell * pCell)173 void ScColumn::Append( SCROW nRow, ScBaseCell* pCell )
174 {
175 	if (nCount + 1 > nLimit)
176 	{
177 		if (bDoubleAlloc)
178 		{
179 			if (nLimit < COLUMN_DELTA)
180 				nLimit = COLUMN_DELTA;
181 			else
182 			{
183 				nLimit *= 2;
184                 if ( nLimit > sal::static_int_cast<SCSIZE>(MAXROWCOUNT) )
185 					nLimit = MAXROWCOUNT;
186 			}
187 		}
188 		else
189 			nLimit += COLUMN_DELTA;
190 
191 		ColEntry* pNewItems = new ColEntry[nLimit];
192 		if (pItems)
193 		{
194 			memmove( pNewItems, pItems, nCount * sizeof(ColEntry) );
195 			delete[] pItems;
196 		}
197 		pItems = pNewItems;
198 	}
199 	pItems[nCount].pCell = pCell;
200 	pItems[nCount].nRow  = nRow;
201 	++nCount;
202 }
203 
204 
Delete(SCROW nRow)205 void ScColumn::Delete( SCROW nRow )
206 {
207 	SCSIZE	nIndex;
208 
209 	if (Search(nRow, nIndex))
210 	{
211 		ScBaseCell* pCell = pItems[nIndex].pCell;
212 		ScNoteCell* pNoteCell = new ScNoteCell;
213 		pItems[nIndex].pCell = pNoteCell;		// Dummy fuer Interpret
214 		pDocument->Broadcast( ScHint( SC_HINT_DYING,
215 			ScAddress( nCol, nRow, nTab ), pCell ) );
216         if ( SvtBroadcaster* pBC = pCell->ReleaseBroadcaster() )
217 		{
218             pNoteCell->TakeBroadcaster( pBC );
219 		}
220 		else
221 		{
222 			delete pNoteCell;
223 			--nCount;
224 			memmove( &pItems[nIndex], &pItems[nIndex + 1], (nCount - nIndex) * sizeof(ColEntry) );
225 			pItems[nCount].nRow = 0;
226 			pItems[nCount].pCell = NULL;
227 			//	Soll man hier den Speicher freigeben (delta)? Wird dann langsamer!
228 		}
229 		pCell->EndListeningTo( pDocument );
230 		pCell->Delete();
231 	}
232 }
233 
234 
DeleteAtIndex(SCSIZE nIndex)235 void ScColumn::DeleteAtIndex( SCSIZE nIndex )
236 {
237 	ScBaseCell* pCell = pItems[nIndex].pCell;
238 	ScNoteCell* pNoteCell = new ScNoteCell;
239 	pItems[nIndex].pCell = pNoteCell;		// Dummy fuer Interpret
240 	pDocument->Broadcast( ScHint( SC_HINT_DYING,
241 		ScAddress( nCol, pItems[nIndex].nRow, nTab ), pCell ) );
242 	delete pNoteCell;
243 	--nCount;
244 	memmove( &pItems[nIndex], &pItems[nIndex + 1], (nCount - nIndex) * sizeof(ColEntry) );
245 	pItems[nCount].nRow = 0;
246 	pItems[nCount].pCell = NULL;
247 	pCell->EndListeningTo( pDocument );
248 	pCell->Delete();
249 }
250 
251 
FreeAll()252 void ScColumn::FreeAll()
253 {
254 	if (pItems)
255 	{
256 		for (SCSIZE i = 0; i < nCount; i++)
257 			pItems[i].pCell->Delete();
258 		delete[] pItems;
259 		pItems = NULL;
260 	}
261 	nCount = 0;
262 	nLimit = 0;
263 }
264 
265 
DeleteRow(SCROW nStartRow,SCSIZE nSize)266 void ScColumn::DeleteRow( SCROW nStartRow, SCSIZE nSize )
267 {
268 	pAttrArray->DeleteRow( nStartRow, nSize );
269 
270 	if ( !pItems || !nCount )
271 		return ;
272 
273 	SCSIZE nFirstIndex;
274 	Search( nStartRow, nFirstIndex );
275 	if ( nFirstIndex >= nCount )
276 		return ;
277 
278 	sal_Bool bOldAutoCalc = pDocument->GetAutoCalc();
279 	pDocument->SetAutoCalc( sal_False );	// Mehrfachberechnungen vermeiden
280 
281 	sal_Bool bFound=sal_False;
282 	SCROW nEndRow = nStartRow + nSize - 1;
283     SCSIZE nStartIndex = 0;
284     SCSIZE nEndIndex = 0;
285 	SCSIZE i;
286 
287 	for ( i = nFirstIndex; i < nCount && pItems[i].nRow <= nEndRow; i++ )
288 	{
289 		if (!bFound)
290 		{
291 			nStartIndex = i;
292 			bFound = sal_True;
293 		}
294 		nEndIndex = i;
295 
296 		ScBaseCell* pCell = pItems[i].pCell;
297 		SvtBroadcaster* pBC = pCell->GetBroadcaster();
298 		if (pBC)
299 		{
300 // gibt jetzt invalid reference, kein Aufruecken der direkten Referenzen
301 //			MoveListeners( *pBC, nRow+nSize );
302             pCell->DeleteBroadcaster();
303 			//	in DeleteRange werden leere Broadcaster geloescht
304 		}
305 	}
306 	if (bFound)
307 	{
308 		DeleteRange( nStartIndex, nEndIndex, IDF_CONTENTS );
309 		Search( nStartRow, i );
310 		if ( i >= nCount )
311 		{
312 			pDocument->SetAutoCalc( bOldAutoCalc );
313 			return ;
314 		}
315 	}
316 	else
317 		i = nFirstIndex;
318 
319 	ScAddress aAdr( nCol, 0, nTab );
320     ScHint aHint( SC_HINT_DATACHANGED, aAdr, NULL );    // only areas (ScBaseCell* == NULL)
321     ScAddress& rAddress = aHint.GetAddress();
322     // for sparse occupation use single broadcasts, not ranges
323     sal_Bool bSingleBroadcasts = (((pItems[nCount-1].nRow - pItems[i].nRow) /
324                 (nCount - i)) > 1);
325     if ( bSingleBroadcasts )
326     {
327         SCROW nLastBroadcast = MAXROW+1;
328         for ( ; i < nCount; i++ )
329         {
330             SCROW nOldRow = pItems[i].nRow;
331             // #43940# Aenderung Quelle broadcasten
332             rAddress.SetRow( nOldRow );
333             pDocument->AreaBroadcast( aHint );
334             SCROW nNewRow = (pItems[i].nRow -= nSize);
335             // #43940# Aenderung Ziel broadcasten
336             if ( nLastBroadcast != nNewRow )
337             {   // direkt aufeinanderfolgende nicht doppelt broadcasten
338                 rAddress.SetRow( nNewRow );
339                 pDocument->AreaBroadcast( aHint );
340             }
341             nLastBroadcast = nOldRow;
342             ScBaseCell* pCell = pItems[i].pCell;
343             if ( pCell->GetCellType() == CELLTYPE_FORMULA )
344                 ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
345         }
346     }
347     else
348     {
349         rAddress.SetRow( pItems[i].nRow );
350         ScRange aRange( rAddress );
351         aRange.aEnd.SetRow( pItems[nCount-1].nRow );
352         for ( ; i < nCount; i++ )
353         {
354             SCROW nNewRow = (pItems[i].nRow -= nSize);
355             ScBaseCell* pCell = pItems[i].pCell;
356             if ( pCell->GetCellType() == CELLTYPE_FORMULA )
357                 ((ScFormulaCell*)pCell)->aPos.SetRow( nNewRow );
358         }
359         pDocument->AreaBroadcastInRange( aRange, aHint );
360     }
361 
362 	pDocument->SetAutoCalc( bOldAutoCalc );
363 }
364 
365 
DeleteRange(SCSIZE nStartIndex,SCSIZE nEndIndex,sal_uInt16 nDelFlag)366 void ScColumn::DeleteRange( SCSIZE nStartIndex, SCSIZE nEndIndex, sal_uInt16 nDelFlag )
367 {
368     /*  If caller specifies to not remove the note caption objects, all cells
369         have to forget the pointers to them. This is used e.g. while undoing a
370         "paste cells" operation, which removes the caption objects later in
371         drawing undo. */
372     bool bDeleteNote = (nDelFlag & IDF_NOTE) != 0;
373     bool bNoCaptions = (nDelFlag & IDF_NOCAPTIONS) != 0;
374     if (bDeleteNote && bNoCaptions)
375 		for ( SCSIZE nIdx = nStartIndex; nIdx <= nEndIndex; ++nIdx )
376 			if ( ScPostIt* pNote = pItems[ nIdx ].pCell->GetNote() )
377 				pNote->ForgetCaption();
378 
379     // special simple mode if all contents are deleted and cells do not contain broadcasters
380 	bool bSimple = ((nDelFlag & IDF_CONTENTS) == IDF_CONTENTS);
381 	if (bSimple)
382 		for ( SCSIZE nIdx = nStartIndex; bSimple && (nIdx <= nEndIndex); ++nIdx )
383 			if (pItems[ nIdx ].pCell->GetBroadcaster())
384 				bSimple = false;
385 
386     ScHint aHint( SC_HINT_DYING, ScAddress( nCol, 0, nTab ), 0 );
387 
388     // cache all formula cells, they will be deleted at end of this function
389 	typedef ::std::vector< ScFormulaCell* > FormulaCellVector;
390 	FormulaCellVector aDelCells;
391     aDelCells.reserve( nEndIndex - nStartIndex + 1 );
392 
393     // simple deletion of the cell objects
394 	if (bSimple)
395 	{
396         // pNoteCell: dummy replacement for old cells, to prevent that interpreter uses old cell
397 		ScNoteCell* pNoteCell = new ScNoteCell;
398 		for ( SCSIZE nIdx = nStartIndex; nIdx <= nEndIndex; ++nIdx )
399 		{
400 			ScBaseCell* pOldCell = pItems[ nIdx ].pCell;
401 			if (pOldCell->GetCellType() == CELLTYPE_FORMULA)
402             {
403                 // cache formula cell, will be deleted below
404 				aDelCells.push_back( static_cast< ScFormulaCell* >( pOldCell ) );
405             }
406 			else
407 			{
408 				// interpret in broadcast must not use the old cell
409 				pItems[ nIdx ].pCell = pNoteCell;
410                 aHint.GetAddress().SetRow( pItems[ nIdx ].nRow );
411                 aHint.SetCell( pOldCell );
412 				pDocument->Broadcast( aHint );
413 				pOldCell->Delete();
414 			}
415 		}
416 		delete pNoteCell;
417 		memmove( &pItems[nStartIndex], &pItems[nEndIndex + 1], (nCount - nEndIndex - 1) * sizeof(ColEntry) );
418 		nCount -= nEndIndex-nStartIndex+1;
419 	}
420 
421     // else: delete some contents of the cells
422 	else
423 	{
424 		SCSIZE j = nStartIndex;
425         for ( SCSIZE nIdx = nStartIndex; nIdx <= nEndIndex; ++nIdx )
426 		{
427             // decide whether to delete the cell object according to passed flags
428 			bool bDelete = false;
429 			ScBaseCell* pOldCell = pItems[j].pCell;
430 			CellType eCellType = pOldCell->GetCellType();
431 			switch ( eCellType )
432 			{
433 				case CELLTYPE_VALUE:
434                 {
435                     sal_uInt16 nValFlags = nDelFlag & (IDF_DATETIME|IDF_VALUE);
436                     // delete values and dates?
437 					bDelete = nValFlags == (IDF_DATETIME|IDF_VALUE);
438                     // if not, decide according to cell number format
439 					if( !bDelete && (nValFlags != 0) )
440 					{
441 						sal_uLong nIndex = (sal_uLong)((SfxUInt32Item*)GetAttr( pItems[j].nRow, ATTR_VALUE_FORMAT ))->GetValue();
442 						short nType = pDocument->GetFormatTable()->GetType(nIndex);
443 						bool bIsDate = (nType == NUMBERFORMAT_DATE) || (nType == NUMBERFORMAT_TIME) || (nType == NUMBERFORMAT_DATETIME);
444                         bDelete = nValFlags == (bIsDate ? IDF_DATETIME : IDF_VALUE);
445 					}
446                 }
447                 break;
448 
449 				case CELLTYPE_STRING:
450 				case CELLTYPE_EDIT:
451                     bDelete = (nDelFlag & IDF_STRING) != 0;
452                 break;
453 
454 				case CELLTYPE_FORMULA:
455                     bDelete = (nDelFlag & IDF_FORMULA) != 0;
456                 break;
457 
458 				case CELLTYPE_NOTE:
459                     // do note delete note cell with broadcaster
460 					bDelete = bDeleteNote && !pOldCell->GetBroadcaster();
461                 break;
462 
463                 default:;   // added to avoid warnings
464 			}
465 
466 			if (bDelete)
467 			{
468                 // try to create a replacement note cell, if note or broadcaster exists
469 				ScNoteCell* pNoteCell = 0;
470 				if (eCellType != CELLTYPE_NOTE)
471 				{
472                     // do not rescue note if it has to be deleted according to passed flags
473 					ScPostIt* pNote = bDeleteNote ? 0 : pOldCell->ReleaseNote();
474                     // #i99844# do not release broadcaster from old cell, it still has to notify deleted content
475                     SvtBroadcaster* pBC = pOldCell->GetBroadcaster();
476                     if( pNote || pBC )
477                         pNoteCell = new ScNoteCell( pNote, pBC );
478 				}
479 
480                 // remove cell entry in cell item list
481 				SCROW nOldRow = pItems[j].nRow;
482 				if (pNoteCell)
483 				{
484                     // replace old cell with the replacement note cell
485 					pItems[j].pCell = pNoteCell;
486 					++j;
487 				}
488 				else
489 				{
490                     // remove the old cell from the cell item list
491 					--nCount;
492 					memmove( &pItems[j], &pItems[j + 1], (nCount - j) * sizeof(ColEntry) );
493 					pItems[nCount].nRow = 0;
494 					pItems[nCount].pCell = 0;
495 				}
496 
497                 // cache formula cells (will be deleted later), delete cell of other type
498 				if (eCellType == CELLTYPE_FORMULA)
499 				{
500 					aDelCells.push_back( static_cast< ScFormulaCell* >( pOldCell ) );
501 				}
502 				else
503 				{
504                     aHint.GetAddress().SetRow( nOldRow );
505                     aHint.SetCell( pOldCell );
506 					pDocument->Broadcast( aHint );
507                     // #i99844# after broadcasting, old cell has to forget the broadcaster (owned by pNoteCell)
508                     pOldCell->ReleaseBroadcaster();
509 					pOldCell->Delete();
510 				}
511 			}
512 			else
513 			{
514                 // delete cell note
515 				if (bDeleteNote)
516 					pItems[j].pCell->DeleteNote();
517                 // cell not deleted, move index to next cell
518 				++j;
519 			}
520 		}
521 	}
522 
523     // *** delete all formula cells ***
524 
525 	// first, all cells stop listening, may save unneeded recalcualtions
526 	for ( FormulaCellVector::iterator aIt = aDelCells.begin(), aEnd = aDelCells.end(); aIt != aEnd; ++aIt )
527 		(*aIt)->EndListeningTo( pDocument );
528 
529     // #i101869# if the note cell with the broadcaster was deleted in EndListening,
530     // forget the pointer to the broadcaster
531     for ( FormulaCellVector::iterator aIt = aDelCells.begin(), aEnd = aDelCells.end(); aIt != aEnd; ++aIt )
532     {
533         SCSIZE nIndex;
534         if ( !Search( (*aIt)->aPos.Row(), nIndex ) )
535             (*aIt)->ReleaseBroadcaster();
536     }
537 
538     // broadcast SC_HINT_DYING for all cells and delete them
539 	for ( FormulaCellVector::iterator aIt = aDelCells.begin(), aEnd = aDelCells.end(); aIt != aEnd; ++aIt )
540 	{
541         aHint.SetAddress( (*aIt)->aPos );
542         aHint.SetCell( *aIt );
543 		pDocument->Broadcast( aHint );
544         // #i99844# after broadcasting, old cell has to forget the broadcaster (owned by replacement note cell)
545         (*aIt)->ReleaseBroadcaster();
546 		(*aIt)->Delete();
547 	}
548 }
549 
550 
DeleteArea(SCROW nStartRow,SCROW nEndRow,sal_uInt16 nDelFlag)551 void ScColumn::DeleteArea(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nDelFlag)
552 {
553 	//	FreeAll darf hier nicht gerufen werden wegen Broadcastern
554 
555 	//	Attribute erst am Ende, damit vorher noch zwischen Zahlen und Datum
556 	//	unterschieden werden kann (#47901#)
557 
558     sal_uInt16 nContMask = IDF_CONTENTS;
559     //  IDF_NOCAPTIONS needs to be passed too, if IDF_NOTE is set
560     if( nDelFlag & IDF_NOTE )
561         nContMask |= IDF_NOCAPTIONS;
562     sal_uInt16 nContFlag = nDelFlag & nContMask;
563 
564 	if (pItems && nCount>0 && nContFlag)
565 	{
566 		if (nStartRow==0 && nEndRow==MAXROW)
567             DeleteRange( 0, nCount-1, nContFlag );
568 		else
569 		{
570 			sal_Bool bFound=sal_False;
571             SCSIZE nStartIndex = 0;
572             SCSIZE nEndIndex = 0;
573 			for (SCSIZE i = 0; i < nCount; i++)
574 				if ((pItems[i].nRow >= nStartRow) && (pItems[i].nRow <= nEndRow))
575 				{
576 					if (!bFound)
577 					{
578 						nStartIndex = i;
579 						bFound = sal_True;
580 					}
581 					nEndIndex = i;
582 				}
583 			if (bFound)
584                 DeleteRange( nStartIndex, nEndIndex, nContFlag );
585 		}
586 	}
587 
588 	if ( nDelFlag & IDF_EDITATTR )
589 	{
590 		DBG_ASSERT( nContFlag == 0, "DeleteArea: falsche Flags" );
591 		RemoveEditAttribs( nStartRow, nEndRow );
592 	}
593 
594 	//	Attribute erst hier
595 	if ((nDelFlag & IDF_ATTRIB) == IDF_ATTRIB) pAttrArray->DeleteArea( nStartRow, nEndRow );
596 	else if ((nDelFlag & IDF_ATTRIB) != 0) pAttrArray->DeleteHardAttr( nStartRow, nEndRow );
597 }
598 
599 
CreateRefCell(ScDocument * pDestDoc,const ScAddress & rDestPos,SCSIZE nIndex,sal_uInt16 nFlags) const600 ScFormulaCell* ScColumn::CreateRefCell( ScDocument* pDestDoc, const ScAddress& rDestPos,
601 											SCSIZE nIndex, sal_uInt16 nFlags ) const
602 {
603 	sal_uInt16 nContFlags = nFlags & IDF_CONTENTS;
604 	if (!nContFlags)
605 		return NULL;
606 
607 	//	Testen, ob Zelle kopiert werden soll
608 	//	auch bei IDF_CONTENTS komplett, wegen Notes / Broadcastern
609 
610 	sal_Bool bMatch = sal_False;
611 	ScBaseCell* pCell = pItems[nIndex].pCell;
612 	CellType eCellType = pCell->GetCellType();
613 	switch ( eCellType )
614 	{
615 		case CELLTYPE_VALUE:
616 			{
617 				sal_uInt16 nValFlags = nFlags & (IDF_DATETIME|IDF_VALUE);
618 
619 				if ( nValFlags == (IDF_DATETIME|IDF_VALUE) )
620 					bMatch = sal_True;
621 				else if ( nValFlags )
622 				{
623 					sal_uLong nNumIndex = (sal_uLong)((SfxUInt32Item*)GetAttr(
624 									pItems[nIndex].nRow, ATTR_VALUE_FORMAT ))->GetValue();
625 					short nTyp = pDocument->GetFormatTable()->GetType(nNumIndex);
626 					if ((nTyp == NUMBERFORMAT_DATE) || (nTyp == NUMBERFORMAT_TIME) || (nTyp == NUMBERFORMAT_DATETIME))
627 						bMatch = ((nFlags & IDF_DATETIME) != 0);
628 					else
629 						bMatch = ((nFlags & IDF_VALUE) != 0);
630 				}
631 			}
632 			break;
633 		case CELLTYPE_STRING:
634 		case CELLTYPE_EDIT:		bMatch = ((nFlags & IDF_STRING) != 0); break;
635 		case CELLTYPE_FORMULA:	bMatch = ((nFlags & IDF_FORMULA) != 0); break;
636         default:
637         {
638             // added to avoid warnings
639         }
640 	}
641 	if (!bMatch)
642 		return NULL;
643 
644 
645 	//	Referenz einsetzen
646 	ScSingleRefData aRef;
647 	aRef.nCol = nCol;
648 	aRef.nRow = pItems[nIndex].nRow;
649 	aRef.nTab = nTab;
650 	aRef.InitFlags();							// -> alles absolut
651 	aRef.SetFlag3D(sal_True);
652 
653 	//!	3D(sal_False) und TabRel(sal_True), wenn die endgueltige Position auf der selben Tabelle ist?
654 	//!	(bei TransposeClip ist die Zielposition noch nicht bekannt)
655 
656 	aRef.CalcRelFromAbs( rDestPos );
657 
658 	ScTokenArray aArr;
659 	aArr.AddSingleReference( aRef );
660 
661 	return new ScFormulaCell( pDestDoc, rDestPos, &aArr );
662 }
663 
664 
665 //	rColumn = Quelle
666 //	nRow1, nRow2 = Zielposition
667 
CopyFromClip(SCROW nRow1,SCROW nRow2,long nDy,sal_uInt16 nInsFlag,sal_Bool bAsLink,sal_Bool bSkipAttrForEmpty,ScColumn & rColumn)668 void ScColumn::CopyFromClip(SCROW nRow1, SCROW nRow2, long nDy,
669 								sal_uInt16 nInsFlag, sal_Bool bAsLink, sal_Bool bSkipAttrForEmpty,
670 								ScColumn& rColumn)
671 {
672 	if ((nInsFlag & IDF_ATTRIB) != 0)
673 	{
674 		if ( bSkipAttrForEmpty )
675 		{
676 			//	copy only attributes for non-empty cells
677 			//	(notes are not counted as non-empty here, to match the content behavior)
678 
679 			SCSIZE nStartIndex;
680 			rColumn.Search( nRow1-nDy, nStartIndex );
681 			while ( nStartIndex < rColumn.nCount && rColumn.pItems[nStartIndex].nRow <= nRow2-nDy )
682 			{
683 				SCSIZE nEndIndex = nStartIndex;
684 				if ( rColumn.pItems[nStartIndex].pCell->GetCellType() != CELLTYPE_NOTE )
685 				{
686 					SCROW nStartRow = rColumn.pItems[nStartIndex].nRow;
687 					SCROW nEndRow = nStartRow;
688 
689 					//	find consecutive non-empty cells
690 
691 					while ( nEndRow < nRow2-nDy &&
692 							nEndIndex+1 < rColumn.nCount &&
693 							rColumn.pItems[nEndIndex+1].nRow == nEndRow+1 &&
694 							rColumn.pItems[nEndIndex+1].pCell->GetCellType() != CELLTYPE_NOTE )
695 					{
696 						++nEndIndex;
697 						++nEndRow;
698 					}
699 
700 					rColumn.pAttrArray->CopyAreaSafe( nStartRow+nDy, nEndRow+nDy, nDy, *pAttrArray );
701 				}
702 				nStartIndex = nEndIndex + 1;
703 			}
704 		}
705 		else
706 			rColumn.pAttrArray->CopyAreaSafe( nRow1, nRow2, nDy, *pAttrArray );
707 	}
708     if ((nInsFlag & IDF_CONTENTS) == 0)
709 		return;
710 
711 	if ( bAsLink && nInsFlag == IDF_ALL )
712 	{
713 		//	bei "alles" werden auch leere Zellen referenziert
714 		//!	IDF_ALL muss immer mehr Flags enthalten, als bei "Inhalte Einfuegen"
715 		//!	einzeln ausgewaehlt werden koennen!
716 
717 		Resize( nCount + static_cast<SCSIZE>(nRow2-nRow1+1) );
718 
719 		ScAddress aDestPos( nCol, 0, nTab );		// Row wird angepasst
720 
721 		//	Referenz erzeugen (Quell-Position)
722 		ScSingleRefData aRef;
723 		aRef.nCol = rColumn.nCol;
724 		//	nRow wird angepasst
725 		aRef.nTab = rColumn.nTab;
726 		aRef.InitFlags();							// -> alles absolut
727 		aRef.SetFlag3D(sal_True);
728 
729 		for (SCROW nDestRow = nRow1; nDestRow <= nRow2; nDestRow++)
730 		{
731 			aRef.nRow = nDestRow - nDy;				// Quell-Zeile
732 			aDestPos.SetRow( nDestRow );
733 
734 			aRef.CalcRelFromAbs( aDestPos );
735 			ScTokenArray aArr;
736 			aArr.AddSingleReference( aRef );
737 			Insert( nDestRow, new ScFormulaCell( pDocument, aDestPos, &aArr ) );
738 		}
739 
740 		return;
741 	}
742 
743 	SCSIZE nColCount = rColumn.nCount;
744 
745     // ignore IDF_FORMULA - "all contents but no formulas" results in the same number of cells
746 	if ((nInsFlag & ( IDF_CONTENTS & ~IDF_FORMULA )) == ( IDF_CONTENTS & ~IDF_FORMULA ) && nRow2-nRow1 >= 64)
747 	{
748         //! Always do the Resize from the outside, where the number of repetitions is known
749         //! (then it can be removed here)
750 
751 		SCSIZE nNew = nCount + nColCount;
752 		if ( nLimit < nNew )
753 			Resize( nNew );
754 	}
755 
756     // IDF_ADDNOTES must be passed without other content flags than IDF_NOTE
757     bool bAddNotes = (nInsFlag & (IDF_CONTENTS | IDF_ADDNOTES)) == (IDF_NOTE | IDF_ADDNOTES);
758 
759 	sal_Bool bAtEnd = sal_False;
760 	for (SCSIZE i = 0; i < nColCount && !bAtEnd; i++)
761 	{
762 		SCsROW nDestRow = rColumn.pItems[i].nRow + nDy;
763 		if ( nDestRow > (SCsROW) nRow2 )
764 			bAtEnd = sal_True;
765 		else if ( nDestRow >= (SCsROW) nRow1 )
766 		{
767 			//	rows at the beginning may be skipped if filtered rows are left out,
768 			//	nDestRow may be negative then
769 
770             ScAddress aDestPos( nCol, (SCROW)nDestRow, nTab );
771 
772             /*  #i102056# Paste from clipboard needs to paste the cell notes in
773                 a second pass. This must not overwrite the existing cells
774                 already copied to the destination position in the first pass.
775                 To indicate this special case, the modifier IDF_ADDNOTES is
776                 passed together with IDF_NOTE in nInsFlag. Of course, there is
777                 still the need to create a new cell, if there is no cell at the
778                 destination position at all. */
779             ScBaseCell* pAddNoteCell = bAddNotes ? GetCell( aDestPos.Row() ) : 0;
780             if (pAddNoteCell)
781             {
782                 // do nothing if source cell does not contain a note
783                 const ScBaseCell* pSourceCell = rColumn.pItems[i].pCell;
784                 const ScPostIt* pSourceNote = pSourceCell ? pSourceCell->GetNote() : 0;
785                 if (pSourceNote)
786                 {
787                     DBG_ASSERT( !pAddNoteCell->HasNote(), "ScColumn::CopyFromClip - unexpected note at destination cell" );
788                     bool bCloneCaption = (nInsFlag & IDF_NOCAPTIONS) == 0;
789                     // #i52342# if caption is cloned, the note must be constructed with the destination document
790                     ScAddress aSourcePos( rColumn.nCol, rColumn.pItems[i].nRow, rColumn.nTab );
791                     ScPostIt* pNewNote = pSourceNote->Clone( aSourcePos, *pDocument, aDestPos, bCloneCaption );
792                     pAddNoteCell->TakeNote( pNewNote );
793                 }
794             }
795             else
796             {
797                 ScBaseCell* pNewCell = bAsLink ?
798                     rColumn.CreateRefCell( pDocument, aDestPos, i, nInsFlag ) :
799                     rColumn.CloneCell( i, nInsFlag, *pDocument, aDestPos );
800                 if (pNewCell)
801                     Insert( aDestPos.Row(), pNewCell );
802             }
803 		}
804 	}
805 }
806 
807 
808 namespace {
809 
810 /** Helper for ScColumn::CloneCell - decides whether to clone a value cell depending on clone flags and number format. */
lclCanCloneValue(ScDocument & rDoc,const ScColumn & rCol,SCROW nRow,bool bCloneValue,bool bCloneDateTime)811 bool lclCanCloneValue( ScDocument& rDoc, const ScColumn& rCol, SCROW nRow, bool bCloneValue, bool bCloneDateTime )
812 {
813     // values and dates, or nothing to be cloned -> not needed to check number format
814     if( bCloneValue == bCloneDateTime )
815         return bCloneValue;
816 
817     // check number format of value cell
818     sal_uLong nNumIndex = (sal_uLong)((SfxUInt32Item*)rCol.GetAttr( nRow, ATTR_VALUE_FORMAT ))->GetValue();
819     short nTyp = rDoc.GetFormatTable()->GetType( nNumIndex );
820     bool bIsDateTime = (nTyp == NUMBERFORMAT_DATE) || (nTyp == NUMBERFORMAT_TIME) || (nTyp == NUMBERFORMAT_DATETIME);
821     return bIsDateTime ? bCloneDateTime : bCloneValue;
822 }
823 
824 } // namespace
825 
826 
CloneCell(SCSIZE nIndex,sal_uInt16 nFlags,ScDocument & rDestDoc,const ScAddress & rDestPos)827 ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, sal_uInt16 nFlags, ScDocument& rDestDoc, const ScAddress& rDestPos)
828 {
829     bool bCloneValue    = (nFlags & IDF_VALUE) != 0;
830     bool bCloneDateTime = (nFlags & IDF_DATETIME) != 0;
831     bool bCloneString   = (nFlags & IDF_STRING) != 0;
832     bool bCloneFormula  = (nFlags & IDF_FORMULA) != 0;
833     bool bCloneNote     = (nFlags & IDF_NOTE) != 0;
834 
835     ScBaseCell* pNew = 0;
836     ScBaseCell& rSource = *pItems[nIndex].pCell;
837     switch (rSource.GetCellType())
838 	{
839 		case CELLTYPE_NOTE:
840             // note will be cloned below
841         break;
842 
843         case CELLTYPE_STRING:
844 		case CELLTYPE_EDIT:
845             // note will be cloned below
846             if (bCloneString)
847                 pNew = rSource.CloneWithoutNote( rDestDoc, rDestPos );
848         break;
849 
850 		case CELLTYPE_VALUE:
851             // note will be cloned below
852             if (lclCanCloneValue( *pDocument, *this, pItems[nIndex].nRow, bCloneValue, bCloneDateTime ))
853                 pNew = rSource.CloneWithoutNote( rDestDoc, rDestPos );
854         break;
855 
856 		case CELLTYPE_FORMULA:
857             if (bCloneFormula)
858             {
859                 // note will be cloned below
860                 pNew = rSource.CloneWithoutNote( rDestDoc, rDestPos );
861             }
862             else if ( (bCloneValue || bCloneDateTime || bCloneString) && !rDestDoc.IsUndo() )
863             {
864                 //  #48491# ins Undo-Dokument immer nur die Original-Zelle kopieren,
865                 //  aus Formeln keine Value/String-Zellen erzeugen
866                 ScFormulaCell& rForm = (ScFormulaCell&)rSource;
867                 sal_uInt16 nErr = rForm.GetErrCode();
868                 if ( nErr )
869                 {
870                     // error codes are cloned with values
871                     if (bCloneValue)
872                     {
873                         ScFormulaCell* pErrCell = new ScFormulaCell( &rDestDoc, rDestPos );
874                         pErrCell->SetErrCode( nErr );
875                         pNew = pErrCell;
876                     }
877                 }
878                 else if (rForm.IsValue())
879                 {
880                     if (lclCanCloneValue( *pDocument, *this, pItems[nIndex].nRow, bCloneValue, bCloneDateTime ))
881                     {
882                         double nVal = rForm.GetValue();
883                         pNew = new ScValueCell(nVal);
884                     }
885                 }
886                 else if (bCloneString)
887                 {
888                     String aString;
889                     rForm.GetString( aString );
890                     // #33224# do not clone empty string
891                     if (aString.Len() > 0)
892                     {
893                         if ( rForm.IsMultilineResult() )
894                         {
895                             pNew = new ScEditCell( aString, &rDestDoc );
896                         }
897                         else
898                         {
899                             pNew = new ScStringCell( aString );
900                         }
901                     }
902                 }
903             }
904         break;
905 
906         default: DBG_ERRORFILE( "ScColumn::CloneCell - unknown cell type" );
907 	}
908 
909     // clone the cell note
910     if (bCloneNote)
911     {
912         if (ScPostIt* pNote = rSource.GetNote())
913         {
914             bool bCloneCaption = (nFlags & IDF_NOCAPTIONS) == 0;
915             // #i52342# if caption is cloned, the note must be constructed with the destination document
916             ScAddress aOwnPos( nCol, pItems[nIndex].nRow, nTab );
917             ScPostIt* pNewNote = pNote->Clone( aOwnPos, rDestDoc, rDestPos, bCloneCaption );
918             if (!pNew)
919                 pNew = new ScNoteCell( pNewNote );
920             else
921                 pNew->TakeNote( pNewNote );
922         }
923     }
924 
925 	return pNew;
926 }
927 
928 
MixMarked(const ScMarkData & rMark,sal_uInt16 nFunction,sal_Bool bSkipEmpty,ScColumn & rSrcCol)929 void ScColumn::MixMarked( const ScMarkData& rMark, sal_uInt16 nFunction,
930 							sal_Bool bSkipEmpty, ScColumn& rSrcCol )
931 {
932 	SCROW nRow1, nRow2;
933 
934 	if (rMark.IsMultiMarked())
935 	{
936 		ScMarkArrayIter aIter( rMark.GetArray()+nCol );
937 		while (aIter.Next( nRow1, nRow2 ))
938 			MixData( nRow1, nRow2, nFunction, bSkipEmpty, rSrcCol );
939 	}
940 }
941 
942 
943 //	Ergebnis in rVal1
944 
lcl_DoFunction(double & rVal1,double nVal2,sal_uInt16 nFunction)945 sal_Bool lcl_DoFunction( double& rVal1, double nVal2, sal_uInt16 nFunction )
946 {
947 	sal_Bool bOk = sal_False;
948 	switch (nFunction)
949 	{
950 		case PASTE_ADD:
951 			bOk = SubTotal::SafePlus( rVal1, nVal2 );
952 			break;
953 		case PASTE_SUB:
954 			nVal2 = -nVal2;		//! geht das immer ohne Fehler?
955 			bOk = SubTotal::SafePlus( rVal1, nVal2 );
956 			break;
957 		case PASTE_MUL:
958 			bOk = SubTotal::SafeMult( rVal1, nVal2 );
959 			break;
960 		case PASTE_DIV:
961 			bOk = SubTotal::SafeDiv( rVal1, nVal2 );
962 			break;
963 	}
964 	return bOk;
965 }
966 
967 
lcl_AddCode(ScTokenArray & rArr,ScFormulaCell * pCell)968 void lcl_AddCode( ScTokenArray& rArr, ScFormulaCell* pCell )
969 {
970 	rArr.AddOpCode(ocOpen);
971 
972 	ScTokenArray* pCode = pCell->GetCode();
973 	if (pCode)
974 	{
975         const formula::FormulaToken* pToken = pCode->First();
976 		while (pToken)
977 		{
978 			rArr.AddToken( *pToken );
979 			pToken = pCode->Next();
980 		}
981 	}
982 
983 	rArr.AddOpCode(ocClose);
984 }
985 
986 
MixData(SCROW nRow1,SCROW nRow2,sal_uInt16 nFunction,sal_Bool bSkipEmpty,ScColumn & rSrcCol)987 void ScColumn::MixData( SCROW nRow1, SCROW nRow2,
988 							sal_uInt16 nFunction, sal_Bool bSkipEmpty,
989 							ScColumn& rSrcCol )
990 {
991 	SCSIZE nSrcCount = rSrcCol.nCount;
992 
993 	SCSIZE nIndex;
994 	Search( nRow1, nIndex );
995 
996 //	SCSIZE nSrcIndex = 0;
997 	SCSIZE nSrcIndex;
998 	rSrcCol.Search( nRow1, nSrcIndex );			//! Testen, ob Daten ganz vorne
999 
1000 	SCROW nNextThis = MAXROW+1;
1001 	if ( nIndex < nCount )
1002 		nNextThis = pItems[nIndex].nRow;
1003 	SCROW nNextSrc = MAXROW+1;
1004 	if ( nSrcIndex < nSrcCount )
1005 		nNextSrc = rSrcCol.pItems[nSrcIndex].nRow;
1006 
1007 	while ( nNextThis <= nRow2 || nNextSrc <= nRow2 )
1008 	{
1009 		SCROW nRow = Min( nNextThis, nNextSrc );
1010 
1011 		ScBaseCell* pSrc = NULL;
1012 		ScBaseCell* pDest = NULL;
1013 		ScBaseCell* pNew = NULL;
1014 		sal_Bool bDelete = sal_False;
1015 
1016 		if ( nSrcIndex < nSrcCount && nNextSrc == nRow )
1017 			pSrc = rSrcCol.pItems[nSrcIndex].pCell;
1018 
1019 		if ( nIndex < nCount && nNextThis == nRow )
1020 			pDest = pItems[nIndex].pCell;
1021 
1022         DBG_ASSERT( pSrc || pDest, "Nanu ?" );
1023 
1024 		CellType eSrcType  = pSrc  ? pSrc->GetCellType()  : CELLTYPE_NONE;
1025 		CellType eDestType = pDest ? pDest->GetCellType() : CELLTYPE_NONE;
1026 
1027 		sal_Bool bSrcEmpty = ( eSrcType == CELLTYPE_NONE || eSrcType == CELLTYPE_NOTE );
1028 		sal_Bool bDestEmpty = ( eDestType == CELLTYPE_NONE || eDestType == CELLTYPE_NOTE );
1029 
1030 		if ( bSkipEmpty && bDestEmpty )		// Originalzelle wiederherstellen
1031 		{
1032 			if ( pSrc )						// war da eine Zelle?
1033 			{
1034                 pNew = pSrc->CloneWithoutNote( *pDocument );
1035 			}
1036 		}
1037 		else if ( nFunction )				// wirklich Rechenfunktion angegeben
1038 		{
1039 			double nVal1;
1040 			double nVal2;
1041 			if ( eSrcType == CELLTYPE_VALUE )
1042 				nVal1 = ((ScValueCell*)pSrc)->GetValue();
1043 			else
1044 				nVal1 = 0.0;
1045 			if ( eDestType == CELLTYPE_VALUE )
1046 				nVal2 = ((ScValueCell*)pDest)->GetValue();
1047 			else
1048 				nVal2 = 0.0;
1049 
1050 			//	leere Zellen werden als Werte behandelt
1051 
1052 			sal_Bool bSrcVal  = ( bSrcEmpty || eSrcType == CELLTYPE_VALUE );
1053 			sal_Bool bDestVal  = ( bDestEmpty || eDestType == CELLTYPE_VALUE );
1054 
1055 			sal_Bool bSrcText = ( eSrcType == CELLTYPE_STRING ||
1056 								eSrcType == CELLTYPE_EDIT );
1057 			sal_Bool bDestText = ( eDestType == CELLTYPE_STRING ||
1058 								eDestType == CELLTYPE_EDIT );
1059 
1060 			//	sonst bleibt nur Formel...
1061 
1062 			if ( bSrcEmpty && bDestEmpty )
1063 			{
1064 				//	beide leer -> nix
1065 			}
1066 			else if ( bSrcVal && bDestVal )
1067 			{
1068 				//	neuen Wert eintragen, oder Fehler bei Ueberlauf
1069 
1070 				sal_Bool bOk = lcl_DoFunction( nVal1, nVal2, nFunction );
1071 
1072 				if (bOk)
1073 					pNew = new ScValueCell( nVal1 );
1074 				else
1075 				{
1076 					ScFormulaCell* pFC = new ScFormulaCell( pDocument,
1077 												ScAddress( nCol, nRow, nTab ) );
1078 					pFC->SetErrCode( errNoValue );
1079 					//!	oder NOVALUE, dann auch in consoli,
1080 					//!	sonst in Interpreter::GetCellValue die Abfrage auf errNoValue raus
1081 					//!	(dann geht Stringzelle+Wertzelle nicht mehr)
1082 					pNew = pFC;
1083 				}
1084 			}
1085 			else if ( bSrcText || bDestText )
1086 			{
1087 				//	mit Texten wird nicht gerechnet - immer "alte" Zelle, also pSrc
1088 
1089 				if (pSrc)
1090                     pNew = pSrc->CloneWithoutNote( *pDocument );
1091 				else if (pDest)
1092 					bDelete = sal_True;
1093 			}
1094 			else
1095 			{
1096 				//	Kombination aus Wert und mindestens einer Formel -> Formel erzeugen
1097 
1098 				ScTokenArray aArr;
1099 
1100 				//	erste Zelle
1101 				if ( eSrcType == CELLTYPE_FORMULA )
1102 					lcl_AddCode( aArr, (ScFormulaCell*)pSrc );
1103 				else
1104 					aArr.AddDouble( nVal1 );
1105 
1106 				//	Operator
1107 				OpCode eOp = ocAdd;
1108 				switch ( nFunction )
1109 				{
1110 					case PASTE_ADD:	eOp = ocAdd; break;
1111 					case PASTE_SUB:	eOp = ocSub; break;
1112 					case PASTE_MUL:	eOp = ocMul; break;
1113 					case PASTE_DIV:	eOp = ocDiv; break;
1114 				}
1115 				aArr.AddOpCode(eOp);				// Funktion
1116 
1117 				//	zweite Zelle
1118 				if ( eDestType == CELLTYPE_FORMULA )
1119 					lcl_AddCode( aArr, (ScFormulaCell*)pDest );
1120 				else
1121 					aArr.AddDouble( nVal2 );
1122 
1123 				pNew = new ScFormulaCell( pDocument, ScAddress( nCol, nRow, nTab ), &aArr );
1124 			}
1125 		}
1126 
1127 
1128 		if ( pNew || bDelete )			// neues Ergebnis ?
1129 		{
1130 			if (pDest && !pNew)						// alte Zelle da ?
1131 			{
1132 				if ( pDest->GetBroadcaster() )
1133 					pNew = new ScNoteCell;			// Broadcaster uebernehmen
1134 				else
1135 					Delete(nRow);					// -> loeschen
1136 			}
1137 			if (pNew)
1138 				Insert(nRow, pNew);		// neue einfuegen
1139 
1140 			Search( nRow, nIndex );		// alles kann sich verschoben haben
1141 			if (pNew)
1142 				nNextThis = nRow;		// nIndex zeigt jetzt genau auf nRow
1143 			else
1144 				nNextThis = ( nIndex < nCount ) ? pItems[nIndex].nRow : MAXROW+1;
1145 		}
1146 
1147 		if ( nNextThis == nRow )
1148 		{
1149 			++nIndex;
1150 			nNextThis = ( nIndex < nCount ) ? pItems[nIndex].nRow : MAXROW+1;
1151 		}
1152 		if ( nNextSrc == nRow )
1153 		{
1154 			++nSrcIndex;
1155 			nNextSrc = ( nSrcIndex < nSrcCount ) ?
1156 							rSrcCol.pItems[nSrcIndex].nRow :
1157 							MAXROW+1;
1158 		}
1159 	}
1160 }
1161 
1162 
CreateAttrIterator(SCROW nStartRow,SCROW nEndRow) const1163 ScAttrIterator* ScColumn::CreateAttrIterator( SCROW nStartRow, SCROW nEndRow ) const
1164 {
1165 	return new ScAttrIterator( pAttrArray, nStartRow, nEndRow );
1166 }
1167 
1168 
StartAllListeners()1169 void ScColumn::StartAllListeners()
1170 {
1171 	if (pItems)
1172 		for (SCSIZE i = 0; i < nCount; i++)
1173 		{
1174 			ScBaseCell* pCell = pItems[i].pCell;
1175 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1176 			{
1177 				SCROW nRow = pItems[i].nRow;
1178 				((ScFormulaCell*)pCell)->StartListeningTo( pDocument );
1179 				if ( nRow != pItems[i].nRow )
1180 					Search( nRow, i );		// Listener eingefuegt?
1181 			}
1182 		}
1183 }
1184 
1185 
StartNeededListeners()1186 void ScColumn::StartNeededListeners()
1187 {
1188 	if (pItems)
1189     {
1190 		for (SCSIZE i = 0; i < nCount; i++)
1191 		{
1192 			ScBaseCell* pCell = pItems[i].pCell;
1193 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1194 			{
1195                 ScFormulaCell* pFCell = static_cast<ScFormulaCell*>(pCell);
1196                 if (pFCell->NeedsListening())
1197                 {
1198                     SCROW nRow = pItems[i].nRow;
1199                     pFCell->StartListeningTo( pDocument );
1200                     if ( nRow != pItems[i].nRow )
1201                         Search( nRow, i );		// Listener eingefuegt?
1202                 }
1203 			}
1204 		}
1205     }
1206 }
1207 
1208 
BroadcastInArea(SCROW nRow1,SCROW nRow2)1209 void ScColumn::BroadcastInArea( SCROW nRow1, SCROW nRow2 )
1210 {
1211 	if ( pItems )
1212 	{
1213         SCROW nRow;
1214         SCSIZE nIndex;
1215 		Search( nRow1, nIndex );
1216 		while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
1217 		{
1218 			ScBaseCell* pCell = pItems[nIndex].pCell;
1219 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1220 				((ScFormulaCell*)pCell)->SetDirty();
1221 			else
1222 				pDocument->Broadcast( ScHint( SC_HINT_DATACHANGED,
1223 					ScAddress( nCol, nRow, nTab ), pCell ) );
1224 			nIndex++;
1225 		}
1226 	}
1227 }
1228 
1229 
StartListeningInArea(SCROW nRow1,SCROW nRow2)1230 void ScColumn::StartListeningInArea( SCROW nRow1, SCROW nRow2 )
1231 {
1232 	if ( pItems )
1233 	{
1234         SCROW nRow;
1235         SCSIZE nIndex;
1236 		Search( nRow1, nIndex );
1237 		while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRow2 )
1238 		{
1239 			ScBaseCell* pCell = pItems[nIndex].pCell;
1240 			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
1241 				((ScFormulaCell*)pCell)->StartListeningTo( pDocument );
1242 			if ( nRow != pItems[nIndex].nRow )
1243 				Search( nRow, nIndex );		// durch Listening eingefuegt
1244 			nIndex++;
1245 		}
1246 	}
1247 }
1248 
1249 
1250 //	sal_True = Zahlformat gesetzt
SetString(SCROW nRow,SCTAB nTabP,const String & rString,formula::FormulaGrammar::AddressConvention eConv,SvNumberFormatter * pLangFormatter,bool bDetectNumberFormat)1251 sal_Bool ScColumn::SetString( SCROW nRow, SCTAB nTabP, const String& rString,
1252                           formula::FormulaGrammar::AddressConvention eConv,
1253                           SvNumberFormatter* pLangFormatter, bool bDetectNumberFormat )
1254 {
1255 	sal_Bool bNumFmtSet = sal_False;
1256 	if (VALIDROW(nRow))
1257 	{
1258 		ScBaseCell* pNewCell = NULL;
1259 		sal_Bool bIsLoading = sal_False;
1260 		if (rString.Len() > 0)
1261 		{
1262 			double nVal;
1263             sal_uInt32 nIndex, nOldIndex = 0;
1264 			sal_Unicode cFirstChar;
1265             // #i110979# If a different NumberFormatter is passed in (pLangFormatter),
1266             // its formats aren't valid in the document.
1267             // Only use the language / LocaleDataWrapper from pLangFormatter,
1268             // always the document's number formatter for IsNumberFormat.
1269             SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
1270 			SfxObjectShell* pDocSh = pDocument->GetDocumentShell();
1271 			if ( pDocSh )
1272 				bIsLoading = pDocSh->IsLoading();
1273 			// IsLoading bei ConvertFrom Import
1274 			if ( !bIsLoading )
1275 			{
1276 				nIndex = nOldIndex = GetNumberFormat( nRow );
1277 				if ( rString.Len() > 1
1278 						&& pFormatter->GetType(nIndex) != NUMBERFORMAT_TEXT )
1279 					cFirstChar = rString.GetChar(0);
1280 				else
1281 					cFirstChar = 0;								// Text
1282 			}
1283 			else
1284 			{	// waehrend ConvertFrom Import gibt es keine gesetzten Formate
1285 				cFirstChar = rString.GetChar(0);
1286 			}
1287 
1288 			if ( cFirstChar == '=' )
1289 			{
1290 				if ( rString.Len() == 1 )						// = Text
1291 					pNewCell = new ScStringCell( rString );
1292 				else											// =Formel
1293 					pNewCell = new ScFormulaCell( pDocument,
1294                         ScAddress( nCol, nRow, nTabP ), rString,
1295                         formula::FormulaGrammar::mergeToGrammar( formula::FormulaGrammar::GRAM_DEFAULT,
1296                             eConv), MM_NONE );
1297 			}
1298 			else if ( cFirstChar == '\'')						// 'Text
1299 				pNewCell = new ScStringCell( rString.Copy(1) );
1300 			else
1301 			{
1302 				sal_Bool bIsText = sal_False;
1303 				if ( bIsLoading )
1304 				{
1305 					if ( pItems && nCount )
1306 					{
1307 						String aStr;
1308 						SCSIZE i = nCount;
1309 						SCSIZE nStop = (i >= 3 ? i - 3 : 0);
1310 						// die letzten Zellen vergleichen, ob gleicher String
1311 						// und IsNumberFormat eingespart werden kann
1312 						do
1313 						{
1314 							i--;
1315 							ScBaseCell* pCell = pItems[i].pCell;
1316 							switch ( pCell->GetCellType() )
1317 							{
1318 								case CELLTYPE_STRING :
1319 									((ScStringCell*)pCell)->GetString( aStr );
1320 									if ( rString == aStr )
1321 										bIsText = sal_True;
1322 								break;
1323 								case CELLTYPE_NOTE :	// durch =Formel referenziert
1324 								break;
1325 								default:
1326 									if ( i == nCount - 1 )
1327 										i = 0;
1328 										// wahrscheinlich ganze Spalte kein String
1329 							}
1330 						} while ( i && i > nStop && !bIsText );
1331 					}
1332 					// nIndex fuer IsNumberFormat vorbelegen
1333 					if ( !bIsText )
1334 						nIndex = nOldIndex = pFormatter->GetStandardIndex();
1335 				}
1336 
1337                 do
1338                 {
1339                     if (bIsText)
1340                         break;
1341 
1342                     if (bDetectNumberFormat)
1343                     {
1344                         if ( pLangFormatter )
1345                         {
1346                             // for number detection: valid format index for selected language
1347                             nIndex = pFormatter->GetStandardIndex( pLangFormatter->GetLanguage() );
1348                         }
1349 
1350                         if (!pFormatter->IsNumberFormat(rString, nIndex, nVal))
1351                             break;
1352 
1353                         if ( pLangFormatter )
1354                         {
1355                             // convert back to the original language if a built-in format was detected
1356                             const SvNumberformat* pOldFormat = pFormatter->GetEntry( nOldIndex );
1357                             if ( pOldFormat )
1358                                 nIndex = pFormatter->GetFormatForLanguageIfBuiltIn( nIndex, pOldFormat->GetLanguage() );
1359                         }
1360 
1361                         pNewCell = new ScValueCell( nVal );
1362                         if ( nIndex != nOldIndex)
1363                         {
1364                             // #i22345# New behavior: Apply the detected number format only if
1365                             // the old one was the default number, date, time or boolean format.
1366                             // Exception: If the new format is boolean, always apply it.
1367 
1368                             sal_Bool bOverwrite = sal_False;
1369                             const SvNumberformat* pOldFormat = pFormatter->GetEntry( nOldIndex );
1370                             if ( pOldFormat )
1371                             {
1372                                 short nOldType = pOldFormat->GetType() & ~NUMBERFORMAT_DEFINED;
1373                                 if ( nOldType == NUMBERFORMAT_NUMBER || nOldType == NUMBERFORMAT_DATE ||
1374                                      nOldType == NUMBERFORMAT_TIME || nOldType == NUMBERFORMAT_LOGICAL )
1375                                 {
1376                                     if ( nOldIndex == pFormatter->GetStandardFormat(
1377                                                         nOldType, pOldFormat->GetLanguage() ) )
1378                                     {
1379                                         bOverwrite = sal_True;      // default of these types can be overwritten
1380                                     }
1381                                 }
1382                             }
1383                             if ( !bOverwrite && pFormatter->GetType( nIndex ) == NUMBERFORMAT_LOGICAL )
1384                             {
1385                                 bOverwrite = sal_True;              // overwrite anything if boolean was detected
1386                             }
1387 
1388                             if ( bOverwrite )
1389                             {
1390                                 ApplyAttr( nRow, SfxUInt32Item( ATTR_VALUE_FORMAT,
1391                                     (sal_uInt32) nIndex) );
1392                                 bNumFmtSet = sal_True;
1393                             }
1394                         }
1395                     }
1396                     else
1397                     {
1398                         // Only check if the string is a regular number.
1399                         SvNumberFormatter* pLocaleSource = pLangFormatter ? pLangFormatter : pFormatter;
1400                         const LocaleDataWrapper* pLocale = pLocaleSource->GetLocaleData();
1401                         if (!pLocale)
1402                             break;
1403 
1404                         LocaleDataItem aLocaleItem = pLocale->getLocaleItem();
1405                         const OUString& rDecSep = aLocaleItem.decimalSeparator;
1406                         const OUString& rGroupSep = aLocaleItem.thousandSeparator;
1407                         if (rDecSep.getLength() != 1 || rGroupSep.getLength() != 1)
1408                             break;
1409 
1410                         sal_Unicode dsep = rDecSep.getStr()[0];
1411                         sal_Unicode gsep = rGroupSep.getStr()[0];
1412 
1413                         if (!ScStringUtil::parseSimpleNumber(rString, dsep, gsep, nVal))
1414                             break;
1415 
1416                         pNewCell = new ScValueCell(nVal);
1417                     }
1418                 }
1419                 while (false);
1420 
1421                 if (!pNewCell)
1422                     pNewCell = new ScStringCell(rString);
1423             }
1424         }
1425 
1426 		if ( bIsLoading && (!nCount || nRow > pItems[nCount-1].nRow) )
1427 		{	// Search einsparen und ohne Umweg ueber Insert, Listener aufbauen
1428 			// und Broadcast kommt eh erst nach dem Laden
1429 			if ( pNewCell )
1430 				Append( nRow, pNewCell );
1431 		}
1432 		else
1433 		{
1434 			SCSIZE i;
1435 			if (Search(nRow, i))
1436 			{
1437 				ScBaseCell* pOldCell = pItems[i].pCell;
1438 				ScPostIt* pNote = pOldCell->ReleaseNote();
1439                 SvtBroadcaster* pBC = pOldCell->ReleaseBroadcaster();
1440 				if (pNewCell || pNote || pBC)
1441 				{
1442 					if (pNewCell)
1443                         pNewCell->TakeNote( pNote );
1444                     else
1445 						pNewCell = new ScNoteCell( pNote );
1446 					if (pBC)
1447 					{
1448                         pNewCell->TakeBroadcaster(pBC);
1449 						pLastFormulaTreeTop = 0;	// Err527 Workaround
1450 					}
1451 
1452 					if ( pOldCell->GetCellType() == CELLTYPE_FORMULA )
1453 					{
1454 						pOldCell->EndListeningTo( pDocument );
1455 						// falls in EndListening NoteCell in gleicher Col zerstoert
1456 						if ( i >= nCount || pItems[i].nRow != nRow )
1457 							Search(nRow, i);
1458 					}
1459 					pOldCell->Delete();
1460 					pItems[i].pCell = pNewCell;			// ersetzen
1461 					if ( pNewCell->GetCellType() == CELLTYPE_FORMULA )
1462 					{
1463 						pNewCell->StartListeningTo( pDocument );
1464 						((ScFormulaCell*)pNewCell)->SetDirty();
1465 					}
1466 					else
1467 						pDocument->Broadcast( ScHint( SC_HINT_DATACHANGED,
1468                             ScAddress( nCol, nRow, nTabP ), pNewCell ) );
1469 				}
1470 				else
1471 				{
1472 					DeleteAtIndex(i);					// loeschen und Broadcast
1473 				}
1474 			}
1475 			else if (pNewCell)
1476 			{
1477 				Insert(nRow, pNewCell);					// neu eintragen und Broadcast
1478 			}
1479 		}
1480 
1481 		//	hier keine Formate mehr fuer Formeln setzen!
1482 		//	(werden bei der Ausgabe abgefragt)
1483 
1484 	}
1485 	return bNumFmtSet;
1486 }
1487 
1488 
GetFilterEntries(SCROW nStartRow,SCROW nEndRow,TypedScStrCollection & rStrings,bool & rHasDates)1489 void ScColumn::GetFilterEntries(SCROW nStartRow, SCROW nEndRow, TypedScStrCollection& rStrings, bool& rHasDates)
1490 {
1491     bool bHasDates = false;
1492 	SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
1493 	String aString;
1494     SCROW nRow = 0;
1495 	SCSIZE nIndex;
1496 
1497 	Search( nStartRow, nIndex );
1498 
1499 	while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : sal_False )
1500 	{
1501 		ScBaseCell*			 pCell	  = pItems[nIndex].pCell;
1502 		TypedStrData*		 pData;
1503 		sal_uLong				 nFormat  = GetNumberFormat( nRow );
1504 
1505 		ScCellFormat::GetInputString( pCell, nFormat, aString, *pFormatter );
1506 
1507 		if ( pDocument->HasStringData( nCol, nRow, nTab ) )
1508 			pData = new TypedStrData( aString );
1509 		else
1510 		{
1511 			double nValue;
1512 
1513 			switch ( pCell->GetCellType() )
1514 			{
1515 				case CELLTYPE_VALUE:
1516 					nValue = ((ScValueCell*)pCell)->GetValue();
1517 					break;
1518 
1519 				case CELLTYPE_FORMULA:
1520 					nValue = ((ScFormulaCell*)pCell)->GetValue();
1521 					break;
1522 
1523 				default:
1524 					nValue = 0.0;
1525 			}
1526 
1527             if (pFormatter)
1528             {
1529                 short nType = pFormatter->GetType(nFormat);
1530                 if ((nType & NUMBERFORMAT_DATE) && !(nType & NUMBERFORMAT_TIME))
1531                 {
1532                     // special case for date values.  Disregard the time
1533                     // element if the number format is of date type.
1534                     nValue = ::rtl::math::approxFloor(nValue);
1535                     bHasDates = true;
1536                 }
1537             }
1538 
1539 			pData = new TypedStrData( aString, nValue, SC_STRTYPE_VALUE );
1540 		}
1541 #if 0 // DR
1542 		ScPostIt aCellNote( ScPostIt::UNINITIALIZED );
1543 		// Hide visible notes during Filtering.
1544 		if(pCell->GetNote(aCellNote) && aCellNote.IsCaptionShown())
1545 		{
1546 		    ScDetectiveFunc( pDocument, nTab ).HideComment( nCol, nRow );
1547 		    aCellNote.SetShown( false );
1548 		    pCell->SetNote(aCellNote);
1549 		}
1550 #endif
1551 
1552 		if ( !rStrings.Insert( pData ) )
1553 			delete pData;								// doppelt
1554 
1555 		++nIndex;
1556 	}
1557 
1558     rHasDates = bHasDates;
1559 }
1560 
1561 //
1562 //	GetDataEntries - Strings aus zusammenhaengendem Bereich um nRow
1563 //
1564 
1565 //	DATENT_MAX		- max. Anzahl Eintrage in Liste fuer Auto-Eingabe
1566 //	DATENT_SEARCH	- max. Anzahl Zellen, die durchsucht werden - neu: nur Strings zaehlen
1567 #define DATENT_MAX		200
1568 #define DATENT_SEARCH	2000
1569 
1570 
GetDataEntries(SCROW nStartRow,TypedScStrCollection & rStrings,sal_Bool bLimit)1571 sal_Bool ScColumn::GetDataEntries(SCROW nStartRow, TypedScStrCollection& rStrings, sal_Bool bLimit)
1572 {
1573 	sal_Bool bFound = sal_False;
1574 	SCSIZE nThisIndex;
1575 	sal_Bool bThisUsed = Search( nStartRow, nThisIndex );
1576 	String aString;
1577 	sal_uInt16 nCells = 0;
1578 
1579 	//	Die Beschraenkung auf angrenzende Zellen (ohne Luecken) ist nicht mehr gewollt
1580 	//	(Featurekommission zur 5.1), stattdessen abwechselnd nach oben und unten suchen,
1581 	//	damit naheliegende Zellen wenigstens zuerst gefunden werden.
1582 	//!	Abstaende der Zeilennummern vergleichen? (Performance??)
1583 
1584 	SCSIZE nUpIndex = nThisIndex;		// zeigt hinter die Zelle
1585 	SCSIZE nDownIndex = nThisIndex;		// zeigt auf die Zelle
1586 	if (bThisUsed)
1587 		++nDownIndex;					// Startzelle ueberspringen
1588 
1589 	while ( nUpIndex || nDownIndex < nCount )
1590 	{
1591 		if ( nUpIndex )					// nach oben
1592 		{
1593 			ScBaseCell* pCell = pItems[nUpIndex-1].pCell;
1594 			CellType eType = pCell->GetCellType();
1595 			if (eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT)		// nur Strings interessieren
1596 			{
1597 				if (eType == CELLTYPE_STRING)
1598 					((ScStringCell*)pCell)->GetString(aString);
1599 				else
1600 					((ScEditCell*)pCell)->GetString(aString);
1601 
1602 				TypedStrData* pData = new TypedStrData(aString);
1603 				if ( !rStrings.Insert( pData ) )
1604 					delete pData;											// doppelt
1605 				else if ( bLimit && rStrings.GetCount() >= DATENT_MAX )
1606 					break;													// Maximum erreicht
1607 				bFound = sal_True;
1608 
1609 				if ( bLimit )
1610 					if (++nCells >= DATENT_SEARCH)
1611 						break;									// genug gesucht
1612 			}
1613 			--nUpIndex;
1614 		}
1615 
1616 		if ( nDownIndex < nCount )		// nach unten
1617 		{
1618 			ScBaseCell* pCell = pItems[nDownIndex].pCell;
1619 			CellType eType = pCell->GetCellType();
1620 			if (eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT)		// nur Strings interessieren
1621 			{
1622 				if (eType == CELLTYPE_STRING)
1623 					((ScStringCell*)pCell)->GetString(aString);
1624 				else
1625 					((ScEditCell*)pCell)->GetString(aString);
1626 
1627 				TypedStrData* pData = new TypedStrData(aString);
1628 				if ( !rStrings.Insert( pData ) )
1629 					delete pData;											// doppelt
1630 				else if ( bLimit && rStrings.GetCount() >= DATENT_MAX )
1631 					break;													// Maximum erreicht
1632 				bFound = sal_True;
1633 
1634 				if ( bLimit )
1635 					if (++nCells >= DATENT_SEARCH)
1636 						break;									// genug gesucht
1637 			}
1638 			++nDownIndex;
1639 		}
1640 	}
1641 
1642 	return bFound;
1643 }
1644 
1645 #undef DATENT_MAX
1646 #undef DATENT_SEARCH
1647 
1648 
RemoveProtected(SCROW nStartRow,SCROW nEndRow)1649 void ScColumn::RemoveProtected( SCROW nStartRow, SCROW nEndRow )
1650 {
1651 	ScAttrIterator aAttrIter( pAttrArray, nStartRow, nEndRow );
1652 	SCROW nTop = -1;
1653 	SCROW nBottom = -1;
1654 	SCSIZE nIndex;
1655 	const ScPatternAttr* pPattern = aAttrIter.Next( nTop, nBottom );
1656 	while (pPattern)
1657 	{
1658 		const ScProtectionAttr* pAttr = (const ScProtectionAttr*)&pPattern->GetItem(ATTR_PROTECTION);
1659 		if ( pAttr->GetHideCell() )
1660 			DeleteArea( nTop, nBottom, IDF_CONTENTS );
1661 		else if ( pAttr->GetHideFormula() )
1662 		{
1663 			Search( nTop, nIndex );
1664 			while ( nIndex<nCount && pItems[nIndex].nRow<=nBottom )
1665 			{
1666 				if ( pItems[nIndex].pCell->GetCellType() == CELLTYPE_FORMULA )
1667 				{
1668 					ScFormulaCell* pFormula = (ScFormulaCell*)pItems[nIndex].pCell;
1669 					if (pFormula->IsValue())
1670 					{
1671 						double nVal = pFormula->GetValue();
1672 						pItems[nIndex].pCell = new ScValueCell( nVal );
1673 					}
1674 					else
1675 					{
1676 						String aString;
1677 						pFormula->GetString(aString);
1678 						pItems[nIndex].pCell = new ScStringCell( aString );
1679 					}
1680 					delete pFormula;
1681 				}
1682 				++nIndex;
1683 			}
1684 		}
1685 
1686 		pPattern = aAttrIter.Next( nTop, nBottom );
1687 	}
1688 }
1689 
1690 
SetError(SCROW nRow,const sal_uInt16 nError)1691 void ScColumn::SetError( SCROW nRow, const sal_uInt16 nError)
1692 {
1693 	if (VALIDROW(nRow))
1694 	{
1695 		ScFormulaCell* pCell = new ScFormulaCell
1696 			( pDocument, ScAddress( nCol, nRow, nTab ) );
1697 		pCell->SetErrCode( nError );
1698 		Insert( nRow, pCell );
1699 	}
1700 }
1701 
1702 
SetValue(SCROW nRow,const double & rVal)1703 void ScColumn::SetValue( SCROW nRow, const double& rVal)
1704 {
1705 	if (VALIDROW(nRow))
1706 	{
1707 		ScBaseCell* pCell = new ScValueCell(rVal);
1708 		Insert( nRow, pCell );
1709 	}
1710 }
1711 
1712 
GetString(SCROW nRow,String & rString) const1713 void ScColumn::GetString( SCROW nRow, String& rString ) const
1714 {
1715 	SCSIZE	nIndex;
1716 	Color* pColor;
1717 	if (Search(nRow, nIndex))
1718 	{
1719 		ScBaseCell* pCell = pItems[nIndex].pCell;
1720 		if (pCell->GetCellType() != CELLTYPE_NOTE)
1721 		{
1722 			sal_uLong nFormat = GetNumberFormat( nRow );
1723 			ScCellFormat::GetString( pCell, nFormat, rString, &pColor, *(pDocument->GetFormatTable()) );
1724 		}
1725 		else
1726 			rString.Erase();
1727 	}
1728 	else
1729 		rString.Erase();
1730 }
1731 
1732 template<>
FillDPCacheT(long nDim,SCROW nStartRow,SCROW nEndRow,const boost::function<void (ScDPItemData *)> & rAddLabel,const boost::function<sal_Bool (long,ScDPItemData *,bool)> & rAddData)1733 void  ScColumn::FillDPCacheT( long nDim, SCROW nStartRow, SCROW nEndRow, const boost::function<void(ScDPItemData*)> & rAddLabel, const boost::function<sal_Bool(long,ScDPItemData*, bool)> & rAddData )
1734 {
1735     SCROW nPattenRowStart = -1, nPatternRowEnd = -1;
1736     SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
1737     sal_uLong nNumberFormat = 0;
1738     sal_uLong nNumberFormatType = NUMBERFORMAT_NUMBER;
1739     SCROW nCurRow = nStartRow;
1740     ScDPItemData * pDPItemData = NULL;
1741 
1742     if ( pItems )
1743     {
1744         SCSIZE nIndex;
1745 
1746         for ( Search( nStartRow, nIndex ) ? void( ) : void(nIndex = nCount); nIndex < nCount && pItems[nIndex].nRow <= nEndRow; ++nIndex, ++nCurRow )
1747         {
1748             for( ; nCurRow < pItems[nIndex].nRow; nCurRow++ )
1749                 if( nCurRow == nStartRow )
1750                     rAddLabel( new ScDPItemData() );
1751                 else
1752                     rAddData( nDim, new ScDPItemData(), false);
1753 
1754             if( nCurRow > nPatternRowEnd )
1755                 if( const ScPatternAttr* pPattern = pAttrArray ? pAttrArray->GetPatternRange( nPattenRowStart, nPatternRowEnd, nCurRow ) : NULL )
1756                     nNumberFormatType = pFormatter->GetType( nNumberFormat = pPattern->GetNumberFormat( pFormatter ) );
1757                 else
1758                     nNumberFormatType = NUMBERFORMAT_NUMBER, nNumberFormat = 0;
1759 
1760             if( ScBaseCell* pCell = pItems[nIndex].pCell )
1761                 if( pCell->GetCellType() == CELLTYPE_FORMULA && ((ScFormulaCell*)pCell)->GetErrCode() )
1762 		{
1763 		    String str( GetStringFromCell( pCell, nNumberFormat, pFormatter ) );
1764 		    sal_uInt8 bFlag = ScDPItemData::MK_ERR;
1765                     pDPItemData = new ScDPItemData( 0, str, 0.0, bFlag );
1766 		}
1767                 else if( pCell->HasValueData() )
1768                 {
1769                     double fVal = GetValueFromCell( pCell );
1770                     String str( GetStringFromCell( pCell, nNumberFormat, pFormatter ) );
1771                     sal_uInt8 bFlag = ScDPItemData::MK_VAL|ScDPItemData::MK_DATA|(ScDPItemData::MK_DATE * isDateFormat( nNumberFormatType ));
1772                     pDPItemData = new ScDPItemData( nNumberFormat, str, fVal, bFlag );
1773                 }
1774                 else if( !pCell->IsBlank() )
1775                     pDPItemData = new ScDPItemData( GetStringFromCell( pCell, nNumberFormat, pFormatter ) );
1776                 else
1777                     pDPItemData = new ScDPItemData();
1778             else
1779                 pDPItemData = new ScDPItemData();
1780 
1781             if( nCurRow == nStartRow )
1782                 rAddLabel( pDPItemData );
1783             else
1784                 rAddData( nDim, pDPItemData, false );
1785         }
1786     }
1787 
1788     for( ; nCurRow <= nEndRow; nCurRow++ )
1789         if( nCurRow == nStartRow )
1790             rAddLabel( new ScDPItemData() );
1791         else
1792             rAddData( nDim, new ScDPItemData(), false );
1793 }
FillDPCache(ScDPTableDataCache * pCache,long nDim,SCROW nStartRow,SCROW nEndRow)1794 void  ScColumn::FillDPCache( ScDPTableDataCache * pCache, long nDim, SCROW nStartRow, SCROW nEndRow )
1795 {
1796     FillDPCacheT<boost::function<void(ScDPItemData*)>, boost::function<sal_Bool(long,ScDPItemData*, bool)> >( nDim, nStartRow, nEndRow, boost::bind( &ScDPTableDataCache::AddLabel, pCache, _1 ), boost::bind( &ScDPTableDataCache::AddData, pCache, _1, _2, _3 ) );
1797 }
1798 
GetInputString(SCROW nRow,String & rString) const1799 void ScColumn::GetInputString( SCROW nRow, String& rString ) const
1800 {
1801 	SCSIZE	nIndex;
1802 	if (Search(nRow, nIndex))
1803 	{
1804 		ScBaseCell* pCell = pItems[nIndex].pCell;
1805 		if (pCell->GetCellType() != CELLTYPE_NOTE)
1806 		{
1807 			sal_uLong nFormat = GetNumberFormat( nRow );
1808 			ScCellFormat::GetInputString( pCell, nFormat, rString, *(pDocument->GetFormatTable()) );
1809 		}
1810 		else
1811 			rString.Erase();
1812 	}
1813 	else
1814 		rString.Erase();
1815 }
1816 
1817 
GetValue(SCROW nRow) const1818 double ScColumn::GetValue( SCROW nRow ) const
1819 {
1820 	SCSIZE	nIndex;
1821 	if (Search(nRow, nIndex))
1822 	{
1823 		ScBaseCell* pCell = pItems[nIndex].pCell;
1824 		switch (pCell->GetCellType())
1825 		{
1826 			case CELLTYPE_VALUE:
1827 				return ((ScValueCell*)pCell)->GetValue();
1828 //                break;
1829 			case CELLTYPE_FORMULA:
1830 				{
1831 					if (((ScFormulaCell*)pCell)->IsValue())
1832 						return ((ScFormulaCell*)pCell)->GetValue();
1833 					else
1834 						return 0.0;
1835 				}
1836 //                break;
1837 			default:
1838 				return 0.0;
1839 //                break;
1840 		}
1841 	}
1842 	return 0.0;
1843 }
1844 
1845 
GetFormula(SCROW nRow,String & rFormula,sal_Bool) const1846 void ScColumn::GetFormula( SCROW nRow, String& rFormula, sal_Bool ) const
1847 {
1848 	SCSIZE	nIndex;
1849 	if (Search(nRow, nIndex))
1850 	{
1851 		ScBaseCell* pCell = pItems[nIndex].pCell;
1852 		if (pCell->GetCellType() == CELLTYPE_FORMULA)
1853 			((ScFormulaCell*)pCell)->GetFormula( rFormula );
1854 		else
1855 			rFormula.Erase();
1856 	}
1857 	else
1858 		rFormula.Erase();
1859 }
1860 
1861 
GetCellType(SCROW nRow) const1862 CellType ScColumn::GetCellType( SCROW nRow ) const
1863 {
1864 	SCSIZE	nIndex;
1865 	if (Search(nRow, nIndex))
1866 		return pItems[nIndex].pCell->GetCellType();
1867 	return CELLTYPE_NONE;
1868 }
1869 
1870 
GetErrCode(SCROW nRow) const1871 sal_uInt16 ScColumn::GetErrCode( SCROW nRow ) const
1872 {
1873 	SCSIZE	nIndex;
1874 	if (Search(nRow, nIndex))
1875 	{
1876 		ScBaseCell* pCell = pItems[nIndex].pCell;
1877 		if (pCell->GetCellType() == CELLTYPE_FORMULA)
1878 			return ((ScFormulaCell*)pCell)->GetErrCode();
1879 	}
1880 	return 0;
1881 }
1882 
1883 
HasStringData(SCROW nRow) const1884 sal_Bool ScColumn::HasStringData( SCROW nRow ) const
1885 {
1886 	SCSIZE	nIndex;
1887 	if (Search(nRow, nIndex))
1888 		return (pItems[nIndex].pCell)->HasStringData();
1889 	return sal_False;
1890 }
1891 
1892 
HasValueData(SCROW nRow) const1893 sal_Bool ScColumn::HasValueData( SCROW nRow ) const
1894 {
1895 	SCSIZE	nIndex;
1896 	if (Search(nRow, nIndex))
1897 		return (pItems[nIndex].pCell)->HasValueData();
1898 	return sal_False;
1899 }
1900 
HasStringCells(SCROW nStartRow,SCROW nEndRow) const1901 sal_Bool ScColumn::HasStringCells( SCROW nStartRow, SCROW nEndRow ) const
1902 {
1903 	//	sal_True, wenn String- oder Editzellen im Bereich
1904 
1905 	if ( pItems )
1906 	{
1907 		SCSIZE nIndex;
1908 		Search( nStartRow, nIndex );
1909 		while ( nIndex < nCount && pItems[nIndex].nRow <= nEndRow )
1910 		{
1911 			CellType eType = pItems[nIndex].pCell->GetCellType();
1912 			if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT )
1913 				return sal_True;
1914 			++nIndex;
1915 		}
1916 	}
1917 	return sal_False;
1918 }
1919 
1920 
GetNote(SCROW nRow)1921 ScPostIt* ScColumn::GetNote( SCROW nRow )
1922 {
1923 	SCSIZE nIndex;
1924 	return Search( nRow, nIndex ) ? pItems[ nIndex ].pCell->GetNote() : 0;
1925 }
1926 
1927 
TakeNote(SCROW nRow,ScPostIt * pNote)1928 void ScColumn::TakeNote( SCROW nRow, ScPostIt* pNote )
1929 {
1930 	SCSIZE nIndex;
1931 	if( Search( nRow, nIndex ) )
1932 		pItems[ nIndex ].pCell->TakeNote( pNote );
1933     else
1934         Insert( nRow, new ScNoteCell( pNote ) );
1935 }
1936 
1937 
ReleaseNote(SCROW nRow)1938 ScPostIt* ScColumn::ReleaseNote( SCROW nRow )
1939 {
1940     ScPostIt* pNote = 0;
1941 	SCSIZE nIndex;
1942 	if( Search( nRow, nIndex ) )
1943 	{
1944 		ScBaseCell* pCell = pItems[ nIndex ].pCell;
1945         pNote = pCell->ReleaseNote();
1946 		if( (pCell->GetCellType() == CELLTYPE_NOTE) && !pCell->GetBroadcaster() )
1947 			DeleteAtIndex( nIndex );
1948 	}
1949     return pNote;
1950 }
1951 
1952 
DeleteNote(SCROW nRow)1953 void ScColumn::DeleteNote( SCROW nRow )
1954 {
1955     delete ReleaseNote( nRow );
1956 }
1957 
1958 
GetMaxStringLen(SCROW nRowStart,SCROW nRowEnd,CharSet eCharSet) const1959 sal_Int32 ScColumn::GetMaxStringLen( SCROW nRowStart, SCROW nRowEnd, CharSet eCharSet ) const
1960 {
1961 	sal_Int32 nStringLen = 0;
1962 	if ( pItems )
1963 	{
1964 		String aString;
1965         rtl::OString aOString;
1966         bool bIsOctetTextEncoding = rtl_isOctetTextEncoding( eCharSet);
1967 		SvNumberFormatter* pNumFmt = pDocument->GetFormatTable();
1968         SCSIZE nIndex;
1969         SCROW nRow;
1970 		Search( nRowStart, nIndex );
1971 		while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRowEnd )
1972 		{
1973 			ScBaseCell* pCell = pItems[nIndex].pCell;
1974 			if ( pCell->GetCellType() != CELLTYPE_NOTE )
1975 			{
1976 				Color* pColor;
1977 				sal_uLong nFormat = (sal_uLong) ((SfxUInt32Item*) GetAttr(
1978 					nRow, ATTR_VALUE_FORMAT ))->GetValue();
1979 				ScCellFormat::GetString( pCell, nFormat, aString, &pColor,
1980 					*pNumFmt );
1981                 sal_Int32 nLen;
1982                 if (bIsOctetTextEncoding)
1983                 {
1984                     rtl::OUString aOUString( aString);
1985                     if (!aOUString.convertToString( &aOString, eCharSet,
1986                                 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR |
1987                                 RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR))
1988                     {
1989                         // TODO: anything? this is used by the dBase export filter
1990                         // that throws an error anyway, but in case of another
1991                         // context we might want to indicate a conversion error
1992                         // early.
1993                     }
1994                     nLen = aOString.getLength();
1995                 }
1996                 else
1997                     nLen = aString.Len() * sizeof(sal_Unicode);
1998 				if ( nStringLen < nLen)
1999 					nStringLen = nLen;
2000 			}
2001 			nIndex++;
2002 		}
2003 	}
2004 	return nStringLen;
2005 }
2006 
2007 
GetMaxNumberStringLen(sal_uInt16 & nPrecision,SCROW nRowStart,SCROW nRowEnd) const2008 xub_StrLen ScColumn::GetMaxNumberStringLen(
2009     sal_uInt16& nPrecision, SCROW nRowStart, SCROW nRowEnd ) const
2010 {
2011     xub_StrLen nStringLen = 0;
2012     nPrecision = pDocument->GetDocOptions().GetStdPrecision();
2013     if ( nPrecision == SvNumberFormatter::UNLIMITED_PRECISION )
2014         // In case of unlimited precision, use 2 instead.
2015         nPrecision = 2;
2016 
2017     if ( pItems )
2018     {
2019         String aString;
2020         SvNumberFormatter* pNumFmt = pDocument->GetFormatTable();
2021         SCSIZE nIndex;
2022         SCROW nRow;
2023         Search( nRowStart, nIndex );
2024         while ( nIndex < nCount && (nRow = pItems[nIndex].nRow) <= nRowEnd )
2025         {
2026             ScBaseCell* pCell = pItems[nIndex].pCell;
2027             CellType eType = pCell->GetCellType();
2028             if ( eType == CELLTYPE_VALUE || (eType == CELLTYPE_FORMULA
2029                     && ((ScFormulaCell*)pCell)->IsValue()) )
2030             {
2031                 sal_uLong nFormat = (sal_uLong) ((SfxUInt32Item*) GetAttr(
2032                     nRow, ATTR_VALUE_FORMAT ))->GetValue();
2033                 ScCellFormat::GetInputString( pCell, nFormat, aString, *pNumFmt );
2034                 xub_StrLen nLen = aString.Len();
2035                 if ( nLen )
2036                 {
2037                     if ( nFormat )
2038                     {   // more decimals than standard?
2039                         sal_uInt16 nPrec = pNumFmt->GetFormatPrecision( nFormat );
2040                         if ( nPrec != SvNumberFormatter::UNLIMITED_PRECISION && nPrec > nPrecision )
2041                             nPrecision = nPrec;
2042                     }
2043                     if ( nPrecision )
2044                     {   // less than nPrecision in string => widen it
2045                         // more => shorten it
2046                         String aSep = pNumFmt->GetFormatDecimalSep( nFormat );
2047                         xub_StrLen nTmp = aString.Search( aSep );
2048                         if ( nTmp == STRING_NOTFOUND )
2049                             nLen += nPrecision + aSep.Len();
2050                         else
2051                         {
2052                             nTmp = aString.Len() - (nTmp + aSep.Len());
2053                             if ( nTmp != nPrecision )
2054                                 nLen += nPrecision - nTmp;
2055                                 // nPrecision > nTmp : nLen + Diff
2056                                 // nPrecision < nTmp : nLen - Diff
2057                         }
2058                     }
2059                     if ( nStringLen < nLen )
2060                         nStringLen = nLen;
2061                 }
2062             }
2063             nIndex++;
2064         }
2065     }
2066     return nStringLen;
2067 }
2068 
2069