?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
re-enabled user-defined numeric fields for dBase export
[LibreOffice.git] / sc / source / core / data / document.cxx
blob6369388f159be448a77fb00acb1d44c8669e9ee7
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include "scitems.hxx"
21 #include <editeng/eeitem.hxx>
22
23 #include <editeng/boxitem.hxx>
24 #include <editeng/frmdiritem.hxx>
25 #include "editeng/editobj.hxx"
26 #include <svx/pageitem.hxx>
27 #include <editeng/editeng.hxx>
28 #include <svx/svditer.hxx>
29 #include <svx/svdpage.hxx>
30 #include <svx/svdocapt.hxx>
31 #include <sfx2/app.hxx>
32 #include <sfx2/objsh.hxx>
33 #include <sfx2/docfile.hxx>
34 #include <svl/poolcach.hxx>
35 #include <unotools/saveopt.hxx>
36 #include <svl/zforlist.hxx>
37 #include <unotools/charclass.hxx>
38 #include <unotools/transliterationwrapper.hxx>
39 #include <tools/tenccvt.hxx>
40 #include <tools/urlobj.hxx>
41
42 #include <com/sun/star/text/WritingMode2.hpp>
43 #include <com/sun/star/script/vba/XVBACompatibility.hpp>
44 #include <com/sun/star/sheet/TablePageBreakData.hpp>
45 #include <com/sun/star/lang/NotInitializedException.hpp>
46
47 #include "document.hxx"
48 #include "table.hxx"
49 #include "attrib.hxx"
50 #include "attarray.hxx"
51 #include "markarr.hxx"
52 #include "patattr.hxx"
53 #include "rangenam.hxx"
54 #include "poolhelp.hxx"
55 #include "docpool.hxx"
56 #include "stlpool.hxx"
57 #include "stlsheet.hxx"
58 #include "globstr.hrc"
59 #include "rechead.hxx"
60 #include "dbdata.hxx"
61 #include "pivot.hxx"
62 #include "chartlis.hxx"
63 #include "rangelst.hxx"
64 #include "markdata.hxx"
65 #include "drwlayer.hxx"
66 #include "conditio.hxx"
67 #include "colorscale.hxx"
68 #include "validat.hxx"
69 #include "prnsave.hxx"
70 #include "chgtrack.hxx"
71 #include "sc.hrc"
72 #include "scresid.hxx"
73 #include "hints.hxx"
74 #include "detdata.hxx"
75 #include "cell.hxx"
76 #include "dpobject.hxx"
77 #include "detfunc.hxx" // for UpdateAllComments
78 #include "scmod.hxx"
79 #include "dociter.hxx"
80 #include "progress.hxx"
81 #include "autonamecache.hxx"
82 #include "bcaslot.hxx"
83 #include "postit.hxx"
84 #include "externalrefmgr.hxx"
85 #include "tabprotection.hxx"
86 #include "clipparam.hxx"
87 #include "stlalgorithm.hxx"
88 #include "defaultsoptions.hxx"
89 #include "editutil.hxx"
90 #include "stringutil.hxx"
91 #include "formulaiter.hxx"
92 #include "formulacell.hxx"
93 #include "clipcontext.hxx"
94 #include "listenercontext.hxx"
95
96 #include <map>
97 #include <limits>
98 #include <boost/scoped_ptr.hpp>
99
100 using ::editeng::SvxBorderLine;
101 using namespace ::com::sun::star;
102
103 namespace WritingMode2 = ::com::sun::star::text::WritingMode2;
104 using ::com::sun::star::uno::Sequence;
105 using ::com::sun::star::sheet::TablePageBreakData;
106 using ::std::set;
107
108 namespace {
109
110 std::pair<SCTAB,SCTAB> getMarkedTableRange(const std::vector<ScTable*>& rTables, const ScMarkData& rMark)
111 {
112 SCTAB nTabStart = MAXTAB;
113 SCTAB nTabEnd = 0;
114 SCTAB nMax = static_cast<SCTAB>(rTables.size());
115 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
116 for (; itr != itrEnd && *itr < nMax; ++itr)
117 {
118 if (!rTables[*itr])
119 continue;
120
121 if (*itr < nTabStart)
122 nTabStart = *itr;
123 nTabEnd = *itr;
124 }
125
126 return std::pair<SCTAB,SCTAB>(nTabStart,nTabEnd);
127 }
128
129 }
130
131 struct ScDefaultAttr
132 {
133 const ScPatternAttr* pAttr;
134 SCROW nFirst;
135 SCSIZE nCount;
136 ScDefaultAttr(const ScPatternAttr* pPatAttr) : pAttr(pPatAttr), nFirst(0), nCount(0) {}
137 };
138
139 struct ScLessDefaultAttr
140 {
141 bool operator() (const ScDefaultAttr& rValue1, const ScDefaultAttr& rValue2) const
142 {
143 return rValue1.pAttr < rValue2.pAttr;
144 }
145 };
146
147 typedef std::set<ScDefaultAttr, ScLessDefaultAttr> ScDefaultAttrSet;
148
149 void ScDocument::MakeTable( SCTAB nTab,bool _bNeedsNameCheck )
150 {
151 if ( ValidTab(nTab) && ( nTab >= static_cast<SCTAB>(maTabs.size()) ||!maTabs[nTab]) )
152 {
153 // Get Custom prefix
154 const ScDefaultsOptions& rOpt = SC_MOD()->GetDefaultsOptions();
155 OUString aString = rOpt.GetInitTabPrefix();
156
157 aString += OUString::valueOf(static_cast<sal_Int32>(nTab+1));
158 if ( _bNeedsNameCheck )
159 CreateValidTabName( aString ); // no doubles
160 if (nTab < static_cast<SCTAB>(maTabs.size()))
161 {
162 maTabs[nTab] = new ScTable(this, nTab, aString);
163 }
164 else
165 {
166 while(nTab > static_cast<SCTAB>(maTabs.size()))
167 maTabs.push_back(NULL);
168 maTabs.push_back( new ScTable(this, nTab, aString) );
169 }
170 maTabs[nTab]->SetLoadingMedium(bLoadingMedium);
171 }
172 }
173
174
175 bool ScDocument::HasTable( SCTAB nTab ) const
176 {
177 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
178 if (maTabs[nTab])
179 return true;
180
181 return false;
182 }
183
184 bool ScDocument::GetName( SCTAB nTab, OUString& rName ) const
185 {
186 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
187 if (maTabs[nTab])
188 {
189 maTabs[nTab]->GetName( rName );
190 return true;
191 }
192 rName = OUString();
193 return false;
194 }
195
196 OUString ScDocument::GetCopyTabName( SCTAB nTab ) const
197 {
198 if (nTab < static_cast<SCTAB>(maTabNames.size()))
199 return maTabNames[nTab];
200 else
201 return OUString();
202 }
203
204 bool ScDocument::SetCodeName( SCTAB nTab, const OUString& rName )
205 {
206 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
207 {
208 if (maTabs[nTab])
209 {
210 maTabs[nTab]->SetCodeName( rName );
211 return true;
212 }
213 }
214 OSL_TRACE( "**** can't set code name %s", OUStringToOString( rName, RTL_TEXTENCODING_UTF8 ).getStr() );
215 return false;
216 }
217
218 bool ScDocument::GetCodeName( SCTAB nTab, OUString& rName ) const
219 {
220 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
221 if (maTabs[nTab])
222 {
223 maTabs[nTab]->GetCodeName( rName );
224 return true;
225 }
226 rName = OUString();
227 return false;
228 }
229
230 bool ScDocument::GetTable( const OUString& rName, SCTAB& rTab ) const
231 {
232 OUString aUpperName = ScGlobal::pCharClass->uppercase(rName);
233
234 for (SCTAB i=0; i< static_cast<SCTAB>(maTabs.size()); i++)
235 if (maTabs[i])
236 {
237 if (aUpperName.equals(maTabs[i]->GetUpperName()))
238 {
239 rTab = i;
240 return true;
241 }
242 }
243 rTab = 0;
244 return false;
245 }
246
247 ScDBData* ScDocument::GetAnonymousDBData(SCTAB nTab)
248 {
249 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
250 return maTabs[nTab]->GetAnonymousDBData();
251 return NULL;
252 }
253
254 void ScDocument::SetAnonymousDBData(SCTAB nTab, ScDBData* pDBData)
255 {
256 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
257 maTabs[nTab]->SetAnonymousDBData(pDBData);
258 }
259
260
261 bool ScDocument::ValidTabName( const OUString& rName )
262 {
263 if (rName.isEmpty())
264 return false;
265 sal_Int32 nLen = rName.getLength();
266
267 #if 1
268 // Restrict sheet names to what Excel accepts.
269 /* TODO: We may want to remove this restriction for full ODFF compliance.
270 * Merely loading and calculating ODF documents using these characters in
271 * sheet names is not affected by this, but all sheet name editing and
272 * copying functionality is, maybe falling back to "Sheet4" or similar. */
273 for (sal_Int32 i = 0; i < nLen; ++i)
274 {
275 const sal_Unicode c = rName[i];
276 switch (c)
277 {
278 case ':':
279 case '\\':
280 case '/':
281 case '?':
282 case '*':
283 case '[':
284 case ']':
285 // these characters are not allowed to match XL's convention.
286 return false;
287 case '\'':
288 if (i == 0 || i == nLen - 1)
289 // single quote is not allowed at the first or last
290 // character position.
291 return false;
292 break;
293 }
294 }
295 #endif
296
297 return true;
298 }
299
300
301 bool ScDocument::ValidNewTabName( const OUString& rName ) const
302 {
303 bool bValid = ValidTabName(rName);
304 TableContainer::const_iterator it = maTabs.begin();
305 for (; it != maTabs.end() && bValid; ++it)
306 if ( *it )
307 {
308 OUString aOldName;
309 (*it)->GetName(aOldName);
310 bValid = !ScGlobal::GetpTransliteration()->isEqual( rName, aOldName );
311 }
312 return bValid;
313 }
314
315
316 void ScDocument::CreateValidTabName(OUString& rName) const
317 {
318 if ( !ValidTabName(rName) )
319 {
320 // Find new one
321
322 // Get Custom prefix
323 const ScDefaultsOptions& rOpt = SC_MOD()->GetDefaultsOptions();
324 OUString aStrTable = rOpt.GetInitTabPrefix();
325
326 bool bOk = false;
327
328 // First test if the prefix is valid, if so only avoid doubles
329 bool bPrefix = ValidTabName( aStrTable );
330 OSL_ENSURE(bPrefix, "Invalid Table Name");
331 SCTAB nDummy;
332
333 for ( SCTAB i = static_cast<SCTAB>(maTabs.size())+1; !bOk ; i++ )
334 {
335 OUStringBuffer aBuf;
336 aBuf.append(aStrTable);
337 aBuf.append(static_cast<sal_Int32>(i));
338 rName = aBuf.makeStringAndClear();
339 if (bPrefix)
340 bOk = ValidNewTabName( rName );
341 else
342 bOk = !GetTable( rName, nDummy );
343 }
344 }
345 else
346 {
347 // testing the supplied Name
348
349 if ( !ValidNewTabName(rName) )
350 {
351 SCTAB i = 1;
352 OUStringBuffer aName;
353 do
354 {
355 i++;
356 aName = rName;
357 aName.append('_');
358 aName.append(static_cast<sal_Int32>(i));
359 }
360 while (!ValidNewTabName(aName.toString()) && (i < MAXTAB+1));
361 rName = aName.makeStringAndClear();
362 }
363 }
364 }
365
366 void ScDocument::CreateValidTabNames(std::vector<OUString>& aNames, SCTAB nCount) const
367 {
368 aNames.clear();//ensure that the vector is empty
369
370 // Get Custom prefix
371 const ScDefaultsOptions& rOpt = SC_MOD()->GetDefaultsOptions();
372 OUString aStrTable = rOpt.GetInitTabPrefix();
373
374 OUStringBuffer rName;
375 bool bOk = false;
376
377 // First test if the prefix is valid, if so only avoid doubles
378 bool bPrefix = ValidTabName( aStrTable );
379 OSL_ENSURE(bPrefix, "Invalid Table Name");
380 SCTAB nDummy;
381 SCTAB i = static_cast<SCTAB>(maTabs.size())+1;
382
383 for (SCTAB j = 0; j < nCount; ++j)
384 {
385 bOk = false;
386 while(!bOk)
387 {
388 rName = aStrTable;
389 rName.append(static_cast<sal_Int32>(i));
390 if (bPrefix)
391 bOk = ValidNewTabName( rName.toString() );
392 else
393 bOk = !GetTable( rName.toString(), nDummy );
394 i++;
395 }
396 aNames.push_back(rName.makeStringAndClear());
397 }
398 }
399
400 void ScDocument::AppendTabOnLoad(const OUString& rName)
401 {
402 SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
403 if (!ValidTab(nTabCount))
404 // max table count reached. No more tables.
405 return;
406
407 OUString aName = rName;
408 CreateValidTabName(aName);
409 maTabs.push_back( new ScTable(this, nTabCount, aName) );
410 }
411
412 void ScDocument::SetTabNameOnLoad(SCTAB nTab, const OUString& rName)
413 {
414 if (!ValidTab(nTab) || static_cast<SCTAB>(maTabs.size()) <= nTab)
415 return;
416
417 if (!ValidTabName(rName))
418 return;
419
420 maTabs[nTab]->SetName(rName);
421 }
422
423 void ScDocument::InvalidateStreamOnSave()
424 {
425 TableContainer::iterator it = maTabs.begin(), itEnd = maTabs.end();
426 for (; it != itEnd; ++it)
427 {
428 ScTable* pTab = *it;
429 if (pTab)
430 pTab->SetStreamValid(false);
431 }
432 }
433
434 bool ScDocument::InsertTab( SCTAB nPos, const OUString& rName,
435 bool bExternalDocument )
436 {
437 SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
438 bool bValid = ValidTab(nTabCount);
439 if ( !bExternalDocument ) // else test rName == "'Doc'!Tab" first
440 bValid = (bValid && ValidNewTabName(rName));
441 if (bValid)
442 {
443 if (nPos == SC_TAB_APPEND || nPos >= nTabCount)
444 {
445 maTabs.push_back( new ScTable(this, nTabCount, rName) );
446 if ( bExternalDocument )
447 maTabs[nTabCount]->SetVisible( false );
448 }
449 else
450 {
451 if (ValidTab(nPos) && (nPos < nTabCount))
452 {
453 ScRange aRange( 0,0,nPos, MAXCOL,MAXROW,MAXTAB );
454 xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
455 xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
456 if (pRangeName)
457 pRangeName->UpdateTabRef( nPos, 1 );
458 pDBCollection->UpdateReference(
459 URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
460 if (pDPCollection)
461 pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
462 if (pDetOpList)
463 pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,1 );
464 UpdateChartRef( URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
465 UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,1 );
466 if ( pUnoBroadcaster )
467 pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,1 ) );
468
469 SCTAB i;
470 TableContainer::iterator it = maTabs.begin();
471 for (; it != maTabs.end(); ++it)
472 if ( *it )
473 (*it)->UpdateInsertTab(nPos);
474 maTabs.push_back(NULL);
475 for (i = nTabCount; i > nPos; i--)
476 {
477 maTabs[i] = maTabs[i - 1];
478 }
479
480 maTabs[nPos] = new ScTable(this, nPos, rName);
481
482 // UpdateBroadcastAreas must be called between UpdateInsertTab,
483 // which ends listening, and StartAllListeners, to not modify
484 // areas that are to be inserted by starting listeners.
485 UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,1);
486 it = maTabs.begin();
487 for (; it != maTabs.end(); ++it)
488 if ( *it )
489 (*it)->UpdateCompile();
490 it = maTabs.begin();
491 for (; it != maTabs.end(); ++it)
492 if ( *it )
493 (*it)->StartAllListeners();
494
495 if ( pValidationList )
496 pValidationList->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
497 // sheet names of references are not valid until sheet is inserted
498 if ( pChartListenerCollection )
499 pChartListenerCollection->UpdateScheduledSeriesRanges();
500
501 bValid = true;
502 }
503 else
504 bValid = false;
505 }
506 }
507
508 if (bValid)
509 SetDirty();
510
511 return bValid;
512 }
513
514
515 bool ScDocument::InsertTabs( SCTAB nPos, const std::vector<OUString>& rNames,
516 bool bExternalDocument, bool bNamesValid )
517 {
518 SCTAB nNewSheets = static_cast<SCTAB>(rNames.size());
519 SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
520 bool bValid = bNamesValid || ValidTab(nTabCount+nNewSheets);
521 // if ( !bExternalDocument ) // else test rName == "'Doc'!Tab" first
522 // bValid = (bValid && ValidNewTabName(rNames));
523 if (bValid)
524 {
525 if (nPos == SC_TAB_APPEND || nPos >= nTabCount)
526 {
527 for ( SCTAB i = 0; i < nNewSheets; ++i )
528 {
529 maTabs.push_back( new ScTable(this, nTabCount + i, rNames.at(i)) );
530 if ( bExternalDocument )
531 maTabs[nTabCount+i]->SetVisible( false );
532 }
533 }
534 else
535 {
536 if (ValidTab(nPos) && (nPos < nTabCount))
537 {
538 ScRange aRange( 0,0,nPos, MAXCOL,MAXROW,MAXTAB );
539 xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,nNewSheets );
540 xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,nNewSheets );
541 if (pRangeName)
542 pRangeName->UpdateTabRef( nPos, 1, 0, nNewSheets);
543 pDBCollection->UpdateReference(
544 URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,nNewSheets );
545 if (pDPCollection)
546 pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,nNewSheets );
547 if (pDetOpList)
548 pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,nNewSheets );
549 UpdateChartRef( URM_INSDEL, 0,0,nPos, MAXCOL,MAXROW,MAXTAB, 0,0,nNewSheets );
550 UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0, nNewSheets );
551 if ( pUnoBroadcaster )
552 pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,nNewSheets ) );
553
554 TableContainer::iterator it = maTabs.begin();
555 for (; it != maTabs.end(); ++it)
556 if ( *it )
557 (*it)->UpdateInsertTab(nPos, nNewSheets);
558 it = maTabs.begin();
559 maTabs.insert(it+nPos,nNewSheets, NULL);
560 for (SCTAB i = 0; i < nNewSheets; ++i)
561 {
562 maTabs[nPos + i] = new ScTable(this, nPos + i, rNames.at(i));
563 }
564
565 // UpdateBroadcastAreas must be called between UpdateInsertTab,
566 // which ends listening, and StartAllListeners, to not modify
567 // areas that are to be inserted by starting listeners.
568 UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,nNewSheets);
569 it = maTabs.begin();
570 for (; it != maTabs.end(); ++it)
571 {
572 if ( *it )
573 (*it)->UpdateCompile();
574 }
575 it = maTabs.begin();
576 for (; it != maTabs.end(); ++it)
577 if ( *it )
578 (*it)->StartAllListeners();
579
580 if ( pValidationList )
581 pValidationList->UpdateReference( URM_INSDEL, aRange, 0,0,nNewSheets );
582 // sheet names of references are not valid until sheet is inserted
583 if ( pChartListenerCollection )
584 pChartListenerCollection->UpdateScheduledSeriesRanges();
585
586 bValid = true;
587 }
588 else
589 bValid = false;
590 }
591 }
592
593 if (bValid)
594 SetDirty();
595
596 return bValid;
597 }
598
599
600 bool ScDocument::DeleteTab( SCTAB nTab, ScDocument* pRefUndoDoc )
601 {
602 bool bValid = false;
603 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
604 {
605 if (maTabs[nTab])
606 {
607 SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
608 if (nTabCount > 1)
609 {
610 bool bOldAutoCalc = GetAutoCalc();
611 SetAutoCalc( false ); // avoid multiple calculations
612 ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab );
613 DelBroadcastAreasInRange( aRange );
614
615 // #i8180# remove database ranges etc. that are on the deleted tab
616 // (restored in undo with ScRefUndoData)
617
618 xColNameRanges->DeleteOnTab( nTab );
619 xRowNameRanges->DeleteOnTab( nTab );
620 pDBCollection->DeleteOnTab( nTab );
621 if (pDPCollection)
622 pDPCollection->DeleteOnTab( nTab );
623 if (pDetOpList)
624 pDetOpList->DeleteOnTab( nTab );
625 DeleteAreaLinksOnTab( nTab );
626
627 // normal reference update
628
629 aRange.aEnd.SetTab( static_cast<SCTAB>(maTabs.size())-1 );
630 xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1 );
631 xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1 );
632 if (pRangeName)
633 pRangeName->UpdateTabRef( nTab, 2 );
634 pDBCollection->UpdateReference(
635 URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1 );
636 if (pDPCollection)
637 pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,-1 );
638 if (pDetOpList)
639 pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,-1 );
640 UpdateChartRef( URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1 );
641 UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1 );
642 if ( pValidationList )
643 pValidationList->UpdateReference( URM_INSDEL, aRange, 0,0,-1 );
644 if ( pUnoBroadcaster )
645 pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,-1 ) );
646
647 for (SCTAB i = 0, n = static_cast<SCTAB>(maTabs.size()); i < n; ++i)
648 if (maTabs[i])
649 maTabs[i]->UpdateDeleteTab(
650 nTab, false, pRefUndoDoc ? pRefUndoDoc->maTabs[i] : 0);
651
652 TableContainer::iterator it = maTabs.begin() + nTab;
653 delete *it;
654 maTabs.erase(it);
655 // UpdateBroadcastAreas must be called between UpdateDeleteTab,
656 // which ends listening, and StartAllListeners, to not modify
657 // areas that are to be inserted by starting listeners.
658 UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,-1);
659 it = maTabs.begin();
660 for (; it != maTabs.end(); ++it)
661 if ( *it )
662 (*it)->UpdateCompile();
663 // Excel-Filter deletes some Tables while loading, Listeners will
664 // only be triggered after the loading is done.
665 if ( !bInsertingFromOtherDoc )
666 {
667 it = maTabs.begin();
668 for (; it != maTabs.end(); ++it)
669 if ( *it )
670 (*it)->StartAllListeners();
671 SetDirty();
672 }
673 // sheet names of references are not valid until sheet is deleted
674 pChartListenerCollection->UpdateScheduledSeriesRanges();
675
676 SetAutoCalc( bOldAutoCalc );
677 bValid = true;
678 }
679 }
680 }
681 return bValid;
682 }
683
684
685 bool ScDocument::DeleteTabs( SCTAB nTab, SCTAB nSheets, ScDocument* pRefUndoDoc )
686 {
687 bool bValid = false;
688 if (ValidTab(nTab) && (nTab + nSheets) < static_cast<SCTAB>(maTabs.size()))
689 {
690 if (maTabs[nTab])
691 {
692 SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
693 if (nTabCount > nSheets)
694 {
695 bool bOldAutoCalc = GetAutoCalc();
696 SetAutoCalc( false ); // avoid multiple calculations
697 for (SCTAB aTab = 0; aTab < nSheets; ++aTab)
698 {
699 ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTab + aTab );
700 DelBroadcastAreasInRange( aRange );
701
702 // #i8180# remove database ranges etc. that are on the deleted tab
703 // (restored in undo with ScRefUndoData)
704
705 xColNameRanges->DeleteOnTab( nTab + aTab );
706 xRowNameRanges->DeleteOnTab( nTab + aTab );
707 pDBCollection->DeleteOnTab( nTab + aTab );
708 if (pDPCollection)
709 pDPCollection->DeleteOnTab( nTab + aTab );
710 if (pDetOpList)
711 pDetOpList->DeleteOnTab( nTab + aTab );
712 DeleteAreaLinksOnTab( nTab + aTab );
713 if (pRangeName)
714 pRangeName->UpdateTabRef( nTab + aTab, 2 );
715 }
716 // normal reference update
717
718 ScRange aRange( 0, 0, nTab, MAXCOL, MAXROW, nTabCount - 1 );
719 xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1*nSheets );
720 xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,-1*nSheets );
721 pDBCollection->UpdateReference(
722 URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1*nSheets );
723 if (pDPCollection)
724 pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,-1*nSheets );
725 if (pDetOpList)
726 pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,-1*nSheets );
727 UpdateChartRef( URM_INSDEL, 0,0,nTab, MAXCOL,MAXROW,MAXTAB, 0,0,-1*nSheets );
728 UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,-1*nSheets );
729 if ( pValidationList )
730 pValidationList->UpdateReference( URM_INSDEL, aRange, 0,0,-1*nSheets );
731 if ( pUnoBroadcaster )
732 pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,-1*nSheets ) );
733
734 for (SCTAB i = 0, n = static_cast<SCTAB>(maTabs.size()); i < n; ++i)
735 if (maTabs[i])
736 maTabs[i]->UpdateDeleteTab(
737 nTab, false, pRefUndoDoc ? pRefUndoDoc->maTabs[i] : 0,nSheets);
738
739 TableContainer::iterator it = maTabs.begin() + nTab;
740 TableContainer::iterator itEnd = it + nSheets;
741 std::for_each(it, itEnd, ScDeleteObjectByPtr<ScTable>());
742 maTabs.erase(it, itEnd);
743 // UpdateBroadcastAreas must be called between UpdateDeleteTab,
744 // which ends listening, and StartAllListeners, to not modify
745 // areas that are to be inserted by starting listeners.
746 UpdateBroadcastAreas( URM_INSDEL, aRange, 0,0,-1*nSheets);
747 it = maTabs.begin();
748 for (; it != maTabs.end(); ++it)
749 if ( *it )
750 (*it)->UpdateCompile();
751 // Excel-Filter deletes some Tables while loading, Listeners will
752 // only be triggered after the loading is done.
753 if ( !bInsertingFromOtherDoc )
754 {
755 it = maTabs.begin();
756 for (; it != maTabs.end(); ++it)
757 if ( *it )
758 (*it)->StartAllListeners();
759 SetDirty();
760 }
761 // sheet names of references are not valid until sheet is deleted
762 pChartListenerCollection->UpdateScheduledSeriesRanges();
763
764 SetAutoCalc( bOldAutoCalc );
765 bValid = true;
766 }
767 }
768 }
769 return bValid;
770 }
771
772
773 bool ScDocument::RenameTab( SCTAB nTab, const OUString& rName, bool /* bUpdateRef */,
774 bool bExternalDocument )
775 {
776 bool bValid = false;
777 SCTAB i;
778 if (ValidTab(nTab))
779 {
780 if (maTabs[nTab])
781 {
782 if ( bExternalDocument )
783 bValid = true; // composed name
784 else
785 bValid = ValidTabName(rName);
786 for (i=0; (i< static_cast<SCTAB>(maTabs.size())) && bValid; i++)
787 if (maTabs[i] && (i != nTab))
788 {
789 OUString aOldName;
790 maTabs[i]->GetName(aOldName);
791 bValid = !ScGlobal::GetpTransliteration()->isEqual( rName, aOldName );
792 }
793 if (bValid)
794 {
795 // #i75258# update charts before renaming, so they can get their live data objects.
796 // Once the charts are live, the sheet can be renamed without problems.
797 if ( pChartListenerCollection )
798 pChartListenerCollection->UpdateChartsContainingTab( nTab );
799 maTabs[nTab]->SetName(rName);
800
801 // If formulas refer to the renamed sheet, the TokenArray remains valid,
802 // but the XML stream must be re-generated.
803 TableContainer::iterator it = maTabs.begin();
804 for (; it != maTabs.end(); ++it)
805 if ( *it && (*it)->IsStreamValid())
806 (*it)->SetStreamValid( false );
807 }
808 }
809 }
810 return bValid;
811 }
812
813
814 void ScDocument::SetVisible( SCTAB nTab, bool bVisible )
815 {
816 if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
817 if (maTabs[nTab])
818 maTabs[nTab]->SetVisible(bVisible);
819 }
820
821
822 bool ScDocument::IsVisible( SCTAB nTab ) const
823 {
824 if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
825 if (maTabs[nTab])
826 return maTabs[nTab]->IsVisible();
827
828 return false;
829 }
830
831
832 bool ScDocument::IsStreamValid( SCTAB nTab ) const
833 {
834 if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab] )
835 return maTabs[nTab]->IsStreamValid();
836
837 return false;
838 }
839
840
841 void ScDocument::SetStreamValid( SCTAB nTab, bool bSet, bool bIgnoreLock )
842 {
843 if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab] )
844 maTabs[nTab]->SetStreamValid( bSet, bIgnoreLock );
845 }
846
847
848 void ScDocument::LockStreamValid( bool bLock )
849 {
850 mbStreamValidLocked = bLock;
851 }
852
853
854 bool ScDocument::IsPendingRowHeights( SCTAB nTab ) const
855 {
856 if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab] )
857 return maTabs[nTab]->IsPendingRowHeights();
858
859 return false;
860 }
861
862
863 void ScDocument::SetPendingRowHeights( SCTAB nTab, bool bSet )
864 {
865 if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab] )
866 maTabs[nTab]->SetPendingRowHeights( bSet );
867 }
868
869
870 void ScDocument::SetLayoutRTL( SCTAB nTab, bool bRTL )
871 {
872 if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab] )
873 {
874 if ( bImportingXML )
875 {
876 // #i57869# only set the LoadingRTL flag, the real setting (including mirroring)
877 // is applied in SetImportingXML(false). This is so the shapes can be loaded in
878 // normal LTR mode.
879
880 maTabs[nTab]->SetLoadingRTL( bRTL );
881 return;
882 }
883
884 maTabs[nTab]->SetLayoutRTL( bRTL ); // only sets the flag
885 maTabs[nTab]->SetDrawPageSize();
886
887 // mirror existing objects:
888
889 if (pDrawLayer)
890 {
891 SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
892 OSL_ENSURE(pPage,"Page ?");
893 if (pPage)
894 {
895 SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS );
896 SdrObject* pObject = aIter.Next();
897 while (pObject)
898 {
899 // objects with ScDrawObjData are re-positioned in SetPageSize,
900 // don't mirror again
901 ScDrawObjData* pData = ScDrawLayer::GetObjData( pObject );
902 if ( !pData )
903 pDrawLayer->MirrorRTL( pObject );
904
905 pObject->SetContextWritingMode( bRTL ? WritingMode2::RL_TB : WritingMode2::LR_TB );
906
907 pObject = aIter.Next();
908 }
909 }
910 }
911 }
912 }
913
914
915 bool ScDocument::IsLayoutRTL( SCTAB nTab ) const
916 {
917 if ( ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab] )
918 return maTabs[nTab]->IsLayoutRTL();
919
920 return false;
921 }
922
923
924 bool ScDocument::IsNegativePage( SCTAB nTab ) const
925 {
926 // Negative page area is always used for RTL layout.
927 // The separate method is used to find all RTL handling of drawing objects.
928 return IsLayoutRTL( nTab );
929 }
930
931
932 /* ----------------------------------------------------------------------------
933 used search area:
934
935 GetCellArea - Only Data
936 GetTableArea - Data / Attributes
937 GetPrintArea - intended for character objects,
938 sweeps attributes all the way to bottom / right
939 ---------------------------------------------------------------------------- */
940
941
942 bool ScDocument::GetCellArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const
943 {
944 if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
945 if (maTabs[nTab])
946 return maTabs[nTab]->GetCellArea( rEndCol, rEndRow );
947
948 rEndCol = 0;
949 rEndRow = 0;
950 return false;
951 }
952
953
954 bool ScDocument::GetTableArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow ) const
955 {
956 if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
957 if (maTabs[nTab])
958 return maTabs[nTab]->GetTableArea( rEndCol, rEndRow );
959
960 rEndCol = 0;
961 rEndRow = 0;
962 return false;
963 }
964
965 bool ScDocument::ShrinkToDataArea(SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow) const
966 {
967 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB> (maTabs.size()) || !maTabs[nTab])
968 return false;
969
970 SCCOL nCol1, nCol2;
971 SCROW nRow1, nRow2;
972 maTabs[nTab]->GetFirstDataPos(nCol1, nRow1);
973 maTabs[nTab]->GetLastDataPos(nCol2, nRow2);
974
975 if (nCol1 > nCol2 || nRow1 > nRow2)
976 // invalid range.
977 return false;
978
979 // Make sure the area only shrinks, and doesn't grow.
980 if (rStartCol < nCol1)
981 rStartCol = nCol1;
982 if (nCol2 < rEndCol)
983 rEndCol = nCol2;
984 if (rStartRow < nRow1)
985 rStartRow = nRow1;
986 if (nRow2 < rEndRow)
987 rEndRow = nRow2;
988
989 if (rStartCol > rEndCol || rStartRow > rEndRow)
990 // invalid range.
991 return false;
992
993 return true; // success!
994 }
995
996 bool ScDocument::ShrinkToUsedDataArea( bool& o_bShrunk, SCTAB nTab, SCCOL& rStartCol,
997 SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow, bool bColumnsOnly ) const
998 {
999 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB> (maTabs.size()) || !maTabs[nTab])
1000 {
1001 o_bShrunk = false;
1002 return false;
1003 }
1004 return maTabs[nTab]->ShrinkToUsedDataArea( o_bShrunk, rStartCol, rStartRow, rEndCol, rEndRow, bColumnsOnly);
1005 }
1006
1007 // connected area
1008
1009 void ScDocument::GetDataArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
1010 SCCOL& rEndCol, SCROW& rEndRow, bool bIncludeOld, bool bOnlyDown ) const
1011 {
1012 if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab])
1013 maTabs[nTab]->GetDataArea( rStartCol, rStartRow, rEndCol, rEndRow, bIncludeOld, bOnlyDown );
1014 }
1015
1016
1017 void ScDocument::LimitChartArea( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow,
1018 SCCOL& rEndCol, SCROW& rEndRow )
1019 {
1020 if (ValidTab(nTab) && nTab < static_cast<SCTAB> (maTabs.size()))
1021 if (maTabs[nTab])
1022 maTabs[nTab]->LimitChartArea( rStartCol, rStartRow, rEndCol, rEndRow );
1023 }
1024
1025
1026 void ScDocument::LimitChartIfAll( ScRangeListRef& rRangeList )
1027 {
1028 ScRangeListRef aNew = new ScRangeList;
1029 if (rRangeList.Is())
1030 {
1031 for ( size_t i = 0, nCount = rRangeList->size(); i < nCount; i++ )
1032 {
1033 ScRange aRange( *(*rRangeList)[i] );
1034 if ( ( aRange.aStart.Col() == 0 && aRange.aEnd.Col() == MAXCOL ) ||
1035 ( aRange.aStart.Row() == 0 && aRange.aEnd.Row() == MAXROW ) )
1036 {
1037 SCCOL nStartCol = aRange.aStart.Col();
1038 SCROW nStartRow = aRange.aStart.Row();
1039 SCCOL nEndCol = aRange.aEnd.Col();
1040 SCROW nEndRow = aRange.aEnd.Row();
1041 SCTAB nTab = aRange.aStart.Tab();
1042 if ( nTab < static_cast<SCTAB> (maTabs.size()) && maTabs[nTab])
1043 maTabs[nTab]->LimitChartArea(nStartCol, nStartRow, nEndCol, nEndRow);
1044 aRange.aStart.SetCol( nStartCol );
1045 aRange.aStart.SetRow( nStartRow );
1046 aRange.aEnd.SetCol( nEndCol );
1047 aRange.aEnd.SetRow( nEndRow );
1048 }
1049 aNew->Append(aRange);
1050 }
1051 }
1052 else
1053 {
1054 OSL_FAIL("LimitChartIfAll: Ref==0");
1055 }
1056 rRangeList = aNew;
1057 }
1058
1059
1060 static void lcl_GetFirstTabRange( SCTAB& rTabRangeStart, SCTAB& rTabRangeEnd, const ScMarkData* pTabMark, SCTAB aMaxTab )
1061 {
1062 // without ScMarkData, leave start/end unchanged
1063 if ( pTabMark )
1064 {
1065 for (SCTAB nTab=0; nTab< aMaxTab; ++nTab)
1066 if (pTabMark->GetTableSelect(nTab))
1067 {
1068 // find first range of consecutive selected sheets
1069 rTabRangeStart = pTabMark->GetFirstSelected();
1070 while ( nTab+1 < aMaxTab && pTabMark->GetTableSelect(nTab+1) )
1071 ++nTab;
1072 rTabRangeEnd = nTab;
1073 return;
1074 }
1075 }
1076 }
1077
1078 static bool lcl_GetNextTabRange( SCTAB& rTabRangeStart, SCTAB& rTabRangeEnd, const ScMarkData* pTabMark, SCTAB aMaxTab )
1079 {
1080 if ( pTabMark )
1081 {
1082 // find next range of consecutive selected sheets after rTabRangeEnd
1083 for (SCTAB nTab=rTabRangeEnd+1; nTab< aMaxTab; ++nTab)
1084 if (pTabMark->GetTableSelect(nTab))
1085 {
1086 rTabRangeStart = nTab;
1087 while ( nTab+1 < aMaxTab && pTabMark->GetTableSelect(nTab+1) )
1088 ++nTab;
1089 rTabRangeEnd = nTab;
1090 return true;
1091 }
1092 }
1093 return false;
1094 }
1095
1096
1097 bool ScDocument::CanInsertRow( const ScRange& rRange ) const
1098 {
1099 SCCOL nStartCol = rRange.aStart.Col();
1100 SCROW nStartRow = rRange.aStart.Row();
1101 SCTAB nStartTab = rRange.aStart.Tab();
1102 SCCOL nEndCol = rRange.aEnd.Col();
1103 SCROW nEndRow = rRange.aEnd.Row();
1104 SCTAB nEndTab = rRange.aEnd.Tab();
1105 PutInOrder( nStartCol, nEndCol );
1106 PutInOrder( nStartRow, nEndRow );
1107 PutInOrder( nStartTab, nEndTab );
1108 SCSIZE nSize = static_cast<SCSIZE>(nEndRow - nStartRow + 1);
1109
1110 bool bTest = true;
1111 for (SCTAB i=nStartTab; i<=nEndTab && bTest && i < static_cast<SCTAB>(maTabs.size()); i++)
1112 if (maTabs[i])
1113 bTest &= maTabs[i]->TestInsertRow( nStartCol, nEndCol, nSize );
1114
1115 return bTest;
1116 }
1117
1118 namespace {
1119
1120 struct BroadcastRecalcOnRefMoveHandler : std::unary_function<ScTable*, void>
1121 {
1122 void operator() (ScTable* p)
1123 {
1124 if (p)
1125 p->BroadcastRecalcOnRefMove();
1126 }
1127 };
1128
1129 }
1130
1131 bool ScDocument::InsertRow( SCCOL nStartCol, SCTAB nStartTab,
1132 SCCOL nEndCol, SCTAB nEndTab,
1133 SCROW nStartRow, SCSIZE nSize, ScDocument* pRefUndoDoc,
1134 const ScMarkData* pTabMark )
1135 {
1136 SCTAB i;
1137
1138 PutInOrder( nStartCol, nEndCol );
1139 PutInOrder( nStartTab, nEndTab );
1140 if ( pTabMark )
1141 {
1142 nStartTab = 0;
1143 nEndTab = static_cast<SCTAB>(maTabs.size()) -1;
1144 }
1145
1146 bool bTest = true;
1147 bool bRet = false;
1148 bool bOldAutoCalc = GetAutoCalc();
1149 SetAutoCalc( false ); // avoid mulitple calculations
1150 for ( i = nStartTab; i <= nEndTab && bTest && i < static_cast<SCTAB>(maTabs.size()); i++)
1151 if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1152 bTest &= maTabs[i]->TestInsertRow( nStartCol, nEndCol, nSize );
1153 if (bTest)
1154 {
1155 // UpdateBroadcastAreas have to be called before UpdateReference, so that entries
1156 // aren't shifted that would be rebuild at UpdateReference
1157
1158 // handle chunks of consecutive selected sheets together
1159 SCTAB nTabRangeStart = nStartTab;
1160 SCTAB nTabRangeEnd = nEndTab;
1161 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1162 do
1163 {
1164 UpdateBroadcastAreas( URM_INSDEL, ScRange(
1165 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1166 ScAddress( nEndCol, MAXROW, nTabRangeEnd )), 0, static_cast<SCsROW>(nSize), 0 );
1167 }
1168 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1169
1170 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1171 do
1172 {
1173 UpdateReference( URM_INSDEL, nStartCol, nStartRow, nTabRangeStart,
1174 nEndCol, MAXROW, nTabRangeEnd,
1175 0, static_cast<SCsROW>(nSize), 0, pRefUndoDoc, false ); // without drawing objects
1176 }
1177 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1178
1179 for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(maTabs.size()); i++)
1180 if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1181 maTabs[i]->InsertRow( nStartCol, nEndCol, nStartRow, nSize );
1182
1183 // UpdateRef for drawing layer must be after inserting,
1184 // when the new row heights are known.
1185 for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(maTabs.size()); i++)
1186 if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1187 maTabs[i]->UpdateDrawRef( URM_INSDEL,
1188 nStartCol, nStartRow, nStartTab, nEndCol, MAXROW, nEndTab,
1189 0, static_cast<SCsROW>(nSize), 0 );
1190
1191 if ( pChangeTrack && pChangeTrack->IsInDeleteUndo() )
1192 { // durch Restaurierung von Referenzen auf geloeschte Bereiche ist
1193 // ein neues Listening faellig, bisherige Listener wurden in
1194 // FormulaCell UpdateReference abgehaengt
1195 StartAllListeners();
1196 }
1197 else
1198 { // Listeners have been removed in UpdateReference
1199 TableContainer::iterator it = maTabs.begin();
1200 for (; it != maTabs.end(); ++it)
1201 if (*it)
1202 (*it)->StartNeededListeners();
1203 // At least all cells using range names pointing relative to the
1204 // moved range must be recalculated, and all cells marked postponed
1205 // dirty.
1206 it = maTabs.begin();
1207 for (; it != maTabs.end(); ++it)
1208 if (*it)
1209 (*it)->SetDirtyIfPostponed();
1210
1211 // Cells containing functions such as CELL, COLUMN or ROW may have
1212 // changed their values on relocation. Broadcast them.
1213 std::for_each(maTabs.begin(), maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1214 }
1215 bRet = true;
1216 }
1217 SetAutoCalc( bOldAutoCalc );
1218 if ( bRet )
1219 pChartListenerCollection->UpdateDirtyCharts();
1220 return bRet;
1221 }
1222
1223
1224 bool ScDocument::InsertRow( const ScRange& rRange, ScDocument* pRefUndoDoc )
1225 {
1226 return InsertRow( rRange.aStart.Col(), rRange.aStart.Tab(),
1227 rRange.aEnd.Col(), rRange.aEnd.Tab(),
1228 rRange.aStart.Row(), static_cast<SCSIZE>(rRange.aEnd.Row()-rRange.aStart.Row()+1),
1229 pRefUndoDoc );
1230 }
1231
1232
1233 void ScDocument::DeleteRow( SCCOL nStartCol, SCTAB nStartTab,
1234 SCCOL nEndCol, SCTAB nEndTab,
1235 SCROW nStartRow, SCSIZE nSize,
1236 ScDocument* pRefUndoDoc, bool* pUndoOutline,
1237 const ScMarkData* pTabMark )
1238 {
1239 SCTAB i;
1240
1241 PutInOrder( nStartCol, nEndCol );
1242 PutInOrder( nStartTab, nEndTab );
1243 if ( pTabMark )
1244 {
1245 nStartTab = 0;
1246 nEndTab = static_cast<SCTAB>(maTabs.size())-1;
1247 }
1248
1249 bool bOldAutoCalc = GetAutoCalc();
1250 SetAutoCalc( false ); // avoid multiple calculations
1251
1252 // handle chunks of consecutive selected sheets together
1253 SCTAB nTabRangeStart = nStartTab;
1254 SCTAB nTabRangeEnd = nEndTab;
1255 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1256 do
1257 {
1258 if ( ValidRow(nStartRow+nSize) )
1259 {
1260 DelBroadcastAreasInRange( ScRange(
1261 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1262 ScAddress( nEndCol, nStartRow+nSize-1, nTabRangeEnd ) ) );
1263 UpdateBroadcastAreas( URM_INSDEL, ScRange(
1264 ScAddress( nStartCol, nStartRow+nSize, nTabRangeStart ),
1265 ScAddress( nEndCol, MAXROW, nTabRangeEnd )), 0, -(static_cast<SCsROW>(nSize)), 0 );
1266 }
1267 else
1268 DelBroadcastAreasInRange( ScRange(
1269 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1270 ScAddress( nEndCol, MAXROW, nTabRangeEnd ) ) );
1271 }
1272 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1273
1274 if ( ValidRow(nStartRow+nSize) )
1275 {
1276 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1277 do
1278 {
1279 UpdateReference( URM_INSDEL, nStartCol, nStartRow+nSize, nTabRangeStart,
1280 nEndCol, MAXROW, nTabRangeEnd,
1281 0, -(static_cast<SCsROW>(nSize)), 0, pRefUndoDoc, true, false );
1282 }
1283 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1284 }
1285
1286 if (pUndoOutline)
1287 *pUndoOutline = false;
1288
1289 for ( i = nStartTab; i <= nEndTab && i < static_cast<SCTAB>(maTabs.size()); i++)
1290 if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1291 maTabs[i]->DeleteRow( nStartCol, nEndCol, nStartRow, nSize, pUndoOutline );
1292
1293 if ( ValidRow(nStartRow+nSize) )
1294 { // Listeners have been removed in UpdateReference
1295 TableContainer::iterator it = maTabs.begin();
1296 for (; it != maTabs.end(); ++it)
1297 if (*it)
1298 (*it)->StartNeededListeners();
1299 // At least all cells using range names pointing relative to the moved
1300 // range must be recalculated, and all cells marked postponed dirty.
1301 it = maTabs.begin();
1302 for (; it != maTabs.end(); ++it)
1303 if (*it)
1304 (*it)->SetDirtyIfPostponed();
1305
1306 // Cells containing functions such as CELL, COLUMN or ROW may have
1307 // changed their values on relocation. Broadcast them.
1308 std::for_each(maTabs.begin(), maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1309 }
1310
1311 SetAutoCalc( bOldAutoCalc );
1312 pChartListenerCollection->UpdateDirtyCharts();
1313 }
1314
1315
1316 void ScDocument::DeleteRow( const ScRange& rRange, ScDocument* pRefUndoDoc, bool* pUndoOutline )
1317 {
1318 DeleteRow( rRange.aStart.Col(), rRange.aStart.Tab(),
1319 rRange.aEnd.Col(), rRange.aEnd.Tab(),
1320 rRange.aStart.Row(), static_cast<SCSIZE>(rRange.aEnd.Row()-rRange.aStart.Row()+1),
1321 pRefUndoDoc, pUndoOutline );
1322 }
1323
1324
1325 bool ScDocument::CanInsertCol( const ScRange& rRange ) const
1326 {
1327 SCCOL nStartCol = rRange.aStart.Col();
1328 SCROW nStartRow = rRange.aStart.Row();
1329 SCTAB nStartTab = rRange.aStart.Tab();
1330 SCCOL nEndCol = rRange.aEnd.Col();
1331 SCROW nEndRow = rRange.aEnd.Row();
1332 SCTAB nEndTab = rRange.aEnd.Tab();
1333 PutInOrder( nStartCol, nEndCol );
1334 PutInOrder( nStartRow, nEndRow );
1335 PutInOrder( nStartTab, nEndTab );
1336 SCSIZE nSize = static_cast<SCSIZE>(nEndCol - nStartCol + 1);
1337
1338 bool bTest = true;
1339 for (SCTAB i=nStartTab; i<=nEndTab && bTest && i < static_cast<SCTAB>(maTabs.size()); i++)
1340 if (maTabs[i])
1341 bTest &= maTabs[i]->TestInsertCol( nStartRow, nEndRow, nSize );
1342
1343 return bTest;
1344 }
1345
1346
1347 bool ScDocument::InsertCol( SCROW nStartRow, SCTAB nStartTab,
1348 SCROW nEndRow, SCTAB nEndTab,
1349 SCCOL nStartCol, SCSIZE nSize, ScDocument* pRefUndoDoc,
1350 const ScMarkData* pTabMark )
1351 {
1352 SCTAB i;
1353
1354 PutInOrder( nStartRow, nEndRow );
1355 PutInOrder( nStartTab, nEndTab );
1356 if ( pTabMark )
1357 {
1358 nStartTab = 0;
1359 nEndTab = static_cast<SCTAB>(maTabs.size())-1;
1360 }
1361
1362 bool bTest = true;
1363 bool bRet = false;
1364 bool bOldAutoCalc = GetAutoCalc();
1365 SetAutoCalc( false ); // avoid multiple calculations
1366 for ( i = nStartTab; i <= nEndTab && bTest && i < static_cast<SCTAB>(maTabs.size()); i++)
1367 if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1368 bTest &= maTabs[i]->TestInsertCol( nStartRow, nEndRow, nSize );
1369 if (bTest)
1370 {
1371 // handle chunks of consecutive selected sheets together
1372 SCTAB nTabRangeStart = nStartTab;
1373 SCTAB nTabRangeEnd = nEndTab;
1374 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1375 do
1376 {
1377 UpdateBroadcastAreas( URM_INSDEL, ScRange(
1378 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1379 ScAddress( MAXCOL, nEndRow, nTabRangeEnd )), static_cast<SCsCOL>(nSize), 0, 0 );
1380 }
1381 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1382
1383 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1384 do
1385 {
1386 UpdateReference( URM_INSDEL, nStartCol, nStartRow, nTabRangeStart,
1387 MAXCOL, nEndRow, nTabRangeEnd,
1388 static_cast<SCsCOL>(nSize), 0, 0, pRefUndoDoc, true, false );
1389 }
1390 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1391
1392 for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(maTabs.size()); i++)
1393 if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1394 maTabs[i]->InsertCol( nStartCol, nStartRow, nEndRow, nSize );
1395
1396 if ( pChangeTrack && pChangeTrack->IsInDeleteUndo() )
1397 { // durch Restaurierung von Referenzen auf geloeschte Bereiche ist
1398 // ein neues Listening faellig, bisherige Listener wurden in
1399 // FormulaCell UpdateReference abgehaengt
1400 StartAllListeners();
1401 }
1402 else
1403 {// Listeners have been removed in UpdateReference
1404 TableContainer::iterator it = maTabs.begin();
1405 for (; it != maTabs.end(); ++it)
1406 if (*it)
1407 (*it)->StartNeededListeners();
1408 // At least all cells using range names pointing relative to the
1409 // moved range must be recalculated, and all cells marked postponed
1410 // dirty.
1411 it = maTabs.begin();
1412 for (; it != maTabs.end(); ++it)
1413 if (*it)
1414 (*it)->SetDirtyIfPostponed();
1415
1416 // Cells containing functions such as CELL, COLUMN or ROW may have
1417 // changed their values on relocation. Broadcast them.
1418 std::for_each(maTabs.begin(), maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1419 }
1420 bRet = true;
1421 }
1422 SetAutoCalc( bOldAutoCalc );
1423 if ( bRet )
1424 pChartListenerCollection->UpdateDirtyCharts();
1425 return bRet;
1426 }
1427
1428
1429 bool ScDocument::InsertCol( const ScRange& rRange, ScDocument* pRefUndoDoc )
1430 {
1431 return InsertCol( rRange.aStart.Row(), rRange.aStart.Tab(),
1432 rRange.aEnd.Row(), rRange.aEnd.Tab(),
1433 rRange.aStart.Col(), static_cast<SCSIZE>(rRange.aEnd.Col()-rRange.aStart.Col()+1),
1434 pRefUndoDoc );
1435 }
1436
1437
1438 void ScDocument::DeleteCol(SCROW nStartRow, SCTAB nStartTab, SCROW nEndRow, SCTAB nEndTab,
1439 SCCOL nStartCol, SCSIZE nSize, ScDocument* pRefUndoDoc,
1440 bool* pUndoOutline, const ScMarkData* pTabMark )
1441 {
1442 SCTAB i;
1443
1444 PutInOrder( nStartRow, nEndRow );
1445 PutInOrder( nStartTab, nEndTab );
1446 if ( pTabMark )
1447 {
1448 nStartTab = 0;
1449 nEndTab = static_cast<SCTAB>(maTabs.size())-1;
1450 }
1451
1452 bool bOldAutoCalc = GetAutoCalc();
1453 SetAutoCalc( false ); // avoid multiple calculations
1454
1455 // handle chunks of consecutive selected sheets together
1456 SCTAB nTabRangeStart = nStartTab;
1457 SCTAB nTabRangeEnd = nEndTab;
1458 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1459 do
1460 {
1461 if ( ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1462 {
1463 DelBroadcastAreasInRange( ScRange(
1464 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1465 ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize-1), nEndRow, nTabRangeEnd ) ) );
1466 UpdateBroadcastAreas( URM_INSDEL, ScRange(
1467 ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart ),
1468 ScAddress( MAXCOL, nEndRow, nTabRangeEnd )), -static_cast<SCsCOL>(nSize), 0, 0 );
1469 }
1470 else
1471 DelBroadcastAreasInRange( ScRange(
1472 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1473 ScAddress( MAXCOL, nEndRow, nTabRangeEnd ) ) );
1474 }
1475 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1476
1477 if ( ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1478 {
1479 lcl_GetFirstTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) );
1480 do
1481 {
1482 UpdateReference( URM_INSDEL, sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart,
1483 MAXCOL, nEndRow, nTabRangeEnd,
1484 -static_cast<SCsCOL>(nSize), 0, 0, pRefUndoDoc, true, false );
1485 }
1486 while ( lcl_GetNextTabRange( nTabRangeStart, nTabRangeEnd, pTabMark, static_cast<SCTAB>(maTabs.size()) ) );
1487 }
1488
1489 if (pUndoOutline)
1490 *pUndoOutline = false;
1491
1492 for ( i = nStartTab; i <= nEndTab && i < static_cast<SCTAB>(maTabs.size()); i++)
1493 if (maTabs[i] && (!pTabMark || pTabMark->GetTableSelect(i)))
1494 maTabs[i]->DeleteCol( nStartCol, nStartRow, nEndRow, nSize, pUndoOutline );
1495
1496 if ( ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1497 {// Listeners have been removed in UpdateReference
1498 TableContainer::iterator it = maTabs.begin();
1499 for (; it != maTabs.end(); ++it)
1500 if (*it)
1501 (*it)->StartNeededListeners();
1502 // At least all cells using range names pointing relative to the moved
1503 // range must be recalculated, and all cells marked postponed dirty.
1504 it = maTabs.begin();
1505 for (; it != maTabs.end(); ++it)
1506 if (*it)
1507 (*it)->SetDirtyIfPostponed();
1508
1509 // Cells containing functions such as CELL, COLUMN or ROW may have
1510 // changed their values on relocation. Broadcast them.
1511 std::for_each(maTabs.begin(), maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1512 }
1513
1514 SetAutoCalc( bOldAutoCalc );
1515 pChartListenerCollection->UpdateDirtyCharts();
1516 }
1517
1518
1519 void ScDocument::DeleteCol( const ScRange& rRange, ScDocument* pRefUndoDoc, bool* pUndoOutline )
1520 {
1521 DeleteCol( rRange.aStart.Row(), rRange.aStart.Tab(),
1522 rRange.aEnd.Row(), rRange.aEnd.Tab(),
1523 rRange.aStart.Col(), static_cast<SCSIZE>(rRange.aEnd.Col()-rRange.aStart.Col()+1),
1524 pRefUndoDoc, pUndoOutline );
1525 }
1526
1527
1528 // fuer Area-Links: Zellen einuegen/loeschen, wenn sich der Bereich veraendert
1529 // (ohne Paint)
1530
1531
1532 static void lcl_GetInsDelRanges( const ScRange& rOld, const ScRange& rNew,
1533 ScRange& rColRange, bool& rInsCol, bool& rDelCol,
1534 ScRange& rRowRange, bool& rInsRow, bool& rDelRow )
1535 {
1536 OSL_ENSURE( rOld.aStart == rNew.aStart, "FitBlock: Beginning is different" );
1537
1538 rInsCol = rDelCol = rInsRow = rDelRow = false;
1539
1540 SCCOL nStartX = rOld.aStart.Col();
1541 SCROW nStartY = rOld.aStart.Row();
1542 SCCOL nOldEndX = rOld.aEnd.Col();
1543 SCROW nOldEndY = rOld.aEnd.Row();
1544 SCCOL nNewEndX = rNew.aEnd.Col();
1545 SCROW nNewEndY = rNew.aEnd.Row();
1546 SCTAB nTab = rOld.aStart.Tab();
1547
1548 // wenn es mehr Zeilen werden, werden Spalten auf der alten Hoehe eingefuegt/geloescht
1549 bool bGrowY = ( nNewEndY > nOldEndY );
1550 SCROW nColEndY = bGrowY ? nOldEndY : nNewEndY;
1551 SCCOL nRowEndX = bGrowY ? nNewEndX : nOldEndX;
1552
1553 // Spalten
1554
1555 if ( nNewEndX > nOldEndX ) // Spalten einfuegen
1556 {
1557 rColRange = ScRange( nOldEndX+1, nStartY, nTab, nNewEndX, nColEndY, nTab );
1558 rInsCol = true;
1559 }
1560 else if ( nNewEndX < nOldEndX ) // Spalten loeschen
1561 {
1562 rColRange = ScRange( nNewEndX+1, nStartY, nTab, nOldEndX, nColEndY, nTab );
1563 rDelCol = true;
1564 }
1565
1566 // Zeilen
1567
1568 if ( nNewEndY > nOldEndY ) // Zeilen einfuegen
1569 {
1570 rRowRange = ScRange( nStartX, nOldEndY+1, nTab, nRowEndX, nNewEndY, nTab );
1571 rInsRow = true;
1572 }
1573 else if ( nNewEndY < nOldEndY ) // Zeilen loeschen
1574 {
1575 rRowRange = ScRange( nStartX, nNewEndY+1, nTab, nRowEndX, nOldEndY, nTab );
1576 rDelRow = true;
1577 }
1578 }
1579
1580
1581 bool ScDocument::HasPartOfMerged( const ScRange& rRange )
1582 {
1583 bool bPart = false;
1584 SCTAB nTab = rRange.aStart.Tab();
1585
1586 SCCOL nStartX = rRange.aStart.Col();
1587 SCROW nStartY = rRange.aStart.Row();
1588 SCCOL nEndX = rRange.aEnd.Col();
1589 SCROW nEndY = rRange.aEnd.Row();
1590
1591 if (HasAttrib( nStartX, nStartY, nTab, nEndX, nEndY, nTab,
1592 HASATTR_MERGED | HASATTR_OVERLAPPED ))
1593 {
1594 ExtendMerge( nStartX, nStartY, nEndX, nEndY, nTab );
1595 ExtendOverlapped( nStartX, nStartY, nEndX, nEndY, nTab );
1596
1597 bPart = ( nStartX != rRange.aStart.Col() || nEndX != rRange.aEnd.Col() ||
1598 nStartY != rRange.aStart.Row() || nEndY != rRange.aEnd.Row() );
1599 }
1600 return bPart;
1601 }
1602
1603 size_t ScDocument::GetFormulaHash( const ScAddress& rPos ) const
1604 {
1605 SCTAB nTab = rPos.Tab();
1606 if (!ValidTab(nTab) || static_cast<size_t>(nTab) >= maTabs.size() || !maTabs[nTab])
1607 return 0;
1608
1609 return maTabs[nTab]->GetFormulaHash(rPos.Col(), rPos.Row());
1610 }
1611
1612 ScFormulaVectorState ScDocument::GetFormulaVectorState( const ScAddress& rPos ) const
1613 {
1614 SCTAB nTab = rPos.Tab();
1615 if (!ValidTab(nTab) || static_cast<size_t>(nTab) >= maTabs.size() || !maTabs[nTab])
1616 return FormulaVectorUnknown;
1617
1618 return maTabs[nTab]->GetFormulaVectorState(rPos.Col(), rPos.Row());
1619 }
1620
1621 formula::FormulaTokenRef ScDocument::ResolveStaticReference( const ScAddress& rPos )
1622 {
1623 SCTAB nTab = rPos.Tab();
1624 if (!TableExists(nTab))
1625 return formula::FormulaTokenRef();
1626
1627 return maTabs[nTab]->ResolveStaticReference(rPos.Col(), rPos.Row());
1628 }
1629
1630 formula::FormulaTokenRef ScDocument::ResolveStaticReference( const ScRange& rRange )
1631 {
1632 SCTAB nTab = rRange.aStart.Tab();
1633 if (nTab != rRange.aEnd.Tab() || !TableExists(nTab))
1634 return formula::FormulaTokenRef();
1635
1636 return maTabs[nTab]->ResolveStaticReference(
1637 rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row());
1638 }
1639
1640 const double* ScDocument::FetchDoubleArray(
1641 sc::FormulaGroupContext& rCxt, const ScAddress& rPos, SCROW nLength ) const
1642 {
1643 SCTAB nTab = rPos.Tab();
1644 if (!TableExists(nTab))
1645 return NULL;
1646
1647 return maTabs[nTab]->FetchDoubleArray(rCxt, rPos.Col(), rPos.Row(), rPos.Row()+nLength-1);
1648 }
1649
1650 bool ScDocument::CanFitBlock( const ScRange& rOld, const ScRange& rNew )
1651 {
1652 if ( rOld == rNew )
1653 return true;
1654
1655 bool bOk = true;
1656 bool bInsCol,bDelCol,bInsRow,bDelRow;
1657 ScRange aColRange,aRowRange;
1658 lcl_GetInsDelRanges( rOld, rNew, aColRange,bInsCol,bDelCol, aRowRange,bInsRow,bDelRow );
1659
1660 if ( bInsCol && !CanInsertCol( aColRange ) ) // Zellen am Rand ?
1661 bOk = false;
1662 if ( bInsRow && !CanInsertRow( aRowRange ) ) // Zellen am Rand ?
1663 bOk = false;
1664
1665 if ( bInsCol || bDelCol )
1666 {
1667 aColRange.aEnd.SetCol(MAXCOL);
1668 if ( HasPartOfMerged(aColRange) )
1669 bOk = false;
1670 }
1671 if ( bInsRow || bDelRow )
1672 {
1673 aRowRange.aEnd.SetRow(MAXROW);
1674 if ( HasPartOfMerged(aRowRange) )
1675 bOk = false;
1676 }
1677
1678 return bOk;
1679 }
1680
1681
1682 void ScDocument::FitBlock( const ScRange& rOld, const ScRange& rNew, bool bClear )
1683 {
1684 if (bClear)
1685 DeleteAreaTab( rOld, IDF_ALL );
1686
1687 bool bInsCol,bDelCol,bInsRow,bDelRow;
1688 ScRange aColRange,aRowRange;
1689 lcl_GetInsDelRanges( rOld, rNew, aColRange,bInsCol,bDelCol, aRowRange,bInsRow,bDelRow );
1690
1691 if ( bInsCol )
1692 InsertCol( aColRange ); // Spalten zuerst einfuegen
1693 if ( bInsRow )
1694 InsertRow( aRowRange );
1695
1696 if ( bDelRow )
1697 DeleteRow( aRowRange ); // Zeilen zuerst loeschen
1698 if ( bDelCol )
1699 DeleteCol( aColRange );
1700
1701 // Referenzen um eingefuegte Zeilen erweitern
1702
1703 if ( bInsCol || bInsRow )
1704 {
1705 ScRange aGrowSource = rOld;
1706 aGrowSource.aEnd.SetCol(std::min( rOld.aEnd.Col(), rNew.aEnd.Col() ));
1707 aGrowSource.aEnd.SetRow(std::min( rOld.aEnd.Row(), rNew.aEnd.Row() ));
1708 SCCOL nGrowX = bInsCol ? ( rNew.aEnd.Col() - rOld.aEnd.Col() ) : 0;
1709 SCROW nGrowY = bInsRow ? ( rNew.aEnd.Row() - rOld.aEnd.Row() ) : 0;
1710 UpdateGrow( aGrowSource, nGrowX, nGrowY );
1711 }
1712 }
1713
1714
1715 void ScDocument::DeleteArea(SCCOL nCol1, SCROW nRow1,
1716 SCCOL nCol2, SCROW nRow2,
1717 const ScMarkData& rMark, sal_uInt16 nDelFlag)
1718 {
1719 PutInOrder( nCol1, nCol2 );
1720 PutInOrder( nRow1, nRow2 );
1721 bool bOldAutoCalc = GetAutoCalc();
1722 SetAutoCalc( false ); // avoid multiple calculations
1723 for (SCTAB i = 0; i < static_cast<SCTAB>(maTabs.size()); i++)
1724 if (maTabs[i])
1725 if ( rMark.GetTableSelect(i) || bIsUndo )
1726 maTabs[i]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag);
1727 SetAutoCalc( bOldAutoCalc );
1728 }
1729
1730
1731 void ScDocument::DeleteAreaTab(SCCOL nCol1, SCROW nRow1,
1732 SCCOL nCol2, SCROW nRow2,
1733 SCTAB nTab, sal_uInt16 nDelFlag)
1734 {
1735 PutInOrder( nCol1, nCol2 );
1736 PutInOrder( nRow1, nRow2 );
1737 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
1738 {
1739 bool bOldAutoCalc = GetAutoCalc();
1740 SetAutoCalc( false ); // avoid multiple calculations
1741 maTabs[nTab]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag);
1742 SetAutoCalc( bOldAutoCalc );
1743 }
1744 }
1745
1746
1747 void ScDocument::DeleteAreaTab( const ScRange& rRange, sal_uInt16 nDelFlag )
1748 {
1749 for ( SCTAB nTab = rRange.aStart.Tab(); nTab <= rRange.aEnd.Tab(); nTab++ )
1750 DeleteAreaTab( rRange.aStart.Col(), rRange.aStart.Row(),
1751 rRange.aEnd.Col(), rRange.aEnd.Row(),
1752 nTab, nDelFlag );
1753 }
1754
1755
1756 void ScDocument::InitUndoSelected( ScDocument* pSrcDoc, const ScMarkData& rTabSelection,
1757 bool bColInfo, bool bRowInfo )
1758 {
1759 if (bIsUndo)
1760 {
1761 Clear();
1762
1763 xPoolHelper = pSrcDoc->xPoolHelper;
1764
1765
1766 OUString aString;
1767 for (SCTAB nTab = 0; nTab <= rTabSelection.GetLastSelected(); nTab++)
1768 if ( rTabSelection.GetTableSelect( nTab ) )
1769 {
1770 ScTable* pTable = new ScTable(this, nTab, aString, bColInfo, bRowInfo);
1771 if (nTab < static_cast<SCTAB>(maTabs.size()))
1772 maTabs[nTab] = pTable;
1773 else
1774 maTabs.push_back(pTable);
1775 }
1776 else
1777 {
1778 if (nTab < static_cast<SCTAB>(maTabs.size()))
1779 maTabs[nTab]=NULL;
1780 else
1781 maTabs.push_back(NULL);
1782 }
1783 }
1784 else
1785 {
1786 OSL_FAIL("InitUndo");
1787 }
1788 }
1789
1790
1791 void ScDocument::InitUndo( ScDocument* pSrcDoc, SCTAB nTab1, SCTAB nTab2,
1792 bool bColInfo, bool bRowInfo )
1793 {
1794 if (bIsUndo)
1795 {
1796 Clear();
1797
1798 xPoolHelper = pSrcDoc->xPoolHelper;
1799 if (pSrcDoc->pShell->GetMedium())
1800 maFileURL = pSrcDoc->pShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DECODE_TO_IURI);
1801
1802 OUString aString;
1803 if ( nTab2 >= static_cast<SCTAB>(maTabs.size()))
1804 maTabs.resize(nTab2 + 1, NULL);
1805 for (SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
1806 {
1807 ScTable* pTable = new ScTable(this, nTab, aString, bColInfo, bRowInfo);
1808 maTabs[nTab] = pTable;
1809 }
1810 }
1811 else
1812 {
1813 OSL_FAIL("InitUndo");
1814 }
1815 }
1816
1817
1818 void ScDocument::AddUndoTab( SCTAB nTab1, SCTAB nTab2, bool bColInfo, bool bRowInfo )
1819 {
1820 if (bIsUndo)
1821 {
1822 OUString aString;
1823 if (nTab2 >= static_cast<SCTAB>(maTabs.size()))
1824 {
1825 maTabs.resize(nTab2+1,NULL);
1826 }
1827 for (SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
1828 if (!maTabs[nTab])
1829 {
1830 maTabs[nTab] = new ScTable(this, nTab, aString, bColInfo, bRowInfo);
1831 }
1832
1833 }
1834 else
1835 {
1836 OSL_FAIL("InitUndo");
1837 }
1838 }
1839
1840
1841 void ScDocument::SetCutMode( bool bVal )
1842 {
1843 if (bIsClip)
1844 GetClipParam().mbCutMode = bVal;
1845 else
1846 {
1847 OSL_FAIL("SetCutMode without bIsClip");
1848 }
1849 }
1850
1851
1852 bool ScDocument::IsCutMode()
1853 {
1854 if (bIsClip)
1855 return GetClipParam().mbCutMode;
1856 else
1857 {
1858 OSL_FAIL("IsCutMode without bIsClip");
1859 return false;
1860 }
1861 }
1862
1863
1864 void ScDocument::CopyToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1865 SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
1866 sal_uInt16 nFlags, bool bOnlyMarked, ScDocument* pDestDoc,
1867 const ScMarkData* pMarks, bool bColRowFlags )
1868 {
1869 PutInOrder( nCol1, nCol2 );
1870 PutInOrder( nRow1, nRow2 );
1871 PutInOrder( nTab1, nTab2 );
1872 if( pDestDoc->aDocName.isEmpty() )
1873 pDestDoc->aDocName = aDocName;
1874 if (ValidTab(nTab1) && ValidTab(nTab2))
1875 {
1876 sc::CopyToDocContext aCxt(*pDestDoc);
1877 bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1878 pDestDoc->SetAutoCalc( false ); // avoid multiple calculations
1879 SCTAB nMinSizeBothTabs = static_cast<SCTAB>(std::min(maTabs.size(), pDestDoc->maTabs.size()));
1880 for (SCTAB i = nTab1; i <= nTab2 && i < nMinSizeBothTabs; i++)
1881 {
1882 if (maTabs[i] && pDestDoc->maTabs[i])
1883 maTabs[i]->CopyToTable(aCxt, nCol1, nRow1, nCol2, nRow2, nFlags,
1884 bOnlyMarked, pDestDoc->maTabs[i], pMarks,
1885 false, bColRowFlags );
1886 }
1887 pDestDoc->SetAutoCalc( bOldAutoCalc );
1888 }
1889 }
1890
1891
1892 void ScDocument::UndoToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1893 SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
1894 sal_uInt16 nFlags, bool bOnlyMarked, ScDocument* pDestDoc,
1895 const ScMarkData* pMarks)
1896 {
1897 PutInOrder( nCol1, nCol2 );
1898 PutInOrder( nRow1, nRow2 );
1899 PutInOrder( nTab1, nTab2 );
1900 if (ValidTab(nTab1) && ValidTab(nTab2))
1901 {
1902 bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1903 pDestDoc->SetAutoCalc( false ); // avoid multiple calculations
1904 if (nTab1 > 0)
1905 CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, IDF_FORMULA, false, pDestDoc, pMarks );
1906
1907 sc::CopyToDocContext aCxt(*pDestDoc);
1908 OSL_ASSERT( nTab2 < static_cast<SCTAB>(maTabs.size()) && nTab2 < static_cast<SCTAB>(pDestDoc->maTabs.size()));
1909 for (SCTAB i = nTab1; i <= nTab2; i++)
1910 {
1911 if (maTabs[i] && pDestDoc->maTabs[i])
1912 maTabs[i]->UndoToTable(aCxt, nCol1, nRow1, nCol2, nRow2, nFlags,
1913 bOnlyMarked, pDestDoc->maTabs[i], pMarks);
1914 }
1915
1916 if (nTab2 < MAXTAB)
1917 CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,MAXTAB, IDF_FORMULA, false, pDestDoc, pMarks );
1918 pDestDoc->SetAutoCalc( bOldAutoCalc );
1919 }
1920 }
1921
1922
1923 void ScDocument::CopyToDocument(const ScRange& rRange,
1924 sal_uInt16 nFlags, bool bOnlyMarked, ScDocument* pDestDoc,
1925 const ScMarkData* pMarks, bool bColRowFlags)
1926 {
1927 ScRange aNewRange = rRange;
1928 aNewRange.Justify();
1929
1930 if( pDestDoc->aDocName.isEmpty() )
1931 pDestDoc->aDocName = aDocName;
1932 bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1933 pDestDoc->SetAutoCalc( false ); // avoid multiple calculations
1934 sc::CopyToDocContext aCxt(*pDestDoc);
1935 SCTAB nMinSizeBothTabs = static_cast<SCTAB>(std::min(maTabs.size(), pDestDoc->maTabs.size()));
1936 for (SCTAB i = aNewRange.aStart.Tab(); i <= aNewRange.aEnd.Tab() && i < nMinSizeBothTabs; i++)
1937 {
1938 if (!TableExists(i) || !pDestDoc->TableExists(i))
1939 continue;
1940
1941 maTabs[i]->CopyToTable(aCxt, aNewRange.aStart.Col(), aNewRange.aStart.Row(),
1942 aNewRange.aEnd.Col(), aNewRange.aEnd.Row(),
1943 nFlags, bOnlyMarked, pDestDoc->maTabs[i],
1944 pMarks, false, bColRowFlags);
1945 }
1946 pDestDoc->SetAutoCalc( bOldAutoCalc );
1947 }
1948
1949
1950 void ScDocument::UndoToDocument(const ScRange& rRange,
1951 sal_uInt16 nFlags, bool bOnlyMarked, ScDocument* pDestDoc,
1952 const ScMarkData* pMarks)
1953 {
1954 ScRange aNewRange = rRange;
1955 aNewRange.Justify();
1956 SCTAB nTab1 = aNewRange.aStart.Tab();
1957 SCTAB nTab2 = aNewRange.aEnd.Tab();
1958
1959 bool bOldAutoCalc = pDestDoc->GetAutoCalc();
1960 pDestDoc->SetAutoCalc( false ); // avoid multiple calculations
1961 sc::CopyToDocContext aCxt(*pDestDoc);
1962 if (nTab1 > 0)
1963 CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTab1-1, IDF_FORMULA, false, pDestDoc, pMarks );
1964
1965 SCTAB nMinSizeBothTabs = static_cast<SCTAB>(std::min(maTabs.size(), pDestDoc->maTabs.size()));
1966 for (SCTAB i = nTab1; i <= nTab2 && i < nMinSizeBothTabs; i++)
1967 {
1968 if (maTabs[i] && pDestDoc->maTabs[i])
1969 maTabs[i]->UndoToTable(aCxt, aNewRange.aStart.Col(), aNewRange.aStart.Row(),
1970 aNewRange.aEnd.Col(), aNewRange.aEnd.Row(),
1971 nFlags, bOnlyMarked, pDestDoc->maTabs[i], pMarks);
1972 }
1973
1974 if (nTab2 < static_cast<SCTAB>(maTabs.size()))
1975 CopyToDocument( 0,0,nTab2+1, MAXCOL,MAXROW,maTabs.size(), IDF_FORMULA, false, pDestDoc, pMarks );
1976 pDestDoc->SetAutoCalc( bOldAutoCalc );
1977 }
1978
1979 // bUseRangeForVBA added for VBA api support to allow content of a specified
1980 // range to be copied ( e.g. don't use marked data but the just the range
1981 // specified by rClipParam
1982 void ScDocument::CopyToClip(const ScClipParam& rClipParam,
1983 ScDocument* pClipDoc, const ScMarkData* pMarks,
1984 bool bAllTabs, bool bKeepScenarioFlags, bool bIncludeObjects, bool bCloneNoteCaptions, bool bUseRangeForVBA )
1985 {
1986 OSL_ENSURE( !bUseRangeForVBA && ( bAllTabs || pMarks ), "CopyToClip: ScMarkData fails" );
1987
1988 if (bIsClip)
1989 return;
1990
1991 if (!pClipDoc)
1992 {
1993 OSL_TRACE("CopyToClip: no ClipDoc");
1994 pClipDoc = SC_MOD()->GetClipDoc();
1995 }
1996
1997 if (pShell->GetMedium())
1998 {
1999 pClipDoc->maFileURL = pShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DECODE_TO_IURI);
2000 // for unsaved files use the title name and adjust during save of file
2001 if (pClipDoc->maFileURL.isEmpty())
2002 pClipDoc->maFileURL = pShell->GetName();
2003 }
2004 else
2005 {
2006 pClipDoc->maFileURL = pShell->GetName();
2007 }
2008
2009 //init maTabNames
2010 for (TableContainer::iterator itr = maTabs.begin(); itr != maTabs.end(); ++itr)
2011 {
2012 if( *itr )
2013 {
2014 OUString aTabName;
2015 (*itr)->GetName(aTabName);
2016 pClipDoc->maTabNames.push_back(aTabName);
2017 }
2018 else
2019 pClipDoc->maTabNames.push_back(OUString());
2020 }
2021
2022 pClipDoc->aDocName = aDocName;
2023 pClipDoc->SetClipParam(rClipParam);
2024 ScRange aClipRange = rClipParam.getWholeRange();
2025 SCTAB nTab = aClipRange.aStart.Tab();
2026 SCTAB i = 0;
2027 SCTAB nEndTab = static_cast<SCTAB>(maTabs.size());
2028
2029 if ( bUseRangeForVBA )
2030 {
2031 pClipDoc->ResetClip( this, nTab );
2032 i = nTab;
2033 nEndTab = nTab + 1;
2034 }
2035 else
2036 pClipDoc->ResetClip(this, pMarks);
2037
2038 sc::CopyToClipContext aCxt(*pClipDoc, bKeepScenarioFlags, bCloneNoteCaptions);
2039 CopyRangeNamesToClip(pClipDoc, aClipRange, pMarks, bAllTabs);
2040
2041 for ( ; i < nEndTab; ++i)
2042 {
2043 if (!maTabs[i] || i >= static_cast<SCTAB>(pClipDoc->maTabs.size()) || !pClipDoc->maTabs[i])
2044 continue;
2045
2046 if ( !bUseRangeForVBA && ( pMarks && !pMarks->GetTableSelect(i) ) )
2047 continue;
2048
2049 maTabs[i]->CopyToClip(aCxt, rClipParam.maRanges, pClipDoc->maTabs[i]);
2050
2051 if (pDrawLayer && bIncludeObjects)
2052 {
2053 // also copy drawing objects
2054 Rectangle aObjRect = GetMMRect(
2055 aClipRange.aStart.Col(), aClipRange.aStart.Row(), aClipRange.aEnd.Col(), aClipRange.aEnd.Row(), i);
2056 pDrawLayer->CopyToClip(pClipDoc, i, aObjRect);
2057 }
2058 }
2059
2060 // Make sure to mark overlapped cells.
2061 pClipDoc->ExtendMerge(aClipRange, true);
2062 }
2063
2064 void ScDocument::CopyStaticToDocument(const ScRange& rSrcRange, SCTAB nDestTab, ScDocument* pDestDoc)
2065 {
2066 if (!pDestDoc)
2067 return;
2068
2069 ScTable* pSrcTab = rSrcRange.aStart.Tab() < static_cast<SCTAB>(maTabs.size()) ? maTabs[rSrcRange.aStart.Tab()] : NULL;
2070 ScTable* pDestTab = nDestTab < static_cast<SCTAB>(pDestDoc->maTabs.size()) ? pDestDoc->maTabs[nDestTab] : NULL;
2071
2072 if (!pSrcTab || !pDestTab)
2073 return;
2074
2075 pSrcTab->CopyStaticToDocument(
2076 rSrcRange.aStart.Col(), rSrcRange.aStart.Row(), rSrcRange.aEnd.Col(), rSrcRange.aEnd.Row(), pDestTab);
2077 }
2078
2079 void ScDocument::CopyCellToDocument( const ScAddress& rSrcPos, const ScAddress& rDestPos, ScDocument& rDestDoc )
2080 {
2081 if (!TableExists(rSrcPos.Tab()) || !rDestDoc.TableExists(rDestPos.Tab()))
2082 return;
2083
2084 ScTable& rSrcTab = *maTabs[rSrcPos.Tab()];
2085 ScTable& rDestTab = *rDestDoc.maTabs[rDestPos.Tab()];
2086
2087 rSrcTab.CopyCellToDocument(rSrcPos.Col(), rSrcPos.Row(), rDestPos.Col(), rDestPos.Row(), rDestTab);
2088 }
2089
2090 void ScDocument::CopyTabToClip(SCCOL nCol1, SCROW nRow1,
2091 SCCOL nCol2, SCROW nRow2,
2092 SCTAB nTab, ScDocument* pClipDoc)
2093 {
2094 if (!bIsClip)
2095 {
2096 if (pShell->GetMedium())
2097 {
2098 pClipDoc->maFileURL = pShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DECODE_TO_IURI);
2099 // for unsaved files use the title name and adjust during save of file
2100 if (pClipDoc->maFileURL.isEmpty())
2101 pClipDoc->maFileURL = pShell->GetName();
2102 }
2103 else
2104 {
2105 pClipDoc->maFileURL = pShell->GetName();
2106 }
2107
2108 //init maTabNames
2109 for (TableContainer::iterator itr = maTabs.begin(); itr != maTabs.end(); ++itr)
2110 {
2111 if( *itr )
2112 {
2113 OUString aTabName;
2114 (*itr)->GetName(aTabName);
2115 pClipDoc->maTabNames.push_back(aTabName);
2116 }
2117 else
2118 pClipDoc->maTabNames.push_back(OUString());
2119 }
2120
2121 PutInOrder( nCol1, nCol2 );
2122 PutInOrder( nRow1, nRow2 );
2123 if (!pClipDoc)
2124 {
2125 OSL_TRACE("CopyTabToClip: no ClipDoc");
2126 pClipDoc = SC_MOD()->GetClipDoc();
2127 }
2128
2129 ScClipParam& rClipParam = pClipDoc->GetClipParam();
2130 pClipDoc->aDocName = aDocName;
2131 rClipParam.maRanges.RemoveAll();
2132 rClipParam.maRanges.Append(ScRange(nCol1, nRow1, 0, nCol2, nRow2, 0));
2133 pClipDoc->ResetClip( this, nTab );
2134
2135 sc::CopyToClipContext aCxt(*pClipDoc, false, true);
2136 if (nTab < static_cast<SCTAB>(maTabs.size()) && nTab < static_cast<SCTAB>(pClipDoc->maTabs.size()))
2137 if (maTabs[nTab] && pClipDoc->maTabs[nTab])
2138 maTabs[nTab]->CopyToClip(aCxt, nCol1, nRow1, nCol2, nRow2, pClipDoc->maTabs[nTab]);
2139
2140 pClipDoc->GetClipParam().mbCutMode = false;
2141 }
2142 }
2143
2144
2145 void ScDocument::TransposeClip( ScDocument* pTransClip, sal_uInt16 nFlags, bool bAsLink )
2146 {
2147 OSL_ENSURE( bIsClip && pTransClip && pTransClip->bIsClip,
2148 "TransposeClip with wrong Document" );
2149
2150 // initialisieren
2151 // -> pTransClip muss vor dem Original-Dokument geloescht werden!
2152
2153 pTransClip->ResetClip(this, (ScMarkData*)NULL); // alle
2154
2155 // Bereiche uebernehmen
2156
2157 if (pRangeName)
2158 {
2159 pTransClip->GetRangeName()->clear();
2160 ScRangeName::const_iterator itr = pRangeName->begin(), itrEnd = pRangeName->end();
2161 for (; itr != itrEnd; ++itr)
2162 {
2163 sal_uInt16 nIndex = itr->second->GetIndex();
2164 ScRangeData* pData = new ScRangeData(*itr->second);
2165 if (pTransClip->pRangeName->insert(pData))
2166 pData->SetIndex(nIndex);
2167 }
2168 }
2169
2170 // The data
2171
2172 ScRange aClipRange = GetClipParam().getWholeRange();
2173 if ( ValidRow(aClipRange.aEnd.Row()-aClipRange.aStart.Row()) )
2174 {
2175 for (SCTAB i=0; i< static_cast<SCTAB>(maTabs.size()); i++)
2176 if (maTabs[i])
2177 {
2178 OSL_ENSURE( pTransClip->maTabs[i], "TransposeClip: Table not there" );
2179 maTabs[i]->TransposeClip( aClipRange.aStart.Col(), aClipRange.aStart.Row(),
2180 aClipRange.aEnd.Col(), aClipRange.aEnd.Row(),
2181 pTransClip->maTabs[i], nFlags, bAsLink );
2182
2183 if ( pDrawLayer && ( nFlags & IDF_OBJECTS ) )
2184 {
2185 // Drawing objects are copied to the new area without transposing.
2186 // CopyFromClip is used to adjust the objects to the transposed block's
2187 // cell range area.
2188 // (pDrawLayer in the original clipboard document is set only if there
2189 // are drawing objects to copy)
2190
2191 pTransClip->InitDrawLayer();
2192 Rectangle aSourceRect = GetMMRect( aClipRange.aStart.Col(), aClipRange.aStart.Row(),
2193 aClipRange.aEnd.Col(), aClipRange.aEnd.Row(), i );
2194 Rectangle aDestRect = pTransClip->GetMMRect( 0, 0,
2195 static_cast<SCCOL>(aClipRange.aEnd.Row() - aClipRange.aStart.Row()),
2196 static_cast<SCROW>(aClipRange.aEnd.Col() - aClipRange.aStart.Col()), i );
2197 pTransClip->pDrawLayer->CopyFromClip( pDrawLayer, i, aSourceRect, ScAddress(0,0,i), aDestRect );
2198 }
2199 }
2200
2201 pTransClip->SetClipParam(GetClipParam());
2202 pTransClip->GetClipParam().transpose();
2203 }
2204 else
2205 {
2206 OSL_TRACE("TransposeClip: Too big");
2207 }
2208
2209 // Dies passiert erst beim Einfuegen...
2210
2211 GetClipParam().mbCutMode = false;
2212 }
2213
2214 namespace {
2215
2216 void copyUsedNamesToClip(ScRangeName* pClipRangeName, ScRangeName* pRangeName, const std::set<sal_uInt16>& rUsedNames)
2217 {
2218 pClipRangeName->clear();
2219 ScRangeName::const_iterator itr = pRangeName->begin(), itrEnd = pRangeName->end();
2220 for (; itr != itrEnd; ++itr) //! DB-Bereiche Pivot-Bereiche auch !!!
2221 {
2222 sal_uInt16 nIndex = itr->second->GetIndex();
2223 bool bInUse = (rUsedNames.count(nIndex) > 0);
2224 if (!bInUse)
2225 continue;
2226
2227 ScRangeData* pData = new ScRangeData(*itr->second);
2228 if (pClipRangeName->insert(pData))
2229 pData->SetIndex(nIndex);
2230 }
2231 }
2232
2233 }
2234
2235 void ScDocument::CopyRangeNamesToClip(ScDocument* pClipDoc, const ScRange& rClipRange, const ScMarkData* pMarks, bool bAllTabs)
2236 {
2237 if (!pRangeName || pRangeName->empty())
2238 return;
2239
2240 std::set<sal_uInt16> aUsedNames; // indexes of named ranges that are used in the copied cells
2241 SCTAB nMinSizeBothTabs = static_cast<SCTAB>(std::min(maTabs.size(), pClipDoc->maTabs.size()));
2242 for (SCTAB i = 0; i < nMinSizeBothTabs; ++i)
2243 if (maTabs[i] && pClipDoc->maTabs[i])
2244 if ( bAllTabs || !pMarks || pMarks->GetTableSelect(i) )
2245 maTabs[i]->FindRangeNamesInUse(
2246 rClipRange.aStart.Col(), rClipRange.aStart.Row(),
2247 rClipRange.aEnd.Col(), rClipRange.aEnd.Row(), aUsedNames);
2248
2249 copyUsedNamesToClip(pClipDoc->GetRangeName(), pRangeName, aUsedNames);
2250 }
2251
2252 ScDocument::NumFmtMergeHandler::NumFmtMergeHandler(ScDocument* pDoc, ScDocument* pSrcDoc) :
2253 mpDoc(pDoc)
2254 {
2255 mpDoc->MergeNumberFormatter(pSrcDoc);
2256 }
2257
2258 ScDocument::NumFmtMergeHandler::~NumFmtMergeHandler()
2259 {
2260 mpDoc->pFormatExchangeList = NULL;
2261 }
2262
2263 SvtBroadcaster* ScDocument::GetBroadcaster( const ScAddress& rPos )
2264 {
2265 ScTable* pTab = FetchTable(rPos.Tab());
2266 if (!pTab)
2267 return NULL;
2268
2269 return pTab->GetBroadcaster(rPos.Col(), rPos.Row());
2270 }
2271
2272 const SvtBroadcaster* ScDocument::GetBroadcaster( const ScAddress& rPos ) const
2273 {
2274 const ScTable* pTab = FetchTable(rPos.Tab());
2275 if (!pTab)
2276 return NULL;
2277
2278 return pTab->GetBroadcaster(rPos.Col(), rPos.Row());
2279 }
2280
2281 void ScDocument::DeleteBroadcasters( sc::ColumnBlockPosition& rBlockPos, const ScAddress& rTopPos, SCROW nLength )
2282 {
2283 ScTable* pTab = FetchTable(rTopPos.Tab());
2284 if (!pTab || nLength <= 0)
2285 return;
2286
2287 pTab->DeleteBroadcasters(rBlockPos, rTopPos.Col(), rTopPos.Row(), rTopPos.Row()+nLength-1);
2288 }
2289
2290 bool ScDocument::HasBroadcaster( SCTAB nTab, SCCOL nCol ) const
2291 {
2292 const ScTable* pTab = FetchTable(nTab);
2293 if (!pTab)
2294 return false;
2295
2296 return pTab->HasBroadcaster(nCol);
2297 }
2298
2299 bool ScDocument::TableExists( SCTAB nTab ) const
2300 {
2301 return ValidTab(nTab) && static_cast<size_t>(nTab) < maTabs.size() && maTabs[nTab];
2302 }
2303
2304 ScTable* ScDocument::FetchTable( SCTAB nTab )
2305 {
2306 if (!TableExists(nTab))
2307 return NULL;
2308
2309 return maTabs[nTab];
2310 }
2311
2312 const ScTable* ScDocument::FetchTable( SCTAB nTab ) const
2313 {
2314 if (!TableExists(nTab))
2315 return NULL;
2316
2317 return maTabs[nTab];
2318 }
2319
2320 void ScDocument::MergeNumberFormatter(ScDocument* pSrcDoc)
2321 {
2322 SvNumberFormatter* pThisFormatter = xPoolHelper->GetFormTable();
2323 SvNumberFormatter* pOtherFormatter = pSrcDoc->xPoolHelper->GetFormTable();
2324 if (pOtherFormatter && pOtherFormatter != pThisFormatter)
2325 {
2326 SvNumberFormatterIndexTable* pExchangeList =
2327 pThisFormatter->MergeFormatter(*(pOtherFormatter));
2328 if (!pExchangeList->empty())
2329 pFormatExchangeList = pExchangeList;
2330 }
2331 }
2332
2333 ScClipParam& ScDocument::GetClipParam()
2334 {
2335 if (!mpClipParam.get())
2336 mpClipParam.reset(new ScClipParam);
2337
2338 return *mpClipParam;
2339 }
2340
2341 void ScDocument::SetClipParam(const ScClipParam& rParam)
2342 {
2343 mpClipParam.reset(new ScClipParam(rParam));
2344 }
2345
2346 bool ScDocument::IsClipboardSource() const
2347 {
2348 ScDocument* pClipDoc = SC_MOD()->GetClipDoc();
2349 return pClipDoc && pClipDoc->xPoolHelper.is() &&
2350 xPoolHelper->GetDocPool() == pClipDoc->xPoolHelper->GetDocPool();
2351 }
2352
2353
2354 void ScDocument::StartListeningFromClip( SCCOL nCol1, SCROW nRow1,
2355 SCCOL nCol2, SCROW nRow2,
2356 const ScMarkData& rMark, sal_uInt16 nInsFlag )
2357 {
2358 if (nInsFlag & IDF_CONTENTS)
2359 {
2360 sc::StartListeningContext aCxt(*this);
2361 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
2362 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
2363 for (; itr != itrEnd && *itr < nMax; ++itr)
2364 if (maTabs[*itr])
2365 maTabs[*itr]->StartListeningInArea(aCxt, nCol1, nRow1, nCol2, nRow2);
2366 }
2367 }
2368
2369
2370 void ScDocument::BroadcastFromClip( SCCOL nCol1, SCROW nRow1,
2371 SCCOL nCol2, SCROW nRow2,
2372 const ScMarkData& rMark, sal_uInt16 nInsFlag )
2373 {
2374 if (nInsFlag & IDF_CONTENTS)
2375 {
2376 ScBulkBroadcast aBulkBroadcast( GetBASM());
2377 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
2378 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
2379 for (; itr != itrEnd && *itr < nMax; ++itr)
2380 if (maTabs[*itr])
2381 maTabs[*itr]->BroadcastInArea( nCol1, nRow1, nCol2, nRow2 );
2382 }
2383 }
2384
2385 bool ScDocument::InitColumnBlockPosition( sc::ColumnBlockPosition& rBlockPos, SCTAB nTab, SCCOL nCol )
2386 {
2387 if (!TableExists(nTab))
2388 return false;
2389
2390 return maTabs[nTab]->InitColumnBlockPosition(rBlockPos, nCol);
2391 }
2392
2393 void ScDocument::CopyBlockFromClip(
2394 sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
2395 const ScMarkData& rMark, SCsCOL nDx, SCsROW nDy )
2396 {
2397 TableContainer& rClipTabs = rCxt.getClipDoc()->maTabs;
2398 SCTAB nTabEnd = rCxt.getTabEnd();
2399 SCTAB nClipTab = 0;
2400 for (SCTAB i = rCxt.getTabStart(); i <= nTabEnd && i < static_cast<SCTAB>(maTabs.size()); i++)
2401 {
2402 if (maTabs[i] && rMark.GetTableSelect(i) )
2403 {
2404 while (!rClipTabs[nClipTab]) nClipTab = (nClipTab+1) % (static_cast<SCTAB>(rClipTabs.size()));
2405
2406 maTabs[i]->CopyFromClip(
2407 rCxt, nCol1, nRow1, nCol2, nRow2, nDx, nDy, rClipTabs[nClipTab]);
2408
2409 if (rCxt.getClipDoc()->pDrawLayer && (rCxt.getInsertFlag() & IDF_OBJECTS))
2410 {
2411 // also copy drawing objects
2412
2413 // drawing layer must be created before calling CopyFromClip
2414 // (ScDocShell::MakeDrawLayer also does InitItems etc.)
2415 OSL_ENSURE( pDrawLayer, "CopyBlockFromClip: No drawing layer" );
2416 if ( pDrawLayer )
2417 {
2418 // For GetMMRect, the row heights in the target document must already be valid
2419 // (copied in an extra step before pasting, or updated after pasting cells, but
2420 // before pasting objects).
2421
2422 Rectangle aSourceRect = rCxt.getClipDoc()->GetMMRect(
2423 nCol1-nDx, nRow1-nDy, nCol2-nDx, nRow2-nDy, nClipTab );
2424 Rectangle aDestRect = GetMMRect( nCol1, nRow1, nCol2, nRow2, i );
2425 pDrawLayer->CopyFromClip(rCxt.getClipDoc()->pDrawLayer, nClipTab, aSourceRect,
2426 ScAddress( nCol1, nRow1, i ), aDestRect );
2427 }
2428 }
2429
2430 nClipTab = (nClipTab+1) % (static_cast<SCTAB>(rClipTabs.size()));
2431 }
2432 }
2433 if (rCxt.getInsertFlag() & IDF_CONTENTS)
2434 {
2435 nClipTab = 0;
2436 for (SCTAB i = rCxt.getTabStart(); i <= nTabEnd && i < static_cast<SCTAB>(maTabs.size()); i++)
2437 {
2438 if (maTabs[i] && rMark.GetTableSelect(i) )
2439 {
2440 while (!rClipTabs[nClipTab]) nClipTab = (nClipTab+1) % (static_cast<SCTAB>(rClipTabs.size()));
2441 SCsTAB nDz = ((SCsTAB)i) - nClipTab;
2442
2443 // ranges of consecutive selected tables (in clipboard and dest. doc)
2444 // must be handled in one UpdateReference call
2445 SCTAB nFollow = 0;
2446 while ( i + nFollow < nTabEnd
2447 && rMark.GetTableSelect( i + nFollow + 1 )
2448 && nClipTab + nFollow < MAXTAB
2449 && rClipTabs[(nClipTab + nFollow + 1) % static_cast<SCTAB>(rClipTabs.size())] )
2450 ++nFollow;
2451
2452 if (rCxt.getClipDoc()->GetClipParam().mbCutMode)
2453 {
2454 bool bOldInserting = IsInsertingFromOtherDoc();
2455 SetInsertingFromOtherDoc( true);
2456 UpdateReference( URM_MOVE,
2457 nCol1, nRow1, i, nCol2, nRow2, i+nFollow,
2458 nDx, nDy, nDz, rCxt.getUndoDoc(), false );
2459 SetInsertingFromOtherDoc( bOldInserting);
2460 }
2461 else
2462 UpdateReference( URM_COPY,
2463 nCol1, nRow1, i, nCol2, nRow2, i+nFollow,
2464 nDx, nDy, nDz, rCxt.getUndoDoc(), false );
2465
2466 nClipTab = (nClipTab+nFollow+1) % (static_cast<SCTAB>(rClipTabs.size()));
2467 i = sal::static_int_cast<SCTAB>( i + nFollow );
2468 }
2469 }
2470 }
2471 }
2472
2473
2474 void ScDocument::CopyNonFilteredFromClip(
2475 sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
2476 const ScMarkData& rMark, SCsCOL nDx, SCROW & rClipStartRow )
2477 {
2478 // call CopyBlockFromClip for ranges of consecutive non-filtered rows
2479 // nCol1/nRow1 etc. is in target doc
2480
2481 // filtered state is taken from first used table in clipboard (as in GetClipArea)
2482 SCTAB nFlagTab = 0;
2483 TableContainer& rClipTabs = rCxt.getClipDoc()->maTabs;
2484 while ( nFlagTab < static_cast<SCTAB>(rClipTabs.size()) && !rClipTabs[nFlagTab] )
2485 ++nFlagTab;
2486
2487 SCROW nSourceRow = rClipStartRow;
2488 SCROW nSourceEnd = 0;
2489 if (!rCxt.getClipDoc()->GetClipParam().maRanges.empty())
2490 nSourceEnd = rCxt.getClipDoc()->GetClipParam().maRanges.front()->aEnd.Row();
2491 SCROW nDestRow = nRow1;
2492
2493 while ( nSourceRow <= nSourceEnd && nDestRow <= nRow2 )
2494 {
2495 // skip filtered rows
2496 nSourceRow = rCxt.getClipDoc()->FirstNonFilteredRow(nSourceRow, nSourceEnd, nFlagTab);
2497
2498 if ( nSourceRow <= nSourceEnd )
2499 {
2500 // look for more non-filtered rows following
2501 SCROW nLastRow = nSourceRow;
2502 rCxt.getClipDoc()->RowFiltered(nSourceRow, nFlagTab, NULL, &nLastRow);
2503 SCROW nFollow = nLastRow - nSourceRow;
2504
2505 if (nFollow > nSourceEnd - nSourceRow)
2506 nFollow = nSourceEnd - nSourceRow;
2507 if (nFollow > nRow2 - nDestRow)
2508 nFollow = nRow2 - nDestRow;
2509
2510 SCsROW nNewDy = ((SCsROW)nDestRow) - nSourceRow;
2511 CopyBlockFromClip(
2512 rCxt, nCol1, nDestRow, nCol2, nDestRow + nFollow, rMark, nDx, nNewDy);
2513
2514 nSourceRow += nFollow + 1;
2515 nDestRow += nFollow + 1;
2516 }
2517 }
2518 rClipStartRow = nSourceRow;
2519 }
2520
2521
2522 void ScDocument::CopyFromClip( const ScRange& rDestRange, const ScMarkData& rMark,
2523 sal_uInt16 nInsFlag,
2524 ScDocument* pRefUndoDoc, ScDocument* pClipDoc, bool bResetCut,
2525 bool bAsLink, bool bIncludeFiltered, bool bSkipAttrForEmpty,
2526 const ScRangeList * pDestRanges )
2527 {
2528 if (bIsClip)
2529 return;
2530
2531 if (!pClipDoc)
2532 {
2533 OSL_FAIL("CopyFromClip: no ClipDoc");
2534 pClipDoc = SC_MOD()->GetClipDoc();
2535 }
2536
2537 if (!pClipDoc->bIsClip || !pClipDoc->GetTableCount())
2538 return;
2539
2540 bool bOldAutoCalc = GetAutoCalc();
2541 SetAutoCalc( false ); // avoid multiple recalculations
2542
2543 NumFmtMergeHandler aNumFmtMergeHdl(this, pClipDoc);
2544
2545 SCCOL nAllCol1 = rDestRange.aStart.Col();
2546 SCROW nAllRow1 = rDestRange.aStart.Row();
2547 SCCOL nAllCol2 = rDestRange.aEnd.Col();
2548 SCROW nAllRow2 = rDestRange.aEnd.Row();
2549
2550 SCCOL nXw = 0;
2551 SCROW nYw = 0;
2552 ScRange aClipRange = pClipDoc->GetClipParam().getWholeRange();
2553 for (SCTAB nTab = 0; nTab < static_cast<SCTAB>(pClipDoc->maTabs.size()); nTab++) // find largest merge overlap
2554 if (pClipDoc->maTabs[nTab]) // all sheets of the clipboard content
2555 {
2556 SCCOL nThisEndX = aClipRange.aEnd.Col();
2557 SCROW nThisEndY = aClipRange.aEnd.Row();
2558 pClipDoc->ExtendMerge( aClipRange.aStart.Col(),
2559 aClipRange.aStart.Row(),
2560 nThisEndX, nThisEndY, nTab );
2561 // only extra value from ExtendMerge
2562 nThisEndX = sal::static_int_cast<SCCOL>( nThisEndX - aClipRange.aEnd.Col() );
2563 nThisEndY = sal::static_int_cast<SCROW>( nThisEndY - aClipRange.aEnd.Row() );
2564 if ( nThisEndX > nXw )
2565 nXw = nThisEndX;
2566 if ( nThisEndY > nYw )
2567 nYw = nThisEndY;
2568 }
2569
2570 SCCOL nDestAddX;
2571 SCROW nDestAddY;
2572 pClipDoc->GetClipArea( nDestAddX, nDestAddY, bIncludeFiltered );
2573 nXw = sal::static_int_cast<SCCOL>( nXw + nDestAddX );
2574 nYw = sal::static_int_cast<SCROW>( nYw + nDestAddY ); // ClipArea, plus ExtendMerge value
2575
2576 /* Decide which contents to delete before copying. Delete all
2577 contents if nInsFlag contains any real content flag.
2578 #i102056# Notes are pasted from clipboard in a second pass,
2579 together with the special flag IDF_ADDNOTES that states to not
2580 overwrite/delete existing cells but to insert the notes into
2581 these cells. In this case, just delete old notes from the
2582 destination area. */
2583 sal_uInt16 nDelFlag = IDF_NONE;
2584 if ( (nInsFlag & (IDF_CONTENTS | IDF_ADDNOTES)) == (IDF_NOTE | IDF_ADDNOTES) )
2585 nDelFlag |= IDF_NOTE;
2586 else if ( nInsFlag & IDF_CONTENTS )
2587 nDelFlag |= IDF_CONTENTS;
2588 // With bSkipAttrForEmpty, don't remove attributes, copy
2589 // on top of existing attributes instead.
2590 if ( ( nInsFlag & IDF_ATTRIB ) && !bSkipAttrForEmpty )
2591 nDelFlag |= IDF_ATTRIB;
2592
2593 sc::CopyFromClipContext aCxt(*this, pRefUndoDoc, pClipDoc, nInsFlag, bAsLink, bSkipAttrForEmpty);
2594 std::pair<SCTAB,SCTAB> aTabRanges = getMarkedTableRange(maTabs, rMark);
2595 aCxt.setTabRange(aTabRanges.first, aTabRanges.second);
2596
2597 ScRangeList aLocalRangeList;
2598 if (!pDestRanges)
2599 {
2600 aLocalRangeList.Append( rDestRange);
2601 pDestRanges = &aLocalRangeList;
2602 }
2603
2604 bInsertingFromOtherDoc = true; // kein Broadcast/Listener aufbauen bei Insert
2605
2606 SCCOL nClipStartCol = aClipRange.aStart.Col();
2607 SCROW nClipStartRow = aClipRange.aStart.Row();
2608 SCROW nClipEndRow = aClipRange.aEnd.Row();
2609 for ( size_t nRange = 0; nRange < pDestRanges->size(); ++nRange )
2610 {
2611 const ScRange* pRange = (*pDestRanges)[nRange];
2612 SCCOL nCol1 = pRange->aStart.Col();
2613 SCROW nRow1 = pRange->aStart.Row();
2614 SCCOL nCol2 = pRange->aEnd.Col();
2615 SCROW nRow2 = pRange->aEnd.Row();
2616
2617 DeleteArea(nCol1, nRow1, nCol2, nRow2, rMark, nDelFlag);
2618
2619 SCCOL nC1 = nCol1;
2620 SCROW nR1 = nRow1;
2621 SCCOL nC2 = nC1 + nXw;
2622 if (nC2 > nCol2)
2623 nC2 = nCol2;
2624 SCROW nR2 = nR1 + nYw;
2625 if (nR2 > nRow2)
2626 nR2 = nRow2;
2627
2628 do
2629 {
2630 // Pasting is done column-wise, when pasting to a filtered
2631 // area this results in partitioning and we have to
2632 // remember and reset the start row for each column until
2633 // it can be advanced for the next chunk of unfiltered
2634 // rows.
2635 SCROW nSaveClipStartRow = nClipStartRow;
2636 do
2637 {
2638 nClipStartRow = nSaveClipStartRow;
2639 SCsCOL nDx = ((SCsCOL)nC1) - nClipStartCol;
2640 SCsROW nDy = ((SCsROW)nR1) - nClipStartRow;
2641 if ( bIncludeFiltered )
2642 {
2643 CopyBlockFromClip(
2644 aCxt, nC1, nR1, nC2, nR2, rMark, nDx, nDy);
2645 nClipStartRow += nR2 - nR1 + 1;
2646 }
2647 else
2648 {
2649 CopyNonFilteredFromClip(
2650 aCxt, nC1, nR1, nC2, nR2, rMark, nDx, nClipStartRow);
2651 }
2652 nC1 = nC2 + 1;
2653 nC2 = std::min((SCCOL)(nC1 + nXw), nCol2);
2654 } while (nC1 <= nCol2);
2655 if (nClipStartRow > nClipEndRow)
2656 nClipStartRow = aClipRange.aStart.Row();
2657 nC1 = nCol1;
2658 nC2 = nC1 + nXw;
2659 if (nC2 > nCol2)
2660 nC2 = nCol2;
2661 nR1 = nR2 + 1;
2662 nR2 = std::min((SCROW)(nR1 + nYw), nRow2);
2663 } while (nR1 <= nRow2);
2664 }
2665
2666 bInsertingFromOtherDoc = false;
2667
2668 // Listener aufbauen nachdem alles inserted wurde
2669 StartListeningFromClip( nAllCol1, nAllRow1, nAllCol2, nAllRow2, rMark, nInsFlag );
2670 // nachdem alle Listener aufgebaut wurden, kann gebroadcastet werden
2671 BroadcastFromClip( nAllCol1, nAllRow1, nAllCol2, nAllRow2, rMark, nInsFlag );
2672 if (bResetCut)
2673 pClipDoc->GetClipParam().mbCutMode = false;
2674 SetAutoCalc( bOldAutoCalc );
2675 }
2676
2677 static SCROW lcl_getLastNonFilteredRow(
2678 const ScBitMaskCompressedArray<SCROW, sal_uInt8>& rFlags, SCROW nBegRow, SCROW nEndRow,
2679 SCROW nRowCount)
2680 {
2681 SCROW nFilteredRow = rFlags.GetFirstForCondition(
2682 nBegRow, nEndRow, CR_FILTERED, CR_FILTERED);
2683
2684 SCROW nRow = nFilteredRow - 1;
2685 if (nRow - nBegRow + 1 > nRowCount)
2686 // make sure the row range stays within the data size.
2687 nRow = nBegRow + nRowCount - 1;
2688
2689 return nRow;
2690 }
2691
2692 void ScDocument::CopyMultiRangeFromClip(
2693 const ScAddress& rDestPos, const ScMarkData& rMark, sal_uInt16 nInsFlag, ScDocument* pClipDoc,
2694 bool bResetCut, bool bAsLink, bool /*bIncludeFiltered*/, bool bSkipAttrForEmpty)
2695 {
2696 if (bIsClip)
2697 return;
2698
2699 if (!pClipDoc->bIsClip || !pClipDoc->GetTableCount())
2700 // There is nothing in the clip doc to copy.
2701 return;
2702
2703 bool bOldAutoCalc = GetAutoCalc();
2704 SetAutoCalc( false ); // avoid multiple recalculations
2705
2706 NumFmtMergeHandler aNumFmtMergeHdl(this, pClipDoc);
2707
2708 SCCOL nCol1 = rDestPos.Col();
2709 SCROW nRow1 = rDestPos.Row();
2710 ScClipParam& rClipParam = pClipDoc->GetClipParam();
2711
2712 sc::CopyFromClipContext aCxt(*this, NULL, pClipDoc, nInsFlag, bAsLink, bSkipAttrForEmpty);
2713 std::pair<SCTAB,SCTAB> aTabRanges = getMarkedTableRange(maTabs, rMark);
2714 aCxt.setTabRange(aTabRanges.first, aTabRanges.second);
2715
2716 ScRange aDestRange;
2717 rMark.GetMarkArea(aDestRange);
2718 SCROW nLastMarkedRow = aDestRange.aEnd.Row();
2719
2720 bInsertingFromOtherDoc = true; // kein Broadcast/Listener aufbauen bei Insert
2721
2722 SCROW nBegRow = nRow1;
2723 sal_uInt16 nDelFlag = IDF_CONTENTS;
2724 const ScBitMaskCompressedArray<SCROW, sal_uInt8>& rFlags = GetRowFlagsArray(aCxt.getTabStart());
2725
2726 for ( size_t i = 0, n = rClipParam.maRanges.size(); i < n; ++i )
2727 {
2728 ScRange* p = rClipParam.maRanges[ i ];
2729 // The begin row must not be filtered.
2730
2731 SCROW nRowCount = p->aEnd.Row() - p->aStart.Row() + 1;
2732
2733 SCsCOL nDx = static_cast<SCsCOL>(nCol1 - p->aStart.Col());
2734 SCsROW nDy = static_cast<SCsROW>(nBegRow - p->aStart.Row());
2735 SCCOL nCol2 = nCol1 + p->aEnd.Col() - p->aStart.Col();
2736
2737 SCROW nEndRow = lcl_getLastNonFilteredRow(rFlags, nBegRow, nLastMarkedRow, nRowCount);
2738
2739 if (!bSkipAttrForEmpty)
2740 DeleteArea(nCol1, nBegRow, nCol2, nEndRow, rMark, nDelFlag);
2741
2742 CopyBlockFromClip(aCxt, nCol1, nBegRow, nCol2, nEndRow, rMark, nDx, nDy);
2743 nRowCount -= nEndRow - nBegRow + 1;
2744
2745 while (nRowCount > 0)
2746 {
2747 // Get the first non-filtered row.
2748 SCROW nNonFilteredRow = rFlags.GetFirstForCondition(nEndRow+1, nLastMarkedRow, CR_FILTERED, 0);
2749 if (nNonFilteredRow > nLastMarkedRow)
2750 return;
2751
2752 SCROW nRowsSkipped = nNonFilteredRow - nEndRow - 1;
2753 nDy += nRowsSkipped;
2754
2755 nBegRow = nNonFilteredRow;
2756 nEndRow = lcl_getLastNonFilteredRow(rFlags, nBegRow, nLastMarkedRow, nRowCount);
2757
2758 if (!bSkipAttrForEmpty)
2759 DeleteArea(nCol1, nBegRow, nCol2, nEndRow, rMark, nDelFlag);
2760
2761 CopyBlockFromClip(aCxt, nCol1, nBegRow, nCol2, nEndRow, rMark, nDx, nDy);
2762 nRowCount -= nEndRow - nBegRow + 1;
2763 }
2764
2765 if (rClipParam.meDirection == ScClipParam::Row)
2766 // Begin row for the next range being pasted.
2767 nBegRow = rFlags.GetFirstForCondition(nEndRow+1, nLastMarkedRow, CR_FILTERED, 0);
2768 else
2769 nBegRow = nRow1;
2770
2771 if (rClipParam.meDirection == ScClipParam::Column)
2772 nCol1 += p->aEnd.Col() - p->aStart.Col() + 1;
2773 }
2774
2775 bInsertingFromOtherDoc = false;
2776
2777 ScRangeList aRanges;
2778 aRanges.Append(aDestRange);
2779
2780 // Listener aufbauen nachdem alles inserted wurde
2781 StartListeningFromClip(aDestRange.aStart.Col(), aDestRange.aStart.Row(),
2782 aDestRange.aEnd.Col(), aDestRange.aEnd.Row(), rMark, nInsFlag );
2783 // nachdem alle Listener aufgebaut wurden, kann gebroadcastet werden
2784 BroadcastFromClip(aDestRange.aStart.Col(), aDestRange.aStart.Row(),
2785 aDestRange.aEnd.Col(), aDestRange.aEnd.Row(), rMark, nInsFlag );
2786
2787 if (bResetCut)
2788 pClipDoc->GetClipParam().mbCutMode = false;
2789 SetAutoCalc( bOldAutoCalc );
2790 }
2791
2792 void ScDocument::SetClipArea( const ScRange& rArea, bool bCut )
2793 {
2794 if (bIsClip)
2795 {
2796 ScClipParam& rClipParam = GetClipParam();
2797 rClipParam.maRanges.RemoveAll();
2798 rClipParam.maRanges.Append(rArea);
2799 rClipParam.mbCutMode = bCut;
2800 }
2801 else
2802 {
2803 OSL_FAIL("SetClipArea: No Clip");
2804 }
2805 }
2806
2807
2808 void ScDocument::GetClipArea(SCCOL& nClipX, SCROW& nClipY, bool bIncludeFiltered)
2809 {
2810 if (!bIsClip)
2811 {
2812 OSL_FAIL("GetClipArea: No Clip");
2813 return;
2814 }
2815
2816 ScRangeList& rClipRanges = GetClipParam().maRanges;
2817 if (rClipRanges.empty())
2818 // No clip range. Bail out.
2819 return;
2820
2821 ScRange* p = rClipRanges.front();
2822 SCCOL nStartCol = p->aStart.Col();
2823 SCCOL nEndCol = p->aEnd.Col();
2824 SCROW nStartRow = p->aStart.Row();
2825 SCROW nEndRow = p->aEnd.Row();
2826 for ( size_t i = 1, n = rClipRanges.size(); i < n; ++i )
2827 {
2828 p = rClipRanges[ i ];
2829 if (p->aStart.Col() < nStartCol)
2830 nStartCol = p->aStart.Col();
2831 if (p->aStart.Row() < nStartRow)
2832 nStartRow = p->aStart.Row();
2833 if (p->aEnd.Col() > nEndCol)
2834 nEndCol = p->aEnd.Col();
2835 if (p->aEnd.Row() < nEndRow)
2836 nEndRow = p->aEnd.Row();
2837 }
2838
2839 nClipX = nEndCol - nStartCol;
2840
2841 if ( bIncludeFiltered )
2842 nClipY = nEndRow - nStartRow;
2843 else
2844 {
2845 // count non-filtered rows
2846 // count on first used table in clipboard
2847 SCTAB nCountTab = 0;
2848 while ( nCountTab < static_cast<SCTAB>(maTabs.size()) && !maTabs[nCountTab] )
2849 ++nCountTab;
2850
2851 SCROW nResult = CountNonFilteredRows(nStartRow, nEndRow, nCountTab);
2852
2853 if ( nResult > 0 )
2854 nClipY = nResult - 1;
2855 else
2856 nClipY = 0; // always return at least 1 row
2857 }
2858 }
2859
2860
2861 void ScDocument::GetClipStart(SCCOL& nClipX, SCROW& nClipY)
2862 {
2863 if (bIsClip)
2864 {
2865 ScRangeList& rClipRanges = GetClipParam().maRanges;
2866 if ( !rClipRanges.empty() )
2867 {
2868 nClipX = rClipRanges.front()->aStart.Col();
2869 nClipY = rClipRanges.front()->aStart.Row();
2870 }
2871 }
2872 else
2873 {
2874 OSL_FAIL("GetClipStart: No Clip");
2875 }
2876 }
2877
2878
2879 bool ScDocument::HasClipFilteredRows()
2880 {
2881 // count on first used table in clipboard
2882 SCTAB nCountTab = 0;
2883 while ( nCountTab < static_cast<SCTAB>(maTabs.size()) && !maTabs[nCountTab] )
2884 ++nCountTab;
2885
2886 ScRangeList& rClipRanges = GetClipParam().maRanges;
2887 if ( rClipRanges.empty() )
2888 return false;
2889
2890 for ( size_t i = 0, n = rClipRanges.size(); i < n; ++i )
2891 {
2892 ScRange* p = rClipRanges[ i ];
2893 bool bAnswer = maTabs[nCountTab]->HasFilteredRows(p->aStart.Row(), p->aEnd.Row());
2894 if (bAnswer)
2895 return true;
2896 }
2897 return false;
2898 }
2899
2900
2901 void ScDocument::MixDocument( const ScRange& rRange, sal_uInt16 nFunction, bool bSkipEmpty,
2902 ScDocument* pSrcDoc )
2903 {
2904 SCTAB nTab1 = rRange.aStart.Tab();
2905 SCTAB nTab2 = rRange.aEnd.Tab();
2906 sc::MixDocContext aCxt(*this);
2907 SCTAB nMinSizeBothTabs = static_cast<SCTAB>(std::min(maTabs.size(), pSrcDoc->maTabs.size()));
2908 for (SCTAB i = nTab1; i <= nTab2 && i < nMinSizeBothTabs; i++)
2909 {
2910 ScTable* pTab = FetchTable(i);
2911 const ScTable* pSrcTab = pSrcDoc->FetchTable(i);
2912 if (!pTab || !pSrcTab)
2913 continue;
2914
2915 pTab->MixData(
2916 aCxt, rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row(),
2917 nFunction, bSkipEmpty, pSrcTab);
2918 }
2919 }
2920
2921
2922 void ScDocument::FillTab( const ScRange& rSrcArea, const ScMarkData& rMark,
2923 sal_uInt16 nFlags, sal_uInt16 nFunction,
2924 bool bSkipEmpty, bool bAsLink )
2925 {
2926 sal_uInt16 nDelFlags = nFlags;
2927 if (nDelFlags & IDF_CONTENTS)
2928 nDelFlags |= IDF_CONTENTS; // immer alle Inhalte oder keine loeschen!
2929
2930 SCTAB nSrcTab = rSrcArea.aStart.Tab();
2931
2932 if (ValidTab(nSrcTab) && nSrcTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nSrcTab])
2933 {
2934 SCCOL nStartCol = rSrcArea.aStart.Col();
2935 SCROW nStartRow = rSrcArea.aStart.Row();
2936 SCCOL nEndCol = rSrcArea.aEnd.Col();
2937 SCROW nEndRow = rSrcArea.aEnd.Row();
2938 boost::scoped_ptr<ScDocument> pMixDoc;
2939 bool bDoMix = ( bSkipEmpty || nFunction ) && ( nFlags & IDF_CONTENTS );
2940
2941 bool bOldAutoCalc = GetAutoCalc();
2942 SetAutoCalc( false ); // avoid multiple calculations
2943
2944 sc::CopyToDocContext aCxt(*this);
2945 sc::MixDocContext aMixDocCxt(*this);
2946
2947 SCTAB nCount = static_cast<SCTAB>(maTabs.size());
2948 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
2949 for (; itr != itrEnd && *itr < nCount; ++itr)
2950 if ( *itr!=nSrcTab && maTabs[*itr])
2951 {
2952 SCTAB i = *itr;
2953 if (bDoMix)
2954 {
2955 if (!pMixDoc)
2956 {
2957 pMixDoc.reset(new ScDocument(SCDOCMODE_UNDO));
2958 pMixDoc->InitUndo( this, i, i );
2959 }
2960 else
2961 pMixDoc->AddUndoTab( i, i );
2962
2963 // context used for copying content to the temporary mix document.
2964 sc::CopyToDocContext aMixCxt(*pMixDoc);
2965 maTabs[i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow,
2966 IDF_CONTENTS, false, pMixDoc->maTabs[i] );
2967 }
2968 maTabs[i]->DeleteArea( nStartCol,nStartRow, nEndCol,nEndRow, nDelFlags);
2969 maTabs[nSrcTab]->CopyToTable(aCxt, nStartCol,nStartRow, nEndCol,nEndRow,
2970 nFlags, false, maTabs[i], NULL, bAsLink );
2971
2972 if (bDoMix)
2973 maTabs[i]->MixData(aMixDocCxt, nStartCol,nStartRow, nEndCol,nEndRow,
2974 nFunction, bSkipEmpty, pMixDoc->maTabs[i] );
2975 }
2976
2977 SetAutoCalc( bOldAutoCalc );
2978 }
2979 else
2980 {
2981 OSL_FAIL("wrong table");
2982 }
2983 }
2984
2985
2986 void ScDocument::FillTabMarked( SCTAB nSrcTab, const ScMarkData& rMark,
2987 sal_uInt16 nFlags, sal_uInt16 nFunction,
2988 bool bSkipEmpty, bool bAsLink )
2989 {
2990 sal_uInt16 nDelFlags = nFlags;
2991 if (nDelFlags & IDF_CONTENTS)
2992 nDelFlags |= IDF_CONTENTS; // immer alle Inhalte oder keine loeschen!
2993
2994 if (ValidTab(nSrcTab) && nSrcTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nSrcTab])
2995 {
2996 boost::scoped_ptr<ScDocument> pMixDoc;
2997 bool bDoMix = ( bSkipEmpty || nFunction ) && ( nFlags & IDF_CONTENTS );
2998
2999 bool bOldAutoCalc = GetAutoCalc();
3000 SetAutoCalc( false ); // avoid multiple calculations
3001
3002 ScRange aArea;
3003 rMark.GetMultiMarkArea( aArea );
3004 SCCOL nStartCol = aArea.aStart.Col();
3005 SCROW nStartRow = aArea.aStart.Row();
3006 SCCOL nEndCol = aArea.aEnd.Col();
3007 SCROW nEndRow = aArea.aEnd.Row();
3008
3009 sc::CopyToDocContext aCxt(*this);
3010 sc::MixDocContext aMixDocCxt(*this);
3011 SCTAB nCount = static_cast<SCTAB>(maTabs.size());
3012 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
3013 for (; itr != itrEnd && *itr < nCount; ++itr)
3014 if ( *itr!=nSrcTab && maTabs[*itr] )
3015 {
3016 SCTAB i = *itr;
3017 if (bDoMix)
3018 {
3019 if (!pMixDoc)
3020 {
3021 pMixDoc.reset(new ScDocument(SCDOCMODE_UNDO));
3022 pMixDoc->InitUndo( this, i, i );
3023 }
3024 else
3025 pMixDoc->AddUndoTab( i, i );
3026
3027 sc::CopyToDocContext aMixCxt(*pMixDoc);
3028 maTabs[i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3029 IDF_CONTENTS, true, pMixDoc->maTabs[i], &rMark );
3030 }
3031
3032 maTabs[i]->DeleteSelection( nDelFlags, rMark );
3033 maTabs[nSrcTab]->CopyToTable(aCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3034 nFlags, true, maTabs[i], &rMark, bAsLink );
3035
3036 if (bDoMix)
3037 maTabs[i]->MixMarked(aMixDocCxt, rMark, nFunction, bSkipEmpty, pMixDoc->maTabs[i]);
3038 }
3039
3040 SetAutoCalc( bOldAutoCalc );
3041 }
3042 else
3043 {
3044 OSL_FAIL("wrong table");
3045 }
3046 }
3047
3048 void ScDocument::PutCell( const ScAddress& rPos, ScBaseCell* pCell, bool bForceTab )
3049 {
3050 SCTAB nTab = rPos.Tab();
3051 if ( bForceTab && ( nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab]) )
3052 {
3053 bool bExtras = !bIsUndo; // Spaltenbreiten, Zeilenhoehen, Flags
3054
3055 if (nTab >= static_cast<SCTAB>(maTabs.size()))
3056 maTabs.resize(nTab + 1,NULL);
3057 maTabs[nTab] = new ScTable(this, nTab,
3058 OUString("temp"),
3059 bExtras, bExtras);
3060 }
3061
3062 if (maTabs[nTab])
3063 maTabs[nTab]->PutCell( rPos, pCell );
3064 }
3065
3066
3067 bool ScDocument::SetString( SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString& rString,
3068 ScSetStringParam* pParam )
3069 {
3070 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3071 return maTabs[nTab]->SetString( nCol, nRow, nTab, rString, pParam );
3072 else
3073 return false;
3074 }
3075
3076 bool ScDocument::SetString(
3077 const ScAddress& rPos, const OUString& rString, ScSetStringParam* pParam )
3078 {
3079 return SetString(rPos.Col(), rPos.Row(), rPos.Tab(), rString, pParam);
3080 }
3081
3082 void ScDocument::SetEditText( const ScAddress& rPos, EditTextObject* pEditText )
3083 {
3084 if (!TableExists(rPos.Tab()))
3085 {
3086 delete pEditText;
3087 return;
3088 }
3089
3090 maTabs[rPos.Tab()]->SetEditText(rPos.Col(), rPos.Row(), pEditText);
3091 }
3092
3093 void ScDocument::SetEditText( const ScAddress& rPos, const EditTextObject& rEditText, const SfxItemPool* pEditPool )
3094 {
3095 if (!TableExists(rPos.Tab()))
3096 return;
3097
3098 maTabs[rPos.Tab()]->SetEditText(rPos.Col(), rPos.Row(), rEditText, pEditPool);
3099 }
3100
3101 void ScDocument::SetEditText( const ScAddress& rPos, const OUString& rStr )
3102 {
3103 if (!TableExists(rPos.Tab()))
3104 return;
3105
3106 ScFieldEditEngine& rEngine = GetEditEngine();
3107 rEngine.SetText(rStr);
3108 maTabs[rPos.Tab()]->SetEditText(rPos.Col(), rPos.Row(), rEngine.CreateTextObject());
3109 }
3110
3111 void ScDocument::SetTextCell( const ScAddress& rPos, const OUString& rStr )
3112 {
3113 if (!TableExists(rPos.Tab()))
3114 return;
3115
3116 if (ScStringUtil::isMultiline(rStr))
3117 {
3118 ScFieldEditEngine& rEngine = GetEditEngine();
3119 rEngine.SetText(rStr);
3120 maTabs[rPos.Tab()]->SetEditText(rPos.Col(), rPos.Row(), rEngine.CreateTextObject());
3121 }
3122 else
3123 {
3124 ScSetStringParam aParam;
3125 aParam.setTextInput();
3126 maTabs[rPos.Tab()]->SetString(rPos.Col(), rPos.Row(), rPos.Tab(), rStr, &aParam);
3127 }
3128 }
3129
3130 void ScDocument::SetEmptyCell( const ScAddress& rPos )
3131 {
3132 if (!TableExists(rPos.Tab()))
3133 return;
3134
3135 maTabs[rPos.Tab()]->SetEmptyCell(rPos.Col(), rPos.Row());
3136 }
3137
3138 void ScDocument::SetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rVal )
3139 {
3140 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
3141 if (maTabs[nTab])
3142 maTabs[nTab]->SetValue( nCol, nRow, rVal );
3143 }
3144
3145 void ScDocument::SetValue( const ScAddress& rPos, double fVal )
3146 {
3147 if (!TableExists(rPos.Tab()))
3148 return;
3149
3150 maTabs[rPos.Tab()]->SetValue(rPos.Col(), rPos.Row(), fVal);
3151 }
3152
3153 OUString ScDocument::GetString( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
3154 {
3155 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
3156 {
3157 OUString aStr;
3158 maTabs[nTab]->GetString(nCol, nRow, aStr);
3159 return aStr;
3160 }
3161 else
3162 return EMPTY_OUSTRING;
3163 }
3164
3165 OUString ScDocument::GetString( const ScAddress& rPos ) const
3166 {
3167 if (!TableExists(rPos.Tab()))
3168 return EMPTY_OUSTRING;
3169
3170 OUString aStr;
3171 maTabs[rPos.Tab()]->GetString(rPos.Col(), rPos.Row(), aStr);
3172 return aStr;
3173 }
3174
3175 const OUString* ScDocument::GetStringCell( const ScAddress& rPos ) const
3176 {
3177 if (!TableExists(rPos.Tab()))
3178 return NULL;
3179
3180 return maTabs[rPos.Tab()]->GetStringCell(rPos.Col(), rPos.Row());
3181 }
3182
3183 double* ScDocument::GetValueCell( const ScAddress& rPos )
3184 {
3185 if (!TableExists(rPos.Tab()))
3186 return NULL;
3187
3188 return maTabs[rPos.Tab()]->GetValueCell(rPos.Col(), rPos.Row());
3189 }
3190
3191 void ScDocument::GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, OUString& rString )
3192 {
3193 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3194 maTabs[nTab]->GetInputString( nCol, nRow, rString );
3195 else
3196 rString = OUString();
3197 }
3198
3199 void ScDocument::GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rString )
3200 {
3201 OUString aString;
3202 GetInputString( nCol, nRow, nTab, aString);
3203 rString = aString;
3204 }
3205
3206 sal_uInt16 ScDocument::GetStringForFormula( const ScAddress& rPos, OUString& rString )
3207 {
3208 // Used in formulas (add-in parameters etc), so it must use the same semantics as
3209 // ScInterpreter::GetCellString: always format values as numbers.
3210 // The return value is the error code.
3211
3212 ScRefCellValue aCell;
3213 aCell.assign(*this, rPos);
3214 if (aCell.isEmpty())
3215 {
3216 rString = EMPTY_OUSTRING;
3217 return 0;
3218 }
3219
3220 sal_uInt16 nErr = 0;
3221 OUString aStr;
3222 SvNumberFormatter* pFormatter = GetFormatTable();
3223 switch (aCell.meType)
3224 {
3225 case CELLTYPE_STRING:
3226 case CELLTYPE_EDIT:
3227 aStr = aCell.getString(this);
3228 break;
3229 case CELLTYPE_FORMULA:
3230 {
3231 ScFormulaCell* pFCell = aCell.mpFormula;
3232 nErr = pFCell->GetErrCode();
3233 if (pFCell->IsValue())
3234 {
3235 double fVal = pFCell->GetValue();
3236 sal_uInt32 nIndex = pFormatter->GetStandardFormat(
3237 NUMBERFORMAT_NUMBER,
3238 ScGlobal::eLnge);
3239 pFormatter->GetInputLineString(fVal, nIndex, aStr);
3240 }
3241 else
3242 aStr = pFCell->GetString();
3243 }
3244 break;
3245 case CELLTYPE_VALUE:
3246 {
3247 double fVal = aCell.mfValue;
3248 sal_uInt32 nIndex = pFormatter->GetStandardFormat(
3249 NUMBERFORMAT_NUMBER,
3250 ScGlobal::eLnge);
3251 pFormatter->GetInputLineString(fVal, nIndex, aStr);
3252 }
3253 break;
3254 default:
3255 ;
3256 }
3257
3258 rString = aStr;
3259 return nErr;
3260 }
3261
3262
3263 void ScDocument::GetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, double& rValue ) const
3264 {
3265 if (TableExists(nTab))
3266 rValue = maTabs[nTab]->GetValue( nCol, nRow );
3267 else
3268 rValue = 0.0;
3269 }
3270
3271 const EditTextObject* ScDocument::GetEditText( const ScAddress& rPos ) const
3272 {
3273 SCTAB nTab = rPos.Tab();
3274 if (!TableExists(nTab))
3275 return NULL;
3276
3277 return maTabs[nTab]->GetEditText(rPos.Col(), rPos.Row());
3278 }
3279
3280 void ScDocument::RemoveEditTextCharAttribs( const ScAddress& rPos, const ScPatternAttr& rAttr )
3281 {
3282 if (!TableExists(rPos.Tab()))
3283 return;
3284
3285 return maTabs[rPos.Tab()]->RemoveEditTextCharAttribs(rPos.Col(), rPos.Row(), rAttr);
3286 }
3287
3288 double ScDocument::GetValue( const ScAddress& rPos ) const
3289 {
3290 SCTAB nTab = rPos.Tab();
3291 if ( nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3292 return maTabs[nTab]->GetValue(rPos.Col(), rPos.Row());
3293 return 0.0;
3294 }
3295
3296
3297 void ScDocument::GetNumberFormat( SCCOL nCol, SCROW nRow, SCTAB nTab,
3298 sal_uInt32& rFormat ) const
3299 {
3300 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
3301 if (maTabs[nTab])
3302 {
3303 rFormat = maTabs[nTab]->GetNumberFormat( nCol, nRow );
3304 return ;
3305 }
3306 rFormat = 0;
3307 }
3308
3309 sal_uInt32 ScDocument::GetNumberFormat( const ScRange& rRange ) const
3310 {
3311 SCTAB nTab1 = rRange.aStart.Tab(), nTab2 = rRange.aEnd.Tab();
3312 SCCOL nCol1 = rRange.aStart.Col(), nCol2 = rRange.aEnd.Col();
3313 SCROW nRow1 = rRange.aStart.Row(), nRow2 = rRange.aEnd.Row();
3314
3315 if (!ValidTab(nTab1) || !ValidTab(nTab2) || !maTabs[nTab1] || !maTabs[nTab2])
3316 return 0;
3317
3318 sal_uInt32 nFormat = 0;
3319 bool bFirstItem = true;
3320 for (SCTAB nTab = nTab1; nTab <= nTab2 && nTab < static_cast<SCTAB>(maTabs.size()) ; ++nTab)
3321 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
3322 {
3323 sal_uInt32 nThisFormat = maTabs[nTab]->GetNumberFormat(nCol, nRow1, nRow2);
3324 if (bFirstItem)
3325 {
3326 nFormat = nThisFormat;
3327 bFirstItem = false;
3328 }
3329 else if (nThisFormat != nFormat)
3330 return 0;
3331 }
3332
3333 return nFormat;
3334 }
3335
3336 sal_uInt32 ScDocument::GetNumberFormat( const ScAddress& rPos ) const
3337 {
3338 SCTAB nTab = rPos.Tab();
3339 if ( maTabs[nTab] )
3340 return maTabs[nTab]->GetNumberFormat( rPos );
3341 return 0;
3342 }
3343
3344 void ScDocument::SetNumberFormat( const ScAddress& rPos, sal_uInt32 nNumberFormat )
3345 {
3346 if (!TableExists(rPos.Tab()))
3347 return;
3348
3349 maTabs[rPos.Tab()]->SetNumberFormat(rPos.Col(), rPos.Row(), nNumberFormat);
3350 }
3351
3352 void ScDocument::GetNumberFormatInfo( short& nType, sal_uLong& nIndex,
3353 const ScAddress& rPos ) const
3354 {
3355 SCTAB nTab = rPos.Tab();
3356 if ( nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3357 {
3358 nIndex = maTabs[nTab]->GetNumberFormat( rPos );
3359 nType = GetFormatTable()->GetType( nIndex );
3360 }
3361 else
3362 {
3363 nType = NUMBERFORMAT_UNDEFINED;
3364 nIndex = 0;
3365 }
3366 }
3367
3368
3369 void ScDocument::GetFormula( SCCOL nCol, SCROW nRow, SCTAB nTab, OUString& rFormula ) const
3370 {
3371 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3372 maTabs[nTab]->GetFormula( nCol, nRow, rFormula );
3373 else
3374 rFormula = OUString();
3375 }
3376
3377
3378 void ScDocument::GetFormula( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rFormula ) const
3379 {
3380 OUString aString;
3381 GetFormula( nCol, nRow, nTab, aString);
3382 rFormula = aString;
3383 }
3384
3385 const ScTokenArray* ScDocument::GetFormulaTokens( const ScAddress& rPos ) const
3386 {
3387 if (!TableExists(rPos.Tab()))
3388 return NULL;
3389
3390 return maTabs[rPos.Tab()]->GetFormulaTokens(rPos.Col(), rPos.Row());
3391 }
3392
3393 const ScFormulaCell* ScDocument::GetFormulaCell( const ScAddress& rPos ) const
3394 {
3395 if (!TableExists(rPos.Tab()))
3396 return NULL;
3397
3398 return maTabs[rPos.Tab()]->GetFormulaCell(rPos.Col(), rPos.Row());
3399 }
3400
3401 ScFormulaCell* ScDocument::GetFormulaCell( const ScAddress& rPos )
3402 {
3403 if (!TableExists(rPos.Tab()))
3404 return NULL;
3405
3406 return maTabs[rPos.Tab()]->GetFormulaCell(rPos.Col(), rPos.Row());
3407 }
3408
3409 CellType ScDocument::GetCellType( const ScAddress& rPos ) const
3410 {
3411 SCTAB nTab = rPos.Tab();
3412 if ( nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3413 return maTabs[nTab]->GetCellType( rPos );
3414 return CELLTYPE_NONE;
3415 }
3416
3417
3418 void ScDocument::GetCellType( SCCOL nCol, SCROW nRow, SCTAB nTab,
3419 CellType& rCellType ) const
3420 {
3421 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
3422 rCellType = maTabs[nTab]->GetCellType( nCol, nRow );
3423 else
3424 rCellType = CELLTYPE_NONE;
3425 }
3426
3427 bool ScDocument::HasStringData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
3428 {
3429 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3430 return maTabs[nTab]->HasStringData( nCol, nRow );
3431 else
3432 return false;
3433 }
3434
3435
3436 bool ScDocument::HasValueData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
3437 {
3438 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3439 return maTabs[nTab]->HasValueData( nCol, nRow );
3440 else
3441 return false;
3442 }
3443
3444 bool ScDocument::HasValueData( const ScAddress& rPos ) const
3445 {
3446 return HasValueData(rPos.Col(), rPos.Row(), rPos.Tab());
3447 }
3448
3449 bool ScDocument::HasStringCells( const ScRange& rRange ) const
3450 {
3451 // true, wenn String- oder Editzellen im Bereich
3452
3453 SCCOL nStartCol = rRange.aStart.Col();
3454 SCROW nStartRow = rRange.aStart.Row();
3455 SCTAB nStartTab = rRange.aStart.Tab();
3456 SCCOL nEndCol = rRange.aEnd.Col();
3457 SCROW nEndRow = rRange.aEnd.Row();
3458 SCTAB nEndTab = rRange.aEnd.Tab();
3459
3460 for ( SCTAB nTab=nStartTab; nTab<=nEndTab && nTab < static_cast<SCTAB>(maTabs.size()); nTab++ )
3461 if ( maTabs[nTab] && maTabs[nTab]->HasStringCells( nStartCol, nStartRow, nEndCol, nEndRow ) )
3462 return true;
3463
3464 return false;
3465 }
3466
3467
3468 bool ScDocument::HasSelectionData( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
3469 {
3470 sal_uInt32 nValidation = static_cast< const SfxUInt32Item* >( GetAttr( nCol, nRow, nTab, ATTR_VALIDDATA ) )->GetValue();
3471 if( nValidation )
3472 {
3473 const ScValidationData* pData = GetValidationEntry( nValidation );
3474 if( pData && pData->HasSelectionList() )
3475 return true;
3476 }
3477 return HasStringCells( ScRange( nCol, 0, nTab, nCol, MAXROW, nTab ) );
3478 }
3479
3480
3481 void ScDocument::InitializeNoteCaptions( SCTAB nTab, bool bForced )
3482 {
3483 if( ValidTab( nTab ) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[ nTab ] )
3484 maTabs[ nTab ]->InitializeNoteCaptions( bForced );
3485 }
3486
3487 void ScDocument::SetDirty()
3488 {
3489 bool bOldAutoCalc = GetAutoCalc();
3490 bAutoCalc = false; // keine Mehrfachberechnung
3491 { // scope for bulk broadcast
3492 ScBulkBroadcast aBulkBroadcast( GetBASM());
3493 TableContainer::iterator it = maTabs.begin();
3494 for (;it != maTabs.end(); ++it)
3495 if (*it)
3496 (*it)->SetDirty();
3497 }
3498
3499 // Charts werden zwar auch ohne AutoCalc im Tracking auf Dirty gesetzt,
3500 // wenn alle Formeln dirty sind, werden die Charts aber nicht mehr erwischt
3501 // (#45205#) - darum alle Charts nochmal explizit
3502 if (pChartListenerCollection)
3503 pChartListenerCollection->SetDirty();
3504
3505 SetAutoCalc( bOldAutoCalc );
3506 }
3507
3508
3509 void ScDocument::SetDirty( const ScRange& rRange )
3510 {
3511 bool bOldAutoCalc = GetAutoCalc();
3512 bAutoCalc = false; // keine Mehrfachberechnung
3513 { // scope for bulk broadcast
3514 ScBulkBroadcast aBulkBroadcast( GetBASM());
3515 SCTAB nTab2 = rRange.aEnd.Tab();
3516 for (SCTAB i=rRange.aStart.Tab(); i<=nTab2 && i < static_cast<SCTAB>(maTabs.size()); i++)
3517 if (maTabs[i]) maTabs[i]->SetDirty( rRange );
3518 }
3519 SetAutoCalc( bOldAutoCalc );
3520 }
3521
3522
3523 void ScDocument::SetTableOpDirty( const ScRange& rRange )
3524 {
3525 bool bOldAutoCalc = GetAutoCalc();
3526 bAutoCalc = false; // no multiple recalculation
3527 SCTAB nTab2 = rRange.aEnd.Tab();
3528 for (SCTAB i=rRange.aStart.Tab(); i<=nTab2 && i < static_cast<SCTAB>(maTabs.size()); i++)
3529 if (maTabs[i]) maTabs[i]->SetTableOpDirty( rRange );
3530 SetAutoCalc( bOldAutoCalc );
3531 }
3532
3533
3534 void ScDocument::InterpretDirtyCells( const ScRangeList& rRanges )
3535 {
3536 for (size_t nPos=0, nRangeCount = rRanges.size(); nPos < nRangeCount; nPos++)
3537 {
3538 ScCellIterator aIter( this, *rRanges[ nPos ] );
3539 for (bool bHas = aIter.first(); bHas; bHas = aIter.next())
3540 {
3541 if (aIter.getType() != CELLTYPE_FORMULA)
3542 continue;
3543
3544 ScFormulaCell* p = aIter.getFormulaCell();
3545 if (p->GetDirty() && GetAutoCalc())
3546 p->Interpret();
3547 }
3548 }
3549 }
3550
3551
3552 void ScDocument::AddTableOpFormulaCell( ScFormulaCell* pCell )
3553 {
3554 if ( !aTableOpList.empty() )
3555 {
3556 ScInterpreterTableOpParams* p = &aTableOpList.back();
3557 if ( p->bCollectNotifications )
3558 {
3559 if ( p->bRefresh )
3560 { // refresh pointers only
3561 p->aNotifiedFormulaCells.push_back( pCell );
3562 }
3563 else
3564 { // init both, address and pointer
3565 p->aNotifiedFormulaCells.push_back( pCell );
3566 p->aNotifiedFormulaPos.push_back( pCell->aPos );
3567 }
3568 }
3569 }
3570 }
3571
3572
3573 void ScDocument::CalcAll()
3574 {
3575 ClearLookupCaches(); // Ensure we don't deliver zombie data.
3576 bool bOldAutoCalc = GetAutoCalc();
3577 SetAutoCalc( true );
3578 TableContainer::iterator it = maTabs.begin();
3579 for (; it != maTabs.end(); ++it)
3580 if (*it)
3581 (*it)->SetDirtyVar();
3582 for (it = maTabs.begin(); it != maTabs.end(); ++it)
3583 if (*it)
3584 (*it)->CalcAll();
3585 ClearFormulaTree();
3586 SetAutoCalc( bOldAutoCalc );
3587 }
3588
3589
3590 void ScDocument::CompileAll()
3591 {
3592 TableContainer::iterator it = maTabs.begin();
3593 for (; it != maTabs.end(); ++it)
3594 if (*it)
3595 (*it)->CompileAll();
3596 SetDirty();
3597 }
3598
3599
3600 void ScDocument::CompileXML()
3601 {
3602 bool bOldAutoCalc = GetAutoCalc();
3603 SetAutoCalc( false );
3604 ScProgress aProgress( GetDocumentShell(), ScGlobal::GetRscString(
3605 STR_PROGRESS_CALCULATING ), GetXMLImportedFormulaCount() );
3606
3607 // set AutoNameCache to speed up automatic name lookup
3608 OSL_ENSURE( !pAutoNameCache, "AutoNameCache already set" );
3609 pAutoNameCache = new ScAutoNameCache( this );
3610
3611 if (pRangeName)
3612 pRangeName->CompileUnresolvedXML();
3613
3614 TableContainer::iterator it = maTabs.begin();
3615 for (; it != maTabs.end(); ++it)
3616 if (*it)
3617 (*it)->CompileXML( aProgress );
3618
3619 DELETEZ( pAutoNameCache ); // valid only during CompileXML, where cell contents don't change
3620
3621 if ( pValidationList )
3622 pValidationList->CompileXML();
3623
3624 SetAutoCalc( bOldAutoCalc );
3625 }
3626
3627 bool ScDocument::CompileErrorCells(sal_uInt16 nErrCode)
3628 {
3629 bool bCompiled = false;
3630 TableContainer::iterator it = maTabs.begin(), itEnd = maTabs.end();
3631 for (; it != itEnd; ++it)
3632 {
3633 ScTable* pTab = *it;
3634 if (!pTab)
3635 continue;
3636
3637 if (pTab->CompileErrorCells(nErrCode))
3638 bCompiled = true;
3639 }
3640
3641 return bCompiled;
3642 }
3643
3644 void ScDocument::CalcAfterLoad()
3645 {
3646 if (bIsClip) // Excel-Dateien werden aus dem Clipboard in ein Clip-Doc geladen
3647 return; // dann wird erst beim Einfuegen in das richtige Doc berechnet
3648
3649 bCalcingAfterLoad = true;
3650 {
3651 TableContainer::iterator it = maTabs.begin();
3652 for (; it != maTabs.end(); ++it)
3653 if (*it)
3654 (*it)->CalcAfterLoad();
3655 for (it = maTabs.begin(); it != maTabs.end(); ++it)
3656 if (*it)
3657 (*it)->SetDirtyAfterLoad();
3658 }
3659 bCalcingAfterLoad = false;
3660
3661 SetDetectiveDirty(false); // noch keine wirklichen Aenderungen
3662
3663 // #i112436# If formula cells are already dirty, they don't broadcast further changes.
3664 // So the source ranges of charts must be interpreted even if they are not visible,
3665 // similar to ScMyShapeResizer::CreateChartListener for loading own files (i104899).
3666 if (pChartListenerCollection)
3667 {
3668 const ScChartListenerCollection::ListenersType& rListeners = pChartListenerCollection->getListeners();
3669 ScChartListenerCollection::ListenersType::const_iterator it = rListeners.begin(), itEnd = rListeners.end();
3670 for (; it != itEnd; ++it)
3671 {
3672 const ScChartListener* p = it->second;
3673 InterpretDirtyCells(*p->GetRangeList());
3674 }
3675 }
3676 }
3677
3678
3679 sal_uInt16 ScDocument::GetErrCode( const ScAddress& rPos ) const
3680 {
3681 SCTAB nTab = rPos.Tab();
3682 if ( nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3683 return maTabs[nTab]->GetErrCode( rPos );
3684 return 0;
3685 }
3686
3687
3688 void ScDocument::ResetChanged( const ScRange& rRange )
3689 {
3690 SCTAB nTabSize = static_cast<SCTAB>(maTabs.size());
3691 SCTAB nTab1 = rRange.aStart.Tab();
3692 SCTAB nTab2 = rRange.aEnd.Tab();
3693 for (SCTAB nTab = nTab1; nTab1 <= nTab2 && nTab < nTabSize; ++nTab)
3694 if (maTabs[nTab])
3695 maTabs[nTab]->ResetChanged(rRange);
3696 }
3697
3698 //
3699 // Spaltenbreiten / Zeilenhoehen --------------------------------------
3700 //
3701
3702
3703 void ScDocument::SetColWidth( SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth )
3704 {
3705 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3706 maTabs[nTab]->SetColWidth( nCol, nNewWidth );
3707 }
3708
3709 void ScDocument::SetColWidthOnly( SCCOL nCol, SCTAB nTab, sal_uInt16 nNewWidth )
3710 {
3711 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3712 maTabs[nTab]->SetColWidthOnly( nCol, nNewWidth );
3713 }
3714
3715 void ScDocument::SetRowHeight( SCROW nRow, SCTAB nTab, sal_uInt16 nNewHeight )
3716 {
3717 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3718 maTabs[nTab]->SetRowHeight( nRow, nNewHeight );
3719 }
3720
3721
3722 void ScDocument::SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nNewHeight )
3723 {
3724 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3725 maTabs[nTab]->SetRowHeightRange
3726 ( nStartRow, nEndRow, nNewHeight, 1.0, 1.0 );
3727 }
3728
3729 void ScDocument::SetRowHeightOnly( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nNewHeight )
3730 {
3731 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3732 maTabs[nTab]->SetRowHeightOnly( nStartRow, nEndRow, nNewHeight );
3733 }
3734
3735 void ScDocument::SetManualHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bManual )
3736 {
3737 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3738 maTabs[nTab]->SetManualHeight( nStartRow, nEndRow, bManual );
3739 }
3740
3741
3742 sal_uInt16 ScDocument::GetColWidth( SCCOL nCol, SCTAB nTab, bool bHiddenAsZero ) const
3743 {
3744 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3745 return maTabs[nTab]->GetColWidth( nCol, bHiddenAsZero );
3746 OSL_FAIL("wrong table number");
3747 return 0;
3748 }
3749
3750
3751 sal_uInt16 ScDocument::GetOriginalWidth( SCCOL nCol, SCTAB nTab ) const
3752 {
3753 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3754 return maTabs[nTab]->GetOriginalWidth( nCol );
3755 OSL_FAIL("wrong table number");
3756 return 0;
3757 }
3758
3759
3760 sal_uInt16 ScDocument::GetCommonWidth( SCCOL nEndCol, SCTAB nTab ) const
3761 {
3762 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3763 return maTabs[nTab]->GetCommonWidth( nEndCol );
3764 OSL_FAIL("Wrong table number");
3765 return 0;
3766 }
3767
3768
3769 sal_uInt16 ScDocument::GetOriginalHeight( SCROW nRow, SCTAB nTab ) const
3770 {
3771 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3772 return maTabs[nTab]->GetOriginalHeight( nRow );
3773 OSL_FAIL("Wrong table number");
3774 return 0;
3775 }
3776
3777
3778 sal_uInt16 ScDocument::GetRowHeight( SCROW nRow, SCTAB nTab, bool bHiddenAsZero ) const
3779 {
3780 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3781 return maTabs[nTab]->GetRowHeight( nRow, NULL, NULL, bHiddenAsZero );
3782 OSL_FAIL("Wrong sheet number");
3783 return 0;
3784 }
3785
3786
3787 sal_uInt16 ScDocument::GetRowHeight( SCROW nRow, SCTAB nTab, SCROW* pStartRow, SCROW* pEndRow, bool bHiddenAsZero ) const
3788 {
3789 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3790 return maTabs[nTab]->GetRowHeight( nRow, pStartRow, pEndRow, bHiddenAsZero );
3791 OSL_FAIL("Wrong sheet number");
3792 return 0;
3793 }
3794
3795
3796 sal_uLong ScDocument::GetRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bHiddenAsZero ) const
3797 {
3798 if (nStartRow == nEndRow)
3799 return GetRowHeight( nStartRow, nTab, bHiddenAsZero ); // faster for a single row
3800
3801 // check bounds because this method replaces former for(i=start;i<=end;++i) loops
3802 if (nStartRow > nEndRow)
3803 return 0;
3804
3805 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3806 return maTabs[nTab]->GetRowHeight( nStartRow, nEndRow, bHiddenAsZero );
3807
3808 OSL_FAIL("wrong sheet number");
3809 return 0;
3810 }
3811
3812 SCROW ScDocument::GetRowForHeight( SCTAB nTab, sal_uLong nHeight ) const
3813 {
3814 return maTabs[nTab]->GetRowForHeight(nHeight);
3815 }
3816
3817 sal_uLong ScDocument::GetScaledRowHeight( SCROW nStartRow, SCROW nEndRow,
3818 SCTAB nTab, double fScale ) const
3819 {
3820 // faster for a single row
3821 if (nStartRow == nEndRow)
3822 return (sal_uLong) (GetRowHeight( nStartRow, nTab) * fScale);
3823
3824 // check bounds because this method replaces former for(i=start;i<=end;++i) loops
3825 if (nStartRow > nEndRow)
3826 return 0;
3827
3828 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3829 return maTabs[nTab]->GetScaledRowHeight( nStartRow, nEndRow, fScale);
3830
3831 OSL_FAIL("wrong sheet number");
3832 return 0;
3833 }
3834
3835 SCROW ScDocument::GetHiddenRowCount( SCROW nRow, SCTAB nTab ) const
3836 {
3837 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3838 return maTabs[nTab]->GetHiddenRowCount( nRow );
3839 OSL_FAIL("wrong table number");
3840 return 0;
3841 }
3842
3843
3844 sal_uLong ScDocument::GetColOffset( SCCOL nCol, SCTAB nTab, bool bHiddenAsZero ) const
3845 {
3846 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3847 return maTabs[nTab]->GetColOffset( nCol, bHiddenAsZero );
3848 OSL_FAIL("wrong table number");
3849 return 0;
3850 }
3851
3852
3853 sal_uLong ScDocument::GetRowOffset( SCROW nRow, SCTAB nTab, bool bHiddenAsZero ) const
3854 {
3855 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3856 return maTabs[nTab]->GetRowOffset( nRow, bHiddenAsZero );
3857 OSL_FAIL("wrong table number");
3858 return 0;
3859 }
3860
3861
3862 sal_uInt16 ScDocument::GetOptimalColWidth( SCCOL nCol, SCTAB nTab, OutputDevice* pDev,
3863 double nPPTX, double nPPTY,
3864 const Fraction& rZoomX, const Fraction& rZoomY,
3865 bool bFormula, const ScMarkData* pMarkData,
3866 const ScColWidthParam* pParam )
3867 {
3868 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3869 return maTabs[nTab]->GetOptimalColWidth( nCol, pDev, nPPTX, nPPTY,
3870 rZoomX, rZoomY, bFormula, pMarkData, pParam );
3871 OSL_FAIL("wrong table number");
3872 return 0;
3873 }
3874
3875
3876 long ScDocument::GetNeededSize( SCCOL nCol, SCROW nRow, SCTAB nTab,
3877 OutputDevice* pDev,
3878 double nPPTX, double nPPTY,
3879 const Fraction& rZoomX, const Fraction& rZoomY,
3880 bool bWidth, bool bTotalSize )
3881 {
3882 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3883 return maTabs[nTab]->GetNeededSize
3884 ( nCol, nRow, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bWidth, bTotalSize );
3885 OSL_FAIL("wrong table number");
3886 return 0;
3887 }
3888
3889
3890 bool ScDocument::SetOptimalHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt16 nExtra,
3891 OutputDevice* pDev,
3892 double nPPTX, double nPPTY,
3893 const Fraction& rZoomX, const Fraction& rZoomY,
3894 bool bShrink )
3895 {
3896 //! MarkToMulti();
3897 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3898 return maTabs[nTab]->SetOptimalHeight( nStartRow, nEndRow, nExtra,
3899 pDev, nPPTX, nPPTY, rZoomX, rZoomY, bShrink );
3900 OSL_FAIL("wrong table number");
3901 return false;
3902 }
3903
3904
3905 void ScDocument::UpdateAllRowHeights( OutputDevice* pDev, double nPPTX, double nPPTY,
3906 const Fraction& rZoomX, const Fraction& rZoomY, const ScMarkData* pTabMark )
3907 {
3908 // one progress across all (selected) sheets
3909
3910 sal_uLong nCellCount = 0;
3911 for ( SCTAB nTab=0; nTab< static_cast<SCTAB>(maTabs.size()); nTab++ )
3912 if ( maTabs[nTab] && ( !pTabMark || pTabMark->GetTableSelect(nTab) ) )
3913 nCellCount += maTabs[nTab]->GetWeightedCount();
3914
3915 ScProgress aProgress( GetDocumentShell(), ScGlobal::GetRscString(STR_PROGRESS_HEIGHTING), nCellCount );
3916
3917 sal_uLong nProgressStart = 0;
3918 for ( SCTAB nTab=0; nTab< static_cast<SCTAB>(maTabs.size()); nTab++ )
3919 if ( maTabs[nTab] && ( !pTabMark || pTabMark->GetTableSelect(nTab) ) )
3920 {
3921 maTabs[nTab]->SetOptimalHeightOnly( 0, MAXROW, 0,
3922 pDev, nPPTX, nPPTY, rZoomX, rZoomY, false, &aProgress, nProgressStart );
3923 maTabs[nTab]->SetDrawPageSize(true, true);
3924 nProgressStart += maTabs[nTab]->GetWeightedCount();
3925 }
3926 }
3927
3928
3929 //
3930 // Spalten-/Zeilen-Flags ----------------------------------------------
3931 //
3932
3933 void ScDocument::ShowCol(SCCOL nCol, SCTAB nTab, bool bShow)
3934 {
3935 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3936 maTabs[nTab]->ShowCol( nCol, bShow );
3937 }
3938
3939
3940 void ScDocument::ShowRow(SCROW nRow, SCTAB nTab, bool bShow)
3941 {
3942 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3943 maTabs[nTab]->ShowRow( nRow, bShow );
3944 }
3945
3946
3947 void ScDocument::ShowRows(SCROW nRow1, SCROW nRow2, SCTAB nTab, bool bShow)
3948 {
3949 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3950 maTabs[nTab]->ShowRows( nRow1, nRow2, bShow );
3951 }
3952
3953
3954 void ScDocument::SetRowFlags( SCROW nRow, SCTAB nTab, sal_uInt8 nNewFlags )
3955 {
3956 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3957 maTabs[nTab]->SetRowFlags( nRow, nNewFlags );
3958 }
3959
3960
3961 void ScDocument::SetRowFlags( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, sal_uInt8 nNewFlags )
3962 {
3963 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3964 maTabs[nTab]->SetRowFlags( nStartRow, nEndRow, nNewFlags );
3965 }
3966
3967
3968 sal_uInt8 ScDocument::GetColFlags( SCCOL nCol, SCTAB nTab ) const
3969 {
3970 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3971 return maTabs[nTab]->GetColFlags( nCol );
3972 OSL_FAIL("wrong table number");
3973 return 0;
3974 }
3975
3976 sal_uInt8 ScDocument::GetRowFlags( SCROW nRow, SCTAB nTab ) const
3977 {
3978 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3979 return maTabs[nTab]->GetRowFlags( nRow );
3980 OSL_FAIL("wrong table number");
3981 return 0;
3982 }
3983
3984 const ScBitMaskCompressedArray< SCROW, sal_uInt8> & ScDocument::GetRowFlagsArray(
3985 SCTAB nTab ) const
3986 {
3987 const ScBitMaskCompressedArray< SCROW, sal_uInt8> * pFlags;
3988 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
3989 pFlags = maTabs[nTab]->GetRowFlagsArray();
3990 else
3991 {
3992 OSL_FAIL("wrong sheet number");
3993 pFlags = 0;
3994 }
3995 if (!pFlags)
3996 {
3997 OSL_FAIL("no row flags at sheet");
3998 static ScBitMaskCompressedArray< SCROW, sal_uInt8> aDummy( MAXROW, 0);
3999 pFlags = &aDummy;
4000 }
4001 return *pFlags;
4002 }
4003
4004 void ScDocument::GetAllRowBreaks(set<SCROW>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const
4005 {
4006 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4007 return;
4008 maTabs[nTab]->GetAllRowBreaks(rBreaks, bPage, bManual);
4009 }
4010
4011 void ScDocument::GetAllColBreaks(set<SCCOL>& rBreaks, SCTAB nTab, bool bPage, bool bManual) const
4012 {
4013 if (!ValidTab(nTab) || !maTabs[nTab])
4014 return;
4015
4016 maTabs[nTab]->GetAllColBreaks(rBreaks, bPage, bManual);
4017 }
4018
4019 ScBreakType ScDocument::HasRowBreak(SCROW nRow, SCTAB nTab) const
4020 {
4021 ScBreakType nType = BREAK_NONE;
4022 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab] || !ValidRow(nRow))
4023 return nType;
4024
4025 if (maTabs[nTab]->HasRowPageBreak(nRow))
4026 nType |= BREAK_PAGE;
4027
4028 if (maTabs[nTab]->HasRowManualBreak(nRow))
4029 nType |= BREAK_MANUAL;
4030
4031 return nType;
4032 }
4033
4034 ScBreakType ScDocument::HasColBreak(SCCOL nCol, SCTAB nTab) const
4035 {
4036 ScBreakType nType = BREAK_NONE;
4037 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab] || !ValidCol(nCol))
4038 return nType;
4039
4040 if (maTabs[nTab]->HasColPageBreak(nCol))
4041 nType |= BREAK_PAGE;
4042
4043 if (maTabs[nTab]->HasColManualBreak(nCol))
4044 nType |= BREAK_MANUAL;
4045
4046 return nType;
4047 }
4048
4049 void ScDocument::SetRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual)
4050 {
4051 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab] || !ValidRow(nRow))
4052 return;
4053
4054 maTabs[nTab]->SetRowBreak(nRow, bPage, bManual);
4055 }
4056
4057 void ScDocument::SetColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual)
4058 {
4059 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab] || !ValidCol(nCol))
4060 return;
4061
4062 maTabs[nTab]->SetColBreak(nCol, bPage, bManual);
4063 }
4064
4065 void ScDocument::RemoveRowBreak(SCROW nRow, SCTAB nTab, bool bPage, bool bManual)
4066 {
4067 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab] || !ValidRow(nRow))
4068 return;
4069
4070 maTabs[nTab]->RemoveRowBreak(nRow, bPage, bManual);
4071 }
4072
4073 void ScDocument::RemoveColBreak(SCCOL nCol, SCTAB nTab, bool bPage, bool bManual)
4074 {
4075 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab] || !ValidCol(nCol))
4076 return;
4077
4078 maTabs[nTab]->RemoveColBreak(nCol, bPage, bManual);
4079 }
4080
4081 Sequence<TablePageBreakData> ScDocument::GetRowBreakData(SCTAB nTab) const
4082 {
4083 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4084 return Sequence<TablePageBreakData>();
4085
4086 return maTabs[nTab]->GetRowBreakData();
4087 }
4088
4089 bool ScDocument::RowHidden(SCROW nRow, SCTAB nTab, SCROW* pFirstRow, SCROW* pLastRow) const
4090 {
4091 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4092 return false;
4093
4094 return maTabs[nTab]->RowHidden(nRow, pFirstRow, pLastRow);
4095 }
4096
4097 bool ScDocument::HasHiddenRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4098 {
4099 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4100 return false;
4101
4102 return maTabs[nTab]->HasHiddenRows(nStartRow, nEndRow);
4103 }
4104
4105 bool ScDocument::ColHidden(SCCOL nCol, SCTAB nTab, SCCOL* pFirstCol, SCCOL* pLastCol) const
4106 {
4107 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4108 {
4109 if (pFirstCol)
4110 *pFirstCol = nCol;
4111 if (pLastCol)
4112 *pLastCol = nCol;
4113 return false;
4114 }
4115
4116 return maTabs[nTab]->ColHidden(nCol, pFirstCol, pLastCol);
4117 }
4118
4119 void ScDocument::SetRowHidden(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bHidden)
4120 {
4121 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4122 return;
4123
4124 maTabs[nTab]->SetRowHidden(nStartRow, nEndRow, bHidden);
4125 }
4126
4127 void ScDocument::SetColHidden(SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bHidden)
4128 {
4129 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4130 return;
4131
4132 maTabs[nTab]->SetColHidden(nStartCol, nEndCol, bHidden);
4133 }
4134
4135 SCROW ScDocument::FirstVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4136 {
4137 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4138 return ::std::numeric_limits<SCROW>::max();;
4139
4140 return maTabs[nTab]->FirstVisibleRow(nStartRow, nEndRow);
4141 }
4142
4143 SCROW ScDocument::LastVisibleRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4144 {
4145 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4146 return ::std::numeric_limits<SCROW>::max();;
4147
4148 return maTabs[nTab]->LastVisibleRow(nStartRow, nEndRow);
4149 }
4150
4151 SCROW ScDocument::CountVisibleRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4152 {
4153 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4154 return 0;
4155
4156 return maTabs[nTab]->CountVisibleRows(nStartRow, nEndRow);
4157 }
4158
4159 bool ScDocument::RowFiltered(SCROW nRow, SCTAB nTab, SCROW* pFirstRow, SCROW* pLastRow) const
4160 {
4161 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4162 return false;
4163
4164 return maTabs[nTab]->RowFiltered(nRow, pFirstRow, pLastRow);
4165 }
4166
4167 bool ScDocument::HasFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4168 {
4169 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4170 return false;
4171
4172 return maTabs[nTab]->HasFilteredRows(nStartRow, nEndRow);
4173 }
4174
4175 bool ScDocument::ColFiltered(SCCOL nCol, SCTAB nTab, SCCOL* pFirstCol, SCCOL* pLastCol) const
4176 {
4177 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4178 return false;
4179
4180 return maTabs[nTab]->ColFiltered(nCol, pFirstCol, pLastCol);
4181 }
4182
4183 void ScDocument::SetRowFiltered(SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bFiltered)
4184 {
4185 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4186 return;
4187
4188 maTabs[nTab]->SetRowFiltered(nStartRow, nEndRow, bFiltered);
4189 }
4190
4191
4192 SCROW ScDocument::FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4193 {
4194 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4195 return ::std::numeric_limits<SCROW>::max();;
4196
4197 return maTabs[nTab]->FirstNonFilteredRow(nStartRow, nEndRow);
4198 }
4199
4200 SCROW ScDocument::LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4201 {
4202 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4203 return ::std::numeric_limits<SCROW>::max();;
4204
4205 return maTabs[nTab]->LastNonFilteredRow(nStartRow, nEndRow);
4206 }
4207
4208 SCROW ScDocument::CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow, SCTAB nTab) const
4209 {
4210 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4211 return 0;
4212
4213 return maTabs[nTab]->CountNonFilteredRows(nStartRow, nEndRow);
4214 }
4215
4216 bool ScDocument::IsManualRowHeight(SCROW nRow, SCTAB nTab) const
4217 {
4218 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4219 return false;
4220
4221 return maTabs[nTab]->IsManualRowHeight(nRow);
4222 }
4223
4224 void ScDocument::SyncColRowFlags()
4225 {
4226 TableContainer::iterator it = maTabs.begin();
4227 for (; it != maTabs.end(); ++it)
4228 {
4229 if (*it)
4230 (*it)->SyncColRowFlags();
4231 }
4232 }
4233
4234 SCROW ScDocument::GetLastFlaggedRow( SCTAB nTab ) const
4235 {
4236 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4237 return maTabs[nTab]->GetLastFlaggedRow();
4238 return 0;
4239 }
4240
4241
4242 SCCOL ScDocument::GetLastChangedCol( SCTAB nTab ) const
4243 {
4244 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4245 return maTabs[nTab]->GetLastChangedCol();
4246 return 0;
4247 }
4248
4249 SCROW ScDocument::GetLastChangedRow( SCTAB nTab ) const
4250 {
4251 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4252 return maTabs[nTab]->GetLastChangedRow();
4253 return 0;
4254 }
4255
4256
4257 SCCOL ScDocument::GetNextDifferentChangedCol( SCTAB nTab, SCCOL nStart) const
4258 {
4259 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4260 {
4261 sal_uInt8 nStartFlags = maTabs[nTab]->GetColFlags(nStart);
4262 sal_uInt16 nStartWidth = maTabs[nTab]->GetOriginalWidth(nStart);
4263 for (SCCOL nCol = nStart + 1; nCol <= MAXCOL; nCol++)
4264 {
4265 if (((nStartFlags & CR_MANUALBREAK) != (maTabs[nTab]->GetColFlags(nCol) & CR_MANUALBREAK)) ||
4266 (nStartWidth != maTabs[nTab]->GetOriginalWidth(nCol)) ||
4267 ((nStartFlags & CR_HIDDEN) != (maTabs[nTab]->GetColFlags(nCol) & CR_HIDDEN)) )
4268 return nCol;
4269 }
4270 return MAXCOL+1;
4271 }
4272 return 0;
4273 }
4274
4275 SCROW ScDocument::GetNextDifferentChangedRow( SCTAB nTab, SCROW nStart, bool bCareManualSize) const
4276 {
4277 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4278 return 0;
4279
4280 const ScBitMaskCompressedArray<SCROW, sal_uInt8>* pRowFlagsArray = maTabs[nTab]->GetRowFlagsArray();
4281 if (!pRowFlagsArray)
4282 return 0;
4283
4284 if (!maTabs[nTab]->mpRowHeights || !maTabs[nTab]->mpHiddenRows)
4285 return 0;
4286
4287 size_t nIndex; // ignored
4288 SCROW nFlagsEndRow;
4289 SCROW nHiddenEndRow;
4290 SCROW nHeightEndRow;
4291 sal_uInt8 nFlags;
4292 bool bHidden;
4293 sal_uInt16 nHeight;
4294 sal_uInt8 nStartFlags = nFlags = pRowFlagsArray->GetValue( nStart, nIndex, nFlagsEndRow);
4295 bool bStartHidden = bHidden = maTabs[nTab]->RowHidden( nStart, NULL, &nHiddenEndRow);
4296 sal_uInt16 nStartHeight = nHeight = maTabs[nTab]->GetRowHeight( nStart, NULL, &nHeightEndRow, false);
4297 SCROW nRow;
4298 while ((nRow = std::min( nHiddenEndRow, std::min( nFlagsEndRow, nHeightEndRow)) + 1) <= MAXROW)
4299 {
4300 if (nFlagsEndRow < nRow)
4301 nFlags = pRowFlagsArray->GetValue( nRow, nIndex, nFlagsEndRow);
4302 if (nHiddenEndRow < nRow)
4303 bHidden = maTabs[nTab]->RowHidden( nRow, NULL, &nHiddenEndRow);
4304 if (nHeightEndRow < nRow)
4305 nHeight = maTabs[nTab]->GetRowHeight( nRow, NULL, &nHeightEndRow, false);
4306
4307 if (((nStartFlags & CR_MANUALBREAK) != (nFlags & CR_MANUALBREAK)) ||
4308 ((nStartFlags & CR_MANUALSIZE) != (nFlags & CR_MANUALSIZE)) ||
4309 (bStartHidden != bHidden) ||
4310 (bCareManualSize && (nStartFlags & CR_MANUALSIZE) && (nStartHeight != nHeight)) ||
4311 (!bCareManualSize && ((nStartHeight != nHeight))))
4312 return nRow;
4313 }
4314
4315 return MAXROW+1;
4316 }
4317
4318 bool ScDocument::GetColDefault( SCTAB nTab, SCCOL nCol, SCROW nLastRow, SCROW& nDefault)
4319 {
4320 bool bRet(false);
4321 nDefault = 0;
4322 ScDocAttrIterator aDocAttrItr(this, nTab, nCol, 0, nCol, nLastRow);
4323 SCCOL nColumn;
4324 SCROW nStartRow;
4325 SCROW nEndRow;
4326 const ScPatternAttr* pAttr = aDocAttrItr.GetNext(nColumn, nStartRow, nEndRow);
4327 if (nEndRow < nLastRow)
4328 {
4329 ScDefaultAttrSet aSet;
4330 ScDefaultAttrSet::iterator aItr = aSet.end();
4331 while (pAttr)
4332 {
4333 ScDefaultAttr aAttr(pAttr);
4334 aItr = aSet.find(aAttr);
4335 if (aItr == aSet.end())
4336 {
4337 aAttr.nCount = static_cast<SCSIZE>(nEndRow - nStartRow + 1);
4338 aAttr.nFirst = nStartRow;
4339 aSet.insert(aAttr);
4340 }
4341 else
4342 {
4343 aAttr.nCount = aItr->nCount + static_cast<SCSIZE>(nEndRow - nStartRow + 1);
4344 aAttr.nFirst = aItr->nFirst;
4345 aSet.erase(aItr);
4346 aSet.insert(aAttr);
4347 }
4348 pAttr = aDocAttrItr.GetNext(nColumn, nStartRow, nEndRow);
4349 }
4350 ScDefaultAttrSet::iterator aDefaultItr = aSet.begin();
4351 aItr = aDefaultItr;
4352 ++aItr;
4353 while (aItr != aSet.end())
4354 {
4355 // for entries with equal count, use the one with the lowest start row,
4356 // don't use the random order of pointer comparisons
4357 if ( aItr->nCount > aDefaultItr->nCount ||
4358 ( aItr->nCount == aDefaultItr->nCount && aItr->nFirst < aDefaultItr->nFirst ) )
4359 aDefaultItr = aItr;
4360 ++aItr;
4361 }
4362 nDefault = aDefaultItr->nFirst;
4363 bRet = true;
4364 }
4365 else
4366 bRet = true;
4367 return bRet;
4368 }
4369
4370 bool ScDocument::GetRowDefault( SCTAB /* nTab */, SCROW /* nRow */, SCCOL /* nLastCol */, SCCOL& /* nDefault */ )
4371 {
4372 return false;
4373 }
4374
4375 void ScDocument::StripHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab )
4376 {
4377 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4378 maTabs[nTab]->StripHidden( rX1, rY1, rX2, rY2 );
4379 }
4380
4381
4382 void ScDocument::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2, SCTAB nTab )
4383 {
4384 if ( ValidTab(nTab) && maTabs[nTab] )
4385 maTabs[nTab]->ExtendHidden( rX1, rY1, rX2, rY2 );
4386 }
4387
4388 //
4389 // Attribute ----------------------------------------------------------
4390 //
4391
4392 const SfxPoolItem* ScDocument::GetAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nWhich ) const
4393 {
4394 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4395 {
4396 const SfxPoolItem* pTemp = maTabs[nTab]->GetAttr( nCol, nRow, nWhich );
4397 if (pTemp)
4398 return pTemp;
4399 else
4400 {
4401 OSL_FAIL( "Attribut Null" );
4402 }
4403 }
4404 return &xPoolHelper->GetDocPool()->GetDefaultItem( nWhich );
4405 }
4406
4407 const SfxPoolItem* ScDocument::GetAttr( const ScAddress& rPos, sal_uInt16 nWhich ) const
4408 {
4409 return GetAttr(rPos.Col(), rPos.Row(), rPos.Tab(), nWhich);
4410 }
4411
4412 const ScPatternAttr* ScDocument::GetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
4413 {
4414 if (TableExists(nTab))
4415 return maTabs[nTab]->GetPattern( nCol, nRow );
4416 return NULL;
4417 }
4418
4419 const ScPatternAttr* ScDocument::GetPattern( const ScAddress& rPos ) const
4420 {
4421 if (TableExists(rPos.Tab()))
4422 return maTabs[rPos.Tab()]->GetPattern(rPos.Col(), rPos.Row());
4423
4424 return NULL;
4425 }
4426
4427 const ScPatternAttr* ScDocument::GetMostUsedPattern( SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab ) const
4428 {
4429 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4430 return maTabs[nTab]->GetMostUsedPattern( nCol, nStartRow, nEndRow );
4431 return NULL;
4432 }
4433
4434
4435 void ScDocument::ApplyAttr( SCCOL nCol, SCROW nRow, SCTAB nTab, const SfxPoolItem& rAttr )
4436 {
4437 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4438 maTabs[nTab]->ApplyAttr( nCol, nRow, rAttr );
4439 }
4440
4441
4442 void ScDocument::ApplyPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr& rAttr )
4443 {
4444 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4445 maTabs[nTab]->ApplyPattern( nCol, nRow, rAttr );
4446 }
4447
4448
4449 void ScDocument::ApplyPatternArea( SCCOL nStartCol, SCROW nStartRow,
4450 SCCOL nEndCol, SCROW nEndRow,
4451 const ScMarkData& rMark,
4452 const ScPatternAttr& rAttr,
4453 ScEditDataArray* pDataArray )
4454 {
4455 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4456 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4457 for (; itr != itrEnd && *itr < nMax; ++itr)
4458 if (maTabs[*itr])
4459 maTabs[*itr]->ApplyPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rAttr, pDataArray );
4460 }
4461
4462
4463 void ScDocument::ApplyPatternAreaTab( SCCOL nStartCol, SCROW nStartRow,
4464 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScPatternAttr& rAttr )
4465 {
4466 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
4467 if (maTabs[nTab])
4468 maTabs[nTab]->ApplyPatternArea( nStartCol, nStartRow, nEndCol, nEndRow, rAttr );
4469 }
4470
4471 bool ScDocument::SetAttrEntries(SCCOL nCol, SCTAB nTab, ScAttrEntry* pData, SCSIZE nSize)
4472 {
4473 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
4474 return false;
4475
4476 return maTabs[nTab]->SetAttrEntries(nCol, pData, nSize);
4477 }
4478
4479 void ScDocument::ApplyPatternIfNumberformatIncompatible( const ScRange& rRange,
4480 const ScMarkData& rMark, const ScPatternAttr& rPattern, short nNewType )
4481 {
4482 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4483 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4484 for (; itr != itrEnd && *itr < nMax; ++itr)
4485 if (maTabs[*itr])
4486 maTabs[*itr]->ApplyPatternIfNumberformatIncompatible( rRange, rPattern, nNewType );
4487 }
4488
4489 void ScDocument::AddCondFormatData( const ScRangeList& rRange, SCTAB nTab, sal_uInt32 nIndex )
4490 {
4491 if(!(static_cast<size_t>(nTab) < maTabs.size()))
4492 return;
4493
4494 if(!maTabs[nTab])
4495 return;
4496
4497 maTabs[nTab]->AddCondFormatData(rRange, nIndex);
4498 }
4499
4500 void ScDocument::RemoveCondFormatData( const ScRangeList& rRange, SCTAB nTab, sal_uInt32 nIndex )
4501 {
4502 if(!(static_cast<size_t>(nTab) < maTabs.size()))
4503 return;
4504
4505 if(!maTabs[nTab])
4506 return;
4507
4508 maTabs[nTab]->RemoveCondFormatData(rRange, nIndex);
4509 }
4510
4511
4512 void ScDocument::ApplyStyle( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScStyleSheet& rStyle)
4513 {
4514 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
4515 if (maTabs[nTab])
4516 maTabs[nTab]->ApplyStyle( nCol, nRow, rStyle );
4517 }
4518
4519
4520 void ScDocument::ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow,
4521 SCCOL nEndCol, SCROW nEndRow,
4522 const ScMarkData& rMark,
4523 const ScStyleSheet& rStyle)
4524 {
4525 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4526 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4527 for (; itr != itrEnd && *itr < nMax; ++itr)
4528 if (maTabs[*itr])
4529 maTabs[*itr]->ApplyStyleArea( nStartCol, nStartRow, nEndCol, nEndRow, rStyle );
4530 }
4531
4532
4533 void ScDocument::ApplyStyleAreaTab( SCCOL nStartCol, SCROW nStartRow,
4534 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, const ScStyleSheet& rStyle)
4535 {
4536 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
4537 if (maTabs[nTab])
4538 maTabs[nTab]->ApplyStyleArea( nStartCol, nStartRow, nEndCol, nEndRow, rStyle );
4539 }
4540
4541
4542 void ScDocument::ApplySelectionStyle(const ScStyleSheet& rStyle, const ScMarkData& rMark)
4543 {
4544 // ApplySelectionStyle needs multi mark
4545 if ( rMark.IsMarked() && !rMark.IsMultiMarked() )
4546 {
4547 ScRange aRange;
4548 rMark.GetMarkArea( aRange );
4549 ApplyStyleArea( aRange.aStart.Col(), aRange.aStart.Row(),
4550 aRange.aEnd.Col(), aRange.aEnd.Row(), rMark, rStyle );
4551 }
4552 else
4553 {
4554 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4555 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4556 for (; itr != itrEnd && *itr < nMax; ++itr)
4557 if ( maTabs[*itr] )
4558 maTabs[*itr]->ApplySelectionStyle( rStyle, rMark );
4559 }
4560 }
4561
4562
4563 void ScDocument::ApplySelectionLineStyle( const ScMarkData& rMark,
4564 const SvxBorderLine* pLine, bool bColorOnly )
4565 {
4566 if ( bColorOnly && !pLine )
4567 return;
4568
4569 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4570 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4571 for (; itr != itrEnd && *itr < nMax; ++itr)
4572 if (maTabs[*itr])
4573 maTabs[*itr]->ApplySelectionLineStyle( rMark, pLine, bColorOnly );
4574 }
4575
4576
4577 const ScStyleSheet* ScDocument::GetStyle( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
4578 {
4579 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4580 return maTabs[nTab]->GetStyle(nCol, nRow);
4581 else
4582 return NULL;
4583 }
4584
4585
4586 const ScStyleSheet* ScDocument::GetSelectionStyle( const ScMarkData& rMark ) const
4587 {
4588 bool bEqual = true;
4589 bool bFound;
4590
4591 const ScStyleSheet* pStyle = NULL;
4592 const ScStyleSheet* pNewStyle;
4593
4594 if ( rMark.IsMultiMarked() )
4595 {
4596 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4597 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4598 for (; itr != itrEnd && *itr < nMax; ++itr)
4599 if (maTabs[*itr])
4600 {
4601 pNewStyle = maTabs[*itr]->GetSelectionStyle( rMark, bFound );
4602 if (bFound)
4603 {
4604 if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
4605 bEqual = false; // unterschiedliche
4606 pStyle = pNewStyle;
4607 }
4608 }
4609 }
4610 if ( rMark.IsMarked() )
4611 {
4612 ScRange aRange;
4613 rMark.GetMarkArea( aRange );
4614 for (SCTAB i=aRange.aStart.Tab(); i<=aRange.aEnd.Tab() && bEqual && i < static_cast<SCTAB>(maTabs.size()); i++)
4615 if (maTabs[i] && rMark.GetTableSelect(i))
4616 {
4617 pNewStyle = maTabs[i]->GetAreaStyle( bFound,
4618 aRange.aStart.Col(), aRange.aStart.Row(),
4619 aRange.aEnd.Col(), aRange.aEnd.Row() );
4620 if (bFound)
4621 {
4622 if ( !pNewStyle || ( pStyle && pNewStyle != pStyle ) )
4623 bEqual = false; // unterschiedliche
4624 pStyle = pNewStyle;
4625 }
4626 }
4627 }
4628
4629 return bEqual ? pStyle : NULL;
4630 }
4631
4632
4633 void ScDocument::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, bool bRemoved,
4634 OutputDevice* pDev,
4635 double nPPTX, double nPPTY,
4636 const Fraction& rZoomX, const Fraction& rZoomY )
4637 {
4638 TableContainer::iterator it = maTabs.begin();
4639 for (; it != maTabs.end(); ++it)
4640 if (*it)
4641 (*it)->StyleSheetChanged
4642 ( pStyleSheet, bRemoved, pDev, nPPTX, nPPTY, rZoomX, rZoomY );
4643
4644 if ( pStyleSheet && pStyleSheet->GetName() == ScGlobal::GetRscString(STR_STYLENAME_STANDARD) )
4645 {
4646 // update attributes for all note objects
4647 ScDetectiveFunc::UpdateAllComments( *this );
4648 }
4649 }
4650
4651
4652 bool ScDocument::IsStyleSheetUsed( const ScStyleSheet& rStyle, bool bGatherAllStyles ) const
4653 {
4654 if ( bStyleSheetUsageInvalid || rStyle.GetUsage() == ScStyleSheet::UNKNOWN )
4655 {
4656 if ( bGatherAllStyles )
4657 {
4658 SfxStyleSheetIterator aIter( xPoolHelper->GetStylePool(),
4659 SFX_STYLE_FAMILY_PARA );
4660 for ( const SfxStyleSheetBase* pStyle = aIter.First(); pStyle;
4661 pStyle = aIter.Next() )
4662 {
4663 const ScStyleSheet* pScStyle = PTR_CAST( ScStyleSheet, pStyle );
4664 if ( pScStyle )
4665 pScStyle->SetUsage( ScStyleSheet::NOTUSED );
4666 }
4667 }
4668
4669 bool bIsUsed = false;
4670
4671 TableContainer::const_iterator it = maTabs.begin();
4672 for (; it != maTabs.end(); ++it)
4673 if (*it)
4674 {
4675 if ( (*it)->IsStyleSheetUsed( rStyle, bGatherAllStyles ) )
4676 {
4677 if ( !bGatherAllStyles )
4678 return true;
4679 bIsUsed = true;
4680 }
4681 }
4682
4683 if ( bGatherAllStyles )
4684 bStyleSheetUsageInvalid = false;
4685
4686 return bIsUsed;
4687 }
4688
4689 return rStyle.GetUsage() == ScStyleSheet::USED;
4690 }
4691
4692
4693 bool ScDocument::ApplyFlagsTab( SCCOL nStartCol, SCROW nStartRow,
4694 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, sal_Int16 nFlags )
4695 {
4696 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
4697 if (maTabs[nTab])
4698 return maTabs[nTab]->ApplyFlags( nStartCol, nStartRow, nEndCol, nEndRow, nFlags );
4699
4700 OSL_FAIL("ApplyFlags: wrong table");
4701 return false;
4702 }
4703
4704
4705 bool ScDocument::RemoveFlagsTab( SCCOL nStartCol, SCROW nStartRow,
4706 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab, sal_Int16 nFlags )
4707 {
4708 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
4709 if (maTabs[nTab])
4710 return maTabs[nTab]->RemoveFlags( nStartCol, nStartRow, nEndCol, nEndRow, nFlags );
4711
4712 OSL_FAIL("RemoveFlags: wrong table");
4713 return false;
4714 }
4715
4716
4717 void ScDocument::SetPattern( SCCOL nCol, SCROW nRow, SCTAB nTab, const ScPatternAttr& rAttr,
4718 bool bPutToPool )
4719 {
4720 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
4721 if (maTabs[nTab])
4722 maTabs[nTab]->SetPattern( nCol, nRow, rAttr, bPutToPool );
4723 }
4724
4725
4726 void ScDocument::SetPattern( const ScAddress& rPos, const ScPatternAttr& rAttr,
4727 bool bPutToPool )
4728 {
4729 SCTAB nTab = rPos.Tab();
4730 if ( nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
4731 maTabs[nTab]->SetPattern( rPos, rAttr, bPutToPool );
4732 }
4733
4734
4735 ScPatternAttr* ScDocument::CreateSelectionPattern( const ScMarkData& rMark, bool bDeep )
4736 {
4737 ScMergePatternState aState;
4738
4739 if ( rMark.IsMultiMarked() ) // multi selection
4740 {
4741 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4742 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4743 for (; itr != itrEnd && *itr < nMax; ++itr)
4744 if (maTabs[*itr])
4745 maTabs[*itr]->MergeSelectionPattern( aState, rMark, bDeep );
4746 }
4747 if ( rMark.IsMarked() ) // simle selection
4748 {
4749 ScRange aRange;
4750 rMark.GetMarkArea(aRange);
4751 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4752 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4753 for (; itr != itrEnd && *itr < nMax; ++itr)
4754 if (maTabs[*itr])
4755 maTabs[*itr]->MergePatternArea( aState,
4756 aRange.aStart.Col(), aRange.aStart.Row(),
4757 aRange.aEnd.Col(), aRange.aEnd.Row(), bDeep );
4758 }
4759
4760 OSL_ENSURE( aState.pItemSet, "SelectionPattern Null" );
4761 if (aState.pItemSet)
4762 return new ScPatternAttr( aState.pItemSet );
4763 else
4764 return new ScPatternAttr( GetPool() ); // empty
4765 }
4766
4767
4768 const ScPatternAttr* ScDocument::GetSelectionPattern( const ScMarkData& rMark, bool bDeep )
4769 {
4770 delete pSelectionAttr;
4771 pSelectionAttr = CreateSelectionPattern( rMark, bDeep );
4772 return pSelectionAttr;
4773 }
4774
4775
4776 void ScDocument::GetSelectionFrame( const ScMarkData& rMark,
4777 SvxBoxItem& rLineOuter,
4778 SvxBoxInfoItem& rLineInner )
4779 {
4780 rLineOuter.SetLine(NULL, BOX_LINE_TOP);
4781 rLineOuter.SetLine(NULL, BOX_LINE_BOTTOM);
4782 rLineOuter.SetLine(NULL, BOX_LINE_LEFT);
4783 rLineOuter.SetLine(NULL, BOX_LINE_RIGHT);
4784 rLineOuter.SetDistance(0);
4785
4786 rLineInner.SetLine(NULL, BOXINFO_LINE_HORI);
4787 rLineInner.SetLine(NULL, BOXINFO_LINE_VERT);
4788 rLineInner.SetTable(true);
4789 rLineInner.SetDist(true);
4790 rLineInner.SetMinDist(false);
4791
4792 ScLineFlags aFlags;
4793
4794 if (rMark.IsMarked())
4795 {
4796 ScRange aRange;
4797 rMark.GetMarkArea(aRange);
4798 rLineInner.EnableHor( aRange.aStart.Row() != aRange.aEnd.Row() );
4799 rLineInner.EnableVer( aRange.aStart.Col() != aRange.aEnd.Col() );
4800 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
4801 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
4802 for (; itr != itrEnd && *itr < nMax; ++itr)
4803 if (maTabs[*itr])
4804 maTabs[*itr]->MergeBlockFrame( &rLineOuter, &rLineInner, aFlags,
4805 aRange.aStart.Col(), aRange.aStart.Row(),
4806 aRange.aEnd.Col(), aRange.aEnd.Row() );
4807 }
4808
4809 // Don't care Status auswerten
4810
4811 rLineInner.SetValid( VALID_LEFT, ( aFlags.nLeft != SC_LINE_DONTCARE ) );
4812 rLineInner.SetValid( VALID_RIGHT, ( aFlags.nRight != SC_LINE_DONTCARE ) );
4813 rLineInner.SetValid( VALID_TOP, ( aFlags.nTop != SC_LINE_DONTCARE ) );
4814 rLineInner.SetValid( VALID_BOTTOM, ( aFlags.nBottom != SC_LINE_DONTCARE ) );
4815 rLineInner.SetValid( VALID_HORI, ( aFlags.nHori != SC_LINE_DONTCARE ) );
4816 rLineInner.SetValid( VALID_VERT, ( aFlags.nVert != SC_LINE_DONTCARE ) );
4817 }
4818
4819
4820 bool ScDocument::HasAttrib( SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
4821 SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt16 nMask ) const
4822 {
4823 if ( nMask & HASATTR_ROTATE )
4824 {
4825 // Attribut im Dokument ueberhaupt verwendet?
4826 // (wie in fillinfo)
4827
4828 ScDocumentPool* pPool = xPoolHelper->GetDocPool();
4829
4830 bool bAnyItem = false;
4831 sal_uInt32 nRotCount = pPool->GetItemCount2( ATTR_ROTATE_VALUE );
4832 for (sal_uInt32 nItem=0; nItem<nRotCount; nItem++)
4833 {
4834 const SfxPoolItem* pItem = pPool->GetItem2( ATTR_ROTATE_VALUE, nItem );
4835 if ( pItem )
4836 {
4837 // 90 or 270 degrees is former SvxOrientationItem - only look for other values
4838 // (see ScPatternAttr::GetCellOrientation)
4839 sal_Int32 nAngle = static_cast<const SfxInt32Item*>(pItem)->GetValue();
4840 if ( nAngle != 0 && nAngle != 9000 && nAngle != 27000 )
4841 {
4842 bAnyItem = true;
4843 break;
4844 }
4845 }
4846 }
4847 if (!bAnyItem)
4848 nMask &= ~HASATTR_ROTATE;
4849 }
4850
4851 if ( nMask & HASATTR_RTL )
4852 {
4853 // first check if right-to left is in the pool at all
4854 // (the same item is used in cell and page format)
4855
4856 ScDocumentPool* pPool = xPoolHelper->GetDocPool();
4857
4858 bool bHasRtl = false;
4859 sal_uInt32 nDirCount = pPool->GetItemCount2( ATTR_WRITINGDIR );
4860 for (sal_uInt32 nItem=0; nItem<nDirCount; nItem++)
4861 {
4862 const SfxPoolItem* pItem = pPool->GetItem2( ATTR_WRITINGDIR, nItem );
4863 if ( pItem && ((const SvxFrameDirectionItem*)pItem)->GetValue() == FRMDIR_HORI_RIGHT_TOP )
4864 {
4865 bHasRtl = true;
4866 break;
4867 }
4868 }
4869 if (!bHasRtl)
4870 nMask &= ~HASATTR_RTL;
4871 }
4872
4873 if (!nMask)
4874 return false;
4875
4876 bool bFound = false;
4877 for (SCTAB i=nTab1; i<=nTab2 && !bFound && i < static_cast<SCTAB>(maTabs.size()); i++)
4878 if (maTabs[i])
4879 {
4880 if ( nMask & HASATTR_RTL )
4881 {
4882 if ( GetEditTextDirection(i) == EE_HTEXTDIR_R2L ) // sheet default
4883 bFound = true;
4884 }
4885 if ( nMask & HASATTR_RIGHTORCENTER )
4886 {
4887 // On a RTL sheet, don't start to look for the default left value
4888 // (which is then logically right), instead always assume true.
4889 // That way, ScAttrArray::HasAttrib doesn't have to handle RTL sheets.
4890
4891 if ( IsLayoutRTL(i) )
4892 bFound = true;
4893 }
4894
4895 if ( !bFound )
4896 bFound = maTabs[i]->HasAttrib( nCol1, nRow1, nCol2, nRow2, nMask );
4897 }
4898
4899 return bFound;
4900 }
4901
4902 bool ScDocument::HasAttrib( const ScRange& rRange, sal_uInt16 nMask ) const
4903 {
4904 return HasAttrib( rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(),
4905 rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(),
4906 nMask );
4907 }
4908
4909 void ScDocument::FindMaxRotCol( SCTAB nTab, RowInfo* pRowInfo, SCSIZE nArrCount,
4910 SCCOL nX1, SCCOL nX2 ) const
4911 {
4912 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4913 maTabs[nTab]->FindMaxRotCol( pRowInfo, nArrCount, nX1, nX2 );
4914 else
4915 {
4916 OSL_FAIL("FindMaxRotCol: wrong table");
4917 }
4918 }
4919
4920 void ScDocument::GetBorderLines( SCCOL nCol, SCROW nRow, SCTAB nTab,
4921 const SvxBorderLine** ppLeft, const SvxBorderLine** ppTop,
4922 const SvxBorderLine** ppRight, const SvxBorderLine** ppBottom ) const
4923 {
4924 //! Seitengrenzen fuer Druck beruecksichtigen !!!!!
4925
4926 const SvxBoxItem* pThisAttr = (const SvxBoxItem*) GetEffItem( nCol, nRow, nTab, ATTR_BORDER );
4927 OSL_ENSURE(pThisAttr,"where is the attribute?");
4928
4929 const SvxBorderLine* pLeftLine = pThisAttr->GetLeft();
4930 const SvxBorderLine* pTopLine = pThisAttr->GetTop();
4931 const SvxBorderLine* pRightLine = pThisAttr->GetRight();
4932 const SvxBorderLine* pBottomLine = pThisAttr->GetBottom();
4933
4934 if ( nCol > 0 )
4935 {
4936 const SvxBorderLine* pOther = ((const SvxBoxItem*)
4937 GetEffItem( nCol-1, nRow, nTab, ATTR_BORDER ))->GetRight();
4938 if ( ScHasPriority( pOther, pLeftLine ) )
4939 pLeftLine = pOther;
4940 }
4941 if ( nRow > 0 )
4942 {
4943 const SvxBorderLine* pOther = ((const SvxBoxItem*)
4944 GetEffItem( nCol, nRow-1, nTab, ATTR_BORDER ))->GetBottom();
4945 if ( ScHasPriority( pOther, pTopLine ) )
4946 pTopLine = pOther;
4947 }
4948 if ( nCol < MAXCOL )
4949 {
4950 const SvxBorderLine* pOther = ((const SvxBoxItem*)
4951 GetEffItem( nCol+1, nRow, nTab, ATTR_BORDER ))->GetLeft();
4952 if ( ScHasPriority( pOther, pRightLine ) )
4953 pRightLine = pOther;
4954 }
4955 if ( nRow < MAXROW )
4956 {
4957 const SvxBorderLine* pOther = ((const SvxBoxItem*)
4958 GetEffItem( nCol, nRow+1, nTab, ATTR_BORDER ))->GetTop();
4959 if ( ScHasPriority( pOther, pBottomLine ) )
4960 pBottomLine = pOther;
4961 }
4962
4963 if (ppLeft)
4964 *ppLeft = pLeftLine;
4965 if (ppTop)
4966 *ppTop = pTopLine;
4967 if (ppRight)
4968 *ppRight = pRightLine;
4969 if (ppBottom)
4970 *ppBottom = pBottomLine;
4971 }
4972
4973 bool ScDocument::IsBlockEmpty( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
4974 SCCOL nEndCol, SCROW nEndRow, bool bIgnoreNotes ) const
4975 {
4976 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
4977 if (maTabs[nTab])
4978 return maTabs[nTab]->IsBlockEmpty( nStartCol, nStartRow, nEndCol, nEndRow, bIgnoreNotes );
4979
4980 OSL_FAIL("wrong table number");
4981 return false;
4982 }
4983
4984
4985 void ScDocument::LockTable(SCTAB nTab)
4986 {
4987 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4988 maTabs[nTab]->LockTable();
4989 else
4990 {
4991 OSL_FAIL("wrong table number");
4992 }
4993 }
4994
4995
4996 void ScDocument::UnlockTable(SCTAB nTab)
4997 {
4998 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
4999 maTabs[nTab]->UnlockTable();
5000 else
5001 {
5002 OSL_FAIL("wrong table number");
5003 }
5004 }
5005
5006
5007 bool ScDocument::IsBlockEditable( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
5008 SCCOL nEndCol, SCROW nEndRow,
5009 bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
5010 {
5011 // import into read-only document is possible
5012 if (!bImportingXML && !mbChangeReadOnlyEnabled && pShell && pShell->IsReadOnly())
5013 {
5014 if ( pOnlyNotBecauseOfMatrix )
5015 *pOnlyNotBecauseOfMatrix = false;
5016 return false;
5017 }
5018
5019 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
5020 if (maTabs[nTab])
5021 return maTabs[nTab]->IsBlockEditable( nStartCol, nStartRow, nEndCol,
5022 nEndRow, pOnlyNotBecauseOfMatrix );
5023
5024 OSL_FAIL("wrong table number");
5025 if ( pOnlyNotBecauseOfMatrix )
5026 *pOnlyNotBecauseOfMatrix = false;
5027 return false;
5028 }
5029
5030
5031 bool ScDocument::IsSelectionEditable( const ScMarkData& rMark,
5032 bool* pOnlyNotBecauseOfMatrix /* = NULL */ ) const
5033 {
5034 // import into read-only document is possible
5035 if ( !bImportingXML && !mbChangeReadOnlyEnabled && pShell && pShell->IsReadOnly() )
5036 {
5037 if ( pOnlyNotBecauseOfMatrix )
5038 *pOnlyNotBecauseOfMatrix = false;
5039 return false;
5040 }
5041
5042 ScRange aRange;
5043 rMark.GetMarkArea(aRange);
5044
5045 bool bOk = true;
5046 bool bMatrix = ( pOnlyNotBecauseOfMatrix != NULL );
5047 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5048 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5049 for (; itr != itrEnd && *itr < nMax && (bOk || bMatrix); ++itr)
5050 {
5051 if ( maTabs[*itr] )
5052 {
5053 if (rMark.IsMarked())
5054 {
5055 if ( !maTabs[*itr]->IsBlockEditable( aRange.aStart.Col(),
5056 aRange.aStart.Row(), aRange.aEnd.Col(),
5057 aRange.aEnd.Row(), pOnlyNotBecauseOfMatrix ) )
5058 {
5059 bOk = false;
5060 if ( pOnlyNotBecauseOfMatrix )
5061 bMatrix = *pOnlyNotBecauseOfMatrix;
5062 }
5063 }
5064 if (rMark.IsMultiMarked())
5065 {
5066 if ( !maTabs[*itr]->IsSelectionEditable( rMark, pOnlyNotBecauseOfMatrix ) )
5067 {
5068 bOk = false;
5069 if ( pOnlyNotBecauseOfMatrix )
5070 bMatrix = *pOnlyNotBecauseOfMatrix;
5071 }
5072 }
5073 }
5074 }
5075
5076 if ( pOnlyNotBecauseOfMatrix )
5077 *pOnlyNotBecauseOfMatrix = ( !bOk && bMatrix );
5078
5079 return bOk;
5080 }
5081
5082
5083 bool ScDocument::HasSelectedBlockMatrixFragment( SCCOL nStartCol, SCROW nStartRow,
5084 SCCOL nEndCol, SCROW nEndRow,
5085 const ScMarkData& rMark ) const
5086 {
5087 bool bOk = true;
5088 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5089 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5090 for (; itr != itrEnd && *itr < nMax && bOk; ++itr)
5091 if (maTabs[*itr])
5092 if (maTabs[*itr]->HasBlockMatrixFragment( nStartCol, nStartRow, nEndCol, nEndRow ))
5093 bOk = false;
5094
5095 return !bOk;
5096 }
5097
5098 bool ScDocument::GetMatrixFormulaRange( const ScAddress& rCellPos, ScRange& rMatrix )
5099 {
5100 // if rCell is part of a matrix formula, return its complete range
5101
5102 ScFormulaCell* pFCell = GetFormulaCell(rCellPos);
5103 if (!pFCell)
5104 // not a formula cell. Bail out.
5105 return false;
5106
5107 ScAddress aOrigin = rCellPos;
5108 if (!pFCell->GetMatrixOrigin(aOrigin))
5109 // Failed to get the address of the matrix origin.
5110 return false;
5111
5112 if (aOrigin != rCellPos)
5113 {
5114 pFCell = GetFormulaCell(aOrigin);
5115 if (!pFCell)
5116 // The matrix origin cell is not a formula cell !? Something is up...
5117 return false;
5118 }
5119
5120 SCCOL nSizeX;
5121 SCROW nSizeY;
5122 pFCell->GetMatColsRows(nSizeX, nSizeY);
5123 if (nSizeX <= 0 || nSizeY <= 0)
5124 {
5125 // GetMatrixEdge computes also dimensions of the matrix
5126 // if not already done (may occur if document is loaded
5127 // from old file format).
5128 // Needs an "invalid" initialized address.
5129 aOrigin.SetInvalid();
5130 pFCell->GetMatrixEdge(aOrigin);
5131 pFCell->GetMatColsRows(nSizeX, nSizeY);
5132 }
5133
5134 if (nSizeX <= 0 || nSizeY <= 0)
5135 // Matrix size is still invalid. Give up.
5136 return false;
5137
5138 ScAddress aEnd( aOrigin.Col() + nSizeX - 1,
5139 aOrigin.Row() + nSizeY - 1,
5140 aOrigin.Tab() );
5141
5142 rMatrix.aStart = aOrigin;
5143 rMatrix.aEnd = aEnd;
5144
5145 return true;
5146 }
5147
5148
5149 bool ScDocument::ExtendOverlapped( SCCOL& rStartCol, SCROW& rStartRow,
5150 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ) const
5151 {
5152 bool bFound = false;
5153 if ( ValidColRow(rStartCol,rStartRow) && ValidColRow(nEndCol,nEndRow) && ValidTab(nTab) )
5154 {
5155 if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5156 {
5157 SCCOL nCol;
5158 SCCOL nOldCol = rStartCol;
5159 SCROW nOldRow = rStartRow;
5160 for (nCol=nOldCol; nCol<=nEndCol; nCol++)
5161 while (((ScMergeFlagAttr*)GetAttr(nCol,rStartRow,nTab,ATTR_MERGE_FLAG))->
5162 IsVerOverlapped())
5163 --rStartRow;
5164
5165 //! weiterreichen ?
5166
5167 ScAttrArray* pAttrArray = maTabs[nTab]->aCol[nOldCol].pAttrArray;
5168 SCSIZE nIndex;
5169 pAttrArray->Search( nOldRow, nIndex );
5170 SCROW nAttrPos = nOldRow;
5171 while (nAttrPos<=nEndRow)
5172 {
5173 OSL_ENSURE( nIndex < pAttrArray->nCount, "Wrong index in AttrArray" );
5174
5175 if (((ScMergeFlagAttr&)pAttrArray->pData[nIndex].pPattern->
5176 GetItem(ATTR_MERGE_FLAG)).IsHorOverlapped())
5177 {
5178 SCROW nLoopEndRow = std::min( nEndRow, pAttrArray->pData[nIndex].nRow );
5179 for (SCROW nAttrRow = nAttrPos; nAttrRow <= nLoopEndRow; nAttrRow++)
5180 {
5181 SCCOL nTempCol = nOldCol;
5182 do
5183 --nTempCol;
5184 while (((ScMergeFlagAttr*)GetAttr(nTempCol,nAttrRow,nTab,ATTR_MERGE_FLAG))
5185 ->IsHorOverlapped());
5186 if (nTempCol < rStartCol)
5187 rStartCol = nTempCol;
5188 }
5189 }
5190 nAttrPos = pAttrArray->pData[nIndex].nRow + 1;
5191 ++nIndex;
5192 }
5193 }
5194 }
5195 else
5196 {
5197 OSL_FAIL("ExtendOverlapped: invalid range");
5198 }
5199
5200 return bFound;
5201 }
5202
5203
5204 bool ScDocument::ExtendMergeSel( SCCOL nStartCol, SCROW nStartRow,
5205 SCCOL& rEndCol, SCROW& rEndRow,
5206 const ScMarkData& rMark, bool bRefresh )
5207 {
5208 // use all selected sheets from rMark
5209
5210 bool bFound = false;
5211 SCCOL nOldEndCol = rEndCol;
5212 SCROW nOldEndRow = rEndRow;
5213
5214 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5215 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5216 for (; itr != itrEnd && *itr < nMax; ++itr)
5217 if ( maTabs[*itr] )
5218 {
5219 SCCOL nThisEndCol = nOldEndCol;
5220 SCROW nThisEndRow = nOldEndRow;
5221 if ( ExtendMerge( nStartCol, nStartRow, nThisEndCol, nThisEndRow, *itr, bRefresh ) )
5222 bFound = true;
5223 if ( nThisEndCol > rEndCol )
5224 rEndCol = nThisEndCol;
5225 if ( nThisEndRow > rEndRow )
5226 rEndRow = nThisEndRow;
5227 }
5228
5229 return bFound;
5230 }
5231
5232
5233 bool ScDocument::ExtendMerge( SCCOL nStartCol, SCROW nStartRow,
5234 SCCOL& rEndCol, SCROW& rEndRow,
5235 SCTAB nTab, bool bRefresh )
5236 {
5237 bool bFound = false;
5238 if ( ValidColRow(nStartCol,nStartRow) && ValidColRow(rEndCol,rEndRow) && ValidTab(nTab) )
5239 {
5240 if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5241 bFound = maTabs[nTab]->ExtendMerge( nStartCol, nStartRow, rEndCol, rEndRow, bRefresh );
5242
5243 if (bRefresh)
5244 RefreshAutoFilter( nStartCol, nStartRow, rEndCol, rEndRow, nTab );
5245 }
5246 else
5247 {
5248 OSL_FAIL("ExtendMerge: invalid range");
5249 }
5250
5251 return bFound;
5252 }
5253
5254
5255 bool ScDocument::ExtendMerge( ScRange& rRange, bool bRefresh )
5256 {
5257 bool bFound = false;
5258 SCTAB nStartTab = rRange.aStart.Tab();
5259 SCTAB nEndTab = rRange.aEnd.Tab();
5260 SCCOL nEndCol = rRange.aEnd.Col();
5261 SCROW nEndRow = rRange.aEnd.Row();
5262
5263 PutInOrder( nStartTab, nEndTab );
5264 for (SCTAB nTab = nStartTab; nTab <= nEndTab && nTab < static_cast<SCTAB>(maTabs.size()); nTab++ )
5265 {
5266 SCCOL nExtendCol = rRange.aEnd.Col();
5267 SCROW nExtendRow = rRange.aEnd.Row();
5268 if (ExtendMerge( rRange.aStart.Col(), rRange.aStart.Row(),
5269 nExtendCol, nExtendRow,
5270 nTab, bRefresh ) )
5271 {
5272 bFound = true;
5273 if (nExtendCol > nEndCol) nEndCol = nExtendCol;
5274 if (nExtendRow > nEndRow) nEndRow = nExtendRow;
5275 }
5276 }
5277
5278 rRange.aEnd.SetCol(nEndCol);
5279 rRange.aEnd.SetRow(nEndRow);
5280
5281 return bFound;
5282 }
5283
5284 bool ScDocument::ExtendTotalMerge( ScRange& rRange ) const
5285 {
5286 // Bereich genau dann auf zusammengefasste Zellen erweitern, wenn
5287 // dadurch keine neuen nicht-ueberdeckten Zellen getroffen werden
5288
5289 bool bRet = false;
5290 ScRange aExt = rRange;
5291 // ExtendMerge() is non-const, but called withouth refresh.
5292 if (const_cast<ScDocument*>(this)->ExtendMerge( aExt, false))
5293 {
5294 if ( aExt.aEnd.Row() > rRange.aEnd.Row() )
5295 {
5296 ScRange aTest = aExt;
5297 aTest.aStart.SetRow( rRange.aEnd.Row() + 1 );
5298 if ( HasAttrib( aTest, HASATTR_NOTOVERLAPPED ) )
5299 aExt.aEnd.SetRow(rRange.aEnd.Row());
5300 }
5301 if ( aExt.aEnd.Col() > rRange.aEnd.Col() )
5302 {
5303 ScRange aTest = aExt;
5304 aTest.aStart.SetCol( rRange.aEnd.Col() + 1 );
5305 if ( HasAttrib( aTest, HASATTR_NOTOVERLAPPED ) )
5306 aExt.aEnd.SetCol(rRange.aEnd.Col());
5307 }
5308
5309 bRet = ( aExt.aEnd != rRange.aEnd );
5310 rRange = aExt;
5311 }
5312 return bRet;
5313 }
5314
5315 bool ScDocument::ExtendOverlapped( ScRange& rRange ) const
5316 {
5317 bool bFound = false;
5318 SCTAB nStartTab = rRange.aStart.Tab();
5319 SCTAB nEndTab = rRange.aEnd.Tab();
5320 SCCOL nStartCol = rRange.aStart.Col();
5321 SCROW nStartRow = rRange.aStart.Row();
5322
5323 PutInOrder( nStartTab, nEndTab );
5324 for (SCTAB nTab = nStartTab; nTab <= nEndTab && nTab < static_cast<SCTAB>(maTabs.size()); nTab++ )
5325 {
5326 SCCOL nExtendCol = rRange.aStart.Col();
5327 SCROW nExtendRow = rRange.aStart.Row();
5328 ExtendOverlapped( nExtendCol, nExtendRow,
5329 rRange.aEnd.Col(), rRange.aEnd.Row(), nTab );
5330 if (nExtendCol < nStartCol)
5331 {
5332 nStartCol = nExtendCol;
5333 bFound = true;
5334 }
5335 if (nExtendRow < nStartRow)
5336 {
5337 nStartRow = nExtendRow;
5338 bFound = true;
5339 }
5340 }
5341
5342 rRange.aStart.SetCol(nStartCol);
5343 rRange.aStart.SetRow(nStartRow);
5344
5345 return bFound;
5346 }
5347
5348 bool ScDocument::RefreshAutoFilter( SCCOL nStartCol, SCROW nStartRow,
5349 SCCOL nEndCol, SCROW nEndRow, SCTAB nTab )
5350 {
5351 SCTAB nDBTab;
5352 SCCOL nDBStartCol;
5353 SCROW nDBStartRow;
5354 SCCOL nDBEndCol;
5355 SCROW nDBEndRow;
5356
5357 // Autofilter loeschen
5358
5359 bool bChange = RemoveFlagsTab( nStartCol,nStartRow, nEndCol,nEndRow, nTab, SC_MF_AUTO );
5360
5361 // Autofilter setzen
5362
5363 const ScDBData* pData = NULL;
5364 ScDBCollection::NamedDBs& rDBs = pDBCollection->getNamedDBs();
5365 ScDBCollection::NamedDBs::const_iterator itr = rDBs.begin(), itrEnd = rDBs.end();
5366 for (; itr != itrEnd; ++itr)
5367 {
5368 if (itr->HasAutoFilter())
5369 {
5370 itr->GetArea( nDBTab, nDBStartCol,nDBStartRow, nDBEndCol,nDBEndRow );
5371 if ( nDBTab==nTab && nDBStartRow<=nEndRow && nDBEndRow>=nStartRow &&
5372 nDBStartCol<=nEndCol && nDBEndCol>=nStartCol )
5373 {
5374 if (ApplyFlagsTab( nDBStartCol,nDBStartRow, nDBEndCol,nDBStartRow,
5375 nDBTab, SC_MF_AUTO ))
5376 bChange = true;
5377 }
5378 }
5379 }
5380 if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5381 pData = maTabs[nTab]->GetAnonymousDBData();
5382 else
5383 pData=NULL;
5384 if (pData)
5385 {
5386 if (pData->HasAutoFilter())
5387 {
5388 pData->GetArea( nDBTab, nDBStartCol,nDBStartRow, nDBEndCol,nDBEndRow );
5389 if ( nDBTab==nTab && nDBStartRow<=nEndRow && nDBEndRow>=nStartRow &&
5390 nDBStartCol<=nEndCol && nDBEndCol>=nStartCol )
5391 {
5392 if (ApplyFlagsTab( nDBStartCol,nDBStartRow, nDBEndCol,nDBStartRow,
5393 nDBTab, SC_MF_AUTO ))
5394 bChange = true;
5395 }
5396 }
5397 }
5398 return bChange;
5399 }
5400
5401 void ScDocument::SkipOverlapped( SCCOL& rCol, SCROW& rRow, SCTAB nTab ) const
5402 {
5403 while (IsHorOverlapped(rCol, rRow, nTab))
5404 --rCol;
5405 while (IsVerOverlapped(rCol, rRow, nTab))
5406 --rRow;
5407 }
5408
5409 bool ScDocument::IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
5410 {
5411 const ScMergeFlagAttr* pAttr = (const ScMergeFlagAttr*)
5412 GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG );
5413 if (pAttr)
5414 return pAttr->IsHorOverlapped();
5415 else
5416 {
5417 OSL_FAIL("Overlapped: Attr==0");
5418 return false;
5419 }
5420 }
5421
5422
5423 bool ScDocument::IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
5424 {
5425 const ScMergeFlagAttr* pAttr = (const ScMergeFlagAttr*)
5426 GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG );
5427 if (pAttr)
5428 return pAttr->IsVerOverlapped();
5429 else
5430 {
5431 OSL_FAIL("Overlapped: Attr==0");
5432 return false;
5433 }
5434 }
5435
5436
5437 void ScDocument::ApplySelectionFrame( const ScMarkData& rMark,
5438 const SvxBoxItem* pLineOuter,
5439 const SvxBoxInfoItem* pLineInner )
5440 {
5441 ScRangeList aRangeList;
5442 rMark.FillRangeListWithMarks( &aRangeList, false );
5443 size_t nRangeCount = aRangeList.size();
5444 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5445 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5446 for (; itr != itrEnd && *itr < nMax; ++itr)
5447 {
5448 if (maTabs[*itr])
5449 {
5450 for ( size_t j=0; j < nRangeCount; j++ )
5451 {
5452 ScRange aRange = *aRangeList[ j ];
5453 maTabs[*itr]->ApplyBlockFrame( pLineOuter, pLineInner,
5454 aRange.aStart.Col(), aRange.aStart.Row(),
5455 aRange.aEnd.Col(), aRange.aEnd.Row() );
5456 }
5457 }
5458 }
5459 }
5460
5461
5462 void ScDocument::ApplyFrameAreaTab( const ScRange& rRange,
5463 const SvxBoxItem* pLineOuter,
5464 const SvxBoxInfoItem* pLineInner )
5465 {
5466 SCTAB nStartTab = rRange.aStart.Tab();
5467 SCTAB nEndTab = rRange.aStart.Tab();
5468 for (SCTAB nTab=nStartTab; nTab<=nEndTab && nTab < static_cast<SCTAB>(maTabs.size()); nTab++)
5469 if (maTabs[nTab])
5470 maTabs[nTab]->ApplyBlockFrame( pLineOuter, pLineInner,
5471 rRange.aStart.Col(), rRange.aStart.Row(),
5472 rRange.aEnd.Col(), rRange.aEnd.Row() );
5473 }
5474
5475
5476 void ScDocument::ApplySelectionPattern( const ScPatternAttr& rAttr, const ScMarkData& rMark, ScEditDataArray* pDataArray )
5477 {
5478 const SfxItemSet* pSet = &rAttr.GetItemSet();
5479 bool bSet = false;
5480 sal_uInt16 i;
5481 for (i=ATTR_PATTERN_START; i<=ATTR_PATTERN_END && !bSet; i++)
5482 if (pSet->GetItemState(i) == SFX_ITEM_SET)
5483 bSet = true;
5484
5485 if (bSet)
5486 {
5487 // ApplySelectionCache needs multi mark
5488 if ( rMark.IsMarked() && !rMark.IsMultiMarked() )
5489 {
5490 ScRange aRange;
5491 rMark.GetMarkArea( aRange );
5492 ApplyPatternArea( aRange.aStart.Col(), aRange.aStart.Row(),
5493 aRange.aEnd.Col(), aRange.aEnd.Row(), rMark, rAttr, pDataArray );
5494 }
5495 else
5496 {
5497 SfxItemPoolCache aCache( xPoolHelper->GetDocPool(), pSet );
5498 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5499 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5500 for (; itr != itrEnd && *itr < nMax; ++itr)
5501 if (maTabs[*itr])
5502 maTabs[*itr]->ApplySelectionCache( &aCache, rMark, pDataArray );
5503 }
5504 }
5505 }
5506
5507
5508 void ScDocument::ChangeSelectionIndent( bool bIncrement, const ScMarkData& rMark )
5509 {
5510 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5511 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5512 for (; itr != itrEnd && *itr < nMax; ++itr)
5513 if (maTabs[*itr])
5514 maTabs[*itr]->ChangeSelectionIndent( bIncrement, rMark );
5515 }
5516
5517
5518 void ScDocument::ClearSelectionItems( const sal_uInt16* pWhich, const ScMarkData& rMark )
5519 {
5520 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5521 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5522 for (; itr != itrEnd && *itr < nMax; ++itr)
5523 if (maTabs[*itr])
5524 maTabs[*itr]->ClearSelectionItems( pWhich, rMark );
5525 }
5526
5527
5528 void ScDocument::DeleteSelection( sal_uInt16 nDelFlag, const ScMarkData& rMark )
5529 {
5530 SCTAB nMax = static_cast<SCTAB>(maTabs.size());
5531 ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
5532 for (; itr != itrEnd && *itr < nMax; ++itr)
5533 if (maTabs[*itr])
5534 maTabs[*itr]->DeleteSelection( nDelFlag, rMark );
5535 }
5536
5537
5538 void ScDocument::DeleteSelectionTab( SCTAB nTab, sal_uInt16 nDelFlag, const ScMarkData& rMark )
5539 {
5540 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5541 maTabs[nTab]->DeleteSelection( nDelFlag, rMark );
5542 else
5543 {
5544 OSL_FAIL("wrong table");
5545 }
5546 }
5547
5548
5549 ScPatternAttr* ScDocument::GetDefPattern() const
5550 {
5551 return (ScPatternAttr*) &xPoolHelper->GetDocPool()->GetDefaultItem(ATTR_PATTERN);
5552 }
5553
5554
5555 ScDocumentPool* ScDocument::GetPool()
5556 {
5557 return xPoolHelper->GetDocPool();
5558 }
5559
5560
5561
5562 ScStyleSheetPool* ScDocument::GetStyleSheetPool() const
5563 {
5564 return xPoolHelper->GetStylePool();
5565 }
5566
5567
5568 SCSIZE ScDocument::GetEmptyLinesInBlock( SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
5569 SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab, ScDirection eDir )
5570 {
5571 PutInOrder(nStartCol, nEndCol);
5572 PutInOrder(nStartRow, nEndRow);
5573 PutInOrder(nStartTab, nEndTab);
5574 if (ValidTab(nStartTab) && nStartTab < static_cast<SCTAB>(maTabs.size()))
5575 {
5576 if (maTabs[nStartTab])
5577 return maTabs[nStartTab]->GetEmptyLinesInBlock(nStartCol, nStartRow, nEndCol, nEndRow, eDir);
5578 else
5579 return 0;
5580 }
5581 else
5582 return 0;
5583 }
5584
5585
5586 void ScDocument::FindAreaPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, ScMoveDirection eDirection ) const
5587 {
5588 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5589 maTabs[nTab]->FindAreaPos( rCol, rRow, eDirection );
5590 }
5591
5592
5593 void ScDocument::GetNextPos( SCCOL& rCol, SCROW& rRow, SCTAB nTab, SCsCOL nMovX, SCsROW nMovY,
5594 bool bMarked, bool bUnprotected, const ScMarkData& rMark ) const
5595 {
5596 OSL_ENSURE( !nMovX || !nMovY, "GetNextPos: only X or Y" );
5597
5598 ScMarkData aCopyMark = rMark;
5599 aCopyMark.SetMarking(false);
5600 aCopyMark.MarkToMulti();
5601
5602 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5603 maTabs[nTab]->GetNextPos( rCol, rRow, nMovX, nMovY, bMarked, bUnprotected, aCopyMark );
5604 }
5605
5606 //
5607 // Datei-Operationen
5608 //
5609
5610
5611 void ScDocument::UpdStlShtPtrsFrmNms()
5612 {
5613 ScPatternAttr::pDoc = this;
5614
5615 ScDocumentPool* pPool = xPoolHelper->GetDocPool();
5616
5617 sal_uInt32 nCount = pPool->GetItemCount2(ATTR_PATTERN);
5618 ScPatternAttr* pPattern;
5619 for (sal_uInt32 i=0; i<nCount; i++)
5620 {
5621 pPattern = (ScPatternAttr*)pPool->GetItem2(ATTR_PATTERN, i);
5622 if (pPattern)
5623 pPattern->UpdateStyleSheet();
5624 }
5625 ((ScPatternAttr&)pPool->GetDefaultItem(ATTR_PATTERN)).UpdateStyleSheet();
5626 }
5627
5628
5629 void ScDocument::StylesToNames()
5630 {
5631 ScPatternAttr::pDoc = this;
5632
5633 ScDocumentPool* pPool = xPoolHelper->GetDocPool();
5634
5635 sal_uInt32 nCount = pPool->GetItemCount2(ATTR_PATTERN);
5636 ScPatternAttr* pPattern;
5637 for (sal_uInt32 i=0; i<nCount; i++)
5638 {
5639 pPattern = (ScPatternAttr*)pPool->GetItem2(ATTR_PATTERN, i);
5640 if (pPattern)
5641 pPattern->StyleToName();
5642 }
5643 ((ScPatternAttr&)pPool->GetDefaultItem(ATTR_PATTERN)).StyleToName();
5644 }
5645
5646
5647 sal_uLong ScDocument::GetCellCount() const
5648 {
5649 sal_uLong nCellCount = 0L;
5650
5651 TableContainer::const_iterator it = maTabs.begin();
5652 for (; it != maTabs.end(); ++it)
5653 if ( *it )
5654 nCellCount += (*it)->GetCellCount();
5655
5656 return nCellCount;
5657 }
5658
5659 SCSIZE ScDocument::GetCellCount(SCTAB nTab, SCCOL nCol) const
5660 {
5661 if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
5662 return 0;
5663
5664 return maTabs[nTab]->GetCellCount(nCol);
5665 }
5666
5667 sal_uLong ScDocument::GetCodeCount() const
5668 {
5669 sal_uLong nCodeCount = 0;
5670
5671 TableContainer::const_iterator it = maTabs.begin();
5672 for (; it != maTabs.end(); ++it)
5673 if ( *it )
5674 nCodeCount += (*it)->GetCodeCount();
5675
5676 return nCodeCount;
5677 }
5678
5679
5680 void ScDocument::PageStyleModified( SCTAB nTab, const OUString& rNewName )
5681 {
5682 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5683 maTabs[nTab]->PageStyleModified( rNewName );
5684 }
5685
5686
5687 void ScDocument::SetPageStyle( SCTAB nTab, const OUString& rName )
5688 {
5689 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5690 maTabs[nTab]->SetPageStyle( rName );
5691 }
5692
5693
5694 const OUString ScDocument::GetPageStyle( SCTAB nTab ) const
5695 {
5696 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5697 return maTabs[nTab]->GetPageStyle();
5698
5699 return OUString();
5700 }
5701
5702
5703 void ScDocument::SetPageSize( SCTAB nTab, const Size& rSize )
5704 {
5705 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5706 maTabs[nTab]->SetPageSize( rSize );
5707 }
5708
5709 Size ScDocument::GetPageSize( SCTAB nTab ) const
5710 {
5711 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5712 return maTabs[nTab]->GetPageSize();
5713
5714 OSL_FAIL("invalid tab");
5715 return Size();
5716 }
5717
5718
5719 void ScDocument::SetRepeatArea( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow )
5720 {
5721 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5722 maTabs[nTab]->SetRepeatArea( nStartCol, nEndCol, nStartRow, nEndRow );
5723 }
5724
5725 void ScDocument::InvalidatePageBreaks(SCTAB nTab)
5726 {
5727 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5728 maTabs[nTab]->InvalidatePageBreaks();
5729 }
5730
5731 void ScDocument::UpdatePageBreaks( SCTAB nTab, const ScRange* pUserArea )
5732 {
5733 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5734 maTabs[nTab]->UpdatePageBreaks( pUserArea );
5735 }
5736
5737 void ScDocument::RemoveManualBreaks( SCTAB nTab )
5738 {
5739 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5740 maTabs[nTab]->RemoveManualBreaks();
5741 }
5742
5743 bool ScDocument::HasManualBreaks( SCTAB nTab ) const
5744 {
5745 if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
5746 return maTabs[nTab]->HasManualBreaks();
5747
5748 OSL_FAIL("invalid tab");
5749 return false;
5750 }
5751
5752
5753 void ScDocument::GetDocStat( ScDocStat& rDocStat )
5754 {
5755 rDocStat.nTableCount = GetTableCount();
5756 rDocStat.aDocName = aDocName;
5757 rDocStat.nCellCount = GetCellCount();
5758 }
5759
5760
5761 bool ScDocument::HasPrintRange()
5762 {
5763 bool bResult = false;
5764
5765 TableContainer::iterator it = maTabs.begin();
5766 for (; it != maTabs.end() && !bResult; ++it)
5767 if ( *it )
5768 bResult = (*it)->IsPrintEntireSheet() || ((*it)->GetPrintRangeCount() > 0);
5769
5770 return bResult;
5771 }
5772
5773
5774 bool ScDocument::IsPrintEntireSheet( SCTAB nTab ) const
5775 {
5776 return (ValidTab(nTab) ) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsPrintEntireSheet();
5777 }
5778
5779
5780 sal_uInt16 ScDocument::GetPrintRangeCount( SCTAB nTab )
5781 {
5782 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5783 return maTabs[nTab]->GetPrintRangeCount();
5784
5785 return 0;
5786 }
5787
5788
5789 const ScRange* ScDocument::GetPrintRange( SCTAB nTab, sal_uInt16 nPos )
5790 {
5791 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5792 return maTabs[nTab]->GetPrintRange(nPos);
5793
5794 return NULL;
5795 }
5796
5797
5798 const ScRange* ScDocument::GetRepeatColRange( SCTAB nTab )
5799 {
5800 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5801 return maTabs[nTab]->GetRepeatColRange();
5802
5803 return NULL;
5804 }
5805
5806
5807 const ScRange* ScDocument::GetRepeatRowRange( SCTAB nTab )
5808 {
5809 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5810 return maTabs[nTab]->GetRepeatRowRange();
5811
5812 return NULL;
5813 }
5814
5815
5816 void ScDocument::ClearPrintRanges( SCTAB nTab )
5817 {
5818 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5819 maTabs[nTab]->ClearPrintRanges();
5820 }
5821
5822
5823 void ScDocument::AddPrintRange( SCTAB nTab, const ScRange& rNew )
5824 {
5825 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5826 maTabs[nTab]->AddPrintRange( rNew );
5827 }
5828
5829
5830 void ScDocument::SetPrintEntireSheet( SCTAB nTab )
5831 {
5832 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5833 maTabs[nTab]->SetPrintEntireSheet();
5834 }
5835
5836
5837 void ScDocument::SetRepeatColRange( SCTAB nTab, const ScRange* pNew )
5838 {
5839 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5840 maTabs[nTab]->SetRepeatColRange( pNew );
5841 }
5842
5843
5844 void ScDocument::SetRepeatRowRange( SCTAB nTab, const ScRange* pNew )
5845 {
5846 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5847 maTabs[nTab]->SetRepeatRowRange( pNew );
5848 }
5849
5850
5851 ScPrintRangeSaver* ScDocument::CreatePrintRangeSaver() const
5852 {
5853 SCTAB nCount = static_cast<SCTAB>(maTabs.size());
5854 ScPrintRangeSaver* pNew = new ScPrintRangeSaver( nCount );
5855 for (SCTAB i=0; i<nCount; i++)
5856 if (maTabs[i])
5857 maTabs[i]->FillPrintSaver( pNew->GetTabData(i) );
5858 return pNew;
5859 }
5860
5861
5862 void ScDocument::RestorePrintRanges( const ScPrintRangeSaver& rSaver )
5863 {
5864 SCTAB nCount = rSaver.GetTabCount();
5865 for (SCTAB i=0; i<nCount && i < static_cast<SCTAB>(maTabs.size()); i++)
5866 if (maTabs[i])
5867 maTabs[i]->RestorePrintRanges( rSaver.GetTabData(i) );
5868 }
5869
5870
5871 bool ScDocument::NeedPageResetAfterTab( SCTAB nTab ) const
5872 {
5873 // Die Seitennummern-Zaehlung faengt bei einer Tabelle neu an, wenn eine
5874 // andere Vorlage als bei der vorherigen gesetzt ist (nur Namen vergleichen)
5875 // und eine Seitennummer angegeben ist (nicht 0)
5876
5877 if ( nTab + 1 < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab+1] )
5878 {
5879 OUString aNew = maTabs[nTab+1]->GetPageStyle();
5880 if ( aNew != maTabs[nTab]->GetPageStyle() )
5881 {
5882 SfxStyleSheetBase* pStyle = xPoolHelper->GetStylePool()->Find( aNew, SFX_STYLE_FAMILY_PAGE );
5883 if ( pStyle )
5884 {
5885 const SfxItemSet& rSet = pStyle->GetItemSet();
5886 sal_uInt16 nFirst = ((const SfxUInt16Item&)rSet.Get(ATTR_PAGE_FIRSTPAGENO)).GetValue();
5887 if ( nFirst != 0 )
5888 return true; // Seitennummer in neuer Vorlage angegeben
5889 }
5890 }
5891 }
5892
5893 return false; // sonst nicht
5894 }
5895
5896 SfxUndoManager* ScDocument::GetUndoManager()
5897 {
5898 if (!mpUndoManager)
5899 mpUndoManager = new SfxUndoManager;
5900 return mpUndoManager;
5901 }
5902
5903 ScRowBreakIterator* ScDocument::GetRowBreakIterator(SCTAB nTab) const
5904 {
5905 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5906 return new ScRowBreakIterator(maTabs[nTab]->maRowPageBreaks);
5907 return NULL;
5908 }
5909
5910 void ScDocument::AddSubTotalCell(ScFormulaCell* pCell)
5911 {
5912 maSubTotalCells.insert(pCell);
5913 }
5914
5915 void ScDocument::RemoveSubTotalCell(ScFormulaCell* pCell)
5916 {
5917 maSubTotalCells.erase(pCell);
5918 }
5919
5920 namespace {
5921
5922 bool lcl_hasDirtyRange(ScFormulaCell* pCell, const ScRange& rDirtyRange)
5923 {
5924 ScDetectiveRefIter aRefIter(pCell);
5925 ScRange aRange;
5926 while (aRefIter.GetNextRef(aRange))
5927 {
5928 if (aRange.Intersects(rDirtyRange))
5929 return true;
5930 }
5931 return false;
5932 }
5933
5934 }
5935
5936 void ScDocument::SetSubTotalCellsDirty(const ScRange& rDirtyRange)
5937 {
5938 // to update the list by skipping cells that no longer contain subtotal function.
5939 set<ScFormulaCell*> aNewSet;
5940
5941 bool bOldRecalc = GetAutoCalc();
5942 SetAutoCalc(false);
5943 set<ScFormulaCell*>::iterator itr = maSubTotalCells.begin(), itrEnd = maSubTotalCells.end();
5944 for (; itr != itrEnd; ++itr)
5945 {
5946 ScFormulaCell* pCell = *itr;
5947 if (pCell->IsSubTotal())
5948 {
5949 aNewSet.insert(pCell);
5950 if (lcl_hasDirtyRange(pCell, rDirtyRange))
5951 pCell->SetDirty();
5952 }
5953 }
5954
5955 SetAutoCalc(bOldRecalc);
5956 maSubTotalCells.swap(aNewSet); // update the list.
5957 }
5958
5959 sal_uInt16 ScDocument::GetTextWidth( const ScAddress& rPos ) const
5960 {
5961 SCTAB nTab = rPos.Tab();
5962 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5963 return maTabs[nTab]->GetTextWidth(rPos.Col(), rPos.Row());
5964
5965 return 0;
5966 }
5967
5968 void ScDocument::SetTextWidth( const ScAddress& rPos, sal_uInt16 nWidth )
5969 {
5970 SCTAB nTab = rPos.Tab();
5971 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5972 maTabs[nTab]->SetTextWidth(rPos.Col(), rPos.Row(), nWidth);
5973 }
5974
5975 sal_uInt8 ScDocument::GetScriptType( const ScAddress& rPos ) const
5976 {
5977 SCTAB nTab = rPos.Tab();
5978 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5979 return maTabs[nTab]->GetScriptType(rPos.Col(), rPos.Row());
5980
5981 return 0;
5982 }
5983
5984 void ScDocument::SetScriptType( const ScAddress& rPos, sal_uInt8 nType )
5985 {
5986 SCTAB nTab = rPos.Tab();
5987 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
5988 maTabs[nTab]->SetScriptType(rPos.Col(), rPos.Row(), nType);
5989 }
5990
5991 void ScDocument::EnableUndo( bool bVal )
5992 {
5993 // The undo manager increases lock count every time undo is disabled.
5994 // Because of this, we shouldn't disable undo unless it's currently
5995 // enabled, or else re-enabling it may not actually re-enable undo unless
5996 // the lock count becomes zero.
5997
5998 if (bVal != GetUndoManager()->IsUndoEnabled())
5999 {
6000 GetUndoManager()->EnableUndo(bVal);
6001 if( pDrawLayer ) pDrawLayer->EnableUndo(bVal);
6002 }
6003
6004 mbUndoEnabled = bVal;
6005 }
6006
6007 bool ScDocument::IsUserInteractionEnabled() const
6008 {
6009 return mbUserInteractionEnabled;
6010 }
6011
6012 void ScDocument::EnableUserInteraction( bool bVal )
6013 {
6014 mbUserInteractionEnabled = bVal;
6015 }
6016
6017 bool ScDocument::IsInVBAMode() const
6018 {
6019 if (!pShell)
6020 return false;
6021
6022 try
6023 {
6024 uno::Reference<script::vba::XVBACompatibility> xVBA(
6025 pShell->GetBasicContainer(), uno::UNO_QUERY);
6026
6027 return xVBA.is() && xVBA->getVBACompatibilityMode();
6028 }
6029 catch (const lang::NotInitializedException&) {}
6030
6031 return false;
6032 }
6033
6034 ScNotes* ScDocument::GetNotes(SCTAB nTab)
6035 {
6036 if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
6037 return maTabs[nTab]->GetNotes();
6038
6039 return NULL;
6040 }
6041
6042 void ScDocument::SetAutoNameCache( ScAutoNameCache* pCache )
6043 {
6044 delete pAutoNameCache;
6045 pAutoNameCache = pCache;
6046 }
6047
6048 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE