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