Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sc / source / ui / view / viewfunc.cxx
blob: a72cfed716e87b07cabdc702a52dbc18c3a385a1 [file] [log] [blame]
/**************************************************************
*
* 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 <editeng/eeitem.hxx>
#include <sfx2/app.hxx>
#include <svx/algitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/editobj.hxx>
#include <editeng/editview.hxx>
#include <editeng/langitem.hxx>
#include <editeng/scripttypeitem.hxx>
#include <sfx2/bindings.hxx>
#include <svl/zforlist.hxx>
#include <svl/zformat.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/sound.hxx>
#include <vcl/virdev.hxx>
#include <vcl/waitobj.hxx>
#include <vcl/wrkwin.hxx>
#include <stdlib.h> // qsort
#include "viewfunc.hxx"
#include "tabvwsh.hxx"
#include "docsh.hxx"
#include "attrib.hxx"
#include "patattr.hxx"
#include "docpool.hxx"
#include "uiitems.hxx"
#include "sc.hrc"
#include "undocell.hxx"
#include "undoblk.hxx"
#include "undotab.hxx"
#include "refundo.hxx"
#include "dbcolect.hxx"
#include "olinetab.hxx"
#include "rangeutl.hxx"
#include "rangenam.hxx"
#include "globstr.hrc"
#include "global.hxx"
#include "stlsheet.hxx"
#include "editutil.hxx"
//CHINA001 #include "namecrea.hxx" // wegen Flags
#include "cell.hxx"
#include "scresid.hxx"
#include "inputhdl.hxx"
#include "scmod.hxx"
#include "inputopt.hxx"
#include "compiler.hxx"
#include "docfunc.hxx"
#include "appoptio.hxx"
#include "dociter.hxx"
#include "sizedev.hxx"
#include "editable.hxx"
#include "scui_def.hxx" //CHINA001
#include "funcdesc.hxx"
#include "docuno.hxx"
#include "cellsuno.hxx"
//==================================================================
ScViewFunc::ScViewFunc( Window* pParent, ScDocShell& rDocSh, ScTabViewShell* pViewShell ) :
ScTabView( pParent, rDocSh, pViewShell ),
bFormatValid( sal_False )
{
}
//UNUSED2008-05 ScViewFunc::ScViewFunc( Window* pParent, const ScViewFunc& rViewFunc, ScTabViewShell* pViewShell ) :
//UNUSED2008-05 ScTabView( pParent, rViewFunc, pViewShell ),
//UNUSED2008-05 bFormatValid( sal_False )
//UNUSED2008-05 {
//UNUSED2008-05 }
ScViewFunc::~ScViewFunc()
{
}
//------------------------------------------------------------------------------------
void ScViewFunc::StartFormatArea()
{
// ueberhaupt aktiviert?
if ( !SC_MOD()->GetInputOptions().GetExtendFormat() )
return;
// start only with single cell (marked or cursor position)
ScRange aMarkRange;
sal_Bool bOk = (GetViewData()->GetSimpleArea( aMarkRange ) == SC_MARK_SIMPLE);
if ( bOk && aMarkRange.aStart != aMarkRange.aEnd )
bOk = sal_False;
if (bOk)
{
bFormatValid = sal_True;
aFormatSource = aMarkRange.aStart;
aFormatArea = ScRange( aFormatSource );
}
else
bFormatValid = sal_False; // keinen alten Bereich behalten
}
sal_Bool ScViewFunc::TestFormatArea( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bAttrChanged )
{
// ueberhaupt aktiviert?
if ( !SC_MOD()->GetInputOptions().GetExtendFormat() )
return sal_False;
// Test: Eingabe mit Zahlformat (bAttrChanged) immer als neue Attributierung behandeln
// (alte Area verwerfen). Wenn das nicht gewollt ist, den if-Teil weglassen:
if ( bAttrChanged )
{
StartFormatArea();
return sal_False;
}
//! Abfrage, ob Zelle leer war ???
sal_Bool bFound = sal_False;
ScRange aNewRange = aFormatArea;
if ( bFormatValid && nTab == aFormatSource.Tab() )
{
if ( nRow >= aFormatArea.aStart.Row() && nRow <= aFormatArea.aEnd.Row() )
{
// innerhalb ?
if ( nCol >= aFormatArea.aStart.Col() && nCol <= aFormatArea.aEnd.Col() )
{
bFound = sal_True; // Bereich nicht aendern
}
// links ?
if ( nCol+1 == aFormatArea.aStart.Col() )
{
bFound = sal_True;
aNewRange.aStart.SetCol( nCol );
}
// rechts ?
if ( nCol == aFormatArea.aEnd.Col()+1 )
{
bFound = sal_True;
aNewRange.aEnd.SetCol( nCol );
}
}
if ( nCol >= aFormatArea.aStart.Col() && nCol <= aFormatArea.aEnd.Col() )
{
// oben ?
if ( nRow+1 == aFormatArea.aStart.Row() )
{
bFound = sal_True;
aNewRange.aStart.SetRow( nRow );
}
// unten ?
if ( nRow == aFormatArea.aEnd.Row()+1 )
{
bFound = sal_True;
aNewRange.aEnd.SetRow( nRow );
}
}
}
if (bFound)
aFormatArea = aNewRange; // erweitern
else
{
bFormatValid = sal_False; // ausserhalb -> abbrechen
if ( bAttrChanged ) // Wert mit Zahlformat eingegeben?
StartFormatArea(); // dann ggf. neu starten
}
return bFound;
}
void ScViewFunc::DoAutoAttributes( SCCOL nCol, SCROW nRow, SCTAB nTab,
sal_Bool bAttrChanged, sal_Bool bAddUndo )
{
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
if (bAddUndo && !pDoc->IsUndoEnabled())
bAddUndo = sal_False;
const ScPatternAttr* pSource = pDoc->GetPattern(
aFormatSource.Col(), aFormatSource.Row(), nTab );
if ( !((const ScMergeAttr&)pSource->GetItem(ATTR_MERGE)).IsMerged() )
{
const ScPatternAttr* pDocOld = pDoc->GetPattern( nCol, nRow, nTab );
// pDocOld ist nur bis zum Apply... gueltig!
ScPatternAttr* pOldPattern = NULL;
if ( bAddUndo )
pOldPattern = new ScPatternAttr( *pDocOld );
const ScStyleSheet* pSrcStyle = pSource->GetStyleSheet();
if ( pSrcStyle && pSrcStyle != pDocOld->GetStyleSheet() )
pDoc->ApplyStyle( nCol, nRow, nTab, *pSrcStyle );
pDoc->ApplyPattern( nCol, nRow, nTab, *pSource );
AdjustRowHeight( nRow, nRow, sal_True ); //! nicht doppelt ?
if ( bAddUndo )
{
const ScPatternAttr* pNewPattern = pDoc->GetPattern( nCol, nRow, nTab );
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoCursorAttr( pDocSh, nCol, nRow, nTab,
pOldPattern, pNewPattern, pSource,
sal_True ) );
delete pOldPattern; // wird im Undo kopiert (Pool)
}
}
if ( bAttrChanged ) // Wert mit Zahlformat eingegeben?
aFormatSource.Set( nCol, nRow, nTab ); // dann als neue Quelle
}
//------------------------------------------------------------------------------------
// Hilfsroutinen
sal_uInt16 ScViewFunc::GetOptimalColWidth( SCCOL nCol, SCTAB nTab, sal_Bool bFormula )
{
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
ScMarkData& rMark = GetViewData()->GetMarkData();
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_uInt16 nTwips = pDoc->GetOptimalColWidth( nCol, nTab, aProv.GetDevice(),
nPPTX, nPPTY, aZoomX, aZoomY, bFormula, &rMark );
return nTwips;
}
sal_Bool ScViewFunc::SelectionEditable( sal_Bool* pOnlyNotBecauseOfMatrix /* = NULL */ )
{
sal_Bool bRet;
ScDocument* pDoc = GetViewData()->GetDocument();
ScMarkData& rMark = GetViewData()->GetMarkData();
if (rMark.IsMarked() || rMark.IsMultiMarked())
bRet = pDoc->IsSelectionEditable( rMark, pOnlyNotBecauseOfMatrix );
else
{
SCCOL nCol = GetViewData()->GetCurX();
SCROW nRow = GetViewData()->GetCurY();
SCTAB nTab = GetViewData()->GetTabNo();
bRet = pDoc->IsBlockEditable( nTab, nCol, nRow, nCol, nRow,
pOnlyNotBecauseOfMatrix );
}
return bRet;
}
#ifndef LRU_MAX
#define LRU_MAX 10
#endif
sal_Bool lcl_FunctionKnown( sal_uInt16 nOpCode )
{
const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
if ( pFuncList )
{
sal_uLong nCount = pFuncList->GetCount();
for (sal_uLong i=0; i<nCount; i++)
if ( pFuncList->GetFunction(i)->nFIndex == nOpCode )
return sal_True;
}
return sal_False;
}
sal_Bool lcl_AddFunction( ScAppOptions& rAppOpt, sal_uInt16 nOpCode )
{
sal_uInt16 nOldCount = rAppOpt.GetLRUFuncListCount();
sal_uInt16* pOldList = rAppOpt.GetLRUFuncList();
sal_uInt16 nPos;
for (nPos=0; nPos<nOldCount; nPos++)
if (pOldList[nPos] == nOpCode) // is the function already in the list?
{
if ( nPos == 0 )
return sal_False; // already at the top -> no change
// count doesn't change, so the original array is modified
for (sal_uInt16 nCopy=nPos; nCopy>0; nCopy--)
pOldList[nCopy] = pOldList[nCopy-1];
pOldList[0] = nOpCode;
return sal_True; // list has changed
}
if ( !lcl_FunctionKnown( nOpCode ) )
return sal_False; // not in function list -> no change
sal_uInt16 nNewCount = Min( (sal_uInt16)(nOldCount + 1), (sal_uInt16)LRU_MAX );
sal_uInt16 nNewList[LRU_MAX];
nNewList[0] = nOpCode;
for (nPos=1; nPos<nNewCount; nPos++)
nNewList[nPos] = pOldList[nPos-1];
rAppOpt.SetLRUFuncList( nNewList, nNewCount );
return sal_True; // list has changed
}
// eigentliche Funktionen
// Eingabe - Undo OK
void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab, const String& rString,
sal_Bool bRecord, const EditTextObject* pData )
{
ScDocument* pDoc = GetViewData()->GetDocument();
ScMarkData& rMark = GetViewData()->GetMarkData();
SCTAB nTabCount = pDoc->GetTableCount();
SCTAB nSelCount = rMark.GetSelectCount();
SCTAB i;
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocShellModificator aModificator( *pDocSh );
ScEditableTester aTester( pDoc, nCol,nRow, nCol,nRow, rMark );
if (aTester.IsEditable())
{
sal_Bool bEditDeleted = sal_False;
sal_uInt8 nOldScript = 0;
ScBaseCell** ppOldCells = NULL;
sal_Bool* pHasFormat = NULL;
sal_uLong* pOldFormats = NULL;
SCTAB* pTabs = NULL;
SCTAB nUndoPos = 0;
EditTextObject* pUndoData = NULL;
if ( bRecord )
{
ppOldCells = new ScBaseCell*[nSelCount];
pHasFormat = new sal_Bool[nSelCount];
pOldFormats = new sal_uLong[nSelCount];
pTabs = new SCTAB[nSelCount];
nUndoPos = 0;
for (i=0; i<nTabCount; i++)
if (rMark.GetTableSelect(i))
{
pTabs[nUndoPos] = i;
ScBaseCell* pDocCell;
pDoc->GetCell( nCol, nRow, i, pDocCell );
if ( pDocCell )
{
ppOldCells[nUndoPos] = pDocCell->CloneWithoutNote( *pDoc );
if ( pDocCell->GetCellType() == CELLTYPE_EDIT )
bEditDeleted = sal_True;
sal_uInt8 nDocScript = pDoc->GetScriptType( nCol, nRow, i, pDocCell );
if ( nOldScript == 0 )
nOldScript = nDocScript;
else if ( nDocScript != nOldScript )
bEditDeleted = sal_True;
}
else
{
ppOldCells[nUndoPos] = NULL;
}
const SfxPoolItem* pItem;
const ScPatternAttr* pPattern = pDoc->GetPattern(nCol, nRow, i);
if ( SFX_ITEM_SET == pPattern->GetItemSet().GetItemState(
ATTR_VALUE_FORMAT,sal_False,&pItem) )
{
pHasFormat[nUndoPos] = sal_True;
pOldFormats[nUndoPos] = ((const SfxUInt32Item*)pItem)->GetValue();
}
else
pHasFormat[nUndoPos] = sal_False;
++nUndoPos;
}
DBG_ASSERT( nUndoPos==nSelCount, "nUndoPos!=nSelCount" );
pUndoData = ( pData ? pData->Clone() : NULL );
}
bool bFormula = false;
// a single '=' character is handled as string (needed for special filters)
if ( rString.Len() > 1 )
{
if ( rString.GetChar(0) == '=' )
{
// handle as formula
bFormula = true;
}
else if ( rString.GetChar(0) == '+' || rString.GetChar(0) == '-' )
{
// if there is more than one leading '+' or '-' character, remove the additional ones
String aString( rString );
xub_StrLen nIndex = 1;
xub_StrLen nLen = aString.Len();
while ( nIndex < nLen && ( aString.GetChar( nIndex ) == '+' || aString.GetChar( nIndex ) == '-' ) )
{
++nIndex;
}
aString.Erase( 1, nIndex - 1 );
// if the remaining part without the leading '+' or '-' character
// is non-empty and not a number, handle as formula
if ( aString.Len() > 1 )
{
sal_uInt32 nFormat = 0;
pDoc->GetNumberFormat( nCol, nRow, nTab, nFormat );
SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
double fNumber = 0;
if ( !pFormatter->IsNumberFormat( aString, nFormat, fNumber ) )
{
bFormula = true;
}
}
}
}
sal_Bool bNumFmtChanged = sal_False;
if ( bFormula )
{ // Formel, compile mit AutoCorrection
for (i=0; i<nTabCount; i++)
if (rMark.GetTableSelect(i))
break;
ScAddress aPos( nCol, nRow, i );
ScCompiler aComp( pDoc, aPos);
aComp.SetGrammar(pDoc->GetGrammar());
//2do: AutoCorrection via CalcOptions abschaltbar machen
aComp.SetAutoCorrection( sal_True );
if ( rString.GetChar(0) == '+' || rString.GetChar(0) == '-' )
{
aComp.SetExtendedErrorDetection( true );
}
String aFormula( rString );
ScTokenArray* pArr;
sal_Bool bAgain;
do
{
bAgain = sal_False;
sal_Bool bAddEqual = sal_False;
ScTokenArray* pArrFirst = pArr = aComp.CompileString( aFormula );
sal_Bool bCorrected = aComp.IsCorrected();
if ( bCorrected )
{ // probieren, mit erster Parser-Korrektur neu zu parsen
pArr = aComp.CompileString( aComp.GetCorrectedFormula() );
}
if ( !pArr->GetCodeError() )
{
bAddEqual = sal_True;
aComp.CompileTokenArray();
bCorrected |= aComp.IsCorrected();
}
if ( bCorrected )
{
String aCorrectedFormula;
if ( bAddEqual )
{
aCorrectedFormula = '=';
aCorrectedFormula += aComp.GetCorrectedFormula();
}
else
aCorrectedFormula = aComp.GetCorrectedFormula();
short nResult;
if ( aCorrectedFormula.Len() == 1 )
nResult = RET_NO; // leere Formel, nur '='
else
{
String aMessage( ScResId( SCSTR_FORMULA_AUTOCORRECTION ) );
aMessage += aCorrectedFormula;
nResult = QueryBox( GetViewData()->GetDialogParent(),
WinBits(WB_YES_NO | WB_DEF_YES),
aMessage ).Execute();
}
if ( nResult == RET_YES )
{
aFormula = aCorrectedFormula;
if ( pArr != pArrFirst )
delete pArrFirst;
bAgain = sal_True;
}
else
{
if ( pArr != pArrFirst )
{
delete pArr;
pArr = pArrFirst;
}
}
}
} while ( bAgain );
// um in mehreren Tabellen eingesetzt zu werden, muss die Formel
// via ScFormulaCell copy-ctor evtl. wegen RangeNames neu kompiliert
// werden, gleiches Code-Array fuer alle Zellen geht nicht.
// Wenn das Array einen Fehler enthaelt, muss in den neu erzeugten
// Zellen RPN geloescht und der Fehler explizit gesetzt werden, da
// via FormulaCell copy-ctor und Interpreter das, wenn moeglich,
// wieder glattgebuegelt wird, zu intelligent.. z.B.: =1))
sal_uInt16 nError = pArr->GetCodeError();
if ( !nError )
{
// #68693# update list of recent functions with all functions that
// are not within parentheses
ScModule* pScMod = SC_MOD();
ScAppOptions aAppOpt = pScMod->GetAppOptions();
sal_Bool bOptChanged = sal_False;
formula::FormulaToken** ppToken = pArr->GetArray();
sal_uInt16 nTokens = pArr->GetLen();
sal_uInt16 nLevel = 0;
for (sal_uInt16 nTP=0; nTP<nTokens; nTP++)
{
formula::FormulaToken* pTok = ppToken[nTP];
OpCode eOp = pTok->GetOpCode();
if ( eOp == ocOpen )
++nLevel;
else if ( eOp == ocClose && nLevel )
--nLevel;
if ( nLevel == 0 && pTok->IsFunction() &&
lcl_AddFunction( aAppOpt, sal::static_int_cast<sal_uInt16>( eOp ) ) )
bOptChanged = sal_True;
}
if ( bOptChanged )
{
pScMod->SetAppOptions(aAppOpt);
pScMod->RecentFunctionsChanged();
}
}
ScFormulaCell aCell( pDoc, aPos, pArr,formula::FormulaGrammar::GRAM_DEFAULT, MM_NONE );
delete pArr;
sal_Bool bAutoCalc = pDoc->GetAutoCalc();
SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
for ( ; i<nTabCount; i++)
{
if (rMark.GetTableSelect(i))
{
aPos.SetTab( i );
sal_uLong nIndex = (sal_uLong) ((SfxUInt32Item*) pDoc->GetAttr(
nCol, nRow, i, ATTR_VALUE_FORMAT ))->GetValue();
if ( pFormatter->GetType( nIndex ) == NUMBERFORMAT_TEXT ||
( ( rString.GetChar(0) == '+' || rString.GetChar(0) == '-' ) && nError && rString.Equals( aFormula ) ) )
{
if ( pData )
{
ScEditCell* pCell = new ScEditCell( pData, pDoc, NULL );
pDoc->PutCell( aPos, pCell );
}
else
{
ScStringCell* pCell = new ScStringCell( aFormula );
pDoc->PutCell( aPos, pCell );
}
}
else
{
DELETEZ(pUndoData);
ScFormulaCell* pCell = new ScFormulaCell( aCell, *pDoc, aPos );
if ( nError )
{
pCell->GetCode()->DelRPN();
pCell->SetErrCode( nError );
if(pCell->GetCode()->IsHyperLink())
pCell->GetCode()->SetHyperLink(sal_False);
}
pDoc->PutCell( aPos, pCell );
if ( !bAutoCalc )
{ // einmal nur die Zelle berechnen und wieder dirty setzen
pCell->Interpret();
pCell->SetDirtyVar();
pDoc->PutInFormulaTree( pCell );
}
}
}
}
}
else
{
for (i=0; i<nTabCount; i++)
if (rMark.GetTableSelect(i))
if (pDoc->SetString( nCol, nRow, i, rString ))
bNumFmtChanged = sal_True;
}
// row height must be changed if new text has a different script type
for (i=0; i<nTabCount && !bEditDeleted; i++)
if (rMark.GetTableSelect(i))
if ( pDoc->GetScriptType( nCol, nRow, i ) != nOldScript )
bEditDeleted = sal_True;
HideAllCursors();
if (bEditDeleted || pDoc->HasAttrib( nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_NEEDHEIGHT ))
AdjustRowHeight(nRow,nRow);
sal_Bool bAutoFormat = TestFormatArea(nCol, nRow, nTab, bNumFmtChanged);
if (bAutoFormat)
DoAutoAttributes(nCol, nRow, nTab, bNumFmtChanged, bRecord);
if ( bRecord )
{ // wg. ChangeTrack erst jetzt
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoEnterData( pDocSh, nCol, nRow, nTab, nUndoPos, pTabs,
ppOldCells, pHasFormat, pOldFormats,
rString, pUndoData ) );
}
for (i=0; i<nTabCount; i++)
if (rMark.GetTableSelect(i))
pDocSh->PostPaintCell( nCol, nRow, i );
ShowAllCursors();
pDocSh->UpdateOle(GetViewData());
// #i97876# Spreadsheet data changes are not notified
ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
if ( pModelObj && pModelObj->HasChangesListeners() )
{
ScRangeList aChangeRanges;
for ( i = 0; i < nTabCount; ++i )
{
if ( rMark.GetTableSelect( i ) )
{
aChangeRanges.Append( ScRange( nCol, nRow, i ) );
}
}
pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
}
aModificator.SetDocumentModified();
}
else
{
ErrorMessage(aTester.GetMessageId());
PaintArea( nCol, nRow, nCol, nRow ); // da steht evtl. noch die Edit-Engine
}
}
// Wert in einzele Zelle eintragen (nur auf nTab)
void ScViewFunc::EnterValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rValue )
{
ScDocument* pDoc = GetViewData()->GetDocument();
ScDocShell* pDocSh = GetViewData()->GetDocShell();
sal_Bool bUndo (pDoc->IsUndoEnabled());
if ( pDoc && pDocSh )
{
ScDocShellModificator aModificator( *pDocSh );
ScEditableTester aTester( pDoc, nTab, nCol,nRow, nCol,nRow );
if (aTester.IsEditable())
{
ScAddress aPos( nCol, nRow, nTab );
ScBaseCell* pOldCell = pDoc->GetCell( aPos );
sal_Bool bNeedHeight = ( pOldCell && pOldCell->GetCellType() == CELLTYPE_EDIT )
|| pDoc->HasAttrib(
nCol,nRow,nTab, nCol,nRow,nTab, HASATTR_NEEDHEIGHT );
// Undo
ScBaseCell* pUndoCell = (bUndo && pOldCell) ? pOldCell->CloneWithoutNote( *pDoc ) : 0;
pDoc->SetValue( nCol, nRow, nTab, rValue );
// wg. ChangeTrack nach Aenderung im Dokument
if (bUndo)
{
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoEnterValue( pDocSh, aPos, pUndoCell, rValue, bNeedHeight ) );
}
/*! Zeilenhoehe anpassen? Dann auch bei Undo...
if (bNeedHeight)
AdjustRowHeight(nRow,nRow);
*/
pDocSh->PostPaintCell( aPos );
pDocSh->UpdateOle(GetViewData());
aModificator.SetDocumentModified();
}
else
ErrorMessage(aTester.GetMessageId());
}
}
void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab, const EditTextObject* pData,
sal_Bool bRecord, sal_Bool bTestSimple )
{
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScMarkData& rMark = GetViewData()->GetMarkData();
ScDocument* pDoc = pDocSh->GetDocument();
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
ScDocShellModificator aModificator( *pDocSh );
ScEditableTester aTester( pDoc, nTab, nCol,nRow, nCol,nRow );
if (aTester.IsEditable())
{
//
// Test auf Attribute
//
sal_Bool bSimple = sal_False;
sal_Bool bCommon = sal_False;
ScPatternAttr* pCellAttrs = NULL;
EditTextObject* pNewData = NULL;
String aString;
const ScPatternAttr* pOldPattern = pDoc->GetPattern( nCol, nRow, nTab );
ScTabEditEngine aEngine( *pOldPattern, pDoc->GetEnginePool() );
aEngine.SetText(*pData);
if (bTestSimple) // Testen, ob einfacher String ohne Attribute
{
ScEditAttrTester aAttrTester( &aEngine );
bSimple = !aAttrTester.NeedsObject();
bCommon = aAttrTester.NeedsCellAttr();
// formulas have to be recognized even if they're formatted
// (but commmon attributes are still collected)
if ( !bSimple && aEngine.GetParagraphCount() == 1 )
{
String aParStr = aEngine.GetText( (sal_uInt16) 0 );
if ( aParStr.GetChar(0) == '=' )
bSimple = sal_True;
}
if (bCommon) // Attribute fuer Tabelle
{
pCellAttrs = new ScPatternAttr( *pOldPattern );
pCellAttrs->GetFromEditItemSet( &aAttrTester.GetAttribs() );
//! remove common attributes from EditEngine?
}
}
// #i97726# always get text for "repeat" of undo action
aString = ScEditUtil::GetSpaceDelimitedString(aEngine);
//
// Undo
//
SCTAB nTabCount = pDoc->GetTableCount();
SCTAB nSelCount = rMark.GetSelectCount();
SCTAB i;
ScBaseCell** ppOldCells = NULL;
SCTAB* pTabs = NULL;
SCTAB nPos = 0;
EditTextObject* pUndoData = NULL;
if (bRecord && !bSimple)
{
ppOldCells = new ScBaseCell*[nSelCount];
pTabs = new SCTAB[nSelCount];
nPos = 0;
for (i=0; i<nTabCount; i++)
if (rMark.GetTableSelect(i))
{
pTabs[nPos] = i;
ScBaseCell* pDocCell;
pDoc->GetCell( nCol, nRow, i, pDocCell );
ppOldCells[nPos] = pDocCell ? pDocCell->CloneWithoutNote( *pDoc ) : 0;
++nPos;
}
DBG_ASSERT( nPos==nSelCount, "nPos!=nSelCount" );
pUndoData = pData->Clone();
}
//
// Daten eintragen
//
if (bCommon)
pDoc->ApplyPattern(nCol,nRow,nTab,*pCellAttrs); //! Undo
if (bSimple)
{
if (bCommon)
AdjustRowHeight(nRow,nRow);
EnterData(nCol,nRow,nTab,aString,bRecord);
}
else
{
for (i=0; i<nTabCount; i++)
if (rMark.GetTableSelect(i))
pDoc->PutCell( nCol, nRow, i, new ScEditCell( pData, pDoc, NULL ) );
if ( bRecord )
{ // wg. ChangeTrack erst jetzt
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoEnterData( pDocSh, nCol, nRow, nTab, nPos, pTabs,
ppOldCells, NULL, NULL, aString,
pUndoData ) );
}
HideAllCursors();
AdjustRowHeight(nRow,nRow);
for (i=0; i<nTabCount; i++)
if (rMark.GetTableSelect(i))
pDocSh->PostPaintCell( nCol, nRow, i );
ShowAllCursors();
pDocSh->UpdateOle(GetViewData());
// #i97876# Spreadsheet data changes are not notified
ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
if ( pModelObj && pModelObj->HasChangesListeners() )
{
ScRangeList aChangeRanges;
for ( i = 0; i < nTabCount; ++i )
{
if ( rMark.GetTableSelect( i ) )
{
aChangeRanges.Append( ScRange( nCol, nRow, i ) );
}
}
pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
}
aModificator.SetDocumentModified();
}
delete pCellAttrs;
delete pNewData;
}
else
{
ErrorMessage(aTester.GetMessageId());
PaintArea( nCol, nRow, nCol, nRow ); // da steht evtl. noch die Edit-Engine
}
}
void ScViewFunc::EnterDataAtCursor( const String& rString )
{
SCCOL nPosX = GetViewData()->GetCurX();
SCROW nPosY = GetViewData()->GetCurY();
SCTAB nTab = GetViewData()->GetTabNo();
EnterData( nPosX, nPosY, nTab, rString );
}
void ScViewFunc::EnterMatrix( const String& rString )
{
ScViewData* pData = GetViewData();
const ScMarkData& rMark = pData->GetMarkData();
if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
{
// nichts markiert -> automatisch Block mit Groesse des Ergebnisses
// Formel temporaer berechnen, um an die Groesse heranzukommen
ScDocument* pDoc = pData->GetDocument();
SCCOL nCol = pData->GetCurX();
SCROW nRow = pData->GetCurY();
SCTAB nTab = pData->GetTabNo();
ScFormulaCell aFormCell( pDoc, ScAddress(nCol,nRow,nTab), rString,formula::FormulaGrammar::GRAM_DEFAULT, MM_FORMULA );
SCSIZE nSizeX;
SCSIZE nSizeY;
aFormCell.GetResultDimensions( nSizeX, nSizeY );
if ( nSizeX != 0 && nSizeY != 0 &&
nCol+nSizeX-1 <= sal::static_int_cast<SCSIZE>(MAXCOL) &&
nRow+nSizeY-1 <= sal::static_int_cast<SCSIZE>(MAXROW) )
{
ScRange aResult( nCol, nRow, nTab,
sal::static_int_cast<SCCOL>(nCol+nSizeX-1),
sal::static_int_cast<SCROW>(nRow+nSizeY-1), nTab );
MarkRange( aResult, sal_False );
}
}
ScRange aRange;
if (pData->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
{
ScDocShell* pDocSh = pData->GetDocShell();
sal_Bool bSuccess = pDocSh->GetDocFunc().EnterMatrix( aRange, &rMark, NULL, rString, sal_False, sal_False, EMPTY_STRING, formula::FormulaGrammar::GRAM_DEFAULT );
if (bSuccess)
pDocSh->UpdateOle(GetViewData());
}
else
ErrorMessage(STR_NOMULTISELECT);
}
sal_uInt8 ScViewFunc::GetSelectionScriptType()
{
sal_uInt8 nScript = 0;
ScDocument* pDoc = GetViewData()->GetDocument();
const ScMarkData& rMark = GetViewData()->GetMarkData();
if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
{
// no selection -> cursor
nScript = pDoc->GetScriptType( GetViewData()->GetCurX(),
GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
}
else
{
ScRangeList aRanges;
rMark.FillRangeListWithMarks( &aRanges, sal_False );
sal_uLong nCount = aRanges.Count();
for (sal_uLong i=0; i<nCount; i++)
{
ScRange aRange = *aRanges.GetObject(i);
ScCellIterator aIter( pDoc, aRange );
ScBaseCell* pCell = aIter.GetFirst();
while ( pCell )
{
nScript |= pDoc->GetScriptType( aIter.GetCol(), aIter.GetRow(), aIter.GetTab(), pCell );
pCell = aIter.GetNext();
}
}
}
if (nScript == 0)
nScript = ScGlobal::GetDefaultScriptType();
return nScript;
}
const ScPatternAttr* ScViewFunc::GetSelectionPattern()
{
// Don't use UnmarkFiltered in slot state functions, for performance reasons.
// The displayed state is always that of the whole selection including filtered rows.
const ScMarkData& rMark = GetViewData()->GetMarkData();
ScDocument* pDoc = GetViewData()->GetDocument();
if ( rMark.IsMarked() || rMark.IsMultiMarked() )
{
// MarkToMulti is no longer necessary for pDoc->GetSelectionPattern
const ScPatternAttr* pAttr = pDoc->GetSelectionPattern( rMark );
return pAttr;
}
else
{
SCCOL nCol = GetViewData()->GetCurX();
SCROW nRow = GetViewData()->GetCurY();
SCTAB nTab = GetViewData()->GetTabNo();
ScMarkData aTempMark( rMark ); // copy sheet selection
aTempMark.SetMarkArea( ScRange( nCol, nRow, nTab ) );
const ScPatternAttr* pAttr = pDoc->GetSelectionPattern( aTempMark );
return pAttr;
}
}
void ScViewFunc::GetSelectionFrame( SvxBoxItem& rLineOuter,
SvxBoxInfoItem& rLineInner )
{
ScDocument* pDoc = GetViewData()->GetDocument();
const ScMarkData& rMark = GetViewData()->GetMarkData();
if ( rMark.IsMarked() || rMark.IsMultiMarked() )
{
if ( rMark.IsMultiMarked() )
{
ScMarkData aNewMark( rMark ); // use local copy for MarkToSimple
aNewMark.MarkToSimple(); // simple block is needed for GetSelectionFrame
pDoc->GetSelectionFrame( aNewMark, rLineOuter, rLineInner );
}
else
pDoc->GetSelectionFrame( rMark, rLineOuter, rLineInner );
}
else
{
const ScPatternAttr* pAttrs =
pDoc->GetPattern( GetViewData()->GetCurX(),
GetViewData()->GetCurY(),
GetViewData()->GetTabNo() );
rLineOuter = (const SvxBoxItem&) (pAttrs->GetItem( ATTR_BORDER ));
rLineInner = (const SvxBoxInfoItem&)(pAttrs->GetItem( ATTR_BORDER_INNER ));
rLineInner.SetTable(sal_False);
rLineInner.SetDist(sal_True);
rLineInner.SetMinDist(sal_False);
}
}
//
// Attribute anwenden - Undo OK
//
// kompletter Set ( ATTR_STARTINDEX, ATTR_ENDINDEX )
//
void ScViewFunc::ApplyAttributes( const SfxItemSet* pDialogSet,
const SfxItemSet* pOldSet,
sal_Bool bRecord )
{
// nur wegen Matrix nicht editierbar? Attribute trotzdem ok
sal_Bool bOnlyNotBecauseOfMatrix;
if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
ScPatternAttr aOldAttrs( new SfxItemSet(*pOldSet) );
ScPatternAttr aNewAttrs( new SfxItemSet(*pDialogSet) );
aNewAttrs.DeleteUnchanged( &aOldAttrs );
if ( pDialogSet->GetItemState( ATTR_VALUE_FORMAT ) == SFX_ITEM_SET )
{ // #82521# don't reset to default SYSTEM GENERAL if not intended
sal_uInt32 nOldFormat =
((const SfxUInt32Item&)pOldSet->Get( ATTR_VALUE_FORMAT )).GetValue();
sal_uInt32 nNewFormat =
((const SfxUInt32Item&)pDialogSet->Get( ATTR_VALUE_FORMAT )).GetValue();
if ( nNewFormat != nOldFormat )
{
SvNumberFormatter* pFormatter =
GetViewData()->GetDocument()->GetFormatTable();
const SvNumberformat* pOldEntry = pFormatter->GetEntry( nOldFormat );
LanguageType eOldLang =
pOldEntry ? pOldEntry->GetLanguage() : LANGUAGE_DONTKNOW;
const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewFormat );
LanguageType eNewLang =
pNewEntry ? pNewEntry->GetLanguage() : LANGUAGE_DONTKNOW;
if ( eNewLang != eOldLang )
{
aNewAttrs.GetItemSet().Put(
SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
// #40606# nur die Sprache geaendert -> Zahlformat-Attribut nicht anfassen
sal_uInt32 nNewMod = nNewFormat % SV_COUNTRY_LANGUAGE_OFFSET;
if ( nNewMod == ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) &&
nNewMod <= SV_MAX_ANZ_STANDARD_FORMATE )
aNewAttrs.GetItemSet().ClearItem( ATTR_VALUE_FORMAT );
}
}
}
const SvxBoxItem* pOldOuter = (const SvxBoxItem*) &pOldSet->Get( ATTR_BORDER );
const SvxBoxItem* pNewOuter = (const SvxBoxItem*) &pDialogSet->Get( ATTR_BORDER );
const SvxBoxInfoItem* pOldInner = (const SvxBoxInfoItem*) &pOldSet->Get( ATTR_BORDER_INNER );
const SvxBoxInfoItem* pNewInner = (const SvxBoxInfoItem*) &pDialogSet->Get( ATTR_BORDER_INNER );
SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
SfxItemPool* pNewPool = rNewSet.GetPool();
pNewPool->Put( *pNewOuter ); // noch nicht loeschen
pNewPool->Put( *pNewInner );
rNewSet.ClearItem( ATTR_BORDER );
rNewSet.ClearItem( ATTR_BORDER_INNER );
/*
* Feststellen, ob Rahmenattribute zu setzen sind:
* 1. Neu != Alt
* 2. Ist eine der Linien nicht-DontCare (seit 238.f: IsxxValid())
*
*/
sal_Bool bFrame = (pDialogSet->GetItemState( ATTR_BORDER ) != SFX_ITEM_DEFAULT)
|| (pDialogSet->GetItemState( ATTR_BORDER_INNER ) != SFX_ITEM_DEFAULT);
if ( pNewOuter==pOldOuter && pNewInner==pOldInner )
bFrame = sal_False;
// das sollte doch der Pool abfangen: ?!??!??
if ( bFrame && pNewOuter && pNewInner )
if ( *pNewOuter == *pOldOuter && *pNewInner == *pOldInner )
bFrame = sal_False;
if ( pNewInner )
{
bFrame = bFrame
&& ( pNewInner->IsValid(VALID_LEFT)
|| pNewInner->IsValid(VALID_RIGHT)
|| pNewInner->IsValid(VALID_TOP)
|| pNewInner->IsValid(VALID_BOTTOM)
|| pNewInner->IsValid(VALID_HORI)
|| pNewInner->IsValid(VALID_VERT) );
}
else
bFrame = sal_False;
if (!bFrame)
ApplySelectionPattern( aNewAttrs, bRecord ); // nur normale
else
{
// wenn neue Items Default-Items sind, so muessen die
// alten Items geputtet werden:
sal_Bool bDefNewOuter = ( SFX_ITEMS_STATICDEFAULT == pNewOuter->GetKind() );
sal_Bool bDefNewInner = ( SFX_ITEMS_STATICDEFAULT == pNewInner->GetKind() );
ApplyPatternLines( aNewAttrs,
bDefNewOuter ? pOldOuter : pNewOuter,
bDefNewInner ? pOldInner : pNewInner,
bRecord );
}
pNewPool->Remove( *pNewOuter ); // freigeben
pNewPool->Remove( *pNewInner );
// Hoehen anpassen
AdjustBlockHeight();
// CellContentChanged wird von ApplySelectionPattern / ApplyPatternLines gerufen
}
void ScViewFunc::ApplyAttr( const SfxPoolItem& rAttrItem )
{
// nur wegen Matrix nicht editierbar? Attribute trotzdem ok
sal_Bool bOnlyNotBecauseOfMatrix;
if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
ScPatternAttr aNewAttrs( new SfxItemSet( *GetViewData()->GetDocument()->GetPool(),
ATTR_PATTERN_START, ATTR_PATTERN_END ) );
aNewAttrs.GetItemSet().Put( rAttrItem );
// Wenn Ausrichtung eingestellt wird (ueber Buttons), immer Einzug 0
if ( rAttrItem.Which() == ATTR_HOR_JUSTIFY )
aNewAttrs.GetItemSet().Put( SfxUInt16Item( ATTR_INDENT, 0 ) );
ApplySelectionPattern( aNewAttrs );
AdjustBlockHeight();
// CellContentChanged wird von ApplySelectionPattern gerufen
}
// Pattern und Rahmen
void ScViewFunc::ApplyPatternLines( const ScPatternAttr& rAttr, const SvxBoxItem* pNewOuter,
const SvxBoxInfoItem* pNewInner, sal_Bool bRecord )
{
ScDocument* pDoc = GetViewData()->GetDocument();
ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered
ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
ScRange aMarkRange;
aFuncMark.MarkToSimple();
sal_Bool bMulti = aFuncMark.IsMultiMarked();
if (bMulti)
aFuncMark.GetMultiMarkArea( aMarkRange );
else if (aFuncMark.IsMarked())
aFuncMark.GetMarkArea( aMarkRange );
else
{
aMarkRange = ScRange( GetViewData()->GetCurX(),
GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
DoneBlockMode();
InitOwnBlockMode();
aFuncMark.SetMarkArea(aMarkRange);
MarkDataChanged();
}
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocShellModificator aModificator( *pDocSh );
if (bRecord)
{
ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
SCTAB nStartTab = aMarkRange.aStart.Tab();
SCTAB nTabCount = pDoc->GetTableCount();
pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
for (SCTAB i=0; i<nTabCount; i++)
if (i != nStartTab && aFuncMark.GetTableSelect(i))
pUndoDoc->AddUndoTab( i, i );
ScRange aCopyRange = aMarkRange;
aCopyRange.aStart.SetTab(0);
aCopyRange.aEnd.SetTab(nTabCount-1);
pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pUndoDoc, &aFuncMark );
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoSelectionAttr(
pDocSh, aFuncMark,
aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), aMarkRange.aStart.Tab(),
aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(), aMarkRange.aEnd.Tab(),
pUndoDoc, bMulti, &rAttr, pNewOuter, pNewInner ) );
}
sal_uInt16 nExt = SC_PF_TESTMERGE;
pDocSh->UpdatePaintExt( nExt, aMarkRange ); // content before the change
pDoc->ApplySelectionFrame( aFuncMark, pNewOuter, pNewInner );
pDocSh->UpdatePaintExt( nExt, aMarkRange ); // content after the change
aFuncMark.MarkToMulti();
pDoc->ApplySelectionPattern( rAttr, aFuncMark );
pDocSh->PostPaint( aMarkRange, PAINT_GRID, nExt );
pDocSh->UpdateOle(GetViewData());
aModificator.SetDocumentModified();
CellContentChanged();
StartFormatArea();
}
// nur Pattern
void ScViewFunc::ApplySelectionPattern( const ScPatternAttr& rAttr,
sal_Bool bRecord, sal_Bool bCursorOnly )
{
ScViewData* pViewData = GetViewData();
ScDocShell* pDocSh = pViewData->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
ScMarkData aFuncMark( pViewData->GetMarkData() ); // local copy for UnmarkFiltered
ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
// State from old ItemSet doesn't matter for paint flags, as any change will be
// from SFX_ITEM_SET in the new ItemSet (default is ignored in ApplyPattern).
// New alignment is checked (check in PostPaint isn't enough) in case a right
// alignment is changed to left.
const SfxItemSet& rNewSet = rAttr.GetItemSet();
sal_Bool bSetLines = rNewSet.GetItemState( ATTR_BORDER, sal_True ) == SFX_ITEM_SET ||
rNewSet.GetItemState( ATTR_SHADOW, sal_True ) == SFX_ITEM_SET;
sal_Bool bSetAlign = rNewSet.GetItemState( ATTR_HOR_JUSTIFY, sal_True ) == SFX_ITEM_SET;
sal_uInt16 nExtFlags = 0;
if ( bSetLines )
nExtFlags |= SC_PF_LINES;
if ( bSetAlign )
nExtFlags |= SC_PF_WHOLEROWS;
ScDocShellModificator aModificator( *pDocSh );
sal_Bool bMulti = aFuncMark.IsMultiMarked();
aFuncMark.MarkToMulti();
sal_Bool bOnlyTab = (!aFuncMark.IsMultiMarked() && !bCursorOnly && aFuncMark.GetSelectCount() > 1);
if (bOnlyTab)
{
SCCOL nCol = pViewData->GetCurX();
SCROW nRow = pViewData->GetCurY();
SCTAB nTab = pViewData->GetTabNo();
aFuncMark.SetMarkArea(ScRange(nCol,nRow,nTab));
aFuncMark.MarkToMulti();
}
ScRangeList aChangeRanges;
if (aFuncMark.IsMultiMarked() && !bCursorOnly)
{
ScRange aMarkRange;
aFuncMark.GetMultiMarkArea( aMarkRange );
SCTAB nTabCount = pDoc->GetTableCount();
for ( SCTAB i = 0; i < nTabCount; ++i )
{
if ( aFuncMark.GetTableSelect( i ) )
{
ScRange aChangeRange( aMarkRange );
aChangeRange.aStart.SetTab( i );
aChangeRange.aEnd.SetTab( i );
aChangeRanges.Append( aChangeRange );
}
}
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 (bRecord)
{
ScRange aCopyRange = aMarkRange;
aCopyRange.aStart.SetTab(0);
aCopyRange.aEnd.SetTab(nTabCount-1);
ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
for (SCTAB i=0; i<nTabCount; i++)
if (i != nStartTab && aFuncMark.GetTableSelect(i))
pUndoDoc->AddUndoTab( i, i );
pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pUndoDoc, &aFuncMark );
aFuncMark.MarkToMulti();
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoSelectionAttr(
pDocSh, aFuncMark,
nStartCol, nStartRow, nStartTab,
nEndCol, nEndRow, nEndTab,
pUndoDoc, bMulti, &rAttr ) );
}
pDoc->ApplySelectionPattern( rAttr, aFuncMark );
pDocSh->PostPaint( nStartCol, nStartRow, nStartTab,
nEndCol, nEndRow, nEndTab,
PAINT_GRID, nExtFlags | SC_PF_TESTMERGE );
pDocSh->UpdateOle(GetViewData());
aModificator.SetDocumentModified();
CellContentChanged();
}
else // einzelne Zelle - Undo einfacher
{
SCCOL nCol = pViewData->GetCurX();
SCROW nRow = pViewData->GetCurY();
SCTAB nTab = pViewData->GetTabNo();
aChangeRanges.Append( ScRange( nCol, nRow, nTab ) );
ScPatternAttr* pOldPat = new ScPatternAttr(*pDoc->GetPattern( nCol, nRow, nTab ));
pDoc->ApplyPattern( nCol, nRow, nTab, rAttr );
const ScPatternAttr* pNewPat = pDoc->GetPattern( nCol, nRow, nTab );
if (bRecord)
{
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoCursorAttr( pDocSh,
nCol, nRow, nTab,
pOldPat, pNewPat, &rAttr,
sal_False ) ); // sal_False = nicht automatisch
}
delete pOldPat; // wird im Undo kopiert (Pool)
pDocSh->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID, nExtFlags | SC_PF_TESTMERGE );
pDocSh->UpdateOle(GetViewData());
aModificator.SetDocumentModified();
CellContentChanged();
}
// #i97876# Spreadsheet data changes are not notified
ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
if ( pModelObj && pModelObj->HasChangesListeners() )
{
::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aProperties;
sal_Int32 nCount = 0;
const SfxItemPropertyMap* pMap = ScCellObj::GetCellPropertyMap();
PropertyEntryVector_t aPropVector = pMap->getPropertyEntries();
for ( sal_uInt16 nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; ++nWhich )
{
const SfxPoolItem* pItem = 0;
if ( rNewSet.GetItemState( nWhich, sal_True, &pItem ) == SFX_ITEM_SET && pItem )
{
PropertyEntryVector_t::const_iterator aIt = aPropVector.begin();
while ( aIt != aPropVector.end())
{
if ( aIt->nWID == nWhich )
{
::com::sun::star::uno::Any aVal;
pItem->QueryValue( aVal, aIt->nMemberId );
aProperties.realloc( nCount + 1 );
aProperties[ nCount ].Name = aIt->sName;
aProperties[ nCount ].Value <<= aVal;
++nCount;
}
++aIt;
}
}
}
pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "attribute" ) ), aChangeRanges, aProperties );
}
StartFormatArea();
}
void ScViewFunc::ApplyUserItemSet( const SfxItemSet& rItemSet )
{
// ItemSet from UI, may have different pool
sal_Bool bOnlyNotBecauseOfMatrix;
if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
ScPatternAttr aNewAttrs( GetViewData()->GetDocument()->GetPool() );
SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
rNewSet.Put( rItemSet, sal_False );
ApplySelectionPattern( aNewAttrs );
AdjustBlockHeight();
}
const SfxStyleSheet* ScViewFunc::GetStyleSheetFromMarked()
{
// Don't use UnmarkFiltered in slot state functions, for performance reasons.
// The displayed state is always that of the whole selection including filtered rows.
const ScStyleSheet* pSheet = NULL;
ScViewData* pViewData = GetViewData();
ScDocument* pDoc = pViewData->GetDocument();
ScMarkData& rMark = pViewData->GetMarkData();
if ( rMark.IsMarked() || rMark.IsMultiMarked() )
pSheet = pDoc->GetSelectionStyle( rMark ); // MarkToMulti isn't necessary
else
pSheet = pDoc->GetStyle( pViewData->GetCurX(),
pViewData->GetCurY(),
pViewData->GetTabNo() );
return pSheet;
}
void ScViewFunc::SetStyleSheetToMarked( SfxStyleSheet* pStyleSheet, sal_Bool bRecord )
{
// nur wegen Matrix nicht editierbar? Attribute trotzdem ok
sal_Bool bOnlyNotBecauseOfMatrix;
if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
if ( !pStyleSheet) return;
// -------------------------------------------------------------------
ScViewData* pViewData = GetViewData();
ScDocShell* pDocSh = pViewData->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
ScMarkData aFuncMark( pViewData->GetMarkData() ); // local copy for UnmarkFiltered
ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
SCTAB nTabCount = pDoc->GetTableCount();
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
ScDocShellModificator aModificator( *pDocSh );
if ( aFuncMark.IsMarked() || aFuncMark.IsMultiMarked() )
{
ScRange aMarkRange;
aFuncMark.MarkToMulti();
aFuncMark.GetMultiMarkArea( aMarkRange );
if ( bRecord )
{
SCTAB nTab = pViewData->GetTabNo();
ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
pUndoDoc->InitUndo( pDoc, nTab, nTab );
for (SCTAB i=0; i<nTabCount; i++)
if (i != nTab && aFuncMark.GetTableSelect(i))
pUndoDoc->AddUndoTab( i, i );
ScRange aCopyRange = aMarkRange;
aCopyRange.aStart.SetTab(0);
aCopyRange.aEnd.SetTab(nTabCount-1);
pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, sal_True, pUndoDoc, &aFuncMark );
aFuncMark.MarkToMulti();
String aName = pStyleSheet->GetName();
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoSelectionStyle( pDocSh, aFuncMark, aMarkRange, aName, pUndoDoc ) );
}
pDoc->ApplySelectionStyle( (ScStyleSheet&)*pStyleSheet, aFuncMark );
if (!AdjustBlockHeight())
pViewData->GetDocShell()->PostPaint( aMarkRange, PAINT_GRID );
aFuncMark.MarkToSimple();
}
else
{
SCCOL nCol = pViewData->GetCurX();
SCROW nRow = pViewData->GetCurY();
SCTAB nTab = pViewData->GetTabNo();
if ( bRecord )
{
ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
pUndoDoc->InitUndo( pDoc, nTab, nTab );
for (SCTAB i=0; i<nTabCount; i++)
if (i != nTab && aFuncMark.GetTableSelect(i))
pUndoDoc->AddUndoTab( i, i );
ScRange aCopyRange( nCol, nRow, 0, nCol, nRow, nTabCount-1 );
pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, sal_False, pUndoDoc );
ScRange aMarkRange ( nCol, nRow, nTab );
ScMarkData aUndoMark = aFuncMark;
aUndoMark.SetMultiMarkArea( aMarkRange );
String aName = pStyleSheet->GetName();
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoSelectionStyle( pDocSh, aUndoMark, aMarkRange, aName, pUndoDoc ) );
}
for (SCTAB i=0; i<nTabCount; i++)
if (aFuncMark.GetTableSelect(i))
pDoc->ApplyStyle( nCol, nRow, i, (ScStyleSheet&)*pStyleSheet );
if (!AdjustBlockHeight())
pViewData->GetDocShell()->PostPaintCell( nCol, nRow, nTab );
}
aModificator.SetDocumentModified();
StartFormatArea();
}
void ScViewFunc::RemoveStyleSheetInUse( const SfxStyleSheetBase* pStyleSheet )
{
if ( !pStyleSheet) return;
// -------------------------------------------------------------------
ScViewData* pViewData = GetViewData();
ScDocument* pDoc = pViewData->GetDocument();
ScDocShell* pDocSh = pViewData->GetDocShell();
ScDocShellModificator aModificator( *pDocSh );
VirtualDevice aVirtDev;
aVirtDev.SetMapMode(MAP_PIXEL);
pDoc->StyleSheetChanged( pStyleSheet, sal_True, &aVirtDev,
pViewData->GetPPTX(),
pViewData->GetPPTY(),
pViewData->GetZoomX(),
pViewData->GetZoomY() );
pDocSh->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID|PAINT_LEFT );
aModificator.SetDocumentModified();
ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
if (pHdl)
pHdl->ForgetLastPattern();
}
void ScViewFunc::UpdateStyleSheetInUse( const SfxStyleSheetBase* pStyleSheet )
{
if ( !pStyleSheet) return;
// -------------------------------------------------------------------
ScViewData* pViewData = GetViewData();
ScDocument* pDoc = pViewData->GetDocument();
ScDocShell* pDocSh = pViewData->GetDocShell();
ScDocShellModificator aModificator( *pDocSh );
VirtualDevice aVirtDev;
aVirtDev.SetMapMode(MAP_PIXEL);
pDoc->StyleSheetChanged( pStyleSheet, sal_False, &aVirtDev,
pViewData->GetPPTX(),
pViewData->GetPPTY(),
pViewData->GetZoomX(),
pViewData->GetZoomY() );
pDocSh->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID|PAINT_LEFT );
aModificator.SetDocumentModified();
ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
if (pHdl)
pHdl->ForgetLastPattern();
}
// Zellen einfuegen - Undo OK
sal_Bool ScViewFunc::InsertCells( InsCellCmd eCmd, sal_Bool bRecord, sal_Bool bPartOfPaste )
{
ScRange aRange;
if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
{
ScDocShell* pDocSh = GetViewData()->GetDocShell();
const ScMarkData& rMark = GetViewData()->GetMarkData();
sal_Bool bSuccess = pDocSh->GetDocFunc().InsertCells( aRange, &rMark, eCmd, bRecord, sal_False, bPartOfPaste );
if (bSuccess)
{
pDocSh->UpdateOle(GetViewData());
CellContentChanged();
// #i97876# Spreadsheet data changes are not notified
ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
if ( pModelObj && pModelObj->HasChangesListeners() )
{
if ( eCmd == INS_INSROWS || eCmd == INS_INSCOLS )
{
ScRangeList aChangeRanges;
aChangeRanges.Append( aRange );
::rtl::OUString aOperation = ( eCmd == INS_INSROWS ?
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "insert-rows" ) ) :
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "insert-columns" ) ) );
pModelObj->NotifyChanges( aOperation, aChangeRanges );
}
}
}
return bSuccess;
}
else
{
ErrorMessage(STR_NOMULTISELECT);
return sal_False;
}
}
// Zellen loeschen - Undo OK
void ScViewFunc::DeleteCells( DelCellCmd eCmd, sal_Bool bRecord )
{
ScRange aRange;
if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
{
ScDocShell* pDocSh = GetViewData()->GetDocShell();
const ScMarkData& rMark = GetViewData()->GetMarkData();
// #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
if ( pDocSh->IsDocShared() && ( eCmd == DEL_DELROWS || eCmd == DEL_DELCOLS ) )
{
ScRange aDelRange( aRange.aStart );
SCCOLROW nCount = 0;
if ( eCmd == DEL_DELROWS )
{
nCount = sal::static_int_cast< SCCOLROW >( aRange.aEnd.Row() - aRange.aStart.Row() + 1 );
}
else
{
nCount = sal::static_int_cast< SCCOLROW >( aRange.aEnd.Col() - aRange.aStart.Col() + 1 );
}
while ( nCount > 0 )
{
pDocSh->GetDocFunc().DeleteCells( aDelRange, &rMark, eCmd, bRecord, sal_False );
--nCount;
}
}
else
{
pDocSh->GetDocFunc().DeleteCells( aRange, &rMark, eCmd, bRecord, sal_False );
}
pDocSh->UpdateOle(GetViewData());
CellContentChanged();
// #i97876# Spreadsheet data changes are not notified
ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
if ( pModelObj && pModelObj->HasChangesListeners() )
{
if ( eCmd == DEL_DELROWS || eCmd == DEL_DELCOLS )
{
ScRangeList aChangeRanges;
aChangeRanges.Append( aRange );
::rtl::OUString aOperation = ( eCmd == DEL_DELROWS ?
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "delete-rows" ) ) :
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "delete-columns" ) ) );
pModelObj->NotifyChanges( aOperation, aChangeRanges );
}
}
// #58106# Cursor direkt hinter den geloeschten Bereich setzen
SCCOL nCurX = GetViewData()->GetCurX();
SCROW nCurY = GetViewData()->GetCurY();
if ( eCmd==DEL_CELLSLEFT || eCmd==DEL_DELCOLS )
nCurX = aRange.aStart.Col();
else
nCurY = aRange.aStart.Row();
SetCursor( nCurX, nCurY );
}
else
{
if (eCmd == DEL_DELCOLS)
DeleteMulti( sal_False, bRecord );
else if (eCmd == DEL_DELROWS)
DeleteMulti( sal_True, bRecord );
else
ErrorMessage(STR_NOMULTISELECT);
}
Unmark();
}
void ScViewFunc::DeleteMulti( sal_Bool bRows, sal_Bool bRecord )
{
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocShellModificator aModificator( *pDocSh );
SCTAB nTab = GetViewData()->GetTabNo();
ScDocument* pDoc = pDocSh->GetDocument();
ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered
ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
SCCOLROW* pRanges = new SCCOLROW[MAXCOLROWCOUNT];
SCCOLROW nRangeCnt = bRows ? aFuncMark.GetMarkRowRanges( pRanges ) :
aFuncMark.GetMarkColumnRanges( pRanges );
if (nRangeCnt == 0)
{
pRanges[0] = pRanges[1] = bRows ? static_cast<SCCOLROW>(GetViewData()->GetCurY()) : static_cast<SCCOLROW>(GetViewData()->GetCurX());
nRangeCnt = 1;
}
// Test ob erlaubt
SCCOLROW* pOneRange = pRanges;
sal_uInt16 nErrorId = 0;
sal_Bool bNeedRefresh = sal_False;
SCCOLROW nRangeNo;
for (nRangeNo=0; nRangeNo<nRangeCnt && !nErrorId; nRangeNo++)
{
SCCOLROW nStart = *(pOneRange++);
SCCOLROW nEnd = *(pOneRange++);
SCCOL nStartCol, nEndCol;
SCROW nStartRow, nEndRow;
if ( bRows )
{
nStartCol = 0;
nEndCol = MAXCOL;
nStartRow = static_cast<SCROW>(nStart);
nEndRow = static_cast<SCROW>(nEnd);
}
else
{
nStartCol = static_cast<SCCOL>(nStart);
nEndCol = static_cast<SCCOL>(nEnd);
nStartRow = 0;
nEndRow = MAXROW;
}
// cell protection (only needed for first range, as all following cells are moved)
if ( nRangeNo == 0 )
{
// test to the end of the sheet
ScEditableTester aTester( pDoc, nTab, nStartCol, nStartRow, MAXCOL, MAXROW );
if (!aTester.IsEditable())
nErrorId = aTester.GetMessageId();
}
// merged cells
SCCOL nMergeStartX = nStartCol;
SCROW nMergeStartY = nStartRow;
SCCOL nMergeEndX = nEndCol;
SCROW nMergeEndY = nEndRow;
pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, nTab );
pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, nTab );
if ( nMergeStartX != nStartCol || nMergeStartY != nStartRow )
{
// Disallow deleting parts of a merged cell.
// Deleting the start is allowed (merge is removed), so the end doesn't have to be checked.
nErrorId = STR_MSSG_DELETECELLS_0;
}
if ( nMergeEndX != nEndCol || nMergeEndY != nEndRow )
{
// detect if the start of a merged cell is deleted, so the merge flags can be refreshed
bNeedRefresh = sal_True;
}
}
if ( nErrorId )
{
ErrorMessage( nErrorId );
delete[] pRanges;
return;
}
// ausfuehren
WaitObject aWait( GetFrameWin() ); // wichtig wegen TrackFormulas bei UpdateReference
ScDocument* pUndoDoc = NULL;
ScRefUndoData* pUndoData = NULL;
if (bRecord)
{
pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
pUndoDoc->InitUndo( pDoc, nTab, nTab, !bRows, bRows ); // Zeilenhoehen
pOneRange = pRanges;
for (nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
{
SCCOLROW nStart = *(pOneRange++);
SCCOLROW nEnd = *(pOneRange++);
if (bRows)
pDoc->CopyToDocument( 0,nStart,nTab, MAXCOL,nEnd,nTab, IDF_ALL,sal_False,pUndoDoc );
else
pDoc->CopyToDocument( static_cast<SCCOL>(nStart),0,nTab,
static_cast<SCCOL>(nEnd),MAXROW,nTab,
IDF_ALL,sal_False,pUndoDoc );
}
// alle Formeln wegen Referenzen
SCTAB nTabCount = pDoc->GetTableCount();
pUndoDoc->AddUndoTab( 0, nTabCount-1, sal_False, sal_False );
pDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,MAXTAB, IDF_FORMULA,sal_False,pUndoDoc );
pUndoData = new ScRefUndoData( pDoc );
pDoc->BeginDrawUndo();
}
pOneRange = &pRanges[2*nRangeCnt]; // rueckwaerts
for (nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
{
SCCOLROW nEnd = *(--pOneRange);
SCCOLROW nStart = *(--pOneRange);
if (bRows)
pDoc->DeleteRow( 0,nTab, MAXCOL,nTab, nStart, static_cast<SCSIZE>(nEnd-nStart+1) );
else
pDoc->DeleteCol( 0,nTab, MAXROW,nTab, static_cast<SCCOL>(nStart), static_cast<SCSIZE>(nEnd-nStart+1) );
}
if (bNeedRefresh)
{
SCCOLROW nFirstStart = pRanges[0];
SCCOL nStartCol = bRows ? 0 : static_cast<SCCOL>(nFirstStart);
SCROW nStartRow = bRows ? static_cast<SCROW>(nFirstStart) : 0;
SCCOL nEndCol = MAXCOL;
SCROW nEndRow = MAXROW;
pDoc->RemoveFlagsTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER );
pDoc->ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab, sal_True );
}
if (bRecord)
{
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoDeleteMulti( pDocSh, bRows, bNeedRefresh, nTab, pRanges, nRangeCnt,
pUndoDoc, pUndoData ) );
}
if (!AdjustRowHeight(0, MAXROW))
{
if (bRows)
pDocSh->PostPaint( 0,pRanges[0],nTab, MAXCOL,MAXROW,nTab, PAINT_GRID | PAINT_LEFT );
else
pDocSh->PostPaint( static_cast<SCCOL>(pRanges[0]),0,nTab,
MAXCOL,MAXROW,nTab, PAINT_GRID | PAINT_TOP );
}
aModificator.SetDocumentModified();
CellContentChanged();
// #58106# Cursor direkt hinter den ersten geloeschten Bereich setzen
SCCOL nCurX = GetViewData()->GetCurX();
SCROW nCurY = GetViewData()->GetCurY();
if ( bRows )
nCurY = pRanges[0];
else
nCurX = static_cast<SCCOL>(pRanges[0]);
SetCursor( nCurX, nCurY );
delete[] pRanges;
SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
}
// Inhalte loeschen
void ScViewFunc::DeleteContents( sal_uInt16 nFlags, sal_Bool bRecord )
{
// nur wegen Matrix nicht editierbar? Attribute trotzdem ok
sal_Bool bOnlyNotBecauseOfMatrix;
sal_Bool bEditable = SelectionEditable( &bOnlyNotBecauseOfMatrix );
if ( !bEditable )
{
if ( !(bOnlyNotBecauseOfMatrix &&
((nFlags & (IDF_ATTRIB | IDF_EDITATTR)) == nFlags)) )
{
ErrorMessage(bOnlyNotBecauseOfMatrix ? STR_MATRIXFRAGMENTERR : STR_PROTECTIONERR);
return;
}
}
ScRange aMarkRange;
sal_Bool bSimple = sal_False;
ScDocument* pDoc = GetViewData()->GetDocument();
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered
ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
ScDocShellModificator aModificator( *pDocSh );
if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
{
aMarkRange.aStart.SetCol(GetViewData()->GetCurX());
aMarkRange.aStart.SetRow(GetViewData()->GetCurY());
aMarkRange.aStart.SetTab(GetViewData()->GetTabNo());
aMarkRange.aEnd = aMarkRange.aStart;
if ( pDoc->HasAttrib( aMarkRange, HASATTR_MERGED ) )
{
// InitOwnBlockMode();
aFuncMark.SetMarkArea( aMarkRange );
}
else
bSimple = sal_True;
}
aFuncMark.SetMarking(sal_False); // for MarkToMulti
aFuncMark.MarkToSimple(); // before bMulti test below
DBG_ASSERT( aFuncMark.IsMarked() || aFuncMark.IsMultiMarked() || bSimple, "delete what?" );
ScDocument* pUndoDoc = NULL;
sal_Bool bMulti = !bSimple && aFuncMark.IsMultiMarked();
if (!bSimple)
{
aFuncMark.MarkToMulti();
aFuncMark.GetMultiMarkArea( aMarkRange );
}
ScRange aExtendedRange(aMarkRange);
if (!bSimple)
{
if ( pDoc->ExtendMerge( aExtendedRange, sal_True ) )
bMulti = sal_False;
}
// keine Objekte auf geschuetzten Tabellen
sal_Bool bObjects = sal_False;
if ( nFlags & IDF_OBJECTS )
{
bObjects = sal_True;
SCTAB nTabCount = pDoc->GetTableCount();
for (SCTAB nTab=0; nTab<nTabCount; nTab++)
if (aFuncMark.GetTableSelect(nTab) && pDoc->IsTabProtected(nTab))
bObjects = sal_False;
}
sal_uInt16 nExtFlags = 0; // extra flags are needed only if attributes are deleted
if ( nFlags & IDF_ATTRIB )
pDocSh->UpdatePaintExt( nExtFlags, aMarkRange );
// Reihenfolge:
// 1) BeginDrawUndo
// 2) Objekte loeschen (DrawUndo wird gefuellt)
// 3) Inhalte fuer Undo kopieren
// 4) Inhalte loeschen
// 5) Undo-Aktion anlegen
sal_Bool bDrawUndo = bObjects || ( nFlags & IDF_NOTE ); // needed for shown notes
if ( bDrawUndo && bRecord )
pDoc->BeginDrawUndo();
if (bObjects)
{
if (bMulti)
pDoc->DeleteObjectsInSelection( aFuncMark );
else
pDoc->DeleteObjectsInArea( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
/*!*/ aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(),
aFuncMark );
}
if ( bRecord )
{
pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
SCTAB nTab = aMarkRange.aStart.Tab();
pUndoDoc->InitUndo( pDoc, nTab, nTab );
SCTAB nTabCount = pDoc->GetTableCount();
for (SCTAB i=0; i<nTabCount; i++)
if (i != nTab && aFuncMark.GetTableSelect(i))
pUndoDoc->AddUndoTab( i, i );
ScRange aCopyRange = aExtendedRange;
aCopyRange.aStart.SetTab(0);
aCopyRange.aEnd.SetTab(nTabCount-1);
// bei "Format/Standard" alle Attribute kopieren, weil CopyToDocument
// nur mit IDF_HARDATTR zu langsam ist:
sal_uInt16 nUndoDocFlags = nFlags;
if (nFlags & IDF_ATTRIB)
nUndoDocFlags |= IDF_ATTRIB;
if (nFlags & IDF_EDITATTR) // Edit-Engine-Attribute
nUndoDocFlags |= IDF_STRING; // -> Zellen werden geaendert
if (nFlags & IDF_NOTE)
nUndoDocFlags |= IDF_CONTENTS; // #68795# copy all cells with their notes
// do not copy note captions to undo document
nUndoDocFlags |= IDF_NOCAPTIONS;
pDoc->CopyToDocument( aCopyRange, nUndoDocFlags, bMulti, pUndoDoc, &aFuncMark );
}
HideAllCursors(); // falls Zusammenfassung aufgehoben wird
if (bSimple)
pDoc->DeleteArea( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(),
aFuncMark, nFlags );
else
{
pDoc->DeleteSelection( nFlags, aFuncMark );
// aFuncMark.MarkToSimple();
}
if ( bRecord )
{
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoDeleteContents( pDocSh, aFuncMark, aExtendedRange,
pUndoDoc, bMulti, nFlags, bDrawUndo ) );
}
if (!AdjustRowHeight( aExtendedRange.aStart.Row(), aExtendedRange.aEnd.Row() ))
pDocSh->PostPaint( aExtendedRange, PAINT_GRID, nExtFlags );
pDocSh->UpdateOle(GetViewData());
// #i97876# Spreadsheet data changes are not notified
ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
if ( pModelObj && pModelObj->HasChangesListeners() )
{
ScRangeList aChangeRanges;
if ( bSimple )
{
aChangeRanges.Append( aMarkRange );
}
else
{
aFuncMark.FillRangeListWithMarks( &aChangeRanges, sal_False );
}
pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
}
aModificator.SetDocumentModified();
CellContentChanged();
ShowAllCursors();
if ( nFlags & IDF_ATTRIB )
{
if ( nFlags & IDF_CONTENTS )
ForgetFormatArea();
else
StartFormatArea(); // Attribute loeschen ist auch Attributierung
}
}
// Spaltenbreiten/Zeilenhoehen (ueber Header) - Undo OK
void ScViewFunc::SetWidthOrHeight( sal_Bool bWidth, SCCOLROW nRangeCnt, SCCOLROW* pRanges,
ScSizeMode eMode, sal_uInt16 nSizeTwips,
sal_Bool bRecord, sal_Bool bPaint, ScMarkData* pMarkData )
{
if (nRangeCnt == 0)
return;
// use view's mark if none specified
if ( !pMarkData )
pMarkData = &GetViewData()->GetMarkData();
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
SCTAB nTabCount = pDoc->GetTableCount();
SCTAB nFirstTab = pMarkData->GetFirstSelected();
SCTAB nCurTab = GetViewData()->GetTabNo();
SCTAB nTab;
if (bRecord && !pDoc->IsUndoEnabled())
bRecord = sal_False;
ScDocShellModificator aModificator( *pDocSh );
sal_Bool bAllowed = sal_True;
for (nTab=0; nTab<nTabCount && bAllowed; nTab++)
if (pMarkData->GetTableSelect(nTab))
{
for ( SCCOLROW i=0; i<nRangeCnt && bAllowed; i++ )
{
sal_Bool bOnlyMatrix;
if (bWidth)
bAllowed = pDoc->IsBlockEditable( nTab,
static_cast<SCCOL>(pRanges[2*i]),0,
static_cast<SCCOL>(pRanges[2*i+1]),MAXROW,
&bOnlyMatrix ) || bOnlyMatrix;
else
bAllowed = pDoc->IsBlockEditable( nTab, 0,pRanges[2*i],
MAXCOL,pRanges[2*i+1], &bOnlyMatrix ) ||
bOnlyMatrix;
}
}
if ( !bAllowed )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
SCCOLROW nStart = pRanges[0];
SCCOLROW nEnd = pRanges[2*nRangeCnt-1];
sal_Bool bFormula = sal_False;
if ( eMode == SC_SIZE_OPTIMAL )
{
const ScViewOptions& rOpts = GetViewData()->GetOptions();
bFormula = rOpts.GetOption( VOPT_FORMULAS );
}
ScDocument* pUndoDoc = NULL;
ScOutlineTable* pUndoTab = NULL;
SCCOLROW* pUndoRanges = NULL;
if ( bRecord )
{
pDoc->BeginDrawUndo(); // Drawing Updates
pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
for (nTab=0; nTab<nTabCount; nTab++)
if (pMarkData->GetTableSelect(nTab))
{
if (bWidth)
{
if ( nTab == nFirstTab )
pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_False );
else
pUndoDoc->AddUndoTab( nTab, nTab, sal_True, sal_False );
pDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE,
sal_False, pUndoDoc );
}
else
{
if ( nTab == nFirstTab )
pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_False, sal_True );
else
pUndoDoc->AddUndoTab( nTab, nTab, sal_False, sal_True );
pDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, sal_False, pUndoDoc );
}
}
pUndoRanges = new SCCOLROW[ 2*nRangeCnt ];
memmove( pUndoRanges, pRanges, 2*nRangeCnt*sizeof(SCCOLROW) );
//! outlines from all tables?
ScOutlineTable* pTable = pDoc->GetOutlineTable( nCurTab );
if (pTable)
pUndoTab = new ScOutlineTable( *pTable );
}
if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
pMarkData->MarkToMulti();
sal_Bool bShow = nSizeTwips > 0 || eMode != SC_SIZE_DIRECT;
sal_Bool bOutline = sal_False;
for (nTab=0; nTab<nTabCount; nTab++)
if (pMarkData->GetTableSelect(nTab))
{
const SCCOLROW* pTabRanges = pRanges;
pDoc->IncSizeRecalcLevel( nTab ); // nicht fuer jede Spalte einzeln
pDoc->InitializeNoteCaptions( nTab );
for (SCCOLROW nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
{
SCCOLROW nStartNo = *(pTabRanges++);
SCCOLROW nEndNo = *(pTabRanges++);
if ( !bWidth ) // Hoehen immer blockweise
{
if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
{
sal_Bool bAll = ( eMode==SC_SIZE_OPTIMAL );
if (!bAll)
{
// fuer alle eingeblendeten CR_MANUALSIZE loeschen,
// dann SetOptimalHeight mit bShrink = FALSE
for (SCROW nRow = nStartNo; nRow <= nEndNo; ++nRow)
{
SCROW nLastRow = nRow;
if (pDoc->RowHidden(nRow, nTab, NULL, &nLastRow))
{
nRow = nLastRow;
continue;
}
sal_uInt8 nOld = pDoc->GetRowFlags(nRow, nTab);
if (nOld & CR_MANUALSIZE)
pDoc->SetRowFlags(nRow, nTab, nOld & ~CR_MANUALSIZE);
}
}
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 );
}
pDoc->SetOptimalHeight( nStartNo, nEndNo, nTab, nSizeTwips, aProv.GetDevice(),
nPPTX, nPPTY, aZoomX, aZoomY, bAll );
if (bAll)
pDoc->ShowRows( nStartNo, nEndNo, nTab, sal_True );
// Manual-Flag wird bei bAll=sal_True schon in SetOptimalHeight gesetzt
// (an bei Extra-Height, sonst aus).
}
else if ( eMode==SC_SIZE_DIRECT )
{
if (nSizeTwips)
{
pDoc->SetRowHeightRange( nStartNo, nEndNo, nTab, nSizeTwips );
pDoc->SetManualHeight( nStartNo, nEndNo, nTab, sal_True ); // height was set manually
}
pDoc->ShowRows( nStartNo, nEndNo, nTab, nSizeTwips != 0 );
}
else if ( eMode==SC_SIZE_SHOW )
{
pDoc->ShowRows( nStartNo, nEndNo, nTab, sal_True );
}
}
else // Spaltenbreiten
{
for (SCCOL nCol=static_cast<SCCOL>(nStartNo); nCol<=static_cast<SCCOL>(nEndNo); nCol++)
{
if ( eMode != SC_SIZE_VISOPT || !pDoc->ColHidden(nCol, nTab) )
{
sal_uInt16 nThisSize = nSizeTwips;
if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
nThisSize = nSizeTwips + GetOptimalColWidth( nCol, nTab, bFormula );
if ( nThisSize )
pDoc->SetColWidth( nCol, nTab, nThisSize );
pDoc->ShowCol( nCol, nTab, bShow );
}
}
}
// Outline anpassen
if (bWidth)
{
if ( pDoc->UpdateOutlineCol( static_cast<SCCOL>(nStartNo),
static_cast<SCCOL>(nEndNo), nTab, bShow ) )
bOutline = sal_True;
}
else
{
if ( pDoc->UpdateOutlineRow( nStartNo, nEndNo, nTab, bShow ) )
bOutline = sal_True;
}
}
pDoc->DecSizeRecalcLevel( nTab ); // nicht fuer jede Spalte einzeln
}
if (!bOutline)
DELETEZ(pUndoTab);
if (bRecord)
{
pDocSh->GetUndoManager()->AddUndoAction(
new ScUndoWidthOrHeight( pDocSh, *pMarkData,
nStart, nCurTab, nEnd, nCurTab,
pUndoDoc, nRangeCnt, pUndoRanges,
pUndoTab, eMode, nSizeTwips, bWidth ) );
}
for (nTab=0; nTab<nTabCount; nTab++)
if (pMarkData->GetTableSelect(nTab))
pDoc->UpdatePageBreaks( nTab );
GetViewData()->GetView()->UpdateScrollBars();
if (bPaint)
{
HideCursor();
for (nTab=0; nTab<nTabCount; nTab++)
if (pMarkData->GetTableSelect(nTab))
{
if (bWidth)
{
if (pDoc->HasAttrib( static_cast<SCCOL>(nStart),0,nTab,
static_cast<SCCOL>(nEnd),MAXROW,nTab,
HASATTR_MERGED | HASATTR_OVERLAPPED ))
nStart = 0;
if (nStart > 0) // weiter oben anfangen wegen Linien und Cursor
--nStart;
pDocSh->PostPaint( static_cast<SCCOL>(nStart), 0, nTab,
MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_TOP );
}
else
{
if (pDoc->HasAttrib( 0,nStart,nTab, MAXCOL,nEnd,nTab, HASATTR_MERGED | HASATTR_OVERLAPPED ))
nStart = 0;
if (nStart != 0)
--nStart;
pDocSh->PostPaint( 0, nStart, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_LEFT );
}
}
pDocSh->UpdateOle(GetViewData());
aModificator.SetDocumentModified();
ShowCursor();
}
// #i97876# Spreadsheet data changes are not notified
if ( bWidth )
{
ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
if ( pModelObj && pModelObj->HasChangesListeners() )
{
ScRangeList aChangeRanges;
for ( nTab = 0; nTab < nTabCount; ++nTab )
{
if ( pMarkData->GetTableSelect( nTab ) )
{
const SCCOLROW* pTabRanges = pRanges;
for ( SCCOLROW nRange = 0; nRange < nRangeCnt; ++nRange )
{
SCCOL nStartCol = static_cast< SCCOL >( *(pTabRanges++) );
SCCOL nEndCol = static_cast< SCCOL >( *(pTabRanges++) );
for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol )
{
aChangeRanges.Append( ScRange( nCol, 0, nTab ) );
}
}
}
}
pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "column-resize" ) ), aChangeRanges );
}
}
}
// Spaltenbreiten/Zeilenhoehen (ueber Blockmarken)
void ScViewFunc::SetMarkedWidthOrHeight( sal_Bool bWidth, ScSizeMode eMode, sal_uInt16 nSizeTwips,
sal_Bool bRecord, sal_Bool bPaint )
{
ScMarkData& rMark = GetViewData()->GetMarkData();
rMark.MarkToMulti();
if (!rMark.IsMultiMarked())
{
SCCOL nCol = GetViewData()->GetCurX();
SCROW nRow = GetViewData()->GetCurY();
SCTAB nTab = GetViewData()->GetTabNo();
DoneBlockMode();
InitOwnBlockMode();
rMark.SetMultiMarkArea( ScRange( nCol,nRow,nTab ), sal_True );
MarkDataChanged();
}
SCCOLROW* pRanges = new SCCOLROW[MAXCOLROWCOUNT];
SCCOLROW nRangeCnt = 0;
if ( bWidth )
nRangeCnt = rMark.GetMarkColumnRanges( pRanges );
else
nRangeCnt = rMark.GetMarkRowRanges( pRanges );
SetWidthOrHeight( bWidth, nRangeCnt, pRanges, eMode, nSizeTwips, bRecord, bPaint );
delete[] pRanges;
rMark.MarkToSimple();
}
void ScViewFunc::ModifyCellSize( ScDirection eDir, sal_Bool bOptimal )
{
//! Schrittweiten einstellbar
// Schrittweite ist auch Minimum
sal_uInt16 nStepX = STD_COL_WIDTH / 5;
sal_uInt16 nStepY = ScGlobal::nStdRowHeight;
ScModule* pScMod = SC_MOD();
sal_Bool bAnyEdit = pScMod->IsInputMode();
SCCOL nCol = GetViewData()->GetCurX();
SCROW nRow = GetViewData()->GetCurY();
SCTAB nTab = GetViewData()->GetTabNo();
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
sal_Bool bAllowed, bOnlyMatrix;
if ( eDir == DIR_LEFT || eDir == DIR_RIGHT )
bAllowed = pDoc->IsBlockEditable( nTab, nCol,0, nCol,MAXROW, &bOnlyMatrix );
else
bAllowed = pDoc->IsBlockEditable( nTab, 0,nRow, MAXCOL,nRow, &bOnlyMatrix );
if ( !bAllowed && !bOnlyMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
HideAllCursors();
sal_uInt16 nWidth = pDoc->GetColWidth( nCol, nTab );
sal_uInt16 nHeight = pDoc->GetRowHeight( nRow, nTab );
SCCOLROW nRange[2];
if ( eDir == DIR_LEFT || eDir == DIR_RIGHT )
{
if (bOptimal) // Breite dieser einen Zelle
{
if ( bAnyEdit )
{
// beim Editieren die aktuelle Breite der Eingabe
ScInputHandler* pHdl = pScMod->GetInputHdl( GetViewData()->GetViewShell() );
if (pHdl)
{
long nEdit = pHdl->GetTextSize().Width(); // in 1/100mm
const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, nTab );
const SvxMarginItem& rMItem =
(const SvxMarginItem&)pPattern->GetItem(ATTR_MARGIN);
sal_uInt16 nMargin = rMItem.GetLeftMargin() + rMItem.GetRightMargin();
if ( ((const SvxHorJustifyItem&) pPattern->
GetItem( ATTR_HOR_JUSTIFY )).GetValue() == SVX_HOR_JUSTIFY_LEFT )
nMargin = sal::static_int_cast<sal_uInt16>(
nMargin + ((const SfxUInt16Item&)pPattern->GetItem(ATTR_INDENT)).GetValue() );
nWidth = (sal_uInt16)(nEdit * pDocSh->GetOutputFactor() / HMM_PER_TWIPS)
+ nMargin + STD_EXTRA_WIDTH;
}
}
else
{
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 );
}
long nPixel = pDoc->GetNeededSize( nCol, nRow, nTab, aProv.GetDevice(),
nPPTX, nPPTY, aZoomX, aZoomY, sal_True );
sal_uInt16 nTwips = (sal_uInt16)( nPixel / nPPTX );
if (nTwips != 0)
nWidth = nTwips + STD_EXTRA_WIDTH;
else
nWidth = STD_COL_WIDTH;
}
}
else // vergroessern / verkleinern
{
if ( eDir == DIR_RIGHT )
nWidth = sal::static_int_cast<sal_uInt16>( nWidth + nStepX );
else if ( nWidth > nStepX )
nWidth = sal::static_int_cast<sal_uInt16>( nWidth - nStepX );
if ( nWidth < nStepX ) nWidth = nStepX;
if ( nWidth > MAX_COL_WIDTH ) nWidth = MAX_COL_WIDTH;
}
nRange[0] = nRange[1] = nCol;
SetWidthOrHeight( sal_True, 1, nRange, SC_SIZE_DIRECT, nWidth );
// hier bei Breite auch Hoehe anpassen (nur die eine Zeile)
if (!bAnyEdit)
{
const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, nTab );
sal_Bool bNeedHeight =
((const SfxBoolItem&)pPattern->GetItem( ATTR_LINEBREAK )).GetValue() ||
((const SvxHorJustifyItem&)pPattern->
GetItem( ATTR_HOR_JUSTIFY )).GetValue() == SVX_HOR_JUSTIFY_BLOCK;
if (bNeedHeight)
AdjustRowHeight( nRow, nRow );
}
}
else
{
ScSizeMode eMode;
if (bOptimal)
{
eMode = SC_SIZE_OPTIMAL;
nHeight = 0;
}
else
{
eMode = SC_SIZE_DIRECT;
if ( eDir == DIR_BOTTOM )
nHeight = sal::static_int_cast<sal_uInt16>( nHeight + nStepY );
else if ( nHeight > nStepY )
nHeight = sal::static_int_cast<sal_uInt16>( nHeight - nStepY );
if ( nHeight < nStepY ) nHeight = nStepY;
if ( nHeight > MAX_COL_HEIGHT ) nHeight = MAX_COL_HEIGHT;
//! MAX_COL_HEIGHT umbenennen in MAX_ROW_HEIGHT in global.hxx !!!!!!
}
nRange[0] = nRange[1] = nRow;
SetWidthOrHeight( sal_False, 1, nRange, eMode, nHeight );
}
if ( bAnyEdit )
{
UpdateEditView();
if ( pDoc->HasAttrib( nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_NEEDHEIGHT ) )
{
ScInputHandler* pHdl = pScMod->GetInputHdl( GetViewData()->GetViewShell() );
if (pHdl)
pHdl->SetModified(); // damit bei Enter die Hoehe angepasst wird
}
}
ShowAllCursors();
}
void ScViewFunc::ProtectSheet( SCTAB nTab, const ScTableProtection& rProtect )
{
if (nTab == TABLEID_DOC)
return;
ScMarkData& rMark = GetViewData()->GetMarkData();
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
ScDocFunc aFunc(*pDocSh);
bool bUndo(pDoc->IsUndoEnabled());
// modifying several tables is handled here
if (bUndo)
{
String aUndo = ScGlobal::GetRscString( STR_UNDO_PROTECT_TAB );
pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
}
SCTAB nCount = pDocSh->GetDocument()->GetTableCount();
for ( SCTAB i=0; i<nCount; i++ )
if ( rMark.GetTableSelect(i) )
aFunc.ProtectSheet(i, rProtect);
if (bUndo)
pDocSh->GetUndoManager()->LeaveListAction();
UpdateLayerLocks(); //! broadcast to all views
}
void ScViewFunc::Protect( SCTAB nTab, const String& rPassword )
{
ScMarkData& rMark = GetViewData()->GetMarkData();
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
ScDocFunc aFunc(*pDocSh);
sal_Bool bUndo(pDoc->IsUndoEnabled());
if ( nTab == TABLEID_DOC || rMark.GetSelectCount() <= 1 )
aFunc.Protect( nTab, rPassword, sal_False );
else
{
// modifying several tables is handled here
if (bUndo)
{
String aUndo = ScGlobal::GetRscString( STR_UNDO_PROTECT_TAB );
pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
}
SCTAB nCount = pDocSh->GetDocument()->GetTableCount();
for ( SCTAB i=0; i<nCount; i++ )
if ( rMark.GetTableSelect(i) )
aFunc.Protect( i, rPassword, sal_False );
if (bUndo)
pDocSh->GetUndoManager()->LeaveListAction();
}
UpdateLayerLocks(); //! broadcast to all views
}
sal_Bool ScViewFunc::Unprotect( SCTAB nTab, const String& rPassword )
{
ScMarkData& rMark = GetViewData()->GetMarkData();
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
ScDocFunc aFunc(*pDocSh);
sal_Bool bChanged = sal_False;
sal_Bool bUndo (pDoc->IsUndoEnabled());
if ( nTab == TABLEID_DOC || rMark.GetSelectCount() <= 1 )
bChanged = aFunc.Unprotect( nTab, rPassword, sal_False );
else
{
// modifying several tables is handled here
if (bUndo)
{
String aUndo = ScGlobal::GetRscString( STR_UNDO_UNPROTECT_TAB );
pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
}
SCTAB nCount = pDocSh->GetDocument()->GetTableCount();
for ( SCTAB i=0; i<nCount; i++ )
if ( rMark.GetTableSelect(i) )
if ( aFunc.Unprotect( i, rPassword, sal_False ) )
bChanged = sal_True;
if (bUndo)
pDocSh->GetUndoManager()->LeaveListAction();
}
if (bChanged)
UpdateLayerLocks(); //! broadcast to all views
return bChanged;
}
void ScViewFunc::SetNoteText( const ScAddress& rPos, const String& rNoteText )
{
GetViewData()->GetDocShell()->GetDocFunc().SetNoteText( rPos, rNoteText, sal_False );
}
void ScViewFunc::ReplaceNote( const ScAddress& rPos, const String& rNoteText, const String* pAuthor, const String* pDate )
{
GetViewData()->GetDocShell()->GetDocFunc().ReplaceNote( rPos, rNoteText, pAuthor, pDate, sal_False );
}
void ScViewFunc::SetNumberFormat( short nFormatType, sal_uLong nAdd )
{
// nur wegen Matrix nicht editierbar? Attribute trotzdem ok
sal_Bool bOnlyNotBecauseOfMatrix;
if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
sal_uInt32 nNumberFormat = 0;
ScViewData* pViewData = GetViewData();
ScDocument* pDoc = pViewData->GetDocument();
SvNumberFormatter* pNumberFormatter = pDoc->GetFormatTable();
LanguageType eLanguage = ScGlobal::eLnge;
ScPatternAttr aNewAttrs( pDoc->GetPool() );
// #67936# always take language from cursor position, even if there is a selection
sal_uInt32 nCurrentNumberFormat;
pDoc->GetNumberFormat( pViewData->GetCurX(),
pViewData->GetCurY(),
pViewData->GetTabNo(),
nCurrentNumberFormat );
const SvNumberformat* pEntry = pNumberFormatter->GetEntry( nCurrentNumberFormat );
if (pEntry)
eLanguage = pEntry->GetLanguage(); // sonst ScGlobal::eLnge behalten
nNumberFormat = pNumberFormatter->GetStandardFormat( nFormatType, eLanguage ) + nAdd;
SfxItemSet& rSet = aNewAttrs.GetItemSet();
rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumberFormat ) );
// ATTR_LANGUAGE_FORMAT nicht
ApplySelectionPattern( aNewAttrs, sal_True );
}
void ScViewFunc::SetNumFmtByStr( const String& rCode )
{
// nur wegen Matrix nicht editierbar? Attribute trotzdem ok
sal_Bool bOnlyNotBecauseOfMatrix;
if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
ScViewData* pViewData = GetViewData();
ScDocument* pDoc = pViewData->GetDocument();
SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
// Sprache immer von Cursorposition
sal_uInt32 nCurrentNumberFormat;
pDoc->GetNumberFormat( pViewData->GetCurX(), pViewData->GetCurY(),
pViewData->GetTabNo(), nCurrentNumberFormat );
const SvNumberformat* pEntry = pFormatter->GetEntry( nCurrentNumberFormat );
LanguageType eLanguage = pEntry ? pEntry->GetLanguage() : ScGlobal::eLnge;
// Index fuer String bestimmen
sal_Bool bOk = sal_True;
sal_uInt32 nNumberFormat = pFormatter->GetEntryKey( rCode, eLanguage );
if ( nNumberFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
{
// neu eintragen
String aFormat = rCode; // wird veraendert
xub_StrLen nErrPos = 0;
short nType = 0; //! ???
bOk = pFormatter->PutEntry( aFormat, nErrPos, nType, nNumberFormat, eLanguage );
}
if ( bOk ) // gueltiges Format?
{
ScPatternAttr aNewAttrs( pDoc->GetPool() );
SfxItemSet& rSet = aNewAttrs.GetItemSet();
rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumberFormat ) );
rSet.Put( SvxLanguageItem( eLanguage, ATTR_LANGUAGE_FORMAT ) );
ApplySelectionPattern( aNewAttrs, sal_True );
}
//! sonst Fehler zuerueckgeben / Meldung ausgeben ???
}
void ScViewFunc::ChangeNumFmtDecimals( sal_Bool bIncrement )
{
// nur wegen Matrix nicht editierbar? Attribute trotzdem ok
sal_Bool bOnlyNotBecauseOfMatrix;
if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
{
ErrorMessage(STR_PROTECTIONERR);
return;
}
ScDocument* pDoc = GetViewData()->GetDocument();
SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
SCCOL nCol = GetViewData()->GetCurX();
SCROW nRow = GetViewData()->GetCurY();
SCTAB nTab = GetViewData()->GetTabNo();
sal_uInt32 nOldFormat;
pDoc->GetNumberFormat( nCol, nRow, nTab, nOldFormat );
const SvNumberformat* pOldEntry = pFormatter->GetEntry( nOldFormat );
if (!pOldEntry)
{
DBG_ERROR("Zahlformat nicht gefunden !!!");
return;
}
// was haben wir denn da?
sal_uInt32 nNewFormat = nOldFormat;
sal_Bool bError = sal_False;
LanguageType eLanguage = pOldEntry->GetLanguage();
sal_Bool bThousand, bNegRed;
sal_uInt16 nPrecision, nLeading;
pOldEntry->GetFormatSpecialInfo( bThousand, bNegRed, nPrecision, nLeading );
short nOldType = pOldEntry->GetType();
if ( 0 == ( nOldType & (
NUMBERFORMAT_NUMBER | NUMBERFORMAT_CURRENCY | NUMBERFORMAT_PERCENT ) ) )
{
// Datum, Zeit, Bruch, logisch, Text kann nicht angepasst werden
//! bei Wisssenschaftlich kann es der Numberformatter auch nicht
bError = sal_True;
}
//! Das SvNumberformat hat einen Member bStandard, verraet ihn aber nicht
sal_Bool bWasStandard = ( nOldFormat == pFormatter->GetStandardIndex( eLanguage ) );
if (bWasStandard)
{
// bei "Standard" die Nachkommastellen abhaengig vom Zellinhalt
// 0 bei leer oder Text -> keine Nachkommastellen
double nVal = pDoc->GetValue( ScAddress( nCol, nRow, nTab ) );
// Die Wege des Numberformatters sind unergruendlich, darum ausprobieren:
String aOut;
Color* pCol;
((SvNumberformat*)pOldEntry)->GetOutputString( nVal, aOut, &pCol );
nPrecision = 0;
// 'E' fuer Exponential ist fest im Numberformatter
if ( aOut.Search('E') != STRING_NOTFOUND )
bError = sal_True; // Exponential nicht veraendern
else
{
String aDecSep( pFormatter->GetFormatDecimalSep( nOldFormat ) );
xub_StrLen nPos = aOut.Search( aDecSep );
if ( nPos != STRING_NOTFOUND )
nPrecision = aOut.Len() - nPos - aDecSep.Len();
// sonst 0 behalten
}
}
if (!bError)
{
if (bIncrement)
{
if (nPrecision<20)
++nPrecision; // erhoehen
else
bError = sal_True; // 20 ist Maximum
}
else
{
if (nPrecision)
--nPrecision; // vermindern
else
bError = sal_True; // weniger als 0 geht nicht
}
}
if (!bError)
{
String aNewPicture;
pFormatter->GenerateFormat( aNewPicture, nOldFormat, eLanguage,
bThousand, bNegRed, nPrecision, nLeading );
nNewFormat = pFormatter->GetEntryKey( aNewPicture, eLanguage );
if ( nNewFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
{
xub_StrLen nErrPos = 0;
short nNewType = 0;
sal_Bool bOk = pFormatter->PutEntry( aNewPicture, nErrPos,
nNewType, nNewFormat, eLanguage );
DBG_ASSERT( bOk, "falsches Zahlformat generiert" );
if (!bOk)
bError = sal_True;
}
}
if (!bError)
{
ScPatternAttr aNewAttrs( pDoc->GetPool() );
SfxItemSet& rSet = aNewAttrs.GetItemSet();
rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
// ATTR_LANGUAGE_FORMAT nicht
ApplySelectionPattern( aNewAttrs, sal_True );
}
else
Sound::Beep(); // war nix
}
void ScViewFunc::ChangeIndent( sal_Bool bIncrement )
{
ScViewData* pViewData = GetViewData();
ScDocShell* pDocSh = pViewData->GetDocShell();
ScMarkData& rMark = pViewData->GetMarkData();
ScMarkData aWorkMark = rMark;
ScViewUtil::UnmarkFiltered( aWorkMark, pDocSh->GetDocument() );
aWorkMark.MarkToMulti();
if (!aWorkMark.IsMultiMarked())
{
SCCOL nCol = pViewData->GetCurX();
SCROW nRow = pViewData->GetCurY();
SCTAB nTab = pViewData->GetTabNo();
aWorkMark.SetMultiMarkArea( ScRange(nCol,nRow,nTab) );
}
sal_Bool bSuccess = pDocSh->GetDocFunc().ChangeIndent( aWorkMark, bIncrement, sal_False );
if (bSuccess)
{
pDocSh->UpdateOle(pViewData);
StartFormatArea();
// stuff for sidebar panels
SfxBindings& rBindings = GetViewData()->GetBindings();
rBindings.Invalidate( SID_H_ALIGNCELL );
rBindings.Invalidate( SID_ATTR_ALIGN_INDENT );
}
}
sal_Bool ScViewFunc::InsertName( const String& rName, const String& rSymbol,
const String& rType )
{
// Type = P,R,C,F (und Kombinationen)
//! Undo...
sal_Bool bOk = sal_False;
ScDocShell* pDocSh = GetViewData()->GetDocShell();
ScDocument* pDoc = pDocSh->GetDocument();
SCTAB nTab = GetViewData()->GetTabNo();
ScRangeName* pList = pDoc->GetRangeName();
RangeType nType = RT_NAME;
ScRangeData* pNewEntry = new ScRangeData( pDoc, rName, rSymbol,
ScAddress( GetViewData()->GetCurX(), GetViewData()->GetCurY(),
nTab), nType );
String aUpType = rType;
aUpType.ToUpperAscii();
if ( aUpType.Search( 'P' ) != STRING_NOTFOUND )
nType |= RT_PRINTAREA;
if ( aUpType.Search( 'R' ) != STRING_NOTFOUND )
nType |= RT_ROWHEADER;
if ( aUpType.Search( 'C' ) != STRING_NOTFOUND )
nType |= RT_COLHEADER;
if ( aUpType.Search( 'F' ) != STRING_NOTFOUND )
nType |= RT_CRITERIA;
pNewEntry->AddType(nType);
if ( !pNewEntry->GetErrCode() ) // Text gueltig?
{
ScDocShellModificator aModificator( *pDocSh );
pDoc->CompileNameFormula( sal_True ); // CreateFormulaString
// Eintrag bereits vorhanden? Dann vorher entfernen (=Aendern)
sal_uInt16 nFoundAt;
if ( pList->SearchName( rName, nFoundAt ) )
{ // alten Index uebernehmen
pNewEntry->SetIndex( ((ScRangeData*)pList->At(nFoundAt))->GetIndex() );
pList->AtFree( nFoundAt );
}
if ( pList->Insert( pNewEntry ) )
{
pNewEntry = NULL; // nicht loeschen
bOk = sal_True;
}
pDoc->CompileNameFormula( sal_False ); // CompileFormulaString
aModificator.SetDocumentModified();
SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) );
}
delete pNewEntry; // wenn er nicht eingefuegt wurde
return bOk;
}
void ScViewFunc::CreateNames( sal_uInt16 nFlags )
{
sal_Bool bDone = sal_False;
ScRange aRange;
if ( GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE )
bDone = GetViewData()->GetDocShell()->GetDocFunc().CreateNames( aRange, nFlags, sal_False );
if (!bDone)
ErrorMessage(STR_CREATENAME_MARKERR);
}
sal_uInt16 ScViewFunc::GetCreateNameFlags()
{
sal_uInt16 nFlags = 0;
SCCOL nStartCol, nEndCol;
SCROW nStartRow, nEndRow;
SCTAB nDummy;
if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nDummy,nEndCol,nEndRow,nDummy) == SC_MARK_SIMPLE)
{
ScDocument* pDoc = GetViewData()->GetDocument();
SCTAB nTab = GetViewData()->GetTabNo();
sal_Bool bOk;
SCCOL i;
SCROW j;
bOk = sal_True;
SCCOL nFirstCol = nStartCol;
SCCOL nLastCol = nEndCol;
if (nStartCol+1 < nEndCol) { ++nFirstCol; --nLastCol; }
for (i=nFirstCol; i<=nLastCol && bOk; i++)
if (!pDoc->HasStringData( i,nStartRow,nTab ))
bOk = sal_False;
if (bOk)
nFlags |= NAME_TOP;
else // Bottom nur wenn nicht Top
{
bOk = sal_True;
for (i=nFirstCol; i<=nLastCol && bOk; i++)
if (!pDoc->HasStringData( i,nEndRow,nTab ))
bOk = sal_False;
if (bOk)
nFlags |= NAME_BOTTOM;
}
bOk = sal_True;
SCROW nFirstRow = nStartRow;
SCROW nLastRow = nEndRow;
if (nStartRow+1 < nEndRow) { ++nFirstRow; --nLastRow; }
for (j=nFirstRow; j<=nLastRow && bOk; j++)
if (!pDoc->HasStringData( nStartCol,j,nTab ))
bOk = sal_False;
if (bOk)
nFlags |= NAME_LEFT;
else // Right nur wenn nicht Left
{
bOk = sal_True;
for (j=nFirstRow; j<=nLastRow && bOk; j++)
if (!pDoc->HasStringData( nEndCol,j,nTab ))
bOk = sal_False;
if (bOk)
nFlags |= NAME_RIGHT;
}
}
if (nStartCol == nEndCol)
nFlags &= ~( NAME_LEFT | NAME_RIGHT );
if (nStartRow == nEndRow)
nFlags &= ~( NAME_TOP | NAME_BOTTOM );
return nFlags;
}
void ScViewFunc::InsertNameList()
{
ScAddress aPos( GetViewData()->GetCurX(), GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
ScDocShell* pDocSh = GetViewData()->GetDocShell();
if ( pDocSh->GetDocFunc().InsertNameList( aPos, sal_False ) )
pDocSh->UpdateOle(GetViewData());
}