Line data Source code
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/editeng.hxx>
24 : #include <editeng/forbiddencharacterstable.hxx>
25 : #include <osl/thread.h>
26 : #include <svx/xtable.hxx>
27 : #include <sfx2/linkmgr.hxx>
28 : #include <svx/svdpool.hxx>
29 : #include <svx/svdobj.hxx>
30 : #include <sfx2/bindings.hxx>
31 : #include <sfx2/objsh.hxx>
32 : #include <sfx2/docfile.hxx>
33 : #include <sfx2/printer.hxx>
34 : #include <svl/zforlist.hxx>
35 : #include <svl/zformat.hxx>
36 : #include <vcl/virdev.hxx>
37 : #include <comphelper/processfactory.hxx>
38 : #include <svl/PasswordHelper.hxx>
39 : #include <svl/sharedstringpool.hxx>
40 : #include <tools/tenccvt.hxx>
41 : #include <tools/urlobj.hxx>
42 : #include <rtl/crc.h>
43 : #include <basic/basmgr.hxx>
44 :
45 : #include "document.hxx"
46 : #include "table.hxx"
47 : #include "attrib.hxx"
48 : #include "patattr.hxx"
49 : #include "rangenam.hxx"
50 : #include "dbdata.hxx"
51 : #include "pivot.hxx"
52 : #include "docpool.hxx"
53 : #include "stlpool.hxx"
54 : #include "stlsheet.hxx"
55 : #include "globstr.hrc"
56 : #include "chartarr.hxx"
57 : #include "chartlock.hxx"
58 : #include "rechead.hxx"
59 : #include "global.hxx"
60 : #include "brdcst.hxx"
61 : #include "bcaslot.hxx"
62 : #include "adiasync.hxx"
63 : #include "addinlis.hxx"
64 : #include "chartlis.hxx"
65 : #include "markdata.hxx"
66 : #include "conditio.hxx"
67 : #include "colorscale.hxx"
68 : #include "validat.hxx"
69 : #include "progress.hxx"
70 : #include "detdata.hxx"
71 : #include "sc.hrc"
72 : #include "ddelink.hxx"
73 : #include "chgtrack.hxx"
74 : #include "chgviset.hxx"
75 : #include "editutil.hxx"
76 : #include "hints.hxx"
77 : #include "dpobject.hxx"
78 : #include "scrdata.hxx"
79 : #include "poolhelp.hxx"
80 : #include "unoreflist.hxx"
81 : #include "listenercalls.hxx"
82 : #include "recursionhelper.hxx"
83 : #include "lookupcache.hxx"
84 : #include "externalrefmgr.hxx"
85 : #include "appoptio.hxx"
86 : #include "scmod.hxx"
87 : #include "../../ui/inc/viewutil.hxx"
88 : #include "tabprotection.hxx"
89 : #include "formulaparserpool.hxx"
90 : #include "clipparam.hxx"
91 : #include "macromgr.hxx"
92 : #include "formulacell.hxx"
93 : #include "clipcontext.hxx"
94 : #include "refupdatecontext.hxx"
95 : #include "refreshtimerprotector.hxx"
96 : #include "scopetools.hxx"
97 : #include "formulagroup.hxx"
98 : #include "documentlinkmgr.hxx"
99 : #include "interpre.hxx"
100 : #include <tokenstringcontext.hxx>
101 : #include "docsh.hxx"
102 :
103 : using namespace com::sun::star;
104 :
105 : // pImpl because including lookupcache.hxx in document.hxx isn't wanted, and
106 : // dtor plus helpers are convenient.
107 12 : struct ScLookupCacheMapImpl
108 : {
109 : ScLookupCacheMap aCacheMap;
110 12 : ~ScLookupCacheMapImpl()
111 12 : {
112 12 : freeCaches();
113 12 : }
114 10 : void clear()
115 : {
116 10 : freeCaches();
117 : // Zap map.
118 10 : ScLookupCacheMap aTmp;
119 10 : aCacheMap.swap( aTmp);
120 10 : }
121 : private:
122 22 : void freeCaches()
123 : {
124 34 : for (ScLookupCacheMap::iterator it( aCacheMap.begin()); it != aCacheMap.end(); ++it)
125 12 : delete (*it).second;
126 22 : }
127 : };
128 :
129 : // STATIC DATA -----------------------------------------------------------
130 :
131 4242 : ScDocument::ScDocument( ScDocumentMode eMode, SfxObjectShell* pDocShell ) :
132 4242 : mpCellStringPool(new svl::SharedStringPool(ScGlobal::pCharClass)),
133 : mpFormulaGroupCxt(NULL),
134 4242 : maCalcConfig( ScInterpreter::GetGlobalConfig()),
135 : mpUndoManager( NULL ),
136 : pEditEngine( NULL ),
137 : pNoteEngine( NULL ),
138 : pShell( pDocShell ),
139 : pPrinter( NULL ),
140 : pVirtualDevice_100th_mm( NULL ),
141 : pDrawLayer( NULL ),
142 : pValidationList( NULL ),
143 : pFormatExchangeList( NULL ),
144 : pRangeName(NULL),
145 : pDPCollection( NULL ),
146 : pFormulaTree( NULL ),
147 : pEOFormulaTree( NULL ),
148 : pFormulaTrack( NULL ),
149 : pEOFormulaTrack( NULL ),
150 : pClipData( NULL ),
151 : pDetOpList(NULL),
152 : pChangeTrack( NULL ),
153 : pUnoBroadcaster( NULL ),
154 : pUnoListenerCalls( NULL ),
155 : pUnoRefUndoList( NULL ),
156 : pChangeViewSettings( NULL ),
157 : pScriptTypeData( NULL ),
158 : pCacheFieldEditEngine( NULL ),
159 : pViewOptions( NULL ),
160 : pDocOptions( NULL ),
161 : pExtDocOptions( NULL ),
162 : pConsolidateDlgData( NULL ),
163 : pRecursionHelper( NULL ),
164 : pAutoNameCache( NULL ),
165 : pLookupCacheMapImpl( NULL ),
166 : pPreviewFont( NULL ),
167 : pPreviewCellStyle( NULL ),
168 : nUnoObjectId( 0 ),
169 : nRangeOverflowType( 0 ),
170 : aCurTextWidthCalcPos(MAXCOL,0,0),
171 : aTableOpList( 0 ),
172 : nFormulaCodeInTree(0),
173 : nXMLImportedFormulaCount( 0 ),
174 : nInterpretLevel(0),
175 : nMacroInterpretLevel(0),
176 : nInterpreterTableOpLevel(0),
177 : nSrcVer( SC_CURRENT_VERSION ),
178 : nSrcMaxRow( MAXROW ),
179 : nFormulaTrackCount(0),
180 : bHardRecalcState(false),
181 : nVisibleTab( 0 ),
182 : eLinkMode(LM_UNKNOWN),
183 4242 : bAutoCalc( eMode == SCDOCMODE_DOCUMENT ),
184 : bAutoCalcShellDisabled( false ),
185 : bForcedFormulaPending( false ),
186 : bCalculatingFormulaTree( false ),
187 4242 : bIsClip( eMode == SCDOCMODE_CLIP ),
188 4242 : bIsUndo( eMode == SCDOCMODE_UNDO ),
189 : bIsVisible( false ),
190 : bIsEmbedded( false ),
191 : bInsertingFromOtherDoc( false ),
192 : bLoadingMedium( false ),
193 : bImportingXML( false ),
194 : bCalcingAfterLoad( false ),
195 : bNoListening( false ),
196 : mbIdleEnabled(true),
197 : bInLinkUpdate( false ),
198 : bChartListenerCollectionNeedsUpdate( false ),
199 : bHasForcedFormulas( false ),
200 : bInDtorClear( false ),
201 : bExpandRefs( false ),
202 : bDetectiveDirty( false ),
203 : nMacroCallMode( SC_MACROCALL_ALLOWED ),
204 : bHasMacroFunc( false ),
205 : nVisSpellState( 0 ),
206 : nAsianCompression(SC_ASIANCOMPRESSION_INVALID),
207 : nAsianKerning(SC_ASIANKERNING_INVALID),
208 : bPastingDrawFromOtherDoc( false ),
209 : nInDdeLinkUpdate( 0 ),
210 : bInUnoBroadcast( false ),
211 : bInUnoListenerCall( false ),
212 : eGrammar( formula::FormulaGrammar::GRAM_NATIVE ),
213 : bStyleSheetUsageInvalid( true ),
214 : mbUndoEnabled( true ),
215 : mbAdjustHeightEnabled( true ),
216 : mbExecuteLinkEnabled( true ),
217 : mbChangeReadOnlyEnabled( false ),
218 : mbStreamValidLocked( false ),
219 : mbUserInteractionEnabled(true),
220 : mnNamedRangesLockCount(0),
221 25452 : mbUseEmbedFonts(false)
222 : {
223 4242 : SetStorageGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT);
224 :
225 4242 : eSrcSet = osl_getThreadTextEncoding();
226 :
227 4242 : if ( eMode == SCDOCMODE_DOCUMENT )
228 : {
229 2258 : xPoolHelper = new ScPoolHelper( this );
230 :
231 2258 : pBASM = new ScBroadcastAreaSlotMachine( this );
232 2258 : pChartListenerCollection = new ScChartListenerCollection( this );
233 2258 : pRefreshTimerControl = new ScRefreshTimerControl;
234 : }
235 : else
236 : {
237 1984 : pBASM = NULL;
238 1984 : pChartListenerCollection = NULL;
239 1984 : pRefreshTimerControl = NULL;
240 : }
241 4242 : pDBCollection = new ScDBCollection(this);
242 4242 : pSelectionAttr = NULL;
243 4242 : pChartCollection = new ScChartCollection;
244 4242 : apTemporaryChartLock.reset( new ScTemporaryChartLock(this) );
245 4242 : xColNameRanges = new ScRangePairList;
246 4242 : xRowNameRanges = new ScRangePairList;
247 4242 : ImplCreateOptions();
248 : // languages for a visible document are set by docshell later (from options)
249 4242 : SetLanguage( ScGlobal::eLnge, ScGlobal::eLnge, ScGlobal::eLnge );
250 :
251 4242 : aTrackTimer.SetTimeoutHdl( LINK( this, ScDocument, TrackTimeHdl ) );
252 4242 : aTrackTimer.SetTimeout( 100 );
253 4242 : }
254 :
255 1464 : sfx2::LinkManager* ScDocument::GetLinkManager()
256 : {
257 1464 : return GetDocLinkManager().getLinkManager(true);
258 : }
259 :
260 26 : const sfx2::LinkManager* ScDocument::GetLinkManager() const
261 : {
262 26 : return GetDocLinkManager().getExistingLinkManager();
263 : }
264 :
265 5793 : sc::DocumentLinkManager& ScDocument::GetDocLinkManager()
266 : {
267 5793 : if (!mpDocLinkMgr)
268 1390 : mpDocLinkMgr.reset(new sc::DocumentLinkManager(*this, pShell));
269 5793 : return *mpDocLinkMgr;
270 : }
271 :
272 570 : const sc::DocumentLinkManager& ScDocument::GetDocLinkManager() const
273 : {
274 570 : return const_cast<ScDocument*>(this)->GetDocLinkManager();
275 : }
276 :
277 4740 : void ScDocument::SetStorageGrammar( formula::FormulaGrammar::Grammar eGram )
278 : {
279 : OSL_PRECOND(
280 : eGram == formula::FormulaGrammar::GRAM_ODFF ||
281 : eGram == formula::FormulaGrammar::GRAM_PODF,
282 : "ScDocument::SetStorageGrammar: wrong storage grammar");
283 :
284 4740 : eStorageGrammar = eGram;
285 :
286 : // FIXME: the XML import shouldn't strip brackets, the compiler should
287 : // digest them instead, which could also speedup reference recognition
288 : // during import.
289 :
290 : eXmlImportGrammar = formula::FormulaGrammar::mergeToGrammar( eGram,
291 4740 : formula::FormulaGrammar::CONV_OOO);
292 4740 : }
293 :
294 544 : void ScDocument::SetDocVisible( bool bSet )
295 : {
296 : // called from view ctor - only for a visible document,
297 : // each new sheet's RTL flag is initialized from the locale
298 544 : bIsVisible = bSet;
299 544 : }
300 :
301 54 : sal_uInt32 ScDocument::GetDocumentID() const
302 : {
303 54 : const ScDocument* pThis = this;
304 54 : sal_uInt32 nCrc = rtl_crc32( 0, &pThis, sizeof(ScDocument*) );
305 : // the this pointer only might not be sufficient
306 54 : nCrc = rtl_crc32( nCrc, &pShell, sizeof(SfxObjectShell*) );
307 54 : return nCrc;
308 : }
309 :
310 0 : void ScDocument::StartChangeTracking()
311 : {
312 0 : if (!pChangeTrack)
313 0 : pChangeTrack = new ScChangeTrack( this );
314 0 : }
315 :
316 12 : void ScDocument::EndChangeTracking()
317 : {
318 12 : delete pChangeTrack;
319 12 : pChangeTrack = NULL;
320 12 : }
321 :
322 12 : void ScDocument::SetChangeTrack( ScChangeTrack* pTrack )
323 : {
324 : OSL_ENSURE( pTrack->GetDocument() == this, "SetChangeTrack: different documents" );
325 12 : if ( !pTrack || pTrack == pChangeTrack || pTrack->GetDocument() != this )
326 12 : return ;
327 12 : EndChangeTracking();
328 12 : pChangeTrack = pTrack;
329 : }
330 :
331 0 : IMPL_LINK_NOARG(ScDocument, TrackTimeHdl)
332 : {
333 0 : if ( ScDdeLink::IsInUpdate() ) // nicht verschachteln
334 : {
335 0 : aTrackTimer.Start(); // spaeter nochmal versuchen
336 : }
337 0 : else if (pShell) // ausfuehren
338 : {
339 0 : TrackFormulas();
340 0 : pShell->Broadcast( SfxSimpleHint( FID_DATACHANGED ) );
341 :
342 : // modified...
343 :
344 0 : if (!pShell->IsModified())
345 : {
346 0 : pShell->SetModified( true );
347 0 : SfxBindings* pBindings = GetViewBindings();
348 0 : if (pBindings)
349 : {
350 0 : pBindings->Invalidate( SID_SAVEDOC );
351 0 : pBindings->Invalidate( SID_DOC_MODIFIED );
352 : }
353 : }
354 : }
355 :
356 0 : return 0;
357 : }
358 :
359 1324 : void ScDocument::SetExpandRefs( bool bVal )
360 : {
361 1324 : bExpandRefs = bVal;
362 1324 : }
363 :
364 4 : void ScDocument::StartTrackTimer()
365 : {
366 4 : if (!aTrackTimer.IsActive()) // nicht ewig aufschieben
367 2 : aTrackTimer.Start();
368 4 : }
369 :
370 8384 : ScDocument::~ScDocument()
371 : {
372 : OSL_PRECOND( !bInLinkUpdate, "bInLinkUpdate in dtor" );
373 :
374 4192 : bInDtorClear = true;
375 :
376 : // first of all disable all refresh timers by deleting the control
377 4192 : if ( pRefreshTimerControl )
378 : { // To be sure there isn't anything running do it with a protector,
379 : // this ensures also that nothing needs the control anymore.
380 2212 : ScRefreshTimerProtector aProt( GetRefreshTimerControlAddress() );
381 2212 : delete pRefreshTimerControl, pRefreshTimerControl = NULL;
382 : }
383 :
384 4192 : mxFormulaParserPool.reset();
385 : // Destroy the external ref mgr instance here because it has a timer
386 : // which needs to be stopped before the app closes.
387 4192 : pExternalRefMgr.reset();
388 :
389 4192 : ScAddInAsync::RemoveDocument( this );
390 4192 : ScAddInListener::RemoveDocument( this );
391 4192 : DELETEZ( pChartListenerCollection); // vor pBASM wg. evtl. Listener!
392 4192 : DELETEZ( pLookupCacheMapImpl); // before pBASM because of listeners
393 : // BroadcastAreas vor allen Zellen zerstoeren um unnoetige
394 : // Einzel-EndListenings der Formelzellen zu vermeiden
395 4192 : delete pBASM; // BroadcastAreaSlotMachine
396 4192 : pBASM = NULL;
397 :
398 4192 : delete pUnoBroadcaster; // broadcasted nochmal SFX_HINT_DYING
399 4192 : pUnoBroadcaster = NULL;
400 :
401 4192 : delete pUnoRefUndoList;
402 4192 : delete pUnoListenerCalls;
403 :
404 4192 : Clear( true ); // true = from destructor (needed for SdrModel::ClearModel)
405 :
406 4192 : if (pValidationList)
407 : {
408 74 : for( ScValidationDataList::iterator it = pValidationList->begin(); it != pValidationList->end(); ++it )
409 56 : delete *it;
410 18 : pValidationList->clear();
411 18 : DELETEZ(pValidationList);
412 : }
413 4192 : delete pRangeName;
414 4192 : delete pDBCollection;
415 4192 : delete pSelectionAttr;
416 4192 : apTemporaryChartLock.reset();
417 4192 : delete pChartCollection;
418 4192 : DeleteDrawLayer();
419 4192 : delete pFormatExchangeList;
420 4192 : delete pPrinter;
421 4192 : ImplDeleteOptions();
422 4192 : delete pConsolidateDlgData;
423 4192 : delete pClipData;
424 4192 : delete pDetOpList; // loescht auch die Eintraege
425 4192 : delete pChangeTrack;
426 4192 : delete pEditEngine;
427 4192 : delete pNoteEngine;
428 4192 : delete pChangeViewSettings; // und weg damit
429 4192 : delete pVirtualDevice_100th_mm;
430 :
431 4192 : delete pDPCollection;
432 :
433 : // delete the EditEngine before destroying the xPoolHelper
434 4192 : delete pCacheFieldEditEngine;
435 :
436 4192 : if ( xPoolHelper.is() && !bIsClip )
437 4060 : xPoolHelper->SourceDocumentGone();
438 4192 : xPoolHelper.clear();
439 :
440 4192 : delete pScriptTypeData;
441 4192 : delete pRecursionHelper;
442 :
443 4192 : delete pPreviewFont;
444 : SAL_WARN_IF( pAutoNameCache, "sc.core", "AutoNameCache still set in dtor" );
445 :
446 4192 : mpFormulaGroupCxt.reset();
447 4192 : mpCellStringPool.reset();
448 4192 : }
449 :
450 146 : void ScDocument::InitClipPtrs( ScDocument* pSourceDoc )
451 : {
452 : OSL_ENSURE(bIsClip, "InitClipPtrs and not bIsClip");
453 :
454 146 : if (pValidationList)
455 : {
456 0 : for(ScValidationDataList::iterator it = pValidationList->begin(); it != pValidationList->end(); ++it )
457 0 : delete *it;
458 0 : pValidationList->clear();
459 0 : DELETEZ(pValidationList);
460 : }
461 :
462 146 : Clear();
463 :
464 146 : SharePooledResources(pSourceDoc);
465 :
466 : // bedingte Formate / Gueltigkeiten
467 : //! Vorlagen kopieren?
468 146 : const ScValidationDataList* pSourceValid = pSourceDoc->pValidationList;
469 146 : if ( pSourceValid )
470 4 : pValidationList = new ScValidationDataList(this, *pSourceValid);
471 :
472 : // Links in Stream speichern
473 146 : delete pClipData;
474 146 : if (pSourceDoc->GetDocLinkManager().hasDdeLinks())
475 : {
476 0 : pClipData = new SvMemoryStream;
477 0 : pSourceDoc->SaveDdeLinks(*pClipData);
478 : }
479 : else
480 146 : pClipData = NULL;
481 :
482 : // Options pointers exist (ImplCreateOptions) for any document.
483 : // Must be copied for correct results in OLE objects (#i42666#).
484 146 : SetDocOptions( pSourceDoc->GetDocOptions() );
485 146 : SetViewOptions( pSourceDoc->GetViewOptions() );
486 146 : }
487 :
488 1571603 : SvNumberFormatter* ScDocument::GetFormatTable() const
489 : {
490 1571603 : return xPoolHelper->GetFormTable();
491 : }
492 :
493 0 : SvNumberFormatter* ScDocument::CreateFormatTable() const
494 : {
495 0 : return xPoolHelper->CreateNumberFormatter();
496 : }
497 :
498 2715 : SfxItemPool* ScDocument::GetEditPool() const
499 : {
500 2715 : return xPoolHelper->GetEditPool();
501 : }
502 :
503 2639 : SfxItemPool* ScDocument::GetEnginePool() const
504 : {
505 2639 : return xPoolHelper->GetEnginePool();
506 : }
507 :
508 524 : ScFieldEditEngine& ScDocument::GetEditEngine()
509 : {
510 524 : if ( !pEditEngine )
511 : {
512 62 : pEditEngine = new ScFieldEditEngine(this, GetEnginePool(), GetEditPool());
513 62 : pEditEngine->SetUpdateMode( false );
514 62 : pEditEngine->EnableUndo( false );
515 62 : pEditEngine->SetRefMapMode( MAP_100TH_MM );
516 62 : ApplyAsianEditSettings( *pEditEngine );
517 : }
518 524 : return *pEditEngine;
519 : }
520 :
521 10 : ScNoteEditEngine& ScDocument::GetNoteEngine()
522 : {
523 10 : if ( !pNoteEngine )
524 : {
525 4 : pNoteEngine = new ScNoteEditEngine( GetEnginePool(), GetEditPool() );
526 4 : pNoteEngine->SetUpdateMode( false );
527 4 : pNoteEngine->EnableUndo( false );
528 4 : pNoteEngine->SetRefMapMode( MAP_100TH_MM );
529 4 : ApplyAsianEditSettings( *pNoteEngine );
530 4 : const SfxItemSet& rItemSet = GetDefPattern()->GetItemSet();
531 4 : SfxItemSet* pEEItemSet = new SfxItemSet( pNoteEngine->GetEmptyItemSet() );
532 4 : ScPatternAttr::FillToEditItemSet( *pEEItemSet, rItemSet );
533 4 : pNoteEngine->SetDefaults( pEEItemSet ); // edit engine takes ownership
534 : }
535 10 : return *pNoteEngine;
536 : }
537 :
538 110 : void ScDocument::ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks )
539 : {
540 110 : if (bIsClip)
541 : {
542 110 : InitClipPtrs(pSourceDoc);
543 :
544 302 : for (SCTAB i = 0; i < static_cast<SCTAB>(pSourceDoc->maTabs.size()); i++)
545 192 : if (pSourceDoc->maTabs[i])
546 192 : if (!pMarks || pMarks->GetTableSelect(i))
547 : {
548 108 : OUString aString;
549 108 : pSourceDoc->maTabs[i]->GetName(aString);
550 108 : if ( i < static_cast<SCTAB>(maTabs.size()) )
551 : {
552 0 : maTabs[i] = new ScTable(this, i, aString);
553 :
554 : }
555 : else
556 : {
557 108 : if( i > static_cast<SCTAB>(maTabs.size()) )
558 : {
559 0 : maTabs.resize(i, NULL );
560 : }
561 108 : maTabs.push_back(new ScTable(this, i, aString));
562 : }
563 108 : maTabs[i]->SetLayoutRTL( pSourceDoc->maTabs[i]->IsLayoutRTL() );
564 : }
565 : }
566 : else
567 : {
568 : OSL_FAIL("ResetClip");
569 : }
570 110 : }
571 :
572 36 : void ScDocument::ResetClip( ScDocument* pSourceDoc, SCTAB nTab )
573 : {
574 36 : if (bIsClip)
575 : {
576 36 : InitClipPtrs(pSourceDoc);
577 36 : if (nTab >= static_cast<SCTAB>(maTabs.size()))
578 : {
579 36 : maTabs.resize(nTab+1, NULL );
580 : }
581 36 : maTabs[nTab] = new ScTable(this, nTab,
582 72 : OUString("baeh"));
583 36 : if (nTab < static_cast<SCTAB>(pSourceDoc->maTabs.size()) && pSourceDoc->maTabs[nTab])
584 36 : maTabs[nTab]->SetLayoutRTL( pSourceDoc->maTabs[nTab]->IsLayoutRTL() );
585 : }
586 : else
587 : {
588 : OSL_FAIL("ResetClip");
589 : }
590 36 : }
591 :
592 9332 : void ScDocument::EnsureTable( SCTAB nTab )
593 : {
594 9332 : bool bExtras = !bIsUndo; // Spaltenbreiten, Zeilenhoehen, Flags
595 9332 : if (static_cast<size_t>(nTab) >= maTabs.size())
596 0 : maTabs.resize(nTab+1, NULL);
597 :
598 9332 : if (!maTabs[nTab])
599 0 : maTabs[nTab] = new ScTable(this, nTab, "temp", bExtras, bExtras);
600 9332 : }
601 :
602 147200 : ScRefCellValue ScDocument::GetRefCellValue( const ScAddress& rPos )
603 : {
604 147200 : if (!TableExists(rPos.Tab()))
605 0 : return ScRefCellValue(); // empty
606 :
607 147200 : return maTabs[rPos.Tab()]->GetRefCellValue(rPos.Col(), rPos.Row());
608 : }
609 :
610 93341 : svl::SharedStringPool& ScDocument::GetSharedStringPool()
611 : {
612 93341 : return *mpCellStringPool;
613 : }
614 :
615 0 : const svl::SharedStringPool& ScDocument::GetSharedStringPool() const
616 : {
617 0 : return *mpCellStringPool;
618 : }
619 :
620 3572 : bool ScDocument::GetPrintArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow,
621 : bool bNotes ) const
622 : {
623 3572 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
624 : {
625 3572 : bool bAny = maTabs[nTab]->GetPrintArea( rEndCol, rEndRow, bNotes );
626 3572 : if (pDrawLayer)
627 : {
628 2672 : ScRange aDrawRange(0,0,nTab, MAXCOL,MAXROW,nTab);
629 2672 : if (DrawGetPrintArea( aDrawRange, true, true ))
630 : {
631 972 : if (aDrawRange.aEnd.Col()>rEndCol) rEndCol=aDrawRange.aEnd.Col();
632 972 : if (aDrawRange.aEnd.Row()>rEndRow) rEndRow=aDrawRange.aEnd.Row();
633 972 : bAny = true;
634 : }
635 : }
636 3572 : return bAny;
637 : }
638 :
639 0 : rEndCol = 0;
640 0 : rEndRow = 0;
641 0 : return false;
642 : }
643 :
644 0 : bool ScDocument::GetPrintAreaHor( SCTAB nTab, SCROW nStartRow, SCROW nEndRow,
645 : SCCOL& rEndCol, bool bNotes ) const
646 : {
647 0 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
648 : {
649 0 : bool bAny = maTabs[nTab]->GetPrintAreaHor( nStartRow, nEndRow, rEndCol, bNotes );
650 0 : if (pDrawLayer)
651 : {
652 0 : ScRange aDrawRange(0,nStartRow,nTab, MAXCOL,nEndRow,nTab);
653 0 : if (DrawGetPrintArea( aDrawRange, true, false ))
654 : {
655 0 : if (aDrawRange.aEnd.Col()>rEndCol) rEndCol=aDrawRange.aEnd.Col();
656 0 : bAny = true;
657 : }
658 : }
659 0 : return bAny;
660 : }
661 :
662 0 : rEndCol = 0;
663 0 : return false;
664 : }
665 :
666 80 : bool ScDocument::GetPrintAreaVer( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol,
667 : SCROW& rEndRow, bool bNotes ) const
668 : {
669 80 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
670 : {
671 80 : bool bAny = maTabs[nTab]->GetPrintAreaVer( nStartCol, nEndCol, rEndRow, bNotes );
672 80 : if (pDrawLayer)
673 : {
674 68 : ScRange aDrawRange(nStartCol,0,nTab, nEndCol,MAXROW,nTab);
675 68 : if (DrawGetPrintArea( aDrawRange, false, true ))
676 : {
677 8 : if (aDrawRange.aEnd.Row()>rEndRow) rEndRow=aDrawRange.aEnd.Row();
678 8 : bAny = true;
679 : }
680 : }
681 80 : return bAny;
682 : }
683 :
684 0 : rEndRow = 0;
685 0 : return false;
686 : }
687 :
688 2988 : bool ScDocument::GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const
689 : {
690 2988 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
691 : {
692 2988 : bool bAny = maTabs[nTab]->GetDataStart( rStartCol, rStartRow );
693 2988 : if (pDrawLayer)
694 : {
695 2452 : ScRange aDrawRange(0,0,nTab, MAXCOL,MAXROW,nTab);
696 2452 : if (DrawGetPrintArea( aDrawRange, true, true ))
697 : {
698 1016 : if (aDrawRange.aStart.Col()<rStartCol) rStartCol=aDrawRange.aStart.Col();
699 1016 : if (aDrawRange.aStart.Row()<rStartRow) rStartRow=aDrawRange.aStart.Row();
700 1016 : bAny = true;
701 : }
702 : }
703 2988 : return bAny;
704 : }
705 :
706 0 : rStartCol = 0;
707 0 : rStartRow = 0;
708 0 : return false;
709 : }
710 :
711 28 : bool ScDocument::MoveTab( SCTAB nOldPos, SCTAB nNewPos, ScProgress* pProgress )
712 : {
713 28 : if (nOldPos == nNewPos)
714 0 : return false;
715 :
716 28 : SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
717 28 : if(nTabCount < 2)
718 0 : return false;
719 :
720 28 : bool bValid = false;
721 28 : if (ValidTab(nOldPos) && nOldPos < nTabCount )
722 : {
723 28 : if (maTabs[nOldPos])
724 : {
725 28 : sc::AutoCalcSwitch aACSwitch(*this, false);
726 :
727 28 : SetNoListening( true );
728 28 : if (nNewPos == SC_TAB_APPEND || nNewPos >= nTabCount)
729 0 : nNewPos = nTabCount-1;
730 :
731 : // Referenz-Updaterei
732 : //! mit UpdateReference zusammenfassen!
733 :
734 56 : sc::RefUpdateMoveTabContext aCxt(nOldPos, nNewPos);
735 :
736 28 : SCsTAB nDz = ((SCsTAB)nNewPos) - (SCsTAB)nOldPos;
737 28 : ScRange aSourceRange( 0,0,nOldPos, MAXCOL,MAXROW,nOldPos );
738 28 : if (pRangeName)
739 2 : pRangeName->UpdateMoveTab(aCxt);
740 :
741 28 : pDBCollection->UpdateMoveTab( nOldPos, nNewPos );
742 28 : xColNameRanges->UpdateReference( URM_REORDER, this, aSourceRange, 0,0,nDz );
743 28 : xRowNameRanges->UpdateReference( URM_REORDER, this, aSourceRange, 0,0,nDz );
744 28 : if (pDPCollection)
745 4 : pDPCollection->UpdateReference( URM_REORDER, aSourceRange, 0,0,nDz );
746 28 : if (pDetOpList)
747 0 : pDetOpList->UpdateReference( this, URM_REORDER, aSourceRange, 0,0,nDz );
748 : UpdateChartRef( URM_REORDER,
749 28 : 0,0,nOldPos, MAXCOL,MAXROW,nOldPos, 0,0,nDz );
750 28 : UpdateRefAreaLinks( URM_REORDER, aSourceRange, 0,0,nDz );
751 28 : if ( pValidationList )
752 0 : pValidationList->UpdateMoveTab(aCxt);
753 28 : if ( pUnoBroadcaster )
754 : pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_REORDER,
755 28 : aSourceRange, 0,0,nDz ) );
756 :
757 28 : ScTable* pSaveTab = maTabs[nOldPos];
758 28 : maTabs.erase(maTabs.begin()+nOldPos);
759 28 : maTabs.insert(maTabs.begin()+nNewPos, pSaveTab);
760 28 : TableContainer::iterator it = maTabs.begin();
761 106 : for (SCTAB i = 0; i < nTabCount; i++)
762 78 : if (maTabs[i])
763 78 : maTabs[i]->UpdateMoveTab(aCxt, i, pProgress);
764 28 : it = maTabs.begin();
765 106 : for (; it != maTabs.end(); ++it)
766 78 : if (*it)
767 78 : (*it)->UpdateCompile();
768 28 : SetNoListening( false );
769 28 : it = maTabs.begin();
770 106 : for (; it != maTabs.end(); ++it)
771 78 : if (*it)
772 78 : (*it)->StartAllListeners();
773 : // sheet names of references may not be valid until sheet is moved
774 28 : pChartListenerCollection->UpdateScheduledSeriesRanges();
775 :
776 28 : sc::SetFormulaDirtyContext aFormulaDirtyCxt;
777 28 : SetAllFormulasDirty(aFormulaDirtyCxt);
778 :
779 28 : if (pDrawLayer)
780 2 : DrawMovePage( static_cast<sal_uInt16>(nOldPos), static_cast<sal_uInt16>(nNewPos) );
781 :
782 56 : bValid = true;
783 : }
784 : }
785 28 : return bValid;
786 : }
787 :
788 12 : bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData* pOnlyMarked )
789 : {
790 12 : if (SC_TAB_APPEND == nNewPos || nNewPos >= static_cast<SCTAB>(maTabs.size()))
791 10 : nNewPos = static_cast<SCTAB>(maTabs.size());
792 12 : OUString aName;
793 12 : GetName(nOldPos, aName);
794 :
795 : // vorneweg testen, ob der Prefix als gueltig erkannt wird
796 : // wenn nicht, nur doppelte vermeiden
797 12 : bool bPrefix = ValidTabName( aName );
798 : OSL_ENSURE(bPrefix, "invalid table name");
799 : SCTAB nDummy;
800 :
801 12 : CreateValidTabName(aName);
802 :
803 : bool bValid;
804 12 : if (bPrefix)
805 12 : bValid = ValidNewTabName(aName);
806 : else
807 0 : bValid = !GetTable( aName, nDummy );
808 :
809 24 : sc::AutoCalcSwitch aACSwitch(*this, false);
810 24 : sc::RefUpdateInsertTabContext aCxt(nNewPos, 1);
811 :
812 12 : if (bValid)
813 : {
814 12 : if (nNewPos >= static_cast<SCTAB>(maTabs.size()))
815 : {
816 10 : nNewPos = static_cast<SCTAB>(maTabs.size());
817 10 : maTabs.push_back(new ScTable(this, nNewPos, aName));
818 : }
819 : else
820 : {
821 2 : if (ValidTab(nNewPos) && (nNewPos < static_cast<SCTAB>(maTabs.size())))
822 : {
823 2 : SetNoListening( true );
824 :
825 2 : ScRange aRange( 0,0,nNewPos, MAXCOL,MAXROW,MAXTAB );
826 2 : xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
827 2 : xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
828 2 : if (pRangeName)
829 0 : pRangeName->UpdateInsertTab(aCxt);
830 :
831 : pDBCollection->UpdateReference(
832 2 : URM_INSDEL, 0,0,nNewPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
833 2 : if (pDPCollection)
834 0 : pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
835 2 : if (pDetOpList)
836 0 : pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,1 );
837 2 : UpdateChartRef( URM_INSDEL, 0,0,nNewPos, MAXCOL,MAXROW,MAXTAB, 0,0,1 );
838 2 : UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,1 );
839 2 : if ( pUnoBroadcaster )
840 2 : pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,1 ) );
841 :
842 : SCTAB i;
843 6 : for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
844 4 : if (*it && it != (maTabs.begin() + nOldPos))
845 2 : (*it)->UpdateInsertTab(aCxt);
846 2 : maTabs.push_back(NULL);
847 6 : for (i = static_cast<SCTAB>(maTabs.size())-1; i > nNewPos; i--)
848 4 : maTabs[i] = maTabs[i - 1];
849 2 : if (nNewPos <= nOldPos)
850 2 : nOldPos++;
851 2 : maTabs[nNewPos] = new ScTable(this, nNewPos, aName);
852 2 : bValid = true;
853 8 : for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
854 6 : if (*it && it != maTabs.begin()+nOldPos && it != maTabs.begin() + nNewPos)
855 2 : (*it)->UpdateCompile();
856 2 : SetNoListening( false );
857 8 : for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
858 6 : if (*it && it != maTabs.begin()+nOldPos && it != maTabs.begin()+nNewPos)
859 2 : (*it)->StartAllListeners();
860 :
861 2 : if (pValidationList)
862 0 : pValidationList->UpdateInsertTab(aCxt);
863 :
864 : // sheet names of references may not be valid until sheet is copied
865 2 : pChartListenerCollection->UpdateScheduledSeriesRanges();
866 : }
867 : else
868 0 : bValid = false;
869 : }
870 : }
871 :
872 12 : if (bValid)
873 : {
874 12 : SetNoListening( true ); // noch nicht bei CopyToTable/Insert
875 12 : sc::CopyToDocContext aCopyDocCxt(*this);
876 12 : maTabs[nOldPos]->CopyToTable(aCopyDocCxt, 0, 0, MAXCOL, MAXROW, IDF_ALL, (pOnlyMarked != NULL),
877 24 : maTabs[nNewPos], pOnlyMarked );
878 12 : maTabs[nNewPos]->SetTabBgColor(maTabs[nOldPos]->GetTabBgColor());
879 :
880 12 : SCTAB nDz = nNewPos - nOldPos;
881 24 : sc::RefUpdateContext aRefCxt(*this);
882 12 : aRefCxt.meMode = URM_COPY;
883 12 : aRefCxt.maRange = ScRange(0, 0, nNewPos, MAXCOL, MAXROW, nNewPos);
884 12 : aRefCxt.mnTabDelta = nDz;
885 12 : maTabs[nNewPos]->UpdateReference(aRefCxt, NULL);
886 :
887 24 : sc::RefUpdateInsertTabContext aInsTabCxt(nNewPos, 1);
888 12 : maTabs[nNewPos]->UpdateInsertTabAbs(nNewPos); // alle abs. um eins hoch!!
889 12 : maTabs[nOldPos]->UpdateInsertTab(aInsTabCxt);
890 :
891 12 : maTabs[nOldPos]->UpdateCompile();
892 12 : maTabs[nNewPos]->UpdateCompile( true ); // maybe already compiled in Clone, but used names need recompilation
893 12 : SetNoListening( false );
894 12 : maTabs[nOldPos]->StartAllListeners();
895 12 : maTabs[nNewPos]->StartAllListeners();
896 :
897 12 : sc::SetFormulaDirtyContext aFormulaDirtyCxt;
898 12 : SetAllFormulasDirty(aFormulaDirtyCxt);
899 :
900 12 : if (pDrawLayer)
901 4 : DrawCopyPage( static_cast<sal_uInt16>(nOldPos), static_cast<sal_uInt16>(nNewPos) );
902 :
903 12 : if (pDPCollection)
904 0 : pDPCollection->CopyToTab(nOldPos, nNewPos);
905 :
906 12 : maTabs[nNewPos]->SetPageStyle( maTabs[nOldPos]->GetPageStyle() );
907 12 : maTabs[nNewPos]->SetPendingRowHeights( maTabs[nOldPos]->IsPendingRowHeights() );
908 :
909 : // Copy the custom print range if exists.
910 12 : maTabs[nNewPos]->CopyPrintRange(*maTabs[nOldPos]);
911 :
912 : // Copy the RTL settings
913 12 : maTabs[nNewPos]->SetLayoutRTL(maTabs[nOldPos]->IsLayoutRTL());
914 24 : maTabs[nNewPos]->SetLoadingRTL(maTabs[nOldPos]->IsLoadingRTL());
915 : }
916 :
917 24 : return bValid;
918 : }
919 :
920 26 : sal_uLong ScDocument::TransferTab( ScDocument* pSrcDoc, SCTAB nSrcPos,
921 : SCTAB nDestPos, bool bInsertNew,
922 : bool bResultsOnly )
923 : {
924 26 : sal_uLong nRetVal = 1; // 0 => Fehler 1 = ok
925 : // 3 => NameBox
926 : // 4 => beides
927 :
928 26 : if (pSrcDoc->pShell->GetMedium())
929 : {
930 26 : pSrcDoc->maFileURL = pSrcDoc->pShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DECODE_TO_IURI);
931 : // for unsaved files use the title name and adjust during save of file
932 26 : if (pSrcDoc->maFileURL.isEmpty())
933 2 : pSrcDoc->maFileURL = pSrcDoc->pShell->GetName();
934 : }
935 : else
936 : {
937 0 : pSrcDoc->maFileURL = pSrcDoc->pShell->GetName();
938 : }
939 :
940 26 : bool bValid = true;
941 26 : if (bInsertNew) // neu einfuegen
942 : {
943 22 : OUString aName;
944 22 : pSrcDoc->GetName(nSrcPos, aName);
945 22 : CreateValidTabName(aName);
946 22 : bValid = InsertTab(nDestPos, aName);
947 :
948 : // Copy the RTL settings
949 22 : maTabs[nDestPos]->SetLayoutRTL(pSrcDoc->maTabs[nSrcPos]->IsLayoutRTL());
950 22 : maTabs[nDestPos]->SetLoadingRTL(pSrcDoc->maTabs[nSrcPos]->IsLoadingRTL());
951 : }
952 : else // bestehende Tabelle ersetzen
953 : {
954 4 : if (ValidTab(nDestPos) && nDestPos < static_cast<SCTAB>(maTabs.size()) && maTabs[nDestPos])
955 : {
956 4 : maTabs[nDestPos]->DeleteArea( 0,0, MAXCOL,MAXROW, IDF_ALL );
957 : }
958 : else
959 0 : bValid = false;
960 : }
961 :
962 26 : if (bValid)
963 : {
964 26 : bool bOldAutoCalcSrc = false;
965 26 : bool bOldAutoCalc = GetAutoCalc();
966 26 : SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
967 26 : SetNoListening( true );
968 26 : if ( bResultsOnly )
969 : {
970 4 : bOldAutoCalcSrc = pSrcDoc->GetAutoCalc();
971 4 : pSrcDoc->SetAutoCalc( true ); // falls was berechnet werden muss
972 : }
973 :
974 : {
975 26 : NumFmtMergeHandler aNumFmtMergeHdl(this, pSrcDoc);
976 :
977 52 : sc::CopyToDocContext aCxt(*this);
978 26 : nDestPos = std::min(nDestPos, (SCTAB)(GetTableCount() - 1));
979 : { // scope for bulk broadcast
980 26 : ScBulkBroadcast aBulkBroadcast( pBASM);
981 26 : pSrcDoc->maTabs[nSrcPos]->CopyToTable(aCxt, 0, 0, MAXCOL, MAXROW,
982 34 : ( bResultsOnly ? IDF_ALL & ~IDF_FORMULA : IDF_ALL),
983 104 : false, maTabs[nDestPos] );
984 26 : }
985 : }
986 26 : maTabs[nDestPos]->SetTabNo(nDestPos);
987 26 : maTabs[nDestPos]->SetTabBgColor(pSrcDoc->maTabs[nSrcPos]->GetTabBgColor());
988 :
989 26 : if ( !bResultsOnly )
990 : {
991 22 : sc::RefUpdateContext aRefCxt(*this);
992 22 : aRefCxt.meMode = URM_COPY;
993 22 : aRefCxt.maRange = ScRange(0, 0, nDestPos, MAXCOL, MAXROW, nDestPos);
994 22 : aRefCxt.mnTabDelta = nDestPos - nSrcPos;
995 22 : maTabs[nDestPos]->UpdateReference(aRefCxt, NULL);
996 :
997 : // Readjust self-contained absolute references to this sheet
998 22 : maTabs[nDestPos]->TestTabRefAbs(nSrcPos);
999 44 : sc::CompileFormulaContext aFormulaCxt(this);
1000 44 : maTabs[nDestPos]->CompileAll(aFormulaCxt);
1001 : }
1002 :
1003 26 : SetNoListening( false );
1004 26 : if ( !bResultsOnly )
1005 22 : maTabs[nDestPos]->StartAllListeners();
1006 26 : SetDirty( ScRange( 0, 0, nDestPos, MAXCOL, MAXROW, nDestPos));
1007 :
1008 26 : if ( bResultsOnly )
1009 4 : pSrcDoc->SetAutoCalc( bOldAutoCalcSrc );
1010 26 : SetAutoCalc( bOldAutoCalc );
1011 :
1012 : // Drawing kopieren
1013 :
1014 26 : if (bInsertNew)
1015 22 : TransferDrawPage( pSrcDoc, nSrcPos, nDestPos );
1016 :
1017 26 : maTabs[nDestPos]->SetPendingRowHeights( pSrcDoc->maTabs[nSrcPos]->IsPendingRowHeights() );
1018 : }
1019 26 : if (!bValid)
1020 0 : nRetVal = 0;
1021 26 : bool bVbaEnabled = IsInVBAMode();
1022 :
1023 26 : if ( bVbaEnabled )
1024 : {
1025 0 : SfxObjectShell* pSrcShell = pSrcDoc->GetDocumentShell();
1026 0 : if ( pSrcShell )
1027 : {
1028 0 : OUString aLibName("Standard");
1029 0 : const BasicManager *pBasicManager = pSrcShell->GetBasicManager();
1030 0 : if (pBasicManager && !pBasicManager->GetName().isEmpty())
1031 : {
1032 0 : aLibName = pSrcShell->GetBasicManager()->GetName();
1033 : }
1034 0 : OUString sCodeName;
1035 0 : OUString sSource;
1036 0 : uno::Reference< script::XLibraryContainer > xLibContainer = pSrcShell->GetBasicContainer();
1037 0 : uno::Reference< container::XNameContainer > xLib;
1038 0 : if( xLibContainer.is() )
1039 : {
1040 0 : uno::Any aLibAny = xLibContainer->getByName(aLibName);
1041 0 : aLibAny >>= xLib;
1042 : }
1043 :
1044 0 : if( xLib.is() )
1045 : {
1046 0 : OUString sSrcCodeName;
1047 0 : pSrcDoc->GetCodeName( nSrcPos, sSrcCodeName );
1048 0 : OUString sRTLSource;
1049 0 : xLib->getByName( sSrcCodeName ) >>= sRTLSource;
1050 0 : sSource = sRTLSource;
1051 : }
1052 0 : VBA_InsertModule( *this, nDestPos, sCodeName, sSource );
1053 : }
1054 : }
1055 :
1056 26 : return nRetVal;
1057 : }
1058 :
1059 2 : void ScDocument::SetError( SCCOL nCol, SCROW nRow, SCTAB nTab, const sal_uInt16 nError)
1060 : {
1061 2 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
1062 2 : if (maTabs[nTab])
1063 2 : maTabs[nTab]->SetError( nCol, nRow, nError );
1064 2 : }
1065 :
1066 0 : void ScDocument::SetFormula(
1067 : const ScAddress& rPos, const ScTokenArray& rArray, formula::FormulaGrammar::Grammar eGram )
1068 : {
1069 0 : if (!TableExists(rPos.Tab()))
1070 0 : return;
1071 :
1072 0 : maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rArray, eGram);
1073 : }
1074 :
1075 0 : void ScDocument::SetFormula(
1076 : const ScAddress& rPos, const OUString& rFormula, formula::FormulaGrammar::Grammar eGram )
1077 : {
1078 0 : if (!TableExists(rPos.Tab()))
1079 0 : return;
1080 :
1081 0 : maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rFormula, eGram);
1082 : }
1083 :
1084 594 : ScFormulaCell* ScDocument::SetFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell )
1085 : {
1086 594 : if (!TableExists(rPos.Tab()))
1087 : {
1088 0 : delete pCell;
1089 0 : return NULL;
1090 : }
1091 :
1092 594 : return maTabs[rPos.Tab()]->SetFormulaCell(rPos.Col(), rPos.Row(), pCell);
1093 : }
1094 :
1095 6 : bool ScDocument::SetFormulaCells( const ScAddress& rPos, std::vector<ScFormulaCell*>& rCells )
1096 : {
1097 6 : if (rCells.empty())
1098 0 : return false;
1099 :
1100 6 : ScTable* pTab = FetchTable(rPos.Tab());
1101 6 : if (!pTab)
1102 0 : return false;
1103 :
1104 6 : return pTab->SetFormulaCells(rPos.Col(), rPos.Row(), rCells);
1105 : }
1106 :
1107 2 : void ScDocument::SetConsolidateDlgData( const ScConsolidateParam* pData )
1108 : {
1109 2 : delete pConsolidateDlgData;
1110 :
1111 2 : if ( pData )
1112 2 : pConsolidateDlgData = new ScConsolidateParam( *pData );
1113 : else
1114 0 : pConsolidateDlgData = NULL;
1115 2 : }
1116 :
1117 8 : void ScDocument::SetChangeViewSettings(const ScChangeViewSettings& rNew)
1118 : {
1119 8 : if (pChangeViewSettings==NULL)
1120 8 : pChangeViewSettings = new ScChangeViewSettings;
1121 :
1122 : OSL_ENSURE( pChangeViewSettings, "Oops. No ChangeViewSettings :-( by!" );
1123 :
1124 8 : *pChangeViewSettings=rNew;
1125 8 : }
1126 :
1127 2088 : ScFieldEditEngine* ScDocument::CreateFieldEditEngine()
1128 : {
1129 2088 : ScFieldEditEngine* pNewEditEngine = NULL;
1130 2088 : if (!pCacheFieldEditEngine)
1131 : {
1132 : pNewEditEngine = new ScFieldEditEngine(
1133 116 : this, GetEnginePool(), GetEditPool(), false);
1134 : }
1135 : else
1136 : {
1137 1972 : if ( !bImportingXML )
1138 : {
1139 : // #i66209# previous use might not have restored update mode,
1140 : // ensure same state as for a new EditEngine (UpdateMode = true)
1141 1972 : if ( !pCacheFieldEditEngine->GetUpdateMode() )
1142 0 : pCacheFieldEditEngine->SetUpdateMode(true);
1143 : }
1144 :
1145 1972 : pNewEditEngine = pCacheFieldEditEngine;
1146 1972 : pCacheFieldEditEngine = NULL;
1147 : }
1148 2088 : return pNewEditEngine;
1149 : }
1150 :
1151 2017 : void ScDocument::DisposeFieldEditEngine(ScFieldEditEngine*& rpEditEngine)
1152 : {
1153 2017 : if (!pCacheFieldEditEngine && rpEditEngine)
1154 : {
1155 1997 : pCacheFieldEditEngine = rpEditEngine;
1156 1997 : pCacheFieldEditEngine->Clear();
1157 : }
1158 : else
1159 20 : delete rpEditEngine;
1160 2017 : rpEditEngine = NULL;
1161 2017 : }
1162 :
1163 388 : ScRecursionHelper* ScDocument::CreateRecursionHelperInstance()
1164 : {
1165 388 : return new ScRecursionHelper;
1166 : }
1167 :
1168 126 : ScLookupCache & ScDocument::GetLookupCache( const ScRange & rRange )
1169 : {
1170 126 : ScLookupCache* pCache = 0;
1171 126 : if (!pLookupCacheMapImpl)
1172 12 : pLookupCacheMapImpl = new ScLookupCacheMapImpl;
1173 126 : ScLookupCacheMap::iterator it( pLookupCacheMapImpl->aCacheMap.find( rRange));
1174 126 : if (it == pLookupCacheMapImpl->aCacheMap.end())
1175 : {
1176 20 : pCache = new ScLookupCache( this, rRange);
1177 20 : AddLookupCache( *pCache);
1178 : }
1179 : else
1180 106 : pCache = (*it).second;
1181 126 : return *pCache;
1182 : }
1183 :
1184 20 : void ScDocument::AddLookupCache( ScLookupCache & rCache )
1185 : {
1186 40 : if (!pLookupCacheMapImpl->aCacheMap.insert( ::std::pair< const ScRange,
1187 40 : ScLookupCache*>( rCache.getRange(), &rCache)).second)
1188 : {
1189 : OSL_FAIL( "ScDocument::AddLookupCache: couldn't add to hash map");
1190 : }
1191 : else
1192 20 : StartListeningArea( rCache.getRange(), &rCache);
1193 20 : }
1194 :
1195 8 : void ScDocument::RemoveLookupCache( ScLookupCache & rCache )
1196 : {
1197 : ScLookupCacheMap::iterator it( pLookupCacheMapImpl->aCacheMap.find(
1198 8 : rCache.getRange()));
1199 8 : if (it == pLookupCacheMapImpl->aCacheMap.end())
1200 : {
1201 : OSL_FAIL( "ScDocument::RemoveLookupCache: range not found in hash map");
1202 : }
1203 : else
1204 : {
1205 8 : ScLookupCache* pCache = (*it).second;
1206 8 : pLookupCacheMapImpl->aCacheMap.erase( it);
1207 8 : EndListeningArea( pCache->getRange(), &rCache);
1208 : }
1209 8 : }
1210 :
1211 478 : void ScDocument::ClearLookupCaches()
1212 : {
1213 478 : if( pLookupCacheMapImpl )
1214 10 : pLookupCacheMapImpl->clear();
1215 478 : }
1216 :
1217 0 : bool ScDocument::IsCellInChangeTrack(const ScAddress &cell,Color *pColCellBoder)
1218 : {
1219 0 : ScChangeTrack* pTrack = GetChangeTrack();
1220 0 : ScChangeViewSettings* pSettings = GetChangeViewSettings();
1221 0 : if ( !pTrack || !pTrack->GetFirst() || !pSettings || !pSettings->ShowChanges() )
1222 0 : return false; // nix da oder abgeschaltet
1223 0 : ScActionColorChanger aColorChanger(*pTrack);
1224 : // Clipping passiert von aussen
1225 : //! ohne Clipping, nur betroffene Zeilen painten ??!??!?
1226 0 : const ScChangeAction* pAction = pTrack->GetFirst();
1227 0 : while (pAction)
1228 : {
1229 : ScChangeActionType eType;
1230 0 : if ( pAction->IsVisible() )
1231 : {
1232 0 : eType = pAction->GetType();
1233 0 : const ScBigRange& rBig = pAction->GetBigRange();
1234 0 : if ( rBig.aStart.Tab() == cell.Tab())
1235 : {
1236 0 : ScRange aRange = rBig.MakeRange();
1237 0 : if ( eType == SC_CAT_DELETE_ROWS )
1238 0 : aRange.aEnd.SetRow( aRange.aStart.Row() );
1239 0 : else if ( eType == SC_CAT_DELETE_COLS )
1240 0 : aRange.aEnd.SetCol( aRange.aStart.Col() );
1241 0 : if (ScViewUtil::IsActionShown( *pAction, *pSettings, *this ) )
1242 : {
1243 0 : if (aRange.In(cell))
1244 : {
1245 0 : if (pColCellBoder != NULL)
1246 : {
1247 0 : aColorChanger.Update( *pAction );
1248 0 : Color aColor( aColorChanger.GetColor() );
1249 0 : *pColCellBoder = aColor;
1250 : }
1251 0 : return true;
1252 : }
1253 : }
1254 : }
1255 0 : if ( eType == SC_CAT_MOVE &&
1256 : static_cast<const ScChangeActionMove*>(pAction)->
1257 0 : GetFromRange().aStart.Tab() == cell.Col() )
1258 : {
1259 : ScRange aRange = static_cast<const ScChangeActionMove*>(pAction)->
1260 0 : GetFromRange().MakeRange();
1261 0 : if (ScViewUtil::IsActionShown( *pAction, *pSettings, *this ) )
1262 : {
1263 0 : if (aRange.In(cell))
1264 : {
1265 0 : if (pColCellBoder != NULL)
1266 : {
1267 0 : aColorChanger.Update( *pAction );
1268 0 : Color aColor( aColorChanger.GetColor() );
1269 0 : *pColCellBoder = aColor;
1270 : }
1271 0 : return true;
1272 : }
1273 : }
1274 : }
1275 : }
1276 0 : pAction = pAction->GetNext();
1277 : }
1278 0 : return false;
1279 : }
1280 :
1281 0 : void ScDocument::GetCellChangeTrackNote( const ScAddress &aCellPos, OUString &aTrackText,bool &bLeftEdge)
1282 : {
1283 0 : aTrackText = OUString();
1284 : // Change-Tracking
1285 0 : ScChangeTrack* pTrack = GetChangeTrack();
1286 0 : ScChangeViewSettings* pSettings = GetChangeViewSettings();
1287 0 : if ( pTrack && pTrack->GetFirst() && pSettings && pSettings->ShowChanges())
1288 : {
1289 0 : const ScChangeAction* pFound = NULL;
1290 0 : const ScChangeAction* pFoundContent = NULL;
1291 0 : const ScChangeAction* pFoundMove = NULL;
1292 0 : long nModified = 0;
1293 0 : const ScChangeAction* pAction = pTrack->GetFirst();
1294 0 : while (pAction)
1295 : {
1296 0 : if ( pAction->IsVisible() &&
1297 0 : ScViewUtil::IsActionShown( *pAction, *pSettings, *this ) )
1298 : {
1299 0 : ScChangeActionType eType = pAction->GetType();
1300 0 : const ScBigRange& rBig = pAction->GetBigRange();
1301 0 : if ( rBig.aStart.Tab() == aCellPos.Tab())
1302 : {
1303 0 : ScRange aRange = rBig.MakeRange();
1304 0 : if ( eType == SC_CAT_DELETE_ROWS )
1305 0 : aRange.aEnd.SetRow( aRange.aStart.Row() );
1306 0 : else if ( eType == SC_CAT_DELETE_COLS )
1307 0 : aRange.aEnd.SetCol( aRange.aStart.Col() );
1308 0 : if ( aRange.In( aCellPos ) )
1309 : {
1310 0 : pFound = pAction; // der letzte gewinnt
1311 0 : switch ( eType )
1312 : {
1313 : case SC_CAT_CONTENT :
1314 0 : pFoundContent = pAction;
1315 0 : break;
1316 : case SC_CAT_MOVE :
1317 0 : pFoundMove = pAction;
1318 0 : break;
1319 : default:
1320 0 : break;
1321 : }
1322 0 : ++nModified;
1323 : }
1324 : }
1325 0 : if ( eType == SC_CAT_MOVE )
1326 : {
1327 : ScRange aRange =
1328 : static_cast<const ScChangeActionMove*>(pAction)->
1329 0 : GetFromRange().MakeRange();
1330 0 : if ( aRange.In( aCellPos ) )
1331 : {
1332 0 : pFound = pAction;
1333 0 : ++nModified;
1334 : }
1335 : }
1336 : }
1337 0 : pAction = pAction->GetNext();
1338 : }
1339 0 : if ( pFound )
1340 : {
1341 0 : if ( pFoundContent && pFound->GetType() != SC_CAT_CONTENT )
1342 0 : pFound = pFoundContent; // Content gewinnt
1343 0 : if ( pFoundMove && pFound->GetType() != SC_CAT_MOVE &&
1344 0 : pFoundMove->GetActionNumber() >
1345 0 : pFound->GetActionNumber() )
1346 0 : pFound = pFoundMove; // Move gewinnt
1347 : // bei geloeschten Spalten: Pfeil auf die linke Seite der Zelle
1348 0 : if ( pFound->GetType() == SC_CAT_DELETE_COLS )
1349 0 : bLeftEdge = true;
1350 0 : DateTime aDT = pFound->GetDateTime();
1351 0 : aTrackText = pFound->GetUser();
1352 0 : aTrackText += ", ";
1353 0 : aTrackText += ScGlobal::pLocaleData->getDate(aDT);
1354 0 : aTrackText += " ";
1355 0 : aTrackText += ScGlobal::pLocaleData->getTime(aDT);
1356 0 : aTrackText += ":\n";
1357 0 : OUString aComStr = pFound->GetComment();
1358 0 : if(!aComStr.isEmpty())
1359 : {
1360 0 : aTrackText += aComStr;
1361 0 : aTrackText += "\n( ";
1362 : }
1363 0 : pFound->GetDescription( aTrackText, this );
1364 0 : if (!aComStr.isEmpty())
1365 : {
1366 0 : aTrackText += ")";
1367 0 : }
1368 : }
1369 : }
1370 0 : }
1371 :
1372 232 : void ScDocument::SetPreviewFont( SfxItemSet* pFont )
1373 : {
1374 232 : delete pPreviewFont;
1375 232 : pPreviewFont = pFont;
1376 232 : }
1377 :
1378 232 : void ScDocument::SetPreviewSelection( ScMarkData& rSel )
1379 : {
1380 232 : maPreviewSelection = rSel;
1381 232 : }
1382 :
1383 14018 : SfxItemSet* ScDocument::GetPreviewFont( SCCOL nCol, SCROW nRow, SCTAB nTab )
1384 : {
1385 14018 : SfxItemSet* pRet = NULL;
1386 14018 : if ( pPreviewFont )
1387 : {
1388 13896 : ScMarkData aSel = GetPreviewSelection();
1389 13896 : if ( aSel.IsCellMarked( nCol, nRow ) && aSel.GetFirstSelected() == nTab )
1390 572 : pRet = pPreviewFont;
1391 : }
1392 14018 : return pRet;
1393 : }
1394 :
1395 4930563 : ScStyleSheet* ScDocument::GetPreviewCellStyle( SCCOL nCol, SCROW nRow, SCTAB nTab )
1396 : {
1397 4930563 : ScStyleSheet* pRet = NULL;
1398 4930563 : ScMarkData aSel = GetPreviewSelection();
1399 4930563 : if ( pPreviewCellStyle && aSel.IsCellMarked( nCol, nRow ) && aSel.GetFirstSelected() == nTab )
1400 0 : pRet = pPreviewCellStyle;
1401 4930563 : return pRet;
1402 228 : }
1403 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
