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 : :
30 : : #include <unotools/transliterationwrapper.hxx>
31 : :
32 : : #include "dbdata.hxx"
33 : : #include "globalnames.hxx"
34 : : #include "refupdat.hxx"
35 : : #include "rechead.hxx"
36 : : #include "document.hxx"
37 : : #include "queryparam.hxx"
38 : : #include "queryentry.hxx"
39 : : #include "globstr.hrc"
40 : : #include "subtotalparam.hxx"
41 : : #include "sortparam.hxx"
42 : :
43 : : #include <memory>
44 : :
45 : : using ::std::auto_ptr;
46 : : using ::std::unary_function;
47 : : using ::std::for_each;
48 : : using ::std::find_if;
49 : : using ::std::remove_if;
50 : : using ::std::pair;
51 : :
52 : : //---------------------------------------------------------------------------------------
53 : :
54 : 143 : bool ScDBData::less::operator() (const ScDBData& left, const ScDBData& right) const
55 : : {
56 [ + - ][ + - ]: 143 : return ScGlobal::GetpTransliteration()->compareString(left.GetName(), right.GetName()) < 0;
[ + - ][ + - ]
57 : : }
58 : :
59 : 63 : ScDBData::ScDBData( const ::rtl::OUString& rName,
60 : : SCTAB nTab,
61 : : SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
62 : : bool bByR, bool bHasH) :
63 [ + - ]: 63 : mpSortParam(new ScSortParam),
64 [ + - ]: 63 : mpQueryParam(new ScQueryParam),
65 [ + - ]: 63 : mpSubTotal(new ScSubTotalParam),
66 [ + - ]: 63 : mpImportParam(new ScImportParam),
67 : : aName (rName),
68 : : aUpper (rName),
69 : : nTable (nTab),
70 : : nStartCol (nCol1),
71 : : nStartRow (nRow1),
72 : : nEndCol (nCol2),
73 : : nEndRow (nRow2),
74 : : bByRow (bByR),
75 : : bHasHeader (bHasH),
76 : : bDoSize (false),
77 : : bKeepFmt (false),
78 : : bStripData (false),
79 : : bIsAdvanced (false),
80 : : bDBSelection(false),
81 : : nIndex (0),
82 : : bAutoFilter (false),
83 [ + - ][ + - ]: 315 : bModified (false)
[ + - ][ + - ]
84 : : {
85 [ + - ]: 63 : aUpper = ScGlobal::pCharClass->uppercase(aUpper);
86 : 63 : }
87 : :
88 : 600 : ScDBData::ScDBData( const ScDBData& rData ) :
89 : : ScRefreshTimer ( rData ),
90 [ + - ]: 600 : mpSortParam(new ScSortParam(*rData.mpSortParam)),
91 [ + - ]: 600 : mpQueryParam(new ScQueryParam(*rData.mpQueryParam)),
92 [ + - ]: 600 : mpSubTotal(new ScSubTotalParam(*rData.mpSubTotal)),
93 [ + - ]: 600 : mpImportParam(new ScImportParam(*rData.mpImportParam)),
94 : : aName (rData.aName),
95 : : aUpper (rData.aUpper),
96 : : nTable (rData.nTable),
97 : : nStartCol (rData.nStartCol),
98 : : nStartRow (rData.nStartRow),
99 : : nEndCol (rData.nEndCol),
100 : : nEndRow (rData.nEndRow),
101 : : bByRow (rData.bByRow),
102 : : bHasHeader (rData.bHasHeader),
103 : : bDoSize (rData.bDoSize),
104 : : bKeepFmt (rData.bKeepFmt),
105 : : bStripData (rData.bStripData),
106 : : bIsAdvanced (rData.bIsAdvanced),
107 : : aAdvSource (rData.aAdvSource),
108 : : bDBSelection (rData.bDBSelection),
109 : : nIndex (rData.nIndex),
110 : : bAutoFilter (rData.bAutoFilter),
111 [ + - ][ + - ]: 3000 : bModified (rData.bModified)
[ + - ][ + - ]
112 : : {
113 : 600 : }
114 : :
115 : 2 : ScDBData::ScDBData( const ::rtl::OUString& rName, const ScDBData& rData ) :
116 : : ScRefreshTimer ( rData ),
117 [ + - ]: 2 : mpSortParam(new ScSortParam(*rData.mpSortParam)),
118 [ + - ]: 2 : mpQueryParam(new ScQueryParam(*rData.mpQueryParam)),
119 [ + - ]: 2 : mpSubTotal(new ScSubTotalParam(*rData.mpSubTotal)),
120 [ + - ]: 2 : mpImportParam(new ScImportParam(*rData.mpImportParam)),
121 : : aName (rName),
122 : : aUpper (rName),
123 : : nTable (rData.nTable),
124 : : nStartCol (rData.nStartCol),
125 : : nStartRow (rData.nStartRow),
126 : : nEndCol (rData.nEndCol),
127 : : nEndRow (rData.nEndRow),
128 : : bByRow (rData.bByRow),
129 : : bHasHeader (rData.bHasHeader),
130 : : bDoSize (rData.bDoSize),
131 : : bKeepFmt (rData.bKeepFmt),
132 : : bStripData (rData.bStripData),
133 : : bIsAdvanced (rData.bIsAdvanced),
134 : : aAdvSource (rData.aAdvSource),
135 : : bDBSelection (rData.bDBSelection),
136 : : nIndex (rData.nIndex),
137 : : bAutoFilter (rData.bAutoFilter),
138 [ + - ][ + - ]: 10 : bModified (rData.bModified)
[ + - ][ + - ]
139 : : {
140 [ + - ]: 2 : aUpper = ScGlobal::pCharClass->uppercase(aUpper);
141 : 2 : }
142 : :
143 : 48 : ScDBData& ScDBData::operator= (const ScDBData& rData)
144 : : {
145 : : // Don't modify the name. The name is not mutable as it is used as a key
146 : : // in the container to keep the db ranges sorted by the name.
147 : 48 : ScRefreshTimer::operator=( rData );
148 [ + - ]: 48 : mpSortParam.reset(new ScSortParam(*rData.mpSortParam));
149 [ + - ]: 48 : mpQueryParam.reset(new ScQueryParam(*rData.mpQueryParam));
150 [ + - ]: 48 : mpSubTotal.reset(new ScSubTotalParam(*rData.mpSubTotal));
151 [ + - ]: 48 : mpImportParam.reset(new ScImportParam(*rData.mpImportParam));
152 : 48 : nTable = rData.nTable;
153 : 48 : nStartCol = rData.nStartCol;
154 : 48 : nStartRow = rData.nStartRow;
155 : 48 : nEndCol = rData.nEndCol;
156 : 48 : nEndRow = rData.nEndRow;
157 : 48 : bByRow = rData.bByRow;
158 : 48 : bHasHeader = rData.bHasHeader;
159 : 48 : bDoSize = rData.bDoSize;
160 : 48 : bKeepFmt = rData.bKeepFmt;
161 : 48 : bStripData = rData.bStripData;
162 : 48 : bIsAdvanced = rData.bIsAdvanced;
163 : 48 : aAdvSource = rData.aAdvSource;
164 : 48 : bDBSelection = rData.bDBSelection;
165 : 48 : nIndex = rData.nIndex;
166 : 48 : bAutoFilter = rData.bAutoFilter;
167 : :
168 : 48 : return *this;
169 : : }
170 : :
171 : 0 : bool ScDBData::operator== (const ScDBData& rData) const
172 : : {
173 : : // Daten, die nicht in den Params sind
174 : :
175 [ # # ][ # # ]: 0 : if ( nTable != rData.nTable ||
[ # # ][ # # ]
[ # # # # ]
[ # # ]
176 : : bDoSize != rData.bDoSize ||
177 : : bKeepFmt != rData.bKeepFmt ||
178 : : bIsAdvanced!= rData.bIsAdvanced||
179 : : bStripData != rData.bStripData ||
180 : : // SAB: I think this should be here, but I don't want to break something
181 : : // bAutoFilter!= rData.bAutoFilter||
182 : 0 : ScRefreshTimer::operator!=( rData )
183 : : )
184 : 0 : return false;
185 : :
186 [ # # ][ # # ]: 0 : if ( bIsAdvanced && aAdvSource != rData.aAdvSource )
[ # # ]
187 : 0 : return false;
188 : :
189 [ # # ][ # # ]: 0 : ScSortParam aSort1, aSort2;
190 [ # # ]: 0 : GetSortParam(aSort1);
191 [ # # ]: 0 : rData.GetSortParam(aSort2);
192 [ # # ][ # # ]: 0 : if (!(aSort1 == aSort2))
193 : 0 : return false;
194 : :
195 [ # # ][ # # ]: 0 : ScQueryParam aQuery1, aQuery2;
196 [ # # ]: 0 : GetQueryParam(aQuery1);
197 [ # # ]: 0 : rData.GetQueryParam(aQuery2);
198 [ # # ][ # # ]: 0 : if (!(aQuery1 == aQuery2))
199 : 0 : return false;
200 : :
201 [ # # ][ # # ]: 0 : ScSubTotalParam aSubTotal1, aSubTotal2;
202 [ # # ]: 0 : GetSubTotalParam(aSubTotal1);
203 [ # # ]: 0 : rData.GetSubTotalParam(aSubTotal2);
204 [ # # ][ # # ]: 0 : if (!(aSubTotal1 == aSubTotal2))
205 : 0 : return false;
206 : :
207 [ # # ][ # # ]: 0 : ScImportParam aImport1, aImport2;
208 [ # # ]: 0 : GetImportParam(aImport1);
209 [ # # ]: 0 : rData.GetImportParam(aImport2);
210 [ # # ][ # # ]: 0 : if (!(aImport1 == aImport2))
211 : 0 : return false;
212 : :
213 [ # # ][ # # ]: 0 : return true;
[ # # ][ # # ]
[ # # ][ # # ]
214 : : }
215 : :
216 [ + - ][ + - ]: 662 : ScDBData::~ScDBData()
[ + - ][ + - ]
217 : : {
218 [ + - ]: 662 : StopRefreshTimer();
219 [ - + ]: 1276 : }
220 : :
221 : :
222 : 0 : ::rtl::OUString ScDBData::GetSourceString() const
223 : : {
224 : 0 : ::rtl::OUStringBuffer aBuf;
225 [ # # ]: 0 : if (mpImportParam->bImport)
226 : : {
227 [ # # ]: 0 : aBuf.append(mpImportParam->aDBName);
228 [ # # ]: 0 : aBuf.append(sal_Unicode('/'));
229 [ # # ]: 0 : aBuf.append(mpImportParam->aStatement);
230 : : }
231 [ # # ]: 0 : return aBuf.makeStringAndClear();
232 : : }
233 : :
234 : 0 : ::rtl::OUString ScDBData::GetOperations() const
235 : : {
236 : 0 : ::rtl::OUStringBuffer aBuf;
237 [ # # ][ # # ]: 0 : if (mpQueryParam->GetEntryCount())
238 : : {
239 [ # # ]: 0 : const ScQueryEntry& rEntry = mpQueryParam->GetEntry(0);
240 [ # # ]: 0 : if (rEntry.bDoQuery)
241 [ # # ][ # # ]: 0 : aBuf.append(ScGlobal::GetRscString(STR_OPERATION_FILTER));
[ # # ]
242 : : }
243 : :
244 [ # # ]: 0 : if (mpSortParam->maKeyState[0].bDoSort)
245 : : {
246 [ # # ]: 0 : if (aBuf.getLength())
247 [ # # ]: 0 : aBuf.appendAscii(RTL_CONSTASCII_STRINGPARAM(", "));
248 [ # # ][ # # ]: 0 : aBuf.append(ScGlobal::GetRscString(STR_OPERATION_SORT));
[ # # ]
249 : : }
250 : :
251 [ # # ][ # # ]: 0 : if (mpSubTotal->bGroupActive[0] && !mpSubTotal->bRemoveOnly)
[ # # ]
252 : : {
253 [ # # ]: 0 : if (aBuf.getLength())
254 [ # # ]: 0 : aBuf.appendAscii(RTL_CONSTASCII_STRINGPARAM(", "));
255 [ # # ][ # # ]: 0 : aBuf.append(ScGlobal::GetRscString(STR_OPERATION_SUBTOTAL));
[ # # ]
256 : : }
257 : :
258 [ # # ]: 0 : if (!aBuf.getLength())
259 [ # # ][ # # ]: 0 : aBuf.append(ScGlobal::GetRscString(STR_OPERATION_NONE));
[ # # ]
260 : :
261 [ # # ]: 0 : return aBuf.makeStringAndClear();
262 : : }
263 : :
264 : 499 : void ScDBData::GetArea(SCTAB& rTab, SCCOL& rCol1, SCROW& rRow1, SCCOL& rCol2, SCROW& rRow2) const
265 : : {
266 : 499 : rTab = nTable;
267 : 499 : rCol1 = nStartCol;
268 : 499 : rRow1 = nStartRow;
269 : 499 : rCol2 = nEndCol;
270 : 499 : rRow2 = nEndRow;
271 : 499 : }
272 : :
273 : 195 : void ScDBData::GetArea(ScRange& rRange) const
274 : : {
275 : 195 : SCROW nNewEndRow = nEndRow;
276 : 195 : rRange = ScRange( nStartCol, nStartRow, nTable, nEndCol, nNewEndRow, nTable );
277 : 195 : }
278 : :
279 : 467 : void ScDBData::SetArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
280 : : {
281 : 467 : nTable = nTab;
282 : 467 : nStartCol = nCol1;
283 : 467 : nStartRow = nRow1;
284 : 467 : nEndCol = nCol2;
285 : 467 : nEndRow = nRow2;
286 : 467 : }
287 : :
288 : 449 : void ScDBData::MoveTo(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
289 : : {
290 : : sal_uInt16 i;
291 : 449 : long nDifX = ((long) nCol1) - ((long) nStartCol);
292 : 449 : long nDifY = ((long) nRow1) - ((long) nStartRow);
293 : :
294 [ + - ]: 449 : long nSortDif = bByRow ? nDifX : nDifY;
295 [ + - ]: 449 : long nSortEnd = bByRow ? static_cast<long>(nCol2) : static_cast<long>(nRow2);
296 : :
297 [ + + ]: 1790 : for (i=0; i<mpSortParam->GetSortKeyCount(); i++)
298 : : {
299 : 1341 : mpSortParam->maKeyState[i].nField += nSortDif;
300 [ - + ]: 1341 : if (mpSortParam->maKeyState[i].nField > nSortEnd)
301 : : {
302 : 0 : mpSortParam->maKeyState[i].nField = 0;
303 : 0 : mpSortParam->maKeyState[i].bDoSort = false;
304 : : }
305 : : }
306 : :
307 : 449 : SCSIZE nCount = mpQueryParam->GetEntryCount();
308 [ + + ]: 4041 : for (i = 0; i < nCount; ++i)
309 : : {
310 : 3592 : ScQueryEntry& rEntry = mpQueryParam->GetEntry(i);
311 : 3592 : rEntry.nField += nDifX;
312 [ - + ]: 3592 : if (rEntry.nField > nCol2)
313 : : {
314 : 0 : rEntry.nField = 0;
315 : 0 : rEntry.bDoQuery = false;
316 : : }
317 : : }
318 [ + + ]: 1796 : for (i=0; i<MAXSUBTOTAL; i++)
319 : : {
320 : 1347 : mpSubTotal->nField[i] = sal::static_int_cast<SCCOL>( mpSubTotal->nField[i] + nDifX );
321 [ - + ]: 1347 : if (mpSubTotal->nField[i] > nCol2)
322 : : {
323 : 0 : mpSubTotal->nField[i] = 0;
324 : 0 : mpSubTotal->bGroupActive[i] = false;
325 : : }
326 : : }
327 : :
328 : 449 : SetArea( nTab, nCol1, nRow1, nCol2, nRow2 );
329 : 449 : }
330 : :
331 : 14 : void ScDBData::GetSortParam( ScSortParam& rSortParam ) const
332 : : {
333 : 14 : rSortParam = *mpSortParam;
334 : 14 : rSortParam.nCol1 = nStartCol;
335 : 14 : rSortParam.nRow1 = nStartRow;
336 : 14 : rSortParam.nCol2 = nEndCol;
337 : 14 : rSortParam.nRow2 = nEndRow;
338 : 14 : rSortParam.bByRow = bByRow;
339 : 14 : rSortParam.bHasHeader = bHasHeader;
340 : 14 : }
341 : :
342 : 14 : void ScDBData::SetSortParam( const ScSortParam& rSortParam )
343 : : {
344 [ + - ]: 14 : mpSortParam.reset(new ScSortParam(rSortParam));
345 : 14 : bByRow = rSortParam.bByRow;
346 : 14 : }
347 : :
348 : 43 : void ScDBData::GetQueryParam( ScQueryParam& rQueryParam ) const
349 : : {
350 : 43 : rQueryParam = *mpQueryParam;
351 : 43 : rQueryParam.nCol1 = nStartCol;
352 : 43 : rQueryParam.nRow1 = nStartRow;
353 : 43 : rQueryParam.nCol2 = nEndCol;
354 : 43 : rQueryParam.nRow2 = nEndRow;
355 : 43 : rQueryParam.nTab = nTable;
356 : 43 : rQueryParam.bByRow = bByRow;
357 : 43 : rQueryParam.bHasHeader = bHasHeader;
358 : 43 : }
359 : :
360 : 76 : void ScDBData::SetQueryParam(const ScQueryParam& rQueryParam)
361 : : {
362 [ + - ]: 76 : mpQueryParam.reset(new ScQueryParam(rQueryParam));
363 : :
364 : : // set bIsAdvanced to false for everything that is not from the
365 : : // advanced filter dialog
366 : 76 : bIsAdvanced = false;
367 : 76 : }
368 : :
369 : 25 : void ScDBData::SetAdvancedQuerySource(const ScRange* pSource)
370 : : {
371 [ + + ]: 25 : if (pSource)
372 : : {
373 : 2 : aAdvSource = *pSource;
374 : 2 : bIsAdvanced = true;
375 : : }
376 : : else
377 : 23 : bIsAdvanced = false;
378 : 25 : }
379 : :
380 : 40 : bool ScDBData::GetAdvancedQuerySource(ScRange& rSource) const
381 : : {
382 : 40 : rSource = aAdvSource;
383 : 40 : return bIsAdvanced;
384 : : }
385 : :
386 : 6 : void ScDBData::GetSubTotalParam(ScSubTotalParam& rSubTotalParam) const
387 : : {
388 : 6 : rSubTotalParam = *mpSubTotal;
389 : :
390 : : // Share the data range with the parent db data. The range in the subtotal
391 : : // param struct is not used.
392 : 6 : rSubTotalParam.nCol1 = nStartCol;
393 : 6 : rSubTotalParam.nRow1 = nStartRow;
394 : 6 : rSubTotalParam.nCol2 = nEndCol;
395 : 6 : rSubTotalParam.nRow2 = nEndRow;
396 : 6 : }
397 : :
398 : 8 : void ScDBData::SetSubTotalParam(const ScSubTotalParam& rSubTotalParam)
399 : : {
400 [ + - ]: 8 : mpSubTotal.reset(new ScSubTotalParam(rSubTotalParam));
401 : 8 : }
402 : :
403 : 4 : void ScDBData::GetImportParam(ScImportParam& rImportParam) const
404 : : {
405 : 4 : rImportParam = *mpImportParam;
406 : : // set the range.
407 : 4 : rImportParam.nCol1 = nStartCol;
408 : 4 : rImportParam.nRow1 = nStartRow;
409 : 4 : rImportParam.nCol2 = nEndCol;
410 : 4 : rImportParam.nRow2 = nEndRow;
411 : 4 : }
412 : :
413 : 32 : void ScDBData::SetImportParam(const ScImportParam& rImportParam)
414 : : {
415 : : // the range is ignored.
416 [ + - ]: 32 : mpImportParam.reset(new ScImportParam(rImportParam));
417 : 32 : }
418 : :
419 : 2 : bool ScDBData::IsDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, bool bStartOnly) const
420 : : {
421 [ + - ]: 2 : if (nTab == nTable)
422 : : {
423 [ - + ]: 2 : if ( bStartOnly )
424 [ # # ][ # # ]: 0 : return ( nCol == nStartCol && nRow == nStartRow );
425 : : else
426 : : return ( nCol >= nStartCol && nCol <= nEndCol &&
427 [ + - ][ + - ]: 2 : nRow >= nStartRow && nRow <= nEndRow );
[ + - ][ + - ]
428 : : }
429 : :
430 : 2 : return false;
431 : : }
432 : :
433 : 52 : bool ScDBData::IsDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
434 : : {
435 : : return (bool)((nTab == nTable)
436 : : && (nCol1 == nStartCol) && (nRow1 == nStartRow)
437 [ + - ][ + + ]: 52 : && (nCol2 == nEndCol) && (nRow2 == nEndRow));
[ + + ][ + + ]
[ + + ]
438 : : }
439 : :
440 : 54 : bool ScDBData::HasImportParam() const
441 : : {
442 [ + - ][ - + ]: 54 : return mpImportParam && mpImportParam->bImport;
443 : : }
444 : :
445 : 0 : bool ScDBData::HasQueryParam() const
446 : : {
447 [ # # ]: 0 : if (!mpQueryParam)
448 : 0 : return false;
449 : :
450 [ # # ]: 0 : if (!mpQueryParam->GetEntryCount())
451 : 0 : return false;
452 : :
453 : 0 : return mpQueryParam->GetEntry(0).bDoQuery;
454 : : }
455 : :
456 : 0 : bool ScDBData::HasSortParam() const
457 : : {
458 [ # # ][ # # ]: 0 : return mpSortParam && mpSortParam->maKeyState[0].bDoSort;
459 : : }
460 : :
461 : 0 : bool ScDBData::HasSubTotalParam() const
462 : : {
463 [ # # ][ # # ]: 0 : return mpSubTotal && mpSubTotal->bGroupActive[0];
464 : : }
465 : :
466 : 0 : void ScDBData::UpdateMoveTab(SCTAB nOldPos, SCTAB nNewPos)
467 : : {
468 : 0 : ScRange aRange;
469 [ # # ]: 0 : GetArea( aRange );
470 : 0 : SCTAB nTab = aRange.aStart.Tab(); // hat nur eine Tabelle
471 : :
472 : : // anpassen wie die aktuelle Tabelle bei ScTablesHint (tabvwsh5.cxx)
473 : :
474 [ # # ]: 0 : if ( nTab == nOldPos ) // verschobene Tabelle
475 : 0 : nTab = nNewPos;
476 [ # # ]: 0 : else if ( nOldPos < nNewPos ) // nach hinten verschoben
477 : : {
478 [ # # ][ # # ]: 0 : if ( nTab > nOldPos && nTab <= nNewPos ) // nachrueckender Bereich
479 : 0 : --nTab;
480 : : }
481 : : else // nach vorne verschoben
482 : : {
483 [ # # ][ # # ]: 0 : if ( nTab >= nNewPos && nTab < nOldPos ) // nachrueckender Bereich
484 : 0 : ++nTab;
485 : : }
486 : :
487 : 0 : bool bChanged = ( nTab != aRange.aStart.Tab() );
488 [ # # ]: 0 : if (bChanged)
489 : 0 : SetArea( nTab, aRange.aStart.Col(), aRange.aStart.Row(),
490 : 0 : aRange.aEnd.Col(),aRange.aEnd .Row() );
491 : :
492 : : // MoveTo ist nicht noetig, wenn nur die Tabelle geaendert ist
493 : :
494 : 0 : SetModified(bChanged);
495 : :
496 : 0 : }
497 : :
498 : 8 : void ScDBData::UpdateReference(ScDocument* pDoc, UpdateRefMode eUpdateRefMode,
499 : : SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
500 : : SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
501 : : SCsCOL nDx, SCsROW nDy, SCsTAB nDz)
502 : : {
503 : : SCCOL theCol1;
504 : : SCROW theRow1;
505 : : SCTAB theTab1;
506 : : SCCOL theCol2;
507 : : SCROW theRow2;
508 : : SCTAB theTab2;
509 : 8 : GetArea( theTab1, theCol1, theRow1, theCol2, theRow2 );
510 : 8 : theTab2 = theTab1;
511 : :
512 : : bool bDoUpdate = ScRefUpdate::Update( pDoc, eUpdateRefMode,
513 : : nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz,
514 [ + - ]: 8 : theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) != UR_NOTHING;
515 [ + + ]: 8 : if (bDoUpdate)
516 [ + - ]: 6 : MoveTo( theTab1, theCol1, theRow1, theCol2, theRow2 );
517 : :
518 : 8 : ScRange aRangeAdvSource;
519 [ - + ][ + - ]: 8 : if ( GetAdvancedQuerySource(aRangeAdvSource) )
520 : : {
521 : 0 : aRangeAdvSource.GetVars( theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 );
522 [ # # ]: 0 : if ( ScRefUpdate::Update( pDoc, eUpdateRefMode,
523 : : nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz,
524 [ # # ]: 0 : theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) )
525 : : {
526 : 0 : aRangeAdvSource.aStart.Set( theCol1,theRow1,theTab1 );
527 : 0 : aRangeAdvSource.aEnd.Set( theCol2,theRow2,theTab2 );
528 [ # # ]: 0 : SetAdvancedQuerySource( &aRangeAdvSource );
529 : :
530 : 0 : bDoUpdate = true; // DBData is modified
531 : : }
532 : : }
533 : :
534 : 8 : SetModified(bDoUpdate);
535 : :
536 : : //! Testen, ob mitten aus dem Bereich geloescht/eingefuegt wurde !!!
537 : 8 : }
538 : :
539 : 0 : void ScDBData::ExtendDataArea(ScDocument* pDoc)
540 : : {
541 : : // Extend the DB area to include data rows immediately below.
542 : : // or shrink it if all cells are empty
543 : 0 : pDoc->GetDataArea(nTable, nStartCol, nStartRow, nEndCol, nEndRow, false, true);
544 : 0 : }
545 : :
546 : : namespace {
547 : :
548 : : class FindByTable : public unary_function<ScDBData, bool>
549 : : {
550 : : SCTAB mnTab;
551 : : public:
552 : 115 : FindByTable(SCTAB nTab) : mnTab(nTab) {}
553 : :
554 : 0 : bool operator() (const ScDBData& r) const
555 : : {
556 : 0 : ScRange aRange;
557 [ # # ]: 0 : r.GetArea(aRange);
558 : 0 : return aRange.aStart.Tab() == mnTab;
559 : : }
560 : : };
561 : :
562 : : class UpdateRefFunc : public unary_function<ScDBData, void>
563 : : {
564 : : ScDocument* mpDoc;
565 : : UpdateRefMode meMode;
566 : : SCCOL mnCol1;
567 : : SCROW mnRow1;
568 : : SCTAB mnTab1;
569 : : SCCOL mnCol2;
570 : : SCROW mnRow2;
571 : : SCTAB mnTab2;
572 : : SCsCOL mnDx;
573 : : SCsROW mnDy;
574 : : SCsTAB mnDz;
575 : :
576 : : public:
577 : 221 : UpdateRefFunc(ScDocument* pDoc, UpdateRefMode eMode,
578 : : SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
579 : : SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
580 : : SCsCOL nDx, SCsROW nDy, SCsTAB nDz) :
581 : : mpDoc(pDoc), meMode(eMode),
582 : : mnCol1(nCol1), mnRow1(nRow1), mnTab1(nTab1),
583 : : mnCol2(nCol2), mnRow2(nRow2), mnTab2(nTab2),
584 : 221 : mnDx(nDx), mnDy(nDy), mnDz(nDz) {}
585 : :
586 : 0 : void operator() (ScDBData& r)
587 : : {
588 : 0 : r.UpdateReference(mpDoc, meMode, mnCol1, mnRow1, mnTab1, mnCol2, mnRow2, mnTab2, mnDx, mnDy, mnDz);
589 : 0 : }
590 : : };
591 : :
592 : : class UpdateMoveTabFunc : public unary_function<ScDBData, void>
593 : : {
594 : : SCTAB mnOldTab;
595 : : SCTAB mnNewTab;
596 : : public:
597 : 15 : UpdateMoveTabFunc(SCTAB nOld, SCTAB nNew) : mnOldTab(nOld), mnNewTab(nNew) {}
598 : 0 : void operator() (ScDBData& r)
599 : : {
600 : 0 : r.UpdateMoveTab(mnOldTab, mnNewTab);
601 : 0 : }
602 : : };
603 : :
604 : : class FindByCursor : public unary_function<ScDBData, bool>
605 : : {
606 : : SCCOL mnCol;
607 : : SCROW mnRow;
608 : : SCTAB mnTab;
609 : : bool mbStartOnly;
610 : : public:
611 : 4 : FindByCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, bool bStartOnly) :
612 : 4 : mnCol(nCol), mnRow(nRow), mnTab(nTab), mbStartOnly(bStartOnly) {}
613 : :
614 : 2 : bool operator() (const ScDBData& r)
615 : : {
616 : 2 : return r.IsDBAtCursor(mnCol, mnRow, mnTab, mbStartOnly);
617 : : }
618 : : };
619 : :
620 : : class FindByRange : public unary_function<ScDBData, bool>
621 : : {
622 : : const ScRange& mrRange;
623 : : public:
624 : 82 : FindByRange(const ScRange& rRange) : mrRange(rRange) {}
625 : :
626 : 10 : bool operator() (const ScDBData& r)
627 : : {
628 : : return r.IsDBAtArea(
629 : 10 : mrRange.aStart.Tab(), mrRange.aStart.Col(), mrRange.aStart.Row(), mrRange.aEnd.Col(), mrRange.aEnd.Row());
630 : : }
631 : : };
632 : :
633 : : class FindByIndex : public unary_function<ScDBData, bool>
634 : : {
635 : : sal_uInt16 mnIndex;
636 : : public:
637 : 6 : FindByIndex(sal_uInt16 nIndex) : mnIndex(nIndex) {}
638 : 6 : bool operator() (const ScDBData& r) const
639 : : {
640 : 6 : return r.GetIndex() == mnIndex;
641 : : }
642 : : };
643 : :
644 : : class FindByName : public unary_function<ScDBData, bool>
645 : : {
646 : : const ::rtl::OUString& mrName;
647 : : public:
648 : 185 : FindByName(const ::rtl::OUString& rName) : mrName(rName) {}
649 : 251 : bool operator() (const ScDBData& r) const
650 : : {
651 : 251 : return r.GetName() == mrName;
652 : : }
653 : : };
654 : :
655 : : class FindByUpperName : public unary_function<ScDBData, bool>
656 : : {
657 : : const ::rtl::OUString& mrName;
658 : : public:
659 : 33 : FindByUpperName(const ::rtl::OUString& rName) : mrName(rName) {}
660 : 6 : bool operator() (const ScDBData& r) const
661 : : {
662 : 6 : return r.GetUpperName() == mrName;
663 : : }
664 : : };
665 : :
666 : : }
667 : :
668 : 1781 : ScDBCollection::NamedDBs::NamedDBs(ScDBCollection& rParent, ScDocument& rDoc) :
669 : 1781 : mrParent(rParent), mrDoc(rDoc) {}
670 : :
671 : 99 : ScDBCollection::NamedDBs::NamedDBs(const NamedDBs& r) :
672 : 99 : maDBs(r.maDBs), mrParent(r.mrParent), mrDoc(r.mrDoc) {}
673 : :
674 : 503 : ScDBCollection::NamedDBs::iterator ScDBCollection::NamedDBs::begin()
675 : : {
676 : 503 : return maDBs.begin();
677 : : }
678 : :
679 : 566 : ScDBCollection::NamedDBs::iterator ScDBCollection::NamedDBs::end()
680 : : {
681 : 566 : return maDBs.end();
682 : : }
683 : :
684 : 232 : ScDBCollection::NamedDBs::const_iterator ScDBCollection::NamedDBs::begin() const
685 : : {
686 : 232 : return maDBs.begin();
687 : : }
688 : :
689 : 231 : ScDBCollection::NamedDBs::const_iterator ScDBCollection::NamedDBs::end() const
690 : : {
691 : 231 : return maDBs.end();
692 : : }
693 : :
694 : 6 : ScDBData* ScDBCollection::NamedDBs::findByIndex(sal_uInt16 nIndex)
695 : : {
696 : : DBsType::iterator itr = find_if(
697 [ + - ][ + - ]: 6 : maDBs.begin(), maDBs.end(), FindByIndex(nIndex));
[ + - ]
698 [ + - ][ + - ]: 6 : return itr == maDBs.end() ? NULL : &(*itr);
[ - + ][ + - ]
699 : : }
700 : :
701 : 185 : ScDBData* ScDBCollection::NamedDBs::findByName(const ::rtl::OUString& rName)
702 : : {
703 : : DBsType::iterator itr = find_if(
704 [ + - ][ + - ]: 185 : maDBs.begin(), maDBs.end(), FindByName(rName));
[ + - ]
705 [ + - ][ + - ]: 185 : return itr == maDBs.end() ? NULL : &(*itr);
[ + + ][ + - ]
706 : : }
707 : :
708 : 33 : ScDBData* ScDBCollection::NamedDBs::findByUpperName(const ::rtl::OUString& rName)
709 : : {
710 : : DBsType::iterator itr = find_if(
711 [ + - ][ + - ]: 33 : maDBs.begin(), maDBs.end(), FindByUpperName(rName));
[ + - ]
712 [ + - ][ + - ]: 33 : return itr == maDBs.end() ? NULL : &(*itr);
[ + + ][ + - ]
713 : : }
714 : :
715 : 28 : bool ScDBCollection::NamedDBs::insert(ScDBData* p)
716 : : {
717 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
718 : 28 : auto_ptr<ScDBData> pData(p);
719 : : SAL_WNODEPRECATED_DECLARATIONS_POP
720 [ + + ]: 28 : if (!pData->GetIndex())
721 : 26 : pData->SetIndex(mrParent.nEntryIndex++);
722 : :
723 [ + - ][ + - ]: 28 : pair<DBsType::iterator, bool> r = maDBs.insert(pData);
724 : :
725 [ + - ][ + - ]: 28 : if (r.second && p->HasImportParam() && !p->HasImportSelection())
[ - + ][ # # ]
[ - + ]
726 : : {
727 : 0 : p->SetRefreshHandler(mrParent.GetRefreshHandler());
728 : 0 : p->SetRefreshControl(mrDoc.GetRefreshTimerControlAddress());
729 : : }
730 [ + - ]: 28 : return r.second;
731 : : }
732 : :
733 : 0 : void ScDBCollection::NamedDBs::erase(iterator itr)
734 : : {
735 : 0 : maDBs.erase(itr);
736 : 0 : }
737 : :
738 : 2 : void ScDBCollection::NamedDBs::erase(const ScDBData& r)
739 : : {
740 : 2 : maDBs.erase(r);
741 : 2 : }
742 : :
743 : 22 : bool ScDBCollection::NamedDBs::empty() const
744 : : {
745 : 22 : return maDBs.empty();
746 : : }
747 : :
748 : 8 : size_t ScDBCollection::NamedDBs::size() const
749 : : {
750 : 8 : return maDBs.size();
751 : : }
752 : :
753 : 36 : bool ScDBCollection::NamedDBs::operator== (const NamedDBs& r) const
754 : : {
755 : 36 : return maDBs == r.maDBs;
756 : : }
757 : :
758 : 351 : ScDBCollection::AnonDBs::iterator ScDBCollection::AnonDBs::begin()
759 : : {
760 : 351 : return maDBs.begin();
761 : : }
762 : :
763 : 351 : ScDBCollection::AnonDBs::iterator ScDBCollection::AnonDBs::end()
764 : : {
765 : 351 : return maDBs.end();
766 : : }
767 : :
768 : 0 : ScDBCollection::AnonDBs::const_iterator ScDBCollection::AnonDBs::begin() const
769 : : {
770 : 0 : return maDBs.begin();
771 : : }
772 : :
773 : 0 : ScDBCollection::AnonDBs::const_iterator ScDBCollection::AnonDBs::end() const
774 : : {
775 : 0 : return maDBs.end();
776 : : }
777 : :
778 : 1 : const ScDBData* ScDBCollection::AnonDBs::findAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, bool bStartOnly) const
779 : : {
780 : : DBsType::const_iterator itr = find_if(
781 [ + - ][ + - ]: 1 : maDBs.begin(), maDBs.end(), FindByCursor(nCol, nRow, nTab, bStartOnly));
[ + - ]
782 [ + - ][ + - ]: 1 : return itr == maDBs.end() ? NULL : &(*itr);
[ + - ][ # # ]
783 : : }
784 : :
785 : 22 : const ScDBData* ScDBCollection::AnonDBs::findByRange(const ScRange& rRange) const
786 : : {
787 : : DBsType::const_iterator itr = find_if(
788 [ + - ][ + - ]: 22 : maDBs.begin(), maDBs.end(), FindByRange(rRange));
[ + - ]
789 [ + - ][ + - ]: 22 : return itr == maDBs.end() ? NULL : &(*itr);
[ + - ][ # # ]
790 : : }
791 : :
792 : 0 : ScDBData* ScDBCollection::AnonDBs::getByRange(const ScRange& rRange)
793 : : {
794 : 0 : const ScDBData* pData = findByRange(rRange);
795 [ # # ]: 0 : if (!pData)
796 : : {
797 : : // Insert a new db data. They all have identical names.
798 [ # # ]: 0 : rtl::OUString aName(RTL_CONSTASCII_USTRINGPARAM(STR_DB_GLOBAL_NONAME));
799 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
800 : : ::std::auto_ptr<ScDBData> pNew(new ScDBData(
801 : 0 : aName, rRange.aStart.Tab(), rRange.aStart.Col(), rRange.aStart.Row(),
802 [ # # ][ # # ]: 0 : rRange.aEnd.Col(), rRange.aEnd.Row(), true, false));
803 : : SAL_WNODEPRECATED_DECLARATIONS_POP
804 : 0 : pData = pNew.get();
805 [ # # ][ # # ]: 0 : maDBs.push_back(pNew);
[ # # ]
806 : : }
807 : 0 : return const_cast<ScDBData*>(pData);
808 : : }
809 : :
810 : 0 : void ScDBCollection::AnonDBs::insert(ScDBData* p)
811 : : {
812 [ # # ]: 0 : rtl::OUString aName(RTL_CONSTASCII_USTRINGPARAM(STR_DB_GLOBAL_NONAME));
813 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
814 : 0 : ::std::auto_ptr<ScDBData> pNew(p);
815 : : SAL_WNODEPRECATED_DECLARATIONS_POP
816 [ # # ][ # # ]: 0 : maDBs.push_back(pNew);
[ # # ]
817 : 0 : }
818 : :
819 : 18 : bool ScDBCollection::AnonDBs::empty() const
820 : : {
821 : 18 : return maDBs.empty();
822 : : }
823 : :
824 : 36 : bool ScDBCollection::AnonDBs::operator== (const AnonDBs& r) const
825 : : {
826 : 36 : return maDBs == r.maDBs;
827 : : }
828 : :
829 : 1781 : ScDBCollection::ScDBCollection(ScDocument* pDocument) :
830 [ + - ]: 1781 : pDoc(pDocument), nEntryIndex(SC_START_INDEX_DB_COLL), maNamedDBs(*this, *pDocument) {}
831 : :
832 : 99 : ScDBCollection::ScDBCollection(const ScDBCollection& r) :
833 [ + - ]: 99 : pDoc(r.pDoc), nEntryIndex(r.nEntryIndex), maNamedDBs(r.maNamedDBs), maAnonDBs(r.maAnonDBs) {}
834 : :
835 : 554 : ScDBCollection::NamedDBs& ScDBCollection::getNamedDBs()
836 : : {
837 : 554 : return maNamedDBs;
838 : : }
839 : :
840 : 0 : const ScDBCollection::NamedDBs& ScDBCollection::getNamedDBs() const
841 : : {
842 : 0 : return maNamedDBs;
843 : : }
844 : :
845 : 27 : ScDBCollection::AnonDBs& ScDBCollection::getAnonDBs()
846 : : {
847 : 27 : return maAnonDBs;
848 : : }
849 : :
850 : 0 : const ScDBCollection::AnonDBs& ScDBCollection::getAnonDBs() const
851 : : {
852 : 0 : return maAnonDBs;
853 : : }
854 : :
855 : 0 : const ScDBData* ScDBCollection::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bStartOnly) const
856 : : {
857 : : // First, search the global named db ranges.
858 : : NamedDBs::DBsType::const_iterator itr = find_if(
859 [ # # ][ # # ]: 0 : maNamedDBs.begin(), maNamedDBs.end(), FindByCursor(nCol, nRow, nTab, bStartOnly));
[ # # ]
860 [ # # ][ # # ]: 0 : if (itr != maNamedDBs.end())
[ # # ]
861 [ # # ]: 0 : return &(*itr);
862 : :
863 : : // Check for the sheet-local anonymous db range.
864 [ # # ]: 0 : const ScDBData* pNoNameData = pDoc->GetAnonymousDBData(nTab);
865 [ # # ]: 0 : if (pNoNameData)
866 [ # # ]: 0 : if (pNoNameData->IsDBAtCursor(nCol,nRow,nTab,bStartOnly))
867 : 0 : return pNoNameData;
868 : :
869 : : // Check the global anonymous db ranges.
870 [ # # ][ # # ]: 0 : const ScDBData* pData = getAnonDBs().findAtCursor(nCol, nRow, nTab, bStartOnly);
871 [ # # ]: 0 : if (pData)
872 : 0 : return pData;
873 : :
874 : 0 : return NULL;
875 : : }
876 : :
877 : 3 : ScDBData* ScDBCollection::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bStartOnly)
878 : : {
879 : : // First, search the global named db ranges.
880 : : NamedDBs::DBsType::iterator itr = find_if(
881 [ + - ][ + - ]: 3 : maNamedDBs.begin(), maNamedDBs.end(), FindByCursor(nCol, nRow, nTab, bStartOnly));
[ + - ]
882 [ + - ][ + - ]: 3 : if (itr != maNamedDBs.end())
[ + + ]
883 [ + - ]: 2 : return &(*itr);
884 : :
885 : : // Check for the sheet-local anonymous db range.
886 [ + - ]: 1 : ScDBData* pNoNameData = pDoc->GetAnonymousDBData(nTab);
887 [ - + ]: 1 : if (pNoNameData)
888 [ # # ]: 0 : if (pNoNameData->IsDBAtCursor(nCol,nRow,nTab,bStartOnly))
889 : 0 : return pNoNameData;
890 : :
891 : : // Check the global anonymous db ranges.
892 [ + - ][ + - ]: 1 : const ScDBData* pData = getAnonDBs().findAtCursor(nCol, nRow, nTab, bStartOnly);
893 [ - + ]: 1 : if (pData)
894 : 0 : return const_cast<ScDBData*>(pData);
895 : :
896 : 3 : return NULL;
897 : : }
898 : :
899 : 0 : const ScDBData* ScDBCollection::GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
900 : : {
901 : : // First, search the global named db ranges.
902 : 0 : ScRange aRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab);
903 : : NamedDBs::DBsType::const_iterator itr = find_if(
904 [ # # ][ # # ]: 0 : maNamedDBs.begin(), maNamedDBs.end(), FindByRange(aRange));
[ # # ]
905 [ # # ][ # # ]: 0 : if (itr != maNamedDBs.end())
[ # # ]
906 [ # # ]: 0 : return &(*itr);
907 : :
908 : : // Check for the sheet-local anonymous db range.
909 [ # # ]: 0 : ScDBData* pNoNameData = pDoc->GetAnonymousDBData(nTab);
910 [ # # ]: 0 : if (pNoNameData)
911 [ # # ]: 0 : if (pNoNameData->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2))
912 : 0 : return pNoNameData;
913 : :
914 : : // Lastly, check the global anonymous db ranges.
915 [ # # ]: 0 : return maAnonDBs.findByRange(aRange);
916 : : }
917 : :
918 : 60 : ScDBData* ScDBCollection::GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
919 : : {
920 : : // First, search the global named db ranges.
921 : 60 : ScRange aRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab);
922 : : NamedDBs::DBsType::iterator itr = find_if(
923 [ + - ][ + - ]: 60 : maNamedDBs.begin(), maNamedDBs.end(), FindByRange(aRange));
[ + - ]
924 [ + - ][ + - ]: 60 : if (itr != maNamedDBs.end())
[ + + ]
925 [ + - ]: 2 : return &(*itr);
926 : :
927 : : // Check for the sheet-local anonymous db range.
928 [ + - ]: 58 : ScDBData* pNoNameData = pDoc->GetAnonymousDBData(nTab);
929 [ + + ]: 58 : if (pNoNameData)
930 [ + + ]: 42 : if (pNoNameData->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2))
931 : 36 : return pNoNameData;
932 : :
933 : : // Lastly, check the global anonymous db ranges.
934 [ + - ][ + - ]: 22 : const ScDBData* pData = getAnonDBs().findByRange(aRange);
935 [ - + ]: 22 : if (pData)
936 : 0 : return const_cast<ScDBData*>(pData);
937 : :
938 : 60 : return NULL;
939 : : }
940 : :
941 : 115 : void ScDBCollection::DeleteOnTab( SCTAB nTab )
942 : : {
943 : 115 : FindByTable func(nTab);
944 : : // First, collect the positions of all items that need to be deleted.
945 [ + - ]: 115 : ::std::vector<NamedDBs::DBsType::iterator> v;
946 : : {
947 [ + - ][ + - ]: 115 : NamedDBs::DBsType::iterator itr = maNamedDBs.begin(), itrEnd = maNamedDBs.end();
948 [ # # ][ + - ]: 115 : for (; itr != itrEnd; ++itr)
[ - + ]
949 : : {
950 [ # # ][ # # ]: 0 : if (func(*itr))
[ # # ]
951 [ # # ]: 0 : v.push_back(itr);
952 : : }
953 : : }
954 : :
955 : : // Delete them all.
956 : 115 : ::std::vector<NamedDBs::DBsType::iterator>::iterator itr = v.begin(), itrEnd = v.end();
957 [ + - ][ - + ]: 115 : for (; itr != itrEnd; ++itr)
958 [ # # ]: 0 : maNamedDBs.erase(*itr);
959 : :
960 [ + - ][ + - ]: 115 : remove_if(maAnonDBs.begin(), maAnonDBs.end(), func);
[ + - ]
961 : 115 : }
962 : :
963 : 221 : void ScDBCollection::UpdateReference(UpdateRefMode eUpdateRefMode,
964 : : SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
965 : : SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
966 : : SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
967 : : {
968 [ + - ]: 221 : ScDBData* pData = pDoc->GetAnonymousDBData(nTab1);
969 [ + + ]: 221 : if (pData)
970 : : {
971 [ + - ][ + - ]: 8 : if (nTab1 == nTab2 && nDz == 0)
972 : : {
973 : : pData->UpdateReference(
974 : : pDoc, eUpdateRefMode,
975 [ + - ]: 8 : nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz);
976 : : }
977 : : else
978 : : {
979 : : //this will perhabs break undo
980 : : }
981 : : }
982 : :
983 : 221 : UpdateRefFunc func(pDoc, eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz);
984 [ + - ][ + - ]: 221 : for_each(maNamedDBs.begin(), maNamedDBs.end(), func);
[ + - ]
985 [ + - ][ + - ]: 221 : for_each(maAnonDBs.begin(), maAnonDBs.end(), func);
[ + - ]
986 : 221 : }
987 : :
988 : :
989 : 15 : void ScDBCollection::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
990 : : {
991 : 15 : UpdateMoveTabFunc func(nOldPos, nNewPos);
992 [ + - ][ + - ]: 15 : for_each(maNamedDBs.begin(), maNamedDBs.end(), func);
[ + - ]
993 [ + - ][ + - ]: 15 : for_each(maAnonDBs.begin(), maAnonDBs.end(), func);
[ + - ]
994 : 15 : }
995 : :
996 : 22 : ScDBData* ScDBCollection::GetDBNearCursor(SCCOL nCol, SCROW nRow, SCTAB nTab )
997 : : {
998 : 22 : ScDBData* pNearData = NULL;
999 [ + - ][ + - ]: 22 : NamedDBs::DBsType::iterator itr = maNamedDBs.begin(), itrEnd = maNamedDBs.end();
1000 [ # # ][ + - ]: 22 : for (; itr != itrEnd; ++itr)
[ - + ]
1001 : : {
1002 : : SCTAB nAreaTab;
1003 : : SCCOL nStartCol, nEndCol;
1004 : : SCROW nStartRow, nEndRow;
1005 [ # # ]: 0 : itr->GetArea( nAreaTab, nStartCol, nStartRow, nEndCol, nEndRow );
1006 [ # # ][ # # ]: 0 : if ( nTab == nAreaTab && nCol+1 >= nStartCol && nCol <= nEndCol+1 &&
[ # # ][ # # ]
[ # # ]
1007 : : nRow+1 >= nStartRow && nRow <= nEndRow+1 )
1008 : : {
1009 [ # # ][ # # ]: 0 : if ( nCol < nStartCol || nCol > nEndCol || nRow < nStartRow || nRow > nEndRow )
[ # # ][ # # ]
1010 : : {
1011 [ # # ]: 0 : if (!pNearData)
1012 [ # # ]: 0 : pNearData = &(*itr); // ersten angrenzenden Bereich merken
1013 : : }
1014 : : else
1015 [ # # ]: 0 : return &(*itr); // nicht "unbenannt" und Cursor steht wirklich drin
1016 : : }
1017 : : }
1018 [ - + ]: 22 : if (pNearData)
1019 : 0 : return pNearData; // angrenzender, wenn nichts direkt getroffen
1020 [ + - ]: 22 : return pDoc->GetAnonymousDBData(nTab); // "unbenannt" nur zurueck, wenn sonst nichts gefunden
1021 : : }
1022 : :
1023 : 16 : bool ScDBCollection::empty() const
1024 : : {
1025 [ + + ][ + - ]: 16 : return maNamedDBs.empty() && maAnonDBs.empty();
1026 : : }
1027 : :
1028 : 36 : bool ScDBCollection::operator== (const ScDBCollection& r) const
1029 : : {
1030 : 72 : return maNamedDBs == r.maNamedDBs && maAnonDBs == r.maAnonDBs &&
1031 [ + - ][ + - ]: 72 : nEntryIndex == r.nEntryIndex && pDoc == r.pDoc && aRefreshHandler == r.aRefreshHandler;
[ + + ]
[ + - + - ]
1032 : : }
1033 : :
1034 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
