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