?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#76258 Various fixes for color filter
[LibreOffice.git] / sc / source / core / data / table3.cxx
blob54c0850931eeb303c2a15a8e7bced063cf9c0575
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <comphelper/processfactory.hxx>
21 #include <comphelper/random.hxx>
22 #include <editeng/brushitem.hxx>
23 #include <editeng/colritem.hxx>
24 #include <unotools/textsearch.hxx>
25 #include <svl/zforlist.hxx>
26 #include <svl/zformat.hxx>
27 #include <unotools/charclass.hxx>
28 #include <unotools/collatorwrapper.hxx>
29 #include <stdlib.h>
30 #include <unotools/transliterationwrapper.hxx>
31 #include <com/sun/star/i18n/KParseTokens.hpp>
32 #include <com/sun/star/i18n/KParseType.hpp>
33 #include <sal/log.hxx>
34 #include <osl/diagnose.h>
35
36 #include <refdata.hxx>
37 #include <table.hxx>
38 #include <scitems.hxx>
39 #include <formulacell.hxx>
40 #include <document.hxx>
41 #include <globstr.hrc>
42 #include <scresid.hxx>
43 #include <global.hxx>
44 #include <stlpool.hxx>
45 #include <patattr.hxx>
46 #include <subtotal.hxx>
47 #include <docoptio.hxx>
48 #include <markdata.hxx>
49 #include <rangelst.hxx>
50 #include <userlist.hxx>
51 #include <progress.hxx>
52 #include <cellform.hxx>
53 #include <queryparam.hxx>
54 #include <queryentry.hxx>
55 #include <subtotalparam.hxx>
56 #include <docpool.hxx>
57 #include <cellvalue.hxx>
58 #include <tokenarray.hxx>
59 #include <mtvcellfunc.hxx>
60 #include <columnspanset.hxx>
61 #include <fstalgorithm.hxx>
62 #include <listenercontext.hxx>
63 #include <sharedformula.hxx>
64 #include <stlsheet.hxx>
65 #include <refhint.hxx>
66 #include <listenerquery.hxx>
67 #include <bcaslot.hxx>
68 #include <reordermap.hxx>
69 #include <drwlayer.hxx>
70
71 #include <svl/sharedstringpool.hxx>
72
73 #include <memory>
74 #include <set>
75 #include <unordered_set>
76 #include <vector>
77 #include <mdds/flat_segment_tree.hpp>
78
79 using namespace ::com::sun::star;
80
81 namespace naturalsort {
82
83 using namespace ::com::sun::star::i18n;
84
85 /** Splits a given string into three parts: the prefix, number string, and
86 the suffix.
87
88 @param sWhole
89 Original string to be split into pieces
90
91 @param sPrefix
92 Prefix string that consists of the part before the first number token.
93 If no number was found, sPrefix is unchanged.
94
95 @param sSuffix
96 String after the last number token. This may still contain number strings.
97 If no number was found, sSuffix is unchanged.
98
99 @param fNum
100 Number converted from the middle number string
101 If no number was found, fNum is unchanged.
102
103 @return Returns TRUE if a numeral element is found in a given string, or
104 FALSE if no numeral element is found.
105 */
106 static bool SplitString( const OUString &sWhole,
107 OUString &sPrefix, OUString &sSuffix, double &fNum )
108 {
109 // Get prefix element, search for any digit and stop.
110 sal_Int32 nPos = 0;
111 while (nPos < sWhole.getLength())
112 {
113 const sal_uInt16 nType = ScGlobal::getCharClassPtr()->getCharacterType( sWhole, nPos);
114 if (nType & KCharacterType::DIGIT)
115 break;
116 sWhole.iterateCodePoints( &nPos );
117 }
118
119 // Return FALSE if no numeral element is found
120 if ( nPos == sWhole.getLength() )
121 return false;
122
123 // Get numeral element
124 const OUString& sUser = ScGlobal::getLocaleDataPtr()->getNumDecimalSep();
125 ParseResult aPRNum = ScGlobal::getCharClassPtr()->parsePredefinedToken(
126 KParseType::ANY_NUMBER, sWhole, nPos,
127 KParseTokens::ANY_NUMBER, "", KParseTokens::ANY_NUMBER, sUser );
128
129 if ( aPRNum.EndPos == nPos )
130 {
131 SAL_WARN("sc.core","naturalsort::SplitString - digit found but no number parsed, pos " <<
132 nPos << " : " << sWhole);
133 return false;
134 }
135
136 sPrefix = sWhole.copy( 0, nPos );
137 fNum = aPRNum.Value;
138 sSuffix = sWhole.copy( aPRNum.EndPos );
139
140 return true;
141 }
142
143 /** Naturally compares two given strings.
144
145 This is the main function that should be called externally. It returns
146 either 1, 0, or -1 depending on the comparison result of given two strings.
147
148 @param sInput1
149 Input string 1
150
151 @param sInput2
152 Input string 2
153
154 @param bCaseSens
155 Boolean value for case sensitivity
156
157 @param pData
158 Pointer to user defined sort list
159
160 @param pCW
161 Pointer to collator wrapper for normal string comparison
162
163 @return Returns 1 if sInput1 is greater, 0 if sInput1 == sInput2, and -1 if
164 sInput2 is greater.
165 */
166 static short Compare( const OUString &sInput1, const OUString &sInput2,
167 const bool bCaseSens, const ScUserListData* pData, const CollatorWrapper *pCW )
168 {
169 OUString sStr1( sInput1 ), sStr2( sInput2 ), sPre1, sSuf1, sPre2, sSuf2;
170
171 do
172 {
173 double nNum1, nNum2;
174 bool bNumFound1 = SplitString( sStr1, sPre1, sSuf1, nNum1 );
175 bool bNumFound2 = SplitString( sStr2, sPre2, sSuf2, nNum2 );
176
177 short nPreRes; // Prefix comparison result
178 if ( pData )
179 {
180 if ( bCaseSens )
181 {
182 if ( !bNumFound1 || !bNumFound2 )
183 return static_cast<short>(pData->Compare( sStr1, sStr2 ));
184 else
185 nPreRes = pData->Compare( sPre1, sPre2 );
186 }
187 else
188 {
189 if ( !bNumFound1 || !bNumFound2 )
190 return static_cast<short>(pData->ICompare( sStr1, sStr2 ));
191 else
192 nPreRes = pData->ICompare( sPre1, sPre2 );
193 }
194 }
195 else
196 {
197 if ( !bNumFound1 || !bNumFound2 )
198 return static_cast<short>(pCW->compareString( sStr1, sStr2 ));
199 else
200 nPreRes = static_cast<short>(pCW->compareString( sPre1, sPre2 ));
201 }
202
203 // Prefix strings differ. Return immediately.
204 if ( nPreRes != 0 ) return nPreRes;
205
206 if ( nNum1 != nNum2 )
207 {
208 if ( nNum1 < nNum2 ) return -1;
209 return (nNum1 > nNum2) ? 1 : 0;
210 }
211
212 // The prefix and the first numerical elements are equal, but the suffix
213 // strings may still differ. Stay in the loop.
214
215 sStr1 = sSuf1;
216 sStr2 = sSuf2;
217
218 } while (true);
219
220 return 0;
221 }
222
223 }
224
225 namespace {
226
227 struct ScSortInfo final
228 {
229 ScRefCellValue maCell;
230 SCCOLROW nOrg;
231 };
232
233 }
234
235 class ScSortInfoArray
236 {
237 public:
238
239 struct Cell
240 {
241 ScRefCellValue maCell;
242 const sc::CellTextAttr* mpAttr;
243 const ScPostIt* mpNote;
244 std::vector<SdrObject*> maDrawObjects;
245 const ScPatternAttr* mpPattern;
246
247 Cell() : mpAttr(nullptr), mpNote(nullptr), maDrawObjects(), mpPattern(nullptr) {}
248 };
249
250 struct Row
251 {
252 std::vector<Cell> maCells;
253
254 bool mbHidden:1;
255 bool mbFiltered:1;
256
257 explicit Row( size_t nColSize ) : maCells(nColSize, Cell()), mbHidden(false), mbFiltered(false) {}
258 };
259
260 typedef std::vector<Row> RowsType;
261
262 private:
263 std::unique_ptr<RowsType> mpRows; /// row-wise data table for sort by row operation.
264
265 std::vector<std::unique_ptr<ScSortInfo[]>> mvppInfo;
266 SCCOLROW nStart;
267 SCCOLROW mnLastIndex; /// index of last non-empty cell position.
268
269 std::vector<SCCOLROW> maOrderIndices;
270 bool mbKeepQuery;
271 bool mbUpdateRefs;
272
273 public:
274 ScSortInfoArray(const ScSortInfoArray&) = delete;
275 const ScSortInfoArray& operator=(const ScSortInfoArray&) = delete;
276
277 ScSortInfoArray( sal_uInt16 nSorts, SCCOLROW nInd1, SCCOLROW nInd2 ) :
278 mvppInfo(nSorts),
279 nStart( nInd1 ),
280 mnLastIndex(nInd2),
281 mbKeepQuery(false),
282 mbUpdateRefs(false)
283 {
284 SCSIZE nCount( nInd2 - nInd1 + 1 );
285 if (nSorts)
286 {
287 for ( sal_uInt16 nSort = 0; nSort < nSorts; nSort++ )
288 {
289 mvppInfo[nSort].reset(new ScSortInfo[nCount]);
290 }
291 }
292
293 for (size_t i = 0; i < nCount; ++i)
294 maOrderIndices.push_back(i+nStart);
295 }
296
297 void SetKeepQuery( bool b ) { mbKeepQuery = b; }
298
299 bool IsKeepQuery() const { return mbKeepQuery; }
300
301 void SetUpdateRefs( bool b ) { mbUpdateRefs = b; }
302
303 bool IsUpdateRefs() const { return mbUpdateRefs; }
304
305 /**
306 * Call this only during normal sorting, not from reordering.
307 */
308 std::unique_ptr<ScSortInfo[]> const & GetFirstArray() const
309 {
310 return mvppInfo[0];
311 }
312
313 /**
314 * Call this only during normal sorting, not from reordering.
315 */
316 ScSortInfo & Get( sal_uInt16 nSort, SCCOLROW nInd )
317 {
318 return mvppInfo[nSort][ nInd - nStart ];
319 }
320
321 /**
322 * Call this only during normal sorting, not from reordering.
323 */
324 void Swap( SCCOLROW nInd1, SCCOLROW nInd2 )
325 {
326 if (nInd1 == nInd2) // avoid self-move-assign
327 return;
328 SCSIZE n1 = static_cast<SCSIZE>(nInd1 - nStart);
329 SCSIZE n2 = static_cast<SCSIZE>(nInd2 - nStart);
330 for ( sal_uInt16 nSort = 0; nSort < static_cast<sal_uInt16>(mvppInfo.size()); nSort++ )
331 {
332 auto & ppInfo = mvppInfo[nSort];
333 std::swap(ppInfo[n1], ppInfo[n2]);
334 }
335
336 std::swap(maOrderIndices[n1], maOrderIndices[n2]);
337
338 if (mpRows)
339 {
340 // Swap rows in data table.
341 RowsType& rRows = *mpRows;
342 std::swap(rRows[n1], rRows[n2]);
343 }
344 }
345
346 void SetOrderIndices( const std::vector<SCCOLROW>& rIndices )
347 {
348 maOrderIndices = rIndices;
349 }
350
351 /**
352 * @param rIndices indices are actual row positions on the sheet, not an
353 * offset from the top row.
354 */
355 void ReorderByRow( const std::vector<SCCOLROW>& rIndices )
356 {
357 if (!mpRows)
358 return;
359
360 RowsType& rRows = *mpRows;
361
362 std::vector<SCCOLROW> aOrderIndices2;
363 aOrderIndices2.reserve(rIndices.size());
364
365 RowsType aRows2;
366 aRows2.reserve(rRows.size());
367
368 for (const auto& rIndex : rIndices)
369 {
370 size_t nPos = rIndex - nStart; // switch to an offset to top row.
371 aRows2.push_back(rRows[nPos]);
372 aOrderIndices2.push_back(maOrderIndices[nPos]);
373 }
374
375 rRows.swap(aRows2);
376 maOrderIndices.swap(aOrderIndices2);
377 }
378
379 sal_uInt16 GetUsedSorts() const { return mvppInfo.size(); }
380
381 SCCOLROW GetStart() const { return nStart; }
382 SCCOLROW GetLast() const { return mnLastIndex; }
383
384 const std::vector<SCCOLROW>& GetOrderIndices() const { return maOrderIndices; }
385
386 RowsType& InitDataRows( size_t nRowSize, size_t nColSize )
387 {
388 mpRows.reset(new RowsType);
389 mpRows->resize(nRowSize, Row(nColSize));
390 return *mpRows;
391 }
392
393 RowsType* GetDataRows()
394 {
395 return mpRows.get();
396 }
397 };
398
399 namespace {
400
401 void initDataRows(
402 ScSortInfoArray& rArray, ScTable& rTab, ScColContainer& rCols,
403 SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
404 bool bPattern, bool bHiddenFiltered )
405 {
406 // Fill row-wise data table.
407 ScSortInfoArray::RowsType& rRows = rArray.InitDataRows(nRow2-nRow1+1, nCol2-nCol1+1);
408
409 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
410 {
411 ScColumn& rCol = rCols[nCol];
412
413 // Skip reordering of cell formats if the whole span is on the same pattern entry.
414 bool bUniformPattern = rCol.GetPatternCount(nRow1, nRow2) < 2u;
415
416 sc::ColumnBlockConstPosition aBlockPos;
417 rCol.InitBlockPosition(aBlockPos);
418 std::map<SCROW, std::vector<SdrObject*>> aRowDrawObjects;
419 ScDrawLayer* pDrawLayer = rTab.GetDoc().GetDrawLayer();
420 if (pDrawLayer)
421 aRowDrawObjects = pDrawLayer->GetObjectsAnchoredToRange(rTab.GetTab(), nCol, nRow1, nRow2);
422
423 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
424 {
425 ScSortInfoArray::Row& rRow = rRows[nRow-nRow1];
426 ScSortInfoArray::Cell& rCell = rRow.maCells[nCol-nCol1];
427 rCell.maCell = rCol.GetCellValue(aBlockPos, nRow);
428 rCell.mpAttr = rCol.GetCellTextAttr(aBlockPos, nRow);
429 rCell.mpNote = rCol.GetCellNote(aBlockPos, nRow);
430 if (pDrawLayer)
431 rCell.maDrawObjects = aRowDrawObjects[nRow];
432
433 if (!bUniformPattern && bPattern)
434 rCell.mpPattern = rCol.GetPattern(nRow);
435 }
436 }
437
438 if (bHiddenFiltered)
439 {
440 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
441 {
442 ScSortInfoArray::Row& rRow = rRows[nRow-nRow1];
443 rRow.mbHidden = rTab.RowHidden(nRow);
444 rRow.mbFiltered = rTab.RowFiltered(nRow);
445 }
446 }
447 }
448
449 }
450
451 std::unique_ptr<ScSortInfoArray> ScTable::CreateSortInfoArray( const sc::ReorderParam& rParam )
452 {
453 std::unique_ptr<ScSortInfoArray> pArray;
454
455 if (rParam.mbByRow)
456 {
457 // Create a sort info array with just the data table.
458 SCROW nRow1 = rParam.maSortRange.aStart.Row();
459 SCROW nRow2 = rParam.maSortRange.aEnd.Row();
460 SCCOL nCol1 = rParam.maSortRange.aStart.Col();
461 SCCOL nCol2 = rParam.maSortRange.aEnd.Col();
462
463 pArray.reset(new ScSortInfoArray(0, nRow1, nRow2));
464 pArray->SetKeepQuery(rParam.mbHiddenFiltered);
465 pArray->SetUpdateRefs(rParam.mbUpdateRefs);
466
467 initDataRows(
468 *pArray, *this, aCol, nCol1, nRow1, nCol2, nRow2,
469 rParam.mbPattern, rParam.mbHiddenFiltered);
470 }
471 else
472 {
473 SCCOLROW nCol1 = rParam.maSortRange.aStart.Col();
474 SCCOLROW nCol2 = rParam.maSortRange.aEnd.Col();
475
476 pArray.reset(new ScSortInfoArray(0, nCol1, nCol2));
477 pArray->SetKeepQuery(rParam.mbHiddenFiltered);
478 pArray->SetUpdateRefs(rParam.mbUpdateRefs);
479 }
480
481 return pArray;
482 }
483
484 std::unique_ptr<ScSortInfoArray> ScTable::CreateSortInfoArray(
485 const ScSortParam& rSortParam, SCCOLROW nInd1, SCCOLROW nInd2,
486 bool bKeepQuery, bool bUpdateRefs )
487 {
488 sal_uInt16 nUsedSorts = 1;
489 while ( nUsedSorts < rSortParam.GetSortKeyCount() && rSortParam.maKeyState[nUsedSorts].bDoSort )
490 nUsedSorts++;
491 std::unique_ptr<ScSortInfoArray> pArray(new ScSortInfoArray( nUsedSorts, nInd1, nInd2 ));
492 pArray->SetKeepQuery(bKeepQuery);
493 pArray->SetUpdateRefs(bUpdateRefs);
494
495 if ( rSortParam.bByRow )
496 {
497 for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
498 {
499 SCCOL nCol = static_cast<SCCOL>(rSortParam.maKeyState[nSort].nField);
500 ScColumn* pCol = &aCol[nCol];
501 sc::ColumnBlockConstPosition aBlockPos;
502 pCol->InitBlockPosition(aBlockPos);
503 for ( SCROW nRow = nInd1; nRow <= nInd2; nRow++ )
504 {
505 ScSortInfo & rInfo = pArray->Get( nSort, nRow );
506 rInfo.maCell = pCol->GetCellValue(aBlockPos, nRow);
507 rInfo.nOrg = nRow;
508 }
509 }
510
511 initDataRows(
512 *pArray, *this, aCol, rSortParam.nCol1, nInd1, rSortParam.nCol2, nInd2,
513 rSortParam.bIncludePattern, bKeepQuery);
514 }
515 else
516 {
517 for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
518 {
519 SCROW nRow = rSortParam.maKeyState[nSort].nField;
520 for ( SCCOL nCol = static_cast<SCCOL>(nInd1);
521 nCol <= static_cast<SCCOL>(nInd2); nCol++ )
522 {
523 ScSortInfo & rInfo = pArray->Get( nSort, nCol );
524 rInfo.maCell = GetCellValue(nCol, nRow);
525 rInfo.nOrg = nCol;
526 }
527 }
528 }
529 return pArray;
530 }
531
532 namespace {
533
534 struct SortedColumn
535 {
536 typedef mdds::flat_segment_tree<SCROW, const ScPatternAttr*> PatRangeType;
537
538 sc::CellStoreType maCells;
539 sc::CellTextAttrStoreType maCellTextAttrs;
540 sc::BroadcasterStoreType maBroadcasters;
541 sc::CellNoteStoreType maCellNotes;
542 std::vector<std::vector<SdrObject*>> maCellDrawObjects;
543
544 PatRangeType maPatterns;
545 PatRangeType::const_iterator miPatternPos;
546
547 SortedColumn(const SortedColumn&) = delete;
548 const SortedColumn operator=(const SortedColumn&) = delete;
549
550 explicit SortedColumn( size_t nTopEmptyRows, const ScSheetLimits& rSheetLimits ) :
551 maCells(nTopEmptyRows),
552 maCellTextAttrs(nTopEmptyRows),
553 maBroadcasters(nTopEmptyRows),
554 maCellNotes(nTopEmptyRows),
555 maCellDrawObjects(),
556 maPatterns(0, rSheetLimits.GetMaxRowCount(), nullptr),
557 miPatternPos(maPatterns.begin()) {}
558
559 void setPattern( SCROW nRow, const ScPatternAttr* pPat )
560 {
561 miPatternPos = maPatterns.insert(miPatternPos, nRow, nRow+1, pPat).first;
562 }
563 };
564
565 struct SortedRowFlags
566 {
567 typedef mdds::flat_segment_tree<SCROW,bool> FlagsType;
568
569 FlagsType maRowsHidden;
570 FlagsType maRowsFiltered;
571 FlagsType::const_iterator miPosHidden;
572 FlagsType::const_iterator miPosFiltered;
573
574 SortedRowFlags(const ScSheetLimits& rSheetLimits) :
575 maRowsHidden(0, rSheetLimits.GetMaxRowCount(), false),
576 maRowsFiltered(0, rSheetLimits.GetMaxRowCount(), false),
577 miPosHidden(maRowsHidden.begin()),
578 miPosFiltered(maRowsFiltered.begin()) {}
579
580 void setRowHidden( SCROW nRow, bool b )
581 {
582 miPosHidden = maRowsHidden.insert(miPosHidden, nRow, nRow+1, b).first;
583 }
584
585 void setRowFiltered( SCROW nRow, bool b )
586 {
587 miPosFiltered = maRowsFiltered.insert(miPosFiltered, nRow, nRow+1, b).first;
588 }
589
590 void swap( SortedRowFlags& r )
591 {
592 maRowsHidden.swap(r.maRowsHidden);
593 maRowsFiltered.swap(r.maRowsFiltered);
594
595 // Just reset the position hints.
596 miPosHidden = maRowsHidden.begin();
597 miPosFiltered = maRowsFiltered.begin();
598 }
599 };
600
601 struct PatternSpan
602 {
603 SCROW mnRow1;
604 SCROW mnRow2;
605 const ScPatternAttr* mpPattern;
606
607 PatternSpan( SCROW nRow1, SCROW nRow2, const ScPatternAttr* pPat ) :
608 mnRow1(nRow1), mnRow2(nRow2), mpPattern(pPat) {}
609 };
610
611 }
612
613 bool ScTable::IsSortCollatorGlobal() const
614 {
615 return pSortCollator == ScGlobal::GetCollator() ||
616 pSortCollator == ScGlobal::GetCaseCollator();
617 }
618
619 void ScTable::InitSortCollator( const ScSortParam& rPar )
620 {
621 if ( !rPar.aCollatorLocale.Language.isEmpty() )
622 {
623 if ( !pSortCollator || IsSortCollatorGlobal() )
624 pSortCollator = new CollatorWrapper( comphelper::getProcessComponentContext() );
625 pSortCollator->loadCollatorAlgorithm( rPar.aCollatorAlgorithm,
626 rPar.aCollatorLocale, (rPar.bCaseSens ? 0 : SC_COLLATOR_IGNORES) );
627 }
628 else
629 { // SYSTEM
630 DestroySortCollator();
631 pSortCollator = (rPar.bCaseSens ? ScGlobal::GetCaseCollator() :
632 ScGlobal::GetCollator());
633 }
634 }
635
636 void ScTable::DestroySortCollator()
637 {
638 if ( pSortCollator )
639 {
640 if ( !IsSortCollatorGlobal() )
641 delete pSortCollator;
642 pSortCollator = nullptr;
643 }
644 }
645
646 namespace {
647
648 template<typename Hint, typename ReorderMap, typename Index>
649 class ReorderNotifier
650 {
651 Hint maHint;
652 public:
653 ReorderNotifier( const ReorderMap& rMap, SCTAB nTab, Index nPos1, Index nPos2 ) :
654 maHint(rMap, nTab, nPos1, nPos2) {}
655
656 void operator() ( SvtListener* p )
657 {
658 p->Notify(maHint);
659 }
660 };
661
662 class FormulaGroupPosCollector
663 {
664 sc::RefQueryFormulaGroup& mrQuery;
665
666 public:
667 explicit FormulaGroupPosCollector( sc::RefQueryFormulaGroup& rQuery ) : mrQuery(rQuery) {}
668
669 void operator() ( const SvtListener* p )
670 {
671 p->Query(mrQuery);
672 }
673 };
674
675 void fillSortedColumnArray(
676 std::vector<std::unique_ptr<SortedColumn>>& rSortedCols,
677 SortedRowFlags& rRowFlags,
678 std::vector<SvtListener*>& rCellListeners,
679 ScSortInfoArray* pArray, SCTAB nTab, SCCOL nCol1, SCCOL nCol2, ScProgress* pProgress, const ScTable* pTable )
680 {
681 SCROW nRow1 = pArray->GetStart();
682 ScSortInfoArray::RowsType* pRows = pArray->GetDataRows();
683 std::vector<SCCOLROW> aOrderIndices = pArray->GetOrderIndices();
684
685 size_t nColCount = nCol2 - nCol1 + 1;
686 std::vector<std::unique_ptr<SortedColumn>> aSortedCols; // storage for copied cells.
687 SortedRowFlags aRowFlags(pTable->GetDoc().GetSheetLimits());
688 aSortedCols.reserve(nColCount);
689 for (size_t i = 0; i < nColCount; ++i)
690 {
691 // In the sorted column container, element positions and row
692 // positions must match, else formula cells may mis-behave during
693 // grouping.
694 aSortedCols.push_back(std::make_unique<SortedColumn>(nRow1, pTable->GetDoc().GetSheetLimits()));
695 }
696
697 for (size_t i = 0; i < pRows->size(); ++i)
698 {
699 ScSortInfoArray::Row& rRow = (*pRows)[i];
700 for (size_t j = 0; j < rRow.maCells.size(); ++j)
701 {
702 ScAddress aCellPos(nCol1 + j, nRow1 + i, nTab);
703
704 ScSortInfoArray::Cell& rCell = rRow.maCells[j];
705
706 sc::CellStoreType& rCellStore = aSortedCols.at(j)->maCells;
707 switch (rCell.maCell.meType)
708 {
709 case CELLTYPE_STRING:
710 assert(rCell.mpAttr);
711 rCellStore.push_back(*rCell.maCell.mpString);
712 break;
713 case CELLTYPE_VALUE:
714 assert(rCell.mpAttr);
715 rCellStore.push_back(rCell.maCell.mfValue);
716 break;
717 case CELLTYPE_EDIT:
718 assert(rCell.mpAttr);
719 rCellStore.push_back(rCell.maCell.mpEditText->Clone().release());
720 break;
721 case CELLTYPE_FORMULA:
722 {
723 assert(rCell.mpAttr);
724 ScAddress aOldPos = rCell.maCell.mpFormula->aPos;
725
726 ScFormulaCell* pNew = rCell.maCell.mpFormula->Clone( aCellPos );
727 if (pArray->IsUpdateRefs())
728 {
729 pNew->CopyAllBroadcasters(*rCell.maCell.mpFormula);
730 pNew->GetCode()->AdjustReferenceOnMovedOrigin(aOldPos, aCellPos);
731 }
732 else
733 {
734 pNew->GetCode()->AdjustReferenceOnMovedOriginIfOtherSheet(aOldPos, aCellPos);
735 }
736
737 if (!rCellListeners.empty())
738 {
739 // Original source cells will be deleted during
740 // sc::CellStoreType::transfer(), SvtListener is a base
741 // class, so we need to replace it.
742 auto it( ::std::find( rCellListeners.begin(), rCellListeners.end(), rCell.maCell.mpFormula));
743 if (it != rCellListeners.end())
744 *it = pNew;
745 }
746
747 rCellStore.push_back(pNew);
748 }
749 break;
750 default:
751 //assert(!rCell.mpAttr);
752 // This assert doesn't hold, for example
753 // CopyCellsFromClipHandler may omit copying cells during
754 // PasteSpecial for which CopyTextAttrsFromClipHandler
755 // still copies a CellTextAttr. So if that really is not
756 // expected then fix it there.
757 rCellStore.push_back_empty();
758 }
759
760 sc::CellTextAttrStoreType& rAttrStore = aSortedCols.at(j)->maCellTextAttrs;
761 if (rCell.mpAttr)
762 rAttrStore.push_back(*rCell.mpAttr);
763 else
764 rAttrStore.push_back_empty();
765
766 if (pArray->IsUpdateRefs())
767 {
768 // At this point each broadcaster instance is managed by 2
769 // containers. We will release those in the original storage
770 // below before transferring them to the document.
771 const SvtBroadcaster* pBroadcaster = pTable->GetBroadcaster( nCol1 + j, aOrderIndices[i]);
772 sc::BroadcasterStoreType& rBCStore = aSortedCols.at(j)->maBroadcasters;
773 if (pBroadcaster)
774 // A const pointer would be implicitly converted to a bool type.
775 rBCStore.push_back(const_cast<SvtBroadcaster*>(pBroadcaster));
776 else
777 rBCStore.push_back_empty();
778 }
779
780 // The same with cell note instances ...
781 sc::CellNoteStoreType& rNoteStore = aSortedCols.at(j)->maCellNotes;
782 if (rCell.mpNote)
783 rNoteStore.push_back(const_cast<ScPostIt*>(rCell.mpNote));
784 else
785 rNoteStore.push_back_empty();
786
787 // Add cell anchored images
788 aSortedCols.at(j)->maCellDrawObjects.push_back(rCell.maDrawObjects);
789
790 if (rCell.mpPattern)
791 aSortedCols.at(j)->setPattern(aCellPos.Row(), rCell.mpPattern);
792 }
793
794 if (pArray->IsKeepQuery())
795 {
796 // Hidden and filtered flags are first converted to segments.
797 SCROW nRow = nRow1 + i;
798 aRowFlags.setRowHidden(nRow, rRow.mbHidden);
799 aRowFlags.setRowFiltered(nRow, rRow.mbFiltered);
800 }
801
802 if (pProgress)
803 pProgress->SetStateOnPercent(i);
804 }
805
806 rSortedCols.swap(aSortedCols);
807 rRowFlags.swap(aRowFlags);
808 }
809
810 void expandRowRange( ScRange& rRange, SCROW nTop, SCROW nBottom )
811 {
812 if (nTop < rRange.aStart.Row())
813 rRange.aStart.SetRow(nTop);
814
815 if (rRange.aEnd.Row() < nBottom)
816 rRange.aEnd.SetRow(nBottom);
817 }
818
819 class FormulaCellCollectAction : public sc::ColumnSpanSet::ColumnAction
820 {
821 std::vector<ScFormulaCell*>& mrCells;
822 ScColumn* mpCol;
823
824 public:
825 explicit FormulaCellCollectAction( std::vector<ScFormulaCell*>& rCells ) :
826 mrCells(rCells), mpCol(nullptr) {}
827
828 virtual void startColumn( ScColumn* pCol ) override
829 {
830 mpCol = pCol;
831 }
832
833 virtual void execute( SCROW nRow1, SCROW nRow2, bool bVal ) override
834 {
835 assert(mpCol);
836
837 if (!bVal)
838 return;
839
840 mpCol->CollectFormulaCells(mrCells, nRow1, nRow2);
841 }
842 };
843
844 class ListenerStartAction : public sc::ColumnSpanSet::ColumnAction
845 {
846 ScColumn* mpCol;
847
848 std::shared_ptr<sc::ColumnBlockPositionSet> mpPosSet;
849 sc::StartListeningContext maStartCxt;
850 sc::EndListeningContext maEndCxt;
851
852 public:
853 explicit ListenerStartAction( ScDocument& rDoc ) :
854 mpCol(nullptr),
855 mpPosSet(std::make_shared<sc::ColumnBlockPositionSet>(rDoc)),
856 maStartCxt(rDoc, mpPosSet),
857 maEndCxt(rDoc, mpPosSet) {}
858
859 virtual void startColumn( ScColumn* pCol ) override
860 {
861 mpCol = pCol;
862 }
863
864 virtual void execute( SCROW nRow1, SCROW nRow2, bool bVal ) override
865 {
866 assert(mpCol);
867
868 if (!bVal)
869 return;
870
871 mpCol->StartListeningFormulaCells(maStartCxt, maEndCxt, nRow1, nRow2);
872 }
873 };
874
875 }
876
877 void ScTable::SortReorderByColumn(
878 const ScSortInfoArray* pArray, SCROW nRow1, SCROW nRow2, bool bPattern, ScProgress* pProgress )
879 {
880 SCCOLROW nStart = pArray->GetStart();
881 SCCOLROW nLast = pArray->GetLast();
882
883 std::vector<SCCOLROW> aIndices = pArray->GetOrderIndices();
884 size_t nCount = aIndices.size();
885
886 // Cut formula grouping at row and reference boundaries before the reordering.
887 ScRange aSortRange(nStart, nRow1, nTab, nLast, nRow2, nTab);
888 for (SCCOL nCol = nStart; nCol <= static_cast<SCCOL>(nLast); ++nCol)
889 aCol[nCol].SplitFormulaGroupByRelativeRef(aSortRange);
890
891 // Collect all listeners of cell broadcasters of sorted range.
892 std::vector<SvtListener*> aCellListeners;
893
894 if (!pArray->IsUpdateRefs())
895 {
896 // Collect listeners of cell broadcasters.
897 for (SCCOL nCol = nStart; nCol <= static_cast<SCCOL>(nLast); ++nCol)
898 aCol[nCol].CollectListeners(aCellListeners, nRow1, nRow2);
899
900 // Remove any duplicate listener entries. We must ensure that we
901 // notify each unique listener only once.
902 std::sort(aCellListeners.begin(), aCellListeners.end());
903 aCellListeners.erase(std::unique(aCellListeners.begin(), aCellListeners.end()), aCellListeners.end());
904
905 // Notify the cells' listeners to stop listening.
906 /* TODO: for performance this could be enhanced to stop and later
907 * restart only listening to within the reordered range and keep
908 * listening to everything outside untouched. */
909 sc::RefStopListeningHint aHint;
910 for (auto const & l : aCellListeners)
911 l->Notify(aHint);
912 }
913
914 // table to keep track of column index to position in the index table.
915 std::vector<SCCOLROW> aPosTable(nCount);
916 for (size_t i = 0; i < nCount; ++i)
917 aPosTable[aIndices[i]-nStart] = i;
918
919 SCCOLROW nDest = nStart;
920 for (size_t i = 0; i < nCount; ++i, ++nDest)
921 {
922 SCCOLROW nSrc = aIndices[i];
923 if (nDest != nSrc)
924 {
925 aCol[nDest].Swap(aCol[nSrc], nRow1, nRow2, bPattern);
926
927 // Update the position of the index that was originally equal to nDest.
928 size_t nPos = aPosTable[nDest-nStart];
929 aIndices[nPos] = nSrc;
930 aPosTable[nSrc-nStart] = nPos;
931 }
932
933 if (pProgress)
934 pProgress->SetStateOnPercent(i);
935 }
936
937 // Reset formula cell positions which became out-of-sync after column reordering.
938 bool bUpdateRefs = pArray->IsUpdateRefs();
939 for (SCCOL nCol = nStart; nCol <= static_cast<SCCOL>(nLast); ++nCol)
940 aCol[nCol].ResetFormulaCellPositions(nRow1, nRow2, bUpdateRefs);
941
942 if (pArray->IsUpdateRefs())
943 {
944 // Set up column reorder map (for later broadcasting of reference updates).
945 sc::ColRowReorderMapType aColMap;
946 const std::vector<SCCOLROW>& rOldIndices = pArray->GetOrderIndices();
947 for (size_t i = 0, n = rOldIndices.size(); i < n; ++i)
948 {
949 SCCOL nNew = i + nStart;
950 SCCOL nOld = rOldIndices[i];
951 aColMap.emplace(nOld, nNew);
952 }
953
954 // Collect all listeners within sorted range ahead of time.
955 std::vector<SvtListener*> aListeners;
956
957 for (SCCOL nCol = nStart; nCol <= static_cast<SCCOL>(nLast); ++nCol)
958 aCol[nCol].CollectListeners(aListeners, nRow1, nRow2);
959
960 // Get all area listeners that listen on one column within the range
961 // and end their listening.
962 ScRange aMoveRange( nStart, nRow1, nTab, nLast, nRow2, nTab);
963 std::vector<sc::AreaListener> aAreaListeners = rDocument.GetBASM()->GetAllListeners(
964 aMoveRange, sc::AreaOverlapType::OneColumnInside);
965 {
966 for (auto& rAreaListener : aAreaListeners)
967 {
968 rDocument.EndListeningArea(rAreaListener.maArea, rAreaListener.mbGroupListening, rAreaListener.mpListener);
969 aListeners.push_back( rAreaListener.mpListener);
970 }
971 }
972
973 // Remove any duplicate listener entries and notify all listeners
974 // afterward. We must ensure that we notify each unique listener only
975 // once.
976 std::sort(aListeners.begin(), aListeners.end());
977 aListeners.erase(std::unique(aListeners.begin(), aListeners.end()), aListeners.end());
978 ReorderNotifier<sc::RefColReorderHint, sc::ColRowReorderMapType, SCCOL> aFunc(aColMap, nTab, nRow1, nRow2);
979 std::for_each(aListeners.begin(), aListeners.end(), aFunc);
980
981 // Re-start area listeners on the reordered columns.
982 {
983 for (auto& rAreaListener : aAreaListeners)
984 {
985 ScRange aNewRange = rAreaListener.maArea;
986 sc::ColRowReorderMapType::const_iterator itCol = aColMap.find( aNewRange.aStart.Col());
987 if (itCol != aColMap.end())
988 {
989 aNewRange.aStart.SetCol( itCol->second);
990 aNewRange.aEnd.SetCol( itCol->second);
991 }
992 rDocument.StartListeningArea(aNewRange, rAreaListener.mbGroupListening, rAreaListener.mpListener);
993 }
994 }
995 }
996 else // !(pArray->IsUpdateRefs())
997 {
998 // Notify the cells' listeners to (re-)start listening.
999 sc::RefStartListeningHint aHint;
1000 for (auto const & l : aCellListeners)
1001 l->Notify(aHint);
1002 }
1003
1004 // Re-join formulas at row boundaries now that all the references have
1005 // been adjusted for column reordering.
1006 for (SCCOL nCol = nStart; nCol <= static_cast<SCCOL>(nLast); ++nCol)
1007 {
1008 sc::CellStoreType& rCells = aCol[nCol].maCells;
1009 sc::CellStoreType::position_type aPos = rCells.position(nRow1);
1010 sc::SharedFormulaUtil::joinFormulaCellAbove(aPos);
1011 if (nRow2 < rDocument.MaxRow())
1012 {
1013 aPos = rCells.position(aPos.first, nRow2+1);
1014 sc::SharedFormulaUtil::joinFormulaCellAbove(aPos);
1015 }
1016 }
1017 }
1018
1019 void ScTable::SortReorderByRow(
1020 ScSortInfoArray* pArray, SCCOL nCol1, SCCOL nCol2, ScProgress* pProgress )
1021 {
1022 assert(!pArray->IsUpdateRefs());
1023
1024 if (nCol2 < nCol1)
1025 return;
1026
1027 SCROW nRow1 = pArray->GetStart();
1028 SCROW nRow2 = pArray->GetLast();
1029
1030 // Collect all listeners of cell broadcasters of sorted range.
1031 std::vector<SvtListener*> aCellListeners;
1032
1033 // When the update ref mode is disabled, we need to detach all formula
1034 // cells in the sorted range before reordering, and re-start them
1035 // afterward.
1036 {
1037 sc::EndListeningContext aCxt(rDocument);
1038 DetachFormulaCells(aCxt, nCol1, nRow1, nCol2, nRow2);
1039 }
1040
1041 // Collect listeners of cell broadcasters.
1042 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
1043 aCol[nCol].CollectListeners(aCellListeners, nRow1, nRow2);
1044
1045 // Remove any duplicate listener entries. We must ensure that we notify
1046 // each unique listener only once.
1047 std::sort(aCellListeners.begin(), aCellListeners.end());
1048 aCellListeners.erase(std::unique(aCellListeners.begin(), aCellListeners.end()), aCellListeners.end());
1049
1050 // Notify the cells' listeners to stop listening.
1051 /* TODO: for performance this could be enhanced to stop and later
1052 * restart only listening to within the reordered range and keep
1053 * listening to everything outside untouched. */
1054 {
1055 sc::RefStopListeningHint aHint;
1056 for (auto const & l : aCellListeners)
1057 l->Notify(aHint);
1058 }
1059
1060 // Split formula groups at the sort range boundaries (if applicable).
1061 std::vector<SCROW> aRowBounds;
1062 aRowBounds.reserve(2);
1063 aRowBounds.push_back(nRow1);
1064 aRowBounds.push_back(nRow2+1);
1065 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
1066 SplitFormulaGroups(nCol, aRowBounds);
1067
1068 // Cells in the data rows only reference values in the document. Make
1069 // a copy before updating the document.
1070 std::vector<std::unique_ptr<SortedColumn>> aSortedCols; // storage for copied cells.
1071 SortedRowFlags aRowFlags(GetDoc().GetSheetLimits());
1072 fillSortedColumnArray(aSortedCols, aRowFlags, aCellListeners, pArray, nTab, nCol1, nCol2, pProgress, this);
1073
1074 for (size_t i = 0, n = aSortedCols.size(); i < n; ++i)
1075 {
1076 SCCOL nThisCol = i + nCol1;
1077
1078 {
1079 sc::CellStoreType& rDest = aCol[nThisCol].maCells;
1080 sc::CellStoreType& rSrc = aSortedCols[i]->maCells;
1081 rSrc.transfer(nRow1, nRow2, rDest, nRow1);
1082 }
1083
1084 {
1085 sc::CellTextAttrStoreType& rDest = aCol[nThisCol].maCellTextAttrs;
1086 sc::CellTextAttrStoreType& rSrc = aSortedCols[i]->maCellTextAttrs;
1087 rSrc.transfer(nRow1, nRow2, rDest, nRow1);
1088 }
1089
1090 {
1091 sc::CellNoteStoreType& rSrc = aSortedCols[i]->maCellNotes;
1092 sc::CellNoteStoreType& rDest = aCol[nThisCol].maCellNotes;
1093
1094 // Do the same as broadcaster storage transfer (to prevent double deletion).
1095 rDest.release_range(nRow1, nRow2);
1096 rSrc.transfer(nRow1, nRow2, rDest, nRow1);
1097 aCol[nThisCol].UpdateNoteCaptions(nRow1, nRow2);
1098 }
1099
1100 // Update draw object positions
1101 aCol[nThisCol].UpdateDrawObjects(aSortedCols[i]->maCellDrawObjects, nRow1, nRow2);
1102
1103 {
1104 // Get all row spans where the pattern is not NULL.
1105 std::vector<PatternSpan> aSpans =
1106 sc::toSpanArrayWithValue<SCROW,const ScPatternAttr*,PatternSpan>(
1107 aSortedCols[i]->maPatterns);
1108
1109 for (const auto& rSpan : aSpans)
1110 {
1111 assert(rSpan.mpPattern); // should never be NULL.
1112 rDocument.GetPool()->Put(*rSpan.mpPattern);
1113 }
1114
1115 for (const auto& rSpan : aSpans)
1116 {
1117 aCol[nThisCol].SetPatternArea(rSpan.mnRow1, rSpan.mnRow2, *rSpan.mpPattern);
1118 rDocument.GetPool()->Remove(*rSpan.mpPattern);
1119 }
1120 }
1121
1122 aCol[nThisCol].CellStorageModified();
1123 }
1124
1125 if (pArray->IsKeepQuery())
1126 {
1127 aRowFlags.maRowsHidden.build_tree();
1128 aRowFlags.maRowsFiltered.build_tree();
1129
1130 // Remove all flags in the range first.
1131 SetRowHidden(nRow1, nRow2, false);
1132 SetRowFiltered(nRow1, nRow2, false);
1133
1134 std::vector<sc::RowSpan> aSpans =
1135 sc::toSpanArray<SCROW,sc::RowSpan>(aRowFlags.maRowsHidden, nRow1);
1136
1137 for (const auto& rSpan : aSpans)
1138 SetRowHidden(rSpan.mnRow1, rSpan.mnRow2, true);
1139
1140 aSpans = sc::toSpanArray<SCROW,sc::RowSpan>(aRowFlags.maRowsFiltered, nRow1);
1141
1142 for (const auto& rSpan : aSpans)
1143 SetRowFiltered(rSpan.mnRow1, rSpan.mnRow2, true);
1144 }
1145
1146 // Notify the cells' listeners to (re-)start listening.
1147 {
1148 sc::RefStartListeningHint aHint;
1149 for (auto const & l : aCellListeners)
1150 l->Notify(aHint);
1151 }
1152
1153 // Re-group columns in the sorted range too.
1154 for (SCCOL i = nCol1; i <= nCol2; ++i)
1155 aCol[i].RegroupFormulaCells();
1156
1157 {
1158 sc::StartListeningContext aCxt(rDocument);
1159 AttachFormulaCells(aCxt, nCol1, nRow1, nCol2, nRow2);
1160 }
1161 }
1162
1163 void ScTable::SortReorderByRowRefUpdate(
1164 ScSortInfoArray* pArray, SCCOL nCol1, SCCOL nCol2, ScProgress* pProgress )
1165 {
1166 assert(pArray->IsUpdateRefs());
1167
1168 if (nCol2 < nCol1)
1169 return;
1170
1171 SCROW nRow1 = pArray->GetStart();
1172 SCROW nRow2 = pArray->GetLast();
1173
1174 ScRange aMoveRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab);
1175 sc::ColumnSpanSet aGrpListenerRanges;
1176
1177 {
1178 // Get the range of formula group listeners within sorted range (if any).
1179 sc::QueryRange aQuery;
1180
1181 ScBroadcastAreaSlotMachine* pBASM = rDocument.GetBASM();
1182 std::vector<sc::AreaListener> aGrpListeners =
1183 pBASM->GetAllListeners(
1184 aMoveRange, sc::AreaOverlapType::InsideOrOverlap, sc::ListenerGroupType::Group);
1185
1186 {
1187 for (const auto& rGrpListener : aGrpListeners)
1188 {
1189 assert(rGrpListener.mbGroupListening);
1190 SvtListener* pGrpLis = rGrpListener.mpListener;
1191 pGrpLis->Query(aQuery);
1192 rDocument.EndListeningArea(rGrpListener.maArea, rGrpListener.mbGroupListening, pGrpLis);
1193 }
1194 }
1195
1196 ScRangeList aTmp;
1197 aQuery.swapRanges(aTmp);
1198
1199 // If the range is within the sorted range, we need to expand its rows
1200 // to the top and bottom of the sorted range, since the formula cells
1201 // could be anywhere in the sorted range after reordering.
1202 for (size_t i = 0, n = aTmp.size(); i < n; ++i)
1203 {
1204 ScRange aRange = aTmp[i];
1205 if (!aMoveRange.Intersects(aRange))
1206 {
1207 // Doesn't overlap with the sorted range at all.
1208 aGrpListenerRanges.set(GetDoc(), aRange, true);
1209 continue;
1210 }
1211
1212 if (aMoveRange.aStart.Col() <= aRange.aStart.Col() && aRange.aEnd.Col() <= aMoveRange.aEnd.Col())
1213 {
1214 // Its column range is within the column range of the sorted range.
1215 expandRowRange(aRange, aMoveRange.aStart.Row(), aMoveRange.aEnd.Row());
1216 aGrpListenerRanges.set(GetDoc(), aRange, true);
1217 continue;
1218 }
1219
1220 // It intersects with the sorted range, but its column range is
1221 // not within the column range of the sorted range. Split it into
1222 // 2 ranges.
1223 ScRange aR1 = aRange;
1224 ScRange aR2 = aRange;
1225 if (aRange.aStart.Col() < aMoveRange.aStart.Col())
1226 {
1227 // Left half is outside the sorted range while the right half is inside.
1228 aR1.aEnd.SetCol(aMoveRange.aStart.Col()-1);
1229 aR2.aStart.SetCol(aMoveRange.aStart.Col());
1230 expandRowRange(aR2, aMoveRange.aStart.Row(), aMoveRange.aEnd.Row());
1231 }
1232 else
1233 {
1234 // Left half is inside the sorted range while the right half is outside.
1235 aR1.aEnd.SetCol(aMoveRange.aEnd.Col()-1);
1236 aR2.aStart.SetCol(aMoveRange.aEnd.Col());
1237 expandRowRange(aR1, aMoveRange.aStart.Row(), aMoveRange.aEnd.Row());
1238 }
1239
1240 aGrpListenerRanges.set(GetDoc(), aR1, true);
1241 aGrpListenerRanges.set(GetDoc(), aR2, true);
1242 }
1243 }
1244
1245 // Split formula groups at the sort range boundaries (if applicable).
1246 std::vector<SCROW> aRowBounds;
1247 aRowBounds.reserve(2);
1248 aRowBounds.push_back(nRow1);
1249 aRowBounds.push_back(nRow2+1);
1250 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
1251 SplitFormulaGroups(nCol, aRowBounds);
1252
1253 // Cells in the data rows only reference values in the document. Make
1254 // a copy before updating the document.
1255 std::vector<std::unique_ptr<SortedColumn>> aSortedCols; // storage for copied cells.
1256 SortedRowFlags aRowFlags(GetDoc().GetSheetLimits());
1257 std::vector<SvtListener*> aListenersDummy;
1258 fillSortedColumnArray(aSortedCols, aRowFlags, aListenersDummy, pArray, nTab, nCol1, nCol2, pProgress, this);
1259
1260 for (size_t i = 0, n = aSortedCols.size(); i < n; ++i)
1261 {
1262 SCCOL nThisCol = i + nCol1;
1263
1264 {
1265 sc::CellStoreType& rDest = aCol[nThisCol].maCells;
1266 sc::CellStoreType& rSrc = aSortedCols[i]->maCells;
1267 rSrc.transfer(nRow1, nRow2, rDest, nRow1);
1268 }
1269
1270 {
1271 sc::CellTextAttrStoreType& rDest = aCol[nThisCol].maCellTextAttrs;
1272 sc::CellTextAttrStoreType& rSrc = aSortedCols[i]->maCellTextAttrs;
1273 rSrc.transfer(nRow1, nRow2, rDest, nRow1);
1274 }
1275
1276 {
1277 sc::BroadcasterStoreType& rSrc = aSortedCols[i]->maBroadcasters;
1278 sc::BroadcasterStoreType& rDest = aCol[nThisCol].maBroadcasters;
1279
1280 // Release current broadcasters first, to prevent them from getting deleted.
1281 rDest.release_range(nRow1, nRow2);
1282
1283 // Transfer sorted broadcaster segment to the document.
1284 rSrc.transfer(nRow1, nRow2, rDest, nRow1);
1285 }
1286
1287 {
1288 sc::CellNoteStoreType& rSrc = aSortedCols[i]->maCellNotes;
1289 sc::CellNoteStoreType& rDest = aCol[nThisCol].maCellNotes;
1290
1291 // Do the same as broadcaster storage transfer (to prevent double deletion).
1292 rDest.release_range(nRow1, nRow2);
1293 rSrc.transfer(nRow1, nRow2, rDest, nRow1);
1294 aCol[nThisCol].UpdateNoteCaptions(nRow1, nRow2);
1295 }
1296
1297 // Update draw object positions
1298 aCol[nThisCol].UpdateDrawObjects(aSortedCols[i]->maCellDrawObjects, nRow1, nRow2);
1299
1300 {
1301 // Get all row spans where the pattern is not NULL.
1302 std::vector<PatternSpan> aSpans =
1303 sc::toSpanArrayWithValue<SCROW,const ScPatternAttr*,PatternSpan>(
1304 aSortedCols[i]->maPatterns);
1305
1306 for (const auto& rSpan : aSpans)
1307 {
1308 assert(rSpan.mpPattern); // should never be NULL.
1309 rDocument.GetPool()->Put(*rSpan.mpPattern);
1310 }
1311
1312 for (const auto& rSpan : aSpans)
1313 {
1314 aCol[nThisCol].SetPatternArea(rSpan.mnRow1, rSpan.mnRow2, *rSpan.mpPattern);
1315 rDocument.GetPool()->Remove(*rSpan.mpPattern);
1316 }
1317 }
1318
1319 aCol[nThisCol].CellStorageModified();
1320 }
1321
1322 if (pArray->IsKeepQuery())
1323 {
1324 aRowFlags.maRowsHidden.build_tree();
1325 aRowFlags.maRowsFiltered.build_tree();
1326
1327 // Remove all flags in the range first.
1328 SetRowHidden(nRow1, nRow2, false);
1329 SetRowFiltered(nRow1, nRow2, false);
1330
1331 std::vector<sc::RowSpan> aSpans =
1332 sc::toSpanArray<SCROW,sc::RowSpan>(aRowFlags.maRowsHidden, nRow1);
1333
1334 for (const auto& rSpan : aSpans)
1335 SetRowHidden(rSpan.mnRow1, rSpan.mnRow2, true);
1336
1337 aSpans = sc::toSpanArray<SCROW,sc::RowSpan>(aRowFlags.maRowsFiltered, nRow1);
1338
1339 for (const auto& rSpan : aSpans)
1340 SetRowFiltered(rSpan.mnRow1, rSpan.mnRow2, true);
1341 }
1342
1343 // Set up row reorder map (for later broadcasting of reference updates).
1344 sc::ColRowReorderMapType aRowMap;
1345 const std::vector<SCCOLROW>& rOldIndices = pArray->GetOrderIndices();
1346 for (size_t i = 0, n = rOldIndices.size(); i < n; ++i)
1347 {
1348 SCROW nNew = i + nRow1;
1349 SCROW nOld = rOldIndices[i];
1350 aRowMap.emplace(nOld, nNew);
1351 }
1352
1353 // Collect all listeners within sorted range ahead of time.
1354 std::vector<SvtListener*> aListeners;
1355
1356 // Collect listeners of cell broadcasters.
1357 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
1358 aCol[nCol].CollectListeners(aListeners, nRow1, nRow2);
1359
1360 // Get all area listeners that listen on one row within the range and end
1361 // their listening.
1362 std::vector<sc::AreaListener> aAreaListeners = rDocument.GetBASM()->GetAllListeners(
1363 aMoveRange, sc::AreaOverlapType::OneRowInside);
1364 {
1365 for (auto& rAreaListener : aAreaListeners)
1366 {
1367 rDocument.EndListeningArea(rAreaListener.maArea, rAreaListener.mbGroupListening, rAreaListener.mpListener);
1368 aListeners.push_back( rAreaListener.mpListener);
1369 }
1370 }
1371
1372 {
1373 // Get all formula cells from the former group area listener ranges.
1374
1375 std::vector<ScFormulaCell*> aFCells;
1376 FormulaCellCollectAction aAction(aFCells);
1377 aGrpListenerRanges.executeColumnAction(rDocument, aAction);
1378
1379 aListeners.insert( aListeners.end(), aFCells.begin(), aFCells.end() );
1380 }
1381
1382 // Remove any duplicate listener entries. We must ensure that we notify
1383 // each unique listener only once.
1384 std::sort(aListeners.begin(), aListeners.end());
1385 aListeners.erase(std::unique(aListeners.begin(), aListeners.end()), aListeners.end());
1386
1387 // Collect positions of all shared formula cells outside the sorted range,
1388 // and make them unshared before notifying them.
1389 sc::RefQueryFormulaGroup aFormulaGroupPos;
1390 aFormulaGroupPos.setSkipRange(ScRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab));
1391
1392 std::for_each(aListeners.begin(), aListeners.end(), FormulaGroupPosCollector(aFormulaGroupPos));
1393 const sc::RefQueryFormulaGroup::TabsType& rGroupTabs = aFormulaGroupPos.getAllPositions();
1394 for (const auto& [rTab, rCols] : rGroupTabs)
1395 {
1396 for (const auto& [nCol, rCol] : rCols)
1397 {
1398 std::vector<SCROW> aBounds(rCol);
1399 rDocument.UnshareFormulaCells(rTab, nCol, aBounds);
1400 }
1401 }
1402
1403 // Notify the listeners to update their references.
1404 ReorderNotifier<sc::RefRowReorderHint, sc::ColRowReorderMapType, SCROW> aFunc(aRowMap, nTab, nCol1, nCol2);
1405 std::for_each(aListeners.begin(), aListeners.end(), aFunc);
1406
1407 // Re-group formulas in affected columns.
1408 for (const auto& [rTab, rCols] : rGroupTabs)
1409 {
1410 for (const auto& rEntry : rCols)
1411 rDocument.RegroupFormulaCells(rTab, rEntry.first);
1412 }
1413
1414 // Re-start area listeners on the reordered rows.
1415 for (const auto& rAreaListener : aAreaListeners)
1416 {
1417 ScRange aNewRange = rAreaListener.maArea;
1418 sc::ColRowReorderMapType::const_iterator itRow = aRowMap.find( aNewRange.aStart.Row());
1419 if (itRow != aRowMap.end())
1420 {
1421 aNewRange.aStart.SetRow( itRow->second);
1422 aNewRange.aEnd.SetRow( itRow->second);
1423 }
1424 rDocument.StartListeningArea(aNewRange, rAreaListener.mbGroupListening, rAreaListener.mpListener);
1425 }
1426
1427 // Re-group columns in the sorted range too.
1428 for (SCCOL i = nCol1; i <= nCol2; ++i)
1429 aCol[i].RegroupFormulaCells();
1430
1431 {
1432 // Re-start area listeners on the old group listener ranges.
1433 ListenerStartAction aAction(rDocument);
1434 aGrpListenerRanges.executeColumnAction(rDocument, aAction);
1435 }
1436 }
1437
1438 short ScTable::CompareCell(
1439 sal_uInt16 nSort,
1440 ScRefCellValue& rCell1, SCCOL nCell1Col, SCROW nCell1Row,
1441 ScRefCellValue& rCell2, SCCOL nCell2Col, SCROW nCell2Row ) const
1442 {
1443 short nRes = 0;
1444
1445 CellType eType1 = rCell1.meType, eType2 = rCell2.meType;
1446
1447 if (!rCell1.isEmpty())
1448 {
1449 if (!rCell2.isEmpty())
1450 {
1451 bool bErr1 = false;
1452 bool bStr1 = ( eType1 != CELLTYPE_VALUE );
1453 if (eType1 == CELLTYPE_FORMULA)
1454 {
1455 if (rCell1.mpFormula->GetErrCode() != FormulaError::NONE)
1456 {
1457 bErr1 = true;
1458 bStr1 = false;
1459 }
1460 else if (rCell1.mpFormula->IsValue())
1461 {
1462 bStr1 = false;
1463 }
1464 }
1465
1466 bool bErr2 = false;
1467 bool bStr2 = ( eType2 != CELLTYPE_VALUE );
1468 if (eType2 == CELLTYPE_FORMULA)
1469 {
1470 if (rCell2.mpFormula->GetErrCode() != FormulaError::NONE)
1471 {
1472 bErr2 = true;
1473 bStr2 = false;
1474 }
1475 else if (rCell2.mpFormula->IsValue())
1476 {
1477 bStr2 = false;
1478 }
1479 }
1480
1481 if ( bStr1 && bStr2 ) // only compare strings as strings!
1482 {
1483 OUString aStr1;
1484 OUString aStr2;
1485 if (eType1 == CELLTYPE_STRING)
1486 aStr1 = rCell1.mpString->getString();
1487 else
1488 GetString(nCell1Col, nCell1Row, aStr1);
1489 if (eType2 == CELLTYPE_STRING)
1490 aStr2 = rCell2.mpString->getString();
1491 else
1492 GetString(nCell2Col, nCell2Row, aStr2);
1493
1494 bool bUserDef = aSortParam.bUserDef; // custom sort order
1495 bool bNaturalSort = aSortParam.bNaturalSort; // natural sort
1496 bool bCaseSens = aSortParam.bCaseSens; // case sensitivity
1497
1498 ScUserList* pList = ScGlobal::GetUserList();
1499 if (bUserDef && pList && pList->size() > aSortParam.nUserIndex )
1500 {
1501 const ScUserListData& rData = (*pList)[aSortParam.nUserIndex];
1502
1503 if ( bNaturalSort )
1504 nRes = naturalsort::Compare( aStr1, aStr2, bCaseSens, &rData, pSortCollator );
1505 else
1506 {
1507 if ( bCaseSens )
1508 nRes = sal::static_int_cast<short>( rData.Compare(aStr1, aStr2) );
1509 else
1510 nRes = sal::static_int_cast<short>( rData.ICompare(aStr1, aStr2) );
1511 }
1512
1513 }
1514 if (!bUserDef)
1515 {
1516 if ( bNaturalSort )
1517 nRes = naturalsort::Compare( aStr1, aStr2, bCaseSens, nullptr, pSortCollator );
1518 else
1519 nRes = static_cast<short>( pSortCollator->compareString( aStr1, aStr2 ) );
1520 }
1521 }
1522 else if ( bStr1 ) // String <-> Number or Error
1523 {
1524 if (bErr2)
1525 nRes = -1; // String in front of Error
1526 else
1527 nRes = 1; // Number in front of String
1528 }
1529 else if ( bStr2 ) // Number or Error <-> String
1530 {
1531 if (bErr1)
1532 nRes = 1; // String in front of Error
1533 else
1534 nRes = -1; // Number in front of String
1535 }
1536 else if (bErr1 && bErr2)
1537 {
1538 // nothing, two Errors are equal
1539 }
1540 else if (bErr1) // Error <-> Number
1541 {
1542 nRes = 1; // Number in front of Error
1543 }
1544 else if (bErr2) // Number <-> Error
1545 {
1546 nRes = -1; // Number in front of Error
1547 }
1548 else // Mixed numbers
1549 {
1550 double nVal1 = rCell1.getValue();
1551 double nVal2 = rCell2.getValue();
1552 if (nVal1 < nVal2)
1553 nRes = -1;
1554 else if (nVal1 > nVal2)
1555 nRes = 1;
1556 }
1557 if ( !aSortParam.maKeyState[nSort].bAscending )
1558 nRes = -nRes;
1559 }
1560 else
1561 nRes = -1;
1562 }
1563 else
1564 {
1565 if (!rCell2.isEmpty())
1566 nRes = 1;
1567 else
1568 nRes = 0; // both empty
1569 }
1570 return nRes;
1571 }
1572
1573 short ScTable::Compare( ScSortInfoArray* pArray, SCCOLROW nIndex1, SCCOLROW nIndex2 ) const
1574 {
1575 short nRes;
1576 sal_uInt16 nSort = 0;
1577 do
1578 {
1579 ScSortInfo& rInfo1 = pArray->Get( nSort, nIndex1 );
1580 ScSortInfo& rInfo2 = pArray->Get( nSort, nIndex2 );
1581 if ( aSortParam.bByRow )
1582 nRes = CompareCell( nSort,
1583 rInfo1.maCell, static_cast<SCCOL>(aSortParam.maKeyState[nSort].nField), rInfo1.nOrg,
1584 rInfo2.maCell, static_cast<SCCOL>(aSortParam.maKeyState[nSort].nField), rInfo2.nOrg );
1585 else
1586 nRes = CompareCell( nSort,
1587 rInfo1.maCell, static_cast<SCCOL>(rInfo1.nOrg), aSortParam.maKeyState[nSort].nField,
1588 rInfo2.maCell, static_cast<SCCOL>(rInfo2.nOrg), aSortParam.maKeyState[nSort].nField );
1589 } while ( nRes == 0 && ++nSort < pArray->GetUsedSorts() );
1590 if( nRes == 0 )
1591 {
1592 ScSortInfo& rInfo1 = pArray->Get( 0, nIndex1 );
1593 ScSortInfo& rInfo2 = pArray->Get( 0, nIndex2 );
1594 if( rInfo1.nOrg < rInfo2.nOrg )
1595 nRes = -1;
1596 else if( rInfo1.nOrg > rInfo2.nOrg )
1597 nRes = 1;
1598 }
1599 return nRes;
1600 }
1601
1602 void ScTable::QuickSort( ScSortInfoArray* pArray, SCCOLROW nLo, SCCOLROW nHi )
1603 {
1604 if ((nHi - nLo) == 1)
1605 {
1606 if (Compare(pArray, nLo, nHi) > 0)
1607 pArray->Swap( nLo, nHi );
1608 }
1609 else
1610 {
1611 SCCOLROW ni = nLo;
1612 SCCOLROW nj = nHi;
1613 do
1614 {
1615 while ((ni <= nHi) && (Compare(pArray, ni, nLo)) < 0)
1616 ni++;
1617 while ((nj >= nLo) && (Compare(pArray, nLo, nj)) < 0)
1618 nj--;
1619 if (ni <= nj)
1620 {
1621 if (ni != nj)
1622 pArray->Swap( ni, nj );
1623 ni++;
1624 nj--;
1625 }
1626 } while (ni < nj);
1627 if ((nj - nLo) < (nHi - ni))
1628 {
1629 if (nLo < nj)
1630 QuickSort(pArray, nLo, nj);
1631 if (ni < nHi)
1632 QuickSort(pArray, ni, nHi);
1633 }
1634 else
1635 {
1636 if (ni < nHi)
1637 QuickSort(pArray, ni, nHi);
1638 if (nLo < nj)
1639 QuickSort(pArray, nLo, nj);
1640 }
1641 }
1642 }
1643
1644 short ScTable::Compare(SCCOLROW nIndex1, SCCOLROW nIndex2) const
1645 {
1646 short nRes;
1647 sal_uInt16 nSort = 0;
1648 const sal_uInt32 nMaxSorts = aSortParam.GetSortKeyCount();
1649 if (aSortParam.bByRow)
1650 {
1651 do
1652 {
1653 SCCOL nCol = static_cast<SCCOL>(aSortParam.maKeyState[nSort].nField);
1654 ScRefCellValue aCell1 = aCol[nCol].GetCellValue(nIndex1);
1655 ScRefCellValue aCell2 = aCol[nCol].GetCellValue(nIndex2);
1656 nRes = CompareCell(nSort, aCell1, nCol, nIndex1, aCell2, nCol, nIndex2);
1657 } while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.maKeyState[nSort].bDoSort );
1658 }
1659 else
1660 {
1661 do
1662 {
1663 SCROW nRow = aSortParam.maKeyState[nSort].nField;
1664 ScRefCellValue aCell1 = aCol[nIndex1].GetCellValue(nRow);
1665 ScRefCellValue aCell2 = aCol[nIndex2].GetCellValue(nRow);
1666 nRes = CompareCell( nSort, aCell1, static_cast<SCCOL>(nIndex1),
1667 nRow, aCell2, static_cast<SCCOL>(nIndex2), nRow );
1668 } while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.maKeyState[nSort].bDoSort );
1669 }
1670 return nRes;
1671 }
1672
1673 bool ScTable::IsSorted( SCCOLROW nStart, SCCOLROW nEnd ) const // over aSortParam
1674 {
1675 for (SCCOLROW i=nStart; i<nEnd; i++)
1676 {
1677 if (Compare( i, i+1 ) > 0)
1678 return false;
1679 }
1680 return true;
1681 }
1682
1683 void ScTable::DecoladeRow( ScSortInfoArray* pArray, SCROW nRow1, SCROW nRow2 )
1684 {
1685 SCROW nRow;
1686 int nMax = nRow2 - nRow1;
1687 for (SCROW i = nRow1; (i + 4) <= nRow2; i += 4)
1688 {
1689 nRow = comphelper::rng::uniform_int_distribution(0, nMax-1);
1690 pArray->Swap(i, nRow1 + nRow);
1691 }
1692 }
1693
1694 void ScTable::Sort(
1695 const ScSortParam& rSortParam, bool bKeepQuery, bool bUpdateRefs,
1696 ScProgress* pProgress, sc::ReorderParam* pUndo )
1697 {
1698 InitSortCollator( rSortParam );
1699 bGlobalKeepQuery = bKeepQuery;
1700
1701 if (pUndo)
1702 {
1703 // Copy over the basic sort parameters.
1704 pUndo->mbByRow = rSortParam.bByRow;
1705 pUndo->mbPattern = rSortParam.bIncludePattern;
1706 pUndo->mbHiddenFiltered = bKeepQuery;
1707 pUndo->mbUpdateRefs = bUpdateRefs;
1708 pUndo->mbHasHeaders = rSortParam.bHasHeader;
1709 }
1710
1711 // It is assumed that the data area has already been trimmed as necessary.
1712
1713 aSortParam = rSortParam; // must be assigned before calling IsSorted()
1714 if (rSortParam.bByRow)
1715 {
1716 SCROW nLastRow = rSortParam.nRow2;
1717 SCROW nRow1 = (rSortParam.bHasHeader ? rSortParam.nRow1 + 1 : rSortParam.nRow1);
1718 if (nRow1 < nLastRow && !IsSorted(nRow1, nLastRow))
1719 {
1720 if(pProgress)
1721 pProgress->SetState( 0, nLastRow-nRow1 );
1722
1723 std::unique_ptr<ScSortInfoArray> pArray(CreateSortInfoArray(aSortParam, nRow1, nLastRow, bKeepQuery, bUpdateRefs));
1724
1725 if ( nLastRow - nRow1 > 255 )
1726 DecoladeRow(pArray.get(), nRow1, nLastRow);
1727
1728 QuickSort(pArray.get(), nRow1, nLastRow);
1729 if (pArray->IsUpdateRefs())
1730 SortReorderByRowRefUpdate(pArray.get(), aSortParam.nCol1, aSortParam.nCol2, pProgress);
1731 else
1732 SortReorderByRow(pArray.get(), aSortParam.nCol1, aSortParam.nCol2, pProgress);
1733
1734 if (pUndo)
1735 {
1736 pUndo->maSortRange = ScRange(rSortParam.nCol1, nRow1, nTab, rSortParam.nCol2, nLastRow, nTab);
1737 pUndo->maOrderIndices = pArray->GetOrderIndices();
1738 }
1739 }
1740 }
1741 else
1742 {
1743 SCCOL nLastCol = rSortParam.nCol2;
1744 SCCOL nCol1 = (rSortParam.bHasHeader ? rSortParam.nCol1 + 1 : rSortParam.nCol1);
1745 if (nCol1 < nLastCol && !IsSorted(nCol1, nLastCol))
1746 {
1747 if(pProgress)
1748 pProgress->SetState( 0, nLastCol-nCol1 );
1749
1750 std::unique_ptr<ScSortInfoArray> pArray(CreateSortInfoArray(aSortParam, nCol1, nLastCol, bKeepQuery, bUpdateRefs));
1751
1752 QuickSort(pArray.get(), nCol1, nLastCol);
1753 SortReorderByColumn(pArray.get(), aSortParam.nRow1, aSortParam.nRow2, aSortParam.bIncludePattern, pProgress);
1754
1755 if (pUndo)
1756 {
1757 pUndo->maSortRange = ScRange(nCol1, aSortParam.nRow1, nTab, nLastCol, aSortParam.nRow2, nTab);
1758 pUndo->maOrderIndices = pArray->GetOrderIndices();
1759 }
1760 }
1761 }
1762 DestroySortCollator();
1763 }
1764
1765 void ScTable::Reorder( const sc::ReorderParam& rParam )
1766 {
1767 if (rParam.maOrderIndices.empty())
1768 return;
1769
1770 std::unique_ptr<ScSortInfoArray> pArray(CreateSortInfoArray(rParam));
1771 if (!pArray)
1772 return;
1773
1774 if (rParam.mbByRow)
1775 {
1776 // Re-play sorting from the known sort indices.
1777 pArray->ReorderByRow(rParam.maOrderIndices);
1778 if (pArray->IsUpdateRefs())
1779 SortReorderByRowRefUpdate(
1780 pArray.get(), rParam.maSortRange.aStart.Col(), rParam.maSortRange.aEnd.Col(), nullptr);
1781 else
1782 SortReorderByRow(
1783 pArray.get(), rParam.maSortRange.aStart.Col(), rParam.maSortRange.aEnd.Col(), nullptr);
1784 }
1785 else
1786 {
1787 // Ordering by column is much simpler. Just set the order indices and we are done.
1788 pArray->SetOrderIndices(rParam.maOrderIndices);
1789 SortReorderByColumn(
1790 pArray.get(), rParam.maSortRange.aStart.Row(), rParam.maSortRange.aEnd.Row(),
1791 rParam.mbPattern, nullptr);
1792 }
1793 }
1794
1795 namespace {
1796
1797 class SubTotalRowFinder
1798 {
1799 const ScTable& mrTab;
1800 const ScSubTotalParam& mrParam;
1801
1802 public:
1803 SubTotalRowFinder(const ScTable& rTab, const ScSubTotalParam& rParam) :
1804 mrTab(rTab), mrParam(rParam) {}
1805
1806 bool operator() (size_t nRow, const ScFormulaCell* pCell)
1807 {
1808 if (!pCell->IsSubTotal())
1809 return false;
1810
1811 SCCOL nStartCol = mrParam.nCol1;
1812 SCCOL nEndCol = mrParam.nCol2;
1813
1814 for (SCCOL nCol : mrTab.GetColumnsRange(0, nStartCol - 1))
1815 {
1816 if (mrTab.HasData(nCol, nRow))
1817 return true;
1818 }
1819 for (SCCOL nCol : mrTab.GetColumnsRange(nEndCol + 1, mrTab.GetDoc().MaxCol()))
1820 {
1821 if (mrTab.HasData(nCol, nRow))
1822 return true;
1823 }
1824 return false;
1825 }
1826 };
1827
1828 }
1829
1830 bool ScTable::TestRemoveSubTotals( const ScSubTotalParam& rParam )
1831 {
1832 SCCOL nStartCol = rParam.nCol1;
1833 SCROW nStartRow = rParam.nRow1 + 1; // Header
1834 SCCOL nEndCol = ClampToAllocatedColumns(rParam.nCol2);
1835 SCROW nEndRow = rParam.nRow2;
1836
1837 for (SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol)
1838 {
1839 const sc::CellStoreType& rCells = aCol[nCol].maCells;
1840 SubTotalRowFinder aFunc(*this, rParam);
1841 std::pair<sc::CellStoreType::const_iterator,size_t> aPos =
1842 sc::FindFormula(rCells, nStartRow, nEndRow, aFunc);
1843 if (aPos.first != rCells.end())
1844 return true;
1845 }
1846 return false;
1847 }
1848
1849 namespace {
1850
1851 struct RemoveSubTotalsHandler
1852 {
1853 std::set<SCROW> aRemoved;
1854
1855 void operator() (size_t nRow, const ScFormulaCell* p)
1856 {
1857 if (p->IsSubTotal())
1858 aRemoved.insert(nRow);
1859 }
1860 };
1861
1862 }
1863
1864 void ScTable::RemoveSubTotals( ScSubTotalParam& rParam )
1865 {
1866 SCCOL nStartCol = rParam.nCol1;
1867 SCROW nStartRow = rParam.nRow1 + 1; // Header
1868 SCCOL nEndCol = ClampToAllocatedColumns(rParam.nCol2);
1869 SCROW nEndRow = rParam.nRow2; // will change
1870
1871 RemoveSubTotalsHandler aFunc;
1872 for (SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol)
1873 {
1874 const sc::CellStoreType& rCells = aCol[nCol].maCells;
1875 sc::ParseFormula(rCells.begin(), rCells, nStartRow, nEndRow, aFunc);
1876 }
1877
1878 auto& aRows = aFunc.aRemoved;
1879
1880 std::for_each(aRows.rbegin(), aRows.rend(), [this](const SCROW nRow) {
1881 RemoveRowBreak(nRow+1, false, true);
1882 rDocument.DeleteRow(0, nTab, rDocument.MaxCol(), nTab, nRow, 1);
1883 });
1884
1885 rParam.nRow2 -= aRows.size();
1886 }
1887
1888 // Delete hard number formats (for result formulas)
1889
1890 static void lcl_RemoveNumberFormat( ScTable* pTab, SCCOL nCol, SCROW nRow )
1891 {
1892 const ScPatternAttr* pPattern = pTab->GetPattern( nCol, nRow );
1893 if ( pPattern->GetItemSet().GetItemState( ATTR_VALUE_FORMAT, false )
1894 == SfxItemState::SET )
1895 {
1896 auto pNewPattern = std::make_unique<ScPatternAttr>( *pPattern );
1897 SfxItemSet& rSet = pNewPattern->GetItemSet();
1898 rSet.ClearItem( ATTR_VALUE_FORMAT );
1899 rSet.ClearItem( ATTR_LANGUAGE_FORMAT );
1900 pTab->SetPattern( nCol, nRow, std::move(pNewPattern) );
1901 }
1902 }
1903
1904 namespace {
1905
1906 struct RowEntry
1907 {
1908 sal_uInt16 nGroupNo;
1909 SCROW nSubStartRow;
1910 SCROW nDestRow;
1911 SCROW nFuncStart;
1912 SCROW nFuncEnd;
1913 };
1914
1915 }
1916
1917 static const char* lcl_GetSubTotalStrId(int id)
1918 {
1919 switch ( id )
1920 {
1921 case SUBTOTAL_FUNC_AVE: return STR_FUN_TEXT_AVG;
1922 case SUBTOTAL_FUNC_CNT:
1923 case SUBTOTAL_FUNC_CNT2: return STR_FUN_TEXT_COUNT;
1924 case SUBTOTAL_FUNC_MAX: return STR_FUN_TEXT_MAX;
1925 case SUBTOTAL_FUNC_MIN: return STR_FUN_TEXT_MIN;
1926 case SUBTOTAL_FUNC_PROD: return STR_FUN_TEXT_PRODUCT;
1927 case SUBTOTAL_FUNC_STD:
1928 case SUBTOTAL_FUNC_STDP: return STR_FUN_TEXT_STDDEV;
1929 case SUBTOTAL_FUNC_SUM: return STR_FUN_TEXT_SUM;
1930 case SUBTOTAL_FUNC_VAR:
1931 case SUBTOTAL_FUNC_VARP: return STR_FUN_TEXT_VAR;
1932 default:
1933 {
1934 return STR_EMPTYDATA;
1935 // added to avoid warnings
1936 }
1937 }
1938 }
1939
1940 // new intermediate results
1941 // rParam.nRow2 is changed!
1942
1943 bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
1944 {
1945 SCCOL nStartCol = rParam.nCol1;
1946 SCROW nStartRow = rParam.nRow1 + 1; // Header
1947 SCCOL nEndCol = rParam.nCol2;
1948 SCROW nEndRow = rParam.nRow2; // will change
1949 sal_uInt16 i;
1950
1951 // Remove empty rows at the end
1952 // so that all exceeding (rDocument.MaxRow()) can be found by InsertRow (#35180#)
1953 // If sorted, all empty rows are at the end.
1954 SCSIZE nEmpty = GetEmptyLinesInBlock( nStartCol, nStartRow, nEndCol, nEndRow, DIR_BOTTOM );
1955 nEndRow -= nEmpty;
1956
1957 sal_uInt16 nLevelCount = 0; // Number of levels
1958 bool bDoThis = true;
1959 for (i=0; i<MAXSUBTOTAL && bDoThis; i++)
1960 if (rParam.bGroupActive[i])
1961 nLevelCount = i+1;
1962 else
1963 bDoThis = false;
1964
1965 if (nLevelCount==0) // do nothing
1966 return true;
1967
1968 SCCOL* nGroupCol = rParam.nField; // columns which will be used when grouping
1969
1970 // With (blank) as a separate category, subtotal rows from
1971 // the other columns must always be tested
1972 // (previously only when a column occurred more than once)
1973 bool bTestPrevSub = ( nLevelCount > 1 );
1974
1975 OUString aSubString;
1976
1977 bool bIgnoreCase = !rParam.bCaseSens;
1978
1979 OUString aCompString[MAXSUBTOTAL];
1980
1981 //TODO: sort?
1982
1983 ScStyleSheet* pStyle = static_cast<ScStyleSheet*>(rDocument.GetStyleSheetPool()->Find(
1984 ScResId(STR_STYLENAME_RESULT), SfxStyleFamily::Para ));
1985
1986 bool bSpaceLeft = true; // Success when inserting?
1987
1988 // For performance reasons collect formula entries so their
1989 // references don't have to be tested for updates each time a new row is
1990 // inserted
1991 RowEntry aRowEntry;
1992 ::std::vector< RowEntry > aRowVector;
1993
1994 for (sal_uInt16 nLevel=0; nLevel<nLevelCount && bSpaceLeft; nLevel++)
1995 {
1996 aRowEntry.nGroupNo = nLevelCount - nLevel - 1;
1997
1998 // how many results per level
1999 SCCOL nResCount = rParam.nSubTotals[aRowEntry.nGroupNo];
2000 // result functions
2001 ScSubTotalFunc* pResFunc = rParam.pFunctions[aRowEntry.nGroupNo];
2002
2003 if (nResCount > 0) // otherwise only sort
2004 {
2005 for (i=0; i<=aRowEntry.nGroupNo; i++)
2006 {
2007 GetString( nGroupCol[i], nStartRow, aSubString );
2008 if ( bIgnoreCase )
2009 aCompString[i] = ScGlobal::getCharClassPtr()->uppercase( aSubString );
2010 else
2011 aCompString[i] = aSubString;
2012 } // aSubString stays on the last
2013
2014 bool bBlockVis = false; // group visible?
2015 aRowEntry.nSubStartRow = nStartRow;
2016 for (SCROW nRow=nStartRow; nRow<=nEndRow+1 && bSpaceLeft; nRow++)
2017 {
2018 bool bChanged;
2019 if (nRow>nEndRow)
2020 bChanged = true;
2021 else
2022 {
2023 bChanged = false;
2024 OUString aString;
2025 for (i=0; i<=aRowEntry.nGroupNo && !bChanged; i++)
2026 {
2027 GetString( nGroupCol[i], nRow, aString );
2028 if (bIgnoreCase)
2029 aString = ScGlobal::getCharClassPtr()->uppercase(aString);
2030 // when sorting, blanks are separate group
2031 // otherwise blank cells are allowed below
2032 bChanged = ( ( !aString.isEmpty() || rParam.bDoSort ) &&
2033 aString != aCompString[i] );
2034 }
2035 if ( bChanged && bTestPrevSub )
2036 {
2037 // No group change on rows that will contain subtotal formulas
2038 bChanged = std::none_of(aRowVector.begin(), aRowVector.end(),
2039 [&nRow](const RowEntry& rEntry) { return rEntry.nDestRow == nRow; });
2040 }
2041 }
2042 if ( bChanged )
2043 {
2044 aRowEntry.nDestRow = nRow;
2045 aRowEntry.nFuncStart = aRowEntry.nSubStartRow;
2046 aRowEntry.nFuncEnd = nRow-1;
2047
2048 bSpaceLeft = rDocument.InsertRow( 0, nTab, rDocument.MaxCol(), nTab,
2049 aRowEntry.nDestRow, 1 );
2050 DBShowRow( aRowEntry.nDestRow, bBlockVis );
2051 if ( rParam.bPagebreak && nRow < rDocument.MaxRow() &&
2052 aRowEntry.nSubStartRow != nStartRow && nLevel == 0)
2053 SetRowBreak(aRowEntry.nSubStartRow, false, true);
2054
2055 if (bSpaceLeft)
2056 {
2057 for ( auto& rRowEntry : aRowVector)
2058 {
2059 if ( aRowEntry.nDestRow <= rRowEntry.nSubStartRow )
2060 ++rRowEntry.nSubStartRow;
2061 if ( aRowEntry.nDestRow <= rRowEntry.nDestRow )
2062 ++rRowEntry.nDestRow;
2063 if ( aRowEntry.nDestRow <= rRowEntry.nFuncStart )
2064 ++rRowEntry.nFuncStart;
2065 if ( aRowEntry.nDestRow <= rRowEntry.nFuncEnd )
2066 ++rRowEntry.nFuncEnd;
2067 }
2068 // collect formula positions
2069 aRowVector.push_back( aRowEntry );
2070
2071 OUString aOutString = aSubString;
2072 if (aOutString.isEmpty())
2073 aOutString = ScResId( STR_EMPTYDATA );
2074 aOutString += " ";
2075 const char* pStrId = STR_TABLE_ERGEBNIS;
2076 if ( nResCount == 1 )
2077 pStrId = lcl_GetSubTotalStrId(pResFunc[0]);
2078 aOutString += ScResId(pStrId);
2079 SetString( nGroupCol[aRowEntry.nGroupNo], aRowEntry.nDestRow, nTab, aOutString );
2080 ApplyStyle( nGroupCol[aRowEntry.nGroupNo], aRowEntry.nDestRow, pStyle );
2081
2082 ++nRow;
2083 ++nEndRow;
2084 aRowEntry.nSubStartRow = nRow;
2085 for (i=0; i<=aRowEntry.nGroupNo; i++)
2086 {
2087 GetString( nGroupCol[i], nRow, aSubString );
2088 if ( bIgnoreCase )
2089 aCompString[i] = ScGlobal::getCharClassPtr()->uppercase( aSubString );
2090 else
2091 aCompString[i] = aSubString;
2092 }
2093 }
2094 }
2095 bBlockVis = !RowFiltered(nRow);
2096 }
2097 }
2098 }
2099
2100 if (!aRowVector.empty())
2101 {
2102 // generate global total
2103 SCROW nGlobalStartRow = aRowVector[0].nSubStartRow;
2104 SCROW nGlobalStartFunc = aRowVector[0].nFuncStart;
2105 SCROW nGlobalEndRow = 0;
2106 SCROW nGlobalEndFunc = 0;
2107 for (const auto& rRowEntry : aRowVector)
2108 {
2109 nGlobalEndRow = (nGlobalEndRow < rRowEntry.nDestRow) ? rRowEntry.nDestRow : nGlobalEndRow;
2110 nGlobalEndFunc = (nGlobalEndFunc < rRowEntry.nFuncEnd) ? rRowEntry.nFuncEnd : nGlobalEndRow;
2111 }
2112
2113 for (sal_uInt16 nLevel = 0; nLevel<nLevelCount; nLevel++)
2114 {
2115 const sal_uInt16 nGroupNo = nLevelCount - nLevel - 1;
2116 const ScSubTotalFunc* pResFunc = rParam.pFunctions[nGroupNo];
2117 if (!pResFunc)
2118 {
2119 // No subtotal function given for this group => no formula or
2120 // label and do not insert a row.
2121 continue;
2122 }
2123
2124 // increment end row
2125 nGlobalEndRow++;
2126
2127 // add row entry for formula
2128 aRowEntry.nGroupNo = nGroupNo;
2129 aRowEntry.nSubStartRow = nGlobalStartRow;
2130 aRowEntry.nFuncStart = nGlobalStartFunc;
2131 aRowEntry.nDestRow = nGlobalEndRow;
2132 aRowEntry.nFuncEnd = nGlobalEndFunc;
2133
2134 // increment row
2135 nGlobalEndFunc++;
2136
2137 bSpaceLeft = rDocument.InsertRow(0, nTab, rDocument.MaxCol(), nTab, aRowEntry.nDestRow, 1);
2138
2139 if (bSpaceLeft)
2140 {
2141 aRowVector.push_back(aRowEntry);
2142 nEndRow++;
2143 DBShowRow(aRowEntry.nDestRow, true);
2144
2145 // insert label
2146 OUString label = ScResId(STR_TABLE_GRAND) + " " + ScResId(lcl_GetSubTotalStrId(pResFunc[0]));
2147 SetString(nGroupCol[aRowEntry.nGroupNo], aRowEntry.nDestRow, nTab, label);
2148 ApplyStyle(nGroupCol[aRowEntry.nGroupNo], aRowEntry.nDestRow, pStyle);
2149 }
2150 }
2151 }
2152
2153 // now insert the formulas
2154 ScComplexRefData aRef;
2155 aRef.InitFlags();
2156 aRef.Ref1.SetAbsTab(nTab);
2157 aRef.Ref2.SetAbsTab(nTab);
2158 for (const auto& rRowEntry : aRowVector)
2159 {
2160 SCCOL nResCount = rParam.nSubTotals[rRowEntry.nGroupNo];
2161 SCCOL* nResCols = rParam.pSubTotals[rRowEntry.nGroupNo];
2162 ScSubTotalFunc* pResFunc = rParam.pFunctions[rRowEntry.nGroupNo];
2163 for ( SCCOL nResult=0; nResult < nResCount; ++nResult )
2164 {
2165 aRef.Ref1.SetAbsCol(nResCols[nResult]);
2166 aRef.Ref1.SetAbsRow(rRowEntry.nFuncStart);
2167 aRef.Ref2.SetAbsCol(nResCols[nResult]);
2168 aRef.Ref2.SetAbsRow(rRowEntry.nFuncEnd);
2169
2170 ScTokenArray aArr(rDocument);
2171 aArr.AddOpCode( ocSubTotal );
2172 aArr.AddOpCode( ocOpen );
2173 aArr.AddDouble( static_cast<double>(pResFunc[nResult]) );
2174 aArr.AddOpCode( ocSep );
2175 aArr.AddDoubleReference( aRef );
2176 aArr.AddOpCode( ocClose );
2177 aArr.AddOpCode( ocStop );
2178 ScFormulaCell* pCell = new ScFormulaCell(
2179 rDocument, ScAddress(nResCols[nResult], rRowEntry.nDestRow, nTab), aArr);
2180 if ( rParam.bIncludePattern )
2181 pCell->SetNeedNumberFormat(true);
2182
2183 SetFormulaCell(nResCols[nResult], rRowEntry.nDestRow, pCell);
2184 if ( nResCols[nResult] != nGroupCol[rRowEntry.nGroupNo] )
2185 {
2186 ApplyStyle( nResCols[nResult], rRowEntry.nDestRow, pStyle );
2187
2188 lcl_RemoveNumberFormat( this, nResCols[nResult], rRowEntry.nDestRow );
2189 }
2190 }
2191
2192 }
2193
2194 //TODO: according to setting, shift intermediate-sum rows up?
2195
2196 //TODO: create Outlines directly?
2197
2198 if (bSpaceLeft)
2199 DoAutoOutline( nStartCol, nStartRow, nEndCol, nEndRow );
2200
2201 rParam.nRow2 = nEndRow; // new end
2202 return bSpaceLeft;
2203 }
2204
2205 namespace {
2206
2207 class QueryEvaluator
2208 {
2209 ScDocument& mrDoc;
2210 svl::SharedStringPool& mrStrPool;
2211 const ScTable& mrTab;
2212 const ScQueryParam& mrParam;
2213 bool mpTestEqualCondition;
2214 utl::TransliterationWrapper* mpTransliteration;
2215 CollatorWrapper* mpCollator;
2216 const bool mbMatchWholeCell;
2217 const bool mbCaseSensitive;
2218
2219 static bool isPartialTextMatchOp(const ScQueryEntry& rEntry)
2220 {
2221 switch (rEntry.eOp)
2222 {
2223 // these operators can only be used with textural comparisons.
2224 case SC_CONTAINS:
2225 case SC_DOES_NOT_CONTAIN:
2226 case SC_BEGINS_WITH:
2227 case SC_ENDS_WITH:
2228 case SC_DOES_NOT_BEGIN_WITH:
2229 case SC_DOES_NOT_END_WITH:
2230 return true;
2231 default:
2232 ;
2233 }
2234 return false;
2235 }
2236
2237 static bool isTextMatchOp(const ScQueryEntry& rEntry)
2238 {
2239 if (isPartialTextMatchOp(rEntry))
2240 return true;
2241
2242 switch (rEntry.eOp)
2243 {
2244 // these operators can be used for either textural or value comparison.
2245 case SC_EQUAL:
2246 case SC_NOT_EQUAL:
2247 return true;
2248 default:
2249 ;
2250 }
2251 return false;
2252 }
2253
2254 bool isRealWildOrRegExp(const ScQueryEntry& rEntry) const
2255 {
2256 if (mrParam.eSearchType == utl::SearchParam::SearchType::Normal)
2257 return false;
2258
2259 return isTextMatchOp(rEntry);
2260 }
2261
2262 bool isTestWildOrRegExp(const ScQueryEntry& rEntry) const
2263 {
2264 if (!mpTestEqualCondition)
2265 return false;
2266
2267 if (mrParam.eSearchType == utl::SearchParam::SearchType::Normal)
2268 return false;
2269
2270 return (rEntry.eOp == SC_LESS_EQUAL || rEntry.eOp == SC_GREATER_EQUAL);
2271 }
2272
2273 void setupTransliteratorIfNeeded()
2274 {
2275 if (!mpTransliteration)
2276 mpTransliteration = mrParam.bCaseSens ? ScGlobal::GetCaseTransliteration() : ScGlobal::GetpTransliteration();
2277 }
2278
2279 void setupCollatorIfNeeded()
2280 {
2281 if (!mpCollator)
2282 mpCollator = mrParam.bCaseSens ? ScGlobal::GetCaseCollator() : ScGlobal::GetCollator();
2283 }
2284
2285 public:
2286 QueryEvaluator(ScDocument& rDoc, const ScTable& rTab, const ScQueryParam& rParam,
2287 bool pTestEqualCondition) :
2288 mrDoc(rDoc),
2289 mrStrPool(rDoc.GetSharedStringPool()),
2290 mrTab(rTab),
2291 mrParam(rParam),
2292 mpTestEqualCondition(pTestEqualCondition),
2293 mpTransliteration(nullptr),
2294 mpCollator(nullptr),
2295 mbMatchWholeCell(rDoc.GetDocOptions().IsMatchWholeCell()),
2296 mbCaseSensitive( rParam.bCaseSens )
2297 {
2298 }
2299
2300 bool isQueryByValue(
2301 const ScQueryEntry::Item& rItem, SCCOL nCol, SCROW nRow, ScRefCellValue& rCell)
2302 {
2303 if (rItem.meType == ScQueryEntry::ByString)
2304 return false;
2305
2306 if (!rCell.isEmpty())
2307 {
2308 if (rCell.meType == CELLTYPE_FORMULA && rCell.mpFormula->GetErrCode() != FormulaError::NONE)
2309 // Error values are compared as string.
2310 return false;
2311
2312 return rCell.hasNumeric();
2313 }
2314
2315 return mrTab.HasValueData(nCol, nRow);
2316 }
2317
2318 bool isQueryByString(
2319 const ScQueryEntry& rEntry, const ScQueryEntry::Item& rItem,
2320 SCCOL nCol, SCROW nRow, const ScRefCellValue& rCell)
2321 {
2322 if (isTextMatchOp(rEntry))
2323 return true;
2324
2325 if (rItem.meType != ScQueryEntry::ByString)
2326 return false;
2327
2328 if (!rCell.isEmpty())
2329 return rCell.hasString();
2330
2331 return mrTab.HasStringData(nCol, nRow);
2332 }
2333
2334 std::pair<bool,bool> compareByValue(
2335 const ScRefCellValue& rCell, SCCOL nCol, SCROW nRow,
2336 const ScQueryEntry& rEntry, const ScQueryEntry::Item& rItem,
2337 const ScInterpreterContext* pContext)
2338 {
2339 bool bOk = false;
2340 bool bTestEqual = false;
2341 double nCellVal;
2342 if (!rCell.isEmpty())
2343 {
2344 switch (rCell.meType)
2345 {
2346 case CELLTYPE_VALUE :
2347 nCellVal = rCell.mfValue;
2348 break;
2349 case CELLTYPE_FORMULA :
2350 nCellVal = rCell.mpFormula->GetValue();
2351 break;
2352 default:
2353 nCellVal = 0.0;
2354 }
2355
2356 }
2357 else
2358 nCellVal = mrTab.GetValue(nCol, nRow);
2359
2360 /* NOTE: lcl_PrepareQuery() prepares a filter query such that if a
2361 * date+time format was queried rEntry.bQueryByDate is not set. In
2362 * case other queries wanted to use this mechanism they should do
2363 * the same, in other words only if rEntry.nVal is an integer value
2364 * rEntry.bQueryByDate should be true and the time fraction be
2365 * stripped here. */
2366 if (rItem.meType == ScQueryEntry::ByDate)
2367 {
2368 sal_uInt32 nNumFmt = pContext ? mrTab.GetNumberFormat(*pContext, ScAddress(nCol, nRow, mrTab.GetTab())) :
2369 mrTab.GetNumberFormat(nCol, nRow);
2370 SvNumberFormatter* pFormatter = pContext ? pContext->GetFormatTable() : mrDoc.GetFormatTable();
2371 const SvNumberformat* pEntry = pFormatter->GetEntry(nNumFmt);
2372 if (pEntry)
2373 {
2374 SvNumFormatType nNumFmtType = pEntry->GetType();
2375 /* NOTE: Omitting the check for absence of
2376 * css::util::NumberFormat::TIME would include also date+time formatted
2377 * values of the same day. That may be desired in some
2378 * cases, querying all time values of a day, but confusing
2379 * in other cases. A user can always setup a standard
2380 * filter query for x >= date AND x < date+1 */
2381 if ((nNumFmtType & SvNumFormatType::DATE) && !(nNumFmtType & SvNumFormatType::TIME))
2382 {
2383 // The format is of date type. Strip off the time
2384 // element.
2385 nCellVal = ::rtl::math::approxFloor(nCellVal);
2386 }
2387 }
2388 }
2389
2390 switch (rEntry.eOp)
2391 {
2392 case SC_EQUAL :
2393 bOk = ::rtl::math::approxEqual(nCellVal, rItem.mfVal);
2394 break;
2395 case SC_LESS :
2396 bOk = (nCellVal < rItem.mfVal) && !::rtl::math::approxEqual(nCellVal, rItem.mfVal);
2397 break;
2398 case SC_GREATER :
2399 bOk = (nCellVal > rItem.mfVal) && !::rtl::math::approxEqual(nCellVal, rItem.mfVal);
2400 break;
2401 case SC_LESS_EQUAL :
2402 bOk = (nCellVal < rItem.mfVal) || ::rtl::math::approxEqual(nCellVal, rItem.mfVal);
2403 if ( bOk && mpTestEqualCondition )
2404 bTestEqual = ::rtl::math::approxEqual(nCellVal, rItem.mfVal);
2405 break;
2406 case SC_GREATER_EQUAL :
2407 bOk = (nCellVal > rItem.mfVal) || ::rtl::math::approxEqual( nCellVal, rItem.mfVal);
2408 if ( bOk && mpTestEqualCondition )
2409 bTestEqual = ::rtl::math::approxEqual(nCellVal, rItem.mfVal);
2410 break;
2411 case SC_NOT_EQUAL :
2412 bOk = !::rtl::math::approxEqual(nCellVal, rItem.mfVal);
2413 break;
2414 default:
2415 {
2416 // added to avoid warnings
2417 }
2418 }
2419
2420 return std::pair<bool,bool>(bOk, bTestEqual);
2421 }
2422
2423 std::pair<bool,bool> compareByString(
2424 const ScRefCellValue& rCell, SCROW nRow, const ScQueryEntry& rEntry, const ScQueryEntry::Item& rItem,
2425 const ScInterpreterContext* pContext)
2426 {
2427 if (!rCell.isEmpty())
2428 {
2429 if (rCell.meType == CELLTYPE_FORMULA && rCell.mpFormula->GetErrCode() != FormulaError::NONE)
2430 {
2431 // Error cell is evaluated as string (for now).
2432 const svl::SharedString aCellStr = mrStrPool.intern(ScGlobal::GetErrorString(rCell.mpFormula->GetErrCode()));
2433 return compareByStringComparator(rEntry, rItem, &aCellStr, nullptr);
2434 }
2435 else if (rCell.meType == CELLTYPE_STRING)
2436 {
2437 return compareByStringComparator(rEntry, rItem, rCell.mpString, nullptr);
2438 }
2439 else
2440 {
2441 sal_uInt32 nFormat = pContext ? mrTab.GetNumberFormat( *pContext, ScAddress(static_cast<SCCOL>(rEntry.nField), nRow, mrTab.GetTab()) ) :
2442 mrTab.GetNumberFormat( static_cast<SCCOL>(rEntry.nField), nRow );
2443 OUString aStr;
2444 SvNumberFormatter* pFormatter = pContext ? pContext->GetFormatTable() : mrDoc.GetFormatTable();
2445 ScCellFormat::GetInputString(rCell, nFormat, aStr, *pFormatter, mrDoc, rEntry.bDoQuery);
2446 return compareByStringComparator(rEntry, rItem, nullptr, &aStr);
2447 }
2448 }
2449 else
2450 {
2451 OUString aStr;
2452 mrTab.GetInputString(static_cast<SCCOL>(rEntry.nField), nRow, aStr);
2453 return compareByStringComparator(rEntry, rItem, nullptr, &aStr);
2454 }
2455 }
2456
2457 // Called from compareByString() method, where different sources of strings are checked.
2458 // The value is placed inside one parameter: [pValueSource1] or [pValueSource2] but never in both.
2459 std::pair<bool,bool> compareByStringComparator(const ScQueryEntry& rEntry, const ScQueryEntry::Item& rItem,
2460 const svl::SharedString* pValueSource1, const OUString * pValueSource2)
2461 {
2462 bool bOk = false;
2463 bool bTestEqual = false;
2464 bool bMatchWholeCell = mbMatchWholeCell;
2465 if (isPartialTextMatchOp(rEntry))
2466 // may have to do partial textural comparison.
2467 bMatchWholeCell = false;
2468
2469 const bool bRealWildOrRegExp = isRealWildOrRegExp(rEntry);
2470 const bool bTestWildOrRegExp = isTestWildOrRegExp(rEntry);
2471
2472 // [pValueSource1] or [pValueSource2] but never both of them or none of them
2473 assert((pValueSource1 != nullptr) != (pValueSource2 != nullptr));
2474
2475 if ( bRealWildOrRegExp || bTestWildOrRegExp )
2476 {
2477 const OUString & rValue = pValueSource1 ? pValueSource1->getString() : *pValueSource2;
2478
2479 sal_Int32 nStart = 0;
2480 sal_Int32 nEnd = rValue.getLength();
2481
2482 // from 614 on, nEnd is behind the found text
2483 bool bMatch = false;
2484 if ( rEntry.eOp == SC_ENDS_WITH || rEntry.eOp == SC_DOES_NOT_END_WITH )
2485 {
2486 nEnd = 0;
2487 nStart = rValue.getLength();
2488 bMatch = rEntry.GetSearchTextPtr( mrParam.eSearchType, mrParam.bCaseSens, bMatchWholeCell )
2489 ->SearchBackward(rValue, &nStart, &nEnd);
2490 }
2491 else
2492 {
2493 bMatch = rEntry.GetSearchTextPtr( mrParam.eSearchType, mrParam.bCaseSens, bMatchWholeCell )
2494 ->SearchForward(rValue, &nStart, &nEnd);
2495 }
2496 if ( bMatch && bMatchWholeCell
2497 && (nStart != 0 || nEnd != rValue.getLength()) )
2498 bMatch = false; // RegExp must match entire cell string
2499 if ( bRealWildOrRegExp )
2500 {
2501 switch (rEntry.eOp)
2502 {
2503 case SC_EQUAL:
2504 case SC_CONTAINS:
2505 bOk = bMatch;
2506 break;
2507 case SC_NOT_EQUAL:
2508 case SC_DOES_NOT_CONTAIN:
2509 bOk = !bMatch;
2510 break;
2511 case SC_BEGINS_WITH:
2512 bOk = ( bMatch && (nStart == 0) );
2513 break;
2514 case SC_DOES_NOT_BEGIN_WITH:
2515 bOk = !( bMatch && (nStart == 0) );
2516 break;
2517 case SC_ENDS_WITH:
2518 bOk = ( bMatch && (nEnd == rValue.getLength()) );
2519 break;
2520 case SC_DOES_NOT_END_WITH:
2521 bOk = !( bMatch && (nEnd == rValue.getLength()) );
2522 break;
2523 default:
2524 {
2525 // added to avoid warnings
2526 }
2527 }
2528 }
2529 else
2530 bTestEqual = bMatch;
2531 }
2532 if ( !bRealWildOrRegExp )
2533 {
2534 // Simple string matching i.e. no regexp match.
2535 if (isTextMatchOp(rEntry))
2536 {
2537 if (rItem.meType != ScQueryEntry::ByString && rItem.maString.isEmpty())
2538 {
2539 // #i18374# When used from functions (match, countif, sumif, vlookup, hlookup, lookup),
2540 // the query value is assigned directly, and the string is empty. In that case,
2541 // don't find any string (isEqual would find empty string results in formula cells).
2542 bOk = false;
2543 if ( rEntry.eOp == SC_NOT_EQUAL )
2544 bOk = !bOk;
2545 }
2546 else if ( bMatchWholeCell )
2547 {
2548 if (pValueSource1)
2549 {
2550 // Fast string equality check by comparing string identifiers.
2551 if (mrParam.bCaseSens)
2552 {
2553 bOk = pValueSource1->getData() == rItem.maString.getData();
2554 }
2555 else
2556 {
2557 bOk = pValueSource1->getDataIgnoreCase() == rItem.maString.getDataIgnoreCase();
2558 }
2559 }
2560 else // if (pValueSource2)
2561 {
2562 if (mrParam.bCaseSens)
2563 {
2564 bOk = (*pValueSource2 == rItem.maString.getString());
2565 }
2566 else
2567 {
2568 // fallback
2569 const svl::SharedString rSource2(mrStrPool.intern(*pValueSource2));
2570 // Fast string equality check by comparing string identifiers.
2571 bOk = rSource2.getDataIgnoreCase() == rItem.maString.getDataIgnoreCase();
2572 }
2573 }
2574
2575 if ( rEntry.eOp == SC_NOT_EQUAL )
2576 bOk = !bOk;
2577 }
2578 else
2579 {
2580 // Where do we find a match (if at all)
2581 sal_Int32 nStrPos;
2582
2583 if (!mbCaseSensitive)
2584 { // Common case for vlookup etc.
2585 const svl::SharedString rSource(pValueSource1? *pValueSource1 : mrStrPool.intern(*pValueSource2));
2586
2587 const rtl_uString *pQuer = rItem.maString.getDataIgnoreCase();
2588 const rtl_uString *pCellStr = rSource.getDataIgnoreCase();
2589
2590 assert(pQuer != nullptr);
2591 assert(pCellStr != nullptr);
2592
2593 const sal_Int32 nIndex = (rEntry.eOp == SC_ENDS_WITH ||
2594 rEntry.eOp == SC_DOES_NOT_END_WITH) ?
2595 (pCellStr->length - pQuer->length) : 0;
2596
2597 if (nIndex < 0)
2598 nStrPos = -1;
2599 else if (rEntry.eOp == SC_EQUAL ||
2600 rEntry.eOp == SC_NOT_EQUAL)
2601 {
2602 nStrPos = pCellStr == pQuer ? 0 : -1;
2603 }
2604 else
2605 { // OUString::indexOf
2606 nStrPos = rtl_ustr_indexOfStr_WithLength(
2607 pCellStr->buffer + nIndex, pCellStr->length - nIndex,
2608 pQuer->buffer, pQuer->length );
2609
2610 if (nStrPos >= 0)
2611 nStrPos += nIndex;
2612 }
2613 }
2614 else
2615 {
2616 const OUString & rValue = pValueSource1 ? pValueSource1->getString() : *pValueSource2;
2617 const OUString aQueryStr = rItem.maString.getString();
2618 const LanguageType nLang = ScGlobal::xSysLocale->GetLanguageTag().getLanguageType();
2619 setupTransliteratorIfNeeded();
2620 const OUString aCell( mpTransliteration->transliterate(
2621 rValue, nLang, 0, rValue.getLength(),
2622 nullptr ) );
2623
2624 const OUString aQuer( mpTransliteration->transliterate(
2625 aQueryStr, nLang, 0, aQueryStr.getLength(),
2626 nullptr ) );
2627
2628 const sal_Int32 nIndex = (rEntry.eOp == SC_ENDS_WITH || rEntry.eOp == SC_DOES_NOT_END_WITH) ?
2629 (aCell.getLength() - aQuer.getLength()) : 0;
2630 nStrPos = ((nIndex < 0) ? -1 : aCell.indexOf( aQuer, nIndex ));
2631 }
2632 switch (rEntry.eOp)
2633 {
2634 case SC_EQUAL:
2635 bOk = ( nStrPos == 0 );
2636 break;
2637 case SC_CONTAINS:
2638 bOk = ( nStrPos != -1 );
2639 break;
2640 case SC_NOT_EQUAL:
2641 bOk = ( nStrPos != 0 );
2642 break;
2643 case SC_DOES_NOT_CONTAIN:
2644 bOk = ( nStrPos == -1 );
2645 break;
2646 case SC_BEGINS_WITH:
2647 bOk = ( nStrPos == 0 );
2648 break;
2649 case SC_DOES_NOT_BEGIN_WITH:
2650 bOk = ( nStrPos != 0 );
2651 break;
2652 case SC_ENDS_WITH:
2653 bOk = ( nStrPos >= 0 );
2654 break;
2655 case SC_DOES_NOT_END_WITH:
2656 bOk = ( nStrPos < 0 );
2657 break;
2658 default:
2659 {
2660 // added to avoid warnings
2661 }
2662 }
2663 }
2664 }
2665 else
2666 { // use collator here because data was probably sorted
2667 const OUString & rValue = pValueSource1 ? pValueSource1->getString() : *pValueSource2;
2668 setupCollatorIfNeeded();
2669 sal_Int32 nCompare = mpCollator->compareString(
2670 rValue, rItem.maString.getString());
2671 switch (rEntry.eOp)
2672 {
2673 case SC_LESS :
2674 bOk = (nCompare < 0);
2675 break;
2676 case SC_GREATER :
2677 bOk = (nCompare > 0);
2678 break;
2679 case SC_LESS_EQUAL :
2680 bOk = (nCompare <= 0);
2681 if ( bOk && mpTestEqualCondition && !bTestEqual )
2682 bTestEqual = (nCompare == 0);
2683 break;
2684 case SC_GREATER_EQUAL :
2685 bOk = (nCompare >= 0);
2686 if ( bOk && mpTestEqualCondition && !bTestEqual )
2687 bTestEqual = (nCompare == 0);
2688 break;
2689 default:
2690 {
2691 // added to avoid warnings
2692 }
2693 }
2694 }
2695 }
2696
2697 return std::pair<bool,bool>(bOk, bTestEqual);
2698 }
2699
2700 std::pair<bool, bool> compareByTextColor(SCCOL nCol, SCROW nRow, SCTAB nTab,
2701 const ScQueryEntry::Item& rItem)
2702 {
2703 ScAddress aPos(nCol, nRow, nTab);
2704 const SvxColorItem* pColor = mrDoc.GetAttr(aPos, ATTR_FONT_COLOR);
2705 Color color = pColor->GetValue();
2706 bool bMatch = rItem.maColor == color;
2707 return std::pair<bool, bool>(bMatch, false);
2708 }
2709
2710 std::pair<bool, bool> compareByBackgroundColor(SCCOL nCol, SCROW nRow, SCTAB nTab,
2711 const ScQueryEntry::Item& rItem)
2712 {
2713 ScAddress aPos(nCol, nRow, nTab);
2714 const SvxBrushItem* pBrush = mrDoc.GetAttr(aPos, ATTR_BACKGROUND);
2715 Color color = pBrush->GetColor();
2716 bool bMatch = rItem.maColor == color;
2717 return std::pair<bool, bool>(bMatch, false);
2718 }
2719
2720 // To be called only if both isQueryByValue() and isQueryByString()
2721 // returned false and range lookup is wanted! In range lookup comparison
2722 // numbers are less than strings. Nothing else is compared.
2723 std::pair<bool,bool> compareByRangeLookup(
2724 const ScRefCellValue& rCell, SCCOL nCol, SCROW nRow,
2725 const ScQueryEntry& rEntry, const ScQueryEntry::Item& rItem)
2726 {
2727 bool bTestEqual = false;
2728
2729 if (rItem.meType == ScQueryEntry::ByString && rEntry.eOp != SC_LESS && rEntry.eOp != SC_LESS_EQUAL)
2730 return std::pair<bool,bool>(false, bTestEqual);
2731
2732 if (rItem.meType != ScQueryEntry::ByString && rEntry.eOp != SC_GREATER && rEntry.eOp != SC_GREATER_EQUAL)
2733 return std::pair<bool,bool>(false, bTestEqual);
2734
2735 if (!rCell.isEmpty())
2736 {
2737 if (rItem.meType == ScQueryEntry::ByString)
2738 {
2739 if (rCell.meType == CELLTYPE_FORMULA && rCell.mpFormula->GetErrCode() != FormulaError::NONE)
2740 // Error values are compared as string.
2741 return std::pair<bool,bool>(false, bTestEqual);
2742
2743 return std::pair<bool,bool>(rCell.hasNumeric(), bTestEqual);
2744 }
2745
2746 return std::pair<bool,bool>(!rCell.hasNumeric(), bTestEqual);
2747 }
2748
2749 if (rItem.meType == ScQueryEntry::ByString)
2750 return std::pair<bool,bool>(mrTab.HasValueData(nCol, nRow), bTestEqual);
2751
2752 return std::pair<bool,bool>(!mrTab.HasValueData(nCol, nRow), bTestEqual);
2753 }
2754 };
2755
2756 }
2757
2758 bool ScTable::ValidQuery(
2759 SCROW nRow, const ScQueryParam& rParam, const ScRefCellValue* pCell, bool* pbTestEqualCondition,
2760 const ScInterpreterContext* pContext, sc::TableColumnBlockPositionSet* pBlockPos)
2761 {
2762 if (!rParam.GetEntry(0).bDoQuery)
2763 return true;
2764
2765 //---------------------------------------------------------------
2766
2767 const SCSIZE nFixedBools = 32;
2768 bool aBool[nFixedBools];
2769 bool aTest[nFixedBools];
2770 SCSIZE nEntryCount = rParam.GetEntryCount();
2771 bool* pPasst = ( nEntryCount <= nFixedBools ? &aBool[0] : new bool[nEntryCount] );
2772 bool* pTest = ( nEntryCount <= nFixedBools ? &aTest[0] : new bool[nEntryCount] );
2773
2774 tools::Long nPos = -1;
2775 QueryEvaluator aEval(rDocument, *this, rParam, pbTestEqualCondition != nullptr);
2776 ScQueryParam::const_iterator it, itBeg = rParam.begin(), itEnd = rParam.end();
2777 for (it = itBeg; it != itEnd && (*it)->bDoQuery; ++it)
2778 {
2779 const ScQueryEntry& rEntry = **it;
2780 SCCOL nCol = static_cast<SCCOL>(rEntry.nField);
2781
2782 // We can only handle one single direct query passed as a known pCell,
2783 // subsequent queries have to obtain the cell.
2784 ScRefCellValue aCell;
2785 if(pCell && it == itBeg)
2786 aCell = *pCell;
2787 else if( pBlockPos )
2788 { // hinted mdds access
2789 ScColumn* column = FetchColumn(nCol);
2790 aCell = column->GetCellValue(*pBlockPos->getBlockPosition( nCol ), nRow);
2791 }
2792 else
2793 aCell = GetCellValue(nCol, nRow);
2794
2795 std::pair<bool,bool> aRes(false, false);
2796
2797 const ScQueryEntry::QueryItemsType& rItems = rEntry.GetQueryItems();
2798 if (rItems.size() == 1 && rItems.front().meType == ScQueryEntry::ByEmpty)
2799 {
2800 bool hasData;
2801 if( pBlockPos )
2802 {
2803 ScColumn* column = FetchColumn(rEntry.nField);
2804 hasData = column->HasDataAt(*pBlockPos->getBlockPosition(rEntry.nField), nRow);
2805 }
2806 else
2807 hasData = aCol[rEntry.nField].HasDataAt(nRow);
2808 if (rEntry.IsQueryByEmpty())
2809 aRes.first = !hasData;
2810 else
2811 {
2812 assert(rEntry.IsQueryByNonEmpty());
2813 aRes.first = hasData;
2814 }
2815 }
2816 else
2817 {
2818 for (const auto& rItem : rItems)
2819 {
2820 if (rItem.meType == ScQueryEntry::ByTextColor)
2821 {
2822 std::pair<bool, bool> aThisRes
2823 = aEval.compareByTextColor(nCol, nRow, nTab, rItem);
2824 aRes.first |= aThisRes.first;
2825 aRes.second |= aThisRes.second;
2826 }
2827 else if (rItem.meType == ScQueryEntry::ByBackgroundColor)
2828 {
2829 std::pair<bool,bool> aThisRes =
2830 aEval.compareByBackgroundColor(nCol, nRow, nTab, rItem);
2831 aRes.first |= aThisRes.first;
2832 aRes.second |= aThisRes.second;
2833 }
2834 else if (aEval.isQueryByValue(rItem, nCol, nRow, aCell))
2835 {
2836 std::pair<bool,bool> aThisRes =
2837 aEval.compareByValue(aCell, nCol, nRow, rEntry, rItem, pContext);
2838 aRes.first |= aThisRes.first;
2839 aRes.second |= aThisRes.second;
2840 }
2841 else if (aEval.isQueryByString(rEntry, rItem, nCol, nRow, aCell))
2842 {
2843 std::pair<bool,bool> aThisRes =
2844 aEval.compareByString(aCell, nRow, rEntry, rItem, pContext);
2845 aRes.first |= aThisRes.first;
2846 aRes.second |= aThisRes.second;
2847 }
2848 else if (rParam.mbRangeLookup)
2849 {
2850 std::pair<bool,bool> aThisRes =
2851 aEval.compareByRangeLookup(aCell, nCol, nRow, rEntry, rItem);
2852 aRes.first |= aThisRes.first;
2853 aRes.second |= aThisRes.second;
2854 }
2855
2856 if (aRes.first && aRes.second)
2857 break;
2858 }
2859 }
2860
2861 if (nPos == -1)
2862 {
2863 nPos++;
2864 pPasst[nPos] = aRes.first;
2865 pTest[nPos] = aRes.second;
2866 }
2867 else
2868 {
2869 if (rEntry.eConnect == SC_AND)
2870 {
2871 pPasst[nPos] = pPasst[nPos] && aRes.first;
2872 pTest[nPos] = pTest[nPos] && aRes.second;
2873 }
2874 else
2875 {
2876 nPos++;
2877 pPasst[nPos] = aRes.first;
2878 pTest[nPos] = aRes.second;
2879 }
2880 }
2881 }
2882
2883 for ( tools::Long j=1; j <= nPos; j++ )
2884 {
2885 pPasst[0] = pPasst[0] || pPasst[j];
2886 pTest[0] = pTest[0] || pTest[j];
2887 }
2888
2889 bool bRet = pPasst[0];
2890 if ( pPasst != &aBool[0] )
2891 delete [] pPasst;
2892 if ( pbTestEqualCondition )
2893 *pbTestEqualCondition = pTest[0];
2894 if ( pTest != &aTest[0] )
2895 delete [] pTest;
2896
2897 return bRet;
2898 }
2899
2900 void ScTable::TopTenQuery( ScQueryParam& rParam )
2901 {
2902 bool bSortCollatorInitialized = false;
2903 SCSIZE nEntryCount = rParam.GetEntryCount();
2904 SCROW nRow1 = (rParam.bHasHeader ? rParam.nRow1 + 1 : rParam.nRow1);
2905 SCSIZE nCount = static_cast<SCSIZE>(rParam.nRow2 - nRow1 + 1);
2906 for ( SCSIZE i=0; (i<nEntryCount) && (rParam.GetEntry(i).bDoQuery); i++ )
2907 {
2908 ScQueryEntry& rEntry = rParam.GetEntry(i);
2909 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
2910
2911 switch ( rEntry.eOp )
2912 {
2913 case SC_TOPVAL:
2914 case SC_BOTVAL:
2915 case SC_TOPPERC:
2916 case SC_BOTPERC:
2917 {
2918 ScSortParam aLocalSortParam( rParam, static_cast<SCCOL>(rEntry.nField) );
2919 aSortParam = aLocalSortParam; // used in CreateSortInfoArray, Compare
2920 if ( !bSortCollatorInitialized )
2921 {
2922 bSortCollatorInitialized = true;
2923 InitSortCollator( aLocalSortParam );
2924 }
2925 std::unique_ptr<ScSortInfoArray> pArray(CreateSortInfoArray(aSortParam, nRow1, rParam.nRow2, bGlobalKeepQuery, false));
2926 DecoladeRow( pArray.get(), nRow1, rParam.nRow2 );
2927 QuickSort( pArray.get(), nRow1, rParam.nRow2 );
2928 std::unique_ptr<ScSortInfo[]> const & ppInfo = pArray->GetFirstArray();
2929 SCSIZE nValidCount = nCount;
2930 // Don't count note or blank cells, they are sorted to the end
2931 while (nValidCount > 0 && ppInfo[nValidCount-1].maCell.isEmpty())
2932 nValidCount--;
2933 // Don't count Strings, they are between Value and blank
2934 while (nValidCount > 0 && ppInfo[nValidCount-1].maCell.hasString())
2935 nValidCount--;
2936 if ( nValidCount > 0 )
2937 {
2938 if ( rItem.meType == ScQueryEntry::ByString )
2939 { // by string ain't going to work
2940 rItem.meType = ScQueryEntry::ByValue;
2941 rItem.mfVal = 10; // 10 and 10% respectively
2942 }
2943 SCSIZE nVal = (rItem.mfVal >= 1 ? static_cast<SCSIZE>(rItem.mfVal) : 1);
2944 SCSIZE nOffset = 0;
2945 switch ( rEntry.eOp )
2946 {
2947 case SC_TOPVAL:
2948 {
2949 rEntry.eOp = SC_GREATER_EQUAL;
2950 if ( nVal > nValidCount )
2951 nVal = nValidCount;
2952 nOffset = nValidCount - nVal; // 1 <= nVal <= nValidCount
2953 }
2954 break;
2955 case SC_BOTVAL:
2956 {
2957 rEntry.eOp = SC_LESS_EQUAL;
2958 if ( nVal > nValidCount )
2959 nVal = nValidCount;
2960 nOffset = nVal - 1; // 1 <= nVal <= nValidCount
2961 }
2962 break;
2963 case SC_TOPPERC:
2964 {
2965 rEntry.eOp = SC_GREATER_EQUAL;
2966 if ( nVal > 100 )
2967 nVal = 100;
2968 nOffset = nValidCount - (nValidCount * nVal / 100);
2969 if ( nOffset >= nValidCount )
2970 nOffset = nValidCount - 1;
2971 }
2972 break;
2973 case SC_BOTPERC:
2974 {
2975 rEntry.eOp = SC_LESS_EQUAL;
2976 if ( nVal > 100 )
2977 nVal = 100;
2978 nOffset = (nValidCount * nVal / 100);
2979 if ( nOffset >= nValidCount )
2980 nOffset = nValidCount - 1;
2981 }
2982 break;
2983 default:
2984 {
2985 // added to avoid warnings
2986 }
2987 }
2988 ScRefCellValue aCell = ppInfo[nOffset].maCell;
2989 if (aCell.hasNumeric())
2990 rItem.mfVal = aCell.getValue();
2991 else
2992 {
2993 OSL_FAIL( "TopTenQuery: pCell no ValueData" );
2994 rEntry.eOp = SC_GREATER_EQUAL;
2995 rItem.mfVal = 0;
2996 }
2997 }
2998 else
2999 {
3000 rEntry.eOp = SC_GREATER_EQUAL;
3001 rItem.meType = ScQueryEntry::ByValue;
3002 rItem.mfVal = 0;
3003 }
3004 }
3005 break;
3006 default:
3007 {
3008 // added to avoid warnings
3009 }
3010 }
3011 }
3012 if ( bSortCollatorInitialized )
3013 DestroySortCollator();
3014 }
3015
3016 namespace {
3017
3018 bool CanOptimizeQueryStringToNumber( SvNumberFormatter* pFormatter, sal_uInt32 nFormatIndex, bool& bDateFormat )
3019 {
3020 // tdf#105629: ScQueryEntry::ByValue queries are faster than ScQueryEntry::ByString.
3021 // The problem with this optimization is that the autofilter dialog apparently converts
3022 // the value to text and then converts that back to a number for filtering.
3023 // If that leads to any change of value (such as when time is rounded to seconds),
3024 // even matching values will be filtered out. Therefore query by value only for formats
3025 // where no such change should occur.
3026 if(const SvNumberformat* pEntry = pFormatter->GetEntry(nFormatIndex))
3027 {
3028 switch(pEntry->GetType())
3029 {
3030 case SvNumFormatType::NUMBER:
3031 case SvNumFormatType::FRACTION:
3032 case SvNumFormatType::SCIENTIFIC:
3033 return true;
3034 case SvNumFormatType::DATE:
3035 case SvNumFormatType::DATETIME:
3036 bDateFormat = true;
3037 break;
3038 default:
3039 break;
3040 }
3041 }
3042 return false;
3043 }
3044
3045 class PrepareQueryItem
3046 {
3047 const ScDocument& mrDoc;
3048 public:
3049 explicit PrepareQueryItem(const ScDocument& rDoc) : mrDoc(rDoc) {}
3050
3051 void operator() (ScQueryEntry::Item& rItem)
3052 {
3053 if (rItem.meType != ScQueryEntry::ByString && rItem.meType != ScQueryEntry::ByDate)
3054 return;
3055
3056 if (rItem.mbFormattedValue)
3057 return;
3058
3059 sal_uInt32 nIndex = 0;
3060 bool bNumber = mrDoc.GetFormatTable()->
3061 IsNumberFormat(rItem.maString.getString(), nIndex, rItem.mfVal);
3062
3063 // Advanced Filter creates only ByString queries that need to be
3064 // converted to ByValue if appropriate. rItem.mfVal now holds the value
3065 // if bNumber==true.
3066
3067 if (rItem.meType == ScQueryEntry::ByString)
3068 {
3069 bool bDateFormat = false;
3070 if (bNumber && CanOptimizeQueryStringToNumber( mrDoc.GetFormatTable(), nIndex, bDateFormat ))
3071 rItem.meType = ScQueryEntry::ByValue;
3072 if (!bDateFormat)
3073 return;
3074 }
3075
3076 // Double-check if the query by date is really appropriate.
3077
3078 if (bNumber && ((nIndex % SV_COUNTRY_LANGUAGE_OFFSET) != 0))
3079 {
3080 const SvNumberformat* pEntry = mrDoc.GetFormatTable()->GetEntry(nIndex);
3081 if (pEntry)
3082 {
3083 SvNumFormatType nNumFmtType = pEntry->GetType();
3084 if (!(nNumFmtType & SvNumFormatType::DATE) || (nNumFmtType & SvNumFormatType::TIME))
3085 rItem.meType = ScQueryEntry::ByValue; // not a date only
3086 else
3087 rItem.meType = ScQueryEntry::ByDate; // date only
3088 }
3089 else
3090 rItem.meType = ScQueryEntry::ByValue; // what the ... not a date
3091 }
3092 else
3093 rItem.meType = ScQueryEntry::ByValue; // not a date
3094 }
3095 };
3096
3097 void lcl_PrepareQuery( const ScDocument* pDoc, ScTable* pTab, ScQueryParam& rParam )
3098 {
3099 bool bTopTen = false;
3100 SCSIZE nEntryCount = rParam.GetEntryCount();
3101
3102 for ( SCSIZE i = 0; i < nEntryCount; ++i )
3103 {
3104 ScQueryEntry& rEntry = rParam.GetEntry(i);
3105 if (!rEntry.bDoQuery)
3106 continue;
3107
3108 ScQueryEntry::QueryItemsType& rItems = rEntry.GetQueryItems();
3109 std::for_each(rItems.begin(), rItems.end(), PrepareQueryItem(*pDoc));
3110
3111 if ( !bTopTen )
3112 {
3113 switch ( rEntry.eOp )
3114 {
3115 case SC_TOPVAL:
3116 case SC_BOTVAL:
3117 case SC_TOPPERC:
3118 case SC_BOTPERC:
3119 {
3120 bTopTen = true;
3121 }
3122 break;
3123 default:
3124 {
3125 }
3126 }
3127 }
3128 }
3129
3130 if ( bTopTen )
3131 {
3132 pTab->TopTenQuery( rParam );
3133 }
3134 }
3135
3136 }
3137
3138 void ScTable::PrepareQuery( ScQueryParam& rQueryParam )
3139 {
3140 lcl_PrepareQuery(&rDocument, this, rQueryParam);
3141 }
3142
3143 SCSIZE ScTable::Query(const ScQueryParam& rParamOrg, bool bKeepSub)
3144 {
3145 ScQueryParam aParam( rParamOrg );
3146 typedef std::unordered_set<OUString> StrSetType;
3147 StrSetType aStrSet;
3148
3149 bool bStarted = false;
3150 bool bOldResult = true;
3151 SCROW nOldStart = 0;
3152 SCROW nOldEnd = 0;
3153
3154 SCSIZE nCount = 0;
3155 SCROW nOutRow = 0;
3156 SCROW nHeader = aParam.bHasHeader ? 1 : 0;
3157
3158 lcl_PrepareQuery(&rDocument, this, aParam);
3159
3160 if (!aParam.bInplace)
3161 {
3162 nOutRow = aParam.nDestRow + nHeader;
3163 if (nHeader > 0)
3164 CopyData( aParam.nCol1, aParam.nRow1, aParam.nCol2, aParam.nRow1,
3165 aParam.nDestCol, aParam.nDestRow, aParam.nDestTab );
3166 }
3167
3168 sc::TableColumnBlockPositionSet blockPos( GetDoc(), nTab ); // cache mdds access
3169
3170 SCROW nRealRow2 = aParam.nRow2;
3171 for (SCROW j = aParam.nRow1 + nHeader; j <= nRealRow2; ++j)
3172 {
3173 bool bResult; // Filter result
3174 bool bValid = ValidQuery(j, aParam, nullptr, nullptr, nullptr, &blockPos);
3175 if (!bValid && bKeepSub) // Keep subtotals
3176 {
3177 for (SCCOL nCol=aParam.nCol1; nCol<=aParam.nCol2 && !bValid; nCol++)
3178 {
3179 ScRefCellValue aCell = GetCellValue(nCol, j);
3180 if (aCell.meType != CELLTYPE_FORMULA)
3181 continue;
3182
3183 if (!aCell.mpFormula->IsSubTotal())
3184 continue;
3185
3186 if (RefVisible(aCell.mpFormula))
3187 bValid = true;
3188 }
3189 }
3190 if (bValid)
3191 {
3192 if (aParam.bDuplicate)
3193 bResult = true;
3194 else
3195 {
3196 OUStringBuffer aStr;
3197 for (SCCOL k=aParam.nCol1; k <= aParam.nCol2; k++)
3198 {
3199 OUString aCellStr;
3200 GetString(k, j, aCellStr);
3201 aStr.append(aCellStr + u"\x0001");
3202 }
3203
3204 bResult = aStrSet.insert(aStr.makeStringAndClear()).second; // unique if inserted.
3205 }
3206 }
3207 else
3208 bResult = false;
3209
3210 if (aParam.bInplace)
3211 {
3212 if (bResult == bOldResult && bStarted)
3213 nOldEnd = j;
3214 else
3215 {
3216 if (bStarted)
3217 DBShowRows(nOldStart,nOldEnd, bOldResult);
3218 nOldStart = nOldEnd = j;
3219 bOldResult = bResult;
3220 }
3221 bStarted = true;
3222 }
3223 else
3224 {
3225 if (bResult)
3226 {
3227 CopyData( aParam.nCol1,j, aParam.nCol2,j, aParam.nDestCol,nOutRow,aParam.nDestTab );
3228 if( nTab == aParam.nDestTab ) // copy to self, changes may invalidate caching position hints
3229 blockPos.invalidate();
3230 ++nOutRow;
3231 }
3232 }
3233 if (bResult)
3234 ++nCount;
3235 }
3236
3237 if (aParam.bInplace && bStarted)
3238 DBShowRows(nOldStart,nOldEnd, bOldResult);
3239
3240 if (aParam.bInplace)
3241 SetDrawPageSize();
3242
3243 return nCount;
3244 }
3245
3246 bool ScTable::CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam)
3247 {
3248 bool bValid = true;
3249 std::unique_ptr<SCCOL[]> pFields(new SCCOL[nCol2-nCol1+1]);
3250 OUString aCellStr;
3251 SCCOL nCol = nCol1;
3252 OSL_ENSURE( rQueryParam.nTab != SCTAB_MAX, "rQueryParam.nTab no value, not bad but no good" );
3253 SCTAB nDBTab = (rQueryParam.nTab == SCTAB_MAX ? nTab : rQueryParam.nTab);
3254 SCROW nDBRow1 = rQueryParam.nRow1;
3255 SCCOL nDBCol2 = rQueryParam.nCol2;
3256 // First row must be column headers
3257 while (bValid && (nCol <= nCol2))
3258 {
3259 OUString aQueryStr;
3260 GetUpperCellString(nCol, nRow1, aQueryStr);
3261 bool bFound = false;
3262 SCCOL i = rQueryParam.nCol1;
3263 while (!bFound && (i <= nDBCol2))
3264 {
3265 if ( nTab == nDBTab )
3266 GetUpperCellString(i, nDBRow1, aCellStr);
3267 else
3268 rDocument.GetUpperCellString(i, nDBRow1, nDBTab, aCellStr);
3269 bFound = (aCellStr == aQueryStr);
3270 if (!bFound) i++;
3271 }
3272 if (bFound)
3273 pFields[nCol - nCol1] = i;
3274 else
3275 bValid = false;
3276 nCol++;
3277 }
3278 if (bValid)
3279 {
3280 sal_uLong nVisible = 0;
3281 for ( nCol=nCol1; nCol<=nCol2; nCol++ )
3282 nVisible += aCol[nCol].VisibleCount( nRow1+1, nRow2 );
3283
3284 if ( nVisible > SCSIZE_MAX / sizeof(void*) )
3285 {
3286 OSL_FAIL("too many filter criteria");
3287 nVisible = 0;
3288 }
3289
3290 SCSIZE nNewEntries = nVisible;
3291 rQueryParam.Resize( nNewEntries );
3292
3293 SCSIZE nIndex = 0;
3294 SCROW nRow = nRow1 + 1;
3295 svl::SharedStringPool& rPool = rDocument.GetSharedStringPool();
3296 while (nRow <= nRow2)
3297 {
3298 nCol = nCol1;
3299 while (nCol <= nCol2)
3300 {
3301 GetInputString( nCol, nRow, aCellStr );
3302 if (!aCellStr.isEmpty())
3303 {
3304 if (nIndex < nNewEntries)
3305 {
3306 rQueryParam.GetEntry(nIndex).nField = pFields[nCol - nCol1];
3307 rQueryParam.FillInExcelSyntax(rPool, aCellStr, nIndex, nullptr);
3308 nIndex++;
3309 if (nIndex < nNewEntries)
3310 rQueryParam.GetEntry(nIndex).eConnect = SC_AND;
3311 }
3312 else
3313 bValid = false;
3314 }
3315 nCol++;
3316 }
3317 nRow++;
3318 if (nIndex < nNewEntries)
3319 rQueryParam.GetEntry(nIndex).eConnect = SC_OR;
3320 }
3321 }
3322 return bValid;
3323 }
3324
3325 bool ScTable::CreateStarQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam)
3326 {
3327 // A valid StarQuery must be at least 4 columns wide. To be precise it
3328 // should be exactly 4 columns ...
3329 // Additionally, if this wasn't checked, a formula pointing to a valid 1-3
3330 // column Excel style query range immediately left to itself would result
3331 // in a circular reference when the field name or operator or value (first
3332 // to third query range column) is obtained (#i58354#). Furthermore, if the
3333 // range wasn't sufficiently specified data changes wouldn't flag formula
3334 // cells for recalculation.
3335 if (nCol2 - nCol1 < 3)
3336 return false;
3337
3338 bool bValid;
3339 OUString aCellStr;
3340 SCSIZE nIndex = 0;
3341 SCROW nRow = nRow1;
3342 OSL_ENSURE( rQueryParam.nTab != SCTAB_MAX, "rQueryParam.nTab no value, not bad but no good" );
3343 SCTAB nDBTab = (rQueryParam.nTab == SCTAB_MAX ? nTab : rQueryParam.nTab);
3344 SCROW nDBRow1 = rQueryParam.nRow1;
3345 SCCOL nDBCol2 = rQueryParam.nCol2;
3346
3347 SCSIZE nNewEntries = static_cast<SCSIZE>(nRow2-nRow1+1);
3348 rQueryParam.Resize( nNewEntries );
3349 svl::SharedStringPool& rPool = rDocument.GetSharedStringPool();
3350
3351 do
3352 {
3353 ScQueryEntry& rEntry = rQueryParam.GetEntry(nIndex);
3354
3355 bValid = false;
3356 // First column AND/OR
3357 if (nIndex > 0)
3358 {
3359 GetUpperCellString(nCol1, nRow, aCellStr);
3360 if ( aCellStr == ScResId(STR_TABLE_AND) )
3361 {
3362 rEntry.eConnect = SC_AND;
3363 bValid = true;
3364 }
3365 else if ( aCellStr == ScResId(STR_TABLE_OR) )
3366 {
3367 rEntry.eConnect = SC_OR;
3368 bValid = true;
3369 }
3370 }
3371 // Second column field name
3372 if ((nIndex < 1) || bValid)
3373 {
3374 bool bFound = false;
3375 GetUpperCellString(nCol1 + 1, nRow, aCellStr);
3376 for (SCCOL i=rQueryParam.nCol1; (i <= nDBCol2) && (!bFound); i++)
3377 {
3378 OUString aFieldStr;
3379 if ( nTab == nDBTab )
3380 GetUpperCellString(i, nDBRow1, aFieldStr);
3381 else
3382 rDocument.GetUpperCellString(i, nDBRow1, nDBTab, aFieldStr);
3383 bFound = (aCellStr == aFieldStr);
3384 if (bFound)
3385 {
3386 rEntry.nField = i;
3387 bValid = true;
3388 }
3389 else
3390 bValid = false;
3391 }
3392 }
3393 // Third column operator =<>...
3394 if (bValid)
3395 {
3396 GetUpperCellString(nCol1 + 2, nRow, aCellStr);
3397 if (aCellStr.startsWith("<"))
3398 {
3399 if (aCellStr[1] == '>')
3400 rEntry.eOp = SC_NOT_EQUAL;
3401 else if (aCellStr[1] == '=')
3402 rEntry.eOp = SC_LESS_EQUAL;
3403 else
3404 rEntry.eOp = SC_LESS;
3405 }
3406 else if (aCellStr.startsWith(">"))
3407 {
3408 if (aCellStr[1] == '=')
3409 rEntry.eOp = SC_GREATER_EQUAL;
3410 else
3411 rEntry.eOp = SC_GREATER;
3412 }
3413 else if (aCellStr.startsWith("="))
3414 rEntry.eOp = SC_EQUAL;
3415
3416 }
3417 // Fourth column values
3418 if (bValid)
3419 {
3420 OUString aStr;
3421 GetString(nCol1 + 3, nRow, aStr);
3422 rEntry.GetQueryItem().maString = rPool.intern(aStr);
3423 rEntry.bDoQuery = true;
3424 }
3425 nIndex++;
3426 nRow++;
3427 }
3428 while (bValid && (nRow <= nRow2) /* && (nIndex < MAXQUERY) */ );
3429 return bValid;
3430 }
3431
3432 bool ScTable::CreateQueryParam(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScQueryParam& rQueryParam)
3433 {
3434 SCSIZE i, nCount;
3435 PutInOrder(nCol1, nCol2);
3436 PutInOrder(nRow1, nRow2);
3437
3438 nCount = rQueryParam.GetEntryCount();
3439 for (i=0; i < nCount; i++)
3440 rQueryParam.GetEntry(i).Clear();
3441
3442 // Standard query table
3443 bool bValid = CreateStarQuery(nCol1, nRow1, nCol2, nRow2, rQueryParam);
3444 // Excel Query table
3445 if (!bValid)
3446 bValid = CreateExcelQuery(nCol1, nRow1, nCol2, nRow2, rQueryParam);
3447
3448 SvNumberFormatter* pFormatter = rDocument.GetFormatTable();
3449 nCount = rQueryParam.GetEntryCount();
3450 if (bValid)
3451 {
3452 // query type must be set
3453 for (i=0; i < nCount; i++)
3454 {
3455 ScQueryEntry::Item& rItem = rQueryParam.GetEntry(i).GetQueryItem();
3456 sal_uInt32 nIndex = 0;
3457 bool bNumber = pFormatter->IsNumberFormat(
3458 rItem.maString.getString(), nIndex, rItem.mfVal);
3459 bool bDateFormat = false;
3460 rItem.meType = bNumber && CanOptimizeQueryStringToNumber( pFormatter, nIndex, bDateFormat )
3461 ? ScQueryEntry::ByValue : (bDateFormat ? ScQueryEntry::ByDate : ScQueryEntry::ByString);
3462 }
3463 }
3464 else
3465 {
3466 for (i=0; i < nCount; i++)
3467 rQueryParam.GetEntry(i).Clear();
3468 }
3469 return bValid;
3470 }
3471
3472 bool ScTable::HasColHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const
3473 {
3474 if (nStartRow == nEndRow)
3475 // Assume only data.
3476 /* XXX NOTE: previous behavior still checked this one row and could
3477 * evaluate it has header row, but that doesn't make much sense. */
3478 return false;
3479
3480 if (nStartCol == nEndCol)
3481 {
3482 CellType eFirstCellType = GetCellType(nStartCol, nStartRow);
3483 CellType eSecondCellType = GetCellType(nStartCol, nStartRow+1);
3484 return ((eFirstCellType == CELLTYPE_STRING || eFirstCellType == CELLTYPE_EDIT) &&
3485 (eSecondCellType != CELLTYPE_STRING && eSecondCellType != CELLTYPE_EDIT));
3486 }
3487
3488 for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
3489 {
3490 CellType eType = GetCellType( nCol, nStartRow );
3491 // Any non-text cell in first row => not headers.
3492 if (eType != CELLTYPE_STRING && eType != CELLTYPE_EDIT)
3493 return false;
3494 }
3495
3496 // First row all text cells, any non-text cell in second row => headers.
3497 SCROW nTestRow = nStartRow + 1;
3498 for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
3499 {
3500 CellType eType = GetCellType( nCol, nTestRow );
3501 if (eType != CELLTYPE_STRING && eType != CELLTYPE_EDIT)
3502 return true;
3503 }
3504
3505 // Also second row all text cells => first row not headers.
3506 return false;
3507 }
3508
3509 bool ScTable::HasRowHeader( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) const
3510 {
3511 if (nStartCol == nEndCol)
3512 // Assume only data.
3513 /* XXX NOTE: previous behavior still checked this one column and could
3514 * evaluate it has header column, but that doesn't make much sense. */
3515 return false;
3516
3517 if (nStartRow == nEndRow)
3518 {
3519 CellType eFirstCellType = GetCellType(nStartCol, nStartRow);
3520 CellType eSecondCellType = GetCellType(nStartCol+1, nStartRow);
3521 return ((eFirstCellType == CELLTYPE_STRING || eFirstCellType == CELLTYPE_EDIT) &&
3522 (eSecondCellType != CELLTYPE_STRING && eSecondCellType != CELLTYPE_EDIT));
3523 }
3524
3525 for (SCROW nRow=nStartRow; nRow<=nEndRow; nRow++)
3526 {
3527 CellType eType = GetCellType( nStartCol, nRow );
3528 // Any non-text cell in first column => not headers.
3529 if (eType != CELLTYPE_STRING && eType != CELLTYPE_EDIT)
3530 return false;
3531 }
3532
3533 // First column all text cells, any non-text cell in second column => headers.
3534 SCCOL nTestCol = nStartCol + 1;
3535 for (SCROW nRow=nStartRow; nRow<=nEndRow; nRow++)
3536 {
3537 CellType eType = GetCellType( nRow, nTestCol );
3538 if (eType != CELLTYPE_STRING && eType != CELLTYPE_EDIT)
3539 return true;
3540 }
3541
3542 // Also second column all text cells => first column not headers.
3543 return false;
3544 }
3545
3546 void ScTable::GetFilterEntries( SCCOL nCol, SCROW nRow1, SCROW nRow2, ScFilterEntries& rFilterEntries )
3547 {
3548 sc::ColumnBlockConstPosition aBlockPos;
3549 aCol[nCol].InitBlockPosition(aBlockPos);
3550 aCol[nCol].GetFilterEntries(aBlockPos, nRow1, nRow2, rFilterEntries, false);
3551 }
3552
3553 void ScTable::GetFilteredFilterEntries(
3554 SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScQueryParam& rParam, ScFilterEntries& rFilterEntries, bool bFiltering )
3555 {
3556 sc::ColumnBlockConstPosition aBlockPos;
3557 aCol[nCol].InitBlockPosition(aBlockPos);
3558
3559 // remove the entry for this column from the query parameter
3560 ScQueryParam aParam( rParam );
3561 aParam.RemoveEntryByField(nCol);
3562
3563 lcl_PrepareQuery(&rDocument, this, aParam);
3564 for ( SCROW j = nRow1; j <= nRow2; ++j )
3565 {
3566 if (ValidQuery(j, aParam))
3567 {
3568 aCol[nCol].GetFilterEntries(aBlockPos, j, j, rFilterEntries, bFiltering);
3569 }
3570 }
3571 }
3572
3573 bool ScTable::GetDataEntries(SCCOL nCol, SCROW nRow, std::set<ScTypedStrData>& rStrings, bool bLimit)
3574 {
3575 return aCol[nCol].GetDataEntries( nRow, rStrings, bLimit );
3576 }
3577
3578 sal_uLong ScTable::GetCellCount() const
3579 {
3580 sal_uLong nCellCount = 0;
3581
3582 for ( SCCOL nCol=0; nCol < aCol.size(); nCol++ )
3583 nCellCount += aCol[nCol].GetCellCount();
3584
3585 return nCellCount;
3586 }
3587
3588 sal_uLong ScTable::GetWeightedCount() const
3589 {
3590 sal_uLong nCellCount = 0;
3591
3592 for ( SCCOL nCol=0; nCol < aCol.size(); nCol++ )
3593 nCellCount += aCol[nCol].GetWeightedCount();
3594
3595 return nCellCount;
3596 }
3597
3598 sal_uLong ScTable::GetWeightedCount(SCROW nStartRow, SCROW nEndRow) const
3599 {
3600 sal_uLong nCellCount = 0;
3601
3602 for ( SCCOL nCol=0; nCol < aCol.size(); nCol++ )
3603 nCellCount += aCol[nCol].GetWeightedCount(nStartRow, nEndRow);
3604
3605 return nCellCount;
3606 }
3607
3608 sal_uLong ScTable::GetCodeCount() const
3609 {
3610 sal_uLong nCodeCount = 0;
3611
3612 for ( SCCOL nCol=0; nCol < aCol.size(); nCol++ )
3613 if ( aCol[nCol].GetCellCount() )
3614 nCodeCount += aCol[nCol].GetCodeCount();
3615
3616 return nCodeCount;
3617 }
3618
3619 sal_Int32 ScTable::GetMaxStringLen( SCCOL nCol, SCROW nRowStart,
3620 SCROW nRowEnd, rtl_TextEncoding eCharSet ) const
3621 {
3622 if ( IsColValid( nCol ) )
3623 return aCol[nCol].GetMaxStringLen( nRowStart, nRowEnd, eCharSet );
3624 else
3625 return 0;
3626 }
3627
3628 sal_Int32 ScTable::GetMaxNumberStringLen(
3629 sal_uInt16& nPrecision, SCCOL nCol, SCROW nRowStart, SCROW nRowEnd ) const
3630 {
3631 if ( IsColValid( nCol ) )
3632 return aCol[nCol].GetMaxNumberStringLen( nPrecision, nRowStart, nRowEnd );
3633 else
3634 return 0;
3635 }
3636
3637 void ScTable::UpdateSelectionFunction( ScFunctionData& rData, const ScMarkData& rMark )
3638 {
3639 ScRangeList aRanges = rMark.GetMarkedRangesForTab( nTab );
3640 ScRange aMarkArea( ScAddress::UNINITIALIZED );
3641 if (rMark.IsMultiMarked())
3642 rMark.GetMultiMarkArea( aMarkArea );
3643 else if (rMark.IsMarked())
3644 rMark.GetMarkArea( aMarkArea );
3645 else
3646 {
3647 assert(!"ScTable::UpdateSelectionFunction - called without anything marked");
3648 aMarkArea.aStart.SetCol(0);
3649 aMarkArea.aEnd.SetCol(rDocument.MaxCol());
3650 }
3651 const SCCOL nStartCol = aMarkArea.aStart.Col();
3652 const SCCOL nEndCol = ClampToAllocatedColumns(aMarkArea.aEnd.Col());
3653 for (SCCOL nCol = nStartCol; nCol <= nEndCol && !rData.getError(); ++nCol)
3654 {
3655 if (mpColFlags && ColHidden(nCol))
3656 continue;
3657
3658 aCol[nCol].UpdateSelectionFunction(aRanges, rData, *mpHiddenRows);
3659 }
3660 }
3661
3662 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE