/************************************************************** * * 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 "scitems.hxx" #include #include #define _SVSTDARR_STRINGS #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "viewfunc.hxx" #include "sc.hrc" #include "globstr.hrc" #include "attrib.hxx" #include "autoform.hxx" #include "cell.hxx" // EnterAutoSum #include "compiler.hxx" #include "docfunc.hxx" #include "docpool.hxx" #include "docsh.hxx" #include "global.hxx" #include "patattr.hxx" #include "printfun.hxx" #include "rangenam.hxx" #include "rangeutl.hxx" #include "refundo.hxx" #include "tablink.hxx" #include "tabvwsh.hxx" #include "uiitems.hxx" #include "undoblk.hxx" #include "undocell.hxx" #include "undotab.hxx" #include "sizedev.hxx" #include "editable.hxx" #include "scmod.hxx" #include "inputhdl.hxx" #include "inputwin.hxx" #include "funcdesc.hxx" #include "docuno.hxx" #include "charthelper.hxx" #include "tabbgcolor.hxx" #include #include #include using namespace com::sun::star; // helper func defined in docfunc.cxx void VBA_DeleteModule( ScDocShell& rDocSh, String& sModuleName ); // STATIC DATA --------------------------------------------------------------- //---------------------------------------------------------------------------- sal_Bool ScViewFunc::AdjustBlockHeight( sal_Bool bPaint, ScMarkData* pMarkData ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); if (!pMarkData) pMarkData = &GetViewData()->GetMarkData(); ScDocument* pDoc = pDocSh->GetDocument(); SCCOLROW* pRanges = new SCCOLROW[MAXCOLROWCOUNT]; SCCOLROW nRangeCnt = pMarkData->GetMarkRowRanges( pRanges ); if (nRangeCnt == 0) { pRanges[0] = pRanges[1] = GetViewData()->GetCurY(); nRangeCnt = 1; } double nPPTX = GetViewData()->GetPPTX(); double nPPTY = GetViewData()->GetPPTY(); Fraction aZoomX = GetViewData()->GetZoomX(); Fraction aZoomY = GetViewData()->GetZoomY(); ScSizeDeviceProvider aProv(pDocSh); if (aProv.IsPrinter()) { nPPTX = aProv.GetPPTX(); nPPTY = aProv.GetPPTY(); aZoomX = aZoomY = Fraction( 1, 1 ); } sal_Bool bAnyChanged = sal_False; SCTAB nTabCount = pDoc->GetTableCount(); for (SCTAB nTab=0; nTabGetTableSelect(nTab)) { SCCOLROW* pOneRange = pRanges; sal_Bool bChanged = sal_False; SCROW nPaintY = 0; for (SCROW nRangeNo=0; nRangeNoSetOptimalHeight( nStartNo, nEndNo, nTab, 0, aProv.GetDevice(), nPPTX, nPPTY, aZoomX, aZoomY, sal_False )) { if (!bChanged) nPaintY = nStartNo; bAnyChanged = bChanged = sal_True; } } if ( bPaint && bChanged ) pDocSh->PostPaint( 0, nPaintY, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_LEFT ); } } delete[] pRanges; if ( bPaint && bAnyChanged ) pDocSh->UpdateOle(GetViewData()); return bAnyChanged; } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::AdjustRowHeight( SCROW nStartRow, SCROW nEndRow, sal_Bool bPaint ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); SCTAB nTab = GetViewData()->GetTabNo(); double nPPTX = GetViewData()->GetPPTX(); double nPPTY = GetViewData()->GetPPTY(); Fraction aZoomX = GetViewData()->GetZoomX(); Fraction aZoomY = GetViewData()->GetZoomY(); sal_uInt16 nOldPixel = 0; if (nStartRow == nEndRow) nOldPixel = (sal_uInt16) (pDoc->GetRowHeight(nStartRow,nTab) * nPPTY); ScSizeDeviceProvider aProv(pDocSh); if (aProv.IsPrinter()) { nPPTX = aProv.GetPPTX(); nPPTY = aProv.GetPPTY(); aZoomX = aZoomY = Fraction( 1, 1 ); } sal_Bool bChanged = pDoc->SetOptimalHeight( nStartRow, nEndRow, nTab, 0, aProv.GetDevice(), nPPTX, nPPTY, aZoomX, aZoomY, sal_False ); if (bChanged && ( nStartRow == nEndRow )) { sal_uInt16 nNewPixel = (sal_uInt16) (pDoc->GetRowHeight(nStartRow,nTab) * nPPTY); if ( nNewPixel == nOldPixel ) bChanged = sal_False; } if ( bPaint && bChanged ) pDocSh->PostPaint( 0, nStartRow, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_LEFT ); return bChanged; } //---------------------------------------------------------------------------- enum ScAutoSum { ScAutoSumNone = 0, ScAutoSumData, ScAutoSumSum }; ScAutoSum lcl_IsAutoSumData( ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, ScDirection eDir, SCCOLROW& nExtend ) { ScBaseCell* pCell; pDoc->GetCell( nCol, nRow, nTab, pCell ); if ( pCell && pCell->HasValueData() ) { if ( pCell->GetCellType() == CELLTYPE_FORMULA ) { ScTokenArray* pCode = ((ScFormulaCell*)pCell)->GetCode(); if ( pCode && pCode->GetOuterFuncOpCode() == ocSum ) { if ( pCode->GetAdjacentExtendOfOuterFuncRefs( nExtend, ScAddress( nCol, nRow, nTab ), eDir ) ) return ScAutoSumSum; } } return ScAutoSumData; } return ScAutoSumNone; } //---------------------------------------------------------------------------- #define SC_AUTOSUM_MAXCOUNT 20 ScAutoSum lcl_SeekAutoSumData( ScDocument* pDoc, SCCOL& nCol, SCROW& nRow, SCTAB nTab, ScDirection eDir, SCCOLROW& nExtend ) { sal_uInt16 nCount = 0; while (nCount < SC_AUTOSUM_MAXCOUNT) { if ( eDir == DIR_TOP ) { if (nRow > 0) --nRow; else return ScAutoSumNone; } else { if (nCol > 0) --nCol; else return ScAutoSumNone; } ScAutoSum eSum; if ( (eSum = lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, eDir, nExtend )) != ScAutoSumNone ) return eSum; ++nCount; } return ScAutoSumNone; } #undef SC_AUTOSUM_MAXCOUNT //---------------------------------------------------------------------------- bool lcl_FindNextSumEntryInColumn( ScDocument* pDoc, SCCOL nCol, SCROW& nRow, SCTAB nTab, SCCOLROW& nExtend, SCROW nMinRow ) { const SCROW nTmp = nRow; ScAutoSum eSkip = ScAutoSumNone; while ( ( eSkip = lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_TOP, nExtend ) ) == ScAutoSumData && nRow > nMinRow ) { --nRow; } if ( eSkip == ScAutoSumSum && nRow < nTmp ) { return true; } return false; } //---------------------------------------------------------------------------- bool lcl_FindNextSumEntryInRow( ScDocument* pDoc, SCCOL& nCol, SCROW nRow, SCTAB nTab, SCCOLROW& nExtend, SCROW nMinCol ) { const SCCOL nTmp = nCol; ScAutoSum eSkip = ScAutoSumNone; while ( ( eSkip = lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_LEFT, nExtend ) ) == ScAutoSumData && nCol > nMinCol ) { --nCol; } if ( eSkip == ScAutoSumSum && nCol < nTmp ) { return true; } return false; } //---------------------------------------------------------------------------- bool lcl_GetAutoSumForColumnRange( ScDocument* pDoc, ScRangeList& rRangeList, const ScRange& rRange ) { const ScAddress aStart = rRange.aStart; const ScAddress aEnd = rRange.aEnd; if ( aStart.Col() != aEnd.Col() ) { return false; } const SCTAB nTab = aEnd.Tab(); const SCCOL nCol = aEnd.Col(); SCROW nEndRow = aEnd.Row(); SCROW nStartRow = nEndRow; SCCOLROW nExtend = 0; const ScAutoSum eSum = lcl_IsAutoSumData( pDoc, nCol, nEndRow, nTab, DIR_TOP, nExtend /*out*/ ); if ( eSum == ScAutoSumSum ) { bool bContinue = false; do { rRangeList.Append( ScRange( nCol, nStartRow, nTab, nCol, nEndRow, nTab ) ); nEndRow = static_cast< SCROW >( nExtend ); if ( ( bContinue = lcl_FindNextSumEntryInColumn( pDoc, nCol, nEndRow /*inout*/, nTab, nExtend /*out*/, aStart.Row() ) ) == true ) { nStartRow = nEndRow; } } while ( bContinue ); } else { while ( nStartRow > aStart.Row() && lcl_IsAutoSumData( pDoc, nCol, nStartRow-1, nTab, DIR_TOP, nExtend /*out*/ ) != ScAutoSumSum ) { --nStartRow; } rRangeList.Append( ScRange( nCol, nStartRow, nTab, nCol, nEndRow, nTab ) ); } return true; } //---------------------------------------------------------------------------- bool lcl_GetAutoSumForRowRange( ScDocument* pDoc, ScRangeList& rRangeList, const ScRange& rRange ) { const ScAddress aStart = rRange.aStart; const ScAddress aEnd = rRange.aEnd; if ( aStart.Row() != aEnd.Row() ) { return false; } const SCTAB nTab = aEnd.Tab(); const SCROW nRow = aEnd.Row(); SCCOL nEndCol = aEnd.Col(); SCCOL nStartCol = nEndCol; SCCOLROW nExtend = 0; const ScAutoSum eSum = lcl_IsAutoSumData( pDoc, nEndCol, nRow, nTab, DIR_LEFT, nExtend /*out*/ ); if ( eSum == ScAutoSumSum ) { bool bContinue = false; do { rRangeList.Append( ScRange( nStartCol, nRow, nTab, nEndCol, nRow, nTab ) ); nEndCol = static_cast< SCCOL >( nExtend ); if ( ( bContinue = lcl_FindNextSumEntryInRow( pDoc, nEndCol /*inout*/, nRow, nTab, nExtend /*out*/, aStart.Col() ) ) == true ) { nStartCol = nEndCol; } } while ( bContinue ); } else { while ( nStartCol > aStart.Col() && lcl_IsAutoSumData( pDoc, nStartCol-1, nRow, nTab, DIR_LEFT, nExtend /*out*/ ) != ScAutoSumSum ) { --nStartCol; } rRangeList.Append( ScRange( nStartCol, nRow, nTab, nEndCol, nRow, nTab ) ); } return true; } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::GetAutoSumArea( ScRangeList& rRangeList ) { ScDocument* pDoc = GetViewData()->GetDocument(); SCTAB nTab = GetViewData()->GetTabNo(); SCCOL nCol = GetViewData()->GetCurX(); SCROW nRow = GetViewData()->GetCurY(); SCCOL nStartCol = nCol; SCROW nStartRow = nRow; SCCOL nEndCol = nCol; SCROW nEndRow = nRow; SCCOL nSeekCol = nCol; SCROW nSeekRow = nRow; SCCOLROW nExtend; // wird per Reference gueltig bei ScAutoSumSum sal_Bool bCol = sal_False; sal_Bool bRow = sal_False; ScAutoSum eSum; if ( nRow != 0 && ((eSum = lcl_IsAutoSumData( pDoc, nCol, nRow-1, nTab, DIR_TOP, nExtend /*out*/ )) == ScAutoSumData ) && ((eSum = lcl_IsAutoSumData( pDoc, nCol, nRow-1, nTab, DIR_LEFT, nExtend /*out*/ )) == ScAutoSumData ) ) { bRow = sal_True; nSeekRow = nRow - 1; } else if ( nCol != 0 && (eSum = lcl_IsAutoSumData( pDoc, nCol-1, nRow, nTab, DIR_LEFT, nExtend /*out*/ )) == ScAutoSumData ) { bCol = sal_True; nSeekCol = nCol - 1; } else if ( (eSum = lcl_SeekAutoSumData( pDoc, nCol, nSeekRow, nTab, DIR_TOP, nExtend /*out*/ )) != ScAutoSumNone ) bRow = sal_True; else if (( eSum = lcl_SeekAutoSumData( pDoc, nSeekCol, nRow, nTab, DIR_LEFT, nExtend /*out*/ )) != ScAutoSumNone ) bCol = sal_True; if ( bCol || bRow ) { if ( bRow ) { nStartRow = nSeekRow; // nSeekRow evtl. per Reference angepasst if ( eSum == ScAutoSumSum ) nEndRow = nStartRow; // nur Summen summieren else nEndRow = nRow - 1; // Datenbereich evtl. nach unten erweitern } else { nStartCol = nSeekCol; // nSeekCol evtl. per Reference angepasst if ( eSum == ScAutoSumSum ) nEndCol = nStartCol; // nur Summen summieren else nEndCol = nCol - 1; // Datenbereich evtl. nach rechts erweitern } sal_Bool bContinue = sal_False; do { if ( eSum == ScAutoSumData ) { if ( bRow ) { while ( nStartRow != 0 && lcl_IsAutoSumData( pDoc, nCol, nStartRow-1, nTab, DIR_TOP, nExtend /*out*/ ) == eSum ) --nStartRow; } else { while ( nStartCol != 0 && lcl_IsAutoSumData( pDoc, nStartCol-1, nRow, nTab, DIR_LEFT, nExtend /*out*/ ) == eSum ) --nStartCol; } } rRangeList.Append( ScRange( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab ) ); if ( eSum == ScAutoSumSum ) { if ( bRow ) { nEndRow = static_cast< SCROW >( nExtend ); if ( ( bContinue = lcl_FindNextSumEntryInColumn( pDoc, nCol, nEndRow /*inout*/, nTab, nExtend /*out*/, 0 ) ) == true ) { nStartRow = nEndRow; } } else { nEndCol = static_cast< SCCOL >( nExtend ); if ( ( bContinue = lcl_FindNextSumEntryInRow( pDoc, nEndCol /*inout*/, nRow, nTab, nExtend /*out*/, 0 ) ) == true ) { nStartCol = nEndCol; } } } } while ( bContinue ); return sal_True; } return sal_False; } //---------------------------------------------------------------------------- void ScViewFunc::EnterAutoSum(const ScRangeList& rRangeList, sal_Bool bSubTotal) // Block mit Summen fuellen { String aFormula = GetAutoSumFormula( rRangeList, bSubTotal ); EnterBlock( aFormula, NULL ); } //---------------------------------------------------------------------------- bool ScViewFunc::AutoSum( const ScRange& rRange, bool bSubTotal, bool bSetCursor, bool bContinue ) { ScDocument* pDoc = GetViewData()->GetDocument(); const SCTAB nTab = rRange.aStart.Tab(); SCCOL nStartCol = rRange.aStart.Col(); SCROW nStartRow = rRange.aStart.Row(); const SCCOL nEndCol = rRange.aEnd.Col(); const SCROW nEndRow = rRange.aEnd.Row(); SCCOLROW nExtend = 0; // out parameter for lcl_IsAutoSumData // ignore rows at the top of the given range which don't contain autosum data bool bRowData = false; for ( SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow ) { for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol ) { if ( lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_TOP, nExtend ) != ScAutoSumNone ) { bRowData = true; break; } } if ( bRowData ) { nStartRow = nRow; break; } } if ( !bRowData ) { return false; } // ignore columns at the left of the given range which don't contain autosum data bool bColData = false; for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol ) { for ( SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow ) { if ( lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_LEFT, nExtend ) != ScAutoSumNone ) { bColData = true; break; } } if ( bColData ) { nStartCol = nCol; break; } } if ( !bColData ) { return false; } const bool bEndRowEmpty = pDoc->IsBlockEmpty( nTab, nStartCol, nEndRow, nEndCol, nEndRow ); const bool bEndColEmpty = pDoc->IsBlockEmpty( nTab, nEndCol, nStartRow, nEndCol, nEndRow ); bool bRow = ( ( nStartRow != nEndRow ) && ( bEndRowEmpty || ( !bEndRowEmpty && !bEndColEmpty ) ) ); bool bCol = ( ( nStartCol != nEndCol ) && ( bEndColEmpty || nStartRow == nEndRow ) ); // find an empty row for entering the result SCROW nInsRow = nEndRow; if ( bRow && !bEndRowEmpty ) { if ( nInsRow < MAXROW ) { ++nInsRow; while ( !pDoc->IsBlockEmpty( nTab, nStartCol, nInsRow, nEndCol, nInsRow ) ) { if ( nInsRow < MAXROW ) { ++nInsRow; } else { bRow = false; break; } } } else { bRow = false; } } // find an empty column for entering the result SCCOL nInsCol = nEndCol; if ( bCol && !bEndColEmpty ) { if ( nInsCol < MAXCOL ) { ++nInsCol; while ( !pDoc->IsBlockEmpty( nTab, nInsCol, nStartRow, nInsCol, nEndRow ) ) { if ( nInsCol < MAXCOL ) { ++nInsCol; } else { bCol = false; break; } } } else { bCol = false; } } if ( !bRow && !bCol ) { return false; } SCCOL nMarkEndCol = nEndCol; SCROW nMarkEndRow = nEndRow; if ( bRow ) { // calculate the row sums for all columns of the given range SCROW nSumEndRow = nEndRow; if ( bEndRowEmpty ) { // the last row of the given range is empty; // don't take into account for calculating the autosum --nSumEndRow; } else { // increase mark range ++nMarkEndRow; } for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol ) { if ( !pDoc->IsBlockEmpty( nTab, nCol, nStartRow, nCol, nSumEndRow ) ) { ScRangeList aRangeList; const ScRange aRange( nCol, nStartRow, nTab, nCol, nSumEndRow, nTab ); if ( lcl_GetAutoSumForColumnRange( pDoc, aRangeList, aRange ) ) { const String aFormula = GetAutoSumFormula( aRangeList, bSubTotal ); EnterData( nCol, nInsRow, nTab, aFormula ); } } } } if ( bCol ) { // calculate the column sums for all rows of the given range SCCOL nSumEndCol = nEndCol; if ( bEndColEmpty ) { // the last column of the given range is empty; // don't take into account for calculating the autosum --nSumEndCol; } else { // increase mark range ++nMarkEndCol; } for ( SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow ) { if ( !pDoc->IsBlockEmpty( nTab, nStartCol, nRow, nSumEndCol, nRow ) ) { ScRangeList aRangeList; const ScRange aRange( nStartCol, nRow, nTab, nSumEndCol, nRow, nTab ); if ( lcl_GetAutoSumForRowRange( pDoc, aRangeList, aRange ) ) { const String aFormula = GetAutoSumFormula( aRangeList, bSubTotal ); EnterData( nInsCol, nRow, nTab, aFormula ); } } } } // set new mark range and cursor position const ScRange aMarkRange( nStartCol, nStartRow, nTab, nMarkEndCol, nMarkEndRow, nTab ); MarkRange( aMarkRange, sal_False, bContinue ); if ( bSetCursor ) { SetCursor( nMarkEndCol, nMarkEndRow ); } return true; } //---------------------------------------------------------------------------- String ScViewFunc::GetAutoSumFormula( const ScRangeList& rRangeList, bool bSubTotal ) { String aFormula = '='; ScFunctionMgr* pFuncMgr = ScGlobal::GetStarCalcFunctionMgr(); const ScFuncDesc* pDesc = NULL; if ( bSubTotal ) { pDesc = pFuncMgr->Get( SC_OPCODE_SUB_TOTAL ); } else { pDesc = pFuncMgr->Get( SC_OPCODE_SUM ); } if ( pDesc && pDesc->pFuncName ) { aFormula += *pDesc->pFuncName; if ( bSubTotal ) { aFormula.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "(9;" ) ); } else { aFormula += '('; } ScDocument* pDoc = GetViewData()->GetDocument(); String aRef; rRangeList.Format( aRef, SCA_VALID, pDoc ); aFormula += aRef; aFormula += ')'; } return aFormula; } //---------------------------------------------------------------------------- void ScViewFunc::EnterBlock( const String& rString, const EditTextObject* pData ) { // Mehrfachselektion vorher abfragen... SCCOL nCol = GetViewData()->GetCurX(); SCROW nRow = GetViewData()->GetCurY(); SCTAB nTab = GetViewData()->GetTabNo(); ScMarkData& rMark = GetViewData()->GetMarkData(); if ( rMark.IsMultiMarked() ) { rMark.MarkToSimple(); if ( rMark.IsMultiMarked() ) { // "Einfuegen auf Mehrfachselektion nicht moeglich" ErrorMessage(STR_MSSG_PASTEFROMCLIP_0); // insert into single cell if ( pData ) EnterData( nCol, nRow, nTab, pData ); else EnterData( nCol, nRow, nTab, rString ); return; } } ScDocument* pDoc = GetViewData()->GetDocument(); String aNewStr = rString; if ( pData ) { const ScPatternAttr* pOldPattern = pDoc->GetPattern( nCol, nRow, nTab ); ScTabEditEngine aEngine( *pOldPattern, pDoc->GetEnginePool() ); aEngine.SetText(*pData); ScEditAttrTester aTester( &aEngine ); if (!aTester.NeedsObject()) { aNewStr = aEngine.GetText(); pData = NULL; } } // Einfuegen per PasteFromClip WaitObject aWait( GetFrameWin() ); ScAddress aPos( nCol, nRow, nTab ); ScDocument* pInsDoc = new ScDocument( SCDOCMODE_CLIP ); pInsDoc->ResetClip( pDoc, nTab ); if (aNewStr.GetChar(0) == '=') // Formel ? { // SetString geht nicht, weil in Clipboard-Dokumenten nicht kompiliert wird! ScFormulaCell* pFCell = new ScFormulaCell( pDoc, aPos, aNewStr ); pInsDoc->PutCell( nCol, nRow, nTab, pFCell ); } else if ( pData ) pInsDoc->PutCell( nCol, nRow, nTab, new ScEditCell( pData, pDoc, NULL ) ); else pInsDoc->SetString( nCol, nRow, nTab, aNewStr ); pInsDoc->SetClipArea( ScRange(aPos) ); // auf Block einfuegen, mit Undo etc. if ( PasteFromClip( IDF_CONTENTS, pInsDoc, PASTE_NOFUNC, sal_False, sal_False, sal_False, INS_NONE, IDF_ATTRIB ) ) { const SfxUInt32Item* pItem = (SfxUInt32Item*) pInsDoc->GetAttr( nCol, nRow, nTab, ATTR_VALUE_FORMAT ); if ( pItem ) { // Numberformat setzen wenn inkompatibel // MarkData wurde bereits in PasteFromClip MarkToSimple'ed ScRange aRange; rMark.GetMarkArea( aRange ); ScPatternAttr* pPattern = new ScPatternAttr( pDoc->GetPool() ); pPattern->GetItemSet().Put( *pItem ); short nNewType = pDoc->GetFormatTable()->GetType( pItem->GetValue() ); pDoc->ApplyPatternIfNumberformatIncompatible( aRange, rMark, *pPattern, nNewType ); delete pPattern; } } delete pInsDoc; } //---------------------------------------------------------------------------- //UNUSED2008-05 void ScViewFunc::PaintWidthHeight( sal_Bool bColumns, SCCOLROW nStart, SCCOLROW nEnd ) //UNUSED2008-05 { //UNUSED2008-05 SCTAB nTab = GetViewData()->GetTabNo(); //UNUSED2008-05 ScDocument* pDoc = GetViewData()->GetDocument(); //UNUSED2008-05 //UNUSED2008-05 sal_uInt16 nParts = PAINT_GRID; //UNUSED2008-05 SCCOL nStartCol = 0; //UNUSED2008-05 SCROW nStartRow = 0; //UNUSED2008-05 SCCOL nEndCol = MAXCOL; // fuer Test auf Merge //UNUSED2008-05 SCROW nEndRow = MAXROW; //UNUSED2008-05 if ( bColumns ) //UNUSED2008-05 { //UNUSED2008-05 nParts |= PAINT_TOP; //UNUSED2008-05 nStartCol = static_cast(nStart); //UNUSED2008-05 nEndCol = static_cast(nEnd); //UNUSED2008-05 } //UNUSED2008-05 else //UNUSED2008-05 { //UNUSED2008-05 nParts |= PAINT_LEFT; //UNUSED2008-05 nStartRow = nStart; //UNUSED2008-05 nEndRow = nEnd; //UNUSED2008-05 } //UNUSED2008-05 if (pDoc->HasAttrib( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab, //UNUSED2008-05 HASATTR_MERGED | HASATTR_OVERLAPPED )) //UNUSED2008-05 { //UNUSED2008-05 nStartCol = 0; //UNUSED2008-05 nStartRow = 0; //UNUSED2008-05 } //UNUSED2008-05 GetViewData()->GetDocShell()->PostPaint( nStartCol,nStartRow,nTab, MAXCOL,MAXROW,nTab, nParts ); //UNUSED2008-05 } //---------------------------------------------------------------------------- // manueller Seitenumbruch void ScViewFunc::InsertPageBreak( sal_Bool bColumn, sal_Bool bRecord, const ScAddress* pPos, sal_Bool bSetModified ) { SCTAB nTab = GetViewData()->GetTabNo(); ScAddress aCursor; if (pPos) aCursor = *pPos; else aCursor = ScAddress( GetViewData()->GetCurX(), GetViewData()->GetCurY(), nTab ); sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc(). InsertPageBreak( bColumn, aCursor, bRecord, bSetModified, sal_False ); if ( bSuccess && bSetModified ) UpdatePageBreakData( sal_True ); // fuer PageBreak-Modus } //---------------------------------------------------------------------------- void ScViewFunc::DeletePageBreak( sal_Bool bColumn, sal_Bool bRecord, const ScAddress* pPos, sal_Bool bSetModified ) { SCTAB nTab = GetViewData()->GetTabNo(); ScAddress aCursor; if (pPos) aCursor = *pPos; else aCursor = ScAddress( GetViewData()->GetCurX(), GetViewData()->GetCurY(), nTab ); sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc(). RemovePageBreak( bColumn, aCursor, bRecord, bSetModified, sal_False ); if ( bSuccess && bSetModified ) UpdatePageBreakData( sal_True ); // fuer PageBreak-Modus } //---------------------------------------------------------------------------- void ScViewFunc::RemoveManualBreaks() { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); SCTAB nTab = GetViewData()->GetTabNo(); sal_Bool bUndo(pDoc->IsUndoEnabled()); if (bUndo) { ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True ); pDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, sal_False, pUndoDoc ); pDocSh->GetUndoManager()->AddUndoAction( new ScUndoRemoveBreaks( pDocSh, nTab, pUndoDoc ) ); } pDoc->RemoveManualBreaks(nTab); pDoc->UpdatePageBreaks(nTab); UpdatePageBreakData( sal_True ); pDocSh->SetDocumentModified(); pDocSh->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID ); } //---------------------------------------------------------------------------- void ScViewFunc::SetPrintZoom(sal_uInt16 nScale, sal_uInt16 nPages) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); SCTAB nTab = GetViewData()->GetTabNo(); pDocSh->SetPrintZoom( nTab, nScale, nPages ); } void ScViewFunc::AdjustPrintZoom() { ScRange aRange; if ( GetViewData()->GetSimpleArea( aRange ) != SC_MARK_SIMPLE ) GetViewData()->GetMarkData().GetMultiMarkArea( aRange ); GetViewData()->GetDocShell()->AdjustPrintZoom( aRange ); } //---------------------------------------------------------------------------- void ScViewFunc::SetPrintRanges( sal_Bool bEntireSheet, const String* pPrint, const String* pRepCol, const String* pRepRow, sal_Bool bAddPrint ) { // on all selected tables ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); SCTAB nTabCount = pDoc->GetTableCount(); ScMarkData& rMark = GetViewData()->GetMarkData(); SCTAB nTab; sal_Bool bUndo (pDoc->IsUndoEnabled()); ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver(); ScAddress::Details aDetails(pDoc->GetAddressConvention(), 0, 0); for (nTab=0; nTabClearPrintRanges( nTab ); if( bEntireSheet ) { pDoc->SetPrintEntireSheet( nTab ); } else if ( pPrint ) { if ( pPrint->Len() ) { const sal_Unicode sep = ScCompiler::GetNativeSymbol(ocSep).GetChar(0); sal_uInt16 nTCount = pPrint->GetTokenCount(sep); for (sal_uInt16 i=0; iGetToken(i, sep); if ( aRange.ParseAny( aToken, pDoc, aDetails ) & SCA_VALID ) pDoc->AddPrintRange( nTab, aRange ); } } } else // NULL = use selection (print range is always set), use empty string to delete all ranges { if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE ) { pDoc->AddPrintRange( nTab, aRange ); } else if ( rMark.IsMultiMarked() ) { rMark.MarkToMulti(); ScRangeListRef aList( new ScRangeList ); rMark.FillRangeListWithMarks( aList, sal_False ); sal_uInt16 nCnt = (sal_uInt16) aList->Count(); if ( nCnt ) { ScRangePtr pR; sal_uInt16 i; for ( pR = aList->First(), i=0; i < nCnt; pR = aList->Next(), i++ ) { pDoc->AddPrintRange( nTab, *pR ); } } } } // repeat columns if ( pRepCol ) { if ( !pRepCol->Len() ) pDoc->SetRepeatColRange( nTab, NULL ); else if ( aRange.ParseAny( *pRepCol, pDoc, aDetails ) & SCA_VALID ) pDoc->SetRepeatColRange( nTab, &aRange ); } // repeat rows if ( pRepRow ) { if ( !pRepRow->Len() ) pDoc->SetRepeatRowRange( nTab, NULL ); else if ( aRange.ParseAny( *pRepRow, pDoc, aDetails ) & SCA_VALID ) pDoc->SetRepeatRowRange( nTab, &aRange ); } } // undo (for all tables) if (bUndo) { SCTAB nCurTab = GetViewData()->GetTabNo(); ScPrintRangeSaver* pNewRanges = pDoc->CreatePrintRangeSaver(); pDocSh->GetUndoManager()->AddUndoAction( new ScUndoPrintRange( pDocSh, nCurTab, pOldRanges, pNewRanges ) ); } // update page breaks for (nTab=0; nTabGetPrinter(), nTab ).UpdatePages(); SfxBindings& rBindings = GetViewData()->GetBindings(); rBindings.Invalidate( SID_DELETE_PRINTAREA ); pDocSh->SetDocumentModified(); } //---------------------------------------------------------------------------- // Zellen zusammenfassen sal_Bool ScViewFunc::TestMergeCells() // Vorab-Test (fuer Menue) { // simple test: sal_True if there's a selection but no multi selection and not filtered const ScMarkData& rMark = GetViewData()->GetMarkData(); if ( rMark.IsMarked() || rMark.IsMultiMarked() ) { ScRange aDummy; return GetViewData()->GetSimpleArea( aDummy) == SC_MARK_SIMPLE; } else return sal_False; } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::MergeCells( sal_Bool bApi, sal_Bool& rDoContents, sal_Bool bRecord ) { // Editable- und Verschachtelungs-Abfrage muss vorneweg sein (auch in DocFunc), // damit dann nicht die Inhalte-QueryBox kommt ScEditableTester aTester( this ); if (!aTester.IsEditable()) { ErrorMessage(aTester.GetMessageId()); return sal_False; } ScMarkData& rMark = GetViewData()->GetMarkData(); rMark.MarkToSimple(); if (!rMark.IsMarked()) { ErrorMessage(STR_NOMULTISELECT); return sal_False; } ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); ScRange aMarkRange; rMark.GetMarkArea( aMarkRange ); SCCOL nStartCol = aMarkRange.aStart.Col(); SCROW nStartRow = aMarkRange.aStart.Row(); SCTAB nStartTab = aMarkRange.aStart.Tab(); SCCOL nEndCol = aMarkRange.aEnd.Col(); SCROW nEndRow = aMarkRange.aEnd.Row(); SCTAB nEndTab = aMarkRange.aEnd.Tab(); if ( nStartCol == nEndCol && nStartRow == nEndRow ) { // nichts zu tun return sal_True; } if ( pDoc->HasAttrib( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab, HASATTR_MERGED | HASATTR_OVERLAPPED ) ) { // "Zusammenfassen nicht verschachteln !" ErrorMessage(STR_MSSG_MERGECELLS_0); return sal_False; } sal_Bool bOk = sal_True; if ( !pDoc->IsBlockEmpty( nStartTab, nStartCol,nStartRow+1, nStartCol,nEndRow, true ) || !pDoc->IsBlockEmpty( nStartTab, nStartCol+1,nStartRow, nEndCol,nEndRow, true ) ) { if (!bApi) { MessBox aBox( GetViewData()->GetDialogParent(), WinBits(WB_YES_NO_CANCEL | WB_DEF_NO), ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ), ScGlobal::GetRscString( STR_MERGE_NOTEMPTY ) ); sal_uInt16 nRetVal = aBox.Execute(); if ( nRetVal == RET_YES ) rDoContents = sal_True; else if ( nRetVal == RET_CANCEL ) bOk = sal_False; } } if (bOk) { HideCursor(); bOk = pDocSh->GetDocFunc().MergeCells( aMarkRange, rDoContents, bRecord, bApi ); ShowCursor(); if (bOk) { SetCursor( nStartCol, nStartRow ); //DoneBlockMode( sal_False); Unmark(); pDocSh->UpdateOle(GetViewData()); UpdateInputLine(); } } return bOk; } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::TestRemoveMerge() { sal_Bool bMerged = sal_False; ScRange aRange; if (GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE) { ScDocument* pDoc = GetViewData()->GetDocument(); if ( pDoc->HasAttrib( aRange, HASATTR_MERGED ) ) bMerged = sal_True; } return bMerged; } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::RemoveMerge( sal_Bool bRecord ) { ScRange aRange; ScEditableTester aTester( this ); if (!aTester.IsEditable()) { ErrorMessage(aTester.GetMessageId()); return sal_False; } else if (GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE) { ScRange aExtended( aRange ); GetViewData()->GetDocument()->ExtendMerge( aExtended ); ScDocShell* pDocSh = GetViewData()->GetDocShell(); HideCursor(); sal_Bool bOk = pDocSh->GetDocFunc().UnmergeCells( aRange, bRecord, sal_False ); MarkRange( aExtended ); ShowCursor(); if (bOk) pDocSh->UpdateOle(GetViewData()); } return sal_True; //! bOk ?? } //---------------------------------------------------------------------------- void ScViewFunc::FillSimple( FillDir eDir, sal_Bool bRecord ) { ScRange aRange; if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); const ScMarkData& rMark = GetViewData()->GetMarkData(); sal_Bool bSuccess = pDocSh->GetDocFunc().FillSimple( aRange, &rMark, eDir, bRecord, sal_False ); if (bSuccess) { pDocSh->UpdateOle(GetViewData()); UpdateScrollBars(); } } else ErrorMessage(STR_NOMULTISELECT); } //---------------------------------------------------------------------------- void ScViewFunc::FillSeries( FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd, double fStart, double fStep, double fMax, sal_Bool bRecord ) { ScRange aRange; if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); const ScMarkData& rMark = GetViewData()->GetMarkData(); sal_Bool bSuccess = pDocSh->GetDocFunc(). FillSeries( aRange, &rMark, eDir, eCmd, eDateCmd, fStart, fStep, fMax, bRecord, sal_False ); if (bSuccess) { pDocSh->UpdateOle(GetViewData()); UpdateScrollBars(); // #i97876# Spreadsheet data changes are not notified ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() ); if ( pModelObj && pModelObj->HasChangesListeners() ) { ScRangeList aChangeRanges; aChangeRanges.Append( aRange ); pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges ); } } } else ErrorMessage(STR_NOMULTISELECT); } //---------------------------------------------------------------------------- void ScViewFunc::FillAuto( FillDir eDir, SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, sal_uLong nCount, sal_Bool bRecord ) { SCTAB nTab = GetViewData()->GetTabNo(); ScRange aRange( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab ); ScRange aSourceRange( aRange ); ScDocShell* pDocSh = GetViewData()->GetDocShell(); const ScMarkData& rMark = GetViewData()->GetMarkData(); sal_Bool bSuccess = pDocSh->GetDocFunc(). FillAuto( aRange, &rMark, eDir, nCount, bRecord, sal_False ); if (bSuccess) { MarkRange( aRange, sal_False ); // aRange ist in FillAuto veraendert worden pDocSh->UpdateOle(GetViewData()); UpdateScrollBars(); // #i97876# Spreadsheet data changes are not notified ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() ); if ( pModelObj && pModelObj->HasChangesListeners() ) { ScRangeList aChangeRanges; ScRange aChangeRange( aRange ); switch ( eDir ) { case FILL_TO_BOTTOM: { aChangeRange.aStart.SetRow( aSourceRange.aEnd.Row() + 1 ); } break; case FILL_TO_TOP: { aChangeRange.aEnd.SetRow( aSourceRange.aStart.Row() - 1 ); } break; case FILL_TO_RIGHT: { aChangeRange.aStart.SetCol( aSourceRange.aEnd.Col() + 1 ); } break; case FILL_TO_LEFT: { aChangeRange.aEnd.SetCol( aSourceRange.aStart.Col() - 1 ); } break; default: { } break; } aChangeRanges.Append( aChangeRange ); pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges ); } } } //---------------------------------------------------------------------------- void ScViewFunc::FillTab( sal_uInt16 nFlags, sal_uInt16 nFunction, sal_Bool bSkipEmpty, sal_Bool bAsLink ) { //! allow source sheet to be protected ScEditableTester aTester( this ); if (!aTester.IsEditable()) { ErrorMessage(aTester.GetMessageId()); return; } ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); ScMarkData& rMark = GetViewData()->GetMarkData(); SCTAB nTab = GetViewData()->GetTabNo(); sal_Bool bUndo(pDoc->IsUndoEnabled()); ScRange aMarkRange; rMark.MarkToSimple(); sal_Bool bMulti = rMark.IsMultiMarked(); if (bMulti) rMark.GetMultiMarkArea( aMarkRange ); else if (rMark.IsMarked()) rMark.GetMarkArea( aMarkRange ); else aMarkRange = ScRange( GetViewData()->GetCurX(), GetViewData()->GetCurY(), nTab ); ScDocument* pUndoDoc = NULL; // if ( bRecord ) if (bUndo) { pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( pDoc, nTab, nTab ); // pUndoDoc->SelectTable( nTab, sal_True ); // nur fuer Markierung SCTAB nTabCount = pDoc->GetTableCount(); for (SCTAB i=0; iAddUndoTab( i, i ); aMarkRange.aStart.SetTab( i ); aMarkRange.aEnd.SetTab( i ); pDoc->CopyToDocument( aMarkRange, IDF_ALL, bMulti, pUndoDoc ); // pUndoDoc->SelectTable( i, sal_True ); } } if (bMulti) pDoc->FillTabMarked( nTab, rMark, nFlags, nFunction, bSkipEmpty, bAsLink ); else { aMarkRange.aStart.SetTab( nTab ); aMarkRange.aEnd.SetTab( nTab ); pDoc->FillTab( aMarkRange, rMark, nFlags, nFunction, bSkipEmpty, bAsLink ); } // if ( bRecord ) if (bUndo) { //! fuer ChangeTrack erst zum Schluss pDocSh->GetUndoManager()->AddUndoAction( new ScUndoFillTable( pDocSh, rMark, aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), nTab, aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(), nTab, pUndoDoc, bMulti, nTab, nFlags, nFunction, bSkipEmpty, bAsLink ) ); } pDocSh->PostPaintGridAll(); pDocSh->PostDataChanged(); } //---------------------------------------------------------------------------- /** Downward fill of selected cell(s) by double-clicking cross-hair cursor Extends a current selection down to the last non-empty cell of an adjacent column when the lower-right corner of the selection is double-clicked. It uses a left-adjoining non-empty column as a guide if such is available, otherwise a right-adjoining non-empty column is used. @author Kohei Yoshida (kohei@openoffice.org) @return No return value @see #i12313# */ void ScViewFunc::FillCrossDblClick() { ScRange aRange; GetViewData()->GetSimpleArea( aRange ); aRange.Justify(); SCTAB nTab = GetViewData()->GetCurPos().Tab(); SCCOL nStartX = aRange.aStart.Col(); SCROW nStartY = aRange.aStart.Row(); SCCOL nEndX = aRange.aEnd.Col(); SCROW nEndY = aRange.aEnd.Row(); ScDocument* pDoc = GetViewData()->GetDocument(); // Make sure the selection is not empty if ( pDoc->IsBlockEmpty( nTab, nStartX, nStartY, nEndX, nEndY ) ) return; if ( nEndY < MAXROW ) { if ( nStartX > 0 ) { SCCOL nMovX = nStartX - 1; SCROW nMovY = nStartY; if ( pDoc->HasData( nMovX, nStartY, nTab ) && pDoc->HasData( nMovX, nStartY + 1, nTab ) ) { pDoc->FindAreaPos( nMovX, nMovY, nTab, 0, 1 ); if ( nMovY > nEndY ) { FillAuto( FILL_TO_BOTTOM, nStartX, nStartY, nEndX, nEndY, nMovY - nEndY ); return; } } } if ( nEndX < MAXCOL ) { SCCOL nMovX = nEndX + 1; SCROW nMovY = nStartY; if ( pDoc->HasData( nMovX, nStartY, nTab ) && pDoc->HasData( nMovX, nStartY + 1, nTab ) ) { pDoc->FindAreaPos( nMovX, nMovY, nTab, 0, 1 ); if ( nMovY > nEndY ) { FillAuto( FILL_TO_BOTTOM, nStartX, nStartY, nEndX, nEndY, nMovY - nEndY ); return; } } } } } //---------------------------------------------------------------------------- void ScViewFunc::TransliterateText( sal_Int32 nType ) { ScMarkData aFuncMark = GetViewData()->GetMarkData(); if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() ) { // no selection -> use cursor position ScAddress aCursor( GetViewData()->GetCurX(), GetViewData()->GetCurY(), GetViewData()->GetTabNo() ); aFuncMark.SetMarkArea( ScRange( aCursor ) ); } sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc(). TransliterateText( aFuncMark, nType, sal_True, sal_False ); if (bSuccess) { GetViewData()->GetViewShell()->UpdateInputHandler(); } } //---------------------------------------------------------------------------- // AutoFormat ScAutoFormatData* ScViewFunc::CreateAutoFormatData() { ScAutoFormatData* pData = NULL; SCCOL nStartCol; SCROW nStartRow; SCTAB nStartTab; SCCOL nEndCol; SCROW nEndRow; SCTAB nEndTab; if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE) { if ( nEndCol-nStartCol >= 3 && nEndRow-nStartRow >= 3 ) { ScDocument* pDoc = GetViewData()->GetDocument(); pData = new ScAutoFormatData; pDoc->GetAutoFormatData( nStartTab, nStartCol,nStartRow,nEndCol,nEndRow, *pData ); } } return pData; } //---------------------------------------------------------------------------- void ScViewFunc::AutoFormat( sal_uInt16 nFormatNo, sal_Bool bRecord ) { #if 1 ScRange aRange; if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScMarkData& rMark = GetViewData()->GetMarkData(); sal_Bool bSuccess = pDocSh->GetDocFunc().AutoFormat( aRange, &rMark, nFormatNo, bRecord, sal_False ); if (bSuccess) pDocSh->UpdateOle(GetViewData()); } else ErrorMessage(STR_NOMULTISELECT); #else // nur wegen Matrix nicht editierbar? Attribute trotzdem ok sal_Bool bOnlyNotBecauseOfMatrix; if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix ) { ErrorMessage(STR_PROTECTIONERR); return; } SCCOL nStartCol; SCROW nStartRow; SCTAB nStartTab; SCCOL nEndCol; SCROW nEndRow; SCTAB nEndTab; if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); ScMarkData& rMark = GetViewData()->GetMarkData(); sal_Bool bSize = (*ScGlobal::GetAutoFormat())[nFormatNo]->GetIncludeWidthHeight(); if (bRecord && !pDoc->IsUndoEnabled()) bRecord = sal_False; ScDocument* pUndoDoc = NULL; if ( bRecord ) { pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab, bSize, bSize ); pDoc->CopyToDocument( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab, IDF_ATTRIB, sal_False, pUndoDoc ); if (bSize) { pDoc->CopyToDocument( nStartCol,0,nStartTab, nEndCol,MAXROW,nEndTab, IDF_NONE, sal_False, pUndoDoc ); pDoc->CopyToDocument( 0,nStartRow,nStartTab, MAXCOL,nEndRow,nEndTab, IDF_NONE, sal_False, pUndoDoc ); } pDoc->BeginDrawUndo(); } GetFrameWin()->EnterWait(); pDoc->AutoFormat( nStartCol, nStartRow, nEndCol, nEndRow, nFormatNo, rMark ); GetFrameWin()->LeaveWait(); if (bSize) { SetMarkedWidthOrHeight( sal_True, SC_SIZE_VISOPT, STD_EXTRA_WIDTH, sal_False, sal_False ); SetMarkedWidthOrHeight( sal_False, SC_SIZE_VISOPT, 0, sal_False, sal_False ); pDocSh->PostPaint( 0,0,nStartTab, MAXCOL,MAXROW,nStartTab, PAINT_GRID | PAINT_LEFT | PAINT_TOP ); } else { sal_Bool bAdj = AdjustBlockHeight( sal_False ); if (bAdj) pDocSh->PostPaint( 0,nStartRow,nStartTab, MAXCOL,MAXROW,nStartTab, PAINT_GRID | PAINT_LEFT ); else pDocSh->PostPaint( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab, PAINT_GRID ); } if ( bRecord ) // Draw-Undo erst jetzt verfuegbar { pDocSh->GetUndoManager()->AddUndoAction( new ScUndoAutoFormat( pDocSh, ScRange(nStartCol,nStartRow,nStartTab, nEndCol,nEndRow,nEndTab), pUndoDoc, rMark, bSize, nFormatNo ) ); } pDocSh->UpdateOle(GetViewData()); pDocSh->SetDocumentModified(); } else ErrorMessage(STR_NOMULTISELECT); #endif } //---------------------------------------------------------------------------- // Suchen & Ersetzen void ScViewFunc::SearchAndReplace( const SvxSearchItem* pSearchItem, sal_Bool bAddUndo, sal_Bool bIsApi ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); ScMarkData& rMark = GetViewData()->GetMarkData(); if (bAddUndo && !pDoc->IsUndoEnabled()) bAddUndo = sal_False; SCCOL nCol = GetViewData()->GetCurX(); SCROW nRow = GetViewData()->GetCurY(); SCTAB nTab = GetViewData()->GetTabNo(); // sal_Bool bAttrib = pSearchItem->GetPattern(); sal_uInt16 nCommand = pSearchItem->GetCommand(); sal_Bool bAllTables = pSearchItem->IsAllTables(); sal_Bool* pOldSelectedTables = NULL; sal_uInt16 nOldSelectedCount = 0; SCTAB nOldTab = nTab; SCTAB nLastTab = pDoc->GetTableCount() - 1; SCTAB nStartTab, nEndTab; if ( bAllTables ) { nStartTab = 0; nEndTab = nLastTab; pOldSelectedTables = new sal_Bool [ nEndTab + 1 ]; for ( SCTAB j = 0; j <= nEndTab; j++ ) { pOldSelectedTables[j] = rMark.GetTableSelect( j ); if ( pOldSelectedTables[j] ) ++nOldSelectedCount; } } else { //! mindestens eine ist immer selektiert nStartTab = nEndTab = rMark.GetFirstSelected(); for ( SCTAB j = nStartTab + 1; j <= nLastTab; j++ ) { if ( rMark.GetTableSelect( j ) ) nEndTab = j; } } if ( nCommand == SVX_SEARCHCMD_REPLACE || nCommand == SVX_SEARCHCMD_REPLACE_ALL ) { for ( SCTAB j = nStartTab; j <= nEndTab; j++ ) { if ( (bAllTables || rMark.GetTableSelect( j )) && pDoc->IsTabProtected( j ) ) { if ( pOldSelectedTables ) delete [] pOldSelectedTables; ErrorMessage(STR_PROTECTIONERR); return; } } } if ( nCommand == SVX_SEARCHCMD_FIND || nCommand == SVX_SEARCHCMD_FIND_ALL) bAddUndo = sal_False; //! bAttrib bei Undo beruecksichtigen !!! ScDocument* pUndoDoc = NULL; ScMarkData* pUndoMark = NULL; String aUndoStr; if (bAddUndo) { pUndoMark = new ScMarkData( rMark ); // Markierung wird veraendert if ( nCommand == SVX_SEARCHCMD_REPLACE_ALL ) { pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab ); } } if ( bAllTables ) { //! alles selektieren, erst nachdem pUndoMark erzeugt wurde for ( SCTAB j = nStartTab; j <= nEndTab; j++ ) { rMark.SelectTable( j, sal_True ); } } DoneBlockMode(sal_True); // Markierung nicht loeschen! InitOwnBlockMode(); // wenn vom Anfang an gesucht wird, nicht nochmal fragen ob vom Anfang gesucht werden soll sal_Bool bFirst = sal_True; if ( nCol == 0 && nRow == 0 && nTab == nStartTab && !pSearchItem->GetBackward() ) bFirst = sal_False; sal_Bool bFound = sal_False; while (sal_True) { GetFrameWin()->EnterWait(); if (pDoc->SearchAndReplace( *pSearchItem, nCol, nRow, nTab, rMark, aUndoStr, pUndoDoc ) ) { bFound = sal_True; bFirst = sal_True; if (bAddUndo) { GetViewData()->GetDocShell()->GetUndoManager()->AddUndoAction( new ScUndoReplace( GetViewData()->GetDocShell(), *pUndoMark, nCol, nRow, nTab, aUndoStr, pUndoDoc, pSearchItem ) ); pUndoDoc = NULL; } break; // Abbruch while True } else if ( bFirst && (nCommand == SVX_SEARCHCMD_FIND || nCommand == SVX_SEARCHCMD_REPLACE) ) { bFirst = sal_False; sal_uInt16 nRetVal; GetFrameWin()->LeaveWait(); if ( bIsApi ) nRetVal = RET_NO; else { // Suchen-Dialog als Parent, wenn vorhanden Window* pParent = GetParentOrChild(SID_SEARCH_DLG); sal_uInt16 nStrId; if ( pSearchItem->GetBackward() ) { if ( nStartTab == nEndTab ) nStrId = STR_MSSG_SEARCHANDREPLACE_1; else nStrId = STR_MSSG_SEARCHANDREPLACE_4; } else { if ( nStartTab == nEndTab ) nStrId = STR_MSSG_SEARCHANDREPLACE_2; else nStrId = STR_MSSG_SEARCHANDREPLACE_5; } MessBox aBox( pParent, WinBits(WB_YES_NO | WB_DEF_YES), ScGlobal::GetRscString( STR_MSSG_SEARCHANDREPLACE_3 ), ScGlobal::GetRscString( nStrId ) ); nRetVal = aBox.Execute(); } if ( nRetVal == RET_YES ) { ScDocument::GetSearchAndReplaceStart( *pSearchItem, nCol, nRow ); if (pSearchItem->GetBackward()) nTab = nEndTab; else nTab = nStartTab; } else { break; // Abbruch while True } } else // nichts gefunden { if ( nCommand == SVX_SEARCHCMD_FIND_ALL || nCommand == SVX_SEARCHCMD_REPLACE_ALL ) { pDocSh->PostPaintGridAll(); // Markierung } GetFrameWin()->LeaveWait(); if (!bIsApi) { // Suchen-Dialog als Parent, wenn vorhanden Window* pParent = GetParentOrChild(SID_SEARCH_DLG); // "nichts gefunden" InfoBox aBox( pParent, ScGlobal::GetRscString( STR_MSSG_SEARCHANDREPLACE_0 ) ); aBox.Execute(); } break; // Abbruch while True } } // of while sal_True if ( pOldSelectedTables ) { // urspruenglich selektierte Tabellen wiederherstellen for ( SCTAB j = nStartTab; j <= nEndTab; j++ ) { rMark.SelectTable( j, pOldSelectedTables[j] ); } if ( bFound ) { // durch Fundstelle neu selektierte Tabelle bleibt rMark.SelectTable( nTab, sal_True ); // wenn vorher nur eine selektiert war, ist es ein Tausch //! wenn nicht, ist jetzt evtl. eine mehr selektiert if ( nOldSelectedCount == 1 && nTab != nOldTab ) rMark.SelectTable( nOldTab, sal_False ); } delete [] pOldSelectedTables; } MarkDataChanged(); if ( bFound ) { if ( nTab != GetViewData()->GetTabNo() ) SetTabNo( nTab ); // wenn nichts markiert ist, DoneBlockMode, damit von hier aus // direkt per Shift-Cursor markiert werden kann: if (!rMark.IsMarked() && !rMark.IsMultiMarked()) DoneBlockMode(sal_True); AlignToCursor( nCol, nRow, SC_FOLLOW_JUMP ); SetCursor( nCol, nRow, sal_True ); if ( nCommand == SVX_SEARCHCMD_REPLACE || nCommand == SVX_SEARCHCMD_REPLACE_ALL ) { if ( nCommand == SVX_SEARCHCMD_REPLACE ) pDocSh->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID ); else pDocSh->PostPaintGridAll(); pDocSh->SetDocumentModified(); } else if ( nCommand == SVX_SEARCHCMD_FIND_ALL ) pDocSh->PostPaintGridAll(); // Markierung GetFrameWin()->LeaveWait(); } delete pUndoDoc; // loeschen wenn nicht benutzt delete pUndoMark; // kann immer geloescht werden } //---------------------------------------------------------------------------- // Zielwertsuche void ScViewFunc::Solve( const ScSolveParam& rParam ) { ScDocument* pDoc = GetViewData()->GetDocument(); SCCOL nDestCol = rParam.aRefVariableCell.Col(); SCROW nDestRow = rParam.aRefVariableCell.Row(); SCTAB nDestTab = rParam.aRefVariableCell.Tab(); ScEditableTester aTester( pDoc, nDestTab, nDestCol,nDestRow, nDestCol,nDestRow ); if (!aTester.IsEditable()) { ErrorMessage(aTester.GetMessageId()); return; } if ( pDoc ) { String aTargetValStr; if ( rParam.pStrTargetVal != NULL ) aTargetValStr = *(rParam.pStrTargetVal); String aMsgStr; String aResStr; double nSolveResult; GetFrameWin()->EnterWait(); sal_Bool bExact = pDoc->Solver( rParam.aRefFormulaCell.Col(), rParam.aRefFormulaCell.Row(), rParam.aRefFormulaCell.Tab(), nDestCol, nDestRow, nDestTab, aTargetValStr, nSolveResult ); GetFrameWin()->LeaveWait(); SvNumberFormatter* pFormatter = pDoc->GetFormatTable(); sal_uLong nFormat = 0; const ScPatternAttr* pPattern = pDoc->GetPattern( nDestCol, nDestRow, nDestTab ); if ( pPattern ) nFormat = pPattern->GetNumberFormat( pFormatter ); Color* p; pFormatter->GetOutputString( nSolveResult, nFormat, aResStr, &p ); if ( bExact ) { aMsgStr = ScGlobal::GetRscString( STR_MSSG_SOLVE_0 ); aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_1 ); aMsgStr += String( aResStr ); aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_2 ); } else { aMsgStr = ScGlobal::GetRscString( STR_MSSG_SOLVE_3 ); aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_4 ); aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_5 ); aMsgStr += String( aResStr ); aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_6 ); } MessBox aBox( GetViewData()->GetDialogParent(), WinBits(WB_YES_NO | WB_DEF_NO), ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ), aMsgStr ); sal_uInt16 nRetVal = aBox.Execute(); if ( RET_YES == nRetVal ) EnterValue( nDestCol, nDestRow, nDestTab, nSolveResult ); GetViewData()->GetViewShell()->UpdateInputHandler( sal_True ); } } //---------------------------------------------------------------------------- // Mehrfachoperation void ScViewFunc::TabOp( const ScTabOpParam& rParam, sal_Bool bRecord ) { ScRange aRange; if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScMarkData& rMark = GetViewData()->GetMarkData(); pDocSh->GetDocFunc().TabOp( aRange, &rMark, rParam, bRecord, sal_False ); } else ErrorMessage(STR_NOMULTISELECT); } //---------------------------------------------------------------------------- void ScViewFunc::MakeScenario( const String& rName, const String& rComment, const Color& rColor, sal_uInt16 nFlags ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScMarkData& rMark = GetViewData()->GetMarkData(); SCTAB nTab = GetViewData()->GetTabNo(); SCTAB nNewTab = pDocSh->MakeScenario( nTab, rName, rComment, rColor, nFlags, rMark ); if (nFlags & SC_SCENARIO_COPYALL) SetTabNo( nNewTab, sal_True ); // SC_SCENARIO_COPYALL -> sichtbar else { SfxBindings& rBindings = GetViewData()->GetBindings(); rBindings.Invalidate( SID_STATUS_DOCPOS ); // Statusbar rBindings.Invalidate( SID_TABLES_COUNT ); rBindings.Invalidate( SID_SELECT_SCENARIO ); rBindings.Invalidate( FID_TABLE_SHOW ); } } //---------------------------------------------------------------------------- void ScViewFunc::ExtendScenario() { ScEditableTester aTester( this ); if (!aTester.IsEditable()) { ErrorMessage(aTester.GetMessageId()); return; } // Undo: Attribute anwenden ScDocument* pDoc = GetViewData()->GetDocument(); ScPatternAttr aPattern( pDoc->GetPool() ); aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) ); aPattern.GetItemSet().Put( ScProtectionAttr( sal_True ) ); ApplySelectionPattern(aPattern); } //---------------------------------------------------------------------------- void ScViewFunc::UseScenario( const String& rName ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); SCTAB nTab = GetViewData()->GetTabNo(); DoneBlockMode(); InitOwnBlockMode(); pDocSh->UseScenario( nTab, rName ); } //---------------------------------------------------------------------------- // Tabelle einfuegen sal_Bool ScViewFunc::InsertTable( const String& rName, SCTAB nTab, sal_Bool bRecord ) { // Reihenfolge Tabelle/Name ist bei DocFunc umgekehrt sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc(). InsertTable( nTab, rName, bRecord, sal_False ); if (bSuccess) SetTabNo( nTab, sal_True ); return bSuccess; } //---------------------------------------------------------------------------- // Tabellen einfuegen sal_Bool ScViewFunc::InsertTables(SvStrings *pNames, SCTAB nTab, SCTAB nCount, sal_Bool bRecord ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); if (bRecord && !pDoc->IsUndoEnabled()) bRecord = sal_False; SvStrings *pNameList= NULL; WaitObject aWait( GetFrameWin() ); if (bRecord) { pNameList= new SvStrings; pDoc->BeginDrawUndo(); // InsertTab erzeugt ein SdrUndoNewPage } sal_Bool bFlag=sal_False; String aValTabName; String *pStr; for(SCTAB i=0;iGetObject(static_cast(i)); } else { aValTabName.Erase(); pDoc->CreateValidTabName( aValTabName); pStr=&aValTabName; } if(pDoc->InsertTab( nTab+i,*pStr)) { bFlag=sal_True; pDocSh->Broadcast( ScTablesHint( SC_TAB_INSERTED, nTab+i ) ); } else { break; } if(pNameList!=NULL) pNameList->Insert(new String(*pStr),pNameList->Count()); } if (bFlag) { if (bRecord) pDocSh->GetUndoManager()->AddUndoAction( new ScUndoInsertTables( pDocSh, nTab, sal_False, pNameList)); // Views updaten: SetTabNo( nTab, sal_True ); pDocSh->PostPaintExtras(); pDocSh->SetDocumentModified(); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); return sal_True; } else { return sal_False; } } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::AppendTable( const String& rName, sal_Bool bRecord ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); if (bRecord && !pDoc->IsUndoEnabled()) bRecord = sal_False; WaitObject aWait( GetFrameWin() ); if (bRecord) pDoc->BeginDrawUndo(); // InsertTab erzeugt ein SdrUndoNewPage if (pDoc->InsertTab( SC_TAB_APPEND, rName )) { SCTAB nTab = pDoc->GetTableCount()-1; if (bRecord) pDocSh->GetUndoManager()->AddUndoAction( new ScUndoInsertTab( pDocSh, nTab, sal_True, rName)); GetViewData()->InsertTab( nTab ); SetTabNo( nTab, sal_True ); pDocSh->PostPaintExtras(); pDocSh->SetDocumentModified(); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); return sal_True; } else { return sal_False; } } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::DeleteTable( SCTAB nTab, sal_Bool bRecord ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); sal_Bool bSuccess = pDocSh->GetDocFunc().DeleteTable( nTab, bRecord, sal_False ); if (bSuccess) { SCTAB nNewTab = nTab; if ( nNewTab >= pDoc->GetTableCount() ) --nNewTab; SetTabNo( nNewTab, sal_True ); } return bSuccess; } sal_Bool ScViewFunc::DeleteTables(const SvShorts &TheTabs, sal_Bool bRecord ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); sal_Bool bVbaEnabled = pDoc ? pDoc->IsInVBAMode() : sal_False; SCTAB nNewTab = TheTabs.front(); WaitObject aWait( GetFrameWin() ); if (bRecord && !pDoc->IsUndoEnabled()) bRecord = sal_False; while ( nNewTab > 0 && !pDoc->IsVisible( nNewTab ) ) --nNewTab; sal_Bool bWasLinked = sal_False; ScDocument* pUndoDoc = NULL; ScRefUndoData* pUndoData = NULL; if (bRecord) { pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); // pUndoDoc->InitDrawLayer( pDocSh ); SCTAB nCount = pDoc->GetTableCount(); // pUndoDoc->InitUndo( pDoc, 0, nCount-1 ); // incl. Ref. String aOldName; for (size_t i = 0; i < TheTabs.size(); i++) { SCTAB nTab = TheTabs[i]; if (i==0) pUndoDoc->InitUndo( pDoc, nTab,nTab, sal_True,sal_True ); // incl. Spalten/Zeilenflags else pUndoDoc->AddUndoTab( nTab,nTab, sal_True,sal_True ); // incl. Spalten/Zeilenflags pDoc->CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,sal_False, pUndoDoc ); pDoc->GetName( nTab, aOldName ); pUndoDoc->RenameTab( nTab, aOldName, sal_False ); if (pDoc->IsLinked(nTab)) { bWasLinked = sal_True; pUndoDoc->SetLink( nTab, pDoc->GetLinkMode(nTab), pDoc->GetLinkDoc(nTab), pDoc->GetLinkFlt(nTab), pDoc->GetLinkOpt(nTab), pDoc->GetLinkTab(nTab), pDoc->GetLinkRefreshDelay(nTab) ); } if ( pDoc->IsScenario(nTab) ) { pUndoDoc->SetScenario( nTab, sal_True ); String aComment; Color aColor; sal_uInt16 nScenFlags; pDoc->GetScenarioData( nTab, aComment, aColor, nScenFlags ); pUndoDoc->SetScenarioData( nTab, aComment, aColor, nScenFlags ); sal_Bool bActive = pDoc->IsActiveScenario( nTab ); pUndoDoc->SetActiveScenario( nTab, bActive ); } pUndoDoc->SetVisible( nTab, pDoc->IsVisible( nTab ) ); pUndoDoc->SetTabBgColor( nTab, pDoc->GetTabBgColor(nTab) ); pUndoDoc->SetSheetEvents( nTab, pDoc->GetSheetEvents( nTab ) ); if ( pDoc->IsTabProtected( nTab ) ) pUndoDoc->SetTabProtection(nTab, pDoc->GetTabProtection(nTab)); // Drawing-Layer muss sein Undo selbst in der Hand behalten !!! // pUndoDoc->TransferDrawPage(pDoc, nTab,nTab); } pUndoDoc->AddUndoTab( 0, nCount-1 ); // alle Tabs fuer Referenzen pDoc->BeginDrawUndo(); // DeleteTab erzeugt ein SdrUndoDelPage pUndoData = new ScRefUndoData( pDoc ); } sal_Bool bDelDone = sal_False; for (size_t i = TheTabs.size(); i > 0; i--) { String sCodeName; sal_Bool bHasCodeName = pDoc->GetCodeName( TheTabs[i-1], sCodeName ); if (pDoc->DeleteTab( TheTabs[i-1], pUndoDoc )) { bDelDone = sal_True; if( bVbaEnabled ) { if( bHasCodeName ) { VBA_DeleteModule( *pDocSh, sCodeName ); } } pDocSh->Broadcast( ScTablesHint( SC_TAB_DELETED, TheTabs[i-1] ) ); } } if (bRecord) { pDocSh->GetUndoManager()->AddUndoAction( new ScUndoDeleteTab( GetViewData()->GetDocShell(), TheTabs, pUndoDoc, pUndoData )); } if (bDelDone) { if ( nNewTab >= pDoc->GetTableCount() ) nNewTab = pDoc->GetTableCount() - 1; SetTabNo( nNewTab, sal_True ); if (bWasLinked) { pDocSh->UpdateLinks(); // Link-Manager updaten GetViewData()->GetBindings().Invalidate(SID_LINKS); } pDocSh->PostPaintExtras(); pDocSh->SetDocumentModified(); SfxApplication* pSfxApp = SFX_APP(); // Navigator pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) ); pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) ); } else { delete pUndoDoc; delete pUndoData; } return bDelDone; } //---------------------------------------------------------------------------- sal_Bool ScViewFunc::RenameTable( const String& rName, SCTAB nTab ) { // Reihenfolge Tabelle/Name ist bei DocFunc umgekehrt sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc(). RenameTable( nTab, rName, sal_True, sal_False ); if (bSuccess) { // Der Tabellenname koennte in einer Formel vorkommen... GetViewData()->GetViewShell()->UpdateInputHandler(); } return bSuccess; } //---------------------------------------------------------------------------- bool ScViewFunc::SetTabBgColor( const Color& rColor, SCTAB nTab ) { bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().SetTabBgColor( nTab, rColor, sal_True, sal_False ); if (bSuccess) { GetViewData()->GetViewShell()->UpdateInputHandler(); } return bSuccess; } bool ScViewFunc::SetTabBgColor( ScUndoTabColorInfo::List& rUndoSetTabBgColorInfoList ) { bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().SetTabBgColor( rUndoSetTabBgColorInfoList, sal_True, sal_False ); if (bSuccess) { GetViewData()->GetViewShell()->UpdateInputHandler(); } return bSuccess; } //---------------------------------------------------------------------------- void ScViewFunc::InsertAreaLink( const String& rFile, const String& rFilter, const String& rOptions, const String& rSource, sal_uLong nRefresh ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); SCCOL nPosX = GetViewData()->GetCurX(); SCROW nPosY = GetViewData()->GetCurY(); SCTAB nTab = GetViewData()->GetTabNo(); ScAddress aPos( nPosX, nPosY, nTab ); pDocSh->GetDocFunc().InsertAreaLink( rFile, rFilter, rOptions, rSource, aPos, nRefresh, sal_False, sal_False ); } //---------------------------------------------------------------------------- void ScViewFunc::InsertTableLink( const String& rFile, const String& rFilter, const String& rOptions, const String& rTabName ) { String aFilterName = rFilter; String aOpt = rOptions; ScDocumentLoader aLoader( rFile, aFilterName, aOpt ); if (!aLoader.IsError()) { ScDocShell* pSrcSh = aLoader.GetDocShell(); ScDocument* pSrcDoc = pSrcSh->GetDocument(); SCTAB nTab = MAXTAB+1; if (!rTabName.Len()) // kein Name angegeben -> erste Tabelle nTab = 0; else { String aTemp; SCTAB nCount = pSrcDoc->GetTableCount(); for (SCTAB i=0; iGetName( i, aTemp ); if ( aTemp == rTabName ) nTab = i; } } if ( nTab <= MAXTAB ) ImportTables( pSrcSh, 1, &nTab, sal_True, GetViewData()->GetTabNo() ); } } //---------------------------------------------------------------------------- // Tabellen aus anderem Dokument kopieren / linken void ScViewFunc::ImportTables( ScDocShell* pSrcShell, SCTAB nCount, const SCTAB* pSrcTabs, sal_Bool bLink,SCTAB nTab ) { ScDocument* pSrcDoc = pSrcShell->GetDocument(); ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); sal_Bool bUndo(pDoc->IsUndoEnabled()); //SCTAB nTab = GetViewData()->GetTabNo(); sal_Bool bError = sal_False; sal_Bool bRefs = sal_False; sal_Bool bName = sal_False; if (pSrcDoc->GetDrawLayer()) pDocSh->MakeDrawLayer(); if (bUndo) pDoc->BeginDrawUndo(); // drawing layer must do its own undo actions SCTAB nInsCount = 0; SCTAB i; for( i=0; iGetName( pSrcTabs[i], aName ); pDoc->CreateValidTabName( aName ); if ( !pDoc->InsertTab( nTab+i, aName ) ) { bError = sal_True; // total error break; // for } ++nInsCount; } for (i=0; iTransferTab( pSrcDoc, nSrcTab, nDestTab1, sal_False ); // no insert switch (nErrVal) { case 0: // interner Fehler oder voll Fehler bError = sal_True; break; case 2: bRefs = sal_True; break; case 3: bName = sal_True; break; case 4: bRefs = bName = sal_True; break; } // TransferTab doesn't copy drawing objects with bInsertNew=FALSE if ( !bError ) pDoc->TransferDrawPage( pSrcDoc, nSrcTab, nDestTab1 ); if(!bError &&pSrcDoc->IsScenario(nSrcTab)) { String aComment; Color aColor; sal_uInt16 nFlags; pSrcDoc->GetScenarioData(nSrcTab, aComment,aColor, nFlags); pDoc->SetScenario( nDestTab1,sal_True); pDoc->SetScenarioData( nTab+i,aComment,aColor,nFlags); sal_Bool bActive = pSrcDoc->IsActiveScenario(nSrcTab ); pDoc->SetActiveScenario( nDestTab1, bActive ); sal_Bool bVisible=pSrcDoc->IsVisible(nSrcTab); pDoc->SetVisible(nDestTab1,bVisible ); } } if (bLink) { sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager(); SfxMedium* pMed = pSrcShell->GetMedium(); String aFileName = pMed->GetName(); String aFilterName; if (pMed->GetFilter()) aFilterName = pMed->GetFilter()->GetFilterName(); String aOptions = ScDocumentLoader::GetOptions(*pMed); sal_Bool bWasThere = pDoc->HasLink( aFileName, aFilterName, aOptions ); sal_uLong nRefresh = 0; String aTabStr; for (i=0; iGetName( pSrcTabs[i], aTabStr ); pDoc->SetLink( nTab+i, SC_LINK_NORMAL, aFileName, aFilterName, aOptions, aTabStr, nRefresh ); } if (!bWasThere) // Link pro Quelldokument nur einmal eintragen { ScTableLink* pLink = new ScTableLink( pDocSh, aFileName, aFilterName, aOptions, nRefresh ); pLink->SetInCreate( sal_True ); pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aFileName, &aFilterName ); pLink->Update(); pLink->SetInCreate( sal_False ); SfxBindings& rBindings = GetViewData()->GetBindings(); rBindings.Invalidate( SID_LINKS ); } } if (bUndo) { pDocSh->GetUndoManager()->AddUndoAction( new ScUndoImportTab( pDocSh, nTab, nCount, bLink ) ); } for (i=0; iInsertTab(nTab); SetTabNo(nTab,sal_True); pDocSh->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS ); SfxApplication* pSfxApp = SFX_APP(); pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) ); pDocSh->PostPaintExtras(); pDocSh->PostPaintGridAll(); pDocSh->SetDocumentModified(); if (bRefs) ErrorMessage(STR_ABSREFLOST); if (bName) ErrorMessage(STR_NAMECONFLICT); } //---------------------------------------------------------------------------- // Tabelle in anderes Dokument verschieben / kopieren void ScViewFunc::MoveTable( sal_uInt16 nDestDocNo, SCTAB nDestTab, sal_Bool bCopy ) { ScDocument* pDoc = GetViewData()->GetDocument(); ScDocShell* pDocShell = GetViewData()->GetDocShell(); ScDocument* pDestDoc = NULL; ScDocShell* pDestShell = NULL; ScTabViewShell* pDestViewSh = NULL; sal_Bool bUndo (pDoc->IsUndoEnabled()); sal_Bool bNewDoc = ( nDestDocNo == SC_DOC_NEW ); if ( bNewDoc ) { nDestTab = 0; // als erstes einfuegen // ohne SFX_CALLMODE_RECORD ausfuehren, weil schon im Move-Befehl enthalten: String aUrl = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("private:factory/")); aUrl.AppendAscii(RTL_CONSTASCII_STRINGPARAM( STRING_SCAPP )); // "scalc" SfxStringItem aItem( SID_FILE_NAME, aUrl ); SfxStringItem aTarget( SID_TARGETNAME, String::CreateFromAscii("_blank") ); const SfxPoolItem* pRetItem = GetViewData()->GetDispatcher().Execute( SID_OPENDOC, SFX_CALLMODE_API|SFX_CALLMODE_SYNCHRON, &aItem, &aTarget, 0L ); if ( pRetItem ) { if ( pRetItem->ISA( SfxObjectItem ) ) pDestShell = PTR_CAST( ScDocShell, ((const SfxObjectItem*)pRetItem)->GetShell() ); else if ( pRetItem->ISA( SfxViewFrameItem ) ) { SfxViewFrame* pFrm = ((const SfxViewFrameItem*)pRetItem)->GetFrame(); if (pFrm) pDestShell = PTR_CAST( ScDocShell, pFrm->GetObjectShell() ); } if (pDestShell) pDestViewSh = pDestShell->GetBestViewShell(); } } else pDestShell = ScDocShell::GetShellByNum( nDestDocNo ); if (!pDestShell) { DBG_ERROR("Dest-Doc nicht gefunden !!!"); return; } pDestDoc = pDestShell->GetDocument(); SCTAB nTab = GetViewData()->GetTabNo(); if (pDestDoc != pDoc) { if (bNewDoc) { while (pDestDoc->GetTableCount() > 1) pDestDoc->DeleteTab(0); pDestDoc->RenameTab( 0, String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("______42_____")), sal_False ); } ScMarkData& rMark = GetViewData()->GetMarkData(); SCTAB nTabCount = pDoc->GetTableCount(); SCTAB nTabSelCount = rMark.GetSelectCount(); SvShorts TheTabs; for(SCTAB i=0;iGetName( i, aTabName); TheTabs.push_back(i); for(SCTAB j=i+1;jIsVisible(j))&&(pDoc->IsScenario(j))) { pDoc->GetName( j, aTabName); TheTabs.push_back(j); i=j; } else break; } } } GetFrameWin()->EnterWait(); if (pDoc->GetDrawLayer()) pDestShell->MakeDrawLayer(); if (!bNewDoc && bUndo) pDestDoc->BeginDrawUndo(); // drawing layer must do its own undo actions sal_uLong nErrVal =1; if(nDestTab==SC_TAB_APPEND) nDestTab=pDestDoc->GetTableCount(); SCTAB nDestTab1=nDestTab; for( size_t j=0; jGetName( TheTabs[j], aName ); pDestDoc->CreateValidTabName( aName ); if ( !pDestDoc->InsertTab( nDestTab1, aName ) ) { nErrVal = 0; // total error break; // for } } if ( nErrVal > 0 ) { nDestTab1 = nDestTab; for(size_t i=0;iTransferTab( pDoc, TheTabs[i], nDestTab1, sal_False ); // no insert // TransferTab doesn't copy drawing objects with bInsertNew=FALSE if ( nErrVal > 0 ) pDestDoc->TransferDrawPage( pDoc, TheTabs[i], nDestTab1 ); if(nErrVal>0 && pDoc->IsScenario(TheTabs[i])) { String aComment; Color aColor; sal_uInt16 nFlags; pDoc->GetScenarioData(TheTabs[i], aComment,aColor, nFlags); pDestDoc->SetScenario(nDestTab1,sal_True); pDestDoc->SetScenarioData(nDestTab1,aComment,aColor,nFlags); sal_Bool bActive = pDoc->IsActiveScenario(TheTabs[i]); pDestDoc->SetActiveScenario(nDestTab1, bActive ); sal_Bool bVisible=pDoc->IsVisible(TheTabs[i]); pDestDoc->SetVisible(nDestTab1,bVisible ); } if ( nErrVal > 0 && pDoc->IsTabProtected( TheTabs[i] ) ) pDestDoc->SetTabProtection(nDestTab1, pDoc->GetTabProtection(TheTabs[i])); nDestTab1++; } } String sName; if (!bNewDoc && bUndo) { pDestDoc->GetName(nDestTab, sName); pDestShell->GetUndoManager()->AddUndoAction( new ScUndoImportTab( pDestShell, nDestTab, static_cast(TheTabs.size()), sal_False)); } else { pDestShell->GetUndoManager()->Clear(); } GetFrameWin()->LeaveWait(); switch (nErrVal) { case 0: // interner Fehler oder voll Fehler { ErrorMessage(STR_TABINSERT_ERROR); return; } //break; case 2: ErrorMessage(STR_ABSREFLOST); break; case 3: ErrorMessage(STR_NAMECONFLICT); break; case 4: { ErrorMessage(STR_ABSREFLOST); ErrorMessage(STR_NAMECONFLICT); } break; default: break; } //pDestShell->GetUndoManager()->Clear(); //! Undo implementieren !!! /* String sName; pDestDoc->GetName(nDestTab, sName); pDestShell->GetUndoManager()->AddUndoAction( new ScUndoInsertTab( pDestShell, nDestTab, sal_True, sName ) ); */ if (!bCopy) { if(nTabCount!=nTabSelCount) DeleteTables(TheTabs);// incl. Paint & Undo else ErrorMessage(STR_TABREMOVE_ERROR); } if (bNewDoc) { // ChartListenerCollection must be updated before DeleteTab if ( pDestDoc->IsChartListenerCollectionNeedsUpdate() ) pDestDoc->UpdateChartListenerCollection(); pDestDoc->DeleteTab(static_cast(TheTabs.size())); // first old table //? pDestDoc->SelectTable(0, sal_True); // neue erste Tabelle selektieren if (pDestViewSh) pDestViewSh->TabChanged(); // Pages auf dem Drawing-Layer pDestShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS | PAINT_SIZE ); // PAINT_SIZE fuer Gliederung } else { pDestShell->Broadcast( ScTablesHint( SC_TAB_INSERTED, nDestTab ) ); pDestShell->PostPaintExtras(); pDestShell->PostPaintGridAll(); } TheTabs.clear(); pDestShell->SetDocumentModified(); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); } else // within the documents { ScMarkData& rMark = GetViewData()->GetMarkData(); SCTAB nTabCount = pDoc->GetTableCount(); SvShorts TheTabs; SvShorts TheDestTabs; SvStrings TheTabNames; String aDestName; String *pString; for(SCTAB i=0;iGetName( i, aTabName); TheTabNames.Insert(new String(aTabName),TheTabNames.Count()); for(SCTAB j=i+1;jIsVisible(j))&&(pDoc->IsScenario(j))) { pDoc->GetName( j, aTabName); TheTabNames.Insert(new String(aTabName),TheTabNames.Count()); i=j; } else break; } } } if (bCopy && bUndo) pDoc->BeginDrawUndo(); // drawing layer must do its own undo actions pDoc->GetName( nDestTab, aDestName); SCTAB nDestTab1=nDestTab; SCTAB nMovTab=0; for(int j=0;jGetTableCount(); pString=TheTabNames[sal::static_int_cast(j)]; if(!pDoc->GetTable(*pString,nMovTab)) { nMovTab=nTabCount; } if(!pDoc->GetTable(aDestName,nDestTab1)) { nDestTab1=nTabCount; } pDocShell->MoveTable( nMovTab, nDestTab1, bCopy, sal_False ); // Undo ist hier if(bCopy && pDoc->IsScenario(nMovTab)) { String aComment; Color aColor; sal_uInt16 nFlags; pDoc->GetScenarioData(nMovTab, aComment,aColor, nFlags); pDoc->SetScenario(nDestTab1,sal_True); pDoc->SetScenarioData(nDestTab1,aComment,aColor,nFlags); sal_Bool bActive = pDoc->IsActiveScenario(nMovTab ); pDoc->SetActiveScenario( nDestTab1, bActive ); sal_Bool bVisible=pDoc->IsVisible(nMovTab); pDoc->SetVisible(nDestTab1,bVisible ); } TheTabs.push_back(nMovTab); if(!bCopy) { if(!pDoc->GetTable(*pString,nDestTab1)) { nDestTab1=nTabCount; } } TheDestTabs.push_back(nDestTab1); delete pString; } nTab = GetViewData()->GetTabNo(); if (bUndo) { if (bCopy) { pDocShell->GetUndoManager()->AddUndoAction( new ScUndoCopyTab( pDocShell, TheTabs, TheDestTabs)); } else { pDocShell->GetUndoManager()->AddUndoAction( new ScUndoMoveTab( pDocShell, TheTabs, TheDestTabs)); } } SCTAB nNewTab = nDestTab; if (nNewTab == SC_TAB_APPEND) nNewTab = pDoc->GetTableCount()-1; else if (!bCopy && nTabGetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); sal_Bool bUndo(pDoc->IsUndoEnabled()); sal_Bool bFound = sal_False; SCTAB nPos = 0; String aTabName; SCTAB nCount = pDoc->GetTableCount(); for (SCTAB i=0; iGetName( i, aTabName ); if ( aTabName == rName ) { nPos = i; bFound = sal_True; } } if (bFound) { pDoc->SetVisible( nPos, sal_True ); if (bUndo) { pDocSh->GetUndoManager()->AddUndoAction( new ScUndoShowHideTab( pDocSh, nPos, sal_True ) ); } SetTabNo( nPos, sal_True ); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); pDocSh->PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_EXTRAS); pDocSh->SetDocumentModified(); } else Sound::Beep(); } //---------------------------------------------------------------------------- void ScViewFunc::HideTable( SCTAB nTab ) { ScDocShell* pDocSh = GetViewData()->GetDocShell(); ScDocument* pDoc = pDocSh->GetDocument(); sal_Bool bUndo(pDoc->IsUndoEnabled()); SCTAB nVisible = 0; SCTAB nCount = pDoc->GetTableCount(); for (SCTAB i=0; iIsVisible(i)) ++nVisible; } if (nVisible > 1) { pDoc->SetVisible( nTab, sal_False ); if (bUndo) { pDocSh->GetUndoManager()->AddUndoAction( new ScUndoShowHideTab( pDocSh, nTab, sal_False ) ); } // Views updaten: pDocSh->Broadcast( ScTablesHint( SC_TAB_HIDDEN, nTab ) ); SetTabNo( nTab, sal_True ); SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) ); pDocSh->PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_EXTRAS); pDocSh->SetDocumentModified(); } else Sound::Beep(); } //---------------------------------------------------------------------------- void ScViewFunc::InsertSpecialChar( const String& rStr, const Font& rFont ) { ScEditableTester aTester( this ); if (!aTester.IsEditable()) { ErrorMessage(aTester.GetMessageId()); return; } const sal_Unicode* pChar = rStr.GetBuffer(); ScTabViewShell* pViewShell = GetViewData()->GetViewShell(); SvxFontItem aFontItem( rFont.GetFamily(), rFont.GetName(), rFont.GetStyleName(), rFont.GetPitch(), rFont.GetCharSet(), ATTR_FONT ); // if string contains WEAK characters, set all fonts sal_uInt8 nScript; ScDocument* pDoc = GetViewData()->GetDocument(); if ( pDoc->HasStringWeakCharacters( rStr ) ) nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX; else nScript = pDoc->GetStringScriptType( rStr ); SvxScriptSetItem aSetItem( SID_ATTR_CHAR_FONT, pViewShell->GetPool() ); aSetItem.PutItemForScriptType( nScript, aFontItem ); ApplyUserItemSet( aSetItem.GetItemSet() ); while ( *pChar ) pViewShell->TabKeyInput( KeyEvent( *(pChar++), KeyCode() ) ); } //---------------------------------------------------------------------------- void ScViewFunc::UpdateLineAttrs( SvxBorderLine& rLine, const SvxBorderLine* pDestLine, const SvxBorderLine* pSrcLine, sal_Bool bColor ) { if ( pSrcLine && pDestLine ) { if ( bColor ) { rLine.SetColor ( pSrcLine->GetColor() ); rLine.SetOutWidth ( pDestLine->GetOutWidth() ); rLine.SetInWidth ( pDestLine->GetInWidth() ); rLine.SetDistance ( pDestLine->GetDistance() ); } else { rLine.SetColor ( pDestLine->GetColor() ); rLine.SetOutWidth ( pSrcLine->GetOutWidth() ); rLine.SetInWidth ( pSrcLine->GetInWidth() ); rLine.SetDistance ( pSrcLine->GetDistance() ); } } } #define SET_LINE_ATTRIBUTES(LINE,BOXLINE) \ pBoxLine = aBoxItem.Get##LINE(); \ if ( pBoxLine ) \ { \ if ( pLine ) \ { \ UpdateLineAttrs( aLine, pBoxLine, pLine, bColorOnly ); \ aBoxItem.SetLine( &aLine, BOXLINE ); \ } \ else \ aBoxItem.SetLine( NULL, BOXLINE ); \ } //---------------------------------------------------------------------------- void ScViewFunc::SetSelectionFrameLines( const SvxBorderLine* pLine, sal_Bool bColorOnly ) { // nur wegen Matrix nicht editierbar? Attribute trotzdem ok sal_Bool bOnlyNotBecauseOfMatrix; if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix ) { ErrorMessage(STR_PROTECTIONERR); return; } ScDocument* pDoc = GetViewData()->GetDocument(); ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered ScViewUtil::UnmarkFiltered( aFuncMark, pDoc ); ScDocShell* pDocSh = GetViewData()->GetDocShell(); const ScPatternAttr* pSelAttrs = GetSelectionPattern(); const SfxItemSet& rSelItemSet = pSelAttrs->GetItemSet(); const SfxPoolItem* pBorderAttr = NULL; SfxItemState eItemState = rSelItemSet.GetItemState( ATTR_BORDER, sal_True, &pBorderAttr ); const SfxPoolItem* pTLBRItem = 0; SfxItemState eTLBRState = rSelItemSet.GetItemState( ATTR_BORDER_TLBR, sal_True, &pTLBRItem ); const SfxPoolItem* pBLTRItem = 0; SfxItemState eBLTRState = rSelItemSet.GetItemState( ATTR_BORDER_BLTR, sal_True, &pBLTRItem ); // any of the lines visible? if( (eItemState != SFX_ITEM_DEFAULT) || (eTLBRState != SFX_ITEM_DEFAULT) || (eBLTRState != SFX_ITEM_DEFAULT) ) { // none of the lines don't care? if( (eItemState != SFX_ITEM_DONTCARE) && (eTLBRState != SFX_ITEM_DONTCARE) && (eBLTRState != SFX_ITEM_DONTCARE) ) { SfxItemSet* pOldSet = new SfxItemSet( *(pDoc->GetPool()), ATTR_PATTERN_START, ATTR_PATTERN_END ); SfxItemSet* pNewSet = new SfxItemSet( *(pDoc->GetPool()), ATTR_PATTERN_START, ATTR_PATTERN_END ); //------------------------------------------------------------ const SvxBorderLine* pBoxLine = NULL; SvxBorderLine aLine; // hier wird die pBoxLine benutzt: if( pBorderAttr ) { SvxBoxItem aBoxItem( *(const SvxBoxItem*)pBorderAttr ); SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER ); SET_LINE_ATTRIBUTES(Top,BOX_LINE_TOP) SET_LINE_ATTRIBUTES(Bottom,BOX_LINE_BOTTOM) SET_LINE_ATTRIBUTES(Left,BOX_LINE_LEFT) SET_LINE_ATTRIBUTES(Right,BOX_LINE_RIGHT) aBoxInfoItem.SetLine( aBoxItem.GetTop(), BOXINFO_LINE_HORI ); aBoxInfoItem.SetLine( aBoxItem.GetLeft(), BOXINFO_LINE_VERT ); aBoxInfoItem.ResetFlags(); // Lines auf Valid setzen pOldSet->Put( *pBorderAttr ); pNewSet->Put( aBoxItem ); pNewSet->Put( aBoxInfoItem ); } if( pTLBRItem && ((const SvxLineItem*)pTLBRItem)->GetLine() ) { SvxLineItem aTLBRItem( *(const SvxLineItem*)pTLBRItem ); UpdateLineAttrs( aLine, aTLBRItem.GetLine(), pLine, bColorOnly ); aTLBRItem.SetLine( &aLine ); pOldSet->Put( *pTLBRItem ); pNewSet->Put( aTLBRItem ); } if( pBLTRItem && ((const SvxLineItem*)pBLTRItem)->GetLine() ) { SvxLineItem aBLTRItem( *(const SvxLineItem*)pBLTRItem ); UpdateLineAttrs( aLine, aBLTRItem.GetLine(), pLine, bColorOnly ); aBLTRItem.SetLine( &aLine ); pOldSet->Put( *pBLTRItem ); pNewSet->Put( aBLTRItem ); } ApplyAttributes( pNewSet, pOldSet ); delete pOldSet; delete pNewSet; } else // if ( eItemState == SFX_ITEM_DONTCARE ) { aFuncMark.MarkToMulti(); pDoc->ApplySelectionLineStyle( aFuncMark, pLine, bColorOnly ); } ScRange aMarkRange; aFuncMark.GetMultiMarkArea( aMarkRange ); SCCOL nStartCol = aMarkRange.aStart.Col(); SCROW nStartRow = aMarkRange.aStart.Row(); SCTAB nStartTab = aMarkRange.aStart.Tab(); SCCOL nEndCol = aMarkRange.aEnd.Col(); SCROW nEndRow = aMarkRange.aEnd.Row(); SCTAB nEndTab = aMarkRange.aEnd.Tab(); pDocSh->PostPaint( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE ); pDocSh->UpdateOle( GetViewData() ); pDocSh->SetDocumentModified(); } } #undef SET_LINE_ATTRIBUTES //---------------------------------------------------------------------------- void ScViewFunc::SetConditionalFormat( const ScConditionalFormat& rNew ) { ScDocument* pDoc = GetViewData()->GetDocument(); sal_uLong nIndex = pDoc->AddCondFormat(rNew); // dafuer gibt's kein Undo SfxUInt32Item aItem( ATTR_CONDITIONAL, nIndex ); ApplyAttr( aItem ); // mit Paint und Undo... } //---------------------------------------------------------------------------- void ScViewFunc::SetValidation( const ScValidationData& rNew ) { ScDocument* pDoc = GetViewData()->GetDocument(); sal_uLong nIndex = pDoc->AddValidationEntry(rNew); // dafuer gibt's kein Undo SfxUInt32Item aItem( ATTR_VALIDDATA, nIndex ); ApplyAttr( aItem ); // mit Paint und Undo... }