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