| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_sc.hxx" | |
| // INCLUDE --------------------------------------------------------------- | |
| #include <sfx2/app.hxx> | |
| #include <vcl/msgbox.hxx> | |
| #include <vcl/waitobj.hxx> | |
| #include <svx/dataaccessdescriptor.hxx> | |
| #include <com/sun/star/sdb/CommandType.hpp> | |
| #include "dbdocfun.hxx" | |
| #include "sc.hrc" | |
| #include "dbcolect.hxx" | |
| #include "undodat.hxx" | |
| #include "docsh.hxx" | |
| #include "docfunc.hxx" | |
| #include "globstr.hrc" | |
| #include "tabvwsh.hxx" | |
| #include "patattr.hxx" | |
| #include "rangenam.hxx" | |
| #include "olinetab.hxx" | |
| #include "dpobject.hxx" | |
| #include "dociter.hxx" // for lcl_EmptyExcept | |
| #include "cell.hxx" // for lcl_EmptyExcept | |
| #include "editable.hxx" | |
| #include "attrib.hxx" | |
| #include "drwlayer.hxx" | |
| #include "dpshttab.hxx" | |
| #include "hints.hxx" | |
| using namespace ::com::sun::star; | |
| // ----------------------------------------------------------------- | |
| sal_Bool ScDBDocFunc::AddDBRange( const String& rName, const ScRange& rRange, sal_Bool /* bApi */ ) | |
| { | |
| ScDocShellModificator aModificator( rDocShell ); | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| ScDBCollection* pDocColl = pDoc->GetDBCollection(); | |
| sal_Bool bUndo (pDoc->IsUndoEnabled()); | |
| ScDBCollection* pUndoColl = NULL; | |
| if (bUndo) | |
| pUndoColl = new ScDBCollection( *pDocColl ); | |
| ScDBData* pNew = new ScDBData( rName, rRange.aStart.Tab(), | |
| rRange.aStart.Col(), rRange.aStart.Row(), | |
| rRange.aEnd.Col(), rRange.aEnd.Row() ); | |
| // #i55926# While loading XML, formula cells only have a single string token, | |
| // so CompileDBFormula would never find any name (index) tokens, and would | |
| // unnecessarily loop through all cells. | |
| sal_Bool bCompile = !pDoc->IsImportingXML(); | |
| if ( bCompile ) | |
| pDoc->CompileDBFormula( sal_True ); // CreateFormulaString | |
| sal_Bool bOk = pDocColl->Insert( pNew ); | |
| if ( bCompile ) | |
| pDoc->CompileDBFormula( sal_False ); // CompileFormulaString | |
| if (!bOk) | |
| { | |
| delete pNew; | |
| delete pUndoColl; | |
| return sal_False; | |
| } | |
| if (bUndo) | |
| { | |
| ScDBCollection* pRedoColl = new ScDBCollection( *pDocColl ); | |
| rDocShell.GetUndoManager()->AddUndoAction( | |
| new ScUndoDBData( &rDocShell, pUndoColl, pRedoColl ) ); | |
| } | |
| aModificator.SetDocumentModified(); | |
| SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) ); | |
| return sal_True; | |
| } | |
| sal_Bool ScDBDocFunc::DeleteDBRange( const String& rName, sal_Bool /* bApi */ ) | |
| { | |
| sal_Bool bDone = sal_False; | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| ScDBCollection* pDocColl = pDoc->GetDBCollection(); | |
| sal_Bool bUndo (pDoc->IsUndoEnabled()); | |
| sal_uInt16 nPos = 0; | |
| if (pDocColl->SearchName( rName, nPos )) | |
| { | |
| ScDocShellModificator aModificator( rDocShell ); | |
| ScDBCollection* pUndoColl = NULL; | |
| if (bUndo) | |
| pUndoColl = new ScDBCollection( *pDocColl ); | |
| pDoc->CompileDBFormula( sal_True ); // CreateFormulaString | |
| pDocColl->AtFree( nPos ); | |
| pDoc->CompileDBFormula( sal_False ); // CompileFormulaString | |
| if (bUndo) | |
| { | |
| ScDBCollection* pRedoColl = new ScDBCollection( *pDocColl ); | |
| rDocShell.GetUndoManager()->AddUndoAction( | |
| new ScUndoDBData( &rDocShell, pUndoColl, pRedoColl ) ); | |
| } | |
| aModificator.SetDocumentModified(); | |
| SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) ); | |
| bDone = sal_True; | |
| } | |
| return bDone; | |
| } | |
| sal_Bool ScDBDocFunc::RenameDBRange( const String& rOld, const String& rNew, sal_Bool /* bApi */ ) | |
| { | |
| sal_Bool bDone = sal_False; | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| ScDBCollection* pDocColl = pDoc->GetDBCollection(); | |
| sal_Bool bUndo (pDoc->IsUndoEnabled()); | |
| sal_uInt16 nPos = 0; | |
| sal_uInt16 nDummy = 0; | |
| if ( pDocColl->SearchName( rOld, nPos ) && | |
| !pDocColl->SearchName( rNew, nDummy ) ) | |
| { | |
| ScDocShellModificator aModificator( rDocShell ); | |
| ScDBData* pData = (*pDocColl)[nPos]; | |
| ScDBData* pNewData = new ScDBData(*pData); | |
| pNewData->SetName(rNew); | |
| ScDBCollection* pUndoColl = new ScDBCollection( *pDocColl ); | |
| pDoc->CompileDBFormula( sal_True ); // CreateFormulaString | |
| pDocColl->AtFree( nPos ); | |
| sal_Bool bInserted = pDocColl->Insert( pNewData ); | |
| if (!bInserted) // Fehler -> alten Zustand wiederherstellen | |
| { | |
| delete pNewData; | |
| pDoc->SetDBCollection( pUndoColl ); // gehoert dann dem Dokument | |
| } | |
| pDoc->CompileDBFormula( sal_False ); // CompileFormulaString | |
| if (bInserted) // Einfuegen hat geklappt | |
| { | |
| if (bUndo) | |
| { | |
| ScDBCollection* pRedoColl = new ScDBCollection( *pDocColl ); | |
| rDocShell.GetUndoManager()->AddUndoAction( | |
| new ScUndoDBData( &rDocShell, pUndoColl, pRedoColl ) ); | |
| } | |
| else | |
| delete pUndoColl; | |
| aModificator.SetDocumentModified(); | |
| SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) ); | |
| bDone = sal_True; | |
| } | |
| } | |
| return bDone; | |
| } | |
| sal_Bool ScDBDocFunc::ModifyDBData( const ScDBData& rNewData, sal_Bool /* bApi */ ) | |
| { | |
| sal_Bool bDone = sal_False; | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| ScDBCollection* pDocColl = pDoc->GetDBCollection(); | |
| sal_Bool bUndo (pDoc->IsUndoEnabled()); | |
| sal_uInt16 nPos = 0; | |
| if (pDocColl->SearchName( rNewData.GetName(), nPos )) | |
| { | |
| ScDocShellModificator aModificator( rDocShell ); | |
| ScDBData* pData = (*pDocColl)[nPos]; | |
| ScRange aOldRange, aNewRange; | |
| pData->GetArea(aOldRange); | |
| rNewData.GetArea(aNewRange); | |
| sal_Bool bAreaChanged = ( aOldRange != aNewRange ); // dann muss neu compiliert werden | |
| ScDBCollection* pUndoColl = NULL; | |
| if (bUndo) | |
| pUndoColl = new ScDBCollection( *pDocColl ); | |
| *pData = rNewData; | |
| if (bAreaChanged) | |
| pDoc->CompileDBFormula(); | |
| if (bUndo) | |
| { | |
| ScDBCollection* pRedoColl = new ScDBCollection( *pDocColl ); | |
| rDocShell.GetUndoManager()->AddUndoAction( | |
| new ScUndoDBData( &rDocShell, pUndoColl, pRedoColl ) ); | |
| } | |
| aModificator.SetDocumentModified(); | |
| bDone = sal_True; | |
| } | |
| return bDone; | |
| } | |
| // ----------------------------------------------------------------- | |
| sal_Bool ScDBDocFunc::RepeatDB( const String& rDBName, sal_Bool bRecord, sal_Bool bApi ) | |
| { | |
| //! auch fuer ScDBFunc::RepeatDB benutzen! | |
| sal_Bool bDone = sal_False; | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| if (bRecord && !pDoc->IsUndoEnabled()) | |
| bRecord = sal_False; | |
| ScDBCollection* pColl = pDoc->GetDBCollection(); | |
| sal_uInt16 nIndex; | |
| if ( pColl && pColl->SearchName( rDBName, nIndex ) ) | |
| { | |
| ScDBData* pDBData = (*pColl)[nIndex]; | |
| ScQueryParam aQueryParam; | |
| pDBData->GetQueryParam( aQueryParam ); | |
| sal_Bool bQuery = aQueryParam.GetEntry(0).bDoQuery; | |
| ScSortParam aSortParam; | |
| pDBData->GetSortParam( aSortParam ); | |
| sal_Bool bSort = aSortParam.bDoSort[0]; | |
| ScSubTotalParam aSubTotalParam; | |
| pDBData->GetSubTotalParam( aSubTotalParam ); | |
| sal_Bool bSubTotal = aSubTotalParam.bGroupActive[0] && !aSubTotalParam.bRemoveOnly; | |
| if ( bQuery || bSort || bSubTotal ) | |
| { | |
| sal_Bool bQuerySize = sal_False; | |
| ScRange aOldQuery; | |
| ScRange aNewQuery; | |
| if (bQuery && !aQueryParam.bInplace) | |
| { | |
| ScDBData* pDest = pDoc->GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow, | |
| aQueryParam.nDestTab, sal_True ); | |
| if (pDest && pDest->IsDoSize()) | |
| { | |
| pDest->GetArea( aOldQuery ); | |
| bQuerySize = sal_True; | |
| } | |
| } | |
| SCTAB nTab; | |
| SCCOL nStartCol; | |
| SCROW nStartRow; | |
| SCCOL nEndCol; | |
| SCROW nEndRow; | |
| pDBData->GetArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow ); | |
| //! Undo nur benoetigte Daten ? | |
| ScDocument* pUndoDoc = NULL; | |
| ScOutlineTable* pUndoTab = NULL; | |
| ScRangeName* pUndoRange = NULL; | |
| ScDBCollection* pUndoDB = NULL; | |
| if (bRecord) | |
| { | |
| SCTAB nTabCount = pDoc->GetTableCount(); | |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab ); | |
| if (pTable) | |
| { | |
| pUndoTab = new ScOutlineTable( *pTable ); | |
| // column/row state | |
| SCCOLROW nOutStartCol, nOutEndCol; | |
| SCCOLROW nOutStartRow, nOutEndRow; | |
| pTable->GetColArray()->GetRange( nOutStartCol, nOutEndCol ); | |
| pTable->GetRowArray()->GetRange( nOutStartRow, nOutEndRow ); | |
| pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True ); | |
| pDoc->CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, | |
| nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, | |
| IDF_NONE, sal_False, pUndoDoc ); | |
| pDoc->CopyToDocument( 0, static_cast<SCROW>(nOutStartRow), | |
| nTab, MAXCOL, static_cast<SCROW>(nOutEndRow), nTab, | |
| IDF_NONE, sal_False, pUndoDoc ); | |
| } | |
| else | |
| pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_False, sal_True ); | |
| // Datenbereich sichern - incl. Filter-Ergebnis | |
| pDoc->CopyToDocument( 0,nStartRow,nTab, MAXCOL,nEndRow,nTab, IDF_ALL, sal_False, pUndoDoc ); | |
| // alle Formeln wegen Referenzen | |
| pDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, IDF_FORMULA, sal_False, pUndoDoc ); | |
| // DB- und andere Bereiche | |
| ScRangeName* pDocRange = pDoc->GetRangeName(); | |
| if (pDocRange->GetCount()) | |
| pUndoRange = new ScRangeName( *pDocRange ); | |
| ScDBCollection* pDocDB = pDoc->GetDBCollection(); | |
| if (pDocDB->GetCount()) | |
| pUndoDB = new ScDBCollection( *pDocDB ); | |
| } | |
| if (bSort && bSubTotal) | |
| { | |
| // Sortieren ohne SubTotals | |
| aSubTotalParam.bRemoveOnly = sal_True; // wird unten wieder zurueckgesetzt | |
| DoSubTotals( nTab, aSubTotalParam, NULL, sal_False, bApi ); | |
| } | |
| if (bSort) | |
| { | |
| pDBData->GetSortParam( aSortParam ); // Bereich kann sich geaendert haben | |
| Sort( nTab, aSortParam, sal_False, sal_False, bApi ); | |
| } | |
| if (bQuery) | |
| { | |
| pDBData->GetQueryParam( aQueryParam ); // Bereich kann sich geaendert haben | |
| ScRange aAdvSource; | |
| if (pDBData->GetAdvancedQuerySource(aAdvSource)) | |
| Query( nTab, aQueryParam, &aAdvSource, sal_False, bApi ); | |
| else | |
| Query( nTab, aQueryParam, NULL, sal_False, bApi ); | |
| // bei nicht-inplace kann die Tabelle umgestellt worden sein | |
| // if ( !aQueryParam.bInplace && aQueryParam.nDestTab != nTab ) | |
| // SetTabNo( nTab ); | |
| } | |
| if (bSubTotal) | |
| { | |
| pDBData->GetSubTotalParam( aSubTotalParam ); // Bereich kann sich geaendert haben | |
| aSubTotalParam.bRemoveOnly = sal_False; | |
| DoSubTotals( nTab, aSubTotalParam, NULL, sal_False, bApi ); | |
| } | |
| if (bRecord) | |
| { | |
| SCTAB nDummyTab; | |
| SCCOL nDummyCol; | |
| SCROW nDummyRow; | |
| SCROW nNewEndRow; | |
| pDBData->GetArea( nDummyTab, nDummyCol,nDummyRow, nDummyCol,nNewEndRow ); | |
| const ScRange* pOld = NULL; | |
| const ScRange* pNew = NULL; | |
| if (bQuerySize) | |
| { | |
| ScDBData* pDest = pDoc->GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow, | |
| aQueryParam.nDestTab, sal_True ); | |
| if (pDest) | |
| { | |
| pDest->GetArea( aNewQuery ); | |
| pOld = &aOldQuery; | |
| pNew = &aNewQuery; | |
| } | |
| } | |
| rDocShell.GetUndoManager()->AddUndoAction( | |
| new ScUndoRepeatDB( &rDocShell, nTab, | |
| nStartCol, nStartRow, nEndCol, nEndRow, | |
| nNewEndRow, | |
| //nCurX, nCurY, | |
| nStartCol, nStartRow, | |
| pUndoDoc, pUndoTab, | |
| pUndoRange, pUndoDB, | |
| pOld, pNew ) ); | |
| } | |
| rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, | |
| PAINT_GRID | PAINT_LEFT | PAINT_TOP | PAINT_SIZE ); | |
| bDone = sal_True; | |
| } | |
| else if (!bApi) // "Keine Operationen auszufuehren" | |
| rDocShell.ErrorMessage(STR_MSSG_REPEATDB_0); | |
| } | |
| return bDone; | |
| } | |
| // ----------------------------------------------------------------- | |
| sal_Bool ScDBDocFunc::Sort( SCTAB nTab, const ScSortParam& rSortParam, | |
| sal_Bool bRecord, sal_Bool bPaint, sal_Bool bApi ) | |
| { | |
| ScDocShellModificator aModificator( rDocShell ); | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| if (bRecord && !pDoc->IsUndoEnabled()) | |
| bRecord = sal_False; | |
| SCTAB nSrcTab = nTab; | |
| ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer(); | |
| ScDBData* pDBData = pDoc->GetDBAtArea( nTab, rSortParam.nCol1, rSortParam.nRow1, | |
| rSortParam.nCol2, rSortParam.nRow2 ); | |
| if (!pDBData) | |
| { | |
| DBG_ERROR( "Sort: keine DBData" ); | |
| return sal_False; | |
| } | |
| ScDBData* pDestData = NULL; | |
| ScRange aOldDest; | |
| sal_Bool bCopy = !rSortParam.bInplace; | |
| if ( bCopy && rSortParam.nDestCol == rSortParam.nCol1 && | |
| rSortParam.nDestRow == rSortParam.nRow1 && rSortParam.nDestTab == nTab ) | |
| bCopy = sal_False; | |
| ScSortParam aLocalParam( rSortParam ); | |
| if ( bCopy ) | |
| { | |
| aLocalParam.MoveToDest(); | |
| if ( !ValidColRow( aLocalParam.nCol2, aLocalParam.nRow2 ) ) | |
| { | |
| if (!bApi) | |
| rDocShell.ErrorMessage(STR_PASTE_FULL); | |
| return sal_False; | |
| } | |
| nTab = rSortParam.nDestTab; | |
| pDestData = pDoc->GetDBAtCursor( rSortParam.nDestCol, rSortParam.nDestRow, | |
| rSortParam.nDestTab, sal_True ); | |
| if (pDestData) | |
| pDestData->GetArea(aOldDest); | |
| } | |
| ScEditableTester aTester( pDoc, nTab, aLocalParam.nCol1,aLocalParam.nRow1, | |
| aLocalParam.nCol2,aLocalParam.nRow2 ); | |
| if (!aTester.IsEditable()) | |
| { | |
| if (!bApi) | |
| rDocShell.ErrorMessage(aTester.GetMessageId()); | |
| return sal_False; | |
| } | |
| if ( aLocalParam.bIncludePattern && pDoc->HasAttrib( | |
| aLocalParam.nCol1, aLocalParam.nRow1, nTab, | |
| aLocalParam.nCol2, aLocalParam.nRow2, nTab, | |
| HASATTR_MERGED | HASATTR_OVERLAPPED ) ) | |
| { | |
| // Merge-Attribute wuerden beim Sortieren durcheinanderkommen | |
| if (!bApi) | |
| rDocShell.ErrorMessage(STR_SORT_ERR_MERGED); | |
| return sal_False; | |
| } | |
| // ausfuehren | |
| WaitObject aWait( rDocShell.GetActiveDialogParent() ); | |
| sal_Bool bRepeatQuery = sal_False; // bestehenden Filter wiederholen? | |
| ScQueryParam aQueryParam; | |
| pDBData->GetQueryParam( aQueryParam ); | |
| if ( aQueryParam.GetEntry(0).bDoQuery ) | |
| bRepeatQuery = sal_True; | |
| if (bRepeatQuery && bCopy) | |
| { | |
| if ( aQueryParam.bInplace || | |
| aQueryParam.nDestCol != rSortParam.nDestCol || | |
| aQueryParam.nDestRow != rSortParam.nDestRow || | |
| aQueryParam.nDestTab != rSortParam.nDestTab ) // Query auf selben Zielbereich? | |
| bRepeatQuery = sal_False; | |
| } | |
| ScUndoSort* pUndoAction = 0; | |
| if ( bRecord ) | |
| { | |
| // Referenzen ausserhalb des Bereichs werden nicht veraendert ! | |
| ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| // Zeilenhoehen immer (wegen automatischer Anpassung) | |
| //! auf ScBlockUndo umstellen | |
| pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_False, sal_True ); | |
| /* #i59745# Do not copy note captions to undo document. All existing | |
| caption objects will be repositioned while sorting which is tracked | |
| in drawing undo. When undo is executed, the old positions will be | |
| restored, and the cells with the old notes (which still refer to the | |
| existing captions) will be copied back into the source document. */ | |
| pDoc->CopyToDocument( aLocalParam.nCol1, aLocalParam.nRow1, nTab, | |
| aLocalParam.nCol2, aLocalParam.nRow2, nTab, | |
| IDF_ALL|IDF_NOCAPTIONS, sal_False, pUndoDoc ); | |
| const ScRange* pR = 0; | |
| if (pDestData) | |
| { | |
| /* #i59745# Do not copy note captions from destination range to | |
| undo document. All existing caption objects will be removed | |
| which is tracked in drawing undo. When undo is executed, the | |
| caption objects are reinserted with drawing undo, and the cells | |
| with the old notes (which still refer to the existing captions) | |
| will be copied back into the source document. */ | |
| pDoc->CopyToDocument( aOldDest, IDF_ALL|IDF_NOCAPTIONS, sal_False, pUndoDoc ); | |
| pR = &aOldDest; | |
| } | |
| // Zeilenhoehen immer (wegen automatischer Anpassung) | |
| //! auf ScBlockUndo umstellen | |
| // if (bRepeatQuery) | |
| pDoc->CopyToDocument( 0, aLocalParam.nRow1, nTab, MAXCOL, aLocalParam.nRow2, nTab, | |
| IDF_NONE, sal_False, pUndoDoc ); | |
| ScDBCollection* pUndoDB = NULL; | |
| ScDBCollection* pDocDB = pDoc->GetDBCollection(); | |
| if (pDocDB->GetCount()) | |
| pUndoDB = new ScDBCollection( *pDocDB ); | |
| pUndoAction = new ScUndoSort( &rDocShell, nTab, rSortParam, bRepeatQuery, pUndoDoc, pUndoDB, pR ); | |
| rDocShell.GetUndoManager()->AddUndoAction( pUndoAction ); | |
| // #i59745# collect all drawing undo actions affecting cell note captions | |
| if( pDrawLayer ) | |
| pDrawLayer->BeginCalcUndo(false); | |
| } | |
| if ( bCopy ) | |
| { | |
| if (pDestData) | |
| pDoc->DeleteAreaTab(aOldDest, IDF_CONTENTS); // Zielbereich vorher loeschen | |
| ScRange aSource( rSortParam.nCol1,rSortParam.nRow1,nSrcTab, | |
| rSortParam.nCol2,rSortParam.nRow2,nSrcTab ); | |
| ScAddress aDest( rSortParam.nDestCol, rSortParam.nDestRow, rSortParam.nDestTab ); | |
| rDocShell.GetDocFunc().MoveBlock( aSource, aDest, sal_False, sal_False, sal_False, sal_True ); | |
| } | |
| // #105780# don't call ScDocument::Sort with an empty SortParam (may be empty here if bCopy is set) | |
| if ( aLocalParam.bDoSort[0] ) | |
| pDoc->Sort( nTab, aLocalParam, bRepeatQuery ); | |
| sal_Bool bSave = sal_True; | |
| if (bCopy) | |
| { | |
| ScSortParam aOldSortParam; | |
| pDBData->GetSortParam( aOldSortParam ); | |
| if ( aOldSortParam.bDoSort[0] && aOldSortParam.bInplace ) // Inplace-Sortierung gemerkt? | |
| { | |
| bSave = sal_False; | |
| aOldSortParam.nDestCol = rSortParam.nDestCol; | |
| aOldSortParam.nDestRow = rSortParam.nDestRow; | |
| aOldSortParam.nDestTab = rSortParam.nDestTab; | |
| pDBData->SetSortParam( aOldSortParam ); // dann nur DestPos merken | |
| } | |
| } | |
| if (bSave) // Parameter merken | |
| { | |
| pDBData->SetSortParam( rSortParam ); | |
| pDBData->SetHeader( rSortParam.bHasHeader ); //! ??? | |
| pDBData->SetByRow( rSortParam.bByRow ); //! ??? | |
| } | |
| if (bCopy) // neuen DB-Bereich merken | |
| { | |
| // Tabelle umschalten von aussen (View) | |
| //! SetCursor ??!?! | |
| ScRange aDestPos( aLocalParam.nCol1, aLocalParam.nRow1, nTab, | |
| aLocalParam.nCol2, aLocalParam.nRow2, nTab ); | |
| ScDBData* pNewData; | |
| if (pDestData) | |
| pNewData = pDestData; // Bereich vorhanden -> anpassen | |
| else // Bereich ab Cursor/Markierung wird angelegt | |
| pNewData = rDocShell.GetDBData(aDestPos, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); | |
| if (pNewData) | |
| { | |
| pNewData->SetArea( nTab, | |
| aLocalParam.nCol1,aLocalParam.nRow1, | |
| aLocalParam.nCol2,aLocalParam.nRow2 ); | |
| pNewData->SetSortParam( aLocalParam ); | |
| pNewData->SetHeader( aLocalParam.bHasHeader ); //! ??? | |
| pNewData->SetByRow( aLocalParam.bByRow ); | |
| } | |
| else | |
| { | |
| DBG_ERROR("Zielbereich nicht da"); | |
| } | |
| } | |
| ScRange aDirtyRange( aLocalParam.nCol1, aLocalParam.nRow1, nTab, | |
| aLocalParam.nCol2, aLocalParam.nRow2, nTab ); | |
| pDoc->SetDirty( aDirtyRange ); | |
| if (bPaint) | |
| { | |
| sal_uInt16 nPaint = PAINT_GRID; | |
| SCCOL nStartX = aLocalParam.nCol1; | |
| SCROW nStartY = aLocalParam.nRow1; | |
| SCCOL nEndX = aLocalParam.nCol2; | |
| SCROW nEndY = aLocalParam.nRow2; | |
| if ( bRepeatQuery ) | |
| { | |
| nPaint |= PAINT_LEFT; | |
| nStartX = 0; | |
| nEndX = MAXCOL; | |
| } | |
| if (pDestData) | |
| { | |
| if ( nEndX < aOldDest.aEnd.Col() ) | |
| nEndX = aOldDest.aEnd.Col(); | |
| if ( nEndY < aOldDest.aEnd.Row() ) | |
| nEndY = aOldDest.aEnd.Row(); | |
| } | |
| rDocShell.PostPaint( nStartX, nStartY, nTab, nEndX, nEndY, nTab, nPaint ); | |
| } | |
| // AdjustRowHeight( aLocalParam.nRow1, aLocalParam.nRow2, bPaint ); | |
| rDocShell.AdjustRowHeight( aLocalParam.nRow1, aLocalParam.nRow2, nTab ); | |
| // #i59745# set collected drawing undo actions at sorting undo action | |
| if( pUndoAction && pDrawLayer ) | |
| pUndoAction->SetDrawUndoAction( pDrawLayer->GetCalcUndo() ); | |
| aModificator.SetDocumentModified(); | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------- | |
| sal_Bool ScDBDocFunc::Query( SCTAB nTab, const ScQueryParam& rQueryParam, | |
| const ScRange* pAdvSource, sal_Bool bRecord, sal_Bool bApi ) | |
| { | |
| ScDocShellModificator aModificator( rDocShell ); | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| if (bRecord && !pDoc->IsUndoEnabled()) | |
| bRecord = sal_False; | |
| ScDBData* pDBData = pDoc->GetDBAtArea( nTab, rQueryParam.nCol1, rQueryParam.nRow1, | |
| rQueryParam.nCol2, rQueryParam.nRow2 ); | |
| if (!pDBData) | |
| { | |
| DBG_ERROR( "Query: keine DBData" ); | |
| return sal_False; | |
| } | |
| // Wechsel von Inplace auf nicht-Inplace, dann erst Inplace aufheben: | |
| // (nur, wenn im Dialog "Persistent" ausgewaehlt ist) | |
| if ( !rQueryParam.bInplace && pDBData->HasQueryParam() && rQueryParam.bDestPers ) | |
| { | |
| ScQueryParam aOldQuery; | |
| pDBData->GetQueryParam(aOldQuery); | |
| if (aOldQuery.bInplace) | |
| { | |
| // alte Filterung aufheben | |
| SCSIZE nEC = aOldQuery.GetEntryCount(); | |
| for (SCSIZE i=0; i<nEC; i++) | |
| aOldQuery.GetEntry(i).bDoQuery = sal_False; | |
| aOldQuery.bDuplicate = sal_True; | |
| Query( nTab, aOldQuery, NULL, bRecord, bApi ); | |
| } | |
| } | |
| ScQueryParam aLocalParam( rQueryParam ); // fuer Paint / Zielbereich | |
| sal_Bool bCopy = !rQueryParam.bInplace; // kopiert wird in Table::Query | |
| ScDBData* pDestData = NULL; // Bereich, in den kopiert wird | |
| sal_Bool bDoSize = sal_False; // Zielgroesse anpassen (einf./loeschen) | |
| SCCOL nFormulaCols = 0; // nur bei bDoSize | |
| sal_Bool bKeepFmt = sal_False; | |
| ScRange aOldDest; | |
| ScRange aDestTotal; | |
| if ( bCopy && rQueryParam.nDestCol == rQueryParam.nCol1 && | |
| rQueryParam.nDestRow == rQueryParam.nRow1 && rQueryParam.nDestTab == nTab ) | |
| bCopy = sal_False; | |
| SCTAB nDestTab = nTab; | |
| if ( bCopy ) | |
| { | |
| aLocalParam.MoveToDest(); | |
| nDestTab = rQueryParam.nDestTab; | |
| if ( !ValidColRow( aLocalParam.nCol2, aLocalParam.nRow2 ) ) | |
| { | |
| if (!bApi) | |
| rDocShell.ErrorMessage(STR_PASTE_FULL); | |
| return sal_False; | |
| } | |
| ScEditableTester aTester( pDoc, nDestTab, aLocalParam.nCol1,aLocalParam.nRow1, | |
| aLocalParam.nCol2,aLocalParam.nRow2); | |
| if (!aTester.IsEditable()) | |
| { | |
| if (!bApi) | |
| rDocShell.ErrorMessage(aTester.GetMessageId()); | |
| return sal_False; | |
| } | |
| pDestData = pDoc->GetDBAtCursor( rQueryParam.nDestCol, rQueryParam.nDestRow, | |
| rQueryParam.nDestTab, sal_True ); | |
| if (pDestData) | |
| { | |
| pDestData->GetArea( aOldDest ); | |
| aDestTotal=ScRange( rQueryParam.nDestCol, | |
| rQueryParam.nDestRow, | |
| nDestTab, | |
| rQueryParam.nDestCol + rQueryParam.nCol2 - rQueryParam.nCol1, | |
| rQueryParam.nDestRow + rQueryParam.nRow2 - rQueryParam.nRow1, | |
| nDestTab ); | |
| bDoSize = pDestData->IsDoSize(); | |
| // Test, ob Formeln aufgefuellt werden muessen (nFormulaCols): | |
| if ( bDoSize && aOldDest.aEnd.Col() == aDestTotal.aEnd.Col() ) | |
| { | |
| SCCOL nTestCol = aOldDest.aEnd.Col() + 1; // neben dem Bereich | |
| SCROW nTestRow = rQueryParam.nDestRow + | |
| ( aLocalParam.bHasHeader ? 1 : 0 ); | |
| while ( nTestCol <= MAXCOL && | |
| pDoc->GetCellType(ScAddress( nTestCol, nTestRow, nTab )) == CELLTYPE_FORMULA ) | |
| ++nTestCol, ++nFormulaCols; | |
| } | |
| bKeepFmt = pDestData->IsKeepFmt(); | |
| if ( bDoSize && !pDoc->CanFitBlock( aOldDest, aDestTotal ) ) | |
| { | |
| if (!bApi) | |
| rDocShell.ErrorMessage(STR_MSSG_DOSUBTOTALS_2); // kann keine Zeilen einfuegen | |
| return sal_False; | |
| } | |
| } | |
| } | |
| // ausfuehren | |
| WaitObject aWait( rDocShell.GetActiveDialogParent() ); | |
| sal_Bool bKeepSub = sal_False; // bestehende Teilergebnisse wiederholen? | |
| ScSubTotalParam aSubTotalParam; | |
| if (rQueryParam.GetEntry(0).bDoQuery) // nicht beim Aufheben | |
| { | |
| pDBData->GetSubTotalParam( aSubTotalParam ); // Teilergebnisse vorhanden? | |
| if ( aSubTotalParam.bGroupActive[0] && !aSubTotalParam.bRemoveOnly ) | |
| bKeepSub = sal_True; | |
| } | |
| ScDocument* pUndoDoc = NULL; | |
| ScDBCollection* pUndoDB = NULL; | |
| const ScRange* pOld = NULL; | |
| if ( bRecord ) | |
| { | |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| if (bCopy) | |
| { | |
| pUndoDoc->InitUndo( pDoc, nDestTab, nDestTab, sal_False, sal_True ); | |
| pDoc->CopyToDocument( aLocalParam.nCol1, aLocalParam.nRow1, nDestTab, | |
| aLocalParam.nCol2, aLocalParam.nRow2, nDestTab, | |
| IDF_ALL, sal_False, pUndoDoc ); | |
| // Attribute sichern, falls beim Filtern mitkopiert | |
| if (pDestData) | |
| { | |
| pDoc->CopyToDocument( aOldDest, IDF_ALL, sal_False, pUndoDoc ); | |
| pOld = &aOldDest; | |
| } | |
| } | |
| else | |
| { | |
| pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_False, sal_True ); | |
| pDoc->CopyToDocument( 0, rQueryParam.nRow1, nTab, MAXCOL, rQueryParam.nRow2, nTab, | |
| IDF_NONE, sal_False, pUndoDoc ); | |
| } | |
| ScDBCollection* pDocDB = pDoc->GetDBCollection(); | |
| if (pDocDB->GetCount()) | |
| pUndoDB = new ScDBCollection( *pDocDB ); | |
| pDoc->BeginDrawUndo(); | |
| } | |
| ScDocument* pAttribDoc = NULL; | |
| ScRange aAttribRange; | |
| if (pDestData) // Zielbereich loeschen | |
| { | |
| if ( bKeepFmt ) | |
| { | |
| // kleinere der End-Spalten, Header+1 Zeile | |
| aAttribRange = aOldDest; | |
| if ( aAttribRange.aEnd.Col() > aDestTotal.aEnd.Col() ) | |
| aAttribRange.aEnd.SetCol( aDestTotal.aEnd.Col() ); | |
| aAttribRange.aEnd.SetRow( aAttribRange.aStart.Row() + | |
| ( aLocalParam.bHasHeader ? 1 : 0 ) ); | |
| // auch fuer aufgefuellte Formeln | |
| aAttribRange.aEnd.SetCol( aAttribRange.aEnd.Col() + nFormulaCols ); | |
| pAttribDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| pAttribDoc->InitUndo( pDoc, nDestTab, nDestTab, sal_False, sal_True ); | |
| pDoc->CopyToDocument( aAttribRange, IDF_ATTRIB, sal_False, pAttribDoc ); | |
| } | |
| if ( bDoSize ) | |
| pDoc->FitBlock( aOldDest, aDestTotal ); | |
| else | |
| pDoc->DeleteAreaTab(aOldDest, IDF_ALL); // einfach loeschen | |
| } | |
| // Filtern am Dokument ausfuehren | |
| SCSIZE nCount = pDoc->Query( nTab, rQueryParam, bKeepSub ); | |
| if (bCopy) | |
| { | |
| aLocalParam.nRow2 = aLocalParam.nRow1 + nCount; | |
| if (!aLocalParam.bHasHeader && nCount > 0) | |
| --aLocalParam.nRow2; | |
| if ( bDoSize ) | |
| { | |
| // auf wirklichen Ergebnis-Bereich anpassen | |
| // (das hier ist immer eine Verkleinerung) | |
| ScRange aNewDest( aLocalParam.nCol1, aLocalParam.nRow1, nDestTab, | |
| aLocalParam.nCol2, aLocalParam.nRow2, nDestTab ); | |
| pDoc->FitBlock( aDestTotal, aNewDest, sal_False ); // sal_False - nicht loeschen | |
| if ( nFormulaCols > 0 ) | |
| { | |
| // Formeln ausfuellen | |
| //! Undo (Query und Repeat) !!! | |
| ScRange aNewForm( aLocalParam.nCol2+1, aLocalParam.nRow1, nDestTab, | |
| aLocalParam.nCol2+nFormulaCols, aLocalParam.nRow2, nDestTab ); | |
| ScRange aOldForm = aNewForm; | |
| aOldForm.aEnd.SetRow( aOldDest.aEnd.Row() ); | |
| pDoc->FitBlock( aOldForm, aNewForm, sal_False ); | |
| ScMarkData aMark; | |
| aMark.SelectOneTable(nDestTab); | |
| SCROW nFStartY = aLocalParam.nRow1 + ( aLocalParam.bHasHeader ? 1 : 0 ); | |
| pDoc->Fill( aLocalParam.nCol2+1, nFStartY, | |
| aLocalParam.nCol2+nFormulaCols, nFStartY, aMark, | |
| aLocalParam.nRow2 - nFStartY, | |
| FILL_TO_BOTTOM, FILL_SIMPLE ); | |
| } | |
| } | |
| if ( pAttribDoc ) // gemerkte Attribute zurueckkopieren | |
| { | |
| // Header | |
| if (aLocalParam.bHasHeader) | |
| { | |
| ScRange aHdrRange = aAttribRange; | |
| aHdrRange.aEnd.SetRow( aHdrRange.aStart.Row() ); | |
| pAttribDoc->CopyToDocument( aHdrRange, IDF_ATTRIB, sal_False, pDoc ); | |
| } | |
| // Daten | |
| SCCOL nAttrEndCol = aAttribRange.aEnd.Col(); | |
| SCROW nAttrRow = aAttribRange.aStart.Row() + ( aLocalParam.bHasHeader ? 1 : 0 ); | |
| for (SCCOL nCol = aAttribRange.aStart.Col(); nCol<=nAttrEndCol; nCol++) | |
| { | |
| const ScPatternAttr* pSrcPattern = pAttribDoc->GetPattern( | |
| nCol, nAttrRow, nDestTab ); | |
| DBG_ASSERT(pSrcPattern,"Pattern ist 0"); | |
| if (pSrcPattern) | |
| pDoc->ApplyPatternAreaTab( nCol, nAttrRow, nCol, aLocalParam.nRow2, | |
| nDestTab, *pSrcPattern ); | |
| const ScStyleSheet* pStyle = pSrcPattern->GetStyleSheet(); | |
| if (pStyle) | |
| pDoc->ApplyStyleAreaTab( nCol, nAttrRow, nCol, aLocalParam.nRow2, | |
| nDestTab, *pStyle ); | |
| } | |
| delete pAttribDoc; | |
| } | |
| } | |
| // speichern: Inplace immer, sonst je nach Einstellung | |
| // alter Inplace-Filter ist ggf. schon aufgehoben | |
| sal_Bool bSave = rQueryParam.bInplace || rQueryParam.bDestPers; | |
| if (bSave) // merken | |
| { | |
| pDBData->SetQueryParam( rQueryParam ); | |
| pDBData->SetHeader( rQueryParam.bHasHeader ); //! ??? | |
| pDBData->SetAdvancedQuerySource( pAdvSource ); // after SetQueryParam | |
| } | |
| if (bCopy) // neuen DB-Bereich merken | |
| { | |
| // selektieren wird hinterher von aussen (dbfunc) | |
| // momentan ueber DB-Bereich an der Zielposition, darum muss dort | |
| // auf jeden Fall ein Bereich angelegt werden. | |
| ScDBData* pNewData; | |
| if (pDestData) | |
| pNewData = pDestData; // Bereich vorhanden -> anpassen (immer!) | |
| else // Bereich anlegen | |
| pNewData = rDocShell.GetDBData( | |
| ScRange( aLocalParam.nCol1, aLocalParam.nRow1, nDestTab, | |
| aLocalParam.nCol2, aLocalParam.nRow2, nDestTab ), | |
| SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); | |
| if (pNewData) | |
| { | |
| pNewData->SetArea( nDestTab, aLocalParam.nCol1, aLocalParam.nRow1, | |
| aLocalParam.nCol2, aLocalParam.nRow2 ); | |
| // Query-Param wird am Ziel nicht mehr eingestellt, fuehrt nur zu Verwirrung | |
| // und Verwechslung mit dem Query-Param am Quellbereich (#37187#) | |
| } | |
| else | |
| { | |
| DBG_ERROR("Zielbereich nicht da"); | |
| } | |
| } | |
| if (!bCopy) | |
| { | |
| pDoc->InvalidatePageBreaks(nTab); | |
| pDoc->UpdatePageBreaks( nTab ); | |
| } | |
| // #i23299# because of Subtotal functions, the whole rows must be set dirty | |
| ScRange aDirtyRange( 0 , aLocalParam.nRow1, nDestTab, | |
| MAXCOL, aLocalParam.nRow2, nDestTab ); | |
| pDoc->SetDirty( aDirtyRange ); | |
| if ( bRecord ) | |
| { | |
| // create undo action after executing, because of drawing layer undo | |
| rDocShell.GetUndoManager()->AddUndoAction( | |
| new ScUndoQuery( &rDocShell, nTab, rQueryParam, pUndoDoc, pUndoDB, | |
| pOld, bDoSize, pAdvSource ) ); | |
| } | |
| if (bCopy) | |
| { | |
| SCCOL nEndX = aLocalParam.nCol2; | |
| SCROW nEndY = aLocalParam.nRow2; | |
| if (pDestData) | |
| { | |
| if ( aOldDest.aEnd.Col() > nEndX ) | |
| nEndX = aOldDest.aEnd.Col(); | |
| if ( aOldDest.aEnd.Row() > nEndY ) | |
| nEndY = aOldDest.aEnd.Row(); | |
| } | |
| if (bDoSize) | |
| nEndY = MAXROW; | |
| rDocShell.PostPaint( aLocalParam.nCol1, aLocalParam.nRow1, nDestTab, | |
| nEndX, nEndY, nDestTab, PAINT_GRID ); | |
| } | |
| else | |
| rDocShell.PostPaint( 0, rQueryParam.nRow1, nTab, MAXCOL, MAXROW, nTab, | |
| PAINT_GRID | PAINT_LEFT ); | |
| aModificator.SetDocumentModified(); | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------- | |
| sal_Bool ScDBDocFunc::DoSubTotals( SCTAB nTab, const ScSubTotalParam& rParam, | |
| const ScSortParam* pForceNewSort, sal_Bool bRecord, sal_Bool bApi ) | |
| { | |
| //! auch fuer ScDBFunc::DoSubTotals benutzen! | |
| // dann bleibt aussen: | |
| // - neuen Bereich (aus DBData) markieren | |
| // - SelectionChanged (?) | |
| sal_Bool bDo = !rParam.bRemoveOnly; // sal_False = nur loeschen | |
| sal_Bool bRet = sal_False; | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| if (bRecord && !pDoc->IsUndoEnabled()) | |
| bRecord = sal_False; | |
| ScDBData* pDBData = pDoc->GetDBAtArea( nTab, rParam.nCol1, rParam.nRow1, | |
| rParam.nCol2, rParam.nRow2 ); | |
| if (!pDBData) | |
| { | |
| DBG_ERROR( "SubTotals: keine DBData" ); | |
| return sal_False; | |
| } | |
| ScEditableTester aTester( pDoc, nTab, 0,rParam.nRow1+1, MAXCOL,MAXROW ); | |
| if (!aTester.IsEditable()) | |
| { | |
| if (!bApi) | |
| rDocShell.ErrorMessage(aTester.GetMessageId()); | |
| return sal_False; | |
| } | |
| if (pDoc->HasAttrib( rParam.nCol1, rParam.nRow1+1, nTab, | |
| rParam.nCol2, rParam.nRow2, nTab, HASATTR_MERGED | HASATTR_OVERLAPPED )) | |
| { | |
| if (!bApi) | |
| rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0); // nicht in zusammengefasste einfuegen | |
| return sal_False; | |
| } | |
| sal_Bool bOk = sal_True; | |
| sal_Bool bDelete = sal_False; | |
| if (rParam.bReplace) | |
| if (pDoc->TestRemoveSubTotals( nTab, rParam )) | |
| { | |
| bDelete = sal_True; | |
| bOk = ( MessBox( rDocShell.GetActiveDialogParent(), WinBits(WB_YES_NO | WB_DEF_YES), | |
| // "StarCalc" "Daten loeschen?" | |
| ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ), | |
| ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_1 ) ).Execute() | |
| == RET_YES ); | |
| } | |
| if (bOk) | |
| { | |
| WaitObject aWait( rDocShell.GetActiveDialogParent() ); | |
| ScDocShellModificator aModificator( rDocShell ); | |
| ScSubTotalParam aNewParam( rParam ); // Bereichsende wird veraendert | |
| ScDocument* pUndoDoc = NULL; | |
| ScOutlineTable* pUndoTab = NULL; | |
| ScRangeName* pUndoRange = NULL; | |
| ScDBCollection* pUndoDB = NULL; | |
| SCTAB nTabCount = 0; // fuer Referenz-Undo | |
| if (bRecord) // alte Daten sichern | |
| { | |
| sal_Bool bOldFilter = bDo && rParam.bDoSort; | |
| nTabCount = pDoc->GetTableCount(); | |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab ); | |
| if (pTable) | |
| { | |
| pUndoTab = new ScOutlineTable( *pTable ); | |
| // column/row state | |
| SCCOLROW nOutStartCol, nOutEndCol; | |
| SCCOLROW nOutStartRow, nOutEndRow; | |
| pTable->GetColArray()->GetRange( nOutStartCol, nOutEndCol ); | |
| pTable->GetRowArray()->GetRange( nOutStartRow, nOutEndRow ); | |
| pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True ); | |
| pDoc->CopyToDocument( static_cast<SCCOL>(nOutStartCol), 0, nTab, static_cast<SCCOL>(nOutEndCol), MAXROW, nTab, IDF_NONE, sal_False, pUndoDoc ); | |
| pDoc->CopyToDocument( 0, nOutStartRow, nTab, MAXCOL, nOutEndRow, nTab, IDF_NONE, sal_False, pUndoDoc ); | |
| } | |
| else | |
| pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_False, bOldFilter ); | |
| // Datenbereich sichern - incl. Filter-Ergebnis | |
| pDoc->CopyToDocument( 0,rParam.nRow1+1,nTab, MAXCOL,rParam.nRow2,nTab, | |
| IDF_ALL, sal_False, pUndoDoc ); | |
| // alle Formeln wegen Referenzen | |
| pDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, | |
| IDF_FORMULA, sal_False, pUndoDoc ); | |
| // DB- und andere Bereiche | |
| ScRangeName* pDocRange = pDoc->GetRangeName(); | |
| if (pDocRange->GetCount()) | |
| pUndoRange = new ScRangeName( *pDocRange ); | |
| ScDBCollection* pDocDB = pDoc->GetDBCollection(); | |
| if (pDocDB->GetCount()) | |
| pUndoDB = new ScDBCollection( *pDocDB ); | |
| } | |
| // pDoc->SetOutlineTable( nTab, NULL ); | |
| ScOutlineTable* pOut = pDoc->GetOutlineTable( nTab ); | |
| if (pOut) | |
| pOut->GetRowArray()->RemoveAll(); // nur Zeilen-Outlines loeschen | |
| if (rParam.bReplace) | |
| pDoc->RemoveSubTotals( nTab, aNewParam ); | |
| sal_Bool bSuccess = sal_True; | |
| if (bDo) | |
| { | |
| // Sortieren | |
| if ( rParam.bDoSort || pForceNewSort ) | |
| { | |
| pDBData->SetArea( nTab, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 ); | |
| // Teilergebnis-Felder vor die Sortierung setzen | |
| // (doppelte werden weggelassen, kann darum auch wieder aufgerufen werden) | |
| ScSortParam aOldSort; | |
| pDBData->GetSortParam( aOldSort ); | |
| ScSortParam aSortParam( aNewParam, pForceNewSort ? *pForceNewSort : aOldSort ); | |
| Sort( nTab, aSortParam, sal_False, sal_False, bApi ); | |
| } | |
| bSuccess = pDoc->DoSubTotals( nTab, aNewParam ); | |
| } | |
| ScRange aDirtyRange( aNewParam.nCol1, aNewParam.nRow1, nTab, | |
| aNewParam.nCol2, aNewParam.nRow2, nTab ); | |
| pDoc->SetDirty( aDirtyRange ); | |
| if (bRecord) | |
| { | |
| // ScDBData* pUndoDBData = pDBData ? new ScDBData( *pDBData ) : NULL; | |
| rDocShell.GetUndoManager()->AddUndoAction( | |
| new ScUndoSubTotals( &rDocShell, nTab, | |
| rParam, aNewParam.nRow2, | |
| pUndoDoc, pUndoTab, // pUndoDBData, | |
| pUndoRange, pUndoDB ) ); | |
| } | |
| if (!bSuccess) | |
| { | |
| // "Kann keine Zeilen einfuegen" | |
| if (!bApi) | |
| rDocShell.ErrorMessage(STR_MSSG_DOSUBTOTALS_2); | |
| } | |
| // merken | |
| pDBData->SetSubTotalParam( aNewParam ); | |
| pDBData->SetArea( nTab, aNewParam.nCol1,aNewParam.nRow1, aNewParam.nCol2,aNewParam.nRow2 ); | |
| pDoc->CompileDBFormula(); | |
| rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, | |
| PAINT_GRID | PAINT_LEFT | PAINT_TOP | PAINT_SIZE ); | |
| aModificator.SetDocumentModified(); | |
| bRet = bSuccess; | |
| } | |
| return bRet; | |
| } | |
| //================================================================== | |
| sal_Bool lcl_EmptyExcept( ScDocument* pDoc, const ScRange& rRange, const ScRange& rExcept ) | |
| { | |
| ScCellIterator aIter( pDoc, rRange ); | |
| ScBaseCell* pCell = aIter.GetFirst(); | |
| while (pCell) | |
| { | |
| if ( !pCell->IsBlank() ) // real content? | |
| { | |
| if ( !rExcept.In( ScAddress( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ) ) ) | |
| return sal_False; // cell found | |
| } | |
| pCell = aIter.GetNext(); | |
| } | |
| return sal_True; // nothing found - empty | |
| } | |
| sal_Bool ScDBDocFunc::DataPilotUpdate( ScDPObject* pOldObj, const ScDPObject* pNewObj, | |
| sal_Bool bRecord, sal_Bool bApi, sal_Bool bAllowMove ) | |
| { | |
| ScDocShellModificator aModificator( rDocShell ); | |
| WaitObject aWait( rDocShell.GetActiveDialogParent() ); | |
| sal_Bool bDone = sal_False; | |
| sal_Bool bUndoSelf = sal_False; | |
| sal_uInt16 nErrId = 0; | |
| ScDocument* pOldUndoDoc = NULL; | |
| ScDocument* pNewUndoDoc = NULL; | |
| ScDPObject* pUndoDPObj = NULL; | |
| if ( bRecord && pOldObj ) | |
| pUndoDPObj = new ScDPObject( *pOldObj ); // copy old settings for undo | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| if (bRecord && !pDoc->IsUndoEnabled()) | |
| bRecord = sal_False; | |
| if ( !rDocShell.IsEditable() || pDoc->GetChangeTrack() ) | |
| { | |
| // not recorded -> disallow | |
| //! different error messages? | |
| nErrId = STR_PROTECTIONERR; | |
| } | |
| if ( pOldObj && !nErrId ) | |
| { | |
| ScRange aOldOut = pOldObj->GetOutRange(); | |
| ScEditableTester aTester( pDoc, aOldOut ); | |
| if ( !aTester.IsEditable() ) | |
| nErrId = aTester.GetMessageId(); | |
| } | |
| if ( pNewObj && !nErrId ) | |
| { | |
| // at least one cell at the output position must be editable | |
| // -> check in advance | |
| // (start of output range in pNewObj is valid) | |
| ScRange aNewStart( pNewObj->GetOutRange().aStart ); | |
| ScEditableTester aTester( pDoc, aNewStart ); | |
| if ( !aTester.IsEditable() ) | |
| nErrId = aTester.GetMessageId(); | |
| } | |
| ScDPObject* pDestObj = NULL; | |
| if ( !nErrId ) | |
| { | |
| if ( pOldObj && !pNewObj ) | |
| { | |
| // delete table | |
| ScRange aRange = pOldObj->GetOutRange(); | |
| SCTAB nTab = aRange.aStart.Tab(); | |
| if ( bRecord ) | |
| { | |
| pOldUndoDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| pOldUndoDoc->InitUndo( pDoc, nTab, nTab ); | |
| pDoc->CopyToDocument( aRange, IDF_ALL, sal_False, pOldUndoDoc ); | |
| } | |
| pDoc->DeleteAreaTab( aRange.aStart.Col(), aRange.aStart.Row(), | |
| aRange.aEnd.Col(), aRange.aEnd.Row(), | |
| nTab, IDF_ALL ); | |
| pDoc->RemoveFlagsTab( aRange.aStart.Col(), aRange.aStart.Row(), | |
| aRange.aEnd.Col(), aRange.aEnd.Row(), | |
| nTab, SC_MF_AUTO ); | |
| pDoc->GetDPCollection()->FreeTable( pOldObj ); // object is deleted here | |
| rDocShell.PostPaintGridAll(); //! only necessary parts | |
| rDocShell.PostPaint( aRange.aStart.Col(), aRange.aStart.Row(), nTab, | |
| aRange.aEnd.Col(), aRange.aEnd.Row(), nTab, | |
| PAINT_GRID ); | |
| bDone = sal_True; | |
| } | |
| else if ( pNewObj ) | |
| { | |
| if ( pOldObj ) | |
| { | |
| if ( bRecord ) | |
| { | |
| ScRange aRange = pOldObj->GetOutRange(); | |
| SCTAB nTab = aRange.aStart.Tab(); | |
| pOldUndoDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| pOldUndoDoc->InitUndo( pDoc, nTab, nTab ); | |
| pDoc->CopyToDocument( aRange, IDF_ALL, sal_False, pOldUndoDoc ); | |
| } | |
| if ( pNewObj == pOldObj ) | |
| { | |
| // refresh only - no settings modified | |
| } | |
| else | |
| { | |
| pNewObj->WriteSourceDataTo( *pOldObj ); // copy source data | |
| ScDPSaveData* pData = pNewObj->GetSaveData(); | |
| DBG_ASSERT( pData, "no SaveData from living DPObject" ); | |
| if ( pData ) | |
| pOldObj->SetSaveData( *pData ); // copy SaveData | |
| } | |
| pDestObj = pOldObj; | |
| pDestObj->SetAllowMove( bAllowMove ); | |
| } | |
| else | |
| { | |
| // output range must be set at pNewObj | |
| pDestObj = new ScDPObject( *pNewObj ); | |
| // #i94570# When changing the output position in the dialog, a new table is created | |
| // with the settings from the old table, including the name. | |
| // So we have to check for duplicate names here (before inserting). | |
| if ( pDoc->GetDPCollection()->GetByName(pDestObj->GetName()) ) | |
| pDestObj->SetName( String() ); // ignore the invalid name, create a new name below | |
| pDestObj->SetAlive(sal_True); | |
| if ( !pDoc->GetDPCollection()->InsertNewTable(pDestObj) ) | |
| { | |
| DBG_ERROR("cannot insert DPObject"); | |
| DELETEZ( pDestObj ); | |
| } | |
| } | |
| if ( pDestObj ) | |
| { | |
| // #78541# create new database connection for "refresh" | |
| // (and re-read column entry collections) | |
| // so all changes take effect | |
| if ( pNewObj == pOldObj && pDestObj->IsImportData() ) | |
| pDestObj->InvalidateSource(); | |
| pDestObj->InvalidateData(); // before getting the new output area | |
| // make sure the table has a name (not set by dialog) | |
| if ( !pDestObj->GetName().Len() ) | |
| pDestObj->SetName( pDoc->GetDPCollection()->CreateNewName() ); | |
| sal_Bool bOverflow = sal_False; | |
| ScRange aNewOut = pDestObj->GetNewOutputRange( bOverflow ); | |
| //! test for overlap with other data pilot tables | |
| if( pOldObj ) | |
| { | |
| const ScSheetSourceDesc* pSheetDesc = pOldObj->GetSheetDesc(); | |
| if( pSheetDesc && pSheetDesc->aSourceRange.Intersects( aNewOut ) ) | |
| { | |
| ScRange aOldRange = pOldObj->GetOutRange(); | |
| SCsROW nDiff = aOldRange.aStart.Row()-aNewOut.aStart.Row(); | |
| aNewOut.aStart.SetRow( aOldRange.aStart.Row() ); | |
| aNewOut.aEnd.SetRow( aNewOut.aEnd.Row()+nDiff ); | |
| if( !ValidRow( aNewOut.aStart.Row() ) || !ValidRow( aNewOut.aEnd.Row() ) ) | |
| bOverflow = sal_True; | |
| } | |
| } | |
| if ( bOverflow ) | |
| { | |
| // like with STR_PROTECTIONERR, use undo to reverse everything | |
| DBG_ASSERT( bRecord, "DataPilotUpdate: can't undo" ); | |
| bUndoSelf = sal_True; | |
| nErrId = STR_PIVOT_ERROR; | |
| } | |
| else | |
| { | |
| ScEditableTester aTester( pDoc, aNewOut ); | |
| if ( !aTester.IsEditable() ) | |
| { | |
| // destination area isn't editable | |
| //! reverse everything done so far, don't proceed | |
| // quick solution: proceed to end, use undo action | |
| // to reverse everything: | |
| DBG_ASSERT( bRecord, "DataPilotUpdate: can't undo" ); | |
| bUndoSelf = sal_True; | |
| nErrId = aTester.GetMessageId(); | |
| } | |
| } | |
| // test if new output area is empty except for old area | |
| if ( !bApi ) | |
| { | |
| sal_Bool bEmpty; | |
| if ( pOldObj ) // OutRange of pOldObj (pDestObj) is still old area | |
| bEmpty = lcl_EmptyExcept( pDoc, aNewOut, pOldObj->GetOutRange() ); | |
| else | |
| bEmpty = pDoc->IsBlockEmpty( aNewOut.aStart.Tab(), | |
| aNewOut.aStart.Col(), aNewOut.aStart.Row(), | |
| aNewOut.aEnd.Col(), aNewOut.aEnd.Row() ); | |
| if ( !bEmpty ) | |
| { | |
| QueryBox aBox( rDocShell.GetActiveDialogParent(), WinBits(WB_YES_NO | WB_DEF_YES), | |
| ScGlobal::GetRscString(STR_PIVOT_NOTEMPTY) ); | |
| if (aBox.Execute() == RET_NO) | |
| { | |
| //! like above (not editable), use undo to reverse everything | |
| DBG_ASSERT( bRecord, "DataPilotUpdate: can't undo" ); | |
| bUndoSelf = sal_True; | |
| } | |
| } | |
| } | |
| if ( bRecord ) | |
| { | |
| SCTAB nTab = aNewOut.aStart.Tab(); | |
| pNewUndoDoc = new ScDocument( SCDOCMODE_UNDO ); | |
| pNewUndoDoc->InitUndo( pDoc, nTab, nTab ); | |
| pDoc->CopyToDocument( aNewOut, IDF_ALL, sal_False, pNewUndoDoc ); | |
| } | |
| pDestObj->Output( aNewOut.aStart ); | |
| rDocShell.PostPaintGridAll(); //! only necessary parts | |
| bDone = sal_True; | |
| } | |
| } | |
| // else nothing (no old, no new) | |
| } | |
| if ( bRecord && bDone ) | |
| { | |
| SfxUndoAction* pAction = new ScUndoDataPilot( &rDocShell, | |
| pOldUndoDoc, pNewUndoDoc, pUndoDPObj, pDestObj, bAllowMove ); | |
| pOldUndoDoc = NULL; | |
| pNewUndoDoc = NULL; // pointers are used in undo action | |
| // pUndoDPObj is copied | |
| if (bUndoSelf) | |
| { | |
| // use undo action to restore original state | |
| //! prevent setting the document modified? (ScDocShellModificator) | |
| pAction->Undo(); | |
| delete pAction; | |
| bDone = sal_False; | |
| } | |
| else | |
| rDocShell.GetUndoManager()->AddUndoAction( pAction ); | |
| } | |
| delete pOldUndoDoc; // if not used for undo | |
| delete pNewUndoDoc; | |
| delete pUndoDPObj; | |
| if (bDone) | |
| { | |
| // notify API objects | |
| if (pDestObj) | |
| pDoc->BroadcastUno( ScDataPilotModifiedHint( pDestObj->GetName() ) ); | |
| aModificator.SetDocumentModified(); | |
| } | |
| if ( nErrId && !bApi ) | |
| rDocShell.ErrorMessage( nErrId ); | |
| return bDone; | |
| } | |
| //================================================================== | |
| // | |
| // database import | |
| void ScDBDocFunc::UpdateImport( const String& rTarget, const svx::ODataAccessDescriptor& rDescriptor ) | |
| { | |
| // rTarget is the name of a database range | |
| ScDocument* pDoc = rDocShell.GetDocument(); | |
| ScDBCollection& rDBColl = *pDoc->GetDBCollection(); | |
| ScDBData* pData = NULL; | |
| ScImportParam aImportParam; | |
| sal_Bool bFound = sal_False; | |
| sal_uInt16 nCount = rDBColl.GetCount(); | |
| for (sal_uInt16 i=0; i<nCount && !bFound; i++) | |
| { | |
| pData = rDBColl[i]; | |
| if (pData->GetName() == rTarget) | |
| bFound = sal_True; | |
| } | |
| if (!bFound) | |
| { | |
| InfoBox aInfoBox(rDocShell.GetActiveDialogParent(), | |
| ScGlobal::GetRscString( STR_TARGETNOTFOUND ) ); | |
| aInfoBox.Execute(); | |
| return; | |
| } | |
| SCTAB nTab; | |
| SCCOL nDummyCol; | |
| SCROW nDummyRow; | |
| pData->GetArea( nTab, nDummyCol,nDummyRow,nDummyCol,nDummyRow ); | |
| pData->GetImportParam( aImportParam ); | |
| rtl::OUString sDBName; | |
| rtl::OUString sDBTable; | |
| sal_Int32 nCommandType = 0; | |
| rDescriptor[svx::daDataSource] >>= sDBName; | |
| rDescriptor[svx::daCommand] >>= sDBTable; | |
| rDescriptor[svx::daCommandType] >>= nCommandType; | |
| aImportParam.aDBName = sDBName; | |
| aImportParam.bSql = ( nCommandType == sdb::CommandType::COMMAND ); | |
| aImportParam.aStatement = sDBTable; | |
| aImportParam.bNative = sal_False; | |
| aImportParam.nType = static_cast<sal_uInt8>( ( nCommandType == sdb::CommandType::QUERY ) ? ScDbQuery : ScDbTable ); | |
| aImportParam.bImport = sal_True; | |
| sal_Bool bContinue = DoImport( nTab, aImportParam, &rDescriptor, sal_True ); | |
| // DB-Operationen wiederholen | |
| ScTabViewShell* pViewSh = rDocShell.GetBestViewShell(); | |
| if (pViewSh) | |
| { | |
| ScRange aRange; | |
| pData->GetArea(aRange); | |
| pViewSh->MarkRange(aRange); // selektieren | |
| if ( bContinue ) // #41905# Fehler beim Import -> Abbruch | |
| { | |
| // interne Operationen, wenn welche gespeichert | |
| if ( pData->HasQueryParam() || pData->HasSortParam() || pData->HasSubTotalParam() ) | |
| pViewSh->RepeatDB(); | |
| // Pivottabellen die den Bereich als Quelldaten haben | |
| rDocShell.RefreshPivotTables(aRange); | |
| } | |
| } | |
| } |