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