[Libreoffice-commits] .: sc/inc sc/source

Markus Mohrhard mmohrhard at kemper.freedesktop.org
Sat Mar 31 09:34:05 PDT 2012


 sc/inc/sortparam.hxx                             |   23 -
 sc/source/core/data/sortparam.cxx                |   98 +++---
 sc/source/core/data/table3.cxx                   |   24 -
 sc/source/core/tool/dbdata.cxx                   |   14 
 sc/source/filter/xml/XMLExportDatabaseRanges.cxx |    8 
 sc/source/filter/xml/xmldrani.cxx                |    6 
 sc/source/ui/dbgui/tpsort.cxx                    |  343 ++++++++++++-----------
 sc/source/ui/docshell/dbdocfun.cxx               |    6 
 sc/source/ui/inc/tpsort.hxx                      |   18 -
 sc/source/ui/src/sortdlg.src                     |    6 
 sc/source/ui/unoobj/cellsuno.cxx                 |   16 -
 sc/source/ui/unoobj/datauno.cxx                  |   52 +--
 sc/source/ui/vba/vbarange.cxx                    |   18 -
 sc/source/ui/view/cellsh2.cxx                    |   62 ++--
 sc/source/ui/view/dbfunc3.cxx                    |    2 
 15 files changed, 354 insertions(+), 342 deletions(-)

New commits:
commit 1c78b6dc0d10eb5873c45d6185576633470a593d
Author: Markus Mohrhard <markus.mohrhard at googlemail.com>
Date:   Sat Mar 31 18:33:21 2012 +0200

    revert "remove limitation to 3 sort entries in calc part1"

diff --git a/sc/inc/sortparam.hxx b/sc/inc/sortparam.hxx
index 5f1fee0..f1d4e21 100644
--- a/sc/inc/sortparam.hxx
+++ b/sc/inc/sortparam.hxx
@@ -29,27 +29,16 @@
 #ifndef SC_SORTPARAM_HXX
 #define SC_SORTPARAM_HXX
 
-#define DEFSORT 3
-
-#include <vector>
-
 #include "address.hxx"
 #include <tools/solar.h>
 #include <com/sun/star/lang/Locale.hpp>
 #include "scdllapi.h"
 
+#define MAXSORT 3
+
 struct ScSubTotalParam;
 struct ScQueryParam;
 
-struct ScSortKeyState
-{
-    bool     bDoSort;
-    SCCOLROW nField;
-    bool     bAscending;
-};
-
-typedef ::std::vector<ScSortKeyState> ScSortKeyStateVec;
-
 struct SC_DLLPUBLIC ScSortParam
 {
     SCCOL       nCol1;
@@ -67,12 +56,13 @@ struct SC_DLLPUBLIC ScSortParam
     SCTAB       nDestTab;
     SCCOL       nDestCol;
     SCROW       nDestRow;
-    ScSortKeyStateVec maKeyState;
+    bool        bDoSort[MAXSORT];
+    SCCOLROW    nField[MAXSORT];
+    bool        bAscending[MAXSORT];
     ::com::sun::star::lang::Locale aCollatorLocale;
     ::rtl::OUString aCollatorAlgorithm;
     sal_uInt16  nCompatHeader;
 
-
     ScSortParam();
     ScSortParam( const ScSortParam& r );
     /// SubTotals sort
@@ -83,9 +73,8 @@ struct SC_DLLPUBLIC ScSortParam
     ScSortParam&    operator=  ( const ScSortParam& r );
     bool            operator== ( const ScSortParam& rOther ) const;
     void            Clear       ();
-    void            MoveToDest();
 
-    inline sal_uInt16 GetSortKeyCount() const { return maKeyState.size(); }
+    void            MoveToDest();
 };
 
 
diff --git a/sc/source/core/data/sortparam.cxx b/sc/source/core/data/sortparam.cxx
index b7788e5..26e1ac7 100644
--- a/sc/source/core/data/sortparam.cxx
+++ b/sc/source/core/data/sortparam.cxx
@@ -51,10 +51,15 @@ ScSortParam::ScSortParam( const ScSortParam& r ) :
         bNaturalSort(r.bNaturalSort),bUserDef(r.bUserDef),
         bIncludePattern(r.bIncludePattern),bInplace(r.bInplace),
         nDestTab(r.nDestTab),nDestCol(r.nDestCol),nDestRow(r.nDestRow),
-        maKeyState( r.maKeyState ),
         aCollatorLocale( r.aCollatorLocale ), aCollatorAlgorithm( r.aCollatorAlgorithm ),
         nCompatHeader( r.nCompatHeader )
 {
+    for (sal_uInt16 i=0; i<MAXSORT; i++)
+    {
+        bDoSort[i]    = r.bDoSort[i];
+        nField[i]     = r.nField[i];
+        bAscending[i] = r.bAscending[i];
+    }
 }
 
 //------------------------------------------------------------------------
@@ -71,8 +76,12 @@ void ScSortParam::Clear()
     aCollatorLocale = ::com::sun::star::lang::Locale();
     aCollatorAlgorithm = ::rtl::OUString();
 
-    // Initialize to default size
-    maKeyState.assign( DEFSORT, { false, 0, true } );
+    for (sal_uInt16 i=0; i<MAXSORT; i++)
+    {
+        bDoSort[i]    = false;
+        nField[i]     = 0;
+        bAscending[i] = true;
+    }
 }
 
 //------------------------------------------------------------------------
@@ -94,11 +103,17 @@ ScSortParam& ScSortParam::operator=( const ScSortParam& r )
     nDestTab        = r.nDestTab;
     nDestCol        = r.nDestCol;
     nDestRow        = r.nDestRow;
-    maKeyState      = r.maKeyState;
     aCollatorLocale         = r.aCollatorLocale;
     aCollatorAlgorithm      = r.aCollatorAlgorithm;
     nCompatHeader   = r.nCompatHeader;
 
+    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;
 }
 
@@ -110,20 +125,10 @@ bool ScSortParam::operator==( const ScSortParam& rOther ) const
     // Anzahl der Sorts gleich?
     sal_uInt16 nLast      = 0;
     sal_uInt16 nOtherLast = 0;
-    sal_uInt16 nSortSize = GetSortKeyCount();
-
-    if ( !maKeyState.empty() )
-    {
-        while ( maKeyState[nLast++].bDoSort && nLast < nSortSize ) ;
-        nLast--;
-    }
-
-    if ( !rOther.maKeyState.empty() )
-    {
-        while ( rOther.maKeyState[nOtherLast++].bDoSort && nOtherLast < nSortSize ) ;
-        nOtherLast--;
-    }
-
+    while ( bDoSort[nLast++] && nLast < MAXSORT ) ;
+    while ( rOther.bDoSort[nOtherLast++] && nOtherLast < MAXSORT ) ;
+    nLast--;
+    nOtherLast--;
     if (   (nLast           == nOtherLast)
         && (nCol1           == rOther.nCol1)
         && (nRow1           == rOther.nRow1)
@@ -144,17 +149,14 @@ bool ScSortParam::operator==( const ScSortParam& rOther ) const
         && (aCollatorLocale.Country     == rOther.aCollatorLocale.Country)
         && (aCollatorLocale.Variant     == rOther.aCollatorLocale.Variant)
         && (aCollatorAlgorithm          == rOther.aCollatorAlgorithm)
-        && ( !maKeyState.empty() || !rOther.maKeyState.empty() )
         )
     {
         bEqual = true;
         for ( sal_uInt16 i=0; i<=nLast && bEqual; i++ )
-            bEqual = ( maKeyState[i].nField == rOther.maKeyState[i].nField ) &&
-                ( maKeyState[i].bAscending  == rOther.maKeyState[i].bAscending );
+        {
+            bEqual = (nField[i] == rOther.nField[i]) && (bAscending[i]  == rOther.bAscending[i]);
+        }
     }
-    if ( maKeyState.empty() && rOther.maKeyState.empty() )
-        bEqual = true;
-
     return bEqual;
 }
 
@@ -170,7 +172,6 @@ ScSortParam::ScSortParam( const ScSubTotalParam& rSub, const ScSortParam& rOld )
         nCompatHeader( rOld.nCompatHeader )
 {
     sal_uInt16 nNewCount = 0;
-    sal_uInt16 nSortSize = GetSortKeyCount();
     sal_uInt16 i;
 
     //  zuerst die Gruppen aus den Teilergebnissen
@@ -178,34 +179,42 @@ ScSortParam::ScSortParam( const ScSubTotalParam& rSub, const ScSortParam& rOld )
         for (i=0; i<MAXSUBTOTAL; i++)
             if (rSub.bGroupActive[i])
             {
-                if (nNewCount < nSortSize)
+                if (nNewCount < MAXSORT)
                 {
-                    maKeyState[nNewCount] = { true, rSub.nField[i], rSub.bAscending };
+                    bDoSort[nNewCount]    = true;
+                    nField[nNewCount]     = rSub.nField[i];
+                    bAscending[nNewCount] = rSub.bAscending;
                     ++nNewCount;
                 }
             }
 
     //  dann dahinter die alten Einstellungen
-    for (i=0; i<nSortSize; i++)
-        if (rOld.maKeyState[i].bDoSort)
+    for (i=0; i<MAXSORT; i++)
+        if (rOld.bDoSort[i])
         {
-            SCCOLROW nThisField = rOld.maKeyState[i].nField;
+            SCCOLROW nThisField = rOld.nField[i];
             bool bDouble = false;
             for (sal_uInt16 j=0; j<nNewCount; j++)
-                if ( maKeyState[j].nField == nThisField )
+                if ( nField[j] == nThisField )
                     bDouble = true;
             if (!bDouble)               // ein Feld nicht zweimal eintragen
             {
-                if (nNewCount < nSortSize)
+                if (nNewCount < MAXSORT)
                 {
-                    maKeyState[nNewCount] = { true, nThisField, rOld.maKeyState[i].bAscending };
+                    bDoSort[nNewCount]    = true;
+                    nField[nNewCount]     = nThisField;
+                    bAscending[nNewCount] = rOld.bAscending[i];
                     ++nNewCount;
                 }
             }
         }
 
-    for (i=nNewCount; i<nSortSize; i++)       // Rest loeschen
-        maKeyState.push_back( ScSortKeyState({ false, 0, true }) );
+    for (i=nNewCount; i<MAXSORT; i++)       // Rest loeschen
+    {
+        bDoSort[i]    = false;
+        nField[i]     = 0;
+        bAscending[i] = true;
+    }
 }
 
 //------------------------------------------------------------------------
@@ -219,10 +228,15 @@ ScSortParam::ScSortParam( const ScQueryParam& rParam, SCCOL nCol ) :
         bInplace(true),
         nDestTab(0),nDestCol(0),nDestRow(0), nCompatHeader(2)
 {
-    maKeyState.push_back( ScSortKeyState( { true, nCol, true } ) );
-
-    for (sal_uInt16 i=1; i<GetSortKeyCount(); i++)
-        maKeyState.push_back( ScSortKeyState( { false, 0, true } ) );
+    bDoSort[0] = true;
+    nField[0] = nCol;
+    bAscending[0] = true;
+    for (sal_uInt16 i=1; i<MAXSORT; i++)
+    {
+        bDoSort[i]    = false;
+        nField[i]     = 0;
+        bAscending[i] = true;
+    }
 }
 
 //------------------------------------------------------------------------
@@ -238,11 +252,11 @@ void ScSortParam::MoveToDest()
         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<GetSortKeyCount(); i++)
+        for (sal_uInt16 i=0; i<MAXSORT; i++)
             if (bByRow)
-                maKeyState[i].nField += nDifX;
+                nField[i] += nDifX;
             else
-                maKeyState[i].nField += nDifY;
+                nField[i] += nDifY;
 
         bInplace = true;
     }
diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx
index 3310956..d740a30 100644
--- a/sc/source/core/data/table3.cxx
+++ b/sc/source/core/data/table3.cxx
@@ -270,14 +270,14 @@ public:
 ScSortInfoArray* ScTable::CreateSortInfoArray( SCCOLROW nInd1, SCCOLROW nInd2 )
 {
     sal_uInt16 nUsedSorts = 1;
-    while ( nUsedSorts < nMaxSorts && aSortParam.maKeyState[nUsedSorts].bDoSort )
+    while ( nUsedSorts < nMaxSorts && aSortParam.bDoSort[nUsedSorts] )
         nUsedSorts++;
     ScSortInfoArray* pArray = new ScSortInfoArray( nUsedSorts, nInd1, nInd2 );
     if ( aSortParam.bByRow )
     {
         for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
         {
-            SCCOL nCol = static_cast<SCCOL>(aSortParam.maKeyState[nSort].nField);
+            SCCOL nCol = static_cast<SCCOL>(aSortParam.nField[nSort]);
             ScColumn* pCol = &aCol[nCol];
             for ( SCROW nRow = nInd1; nRow <= nInd2; nRow++ )
             {
@@ -292,7 +292,7 @@ ScSortInfoArray* ScTable::CreateSortInfoArray( SCCOLROW nInd1, SCCOLROW nInd2 )
     {
         for ( sal_uInt16 nSort = 0; nSort < nUsedSorts; nSort++ )
         {
-            SCROW nRow = aSortParam.maKeyState[nSort].nField;
+            SCROW nRow = aSortParam.nField[nSort];
             for ( SCCOL nCol = static_cast<SCCOL>(nInd1);
                     nCol <= static_cast<SCCOL>(nInd2); nCol++ )
             {
@@ -473,7 +473,7 @@ short ScTable::CompareCell( sal_uInt16 nSort,
                 else if (nVal1 > nVal2)
                     nRes = 1;
             }
-            if ( !aSortParam.maKeyState[nSort].bAscending )
+            if ( !aSortParam.bAscending[nSort] )
                 nRes = -nRes;
         }
         else
@@ -499,12 +499,12 @@ short ScTable::Compare( ScSortInfoArray* pArray, SCCOLROW nIndex1, SCCOLROW nInd
         ScSortInfo* pInfo2 = pArray->Get( nSort, nIndex2 );
         if ( aSortParam.bByRow )
             nRes = CompareCell( nSort,
-                pInfo1->pCell, static_cast<SCCOL>(aSortParam.maKeyState[nSort].nField), pInfo1->nOrg,
-                pInfo2->pCell, static_cast<SCCOL>(aSortParam.maKeyState[nSort].nField), pInfo2->nOrg );
+                pInfo1->pCell, static_cast<SCCOL>(aSortParam.nField[nSort]), pInfo1->nOrg,
+                pInfo2->pCell, static_cast<SCCOL>(aSortParam.nField[nSort]), pInfo2->nOrg );
         else
             nRes = CompareCell( nSort,
-                pInfo1->pCell, static_cast<SCCOL>(pInfo1->nOrg), aSortParam.maKeyState[nSort].nField,
-                pInfo2->pCell, static_cast<SCCOL>(pInfo2->nOrg), aSortParam.maKeyState[nSort].nField );
+                pInfo1->pCell, static_cast<SCCOL>(pInfo1->nOrg), aSortParam.nField[nSort],
+                pInfo2->pCell, static_cast<SCCOL>(pInfo2->nOrg), aSortParam.nField[nSort] );
     } while ( nRes == 0 && ++nSort < pArray->GetUsedSorts() );
     if( nRes == 0 )
     {
@@ -684,22 +684,22 @@ short ScTable::Compare(SCCOLROW nIndex1, SCCOLROW nIndex2)
     {
         do
         {
-            SCCOL nCol = static_cast<SCCOL>(aSortParam.maKeyState[nSort].nField);
+            SCCOL nCol = static_cast<SCCOL>(aSortParam.nField[nSort]);
             ScBaseCell* pCell1 = aCol[nCol].GetCell( nIndex1 );
             ScBaseCell* pCell2 = aCol[nCol].GetCell( nIndex2 );
             nRes = CompareCell( nSort, pCell1, nCol, nIndex1, pCell2, nCol, nIndex2 );
-        } while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.maKeyState[nSort].bDoSort );
+        } while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.bDoSort[nSort] );
     }
     else
     {
         do
         {
-            SCROW nRow = aSortParam.maKeyState[nSort].nField;
+            SCROW nRow = aSortParam.nField[nSort];
             ScBaseCell* pCell1 = aCol[nIndex1].GetCell( nRow );
             ScBaseCell* pCell2 = aCol[nIndex2].GetCell( nRow );
             nRes = CompareCell( nSort, pCell1, static_cast<SCCOL>(nIndex1),
                     nRow, pCell2, static_cast<SCCOL>(nIndex2), nRow );
-        } while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.maKeyState[nSort].bDoSort );
+        } while ( nRes == 0 && ++nSort < nMaxSorts && aSortParam.bDoSort[nSort] );
     }
     return nRes;
 }
diff --git a/sc/source/core/tool/dbdata.cxx b/sc/source/core/tool/dbdata.cxx
index 4c14735..c612d32 100644
--- a/sc/source/core/tool/dbdata.cxx
+++ b/sc/source/core/tool/dbdata.cxx
@@ -246,7 +246,7 @@ ScDBData::~ScDBData()
             aBuf.append(ScGlobal::GetRscString(STR_OPERATION_FILTER));
     }
 
-    if (mpSortParam->maKeyState[0].bDoSort)
+    if (mpSortParam->bDoSort[0])
     {
         if (aBuf.getLength())
             aBuf.appendAscii(RTL_CONSTASCII_STRINGPARAM(", "));
@@ -299,13 +299,13 @@ void ScDBData::MoveTo(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW n
     long nSortDif = bByRow ? nDifX : nDifY;
     long nSortEnd = bByRow ? static_cast<long>(nCol2) : static_cast<long>(nRow2);
 
-    for (i=0; i<mpSortParam->GetSortKeyCount(); i++)
+    for (i=0; i<MAXSORT; i++)
     {
-        mpSortParam->maKeyState[i].nField += nSortDif;
-        if (mpSortParam->maKeyState[i].nField > nSortEnd)
+        mpSortParam->nField[i] += nSortDif;
+        if (mpSortParam->nField[i] > nSortEnd)
         {
-            mpSortParam->maKeyState[i].nField = 0;
-            mpSortParam->maKeyState[i].bDoSort = false;
+            mpSortParam->nField[i] = 0;
+            mpSortParam->bDoSort[i] = false;
         }
     }
 
@@ -460,7 +460,7 @@ bool ScDBData::HasQueryParam() const
 
 bool ScDBData::HasSortParam() const
 {
-    return mpSortParam && mpSortParam->maKeyState[0].bDoSort;
+    return mpSortParam && mpSortParam->bDoSort[0];
 }
 
 bool ScDBData::HasSubTotalParam() const
diff --git a/sc/source/filter/xml/XMLExportDatabaseRanges.cxx b/sc/source/filter/xml/XMLExportDatabaseRanges.cxx
index 551c035..8aab8b5 100644
--- a/sc/source/filter/xml/XMLExportDatabaseRanges.cxx
+++ b/sc/source/filter/xml/XMLExportDatabaseRanges.cxx
@@ -317,9 +317,9 @@ private:
 
         // Count sort items first.
         size_t nSortCount = 0;
-        for (; nSortCount < aParam.GetSortKeyCount(); ++nSortCount)
+        for (; nSortCount < MAXSORT; ++nSortCount)
         {
-            if (!aParam.maKeyState[nSortCount].bDoSort)
+            if (!aParam.bDoSort[nSortCount])
                 break;
         }
 
@@ -359,10 +359,10 @@ private:
         for (size_t i = 0; i < nSortCount; ++i)
         {
             // Convert field value from absolute to relative.
-            SCCOLROW nField = aParam.maKeyState[i].nField - nFieldStart;
+            SCCOLROW nField = aParam.nField[i] - nFieldStart;
             mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, OUString::valueOf(nField));
 
-            if (!aParam.maKeyState[i].bAscending)
+            if (!aParam.bAscending[i])
                 mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ORDER, XML_DESCENDING);
 
             if (aParam.bUserDef)
diff --git a/sc/source/filter/xml/xmldrani.cxx b/sc/source/filter/xml/xmldrani.cxx
index c622255..37c4471 100644
--- a/sc/source/filter/xml/xmldrani.cxx
+++ b/sc/source/filter/xml/xmldrani.cxx
@@ -370,11 +370,11 @@ ScDBData* ScXMLDatabaseRangeContext::ConvertToDBData(const OUString& rName)
         ScSortDescriptor::FillSortParam(aParam, aSortSequence);
 
         SCCOLROW nStartPos = aParam.bByRow ? maRange.aStart.Col() : maRange.aStart.Row();
-        for (size_t i = 0; i < aParam.GetSortKeyCount(); ++i)
+        for (size_t i = 0; i < MAXSORT; ++i)
         {
-            if (!aParam.maKeyState[i].bDoSort)
+            if (!aParam.bDoSort[i])
                 break;
-            aParam.maKeyState[i].nField += nStartPos;
+            aParam.nField[i] += nStartPos;
         }
 
         pData->SetSortParam(aParam);
diff --git a/sc/source/ui/dbgui/tpsort.cxx b/sc/source/ui/dbgui/tpsort.cxx
index a964391..f2cc430 100644
--- a/sc/source/ui/dbgui/tpsort.cxx
+++ b/sc/source/ui/dbgui/tpsort.cxx
@@ -114,10 +114,7 @@ ScTabPageSortFields::ScTabPageSortFields( Window*           pParent,
         rSortData       ( ((const ScSortItem&)
                            rArgSet.Get( nWhichSort )).
                                 GetSortData() ),
-        aNewSortData    ( rSortData ),
         nFieldCount     ( 0 ),
-        nSortKeyCount   ( DEFSORT ),
-        nCurrentOffset  ( 0 ),
         bHasHeader      ( false ),
         bSortByRows     ( false )
 {
@@ -131,6 +128,7 @@ ScTabPageSortFields::ScTabPageSortFields( Window*           pParent,
 ScTabPageSortFields::~ScTabPageSortFields()
 {
 }
+
 // -----------------------------------------------------------------------
 
 void ScTabPageSortFields::Init()
@@ -142,19 +140,7 @@ void ScTabPageSortFields::Init()
 
     OSL_ENSURE( pViewData, "ViewData not found!" );
 
-    // Create local copy of ScParam
-    aNewSortData = rSortData;
-
-    if (pDlg)
-    {
-        const SfxItemSet* pExample = pDlg->GetExampleSet();
-        const SfxPoolItem* pItem;
-        if ( pExample && pExample->GetItemState( nWhichSort, sal_True, &pItem ) == SFX_ITEM_SET )
-            aNewSortData = static_cast<const ScSortItem*>(pItem)->GetSortData();
-    }
-
-    // Connect handlers and widgets
-    nFieldArr.push_back( 0 );
+    nFieldArr[0] = 0;
     nFirstCol = 0;
     nFirstRow = 0;
 
@@ -165,10 +151,18 @@ void ScTabPageSortFields::Init()
     aLbSort2.Clear();
     aLbSort3.Clear();
 
-    aLbSortArr = { &aLbSort1,  &aLbSort2,  &aLbSort3 };
-    aBtnUp     = { &aBtnUp1,   &aBtnUp2,   &aBtnUp3 };
-    aBtnDown   = { &aBtnDown1, &aBtnDown2, &aBtnDown3 };
-    aFlArr     = { &aFlSort1,  &aFlSort2,  &aFlSort3 };
+    aSortLbArr[0]       = &aLbSort1;
+    aSortLbArr[1]       = &aLbSort2;
+    aSortLbArr[2]       = &aLbSort3;
+    aDirBtnArr[0][0]    = &aBtnUp1;
+    aDirBtnArr[0][1]    = &aBtnDown1;
+    aDirBtnArr[1][0]    = &aBtnUp2;
+    aDirBtnArr[1][1]    = &aBtnDown2;
+    aDirBtnArr[2][0]    = &aBtnUp3;
+    aDirBtnArr[2][1]    = &aBtnDown3;
+    aFlArr[0]           = &aFlSort1;
+    aFlArr[1]           = &aFlSort2;
+    aFlArr[2]           = &aFlSort3;
 }
 
 // -----------------------------------------------------------------------
@@ -183,63 +177,61 @@ SfxTabPage* ScTabPageSortFields::Create( Window*    pParent,
 
 void ScTabPageSortFields::Reset( const SfxItemSet& /* rArgSet */ )
 {
-    bSortByRows = aNewSortData.bByRow;
-    bHasHeader  = aNewSortData.bHasHeader;
+    bSortByRows = rSortData.bByRow;
+    bHasHeader  = rSortData.bHasHeader;
 
     if ( aLbSort1.GetEntryCount() == 0 )
-        FillFieldLists(0);
+        FillFieldLists();
 
     // ListBox selection:
-    if ( aNewSortData.maKeyState[0].bDoSort )
+
+    if ( rSortData.bDoSort[0] )
     {
-        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+        for ( sal_uInt16 i=0; i<3; i++ )
         {
-            if ( aNewSortData.maKeyState[i].bDoSort )
+            if ( rSortData.bDoSort[i] )
             {
-                aLbSortArr[i]->SelectEntryPos( GetFieldSelPos(
-                                    aNewSortData.maKeyState[i].nField ) );
+                aSortLbArr[i]->SelectEntryPos(
+                     GetFieldSelPos( rSortData.nField[i] ) );
 
-                (aNewSortData.maKeyState[i].bAscending)
-                    ? aBtnUp[i]->Check()
-                    : aBtnDown[i]->Check();
+                (rSortData.bAscending[i])
+                    ? aDirBtnArr[i][0]->Check()     // Up
+                    : aDirBtnArr[i][1]->Check();    // Down
             }
             else
             {
-                aLbSortArr[i]->SelectEntryPos( 0 ); // Select none
-                aBtnUp[i]->Check();
+                aSortLbArr[i]->SelectEntryPos( 0 ); // Select none
+                aDirBtnArr[i][0]->Check();          // Up
             }
         }
 
-        // Enable or disable field depending on preceding Listbox selection
-        EnableField( 0 );
-        for ( sal_uInt16 i=1; i<nSortKeyCount; i++ )
-            if ( aLbSortArr[i - 1] -> GetSelectEntryPos() == 0 )
-                DisableField( i );
-            else
-                EnableField( i );
+        EnableField( 1 );
+        EnableField( 2 );
+        EnableField( 3 );
+        if ( aLbSort1.GetSelectEntryPos() == 0 )
+            DisableField( 2 );
+        if ( aLbSort2.GetSelectEntryPos() == 0 )
+            DisableField( 3 );
     }
     else
     {
         SCCOL  nCol = pViewData->GetCurX();
 
-        if( nCol < aNewSortData.nCol1 )
-            nCol = aNewSortData.nCol1;
-        else if( nCol > aNewSortData.nCol2 )
-            nCol = aNewSortData.nCol2;
-
-        sal_uInt16  nSort1Pos = nCol - aNewSortData.nCol1+1;
-
-        aLbSortArr[0] -> SelectEntryPos( nSort1Pos );
-        for ( sal_uInt16 i=1; i<nSortKeyCount; i++ )
-            aLbSortArr[i] -> SelectEntryPos( 0 );
-
-        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-            aBtnUp[i] -> Check();
-
-        EnableField ( 0 );
+        if( nCol < rSortData.nCol1 )
+            nCol = rSortData.nCol1;
+        else if( nCol > rSortData.nCol2 )
+            nCol = rSortData.nCol2;
+
+        sal_uInt16  nSort1Pos = nCol - rSortData.nCol1+1;
+        aLbSort1.SelectEntryPos( nSort1Pos );
+        aLbSort2.SelectEntryPos( 0 );
+        aLbSort3.SelectEntryPos( 0 );
+        aBtnUp1.Check();
+        aBtnUp2.Check();
+        aBtnUp3.Check();
         EnableField ( 1 );
-        for ( sal_uInt16 i=2; i<nSortKeyCount; i++ )
-            DisableField( i );
+        EnableField ( 2 );
+        DisableField( 3 );
     }
 
     if ( pDlg )
@@ -253,48 +245,65 @@ void ScTabPageSortFields::Reset( const SfxItemSet& /* rArgSet */ )
 
 sal_Bool ScTabPageSortFields::FillItemSet( SfxItemSet& rArgSet )
 {
-    std::vector<sal_uInt16>  nSortPos;
-
-    for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
+    ScSortParam theSortData = rSortData;
+    if (pDlg)
     {
-        nSortPos.push_back( aLbSortArr[i] -> GetSelectEntryPos() );
-
-        if ( nSortPos[i] == LISTBOX_ENTRY_NOTFOUND ) nSortPos[i] = 0;
+        const SfxItemSet* pExample = pDlg->GetExampleSet();
+        const SfxPoolItem* pItem;
+        if ( pExample && pExample->GetItemState( nWhichSort, sal_True, &pItem ) == SFX_ITEM_SET )
+            theSortData = ((const ScSortItem*)pItem)->GetSortData();
     }
 
-    if ( nSortPos[0] > 0 )
+    sal_uInt16  nSort1Pos = aLbSort1.GetSelectEntryPos();
+    sal_uInt16  nSort2Pos = aLbSort2.GetSelectEntryPos();
+    sal_uInt16  nSort3Pos = aLbSort3.GetSelectEntryPos();
+
+    OSL_ENSURE(    (nSort1Pos <= SC_MAXFIELDS)
+                && (nSort2Pos <= SC_MAXFIELDS)
+                && (nSort3Pos <= SC_MAXFIELDS),
+                "Array range error!" );
+
+    if ( nSort1Pos == LISTBOX_ENTRY_NOTFOUND ) nSort1Pos = 0;
+    if ( nSort2Pos == LISTBOX_ENTRY_NOTFOUND ) nSort2Pos = 0;
+    if ( nSort3Pos == LISTBOX_ENTRY_NOTFOUND ) nSort3Pos = 0;
+
+    if ( nSort1Pos > 0 )
     {
-        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-            aNewSortData.maKeyState[i].bDoSort = (nSortPos[i] > 0);
+        theSortData.bDoSort[0] = (nSort1Pos > 0);
+        theSortData.bDoSort[1] = (nSort2Pos > 0);
+        theSortData.bDoSort[2] = (nSort3Pos > 0);
 
         // If the "OK" was selected on the Options page while the sort
         // direction was changed, then the first field (i.e. nFieldArr[0])
         // of the respective direction is chosen as the sorting criterion:
         if ( bSortByRows != pDlg->GetByRows() )
         {
-            for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-                aNewSortData.maKeyState[i].nField = ( bSortByRows ?
-                        static_cast<SCCOLROW>(nFirstRow) :
-                        static_cast<SCCOLROW>(nFirstCol) );
+            theSortData.nField[0] =
+            theSortData.nField[1] =
+            theSortData.nField[2] = ( bSortByRows ?
+                    static_cast<SCCOLROW>(nFirstRow) :
+                    static_cast<SCCOLROW>(nFirstCol) );
         }
         else
         {
-           for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-               aNewSortData.maKeyState[i].nField = nFieldArr[nSortPos[i]];
+            theSortData.nField[0] = nFieldArr[nSort1Pos];
+            theSortData.nField[1] = nFieldArr[nSort2Pos];
+            theSortData.nField[2] = nFieldArr[nSort3Pos];
         }
 
-        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-            aNewSortData.maKeyState[i].bAscending = aBtnUp[i] -> IsChecked();
-
+        theSortData.bAscending[0] = aBtnUp1.IsChecked();
+        theSortData.bAscending[1] = aBtnUp2.IsChecked();
+        theSortData.bAscending[2] = aBtnUp3.IsChecked();
         // bHasHeader is in ScTabPageSortOptions::FillItemSet, where it belongs
     }
     else
     {
-        for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-            aNewSortData.maKeyState[i].bDoSort = false;
+        theSortData.bDoSort[0] =
+        theSortData.bDoSort[1] =
+        theSortData.bDoSort[2] = false;
     }
 
-    rArgSet.Put( ScSortItem( SCITEM_SORTDATA, NULL, &aNewSortData ) );
+    rArgSet.Put( ScSortItem( SCITEM_SORTDATA, NULL, &theSortData ) );
 
     return sal_True;
 }
@@ -306,19 +315,19 @@ void ScTabPageSortFields::ActivatePage()
 {
     if ( pDlg )
     {
-        if ( bHasHeader  != pDlg->GetHeaders()
-             || bSortByRows != pDlg->GetByRows() )
+        if (   bHasHeader  != pDlg->GetHeaders()
+            || bSortByRows != pDlg->GetByRows()   )
         {
-            std::vector<sal_uInt16> nCurSel;
-            for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-                nCurSel.push_back( aLbSortArr[i] -> GetSelectEntryPos() );
+            sal_uInt16  nCurSel1 = aLbSort1.GetSelectEntryPos();
+            sal_uInt16  nCurSel2 = aLbSort2.GetSelectEntryPos();
+            sal_uInt16  nCurSel3 = aLbSort3.GetSelectEntryPos();
 
             bHasHeader  = pDlg->GetHeaders();
             bSortByRows = pDlg->GetByRows();
-            FillFieldLists(0);
-
-            for ( sal_uInt16 i=0; i<nSortKeyCount; i++ )
-                aLbSortArr[i] -> SelectEntryPos( nCurSel[i] );
+            FillFieldLists();
+            aLbSort1.SelectEntryPos( nCurSel1 );
+            aLbSort2.SelectEntryPos( nCurSel2 );
+            aLbSort3.SelectEntryPos( nCurSel3 );
         }
     }
 }
@@ -346,12 +355,14 @@ int ScTabPageSortFields::DeactivatePage( SfxItemSet* pSetP )
 
 void ScTabPageSortFields::DisableField( sal_uInt16 nField )
 {
-    if ( nField<nSortKeyCount )
+    nField--;
+
+    if ( nField<=2 )
     {
-        aLbSortArr[nField]   -> Disable();
-        aBtnUp[nField]       -> Disable();
-        aBtnDown[nField]     -> Disable();
-        aFlArr[nField]       -> Disable();
+        aSortLbArr[nField]   ->Disable();
+        aDirBtnArr[nField][0]->Disable();
+        aDirBtnArr[nField][1]->Disable();
+        aFlArr[nField]       ->Disable();
     }
 }
 
@@ -359,18 +370,20 @@ void ScTabPageSortFields::DisableField( sal_uInt16 nField )
 
 void ScTabPageSortFields::EnableField( sal_uInt16 nField )
 {
-    if ( nField<nSortKeyCount )
+    nField--;
+
+    if ( nField<=2 )
     {
-        aLbSortArr[nField]   -> Enable();
-        aBtnUp[nField]       -> Enable();
-        aBtnDown[nField]     -> Enable();
-        aFlArr[nField]       -> Enable();
+        aSortLbArr[nField]   ->Enable();
+        aDirBtnArr[nField][0]->Enable();
+        aDirBtnArr[nField][1]->Enable();
+        aFlArr[nField]       ->Enable();
     }
 }
 
 // -----------------------------------------------------------------------
 
-void ScTabPageSortFields::FillFieldLists( sal_uInt16 nStartField )
+void ScTabPageSortFields::FillFieldLists()
 {
     if ( pViewData )
     {
@@ -378,11 +391,12 @@ void ScTabPageSortFields::FillFieldLists( sal_uInt16 nStartField )
 
         if ( pDoc )
         {
-            for ( sal_uInt16 i=nStartField; i<nSortKeyCount; i++ )
-            {
-                aLbSortArr[i] -> Clear();
-                aLbSortArr[i] -> InsertEntry( aStrUndefined, 0 );
-            }
+            aLbSort1.Clear();
+            aLbSort2.Clear();
+            aLbSort3.Clear();
+            aLbSort1.InsertEntry( aStrUndefined, 0 );
+            aLbSort2.InsertEntry( aStrUndefined, 0 );
+            aLbSort3.InsertEntry( aStrUndefined, 0 );
 
             SCCOL   nFirstSortCol   = rSortData.nCol1;
             SCROW   nFirstSortRow   = rSortData.nRow1;
@@ -404,11 +418,10 @@ void ScTabPageSortFields::FillFieldLists( sal_uInt16 nStartField )
                         aFieldName += ' ';
                         aFieldName += ScColToAlpha( col );
                     }
-                    nFieldArr.push_back( col );
-
-                    for ( sal_uInt16 j=nStartField; j<nSortKeyCount; j++ )
-                        aLbSortArr[j] -> InsertEntry( aFieldName, i );
-
+                    nFieldArr[i] = col;
+                    aLbSort1.InsertEntry( aFieldName, i );
+                    aLbSort2.InsertEntry( aFieldName, i );
+                    aLbSort3.InsertEntry( aFieldName, i );
                     i++;
                 }
             }
@@ -427,11 +440,10 @@ void ScTabPageSortFields::FillFieldLists( sal_uInt16 nStartField )
                         aFieldName += ' ';
                         aFieldName += String::CreateFromInt32( row+1 );
                     }
-                    nFieldArr.push_back( row );
-
-                    for ( sal_uInt16 j=nStartField; j<nSortKeyCount; j++ )
-                        aLbSortArr[j] -> InsertEntry( aFieldName, i );
-
+                    nFieldArr[i] = row;
+                    aLbSort1.InsertEntry( aFieldName, i );
+                    aLbSort2.InsertEntry( aFieldName, i );
+                    aLbSort3.InsertEntry( aFieldName, i );
                     i++;
                 }
             }
@@ -466,30 +478,38 @@ sal_uInt16 ScTabPageSortFields::GetFieldSelPos( SCCOLROW nField )
 IMPL_LINK( ScTabPageSortFields, SelectHdl, ListBox *, pLb )
 {
     String aSelEntry = pLb->GetSelectEntry();
-    sal_uInt16  nPos   = 0;
-
-    // Find selected listbox
-    while ( pLb != aLbSortArr[nPos] )
-        ++nPos;
 
-    // If not selecting the last Listbox modify the succeeding ones
-    ++nPos;
-    if ( nPos < nSortKeyCount )
+    if ( pLb == &aLbSort1 )
     {
         if ( aSelEntry == aStrUndefined )
         {
-            for ( sal_uInt16 i=nPos; i<nSortKeyCount; i++ )
-            {
-                aLbSortArr[i] -> SelectEntryPos( 0 );
+            aLbSort2.SelectEntryPos( 0 );
+            aLbSort3.SelectEntryPos( 0 );
 
-                if ( aFlArr[i] -> IsEnabled() )
-                    DisableField( i );
-            }
+            if ( aFlSort2.IsEnabled() )
+                DisableField( 2 );
+
+            if ( aFlSort3.IsEnabled() )
+                DisableField( 3 );
+        }
+        else
+        {
+            if ( !aFlSort2.IsEnabled() )
+                EnableField( 2 );
+        }
+    }
+    else if ( pLb == &aLbSort2 )
+    {
+        if ( aSelEntry == aStrUndefined )
+        {
+            aLbSort3.SelectEntryPos( 0 );
+            if ( aFlSort3.IsEnabled() )
+                DisableField( 3 );
         }
         else
         {
-            if ( !aFlArr[nPos] -> IsEnabled() )
-                EnableField( nPos );
+            if ( !aFlSort3.IsEnabled() )
+                EnableField( 3 );
         }
     }
     return 0;
@@ -530,7 +550,6 @@ ScTabPageSortOptions::ScTabPageSortOptions( Window*             pParent,
         nWhichSort      ( rArgSet.GetPool()->GetWhich( SID_SORT ) ),
         rSortData       ( ((const ScSortItem&)
                           rArgSet.Get( nWhichSort )).GetSortData() ),
-        aNewSortData    ( rSortData ),
         pViewData       ( NULL ),
         pDoc            ( NULL ),
         pDlg            ( (ScSortDlg*)(GetParent() ? GetParent()->GetParent() : 0 ) ),
@@ -587,23 +606,12 @@ void ScTabPageSortOptions::Init()
 
     OSL_ENSURE( pViewData, "ViewData not found! :-/" );
 
-    // Create local copy of ScParam
-    aNewSortData = rSortData;
-
-    if (pDlg)
-    {
-        const SfxItemSet* pExample = pDlg->GetExampleSet();
-        const SfxPoolItem* pItem;
-        if ( pExample && pExample->GetItemState( nWhichSort, sal_True, &pItem ) == SFX_ITEM_SET )
-            aNewSortData = static_cast<const ScSortItem*>(pItem)->GetSortData();
-    }
-
     if ( pViewData && pDoc )
     {
         String          theArea;
         ScDBCollection* pDBColl     = pDoc->GetDBCollection();
         String          theDbArea;
-        const SCTAB     nCurTab     = pViewData->GetTabNo();
+        const SCTAB nCurTab     = pViewData->GetTabNo();
         String          theDbName   = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(STR_DB_LOCAL_NONAME));
         const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
 
@@ -628,17 +636,17 @@ void ScTabPageSortOptions::Init()
 
         // Check whether the field that is passed on is a database field:
 
-        ScAddress aScAddress( aNewSortData.nCol1, aNewSortData.nRow1, nCurTab );
+        ScAddress aScAddress( rSortData.nCol1, rSortData.nRow1, nCurTab );
         ScRange( aScAddress,
-                 ScAddress( aNewSortData.nCol2, aNewSortData.nRow2, nCurTab )
+                 ScAddress( rSortData.nCol2, rSortData.nRow2, nCurTab )
                ).Format( theArea, SCR_ABS, pDoc, eConv );
 
         if ( pDBColl )
         {
             ScDBData* pDBData
                     = pDBColl->GetDBAtArea( nCurTab,
-                                            aNewSortData.nCol1, aNewSortData.nRow1,
-                                            aNewSortData.nCol2, aNewSortData.nRow2 );
+                                            rSortData.nCol1, rSortData.nRow1,
+                                            rSortData.nCol2, rSortData.nRow2 );
             if ( pDBData )
             {
                 theDbName = pDBData->GetName();
@@ -744,37 +752,46 @@ void ScTabPageSortOptions::Reset( const SfxItemSet& /* rArgSet */ )
 
 sal_Bool ScTabPageSortOptions::FillItemSet( SfxItemSet& rArgSet )
 {
-    aNewSortData.bByRow          = aBtnTopDown.IsChecked();
-    aNewSortData.bHasHeader      = aBtnHeader.IsChecked();
-    aNewSortData.bCaseSens       = aBtnCase.IsChecked();
-    aNewSortData.bNaturalSort    = aBtnNaturalSort.IsChecked();
-    aNewSortData.bIncludePattern = aBtnFormats.IsChecked();
-    aNewSortData.bInplace        = !aBtnCopyResult.IsChecked();
-    aNewSortData.nDestCol        = theOutPos.Col();
-    aNewSortData.nDestRow        = theOutPos.Row();
-    aNewSortData.nDestTab        = theOutPos.Tab();
-    aNewSortData.bUserDef        = aBtnSortUser.IsChecked();
-    aNewSortData.nUserIndex      = (aBtnSortUser.IsChecked())
-                                   ? aLbSortUser.GetSelectEntryPos()
-                                   : 0;
+    ScSortParam theSortData = rSortData;
+    if (pDlg)
+    {
+        const SfxItemSet* pExample = pDlg->GetExampleSet();
+        const SfxPoolItem* pItem;
+        if ( pExample && pExample->GetItemState( nWhichSort, sal_True, &pItem ) == SFX_ITEM_SET )
+            theSortData = ((const ScSortItem*)pItem)->GetSortData();
+    }
+
+    theSortData.bByRow          = aBtnTopDown.IsChecked();
+    theSortData.bHasHeader      = aBtnHeader.IsChecked();
+    theSortData.bCaseSens       = aBtnCase.IsChecked();
+    theSortData.bNaturalSort    = aBtnNaturalSort.IsChecked();
+    theSortData.bIncludePattern = aBtnFormats.IsChecked();
+    theSortData.bInplace        = !aBtnCopyResult.IsChecked();
+    theSortData.nDestCol        = theOutPos.Col();
+    theSortData.nDestRow        = theOutPos.Row();
+    theSortData.nDestTab        = theOutPos.Tab();
+    theSortData.bUserDef        = aBtnSortUser.IsChecked();
+    theSortData.nUserIndex      = (aBtnSortUser.IsChecked())
+                                    ? aLbSortUser.GetSelectEntryPos()
+                                    : 0;
 
     // get locale
     LanguageType eLang = aLbLanguage.GetSelectLanguage();
-    aNewSortData.aCollatorLocale = MsLangId::convertLanguageToLocale( eLang, false );
+    theSortData.aCollatorLocale = MsLangId::convertLanguageToLocale( eLang, false );
 
     // get algorithm
     String sAlg;
     if ( eLang != LANGUAGE_SYSTEM )
     {
         uno::Sequence<rtl::OUString> aAlgos = pColWrap->listCollatorAlgorithms(
-                aNewSortData.aCollatorLocale );
+                theSortData.aCollatorLocale );
         sal_uInt16 nSel = aLbAlgorithm.GetSelectEntryPos();
         if ( nSel < aAlgos.getLength() )
             sAlg = aAlgos[nSel];
     }
-    aNewSortData.aCollatorAlgorithm = sAlg;
+    theSortData.aCollatorAlgorithm = sAlg;
 
-    rArgSet.Put( ScSortItem( SCITEM_SORTDATA, &aNewSortData ) );
+    rArgSet.Put( ScSortItem( SCITEM_SORTDATA, &theSortData ) );
 
     return sal_True;
 }
diff --git a/sc/source/ui/docshell/dbdocfun.cxx b/sc/source/ui/docshell/dbdocfun.cxx
index a54f906..13b484a 100644
--- a/sc/source/ui/docshell/dbdocfun.cxx
+++ b/sc/source/ui/docshell/dbdocfun.cxx
@@ -282,7 +282,7 @@ bool ScDBDocFunc::RepeatDB( const ::rtl::OUString& rDBName, bool bRecord, bool b
 
         ScSortParam aSortParam;
         pDBData->GetSortParam( aSortParam );
-        sal_Bool bSort = aSortParam.maKeyState[0].bDoSort;
+        sal_Bool bSort = aSortParam.bDoSort[0];
 
         ScSubTotalParam aSubTotalParam;
         pDBData->GetSubTotalParam( aSubTotalParam );
@@ -585,7 +585,7 @@ sal_Bool ScDBDocFunc::Sort( SCTAB nTab, const ScSortParam& rSortParam,
     }
 
     // don't call ScDocument::Sort with an empty SortParam (may be empty here if bCopy is set)
-    if ( aLocalParam.maKeyState[0].bDoSort )
+    if ( aLocalParam.bDoSort[0] )
         pDoc->Sort( nTab, aLocalParam, bRepeatQuery );
 
     sal_Bool bSave = sal_True;
@@ -593,7 +593,7 @@ sal_Bool ScDBDocFunc::Sort( SCTAB nTab, const ScSortParam& rSortParam,
     {
         ScSortParam aOldSortParam;
         pDBData->GetSortParam( aOldSortParam );
-        if ( aOldSortParam.maKeyState[0].bDoSort && aOldSortParam.bInplace )   // Inplace-Sortierung gemerkt?
+        if ( aOldSortParam.bDoSort[0] && aOldSortParam.bInplace )   // Inplace-Sortierung gemerkt?
         {
             bSave = false;
             aOldSortParam.nDestCol = rSortParam.nDestCol;
diff --git a/sc/source/ui/inc/tpsort.hxx b/sc/source/ui/inc/tpsort.hxx
index 2a447cb..8b87726 100644
--- a/sc/source/ui/inc/tpsort.hxx
+++ b/sc/source/ui/inc/tpsort.hxx
@@ -29,7 +29,6 @@
 #ifndef SC_TPSORT_HXX
 #define SC_TPSORT_HXX
 
-#include <vector>
 
 #include <sfx2/tabdlg.hxx>
 #include <vcl/edit.hxx>
@@ -41,7 +40,6 @@
 
 #include "global.hxx"
 #include "address.hxx"
-#include "sortparam.hxx"
 
 //------------------------------------------------------------------------
 
@@ -99,28 +97,23 @@ private:
     ScSortDlg*          pDlg;
     ScViewData*         pViewData;
     const ScSortParam&  rSortData;
-    ScSortParam         aNewSortData;
-    std::vector<SCCOLROW>  nFieldArr;
+    SCCOLROW            nFieldArr[SC_MAXFIELDS];
     sal_uInt16          nFieldCount;
-    sal_uInt16          nSortKeyCount;
-    sal_uInt16          nCurrentOffset;
-
     SCCOL               nFirstCol;
     SCROW               nFirstRow;
     sal_Bool            bHasHeader;
     sal_Bool            bSortByRows;
 
-    std::vector<ListBox*>      aLbSortArr;
-    std::vector<RadioButton*>  aBtnUp;
-    std::vector<RadioButton*>  aBtnDown;
-    std::vector<FixedLine*>    aFlArr;
+    ListBox*            aSortLbArr[3];
+    RadioButton*        aDirBtnArr[3][2];
+    FixedLine*          aFlArr[3];
 
 #ifdef _TPSORT_CXX
 private:
     void    Init            ();
     void    DisableField    ( sal_uInt16 nField );
     void    EnableField     ( sal_uInt16 nField );
-    void    FillFieldLists  ( sal_uInt16 nStartField );
+    void    FillFieldLists  ();
     sal_uInt16  GetFieldSelPos  ( SCCOLROW nField );
 
     // Handler ------------------------
@@ -188,7 +181,6 @@ private:
 
     const sal_uInt16    nWhichSort;
     const ScSortParam&  rSortData;
-    ScSortParam         aNewSortData;
     ScViewData*         pViewData;
     ScDocument*         pDoc;
     ScSortDlg*          pDlg;
diff --git a/sc/source/ui/src/sortdlg.src b/sc/source/ui/src/sortdlg.src
index 466ab7a..a4296f4 100644
--- a/sc/source/ui/src/sortdlg.src
+++ b/sc/source/ui/src/sortdlg.src
@@ -61,7 +61,7 @@ TabPage RID_SCPAGE_SORT_FIELDS
     {
         Pos = MAP_APPFONT ( 6 , 3 ) ;
         Size = MAP_APPFONT ( 248 , 8 ) ;
-        Text [ en-US ] = "Sort ~key 1" ;
+        Text [ en-US ] = "Sort ~by" ;
     };
     ListBox LB_SORT2
     {
@@ -92,7 +92,7 @@ TabPage RID_SCPAGE_SORT_FIELDS
     {
         Pos = MAP_APPFONT ( 6 , 44 ) ;
         Size = MAP_APPFONT ( 248 , 8 ) ;
-        Text [ en-US ] = "Sort ~key 2" ;
+        Text [ en-US ] = "Then b~y" ;
     };
     ListBox LB_SORT3
     {
@@ -123,7 +123,7 @@ TabPage RID_SCPAGE_SORT_FIELDS
     {
         Pos = MAP_APPFONT ( 6 , 85 ) ;
         Size = MAP_APPFONT ( 248 , 8 ) ;
-        Text [ en-US ] = "Sort ~key 3" ;
+        Text [ en-US ] = "T~hen by" ;
     };
 };
 
diff --git a/sc/source/ui/unoobj/cellsuno.cxx b/sc/source/ui/unoobj/cellsuno.cxx
index 750822c..c82e56a 100644
--- a/sc/source/ui/unoobj/cellsuno.cxx
+++ b/sc/source/ui/unoobj/cellsuno.cxx
@@ -5625,9 +5625,9 @@ uno::Sequence<beans::PropertyValue> SAL_CALL ScCellRangeObj::createSortDescripto
             SCCOLROW nFieldStart = aParam.bByRow ?
                 static_cast<SCCOLROW>(aDBRange.aStart.Col()) :
                 static_cast<SCCOLROW>(aDBRange.aStart.Row());
-            for (sal_uInt16 i=0; i<aParam.GetSortKeyCount(); i++)
-                if ( aParam.maKeyState[i].bDoSort && aParam.maKeyState[i].nField >= nFieldStart )
-                    aParam.maKeyState[i].nField -= nFieldStart;
+            for (sal_uInt16 i=0; i<MAXSORT; i++)
+                if ( aParam.bDoSort[i] && aParam.nField[i] >= nFieldStart )
+                    aParam.nField[i] -= nFieldStart;
         }
     }
 
@@ -5653,9 +5653,9 @@ void SAL_CALL ScCellRangeObj::sort( const uno::Sequence<beans::PropertyValue>& a
             SCCOLROW nOldStart = aParam.bByRow ?
                 static_cast<SCCOLROW>(aRange.aStart.Col()) :
                 static_cast<SCCOLROW>(aRange.aStart.Row());
-            for (i=0; i<aParam.GetSortKeyCount(); i++)
-                if ( aParam.maKeyState[i].bDoSort && aParam.maKeyState[i].nField >= nOldStart )
-                    aParam.maKeyState[i].nField -= nOldStart;
+            for (i=0; i<MAXSORT; i++)
+                if ( aParam.bDoSort[i] && aParam.nField[i] >= nOldStart )
+                    aParam.nField[i] -= nOldStart;
         }
 
         ScSortDescriptor::FillSortParam( aParam, aDescriptor );
@@ -5665,8 +5665,8 @@ void SAL_CALL ScCellRangeObj::sort( const uno::Sequence<beans::PropertyValue>& a
         SCCOLROW nFieldStart = aParam.bByRow ?
             static_cast<SCCOLROW>(aRange.aStart.Col()) :
             static_cast<SCCOLROW>(aRange.aStart.Row());
-        for (i=0; i<aParam.GetSortKeyCount(); i++)
-            aParam.maKeyState[i].nField += nFieldStart;
+        for (i=0; i<MAXSORT; i++)
+            aParam.nField[i] += nFieldStart;
 
         SCTAB nTab = aRange.aStart.Tab();
         aParam.nCol1 = aRange.aStart.Col();
diff --git a/sc/source/ui/unoobj/datauno.cxx b/sc/source/ui/unoobj/datauno.cxx
index 8380c0b..125ac54 100644
--- a/sc/source/ui/unoobj/datauno.cxx
+++ b/sc/source/ui/unoobj/datauno.cxx
@@ -334,7 +334,7 @@ void ScSortDescriptor::FillProperties( uno::Sequence<beans::PropertyValue>& rSeq
     aOutPos.Row    = rParam.nDestRow;
 
     sal_uInt16 nSortCount = 0;
-    while ( nSortCount < rParam.GetSortKeyCount() && rParam.maKeyState[nSortCount].bDoSort )
+    while ( nSortCount < MAXSORT && rParam.bDoSort[nSortCount] )
         ++nSortCount;
 
     uno::Sequence<table::TableSortField> aFields(nSortCount);
@@ -343,8 +343,8 @@ void ScSortDescriptor::FillProperties( uno::Sequence<beans::PropertyValue>& rSeq
         table::TableSortField* pFieldArray = aFields.getArray();
         for (sal_uInt16 i=0; i<nSortCount; i++)
         {
-            pFieldArray[i].Field         = rParam.maKeyState[i].nField;
-            pFieldArray[i].IsAscending   = rParam.maKeyState[i].bAscending;
+            pFieldArray[i].Field         = rParam.nField[i];
+            pFieldArray[i].IsAscending   = rParam.bAscending[i];
             pFieldArray[i].FieldType     = table::TableSortFieldType_AUTOMATIC;     // immer Automatic
             pFieldArray[i].IsCaseSensitive = rParam.bCaseSens;
             pFieldArray[i].CollatorLocale = rParam.aCollatorLocale;
@@ -361,7 +361,7 @@ void ScSortDescriptor::FillProperties( uno::Sequence<beans::PropertyValue>& rSeq
     ScUnoHelpFunctions::SetBoolInAny( pArray[1].Value, rParam.bHasHeader );
 
     pArray[2].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_MAXFLD ));
-    pArray[2].Value <<= static_cast<sal_Int32>( rParam.GetSortKeyCount() );
+    pArray[2].Value <<= (sal_Int32) MAXSORT;
 
     pArray[3].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_SORTFLD ));
     pArray[3].Value <<= aFields;
@@ -379,15 +379,13 @@ void ScSortDescriptor::FillProperties( uno::Sequence<beans::PropertyValue>& rSeq
     ScUnoHelpFunctions::SetBoolInAny( pArray[7].Value, rParam.bUserDef );
 
     pArray[8].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_UINDEX ));
-    pArray[8].Value <<= static_cast<sal_Int32>( rParam.nUserIndex );
+    pArray[8].Value <<= (sal_Int32) rParam.nUserIndex;
 }
 
 void ScSortDescriptor::FillSortParam( ScSortParam& rParam, const uno::Sequence<beans::PropertyValue>& rSeq )
 {
     const beans::PropertyValue* pPropArray = rSeq.getConstArray();
     long nPropCount = rSeq.getLength();
-    sal_Int16 nSortSize = rParam.GetSortKeyCount();
-
     for (long nProp = 0; nProp < nPropCount; nProp++)
     {
         const beans::PropertyValue& rProp = pPropArray[nProp];
@@ -409,7 +407,7 @@ void ScSortDescriptor::FillSortParam( ScSortParam& rParam, const uno::Sequence<b
         else if (aPropName.EqualsAscii( SC_UNONAME_MAXFLD ))
         {
             sal_Int32 nVal;
-            if ( (rProp.Value >>= nVal) && nVal > nSortSize )
+            if ( (rProp.Value >>= nVal) && nVal > MAXSORT )
             {
                 //! specify exceptions
                 //! throw lang::IllegalArgumentException();
@@ -423,37 +421,37 @@ void ScSortDescriptor::FillSortParam( ScSortParam& rParam, const uno::Sequence<b
             {
                 sal_Int32 nCount = aSeq.getLength();
                 sal_Int32 i;
-                if ( nCount > static_cast<sal_Int32>( rParam.GetSortKeyCount() ) )
+                if ( nCount > MAXSORT )
                 {
-                    nCount = nSortSize;
-                    rParam.maKeyState.resize(nCount);
+                    OSL_FAIL("Zu viele Sortierfelder");
+                    nCount = MAXSORT;
                 }
                 const util::SortField* pFieldArray = aSeq.getConstArray();
                 for (i=0; i<nCount; i++)
                 {
-                    rParam.maKeyState[i].nField     = static_cast<SCCOLROW>( pFieldArray[i].Field );
-                    rParam.maKeyState[i].bAscending = pFieldArray[i].SortAscending;
+                    rParam.nField[i]     = (SCCOLROW)pFieldArray[i].Field;
+                    rParam.bAscending[i] = pFieldArray[i].SortAscending;
 
                     // FieldType wird ignoriert
-                    rParam.maKeyState[i].bDoSort = true;
+                    rParam.bDoSort[i] = sal_True;
                 }
-                for (i=nCount; i<nSortSize; i++)
-                    rParam.maKeyState[i].bDoSort = false;
+                for (i=nCount; i<MAXSORT; i++)
+                    rParam.bDoSort[i] = false;
             }
             else if ( rProp.Value >>= aNewSeq )
             {
                 sal_Int32 nCount = aNewSeq.getLength();
                 sal_Int32 i;
-                if ( nCount > nSortSize )
+                if ( nCount > MAXSORT )
                 {
-                    nCount = nSortSize;
-                    rParam.maKeyState.resize(nCount);
+                    OSL_FAIL("Zu viele Sortierfelder");
+                    nCount = MAXSORT;
                 }
                 const table::TableSortField* pFieldArray = aNewSeq.getConstArray();
                 for (i=0; i<nCount; i++)
                 {
-                    rParam.maKeyState[i].nField     = static_cast<SCCOLROW>( pFieldArray[i].Field );
-                    rParam.maKeyState[i].bAscending = pFieldArray[i].IsAscending;
+                    rParam.nField[i]     = (SCCOLROW)pFieldArray[i].Field;
+                    rParam.bAscending[i] = pFieldArray[i].IsAscending;
 
                     // only one is possible, sometime we should make it possible to have different for every entry
                     rParam.bCaseSens = pFieldArray[i].IsCaseSensitive;
@@ -461,10 +459,10 @@ void ScSortDescriptor::FillSortParam( ScSortParam& rParam, const uno::Sequence<b
                     rParam.aCollatorAlgorithm = pFieldArray[i].CollatorAlgorithm;
 
                     // FieldType wird ignoriert
-                    rParam.maKeyState[i].bDoSort = true;
+                    rParam.bDoSort[i] = sal_True;
                 }
-                for (i=nCount; i<nSortSize; i++)
-                    rParam.maKeyState[i].bDoSort = false;
+                for (i=nCount; i<MAXSORT; i++)
+                    rParam.bDoSort[i] = false;
             }
         }
         else if (aPropName.EqualsAscii( SC_UNONAME_ISCASE ))
@@ -1820,9 +1818,9 @@ uno::Sequence<beans::PropertyValue> SAL_CALL ScDatabaseRangeObj::getSortDescript
         ScRange aDBRange;
         pData->GetArea(aDBRange);
         SCCOLROW nFieldStart = aParam.bByRow ? static_cast<SCCOLROW>(aDBRange.aStart.Col()) : static_cast<SCCOLROW>(aDBRange.aStart.Row());
-        for (sal_uInt16 i=0; i<aParam.GetSortKeyCount(); i++)
-            if ( aParam.maKeyState[i].bDoSort && aParam.maKeyState[i].nField >= nFieldStart )
-                aParam.maKeyState[i].nField -= nFieldStart;
+        for (sal_uInt16 i=0; i<MAXSORT; i++)
+            if ( aParam.bDoSort[i] && aParam.nField[i] >= nFieldStart )
+                aParam.nField[i] -= nFieldStart;
     }
 
     uno::Sequence<beans::PropertyValue> aSeq( ScSortDescriptor::GetPropertyCount() );
diff --git a/sc/source/ui/vba/vbarange.cxx b/sc/source/ui/vba/vbarange.cxx
index 6b8fa9e..2ec55b3 100644
--- a/sc/source/ui/vba/vbarange.cxx
+++ b/sc/source/ui/vba/vbarange.cxx
@@ -3539,9 +3539,9 @@ ScVbaRange::Sort( const uno::Any& Key1, const uno::Any& Order1, const uno::Any&
 
     // set up defaults
 
-    sal_Int16 nOrder1 = aSortParam.maKeyState[1].bAscending ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
-    sal_Int16 nOrder2 = aSortParam.maKeyState[2].bAscending ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
-    sal_Int16 nOrder3 = aSortParam.maKeyState[3].bAscending ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
+    sal_Int16 nOrder1 = aSortParam.bAscending[0] ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
+    sal_Int16 nOrder2 = aSortParam.bAscending[1] ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
+    sal_Int16 nOrder3 = aSortParam.bAscending[2] ? excel::XlSortOrder::xlAscending : excel::XlSortOrder::xlDescending;
 
     sal_Int16 nCustom = aSortParam.nUserIndex;
     sal_Int16 nSortMethod = excel::XlSortMethod::xlPinYin;
@@ -3620,26 +3620,26 @@ ScVbaRange::Sort( const uno::Any& Key1, const uno::Any& Order1, const uno::Any&
     {
         nOrder1 = ::comphelper::getINT16(Order1);
         if (  nOrder1 == excel::XlSortOrder::xlAscending )
-            aSortParam.maKeyState[0].bAscending  = true;
+            aSortParam.bAscending[0]  = true;
         else
-            aSortParam.maKeyState[0].bAscending  = false;
+            aSortParam.bAscending[0]  = false;
 
     }
     if ( Order2.hasValue() )
     {
         nOrder2 = ::comphelper::getINT16(Order2);
         if ( nOrder2 == excel::XlSortOrder::xlAscending )
-            aSortParam.maKeyState[1].bAscending  = true;
+            aSortParam.bAscending[1]  = true;
         else
-            aSortParam.maKeyState[1].bAscending  = false;
+            aSortParam.bAscending[1]  = false;
     }
     if ( Order3.hasValue() )
     {
         nOrder3 = ::comphelper::getINT16(Order3);
         if ( nOrder3 == excel::XlSortOrder::xlAscending )
-            aSortParam.maKeyState[2].bAscending  = true;
+            aSortParam.bAscending[2]  = true;
         else
-            aSortParam.maKeyState[2].bAscending  = false;
+            aSortParam.bAscending[2]  = false;
     }
 
     uno::Reference< table::XCellRange > xKey1;
diff --git a/sc/source/ui/view/cellsh2.cxx b/sc/source/ui/view/cellsh2.cxx
index cc29587..77121b7 100644
--- a/sc/source/ui/view/cellsh2.cxx
+++ b/sc/source/ui/view/cellsh2.cxx
@@ -376,10 +376,12 @@ void ScCellShell::ExecuteDB( SfxRequest& rReq )
                     aSortParam.bNaturalSort     = false;
                     aSortParam.bIncludePattern  = true;
                     aSortParam.bInplace         = true;
-                    aSortParam.maKeyState[0]    = { true, nCol, nSlotId == SID_SORT_ASCENDING };
+                    aSortParam.bDoSort[0]       = true;
+                    aSortParam.nField[0]        = nCol;
+                    aSortParam.bAscending[0]    = (nSlotId == SID_SORT_ASCENDING);
 
-                    for ( sal_uInt16 i=1; i<aSortParam.GetSortKeyCount(); i++ )
-                        aSortParam.maKeyState[i].bDoSort = false;
+                    for ( sal_uInt16 i=1; i<MAXSORT; i++ )
+                        aSortParam.bDoSort[i] = false;
 
                     aArgSet.Put( ScSortItem( SCITEM_SORTDATA, GetViewData(), &aSortParam ) );
 
@@ -418,18 +420,18 @@ void ScCellShell::ExecuteDB( SfxRequest& rReq )
 
                         const SfxPoolItem* pItem;
                         if ( pArgs->GetItemState( SID_SORT_BYROW, sal_True, &pItem ) == SFX_ITEM_SET )
-                            aSortParam.bByRow = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                            aSortParam.bByRow = ((const SfxBoolItem*)pItem)->GetValue();
                         if ( pArgs->GetItemState( SID_SORT_HASHEADER, sal_True, &pItem ) == SFX_ITEM_SET )
-                            aSortParam.bHasHeader = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                            aSortParam.bHasHeader = ((const SfxBoolItem*)pItem)->GetValue();
                         if ( pArgs->GetItemState( SID_SORT_CASESENS, sal_True, &pItem ) == SFX_ITEM_SET )
-                            aSortParam.bCaseSens = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                            aSortParam.bCaseSens = ((const SfxBoolItem*)pItem)->GetValue();
                     if ( pArgs->GetItemState( SID_SORT_NATURALSORT, true, &pItem ) == SFX_ITEM_SET )
-                        aSortParam.bNaturalSort = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                        aSortParam.bNaturalSort = ((const SfxBoolItem*)pItem)->GetValue();
                         if ( pArgs->GetItemState( SID_SORT_ATTRIBS, true, &pItem ) == SFX_ITEM_SET )
-                            aSortParam.bIncludePattern = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                            aSortParam.bIncludePattern = ((const SfxBoolItem*)pItem)->GetValue();
                         if ( pArgs->GetItemState( SID_SORT_USERDEF, sal_True, &pItem ) == SFX_ITEM_SET )
                         {
-                            sal_uInt16 nUserIndex = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
+                            sal_uInt16 nUserIndex = ((const SfxUInt16Item*)pItem)->GetValue();
                             aSortParam.bUserDef = ( nUserIndex != 0 );
                             if ( nUserIndex )
                                 aSortParam.nUserIndex = nUserIndex - 1;     // Basic: 1-based
@@ -437,25 +439,25 @@ void ScCellShell::ExecuteDB( SfxRequest& rReq )
 
                         SCCOLROW nField0 = 0;
                         if ( pArgs->GetItemState( FN_PARAM_1, sal_True, &pItem ) == SFX_ITEM_SET )
-                            nField0 = static_cast<const SfxInt32Item*>(pItem)->GetValue();
-                        aSortParam.maKeyState[0].bDoSort = ( nField0 != 0 );
-                        aSortParam.maKeyState[0].nField = nField0 > 0 ? (nField0-1) : 0;
+                            nField0 = ((const SfxInt32Item*)pItem)->GetValue();
+                        aSortParam.bDoSort[0] = ( nField0 != 0 );
+                        aSortParam.nField[0] = nField0 > 0 ? (nField0-1) : 0;
                         if ( pArgs->GetItemState( FN_PARAM_2, sal_True, &pItem ) == SFX_ITEM_SET )
-                            aSortParam.maKeyState[0].bAscending = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                            aSortParam.bAscending[0] = ((const SfxBoolItem*)pItem)->GetValue();
                         SCCOLROW nField1 = 0;
                         if ( pArgs->GetItemState( FN_PARAM_3, sal_True, &pItem ) == SFX_ITEM_SET )
-                            nField1 = static_cast<const SfxInt32Item*>(pItem)->GetValue();
-                        aSortParam.maKeyState[1].bDoSort = ( nField1 != 0 );
-                        aSortParam.maKeyState[1].nField = nField1 > 0 ? (nField1-1) : 0;
+                            nField1 = ((const SfxInt32Item*)pItem)->GetValue();
+                        aSortParam.bDoSort[1] = ( nField1 != 0 );
+                        aSortParam.nField[1] = nField1 > 0 ? (nField1-1) : 0;
                         if ( pArgs->GetItemState( FN_PARAM_4, sal_True, &pItem ) == SFX_ITEM_SET )
-                            aSortParam.maKeyState[1].bAscending = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                            aSortParam.bAscending[1] = ((const SfxBoolItem*)pItem)->GetValue();
                         SCCOLROW nField2 = 0;
                         if ( pArgs->GetItemState( FN_PARAM_5, sal_True, &pItem ) == SFX_ITEM_SET )
-                            nField2 = static_cast<const SfxInt32Item*>(pItem)->GetValue();
-                        aSortParam.maKeyState[2].bDoSort = ( nField2 != 0 );
-                        aSortParam.maKeyState[2].nField = nField2 > 0 ? (nField2-1) : 0;
+                            nField2 = ((const SfxInt32Item*)pItem)->GetValue();
+                        aSortParam.bDoSort[2] = ( nField2 != 0 );
+                        aSortParam.nField[2] = nField2 > 0 ? (nField2-1) : 0;
                         if ( pArgs->GetItemState( FN_PARAM_6, sal_True, &pItem ) == SFX_ITEM_SET )
-                            aSortParam.maKeyState[2].bAscending = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                            aSortParam.bAscending[2] = ((const SfxBoolItem*)pItem)->GetValue();
 
                         // subtotal when needed new
                         pTabViewShell->UISort( aSortParam );
@@ -514,26 +516,26 @@ void ScCellShell::ExecuteDB( SfxRequest& rReq )
                                     rOutParam.bIncludePattern ) );
                                 sal_uInt16 nUser = rOutParam.bUserDef ? ( rOutParam.nUserIndex + 1 ) : 0;
                                 rReq.AppendItem( SfxUInt16Item( SID_SORT_USERDEF, nUser ) );
-                                if ( rOutParam.maKeyState[0].bDoSort )
+                                if ( rOutParam.bDoSort[0] )
                                 {
                                     rReq.AppendItem( SfxInt32Item( FN_PARAM_1,
-                                        rOutParam.maKeyState[0].nField + 1 ) );
+                                        rOutParam.nField[0] + 1 ) );
                                     rReq.AppendItem( SfxBoolItem( FN_PARAM_2,
-                                        rOutParam.maKeyState[0].bAscending ) );
+                                        rOutParam.bAscending[0] ) );
                                 }
-                                if ( rOutParam.maKeyState[1].bDoSort )
+                                if ( rOutParam.bDoSort[1] )
                                 {
                                     rReq.AppendItem( SfxInt32Item( FN_PARAM_3,
-                                        rOutParam.maKeyState[1].nField + 1 ) );
+                                        rOutParam.nField[1] + 1 ) );
                                     rReq.AppendItem( SfxBoolItem( FN_PARAM_4,
-                                        rOutParam.maKeyState[1].bAscending ) );
+                                        rOutParam.bAscending[1] ) );
                                 }
-                                if ( rOutParam.maKeyState[2].bDoSort )
+                                if ( rOutParam.bDoSort[2] )
                                 {
                                     rReq.AppendItem( SfxInt32Item( FN_PARAM_5,
-                                        rOutParam.maKeyState[2].nField + 1 ) );
+                                        rOutParam.nField[2] + 1 ) );
                                     rReq.AppendItem( SfxBoolItem( FN_PARAM_6,
-                                        rOutParam.maKeyState[2].bAscending ) );
+                                        rOutParam.bAscending[2] ) );
                                 }
                             }
 
diff --git a/sc/source/ui/view/dbfunc3.cxx b/sc/source/ui/view/dbfunc3.cxx
index bd3fa19..e8bfb3f 100644
--- a/sc/source/ui/view/dbfunc3.cxx
+++ b/sc/source/ui/view/dbfunc3.cxx
@@ -2158,7 +2158,7 @@ void ScDBFunc::RepeatDB( sal_Bool bRecord )
 
     ScSortParam aSortParam;
     pDBData->GetSortParam( aSortParam );
-    sal_Bool bSort = aSortParam.maKeyState[0].bDoSort;
+    sal_Bool bSort = aSortParam.bDoSort[0];
 
     ScSubTotalParam aSubTotalParam;
     pDBData->GetSubTotalParam( aSubTotalParam );


More information about the Libreoffice-commits mailing list