LCOV - code coverage report
Current view: top level - sc/source/ui/view - dbfunc3.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 52 1143 4.5 %
Date: 2015-06-13 12:38:46 Functions: 3 37 8.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "dbfunc.hxx"
      21             : #include "scitems.hxx"
      22             : #include <sfx2/bindings.hxx>
      23             : #include <vcl/svapp.hxx>
      24             : #include <vcl/msgbox.hxx>
      25             : #include <vcl/waitobj.hxx>
      26             : #include <svl/zforlist.hxx>
      27             : #include <sfx2/app.hxx>
      28             : #include <com/sun/star/beans/XPropertySet.hpp>
      29             : #include <com/sun/star/container/XNameAccess.hpp>
      30             : #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
      31             : #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
      32             : #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
      33             : #include <com/sun/star/sheet/DataPilotFieldSortMode.hpp>
      34             : #include <com/sun/star/sheet/DataPilotTableHeaderData.hpp>
      35             : #include <com/sun/star/sheet/GeneralFunction.hpp>
      36             : #include <com/sun/star/sheet/MemberResultFlags.hpp>
      37             : #include <com/sun/star/sheet/XDimensionsSupplier.hpp>
      38             : #include <com/sun/star/sheet/XDrillDownDataSupplier.hpp>
      39             : 
      40             : #include "global.hxx"
      41             : #include "globstr.hrc"
      42             : #include "sc.hrc"
      43             : #include "undotab.hxx"
      44             : #include "undodat.hxx"
      45             : #include "dbdata.hxx"
      46             : #include "rangenam.hxx"
      47             : #include "rangeutl.hxx"
      48             : #include "docsh.hxx"
      49             : #include "olinetab.hxx"
      50             : #include "consoli.hxx"
      51             : #include "olinefun.hxx"
      52             : #include "dpobject.hxx"
      53             : #include "dpsave.hxx"
      54             : #include "dpdimsave.hxx"
      55             : #include "dbdocfun.hxx"
      56             : #include "dpoutput.hxx"
      57             : #include "dptabsrc.hxx"
      58             : #include "dpshttab.hxx"
      59             : #include "dpsdbtab.hxx"
      60             : #include "editable.hxx"
      61             : #include "docpool.hxx"
      62             : #include "patattr.hxx"
      63             : #include "unonames.hxx"
      64             : #include "formulacell.hxx"
      65             : #include "userlist.hxx"
      66             : #include "queryentry.hxx"
      67             : #include "markdata.hxx"
      68             : #include "stringutil.hxx"
      69             : 
      70             : #include <boost/scoped_ptr.hpp>
      71             : #include <list>
      72             : #include <unordered_set>
      73             : #include <unordered_map>
      74             : #include <vector>
      75             : 
      76             : using namespace com::sun::star;
      77             : using ::com::sun::star::uno::Any;
      78             : using ::com::sun::star::uno::Sequence;
      79             : using ::com::sun::star::uno::Reference;
      80             : using ::com::sun::star::uno::UNO_QUERY;
      81             : using ::com::sun::star::beans::XPropertySet;
      82             : using ::com::sun::star::container::XNameAccess;
      83             : using ::com::sun::star::sheet::XDimensionsSupplier;
      84             : using ::std::list;
      85             : using ::std::vector;
      86             : 
      87             : // STATIC DATA -----------------------------------------------------------
      88             : 
      89             : //          Outliner
      90             : 
      91             : //  Outline-Gruppierung erzeugen
      92             : 
      93           0 : void ScDBFunc::MakeOutline( bool bColumns, bool bRecord )
      94             : {
      95           0 :     ScRange aRange;
      96           0 :     if (GetViewData().GetSimpleArea(aRange) == SC_MARK_SIMPLE)
      97             :     {
      98           0 :         ScDocShell* pDocSh = GetViewData().GetDocShell();
      99           0 :         ScOutlineDocFunc aFunc(*pDocSh);
     100           0 :         aFunc.MakeOutline( aRange, bColumns, bRecord, false );
     101             :     }
     102             :     else
     103           0 :         ErrorMessage(STR_NOMULTISELECT);
     104           0 : }
     105             : 
     106             : //  Outline-Gruppierung loeschen
     107             : 
     108           0 : void ScDBFunc::RemoveOutline( bool bColumns, bool bRecord )
     109             : {
     110           0 :     ScRange aRange;
     111           0 :     if (GetViewData().GetSimpleArea(aRange) == SC_MARK_SIMPLE)
     112             :     {
     113           0 :         ScDocShell* pDocSh = GetViewData().GetDocShell();
     114           0 :         ScOutlineDocFunc aFunc(*pDocSh);
     115           0 :         aFunc.RemoveOutline( aRange, bColumns, bRecord, false );
     116             :     }
     117             :     else
     118           0 :         ErrorMessage(STR_NOMULTISELECT);
     119           0 : }
     120             : 
     121             : //  Menue-Status: Outlines loeschen
     122             : 
     123           0 : void ScDBFunc::TestRemoveOutline( bool& rCol, bool& rRow )
     124             : {
     125           0 :     bool bColFound = false;
     126           0 :     bool bRowFound = false;
     127             : 
     128             :     SCCOL nStartCol, nEndCol;
     129             :     SCROW nStartRow, nEndRow;
     130             :     SCTAB nStartTab, nEndTab;
     131           0 :     if (GetViewData().GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
     132             :     {
     133           0 :         SCTAB nTab = nStartTab;
     134           0 :         ScDocument* pDoc = GetViewData().GetDocument();
     135           0 :         ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
     136           0 :         if (pTable)
     137             :         {
     138             :             ScOutlineEntry* pEntry;
     139             :             SCCOLROW nStart;
     140             :             SCCOLROW nEnd;
     141           0 :             bool bColMarked = ( nStartRow == 0 && nEndRow == MAXROW );
     142           0 :             bool bRowMarked = ( nStartCol == 0 && nEndCol == MAXCOL );
     143             : 
     144             :             //  Spalten
     145             : 
     146           0 :             if ( !bRowMarked || bColMarked )        // nicht wenn ganze Zeilen markiert
     147             :             {
     148           0 :                 ScOutlineArray& rArray = pTable->GetColArray();
     149           0 :                 ScSubOutlineIterator aColIter( &rArray );
     150           0 :                 while ((pEntry=aColIter.GetNext()) != NULL && !bColFound)
     151             :                 {
     152           0 :                     nStart = pEntry->GetStart();
     153           0 :                     nEnd   = pEntry->GetEnd();
     154           0 :                     if ( nStartCol<=static_cast<SCCOL>(nEnd) && nEndCol>=static_cast<SCCOL>(nStart) )
     155           0 :                         bColFound = true;
     156             :                 }
     157             :             }
     158             : 
     159             :             //  Zeilen
     160             : 
     161           0 :             if ( !bColMarked || bRowMarked )        // nicht wenn ganze Spalten markiert
     162             :             {
     163           0 :                 ScOutlineArray& rArray = pTable->GetRowArray();
     164           0 :                 ScSubOutlineIterator aRowIter( &rArray );
     165           0 :                 while ((pEntry=aRowIter.GetNext()) != NULL && !bRowFound)
     166             :                 {
     167           0 :                     nStart = pEntry->GetStart();
     168           0 :                     nEnd   = pEntry->GetEnd();
     169           0 :                     if ( nStartRow<=nEnd && nEndRow>=nStart )
     170           0 :                         bRowFound = true;
     171             :                 }
     172             :             }
     173             :         }
     174             :     }
     175             : 
     176           0 :     rCol = bColFound;
     177           0 :     rRow = bRowFound;
     178           0 : }
     179             : 
     180           0 : void ScDBFunc::RemoveAllOutlines( bool bRecord )
     181             : {
     182           0 :     SCTAB nTab = GetViewData().GetTabNo();
     183           0 :     ScDocShell* pDocSh = GetViewData().GetDocShell();
     184           0 :     ScOutlineDocFunc aFunc(*pDocSh);
     185             : 
     186           0 :     bool bOk = aFunc.RemoveAllOutlines( nTab, bRecord );
     187             : 
     188           0 :     if (bOk)
     189           0 :         UpdateScrollBars();
     190           0 : }
     191             : 
     192             : //  Auto-Outlines
     193             : 
     194           0 : void ScDBFunc::AutoOutline( bool bRecord )
     195             : {
     196           0 :     SCTAB nTab = GetViewData().GetTabNo();
     197           0 :     ScRange aRange( 0,0,nTab, MAXCOL,MAXROW,nTab );     // ganze Tabelle, wenn nichts markiert
     198           0 :     ScMarkData& rMark = GetViewData().GetMarkData();
     199           0 :     if ( rMark.IsMarked() || rMark.IsMultiMarked() )
     200             :     {
     201           0 :         rMark.MarkToMulti();
     202           0 :         rMark.GetMultiMarkArea( aRange );
     203             :     }
     204             : 
     205           0 :     ScDocShell* pDocSh = GetViewData().GetDocShell();
     206           0 :     ScOutlineDocFunc aFunc(*pDocSh);
     207           0 :     aFunc.AutoOutline( aRange, bRecord );
     208           0 : }
     209             : 
     210             : //  Outline-Ebene auswaehlen
     211             : 
     212           0 : void ScDBFunc::SelectLevel( bool bColumns, sal_uInt16 nLevel, bool bRecord, bool bPaint )
     213             : {
     214           0 :     SCTAB nTab = GetViewData().GetTabNo();
     215           0 :     ScDocShell* pDocSh = GetViewData().GetDocShell();
     216           0 :     ScOutlineDocFunc aFunc(*pDocSh);
     217             : 
     218           0 :     bool bOk = aFunc.SelectLevel( nTab, bColumns, nLevel, bRecord, bPaint );
     219             : 
     220           0 :     if (bOk)
     221           0 :         UpdateScrollBars();
     222           0 : }
     223             : 
     224             : //  einzelne Outline-Gruppe einblenden
     225             : 
     226           0 : void ScDBFunc::ShowOutline( bool bColumns, sal_uInt16 nLevel, sal_uInt16 nEntry, bool bRecord, bool bPaint )
     227             : {
     228           0 :     SCTAB nTab = GetViewData().GetTabNo();
     229           0 :     ScDocShell* pDocSh = GetViewData().GetDocShell();
     230           0 :     ScOutlineDocFunc aFunc(*pDocSh);
     231             : 
     232           0 :     bool bOk = aFunc.ShowOutline( nTab, bColumns, nLevel, nEntry, bRecord, bPaint );
     233             : 
     234           0 :     if ( bOk && bPaint )
     235           0 :         UpdateScrollBars();
     236           0 : }
     237             : 
     238             : //  einzelne Outline-Gruppe ausblenden
     239             : 
     240           0 : void ScDBFunc::HideOutline( bool bColumns, sal_uInt16 nLevel, sal_uInt16 nEntry, bool bRecord, bool bPaint )
     241             : {
     242           0 :     SCTAB nTab = GetViewData().GetTabNo();
     243           0 :     ScDocShell* pDocSh = GetViewData().GetDocShell();
     244           0 :     ScOutlineDocFunc aFunc(*pDocSh);
     245             : 
     246           0 :     bool bOk = aFunc.HideOutline( nTab, bColumns, nLevel, nEntry, bRecord, bPaint );
     247             : 
     248           0 :     if ( bOk && bPaint )
     249           0 :         UpdateScrollBars();
     250           0 : }
     251             : 
     252             : //  Menue-Status: markierten Bereich ein-/ausblenden
     253             : 
     254           0 : bool ScDBFunc::OutlinePossible(bool bHide)
     255             : {
     256           0 :     bool bEnable = false;
     257             : 
     258             :     SCCOL nStartCol;
     259             :     SCROW nStartRow;
     260             :     SCTAB nStartTab;
     261             :     SCCOL nEndCol;
     262             :     SCROW nEndRow;
     263             :     SCTAB nEndTab;
     264             : 
     265           0 :     if (GetViewData().GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
     266             :     {
     267           0 :         ScDocument* pDoc = GetViewData().GetDocument();
     268           0 :         SCTAB nTab = GetViewData().GetTabNo();
     269           0 :         ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
     270           0 :         if (pTable)
     271             :         {
     272             :             ScOutlineEntry* pEntry;
     273             :             SCCOLROW nStart;
     274             :             SCCOLROW nEnd;
     275             : 
     276             :             //  Spalten
     277             : 
     278           0 :             ScOutlineArray& rColArray = pTable->GetColArray();
     279           0 :             ScSubOutlineIterator aColIter( &rColArray );
     280           0 :             while ((pEntry=aColIter.GetNext()) != NULL && !bEnable)
     281             :             {
     282           0 :                 nStart = pEntry->GetStart();
     283           0 :                 nEnd   = pEntry->GetEnd();
     284           0 :                 if ( bHide )
     285             :                 {
     286           0 :                     if ( nStartCol<=static_cast<SCCOL>(nEnd) && nEndCol>=static_cast<SCCOL>(nStart) )
     287           0 :                         if (!pEntry->IsHidden())
     288           0 :                             bEnable = true;
     289             :                 }
     290             :                 else
     291             :                 {
     292           0 :                     if ( nStart>=nStartCol && nEnd<=nEndCol )
     293           0 :                         if (pEntry->IsHidden())
     294           0 :                             bEnable = true;
     295             :                 }
     296             :             }
     297             : 
     298             :             //  Zeilen
     299             : 
     300           0 :             ScOutlineArray& rRowArray = pTable->GetRowArray();
     301           0 :             ScSubOutlineIterator aRowIter( &rRowArray );
     302           0 :             while ((pEntry=aRowIter.GetNext()) != NULL)
     303             :             {
     304           0 :                 nStart = pEntry->GetStart();
     305           0 :                 nEnd   = pEntry->GetEnd();
     306           0 :                 if ( bHide )
     307             :                 {
     308           0 :                     if ( nStartRow<=nEnd && nEndRow>=nStart )
     309           0 :                         if (!pEntry->IsHidden())
     310           0 :                             bEnable = true;
     311             :                 }
     312             :                 else
     313             :                 {
     314           0 :                     if ( nStart>=nStartRow && nEnd<=nEndRow )
     315           0 :                         if (pEntry->IsHidden())
     316           0 :                             bEnable = true;
     317             :                 }
     318             :             }
     319             :         }
     320             :     }
     321             : 
     322           0 :     return bEnable;
     323             : }
     324             : 
     325             : //  markierten Bereich einblenden
     326             : 
     327           0 : void ScDBFunc::ShowMarkedOutlines( bool bRecord )
     328             : {
     329           0 :     ScRange aRange;
     330           0 :     if (GetViewData().GetSimpleArea(aRange) == SC_MARK_SIMPLE)
     331             :     {
     332           0 :         ScDocShell* pDocSh = GetViewData().GetDocShell();
     333           0 :         ScOutlineDocFunc aFunc(*pDocSh);
     334           0 :         bool bDone = aFunc.ShowMarkedOutlines( aRange, bRecord );
     335           0 :         if (bDone)
     336           0 :             UpdateScrollBars();
     337             :     }
     338             :     else
     339           0 :         ErrorMessage(STR_NOMULTISELECT);
     340           0 : }
     341             : 
     342             : //  markierten Bereich ausblenden
     343             : 
     344           0 : void ScDBFunc::HideMarkedOutlines( bool bRecord )
     345             : {
     346           0 :     ScRange aRange;
     347           0 :     if (GetViewData().GetSimpleArea(aRange) == SC_MARK_SIMPLE)
     348             :     {
     349           0 :         ScDocShell* pDocSh = GetViewData().GetDocShell();
     350           0 :         ScOutlineDocFunc aFunc(*pDocSh);
     351           0 :         bool bDone = aFunc.HideMarkedOutlines( aRange, bRecord );
     352           0 :         if (bDone)
     353           0 :             UpdateScrollBars();
     354             :     }
     355             :     else
     356           0 :         ErrorMessage(STR_NOMULTISELECT);
     357           0 : }
     358             : 
     359             : //          Teilergebnisse
     360             : 
     361           0 : void ScDBFunc::DoSubTotals( const ScSubTotalParam& rParam, bool bRecord,
     362             :                             const ScSortParam* pForceNewSort )
     363             : {
     364           0 :     bool bDo = !rParam.bRemoveOnly;                         // sal_False = nur loeschen
     365             : 
     366           0 :     ScDocShell* pDocSh = GetViewData().GetDocShell();
     367           0 :     ScDocument& rDoc = pDocSh->GetDocument();
     368           0 :     ScMarkData& rMark = GetViewData().GetMarkData();
     369           0 :     SCTAB nTab = GetViewData().GetTabNo();
     370           0 :     if (bRecord && !rDoc.IsUndoEnabled())
     371           0 :         bRecord = false;
     372             : 
     373             :     ScDBData* pDBData = rDoc.GetDBAtArea( nTab, rParam.nCol1, rParam.nRow1,
     374           0 :                                                 rParam.nCol2, rParam.nRow2 );
     375           0 :     if (!pDBData)
     376             :     {
     377             :         OSL_FAIL( "SubTotals: keine DBData" );
     378           0 :         return;
     379             :     }
     380             : 
     381           0 :     ScEditableTester aTester( &rDoc, nTab, 0,rParam.nRow1+1, MAXCOL,MAXROW );
     382           0 :     if (!aTester.IsEditable())
     383             :     {
     384           0 :         ErrorMessage(aTester.GetMessageId());
     385           0 :         return;
     386             :     }
     387             : 
     388           0 :     if (rDoc.HasAttrib( rParam.nCol1, rParam.nRow1+1, nTab,
     389           0 :                          rParam.nCol2, rParam.nRow2, nTab, HASATTR_MERGED | HASATTR_OVERLAPPED ))
     390             :     {
     391           0 :         ErrorMessage(STR_MSSG_INSERTCELLS_0);   // nicht in zusammengefasste einfuegen
     392           0 :         return;
     393             :     }
     394             : 
     395           0 :     WaitObject aWait( GetViewData().GetDialogParent() );
     396           0 :     bool bOk = true;
     397           0 :     if (rParam.bReplace)
     398           0 :         if (rDoc.TestRemoveSubTotals( nTab, rParam ))
     399             :         {
     400           0 :             bOk = ( ScopedVclPtr<MessBox>::Create( GetViewData().GetDialogParent(), WinBits(WB_YES_NO | WB_DEF_YES),
     401             :                 // "StarCalc" "Daten loeschen?"
     402           0 :                 ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ),
     403           0 :                 ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_1 ) )->Execute()
     404           0 :                 == RET_YES );
     405             :         }
     406             : 
     407           0 :     if (bOk)
     408             :     {
     409           0 :         ScDocShellModificator aModificator( *pDocSh );
     410             : 
     411           0 :         ScSubTotalParam aNewParam( rParam );        // Bereichsende wird veraendert
     412           0 :         ScDocument*     pUndoDoc = NULL;
     413           0 :         ScOutlineTable* pUndoTab = NULL;
     414           0 :         ScRangeName*    pUndoRange = NULL;
     415           0 :         ScDBCollection* pUndoDB = NULL;
     416             : 
     417           0 :         if (bRecord)                                        // alte Daten sichern
     418             :         {
     419           0 :             bool bOldFilter = bDo && rParam.bDoSort;
     420           0 :             SCTAB nTabCount = rDoc.GetTableCount();
     421           0 :             pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
     422           0 :             ScOutlineTable* pTable = rDoc.GetOutlineTable( nTab );
     423           0 :             if (pTable)
     424             :             {
     425           0 :                 pUndoTab = new ScOutlineTable( *pTable );
     426             : 
     427             :                 SCCOLROW nOutStartCol;                          // Zeilen/Spaltenstatus
     428             :                 SCCOLROW nOutStartRow;
     429             :                 SCCOLROW nOutEndCol;
     430             :                 SCCOLROW nOutEndRow;
     431           0 :                 pTable->GetColArray().GetRange( nOutStartCol, nOutEndCol );
     432           0 :                 pTable->GetRowArray().GetRange( nOutStartRow, nOutEndRow );
     433             : 
     434           0 :                 pUndoDoc->InitUndo( &rDoc, nTab, nTab, true, true );
     435           0 :                 rDoc.CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, IDF_NONE, false, pUndoDoc );
     436           0 :                 rDoc.CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, IDF_NONE, false, pUndoDoc );
     437             :             }
     438             :             else
     439           0 :                 pUndoDoc->InitUndo( &rDoc, nTab, nTab, false, bOldFilter );
     440             : 
     441             :             //  Datenbereich sichern - incl. Filter-Ergebnis
     442             :             rDoc.CopyToDocument( 0,rParam.nRow1+1,nTab, MAXCOL,rParam.nRow2,nTab,
     443           0 :                                     IDF_ALL, false, pUndoDoc );
     444             : 
     445             :             //  alle Formeln wegen Referenzen
     446             :             rDoc.CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1,
     447           0 :                                         IDF_FORMULA, false, pUndoDoc );
     448             : 
     449             :             //  DB- und andere Bereiche
     450           0 :             ScRangeName* pDocRange = rDoc.GetRangeName();
     451           0 :             if (!pDocRange->empty())
     452           0 :                 pUndoRange = new ScRangeName( *pDocRange );
     453           0 :             ScDBCollection* pDocDB = rDoc.GetDBCollection();
     454           0 :             if (!pDocDB->empty())
     455           0 :                 pUndoDB = new ScDBCollection( *pDocDB );
     456             :         }
     457             : 
     458           0 :         ScOutlineTable* pOut = rDoc.GetOutlineTable( nTab );
     459           0 :         if (pOut)
     460             :         {
     461             :             // Remove all existing outlines in the specified range.
     462           0 :             ScOutlineArray& rRowArray = pOut->GetRowArray();
     463           0 :             sal_uInt16 nDepth = rRowArray.GetDepth();
     464           0 :             for (sal_uInt16 i = 0; i < nDepth; ++i)
     465             :             {
     466             :                 bool bSize;
     467           0 :                 rRowArray.Remove(aNewParam.nRow1, aNewParam.nRow2, bSize);
     468             :             }
     469             :         }
     470             : 
     471           0 :         if (rParam.bReplace)
     472           0 :             rDoc.RemoveSubTotals( nTab, aNewParam );
     473           0 :         bool bSuccess = true;
     474           0 :         if (bDo)
     475             :         {
     476             :             // Sortieren
     477           0 :             if ( rParam.bDoSort || pForceNewSort )
     478             :             {
     479           0 :                 pDBData->SetArea( nTab, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 );
     480             : 
     481             :                 //  Teilergebnis-Felder vor die Sortierung setzen
     482             :                 //  (doppelte werden weggelassen, kann darum auch wieder aufgerufen werden)
     483             : 
     484           0 :                 ScSortParam aOldSort;
     485           0 :                 pDBData->GetSortParam( aOldSort );
     486           0 :                 ScSortParam aSortParam( aNewParam, pForceNewSort ? *pForceNewSort : aOldSort );
     487           0 :                 Sort( aSortParam, false, false );
     488             :             }
     489             : 
     490           0 :             bSuccess = rDoc.DoSubTotals( nTab, aNewParam );
     491             :         }
     492             :         ScRange aDirtyRange( aNewParam.nCol1, aNewParam.nRow1, nTab,
     493           0 :             aNewParam.nCol2, aNewParam.nRow2, nTab );
     494           0 :         rDoc.SetDirty( aDirtyRange, true );
     495             : 
     496           0 :         if (bRecord)
     497             :         {
     498           0 :             pDocSh->GetUndoManager()->AddUndoAction(
     499             :                 new ScUndoSubTotals( pDocSh, nTab,
     500             :                                         rParam, aNewParam.nRow2,
     501             :                                         pUndoDoc, pUndoTab, // pUndoDBData,
     502           0 :                                         pUndoRange, pUndoDB ) );
     503             :         }
     504             : 
     505           0 :         if (!bSuccess)
     506             :         {
     507             :             // "Kann keine Zeilen einfuegen"
     508           0 :             ErrorMessage(STR_MSSG_DOSUBTOTALS_2);
     509             :         }
     510             : 
     511             :                                                     // merken
     512           0 :         pDBData->SetSubTotalParam( aNewParam );
     513           0 :         pDBData->SetArea( nTab, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 );
     514           0 :         rDoc.CompileDBFormula();
     515             : 
     516           0 :         DoneBlockMode();
     517           0 :         InitOwnBlockMode();
     518             :         rMark.SetMarkArea( ScRange( aNewParam.nCol1,aNewParam.nRow1,nTab,
     519           0 :                                     aNewParam.nCol2,aNewParam.nRow2,nTab ) );
     520           0 :         MarkDataChanged();
     521             : 
     522             :         pDocSh->PostPaint(ScRange(0, 0, nTab, MAXCOL, MAXROW, nTab),
     523           0 :                           PAINT_GRID | PAINT_LEFT | PAINT_TOP | PAINT_SIZE);
     524             : 
     525           0 :         aModificator.SetDocumentModified();
     526             : 
     527           0 :         SelectionChanged();
     528           0 :     }
     529             : }
     530             : 
     531             : //          Consolidate
     532             : 
     533           0 : void ScDBFunc::Consolidate( const ScConsolidateParam& rParam, bool bRecord )
     534             : {
     535           0 :     ScDocShell* pDocShell = GetViewData().GetDocShell();
     536           0 :     pDocShell->DoConsolidate( rParam, bRecord );
     537           0 :     SetTabNo( rParam.nTab, true );
     538           0 : }
     539             : 
     540             : //          Pivot
     541             : 
     542           0 : static OUString lcl_MakePivotTabName( const OUString& rPrefix, SCTAB nNumber )
     543             : {
     544           0 :     OUString aName = rPrefix + OUString::number( nNumber );
     545           0 :     return aName;
     546             : }
     547             : 
     548           0 : bool ScDBFunc::MakePivotTable(
     549             :     const ScDPSaveData& rData, const ScRange& rDest, bool bNewTable,
     550             :     const ScDPObject& rSource, bool bApi )
     551             : {
     552             :     //  error message if no fields are set
     553             :     //  this must be removed when drag&drop of fields from a toolbox is available
     554             : 
     555           0 :     if ( rData.IsEmpty() && !bApi )
     556             :     {
     557           0 :         ErrorMessage(STR_PIVOT_NODATA);
     558           0 :         return false;
     559             :     }
     560             : 
     561           0 :     ScDocShell* pDocSh  = GetViewData().GetDocShell();
     562           0 :     ScDocument* pDoc    = GetViewData().GetDocument();
     563           0 :     bool bUndo = pDoc->IsUndoEnabled();
     564             : 
     565           0 :     ScRange aDestRange = rDest;
     566           0 :     if ( bNewTable )
     567             :     {
     568           0 :         SCTAB nSrcTab = GetViewData().GetTabNo();
     569             : 
     570           0 :         OUString aName( ScGlobal::GetRscString(STR_PIVOT_TABLE) );
     571           0 :         OUString aStr;
     572             : 
     573           0 :         pDoc->GetName( nSrcTab, aStr );
     574           0 :         aName += "_";
     575           0 :         aName += aStr;
     576           0 :         aName += "_";
     577             : 
     578           0 :         SCTAB nNewTab = nSrcTab+1;
     579             : 
     580           0 :         SCTAB i=1;
     581           0 :         while ( !pDoc->InsertTab( nNewTab, lcl_MakePivotTabName( aName, i ) ) && i <= MAXTAB )
     582           0 :             i++;
     583             : 
     584           0 :         bool bAppend = ( nNewTab+1 == pDoc->GetTableCount() );
     585           0 :         if (bUndo)
     586             :         {
     587           0 :             pDocSh->GetUndoManager()->AddUndoAction(
     588           0 :                         new ScUndoInsertTab( pDocSh, nNewTab, bAppend, lcl_MakePivotTabName( aName, i ) ));
     589             :         }
     590             : 
     591           0 :         GetViewData().InsertTab( nNewTab );
     592           0 :         SetTabNo(nNewTab, true);
     593             : 
     594           0 :         aDestRange = ScRange( 0, 0, nNewTab );
     595             :     }
     596             : 
     597             :     ScDPObject* pDPObj = pDoc->GetDPAtCursor(
     598           0 :                             aDestRange.aStart.Col(), aDestRange.aStart.Row(), aDestRange.aStart.Tab() );
     599             : 
     600           0 :     ScDPObject aObj( rSource );
     601           0 :     aObj.SetOutRange( aDestRange );
     602           0 :     if ( pDPObj && !rData.GetExistingDimensionData() )
     603             :     {
     604             :         // copy dimension data from old object - lost in the dialog
     605             :         //! change the dialog to keep the dimension data
     606             : 
     607           0 :         ScDPSaveData aNewData( rData );
     608           0 :         const ScDPSaveData* pOldData = pDPObj->GetSaveData();
     609           0 :         if ( pOldData )
     610             :         {
     611           0 :             const ScDPDimensionSaveData* pDimSave = pOldData->GetExistingDimensionData();
     612           0 :             aNewData.SetDimensionData( pDimSave );
     613             :         }
     614           0 :         aObj.SetSaveData( aNewData );
     615             :     }
     616             :     else
     617           0 :         aObj.SetSaveData( rData );
     618             : 
     619           0 :     bool bAllowMove = (pDPObj != NULL);   // allow re-positioning when editing existing table
     620             : 
     621           0 :     ScDBDocFunc aFunc( *pDocSh );
     622           0 :     bool bSuccess = aFunc.DataPilotUpdate(pDPObj, &aObj, true, false, bAllowMove);
     623             : 
     624           0 :     CursorPosChanged();     // shells may be switched
     625             : 
     626           0 :     if ( bNewTable )
     627             :     {
     628           0 :         pDocSh->PostPaintExtras();
     629           0 :         SfxGetpApp()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
     630             :     }
     631             : 
     632           0 :     return bSuccess;
     633             : }
     634             : 
     635           0 : void ScDBFunc::DeletePivotTable()
     636             : {
     637           0 :     ScDocShell* pDocSh    = GetViewData().GetDocShell();
     638           0 :     ScDocument& rDoc      = pDocSh->GetDocument();
     639           0 :     ScDPObject* pDPObj    = rDoc.GetDPAtCursor( GetViewData().GetCurX(),
     640           0 :                                                   GetViewData().GetCurY(),
     641           0 :                                                   GetViewData().GetTabNo() );
     642           0 :     if ( pDPObj )
     643             :     {
     644           0 :         ScDBDocFunc aFunc( *pDocSh );
     645           0 :         aFunc.RemovePivotTable(*pDPObj, true, false);
     646           0 :         CursorPosChanged();     // shells may be switched
     647             :     }
     648             :     else
     649           0 :         ErrorMessage(STR_PIVOT_NOTFOUND);
     650           0 : }
     651             : 
     652           0 : void ScDBFunc::RecalcPivotTable()
     653             : {
     654           0 :     ScDocShell* pDocSh  = GetViewData().GetDocShell();
     655           0 :     ScDocument* pDoc    = GetViewData().GetDocument();
     656             : 
     657           0 :     ScDPObject* pDPObj  = pDoc->GetDPAtCursor( GetViewData().GetCurX(),
     658           0 :                                                   GetViewData().GetCurY(),
     659           0 :                                                   GetViewData().GetTabNo() );
     660           0 :     if (pDPObj)
     661             :     {
     662             :         // Remove existing data cache for the data that this datapilot uses,
     663             :         // to force re-build data cache.
     664           0 :         ScDBDocFunc aFunc(*pDocSh);
     665           0 :         aFunc.RefreshPivotTables(pDPObj, false);
     666             : 
     667           0 :         CursorPosChanged();     // shells may be switched
     668             :     }
     669             :     else
     670           0 :         ErrorMessage(STR_PIVOT_NOTFOUND);
     671           0 : }
     672             : 
     673           0 : void ScDBFunc::GetSelectedMemberList(ScDPUniqueStringSet& rEntries, long& rDimension)
     674             : {
     675           0 :     ScDPObject* pDPObj = GetViewData().GetDocument()->GetDPAtCursor( GetViewData().GetCurX(),
     676           0 :                                         GetViewData().GetCurY(), GetViewData().GetTabNo() );
     677           0 :     if ( !pDPObj )
     678           0 :         return;
     679             : 
     680           0 :     long nStartDimension = -1;
     681           0 :     long nStartHierarchy = -1;
     682           0 :     long nStartLevel     = -1;
     683             : 
     684           0 :     ScRangeListRef xRanges;
     685           0 :     GetViewData().GetMultiArea( xRanges );         // incl. cursor if nothing is selected
     686           0 :     size_t nRangeCount = xRanges->size();
     687           0 :     bool bContinue = true;
     688             : 
     689           0 :     for (size_t nRangePos=0; nRangePos < nRangeCount && bContinue; nRangePos++)
     690             :     {
     691           0 :         ScRange aRange = *(*xRanges)[nRangePos];
     692           0 :         SCCOL nStartCol = aRange.aStart.Col();
     693           0 :         SCROW nStartRow = aRange.aStart.Row();
     694           0 :         SCCOL nEndCol = aRange.aEnd.Col();
     695           0 :         SCROW nEndRow = aRange.aEnd.Row();
     696           0 :         SCTAB nTab = aRange.aStart.Tab();
     697             : 
     698           0 :         for (SCROW nRow=nStartRow; nRow<=nEndRow && bContinue; nRow++)
     699           0 :             for (SCCOL nCol=nStartCol; nCol<=nEndCol && bContinue; nCol++)
     700             :             {
     701           0 :                 sheet::DataPilotTableHeaderData aData;
     702           0 :                 pDPObj->GetHeaderPositionData(ScAddress(nCol, nRow, nTab), aData);
     703           0 :                 if ( aData.Dimension < 0 )
     704           0 :                     bContinue = false;              // not part of any dimension
     705             :                 else
     706             :                 {
     707           0 :                     if ( nStartDimension < 0 )      // first member?
     708             :                     {
     709           0 :                         nStartDimension = aData.Dimension;
     710           0 :                         nStartHierarchy = aData.Hierarchy;
     711           0 :                         nStartLevel     = aData.Level;
     712             :                     }
     713           0 :                     if ( aData.Dimension != nStartDimension ||
     714           0 :                          aData.Hierarchy != nStartHierarchy ||
     715           0 :                          aData.Level     != nStartLevel )
     716             :                     {
     717           0 :                         bContinue = false;          // cannot mix dimensions
     718             :                     }
     719             :                 }
     720           0 :                 if ( bContinue )
     721             :                 {
     722             :                     // accept any part of a member description, also subtotals,
     723             :                     // but don't stop if empty parts are contained
     724           0 :                     if ( aData.Flags & sheet::MemberResultFlags::HASMEMBER )
     725           0 :                         rEntries.insert(aData.MemberName);
     726             :                 }
     727           0 :             }
     728             :     }
     729             : 
     730           0 :     rDimension = nStartDimension;   // dimension from which the found members came
     731           0 :     if (!bContinue)
     732           0 :         rEntries.clear();         // remove all if not valid
     733             : }
     734             : 
     735           0 : bool ScDBFunc::HasSelectionForDateGroup( ScDPNumGroupInfo& rOldInfo, sal_Int32& rParts )
     736             : {
     737             :     // determine if the date group dialog has to be shown for the current selection
     738             : 
     739           0 :     bool bFound = false;
     740             : 
     741           0 :     SCCOL nCurX = GetViewData().GetCurX();
     742           0 :     SCROW nCurY = GetViewData().GetCurY();
     743           0 :     SCTAB nTab = GetViewData().GetTabNo();
     744           0 :     ScDocument* pDoc = GetViewData().GetDocument();
     745             : 
     746           0 :     ScDPObject* pDPObj = pDoc->GetDPAtCursor( nCurX, nCurY, nTab );
     747           0 :     if ( pDPObj )
     748             :     {
     749           0 :         ScDPUniqueStringSet aEntries;
     750           0 :         long nSelectDimension = -1;
     751           0 :         GetSelectedMemberList( aEntries, nSelectDimension );
     752             : 
     753           0 :         if (!aEntries.empty())
     754             :         {
     755             :             bool bIsDataLayout;
     756           0 :             OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
     757           0 :             OUString aBaseDimName( aDimName );
     758             : 
     759           0 :             bool bInGroupDim = false;
     760           0 :             bool bFoundParts = false;
     761             : 
     762             :             ScDPDimensionSaveData* pDimData =
     763           0 :                 const_cast<ScDPDimensionSaveData*>( pDPObj->GetSaveData()->GetExistingDimensionData() );
     764           0 :             if ( pDimData )
     765             :             {
     766           0 :                 const ScDPSaveNumGroupDimension* pNumGroupDim = pDimData->GetNumGroupDim( aDimName );
     767           0 :                 const ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDim( aDimName );
     768           0 :                 if ( pNumGroupDim )
     769             :                 {
     770             :                     //  existing num group dimension
     771             : 
     772           0 :                     if ( pNumGroupDim->GetDatePart() != 0 )
     773             :                     {
     774             :                         //  dimension has date info -> edit settings of this dimension
     775             :                         //  (parts are collected below)
     776             : 
     777           0 :                         rOldInfo = pNumGroupDim->GetDateInfo();
     778           0 :                         bFound = true;
     779             :                     }
     780           0 :                     else if ( pNumGroupDim->GetInfo().mbDateValues )
     781             :                     {
     782             :                         //  Numerical grouping with DateValues flag is used for grouping
     783             :                         //  of days with a "Number of days" value.
     784             : 
     785           0 :                         rOldInfo = pNumGroupDim->GetInfo();
     786           0 :                         rParts = com::sun::star::sheet::DataPilotFieldGroupBy::DAYS;               // not found in CollectDateParts
     787           0 :                         bFoundParts = true;
     788           0 :                         bFound = true;
     789             :                     }
     790           0 :                     bInGroupDim = true;
     791             :                 }
     792           0 :                 else if ( pGroupDim )
     793             :                 {
     794             :                     //  existing additional group dimension
     795             : 
     796           0 :                     if ( pGroupDim->GetDatePart() != 0 )
     797             :                     {
     798             :                         //  dimension has date info -> edit settings of this dimension
     799             :                         //  (parts are collected below)
     800             : 
     801           0 :                         rOldInfo = pGroupDim->GetDateInfo();
     802           0 :                         aBaseDimName = pGroupDim->GetSourceDimName();
     803           0 :                         bFound = true;
     804             :                     }
     805           0 :                     bInGroupDim = true;
     806             :                 }
     807             :             }
     808           0 :             if ( bFound && !bFoundParts )
     809             :             {
     810             :                 // collect date parts from all group dimensions
     811           0 :                 rParts = pDimData->CollectDateParts( aBaseDimName );
     812             :             }
     813           0 :             if ( !bFound && !bInGroupDim )
     814             :             {
     815             :                 // create new date group dimensions if the selection is a single cell
     816             :                 // in a normal dimension with date content
     817             : 
     818           0 :                 ScRange aSelRange;
     819           0 :                 if ( (GetViewData().GetSimpleArea( aSelRange ) == SC_MARK_SIMPLE) &&
     820           0 :                         aSelRange.aStart == aSelRange.aEnd )
     821             :                 {
     822           0 :                     SCCOL nSelCol = aSelRange.aStart.Col();
     823           0 :                     SCROW nSelRow = aSelRange.aStart.Row();
     824           0 :                     SCTAB nSelTab = aSelRange.aStart.Tab();
     825           0 :                     if ( pDoc->HasValueData( nSelCol, nSelRow, nSelTab ) )
     826             :                     {
     827             :                         sal_uLong nIndex = static_cast<const SfxUInt32Item*>(pDoc->GetAttr(
     828           0 :                                         nSelCol, nSelRow, nSelTab, ATTR_VALUE_FORMAT))->GetValue();
     829           0 :                         short nType = pDoc->GetFormatTable()->GetType(nIndex);
     830           0 :                         if ( nType == css::util::NumberFormat::DATE || nType == css::util::NumberFormat::TIME || nType == css::util::NumberFormat::DATETIME )
     831             :                         {
     832           0 :                             bFound = true;
     833             :                             // use currently selected value for automatic limits
     834           0 :                             if( rOldInfo.mbAutoStart )
     835           0 :                                 rOldInfo.mfStart = pDoc->GetValue( aSelRange.aStart );
     836           0 :                             if( rOldInfo.mbAutoEnd )
     837           0 :                                 rOldInfo.mfEnd = pDoc->GetValue( aSelRange.aStart );
     838             :                         }
     839             :                     }
     840             :                 }
     841           0 :             }
     842           0 :         }
     843             :     }
     844             : 
     845           0 :     return bFound;
     846             : }
     847             : 
     848           0 : bool ScDBFunc::HasSelectionForNumGroup( ScDPNumGroupInfo& rOldInfo )
     849             : {
     850             :     // determine if the numeric group dialog has to be shown for the current selection
     851             : 
     852           0 :     bool bFound = false;
     853             : 
     854           0 :     SCCOL nCurX = GetViewData().GetCurX();
     855           0 :     SCROW nCurY = GetViewData().GetCurY();
     856           0 :     SCTAB nTab = GetViewData().GetTabNo();
     857           0 :     ScDocument* pDoc = GetViewData().GetDocument();
     858             : 
     859           0 :     ScDPObject* pDPObj = pDoc->GetDPAtCursor( nCurX, nCurY, nTab );
     860           0 :     if ( pDPObj )
     861             :     {
     862           0 :         ScDPUniqueStringSet aEntries;
     863           0 :         long nSelectDimension = -1;
     864           0 :         GetSelectedMemberList( aEntries, nSelectDimension );
     865             : 
     866           0 :         if (!aEntries.empty())
     867             :         {
     868             :             bool bIsDataLayout;
     869           0 :             OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
     870             : 
     871           0 :             bool bInGroupDim = false;
     872             : 
     873             :             ScDPDimensionSaveData* pDimData =
     874           0 :                 const_cast<ScDPDimensionSaveData*>( pDPObj->GetSaveData()->GetExistingDimensionData() );
     875           0 :             if ( pDimData )
     876             :             {
     877           0 :                 const ScDPSaveNumGroupDimension* pNumGroupDim = pDimData->GetNumGroupDim( aDimName );
     878           0 :                 if ( pNumGroupDim )
     879             :                 {
     880             :                     //  existing num group dimension
     881             :                     //  -> edit settings of this dimension
     882             : 
     883           0 :                     rOldInfo = pNumGroupDim->GetInfo();
     884           0 :                     bFound = true;
     885             :                 }
     886           0 :                 else if ( pDimData->GetNamedGroupDim( aDimName ) )
     887           0 :                     bInGroupDim = true;                                    // in a group dimension
     888             :             }
     889           0 :             if ( !bFound && !bInGroupDim )
     890             :             {
     891             :                 // create a new num group dimension if the selection is a single cell
     892             :                 // in a normal dimension with numeric content
     893             : 
     894           0 :                 ScRange aSelRange;
     895           0 :                 if ( (GetViewData().GetSimpleArea( aSelRange ) == SC_MARK_SIMPLE) &&
     896           0 :                         aSelRange.aStart == aSelRange.aEnd )
     897             :                 {
     898           0 :                     if ( pDoc->HasValueData( aSelRange.aStart.Col(), aSelRange.aStart.Row(),
     899           0 :                                              aSelRange.aStart.Tab() ) )
     900             :                     {
     901           0 :                         bFound = true;
     902             :                         // use currently selected value for automatic limits
     903           0 :                         if( rOldInfo.mbAutoStart )
     904           0 :                             rOldInfo.mfStart = pDoc->GetValue( aSelRange.aStart );
     905           0 :                         if( rOldInfo.mbAutoEnd )
     906           0 :                             rOldInfo.mfEnd = pDoc->GetValue( aSelRange.aStart );
     907             :                     }
     908             :                 }
     909           0 :             }
     910           0 :         }
     911             :     }
     912             : 
     913           0 :     return bFound;
     914             : }
     915             : 
     916           0 : void ScDBFunc::DateGroupDataPilot( const ScDPNumGroupInfo& rInfo, sal_Int32 nParts )
     917             : {
     918           0 :     ScDPObject* pDPObj = GetViewData().GetDocument()->GetDPAtCursor( GetViewData().GetCurX(),
     919           0 :                                         GetViewData().GetCurY(), GetViewData().GetTabNo() );
     920           0 :     if (!pDPObj)
     921           0 :         return;
     922             : 
     923           0 :     ScDPUniqueStringSet aEntries;
     924           0 :     long nSelectDimension = -1;
     925           0 :     GetSelectedMemberList( aEntries, nSelectDimension );
     926             : 
     927           0 :     if (aEntries.empty())
     928           0 :         return;
     929             : 
     930           0 :     std::vector<OUString> aDeletedNames;
     931             :     bool bIsDataLayout;
     932           0 :     OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
     933             : 
     934           0 :     ScDPSaveData aData( *pDPObj->GetSaveData() );
     935           0 :     ScDPDimensionSaveData* pDimData = aData.GetDimensionData();     // created if not there
     936             : 
     937             :     // find the source dimension name.
     938           0 :     OUString aBaseDimName = aDimName;
     939           0 :     if( const ScDPSaveGroupDimension* pBaseGroupDim = pDimData->GetNamedGroupDim( aDimName ) )
     940           0 :         aBaseDimName = pBaseGroupDim->GetSourceDimName();
     941             : 
     942             :     // Remove all group dimensions associated with this source dimension. For
     943             :     // date grouping, we need to remove all existing groups for the affected
     944             :     // source dimension and build new one(s) from scratch.  Keep the deleted
     945             :     // names so that they can be reused during re-construction.
     946           0 :     aData.RemoveAllGroupDimensions(aBaseDimName, &aDeletedNames);
     947             : 
     948           0 :     if ( nParts )
     949             :     {
     950             :         // create date group dimensions
     951             : 
     952           0 :         ScDPNumGroupInfo aEmpty;
     953           0 :         bool bFirst = true;
     954           0 :         sal_Int32 nMask = 1;
     955           0 :         for (sal_uInt16 nBit=0; nBit<32; nBit++)
     956             :         {
     957           0 :             if ( nParts & nMask )
     958             :             {
     959           0 :                 if ( bFirst )
     960             :                 {
     961             :                     // innermost part: create NumGroupDimension (replacing original values)
     962             :                     // Dimension name is left unchanged
     963             : 
     964           0 :                     if ( (nParts == sheet::DataPilotFieldGroupBy::DAYS) && (rInfo.mfStep >= 1.0) )
     965             :                     {
     966             :                         // only days, and a step value specified: use numerical grouping
     967             :                         // with DateValues flag, not date grouping
     968             : 
     969           0 :                         ScDPNumGroupInfo aNumInfo( rInfo );
     970           0 :                         aNumInfo.mbDateValues = true;
     971             : 
     972           0 :                         ScDPSaveNumGroupDimension aNumGroupDim( aBaseDimName, aNumInfo );
     973           0 :                         pDimData->AddNumGroupDimension( aNumGroupDim );
     974             :                     }
     975             :                     else
     976             :                     {
     977           0 :                         ScDPSaveNumGroupDimension aNumGroupDim( aBaseDimName, rInfo, nMask );
     978           0 :                         pDimData->AddNumGroupDimension( aNumGroupDim );
     979             :                     }
     980             : 
     981           0 :                     bFirst = false;
     982             :                 }
     983             :                 else
     984             :                 {
     985             :                     // additional parts: create GroupDimension (shown as additional dimensions)
     986             :                     OUString aGroupDimName =
     987           0 :                         pDimData->CreateDateGroupDimName(nMask, *pDPObj, true, &aDeletedNames);
     988           0 :                     ScDPSaveGroupDimension aGroupDim( aBaseDimName, aGroupDimName );
     989           0 :                     aGroupDim.SetDateInfo( rInfo, nMask );
     990           0 :                     pDimData->AddGroupDimension( aGroupDim );
     991             : 
     992             :                     // set orientation
     993           0 :                     ScDPSaveDimension* pSaveDimension = aData.GetDimensionByName( aGroupDimName );
     994           0 :                     if ( pSaveDimension->GetOrientation() == sheet::DataPilotFieldOrientation_HIDDEN )
     995             :                     {
     996           0 :                         ScDPSaveDimension* pOldDimension = aData.GetDimensionByName( aBaseDimName );
     997           0 :                         pSaveDimension->SetOrientation( pOldDimension->GetOrientation() );
     998           0 :                         long nPosition = 0;     //! before (immediate) base
     999           0 :                         aData.SetPosition( pSaveDimension, nPosition );
    1000           0 :                     }
    1001             :                 }
    1002             :             }
    1003           0 :             nMask *= 2;
    1004             :         }
    1005             :     }
    1006             : 
    1007             :     // apply changes
    1008           0 :     ScDBDocFunc aFunc( *GetViewData().GetDocShell() );
    1009           0 :     pDPObj->SetSaveData( aData );
    1010           0 :     aFunc.RefreshPivotTableGroups(pDPObj);
    1011             : 
    1012             :     // unmark cell selection
    1013           0 :     Unmark();
    1014             : }
    1015             : 
    1016           0 : void ScDBFunc::NumGroupDataPilot( const ScDPNumGroupInfo& rInfo )
    1017             : {
    1018           0 :     ScDPObject* pDPObj = GetViewData().GetDocument()->GetDPAtCursor( GetViewData().GetCurX(),
    1019           0 :                                         GetViewData().GetCurY(), GetViewData().GetTabNo() );
    1020           0 :     if (!pDPObj)
    1021           0 :         return;
    1022             : 
    1023           0 :     ScDPUniqueStringSet aEntries;
    1024           0 :     long nSelectDimension = -1;
    1025           0 :     GetSelectedMemberList( aEntries, nSelectDimension );
    1026             : 
    1027           0 :     if (aEntries.empty())
    1028           0 :         return;
    1029             : 
    1030             :     bool bIsDataLayout;
    1031           0 :     OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
    1032             : 
    1033           0 :     ScDPSaveData aData( *pDPObj->GetSaveData() );
    1034           0 :     ScDPDimensionSaveData* pDimData = aData.GetDimensionData();     // created if not there
    1035             : 
    1036           0 :     ScDPSaveNumGroupDimension* pExisting = pDimData->GetNumGroupDimAcc( aDimName );
    1037           0 :     if ( pExisting )
    1038             :     {
    1039             :         // modify existing group dimension
    1040           0 :         pExisting->SetGroupInfo( rInfo );
    1041             :     }
    1042             :     else
    1043             :     {
    1044             :         // create new group dimension
    1045           0 :         ScDPSaveNumGroupDimension aNumGroupDim( aDimName, rInfo );
    1046           0 :         pDimData->AddNumGroupDimension( aNumGroupDim );
    1047             :     }
    1048             : 
    1049             :     // apply changes
    1050           0 :     ScDBDocFunc aFunc( *GetViewData().GetDocShell() );
    1051           0 :     pDPObj->SetSaveData( aData );
    1052           0 :     aFunc.RefreshPivotTableGroups(pDPObj);
    1053             : 
    1054             :     // unmark cell selection
    1055           0 :     Unmark();
    1056             : }
    1057             : 
    1058           0 : void ScDBFunc::GroupDataPilot()
    1059             : {
    1060           0 :     ScDPObject* pDPObj = GetViewData().GetDocument()->GetDPAtCursor( GetViewData().GetCurX(),
    1061           0 :                                         GetViewData().GetCurY(), GetViewData().GetTabNo() );
    1062           0 :     if (!pDPObj)
    1063           0 :         return;
    1064             : 
    1065           0 :     ScDPUniqueStringSet aEntries;
    1066           0 :     long nSelectDimension = -1;
    1067           0 :     GetSelectedMemberList( aEntries, nSelectDimension );
    1068             : 
    1069           0 :     if (aEntries.empty())
    1070           0 :         return;
    1071             : 
    1072             :     bool bIsDataLayout;
    1073           0 :     OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
    1074             : 
    1075           0 :     ScDPSaveData aData( *pDPObj->GetSaveData() );
    1076           0 :     ScDPDimensionSaveData* pDimData = aData.GetDimensionData();     // created if not there
    1077             : 
    1078             :     // find original base
    1079           0 :     OUString aBaseDimName = aDimName;
    1080           0 :     const ScDPSaveGroupDimension* pBaseGroupDim = pDimData->GetNamedGroupDim( aDimName );
    1081           0 :     if ( pBaseGroupDim )
    1082             :     {
    1083             :         // any entry's SourceDimName is the original base
    1084           0 :         aBaseDimName = pBaseGroupDim->GetSourceDimName();
    1085             :     }
    1086             : 
    1087             :     // find existing group dimension
    1088             :     // (using the selected dim, can be intermediate group dim)
    1089           0 :     ScDPSaveGroupDimension* pGroupDimension = pDimData->GetGroupDimAccForBase( aDimName );
    1090             : 
    1091             :     // remove the selected items from their groups
    1092             :     // (empty groups are removed, too)
    1093           0 :     if ( pGroupDimension )
    1094             :     {
    1095           0 :         ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
    1096           0 :         for (; it != itEnd; ++it)
    1097             :         {
    1098           0 :             const OUString& aEntryName = *it;
    1099           0 :             if ( pBaseGroupDim )
    1100             :             {
    1101             :                 // for each selected (intermediate) group, remove all its items
    1102             :                 // (same logic as for adding, below)
    1103           0 :                 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetNamedGroup( aEntryName );
    1104           0 :                 if ( pBaseGroup )
    1105           0 :                     pBaseGroup->RemoveElementsFromGroups( *pGroupDimension );   // remove all elements
    1106             :                 else
    1107           0 :                     pGroupDimension->RemoveFromGroups( aEntryName );
    1108             :             }
    1109             :             else
    1110           0 :                 pGroupDimension->RemoveFromGroups( aEntryName );
    1111             :         }
    1112             :     }
    1113             : 
    1114           0 :     ScDPSaveGroupDimension* pNewGroupDim = NULL;
    1115           0 :     if ( !pGroupDimension )
    1116             :     {
    1117             :         // create a new group dimension
    1118             :         OUString aGroupDimName =
    1119           0 :             pDimData->CreateGroupDimName(aBaseDimName, *pDPObj, false, NULL);
    1120           0 :         pNewGroupDim = new ScDPSaveGroupDimension( aBaseDimName, aGroupDimName );
    1121             : 
    1122           0 :         pGroupDimension = pNewGroupDim;     // make changes to the new dim if none existed
    1123             : 
    1124           0 :         if ( pBaseGroupDim )
    1125             :         {
    1126             :             // If it's a higher-order group dimension, pre-allocate groups for all
    1127             :             // non-selected original groups, so the individual base members aren't
    1128             :             // used for automatic groups (this would make the original groups hard
    1129             :             // to find).
    1130             :             //! Also do this when removing groups?
    1131             :             //! Handle this case dynamically with automatic groups?
    1132             : 
    1133           0 :             long nGroupCount = pBaseGroupDim->GetGroupCount();
    1134           0 :             for ( long nGroup = 0; nGroup < nGroupCount; nGroup++ )
    1135             :             {
    1136           0 :                 const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetGroupByIndex( nGroup );
    1137             : 
    1138           0 :                 if (!aEntries.count(pBaseGroup->GetGroupName()))
    1139             :                 {
    1140             :                     // add an additional group for each item that is not in the selection
    1141           0 :                     ScDPSaveGroupItem aGroup( pBaseGroup->GetGroupName() );
    1142           0 :                     aGroup.AddElementsFromGroup( *pBaseGroup );
    1143           0 :                     pGroupDimension->AddGroupItem( aGroup );
    1144             :                 }
    1145             :             }
    1146           0 :         }
    1147             :     }
    1148           0 :     OUString aGroupDimName = pGroupDimension->GetGroupDimName();
    1149             : 
    1150           0 :     OUString aGroupName = pGroupDimension->CreateGroupName(ScGlobal::GetRscString(STR_PIVOT_GROUP));
    1151           0 :     ScDPSaveGroupItem aGroup( aGroupName );
    1152           0 :     ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
    1153           0 :     for (; it != itEnd; ++it)
    1154             :     {
    1155           0 :         const OUString& aEntryName = *it;
    1156           0 :         if ( pBaseGroupDim )
    1157             :         {
    1158             :             // for each selected (intermediate) group, add all its items
    1159           0 :             const ScDPSaveGroupItem* pBaseGroup = pBaseGroupDim->GetNamedGroup( aEntryName );
    1160           0 :             if ( pBaseGroup )
    1161           0 :                 aGroup.AddElementsFromGroup( *pBaseGroup );
    1162             :             else
    1163           0 :                 aGroup.AddElement( aEntryName );    // no group found -> automatic group, add the item itself
    1164             :         }
    1165             :         else
    1166           0 :             aGroup.AddElement( aEntryName );        // no group dimension, add all items directly
    1167             :     }
    1168             : 
    1169           0 :     pGroupDimension->AddGroupItem( aGroup );
    1170             : 
    1171           0 :     if ( pNewGroupDim )
    1172             :     {
    1173           0 :         pDimData->AddGroupDimension( *pNewGroupDim );
    1174           0 :         delete pNewGroupDim;        // AddGroupDimension copies the object
    1175             :         // don't access pGroupDimension after here
    1176             :     }
    1177           0 :     pGroupDimension = pNewGroupDim = NULL;
    1178             : 
    1179             :     // set orientation
    1180           0 :     ScDPSaveDimension* pSaveDimension = aData.GetDimensionByName( aGroupDimName );
    1181           0 :     if ( pSaveDimension->GetOrientation() == sheet::DataPilotFieldOrientation_HIDDEN )
    1182             :     {
    1183           0 :         ScDPSaveDimension* pOldDimension = aData.GetDimensionByName( aDimName );
    1184           0 :         pSaveDimension->SetOrientation( pOldDimension->GetOrientation() );
    1185           0 :         long nPosition = 0;     //! before (immediate) base
    1186           0 :         aData.SetPosition( pSaveDimension, nPosition );
    1187             :     }
    1188             : 
    1189             :     // apply changes
    1190           0 :     ScDBDocFunc aFunc( *GetViewData().GetDocShell() );
    1191           0 :     pDPObj->SetSaveData( aData );
    1192           0 :     aFunc.RefreshPivotTableGroups(pDPObj);
    1193             : 
    1194             :     // unmark cell selection
    1195           0 :     Unmark();
    1196             : }
    1197             : 
    1198           0 : void ScDBFunc::UngroupDataPilot()
    1199             : {
    1200           0 :     ScDPObject* pDPObj = GetViewData().GetDocument()->GetDPAtCursor( GetViewData().GetCurX(),
    1201           0 :                                         GetViewData().GetCurY(), GetViewData().GetTabNo() );
    1202           0 :     if (!pDPObj)
    1203           0 :         return;
    1204             : 
    1205           0 :     ScDPUniqueStringSet aEntries;
    1206           0 :     long nSelectDimension = -1;
    1207           0 :     GetSelectedMemberList( aEntries, nSelectDimension );
    1208             : 
    1209           0 :     if (aEntries.empty())
    1210           0 :         return;
    1211             : 
    1212             :     bool bIsDataLayout;
    1213           0 :     OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
    1214             : 
    1215           0 :     ScDPSaveData aData( *pDPObj->GetSaveData() );
    1216           0 :     if (!aData.GetExistingDimensionData())
    1217             :         // There is nothing to ungroup.
    1218           0 :         return;
    1219             : 
    1220           0 :     ScDPDimensionSaveData* pDimData = aData.GetDimensionData();
    1221             : 
    1222           0 :     ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDimAcc( aDimName );
    1223           0 :     const ScDPSaveNumGroupDimension* pNumGroupDim = pDimData->GetNumGroupDim( aDimName );
    1224           0 :     if ( ( pGroupDim && pGroupDim->GetDatePart() != 0 ) ||
    1225           0 :          ( pNumGroupDim && pNumGroupDim->GetDatePart() != 0 ) )
    1226             :     {
    1227             :         // Date grouping: need to remove all affected group dimensions.
    1228             :         // This is done using DateGroupDataPilot with nParts=0.
    1229             : 
    1230           0 :         DateGroupDataPilot( ScDPNumGroupInfo(), 0 );
    1231           0 :         return;
    1232             :     }
    1233             : 
    1234           0 :     if ( pGroupDim )
    1235             :     {
    1236           0 :         ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
    1237           0 :         for (; it != itEnd; ++it)
    1238           0 :             pGroupDim->RemoveGroup(*it);
    1239             : 
    1240             :         // remove group dimension if empty
    1241           0 :         bool bEmptyDim = pGroupDim->IsEmpty();
    1242           0 :         if ( !bEmptyDim )
    1243             :         {
    1244             :             // If all remaining groups in the dimension aren't shown, remove
    1245             :             // the dimension too, as if it was completely empty.
    1246           0 :             ScDPUniqueStringSet aVisibleEntries;
    1247           0 :             pDPObj->GetMemberResultNames( aVisibleEntries, nSelectDimension );
    1248           0 :             bEmptyDim = pGroupDim->HasOnlyHidden( aVisibleEntries );
    1249             :         }
    1250           0 :         if ( bEmptyDim )
    1251             :         {
    1252           0 :             pDimData->RemoveGroupDimension( aDimName );     // pGroupDim is deleted
    1253             : 
    1254             :             // also remove SaveData settings for the dimension that no longer exists
    1255           0 :             aData.RemoveDimensionByName( aDimName );
    1256             :         }
    1257             :     }
    1258           0 :     else if ( pNumGroupDim )
    1259             :     {
    1260             :         // remove the numerical grouping
    1261           0 :         pDimData->RemoveNumGroupDimension( aDimName );
    1262             :         // SaveData settings can remain unchanged - the same dimension still exists
    1263             :     }
    1264             : 
    1265             :     // apply changes
    1266           0 :     ScDBDocFunc aFunc( *GetViewData().GetDocShell() );
    1267           0 :     pDPObj->SetSaveData( aData );
    1268           0 :     aFunc.RefreshPivotTableGroups(pDPObj);
    1269             : 
    1270             :     // unmark cell selection
    1271           0 :     Unmark();
    1272             : }
    1273             : 
    1274           0 : static OUString lcl_replaceMemberNameInSubtotal(const OUString& rSubtotal, const OUString& rMemberName)
    1275             : {
    1276           0 :     sal_Int32 n = rSubtotal.getLength();
    1277           0 :     const sal_Unicode* p = rSubtotal.getStr();
    1278           0 :     OUStringBuffer aBuf, aWordBuf;
    1279           0 :     for (sal_Int32 i = 0; i < n; ++i)
    1280             :     {
    1281           0 :         sal_Unicode c = p[i];
    1282           0 :         if (c == ' ')
    1283             :         {
    1284           0 :             OUString aWord = aWordBuf.makeStringAndClear();
    1285           0 :             if (aWord.equals(rMemberName))
    1286           0 :                 aBuf.append('?');
    1287             :             else
    1288           0 :                 aBuf.append(aWord);
    1289           0 :             aBuf.append(c);
    1290             :         }
    1291           0 :         else if (c == '\\')
    1292             :         {
    1293             :             // Escape a backslash character.
    1294           0 :             aWordBuf.append(c);
    1295           0 :             aWordBuf.append(c);
    1296             :         }
    1297           0 :         else if (c == '?')
    1298             :         {
    1299             :             // A literal '?' must be escaped with a backslash ('\');
    1300           0 :             aWordBuf.append('\\');
    1301           0 :             aWordBuf.append(c);
    1302             :         }
    1303             :         else
    1304           0 :             aWordBuf.append(c);
    1305             :     }
    1306             : 
    1307           0 :     if (!aWordBuf.isEmpty())
    1308             :     {
    1309           0 :         OUString aWord = aWordBuf.makeStringAndClear();
    1310           0 :         if (aWord.equals(rMemberName))
    1311           0 :             aBuf.append('?');
    1312             :         else
    1313           0 :             aBuf.append(aWord);
    1314             :     }
    1315             : 
    1316           0 :     return aBuf.makeStringAndClear();
    1317             : }
    1318             : 
    1319           0 : void ScDBFunc::DataPilotInput( const ScAddress& rPos, const OUString& rString )
    1320             : {
    1321             :     using namespace ::com::sun::star::sheet;
    1322             : 
    1323           0 :     ScDocument* pDoc = GetViewData().GetDocument();
    1324           0 :     ScDPObject* pDPObj = pDoc->GetDPAtCursor( rPos.Col(), rPos.Row(), rPos.Tab() );
    1325           0 :     if (!pDPObj)
    1326           0 :         return;
    1327             : 
    1328           0 :     OUString aOldText = pDoc->GetString(rPos.Col(), rPos.Row(), rPos.Tab());
    1329             : 
    1330           0 :     if ( aOldText == rString )
    1331             :     {
    1332             :         // nothing to do: silently exit
    1333           0 :         return;
    1334             :     }
    1335             : 
    1336           0 :     sal_uInt16 nErrorId = 0;
    1337             : 
    1338           0 :     pDPObj->BuildAllDimensionMembers();
    1339           0 :     ScDPSaveData aData( *pDPObj->GetSaveData() );
    1340           0 :     bool bChange = false;
    1341             : 
    1342           0 :     sal_uInt16 nOrient = DataPilotFieldOrientation_HIDDEN;
    1343           0 :     long nField = pDPObj->GetHeaderDim( rPos, nOrient );
    1344           0 :     if ( nField >= 0 )
    1345             :     {
    1346             :         // changing a field title
    1347           0 :         if ( aData.GetExistingDimensionData() )
    1348             :         {
    1349             :             // only group dimensions can be renamed
    1350             : 
    1351           0 :             ScDPDimensionSaveData* pDimData = aData.GetDimensionData();
    1352           0 :             ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDimAcc( aOldText );
    1353           0 :             if ( pGroupDim )
    1354             :             {
    1355             :                 // valid name: not empty, no existing dimension (group or other)
    1356           0 :                 if (!rString.isEmpty() && !pDPObj->IsDimNameInUse(rString))
    1357             :                 {
    1358           0 :                     pGroupDim->Rename( rString );
    1359             : 
    1360             :                     // also rename in SaveData to preserve the field settings
    1361           0 :                     ScDPSaveDimension* pSaveDim = aData.GetDimensionByName( aOldText );
    1362           0 :                     pSaveDim->SetName( rString );
    1363             : 
    1364           0 :                     bChange = true;
    1365             :                 }
    1366             :                 else
    1367           0 :                     nErrorId = STR_INVALIDNAME;
    1368             :             }
    1369             :         }
    1370           0 :         else if (nOrient == DataPilotFieldOrientation_COLUMN || nOrient == DataPilotFieldOrientation_ROW)
    1371             :         {
    1372           0 :             bool bDataLayout = false;
    1373           0 :             OUString aDimName = pDPObj->GetDimName(nField, bDataLayout);
    1374           0 :             ScDPSaveDimension* pDim = bDataLayout ? aData.GetDataLayoutDimension() : aData.GetDimensionByName(aDimName);
    1375           0 :             if (pDim)
    1376             :             {
    1377           0 :                 if (!rString.isEmpty())
    1378             :                 {
    1379           0 :                     if (rString.equalsIgnoreAsciiCase(aDimName))
    1380             :                     {
    1381           0 :                         pDim->RemoveLayoutName();
    1382           0 :                         bChange = true;
    1383             :                     }
    1384           0 :                     else if (!pDPObj->IsDimNameInUse(rString))
    1385             :                     {
    1386           0 :                         pDim->SetLayoutName(rString);
    1387           0 :                         bChange = true;
    1388             :                     }
    1389             :                     else
    1390           0 :                         nErrorId = STR_INVALIDNAME;
    1391             :                 }
    1392             :                 else
    1393           0 :                     nErrorId = STR_INVALIDNAME;
    1394           0 :             }
    1395             :         }
    1396             :     }
    1397           0 :     else if (pDPObj->IsDataDescriptionCell(rPos))
    1398             :     {
    1399             :         // There is only one data dimension.
    1400           0 :         ScDPSaveDimension* pDim = aData.GetFirstDimension(sheet::DataPilotFieldOrientation_DATA);
    1401           0 :         if (pDim)
    1402             :         {
    1403           0 :             if (!rString.isEmpty())
    1404             :             {
    1405           0 :                 if (pDim->GetName().equalsIgnoreAsciiCase(rString))
    1406             :                 {
    1407           0 :                     pDim->RemoveLayoutName();
    1408           0 :                     bChange = true;
    1409             :                 }
    1410           0 :                 else if (!pDPObj->IsDimNameInUse(rString))
    1411             :                 {
    1412           0 :                     pDim->SetLayoutName(rString);
    1413           0 :                     bChange = true;
    1414             :                 }
    1415             :                 else
    1416           0 :                     nErrorId = STR_INVALIDNAME;
    1417             :             }
    1418             :             else
    1419           0 :                 nErrorId = STR_INVALIDNAME;
    1420             :         }
    1421             :     }
    1422             :     else
    1423             :     {
    1424             :         // This is not a field header.
    1425           0 :         sheet::DataPilotTableHeaderData aPosData;
    1426           0 :         pDPObj->GetHeaderPositionData(rPos, aPosData);
    1427             : 
    1428           0 :         if ((aPosData.Flags & MemberResultFlags::HASMEMBER) && !aOldText.isEmpty())
    1429             :         {
    1430           0 :             if ( aData.GetExistingDimensionData() && !(aPosData.Flags & MemberResultFlags::SUBTOTAL))
    1431             :             {
    1432             :                 bool bIsDataLayout;
    1433           0 :                 OUString aDimName = pDPObj->GetDimName( aPosData.Dimension, bIsDataLayout );
    1434             : 
    1435           0 :                 ScDPDimensionSaveData* pDimData = aData.GetDimensionData();
    1436           0 :                 ScDPSaveGroupDimension* pGroupDim = pDimData->GetNamedGroupDimAcc( aDimName );
    1437           0 :                 if ( pGroupDim )
    1438             :                 {
    1439             :                     // valid name: not empty, no existing group in this dimension
    1440             :                     //! ignore case?
    1441           0 :                     if (!rString.isEmpty() && !pGroupDim->GetNamedGroup(rString))
    1442             :                     {
    1443           0 :                         ScDPSaveGroupItem* pGroup = pGroupDim->GetNamedGroupAcc( aOldText );
    1444           0 :                         if ( pGroup )
    1445           0 :                             pGroup->Rename( rString );     // rename the existing group
    1446             :                         else
    1447             :                         {
    1448             :                             // create a new group to replace the automatic group
    1449           0 :                             ScDPSaveGroupItem aGroup( rString );
    1450           0 :                             aGroup.AddElement( aOldText );
    1451           0 :                             pGroupDim->AddGroupItem( aGroup );
    1452             :                         }
    1453             : 
    1454             :                         // in both cases also adjust savedata, to preserve member settings (show details)
    1455           0 :                         ScDPSaveDimension* pSaveDim = aData.GetDimensionByName( aDimName );
    1456           0 :                         ScDPSaveMember* pSaveMember = pSaveDim->GetExistingMemberByName( aOldText );
    1457           0 :                         if ( pSaveMember )
    1458           0 :                             pSaveMember->SetName( rString );
    1459             : 
    1460           0 :                         bChange = true;
    1461             :                     }
    1462             :                     else
    1463           0 :                         nErrorId = STR_INVALIDNAME;
    1464           0 :                  }
    1465             :             }
    1466           0 :             else if ((aPosData.Flags & MemberResultFlags::GRANDTOTAL))
    1467             :             {
    1468           0 :                 aData.SetGrandTotalName(rString);
    1469           0 :                 bChange = true;
    1470             :             }
    1471           0 :             else if (aPosData.Dimension >= 0 && !aPosData.MemberName.isEmpty())
    1472             :             {
    1473           0 :                 bool bDataLayout = false;
    1474           0 :                 OUString aDimName = pDPObj->GetDimName(static_cast<long>(aPosData.Dimension), bDataLayout);
    1475           0 :                 if (bDataLayout)
    1476             :                 {
    1477             :                     // data dimension
    1478             :                     do
    1479             :                     {
    1480           0 :                         if ((aPosData.Flags & MemberResultFlags::SUBTOTAL))
    1481           0 :                             break;
    1482             : 
    1483           0 :                         ScDPSaveDimension* pDim = aData.GetDimensionByName(aPosData.MemberName);
    1484           0 :                         if (!pDim)
    1485           0 :                             break;
    1486             : 
    1487           0 :                         if (rString.isEmpty())
    1488             :                         {
    1489           0 :                             nErrorId = STR_INVALIDNAME;
    1490           0 :                             break;
    1491             :                         }
    1492             : 
    1493           0 :                         if (aPosData.MemberName.equalsIgnoreAsciiCase(rString))
    1494             :                         {
    1495           0 :                             pDim->RemoveLayoutName();
    1496           0 :                             bChange = true;
    1497             :                         }
    1498           0 :                         else if (!pDPObj->IsDimNameInUse(rString))
    1499             :                         {
    1500           0 :                             pDim->SetLayoutName(rString);
    1501           0 :                             bChange = true;
    1502             :                         }
    1503             :                         else
    1504           0 :                             nErrorId = STR_INVALIDNAME;
    1505             :                     }
    1506             :                     while (false);
    1507             :                 }
    1508             :                 else
    1509             :                 {
    1510             :                     // field member
    1511             :                     do
    1512             :                     {
    1513           0 :                         ScDPSaveDimension* pDim = aData.GetDimensionByName(aDimName);
    1514           0 :                         if (!pDim)
    1515           0 :                             break;
    1516             : 
    1517           0 :                         ScDPSaveMember* pMem = pDim->GetExistingMemberByName(aPosData.MemberName);
    1518           0 :                         if (!pMem)
    1519           0 :                             break;
    1520             : 
    1521           0 :                         if ((aPosData.Flags & MemberResultFlags::SUBTOTAL))
    1522             :                         {
    1523             :                             // Change subtotal only when the table has one data dimension.
    1524           0 :                             if (aData.GetDataDimensionCount() > 1)
    1525           0 :                                 break;
    1526             : 
    1527             :                             // display name for subtotal is allowed only if the subtotal type is 'Automatic'.
    1528           0 :                             if (pDim->GetSubTotalsCount() != 1)
    1529           0 :                                 break;
    1530             : 
    1531           0 :                             if (pDim->GetSubTotalFunc(0) != sheet::GeneralFunction_AUTO)
    1532           0 :                                 break;
    1533             : 
    1534           0 :                             const OUString* pLayoutName = pMem->GetLayoutName();
    1535           0 :                             OUString aMemberName;
    1536           0 :                             if (pLayoutName)
    1537           0 :                                 aMemberName = *pLayoutName;
    1538             :                             else
    1539           0 :                                 aMemberName = aPosData.MemberName;
    1540             : 
    1541           0 :                             OUString aNew = lcl_replaceMemberNameInSubtotal(rString, aMemberName);
    1542           0 :                             pDim->SetSubtotalName(aNew);
    1543           0 :                             bChange = true;
    1544             :                         }
    1545             :                         else
    1546             :                         {
    1547             :                             // Check to make sure the member name isn't
    1548             :                             // already used.
    1549           0 :                             if (!rString.isEmpty())
    1550             :                             {
    1551           0 :                                 if (rString.equalsIgnoreAsciiCase(pMem->GetName()))
    1552             :                                 {
    1553           0 :                                     pMem->RemoveLayoutName();
    1554           0 :                                     bChange = true;
    1555             :                                 }
    1556           0 :                                 else if (!pDim->IsMemberNameInUse(rString))
    1557             :                                 {
    1558           0 :                                     pMem->SetLayoutName(rString);
    1559           0 :                                     bChange = true;
    1560             :                                 }
    1561             :                                 else
    1562           0 :                                     nErrorId = STR_INVALIDNAME;
    1563             :                             }
    1564             :                             else
    1565           0 :                                 nErrorId = STR_INVALIDNAME;
    1566             :                         }
    1567             :                     }
    1568             :                     while (false);
    1569           0 :                 }
    1570             :             }
    1571           0 :         }
    1572             :     }
    1573             : 
    1574           0 :     if ( bChange )
    1575             :     {
    1576             :         // apply changes
    1577           0 :         ScDBDocFunc aFunc( *GetViewData().GetDocShell() );
    1578           0 :         pDPObj->SetSaveData( aData );
    1579           0 :         aFunc.UpdatePivotTable(*pDPObj, true, false);
    1580             :     }
    1581             :     else
    1582             :     {
    1583           0 :         if ( !nErrorId )
    1584           0 :             nErrorId = STR_ERR_DATAPILOT_INPUT;
    1585           0 :         ErrorMessage( nErrorId );
    1586           0 :     }
    1587             : }
    1588             : 
    1589           0 : static void lcl_MoveToEnd( ScDPSaveDimension& rDim, const OUString& rItemName )
    1590             : {
    1591           0 :     ScDPSaveMember* pNewMember = NULL;
    1592           0 :     const ScDPSaveMember* pOldMember = rDim.GetExistingMemberByName( rItemName );
    1593           0 :     if ( pOldMember )
    1594           0 :         pNewMember = new ScDPSaveMember( *pOldMember );
    1595             :     else
    1596           0 :         pNewMember = new ScDPSaveMember( rItemName );
    1597           0 :     rDim.AddMember( pNewMember );
    1598             :     // AddMember takes ownership of the new pointer,
    1599             :     // puts it to the end of the list even if it was in the list before.
    1600           0 : }
    1601             : 
    1602             : struct ScOUStringCollate
    1603             : {
    1604             :     CollatorWrapper* mpCollator;
    1605             : 
    1606           0 :     ScOUStringCollate(CollatorWrapper* pColl) : mpCollator(pColl) {}
    1607             : 
    1608           0 :     bool operator()(const OUString& rStr1, const OUString& rStr2) const
    1609             :     {
    1610           0 :         return ( mpCollator->compareString(rStr1, rStr2) < 0 );
    1611             :     }
    1612             : };
    1613             : 
    1614           0 : bool ScDBFunc::DataPilotSort( const ScAddress& rPos, bool bAscending, sal_uInt16* pUserListId )
    1615             : {
    1616           0 :     ScDocument* pDoc = GetViewData().GetDocument();
    1617           0 :     ScDPObject* pDPObj = pDoc->GetDPAtCursor(rPos.Col(), rPos.Row(), rPos.Tab());
    1618           0 :     if (!pDPObj)
    1619           0 :         return false;
    1620             : 
    1621             :     // We need to run this to get all members later.
    1622           0 :     if ( pUserListId )
    1623           0 :         pDPObj->BuildAllDimensionMembers();
    1624             : 
    1625             :     sal_uInt16 nOrientation;
    1626           0 :     long nDimIndex = pDPObj->GetHeaderDim(rPos, nOrientation);
    1627           0 :     if (nDimIndex < 0)
    1628             :         // Invalid dimension index.  Bail out.
    1629           0 :         return false;
    1630             : 
    1631           0 :     ScDPSaveData* pSaveData = pDPObj->GetSaveData();
    1632           0 :     if (!pSaveData)
    1633           0 :         return false;
    1634             : 
    1635           0 :     ScDPSaveData aNewSaveData(*pSaveData);
    1636             :     bool bDataLayout;
    1637           0 :     OUString aDimName = pDPObj->GetDimName(nDimIndex, bDataLayout);
    1638           0 :     ScDPSaveDimension* pSaveDim = aNewSaveData.GetDimensionByName(aDimName);
    1639           0 :     if (!pSaveDim)
    1640           0 :         return false;
    1641             : 
    1642             :     // manual evaluation of sort order is only needed if a user list id is given
    1643           0 :     if ( pUserListId )
    1644             :     {
    1645             :         typedef ScDPSaveDimension::MemberList MemList;
    1646           0 :         const MemList& rDimMembers = pSaveDim->GetMembers();
    1647           0 :         list<OUString> aMembers;
    1648           0 :         std::unordered_set<OUString, OUStringHash> aMemberSet;
    1649           0 :         size_t nMemberCount = 0;
    1650           0 :         for (MemList::const_iterator itr = rDimMembers.begin(), itrEnd = rDimMembers.end();
    1651             :               itr != itrEnd; ++itr)
    1652             :         {
    1653           0 :             ScDPSaveMember* pMem = *itr;
    1654           0 :             aMembers.push_back(pMem->GetName());
    1655           0 :             aMemberSet.insert(pMem->GetName());
    1656           0 :             ++nMemberCount;
    1657             :         }
    1658             : 
    1659             :         // Sort the member list in ascending order.
    1660           0 :         ScOUStringCollate aCollate( ScGlobal::GetCollator() );
    1661           0 :         aMembers.sort(aCollate);
    1662             : 
    1663             :         // Collect and rank those custom sort strings that also exist in the member name list.
    1664             : 
    1665             :         typedef std::unordered_map<OUString, sal_uInt16, OUStringHash> UserSortMap;
    1666           0 :         UserSortMap aSubStrs;
    1667           0 :         sal_uInt16 nSubCount = 0;
    1668           0 :         if (pUserListId)
    1669             :         {
    1670           0 :             ScUserList* pUserList = ScGlobal::GetUserList();
    1671           0 :             if (!pUserList)
    1672           0 :                 return false;
    1673             : 
    1674             :             {
    1675           0 :                 size_t n = pUserList->size();
    1676           0 :                 if (!n || *pUserListId >= static_cast<sal_uInt16>(n))
    1677           0 :                     return false;
    1678             :             }
    1679             : 
    1680           0 :             const ScUserListData* pData = (*pUserList)[*pUserListId];
    1681           0 :             if (pData)
    1682             :             {
    1683           0 :                 sal_uInt16 n = pData->GetSubCount();
    1684           0 :                 for (sal_uInt16 i = 0; i < n; ++i)
    1685             :                 {
    1686           0 :                     OUString aSub = pData->GetSubStr(i);
    1687           0 :                     if (!aMemberSet.count(aSub))
    1688             :                         // This string doesn't exist in the member name set.  Don't add this.
    1689           0 :                         continue;
    1690             : 
    1691           0 :                     aSubStrs.insert(UserSortMap::value_type(aSub, nSubCount++));
    1692           0 :                 }
    1693             :             }
    1694             :         }
    1695             : 
    1696             :         // Rank all members.
    1697             : 
    1698           0 :         vector<OUString> aRankedNames(nMemberCount);
    1699           0 :         sal_uInt16 nCurStrId = 0;
    1700           0 :         for (list<OUString>::const_iterator itr = aMembers.begin(), itrEnd = aMembers.end();
    1701             :               itr != itrEnd; ++itr)
    1702             :         {
    1703           0 :             OUString aName = *itr;
    1704           0 :             sal_uInt16 nRank = 0;
    1705           0 :             UserSortMap::const_iterator itrSub = aSubStrs.find(aName);
    1706           0 :             if (itrSub == aSubStrs.end())
    1707           0 :                 nRank = nSubCount + nCurStrId++;
    1708             :             else
    1709           0 :                 nRank = itrSub->second;
    1710             : 
    1711           0 :             if (!bAscending)
    1712           0 :                 nRank = static_cast< sal_uInt16 >( nMemberCount - nRank - 1 );
    1713             : 
    1714           0 :             aRankedNames[nRank] = aName;
    1715           0 :         }
    1716             : 
    1717             :         // Re-order ScDPSaveMember instances with the new ranks.
    1718             : 
    1719           0 :         for (vector<OUString>::const_iterator itr = aRankedNames.begin(), itrEnd = aRankedNames.end();
    1720             :               itr != itrEnd; ++itr)
    1721             :         {
    1722           0 :             const ScDPSaveMember* pOldMem = pSaveDim->GetExistingMemberByName(*itr);
    1723           0 :             if (!pOldMem)
    1724             :                 // All members are supposed to be present.
    1725           0 :                 continue;
    1726             : 
    1727           0 :             ScDPSaveMember* pNewMem = new ScDPSaveMember(*pOldMem);
    1728           0 :             pSaveDim->AddMember(pNewMem);
    1729             :         }
    1730             : 
    1731             :         // Set the sorting mode to manual for now.  We may introduce a new sorting
    1732             :         // mode later on.
    1733             : 
    1734           0 :         sheet::DataPilotFieldSortInfo aSortInfo;
    1735           0 :         aSortInfo.Mode = sheet::DataPilotFieldSortMode::MANUAL;
    1736           0 :         pSaveDim->SetSortInfo(&aSortInfo);
    1737             :     }
    1738             :     else
    1739             :     {
    1740             :         // without user list id, just apply sorting mode
    1741             : 
    1742           0 :         sheet::DataPilotFieldSortInfo aSortInfo;
    1743           0 :         aSortInfo.Mode = sheet::DataPilotFieldSortMode::NAME;
    1744           0 :         aSortInfo.IsAscending = bAscending;
    1745           0 :         pSaveDim->SetSortInfo(&aSortInfo);
    1746             :     }
    1747             : 
    1748             :     // Update the datapilot with the newly sorted field members.
    1749             : 
    1750           0 :     boost::scoped_ptr<ScDPObject> pNewObj(new ScDPObject(*pDPObj));
    1751           0 :     pNewObj->SetSaveData(aNewSaveData);
    1752           0 :     ScDBDocFunc aFunc(*GetViewData().GetDocShell());
    1753             : 
    1754           0 :     return aFunc.DataPilotUpdate(pDPObj, pNewObj.get(), true, false);
    1755             : }
    1756             : 
    1757           0 : bool ScDBFunc::DataPilotMove( const ScRange& rSource, const ScAddress& rDest )
    1758             : {
    1759           0 :     bool bRet = false;
    1760           0 :     ScDocument* pDoc = GetViewData().GetDocument();
    1761           0 :     ScDPObject* pDPObj = pDoc->GetDPAtCursor( rSource.aStart.Col(), rSource.aStart.Row(), rSource.aStart.Tab() );
    1762           0 :     if ( pDPObj && pDPObj == pDoc->GetDPAtCursor( rDest.Col(), rDest.Row(), rDest.Tab() ) )
    1763             :     {
    1764           0 :         sheet::DataPilotTableHeaderData aDestData;
    1765           0 :         pDPObj->GetHeaderPositionData( rDest, aDestData );
    1766           0 :         bool bValid = ( aDestData.Dimension >= 0 );        // dropping onto a field
    1767             : 
    1768             :         // look through the source range
    1769           0 :         std::unordered_set< OUString, OUStringHash, std::equal_to<OUString> > aMembersSet;   // for lookup
    1770           0 :         std::vector< OUString > aMembersVector;  // members in original order, for inserting
    1771           0 :         aMembersVector.reserve( std::max( static_cast<SCSIZE>( rSource.aEnd.Col() - rSource.aStart.Col() + 1 ),
    1772           0 :                                           static_cast<SCSIZE>( rSource.aEnd.Row() - rSource.aStart.Row() + 1 ) ) );
    1773           0 :         for (SCROW nRow = rSource.aStart.Row(); bValid && nRow <= rSource.aEnd.Row(); ++nRow )
    1774           0 :             for (SCCOL nCol = rSource.aStart.Col(); bValid && nCol <= rSource.aEnd.Col(); ++nCol )
    1775             :             {
    1776           0 :                 sheet::DataPilotTableHeaderData aSourceData;
    1777           0 :                 pDPObj->GetHeaderPositionData( ScAddress( nCol, nRow, rSource.aStart.Tab() ), aSourceData );
    1778           0 :                 if ( aSourceData.Dimension == aDestData.Dimension && !aSourceData.MemberName.isEmpty() )
    1779             :                 {
    1780           0 :                     if ( aMembersSet.find( aSourceData.MemberName ) == aMembersSet.end() )
    1781             :                     {
    1782           0 :                         aMembersSet.insert( aSourceData.MemberName );
    1783           0 :                         aMembersVector.push_back( aSourceData.MemberName );
    1784             :                     }
    1785             :                     // duplicates are ignored
    1786             :                 }
    1787             :                 else
    1788           0 :                     bValid = false;     // empty (subtotal) or different field
    1789           0 :             }
    1790             : 
    1791           0 :         if ( bValid )
    1792             :         {
    1793             :             bool bIsDataLayout;
    1794           0 :             OUString aDimName = pDPObj->GetDimName( aDestData.Dimension, bIsDataLayout );
    1795           0 :             if ( !bIsDataLayout )
    1796             :             {
    1797           0 :                 ScDPSaveData aData( *pDPObj->GetSaveData() );
    1798           0 :                 ScDPSaveDimension* pDim = aData.GetDimensionByName( aDimName );
    1799             : 
    1800             :                 // get all member names in source order
    1801           0 :                 uno::Sequence<OUString> aMemberNames;
    1802           0 :                 pDPObj->GetMemberNames( aDestData.Dimension, aMemberNames );
    1803             : 
    1804           0 :                 bool bInserted = false;
    1805             : 
    1806           0 :                 sal_Int32 nMemberCount = aMemberNames.getLength();
    1807           0 :                 for (sal_Int32 nMemberPos=0; nMemberPos<nMemberCount; ++nMemberPos)
    1808             :                 {
    1809           0 :                     OUString aMemberStr( aMemberNames[nMemberPos] );
    1810             : 
    1811           0 :                     if ( !bInserted && aMemberNames[nMemberPos] == aDestData.MemberName )
    1812             :                     {
    1813             :                         // insert dragged items before this item
    1814           0 :                         for ( std::vector<OUString>::const_iterator aIter = aMembersVector.begin();
    1815           0 :                               aIter != aMembersVector.end(); ++aIter )
    1816           0 :                             lcl_MoveToEnd( *pDim, *aIter );
    1817           0 :                         bInserted = true;
    1818             :                     }
    1819             : 
    1820           0 :                     if ( aMembersSet.find( aMemberStr ) == aMembersSet.end() )  // skip dragged items
    1821           0 :                         lcl_MoveToEnd( *pDim, aMemberStr );
    1822           0 :                 }
    1823             :                 // insert dragged item at end if dest wasn't found (for example, empty)
    1824           0 :                 if ( !bInserted )
    1825           0 :                     for ( std::vector<OUString>::const_iterator aIter = aMembersVector.begin();
    1826           0 :                           aIter != aMembersVector.end(); ++aIter )
    1827           0 :                         lcl_MoveToEnd( *pDim, *aIter );
    1828             : 
    1829             :                 // Items that were in SaveData, but not in the source, end up at the start of the list.
    1830             : 
    1831             :                 // set flag for manual sorting
    1832           0 :                 sheet::DataPilotFieldSortInfo aSortInfo;
    1833           0 :                 aSortInfo.Mode = sheet::DataPilotFieldSortMode::MANUAL;
    1834           0 :                 pDim->SetSortInfo( &aSortInfo );
    1835             : 
    1836             :                 // apply changes
    1837           0 :                 ScDBDocFunc aFunc( *GetViewData().GetDocShell() );
    1838           0 :                 boost::scoped_ptr<ScDPObject> pNewObj(new ScDPObject( *pDPObj ));
    1839           0 :                 pNewObj->SetSaveData( aData );
    1840           0 :                 aFunc.DataPilotUpdate( pDPObj, pNewObj.get(), true, false );      //! bApi for drag&drop?
    1841           0 :                 pNewObj.reset();
    1842             : 
    1843           0 :                 Unmark();       // entry was moved - no use in leaving the old cell selected
    1844             : 
    1845           0 :                 bRet = true;
    1846           0 :             }
    1847           0 :         }
    1848             :     }
    1849             : 
    1850           0 :     return bRet;
    1851             : }
    1852             : 
    1853           0 : bool ScDBFunc::HasSelectionForDrillDown( sal_uInt16& rOrientation )
    1854             : {
    1855           0 :     bool bRet = false;
    1856             : 
    1857           0 :     ScDPObject* pDPObj = GetViewData().GetDocument()->GetDPAtCursor( GetViewData().GetCurX(),
    1858           0 :                                         GetViewData().GetCurY(), GetViewData().GetTabNo() );
    1859           0 :     if ( pDPObj )
    1860             :     {
    1861           0 :         ScDPUniqueStringSet aEntries;
    1862           0 :         long nSelectDimension = -1;
    1863           0 :         GetSelectedMemberList( aEntries, nSelectDimension );
    1864             : 
    1865           0 :         if (!aEntries.empty())
    1866             :         {
    1867             :             bool bIsDataLayout;
    1868           0 :             OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
    1869           0 :             if ( !bIsDataLayout )
    1870             :             {
    1871           0 :                 ScDPSaveData* pSaveData = pDPObj->GetSaveData();
    1872           0 :                 ScDPSaveDimension* pDim = pSaveData->GetExistingDimensionByName( aDimName );
    1873           0 :                 if ( pDim )
    1874             :                 {
    1875           0 :                     sal_uInt16 nDimOrient = pDim->GetOrientation();
    1876           0 :                     ScDPSaveDimension* pInner = pSaveData->GetInnermostDimension( nDimOrient );
    1877           0 :                     if ( pDim == pInner )
    1878             :                     {
    1879           0 :                         rOrientation = nDimOrient;
    1880           0 :                         bRet = true;
    1881             :                     }
    1882             :                 }
    1883           0 :             }
    1884           0 :         }
    1885             :     }
    1886             : 
    1887           0 :     return bRet;
    1888             : }
    1889             : 
    1890           0 : void ScDBFunc::SetDataPilotDetails(bool bShow, const OUString* pNewDimensionName)
    1891             : {
    1892           0 :     ScDPObject* pDPObj = GetViewData().GetDocument()->GetDPAtCursor( GetViewData().GetCurX(),
    1893           0 :                                         GetViewData().GetCurY(), GetViewData().GetTabNo() );
    1894           0 :     if ( pDPObj )
    1895             :     {
    1896           0 :         ScDPUniqueStringSet aEntries;
    1897           0 :         long nSelectDimension = -1;
    1898           0 :         GetSelectedMemberList( aEntries, nSelectDimension );
    1899             : 
    1900           0 :         if (!aEntries.empty())
    1901             :         {
    1902             :             bool bIsDataLayout;
    1903           0 :             OUString aDimName = pDPObj->GetDimName( nSelectDimension, bIsDataLayout );
    1904           0 :             if ( !bIsDataLayout )
    1905             :             {
    1906           0 :                 ScDPSaveData aData( *pDPObj->GetSaveData() );
    1907           0 :                 ScDPSaveDimension* pDim = aData.GetDimensionByName( aDimName );
    1908             : 
    1909           0 :                 if ( bShow && pNewDimensionName )
    1910             :                 {
    1911             :                     //  add the new dimension with the same orientation, at the end
    1912             : 
    1913           0 :                     ScDPSaveDimension* pNewDim = aData.GetDimensionByName( *pNewDimensionName );
    1914           0 :                     ScDPSaveDimension* pDuplicated = NULL;
    1915           0 :                     if ( pNewDim->GetOrientation() == sheet::DataPilotFieldOrientation_DATA )
    1916             :                     {
    1917             :                         // Need to duplicate the dimension, create column/row in addition to data:
    1918             :                         // The duplicated dimension inherits the existing settings, pNewDim is modified below.
    1919           0 :                         pDuplicated = aData.DuplicateDimension( *pNewDimensionName );
    1920             :                     }
    1921             : 
    1922           0 :                     sal_uInt16 nOrientation = pDim->GetOrientation();
    1923           0 :                     pNewDim->SetOrientation( nOrientation );
    1924             : 
    1925           0 :                     long nPosition = LONG_MAX;
    1926           0 :                     aData.SetPosition( pNewDim, nPosition );
    1927             : 
    1928           0 :                     ScDPSaveDimension* pDataLayout = aData.GetDataLayoutDimension();
    1929           0 :                     if ( pDataLayout->GetOrientation() == nOrientation &&
    1930           0 :                          aData.GetDataDimensionCount() <= 1 )
    1931             :                     {
    1932             :                         // If there is only one data dimension, the data layout dimension
    1933             :                         // must still be the last one in its orientation.
    1934           0 :                         aData.SetPosition( pDataLayout, nPosition );
    1935             :                     }
    1936             : 
    1937           0 :                     if ( pDuplicated )
    1938             :                     {
    1939             :                         // The duplicated (data) dimension needs to be behind the original dimension
    1940           0 :                         aData.SetPosition( pDuplicated, nPosition );
    1941             :                     }
    1942             : 
    1943             :                     //  Hide details for all visible members (selected are changed below).
    1944             :                     //! Use all members from source level instead (including non-visible)?
    1945             : 
    1946           0 :                     ScDPUniqueStringSet aVisibleEntries;
    1947           0 :                     pDPObj->GetMemberResultNames( aVisibleEntries, nSelectDimension );
    1948             : 
    1949           0 :                     ScDPUniqueStringSet::const_iterator it = aVisibleEntries.begin(), itEnd = aVisibleEntries.end();
    1950           0 :                     for (; it != itEnd; ++it)
    1951             :                     {
    1952           0 :                         const OUString& aVisName = *it;
    1953           0 :                         ScDPSaveMember* pMember = pDim->GetMemberByName( aVisName );
    1954           0 :                         pMember->SetShowDetails( false );
    1955           0 :                     }
    1956             :                 }
    1957             : 
    1958           0 :                 ScDPUniqueStringSet::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
    1959           0 :                 for (; it != itEnd; ++it)
    1960             :                 {
    1961           0 :                     ScDPSaveMember* pMember = pDim->GetMemberByName(*it);
    1962           0 :                     pMember->SetShowDetails( bShow );
    1963             :                 }
    1964             : 
    1965             :                 // apply changes
    1966           0 :                 ScDBDocFunc aFunc( *GetViewData().GetDocShell() );
    1967           0 :                 boost::scoped_ptr<ScDPObject> pNewObj(new ScDPObject( *pDPObj ));
    1968           0 :                 pNewObj->SetSaveData( aData );
    1969           0 :                 aFunc.DataPilotUpdate( pDPObj, pNewObj.get(), true, false );
    1970           0 :                 pNewObj.reset();
    1971             : 
    1972             :                 // unmark cell selection
    1973           0 :                 Unmark();
    1974           0 :             }
    1975           0 :         }
    1976             :     }
    1977           0 : }
    1978             : 
    1979          36 : void ScDBFunc::ShowDataPilotSourceData( ScDPObject& rDPObj, const Sequence<sheet::DataPilotFieldFilter>& rFilters )
    1980             : {
    1981          36 :     ScDocument* pDoc = GetViewData().GetDocument();
    1982          36 :     if (pDoc->GetDocumentShell()->IsReadOnly())
    1983             :     {
    1984           0 :         ErrorMessage(STR_READONLYERR);
    1985          20 :         return;
    1986             :     }
    1987             : 
    1988          36 :     Reference<sheet::XDimensionsSupplier> xDimSupplier = rDPObj.GetSource();
    1989          52 :     Reference<container::XNameAccess> xDims = xDimSupplier->getDimensions();
    1990          52 :     Reference<sheet::XDrillDownDataSupplier> xDDSupplier(xDimSupplier, UNO_QUERY);
    1991          36 :     if (!xDDSupplier.is())
    1992           0 :         return;
    1993             : 
    1994          52 :     Sequence< Sequence<Any> > aTabData = xDDSupplier->getDrillDownData(rFilters);
    1995          36 :     sal_Int32 nRowSize = aTabData.getLength();
    1996          36 :     if (nRowSize <= 1)
    1997             :         // There is no data to show.  Bail out.
    1998          20 :         return;
    1999             : 
    2000          16 :     SCCOL nColSize = aTabData[0].getLength();
    2001             : 
    2002          16 :     SCTAB nNewTab = GetViewData().GetTabNo();
    2003             : 
    2004          32 :     boost::scoped_ptr<ScDocument> pInsDoc(new ScDocument(SCDOCMODE_CLIP));
    2005          16 :     pInsDoc->ResetClip( pDoc, nNewTab );
    2006          52 :     for (SCROW nRow = 0; nRow < nRowSize; ++nRow)
    2007             :     {
    2008         216 :         for (SCCOL nCol = 0; nCol < nColSize; ++nCol)
    2009             :         {
    2010         180 :             const Any& rAny = aTabData[nRow][nCol];
    2011         180 :             OUString aStr;
    2012             :             double fVal;
    2013         180 :             if (rAny >>= aStr)
    2014             :             {
    2015          80 :                 ScSetStringParam aParam;
    2016          80 :                 aParam.setTextInput();
    2017          80 :                 pInsDoc->SetString(ScAddress(nCol,nRow,nNewTab), aStr);
    2018             :             }
    2019         100 :             else if (rAny >>= fVal)
    2020         100 :                 pInsDoc->SetValue(nCol, nRow, nNewTab, fVal);
    2021         180 :         }
    2022             :     }
    2023             : 
    2024             :     // set number format (important for dates)
    2025          96 :     for (SCCOL nCol = 0; nCol < nColSize; ++nCol)
    2026             :     {
    2027          80 :         OUString aStr;
    2028          80 :         if (!(aTabData[0][nCol] >>= aStr))
    2029           0 :             continue;
    2030             : 
    2031         160 :         Reference<XPropertySet> xPropSet(xDims->getByName(aStr), UNO_QUERY);
    2032          80 :         if (!xPropSet.is())
    2033           0 :             continue;
    2034             : 
    2035         160 :         Any any = xPropSet->getPropertyValue( OUString(SC_UNO_DP_NUMBERFO) );
    2036          80 :         sal_Int32 nNumFmt = 0;
    2037          80 :         if (!(any >>= nNumFmt))
    2038           0 :             continue;
    2039             : 
    2040         160 :         ScPatternAttr aPattern( pInsDoc->GetPool() );
    2041          80 :         aPattern.GetItemSet().Put( SfxUInt32Item(ATTR_VALUE_FORMAT, static_cast<sal_uInt32>(nNumFmt)) );
    2042          80 :         pInsDoc->ApplyPatternAreaTab(nCol, 1, nCol, nRowSize-1, nNewTab, aPattern);
    2043          80 :     }
    2044             : 
    2045          16 :     SCCOL nEndCol = 0;
    2046          16 :     SCROW nEndRow = 0;
    2047          16 :     pInsDoc->GetCellArea( nNewTab, nEndCol, nEndRow );
    2048          16 :     pInsDoc->SetClipArea( ScRange( 0, 0, nNewTab, nEndCol, nEndRow, nNewTab ) );
    2049             : 
    2050          16 :     ::svl::IUndoManager* pMgr = GetViewData().GetDocShell()->GetUndoManager();
    2051          32 :     OUString aUndo = ScGlobal::GetRscString( STR_UNDO_DOOUTLINE );
    2052          16 :     pMgr->EnterListAction( aUndo, aUndo );
    2053             : 
    2054          32 :     OUString aNewTabName;
    2055          16 :     pDoc->CreateValidTabName(aNewTabName);
    2056          16 :     if ( InsertTable(aNewTabName, nNewTab) )
    2057          16 :         PasteFromClip( IDF_ALL, pInsDoc.get() );
    2058             : 
    2059          32 :     pMgr->LeaveListAction();
    2060             : }
    2061             : 
    2062             : //          DB-Operationen (Sortieren, Filtern, Teilergebnisse) wiederholen
    2063             : 
    2064           0 : void ScDBFunc::RepeatDB( bool bRecord )
    2065             : {
    2066           0 :     SCCOL nCurX = GetViewData().GetCurX();
    2067           0 :     SCROW nCurY = GetViewData().GetCurY();
    2068           0 :     SCTAB nTab = GetViewData().GetTabNo();
    2069           0 :     ScDocument* pDoc = GetViewData().GetDocument();
    2070           0 :     ScDBData* pDBData = GetDBData();
    2071           0 :     if (bRecord && !pDoc->IsUndoEnabled())
    2072           0 :         bRecord = false;
    2073             : 
    2074           0 :     ScQueryParam aQueryParam;
    2075           0 :     pDBData->GetQueryParam( aQueryParam );
    2076           0 :     bool bQuery = aQueryParam.GetEntry(0).bDoQuery;
    2077             : 
    2078           0 :     ScSortParam aSortParam;
    2079           0 :     pDBData->GetSortParam( aSortParam );
    2080           0 :     bool bSort = aSortParam.maKeyState[0].bDoSort;
    2081             : 
    2082           0 :     ScSubTotalParam aSubTotalParam;
    2083           0 :     pDBData->GetSubTotalParam( aSubTotalParam );
    2084           0 :     bool bSubTotal = aSubTotalParam.bGroupActive[0] && !aSubTotalParam.bRemoveOnly;
    2085             : 
    2086           0 :     if ( bQuery || bSort || bSubTotal )
    2087             :     {
    2088           0 :         bool bQuerySize = false;
    2089           0 :         ScRange aOldQuery;
    2090           0 :         ScRange aNewQuery;
    2091           0 :         if (bQuery && !aQueryParam.bInplace)
    2092             :         {
    2093             :             ScDBData* pDest = pDoc->GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,
    2094           0 :                                                     aQueryParam.nDestTab, true );
    2095           0 :             if (pDest && pDest->IsDoSize())
    2096             :             {
    2097           0 :                 pDest->GetArea( aOldQuery );
    2098           0 :                 bQuerySize = true;
    2099             :             }
    2100             :         }
    2101             : 
    2102             :         SCTAB nDummy;
    2103             :         SCCOL nStartCol;
    2104             :         SCROW nStartRow;
    2105             :         SCCOL nEndCol;
    2106             :         SCROW nEndRow;
    2107           0 :         pDBData->GetArea( nDummy, nStartCol, nStartRow, nEndCol, nEndRow );
    2108             : 
    2109             :         //!     Undo nur benoetigte Daten ?
    2110             : 
    2111           0 :         ScDocument* pUndoDoc = NULL;
    2112           0 :         ScOutlineTable* pUndoTab = NULL;
    2113           0 :         ScRangeName* pUndoRange = NULL;
    2114           0 :         ScDBCollection* pUndoDB = NULL;
    2115             : 
    2116           0 :         if (bRecord)
    2117             :         {
    2118           0 :             SCTAB nTabCount = pDoc->GetTableCount();
    2119           0 :             pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
    2120           0 :             ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
    2121           0 :             if (pTable)
    2122             :             {
    2123           0 :                 pUndoTab = new ScOutlineTable( *pTable );
    2124             : 
    2125             :                 SCCOLROW nOutStartCol;                          // Zeilen/Spaltenstatus
    2126             :                 SCCOLROW nOutStartRow;
    2127             :                 SCCOLROW nOutEndCol;
    2128             :                 SCCOLROW nOutEndRow;
    2129           0 :                 pTable->GetColArray().GetRange( nOutStartCol, nOutEndCol );
    2130           0 :                 pTable->GetRowArray().GetRange( nOutStartRow, nOutEndRow );
    2131             : 
    2132           0 :                 pUndoDoc->InitUndo( pDoc, nTab, nTab, true, true );
    2133           0 :                 pDoc->CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, IDF_NONE, false, pUndoDoc );
    2134           0 :                 pDoc->CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, IDF_NONE, false, pUndoDoc );
    2135             :             }
    2136             :             else
    2137           0 :                 pUndoDoc->InitUndo( pDoc, nTab, nTab, false, true );
    2138             : 
    2139             :             //  Datenbereich sichern - incl. Filter-Ergebnis
    2140           0 :             pDoc->CopyToDocument( 0,nStartRow,nTab, MAXCOL,nEndRow,nTab, IDF_ALL, false, pUndoDoc );
    2141             : 
    2142             :             //  alle Formeln wegen Referenzen
    2143           0 :             pDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, IDF_FORMULA, false, pUndoDoc );
    2144             : 
    2145             :             //  DB- und andere Bereiche
    2146           0 :             ScRangeName* pDocRange = pDoc->GetRangeName();
    2147           0 :             if (!pDocRange->empty())
    2148           0 :                 pUndoRange = new ScRangeName( *pDocRange );
    2149           0 :             ScDBCollection* pDocDB = pDoc->GetDBCollection();
    2150           0 :             if (!pDocDB->empty())
    2151           0 :                 pUndoDB = new ScDBCollection( *pDocDB );
    2152             :         }
    2153             : 
    2154           0 :         if (bSort && bSubTotal)
    2155             :         {
    2156             :             //  Sortieren ohne SubTotals
    2157             : 
    2158           0 :             aSubTotalParam.bRemoveOnly = true;      // wird unten wieder zurueckgesetzt
    2159           0 :             DoSubTotals( aSubTotalParam, false );
    2160             :         }
    2161             : 
    2162           0 :         if (bSort)
    2163             :         {
    2164           0 :             pDBData->GetSortParam( aSortParam );            // Bereich kann sich geaendert haben
    2165           0 :             Sort( aSortParam, false, false);
    2166             :         }
    2167           0 :         if (bQuery)
    2168             :         {
    2169           0 :             pDBData->GetQueryParam( aQueryParam );          // Bereich kann sich geaendert haben
    2170           0 :             ScRange aAdvSource;
    2171           0 :             if (pDBData->GetAdvancedQuerySource(aAdvSource))
    2172             :             {
    2173             :                 pDoc->CreateQueryParam(
    2174           0 :                     aAdvSource.aStart.Col(), aAdvSource.aStart.Row(),
    2175           0 :                     aAdvSource.aEnd.Col(), aAdvSource.aEnd.Row(),
    2176           0 :                     aAdvSource.aStart.Tab(), aQueryParam );
    2177           0 :                 Query( aQueryParam, &aAdvSource, false );
    2178             :             }
    2179             :             else
    2180           0 :                 Query( aQueryParam, NULL, false );
    2181             : 
    2182             :             //  bei nicht-inplace kann die Tabelle umgestellt worden sein
    2183           0 :             if ( !aQueryParam.bInplace && aQueryParam.nDestTab != nTab )
    2184           0 :                 SetTabNo( nTab );
    2185             :         }
    2186           0 :         if (bSubTotal)
    2187             :         {
    2188           0 :             pDBData->GetSubTotalParam( aSubTotalParam );    // Bereich kann sich geaendert haben
    2189           0 :             aSubTotalParam.bRemoveOnly = false;
    2190           0 :             DoSubTotals( aSubTotalParam, false );
    2191             :         }
    2192             : 
    2193           0 :         if (bRecord)
    2194             :         {
    2195             :             SCTAB nDummyTab;
    2196             :             SCCOL nDummyCol;
    2197             :             SCROW nDummyRow, nNewEndRow;
    2198           0 :             pDBData->GetArea( nDummyTab, nDummyCol,nDummyRow, nDummyCol,nNewEndRow );
    2199             : 
    2200           0 :             const ScRange* pOld = NULL;
    2201           0 :             const ScRange* pNew = NULL;
    2202           0 :             if (bQuerySize)
    2203             :             {
    2204             :                 ScDBData* pDest = pDoc->GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,
    2205           0 :                                                         aQueryParam.nDestTab, true );
    2206           0 :                 if (pDest)
    2207             :                 {
    2208           0 :                     pDest->GetArea( aNewQuery );
    2209           0 :                     pOld = &aOldQuery;
    2210           0 :                     pNew = &aNewQuery;
    2211             :                 }
    2212             :             }
    2213             : 
    2214           0 :             GetViewData().GetDocShell()->GetUndoManager()->AddUndoAction(
    2215           0 :                 new ScUndoRepeatDB( GetViewData().GetDocShell(), nTab,
    2216             :                                         nStartCol, nStartRow, nEndCol, nEndRow,
    2217             :                                         nNewEndRow,
    2218             :                                         nCurX, nCurY,
    2219             :                                         pUndoDoc, pUndoTab,
    2220             :                                         pUndoRange, pUndoDB,
    2221           0 :                                         pOld, pNew ) );
    2222             :         }
    2223             : 
    2224           0 :         GetViewData().GetDocShell()->PostPaint(
    2225             :             ScRange(0, 0, nTab, MAXCOL, MAXROW, nTab),
    2226           0 :             PAINT_GRID | PAINT_LEFT | PAINT_TOP | PAINT_SIZE);
    2227             :     }
    2228             :     else        // "Keine Operationen auszufuehren"
    2229           0 :         ErrorMessage(STR_MSSG_REPEATDB_0);
    2230         156 : }
    2231             : 
    2232             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11