Line data Source code
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 "sortparam.hxx"
21 : #include "global.hxx"
22 : #include "address.hxx"
23 : #include "queryparam.hxx"
24 : #include "subtotalparam.hxx"
25 :
26 4596 : ScSortParam::ScSortParam()
27 : {
28 4596 : Clear();
29 4596 : }
30 :
31 1040 : ScSortParam::ScSortParam( const ScSortParam& r ) :
32 : nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),nUserIndex(r.nUserIndex),
33 : bHasHeader(r.bHasHeader),bByRow(r.bByRow),bCaseSens(r.bCaseSens),
34 : bNaturalSort(r.bNaturalSort),bUserDef(r.bUserDef),
35 : bIncludePattern(r.bIncludePattern),bInplace(r.bInplace),
36 : nDestTab(r.nDestTab),nDestCol(r.nDestCol),nDestRow(r.nDestRow),
37 : maKeyState( r.maKeyState ),
38 : aCollatorLocale( r.aCollatorLocale ), aCollatorAlgorithm( r.aCollatorAlgorithm ),
39 1040 : nCompatHeader( r.nCompatHeader )
40 : {
41 1040 : }
42 :
43 5578 : ScSortParam::~ScSortParam() {}
44 :
45 4596 : void ScSortParam::Clear()
46 : {
47 : ScSortKeyState aKeyState;
48 :
49 4596 : nCol1=nCol2=nDestCol = 0;
50 4596 : nRow1=nRow2=nDestRow = 0;
51 4596 : nCompatHeader = 2;
52 4596 : nDestTab = 0;
53 4596 : nUserIndex = 0;
54 4596 : bHasHeader=bCaseSens=bUserDef=bNaturalSort = false;
55 4596 : bByRow=bIncludePattern=bInplace = true;
56 4596 : aCollatorLocale = ::com::sun::star::lang::Locale();
57 4596 : aCollatorAlgorithm = OUString();
58 :
59 4596 : aKeyState.bDoSort = false;
60 4596 : aKeyState.nField = 0;
61 4596 : aKeyState.bAscending = true;
62 :
63 : // Initialize to default size
64 4596 : maKeyState.assign( DEFSORT, aKeyState );
65 4596 : }
66 :
67 90 : ScSortParam& ScSortParam::operator=( const ScSortParam& r )
68 : {
69 90 : nCol1 = r.nCol1;
70 90 : nRow1 = r.nRow1;
71 90 : nCol2 = r.nCol2;
72 90 : nRow2 = r.nRow2;
73 90 : nUserIndex = r.nUserIndex;
74 90 : bHasHeader = r.bHasHeader;
75 90 : bByRow = r.bByRow;
76 90 : bCaseSens = r.bCaseSens;
77 90 : bNaturalSort = r.bNaturalSort;
78 90 : bUserDef = r.bUserDef;
79 90 : bIncludePattern = r.bIncludePattern;
80 90 : bInplace = r.bInplace;
81 90 : nDestTab = r.nDestTab;
82 90 : nDestCol = r.nDestCol;
83 90 : nDestRow = r.nDestRow;
84 90 : maKeyState = r.maKeyState;
85 90 : aCollatorLocale = r.aCollatorLocale;
86 90 : aCollatorAlgorithm = r.aCollatorAlgorithm;
87 90 : nCompatHeader = r.nCompatHeader;
88 :
89 90 : return *this;
90 : }
91 :
92 0 : bool ScSortParam::operator==( const ScSortParam& rOther ) const
93 : {
94 0 : bool bEqual = false;
95 : // Anzahl der Sorts gleich?
96 0 : sal_uInt16 nLast = 0;
97 0 : sal_uInt16 nOtherLast = 0;
98 0 : sal_uInt16 nSortSize = GetSortKeyCount();
99 :
100 0 : if ( !maKeyState.empty() )
101 : {
102 0 : while ( maKeyState[nLast++].bDoSort && nLast < nSortSize ) ;
103 0 : nLast--;
104 : }
105 :
106 0 : if ( !rOther.maKeyState.empty() )
107 : {
108 0 : while ( rOther.maKeyState[nOtherLast++].bDoSort && nOtherLast < nSortSize ) ;
109 0 : nOtherLast--;
110 : }
111 :
112 0 : if ( (nLast == nOtherLast)
113 0 : && (nCol1 == rOther.nCol1)
114 0 : && (nRow1 == rOther.nRow1)
115 0 : && (nCol2 == rOther.nCol2)
116 0 : && (nRow2 == rOther.nRow2)
117 0 : && (bHasHeader == rOther.bHasHeader)
118 0 : && (bByRow == rOther.bByRow)
119 0 : && (bCaseSens == rOther.bCaseSens)
120 0 : && (bNaturalSort == rOther.bNaturalSort)
121 0 : && (bUserDef == rOther.bUserDef)
122 0 : && (nUserIndex == rOther.nUserIndex)
123 0 : && (bIncludePattern == rOther.bIncludePattern)
124 0 : && (bInplace == rOther.bInplace)
125 0 : && (nDestTab == rOther.nDestTab)
126 0 : && (nDestCol == rOther.nDestCol)
127 0 : && (nDestRow == rOther.nDestRow)
128 0 : && (aCollatorLocale.Language == rOther.aCollatorLocale.Language)
129 0 : && (aCollatorLocale.Country == rOther.aCollatorLocale.Country)
130 0 : && (aCollatorLocale.Variant == rOther.aCollatorLocale.Variant)
131 0 : && (aCollatorAlgorithm == rOther.aCollatorAlgorithm)
132 0 : && ( !maKeyState.empty() || !rOther.maKeyState.empty() )
133 : )
134 : {
135 0 : bEqual = true;
136 0 : for ( sal_uInt16 i=0; i<=nLast && bEqual; i++ )
137 0 : bEqual = ( maKeyState[i].nField == rOther.maKeyState[i].nField ) &&
138 0 : ( maKeyState[i].bAscending == rOther.maKeyState[i].bAscending );
139 : }
140 0 : if ( maKeyState.empty() && rOther.maKeyState.empty() )
141 0 : bEqual = true;
142 :
143 0 : return bEqual;
144 : }
145 :
146 2 : ScSortParam::ScSortParam( const ScSubTotalParam& rSub, const ScSortParam& rOld ) :
147 : nCol1(rSub.nCol1),nRow1(rSub.nRow1),nCol2(rSub.nCol2),nRow2(rSub.nRow2),nUserIndex(rSub.nUserIndex),
148 : bHasHeader(true),bByRow(true),bCaseSens(rSub.bCaseSens),bNaturalSort(rOld.bNaturalSort),
149 : bUserDef(rSub.bUserDef),bIncludePattern(rSub.bIncludePattern),
150 : bInplace(true),
151 : nDestTab(0),nDestCol(0),nDestRow(0),
152 : aCollatorLocale( rOld.aCollatorLocale ), aCollatorAlgorithm( rOld.aCollatorAlgorithm ),
153 2 : nCompatHeader( rOld.nCompatHeader )
154 : {
155 : sal_uInt16 i;
156 :
157 : // zuerst die Gruppen aus den Teilergebnissen
158 2 : if (rSub.bDoSort)
159 8 : for (i=0; i<MAXSUBTOTAL; i++)
160 6 : if (rSub.bGroupActive[i])
161 : {
162 : ScSortKeyState key;
163 2 : key.bDoSort = true;
164 2 : key.nField = rSub.nField[i];
165 2 : key.bAscending = rSub.bAscending;
166 2 : maKeyState.push_back(key);
167 : }
168 :
169 : // dann dahinter die alten Einstellungen
170 8 : for (i=0; i < rOld.GetSortKeyCount(); i++)
171 6 : if (rOld.maKeyState[i].bDoSort)
172 : {
173 0 : SCCOLROW nThisField = rOld.maKeyState[i].nField;
174 0 : bool bDouble = false;
175 0 : for (sal_uInt16 j = 0; j < GetSortKeyCount(); j++)
176 0 : if ( maKeyState[j].nField == nThisField )
177 0 : bDouble = true;
178 0 : if (!bDouble) // ein Feld nicht zweimal eintragen
179 : {
180 : ScSortKeyState key;
181 0 : key.bDoSort = true;
182 0 : key.nField = nThisField;
183 0 : key.bAscending = rOld.maKeyState[i].bAscending;
184 0 : maKeyState.push_back(key);
185 : }
186 : }
187 2 : }
188 :
189 0 : ScSortParam::ScSortParam( const ScQueryParam& rParam, SCCOL nCol ) :
190 : nCol1(nCol),nRow1(rParam.nRow1),nCol2(nCol),nRow2(rParam.nRow2),nUserIndex(0),
191 : bHasHeader(rParam.bHasHeader),bByRow(true),bCaseSens(rParam.bCaseSens),
192 : bNaturalSort(false),
193 : //! TODO: what about Locale and Algorithm?
194 : bUserDef(false),bIncludePattern(false),
195 : bInplace(true),
196 0 : nDestTab(0),nDestCol(0),nDestRow(0), nCompatHeader(2)
197 : {
198 : ScSortKeyState aKeyState;
199 0 : aKeyState.bDoSort = true;
200 0 : aKeyState.nField = nCol;
201 0 : aKeyState.bAscending = true;
202 :
203 0 : maKeyState.push_back( aKeyState );
204 :
205 : // Set the rest
206 0 : aKeyState.bDoSort = false;
207 0 : aKeyState.nField = 0;
208 :
209 0 : for (sal_uInt16 i=1; i<GetSortKeyCount(); i++)
210 0 : maKeyState.push_back( aKeyState );
211 0 : }
212 :
213 2 : void ScSortParam::MoveToDest()
214 : {
215 2 : if (!bInplace)
216 : {
217 2 : SCsCOL nDifX = ((SCsCOL) nDestCol) - ((SCsCOL) nCol1);
218 2 : SCsROW nDifY = ((SCsROW) nDestRow) - ((SCsROW) nRow1);
219 :
220 2 : nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX );
221 2 : nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY );
222 2 : nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX );
223 2 : nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY );
224 8 : for (sal_uInt16 i=0; i<GetSortKeyCount(); i++)
225 6 : if (bByRow)
226 6 : maKeyState[i].nField += nDifX;
227 : else
228 0 : maKeyState[i].nField += nDifY;
229 :
230 2 : bInplace = true;
231 : }
232 : else
233 : {
234 : OSL_FAIL("MoveToDest, bInplace == TRUE");
235 : }
236 2 : }
237 :
238 : namespace sc {
239 :
240 : namespace {
241 :
242 : struct ReorderIndex
243 : {
244 : struct LessByPos2 : std::binary_function<ReorderIndex, ReorderIndex, bool>
245 : {
246 230 : bool operator() ( const ReorderIndex& r1, const ReorderIndex& r2 ) const
247 : {
248 230 : return r1.mnPos2 < r2.mnPos2;
249 : }
250 : };
251 :
252 : SCCOLROW mnPos1;
253 : SCCOLROW mnPos2;
254 :
255 100 : ReorderIndex( SCCOLROW nPos1, SCCOLROW nPos2 ) : mnPos1(nPos1), mnPos2(nPos2) {}
256 : };
257 :
258 : }
259 :
260 18 : void ReorderParam::reverse()
261 : {
262 : SCCOLROW nStart;
263 18 : if (mbByRow)
264 14 : nStart = maSortRange.aStart.Row();
265 : else
266 4 : nStart = maSortRange.aStart.Col();
267 :
268 18 : size_t n = maOrderIndices.size();
269 18 : std::vector<ReorderIndex> aBucket;
270 18 : aBucket.reserve(n);
271 118 : for (size_t i = 0; i < n; ++i)
272 : {
273 100 : SCCOLROW nPos1 = i + nStart;
274 100 : SCCOLROW nPos2 = maOrderIndices[i];
275 100 : aBucket.push_back(ReorderIndex(nPos1, nPos2));
276 : }
277 :
278 18 : std::sort(aBucket.begin(), aBucket.end(), ReorderIndex::LessByPos2());
279 36 : std::vector<SCCOLROW> aNew;
280 18 : aNew.reserve(n);
281 118 : for (size_t i = 0; i < n; ++i)
282 100 : aNew.push_back(aBucket[i].mnPos1);
283 :
284 36 : maOrderIndices.swap(aNew);
285 18 : }
286 :
287 228 : }
288 :
289 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
