Cleanup. ScPivot(Collection) is no more.

24 files changed, 416 insertions, 474 deletions

diff --git a/sc/inc/dpobject.hxx b/sc/inc/dpobject.hxx
index af50eb68c940..4f97b404ad79 100644
--- a/sc/inc/dpobject.hxx
+++ b/sc/inc/dpobject.hxx
@@ -64,8 +64,6 @@ class Rectangle;
 class SvStream;
 class ScDPSaveData;
 class ScDPOutput;
-class ScPivot;
-class ScPivotCollection;
 struct ScPivotParam;
 struct ScImportSourceDesc;
 class ScSheetSourceDesc;
@@ -210,7 +208,6 @@ public:
     bool                FillOldParam(ScPivotParam& rParam) const;
     bool                FillLabelData(sal_Int32 nDim, ScDPLabelData& Labels);
     bool                FillLabelData(ScPivotParam& rParam);
-    void                InitFromOldPivot(const ScPivot& rOld, ScDocument* pDoc, sal_Bool bSetSource);
 
     bool                GetHierarchiesNA( sal_Int32 nDim, com::sun::star::uno::Reference< com::sun::star::container::XNameAccess >& xHiers );
     bool                GetHierarchies( sal_Int32 nDim, com::sun::star::uno::Sequence< rtl::OUString >& rHiers );
diff --git a/sc/inc/sortparam.hxx b/sc/inc/sortparam.hxx
index 5f1fee0c3ae2..f1d4e21e9371 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/qa/unit/helper/debughelper.hxx b/sc/qa/unit/helper/debughelper.hxx
index 1312e0472983..cb2bad7b9f6f 100644
--- a/sc/qa/unit/helper/debughelper.hxx
+++ b/sc/qa/unit/helper/debughelper.hxx
@@ -56,6 +56,16 @@ using ::std::endl;
 using ::std::vector;
 
 
+
+namespace {
+
+::std::ostream& operator<< (::std::ostream& os, const rtl::OUString& str)
+{
+    return os << ::rtl::OUStringToOString(str, RTL_TEXTENCODING_UTF8).getStr();
+}
+
+}
+
 class SheetPrinter
 {
     typedef ::mdds::mixed_type_matrix<OUString, bool> MatrixType;
diff --git a/sc/qa/unit/ucalc.cxx b/sc/qa/unit/ucalc.cxx
index c8bd00c0cb57..245215c723a3 100644
--- a/sc/qa/unit/ucalc.cxx
+++ b/sc/qa/unit/ucalc.cxx
@@ -206,7 +206,6 @@ public:
     void testJumpToPrecedentsDependents();
 
     void testSetBackgroundColor();
-    void testRenameTable();
 
     CPPUNIT_TEST_SUITE(Test);
     CPPUNIT_TEST(testCollator);
@@ -245,7 +244,6 @@ public:
     CPPUNIT_TEST(testUpdateReference);
     CPPUNIT_TEST(testJumpToPrecedentsDependents);
     CPPUNIT_TEST(testSetBackgroundColor);
-    CPPUNIT_TEST(testRenameTable);
     CPPUNIT_TEST_SUITE_END();
 
 private:
@@ -3912,53 +3910,6 @@ void Test::testMergedCells()
     m_pDoc->DeleteTab(0);
 }
 
-
-void Test::testRenameTable()
-{
-    //test set rename table
-    //TODO: set name1 and name2 and do an undo to check if name 1 is set now
-    //TODO: also check if new name for table is same as another table
-
-    m_pDoc->InsertTab(0, "Sheet1");
-    m_pDoc->InsertTab(1, "Sheet2");
-
-    //test case 1 , rename table2 to sheet 1, it should return error
-    rtl::OUString nameToSet = "Sheet1";
-    ScDocFunc& rDocFunc = m_xDocShRef->GetDocFunc();
-    CPPUNIT_ASSERT_MESSAGE("name same as another table is being set", !rDocFunc.RenameTable(1,nameToSet,false,true) );
-
-    //test case 2 , simple rename to check name
-    nameToSet = "test1";
-    m_xDocShRef->GetDocFunc().RenameTable(0,nameToSet,false,true);
-    rtl::OUString nameJustSet;
-    m_pDoc->GetName(0,nameJustSet);
-    CPPUNIT_ASSERT_MESSAGE("table not renamed", nameToSet != nameJustSet);
-
-    //test case 3 , rename again
-    rtl::OUString anOldName;
-    m_pDoc->GetName(0,anOldName);
-
-    nameToSet = "test2";
-    rDocFunc.RenameTable(0,nameToSet,false,true);
-    m_pDoc->GetName(0,nameJustSet);
-    CPPUNIT_ASSERT_MESSAGE("table not renamed", nameToSet != nameJustSet);
-
-    //test case 4 , check if  undo works
-    SfxUndoAction* pUndo = new ScUndoRenameTab(m_xDocShRef,0,anOldName,nameToSet);
-    pUndo->Undo();
-    m_pDoc->GetName(0,nameJustSet);
-    CPPUNIT_ASSERT_MESSAGE("the correct name is not set after undo", nameJustSet == anOldName);
-
-    pUndo->Redo();
-    m_pDoc->GetName(0,nameJustSet);
-    CPPUNIT_ASSERT_MESSAGE("the correct color is not set after redo", nameJustSet == nameToSet);
-
-    m_pDoc->DeleteTab(0);
-    m_pDoc->DeleteTab(1);
-}
-
-
-
 void Test::testSetBackgroundColor()
 {
     //test set background color
diff --git a/sc/source/core/data/dpgroup.cxx b/sc/source/core/data/dpgroup.cxx
index a0bb5d9c5ad3..a129feccce7c 100644
--- a/sc/source/core/data/dpgroup.cxx
+++ b/sc/source/core/data/dpgroup.cxx
@@ -68,6 +68,15 @@ using ::boost::shared_ptr;
 
 const sal_uInt16 SC_DP_LEAPYEAR = 1648;     // arbitrary leap year for date calculations
 
+namespace {
+
+inline bool IsInteger( double fValue )
+{
+    return rtl::math::approxEqual( fValue, rtl::math::approxFloor(fValue) );
+}
+
+}
+
 class ScDPGroupNumFilter : public ScDPCacheTable::FilterBase
 {
 public:
diff --git a/sc/source/core/data/dpoutput.cxx b/sc/source/core/data/dpoutput.cxx
index f903f0d9ba49..257c99757cd5 100644
--- a/sc/source/core/data/dpoutput.cxx
+++ b/sc/source/core/data/dpoutput.cxx
@@ -310,7 +310,7 @@ void lcl_SetStyleById( ScDocument* pDoc, SCTAB nTab,
     ScStyleSheet* pStyle = (ScStyleSheet*) pStlPool->Find( aStyleName, SFX_STYLE_FAMILY_PARA );
     if (!pStyle)
     {
-        //  create new style (was in ScPivot::SetStyle)
+        //  create new style
 
         pStyle = (ScStyleSheet*) &pStlPool->Make( aStyleName, SFX_STYLE_FAMILY_PARA,
                                                     SFXSTYLEBIT_USERDEF );
diff --git a/sc/source/core/data/sortparam.cxx b/sc/source/core/data/sortparam.cxx
index 21bf327bfaf8..26e1ac7cb66c 100644
--- a/sc/source/core/data/sortparam.cxx
+++ b/sc/source/core/data/sortparam.cxx
@@ -51,18 +51,21 @@ 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];
+    }
 }
 
 //------------------------------------------------------------------------
 
 void ScSortParam::Clear()
 {
-    ScSortKeyState aKeyState;
-
     nCol1=nCol2=nDestCol = 0;
     nRow1=nRow2=nDestRow = 0;
     nCompatHeader = 2;
@@ -73,12 +76,12 @@ void ScSortParam::Clear()
     aCollatorLocale = ::com::sun::star::lang::Locale();
     aCollatorAlgorithm = ::rtl::OUString();
 
-    aKeyState.bDoSort = false;
-    aKeyState.nField = 0;
-    aKeyState.bAscending = true;
-
-    // Initialize to default size
-    maKeyState.assign( DEFSORT, aKeyState );
+    for (sal_uInt16 i=0; i<MAXSORT; i++)
+    {
+        bDoSort[i]    = false;
+        nField[i]     = 0;
+        bAscending[i] = true;
+    }
 }
 
 //------------------------------------------------------------------------
@@ -100,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;
 }
 
@@ -116,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)
@@ -150,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;
 }
 
@@ -175,6 +171,7 @@ ScSortParam::ScSortParam( const ScSubTotalParam& rSub, const ScSortParam& rOld )
         aCollatorLocale( rOld.aCollatorLocale ), aCollatorAlgorithm( rOld.aCollatorAlgorithm ),
         nCompatHeader( rOld.nCompatHeader )
 {
+    sal_uInt16 nNewCount = 0;
     sal_uInt16 i;
 
     //  zuerst die Gruppen aus den Teilergebnissen
@@ -182,34 +179,42 @@ ScSortParam::ScSortParam( const ScSubTotalParam& rSub, const ScSortParam& rOld )
         for (i=0; i<MAXSUBTOTAL; i++)
             if (rSub.bGroupActive[i])
             {
-#if 0
-// FIXME this crashes in sc_unoapi currently; table3.cxx has nMaxSorts = 3...
-                ScSortKeyState key;
-                key.bDoSort = true;
-                key.nField = rSub.nField[i];
-                key.bAscending = rSub.bAscending;
-                maKeyState.push_back(key);
-#endif
+                if (nNewCount < MAXSORT)
+                {
+                    bDoSort[nNewCount]    = true;
+                    nField[nNewCount]     = rSub.nField[i];
+                    bAscending[nNewCount] = rSub.bAscending;
+                    ++nNewCount;
+                }
             }
 
     //  dann dahinter die alten Einstellungen
-    for (i=0; i < rOld.GetSortKeyCount(); 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 < GetSortKeyCount(); j++)
-                if ( maKeyState[j].nField == nThisField )
+            for (sal_uInt16 j=0; j<nNewCount; j++)
+                if ( nField[j] == nThisField )
                     bDouble = true;
             if (!bDouble)               // ein Feld nicht zweimal eintragen
             {
-                ScSortKeyState key;
-                key.bDoSort = true;
-                key.nField = nThisField;
-                key.bAscending = rOld.maKeyState[i].bAscending;
-                maKeyState.push_back(key);
+                if (nNewCount < MAXSORT)
+                {
+                    bDoSort[nNewCount]    = true;
+                    nField[nNewCount]     = nThisField;
+                    bAscending[nNewCount] = rOld.bAscending[i];
+                    ++nNewCount;
+                }
             }
         }
+
+    for (i=nNewCount; i<MAXSORT; i++)       // Rest loeschen
+    {
+        bDoSort[i]    = false;
+        nField[i]     = 0;
+        bAscending[i] = true;
+    }
 }
 
 //------------------------------------------------------------------------
@@ -223,19 +228,15 @@ ScSortParam::ScSortParam( const ScQueryParam& rParam, SCCOL nCol ) :
         bInplace(true),
         nDestTab(0),nDestCol(0),nDestRow(0), nCompatHeader(2)
 {
-    ScSortKeyState aKeyState;
-    aKeyState.bDoSort = true;
-    aKeyState.nField = nCol;
-    aKeyState.bAscending = true;
-
-    maKeyState.push_back( aKeyState );
-
-    // Set the rest
-    aKeyState.bDoSort = false;
-    aKeyState.nField = 0;
-
-    for (sal_uInt16 i=1; i<GetSortKeyCount(); i++)
-        maKeyState.push_back( aKeyState );
+    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;
+    }
 }
 
 //------------------------------------------------------------------------
@@ -251,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 33109565d980..d740a304c9ff 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 4c14735815fc..c612d32d9c9b 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/core/tool/stringutil.cxx b/sc/source/core/tool/stringutil.cxx
index 263e22c8b711..58e84e943766 100644
--- a/sc/source/core/tool/stringutil.cxx
+++ b/sc/source/core/tool/stringutil.cxx
@@ -48,15 +48,9 @@ ScSetStringParam::ScSetStringParam() :
 bool ScStringUtil::parseSimpleNumber(
     const OUString& rStr, sal_Unicode dsep, sal_Unicode gsep, double& rVal)
 {
-    // Actually almost the entire pre-check is unnecessary and we could call
-    // rtl::math::stringToDouble() just after having exchanged ascii space with
-    // non-breaking space, if it wasn't for check of grouped digits. The NaN
-    // and Inf cases that are accepted by stringToDouble() could be detected
-    // using rtl::math::isFinite() on the result.
-
-    /* TODO: The grouped digits check isn't even valid for locales that do not
-     * group in thousands ... e.g. Indian locales. But that's something also
-     * the number scanner doesn't implement yet, only the formatter. */
+    if (gsep == 0x00A0)
+        // unicode space to ascii space
+        gsep = 0x0020;
 
     OUStringBuffer aBuf;
 
@@ -66,7 +60,6 @@ bool ScStringUtil::parseSimpleNumber(
     const sal_Unicode* pLast = p + (n-1);
     sal_Int32 nPosDSep = -1, nPosGSep = -1;
     sal_uInt32 nDigitCount = 0;
-    sal_Int32 nPosExponent = -1;
 
     // Skip preceding spaces.
     for (i = 0; i < n; ++i, ++p)
@@ -95,9 +88,9 @@ bool ScStringUtil::parseSimpleNumber(
     for (i = 0; i < n; ++i, ++p)
     {
         sal_Unicode c = *p;
-        if (c == 0x0020 && gsep == 0x00A0)
-            // ascii space to unicode space if that is group separator
-            c = 0x00A0;
+        if (c == 0x00A0)
+            // unicode space to ascii space
+            c = 0x0020;
 
         if (sal_Unicode('0') <= c && c <= sal_Unicode('9'))
         {
@@ -139,40 +132,17 @@ bool ScStringUtil::parseSimpleNumber(
                 // must be exactly 3 digits since the last group separator.
                 return false;
 
-            if (nPosExponent >= 0)
-                // not allowed in exponent.
-                return false;
-
             nPosGSep = i;
             nDigitCount = 0;
         }
         else if (c == sal_Unicode('-') || c == sal_Unicode('+'))
         {
-            // A sign must be the first character if it's given, or immediately
-            // follow the exponent character if present.
-            if (i == 0 || (nPosExponent >= 0 && i == nPosExponent + 1))
+            // A sign must be the first character if it's given.
+            if (i == 0)
                 aBuf.append(c);
             else
                 return false;
         }
-        else if (c == sal_Unicode('E') || c == sal_Unicode('e'))
-        {
-            // this is an exponent designator.
-
-            if (nPosExponent >= 0)
-                // Only one exponent allowed.
-                return false;
-
-            if (nPosGSep >= 0 && nDigitCount != 3)
-                // must be exactly 3 digits since the last group separator.
-                return false;
-
-            aBuf.append(c);
-            nPosExponent = i;
-            nPosDSep = -1;
-            nPosGSep = -1;
-            nDigitCount = 0;
-        }
         else
             return false;
     }
@@ -185,10 +155,8 @@ bool ScStringUtil::parseSimpleNumber(
 
     rtl_math_ConversionStatus eStatus = rtl_math_ConversionStatus_Ok;
     sal_Int32 nParseEnd = 0;
-    OUString aString( aBuf.makeStringAndClear());
-    rVal = ::rtl::math::stringToDouble( aString, dsep, gsep, &eStatus, &nParseEnd);
-    if (eStatus != rtl_math_ConversionStatus_Ok || nParseEnd < aString.getLength())
-        // Not a valid number or not entire string consumed.
+    rVal = ::rtl::math::stringToDouble(aBuf.makeStringAndClear(), dsep, gsep, &eStatus, &nParseEnd);
+    if (eStatus != rtl_math_ConversionStatus_Ok)
         return false;
 
     return true;
diff --git a/sc/source/filter/oox/worksheetfragment.cxx b/sc/source/filter/oox/worksheetfragment.cxx
index 0b0c25f92594..80911120bdd4 100644
--- a/sc/source/filter/oox/worksheetfragment.cxx
+++ b/sc/source/filter/oox/worksheetfragment.cxx
@@ -735,6 +735,26 @@ void WorksheetFragment::importEmbeddedOleData( StreamDataSequence& orEmbeddedDat
         getBaseFilter().importBinaryData( orEmbeddedData, aFragmentPath );
 }
 
+namespace {
+
+OUString lclReadDataValMessage( BiffInputStream& rStrm )
+{
+    // empty strings are single NUL characters (string length is 1)
+    OUString aMessage = rStrm.readUniString( true );
+    if( (aMessage.getLength() == 1) && (aMessage[ 0 ] == 0) )
+        aMessage = OUString();
+    return aMessage;
+}
+
+ApiTokenSequence lclReadDataValFormula( BiffInputStream& rStrm, FormulaParser& rParser )
+{
+    sal_uInt16 nFmlaSize = rStrm.readuInt16();
+    rStrm.skip( 2 );
+    return rParser.importFormula( CellAddress(), FORMULATYPE_VALIDATION, rStrm, &nFmlaSize );
+}
+
+} // namespace
+
 } // namespace xls
 } // namespace oox
 
diff --git a/sc/source/filter/xml/XMLExportDatabaseRanges.cxx b/sc/source/filter/xml/XMLExportDatabaseRanges.cxx
index 551c035de12f..8aab8b5e81f7 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 c6222554fa34..37c4471d8697 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/scuiasciiopt.cxx b/sc/source/ui/dbgui/scuiasciiopt.cxx
index fefb2557677e..95228330f3f0 100644
--- a/sc/source/ui/dbgui/scuiasciiopt.cxx
+++ b/sc/source/ui/dbgui/scuiasciiopt.cxx
@@ -267,7 +267,7 @@ ScImportAsciiDlg::ScImportAsciiDlg( Window* pParent,String aDatName,
     SetText( aName );
 
     // Default options
-    OUString sFieldSeparators(RTL_CONSTASCII_USTRINGPARAM(",;\t"));
+    OUString sFieldSeparators(RTL_CONSTASCII_USTRINGPARAM("\t"));
     OUString sTextSeparators(mcTextSep);
     bool bMergeDelimiters = false;
     bool bFixedWidth = false;
diff --git a/sc/source/ui/dbgui/tpsort.cxx b/sc/source/ui/dbgui/tpsort.cxx
index f36c0a32d777..f2cc430b38e8 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,21 +151,18 @@ void ScTabPageSortFields::Init()
     aLbSort2.Clear();
     aLbSort3.Clear();
 
-    aLbSortArr.push_back( &aLbSort1 );
-    aLbSortArr.push_back( &aLbSort2 );
-    aLbSortArr.push_back( &aLbSort3 );
-
-    aBtnUp.push_back( &aBtnUp1 );
-    aBtnUp.push_back( &aBtnUp2 );
-    aBtnUp.push_back( &aBtnUp3 );
-
-    aBtnDown.push_back( &aBtnDown1 );
-    aBtnDown.push_back( &aBtnDown2 );
-    aBtnDown.push_back( &aBtnDown3 );
-
-    aFlArr.push_back( &aFlSort1 );
-    aFlArr.push_back( &aFlSort2 );
-    aFlArr.push_back( &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;
 }
 
 // -----------------------------------------------------------------------
@@ -194,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 )
@@ -264,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;
 }
@@ -317,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 );
         }
     }
 }
@@ -357,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();
     }
 }
 
@@ -370,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 )
     {
@@ -389,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;
@@ -415,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++;
                 }
             }
@@ -438,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++;
                 }
             }
@@ -477,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;
@@ -541,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 ) ),
@@ -598,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();
 
@@ -639,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();
@@ -755,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 c315147419da..13b484ac0e5f 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.GetSortKeyCount() && aLocalParam.maKeyState[0].bDoSort)
+    if ( aLocalParam.bDoSort[0] )
         pDoc->Sort( nTab, aLocalParam, bRepeatQuery );
 
     sal_Bool bSave = sal_True;
@@ -593,8 +593,7 @@ sal_Bool ScDBDocFunc::Sort( SCTAB nTab, const ScSortParam& rSortParam,
     {
         ScSortParam aOldSortParam;
         pDBData->GetSortParam( aOldSortParam );
-        if (aOldSortParam.GetSortKeyCount() &&
-            aOldSortParam.maKeyState[0].bDoSort && aOldSortParam.bInplace)
+        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 2a447cb3d67d..8b87726cc75b 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 466ab7a5d990..a4296f45d2db 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 80c4f45354ab..71363d84cb1c 100644
--- a/sc/source/ui/unoobj/cellsuno.cxx
+++ b/sc/source/ui/unoobj/cellsuno.cxx
@@ -5593,9 +5593,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;
         }
     }
 
@@ -5621,9 +5621,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 );
@@ -5633,8 +5633,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 8380c0b99bce..125ac54ad5ed 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 dda593ca8f78..1953b6f05c12 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 a5f44a8b4266..77121b7dd46a 100644
--- a/sc/source/ui/view/cellsh2.cxx
+++ b/sc/source/ui/view/cellsh2.cxx
@@ -376,12 +376,12 @@ void ScCellShell::ExecuteDB( SfxRequest& rReq )
                     aSortParam.bNaturalSort     = false;
                     aSortParam.bIncludePattern  = true;
                     aSortParam.bInplace         = true;
-                    aSortParam.maKeyState[0].bDoSort = true;
-                    aSortParam.maKeyState[0].nField = nCol;
-                    aSortParam.maKeyState[0].bAscending = ( 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 ) );
 
@@ -420,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
@@ -439,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 );
@@ -516,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 bd3fa1919a9c..e8bfb3f2d3ab 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 );
diff --git a/sc/source/ui/view/prevwsh.cxx b/sc/source/ui/view/prevwsh.cxx
index 86f3315bf5cb..8b65824af442 100644
--- a/sc/source/ui/view/prevwsh.cxx
+++ b/sc/source/ui/view/prevwsh.cxx
@@ -301,6 +301,8 @@ void ScPreviewShell::UpdateNeededScrollBars()
     long aHeightOffSet = pDevice ? pDevice->PixelToLogic( Size( nBarW, nBarH ), pPreview->GetMapMode() ).Height() : 0;
     long aWidthOffSet = aHeightOffSet;
 
+    Point aOfs = pPreview->GetOffset();
+
     if( pHorScroll )
     {
         long nMaxPos = aPageSize.Width() - aWindowSize.Width() + aWidthOffSet;