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 <com/sun/star/script/vba/XVBAEventProcessor.hpp>
30 : : #include "scitems.hxx"
31 : : #include <editeng/langitem.hxx>
32 : : #include <svl/srchitem.hxx>
33 : : #include <sfx2/linkmgr.hxx>
34 : : #include <sfx2/bindings.hxx>
35 : : #include <sfx2/objsh.hxx>
36 : : #include <svl/zforlist.hxx>
37 : : #include <svl/PasswordHelper.hxx>
38 : : #include <vcl/svapp.hxx>
39 : : #include "document.hxx"
40 : : #include "attrib.hxx"
41 : : #include "cell.hxx"
42 : : #include "table.hxx"
43 : : #include "rangenam.hxx"
44 : : #include "dbdata.hxx"
45 : : #include "pivot.hxx"
46 : : #include "docpool.hxx"
47 : : #include "poolhelp.hxx"
48 : : #include "autoform.hxx"
49 : : #include "rangelst.hxx"
50 : : #include "chartarr.hxx"
51 : : #include "chartlock.hxx"
52 : : #include "refupdat.hxx"
53 : : #include "docoptio.hxx"
54 : : #include "viewopti.hxx"
55 : : #include "scextopt.hxx"
56 : : #include "brdcst.hxx"
57 : : #include "bcaslot.hxx"
58 : : #include "tablink.hxx"
59 : : #include "externalrefmgr.hxx"
60 : : #include "markdata.hxx"
61 : : #include "validat.hxx"
62 : : #include "dociter.hxx"
63 : : #include "detdata.hxx"
64 : : #include "detfunc.hxx"
65 : : #include "inputopt.hxx" // GetExpandRefs
66 : : #include "chartlis.hxx"
67 : : #include "sc.hrc" // SID_LINK
68 : : #include "hints.hxx"
69 : : #include "dpobject.hxx"
70 : : #include "drwlayer.hxx"
71 : : #include "unoreflist.hxx"
72 : : #include "listenercalls.hxx"
73 : : #include "dpshttab.hxx"
74 : : #include "dpcache.hxx"
75 : : #include "tabprotection.hxx"
76 : : #include "formulaparserpool.hxx"
77 : : #include "clipparam.hxx"
78 : : #include "sheetevents.hxx"
79 : : #include "colorscale.hxx"
80 : : #include "queryentry.hxx"
81 : :
82 : : #include "globalnames.hxx"
83 : : #include <memory>
84 : :
85 : : using namespace com::sun::star;
86 : :
87 : : namespace {
88 : :
89 : 0 : void sortAndRemoveDuplicates(std::vector<ScTypedStrData>& rStrings, bool bCaseSens)
90 : : {
91 [ # # ]: 0 : if (bCaseSens)
92 : : {
93 [ # # ]: 0 : std::sort(rStrings.begin(), rStrings.end(), ScTypedStrData::LessCaseSensitive());
94 : : std::vector<ScTypedStrData>::iterator it =
95 [ # # ]: 0 : std::unique(rStrings.begin(), rStrings.end(), ScTypedStrData::EqualCaseSensitive());
96 [ # # ]: 0 : rStrings.erase(it, rStrings.end());
97 : : }
98 : : else
99 : : {
100 [ # # ]: 0 : std::sort(rStrings.begin(), rStrings.end(), ScTypedStrData::LessCaseInsensitive());
101 : : std::vector<ScTypedStrData>::iterator it =
102 [ # # ]: 0 : std::unique(rStrings.begin(), rStrings.end(), ScTypedStrData::EqualCaseInsensitive());
103 [ # # ]: 0 : rStrings.erase(it, rStrings.end());
104 : : }
105 : 0 : }
106 : :
107 : : }
108 : :
109 : 0 : void ScDocument::GetAllTabRangeNames(ScRangeName::TabNameCopyMap& rNames) const
110 : : {
111 [ # # ]: 0 : ScRangeName::TabNameCopyMap aNames;
112 [ # # ]: 0 : for (SCTAB i = 0; i < static_cast<SCTAB>(maTabs.size()); ++i)
113 : : {
114 [ # # ]: 0 : if (!maTabs[i])
115 : : // no more tables to iterate through.
116 : : break;
117 : :
118 [ # # ]: 0 : const ScRangeName* p = maTabs[i]->GetRangeName();
119 [ # # ][ # # ]: 0 : if (!p || p->empty())
[ # # ][ # # ]
120 : : // ignore empty ones.
121 : 0 : continue;
122 : :
123 [ # # ]: 0 : aNames.insert(ScRangeName::TabNameCopyMap::value_type(i, p));
124 : : }
125 [ # # ]: 0 : rNames.swap(aNames);
126 : 0 : }
127 : :
128 : 0 : void ScDocument::SetAllRangeNames( const boost::ptr_map<rtl::OUString, ScRangeName>& rRangeMap)
129 : : {
130 [ # # ]: 0 : rtl::OUString aGlobalStr(RTL_CONSTASCII_USTRINGPARAM(STR_GLOBAL_RANGE_NAME));
131 [ # # ][ # # ]: 0 : boost::ptr_map<rtl::OUString,ScRangeName>::const_iterator itr = rRangeMap.begin(), itrEnd = rRangeMap.end();
132 [ # # ][ # # ]: 0 : for (; itr!=itrEnd; ++itr)
[ # # ]
133 : : {
134 [ # # ][ # # ]: 0 : if (itr->first == aGlobalStr)
135 : : {
136 [ # # ][ # # ]: 0 : delete pRangeName;
137 [ # # ]: 0 : const ScRangeName* pName = itr->second;
138 [ # # ][ # # ]: 0 : if (pName->empty())
139 : 0 : pRangeName = NULL;
140 : : else
141 [ # # ][ # # ]: 0 : pRangeName = new ScRangeName( *pName );
142 : : }
143 : : else
144 : : {
145 [ # # ]: 0 : const ScRangeName* pName = itr->second;
146 : : SCTAB nTab;
147 [ # # ][ # # ]: 0 : GetTable(itr->first, nTab);
148 [ # # ][ # # ]: 0 : if (pName->empty())
149 [ # # ]: 0 : SetRangeName( nTab, NULL );
150 : : else
151 [ # # ][ # # ]: 0 : SetRangeName( nTab, new ScRangeName( *pName ) );
[ # # ]
152 : : }
153 : 0 : }
154 : 0 : }
155 : :
156 : 0 : void ScDocument::GetTabRangeNameMap(std::map<rtl::OUString, ScRangeName*>& aRangeNameMap)
157 : : {
158 [ # # ]: 0 : for (SCTAB i = 0; i < static_cast<SCTAB>(maTabs.size()); ++i)
159 : : {
160 [ # # ]: 0 : if (!maTabs[i])
161 : 0 : continue;
162 [ # # ]: 0 : ScRangeName* p = maTabs[i]->GetRangeName();
163 [ # # ]: 0 : if (!p )
164 : : {
165 [ # # ][ # # ]: 0 : p = new ScRangeName();
166 [ # # ]: 0 : SetRangeName(i, p);
167 : : }
168 : 0 : rtl::OUString aTableName;
169 [ # # ]: 0 : maTabs[i]->GetName(aTableName);
170 [ # # ]: 0 : aRangeNameMap.insert(std::pair<rtl::OUString, ScRangeName*>(aTableName,p));
171 : 0 : }
172 : 0 : }
173 : :
174 : 0 : void ScDocument::GetRangeNameMap(std::map<rtl::OUString, ScRangeName*>& aRangeNameMap)
175 : : {
176 [ # # ]: 0 : GetTabRangeNameMap(aRangeNameMap);
177 [ # # ]: 0 : if (!pRangeName)
178 : : {
179 [ # # ][ # # ]: 0 : pRangeName = new ScRangeName();
180 : : }
181 [ # # ]: 0 : rtl::OUString aGlobal(RTL_CONSTASCII_USTRINGPARAM(STR_GLOBAL_RANGE_NAME));
182 [ # # ]: 0 : aRangeNameMap.insert(std::pair<rtl::OUString, ScRangeName*>(aGlobal, pRangeName));
183 : 0 : }
184 : :
185 : 1152 : ScRangeName* ScDocument::GetRangeName(SCTAB nTab) const
186 : : {
187 [ + + ][ + - ]: 1152 : if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
[ - + ][ + + ]
188 : 3 : return NULL;
189 : :
190 : 1152 : return maTabs[nTab]->GetRangeName();
191 : : }
192 : :
193 : 1595 : ScRangeName* ScDocument::GetRangeName() const
194 : : {
195 [ + + ]: 1595 : if (!pRangeName)
196 [ + - ]: 282 : pRangeName = new ScRangeName;
197 : 1595 : return pRangeName;
198 : : }
199 : :
200 : 3 : void ScDocument::SetRangeName(SCTAB nTab, ScRangeName* pNew)
201 : : {
202 [ + - ][ + - ]: 3 : if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
[ - + ][ - + ]
203 : 0 : return;
204 : :
205 : 3 : return maTabs[nTab]->SetRangeName(pNew);
206 : : }
207 : :
208 : 51 : void ScDocument::SetRangeName( ScRangeName* pNewRangeName )
209 : : {
210 [ + + ]: 51 : delete pRangeName;
211 : 51 : pRangeName = pNewRangeName;
212 : 51 : }
213 : :
214 : :
215 : 640 : const ScRangeData* ScDocument::GetRangeAtBlock( const ScRange& rBlock, rtl::OUString* pName ) const
216 : : {
217 : 640 : const ScRangeData* pData = NULL;
218 [ + + ]: 640 : if ( pRangeName )
219 : : {
220 : 202 : pData = pRangeName->findByRange( rBlock );
221 [ # # ][ - + ]: 202 : if (pData && pName)
222 : 0 : *pName = pData->GetName();
223 : : }
224 : 640 : return pData;
225 : : }
226 : :
227 : 1496 : ScDBCollection* ScDocument::GetDBCollection() const
228 : : {
229 : 1496 : return pDBCollection;
230 : : }
231 : :
232 : 3 : void ScDocument::SetDBCollection( ScDBCollection* pNewDBCollection, bool bRemoveAutoFilter )
233 : : {
234 [ + - ][ - + ]: 3 : if (pDBCollection && bRemoveAutoFilter)
235 : : {
236 : : // remove auto filter attribute if new db data don't contain auto filter flag
237 : : // start position is also compared, so bRemoveAutoFilter must not be set from ref-undo!
238 : :
239 [ # # ]: 0 : ScDBCollection::NamedDBs& rNamedDBs = pDBCollection->getNamedDBs();
240 [ # # ][ # # ]: 0 : ScDBCollection::NamedDBs::const_iterator itr = rNamedDBs.begin(), itrEnd = rNamedDBs.end();
[ # # ][ # # ]
241 [ # # ][ # # ]: 0 : for (; itr != itrEnd; ++itr)
[ # # ]
242 : : {
243 [ # # ]: 0 : const ScDBData& rOldData = *itr;
244 [ # # ]: 0 : if (!rOldData.HasAutoFilter())
245 : 0 : continue;
246 : :
247 : 0 : ScRange aOldRange;
248 [ # # ]: 0 : rOldData.GetArea(aOldRange);
249 : :
250 : 0 : bool bFound = false;
251 [ # # ]: 0 : if (pNewDBCollection)
252 : : {
253 [ # # ][ # # ]: 0 : ScDBData* pNewData = pNewDBCollection->getNamedDBs().findByName(rOldData.GetName());
254 [ # # ]: 0 : if (pNewData)
255 : : {
256 [ # # ]: 0 : if (pNewData->HasAutoFilter())
257 : : {
258 : 0 : ScRange aNewRange;
259 [ # # ]: 0 : pNewData->GetArea(aNewRange);
260 [ # # ]: 0 : if (aOldRange.aStart == aNewRange.aStart)
261 : 0 : bFound = true;
262 : : }
263 : : }
264 : : }
265 : :
266 [ # # ]: 0 : if (!bFound)
267 : : {
268 : 0 : aOldRange.aEnd.SetRow(aOldRange.aStart.Row());
269 : 0 : RemoveFlagsTab( aOldRange.aStart.Col(), aOldRange.aStart.Row(),
270 : 0 : aOldRange.aEnd.Col(), aOldRange.aEnd.Row(),
271 [ # # ]: 0 : aOldRange.aStart.Tab(), SC_MF_AUTO );
272 [ # # ]: 0 : RepaintRange( aOldRange );
273 : : }
274 : : }
275 : : }
276 : :
277 [ + - ]: 3 : delete pDBCollection;
278 : :
279 : 3 : pDBCollection = pNewDBCollection;
280 : 3 : }
281 : :
282 : 0 : const ScDBData* ScDocument::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, bool bStartOnly) const
283 : : {
284 [ # # ]: 0 : if (pDBCollection)
285 : 0 : return pDBCollection->GetDBAtCursor(nCol, nRow, nTab, bStartOnly);
286 : : else
287 : 0 : return NULL;
288 : : }
289 : :
290 : 3 : ScDBData* ScDocument::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, bool bStartOnly)
291 : : {
292 [ + - ]: 3 : if (pDBCollection)
293 : 3 : return pDBCollection->GetDBAtCursor(nCol, nRow, nTab, bStartOnly);
294 : : else
295 : 3 : return NULL;
296 : : }
297 : :
298 : 0 : const ScDBData* ScDocument::GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
299 : : {
300 [ # # ]: 0 : if (pDBCollection)
301 : 0 : return pDBCollection->GetDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2);
302 : : else
303 : 0 : return NULL;
304 : : }
305 : :
306 : 60 : ScDBData* ScDocument::GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
307 : : {
308 [ + - ]: 60 : if (pDBCollection)
309 : 60 : return pDBCollection->GetDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2);
310 : : else
311 : 60 : return NULL;
312 : : }
313 : :
314 : 1533 : ScDPCollection* ScDocument::GetDPCollection()
315 : : {
316 [ + + ]: 1533 : if (!pDPCollection)
317 [ + - ]: 158 : pDPCollection = new ScDPCollection(this);
318 : 1533 : return pDPCollection;
319 : : }
320 : :
321 : 306 : ScDPObject* ScDocument::GetDPAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab) const
322 : : {
323 [ + + ]: 306 : if (!pDPCollection)
324 : 225 : return NULL;
325 : :
326 [ + - ]: 81 : sal_uInt16 nCount = pDPCollection->GetCount();
327 : 81 : ScAddress aPos( nCol, nRow, nTab );
328 [ + + ]: 181 : for (sal_uInt16 i=0; i<nCount; i++)
329 [ + - ][ + + ]: 102 : if ( (*pDPCollection)[i]->GetOutRange().In( aPos ) )
330 [ + - ]: 2 : return (*pDPCollection)[i];
331 : :
332 : 306 : return NULL;
333 : : }
334 : :
335 : 0 : ScDPObject* ScDocument::GetDPAtBlock( const ScRange & rBlock ) const
336 : : {
337 [ # # ]: 0 : if (!pDPCollection)
338 : 0 : return NULL;
339 : :
340 : : /* Walk the collection in reverse order to get something of an
341 : : * approximation of MS Excels 'most recent' effect. */
342 : 0 : sal_uInt16 i = pDPCollection->GetCount();
343 [ # # ]: 0 : while ( i-- > 0 )
344 [ # # ]: 0 : if ( (*pDPCollection)[i]->GetOutRange().In( rBlock ) )
345 : 0 : return (*pDPCollection)[i];
346 : :
347 : 0 : return NULL;
348 : : }
349 : :
350 : 0 : ScChartCollection* ScDocument::GetChartCollection() const
351 : : {
352 : 0 : return pChartCollection;
353 : : }
354 : :
355 : 4 : void ScDocument::StopTemporaryChartLock()
356 : : {
357 [ + - ]: 4 : if( apTemporaryChartLock.get() )
358 : 4 : apTemporaryChartLock->StopLocking();
359 : 4 : }
360 : :
361 : 15375 : ScChartListenerCollection* ScDocument::GetChartListenerCollection() const
362 : : {
363 : 15375 : return pChartListenerCollection;
364 : : }
365 : :
366 : 0 : void ScDocument::SetChartListenerCollection(
367 : : ScChartListenerCollection* pNewChartListenerCollection,
368 : : bool bSetChartRangeLists )
369 : : {
370 : 0 : ScChartListenerCollection* pOld = pChartListenerCollection;
371 : 0 : pChartListenerCollection = pNewChartListenerCollection;
372 [ # # ]: 0 : if ( pChartListenerCollection )
373 : : {
374 [ # # ]: 0 : if ( pOld )
375 : 0 : pChartListenerCollection->SetDiffDirty( *pOld, bSetChartRangeLists );
376 : 0 : pChartListenerCollection->StartAllListeners();
377 : : }
378 [ # # ]: 0 : delete pOld;
379 : 0 : }
380 : :
381 : 1 : void ScDocument::SetScenario( SCTAB nTab, bool bFlag )
382 : : {
383 [ + - ][ + - ]: 1 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
384 : 1 : maTabs[nTab]->SetScenario(bFlag);
385 : 1 : }
386 : :
387 : 5611 : bool ScDocument::IsScenario( SCTAB nTab ) const
388 : : {
389 [ + - ][ + + ]: 5611 : return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] &&maTabs[nTab]->IsScenario();
[ + - ][ + + ]
390 : : }
391 : :
392 : 1 : void ScDocument::SetScenarioData( SCTAB nTab, const rtl::OUString& rComment,
393 : : const Color& rColor, sal_uInt16 nFlags )
394 : : {
395 [ + - ][ + - ]: 1 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsScenario())
[ + - ][ + - ]
[ + - ]
396 : : {
397 : 1 : maTabs[nTab]->SetScenarioComment( rComment );
398 : 1 : maTabs[nTab]->SetScenarioColor( rColor );
399 : 1 : maTabs[nTab]->SetScenarioFlags( nFlags );
400 : : }
401 : 1 : }
402 : :
403 : 1187 : Color ScDocument::GetTabBgColor( SCTAB nTab ) const
404 : : {
405 [ + - ][ + - ]: 1187 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
406 : 1187 : return maTabs[nTab]->GetTabBgColor();
407 : 1187 : return Color(COL_AUTO);
408 : : }
409 : :
410 : 25 : void ScDocument::SetTabBgColor( SCTAB nTab, const Color& rColor )
411 : : {
412 [ + - ][ + - ]: 25 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
413 : 25 : maTabs[nTab]->SetTabBgColor(rColor);
414 : 25 : }
415 : :
416 : 402 : bool ScDocument::IsDefaultTabBgColor( SCTAB nTab ) const
417 : : {
418 [ + - ][ + - ]: 402 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
419 [ + - ]: 402 : return maTabs[nTab]->GetTabBgColor() == COL_AUTO;
420 : 402 : return true;
421 : : }
422 : :
423 : 0 : void ScDocument::GetScenarioData( SCTAB nTab, rtl::OUString& rComment,
424 : : Color& rColor, sal_uInt16& rFlags ) const
425 : : {
426 [ # # ][ # # ]: 0 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsScenario())
[ # # ][ # # ]
[ # # ]
427 : : {
428 : 0 : maTabs[nTab]->GetScenarioComment( rComment );
429 : 0 : rColor = maTabs[nTab]->GetScenarioColor();
430 : 0 : rFlags = maTabs[nTab]->GetScenarioFlags();
431 : : }
432 : 0 : }
433 : :
434 : 0 : void ScDocument::GetScenarioFlags( SCTAB nTab, sal_uInt16& rFlags ) const
435 : : {
436 [ # # ][ # # ]: 0 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsScenario())
[ # # ][ # # ]
[ # # ]
437 : 0 : rFlags = maTabs[nTab]->GetScenarioFlags();
438 : 0 : }
439 : :
440 : 824 : bool ScDocument::IsLinked( SCTAB nTab ) const
441 : : {
442 [ + - ][ + - ]: 824 : return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsLinked();
[ + - ][ + + ]
443 : : // euqivalent to
444 : : //if (ValidTab(nTab) && pTab[nTab])
445 : : // return pTab[nTab]->IsLinked();
446 : : //return false;
447 : : }
448 : :
449 : 40600 : formula::FormulaGrammar::AddressConvention ScDocument::GetAddressConvention() const
450 : : {
451 : 40600 : return formula::FormulaGrammar::extractRefConvention(eGrammar);
452 : : }
453 : :
454 : 27866 : formula::FormulaGrammar::Grammar ScDocument::GetGrammar() const
455 : : {
456 : 27866 : return eGrammar;
457 : : }
458 : :
459 : 412 : void ScDocument::SetGrammar( formula::FormulaGrammar::Grammar eGram )
460 : : {
461 : 412 : eGrammar = eGram;
462 : 412 : }
463 : :
464 : 6 : sal_uInt8 ScDocument::GetLinkMode( SCTAB nTab ) const
465 : : {
466 [ + - ][ + - ]: 6 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
467 : 6 : return maTabs[nTab]->GetLinkMode();
468 : 6 : return SC_LINK_NONE;
469 : : }
470 : :
471 : 22 : const rtl::OUString ScDocument::GetLinkDoc( SCTAB nTab ) const
472 : : {
473 [ + - ][ + - ]: 22 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
474 : 22 : return maTabs[nTab]->GetLinkDoc();
475 : 22 : return rtl::OUString();
476 : : }
477 : :
478 : 2 : const rtl::OUString ScDocument::GetLinkFlt( SCTAB nTab ) const
479 : : {
480 [ + - ][ + - ]: 2 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
481 : 2 : return maTabs[nTab]->GetLinkFlt();
482 : 2 : return rtl::OUString();
483 : : }
484 : :
485 : 2 : const rtl::OUString ScDocument::GetLinkOpt( SCTAB nTab ) const
486 : : {
487 [ + - ][ + - ]: 2 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
488 : 2 : return maTabs[nTab]->GetLinkOpt();
489 : 2 : return rtl::OUString();
490 : : }
491 : :
492 : 2 : const rtl::OUString ScDocument::GetLinkTab( SCTAB nTab ) const
493 : : {
494 [ + - ][ + - ]: 2 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
495 : 2 : return maTabs[nTab]->GetLinkTab();
496 : 2 : return rtl::OUString();
497 : : }
498 : :
499 : 2 : sal_uLong ScDocument::GetLinkRefreshDelay( SCTAB nTab ) const
500 : : {
501 [ + - ][ + - ]: 2 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
502 : 2 : return maTabs[nTab]->GetLinkRefreshDelay();
503 : 2 : return 0;
504 : : }
505 : :
506 : 6 : void ScDocument::SetLink( SCTAB nTab, sal_uInt8 nMode, const rtl::OUString& rDoc,
507 : : const rtl::OUString& rFilter, const rtl::OUString& rOptions,
508 : : const rtl::OUString& rTabName, sal_uLong nRefreshDelay )
509 : : {
510 [ + - ][ + - ]: 6 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
511 [ + - ][ + - ]: 6 : maTabs[nTab]->SetLink( nMode, rDoc, rFilter, rOptions, rTabName, nRefreshDelay );
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
512 : 6 : }
513 : :
514 : 0 : bool ScDocument::HasLink( const rtl::OUString& rDoc,
515 : : const rtl::OUString& rFilter, const rtl::OUString& rOptions ) const
516 : : {
517 : 0 : SCTAB nCount = static_cast<SCTAB>(maTabs.size());
518 [ # # ]: 0 : for (SCTAB i=0; i<nCount; i++)
519 [ # # # # : 0 : if (maTabs[i]->IsLinked()
# # # # ]
[ # # ]
520 : 0 : && maTabs[i]->GetLinkDoc() == rDoc
521 : 0 : && maTabs[i]->GetLinkFlt() == rFilter
522 : 0 : && maTabs[i]->GetLinkOpt() == rOptions)
523 : 0 : return true;
524 : :
525 : 0 : return false;
526 : : }
527 : :
528 : 0 : bool ScDocument::LinkExternalTab( SCTAB& rTab, const rtl::OUString& aDocTab,
529 : : const rtl::OUString& aFileName, const rtl::OUString& aTabName )
530 : : {
531 [ # # ]: 0 : if ( IsClipboard() )
532 : : {
533 : : OSL_FAIL( "LinkExternalTab in Clipboard" );
534 : 0 : return false;
535 : : }
536 : 0 : rTab = 0;
537 : 0 : rtl::OUString aFilterName; // wird vom Loader gefuellt
538 : 0 : rtl::OUString aOptions; // Filter-Optionen
539 [ # # ][ # # ]: 0 : sal_uInt32 nLinkCnt = pExtDocOptions ? pExtDocOptions->GetDocSettings().mnLinkCnt : 0;
540 [ # # ]: 0 : ScDocumentLoader aLoader( aFileName, aFilterName, aOptions, nLinkCnt + 1 );
541 [ # # ][ # # ]: 0 : if ( aLoader.IsError() )
542 : 0 : return false;
543 [ # # ]: 0 : ScDocument* pSrcDoc = aLoader.GetDocument();
544 : :
545 : : // Tabelle kopieren
546 : : SCTAB nSrcTab;
547 [ # # ][ # # ]: 0 : if ( pSrcDoc->GetTable( aTabName, nSrcTab ) )
548 : : {
549 [ # # ][ # # ]: 0 : if ( !InsertTab( SC_TAB_APPEND, aDocTab, true ) )
550 : : {
551 : : OSL_FAIL("can't insert external document table");
552 : 0 : return false;
553 : : }
554 [ # # ]: 0 : rTab = GetTableCount() - 1;
555 : : // nicht neu einfuegen, nur Ergebnisse
556 [ # # ]: 0 : TransferTab( pSrcDoc, nSrcTab, rTab, false, true );
557 : : }
558 : : else
559 : 0 : return false;
560 : :
561 : 0 : sal_uLong nRefreshDelay = 0;
562 : :
563 [ # # ]: 0 : bool bWasThere = HasLink( aFileName, aFilterName, aOptions );
564 [ # # ]: 0 : SetLink( rTab, SC_LINK_VALUE, aFileName, aFilterName, aOptions, aTabName, nRefreshDelay );
565 [ # # ]: 0 : if ( !bWasThere ) // Link pro Quelldokument nur einmal eintragen
566 : : {
567 [ # # ][ # # ]: 0 : ScTableLink* pLink = new ScTableLink( pShell, aFileName, aFilterName, aOptions, nRefreshDelay );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
568 : 0 : pLink->SetInCreate( true );
569 [ # # ]: 0 : String aFilName = aFilterName;
570 : : GetLinkManager()->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, String(aFileName),
571 [ # # ][ # # ]: 0 : &aFilName );
[ # # ][ # # ]
572 [ # # ]: 0 : pLink->Update();
573 : 0 : pLink->SetInCreate( false );
574 [ # # ]: 0 : SfxBindings* pBindings = GetViewBindings();
575 [ # # ]: 0 : if (pBindings)
576 [ # # ][ # # ]: 0 : pBindings->Invalidate( SID_LINKS );
577 : : }
578 [ # # ]: 0 : return true;
579 : : }
580 : :
581 : 2993 : ScExternalRefManager* ScDocument::GetExternalRefManager() const
582 : : {
583 : 2993 : ScDocument* pThis = const_cast<ScDocument*>(this);
584 [ + + ]: 2993 : if (!pExternalRefMgr.get())
585 [ + - ]: 275 : pThis->pExternalRefMgr.reset( new ScExternalRefManager( pThis));
586 : :
587 : 2993 : return pExternalRefMgr.get();
588 : : }
589 : :
590 : 45 : bool ScDocument::IsInExternalReferenceMarking() const
591 : : {
592 [ + - ][ - + ]: 45 : return pExternalRefMgr.get() && pExternalRefMgr->isInReferenceMarking();
593 : : }
594 : :
595 : 0 : void ScDocument::MarkUsedExternalReferences()
596 : : {
597 [ # # ]: 0 : if (!pExternalRefMgr.get())
598 : 0 : return;
599 [ # # ]: 0 : if (!pExternalRefMgr->hasExternalData())
600 : 0 : return;
601 : : // Charts.
602 : 0 : pExternalRefMgr->markUsedByLinkListeners();
603 : : // Formula cells.
604 : 0 : pExternalRefMgr->markUsedExternalRefCells();
605 : :
606 : : /* NOTE: Conditional formats and validation objects are marked when
607 : : * collecting them during export. */
608 : : }
609 : :
610 : 0 : ScFormulaParserPool& ScDocument::GetFormulaParserPool() const
611 : : {
612 [ # # ]: 0 : if( !mxFormulaParserPool.get() )
613 [ # # ]: 0 : mxFormulaParserPool.reset( new ScFormulaParserPool( *this ) );
614 : 0 : return *mxFormulaParserPool;
615 : : }
616 : :
617 : 426 : const ScSheetEvents* ScDocument::GetSheetEvents( SCTAB nTab ) const
618 : : {
619 [ + - ][ + - ]: 426 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
620 : 426 : return maTabs[nTab]->GetSheetEvents();
621 : 426 : return NULL;
622 : : }
623 : :
624 : 19 : void ScDocument::SetSheetEvents( SCTAB nTab, const ScSheetEvents* pNew )
625 : : {
626 [ + - ][ + - ]: 19 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
627 : 19 : maTabs[nTab]->SetSheetEvents( pNew );
628 : 19 : }
629 : :
630 : 27580 : bool ScDocument::HasSheetEventScript( SCTAB nTab, sal_Int32 nEvent, bool bWithVbaEvents ) const
631 : : {
632 [ + - ][ + - ]: 27580 : if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ]
633 : : {
634 : : // check if any event handler script has been configured
635 : 27580 : const ScSheetEvents* pEvents = maTabs[nTab]->GetSheetEvents();
636 [ # # ][ - + ]: 27580 : if ( pEvents && pEvents->GetScript( nEvent ) )
[ - + ]
637 : 0 : return true;
638 : : // check if VBA event handlers exist
639 [ + + ][ + + ]: 27580 : if (bWithVbaEvents && mxVbaEvents.is()) try
[ + + ]
640 : : {
641 [ + - ]: 40 : uno::Sequence< uno::Any > aArgs( 1 );
642 [ + - ][ + - ]: 40 : aArgs[ 0 ] <<= nTab;
643 [ + - ][ + - ]: 40 : if (mxVbaEvents->hasVbaEventHandler( ScSheetEvents::GetVbaSheetEventId( nEvent ), aArgs ) ||
[ - + ][ # # ]
[ # # ][ # # ]
644 [ # # ][ # # ]: 40 : mxVbaEvents->hasVbaEventHandler( ScSheetEvents::GetVbaDocumentEventId( nEvent ), uno::Sequence< uno::Any >() ))
[ # # ][ # # ]
[ # # ][ # # ]
[ - + ]
645 [ # # ][ # # ]: 40 : return true;
[ - + ]
646 : : }
647 : 40 : catch( uno::Exception& )
648 : : {
649 : : }
650 : : }
651 : 27580 : return false;
652 : : }
653 : :
654 : 19160 : bool ScDocument::HasAnySheetEventScript( sal_Int32 nEvent, bool bWithVbaEvents ) const
655 : : {
656 : 19160 : SCTAB nSize = static_cast<SCTAB>(maTabs.size());
657 [ + + ]: 46740 : for (SCTAB nTab = 0; nTab < nSize; nTab++)
658 [ - + ]: 27580 : if (HasSheetEventScript( nTab, nEvent, bWithVbaEvents ))
659 : 0 : return true;
660 : 19160 : return false;
661 : : }
662 : :
663 : 54 : bool ScDocument::HasAnyCalcNotification() const
664 : : {
665 : 54 : SCTAB nSize = static_cast<SCTAB>(maTabs.size());
666 [ + + ]: 170 : for (SCTAB nTab = 0; nTab < nSize; nTab++)
667 [ + - ][ - + ]: 116 : if (maTabs[nTab] && maTabs[nTab]->GetCalcNotification())
[ - + ]
668 : 0 : return true;
669 : 54 : return false;
670 : : }
671 : :
672 : 0 : bool ScDocument::HasCalcNotification( SCTAB nTab ) const
673 : : {
674 [ # # ][ # # ]: 0 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ # # ][ # # ]
675 : 0 : return maTabs[nTab]->GetCalcNotification();
676 : 0 : return false;
677 : : }
678 : :
679 : 0 : void ScDocument::SetCalcNotification( SCTAB nTab )
680 : : {
681 : : // set only if not set before
682 [ # # ][ # # ]: 0 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && !maTabs[nTab]->GetCalcNotification())
[ # # ][ # # ]
[ # # ]
683 : 0 : maTabs[nTab]->SetCalcNotification(true);
684 : 0 : }
685 : :
686 : 0 : void ScDocument::ResetCalcNotifications()
687 : : {
688 : 0 : SCTAB nSize = static_cast<SCTAB>(maTabs.size());
689 [ # # ]: 0 : for (SCTAB nTab = 0; nTab < nSize; nTab++)
690 [ # # ][ # # ]: 0 : if (maTabs[nTab] && maTabs[nTab]->GetCalcNotification())
[ # # ]
691 : 0 : maTabs[nTab]->SetCalcNotification(false);
692 : 0 : }
693 : :
694 : 6680 : ScOutlineTable* ScDocument::GetOutlineTable( SCTAB nTab, bool bCreate )
695 : : {
696 : 6680 : ScOutlineTable* pVal = NULL;
697 : :
698 [ + - ][ + - ]: 6680 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
[ + - ]
699 [ + - ]: 6680 : if (maTabs[nTab])
700 : : {
701 : 6680 : pVal = maTabs[nTab]->GetOutlineTable();
702 [ + + ]: 6680 : if (!pVal)
703 [ + + ]: 6299 : if (bCreate)
704 : : {
705 : 165 : maTabs[nTab]->StartOutlineTable();
706 : 165 : pVal = maTabs[nTab]->GetOutlineTable();
707 : : }
708 : : }
709 : :
710 : 6680 : return pVal;
711 : : }
712 : :
713 : 0 : bool ScDocument::SetOutlineTable( SCTAB nTab, const ScOutlineTable* pNewOutline )
714 : : {
715 [ # # ][ # # ]: 0 : return VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->SetOutlineTable(pNewOutline);
[ # # ][ # # ]
716 : : }
717 : :
718 : 0 : void ScDocument::DoAutoOutline( SCCOL nStartCol, SCROW nStartRow,
719 : : SCCOL nEndCol, SCROW nEndRow, SCTAB nTab )
720 : : {
721 [ # # ][ # # ]: 0 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ # # ][ # # ]
722 : 0 : maTabs[nTab]->DoAutoOutline( nStartCol, nStartRow, nEndCol, nEndRow );
723 : 0 : }
724 : :
725 : 4 : bool ScDocument::TestRemoveSubTotals( SCTAB nTab, const ScSubTotalParam& rParam )
726 : : {
727 [ + - ][ + - ]: 4 : return VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->TestRemoveSubTotals( rParam );
[ + - ][ - + ]
728 : : }
729 : :
730 : 4 : void ScDocument::RemoveSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
731 : : {
732 [ + - ][ + - ]: 4 : if ( VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
733 : 4 : maTabs[nTab]->RemoveSubTotals( rParam );
734 : 4 : }
735 : :
736 : 2 : bool ScDocument::DoSubTotals( SCTAB nTab, ScSubTotalParam& rParam )
737 : : {
738 [ + - ][ + - ]: 2 : return VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->DoSubTotals( rParam );
[ + - ][ + - ]
739 : : }
740 : :
741 : 0 : bool ScDocument::HasSubTotalCells( const ScRange& rRange )
742 : : {
743 [ # # ]: 0 : ScCellIterator aIter( this, rRange );
744 [ # # ]: 0 : ScBaseCell* pCell = aIter.GetFirst();
745 [ # # ]: 0 : while (pCell)
746 : : {
747 [ # # ][ # # ]: 0 : if ( pCell->GetCellType() == CELLTYPE_FORMULA && ((ScFormulaCell*)pCell)->IsSubTotal() )
[ # # ][ # # ]
748 : 0 : return true;
749 : :
750 [ # # ]: 0 : pCell = aIter.GetNext();
751 : : }
752 : 0 : return false; // none found
753 : : }
754 : :
755 : : // kopiert aus diesem Dokument die Zellen von Positionen, an denen in pPosDoc
756 : : // auch Zellen stehen, nach pDestDoc
757 : :
758 : 0 : void ScDocument::CopyUpdated( ScDocument* pPosDoc, ScDocument* pDestDoc )
759 : : {
760 : 0 : SCTAB nCount = static_cast<SCTAB>(maTabs.size());
761 [ # # ]: 0 : for (SCTAB nTab=0; nTab<nCount; nTab++)
762 [ # # ][ # # ]: 0 : if (maTabs[nTab] && pPosDoc->maTabs[nTab] && pDestDoc->maTabs[nTab])
[ # # ][ # # ]
763 : 0 : maTabs[nTab]->CopyUpdated( pPosDoc->maTabs[nTab], pDestDoc->maTabs[nTab] );
764 : 0 : }
765 : :
766 : 1 : void ScDocument::CopyScenario( SCTAB nSrcTab, SCTAB nDestTab, bool bNewScenario )
767 : : {
768 [ + - ][ + - ]: 4 : if (ValidTab(nSrcTab) && ValidTab(nDestTab) && nSrcTab < static_cast<SCTAB>(maTabs.size())
[ + - + -
+ - + - ]
[ + - ]
769 : 3 : && nDestTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nSrcTab] && maTabs[nDestTab])
770 : : {
771 : : // Flags fuer aktive Szenarios richtig setzen
772 : : // und aktuelle Werte in bisher aktive Szenarios zurueckschreiben
773 : :
774 [ + - ][ + - ]: 1 : ScRangeList aRanges = *maTabs[nSrcTab]->GetScenarioRanges();
775 : :
776 : : // nDestTab ist die Zieltabelle
777 [ + + + - : 6 : for ( SCTAB nTab = nDestTab+1;
+ - ][ + + ]
778 : 4 : nTab< static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsScenario();
779 : : nTab++ )
780 : : {
781 [ - + ]: 1 : if ( maTabs[nTab]->IsActiveScenario() ) // auch wenn's dasselbe Szenario ist
782 : : {
783 : 0 : bool bTouched = false;
784 [ # # ][ # # ]: 0 : for ( size_t nR=0, nRangeCount = aRanges.size(); nR < nRangeCount && !bTouched; nR++ )
[ # # ][ # # ]
785 : : {
786 [ # # ]: 0 : const ScRange* pRange = aRanges[ nR ];
787 [ # # ][ # # ]: 0 : if ( maTabs[nTab]->HasScenarioRange( *pRange ) )
788 : 0 : bTouched = true;
789 : : }
790 [ # # ]: 0 : if (bTouched)
791 : : {
792 : 0 : maTabs[nTab]->SetActiveScenario(false);
793 [ # # ]: 0 : if ( maTabs[nTab]->GetScenarioFlags() & SC_SCENARIO_TWOWAY )
794 [ # # ]: 0 : maTabs[nTab]->CopyScenarioFrom( maTabs[nDestTab] );
795 : : }
796 : : }
797 : : }
798 : :
799 : 1 : maTabs[nSrcTab]->SetActiveScenario(true); // da kommt's her...
800 [ - + ]: 1 : if (!bNewScenario) // Daten aus dem ausgewaehlten Szenario kopieren
801 : : {
802 : 0 : bool bOldAutoCalc = GetAutoCalc();
803 [ # # ]: 0 : SetAutoCalc( false ); // Mehrfachberechnungen vermeiden
804 [ # # ]: 0 : maTabs[nSrcTab]->CopyScenarioTo( maTabs[nDestTab] );
805 [ # # ]: 0 : SetDirty();
806 [ # # ]: 0 : SetAutoCalc( bOldAutoCalc );
807 [ + - ]: 1 : }
808 : : }
809 : 1 : }
810 : :
811 : 0 : void ScDocument::MarkScenario( SCTAB nSrcTab, SCTAB nDestTab, ScMarkData& rDestMark,
812 : : bool bResetMark, sal_uInt16 nNeededBits ) const
813 : : {
814 [ # # ]: 0 : if (bResetMark)
815 : 0 : rDestMark.ResetMark();
816 : :
817 [ # # ][ # # ]: 0 : if (ValidTab(nSrcTab) && nSrcTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nSrcTab])
[ # # ][ # # ]
818 : 0 : maTabs[nSrcTab]->MarkScenarioIn( rDestMark, nNeededBits );
819 : :
820 : 0 : rDestMark.SetAreaTab( nDestTab );
821 : 0 : }
822 : :
823 : 0 : bool ScDocument::HasScenarioRange( SCTAB nTab, const ScRange& rRange ) const
824 : : {
825 [ # # ][ # # ]: 0 : return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->HasScenarioRange( rRange );
[ # # ][ # # ]
826 : : }
827 : :
828 : 0 : const ScRangeList* ScDocument::GetScenarioRanges( SCTAB nTab ) const
829 : : {
830 [ # # ][ # # ]: 0 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ # # ][ # # ]
831 : 0 : return maTabs[nTab]->GetScenarioRanges();
832 : :
833 : 0 : return NULL;
834 : : }
835 : :
836 : 0 : bool ScDocument::IsActiveScenario( SCTAB nTab ) const
837 : : {
838 [ # # ][ # # ]: 0 : return ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && maTabs[nTab]->IsActiveScenario( );
[ # # ][ # # ]
839 : : }
840 : :
841 : 0 : void ScDocument::SetActiveScenario( SCTAB nTab, bool bActive )
842 : : {
843 [ # # ][ # # ]: 0 : if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ # # ][ # # ]
844 : 0 : maTabs[nTab]->SetActiveScenario( bActive );
845 : 0 : }
846 : :
847 : 0 : bool ScDocument::TestCopyScenario( SCTAB nSrcTab, SCTAB nDestTab ) const
848 : : {
849 [ # # ][ # # : 0 : if (ValidTab(nSrcTab) && nSrcTab < static_cast<SCTAB>(maTabs.size())
# # # # ]
[ # # ]
850 : 0 : && nDestTab < static_cast<SCTAB>(maTabs.size())&& ValidTab(nDestTab))
851 : 0 : return maTabs[nSrcTab]->TestCopyScenarioTo( maTabs[nDestTab] );
852 : :
853 : : OSL_FAIL("falsche Tabelle bei TestCopyScenario");
854 : 0 : return false;
855 : : }
856 : :
857 : 27992 : void ScDocument::AddUnoObject( SfxListener& rObject )
858 : : {
859 [ + + ]: 27992 : if (!pUnoBroadcaster)
860 [ + - ]: 846 : pUnoBroadcaster = new SfxBroadcaster;
861 : :
862 : 27992 : rObject.StartListening( *pUnoBroadcaster );
863 : 27992 : }
864 : :
865 : 22100 : void ScDocument::RemoveUnoObject( SfxListener& rObject )
866 : : {
867 [ + - ]: 22100 : if (pUnoBroadcaster)
868 : : {
869 : 22100 : rObject.EndListening( *pUnoBroadcaster );
870 : :
871 [ - + ]: 22100 : if ( bInUnoBroadcast )
872 : : {
873 : : // Broadcasts from ScDocument::BroadcastUno are the only way that
874 : : // uno object methods are called without holding a reference.
875 : : //
876 : : // If RemoveUnoObject is called from an object dtor in the finalizer thread
877 : : // while the main thread is calling BroadcastUno, the dtor thread must wait
878 : : // (or the object's Notify might try to access a deleted object).
879 : : // The SolarMutex can't be locked here because if a component is called from
880 : : // a VCL event, the main thread has the SolarMutex locked all the time.
881 : : //
882 : : // This check is done after calling EndListening, so a later BroadcastUno call
883 : : // won't touch this object.
884 : :
885 : 0 : osl::SolarMutex& rSolarMutex = Application::GetSolarMutex();
886 [ # # ]: 0 : if ( rSolarMutex.tryToAcquire() )
887 : : {
888 : : // BroadcastUno is always called with the SolarMutex locked, so if it
889 : : // can be acquired, this is within the same thread (should not happen)
890 : : OSL_FAIL( "RemoveUnoObject called from BroadcastUno" );
891 : 0 : rSolarMutex.release();
892 : : }
893 : : else
894 : : {
895 : : // let the thread that called BroadcastUno continue
896 [ # # ]: 0 : while ( bInUnoBroadcast )
897 : : {
898 : 0 : osl::Thread::yield();
899 : : }
900 : : }
901 : : }
902 : : }
903 : : else
904 : : {
905 : : OSL_FAIL("No Uno broadcaster");
906 : : }
907 : 22100 : }
908 : :
909 : 17912 : void ScDocument::BroadcastUno( const SfxHint &rHint )
910 : : {
911 [ + - ]: 17912 : if (pUnoBroadcaster)
912 : : {
913 : 17912 : bInUnoBroadcast = true;
914 : 17912 : pUnoBroadcaster->Broadcast( rHint );
915 : 17912 : bInUnoBroadcast = false;
916 : :
917 : : // During Broadcast notification, Uno objects can add to pUnoListenerCalls.
918 : : // The listener calls must be processed after completing the broadcast,
919 : : // because they can add or remove objects from pUnoBroadcaster.
920 : :
921 [ # # # # ]: 17912 : if ( pUnoListenerCalls && rHint.ISA( SfxSimpleHint ) &&
[ # # ][ - + ]
[ - + ]
922 : 0 : ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DATACHANGED &&
923 : 0 : !bInUnoListenerCall )
924 : : {
925 : : // Listener calls may lead to BroadcastUno calls again. The listener calls
926 : : // are not nested, instead the calls are collected in the list, and the
927 : : // outermost call executes them all.
928 : :
929 [ # # ]: 0 : ScChartLockGuard aChartLockGuard(this);
930 : 0 : bInUnoListenerCall = true;
931 [ # # ]: 0 : pUnoListenerCalls->ExecuteAndClear();
932 [ # # ]: 0 : bInUnoListenerCall = false;
933 : : }
934 : : }
935 : 17912 : }
936 : :
937 : 0 : void ScDocument::AddUnoListenerCall( const uno::Reference<util::XModifyListener>& rListener,
938 : : const lang::EventObject& rEvent )
939 : : {
940 : : OSL_ENSURE( bInUnoBroadcast, "AddUnoListenerCall is supposed to be called from BroadcastUno only" );
941 : :
942 [ # # ]: 0 : if ( !pUnoListenerCalls )
943 [ # # ]: 0 : pUnoListenerCalls = new ScUnoListenerCalls;
944 : 0 : pUnoListenerCalls->Add( rListener, rEvent );
945 : 0 : }
946 : :
947 : 36 : void ScDocument::BeginUnoRefUndo()
948 : : {
949 : : OSL_ENSURE( !pUnoRefUndoList, "BeginUnoRefUndo twice" );
950 [ - + ]: 36 : delete pUnoRefUndoList;
951 : :
952 [ + - ]: 36 : pUnoRefUndoList = new ScUnoRefList;
953 : 36 : }
954 : :
955 : 36 : ScUnoRefList* ScDocument::EndUnoRefUndo()
956 : : {
957 : 36 : ScUnoRefList* pRet = pUnoRefUndoList;
958 : 36 : pUnoRefUndoList = NULL;
959 : 36 : return pRet; // must be deleted by caller!
960 : : }
961 : :
962 : 1426 : void ScDocument::AddUnoRefChange( sal_Int64 nId, const ScRangeList& rOldRanges )
963 : : {
964 [ + - ]: 1426 : if ( pUnoRefUndoList )
965 : 1426 : pUnoRefUndoList->Add( nId, rOldRanges );
966 : 1426 : }
967 : :
968 : 16365 : sal_Int64 ScDocument::GetNewUnoId()
969 : : {
970 : 16365 : return ++nUnoObjectId;
971 : : }
972 : :
973 : 65 : void ScDocument::UpdateReference( UpdateRefMode eUpdateRefMode,
974 : : SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
975 : : SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
976 : : SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
977 : : ScDocument* pUndoDoc, bool bIncludeDraw,
978 : : bool bUpdateNoteCaptionPos )
979 : : {
980 : 65 : PutInOrder( nCol1, nCol2 );
981 : 65 : PutInOrder( nRow1, nRow2 );
982 : 65 : PutInOrder( nTab1, nTab2 );
983 [ + - ][ + - ]: 65 : if (VALIDTAB(nTab1) && VALIDTAB(nTab2))
[ + - ]
984 : : {
985 : 65 : bool bExpandRefsOld = IsExpandRefs();
986 [ + + ][ + + ]: 65 : if ( eUpdateRefMode == URM_INSDEL && (nDx > 0 || nDy > 0 || nDz > 0) )
[ - + ][ + + ]
987 : 27 : SetExpandRefs( SC_MOD()->GetInputOptions().GetExpandRefs() );
988 : : SCTAB i;
989 : : SCTAB iMax;
990 [ + + ]: 65 : if ( eUpdateRefMode == URM_COPY )
991 : : {
992 : 25 : i = nTab1;
993 : 25 : iMax = nTab2;
994 : : }
995 : : else
996 : : {
997 : 40 : ScRange aRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
998 [ + - ]: 40 : xColNameRanges->UpdateReference( eUpdateRefMode, this, aRange, nDx, nDy, nDz );
999 [ + - ]: 40 : xRowNameRanges->UpdateReference( eUpdateRefMode, this, aRange, nDx, nDy, nDz );
1000 [ + - ]: 40 : pDBCollection->UpdateReference( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz );
1001 [ + + ]: 40 : if (pRangeName)
1002 [ + - ]: 19 : pRangeName->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz );
1003 [ + + ]: 40 : if ( pDPCollection )
1004 [ + - ]: 11 : pDPCollection->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz );
1005 [ + - ]: 40 : UpdateChartRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz );
1006 [ + - ]: 40 : UpdateRefAreaLinks( eUpdateRefMode, aRange, nDx, nDy, nDz );
1007 [ - + ]: 40 : if ( pValidationList )
1008 [ # # ]: 0 : pValidationList->UpdateReference( eUpdateRefMode, aRange, nDx, nDy, nDz );
1009 [ - + ]: 40 : if ( pDetOpList )
1010 [ # # ]: 0 : pDetOpList->UpdateReference( this, eUpdateRefMode, aRange, nDx, nDy, nDz );
1011 [ + - ]: 40 : if ( pUnoBroadcaster )
1012 : : pUnoBroadcaster->Broadcast( ScUpdateRefHint(
1013 [ + - ][ + - ]: 40 : eUpdateRefMode, aRange, nDx, nDy, nDz ) );
[ + - ]
1014 : 40 : i = 0;
1015 : 40 : iMax = static_cast<SCTAB>(maTabs.size())-1;
1016 : : }
1017 [ + + ][ + - ]: 139 : for ( ; i<=iMax && i < static_cast<SCTAB>(maTabs.size()); i++)
[ + + ]
1018 [ + - ]: 74 : if (maTabs[i])
1019 : 74 : maTabs[i]->UpdateReference(
1020 : : eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2,
1021 : 74 : nDx, nDy, nDz, pUndoDoc, bIncludeDraw, bUpdateNoteCaptionPos );
1022 : :
1023 [ - + ]: 65 : if ( bIsEmbedded )
1024 : : {
1025 : : SCCOL theCol1;
1026 : : SCROW theRow1;
1027 : : SCTAB theTab1;
1028 : : SCCOL theCol2;
1029 : : SCROW theRow2;
1030 : : SCTAB theTab2;
1031 : 0 : theCol1 = aEmbedRange.aStart.Col();
1032 : 0 : theRow1 = aEmbedRange.aStart.Row();
1033 : 0 : theTab1 = aEmbedRange.aStart.Tab();
1034 : 0 : theCol2 = aEmbedRange.aEnd.Col();
1035 : 0 : theRow2 = aEmbedRange.aEnd.Row();
1036 : 0 : theTab2 = aEmbedRange.aEnd.Tab();
1037 [ # # ]: 0 : if ( ScRefUpdate::Update( this, eUpdateRefMode, nCol1,nRow1,nTab1, nCol2,nRow2,nTab2,
1038 [ # # ]: 0 : nDx,nDy,nDz, theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) )
1039 : : {
1040 : 0 : aEmbedRange = ScRange( theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 );
1041 : : }
1042 : : }
1043 : 65 : SetExpandRefs( bExpandRefsOld );
1044 : :
1045 : : // after moving, no clipboard move ref-updates are possible
1046 [ - + ][ - + ]: 65 : if ( eUpdateRefMode != URM_COPY && IsClipboardSource() )
[ + + ]
1047 : : {
1048 : 0 : ScDocument* pClipDoc = SC_MOD()->GetClipDoc();
1049 [ # # ]: 0 : if (pClipDoc)
1050 : 0 : pClipDoc->GetClipParam().mbCutMode = false;
1051 : : }
1052 : : }
1053 : 65 : }
1054 : :
1055 : 0 : void ScDocument::UpdateTranspose( const ScAddress& rDestPos, ScDocument* pClipDoc,
1056 : : const ScMarkData& rMark, ScDocument* pUndoDoc )
1057 : : {
1058 : : OSL_ENSURE(pClipDoc->bIsClip, "UpdateTranspose: kein Clip");
1059 : :
1060 : 0 : ScRange aSource;
1061 [ # # ]: 0 : ScClipParam& rClipParam = GetClipParam();
1062 [ # # ][ # # ]: 0 : if (!rClipParam.maRanges.empty())
1063 [ # # ]: 0 : aSource = *rClipParam.maRanges.front();
1064 : 0 : ScAddress aDest = rDestPos;
1065 : :
1066 : 0 : SCTAB nClipTab = 0;
1067 [ # # ][ # # ]: 0 : for (SCTAB nDestTab=0; nDestTab< static_cast<SCTAB>(maTabs.size()) && maTabs[nDestTab]; nDestTab++)
[ # # ]
1068 [ # # ][ # # ]: 0 : if (rMark.GetTableSelect(nDestTab))
1069 : : {
1070 [ # # ]: 0 : while (!pClipDoc->maTabs[nClipTab]) nClipTab = (nClipTab+1) % (MAXTAB+1);
1071 : 0 : aSource.aStart.SetTab( nClipTab );
1072 : 0 : aSource.aEnd.SetTab( nClipTab );
1073 : 0 : aDest.SetTab( nDestTab );
1074 : :
1075 : : // wie UpdateReference
1076 [ # # ]: 0 : if (pRangeName)
1077 [ # # ]: 0 : pRangeName->UpdateTranspose( aSource, aDest ); // vor den Zellen!
1078 [ # # ]: 0 : for (SCTAB i=0; i< static_cast<SCTAB>(maTabs.size()); i++)
1079 [ # # ]: 0 : if (maTabs[i])
1080 [ # # ]: 0 : maTabs[i]->UpdateTranspose( aSource, aDest, pUndoDoc );
1081 : :
1082 : 0 : nClipTab = (nClipTab+1) % (MAXTAB+1);
1083 : : }
1084 : 0 : }
1085 : :
1086 : 0 : void ScDocument::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
1087 : : {
1088 : : //! pDBCollection
1089 : : //! pPivotCollection
1090 : : //! UpdateChartRef
1091 : :
1092 [ # # ]: 0 : if (pRangeName)
1093 : 0 : pRangeName->UpdateGrow( rArea, nGrowX, nGrowY );
1094 : :
1095 [ # # ][ # # ]: 0 : for (SCTAB i=0; i< static_cast<SCTAB>(maTabs.size()) && maTabs[i]; i++)
[ # # ]
1096 : 0 : maTabs[i]->UpdateGrow( rArea, nGrowX, nGrowY );
1097 : 0 : }
1098 : :
1099 : 27 : void ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScProgress* pProgress, const ScMarkData& rMark,
1100 : : sal_uLong nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,
1101 : : double nStepValue, double nMaxValue)
1102 : : {
1103 : 27 : PutInOrder( nCol1, nCol2 );
1104 : 27 : PutInOrder( nRow1, nRow2 );
1105 : 27 : SCTAB nMax = maTabs.size();
1106 [ + - ][ + - ]: 27 : ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
1107 [ + - ][ + - ]: 54 : for (; itr != itrEnd && *itr < nMax; ++itr)
[ + + ][ + - ]
[ + - ][ + + ]
1108 [ + - ][ + - ]: 27 : if (maTabs[*itr])
1109 [ + - ]: 27 : maTabs[*itr]->Fill(nCol1, nRow1, nCol2, nRow2,
1110 : : nFillCount, eFillDir, eFillCmd, eFillDateCmd,
1111 [ + - ]: 27 : nStepValue, nMaxValue, pProgress);
1112 : 27 : }
1113 : :
1114 : 0 : rtl::OUString ScDocument::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY )
1115 : : {
1116 : 0 : SCTAB nTab = rSource.aStart.Tab();
1117 [ # # ][ # # ]: 0 : if (nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ # # ]
1118 [ # # ]: 0 : return maTabs[nTab]->GetAutoFillPreview( rSource, nEndX, nEndY );
1119 : :
1120 : 0 : return rtl::OUString();
1121 : : }
1122 : :
1123 : 0 : void ScDocument::AutoFormat( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1124 : : sal_uInt16 nFormatNo, const ScMarkData& rMark )
1125 : : {
1126 : 0 : PutInOrder( nStartCol, nEndCol );
1127 : 0 : PutInOrder( nStartRow, nEndRow );
1128 : 0 : SCTAB nMax = maTabs.size();
1129 [ # # ][ # # ]: 0 : ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
1130 [ # # ][ # # ]: 0 : for (; itr != itrEnd && *itr < nMax; ++itr)
[ # # ][ # # ]
[ # # ][ # # ]
1131 [ # # ][ # # ]: 0 : if (maTabs[*itr])
1132 [ # # ][ # # ]: 0 : maTabs[*itr]->AutoFormat( nStartCol, nStartRow, nEndCol, nEndRow, nFormatNo );
1133 : 0 : }
1134 : :
1135 : 0 : void ScDocument::GetAutoFormatData(SCTAB nTab, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1136 : : ScAutoFormatData& rData)
1137 : : {
1138 [ # # ][ # # ]: 0 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
[ # # ]
1139 : : {
1140 [ # # ]: 0 : if (maTabs[nTab])
1141 : : {
1142 : 0 : PutInOrder(nStartCol, nEndCol);
1143 : 0 : PutInOrder(nStartRow, nEndRow);
1144 : 0 : maTabs[nTab]->GetAutoFormatData(nStartCol, nStartRow, nEndCol, nEndRow, rData);
1145 : : }
1146 : : }
1147 : 0 : }
1148 : :
1149 : 54 : void ScDocument::GetSearchAndReplaceStart( const SvxSearchItem& rSearchItem,
1150 : : SCCOL& rCol, SCROW& rRow )
1151 : : {
1152 : 54 : sal_uInt16 nCommand = rSearchItem.GetCommand();
1153 : : bool bReplace = ( nCommand == SVX_SEARCHCMD_REPLACE ||
1154 [ - + ][ + - ]: 54 : nCommand == SVX_SEARCHCMD_REPLACE_ALL );
1155 [ - + ]: 54 : if ( rSearchItem.GetBackward() )
1156 : : {
1157 [ # # ]: 0 : if ( rSearchItem.GetRowDirection() )
1158 : : {
1159 [ # # ]: 0 : if ( rSearchItem.GetPattern() )
1160 : : {
1161 : 0 : rCol = MAXCOL;
1162 : 0 : rRow = MAXROW+1;
1163 : : }
1164 [ # # ]: 0 : else if ( bReplace )
1165 : : {
1166 : 0 : rCol = MAXCOL;
1167 : 0 : rRow = MAXROW;
1168 : : }
1169 : : else
1170 : : {
1171 : 0 : rCol = MAXCOL+1;
1172 : 0 : rRow = MAXROW;
1173 : : }
1174 : : }
1175 : : else
1176 : : {
1177 [ # # ]: 0 : if ( rSearchItem.GetPattern() )
1178 : : {
1179 : 0 : rCol = MAXCOL+1;
1180 : 0 : rRow = MAXROW;
1181 : : }
1182 [ # # ]: 0 : else if ( bReplace )
1183 : : {
1184 : 0 : rCol = MAXCOL;
1185 : 0 : rRow = MAXROW;
1186 : : }
1187 : : else
1188 : : {
1189 : 0 : rCol = MAXCOL;
1190 : 0 : rRow = MAXROW+1;
1191 : : }
1192 : : }
1193 : : }
1194 : : else
1195 : : {
1196 [ - + ]: 54 : if ( rSearchItem.GetRowDirection() )
1197 : : {
1198 [ # # ]: 0 : if ( rSearchItem.GetPattern() )
1199 : : {
1200 : 0 : rCol = 0;
1201 : 0 : rRow = (SCROW) -1;
1202 : : }
1203 [ # # ]: 0 : else if ( bReplace )
1204 : : {
1205 : 0 : rCol = 0;
1206 : 0 : rRow = 0;
1207 : : }
1208 : : else
1209 : : {
1210 : 0 : rCol = (SCCOL) -1;
1211 : 0 : rRow = 0;
1212 : : }
1213 : : }
1214 : : else
1215 : : {
1216 [ - + ]: 54 : if ( rSearchItem.GetPattern() )
1217 : : {
1218 : 0 : rCol = (SCCOL) -1;
1219 : 0 : rRow = 0;
1220 : : }
1221 [ - + ]: 54 : else if ( bReplace )
1222 : : {
1223 : 0 : rCol = 0;
1224 : 0 : rRow = 0;
1225 : : }
1226 : : else
1227 : : {
1228 : 54 : rCol = 0;
1229 : 54 : rRow = (SCROW) -1;
1230 : : }
1231 : : }
1232 : : }
1233 : 54 : }
1234 : :
1235 : 64 : bool ScDocument::SearchAndReplace(
1236 : : const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow, SCTAB& rTab,
1237 : : const ScMarkData& rMark, ScRangeList& rMatchedRanges,
1238 : : rtl::OUString& rUndoStr, ScDocument* pUndoDoc)
1239 : : {
1240 : : //! getrennte Markierungen pro Tabelle verwalten !!!!!!!!!!!!!
1241 : :
1242 : 64 : bool bFound = false;
1243 : 64 : if (rTab >= static_cast<SCTAB>(maTabs.size()))
1244 : : OSL_FAIL("table out of range");
1245 [ + - ]: 64 : if (VALIDTAB(rTab))
1246 : : {
1247 : : SCCOL nCol;
1248 : : SCROW nRow;
1249 : : SCTAB nTab;
1250 : 64 : sal_uInt16 nCommand = rSearchItem.GetCommand();
1251 [ + + ][ + + ]: 64 : if ( nCommand == SVX_SEARCHCMD_FIND_ALL ||
1252 : : nCommand == SVX_SEARCHCMD_REPLACE_ALL )
1253 : : {
1254 : 21 : SCTAB nMax = maTabs.size();
1255 [ + - ][ + - ]: 21 : ScMarkData::const_iterator itr = rMark.begin(), itrEnd = rMark.end();
1256 [ + - ][ + - ]: 42 : for (; itr != itrEnd && *itr < nMax; ++itr)
[ + + ][ + - ]
[ + - ][ + + ]
1257 [ + - ][ + - ]: 21 : if (maTabs[*itr])
1258 : : {
1259 : 21 : nCol = 0;
1260 : 21 : nRow = 0;
1261 [ + - ]: 21 : bFound |= maTabs[*itr]->SearchAndReplace(
1262 [ + - ]: 21 : rSearchItem, nCol, nRow, rMark, rMatchedRanges, rUndoStr, pUndoDoc);
1263 : 21 : }
1264 : :
1265 : : // Markierung wird innen schon komplett gesetzt
1266 : : }
1267 : : else
1268 : : {
1269 : 43 : nCol = rCol;
1270 : 43 : nRow = rRow;
1271 [ - + ]: 43 : if (rSearchItem.GetBackward())
1272 : : {
1273 [ # # ][ # # ]: 0 : for (nTab = rTab; ((SCsTAB)nTab >= 0) && !bFound; nTab--)
[ # # ]
1274 [ # # ]: 0 : if (maTabs[nTab])
1275 : : {
1276 [ # # ][ # # ]: 0 : if (rMark.GetTableSelect(nTab))
1277 : : {
1278 : 0 : bFound = maTabs[nTab]->SearchAndReplace(
1279 [ # # ]: 0 : rSearchItem, nCol, nRow, rMark, rMatchedRanges, rUndoStr, pUndoDoc);
1280 [ # # ]: 0 : if (bFound)
1281 : : {
1282 : 0 : rCol = nCol;
1283 : 0 : rRow = nRow;
1284 : 0 : rTab = nTab;
1285 : : }
1286 : : else
1287 : : ScDocument::GetSearchAndReplaceStart(
1288 : 0 : rSearchItem, nCol, nRow );
1289 : : }
1290 : : }
1291 : : }
1292 : : else
1293 : : {
1294 [ + + ][ + + ]: 125 : for (nTab = rTab; (nTab < static_cast<SCTAB>(maTabs.size())) && !bFound; nTab++)
[ + + ]
1295 [ + - ]: 61 : if (maTabs[nTab])
1296 : : {
1297 [ + - ][ + + ]: 61 : if (rMark.GetTableSelect(nTab))
1298 : : {
1299 : 43 : bFound = maTabs[nTab]->SearchAndReplace(
1300 [ + - ]: 43 : rSearchItem, nCol, nRow, rMark, rMatchedRanges, rUndoStr, pUndoDoc);
1301 [ + + ]: 43 : if (bFound)
1302 : : {
1303 : 28 : rCol = nCol;
1304 : 28 : rRow = nRow;
1305 : 28 : rTab = nTab;
1306 : : }
1307 : : else
1308 : : ScDocument::GetSearchAndReplaceStart(
1309 : 15 : rSearchItem, nCol, nRow );
1310 : : }
1311 : : }
1312 : : }
1313 : : }
1314 : : }
1315 : 64 : return bFound;
1316 : : }
1317 : :
1318 : : // Outline anpassen
1319 : :
1320 : 333 : bool ScDocument::UpdateOutlineCol( SCCOL nStartCol, SCCOL nEndCol, SCTAB nTab, bool bShow )
1321 : : {
1322 [ + - ][ + - ]: 333 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
1323 : 333 : return maTabs[nTab]->UpdateOutlineCol( nStartCol, nEndCol, bShow );
1324 : :
1325 : : OSL_FAIL("missing tab");
1326 : 333 : return false;
1327 : : }
1328 : :
1329 : 34 : bool ScDocument::UpdateOutlineRow( SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bShow )
1330 : : {
1331 [ + - ][ + - ]: 34 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
1332 : 34 : return maTabs[nTab]->UpdateOutlineRow( nStartRow, nEndRow, bShow );
1333 : :
1334 : : OSL_FAIL("missing tab");
1335 : 34 : return false;
1336 : : }
1337 : :
1338 : 10 : void ScDocument::Sort(SCTAB nTab, const ScSortParam& rSortParam, bool bKeepQuery)
1339 : : {
1340 [ + - ][ + - ]: 10 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
1341 : : {
1342 : 10 : bool bOldDisableIdle = IsIdleDisabled();
1343 : 10 : DisableIdle( true );
1344 : 10 : maTabs[nTab]->Sort(rSortParam, bKeepQuery);
1345 : 10 : DisableIdle( bOldDisableIdle );
1346 : : }
1347 : 10 : }
1348 : :
1349 : 16 : SCSIZE ScDocument::Query(SCTAB nTab, const ScQueryParam& rQueryParam, bool bKeepSub)
1350 : : {
1351 [ + - ][ + - ]: 16 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
1352 : 16 : return maTabs[nTab]->Query((ScQueryParam&)rQueryParam, bKeepSub);
1353 : :
1354 : : OSL_FAIL("missing tab");
1355 : 16 : return 0;
1356 : : }
1357 : :
1358 : :
1359 : 0 : void ScDocument::GetUpperCellString(SCCOL nCol, SCROW nRow, SCTAB nTab, rtl::OUString& rStr)
1360 : : {
1361 [ # # ][ # # ]: 0 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ # # ][ # # ]
1362 : 0 : maTabs[nTab]->GetUpperCellString( nCol, nRow, rStr );
1363 : : else
1364 : 0 : rStr = rtl::OUString();
1365 : 0 : }
1366 : :
1367 : 2 : bool ScDocument::CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCTAB nTab, ScQueryParam& rQueryParam)
1368 : : {
1369 [ + - ][ + - ]: 2 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
1370 : 2 : return maTabs[nTab]->CreateQueryParam(nCol1, nRow1, nCol2, nRow2, rQueryParam);
1371 : :
1372 : : OSL_FAIL("missing tab");
1373 : 2 : return false;
1374 : : }
1375 : :
1376 : 0 : bool ScDocument::HasAutoFilter( SCCOL nCurCol, SCROW nCurRow, SCTAB nCurTab )
1377 : : {
1378 : 0 : const ScDBData* pDBData = GetDBAtCursor( nCurCol, nCurRow, nCurTab );
1379 : 0 : bool bHasAutoFilter = (pDBData != NULL);
1380 : :
1381 [ # # ]: 0 : if ( pDBData )
1382 : : {
1383 [ # # ]: 0 : if ( pDBData->HasHeader() )
1384 : : {
1385 : : SCCOL nCol;
1386 : : SCROW nRow;
1387 : : sal_Int16 nFlag;
1388 : :
1389 [ # # ]: 0 : ScQueryParam aParam;
1390 [ # # ]: 0 : pDBData->GetQueryParam( aParam );
1391 : 0 : nRow = aParam.nRow1;
1392 : :
1393 [ # # ][ # # ]: 0 : for ( nCol=aParam.nCol1; nCol<=aParam.nCol2 && bHasAutoFilter; nCol++ )
[ # # ]
1394 : : {
1395 : : nFlag = ((ScMergeFlagAttr*)
1396 [ # # ]: 0 : GetAttr( nCol, nRow, nCurTab, ATTR_MERGE_FLAG ))->
1397 : 0 : GetValue();
1398 : :
1399 [ # # ]: 0 : if ( (nFlag & SC_MF_AUTO) == 0 )
1400 : 0 : bHasAutoFilter = false;
1401 [ # # ]: 0 : }
1402 : : }
1403 : : else
1404 : 0 : bHasAutoFilter = false;
1405 : : }
1406 : :
1407 : 0 : return bHasAutoFilter;
1408 : : }
1409 : :
1410 : 14 : bool ScDocument::HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1411 : : SCTAB nTab )
1412 : : {
1413 [ + - ][ + - ]: 14 : return VALIDTAB(nTab) && maTabs[nTab] && maTabs[nTab]->HasColHeader( nStartCol, nStartRow, nEndCol, nEndRow );
[ + + ]
1414 : : }
1415 : :
1416 : 0 : bool ScDocument::HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1417 : : SCTAB nTab )
1418 : : {
1419 [ # # ][ # # ]: 0 : return VALIDTAB(nTab) && maTabs[nTab] && maTabs[nTab]->HasRowHeader( nStartCol, nStartRow, nEndCol, nEndRow );
[ # # ]
1420 : : }
1421 : :
1422 : : //
1423 : : // GetFilterEntries - Eintraege fuer AutoFilter-Listbox
1424 : : //
1425 : :
1426 : 0 : bool ScDocument::GetFilterEntries(
1427 : : SCCOL nCol, SCROW nRow, SCTAB nTab, bool bFilter, std::vector<ScTypedStrData>& rStrings, bool& rHasDates)
1428 : : {
1429 [ # # ][ # # ]: 0 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] && pDBCollection )
[ # # ][ # # ]
[ # # ]
1430 : : {
1431 : 0 : ScDBData* pDBData = pDBCollection->GetDBAtCursor(nCol, nRow, nTab, false); //!??
1432 [ # # ]: 0 : if (pDBData)
1433 : : {
1434 [ # # ]: 0 : pDBData->ExtendDataArea(this);
1435 : : SCTAB nAreaTab;
1436 : : SCCOL nStartCol;
1437 : : SCROW nStartRow;
1438 : : SCCOL nEndCol;
1439 : : SCROW nEndRow;
1440 [ # # ]: 0 : pDBData->GetArea( nAreaTab, nStartCol, nStartRow, nEndCol, nEndRow );
1441 : :
1442 [ # # ]: 0 : if (pDBData->HasHeader())
1443 : 0 : ++nStartRow;
1444 : :
1445 [ # # ]: 0 : ScQueryParam aParam;
1446 [ # # ]: 0 : pDBData->GetQueryParam( aParam );
1447 : :
1448 : : // return all filter entries, if a filter condition is connected with a boolean OR
1449 [ # # ]: 0 : if ( bFilter )
1450 : : {
1451 [ # # ]: 0 : SCSIZE nEntryCount = aParam.GetEntryCount();
1452 [ # # ][ # # ]: 0 : for ( SCSIZE i = 0; i < nEntryCount && aParam.GetEntry(i).bDoQuery; ++i )
[ # # ][ # # ]
1453 : : {
1454 [ # # ]: 0 : ScQueryEntry& rEntry = aParam.GetEntry(i);
1455 [ # # ]: 0 : if ( rEntry.eConnect != SC_AND )
1456 : : {
1457 : 0 : bFilter = false;
1458 : 0 : break;
1459 : : }
1460 : : }
1461 : : }
1462 : :
1463 [ # # ]: 0 : if ( bFilter )
1464 : : {
1465 [ # # ]: 0 : maTabs[nTab]->GetFilteredFilterEntries( nCol, nStartRow, nEndRow, aParam, rStrings, rHasDates );
1466 : : }
1467 : : else
1468 : : {
1469 [ # # ]: 0 : maTabs[nTab]->GetFilterEntries( nCol, nStartRow, nEndRow, rStrings, rHasDates );
1470 : : }
1471 : :
1472 [ # # ]: 0 : sortAndRemoveDuplicates(rStrings, aParam.bCaseSens);
1473 [ # # ]: 0 : return true;
1474 : : }
1475 : : }
1476 : :
1477 : 0 : return false;
1478 : : }
1479 : :
1480 : : //
1481 : : // GetFilterEntriesArea - Eintraege fuer Filter-Dialog
1482 : : //
1483 : :
1484 : 0 : bool ScDocument::GetFilterEntriesArea(
1485 : : SCCOL nCol, SCROW nStartRow, SCROW nEndRow, SCTAB nTab, bool bCaseSens,
1486 : : std::vector<ScTypedStrData>& rStrings, bool& rHasDates)
1487 : : {
1488 [ # # ][ # # ]: 0 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ # # ][ # # ]
1489 : : {
1490 : 0 : maTabs[nTab]->GetFilterEntries( nCol, nStartRow, nEndRow, rStrings, rHasDates );
1491 : 0 : sortAndRemoveDuplicates(rStrings, bCaseSens);
1492 : 0 : return true;
1493 : : }
1494 : :
1495 : 0 : return false;
1496 : : }
1497 : :
1498 : : //
1499 : : // GetDataEntries - Eintraege fuer Auswahlliste-Listbox (keine Zahlen / Formeln)
1500 : : //
1501 : :
1502 : 0 : bool ScDocument::GetDataEntries(
1503 : : SCCOL nCol, SCROW nRow, SCTAB nTab, bool bCaseSens,
1504 : : std::vector<ScTypedStrData>& rStrings, bool bLimit )
1505 : : {
1506 [ # # ]: 0 : if( !bLimit )
1507 : : {
1508 : : /* Try to generate the list from list validation. This part is skipped,
1509 : : if bLimit==true, because in that case this function is called to get
1510 : : cell values for auto completion on input. */
1511 [ # # ]: 0 : sal_uInt32 nValidation = static_cast< const SfxUInt32Item* >( GetAttr( nCol, nRow, nTab, ATTR_VALIDDATA ) )->GetValue();
1512 [ # # ]: 0 : if( nValidation )
1513 : : {
1514 [ # # ]: 0 : const ScValidationData* pData = GetValidationEntry( nValidation );
1515 [ # # ][ # # ]: 0 : if( pData && pData->FillSelectionList( rStrings, ScAddress( nCol, nRow, nTab ) ) )
[ # # ][ # # ]
[ # # # # ]
1516 : : {
1517 [ # # ]: 0 : if (pData->GetListType() == ValidListType::SORTEDASCENDING)
1518 [ # # ]: 0 : sortAndRemoveDuplicates(rStrings, bCaseSens);
1519 : :
1520 : 0 : return true;
1521 : : }
1522 : : }
1523 : : }
1524 : :
1525 [ # # ][ # # ]: 0 : if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()))
[ # # ]
1526 : 0 : return false;
1527 : :
1528 [ # # ]: 0 : if (!maTabs[nTab])
1529 : 0 : return false;
1530 : :
1531 [ # # ]: 0 : std::set<ScTypedStrData> aStrings;
1532 [ # # ]: 0 : bool bRet = maTabs[nTab]->GetDataEntries(nCol, nRow, aStrings, bLimit);
1533 [ # # ]: 0 : rStrings.insert(rStrings.end(), aStrings.begin(), aStrings.end());
1534 [ # # ]: 0 : sortAndRemoveDuplicates(rStrings, bCaseSens);
1535 : :
1536 : 0 : return bRet;
1537 : : }
1538 : :
1539 : : //
1540 : : // GetFormulaEntries - Eintraege fuer Formel-AutoEingabe
1541 : : //
1542 : :
1543 : 0 : bool ScDocument::GetFormulaEntries( ScTypedCaseStrSet& rStrings )
1544 : : {
1545 : : //
1546 : : // Bereichsnamen
1547 : : //
1548 : :
1549 [ # # ]: 0 : if ( pRangeName )
1550 : : {
1551 [ # # ][ # # ]: 0 : ScRangeName::const_iterator itr = pRangeName->begin(), itrEnd = pRangeName->end();
[ # # ][ # # ]
1552 [ # # ][ # # ]: 0 : for (; itr != itrEnd; ++itr)
[ # # ]
1553 [ # # ][ # # ]: 0 : rStrings.insert(ScTypedStrData(itr->second->GetName(), 0.0, ScTypedStrData::Name));
[ # # ]
1554 : : }
1555 : :
1556 : : //
1557 : : // Datenbank-Bereiche
1558 : : //
1559 : :
1560 [ # # ]: 0 : if ( pDBCollection )
1561 : : {
1562 [ # # ]: 0 : const ScDBCollection::NamedDBs& rDBs = pDBCollection->getNamedDBs();
1563 [ # # ][ # # ]: 0 : ScDBCollection::NamedDBs::const_iterator itr = rDBs.begin(), itrEnd = rDBs.end();
1564 [ # # ][ # # ]: 0 : for (; itr != itrEnd; ++itr)
[ # # ]
1565 [ # # ][ # # ]: 0 : rStrings.insert(ScTypedStrData(itr->GetName(), 0.0, ScTypedStrData::DbName));
[ # # ]
1566 : : }
1567 : :
1568 : : //
1569 : : // Inhalte von Beschriftungsbereichen
1570 : : //
1571 : :
1572 : : ScRangePairList* pLists[2];
1573 : 0 : pLists[0] = GetColNameRanges();
1574 : 0 : pLists[1] = GetRowNameRanges();
1575 [ # # ]: 0 : for (sal_uInt16 nListNo=0; nListNo<2; nListNo++)
1576 : : {
1577 : 0 : ScRangePairList* pList = pLists[ nListNo ];
1578 [ # # ]: 0 : if (pList)
1579 [ # # ][ # # ]: 0 : for ( size_t i = 0, nPairs = pList->size(); i < nPairs; ++i )
1580 : : {
1581 [ # # ]: 0 : ScRangePair* pPair = (*pList)[i];
1582 : 0 : ScRange aRange = pPair->GetRange(0);
1583 [ # # ]: 0 : ScCellIterator aIter( this, aRange );
1584 [ # # ][ # # ]: 0 : for ( ScBaseCell* pCell = aIter.GetFirst(); pCell; pCell = aIter.GetNext() )
[ # # ]
1585 [ # # ][ # # ]: 0 : if ( pCell->HasStringData() )
1586 : : {
1587 [ # # ]: 0 : rtl::OUString aStr = pCell->GetStringData();
1588 [ # # ][ # # ]: 0 : rStrings.insert(ScTypedStrData(aStr, 0.0, ScTypedStrData::Header));
1589 : : }
1590 : : }
1591 : : }
1592 : :
1593 : 0 : return true;
1594 : : }
1595 : :
1596 : :
1597 : 567 : bool ScDocument::IsEmbedded() const
1598 : : {
1599 : 567 : return bIsEmbedded;
1600 : : }
1601 : :
1602 : 0 : void ScDocument::GetEmbedded( ScRange& rRange ) const
1603 : : {
1604 : 0 : rRange = aEmbedRange;
1605 : 0 : }
1606 : :
1607 : 0 : Rectangle ScDocument::GetEmbeddedRect() const // 1/100 mm
1608 : : {
1609 : 0 : Rectangle aRect;
1610 : 0 : ScTable* pTable = NULL;
1611 [ # # ]: 0 : if ( aEmbedRange.aStart.Tab() < static_cast<SCTAB>(maTabs.size()) )
1612 : 0 : pTable = maTabs[aEmbedRange.aStart.Tab()];
1613 : : else
1614 : : OSL_FAIL("table out of range");
1615 [ # # ]: 0 : if (!pTable)
1616 : : {
1617 : : OSL_FAIL("GetEmbeddedRect ohne Tabelle");
1618 : : }
1619 : : else
1620 : : {
1621 : : SCCOL i;
1622 : :
1623 [ # # ]: 0 : for (i=0; i<aEmbedRange.aStart.Col(); i++)
1624 : 0 : aRect.Left() += pTable->GetColWidth(i);
1625 : 0 : aRect.Top() += pTable->GetRowHeight( 0, aEmbedRange.aStart.Row() - 1);
1626 : 0 : aRect.Right() = aRect.Left();
1627 [ # # ]: 0 : for (i=aEmbedRange.aStart.Col(); i<=aEmbedRange.aEnd.Col(); i++)
1628 : 0 : aRect.Right() += pTable->GetColWidth(i);
1629 : 0 : aRect.Bottom() = aRect.Top();
1630 : 0 : aRect.Bottom() += pTable->GetRowHeight( aEmbedRange.aStart.Row(), aEmbedRange.aEnd.Row());
1631 : :
1632 : 0 : aRect.Left() = (long) ( aRect.Left() * HMM_PER_TWIPS );
1633 : 0 : aRect.Right() = (long) ( aRect.Right() * HMM_PER_TWIPS );
1634 : 0 : aRect.Top() = (long) ( aRect.Top() * HMM_PER_TWIPS );
1635 : 0 : aRect.Bottom() = (long) ( aRect.Bottom() * HMM_PER_TWIPS );
1636 : : }
1637 : 0 : return aRect;
1638 : : }
1639 : :
1640 : 0 : void ScDocument::SetEmbedded( const ScRange& rRange )
1641 : : {
1642 : 0 : bIsEmbedded = true;
1643 : 0 : aEmbedRange = rRange;
1644 : 0 : }
1645 : :
1646 : 0 : void ScDocument::ResetEmbedded()
1647 : : {
1648 : 0 : bIsEmbedded = false;
1649 : 0 : aEmbedRange = ScRange();
1650 : 0 : }
1651 : :
1652 : :
1653 : : /** Similar to ScViewData::AddPixelsWhile(), but add height twips and only
1654 : : while result is less than nStopTwips.
1655 : : @return true if advanced at least one row.
1656 : : */
1657 : 72 : bool lcl_AddTwipsWhile( long & rTwips, long nStopTwips, SCROW & rPosY, SCROW nEndRow, const ScTable * pTable )
1658 : : {
1659 : 72 : SCROW nRow = rPosY;
1660 : 72 : bool bAdded = false;
1661 : 72 : bool bStop = false;
1662 [ + - ][ + - ]: 144 : while (rTwips < nStopTwips && nRow <= nEndRow && !bStop)
[ + + ][ + + ]
1663 : : {
1664 : : SCROW nHeightEndRow;
1665 [ + - ]: 72 : sal_uInt16 nHeight = pTable->GetRowHeight( nRow, NULL, &nHeightEndRow);
1666 [ - + ]: 72 : if (nHeightEndRow > nEndRow)
1667 : 0 : nHeightEndRow = nEndRow;
1668 [ - + ]: 72 : if (!nHeight)
1669 : 0 : nRow = nHeightEndRow + 1;
1670 : : else
1671 : : {
1672 : 72 : SCROW nRows = nHeightEndRow - nRow + 1;
1673 : 72 : sal_Int64 nAdd = static_cast<sal_Int64>(nHeight) * nRows;
1674 [ + - ]: 72 : if (nAdd + rTwips >= nStopTwips)
1675 : : {
1676 : 72 : sal_Int64 nDiff = nAdd + rTwips - nStopTwips;
1677 : 72 : nRows -= static_cast<SCROW>(nDiff / nHeight);
1678 : 72 : nAdd = nHeight * nRows;
1679 : : // We're looking for a value that satisfies loop condition.
1680 [ + - ]: 72 : if (nAdd + rTwips >= nStopTwips)
1681 : : {
1682 : 72 : --nRows;
1683 : 72 : nAdd -= nHeight;
1684 : : }
1685 : 72 : bStop = true;
1686 : : }
1687 : 72 : rTwips += static_cast<long>(nAdd);
1688 : 72 : nRow += nRows;
1689 : : }
1690 : : }
1691 [ + + ]: 72 : if (nRow > rPosY)
1692 : : {
1693 : 30 : --nRow;
1694 : 30 : bAdded = true;
1695 : : }
1696 : 72 : rPosY = nRow;
1697 : 72 : return bAdded;
1698 : : }
1699 : :
1700 : 36 : ScRange ScDocument::GetRange( SCTAB nTab, const Rectangle& rMMRect ) const
1701 : : {
1702 : 36 : ScTable* pTable = NULL;
1703 [ + - ]: 36 : if (nTab < static_cast<SCTAB>(maTabs.size()))
1704 : 36 : pTable = maTabs[nTab];
1705 : : else
1706 : : OSL_FAIL("table out of range");
1707 [ - + ]: 36 : if (!pTable)
1708 : : {
1709 : : OSL_FAIL("GetRange ohne Tabelle");
1710 : 0 : return ScRange();
1711 : : }
1712 : :
1713 : 36 : Rectangle aPosRect = rMMRect;
1714 [ + - ][ - + ]: 36 : if ( IsNegativePage( nTab ) )
1715 [ # # ]: 0 : ScDrawLayer::MirrorRectRTL( aPosRect ); // always with positive (LTR) values
1716 : :
1717 : : long nSize;
1718 : : long nTwips;
1719 : : long nAdd;
1720 : : bool bEnd;
1721 : :
1722 : 36 : nSize = 0;
1723 : 36 : nTwips = (long) (aPosRect.Left() / HMM_PER_TWIPS);
1724 : :
1725 : 36 : SCCOL nX1 = 0;
1726 : 36 : bEnd = false;
1727 [ + + ]: 162 : while (!bEnd)
1728 : : {
1729 [ + - ]: 126 : nAdd = (long) pTable->GetColWidth(nX1);
1730 [ + + ][ + - ]: 126 : if (nSize+nAdd <= nTwips+1 && nX1<MAXCOL)
1731 : : {
1732 : 90 : nSize += nAdd;
1733 : 90 : ++nX1;
1734 : : }
1735 : : else
1736 : 36 : bEnd = true;
1737 : : }
1738 : :
1739 : 36 : nTwips = (long) (aPosRect.Right() / HMM_PER_TWIPS);
1740 : :
1741 : 36 : SCCOL nX2 = nX1;
1742 : 36 : bEnd = false;
1743 [ + + ]: 90 : while (!bEnd)
1744 : : {
1745 [ + - ]: 54 : nAdd = (long) pTable->GetColWidth(nX2);
1746 [ + + ][ + - ]: 54 : if (nSize+nAdd < nTwips && nX2<MAXCOL)
1747 : : {
1748 : 18 : nSize += nAdd;
1749 : 18 : ++nX2;
1750 : : }
1751 : : else
1752 : 36 : bEnd = true;
1753 : : }
1754 : :
1755 : :
1756 : 36 : nSize = 0;
1757 : 36 : nTwips = (long) (aPosRect.Top() / HMM_PER_TWIPS);
1758 : :
1759 : 36 : SCROW nY1 = 0;
1760 : : // Was if(nSize+nAdd<=nTwips+1) inside loop => if(nSize+nAdd<nTwips+2)
1761 [ + + ][ + - ]: 36 : if (lcl_AddTwipsWhile( nSize, nTwips+2, nY1, MAXROW, pTable) && nY1 < MAXROW)
[ + + ][ + - ]
1762 : 20 : ++nY1; // original loop ended on last matched +1 unless that was MAXROW
1763 : :
1764 : 36 : nTwips = (long) (aPosRect.Bottom() / HMM_PER_TWIPS);
1765 : :
1766 : 36 : SCROW nY2 = nY1;
1767 : : // Was if(nSize+nAdd<nTwips) inside loop => if(nSize+nAdd<nTwips)
1768 [ + + ][ + - ]: 36 : if (lcl_AddTwipsWhile( nSize, nTwips, nY2, MAXROW, pTable) && nY2 < MAXROW)
[ + + ][ + - ]
1769 : 10 : ++nY2; // original loop ended on last matched +1 unless that was MAXROW
1770 : :
1771 : 36 : return ScRange( nX1,nY1,nTab, nX2,nY2,nTab );
1772 : : }
1773 : :
1774 : 0 : void ScDocument::SetEmbedded( const Rectangle& rRect ) // aus VisArea (1/100 mm)
1775 : : {
1776 : 0 : bIsEmbedded = true;
1777 : 0 : aEmbedRange = GetRange( nVisibleTab, rRect );
1778 : 0 : }
1779 : :
1780 : : // VisArea auf Zellgrenzen anpassen
1781 : :
1782 : 854 : void lcl_SnapHor( ScTable* pTable, long& rVal, SCCOL& rStartCol )
1783 : : {
1784 : 854 : SCCOL nCol = 0;
1785 : 854 : long nTwips = (long) (rVal / HMM_PER_TWIPS);
1786 : 854 : long nSnap = 0;
1787 [ + - ]: 2562 : while ( nCol<MAXCOL )
1788 : : {
1789 : 2562 : long nAdd = pTable->GetColWidth(nCol);
1790 [ - + ][ + + ]: 2562 : if ( nSnap + nAdd/2 < nTwips || nCol < rStartCol )
1791 : : {
1792 : 1708 : nSnap += nAdd;
1793 : 1708 : ++nCol;
1794 : : }
1795 : : else
1796 : 854 : break;
1797 : : }
1798 : 854 : rVal = (long) ( nSnap * HMM_PER_TWIPS );
1799 : 854 : rStartCol = nCol;
1800 : 854 : }
1801 : :
1802 : 854 : void lcl_SnapVer( ScTable* pTable, long& rVal, SCROW& rStartRow )
1803 : : {
1804 : 854 : SCROW nRow = 0;
1805 : 854 : long nTwips = (long) (rVal / HMM_PER_TWIPS);
1806 : 854 : long nSnap = 0;
1807 : :
1808 : 854 : bool bFound = false;
1809 [ + - ]: 6799 : for (SCROW i = nRow; i <= MAXROW; ++i)
1810 : : {
1811 : : SCROW nLastRow;
1812 [ + - ][ + + ]: 6799 : if (pTable->RowHidden(i, NULL, &nLastRow))
1813 : : {
1814 : 15 : i = nLastRow;
1815 : 15 : continue;
1816 : : }
1817 : :
1818 : 6784 : nRow = i;
1819 [ + - ]: 6784 : long nAdd = pTable->GetRowHeight(i);
1820 [ + + ][ - + ]: 6784 : if ( nSnap + nAdd/2 < nTwips || nRow < rStartRow )
1821 : : {
1822 : 5930 : nSnap += nAdd;
1823 : 5930 : ++nRow;
1824 : : }
1825 : : else
1826 : : {
1827 : 854 : bFound = true;
1828 : : break;
1829 : : }
1830 : : }
1831 [ - + ]: 854 : if (!bFound)
1832 : 0 : nRow = MAXROW; // all hidden down to the bottom
1833 : :
1834 : 854 : rVal = (long) ( nSnap * HMM_PER_TWIPS );
1835 : 854 : rStartRow = nRow;
1836 : 854 : }
1837 : :
1838 : 427 : void ScDocument::SnapVisArea( Rectangle& rRect ) const
1839 : : {
1840 : 427 : ScTable* pTable = NULL;
1841 [ + - ]: 427 : if (nVisibleTab < static_cast<SCTAB>(maTabs.size()))
1842 : 427 : pTable = maTabs[nVisibleTab];
1843 : : else
1844 : : OSL_FAIL("table out of range");
1845 [ + - ]: 427 : if (!pTable)
1846 : : {
1847 : : OSL_FAIL("SetEmbedded ohne Tabelle");
1848 : 427 : return;
1849 : : }
1850 : :
1851 [ + - ]: 427 : bool bNegativePage = IsNegativePage( nVisibleTab );
1852 [ - + ]: 427 : if ( bNegativePage )
1853 [ # # ]: 0 : ScDrawLayer::MirrorRectRTL( rRect ); // calculate with positive (LTR) values
1854 : :
1855 : 427 : SCCOL nCol = 0;
1856 [ + - ]: 427 : lcl_SnapHor( pTable, rRect.Left(), nCol );
1857 : 427 : ++nCol; // mindestens eine Spalte
1858 [ + - ]: 427 : lcl_SnapHor( pTable, rRect.Right(), nCol );
1859 : :
1860 : 427 : SCROW nRow = 0;
1861 [ + - ]: 427 : lcl_SnapVer( pTable, rRect.Top(), nRow );
1862 : 427 : ++nRow; // mindestens eine Zeile
1863 [ + - ]: 427 : lcl_SnapVer( pTable, rRect.Bottom(), nRow );
1864 : :
1865 [ - + ]: 427 : if ( bNegativePage )
1866 [ # # ]: 427 : ScDrawLayer::MirrorRectRTL( rRect ); // back to real rectangle
1867 : : }
1868 : :
1869 : 3 : ScDocProtection* ScDocument::GetDocProtection() const
1870 : : {
1871 : 3 : return pDocProtection.get();
1872 : : }
1873 : :
1874 : 5 : void ScDocument::SetDocProtection(const ScDocProtection* pProtect)
1875 : : {
1876 [ + + ]: 5 : if (pProtect)
1877 [ + - ]: 4 : pDocProtection.reset(new ScDocProtection(*pProtect));
1878 : : else
1879 : 1 : pDocProtection.reset(NULL);
1880 : 5 : }
1881 : :
1882 : 33 : bool ScDocument::IsDocProtected() const
1883 : : {
1884 [ + + ][ + - ]: 33 : return pDocProtection.get() && pDocProtection->isProtected();
1885 : : }
1886 : :
1887 : 21 : bool ScDocument::IsDocEditable() const
1888 : : {
1889 : : // import into read-only document is possible
1890 [ + - ][ + - ]: 21 : return !IsDocProtected() && ( bImportingXML || mbChangeReadOnlyEnabled || !pShell || !pShell->IsReadOnly() );
[ + - ][ + - ]
[ + + ]
1891 : : }
1892 : :
1893 : 18326 : bool ScDocument::IsTabProtected( SCTAB nTab ) const
1894 : : {
1895 [ + - ][ + - ]: 18326 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
1896 : 18326 : return maTabs[nTab]->IsProtected();
1897 : :
1898 : : OSL_FAIL("Falsche Tabellennummer");
1899 : 18326 : return false;
1900 : : }
1901 : :
1902 : 12 : ScTableProtection* ScDocument::GetTabProtection( SCTAB nTab ) const
1903 : : {
1904 [ + - ][ + - ]: 12 : if (VALIDTAB(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
[ + - ][ + - ]
1905 : 12 : return maTabs[nTab]->GetProtection();
1906 : :
1907 : 12 : return NULL;
1908 : : }
1909 : :
1910 : 33 : void ScDocument::SetTabProtection(SCTAB nTab, const ScTableProtection* pProtect)
1911 : : {
1912 [ + - ][ - + ]: 33 : if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()))
[ - + ]
1913 : 33 : return;
1914 : :
1915 : 33 : maTabs[nTab]->SetProtection(pProtect);
1916 : : }
1917 : :
1918 : 0 : void ScDocument::CopyTabProtection(SCTAB nTabSrc, SCTAB nTabDest)
1919 : : {
1920 [ # # ][ # # ]: 0 : if (!ValidTab(nTabSrc) || nTabSrc >= static_cast<SCTAB>(maTabs.size()) || nTabDest >= static_cast<SCTAB>(maTabs.size()) || !ValidTab(nTabDest))
[ # # ][ # # ]
[ # # ]
1921 : 0 : return;
1922 : :
1923 : 0 : maTabs[nTabDest]->SetProtection( maTabs[nTabSrc]->GetProtection() );
1924 : : }
1925 : :
1926 : 14483 : const ScDocOptions& ScDocument::GetDocOptions() const
1927 : : {
1928 : : OSL_ENSURE( pDocOptions, "No DocOptions! :-(" );
1929 : 14483 : return *pDocOptions;
1930 : : }
1931 : :
1932 : 1464 : void ScDocument::SetDocOptions( const ScDocOptions& rOpt )
1933 : : {
1934 : : OSL_ENSURE( pDocOptions, "No DocOptions! :-(" );
1935 : :
1936 : 1464 : *pDocOptions = rOpt;
1937 : 1464 : xPoolHelper->SetFormTableOpt(rOpt);
1938 : 1464 : }
1939 : :
1940 : 3266 : const ScViewOptions& ScDocument::GetViewOptions() const
1941 : : {
1942 : : OSL_ENSURE( pViewOptions, "No ViewOptions! :-(" );
1943 : 3266 : return *pViewOptions;
1944 : : }
1945 : :
1946 : 3392 : void ScDocument::SetViewOptions( const ScViewOptions& rOpt )
1947 : : {
1948 : : OSL_ENSURE( pViewOptions, "No ViewOptions! :-(" );
1949 : 3392 : *pViewOptions = rOpt;
1950 : 3392 : }
1951 : :
1952 : 751 : void ScDocument::GetLanguage( LanguageType& rLatin, LanguageType& rCjk, LanguageType& rCtl ) const
1953 : : {
1954 : 751 : rLatin = eLanguage;
1955 : 751 : rCjk = eCjkLanguage;
1956 : 751 : rCtl = eCtlLanguage;
1957 : 751 : }
1958 : :
1959 : 2490 : void ScDocument::SetLanguage( LanguageType eLatin, LanguageType eCjk, LanguageType eCtl )
1960 : : {
1961 : 2490 : eLanguage = eLatin;
1962 : 2490 : eCjkLanguage = eCjk;
1963 : 2490 : eCtlLanguage = eCtl;
1964 [ + + ]: 2490 : if ( xPoolHelper.is() )
1965 : : {
1966 : 1555 : ScDocumentPool* pPool = xPoolHelper->GetDocPool();
1967 [ + - ]: 1555 : pPool->SetPoolDefaultItem( SvxLanguageItem( eLanguage, ATTR_FONT_LANGUAGE ) );
1968 [ + - ]: 1555 : pPool->SetPoolDefaultItem( SvxLanguageItem( eCjkLanguage, ATTR_CJK_FONT_LANGUAGE ) );
1969 [ + - ]: 1555 : pPool->SetPoolDefaultItem( SvxLanguageItem( eCtlLanguage, ATTR_CTL_FONT_LANGUAGE ) );
1970 : : }
1971 : :
1972 : 2490 : UpdateDrawLanguages(); // set edit engine defaults in drawing layer pool
1973 : 2490 : }
1974 : :
1975 : 319 : void ScDocument::SetDrawDefaults()
1976 : : {
1977 : 319 : bSetDrawDefaults = true;
1978 : 319 : UpdateDrawDefaults();
1979 : 319 : }
1980 : :
1981 : 1326 : Rectangle ScDocument::GetMMRect( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, SCTAB nTab ) const
1982 : : {
1983 [ + - ][ + - ]: 1326 : if (!ValidTab(nTab) || nTab >= static_cast<SCTAB>(maTabs.size()) || !maTabs[nTab])
[ - + ][ - + ]
1984 : : {
1985 : : OSL_FAIL("GetMMRect: falsche Tabelle");
1986 [ # # ]: 0 : return Rectangle(0,0,0,0);
1987 : : }
1988 : :
1989 : : SCCOL i;
1990 [ + - ]: 1326 : Rectangle aRect;
1991 : :
1992 [ + + ]: 1708 : for (i=0; i<nStartCol; i++)
1993 [ + - ]: 382 : aRect.Left() += GetColWidth(i,nTab);
1994 [ + - ]: 1326 : aRect.Top() += GetRowHeight( 0, nStartRow-1, nTab);
1995 : :
1996 : 1326 : aRect.Right() = aRect.Left();
1997 : 1326 : aRect.Bottom() = aRect.Top();
1998 : :
1999 [ + + ]: 77280 : for (i=nStartCol; i<=nEndCol; i++)
2000 [ + - ]: 75954 : aRect.Right() += GetColWidth(i,nTab);
2001 [ + - ]: 1326 : aRect.Bottom() += GetRowHeight( nStartRow, nEndRow, nTab);
2002 : :
2003 : 1326 : aRect.Left() = (long)(aRect.Left() * HMM_PER_TWIPS);
2004 : 1326 : aRect.Right() = (long)(aRect.Right() * HMM_PER_TWIPS);
2005 : 1326 : aRect.Top() = (long)(aRect.Top() * HMM_PER_TWIPS);
2006 : 1326 : aRect.Bottom() = (long)(aRect.Bottom() * HMM_PER_TWIPS);
2007 : :
2008 [ - + ][ + - ]: 1326 : if ( IsNegativePage( nTab ) )
2009 [ # # ]: 0 : ScDrawLayer::MirrorRectRTL( aRect );
2010 : :
2011 : 1326 : return aRect;
2012 : : }
2013 : :
2014 : 55 : void ScDocument::SetExtDocOptions( ScExtDocOptions* pNewOptions )
2015 : : {
2016 [ - + ]: 55 : delete pExtDocOptions;
2017 : 55 : pExtDocOptions = pNewOptions;
2018 : 55 : }
2019 : :
2020 : 0 : void ScDocument::DoMergeContents( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
2021 : : SCCOL nEndCol, SCROW nEndRow )
2022 : : {
2023 : 0 : rtl::OUString aEmpty;
2024 : 0 : rtl::OUStringBuffer aTotal;
2025 : 0 : rtl::OUString aCellStr;
2026 : : SCCOL nCol;
2027 : : SCROW nRow;
2028 [ # # ]: 0 : for (nRow=nStartRow; nRow<=nEndRow; nRow++)
2029 [ # # ]: 0 : for (nCol=nStartCol; nCol<=nEndCol; nCol++)
2030 : : {
2031 [ # # ]: 0 : GetString(nCol,nRow,nTab,aCellStr);
2032 [ # # ]: 0 : if (!aCellStr.isEmpty())
2033 : : {
2034 [ # # ]: 0 : if (aTotal.getLength())
2035 [ # # ]: 0 : aTotal.append(' ');
2036 [ # # ]: 0 : aTotal.append(aCellStr);
2037 : : }
2038 [ # # ][ # # ]: 0 : if (nCol != nStartCol || nRow != nStartRow)
2039 [ # # ]: 0 : SetString(nCol,nRow,nTab,aEmpty);
2040 : : }
2041 : :
2042 [ # # ][ # # ]: 0 : SetString(nStartCol,nStartRow,nTab,aTotal.makeStringAndClear());
2043 : 0 : }
2044 : :
2045 : 72 : void ScDocument::DoMerge( SCTAB nTab, SCCOL nStartCol, SCROW nStartRow,
2046 : : SCCOL nEndCol, SCROW nEndRow, bool bDeleteCaptions )
2047 : : {
2048 [ + - ]: 72 : ScMergeAttr aAttr( nEndCol-nStartCol+1, nEndRow-nStartRow+1 );
2049 [ + - ]: 72 : ApplyAttr( nStartCol, nStartRow, nTab, aAttr );
2050 : :
2051 [ + - ]: 72 : if ( nEndCol > nStartCol )
2052 [ + - ]: 72 : ApplyFlagsTab( nStartCol+1, nStartRow, nEndCol, nStartRow, nTab, SC_MF_HOR );
2053 [ + + ]: 72 : if ( nEndRow > nStartRow )
2054 [ + - ]: 30 : ApplyFlagsTab( nStartCol, nStartRow+1, nStartCol, nEndRow, nTab, SC_MF_VER );
2055 [ + - ][ + + ]: 72 : if ( nEndCol > nStartCol && nEndRow > nStartRow )
2056 [ + - ]: 30 : ApplyFlagsTab( nStartCol+1, nStartRow+1, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER );
2057 : :
2058 : : // remove all covered notes (removed captions are collected by drawing undo if active)
2059 [ + + ]: 72 : sal_uInt16 nDelFlag = IDF_NOTE | (bDeleteCaptions ? 0 : IDF_NOCAPTIONS);
2060 [ + - ]: 72 : if( nStartCol < nEndCol )
2061 [ + - ]: 72 : DeleteAreaTab( nStartCol + 1, nStartRow, nEndCol, nStartRow, nTab, nDelFlag );
2062 [ + + ]: 72 : if( nStartRow < nEndRow )
2063 [ + - ][ + - ]: 72 : DeleteAreaTab( nStartCol, nStartRow + 1, nEndCol, nEndRow, nTab, nDelFlag );
2064 : 72 : }
2065 : :
2066 : 0 : void ScDocument::RemoveMerge( SCCOL nCol, SCROW nRow, SCTAB nTab )
2067 : : {
2068 : : const ScMergeAttr* pAttr = (const ScMergeAttr*)
2069 : 0 : GetAttr( nCol, nRow, nTab, ATTR_MERGE );
2070 : :
2071 [ # # ][ # # ]: 0 : if ( pAttr->GetColMerge() <= 1 && pAttr->GetRowMerge() <= 1 )
[ # # ]
2072 : 0 : return;
2073 : :
2074 : 0 : SCCOL nEndCol = nCol + pAttr->GetColMerge() - 1;
2075 : 0 : SCROW nEndRow = nRow + pAttr->GetRowMerge() - 1;
2076 : :
2077 : 0 : RemoveFlagsTab( nCol, nRow, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER );
2078 : :
2079 : : const ScMergeAttr* pDefAttr = (const ScMergeAttr*)
2080 : 0 : &xPoolHelper->GetDocPool()->GetDefaultItem( ATTR_MERGE );
2081 : 0 : ApplyAttr( nCol, nRow, nTab, *pDefAttr );
2082 : : }
2083 : :
2084 : 96 : void ScDocument::ExtendPrintArea( OutputDevice* pDev, SCTAB nTab,
2085 : : SCCOL nStartCol, SCROW nStartRow, SCCOL& rEndCol, SCROW nEndRow ) const
2086 : : {
2087 [ + - ][ + - ]: 96 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
2088 : 96 : maTabs[nTab]->ExtendPrintArea( pDev, nStartCol, nStartRow, rEndCol, nEndRow );
2089 : 96 : }
2090 : :
2091 : 330 : void ScDocument::IncSizeRecalcLevel( SCTAB nTab )
2092 : : {
2093 [ + - ][ + - ]: 330 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
2094 : 330 : maTabs[nTab]->IncRecalcLevel();
2095 : 330 : }
2096 : :
2097 : 330 : void ScDocument::DecSizeRecalcLevel( SCTAB nTab, bool bUpdateNoteCaptionPos )
2098 : : {
2099 [ + - ][ + - ]: 330 : if ( ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab] )
[ + - ][ + - ]
2100 : 330 : maTabs[nTab]->DecRecalcLevel( bUpdateNoteCaptionPos );
2101 [ + - ][ + - ]: 483 : }
2102 : :
2103 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
