| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| |
| #include "sortparam.hxx" |
| #include "global.hxx" |
| #include "address.hxx" |
| #include "queryparam.hxx" |
| #include <tools/debug.hxx> |
| |
| |
| //------------------------------------------------------------------------ |
| |
| ScSortParam::ScSortParam() |
| { |
| Clear(); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScSortParam::ScSortParam( const ScSortParam& r ) : |
| nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2), |
| bHasHeader(r.bHasHeader),bByRow(r.bByRow),bCaseSens(r.bCaseSens), |
| bUserDef(r.bUserDef),nUserIndex(r.nUserIndex),bIncludePattern(r.bIncludePattern), |
| bInplace(r.bInplace), |
| nDestTab(r.nDestTab),nDestCol(r.nDestCol),nDestRow(r.nDestRow), |
| aCollatorLocale( r.aCollatorLocale ), aCollatorAlgorithm( r.aCollatorAlgorithm ) |
| { |
| for (sal_uInt16 i=0; i<MAXSORT; i++) |
| { |
| bDoSort[i] = r.bDoSort[i]; |
| nField[i] = r.nField[i]; |
| bAscending[i] = r.bAscending[i]; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| void ScSortParam::Clear() |
| { |
| nCol1=nCol2=nDestCol = 0; |
| nRow1=nRow2=nDestRow = 0; |
| nCompatHeader = 2; |
| nDestTab = 0; |
| nUserIndex = 0; |
| bHasHeader=bCaseSens=bUserDef = sal_False; |
| bByRow=bIncludePattern=bInplace = sal_True; |
| aCollatorLocale = ::com::sun::star::lang::Locale(); |
| aCollatorAlgorithm.Erase(); |
| |
| for (sal_uInt16 i=0; i<MAXSORT; i++) |
| { |
| bDoSort[i] = sal_False; |
| nField[i] = 0; |
| bAscending[i] = sal_True; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScSortParam& ScSortParam::operator=( const ScSortParam& r ) |
| { |
| nCol1 = r.nCol1; |
| nRow1 = r.nRow1; |
| nCol2 = r.nCol2; |
| nRow2 = r.nRow2; |
| bHasHeader = r.bHasHeader; |
| bCaseSens = r.bCaseSens; |
| bByRow = r.bByRow; |
| bUserDef = r.bUserDef; |
| nUserIndex = r.nUserIndex; |
| bIncludePattern = r.bIncludePattern; |
| bInplace = r.bInplace; |
| nDestTab = r.nDestTab; |
| nDestCol = r.nDestCol; |
| nDestRow = r.nDestRow; |
| aCollatorLocale = r.aCollatorLocale; |
| aCollatorAlgorithm = r.aCollatorAlgorithm; |
| |
| for (sal_uInt16 i=0; i<MAXSORT; i++) |
| { |
| bDoSort[i] = r.bDoSort[i]; |
| nField[i] = r.nField[i]; |
| bAscending[i] = r.bAscending[i]; |
| } |
| |
| return *this; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| sal_Bool ScSortParam::operator==( const ScSortParam& rOther ) const |
| { |
| sal_Bool bEqual = sal_False; |
| // Anzahl der Sorts gleich? |
| sal_uInt16 nLast = 0; |
| sal_uInt16 nOtherLast = 0; |
| while ( bDoSort[nLast++] && nLast < MAXSORT ) ; |
| while ( rOther.bDoSort[nOtherLast++] && nOtherLast < MAXSORT ) ; |
| nLast--; |
| nOtherLast--; |
| if ( (nLast == nOtherLast) |
| && (nCol1 == rOther.nCol1) |
| && (nRow1 == rOther.nRow1) |
| && (nCol2 == rOther.nCol2) |
| && (nRow2 == rOther.nRow2) |
| && (bHasHeader == rOther.bHasHeader) |
| && (bByRow == rOther.bByRow) |
| && (bCaseSens == rOther.bCaseSens) |
| && (bUserDef == rOther.bUserDef) |
| && (nUserIndex == rOther.nUserIndex) |
| && (bIncludePattern == rOther.bIncludePattern) |
| && (bInplace == rOther.bInplace) |
| && (nDestTab == rOther.nDestTab) |
| && (nDestCol == rOther.nDestCol) |
| && (nDestRow == rOther.nDestRow) |
| && (aCollatorLocale.Language == rOther.aCollatorLocale.Language) |
| && (aCollatorLocale.Country == rOther.aCollatorLocale.Country) |
| && (aCollatorLocale.Variant == rOther.aCollatorLocale.Variant) |
| && (aCollatorAlgorithm == rOther.aCollatorAlgorithm) |
| ) |
| { |
| bEqual = sal_True; |
| for ( sal_uInt16 i=0; i<=nLast && bEqual; i++ ) |
| { |
| bEqual = (nField[i] == rOther.nField[i]) && (bAscending[i] == rOther.bAscending[i]); |
| } |
| } |
| return bEqual; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScSortParam::ScSortParam( const ScSubTotalParam& rSub, const ScSortParam& rOld ) : |
| nCol1(rSub.nCol1),nRow1(rSub.nRow1),nCol2(rSub.nCol2),nRow2(rSub.nRow2), |
| bHasHeader(sal_True),bByRow(sal_True),bCaseSens(rSub.bCaseSens), |
| bUserDef(rSub.bUserDef),nUserIndex(rSub.nUserIndex),bIncludePattern(rSub.bIncludePattern), |
| bInplace(sal_True), |
| nDestTab(0),nDestCol(0),nDestRow(0), |
| aCollatorLocale( rOld.aCollatorLocale ), aCollatorAlgorithm( rOld.aCollatorAlgorithm ) |
| { |
| sal_uInt16 nNewCount = 0; |
| sal_uInt16 i; |
| |
| // zuerst die Gruppen aus den Teilergebnissen |
| if (rSub.bDoSort) |
| for (i=0; i<MAXSUBTOTAL; i++) |
| if (rSub.bGroupActive[i]) |
| { |
| if (nNewCount < MAXSORT) |
| { |
| bDoSort[nNewCount] = sal_True; |
| nField[nNewCount] = rSub.nField[i]; |
| bAscending[nNewCount] = rSub.bAscending; |
| ++nNewCount; |
| } |
| } |
| |
| // dann dahinter die alten Einstellungen |
| for (i=0; i<MAXSORT; i++) |
| if (rOld.bDoSort[i]) |
| { |
| SCCOLROW nThisField = rOld.nField[i]; |
| sal_Bool bDouble = sal_False; |
| for (sal_uInt16 j=0; j<nNewCount; j++) |
| if ( nField[j] == nThisField ) |
| bDouble = sal_True; |
| if (!bDouble) // ein Feld nicht zweimal eintragen |
| { |
| if (nNewCount < MAXSORT) |
| { |
| bDoSort[nNewCount] = sal_True; |
| nField[nNewCount] = nThisField; |
| bAscending[nNewCount] = rOld.bAscending[i]; |
| ++nNewCount; |
| } |
| } |
| } |
| |
| for (i=nNewCount; i<MAXSORT; i++) // Rest loeschen |
| { |
| bDoSort[i] = sal_False; |
| nField[i] = 0; |
| bAscending[i] = sal_True; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScSortParam::ScSortParam( const ScQueryParam& rParam, SCCOL nCol ) : |
| nCol1(nCol),nRow1(rParam.nRow1),nCol2(nCol),nRow2(rParam.nRow2), |
| bHasHeader(rParam.bHasHeader),bByRow(sal_True),bCaseSens(rParam.bCaseSens), |
| //! TODO: what about Locale and Algorithm? |
| bUserDef(sal_False),nUserIndex(0),bIncludePattern(sal_False), |
| bInplace(sal_True), |
| nDestTab(0),nDestCol(0),nDestRow(0) |
| { |
| bDoSort[0] = sal_True; |
| nField[0] = nCol; |
| bAscending[0] = sal_True; |
| for (sal_uInt16 i=1; i<MAXSORT; i++) |
| { |
| bDoSort[i] = sal_False; |
| nField[i] = 0; |
| bAscending[i] = sal_True; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| void ScSortParam::MoveToDest() |
| { |
| if (!bInplace) |
| { |
| SCsCOL nDifX = ((SCsCOL) nDestCol) - ((SCsCOL) nCol1); |
| SCsROW nDifY = ((SCsROW) nDestRow) - ((SCsROW) nRow1); |
| |
| nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX ); |
| nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY ); |
| nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX ); |
| nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY ); |
| for (sal_uInt16 i=0; i<MAXSORT; i++) |
| if (bByRow) |
| nField[i] += nDifX; |
| else |
| nField[i] += nDifY; |
| |
| bInplace = sal_True; |
| } |
| else |
| { |
| DBG_ERROR("MoveToDest, bInplace == TRUE"); |
| } |
| } |
| |
