1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sc.hxx"
26
27
28 #include <tools/debug.hxx>
29 #include <unotools/transliterationwrapper.hxx>
30
31 #include "dbcolect.hxx"
32 #include "global.hxx"
33 #include "refupdat.hxx"
34 #include "rechead.hxx"
35 #include "document.hxx"
36 #include "queryparam.hxx"
37 #include "globstr.hrc"
38
39 #define SC_DBNAME_UNNAMED "__Anonymous_Sheet_DB__"
40
41 //---------------------------------------------------------------------------------------
42
ScDBData(const String & rName,SCTAB nTab,SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2,sal_Bool bByR,sal_Bool bHasH)43 ScDBData::ScDBData( const String& rName,
44 SCTAB nTab,
45 SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
46 sal_Bool bByR, sal_Bool bHasH) :
47 aName (rName),
48 nTable (nTab),
49 nStartCol (nCol1),
50 nStartRow (nRow1),
51 nEndCol (nCol2),
52 nEndRow (nRow2),
53 bByRow (bByR),
54 bHasHeader (bHasH),
55 bDoSize (sal_False),
56 bKeepFmt (sal_False),
57 bStripData (sal_False),
58 bIsAdvanced (sal_False),
59 bDBSelection(sal_False),
60 nIndex (0),
61 bAutoFilter (sal_False),
62 bModified (sal_False)
63 {
64 sal_uInt16 i;
65
66 ScSortParam aSortParam;
67 ScQueryParam aQueryParam;
68 ScSubTotalParam aSubTotalParam;
69 ScImportParam aImportParam;
70
71 for (i=0; i<MAXQUERY; i++)
72 pQueryStr[i] = new String;
73
74 for (i=0; i<MAXSUBTOTAL; i++)
75 {
76 nSubTotals[i] = 0;
77 pSubTotals[i] = NULL;
78 pFunctions[i] = NULL;
79 }
80
81 SetSortParam( aSortParam );
82 SetQueryParam( aQueryParam );
83 SetSubTotalParam( aSubTotalParam );
84 SetImportParam( aImportParam );
85 }
86
ScDBData(const ScDBData & rData)87 ScDBData::ScDBData( const ScDBData& rData ) :
88 ScDataObject(),
89 ScRefreshTimer ( rData ),
90 aName (rData.aName),
91 nTable (rData.nTable),
92 nStartCol (rData.nStartCol),
93 nStartRow (rData.nStartRow),
94 nEndCol (rData.nEndCol),
95 nEndRow (rData.nEndRow),
96 bByRow (rData.bByRow),
97 bHasHeader (rData.bHasHeader),
98 bDoSize (rData.bDoSize),
99 bKeepFmt (rData.bKeepFmt),
100 bStripData (rData.bStripData),
101 bSortCaseSens (rData.bSortCaseSens),
102 bIncludePattern (rData.bIncludePattern),
103 bSortInplace (rData.bSortInplace),
104 bSortUserDef (rData.bSortUserDef),
105 nSortUserIndex (rData.nSortUserIndex),
106 nSortDestTab (rData.nSortDestTab),
107 nSortDestCol (rData.nSortDestCol),
108 nSortDestRow (rData.nSortDestRow),
109 aSortLocale (rData.aSortLocale),
110 aSortAlgorithm (rData.aSortAlgorithm),
111 bQueryInplace (rData.bQueryInplace),
112 bQueryCaseSens (rData.bQueryCaseSens),
113 bQueryRegExp (rData.bQueryRegExp),
114 bQueryDuplicate (rData.bQueryDuplicate),
115 nQueryDestTab (rData.nQueryDestTab),
116 nQueryDestCol (rData.nQueryDestCol),
117 nQueryDestRow (rData.nQueryDestRow),
118 bIsAdvanced (rData.bIsAdvanced),
119 aAdvSource (rData.aAdvSource),
120 bSubRemoveOnly (rData.bSubRemoveOnly),
121 bSubReplace (rData.bSubReplace),
122 bSubPagebreak (rData.bSubPagebreak),
123 bSubCaseSens (rData.bSubCaseSens),
124 bSubDoSort (rData.bSubDoSort),
125 bSubAscending (rData.bSubAscending),
126 bSubIncludePattern (rData.bSubIncludePattern),
127 bSubUserDef (rData.bSubUserDef),
128 nSubUserIndex (rData.nSubUserIndex),
129 bDBImport (rData.bDBImport),
130 aDBName (rData.aDBName),
131 aDBStatement (rData.aDBStatement),
132 bDBNative (rData.bDBNative),
133 bDBSelection (rData.bDBSelection),
134 bDBSql (rData.bDBSql),
135 nDBType (rData.nDBType),
136 nIndex (rData.nIndex),
137 bAutoFilter (rData.bAutoFilter),
138 bModified (rData.bModified)
139 {
140 sal_uInt16 i;
141 sal_uInt16 j;
142
143 for (i=0; i<MAXSORT; i++)
144 {
145 bDoSort[i] = rData.bDoSort[i];
146 nSortField[i] = rData.nSortField[i];
147 bAscending[i] = rData.bAscending[i];
148 }
149 for (i=0; i<MAXQUERY; i++)
150 {
151 bDoQuery[i] = rData.bDoQuery[i];
152 nQueryField[i] = rData.nQueryField[i];
153 eQueryOp[i] = rData.eQueryOp[i];
154 bQueryByString[i] = rData.bQueryByString[i];
155 bQueryByDate[i] = rData.bQueryByDate[i];
156 pQueryStr[i] = new String( *(rData.pQueryStr[i]) );
157 nQueryVal[i] = rData.nQueryVal[i];
158 eQueryConnect[i] = rData.eQueryConnect[i];
159 }
160 for (i=0; i<MAXSUBTOTAL; i++)
161 {
162 bDoSubTotal[i] = rData.bDoSubTotal[i];
163 nSubField[i] = rData.nSubField[i];
164
165 SCCOL nCount = rData.nSubTotals[i];
166 nSubTotals[i] = nCount;
167 pFunctions[i] = nCount > 0 ? new ScSubTotalFunc [nCount] : NULL;
168 pSubTotals[i] = nCount > 0 ? new SCCOL [nCount] : NULL;
169
170 for (j=0; j<nCount; j++)
171 {
172 pSubTotals[i][j] = rData.pSubTotals[i][j];
173 pFunctions[i][j] = rData.pFunctions[i][j];
174 }
175 }
176 }
177
operator =(const ScDBData & rData)178 ScDBData& ScDBData::operator= (const ScDBData& rData)
179 {
180 sal_uInt16 i;
181 sal_uInt16 j;
182
183 ScRefreshTimer::operator=( rData );
184 aName = rData.aName;
185 nTable = rData.nTable;
186 nStartCol = rData.nStartCol;
187 nStartRow = rData.nStartRow;
188 nEndCol = rData.nEndCol;
189 nEndRow = rData.nEndRow;
190 bByRow = rData.bByRow;
191 bHasHeader = rData.bHasHeader;
192 bDoSize = rData.bDoSize;
193 bKeepFmt = rData.bKeepFmt;
194 bStripData = rData.bStripData;
195 bSortCaseSens = rData.bSortCaseSens;
196 bIncludePattern = rData.bIncludePattern;
197 bSortInplace = rData.bSortInplace;
198 nSortDestTab = rData.nSortDestTab;
199 nSortDestCol = rData.nSortDestCol;
200 nSortDestRow = rData.nSortDestRow;
201 bSortUserDef = rData.bSortUserDef;
202 nSortUserIndex = rData.nSortUserIndex;
203 aSortLocale = rData.aSortLocale;
204 aSortAlgorithm = rData.aSortAlgorithm;
205 bQueryInplace = rData.bQueryInplace;
206 bQueryCaseSens = rData.bQueryCaseSens;
207 bQueryRegExp = rData.bQueryRegExp;
208 bQueryDuplicate = rData.bQueryDuplicate;
209 nQueryDestTab = rData.nQueryDestTab;
210 nQueryDestCol = rData.nQueryDestCol;
211 nQueryDestRow = rData.nQueryDestRow;
212 bIsAdvanced = rData.bIsAdvanced;
213 aAdvSource = rData.aAdvSource;
214 bSubRemoveOnly = rData.bSubRemoveOnly;
215 bSubReplace = rData.bSubReplace;
216 bSubPagebreak = rData.bSubPagebreak;
217 bSubCaseSens = rData.bSubCaseSens;
218 bSubDoSort = rData.bSubDoSort;
219 bSubAscending = rData.bSubAscending;
220 bSubIncludePattern = rData.bSubIncludePattern;
221 bSubUserDef = rData.bSubUserDef;
222 nSubUserIndex = rData.nSubUserIndex;
223 bDBImport = rData.bDBImport;
224 aDBName = rData.aDBName;
225 aDBStatement = rData.aDBStatement;
226 bDBNative = rData.bDBNative;
227 bDBSelection = rData.bDBSelection;
228 bDBSql = rData.bDBSql;
229 nDBType = rData.nDBType;
230 nIndex = rData.nIndex;
231 bAutoFilter = rData.bAutoFilter;
232
233 for (i=0; i<MAXSORT; i++)
234 {
235 bDoSort[i] = rData.bDoSort[i];
236 nSortField[i] = rData.nSortField[i];
237 bAscending[i] = rData.bAscending[i];
238 }
239 for (i=0; i<MAXQUERY; i++)
240 {
241 bDoQuery[i] = rData.bDoQuery[i];
242 nQueryField[i] = rData.nQueryField[i];
243 eQueryOp[i] = rData.eQueryOp[i];
244 bQueryByString[i] = rData.bQueryByString[i];
245 bQueryByDate[i] = rData.bQueryByDate[i];
246 *pQueryStr[i] = *rData.pQueryStr[i];
247 nQueryVal[i] = rData.nQueryVal[i];
248 eQueryConnect[i] = rData.eQueryConnect[i];
249 }
250 for (i=0; i<MAXSUBTOTAL; i++)
251 {
252 bDoSubTotal[i] = rData.bDoSubTotal[i];
253 nSubField[i] = rData.nSubField[i];
254 SCCOL nCount = rData.nSubTotals[i];
255 nSubTotals[i] = nCount;
256
257 delete[] pSubTotals[i];
258 delete[] pFunctions[i];
259
260 pSubTotals[i] = nCount > 0 ? new SCCOL [nCount] : NULL;
261 pFunctions[i] = nCount > 0 ? new ScSubTotalFunc [nCount] : NULL;
262 for (j=0; j<nCount; j++)
263 {
264 pSubTotals[i][j] = rData.pSubTotals[i][j];
265 pFunctions[i][j] = rData.pFunctions[i][j];
266 }
267 }
268
269 return *this;
270 }
271
operator ==(const ScDBData & rData) const272 sal_Bool ScDBData::operator== (const ScDBData& rData) const
273 {
274 // Daten, die nicht in den Params sind
275
276 if ( nTable != rData.nTable ||
277 bDoSize != rData.bDoSize ||
278 bKeepFmt != rData.bKeepFmt ||
279 bIsAdvanced!= rData.bIsAdvanced||
280 bStripData != rData.bStripData ||
281 // SAB: I think this should be here, but I don't want to break something
282 // bAutoFilter!= rData.bAutoFilter||
283 ScRefreshTimer::operator!=( rData )
284 )
285 return sal_False;
286
287 if ( bIsAdvanced && aAdvSource != rData.aAdvSource )
288 return sal_False;
289
290 ScSortParam aSort1, aSort2;
291 GetSortParam(aSort1);
292 rData.GetSortParam(aSort2);
293 if (!(aSort1 == aSort2))
294 return sal_False;
295
296 ScQueryParam aQuery1, aQuery2;
297 GetQueryParam(aQuery1);
298 rData.GetQueryParam(aQuery2);
299 if (!(aQuery1 == aQuery2))
300 return sal_False;
301
302 ScSubTotalParam aSubTotal1, aSubTotal2;
303 GetSubTotalParam(aSubTotal1);
304 rData.GetSubTotalParam(aSubTotal2);
305 if (!(aSubTotal1 == aSubTotal2))
306 return sal_False;
307
308 ScImportParam aImport1, aImport2;
309 GetImportParam(aImport1);
310 rData.GetImportParam(aImport2);
311 if (!(aImport1 == aImport2))
312 return sal_False;
313
314 return sal_True;
315 }
316
~ScDBData()317 ScDBData::~ScDBData()
318 {
319 StopRefreshTimer();
320 sal_uInt16 i;
321
322 for (i=0; i<MAXQUERY; i++)
323 delete pQueryStr[i];
324 for (i=0; i<MAXSUBTOTAL; i++)
325 {
326 delete[] pSubTotals[i];
327 delete[] pFunctions[i];
328 }
329 }
330
331 //UNUSED2008-05 sal_Bool ScDBData::IsBeyond(SCROW nMaxRow) const
332 //UNUSED2008-05 {
333 //UNUSED2008-05 return ( nStartRow > nMaxRow ||
334 //UNUSED2008-05 nEndRow > nMaxRow ||
335 //UNUSED2008-05 nQueryDestRow > nMaxRow );
336 //UNUSED2008-05 }
337
GetSourceString() const338 String ScDBData::GetSourceString() const
339 {
340 String aVal;
341 if (bDBImport)
342 {
343 aVal = aDBName;
344 aVal += '/';
345 aVal += aDBStatement;
346 }
347 return aVal;
348 }
349
GetOperations() const350 String ScDBData::GetOperations() const
351 {
352 String aVal;
353 if (bDoQuery[0])
354 aVal = ScGlobal::GetRscString(STR_OPERATION_FILTER);
355
356 if (bDoSort[0])
357 {
358 if (aVal.Len())
359 aVal.AppendAscii( RTL_CONSTASCII_STRINGPARAM(", ") );
360 aVal += ScGlobal::GetRscString(STR_OPERATION_SORT);
361 }
362
363 if (bDoSubTotal[0] && !bSubRemoveOnly)
364 {
365 if (aVal.Len())
366 aVal.AppendAscii( RTL_CONSTASCII_STRINGPARAM(", ") );
367 aVal += ScGlobal::GetRscString(STR_OPERATION_SUBTOTAL);
368 }
369
370 if (!aVal.Len())
371 aVal = ScGlobal::GetRscString(STR_OPERATION_NONE);
372
373 return aVal;
374 }
375
GetArea(SCTAB & rTab,SCCOL & rCol1,SCROW & rRow1,SCCOL & rCol2,SCROW & rRow2) const376 void ScDBData::GetArea(SCTAB& rTab, SCCOL& rCol1, SCROW& rRow1, SCCOL& rCol2, SCROW& rRow2) const
377 {
378 rTab = nTable;
379 rCol1 = nStartCol;
380 rRow1 = nStartRow;
381 rCol2 = nEndCol;
382 rRow2 = nEndRow;
383 }
384
GetArea(ScRange & rRange) const385 void ScDBData::GetArea(ScRange& rRange) const
386 {
387 rRange = ScRange( nStartCol,nStartRow,nTable, nEndCol,nEndRow,nTable );
388 }
389
SetArea(SCTAB nTab,SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2)390 void ScDBData::SetArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
391 {
392 nTable = nTab;
393 nStartCol = nCol1;
394 nStartRow = nRow1;
395 nEndCol = nCol2;
396 nEndRow = nRow2;
397 }
398
MoveTo(SCTAB nTab,SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2)399 void ScDBData::MoveTo(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
400 {
401 sal_uInt16 i;
402 long nDifX = ((long) nCol1) - ((long) nStartCol);
403 long nDifY = ((long) nRow1) - ((long) nStartRow);
404
405 long nSortDif = bByRow ? nDifX : nDifY;
406 long nSortEnd = bByRow ? static_cast<long>(nCol2) : static_cast<long>(nRow2);
407
408 for (i=0; i<MAXSORT; i++)
409 {
410 nSortField[i] += nSortDif;
411 if (nSortField[i] > nSortEnd)
412 {
413 nSortField[i] = 0;
414 bDoSort[i] = sal_False;
415 }
416 }
417 for (i=0; i<MAXQUERY; i++)
418 {
419 nQueryField[i] += nDifX;
420 if (nQueryField[i] > nCol2)
421 {
422 nQueryField[i] = 0;
423 bDoQuery[i] = sal_False;
424 }
425 }
426 for (i=0; i<MAXSUBTOTAL; i++)
427 {
428 nSubField[i] = sal::static_int_cast<SCCOL>( nSubField[i] + nDifX );
429 if (nSubField[i] > nCol2)
430 {
431 nSubField[i] = 0;
432 bDoSubTotal[i] = sal_False;
433 }
434 }
435
436 SetArea( nTab, nCol1, nRow1, nCol2, nRow2 );
437 }
438
GetSortParam(ScSortParam & rSortParam) const439 void ScDBData::GetSortParam( ScSortParam& rSortParam ) const
440 {
441 rSortParam.nCol1 = nStartCol;
442 rSortParam.nRow1 = nStartRow;
443 rSortParam.nCol2 = nEndCol;
444 rSortParam.nRow2 = nEndRow;
445 rSortParam.bByRow = bByRow;
446 rSortParam.bHasHeader = bHasHeader;
447 rSortParam.bCaseSens = bSortCaseSens;
448 rSortParam.bInplace = bSortInplace;
449 rSortParam.nDestTab = nSortDestTab;
450 rSortParam.nDestCol = nSortDestCol;
451 rSortParam.nDestRow = nSortDestRow;
452 rSortParam.bIncludePattern = bIncludePattern;
453 rSortParam.bUserDef = bSortUserDef;
454 rSortParam.nUserIndex = nSortUserIndex;
455 for (sal_uInt16 i=0; i<MAXSORT; i++)
456 {
457 rSortParam.bDoSort[i] = bDoSort[i];
458 rSortParam.nField[i] = nSortField[i];
459 rSortParam.bAscending[i] = bAscending[i];
460 }
461 rSortParam.aCollatorLocale = aSortLocale;
462 rSortParam.aCollatorAlgorithm = aSortAlgorithm;
463 }
464
SetSortParam(const ScSortParam & rSortParam)465 void ScDBData::SetSortParam( const ScSortParam& rSortParam )
466 {
467 bSortCaseSens = rSortParam.bCaseSens;
468 bIncludePattern = rSortParam.bIncludePattern;
469 bSortInplace = rSortParam.bInplace;
470 nSortDestTab = rSortParam.nDestTab;
471 nSortDestCol = rSortParam.nDestCol;
472 nSortDestRow = rSortParam.nDestRow;
473 bSortUserDef = rSortParam.bUserDef;
474 nSortUserIndex = rSortParam.nUserIndex;
475 for (sal_uInt16 i=0; i<MAXSORT; i++)
476 {
477 bDoSort[i] = rSortParam.bDoSort[i];
478 nSortField[i] = rSortParam.nField[i];
479 bAscending[i] = rSortParam.bAscending[i];
480 }
481 aSortLocale = rSortParam.aCollatorLocale;
482 aSortAlgorithm = rSortParam.aCollatorAlgorithm;
483
484 //#98317#; set the orientation
485 bByRow = rSortParam.bByRow;
486 }
487
GetQueryParam(ScQueryParam & rQueryParam) const488 void ScDBData::GetQueryParam( ScQueryParam& rQueryParam ) const
489 {
490 rQueryParam.nCol1 = nStartCol;
491 rQueryParam.nRow1 = nStartRow;
492 rQueryParam.nCol2 = nEndCol;
493 rQueryParam.nRow2 = nEndRow;
494 rQueryParam.nTab = nTable;
495 rQueryParam.bByRow = bByRow;
496 rQueryParam.bHasHeader = bHasHeader;
497 rQueryParam.bInplace = bQueryInplace;
498 rQueryParam.bCaseSens = bQueryCaseSens;
499 rQueryParam.bRegExp = bQueryRegExp;
500 rQueryParam.bDuplicate = bQueryDuplicate;
501 rQueryParam.nDestTab = nQueryDestTab;
502 rQueryParam.nDestCol = nQueryDestCol;
503 rQueryParam.nDestRow = nQueryDestRow;
504
505 rQueryParam.Resize( MAXQUERY );
506 for (SCSIZE i=0; i<MAXQUERY; i++)
507 {
508 ScQueryEntry& rEntry = rQueryParam.GetEntry(i);
509
510 rEntry.bDoQuery = bDoQuery[i];
511 rEntry.nField = nQueryField[i];
512 rEntry.eOp = eQueryOp[i];
513 rEntry.bQueryByString = bQueryByString[i];
514 rEntry.bQueryByDate = bQueryByDate[i];
515 *rEntry.pStr = *pQueryStr[i];
516 rEntry.nVal = nQueryVal[i];
517 rEntry.eConnect = eQueryConnect[i];
518 }
519 }
520
SetQueryParam(const ScQueryParam & rQueryParam)521 void ScDBData::SetQueryParam(const ScQueryParam& rQueryParam)
522 {
523 DBG_ASSERT( rQueryParam.GetEntryCount() <= MAXQUERY ||
524 !rQueryParam.GetEntry(MAXQUERY).bDoQuery,
525 "zuviele Eintraege bei ScDBData::SetQueryParam" );
526
527 // set bIsAdvanced to sal_False for everything that is not from the
528 // advanced filter dialog
529 bIsAdvanced = sal_False;
530
531 bQueryInplace = rQueryParam.bInplace;
532 bQueryCaseSens = rQueryParam.bCaseSens;
533 bQueryRegExp = rQueryParam.bRegExp;
534 bQueryDuplicate = rQueryParam.bDuplicate;
535 nQueryDestTab = rQueryParam.nDestTab;
536 nQueryDestCol = rQueryParam.nDestCol;
537 nQueryDestRow = rQueryParam.nDestRow;
538 for (SCSIZE i=0; i<MAXQUERY; i++)
539 {
540 ScQueryEntry& rEntry = rQueryParam.GetEntry(i);
541
542 bDoQuery[i] = rEntry.bDoQuery;
543 nQueryField[i] = rEntry.nField;
544 eQueryOp[i] = rEntry.eOp;
545 bQueryByString[i] = rEntry.bQueryByString;
546 bQueryByDate[i] = rEntry.bQueryByDate;
547 *pQueryStr[i] = *rEntry.pStr;
548 nQueryVal[i] = rEntry.nVal;
549 eQueryConnect[i] = rEntry.eConnect;
550 }
551 }
552
SetAdvancedQuerySource(const ScRange * pSource)553 void ScDBData::SetAdvancedQuerySource(const ScRange* pSource)
554 {
555 if (pSource)
556 {
557 aAdvSource = *pSource;
558 bIsAdvanced = sal_True;
559 }
560 else
561 bIsAdvanced = sal_False;
562 }
563
GetAdvancedQuerySource(ScRange & rSource) const564 sal_Bool ScDBData::GetAdvancedQuerySource(ScRange& rSource) const
565 {
566 rSource = aAdvSource;
567 return bIsAdvanced;
568 }
569
GetSubTotalParam(ScSubTotalParam & rSubTotalParam) const570 void ScDBData::GetSubTotalParam(ScSubTotalParam& rSubTotalParam) const
571 {
572 sal_uInt16 i;
573 sal_uInt16 j;
574
575 rSubTotalParam.nCol1 = nStartCol;
576 rSubTotalParam.nRow1 = nStartRow;
577 rSubTotalParam.nCol2 = nEndCol;
578 rSubTotalParam.nRow2 = nEndRow;
579
580 rSubTotalParam.bRemoveOnly = bSubRemoveOnly;
581 rSubTotalParam.bReplace = bSubReplace;
582 rSubTotalParam.bPagebreak = bSubPagebreak;
583 rSubTotalParam.bCaseSens = bSubCaseSens;
584 rSubTotalParam.bDoSort = bSubDoSort;
585 rSubTotalParam.bAscending = bSubAscending;
586 rSubTotalParam.bIncludePattern = bSubIncludePattern;
587 rSubTotalParam.bUserDef = bSubUserDef;
588 rSubTotalParam.nUserIndex = nSubUserIndex;
589
590 for (i=0; i<MAXSUBTOTAL; i++)
591 {
592 rSubTotalParam.bGroupActive[i] = bDoSubTotal[i];
593 rSubTotalParam.nField[i] = nSubField[i];
594 SCCOL nCount = nSubTotals[i];
595
596 rSubTotalParam.nSubTotals[i] = nCount;
597 delete[] rSubTotalParam.pSubTotals[i];
598 delete[] rSubTotalParam.pFunctions[i];
599 rSubTotalParam.pSubTotals[i] = nCount > 0 ? new SCCOL[nCount] : NULL;
600 rSubTotalParam.pFunctions[i] = nCount > 0 ? new ScSubTotalFunc[nCount]
601 : NULL;
602 for (j=0; j<nCount; j++)
603 {
604 rSubTotalParam.pSubTotals[i][j] = pSubTotals[i][j];
605 rSubTotalParam.pFunctions[i][j] = pFunctions[i][j];
606 }
607 }
608 }
609
SetSubTotalParam(const ScSubTotalParam & rSubTotalParam)610 void ScDBData::SetSubTotalParam(const ScSubTotalParam& rSubTotalParam)
611 {
612 sal_uInt16 i;
613 sal_uInt16 j;
614
615 bSubRemoveOnly = rSubTotalParam.bRemoveOnly;
616 bSubReplace = rSubTotalParam.bReplace;
617 bSubPagebreak = rSubTotalParam.bPagebreak;
618 bSubCaseSens = rSubTotalParam.bCaseSens;
619 bSubDoSort = rSubTotalParam.bDoSort;
620 bSubAscending = rSubTotalParam.bAscending;
621 bSubIncludePattern = rSubTotalParam.bIncludePattern;
622 bSubUserDef = rSubTotalParam.bUserDef;
623 nSubUserIndex = rSubTotalParam.nUserIndex;
624
625 for (i=0; i<MAXSUBTOTAL; i++)
626 {
627 bDoSubTotal[i] = rSubTotalParam.bGroupActive[i];
628 nSubField[i] = rSubTotalParam.nField[i];
629 SCCOL nCount = rSubTotalParam.nSubTotals[i];
630
631 nSubTotals[i] = nCount;
632 delete[] pSubTotals[i];
633 delete[] pFunctions[i];
634 pSubTotals[i] = nCount > 0 ? new SCCOL [nCount] : NULL;
635 pFunctions[i] = nCount > 0 ? new ScSubTotalFunc [nCount] : NULL;
636 for (j=0; j<nCount; j++)
637 {
638 pSubTotals[i][j] = rSubTotalParam.pSubTotals[i][j];
639 pFunctions[i][j] = rSubTotalParam.pFunctions[i][j];
640 }
641 }
642 }
643
GetImportParam(ScImportParam & rImportParam) const644 void ScDBData::GetImportParam(ScImportParam& rImportParam) const
645 {
646 rImportParam.nCol1 = nStartCol;
647 rImportParam.nRow1 = nStartRow;
648 rImportParam.nCol2 = nEndCol;
649 rImportParam.nRow2 = nEndRow;
650
651 rImportParam.bImport = bDBImport;
652 rImportParam.aDBName = aDBName;
653 rImportParam.aStatement = aDBStatement;
654 rImportParam.bNative = bDBNative;
655 rImportParam.bSql = bDBSql;
656 rImportParam.nType = nDBType;
657 }
658
SetImportParam(const ScImportParam & rImportParam)659 void ScDBData::SetImportParam(const ScImportParam& rImportParam)
660 {
661 bDBImport = rImportParam.bImport;
662 aDBName = rImportParam.aDBName;
663 aDBStatement = rImportParam.aStatement;
664 bDBNative = rImportParam.bNative;
665 bDBSql = rImportParam.bSql;
666 nDBType = rImportParam.nType;
667 }
668
IsDBAtCursor(SCCOL nCol,SCROW nRow,SCTAB nTab,sal_Bool bStartOnly) const669 sal_Bool ScDBData::IsDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bStartOnly) const
670 {
671 if (nTab == nTable)
672 {
673 if ( bStartOnly )
674 return ( nCol == nStartCol && nRow == nStartRow );
675 else
676 return ( nCol >= nStartCol && nCol <= nEndCol &&
677 nRow >= nStartRow && nRow <= nEndRow );
678 }
679
680 return sal_False;
681 }
682
IsDBAtArea(SCTAB nTab,SCCOL nCol1,SCROW nRow1,SCCOL nCol2,SCROW nRow2) const683 sal_Bool ScDBData::IsDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
684 {
685 return (sal_Bool)((nTab == nTable)
686 && (nCol1 == nStartCol) && (nRow1 == nStartRow)
687 && (nCol2 == nEndCol) && (nRow2 == nEndRow));
688 }
689
Clone() const690 ScDataObject* ScDBData::Clone() const
691 {
692 return new ScDBData(*this);
693 }
694
695
IsInternalUnnamed() const696 bool ScDBData::IsInternalUnnamed() const
697 {
698 return GetName() == ScGlobal::GetRscString( STR_DB_NONAME );
699 }
700
IsInternalForAutoFilter() const701 bool ScDBData::IsInternalForAutoFilter() const
702 {
703 const String aNoName = String::CreateFromAscii(SC_DBNAME_UNNAMED);
704 const String aBeginName = aName.Copy( 0, aNoName.Len() );
705 return aBeginName == aNoName;
706 }
707
708 //---------------------------------------------------------------------------------------
709 // Compare zum Sortieren
710
Compare(ScDataObject * pKey1,ScDataObject * pKey2) const711 short ScDBCollection::Compare(ScDataObject* pKey1, ScDataObject* pKey2) const
712 {
713 const String& rStr1 = ((ScDBData*)pKey1)->GetName();
714 const String& rStr2 = ((ScDBData*)pKey2)->GetName();
715 return (short) ScGlobal::GetpTransliteration()->compareString( rStr1, rStr2 );
716 }
717
718 // IsEqual - alles gleich
719
IsEqual(ScDataObject * pKey1,ScDataObject * pKey2) const720 sal_Bool ScDBCollection::IsEqual(ScDataObject* pKey1, ScDataObject* pKey2) const
721 {
722 return *(ScDBData*)pKey1 == *(ScDBData*)pKey2;
723 }
724
GetDBAtCursor(SCCOL nCol,SCROW nRow,SCTAB nTab,sal_Bool bStartOnly) const725 ScDBData* ScDBCollection::GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bStartOnly) const
726 {
727 ScDBData* pInternalDBData = NULL;
728 if (pItems)
729 {
730
731 for (sal_uInt16 i = 0; i < nCount; i++)
732 if (((ScDBData*)pItems[i])->IsDBAtCursor(nCol, nRow, nTab, bStartOnly))
733 {
734 ScDBData* pDB = (ScDBData*)pItems[i];
735 if ( pDB->IsInternalUnnamed()
736 || pDB->IsInternalForAutoFilter() )
737 {
738 pInternalDBData = pDB;
739 }
740 else
741 {
742 return pDB;
743 }
744 }
745 }
746 return pInternalDBData;
747 }
748
GetDBAtArea(const SCTAB nTab,const SCCOL nCol1,const SCROW nRow1,const SCCOL nCol2,const SCROW nRow2) const749 ScDBData* ScDBCollection::GetDBAtArea(
750 const SCTAB nTab,
751 const SCCOL nCol1,
752 const SCROW nRow1,
753 const SCCOL nCol2,
754 const SCROW nRow2 ) const
755 {
756 ScDBData* pInternalDBData = NULL;
757 if (pItems)
758 {
759 for (sal_uInt16 i = 0; i < nCount; i++)
760 if (((ScDBData*)pItems[i])->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2))
761 {
762 ScDBData* pDB = (ScDBData*)pItems[i];
763 if ( pDB->IsInternalUnnamed()
764 || pDB->IsInternalForAutoFilter() )
765 pInternalDBData = pDB;
766 else
767 return pDB;
768 }
769 }
770 return pInternalDBData;
771 }
772
GetFilterDBAtTable(SCTAB nTab) const773 ScDBData* ScDBCollection::GetFilterDBAtTable(SCTAB nTab) const
774 {
775 ScDBData* pDataEmpty = NULL;
776 if (pItems)
777 {
778 for (sal_uInt16 i = 0; i < nCount; i++)
779 {
780 ScDBData* pDBTemp = (ScDBData*)pItems[i];
781 if ( pDBTemp->nTable == nTab )
782 {
783 sal_Bool bFilter = pDBTemp->HasAutoFilter() || pDBTemp->HasQueryParam();
784
785 if ( bFilter )
786 return pDBTemp;
787 }
788 }
789 }
790
791 return pDataEmpty;
792 }
793
SearchName(const String & rName,sal_uInt16 & rIndex) const794 sal_Bool ScDBCollection::SearchName( const String& rName, sal_uInt16& rIndex ) const
795 {
796 ScDBData aDataObj( rName, 0,0,0,0,0 );
797 return Search( &aDataObj, rIndex );
798 }
799
DeleteOnTab(SCTAB nTab)800 void ScDBCollection::DeleteOnTab( SCTAB nTab )
801 {
802 sal_uInt16 nPos = 0;
803 while ( nPos < nCount )
804 {
805 // look for output positions on the deleted sheet
806
807 SCCOL nEntryCol1, nEntryCol2;
808 SCROW nEntryRow1, nEntryRow2;
809 SCTAB nEntryTab;
810 static_cast<const ScDBData*>(At(nPos))->GetArea( nEntryTab, nEntryCol1, nEntryRow1, nEntryCol2, nEntryRow2 );
811 if ( nEntryTab == nTab )
812 AtFree(nPos);
813 else
814 ++nPos;
815 }
816 }
817
UpdateReference(UpdateRefMode eUpdateRefMode,SCCOL nCol1,SCROW nRow1,SCTAB nTab1,SCCOL nCol2,SCROW nRow2,SCTAB nTab2,SCsCOL nDx,SCsROW nDy,SCsTAB nDz)818 void ScDBCollection::UpdateReference(UpdateRefMode eUpdateRefMode,
819 SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
820 SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
821 SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
822 {
823 for (sal_uInt16 i=0; i<nCount; i++)
824 {
825 SCCOL theCol1;
826 SCROW theRow1;
827 SCTAB theTab1;
828 SCCOL theCol2;
829 SCROW theRow2;
830 SCTAB theTab2;
831 ((ScDBData*)pItems[i])->GetArea( theTab1, theCol1, theRow1, theCol2, theRow2 );
832 theTab2 = theTab1;
833
834 sal_Bool bDoUpdate = ScRefUpdate::Update( pDoc, eUpdateRefMode,
835 nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz,
836 theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) != UR_NOTHING;
837 if (bDoUpdate)
838 ((ScDBData*)pItems[i])->MoveTo( theTab1, theCol1, theRow1, theCol2, theRow2 );
839
840 ScRange aAdvSource;
841 if ( ((ScDBData*)pItems[i])->GetAdvancedQuerySource(aAdvSource) )
842 {
843 aAdvSource.GetVars( theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 );
844 if ( ScRefUpdate::Update( pDoc, eUpdateRefMode,
845 nCol1,nRow1,nTab1, nCol2,nRow2,nTab2, nDx,nDy,nDz,
846 theCol1,theRow1,theTab1, theCol2,theRow2,theTab2 ) )
847 {
848 aAdvSource.aStart.Set( theCol1,theRow1,theTab1 );
849 aAdvSource.aEnd.Set( theCol2,theRow2,theTab2 );
850 ((ScDBData*)pItems[i])->SetAdvancedQuerySource( &aAdvSource );
851
852 bDoUpdate = sal_True; // DBData is modified
853 }
854 }
855
856 ((ScDBData*)pItems[i])->SetModified(bDoUpdate);
857
858 //! Testen, ob mitten aus dem Bereich geloescht/eingefuegt wurde !!!
859 }
860 }
861
862
UpdateMoveTab(SCTAB nOldPos,SCTAB nNewPos)863 void ScDBCollection::UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos )
864 {
865 // wenn nOldPos vor nNewPos liegt, ist nNewPos schon angepasst
866
867 for (sal_uInt16 i=0; i<nCount; i++)
868 {
869 ScRange aRange;
870 ScDBData* pData = (ScDBData*)pItems[i];
871 pData->GetArea( aRange );
872 SCTAB nTab = aRange.aStart.Tab(); // hat nur eine Tabelle
873
874 // anpassen wie die aktuelle Tabelle bei ScTablesHint (tabvwsh5.cxx)
875
876 if ( nTab == nOldPos ) // verschobene Tabelle
877 nTab = nNewPos;
878 else if ( nOldPos < nNewPos ) // nach hinten verschoben
879 {
880 if ( nTab > nOldPos && nTab <= nNewPos ) // nachrueckender Bereich
881 --nTab;
882 }
883 else // nach vorne verschoben
884 {
885 if ( nTab >= nNewPos && nTab < nOldPos ) // nachrueckender Bereich
886 ++nTab;
887 }
888
889 sal_Bool bChanged = ( nTab != aRange.aStart.Tab() );
890 if (bChanged)
891 pData->SetArea( nTab, aRange.aStart.Col(), aRange.aStart.Row(),
892 aRange.aEnd.Col(),aRange.aEnd .Row() );
893
894 // MoveTo ist nicht noetig, wenn nur die Tabelle geaendert ist
895
896 pData->SetModified(bChanged);
897 }
898 }
899
900
FindIndex(sal_uInt16 nIndex)901 ScDBData* ScDBCollection::FindIndex(sal_uInt16 nIndex)
902 {
903 sal_uInt16 i = 0;
904 while (i < nCount)
905 {
906 if ((*this)[i]->GetIndex() == nIndex)
907 return (*this)[i];
908 i++;
909 }
910 return NULL;
911 }
912
Insert(ScDataObject * pScDataObject)913 sal_Bool ScDBCollection::Insert(ScDataObject* pScDataObject)
914 {
915 ScDBData* pData = (ScDBData*) pScDataObject;
916 if (!pData->GetIndex()) // schon gesetzt?
917 pData->SetIndex(nEntryIndex++);
918 sal_Bool bInserted = ScSortedCollection::Insert(pScDataObject);
919 if ( bInserted && pData->HasImportParam() && !pData->HasImportSelection() )
920 {
921 pData->SetRefreshHandler( GetRefreshHandler() );
922 pData->SetRefreshControl( pDoc->GetRefreshTimerControlAddress() );
923 }
924 return bInserted;
925 }
926
GetNewDefaultDBName()927 String ScDBCollection::GetNewDefaultDBName()
928 {
929 String aNoName = String::CreateFromAscii(SC_DBNAME_UNNAMED);
930 String aNewName;
931 unsigned short nDummy;
932 int i = 1;
933 do
934 {
935 aNewName = aNoName;
936 aNewName += String::CreateFromInt32( i++ );
937 }while(SearchName(aNewName,nDummy));
938 return aNewName;
939 }
940