1b3f79822SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3b3f79822SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4b3f79822SAndrew Rist * or more contributor license agreements. See the NOTICE file
5b3f79822SAndrew Rist * distributed with this work for additional information
6b3f79822SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7b3f79822SAndrew Rist * to you under the Apache License, Version 2.0 (the
8b3f79822SAndrew Rist * "License"); you may not use this file except in compliance
9b3f79822SAndrew Rist * with the License. You may obtain a copy of the License at
10b3f79822SAndrew Rist *
11b3f79822SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12b3f79822SAndrew Rist *
13b3f79822SAndrew Rist * Unless required by applicable law or agreed to in writing,
14b3f79822SAndrew Rist * software distributed under the License is distributed on an
15b3f79822SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16b3f79822SAndrew Rist * KIND, either express or implied. See the License for the
17b3f79822SAndrew Rist * specific language governing permissions and limitations
18b3f79822SAndrew Rist * under the License.
19b3f79822SAndrew Rist *
20b3f79822SAndrew Rist *************************************************************/
21b3f79822SAndrew Rist
22b3f79822SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sc.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir
28cdf0e10cSrcweir
29cdf0e10cSrcweir //------------------------------------------------------------------
30cdf0e10cSrcweir
31cdf0e10cSrcweir // INCLUDE ---------------------------------------------------------------
32cdf0e10cSrcweir
33cdf0e10cSrcweir #include "scitems.hxx"
34cdf0e10cSrcweir #include <editeng/eeitem.hxx>
35cdf0e10cSrcweir
36cdf0e10cSrcweir #include <sfx2/app.hxx>
37cdf0e10cSrcweir #include <svx/algitem.hxx>
38cdf0e10cSrcweir #include <editeng/boxitem.hxx>
39cdf0e10cSrcweir #include <editeng/editobj.hxx>
40cdf0e10cSrcweir #include <editeng/editview.hxx>
41cdf0e10cSrcweir #include <editeng/langitem.hxx>
42cdf0e10cSrcweir #include <editeng/scripttypeitem.hxx>
43cdf0e10cSrcweir #include <sfx2/bindings.hxx>
44cdf0e10cSrcweir #include <svl/zforlist.hxx>
45cdf0e10cSrcweir #include <svl/zformat.hxx>
46cdf0e10cSrcweir #include <vcl/msgbox.hxx>
47cdf0e10cSrcweir #include <vcl/sound.hxx>
48cdf0e10cSrcweir #include <vcl/virdev.hxx>
49cdf0e10cSrcweir #include <vcl/waitobj.hxx>
50cdf0e10cSrcweir #include <vcl/wrkwin.hxx>
51cdf0e10cSrcweir #include <stdlib.h> // qsort
52cdf0e10cSrcweir
53cdf0e10cSrcweir #include "viewfunc.hxx"
54cdf0e10cSrcweir #include "tabvwsh.hxx"
55cdf0e10cSrcweir #include "docsh.hxx"
56cdf0e10cSrcweir #include "attrib.hxx"
57cdf0e10cSrcweir #include "patattr.hxx"
58cdf0e10cSrcweir #include "docpool.hxx"
59cdf0e10cSrcweir #include "uiitems.hxx"
60cdf0e10cSrcweir #include "sc.hrc"
61cdf0e10cSrcweir #include "undocell.hxx"
62cdf0e10cSrcweir #include "undoblk.hxx"
63cdf0e10cSrcweir #include "undotab.hxx"
64cdf0e10cSrcweir #include "refundo.hxx"
65cdf0e10cSrcweir #include "dbcolect.hxx"
66cdf0e10cSrcweir #include "olinetab.hxx"
67cdf0e10cSrcweir #include "rangeutl.hxx"
68cdf0e10cSrcweir #include "rangenam.hxx"
69cdf0e10cSrcweir #include "globstr.hrc"
70cdf0e10cSrcweir #include "global.hxx"
71cdf0e10cSrcweir #include "stlsheet.hxx"
72cdf0e10cSrcweir #include "editutil.hxx"
73cdf0e10cSrcweir //CHINA001 #include "namecrea.hxx" // wegen Flags
74cdf0e10cSrcweir #include "cell.hxx"
75cdf0e10cSrcweir #include "scresid.hxx"
76cdf0e10cSrcweir #include "inputhdl.hxx"
77cdf0e10cSrcweir #include "scmod.hxx"
78cdf0e10cSrcweir #include "inputopt.hxx"
79cdf0e10cSrcweir #include "compiler.hxx"
80cdf0e10cSrcweir #include "docfunc.hxx"
81cdf0e10cSrcweir #include "appoptio.hxx"
82cdf0e10cSrcweir #include "dociter.hxx"
83cdf0e10cSrcweir #include "sizedev.hxx"
84cdf0e10cSrcweir #include "editable.hxx"
85cdf0e10cSrcweir #include "scui_def.hxx" //CHINA001
86cdf0e10cSrcweir #include "funcdesc.hxx"
87cdf0e10cSrcweir #include "docuno.hxx"
88cdf0e10cSrcweir #include "cellsuno.hxx"
89cdf0e10cSrcweir //==================================================================
90cdf0e10cSrcweir
ScViewFunc(Window * pParent,ScDocShell & rDocSh,ScTabViewShell * pViewShell)91cdf0e10cSrcweir ScViewFunc::ScViewFunc( Window* pParent, ScDocShell& rDocSh, ScTabViewShell* pViewShell ) :
92cdf0e10cSrcweir ScTabView( pParent, rDocSh, pViewShell ),
93cdf0e10cSrcweir bFormatValid( sal_False )
94cdf0e10cSrcweir {
95cdf0e10cSrcweir }
96cdf0e10cSrcweir
97cdf0e10cSrcweir //UNUSED2008-05 ScViewFunc::ScViewFunc( Window* pParent, const ScViewFunc& rViewFunc, ScTabViewShell* pViewShell ) :
98cdf0e10cSrcweir //UNUSED2008-05 ScTabView( pParent, rViewFunc, pViewShell ),
99cdf0e10cSrcweir //UNUSED2008-05 bFormatValid( sal_False )
100cdf0e10cSrcweir //UNUSED2008-05 {
101cdf0e10cSrcweir //UNUSED2008-05 }
102cdf0e10cSrcweir
~ScViewFunc()103cdf0e10cSrcweir ScViewFunc::~ScViewFunc()
104cdf0e10cSrcweir {
105cdf0e10cSrcweir }
106cdf0e10cSrcweir
107cdf0e10cSrcweir //------------------------------------------------------------------------------------
108cdf0e10cSrcweir
StartFormatArea()109cdf0e10cSrcweir void ScViewFunc::StartFormatArea()
110cdf0e10cSrcweir {
111cdf0e10cSrcweir // ueberhaupt aktiviert?
112cdf0e10cSrcweir if ( !SC_MOD()->GetInputOptions().GetExtendFormat() )
113cdf0e10cSrcweir return;
114cdf0e10cSrcweir
115cdf0e10cSrcweir // start only with single cell (marked or cursor position)
116cdf0e10cSrcweir ScRange aMarkRange;
117cdf0e10cSrcweir sal_Bool bOk = (GetViewData()->GetSimpleArea( aMarkRange ) == SC_MARK_SIMPLE);
118cdf0e10cSrcweir if ( bOk && aMarkRange.aStart != aMarkRange.aEnd )
119cdf0e10cSrcweir bOk = sal_False;
120cdf0e10cSrcweir
121cdf0e10cSrcweir if (bOk)
122cdf0e10cSrcweir {
123cdf0e10cSrcweir bFormatValid = sal_True;
124cdf0e10cSrcweir aFormatSource = aMarkRange.aStart;
125cdf0e10cSrcweir aFormatArea = ScRange( aFormatSource );
126cdf0e10cSrcweir }
127cdf0e10cSrcweir else
128cdf0e10cSrcweir bFormatValid = sal_False; // keinen alten Bereich behalten
129cdf0e10cSrcweir }
130cdf0e10cSrcweir
TestFormatArea(SCCOL nCol,SCROW nRow,SCTAB nTab,sal_Bool bAttrChanged)131cdf0e10cSrcweir sal_Bool ScViewFunc::TestFormatArea( SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bAttrChanged )
132cdf0e10cSrcweir {
133cdf0e10cSrcweir // ueberhaupt aktiviert?
134cdf0e10cSrcweir if ( !SC_MOD()->GetInputOptions().GetExtendFormat() )
135cdf0e10cSrcweir return sal_False;
136cdf0e10cSrcweir
137cdf0e10cSrcweir // Test: Eingabe mit Zahlformat (bAttrChanged) immer als neue Attributierung behandeln
138cdf0e10cSrcweir // (alte Area verwerfen). Wenn das nicht gewollt ist, den if-Teil weglassen:
139cdf0e10cSrcweir if ( bAttrChanged )
140cdf0e10cSrcweir {
141cdf0e10cSrcweir StartFormatArea();
142cdf0e10cSrcweir return sal_False;
143cdf0e10cSrcweir }
144cdf0e10cSrcweir
145cdf0e10cSrcweir //! Abfrage, ob Zelle leer war ???
146cdf0e10cSrcweir
147cdf0e10cSrcweir sal_Bool bFound = sal_False;
148cdf0e10cSrcweir ScRange aNewRange = aFormatArea;
149cdf0e10cSrcweir if ( bFormatValid && nTab == aFormatSource.Tab() )
150cdf0e10cSrcweir {
151cdf0e10cSrcweir if ( nRow >= aFormatArea.aStart.Row() && nRow <= aFormatArea.aEnd.Row() )
152cdf0e10cSrcweir {
153cdf0e10cSrcweir // innerhalb ?
154cdf0e10cSrcweir if ( nCol >= aFormatArea.aStart.Col() && nCol <= aFormatArea.aEnd.Col() )
155cdf0e10cSrcweir {
156cdf0e10cSrcweir bFound = sal_True; // Bereich nicht aendern
157cdf0e10cSrcweir }
158cdf0e10cSrcweir // links ?
159cdf0e10cSrcweir if ( nCol+1 == aFormatArea.aStart.Col() )
160cdf0e10cSrcweir {
161cdf0e10cSrcweir bFound = sal_True;
162cdf0e10cSrcweir aNewRange.aStart.SetCol( nCol );
163cdf0e10cSrcweir }
164cdf0e10cSrcweir // rechts ?
165cdf0e10cSrcweir if ( nCol == aFormatArea.aEnd.Col()+1 )
166cdf0e10cSrcweir {
167cdf0e10cSrcweir bFound = sal_True;
168cdf0e10cSrcweir aNewRange.aEnd.SetCol( nCol );
169cdf0e10cSrcweir }
170cdf0e10cSrcweir }
171cdf0e10cSrcweir if ( nCol >= aFormatArea.aStart.Col() && nCol <= aFormatArea.aEnd.Col() )
172cdf0e10cSrcweir {
173cdf0e10cSrcweir // oben ?
174cdf0e10cSrcweir if ( nRow+1 == aFormatArea.aStart.Row() )
175cdf0e10cSrcweir {
176cdf0e10cSrcweir bFound = sal_True;
177cdf0e10cSrcweir aNewRange.aStart.SetRow( nRow );
178cdf0e10cSrcweir }
179cdf0e10cSrcweir // unten ?
180cdf0e10cSrcweir if ( nRow == aFormatArea.aEnd.Row()+1 )
181cdf0e10cSrcweir {
182cdf0e10cSrcweir bFound = sal_True;
183cdf0e10cSrcweir aNewRange.aEnd.SetRow( nRow );
184cdf0e10cSrcweir }
185cdf0e10cSrcweir }
186cdf0e10cSrcweir }
187cdf0e10cSrcweir
188cdf0e10cSrcweir if (bFound)
189cdf0e10cSrcweir aFormatArea = aNewRange; // erweitern
190cdf0e10cSrcweir else
191cdf0e10cSrcweir {
192cdf0e10cSrcweir bFormatValid = sal_False; // ausserhalb -> abbrechen
193cdf0e10cSrcweir if ( bAttrChanged ) // Wert mit Zahlformat eingegeben?
194cdf0e10cSrcweir StartFormatArea(); // dann ggf. neu starten
195cdf0e10cSrcweir }
196cdf0e10cSrcweir
197cdf0e10cSrcweir return bFound;
198cdf0e10cSrcweir }
199cdf0e10cSrcweir
DoAutoAttributes(SCCOL nCol,SCROW nRow,SCTAB nTab,sal_Bool bAttrChanged,sal_Bool bAddUndo)200cdf0e10cSrcweir void ScViewFunc::DoAutoAttributes( SCCOL nCol, SCROW nRow, SCTAB nTab,
201cdf0e10cSrcweir sal_Bool bAttrChanged, sal_Bool bAddUndo )
202cdf0e10cSrcweir {
203cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
204cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
205cdf0e10cSrcweir if (bAddUndo && !pDoc->IsUndoEnabled())
206cdf0e10cSrcweir bAddUndo = sal_False;
207cdf0e10cSrcweir
208cdf0e10cSrcweir const ScPatternAttr* pSource = pDoc->GetPattern(
209cdf0e10cSrcweir aFormatSource.Col(), aFormatSource.Row(), nTab );
210cdf0e10cSrcweir if ( !((const ScMergeAttr&)pSource->GetItem(ATTR_MERGE)).IsMerged() )
211cdf0e10cSrcweir {
212cdf0e10cSrcweir const ScPatternAttr* pDocOld = pDoc->GetPattern( nCol, nRow, nTab );
213cdf0e10cSrcweir // pDocOld ist nur bis zum Apply... gueltig!
214cdf0e10cSrcweir
215cdf0e10cSrcweir ScPatternAttr* pOldPattern = NULL;
216cdf0e10cSrcweir if ( bAddUndo )
217cdf0e10cSrcweir pOldPattern = new ScPatternAttr( *pDocOld );
218cdf0e10cSrcweir
219cdf0e10cSrcweir const ScStyleSheet* pSrcStyle = pSource->GetStyleSheet();
220cdf0e10cSrcweir if ( pSrcStyle && pSrcStyle != pDocOld->GetStyleSheet() )
221cdf0e10cSrcweir pDoc->ApplyStyle( nCol, nRow, nTab, *pSrcStyle );
222cdf0e10cSrcweir pDoc->ApplyPattern( nCol, nRow, nTab, *pSource );
223cdf0e10cSrcweir AdjustRowHeight( nRow, nRow, sal_True ); //! nicht doppelt ?
224cdf0e10cSrcweir
225cdf0e10cSrcweir if ( bAddUndo )
226cdf0e10cSrcweir {
227cdf0e10cSrcweir const ScPatternAttr* pNewPattern = pDoc->GetPattern( nCol, nRow, nTab );
228cdf0e10cSrcweir
229cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
230cdf0e10cSrcweir new ScUndoCursorAttr( pDocSh, nCol, nRow, nTab,
231cdf0e10cSrcweir pOldPattern, pNewPattern, pSource,
232cdf0e10cSrcweir sal_True ) );
233cdf0e10cSrcweir
234cdf0e10cSrcweir delete pOldPattern; // wird im Undo kopiert (Pool)
235cdf0e10cSrcweir }
236cdf0e10cSrcweir }
237cdf0e10cSrcweir
238cdf0e10cSrcweir if ( bAttrChanged ) // Wert mit Zahlformat eingegeben?
239cdf0e10cSrcweir aFormatSource.Set( nCol, nRow, nTab ); // dann als neue Quelle
240cdf0e10cSrcweir }
241cdf0e10cSrcweir
242cdf0e10cSrcweir //------------------------------------------------------------------------------------
243cdf0e10cSrcweir
244cdf0e10cSrcweir // Hilfsroutinen
245cdf0e10cSrcweir
GetOptimalColWidth(SCCOL nCol,SCTAB nTab,sal_Bool bFormula)246cdf0e10cSrcweir sal_uInt16 ScViewFunc::GetOptimalColWidth( SCCOL nCol, SCTAB nTab, sal_Bool bFormula )
247cdf0e10cSrcweir {
248cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
249cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
250cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
251cdf0e10cSrcweir
252cdf0e10cSrcweir double nPPTX = GetViewData()->GetPPTX();
253cdf0e10cSrcweir double nPPTY = GetViewData()->GetPPTY();
254cdf0e10cSrcweir Fraction aZoomX = GetViewData()->GetZoomX();
255cdf0e10cSrcweir Fraction aZoomY = GetViewData()->GetZoomY();
256cdf0e10cSrcweir
257cdf0e10cSrcweir ScSizeDeviceProvider aProv(pDocSh);
258cdf0e10cSrcweir if (aProv.IsPrinter())
259cdf0e10cSrcweir {
260cdf0e10cSrcweir nPPTX = aProv.GetPPTX();
261cdf0e10cSrcweir nPPTY = aProv.GetPPTY();
262cdf0e10cSrcweir aZoomX = aZoomY = Fraction( 1, 1 );
263cdf0e10cSrcweir }
264cdf0e10cSrcweir
265cdf0e10cSrcweir sal_uInt16 nTwips = pDoc->GetOptimalColWidth( nCol, nTab, aProv.GetDevice(),
266cdf0e10cSrcweir nPPTX, nPPTY, aZoomX, aZoomY, bFormula, &rMark );
267cdf0e10cSrcweir return nTwips;
268cdf0e10cSrcweir }
269cdf0e10cSrcweir
SelectionEditable(sal_Bool * pOnlyNotBecauseOfMatrix)270cdf0e10cSrcweir sal_Bool ScViewFunc::SelectionEditable( sal_Bool* pOnlyNotBecauseOfMatrix /* = NULL */ )
271cdf0e10cSrcweir {
272cdf0e10cSrcweir sal_Bool bRet;
273cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
274cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
275cdf0e10cSrcweir if (rMark.IsMarked() || rMark.IsMultiMarked())
276cdf0e10cSrcweir bRet = pDoc->IsSelectionEditable( rMark, pOnlyNotBecauseOfMatrix );
277cdf0e10cSrcweir else
278cdf0e10cSrcweir {
279cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
280cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
281cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
282cdf0e10cSrcweir bRet = pDoc->IsBlockEditable( nTab, nCol, nRow, nCol, nRow,
283cdf0e10cSrcweir pOnlyNotBecauseOfMatrix );
284cdf0e10cSrcweir }
285cdf0e10cSrcweir return bRet;
286cdf0e10cSrcweir }
287cdf0e10cSrcweir
288cdf0e10cSrcweir #ifndef LRU_MAX
289cdf0e10cSrcweir #define LRU_MAX 10
290cdf0e10cSrcweir #endif
291cdf0e10cSrcweir
lcl_FunctionKnown(sal_uInt16 nOpCode)292cdf0e10cSrcweir sal_Bool lcl_FunctionKnown( sal_uInt16 nOpCode )
293cdf0e10cSrcweir {
294cdf0e10cSrcweir const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
295cdf0e10cSrcweir if ( pFuncList )
296cdf0e10cSrcweir {
297cdf0e10cSrcweir sal_uLong nCount = pFuncList->GetCount();
298cdf0e10cSrcweir for (sal_uLong i=0; i<nCount; i++)
299cdf0e10cSrcweir if ( pFuncList->GetFunction(i)->nFIndex == nOpCode )
300cdf0e10cSrcweir return sal_True;
301cdf0e10cSrcweir }
302cdf0e10cSrcweir return sal_False;
303cdf0e10cSrcweir }
304cdf0e10cSrcweir
lcl_AddFunction(ScAppOptions & rAppOpt,sal_uInt16 nOpCode)305cdf0e10cSrcweir sal_Bool lcl_AddFunction( ScAppOptions& rAppOpt, sal_uInt16 nOpCode )
306cdf0e10cSrcweir {
307cdf0e10cSrcweir sal_uInt16 nOldCount = rAppOpt.GetLRUFuncListCount();
308cdf0e10cSrcweir sal_uInt16* pOldList = rAppOpt.GetLRUFuncList();
309cdf0e10cSrcweir sal_uInt16 nPos;
310cdf0e10cSrcweir for (nPos=0; nPos<nOldCount; nPos++)
311cdf0e10cSrcweir if (pOldList[nPos] == nOpCode) // is the function already in the list?
312cdf0e10cSrcweir {
313cdf0e10cSrcweir if ( nPos == 0 )
314cdf0e10cSrcweir return sal_False; // already at the top -> no change
315cdf0e10cSrcweir
316cdf0e10cSrcweir // count doesn't change, so the original array is modified
317cdf0e10cSrcweir
318cdf0e10cSrcweir for (sal_uInt16 nCopy=nPos; nCopy>0; nCopy--)
319cdf0e10cSrcweir pOldList[nCopy] = pOldList[nCopy-1];
320cdf0e10cSrcweir pOldList[0] = nOpCode;
321cdf0e10cSrcweir
322cdf0e10cSrcweir return sal_True; // list has changed
323cdf0e10cSrcweir }
324cdf0e10cSrcweir
325cdf0e10cSrcweir if ( !lcl_FunctionKnown( nOpCode ) )
326cdf0e10cSrcweir return sal_False; // not in function list -> no change
327cdf0e10cSrcweir
328cdf0e10cSrcweir sal_uInt16 nNewCount = Min( (sal_uInt16)(nOldCount + 1), (sal_uInt16)LRU_MAX );
329cdf0e10cSrcweir sal_uInt16 nNewList[LRU_MAX];
330cdf0e10cSrcweir nNewList[0] = nOpCode;
331cdf0e10cSrcweir for (nPos=1; nPos<nNewCount; nPos++)
332cdf0e10cSrcweir nNewList[nPos] = pOldList[nPos-1];
333cdf0e10cSrcweir rAppOpt.SetLRUFuncList( nNewList, nNewCount );
334cdf0e10cSrcweir
335cdf0e10cSrcweir return sal_True; // list has changed
336cdf0e10cSrcweir }
337cdf0e10cSrcweir
338cdf0e10cSrcweir // eigentliche Funktionen
339cdf0e10cSrcweir
340cdf0e10cSrcweir // Eingabe - Undo OK
341cdf0e10cSrcweir
EnterData(SCCOL nCol,SCROW nRow,SCTAB nTab,const String & rString,sal_Bool bRecord,const EditTextObject * pData)342cdf0e10cSrcweir void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab, const String& rString,
343cdf0e10cSrcweir sal_Bool bRecord, const EditTextObject* pData )
344cdf0e10cSrcweir {
345cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
346cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
347cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
348cdf0e10cSrcweir SCTAB nSelCount = rMark.GetSelectCount();
349cdf0e10cSrcweir SCTAB i;
350cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
351cdf0e10cSrcweir bRecord = sal_False;
352cdf0e10cSrcweir
353cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
354cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
355cdf0e10cSrcweir
356cdf0e10cSrcweir ScEditableTester aTester( pDoc, nCol,nRow, nCol,nRow, rMark );
357cdf0e10cSrcweir if (aTester.IsEditable())
358cdf0e10cSrcweir {
359cdf0e10cSrcweir sal_Bool bEditDeleted = sal_False;
360cdf0e10cSrcweir sal_uInt8 nOldScript = 0;
361cdf0e10cSrcweir
362cdf0e10cSrcweir ScBaseCell** ppOldCells = NULL;
363cdf0e10cSrcweir sal_Bool* pHasFormat = NULL;
364cdf0e10cSrcweir sal_uLong* pOldFormats = NULL;
365cdf0e10cSrcweir SCTAB* pTabs = NULL;
366cdf0e10cSrcweir SCTAB nUndoPos = 0;
367cdf0e10cSrcweir EditTextObject* pUndoData = NULL;
368cdf0e10cSrcweir if ( bRecord )
369cdf0e10cSrcweir {
370cdf0e10cSrcweir ppOldCells = new ScBaseCell*[nSelCount];
371cdf0e10cSrcweir pHasFormat = new sal_Bool[nSelCount];
372cdf0e10cSrcweir pOldFormats = new sal_uLong[nSelCount];
373cdf0e10cSrcweir pTabs = new SCTAB[nSelCount];
374cdf0e10cSrcweir nUndoPos = 0;
375cdf0e10cSrcweir
376cdf0e10cSrcweir for (i=0; i<nTabCount; i++)
377cdf0e10cSrcweir if (rMark.GetTableSelect(i))
378cdf0e10cSrcweir {
379cdf0e10cSrcweir pTabs[nUndoPos] = i;
380cdf0e10cSrcweir ScBaseCell* pDocCell;
381cdf0e10cSrcweir pDoc->GetCell( nCol, nRow, i, pDocCell );
382cdf0e10cSrcweir if ( pDocCell )
383cdf0e10cSrcweir {
384cdf0e10cSrcweir ppOldCells[nUndoPos] = pDocCell->CloneWithoutNote( *pDoc );
385cdf0e10cSrcweir if ( pDocCell->GetCellType() == CELLTYPE_EDIT )
386cdf0e10cSrcweir bEditDeleted = sal_True;
387cdf0e10cSrcweir
388cdf0e10cSrcweir sal_uInt8 nDocScript = pDoc->GetScriptType( nCol, nRow, i, pDocCell );
389cdf0e10cSrcweir if ( nOldScript == 0 )
390cdf0e10cSrcweir nOldScript = nDocScript;
391cdf0e10cSrcweir else if ( nDocScript != nOldScript )
392cdf0e10cSrcweir bEditDeleted = sal_True;
393cdf0e10cSrcweir }
394cdf0e10cSrcweir else
395cdf0e10cSrcweir {
396cdf0e10cSrcweir ppOldCells[nUndoPos] = NULL;
397cdf0e10cSrcweir }
398cdf0e10cSrcweir
399cdf0e10cSrcweir const SfxPoolItem* pItem;
400cdf0e10cSrcweir const ScPatternAttr* pPattern = pDoc->GetPattern(nCol, nRow, i);
401cdf0e10cSrcweir if ( SFX_ITEM_SET == pPattern->GetItemSet().GetItemState(
402cdf0e10cSrcweir ATTR_VALUE_FORMAT,sal_False,&pItem) )
403cdf0e10cSrcweir {
404cdf0e10cSrcweir pHasFormat[nUndoPos] = sal_True;
405cdf0e10cSrcweir pOldFormats[nUndoPos] = ((const SfxUInt32Item*)pItem)->GetValue();
406cdf0e10cSrcweir }
407cdf0e10cSrcweir else
408cdf0e10cSrcweir pHasFormat[nUndoPos] = sal_False;
409cdf0e10cSrcweir
410cdf0e10cSrcweir ++nUndoPos;
411cdf0e10cSrcweir }
412cdf0e10cSrcweir
413cdf0e10cSrcweir DBG_ASSERT( nUndoPos==nSelCount, "nUndoPos!=nSelCount" );
414cdf0e10cSrcweir
415cdf0e10cSrcweir pUndoData = ( pData ? pData->Clone() : NULL );
416cdf0e10cSrcweir }
417cdf0e10cSrcweir
418cdf0e10cSrcweir bool bFormula = false;
419cdf0e10cSrcweir
420cdf0e10cSrcweir // a single '=' character is handled as string (needed for special filters)
421cdf0e10cSrcweir if ( rString.Len() > 1 )
422cdf0e10cSrcweir {
423cdf0e10cSrcweir if ( rString.GetChar(0) == '=' )
424cdf0e10cSrcweir {
425cdf0e10cSrcweir // handle as formula
426cdf0e10cSrcweir bFormula = true;
427cdf0e10cSrcweir }
428cdf0e10cSrcweir else if ( rString.GetChar(0) == '+' || rString.GetChar(0) == '-' )
429cdf0e10cSrcweir {
430cdf0e10cSrcweir // if there is more than one leading '+' or '-' character, remove the additional ones
431cdf0e10cSrcweir String aString( rString );
432cdf0e10cSrcweir xub_StrLen nIndex = 1;
433cdf0e10cSrcweir xub_StrLen nLen = aString.Len();
434cdf0e10cSrcweir while ( nIndex < nLen && ( aString.GetChar( nIndex ) == '+' || aString.GetChar( nIndex ) == '-' ) )
435cdf0e10cSrcweir {
436cdf0e10cSrcweir ++nIndex;
437cdf0e10cSrcweir }
438cdf0e10cSrcweir aString.Erase( 1, nIndex - 1 );
439cdf0e10cSrcweir
440cdf0e10cSrcweir // if the remaining part without the leading '+' or '-' character
441cdf0e10cSrcweir // is non-empty and not a number, handle as formula
442cdf0e10cSrcweir if ( aString.Len() > 1 )
443cdf0e10cSrcweir {
444cdf0e10cSrcweir sal_uInt32 nFormat = 0;
445cdf0e10cSrcweir pDoc->GetNumberFormat( nCol, nRow, nTab, nFormat );
446cdf0e10cSrcweir SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
447cdf0e10cSrcweir double fNumber = 0;
448cdf0e10cSrcweir if ( !pFormatter->IsNumberFormat( aString, nFormat, fNumber ) )
449cdf0e10cSrcweir {
450cdf0e10cSrcweir bFormula = true;
451cdf0e10cSrcweir }
452cdf0e10cSrcweir }
453cdf0e10cSrcweir }
454cdf0e10cSrcweir }
455cdf0e10cSrcweir
456cdf0e10cSrcweir sal_Bool bNumFmtChanged = sal_False;
457cdf0e10cSrcweir if ( bFormula )
458cdf0e10cSrcweir { // Formel, compile mit AutoCorrection
459cdf0e10cSrcweir for (i=0; i<nTabCount; i++)
460cdf0e10cSrcweir if (rMark.GetTableSelect(i))
461cdf0e10cSrcweir break;
462cdf0e10cSrcweir ScAddress aPos( nCol, nRow, i );
463cdf0e10cSrcweir ScCompiler aComp( pDoc, aPos);
464cdf0e10cSrcweir aComp.SetGrammar(pDoc->GetGrammar());
465cdf0e10cSrcweir //2do: AutoCorrection via CalcOptions abschaltbar machen
466cdf0e10cSrcweir aComp.SetAutoCorrection( sal_True );
467cdf0e10cSrcweir if ( rString.GetChar(0) == '+' || rString.GetChar(0) == '-' )
468cdf0e10cSrcweir {
469cdf0e10cSrcweir aComp.SetExtendedErrorDetection( true );
470cdf0e10cSrcweir }
471cdf0e10cSrcweir String aFormula( rString );
472cdf0e10cSrcweir ScTokenArray* pArr;
473cdf0e10cSrcweir sal_Bool bAgain;
474cdf0e10cSrcweir do
475cdf0e10cSrcweir {
476cdf0e10cSrcweir bAgain = sal_False;
477cdf0e10cSrcweir sal_Bool bAddEqual = sal_False;
478cdf0e10cSrcweir ScTokenArray* pArrFirst = pArr = aComp.CompileString( aFormula );
479cdf0e10cSrcweir sal_Bool bCorrected = aComp.IsCorrected();
480cdf0e10cSrcweir if ( bCorrected )
481cdf0e10cSrcweir { // probieren, mit erster Parser-Korrektur neu zu parsen
482cdf0e10cSrcweir pArr = aComp.CompileString( aComp.GetCorrectedFormula() );
483cdf0e10cSrcweir }
484cdf0e10cSrcweir if ( !pArr->GetCodeError() )
485cdf0e10cSrcweir {
486cdf0e10cSrcweir bAddEqual = sal_True;
487cdf0e10cSrcweir aComp.CompileTokenArray();
488cdf0e10cSrcweir bCorrected |= aComp.IsCorrected();
489cdf0e10cSrcweir }
490cdf0e10cSrcweir if ( bCorrected )
491cdf0e10cSrcweir {
492cdf0e10cSrcweir String aCorrectedFormula;
493cdf0e10cSrcweir if ( bAddEqual )
494cdf0e10cSrcweir {
495cdf0e10cSrcweir aCorrectedFormula = '=';
496cdf0e10cSrcweir aCorrectedFormula += aComp.GetCorrectedFormula();
497cdf0e10cSrcweir }
498cdf0e10cSrcweir else
499cdf0e10cSrcweir aCorrectedFormula = aComp.GetCorrectedFormula();
500cdf0e10cSrcweir short nResult;
501cdf0e10cSrcweir if ( aCorrectedFormula.Len() == 1 )
502cdf0e10cSrcweir nResult = RET_NO; // leere Formel, nur '='
503cdf0e10cSrcweir else
504cdf0e10cSrcweir {
505cdf0e10cSrcweir String aMessage( ScResId( SCSTR_FORMULA_AUTOCORRECTION ) );
506cdf0e10cSrcweir aMessage += aCorrectedFormula;
507cdf0e10cSrcweir nResult = QueryBox( GetViewData()->GetDialogParent(),
508cdf0e10cSrcweir WinBits(WB_YES_NO | WB_DEF_YES),
509cdf0e10cSrcweir aMessage ).Execute();
510cdf0e10cSrcweir }
511cdf0e10cSrcweir if ( nResult == RET_YES )
512cdf0e10cSrcweir {
513cdf0e10cSrcweir aFormula = aCorrectedFormula;
514cdf0e10cSrcweir if ( pArr != pArrFirst )
515cdf0e10cSrcweir delete pArrFirst;
516cdf0e10cSrcweir bAgain = sal_True;
517cdf0e10cSrcweir }
518cdf0e10cSrcweir else
519cdf0e10cSrcweir {
520cdf0e10cSrcweir if ( pArr != pArrFirst )
521cdf0e10cSrcweir {
522cdf0e10cSrcweir delete pArr;
523cdf0e10cSrcweir pArr = pArrFirst;
524cdf0e10cSrcweir }
525cdf0e10cSrcweir }
526cdf0e10cSrcweir }
527cdf0e10cSrcweir } while ( bAgain );
528cdf0e10cSrcweir // um in mehreren Tabellen eingesetzt zu werden, muss die Formel
529cdf0e10cSrcweir // via ScFormulaCell copy-ctor evtl. wegen RangeNames neu kompiliert
530cdf0e10cSrcweir // werden, gleiches Code-Array fuer alle Zellen geht nicht.
531cdf0e10cSrcweir // Wenn das Array einen Fehler enthaelt, muss in den neu erzeugten
532cdf0e10cSrcweir // Zellen RPN geloescht und der Fehler explizit gesetzt werden, da
533cdf0e10cSrcweir // via FormulaCell copy-ctor und Interpreter das, wenn moeglich,
534cdf0e10cSrcweir // wieder glattgebuegelt wird, zu intelligent.. z.B.: =1))
535cdf0e10cSrcweir sal_uInt16 nError = pArr->GetCodeError();
536cdf0e10cSrcweir if ( !nError )
537cdf0e10cSrcweir {
538cdf0e10cSrcweir // #68693# update list of recent functions with all functions that
539cdf0e10cSrcweir // are not within parentheses
540cdf0e10cSrcweir
541cdf0e10cSrcweir ScModule* pScMod = SC_MOD();
542cdf0e10cSrcweir ScAppOptions aAppOpt = pScMod->GetAppOptions();
543cdf0e10cSrcweir sal_Bool bOptChanged = sal_False;
544cdf0e10cSrcweir
545cdf0e10cSrcweir formula::FormulaToken** ppToken = pArr->GetArray();
546cdf0e10cSrcweir sal_uInt16 nTokens = pArr->GetLen();
547cdf0e10cSrcweir sal_uInt16 nLevel = 0;
548cdf0e10cSrcweir for (sal_uInt16 nTP=0; nTP<nTokens; nTP++)
549cdf0e10cSrcweir {
550cdf0e10cSrcweir formula::FormulaToken* pTok = ppToken[nTP];
551cdf0e10cSrcweir OpCode eOp = pTok->GetOpCode();
552cdf0e10cSrcweir if ( eOp == ocOpen )
553cdf0e10cSrcweir ++nLevel;
554cdf0e10cSrcweir else if ( eOp == ocClose && nLevel )
555cdf0e10cSrcweir --nLevel;
556cdf0e10cSrcweir if ( nLevel == 0 && pTok->IsFunction() &&
557cdf0e10cSrcweir lcl_AddFunction( aAppOpt, sal::static_int_cast<sal_uInt16>( eOp ) ) )
558cdf0e10cSrcweir bOptChanged = sal_True;
559cdf0e10cSrcweir }
560cdf0e10cSrcweir
561cdf0e10cSrcweir if ( bOptChanged )
562cdf0e10cSrcweir {
563cdf0e10cSrcweir pScMod->SetAppOptions(aAppOpt);
564cdf0e10cSrcweir pScMod->RecentFunctionsChanged();
565cdf0e10cSrcweir }
566cdf0e10cSrcweir }
567cdf0e10cSrcweir
568cdf0e10cSrcweir ScFormulaCell aCell( pDoc, aPos, pArr,formula::FormulaGrammar::GRAM_DEFAULT, MM_NONE );
569cdf0e10cSrcweir delete pArr;
570cdf0e10cSrcweir sal_Bool bAutoCalc = pDoc->GetAutoCalc();
571cdf0e10cSrcweir SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
572cdf0e10cSrcweir for ( ; i<nTabCount; i++)
573cdf0e10cSrcweir {
574cdf0e10cSrcweir if (rMark.GetTableSelect(i))
575cdf0e10cSrcweir {
576cdf0e10cSrcweir aPos.SetTab( i );
577cdf0e10cSrcweir sal_uLong nIndex = (sal_uLong) ((SfxUInt32Item*) pDoc->GetAttr(
578cdf0e10cSrcweir nCol, nRow, i, ATTR_VALUE_FORMAT ))->GetValue();
579cdf0e10cSrcweir if ( pFormatter->GetType( nIndex ) == NUMBERFORMAT_TEXT ||
580cdf0e10cSrcweir ( ( rString.GetChar(0) == '+' || rString.GetChar(0) == '-' ) && nError && rString.Equals( aFormula ) ) )
581cdf0e10cSrcweir {
582cdf0e10cSrcweir if ( pData )
583cdf0e10cSrcweir {
584cdf0e10cSrcweir ScEditCell* pCell = new ScEditCell( pData, pDoc, NULL );
585cdf0e10cSrcweir pDoc->PutCell( aPos, pCell );
586cdf0e10cSrcweir }
587cdf0e10cSrcweir else
588cdf0e10cSrcweir {
589cdf0e10cSrcweir ScStringCell* pCell = new ScStringCell( aFormula );
590cdf0e10cSrcweir pDoc->PutCell( aPos, pCell );
591cdf0e10cSrcweir }
592cdf0e10cSrcweir }
593cdf0e10cSrcweir else
594cdf0e10cSrcweir {
595cdf0e10cSrcweir DELETEZ(pUndoData);
596cdf0e10cSrcweir ScFormulaCell* pCell = new ScFormulaCell( aCell, *pDoc, aPos );
597cdf0e10cSrcweir if ( nError )
598cdf0e10cSrcweir {
599cdf0e10cSrcweir pCell->GetCode()->DelRPN();
600cdf0e10cSrcweir pCell->SetErrCode( nError );
601cdf0e10cSrcweir if(pCell->GetCode()->IsHyperLink())
602cdf0e10cSrcweir pCell->GetCode()->SetHyperLink(sal_False);
603cdf0e10cSrcweir }
604cdf0e10cSrcweir pDoc->PutCell( aPos, pCell );
605cdf0e10cSrcweir if ( !bAutoCalc )
606cdf0e10cSrcweir { // einmal nur die Zelle berechnen und wieder dirty setzen
607cdf0e10cSrcweir pCell->Interpret();
608cdf0e10cSrcweir pCell->SetDirtyVar();
609cdf0e10cSrcweir pDoc->PutInFormulaTree( pCell );
610cdf0e10cSrcweir }
611cdf0e10cSrcweir }
612cdf0e10cSrcweir
613cdf0e10cSrcweir }
614cdf0e10cSrcweir }
615cdf0e10cSrcweir }
616cdf0e10cSrcweir else
617cdf0e10cSrcweir {
618cdf0e10cSrcweir for (i=0; i<nTabCount; i++)
619cdf0e10cSrcweir if (rMark.GetTableSelect(i))
620cdf0e10cSrcweir if (pDoc->SetString( nCol, nRow, i, rString ))
621cdf0e10cSrcweir bNumFmtChanged = sal_True;
622cdf0e10cSrcweir }
623cdf0e10cSrcweir
624cdf0e10cSrcweir // row height must be changed if new text has a different script type
625cdf0e10cSrcweir for (i=0; i<nTabCount && !bEditDeleted; i++)
626cdf0e10cSrcweir if (rMark.GetTableSelect(i))
627cdf0e10cSrcweir if ( pDoc->GetScriptType( nCol, nRow, i ) != nOldScript )
628cdf0e10cSrcweir bEditDeleted = sal_True;
629cdf0e10cSrcweir
630cdf0e10cSrcweir HideAllCursors();
631cdf0e10cSrcweir
632cdf0e10cSrcweir if (bEditDeleted || pDoc->HasAttrib( nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_NEEDHEIGHT ))
633cdf0e10cSrcweir AdjustRowHeight(nRow,nRow);
634cdf0e10cSrcweir
635cdf0e10cSrcweir sal_Bool bAutoFormat = TestFormatArea(nCol, nRow, nTab, bNumFmtChanged);
636cdf0e10cSrcweir if (bAutoFormat)
637cdf0e10cSrcweir DoAutoAttributes(nCol, nRow, nTab, bNumFmtChanged, bRecord);
638cdf0e10cSrcweir
639cdf0e10cSrcweir if ( bRecord )
640cdf0e10cSrcweir { // wg. ChangeTrack erst jetzt
641cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
642cdf0e10cSrcweir new ScUndoEnterData( pDocSh, nCol, nRow, nTab, nUndoPos, pTabs,
643cdf0e10cSrcweir ppOldCells, pHasFormat, pOldFormats,
644cdf0e10cSrcweir rString, pUndoData ) );
645cdf0e10cSrcweir }
646cdf0e10cSrcweir
647cdf0e10cSrcweir for (i=0; i<nTabCount; i++)
648cdf0e10cSrcweir if (rMark.GetTableSelect(i))
649cdf0e10cSrcweir pDocSh->PostPaintCell( nCol, nRow, i );
650cdf0e10cSrcweir
651cdf0e10cSrcweir ShowAllCursors();
652cdf0e10cSrcweir
653cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
654cdf0e10cSrcweir
655cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
656cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
657cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
658cdf0e10cSrcweir {
659cdf0e10cSrcweir ScRangeList aChangeRanges;
660cdf0e10cSrcweir for ( i = 0; i < nTabCount; ++i )
661cdf0e10cSrcweir {
662cdf0e10cSrcweir if ( rMark.GetTableSelect( i ) )
663cdf0e10cSrcweir {
664cdf0e10cSrcweir aChangeRanges.Append( ScRange( nCol, nRow, i ) );
665cdf0e10cSrcweir }
666cdf0e10cSrcweir }
667cdf0e10cSrcweir pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
668cdf0e10cSrcweir }
669cdf0e10cSrcweir
670cdf0e10cSrcweir aModificator.SetDocumentModified();
671cdf0e10cSrcweir }
672cdf0e10cSrcweir else
673cdf0e10cSrcweir {
674cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
675cdf0e10cSrcweir PaintArea( nCol, nRow, nCol, nRow ); // da steht evtl. noch die Edit-Engine
676cdf0e10cSrcweir }
677cdf0e10cSrcweir }
678cdf0e10cSrcweir
679cdf0e10cSrcweir // Wert in einzele Zelle eintragen (nur auf nTab)
680cdf0e10cSrcweir
EnterValue(SCCOL nCol,SCROW nRow,SCTAB nTab,const double & rValue)681cdf0e10cSrcweir void ScViewFunc::EnterValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rValue )
682cdf0e10cSrcweir {
683cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
684cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
685cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
686cdf0e10cSrcweir
687cdf0e10cSrcweir if ( pDoc && pDocSh )
688cdf0e10cSrcweir {
689cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
690cdf0e10cSrcweir
691cdf0e10cSrcweir ScEditableTester aTester( pDoc, nTab, nCol,nRow, nCol,nRow );
692cdf0e10cSrcweir if (aTester.IsEditable())
693cdf0e10cSrcweir {
694cdf0e10cSrcweir ScAddress aPos( nCol, nRow, nTab );
695cdf0e10cSrcweir ScBaseCell* pOldCell = pDoc->GetCell( aPos );
696cdf0e10cSrcweir sal_Bool bNeedHeight = ( pOldCell && pOldCell->GetCellType() == CELLTYPE_EDIT )
697cdf0e10cSrcweir || pDoc->HasAttrib(
698cdf0e10cSrcweir nCol,nRow,nTab, nCol,nRow,nTab, HASATTR_NEEDHEIGHT );
699cdf0e10cSrcweir
700cdf0e10cSrcweir // Undo
701cdf0e10cSrcweir ScBaseCell* pUndoCell = (bUndo && pOldCell) ? pOldCell->CloneWithoutNote( *pDoc ) : 0;
702cdf0e10cSrcweir
703cdf0e10cSrcweir pDoc->SetValue( nCol, nRow, nTab, rValue );
704cdf0e10cSrcweir
705cdf0e10cSrcweir // wg. ChangeTrack nach Aenderung im Dokument
706cdf0e10cSrcweir if (bUndo)
707cdf0e10cSrcweir {
708cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
709cdf0e10cSrcweir new ScUndoEnterValue( pDocSh, aPos, pUndoCell, rValue, bNeedHeight ) );
710cdf0e10cSrcweir }
711cdf0e10cSrcweir
712cdf0e10cSrcweir /*! Zeilenhoehe anpassen? Dann auch bei Undo...
713cdf0e10cSrcweir if (bNeedHeight)
714cdf0e10cSrcweir AdjustRowHeight(nRow,nRow);
715cdf0e10cSrcweir */
716cdf0e10cSrcweir
717cdf0e10cSrcweir pDocSh->PostPaintCell( aPos );
718cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
719cdf0e10cSrcweir aModificator.SetDocumentModified();
720cdf0e10cSrcweir }
721cdf0e10cSrcweir else
722cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
723cdf0e10cSrcweir }
724cdf0e10cSrcweir }
725cdf0e10cSrcweir
EnterData(SCCOL nCol,SCROW nRow,SCTAB nTab,const EditTextObject * pData,sal_Bool bRecord,sal_Bool bTestSimple)726cdf0e10cSrcweir void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab, const EditTextObject* pData,
727cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bTestSimple )
728cdf0e10cSrcweir {
729cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
730cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
731cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
732cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
733cdf0e10cSrcweir bRecord = sal_False;
734cdf0e10cSrcweir
735cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
736cdf0e10cSrcweir
737cdf0e10cSrcweir ScEditableTester aTester( pDoc, nTab, nCol,nRow, nCol,nRow );
738cdf0e10cSrcweir if (aTester.IsEditable())
739cdf0e10cSrcweir {
740cdf0e10cSrcweir //
741cdf0e10cSrcweir // Test auf Attribute
742cdf0e10cSrcweir //
743cdf0e10cSrcweir sal_Bool bSimple = sal_False;
744cdf0e10cSrcweir sal_Bool bCommon = sal_False;
745cdf0e10cSrcweir ScPatternAttr* pCellAttrs = NULL;
746cdf0e10cSrcweir EditTextObject* pNewData = NULL;
747cdf0e10cSrcweir String aString;
748cdf0e10cSrcweir
749cdf0e10cSrcweir const ScPatternAttr* pOldPattern = pDoc->GetPattern( nCol, nRow, nTab );
750cdf0e10cSrcweir ScTabEditEngine aEngine( *pOldPattern, pDoc->GetEnginePool() );
751cdf0e10cSrcweir aEngine.SetText(*pData);
752cdf0e10cSrcweir
753cdf0e10cSrcweir if (bTestSimple) // Testen, ob einfacher String ohne Attribute
754cdf0e10cSrcweir {
755cdf0e10cSrcweir ScEditAttrTester aAttrTester( &aEngine );
756cdf0e10cSrcweir bSimple = !aAttrTester.NeedsObject();
757cdf0e10cSrcweir bCommon = aAttrTester.NeedsCellAttr();
758cdf0e10cSrcweir
759cdf0e10cSrcweir // formulas have to be recognized even if they're formatted
760cdf0e10cSrcweir // (but commmon attributes are still collected)
761cdf0e10cSrcweir
762cdf0e10cSrcweir if ( !bSimple && aEngine.GetParagraphCount() == 1 )
763cdf0e10cSrcweir {
764cdf0e10cSrcweir String aParStr = aEngine.GetText( (sal_uInt16) 0 );
765cdf0e10cSrcweir if ( aParStr.GetChar(0) == '=' )
766cdf0e10cSrcweir bSimple = sal_True;
767cdf0e10cSrcweir }
768cdf0e10cSrcweir
769cdf0e10cSrcweir if (bCommon) // Attribute fuer Tabelle
770cdf0e10cSrcweir {
771cdf0e10cSrcweir pCellAttrs = new ScPatternAttr( *pOldPattern );
772cdf0e10cSrcweir pCellAttrs->GetFromEditItemSet( &aAttrTester.GetAttribs() );
773cdf0e10cSrcweir //! remove common attributes from EditEngine?
774cdf0e10cSrcweir }
775cdf0e10cSrcweir }
776cdf0e10cSrcweir
777cdf0e10cSrcweir // #i97726# always get text for "repeat" of undo action
778cdf0e10cSrcweir aString = ScEditUtil::GetSpaceDelimitedString(aEngine);
779cdf0e10cSrcweir
780cdf0e10cSrcweir //
781cdf0e10cSrcweir // Undo
782cdf0e10cSrcweir //
783cdf0e10cSrcweir
784cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
785cdf0e10cSrcweir SCTAB nSelCount = rMark.GetSelectCount();
786cdf0e10cSrcweir SCTAB i;
787cdf0e10cSrcweir ScBaseCell** ppOldCells = NULL;
788cdf0e10cSrcweir SCTAB* pTabs = NULL;
789cdf0e10cSrcweir SCTAB nPos = 0;
790cdf0e10cSrcweir EditTextObject* pUndoData = NULL;
791cdf0e10cSrcweir if (bRecord && !bSimple)
792cdf0e10cSrcweir {
793cdf0e10cSrcweir ppOldCells = new ScBaseCell*[nSelCount];
794cdf0e10cSrcweir pTabs = new SCTAB[nSelCount];
795cdf0e10cSrcweir nPos = 0;
796cdf0e10cSrcweir
797cdf0e10cSrcweir for (i=0; i<nTabCount; i++)
798cdf0e10cSrcweir if (rMark.GetTableSelect(i))
799cdf0e10cSrcweir {
800cdf0e10cSrcweir pTabs[nPos] = i;
801cdf0e10cSrcweir ScBaseCell* pDocCell;
802cdf0e10cSrcweir pDoc->GetCell( nCol, nRow, i, pDocCell );
803cdf0e10cSrcweir ppOldCells[nPos] = pDocCell ? pDocCell->CloneWithoutNote( *pDoc ) : 0;
804cdf0e10cSrcweir ++nPos;
805cdf0e10cSrcweir }
806cdf0e10cSrcweir
807cdf0e10cSrcweir DBG_ASSERT( nPos==nSelCount, "nPos!=nSelCount" );
808cdf0e10cSrcweir
809cdf0e10cSrcweir pUndoData = pData->Clone();
810cdf0e10cSrcweir }
811cdf0e10cSrcweir
812cdf0e10cSrcweir //
813cdf0e10cSrcweir // Daten eintragen
814cdf0e10cSrcweir //
815cdf0e10cSrcweir
816cdf0e10cSrcweir if (bCommon)
817cdf0e10cSrcweir pDoc->ApplyPattern(nCol,nRow,nTab,*pCellAttrs); //! Undo
818cdf0e10cSrcweir
819cdf0e10cSrcweir if (bSimple)
820cdf0e10cSrcweir {
821cdf0e10cSrcweir if (bCommon)
822cdf0e10cSrcweir AdjustRowHeight(nRow,nRow);
823cdf0e10cSrcweir
824cdf0e10cSrcweir EnterData(nCol,nRow,nTab,aString,bRecord);
825cdf0e10cSrcweir }
826cdf0e10cSrcweir else
827cdf0e10cSrcweir {
828cdf0e10cSrcweir for (i=0; i<nTabCount; i++)
829cdf0e10cSrcweir if (rMark.GetTableSelect(i))
830cdf0e10cSrcweir pDoc->PutCell( nCol, nRow, i, new ScEditCell( pData, pDoc, NULL ) );
831cdf0e10cSrcweir
832cdf0e10cSrcweir if ( bRecord )
833cdf0e10cSrcweir { // wg. ChangeTrack erst jetzt
834cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
835cdf0e10cSrcweir new ScUndoEnterData( pDocSh, nCol, nRow, nTab, nPos, pTabs,
836cdf0e10cSrcweir ppOldCells, NULL, NULL, aString,
837cdf0e10cSrcweir pUndoData ) );
838cdf0e10cSrcweir }
839cdf0e10cSrcweir
840cdf0e10cSrcweir HideAllCursors();
841cdf0e10cSrcweir
842cdf0e10cSrcweir AdjustRowHeight(nRow,nRow);
843cdf0e10cSrcweir
844cdf0e10cSrcweir for (i=0; i<nTabCount; i++)
845cdf0e10cSrcweir if (rMark.GetTableSelect(i))
846cdf0e10cSrcweir pDocSh->PostPaintCell( nCol, nRow, i );
847cdf0e10cSrcweir
848cdf0e10cSrcweir ShowAllCursors();
849cdf0e10cSrcweir
850cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
851cdf0e10cSrcweir
852cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
853cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
854cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
855cdf0e10cSrcweir {
856cdf0e10cSrcweir ScRangeList aChangeRanges;
857cdf0e10cSrcweir for ( i = 0; i < nTabCount; ++i )
858cdf0e10cSrcweir {
859cdf0e10cSrcweir if ( rMark.GetTableSelect( i ) )
860cdf0e10cSrcweir {
861cdf0e10cSrcweir aChangeRanges.Append( ScRange( nCol, nRow, i ) );
862cdf0e10cSrcweir }
863cdf0e10cSrcweir }
864cdf0e10cSrcweir pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
865cdf0e10cSrcweir }
866cdf0e10cSrcweir
867cdf0e10cSrcweir aModificator.SetDocumentModified();
868cdf0e10cSrcweir }
869cdf0e10cSrcweir
870cdf0e10cSrcweir delete pCellAttrs;
871cdf0e10cSrcweir delete pNewData;
872cdf0e10cSrcweir }
873cdf0e10cSrcweir else
874cdf0e10cSrcweir {
875cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
876cdf0e10cSrcweir PaintArea( nCol, nRow, nCol, nRow ); // da steht evtl. noch die Edit-Engine
877cdf0e10cSrcweir }
878cdf0e10cSrcweir }
879cdf0e10cSrcweir
EnterDataAtCursor(const String & rString)880cdf0e10cSrcweir void ScViewFunc::EnterDataAtCursor( const String& rString )
881cdf0e10cSrcweir {
882cdf0e10cSrcweir SCCOL nPosX = GetViewData()->GetCurX();
883cdf0e10cSrcweir SCROW nPosY = GetViewData()->GetCurY();
884cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
885cdf0e10cSrcweir
886cdf0e10cSrcweir EnterData( nPosX, nPosY, nTab, rString );
887cdf0e10cSrcweir }
888cdf0e10cSrcweir
EnterMatrix(const String & rString)889cdf0e10cSrcweir void ScViewFunc::EnterMatrix( const String& rString )
890cdf0e10cSrcweir {
891cdf0e10cSrcweir ScViewData* pData = GetViewData();
892cdf0e10cSrcweir const ScMarkData& rMark = pData->GetMarkData();
893cdf0e10cSrcweir if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
894cdf0e10cSrcweir {
895cdf0e10cSrcweir // nichts markiert -> automatisch Block mit Groesse des Ergebnisses
896cdf0e10cSrcweir // Formel temporaer berechnen, um an die Groesse heranzukommen
897cdf0e10cSrcweir
898cdf0e10cSrcweir ScDocument* pDoc = pData->GetDocument();
899cdf0e10cSrcweir SCCOL nCol = pData->GetCurX();
900cdf0e10cSrcweir SCROW nRow = pData->GetCurY();
901cdf0e10cSrcweir SCTAB nTab = pData->GetTabNo();
902cdf0e10cSrcweir ScFormulaCell aFormCell( pDoc, ScAddress(nCol,nRow,nTab), rString,formula::FormulaGrammar::GRAM_DEFAULT, MM_FORMULA );
903cdf0e10cSrcweir
904cdf0e10cSrcweir SCSIZE nSizeX;
905cdf0e10cSrcweir SCSIZE nSizeY;
906cdf0e10cSrcweir aFormCell.GetResultDimensions( nSizeX, nSizeY );
907cdf0e10cSrcweir if ( nSizeX != 0 && nSizeY != 0 &&
908cdf0e10cSrcweir nCol+nSizeX-1 <= sal::static_int_cast<SCSIZE>(MAXCOL) &&
909cdf0e10cSrcweir nRow+nSizeY-1 <= sal::static_int_cast<SCSIZE>(MAXROW) )
910cdf0e10cSrcweir {
911cdf0e10cSrcweir ScRange aResult( nCol, nRow, nTab,
912cdf0e10cSrcweir sal::static_int_cast<SCCOL>(nCol+nSizeX-1),
913cdf0e10cSrcweir sal::static_int_cast<SCROW>(nRow+nSizeY-1), nTab );
914cdf0e10cSrcweir MarkRange( aResult, sal_False );
915cdf0e10cSrcweir }
916cdf0e10cSrcweir }
917cdf0e10cSrcweir
918cdf0e10cSrcweir ScRange aRange;
919cdf0e10cSrcweir if (pData->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
920cdf0e10cSrcweir {
921cdf0e10cSrcweir ScDocShell* pDocSh = pData->GetDocShell();
922cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().EnterMatrix( aRange, &rMark, NULL, rString, sal_False, sal_False, EMPTY_STRING, formula::FormulaGrammar::GRAM_DEFAULT );
923cdf0e10cSrcweir if (bSuccess)
924cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
925cdf0e10cSrcweir }
926cdf0e10cSrcweir else
927cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
928cdf0e10cSrcweir }
929cdf0e10cSrcweir
GetSelectionScriptType()930cdf0e10cSrcweir sal_uInt8 ScViewFunc::GetSelectionScriptType()
931cdf0e10cSrcweir {
932cdf0e10cSrcweir sal_uInt8 nScript = 0;
933cdf0e10cSrcweir
934cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
935cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
936cdf0e10cSrcweir if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
937cdf0e10cSrcweir {
938cdf0e10cSrcweir // no selection -> cursor
939cdf0e10cSrcweir
940cdf0e10cSrcweir nScript = pDoc->GetScriptType( GetViewData()->GetCurX(),
941cdf0e10cSrcweir GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
942cdf0e10cSrcweir }
943cdf0e10cSrcweir else
944cdf0e10cSrcweir {
945cdf0e10cSrcweir ScRangeList aRanges;
946cdf0e10cSrcweir rMark.FillRangeListWithMarks( &aRanges, sal_False );
947cdf0e10cSrcweir sal_uLong nCount = aRanges.Count();
948cdf0e10cSrcweir for (sal_uLong i=0; i<nCount; i++)
949cdf0e10cSrcweir {
950cdf0e10cSrcweir ScRange aRange = *aRanges.GetObject(i);
951cdf0e10cSrcweir ScCellIterator aIter( pDoc, aRange );
952cdf0e10cSrcweir ScBaseCell* pCell = aIter.GetFirst();
953cdf0e10cSrcweir while ( pCell )
954cdf0e10cSrcweir {
955cdf0e10cSrcweir nScript |= pDoc->GetScriptType( aIter.GetCol(), aIter.GetRow(), aIter.GetTab(), pCell );
956cdf0e10cSrcweir pCell = aIter.GetNext();
957cdf0e10cSrcweir }
958cdf0e10cSrcweir }
959cdf0e10cSrcweir }
960cdf0e10cSrcweir
961cdf0e10cSrcweir if (nScript == 0)
962cdf0e10cSrcweir nScript = ScGlobal::GetDefaultScriptType();
963cdf0e10cSrcweir
964cdf0e10cSrcweir return nScript;
965cdf0e10cSrcweir }
966cdf0e10cSrcweir
GetSelectionPattern()967cdf0e10cSrcweir const ScPatternAttr* ScViewFunc::GetSelectionPattern()
968cdf0e10cSrcweir {
969cdf0e10cSrcweir // Don't use UnmarkFiltered in slot state functions, for performance reasons.
970cdf0e10cSrcweir // The displayed state is always that of the whole selection including filtered rows.
971cdf0e10cSrcweir
972cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
973cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
974cdf0e10cSrcweir if ( rMark.IsMarked() || rMark.IsMultiMarked() )
975cdf0e10cSrcweir {
976cdf0e10cSrcweir // MarkToMulti is no longer necessary for pDoc->GetSelectionPattern
977cdf0e10cSrcweir const ScPatternAttr* pAttr = pDoc->GetSelectionPattern( rMark );
978cdf0e10cSrcweir return pAttr;
979cdf0e10cSrcweir }
980cdf0e10cSrcweir else
981cdf0e10cSrcweir {
982cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
983cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
984cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
985cdf0e10cSrcweir
986cdf0e10cSrcweir ScMarkData aTempMark( rMark ); // copy sheet selection
987cdf0e10cSrcweir aTempMark.SetMarkArea( ScRange( nCol, nRow, nTab ) );
988cdf0e10cSrcweir const ScPatternAttr* pAttr = pDoc->GetSelectionPattern( aTempMark );
989cdf0e10cSrcweir return pAttr;
990cdf0e10cSrcweir }
991cdf0e10cSrcweir }
992cdf0e10cSrcweir
GetSelectionFrame(SvxBoxItem & rLineOuter,SvxBoxInfoItem & rLineInner)993cdf0e10cSrcweir void ScViewFunc::GetSelectionFrame( SvxBoxItem& rLineOuter,
994cdf0e10cSrcweir SvxBoxInfoItem& rLineInner )
995cdf0e10cSrcweir {
996cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
997cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
998cdf0e10cSrcweir
999cdf0e10cSrcweir if ( rMark.IsMarked() || rMark.IsMultiMarked() )
1000cdf0e10cSrcweir {
1001cdf0e10cSrcweir if ( rMark.IsMultiMarked() )
1002cdf0e10cSrcweir {
1003cdf0e10cSrcweir ScMarkData aNewMark( rMark ); // use local copy for MarkToSimple
1004cdf0e10cSrcweir aNewMark.MarkToSimple(); // simple block is needed for GetSelectionFrame
1005cdf0e10cSrcweir pDoc->GetSelectionFrame( aNewMark, rLineOuter, rLineInner );
1006cdf0e10cSrcweir }
1007cdf0e10cSrcweir else
1008cdf0e10cSrcweir pDoc->GetSelectionFrame( rMark, rLineOuter, rLineInner );
1009cdf0e10cSrcweir }
1010cdf0e10cSrcweir else
1011cdf0e10cSrcweir {
1012cdf0e10cSrcweir const ScPatternAttr* pAttrs =
1013cdf0e10cSrcweir pDoc->GetPattern( GetViewData()->GetCurX(),
1014cdf0e10cSrcweir GetViewData()->GetCurY(),
1015cdf0e10cSrcweir GetViewData()->GetTabNo() );
1016cdf0e10cSrcweir
1017cdf0e10cSrcweir rLineOuter = (const SvxBoxItem&) (pAttrs->GetItem( ATTR_BORDER ));
1018cdf0e10cSrcweir rLineInner = (const SvxBoxInfoItem&)(pAttrs->GetItem( ATTR_BORDER_INNER ));
1019cdf0e10cSrcweir rLineInner.SetTable(sal_False);
1020cdf0e10cSrcweir rLineInner.SetDist(sal_True);
1021cdf0e10cSrcweir rLineInner.SetMinDist(sal_False);
1022cdf0e10cSrcweir }
1023cdf0e10cSrcweir }
1024cdf0e10cSrcweir
1025cdf0e10cSrcweir //
1026cdf0e10cSrcweir // Attribute anwenden - Undo OK
1027cdf0e10cSrcweir //
1028cdf0e10cSrcweir // kompletter Set ( ATTR_STARTINDEX, ATTR_ENDINDEX )
1029cdf0e10cSrcweir //
1030cdf0e10cSrcweir
ApplyAttributes(const SfxItemSet * pDialogSet,const SfxItemSet * pOldSet,sal_Bool bRecord)1031cdf0e10cSrcweir void ScViewFunc::ApplyAttributes( const SfxItemSet* pDialogSet,
1032cdf0e10cSrcweir const SfxItemSet* pOldSet,
1033cdf0e10cSrcweir sal_Bool bRecord )
1034cdf0e10cSrcweir {
1035cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
1036cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1037cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
1038cdf0e10cSrcweir {
1039cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
1040cdf0e10cSrcweir return;
1041cdf0e10cSrcweir }
1042cdf0e10cSrcweir
1043cdf0e10cSrcweir ScPatternAttr aOldAttrs( new SfxItemSet(*pOldSet) );
1044cdf0e10cSrcweir ScPatternAttr aNewAttrs( new SfxItemSet(*pDialogSet) );
1045cdf0e10cSrcweir aNewAttrs.DeleteUnchanged( &aOldAttrs );
1046cdf0e10cSrcweir
1047cdf0e10cSrcweir if ( pDialogSet->GetItemState( ATTR_VALUE_FORMAT ) == SFX_ITEM_SET )
1048cdf0e10cSrcweir { // #82521# don't reset to default SYSTEM GENERAL if not intended
1049cdf0e10cSrcweir sal_uInt32 nOldFormat =
1050cdf0e10cSrcweir ((const SfxUInt32Item&)pOldSet->Get( ATTR_VALUE_FORMAT )).GetValue();
1051cdf0e10cSrcweir sal_uInt32 nNewFormat =
1052cdf0e10cSrcweir ((const SfxUInt32Item&)pDialogSet->Get( ATTR_VALUE_FORMAT )).GetValue();
1053cdf0e10cSrcweir if ( nNewFormat != nOldFormat )
1054cdf0e10cSrcweir {
1055cdf0e10cSrcweir SvNumberFormatter* pFormatter =
1056cdf0e10cSrcweir GetViewData()->GetDocument()->GetFormatTable();
1057cdf0e10cSrcweir const SvNumberformat* pOldEntry = pFormatter->GetEntry( nOldFormat );
1058cdf0e10cSrcweir LanguageType eOldLang =
1059cdf0e10cSrcweir pOldEntry ? pOldEntry->GetLanguage() : LANGUAGE_DONTKNOW;
1060cdf0e10cSrcweir const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewFormat );
1061cdf0e10cSrcweir LanguageType eNewLang =
1062cdf0e10cSrcweir pNewEntry ? pNewEntry->GetLanguage() : LANGUAGE_DONTKNOW;
1063cdf0e10cSrcweir if ( eNewLang != eOldLang )
1064cdf0e10cSrcweir {
1065cdf0e10cSrcweir aNewAttrs.GetItemSet().Put(
1066cdf0e10cSrcweir SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
1067cdf0e10cSrcweir
1068cdf0e10cSrcweir // #40606# nur die Sprache geaendert -> Zahlformat-Attribut nicht anfassen
1069cdf0e10cSrcweir sal_uInt32 nNewMod = nNewFormat % SV_COUNTRY_LANGUAGE_OFFSET;
1070cdf0e10cSrcweir if ( nNewMod == ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) &&
1071cdf0e10cSrcweir nNewMod <= SV_MAX_ANZ_STANDARD_FORMATE )
1072cdf0e10cSrcweir aNewAttrs.GetItemSet().ClearItem( ATTR_VALUE_FORMAT );
1073cdf0e10cSrcweir }
1074cdf0e10cSrcweir }
1075cdf0e10cSrcweir }
1076cdf0e10cSrcweir
1077cdf0e10cSrcweir const SvxBoxItem* pOldOuter = (const SvxBoxItem*) &pOldSet->Get( ATTR_BORDER );
1078cdf0e10cSrcweir const SvxBoxItem* pNewOuter = (const SvxBoxItem*) &pDialogSet->Get( ATTR_BORDER );
1079cdf0e10cSrcweir const SvxBoxInfoItem* pOldInner = (const SvxBoxInfoItem*) &pOldSet->Get( ATTR_BORDER_INNER );
1080cdf0e10cSrcweir const SvxBoxInfoItem* pNewInner = (const SvxBoxInfoItem*) &pDialogSet->Get( ATTR_BORDER_INNER );
1081cdf0e10cSrcweir SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
1082cdf0e10cSrcweir SfxItemPool* pNewPool = rNewSet.GetPool();
1083cdf0e10cSrcweir
1084cdf0e10cSrcweir pNewPool->Put( *pNewOuter ); // noch nicht loeschen
1085cdf0e10cSrcweir pNewPool->Put( *pNewInner );
1086cdf0e10cSrcweir rNewSet.ClearItem( ATTR_BORDER );
1087cdf0e10cSrcweir rNewSet.ClearItem( ATTR_BORDER_INNER );
1088cdf0e10cSrcweir
1089cdf0e10cSrcweir /*
1090cdf0e10cSrcweir * Feststellen, ob Rahmenattribute zu setzen sind:
1091cdf0e10cSrcweir * 1. Neu != Alt
1092cdf0e10cSrcweir * 2. Ist eine der Linien nicht-DontCare (seit 238.f: IsxxValid())
1093cdf0e10cSrcweir *
1094cdf0e10cSrcweir */
1095cdf0e10cSrcweir
1096cdf0e10cSrcweir sal_Bool bFrame = (pDialogSet->GetItemState( ATTR_BORDER ) != SFX_ITEM_DEFAULT)
1097cdf0e10cSrcweir || (pDialogSet->GetItemState( ATTR_BORDER_INNER ) != SFX_ITEM_DEFAULT);
1098cdf0e10cSrcweir
1099cdf0e10cSrcweir if ( pNewOuter==pOldOuter && pNewInner==pOldInner )
1100cdf0e10cSrcweir bFrame = sal_False;
1101cdf0e10cSrcweir
1102cdf0e10cSrcweir // das sollte doch der Pool abfangen: ?!??!??
1103cdf0e10cSrcweir
1104cdf0e10cSrcweir if ( bFrame && pNewOuter && pNewInner )
1105cdf0e10cSrcweir if ( *pNewOuter == *pOldOuter && *pNewInner == *pOldInner )
1106cdf0e10cSrcweir bFrame = sal_False;
1107cdf0e10cSrcweir
1108cdf0e10cSrcweir if ( pNewInner )
1109cdf0e10cSrcweir {
1110cdf0e10cSrcweir bFrame = bFrame
1111cdf0e10cSrcweir && ( pNewInner->IsValid(VALID_LEFT)
1112cdf0e10cSrcweir || pNewInner->IsValid(VALID_RIGHT)
1113cdf0e10cSrcweir || pNewInner->IsValid(VALID_TOP)
1114cdf0e10cSrcweir || pNewInner->IsValid(VALID_BOTTOM)
1115cdf0e10cSrcweir || pNewInner->IsValid(VALID_HORI)
1116cdf0e10cSrcweir || pNewInner->IsValid(VALID_VERT) );
1117cdf0e10cSrcweir }
1118cdf0e10cSrcweir else
1119cdf0e10cSrcweir bFrame = sal_False;
1120cdf0e10cSrcweir
1121cdf0e10cSrcweir if (!bFrame)
1122cdf0e10cSrcweir ApplySelectionPattern( aNewAttrs, bRecord ); // nur normale
1123cdf0e10cSrcweir else
1124cdf0e10cSrcweir {
1125cdf0e10cSrcweir // wenn neue Items Default-Items sind, so muessen die
1126cdf0e10cSrcweir // alten Items geputtet werden:
1127cdf0e10cSrcweir
1128cdf0e10cSrcweir sal_Bool bDefNewOuter = ( SFX_ITEMS_STATICDEFAULT == pNewOuter->GetKind() );
1129cdf0e10cSrcweir sal_Bool bDefNewInner = ( SFX_ITEMS_STATICDEFAULT == pNewInner->GetKind() );
1130cdf0e10cSrcweir
1131cdf0e10cSrcweir ApplyPatternLines( aNewAttrs,
1132cdf0e10cSrcweir bDefNewOuter ? pOldOuter : pNewOuter,
1133cdf0e10cSrcweir bDefNewInner ? pOldInner : pNewInner,
1134cdf0e10cSrcweir bRecord );
1135cdf0e10cSrcweir }
1136cdf0e10cSrcweir
1137cdf0e10cSrcweir pNewPool->Remove( *pNewOuter ); // freigeben
1138cdf0e10cSrcweir pNewPool->Remove( *pNewInner );
1139cdf0e10cSrcweir
1140cdf0e10cSrcweir // Hoehen anpassen
1141cdf0e10cSrcweir AdjustBlockHeight();
1142cdf0e10cSrcweir
1143cdf0e10cSrcweir // CellContentChanged wird von ApplySelectionPattern / ApplyPatternLines gerufen
1144cdf0e10cSrcweir }
1145cdf0e10cSrcweir
ApplyAttr(const SfxPoolItem & rAttrItem)1146cdf0e10cSrcweir void ScViewFunc::ApplyAttr( const SfxPoolItem& rAttrItem )
1147cdf0e10cSrcweir {
1148cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
1149cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1150cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
1151cdf0e10cSrcweir {
1152cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
1153cdf0e10cSrcweir return;
1154cdf0e10cSrcweir }
1155cdf0e10cSrcweir
1156cdf0e10cSrcweir ScPatternAttr aNewAttrs( new SfxItemSet( *GetViewData()->GetDocument()->GetPool(),
1157cdf0e10cSrcweir ATTR_PATTERN_START, ATTR_PATTERN_END ) );
1158cdf0e10cSrcweir
1159cdf0e10cSrcweir aNewAttrs.GetItemSet().Put( rAttrItem );
1160cdf0e10cSrcweir // Wenn Ausrichtung eingestellt wird (ueber Buttons), immer Einzug 0
1161cdf0e10cSrcweir if ( rAttrItem.Which() == ATTR_HOR_JUSTIFY )
1162cdf0e10cSrcweir aNewAttrs.GetItemSet().Put( SfxUInt16Item( ATTR_INDENT, 0 ) );
1163cdf0e10cSrcweir ApplySelectionPattern( aNewAttrs );
1164cdf0e10cSrcweir
1165cdf0e10cSrcweir AdjustBlockHeight();
1166cdf0e10cSrcweir
1167cdf0e10cSrcweir // CellContentChanged wird von ApplySelectionPattern gerufen
1168cdf0e10cSrcweir }
1169cdf0e10cSrcweir
1170cdf0e10cSrcweir
1171cdf0e10cSrcweir // Pattern und Rahmen
1172cdf0e10cSrcweir
ApplyPatternLines(const ScPatternAttr & rAttr,const SvxBoxItem * pNewOuter,const SvxBoxInfoItem * pNewInner,sal_Bool bRecord)1173cdf0e10cSrcweir void ScViewFunc::ApplyPatternLines( const ScPatternAttr& rAttr, const SvxBoxItem* pNewOuter,
1174cdf0e10cSrcweir const SvxBoxInfoItem* pNewInner, sal_Bool bRecord )
1175cdf0e10cSrcweir {
1176cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
1177cdf0e10cSrcweir ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered
1178cdf0e10cSrcweir ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
1179cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1180cdf0e10cSrcweir bRecord = sal_False;
1181cdf0e10cSrcweir
1182cdf0e10cSrcweir ScRange aMarkRange;
1183cdf0e10cSrcweir aFuncMark.MarkToSimple();
1184cdf0e10cSrcweir sal_Bool bMulti = aFuncMark.IsMultiMarked();
1185cdf0e10cSrcweir if (bMulti)
1186cdf0e10cSrcweir aFuncMark.GetMultiMarkArea( aMarkRange );
1187cdf0e10cSrcweir else if (aFuncMark.IsMarked())
1188cdf0e10cSrcweir aFuncMark.GetMarkArea( aMarkRange );
1189cdf0e10cSrcweir else
1190cdf0e10cSrcweir {
1191cdf0e10cSrcweir aMarkRange = ScRange( GetViewData()->GetCurX(),
1192cdf0e10cSrcweir GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
1193cdf0e10cSrcweir DoneBlockMode();
1194cdf0e10cSrcweir InitOwnBlockMode();
1195cdf0e10cSrcweir aFuncMark.SetMarkArea(aMarkRange);
1196cdf0e10cSrcweir MarkDataChanged();
1197cdf0e10cSrcweir }
1198cdf0e10cSrcweir
1199cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1200cdf0e10cSrcweir
1201cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
1202cdf0e10cSrcweir
1203cdf0e10cSrcweir if (bRecord)
1204cdf0e10cSrcweir {
1205cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1206cdf0e10cSrcweir SCTAB nStartTab = aMarkRange.aStart.Tab();
1207cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1208cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
1209cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1210cdf0e10cSrcweir if (i != nStartTab && aFuncMark.GetTableSelect(i))
1211cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
1212cdf0e10cSrcweir
1213cdf0e10cSrcweir ScRange aCopyRange = aMarkRange;
1214cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
1215cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
1216cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pUndoDoc, &aFuncMark );
1217cdf0e10cSrcweir
1218cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1219cdf0e10cSrcweir new ScUndoSelectionAttr(
1220cdf0e10cSrcweir pDocSh, aFuncMark,
1221cdf0e10cSrcweir aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), aMarkRange.aStart.Tab(),
1222cdf0e10cSrcweir aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(), aMarkRange.aEnd.Tab(),
1223cdf0e10cSrcweir pUndoDoc, bMulti, &rAttr, pNewOuter, pNewInner ) );
1224cdf0e10cSrcweir }
1225cdf0e10cSrcweir
1226cdf0e10cSrcweir sal_uInt16 nExt = SC_PF_TESTMERGE;
1227cdf0e10cSrcweir pDocSh->UpdatePaintExt( nExt, aMarkRange ); // content before the change
1228cdf0e10cSrcweir
1229cdf0e10cSrcweir pDoc->ApplySelectionFrame( aFuncMark, pNewOuter, pNewInner );
1230cdf0e10cSrcweir
1231cdf0e10cSrcweir pDocSh->UpdatePaintExt( nExt, aMarkRange ); // content after the change
1232cdf0e10cSrcweir
1233cdf0e10cSrcweir aFuncMark.MarkToMulti();
1234cdf0e10cSrcweir pDoc->ApplySelectionPattern( rAttr, aFuncMark );
1235cdf0e10cSrcweir
1236cdf0e10cSrcweir pDocSh->PostPaint( aMarkRange, PAINT_GRID, nExt );
1237cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1238cdf0e10cSrcweir aModificator.SetDocumentModified();
1239cdf0e10cSrcweir CellContentChanged();
1240cdf0e10cSrcweir
1241cdf0e10cSrcweir StartFormatArea();
1242cdf0e10cSrcweir }
1243cdf0e10cSrcweir
1244cdf0e10cSrcweir // nur Pattern
1245cdf0e10cSrcweir
ApplySelectionPattern(const ScPatternAttr & rAttr,sal_Bool bRecord,sal_Bool bCursorOnly)1246cdf0e10cSrcweir void ScViewFunc::ApplySelectionPattern( const ScPatternAttr& rAttr,
1247cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bCursorOnly )
1248cdf0e10cSrcweir {
1249cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
1250cdf0e10cSrcweir ScDocShell* pDocSh = pViewData->GetDocShell();
1251cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
1252cdf0e10cSrcweir ScMarkData aFuncMark( pViewData->GetMarkData() ); // local copy for UnmarkFiltered
1253cdf0e10cSrcweir ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
1254cdf0e10cSrcweir
1255cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1256cdf0e10cSrcweir bRecord = sal_False;
1257cdf0e10cSrcweir
1258cdf0e10cSrcweir // State from old ItemSet doesn't matter for paint flags, as any change will be
1259cdf0e10cSrcweir // from SFX_ITEM_SET in the new ItemSet (default is ignored in ApplyPattern).
1260cdf0e10cSrcweir // New alignment is checked (check in PostPaint isn't enough) in case a right
1261cdf0e10cSrcweir // alignment is changed to left.
1262cdf0e10cSrcweir const SfxItemSet& rNewSet = rAttr.GetItemSet();
1263cdf0e10cSrcweir sal_Bool bSetLines = rNewSet.GetItemState( ATTR_BORDER, sal_True ) == SFX_ITEM_SET ||
1264cdf0e10cSrcweir rNewSet.GetItemState( ATTR_SHADOW, sal_True ) == SFX_ITEM_SET;
1265cdf0e10cSrcweir sal_Bool bSetAlign = rNewSet.GetItemState( ATTR_HOR_JUSTIFY, sal_True ) == SFX_ITEM_SET;
1266cdf0e10cSrcweir
1267cdf0e10cSrcweir sal_uInt16 nExtFlags = 0;
1268cdf0e10cSrcweir if ( bSetLines )
1269cdf0e10cSrcweir nExtFlags |= SC_PF_LINES;
1270cdf0e10cSrcweir if ( bSetAlign )
1271cdf0e10cSrcweir nExtFlags |= SC_PF_WHOLEROWS;
1272cdf0e10cSrcweir
1273cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
1274cdf0e10cSrcweir
1275cdf0e10cSrcweir sal_Bool bMulti = aFuncMark.IsMultiMarked();
1276cdf0e10cSrcweir aFuncMark.MarkToMulti();
1277cdf0e10cSrcweir sal_Bool bOnlyTab = (!aFuncMark.IsMultiMarked() && !bCursorOnly && aFuncMark.GetSelectCount() > 1);
1278cdf0e10cSrcweir if (bOnlyTab)
1279cdf0e10cSrcweir {
1280cdf0e10cSrcweir SCCOL nCol = pViewData->GetCurX();
1281cdf0e10cSrcweir SCROW nRow = pViewData->GetCurY();
1282cdf0e10cSrcweir SCTAB nTab = pViewData->GetTabNo();
1283cdf0e10cSrcweir aFuncMark.SetMarkArea(ScRange(nCol,nRow,nTab));
1284cdf0e10cSrcweir aFuncMark.MarkToMulti();
1285cdf0e10cSrcweir }
1286cdf0e10cSrcweir
1287cdf0e10cSrcweir ScRangeList aChangeRanges;
1288cdf0e10cSrcweir
1289cdf0e10cSrcweir if (aFuncMark.IsMultiMarked() && !bCursorOnly)
1290cdf0e10cSrcweir {
1291cdf0e10cSrcweir ScRange aMarkRange;
1292cdf0e10cSrcweir aFuncMark.GetMultiMarkArea( aMarkRange );
1293cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1294cdf0e10cSrcweir for ( SCTAB i = 0; i < nTabCount; ++i )
1295cdf0e10cSrcweir {
1296cdf0e10cSrcweir if ( aFuncMark.GetTableSelect( i ) )
1297cdf0e10cSrcweir {
1298cdf0e10cSrcweir ScRange aChangeRange( aMarkRange );
1299cdf0e10cSrcweir aChangeRange.aStart.SetTab( i );
1300cdf0e10cSrcweir aChangeRange.aEnd.SetTab( i );
1301cdf0e10cSrcweir aChangeRanges.Append( aChangeRange );
1302cdf0e10cSrcweir }
1303cdf0e10cSrcweir }
1304cdf0e10cSrcweir
1305cdf0e10cSrcweir SCCOL nStartCol = aMarkRange.aStart.Col();
1306cdf0e10cSrcweir SCROW nStartRow = aMarkRange.aStart.Row();
1307cdf0e10cSrcweir SCTAB nStartTab = aMarkRange.aStart.Tab();
1308cdf0e10cSrcweir SCCOL nEndCol = aMarkRange.aEnd.Col();
1309cdf0e10cSrcweir SCROW nEndRow = aMarkRange.aEnd.Row();
1310cdf0e10cSrcweir SCTAB nEndTab = aMarkRange.aEnd.Tab();
1311cdf0e10cSrcweir
1312cdf0e10cSrcweir if (bRecord)
1313cdf0e10cSrcweir {
1314cdf0e10cSrcweir ScRange aCopyRange = aMarkRange;
1315cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
1316cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
1317cdf0e10cSrcweir
1318cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1319cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
1320cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1321cdf0e10cSrcweir if (i != nStartTab && aFuncMark.GetTableSelect(i))
1322cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
1323cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pUndoDoc, &aFuncMark );
1324cdf0e10cSrcweir
1325cdf0e10cSrcweir aFuncMark.MarkToMulti();
1326cdf0e10cSrcweir
1327cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1328cdf0e10cSrcweir new ScUndoSelectionAttr(
1329cdf0e10cSrcweir pDocSh, aFuncMark,
1330cdf0e10cSrcweir nStartCol, nStartRow, nStartTab,
1331cdf0e10cSrcweir nEndCol, nEndRow, nEndTab,
1332cdf0e10cSrcweir pUndoDoc, bMulti, &rAttr ) );
1333cdf0e10cSrcweir }
1334cdf0e10cSrcweir
1335cdf0e10cSrcweir pDoc->ApplySelectionPattern( rAttr, aFuncMark );
1336cdf0e10cSrcweir
1337cdf0e10cSrcweir pDocSh->PostPaint( nStartCol, nStartRow, nStartTab,
1338cdf0e10cSrcweir nEndCol, nEndRow, nEndTab,
1339cdf0e10cSrcweir PAINT_GRID, nExtFlags | SC_PF_TESTMERGE );
1340cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1341cdf0e10cSrcweir aModificator.SetDocumentModified();
1342cdf0e10cSrcweir CellContentChanged();
1343cdf0e10cSrcweir }
1344cdf0e10cSrcweir else // einzelne Zelle - Undo einfacher
1345cdf0e10cSrcweir {
1346cdf0e10cSrcweir SCCOL nCol = pViewData->GetCurX();
1347cdf0e10cSrcweir SCROW nRow = pViewData->GetCurY();
1348cdf0e10cSrcweir SCTAB nTab = pViewData->GetTabNo();
1349cdf0e10cSrcweir aChangeRanges.Append( ScRange( nCol, nRow, nTab ) );
1350cdf0e10cSrcweir ScPatternAttr* pOldPat = new ScPatternAttr(*pDoc->GetPattern( nCol, nRow, nTab ));
1351cdf0e10cSrcweir
1352cdf0e10cSrcweir pDoc->ApplyPattern( nCol, nRow, nTab, rAttr );
1353cdf0e10cSrcweir
1354cdf0e10cSrcweir const ScPatternAttr* pNewPat = pDoc->GetPattern( nCol, nRow, nTab );
1355cdf0e10cSrcweir
1356cdf0e10cSrcweir if (bRecord)
1357cdf0e10cSrcweir {
1358cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1359cdf0e10cSrcweir new ScUndoCursorAttr( pDocSh,
1360cdf0e10cSrcweir nCol, nRow, nTab,
1361cdf0e10cSrcweir pOldPat, pNewPat, &rAttr,
1362cdf0e10cSrcweir sal_False ) ); // sal_False = nicht automatisch
1363cdf0e10cSrcweir }
1364cdf0e10cSrcweir delete pOldPat; // wird im Undo kopiert (Pool)
1365cdf0e10cSrcweir
1366cdf0e10cSrcweir pDocSh->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID, nExtFlags | SC_PF_TESTMERGE );
1367cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1368cdf0e10cSrcweir aModificator.SetDocumentModified();
1369cdf0e10cSrcweir CellContentChanged();
1370cdf0e10cSrcweir }
1371cdf0e10cSrcweir
1372cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
1373cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
1374cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
1375cdf0e10cSrcweir {
1376cdf0e10cSrcweir ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > aProperties;
1377cdf0e10cSrcweir sal_Int32 nCount = 0;
1378cdf0e10cSrcweir const SfxItemPropertyMap* pMap = ScCellObj::GetCellPropertyMap();
1379cdf0e10cSrcweir PropertyEntryVector_t aPropVector = pMap->getPropertyEntries();
1380cdf0e10cSrcweir for ( sal_uInt16 nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; ++nWhich )
1381cdf0e10cSrcweir {
1382cdf0e10cSrcweir const SfxPoolItem* pItem = 0;
1383cdf0e10cSrcweir if ( rNewSet.GetItemState( nWhich, sal_True, &pItem ) == SFX_ITEM_SET && pItem )
1384cdf0e10cSrcweir {
1385cdf0e10cSrcweir PropertyEntryVector_t::const_iterator aIt = aPropVector.begin();
1386cdf0e10cSrcweir while ( aIt != aPropVector.end())
1387cdf0e10cSrcweir {
1388cdf0e10cSrcweir if ( aIt->nWID == nWhich )
1389cdf0e10cSrcweir {
1390cdf0e10cSrcweir ::com::sun::star::uno::Any aVal;
1391cdf0e10cSrcweir pItem->QueryValue( aVal, aIt->nMemberId );
1392cdf0e10cSrcweir aProperties.realloc( nCount + 1 );
1393cdf0e10cSrcweir aProperties[ nCount ].Name = aIt->sName;
1394cdf0e10cSrcweir aProperties[ nCount ].Value <<= aVal;
1395cdf0e10cSrcweir ++nCount;
1396cdf0e10cSrcweir }
1397cdf0e10cSrcweir ++aIt;
1398cdf0e10cSrcweir }
1399cdf0e10cSrcweir }
1400cdf0e10cSrcweir }
1401cdf0e10cSrcweir pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "attribute" ) ), aChangeRanges, aProperties );
1402cdf0e10cSrcweir }
1403cdf0e10cSrcweir
1404cdf0e10cSrcweir StartFormatArea();
1405cdf0e10cSrcweir }
1406cdf0e10cSrcweir
ApplyUserItemSet(const SfxItemSet & rItemSet)1407cdf0e10cSrcweir void ScViewFunc::ApplyUserItemSet( const SfxItemSet& rItemSet )
1408cdf0e10cSrcweir {
1409cdf0e10cSrcweir // ItemSet from UI, may have different pool
1410cdf0e10cSrcweir
1411cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1412cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
1413cdf0e10cSrcweir {
1414cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
1415cdf0e10cSrcweir return;
1416cdf0e10cSrcweir }
1417cdf0e10cSrcweir
1418cdf0e10cSrcweir ScPatternAttr aNewAttrs( GetViewData()->GetDocument()->GetPool() );
1419cdf0e10cSrcweir SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
1420cdf0e10cSrcweir rNewSet.Put( rItemSet, sal_False );
1421cdf0e10cSrcweir ApplySelectionPattern( aNewAttrs );
1422cdf0e10cSrcweir
1423cdf0e10cSrcweir AdjustBlockHeight();
1424cdf0e10cSrcweir }
1425cdf0e10cSrcweir
GetStyleSheetFromMarked()1426cdf0e10cSrcweir const SfxStyleSheet* ScViewFunc::GetStyleSheetFromMarked()
1427cdf0e10cSrcweir {
1428cdf0e10cSrcweir // Don't use UnmarkFiltered in slot state functions, for performance reasons.
1429cdf0e10cSrcweir // The displayed state is always that of the whole selection including filtered rows.
1430cdf0e10cSrcweir
1431cdf0e10cSrcweir const ScStyleSheet* pSheet = NULL;
1432cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
1433cdf0e10cSrcweir ScDocument* pDoc = pViewData->GetDocument();
1434cdf0e10cSrcweir ScMarkData& rMark = pViewData->GetMarkData();
1435cdf0e10cSrcweir
1436cdf0e10cSrcweir if ( rMark.IsMarked() || rMark.IsMultiMarked() )
1437cdf0e10cSrcweir pSheet = pDoc->GetSelectionStyle( rMark ); // MarkToMulti isn't necessary
1438cdf0e10cSrcweir else
1439cdf0e10cSrcweir pSheet = pDoc->GetStyle( pViewData->GetCurX(),
1440cdf0e10cSrcweir pViewData->GetCurY(),
1441cdf0e10cSrcweir pViewData->GetTabNo() );
1442cdf0e10cSrcweir
1443cdf0e10cSrcweir return pSheet;
1444cdf0e10cSrcweir }
1445cdf0e10cSrcweir
SetStyleSheetToMarked(SfxStyleSheet * pStyleSheet,sal_Bool bRecord)1446cdf0e10cSrcweir void ScViewFunc::SetStyleSheetToMarked( SfxStyleSheet* pStyleSheet, sal_Bool bRecord )
1447cdf0e10cSrcweir {
1448cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
1449cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1450cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
1451cdf0e10cSrcweir {
1452cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
1453cdf0e10cSrcweir return;
1454cdf0e10cSrcweir }
1455cdf0e10cSrcweir
1456cdf0e10cSrcweir if ( !pStyleSheet) return;
1457cdf0e10cSrcweir // -------------------------------------------------------------------
1458cdf0e10cSrcweir
1459cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
1460cdf0e10cSrcweir ScDocShell* pDocSh = pViewData->GetDocShell();
1461cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
1462cdf0e10cSrcweir ScMarkData aFuncMark( pViewData->GetMarkData() ); // local copy for UnmarkFiltered
1463cdf0e10cSrcweir ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
1464cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1465cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1466cdf0e10cSrcweir bRecord = sal_False;
1467cdf0e10cSrcweir
1468cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
1469cdf0e10cSrcweir
1470cdf0e10cSrcweir if ( aFuncMark.IsMarked() || aFuncMark.IsMultiMarked() )
1471cdf0e10cSrcweir {
1472cdf0e10cSrcweir ScRange aMarkRange;
1473cdf0e10cSrcweir aFuncMark.MarkToMulti();
1474cdf0e10cSrcweir aFuncMark.GetMultiMarkArea( aMarkRange );
1475cdf0e10cSrcweir
1476cdf0e10cSrcweir if ( bRecord )
1477cdf0e10cSrcweir {
1478cdf0e10cSrcweir SCTAB nTab = pViewData->GetTabNo();
1479cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1480cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab );
1481cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1482cdf0e10cSrcweir if (i != nTab && aFuncMark.GetTableSelect(i))
1483cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
1484cdf0e10cSrcweir
1485cdf0e10cSrcweir ScRange aCopyRange = aMarkRange;
1486cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
1487cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
1488cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, sal_True, pUndoDoc, &aFuncMark );
1489cdf0e10cSrcweir aFuncMark.MarkToMulti();
1490cdf0e10cSrcweir
1491cdf0e10cSrcweir String aName = pStyleSheet->GetName();
1492cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1493cdf0e10cSrcweir new ScUndoSelectionStyle( pDocSh, aFuncMark, aMarkRange, aName, pUndoDoc ) );
1494cdf0e10cSrcweir }
1495cdf0e10cSrcweir
1496cdf0e10cSrcweir pDoc->ApplySelectionStyle( (ScStyleSheet&)*pStyleSheet, aFuncMark );
1497cdf0e10cSrcweir
1498cdf0e10cSrcweir if (!AdjustBlockHeight())
1499cdf0e10cSrcweir pViewData->GetDocShell()->PostPaint( aMarkRange, PAINT_GRID );
1500cdf0e10cSrcweir
1501cdf0e10cSrcweir aFuncMark.MarkToSimple();
1502cdf0e10cSrcweir }
1503cdf0e10cSrcweir else
1504cdf0e10cSrcweir {
1505cdf0e10cSrcweir SCCOL nCol = pViewData->GetCurX();
1506cdf0e10cSrcweir SCROW nRow = pViewData->GetCurY();
1507cdf0e10cSrcweir SCTAB nTab = pViewData->GetTabNo();
1508cdf0e10cSrcweir
1509cdf0e10cSrcweir if ( bRecord )
1510cdf0e10cSrcweir {
1511cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1512cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab );
1513cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1514cdf0e10cSrcweir if (i != nTab && aFuncMark.GetTableSelect(i))
1515cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
1516cdf0e10cSrcweir
1517cdf0e10cSrcweir ScRange aCopyRange( nCol, nRow, 0, nCol, nRow, nTabCount-1 );
1518cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, sal_False, pUndoDoc );
1519cdf0e10cSrcweir
1520cdf0e10cSrcweir ScRange aMarkRange ( nCol, nRow, nTab );
1521cdf0e10cSrcweir ScMarkData aUndoMark = aFuncMark;
1522cdf0e10cSrcweir aUndoMark.SetMultiMarkArea( aMarkRange );
1523cdf0e10cSrcweir
1524cdf0e10cSrcweir String aName = pStyleSheet->GetName();
1525cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1526cdf0e10cSrcweir new ScUndoSelectionStyle( pDocSh, aUndoMark, aMarkRange, aName, pUndoDoc ) );
1527cdf0e10cSrcweir }
1528cdf0e10cSrcweir
1529cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1530cdf0e10cSrcweir if (aFuncMark.GetTableSelect(i))
1531cdf0e10cSrcweir pDoc->ApplyStyle( nCol, nRow, i, (ScStyleSheet&)*pStyleSheet );
1532cdf0e10cSrcweir
1533cdf0e10cSrcweir if (!AdjustBlockHeight())
1534cdf0e10cSrcweir pViewData->GetDocShell()->PostPaintCell( nCol, nRow, nTab );
1535cdf0e10cSrcweir
1536cdf0e10cSrcweir }
1537cdf0e10cSrcweir
1538cdf0e10cSrcweir aModificator.SetDocumentModified();
1539cdf0e10cSrcweir
1540cdf0e10cSrcweir StartFormatArea();
1541cdf0e10cSrcweir }
1542cdf0e10cSrcweir
1543cdf0e10cSrcweir
RemoveStyleSheetInUse(const SfxStyleSheetBase * pStyleSheet)1544cdf0e10cSrcweir void ScViewFunc::RemoveStyleSheetInUse( const SfxStyleSheetBase* pStyleSheet )
1545cdf0e10cSrcweir {
1546cdf0e10cSrcweir if ( !pStyleSheet) return;
1547cdf0e10cSrcweir // -------------------------------------------------------------------
1548cdf0e10cSrcweir
1549cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
1550cdf0e10cSrcweir ScDocument* pDoc = pViewData->GetDocument();
1551cdf0e10cSrcweir ScDocShell* pDocSh = pViewData->GetDocShell();
1552cdf0e10cSrcweir
1553cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
1554cdf0e10cSrcweir
1555cdf0e10cSrcweir VirtualDevice aVirtDev;
1556cdf0e10cSrcweir aVirtDev.SetMapMode(MAP_PIXEL);
1557cdf0e10cSrcweir pDoc->StyleSheetChanged( pStyleSheet, sal_True, &aVirtDev,
1558cdf0e10cSrcweir pViewData->GetPPTX(),
1559cdf0e10cSrcweir pViewData->GetPPTY(),
1560cdf0e10cSrcweir pViewData->GetZoomX(),
1561cdf0e10cSrcweir pViewData->GetZoomY() );
1562cdf0e10cSrcweir
1563cdf0e10cSrcweir pDocSh->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID|PAINT_LEFT );
1564cdf0e10cSrcweir aModificator.SetDocumentModified();
1565cdf0e10cSrcweir
1566cdf0e10cSrcweir ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
1567cdf0e10cSrcweir if (pHdl)
1568cdf0e10cSrcweir pHdl->ForgetLastPattern();
1569cdf0e10cSrcweir }
1570cdf0e10cSrcweir
UpdateStyleSheetInUse(const SfxStyleSheetBase * pStyleSheet)1571cdf0e10cSrcweir void ScViewFunc::UpdateStyleSheetInUse( const SfxStyleSheetBase* pStyleSheet )
1572cdf0e10cSrcweir {
1573cdf0e10cSrcweir if ( !pStyleSheet) return;
1574cdf0e10cSrcweir // -------------------------------------------------------------------
1575cdf0e10cSrcweir
1576cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
1577cdf0e10cSrcweir ScDocument* pDoc = pViewData->GetDocument();
1578cdf0e10cSrcweir ScDocShell* pDocSh = pViewData->GetDocShell();
1579cdf0e10cSrcweir
1580cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
1581cdf0e10cSrcweir
1582cdf0e10cSrcweir VirtualDevice aVirtDev;
1583cdf0e10cSrcweir aVirtDev.SetMapMode(MAP_PIXEL);
1584cdf0e10cSrcweir pDoc->StyleSheetChanged( pStyleSheet, sal_False, &aVirtDev,
1585cdf0e10cSrcweir pViewData->GetPPTX(),
1586cdf0e10cSrcweir pViewData->GetPPTY(),
1587cdf0e10cSrcweir pViewData->GetZoomX(),
1588cdf0e10cSrcweir pViewData->GetZoomY() );
1589cdf0e10cSrcweir
1590cdf0e10cSrcweir pDocSh->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID|PAINT_LEFT );
1591cdf0e10cSrcweir aModificator.SetDocumentModified();
1592cdf0e10cSrcweir
1593cdf0e10cSrcweir ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
1594cdf0e10cSrcweir if (pHdl)
1595cdf0e10cSrcweir pHdl->ForgetLastPattern();
1596cdf0e10cSrcweir }
1597cdf0e10cSrcweir
1598cdf0e10cSrcweir // Zellen einfuegen - Undo OK
1599cdf0e10cSrcweir
InsertCells(InsCellCmd eCmd,sal_Bool bRecord,sal_Bool bPartOfPaste)1600cdf0e10cSrcweir sal_Bool ScViewFunc::InsertCells( InsCellCmd eCmd, sal_Bool bRecord, sal_Bool bPartOfPaste )
1601cdf0e10cSrcweir {
1602cdf0e10cSrcweir ScRange aRange;
1603cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
1604cdf0e10cSrcweir {
1605cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1606cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
1607cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().InsertCells( aRange, &rMark, eCmd, bRecord, sal_False, bPartOfPaste );
1608cdf0e10cSrcweir if (bSuccess)
1609cdf0e10cSrcweir {
1610cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1611cdf0e10cSrcweir CellContentChanged();
1612cdf0e10cSrcweir
1613cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
1614cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
1615cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
1616cdf0e10cSrcweir {
1617cdf0e10cSrcweir if ( eCmd == INS_INSROWS || eCmd == INS_INSCOLS )
1618cdf0e10cSrcweir {
1619cdf0e10cSrcweir ScRangeList aChangeRanges;
1620cdf0e10cSrcweir aChangeRanges.Append( aRange );
1621cdf0e10cSrcweir ::rtl::OUString aOperation = ( eCmd == INS_INSROWS ?
1622cdf0e10cSrcweir ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "insert-rows" ) ) :
1623cdf0e10cSrcweir ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "insert-columns" ) ) );
1624cdf0e10cSrcweir pModelObj->NotifyChanges( aOperation, aChangeRanges );
1625cdf0e10cSrcweir }
1626cdf0e10cSrcweir }
1627cdf0e10cSrcweir }
1628cdf0e10cSrcweir return bSuccess;
1629cdf0e10cSrcweir }
1630cdf0e10cSrcweir else
1631cdf0e10cSrcweir {
1632cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1633cdf0e10cSrcweir return sal_False;
1634cdf0e10cSrcweir }
1635cdf0e10cSrcweir }
1636cdf0e10cSrcweir
1637cdf0e10cSrcweir // Zellen loeschen - Undo OK
1638cdf0e10cSrcweir
DeleteCells(DelCellCmd eCmd,sal_Bool bRecord)1639cdf0e10cSrcweir void ScViewFunc::DeleteCells( DelCellCmd eCmd, sal_Bool bRecord )
1640cdf0e10cSrcweir {
1641cdf0e10cSrcweir ScRange aRange;
1642cdf0e10cSrcweir if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
1643cdf0e10cSrcweir {
1644cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1645cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
1646cdf0e10cSrcweir
1647cdf0e10cSrcweir // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
1648cdf0e10cSrcweir if ( pDocSh->IsDocShared() && ( eCmd == DEL_DELROWS || eCmd == DEL_DELCOLS ) )
1649cdf0e10cSrcweir {
1650cdf0e10cSrcweir ScRange aDelRange( aRange.aStart );
1651cdf0e10cSrcweir SCCOLROW nCount = 0;
1652cdf0e10cSrcweir if ( eCmd == DEL_DELROWS )
1653cdf0e10cSrcweir {
1654cdf0e10cSrcweir nCount = sal::static_int_cast< SCCOLROW >( aRange.aEnd.Row() - aRange.aStart.Row() + 1 );
1655cdf0e10cSrcweir }
1656cdf0e10cSrcweir else
1657cdf0e10cSrcweir {
1658cdf0e10cSrcweir nCount = sal::static_int_cast< SCCOLROW >( aRange.aEnd.Col() - aRange.aStart.Col() + 1 );
1659cdf0e10cSrcweir }
1660cdf0e10cSrcweir while ( nCount > 0 )
1661cdf0e10cSrcweir {
1662cdf0e10cSrcweir pDocSh->GetDocFunc().DeleteCells( aDelRange, &rMark, eCmd, bRecord, sal_False );
1663cdf0e10cSrcweir --nCount;
1664cdf0e10cSrcweir }
1665cdf0e10cSrcweir }
1666cdf0e10cSrcweir else
1667cdf0e10cSrcweir {
1668cdf0e10cSrcweir pDocSh->GetDocFunc().DeleteCells( aRange, &rMark, eCmd, bRecord, sal_False );
1669cdf0e10cSrcweir }
1670cdf0e10cSrcweir
1671cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1672cdf0e10cSrcweir CellContentChanged();
1673cdf0e10cSrcweir
1674cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
1675cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
1676cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
1677cdf0e10cSrcweir {
1678cdf0e10cSrcweir if ( eCmd == DEL_DELROWS || eCmd == DEL_DELCOLS )
1679cdf0e10cSrcweir {
1680cdf0e10cSrcweir ScRangeList aChangeRanges;
1681cdf0e10cSrcweir aChangeRanges.Append( aRange );
1682cdf0e10cSrcweir ::rtl::OUString aOperation = ( eCmd == DEL_DELROWS ?
1683cdf0e10cSrcweir ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "delete-rows" ) ) :
1684cdf0e10cSrcweir ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "delete-columns" ) ) );
1685cdf0e10cSrcweir pModelObj->NotifyChanges( aOperation, aChangeRanges );
1686cdf0e10cSrcweir }
1687cdf0e10cSrcweir }
1688cdf0e10cSrcweir
1689cdf0e10cSrcweir // #58106# Cursor direkt hinter den geloeschten Bereich setzen
1690cdf0e10cSrcweir SCCOL nCurX = GetViewData()->GetCurX();
1691cdf0e10cSrcweir SCROW nCurY = GetViewData()->GetCurY();
1692cdf0e10cSrcweir if ( eCmd==DEL_CELLSLEFT || eCmd==DEL_DELCOLS )
1693cdf0e10cSrcweir nCurX = aRange.aStart.Col();
1694cdf0e10cSrcweir else
1695cdf0e10cSrcweir nCurY = aRange.aStart.Row();
1696cdf0e10cSrcweir SetCursor( nCurX, nCurY );
1697cdf0e10cSrcweir }
1698cdf0e10cSrcweir else
1699cdf0e10cSrcweir {
1700cdf0e10cSrcweir if (eCmd == DEL_DELCOLS)
1701cdf0e10cSrcweir DeleteMulti( sal_False, bRecord );
1702cdf0e10cSrcweir else if (eCmd == DEL_DELROWS)
1703cdf0e10cSrcweir DeleteMulti( sal_True, bRecord );
1704cdf0e10cSrcweir else
1705cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1706cdf0e10cSrcweir }
1707cdf0e10cSrcweir
1708cdf0e10cSrcweir Unmark();
1709cdf0e10cSrcweir }
1710cdf0e10cSrcweir
DeleteMulti(sal_Bool bRows,sal_Bool bRecord)1711cdf0e10cSrcweir void ScViewFunc::DeleteMulti( sal_Bool bRows, sal_Bool bRecord )
1712cdf0e10cSrcweir {
1713cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1714cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
1715cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
1716cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
1717cdf0e10cSrcweir ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered
1718cdf0e10cSrcweir ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
1719cdf0e10cSrcweir
1720cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1721cdf0e10cSrcweir bRecord = sal_False;
1722cdf0e10cSrcweir SCCOLROW* pRanges = new SCCOLROW[MAXCOLROWCOUNT];
1723cdf0e10cSrcweir SCCOLROW nRangeCnt = bRows ? aFuncMark.GetMarkRowRanges( pRanges ) :
1724cdf0e10cSrcweir aFuncMark.GetMarkColumnRanges( pRanges );
1725cdf0e10cSrcweir if (nRangeCnt == 0)
1726cdf0e10cSrcweir {
1727cdf0e10cSrcweir pRanges[0] = pRanges[1] = bRows ? static_cast<SCCOLROW>(GetViewData()->GetCurY()) : static_cast<SCCOLROW>(GetViewData()->GetCurX());
1728cdf0e10cSrcweir nRangeCnt = 1;
1729cdf0e10cSrcweir }
1730cdf0e10cSrcweir
1731cdf0e10cSrcweir // Test ob erlaubt
1732cdf0e10cSrcweir
1733cdf0e10cSrcweir SCCOLROW* pOneRange = pRanges;
1734cdf0e10cSrcweir sal_uInt16 nErrorId = 0;
1735cdf0e10cSrcweir sal_Bool bNeedRefresh = sal_False;
1736cdf0e10cSrcweir SCCOLROW nRangeNo;
1737cdf0e10cSrcweir for (nRangeNo=0; nRangeNo<nRangeCnt && !nErrorId; nRangeNo++)
1738cdf0e10cSrcweir {
1739cdf0e10cSrcweir SCCOLROW nStart = *(pOneRange++);
1740cdf0e10cSrcweir SCCOLROW nEnd = *(pOneRange++);
1741cdf0e10cSrcweir
1742cdf0e10cSrcweir SCCOL nStartCol, nEndCol;
1743cdf0e10cSrcweir SCROW nStartRow, nEndRow;
1744cdf0e10cSrcweir if ( bRows )
1745cdf0e10cSrcweir {
1746cdf0e10cSrcweir nStartCol = 0;
1747cdf0e10cSrcweir nEndCol = MAXCOL;
1748cdf0e10cSrcweir nStartRow = static_cast<SCROW>(nStart);
1749cdf0e10cSrcweir nEndRow = static_cast<SCROW>(nEnd);
1750cdf0e10cSrcweir }
1751cdf0e10cSrcweir else
1752cdf0e10cSrcweir {
1753cdf0e10cSrcweir nStartCol = static_cast<SCCOL>(nStart);
1754cdf0e10cSrcweir nEndCol = static_cast<SCCOL>(nEnd);
1755cdf0e10cSrcweir nStartRow = 0;
1756cdf0e10cSrcweir nEndRow = MAXROW;
1757cdf0e10cSrcweir }
1758cdf0e10cSrcweir
1759cdf0e10cSrcweir // cell protection (only needed for first range, as all following cells are moved)
1760cdf0e10cSrcweir if ( nRangeNo == 0 )
1761cdf0e10cSrcweir {
1762cdf0e10cSrcweir // test to the end of the sheet
1763cdf0e10cSrcweir ScEditableTester aTester( pDoc, nTab, nStartCol, nStartRow, MAXCOL, MAXROW );
1764cdf0e10cSrcweir if (!aTester.IsEditable())
1765cdf0e10cSrcweir nErrorId = aTester.GetMessageId();
1766cdf0e10cSrcweir }
1767cdf0e10cSrcweir
1768cdf0e10cSrcweir // merged cells
1769cdf0e10cSrcweir SCCOL nMergeStartX = nStartCol;
1770cdf0e10cSrcweir SCROW nMergeStartY = nStartRow;
1771cdf0e10cSrcweir SCCOL nMergeEndX = nEndCol;
1772cdf0e10cSrcweir SCROW nMergeEndY = nEndRow;
1773cdf0e10cSrcweir pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, nTab );
1774cdf0e10cSrcweir pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, nTab );
1775cdf0e10cSrcweir
1776cdf0e10cSrcweir if ( nMergeStartX != nStartCol || nMergeStartY != nStartRow )
1777cdf0e10cSrcweir {
1778cdf0e10cSrcweir // Disallow deleting parts of a merged cell.
1779cdf0e10cSrcweir // Deleting the start is allowed (merge is removed), so the end doesn't have to be checked.
1780cdf0e10cSrcweir
1781cdf0e10cSrcweir nErrorId = STR_MSSG_DELETECELLS_0;
1782cdf0e10cSrcweir }
1783cdf0e10cSrcweir if ( nMergeEndX != nEndCol || nMergeEndY != nEndRow )
1784cdf0e10cSrcweir {
1785cdf0e10cSrcweir // detect if the start of a merged cell is deleted, so the merge flags can be refreshed
1786cdf0e10cSrcweir
1787cdf0e10cSrcweir bNeedRefresh = sal_True;
1788cdf0e10cSrcweir }
1789cdf0e10cSrcweir }
1790cdf0e10cSrcweir
1791cdf0e10cSrcweir if ( nErrorId )
1792cdf0e10cSrcweir {
1793cdf0e10cSrcweir ErrorMessage( nErrorId );
1794cdf0e10cSrcweir delete[] pRanges;
1795cdf0e10cSrcweir return;
1796cdf0e10cSrcweir }
1797cdf0e10cSrcweir
1798cdf0e10cSrcweir // ausfuehren
1799cdf0e10cSrcweir
1800cdf0e10cSrcweir WaitObject aWait( GetFrameWin() ); // wichtig wegen TrackFormulas bei UpdateReference
1801cdf0e10cSrcweir
1802cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
1803cdf0e10cSrcweir ScRefUndoData* pUndoData = NULL;
1804cdf0e10cSrcweir if (bRecord)
1805cdf0e10cSrcweir {
1806cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1807cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab, !bRows, bRows ); // Zeilenhoehen
1808cdf0e10cSrcweir
1809cdf0e10cSrcweir pOneRange = pRanges;
1810cdf0e10cSrcweir for (nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
1811cdf0e10cSrcweir {
1812cdf0e10cSrcweir SCCOLROW nStart = *(pOneRange++);
1813cdf0e10cSrcweir SCCOLROW nEnd = *(pOneRange++);
1814cdf0e10cSrcweir if (bRows)
1815cdf0e10cSrcweir pDoc->CopyToDocument( 0,nStart,nTab, MAXCOL,nEnd,nTab, IDF_ALL,sal_False,pUndoDoc );
1816cdf0e10cSrcweir else
1817cdf0e10cSrcweir pDoc->CopyToDocument( static_cast<SCCOL>(nStart),0,nTab,
1818cdf0e10cSrcweir static_cast<SCCOL>(nEnd),MAXROW,nTab,
1819cdf0e10cSrcweir IDF_ALL,sal_False,pUndoDoc );
1820cdf0e10cSrcweir }
1821cdf0e10cSrcweir
1822cdf0e10cSrcweir // alle Formeln wegen Referenzen
1823cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1824cdf0e10cSrcweir pUndoDoc->AddUndoTab( 0, nTabCount-1, sal_False, sal_False );
1825cdf0e10cSrcweir pDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,MAXTAB, IDF_FORMULA,sal_False,pUndoDoc );
1826cdf0e10cSrcweir
1827cdf0e10cSrcweir pUndoData = new ScRefUndoData( pDoc );
1828cdf0e10cSrcweir
1829cdf0e10cSrcweir pDoc->BeginDrawUndo();
1830cdf0e10cSrcweir }
1831cdf0e10cSrcweir
1832cdf0e10cSrcweir pOneRange = &pRanges[2*nRangeCnt]; // rueckwaerts
1833cdf0e10cSrcweir for (nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
1834cdf0e10cSrcweir {
1835cdf0e10cSrcweir SCCOLROW nEnd = *(--pOneRange);
1836cdf0e10cSrcweir SCCOLROW nStart = *(--pOneRange);
1837cdf0e10cSrcweir
1838cdf0e10cSrcweir if (bRows)
1839cdf0e10cSrcweir pDoc->DeleteRow( 0,nTab, MAXCOL,nTab, nStart, static_cast<SCSIZE>(nEnd-nStart+1) );
1840cdf0e10cSrcweir else
1841cdf0e10cSrcweir pDoc->DeleteCol( 0,nTab, MAXROW,nTab, static_cast<SCCOL>(nStart), static_cast<SCSIZE>(nEnd-nStart+1) );
1842cdf0e10cSrcweir }
1843cdf0e10cSrcweir
1844cdf0e10cSrcweir if (bNeedRefresh)
1845cdf0e10cSrcweir {
1846cdf0e10cSrcweir SCCOLROW nFirstStart = pRanges[0];
1847cdf0e10cSrcweir SCCOL nStartCol = bRows ? 0 : static_cast<SCCOL>(nFirstStart);
1848cdf0e10cSrcweir SCROW nStartRow = bRows ? static_cast<SCROW>(nFirstStart) : 0;
1849cdf0e10cSrcweir SCCOL nEndCol = MAXCOL;
1850cdf0e10cSrcweir SCROW nEndRow = MAXROW;
1851cdf0e10cSrcweir
1852cdf0e10cSrcweir pDoc->RemoveFlagsTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, SC_MF_HOR | SC_MF_VER );
1853cdf0e10cSrcweir pDoc->ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab, sal_True );
1854cdf0e10cSrcweir }
1855cdf0e10cSrcweir
1856cdf0e10cSrcweir if (bRecord)
1857cdf0e10cSrcweir {
1858cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1859cdf0e10cSrcweir new ScUndoDeleteMulti( pDocSh, bRows, bNeedRefresh, nTab, pRanges, nRangeCnt,
1860cdf0e10cSrcweir pUndoDoc, pUndoData ) );
1861cdf0e10cSrcweir }
1862cdf0e10cSrcweir
1863cdf0e10cSrcweir if (!AdjustRowHeight(0, MAXROW))
1864cdf0e10cSrcweir {
1865cdf0e10cSrcweir if (bRows)
1866cdf0e10cSrcweir pDocSh->PostPaint( 0,pRanges[0],nTab, MAXCOL,MAXROW,nTab, PAINT_GRID | PAINT_LEFT );
1867cdf0e10cSrcweir else
1868cdf0e10cSrcweir pDocSh->PostPaint( static_cast<SCCOL>(pRanges[0]),0,nTab,
1869cdf0e10cSrcweir MAXCOL,MAXROW,nTab, PAINT_GRID | PAINT_TOP );
1870cdf0e10cSrcweir }
1871cdf0e10cSrcweir aModificator.SetDocumentModified();
1872cdf0e10cSrcweir
1873cdf0e10cSrcweir CellContentChanged();
1874cdf0e10cSrcweir
1875cdf0e10cSrcweir // #58106# Cursor direkt hinter den ersten geloeschten Bereich setzen
1876cdf0e10cSrcweir SCCOL nCurX = GetViewData()->GetCurX();
1877cdf0e10cSrcweir SCROW nCurY = GetViewData()->GetCurY();
1878cdf0e10cSrcweir if ( bRows )
1879cdf0e10cSrcweir nCurY = pRanges[0];
1880cdf0e10cSrcweir else
1881cdf0e10cSrcweir nCurX = static_cast<SCCOL>(pRanges[0]);
1882cdf0e10cSrcweir SetCursor( nCurX, nCurY );
1883cdf0e10cSrcweir
1884cdf0e10cSrcweir delete[] pRanges;
1885cdf0e10cSrcweir
1886cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1887cdf0e10cSrcweir }
1888cdf0e10cSrcweir
1889cdf0e10cSrcweir // Inhalte loeschen
1890cdf0e10cSrcweir
DeleteContents(sal_uInt16 nFlags,sal_Bool bRecord)1891cdf0e10cSrcweir void ScViewFunc::DeleteContents( sal_uInt16 nFlags, sal_Bool bRecord )
1892cdf0e10cSrcweir {
1893cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
1894cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1895cdf0e10cSrcweir sal_Bool bEditable = SelectionEditable( &bOnlyNotBecauseOfMatrix );
1896cdf0e10cSrcweir if ( !bEditable )
1897cdf0e10cSrcweir {
1898cdf0e10cSrcweir if ( !(bOnlyNotBecauseOfMatrix &&
1899cdf0e10cSrcweir ((nFlags & (IDF_ATTRIB | IDF_EDITATTR)) == nFlags)) )
1900cdf0e10cSrcweir {
1901cdf0e10cSrcweir ErrorMessage(bOnlyNotBecauseOfMatrix ? STR_MATRIXFRAGMENTERR : STR_PROTECTIONERR);
1902cdf0e10cSrcweir return;
1903cdf0e10cSrcweir }
1904cdf0e10cSrcweir }
1905cdf0e10cSrcweir
1906cdf0e10cSrcweir ScRange aMarkRange;
1907cdf0e10cSrcweir sal_Bool bSimple = sal_False;
1908cdf0e10cSrcweir
1909cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
1910cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1911cdf0e10cSrcweir ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered
1912cdf0e10cSrcweir ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
1913cdf0e10cSrcweir
1914cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1915cdf0e10cSrcweir bRecord = sal_False;
1916cdf0e10cSrcweir
1917cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
1918cdf0e10cSrcweir
1919cdf0e10cSrcweir if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
1920cdf0e10cSrcweir {
1921cdf0e10cSrcweir aMarkRange.aStart.SetCol(GetViewData()->GetCurX());
1922cdf0e10cSrcweir aMarkRange.aStart.SetRow(GetViewData()->GetCurY());
1923cdf0e10cSrcweir aMarkRange.aStart.SetTab(GetViewData()->GetTabNo());
1924cdf0e10cSrcweir aMarkRange.aEnd = aMarkRange.aStart;
1925cdf0e10cSrcweir if ( pDoc->HasAttrib( aMarkRange, HASATTR_MERGED ) )
1926cdf0e10cSrcweir {
1927cdf0e10cSrcweir // InitOwnBlockMode();
1928cdf0e10cSrcweir aFuncMark.SetMarkArea( aMarkRange );
1929cdf0e10cSrcweir }
1930cdf0e10cSrcweir else
1931cdf0e10cSrcweir bSimple = sal_True;
1932cdf0e10cSrcweir }
1933cdf0e10cSrcweir
1934cdf0e10cSrcweir aFuncMark.SetMarking(sal_False); // for MarkToMulti
1935cdf0e10cSrcweir aFuncMark.MarkToSimple(); // before bMulti test below
1936cdf0e10cSrcweir
1937cdf0e10cSrcweir DBG_ASSERT( aFuncMark.IsMarked() || aFuncMark.IsMultiMarked() || bSimple, "delete what?" );
1938cdf0e10cSrcweir
1939cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
1940cdf0e10cSrcweir sal_Bool bMulti = !bSimple && aFuncMark.IsMultiMarked();
1941cdf0e10cSrcweir if (!bSimple)
1942cdf0e10cSrcweir {
1943cdf0e10cSrcweir aFuncMark.MarkToMulti();
1944cdf0e10cSrcweir aFuncMark.GetMultiMarkArea( aMarkRange );
1945cdf0e10cSrcweir }
1946cdf0e10cSrcweir ScRange aExtendedRange(aMarkRange);
1947cdf0e10cSrcweir if (!bSimple)
1948cdf0e10cSrcweir {
1949cdf0e10cSrcweir if ( pDoc->ExtendMerge( aExtendedRange, sal_True ) )
1950cdf0e10cSrcweir bMulti = sal_False;
1951cdf0e10cSrcweir }
1952cdf0e10cSrcweir
1953cdf0e10cSrcweir // keine Objekte auf geschuetzten Tabellen
1954cdf0e10cSrcweir sal_Bool bObjects = sal_False;
1955cdf0e10cSrcweir if ( nFlags & IDF_OBJECTS )
1956cdf0e10cSrcweir {
1957cdf0e10cSrcweir bObjects = sal_True;
1958cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1959cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nTabCount; nTab++)
1960cdf0e10cSrcweir if (aFuncMark.GetTableSelect(nTab) && pDoc->IsTabProtected(nTab))
1961cdf0e10cSrcweir bObjects = sal_False;
1962cdf0e10cSrcweir }
1963cdf0e10cSrcweir
1964cdf0e10cSrcweir sal_uInt16 nExtFlags = 0; // extra flags are needed only if attributes are deleted
1965cdf0e10cSrcweir if ( nFlags & IDF_ATTRIB )
1966cdf0e10cSrcweir pDocSh->UpdatePaintExt( nExtFlags, aMarkRange );
1967cdf0e10cSrcweir
1968cdf0e10cSrcweir // Reihenfolge:
1969cdf0e10cSrcweir // 1) BeginDrawUndo
1970cdf0e10cSrcweir // 2) Objekte loeschen (DrawUndo wird gefuellt)
1971cdf0e10cSrcweir // 3) Inhalte fuer Undo kopieren
1972cdf0e10cSrcweir // 4) Inhalte loeschen
1973cdf0e10cSrcweir // 5) Undo-Aktion anlegen
1974cdf0e10cSrcweir
1975cdf0e10cSrcweir sal_Bool bDrawUndo = bObjects || ( nFlags & IDF_NOTE ); // needed for shown notes
1976cdf0e10cSrcweir if ( bDrawUndo && bRecord )
1977cdf0e10cSrcweir pDoc->BeginDrawUndo();
1978cdf0e10cSrcweir
1979cdf0e10cSrcweir if (bObjects)
1980cdf0e10cSrcweir {
1981cdf0e10cSrcweir if (bMulti)
1982cdf0e10cSrcweir pDoc->DeleteObjectsInSelection( aFuncMark );
1983cdf0e10cSrcweir else
1984cdf0e10cSrcweir pDoc->DeleteObjectsInArea( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
1985cdf0e10cSrcweir /*!*/ aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(),
1986cdf0e10cSrcweir aFuncMark );
1987cdf0e10cSrcweir }
1988cdf0e10cSrcweir
1989cdf0e10cSrcweir if ( bRecord )
1990cdf0e10cSrcweir {
1991cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1992cdf0e10cSrcweir SCTAB nTab = aMarkRange.aStart.Tab();
1993cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab );
1994cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1995cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1996cdf0e10cSrcweir if (i != nTab && aFuncMark.GetTableSelect(i))
1997cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
1998cdf0e10cSrcweir ScRange aCopyRange = aExtendedRange;
1999cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
2000cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
2001cdf0e10cSrcweir
2002cdf0e10cSrcweir // bei "Format/Standard" alle Attribute kopieren, weil CopyToDocument
2003cdf0e10cSrcweir // nur mit IDF_HARDATTR zu langsam ist:
2004cdf0e10cSrcweir sal_uInt16 nUndoDocFlags = nFlags;
2005cdf0e10cSrcweir if (nFlags & IDF_ATTRIB)
2006cdf0e10cSrcweir nUndoDocFlags |= IDF_ATTRIB;
2007cdf0e10cSrcweir if (nFlags & IDF_EDITATTR) // Edit-Engine-Attribute
2008cdf0e10cSrcweir nUndoDocFlags |= IDF_STRING; // -> Zellen werden geaendert
2009cdf0e10cSrcweir if (nFlags & IDF_NOTE)
2010cdf0e10cSrcweir nUndoDocFlags |= IDF_CONTENTS; // #68795# copy all cells with their notes
2011cdf0e10cSrcweir // do not copy note captions to undo document
2012cdf0e10cSrcweir nUndoDocFlags |= IDF_NOCAPTIONS;
2013cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, nUndoDocFlags, bMulti, pUndoDoc, &aFuncMark );
2014cdf0e10cSrcweir }
2015cdf0e10cSrcweir
2016cdf0e10cSrcweir HideAllCursors(); // falls Zusammenfassung aufgehoben wird
2017cdf0e10cSrcweir if (bSimple)
2018cdf0e10cSrcweir pDoc->DeleteArea( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
2019cdf0e10cSrcweir aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(),
2020cdf0e10cSrcweir aFuncMark, nFlags );
2021cdf0e10cSrcweir else
2022cdf0e10cSrcweir {
2023cdf0e10cSrcweir pDoc->DeleteSelection( nFlags, aFuncMark );
2024cdf0e10cSrcweir // aFuncMark.MarkToSimple();
2025cdf0e10cSrcweir }
2026cdf0e10cSrcweir
2027cdf0e10cSrcweir if ( bRecord )
2028cdf0e10cSrcweir {
2029cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
2030cdf0e10cSrcweir new ScUndoDeleteContents( pDocSh, aFuncMark, aExtendedRange,
2031cdf0e10cSrcweir pUndoDoc, bMulti, nFlags, bDrawUndo ) );
2032cdf0e10cSrcweir }
2033cdf0e10cSrcweir
2034cdf0e10cSrcweir if (!AdjustRowHeight( aExtendedRange.aStart.Row(), aExtendedRange.aEnd.Row() ))
2035cdf0e10cSrcweir pDocSh->PostPaint( aExtendedRange, PAINT_GRID, nExtFlags );
2036cdf0e10cSrcweir
2037cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
2038cdf0e10cSrcweir
2039cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
2040cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
2041cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
2042cdf0e10cSrcweir {
2043cdf0e10cSrcweir ScRangeList aChangeRanges;
2044cdf0e10cSrcweir if ( bSimple )
2045cdf0e10cSrcweir {
2046cdf0e10cSrcweir aChangeRanges.Append( aMarkRange );
2047cdf0e10cSrcweir }
2048cdf0e10cSrcweir else
2049cdf0e10cSrcweir {
2050cdf0e10cSrcweir aFuncMark.FillRangeListWithMarks( &aChangeRanges, sal_False );
2051cdf0e10cSrcweir }
2052cdf0e10cSrcweir pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
2053cdf0e10cSrcweir }
2054cdf0e10cSrcweir
2055cdf0e10cSrcweir aModificator.SetDocumentModified();
2056cdf0e10cSrcweir CellContentChanged();
2057cdf0e10cSrcweir ShowAllCursors();
2058cdf0e10cSrcweir
2059cdf0e10cSrcweir if ( nFlags & IDF_ATTRIB )
2060cdf0e10cSrcweir {
2061cdf0e10cSrcweir if ( nFlags & IDF_CONTENTS )
2062cdf0e10cSrcweir ForgetFormatArea();
2063cdf0e10cSrcweir else
2064cdf0e10cSrcweir StartFormatArea(); // Attribute loeschen ist auch Attributierung
2065cdf0e10cSrcweir }
2066cdf0e10cSrcweir }
2067cdf0e10cSrcweir
2068cdf0e10cSrcweir // Spaltenbreiten/Zeilenhoehen (ueber Header) - Undo OK
2069cdf0e10cSrcweir
SetWidthOrHeight(sal_Bool bWidth,SCCOLROW nRangeCnt,SCCOLROW * pRanges,ScSizeMode eMode,sal_uInt16 nSizeTwips,sal_Bool bRecord,sal_Bool bPaint,ScMarkData * pMarkData)2070cdf0e10cSrcweir void ScViewFunc::SetWidthOrHeight( sal_Bool bWidth, SCCOLROW nRangeCnt, SCCOLROW* pRanges,
2071cdf0e10cSrcweir ScSizeMode eMode, sal_uInt16 nSizeTwips,
2072cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bPaint, ScMarkData* pMarkData )
2073cdf0e10cSrcweir {
2074cdf0e10cSrcweir if (nRangeCnt == 0)
2075cdf0e10cSrcweir return;
2076cdf0e10cSrcweir
2077cdf0e10cSrcweir // use view's mark if none specified
2078cdf0e10cSrcweir if ( !pMarkData )
2079cdf0e10cSrcweir pMarkData = &GetViewData()->GetMarkData();
2080cdf0e10cSrcweir
2081cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2082cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2083cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
2084cdf0e10cSrcweir SCTAB nFirstTab = pMarkData->GetFirstSelected();
2085cdf0e10cSrcweir SCTAB nCurTab = GetViewData()->GetTabNo();
2086cdf0e10cSrcweir SCTAB nTab;
2087cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2088cdf0e10cSrcweir bRecord = sal_False;
2089cdf0e10cSrcweir
2090cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
2091cdf0e10cSrcweir
2092cdf0e10cSrcweir sal_Bool bAllowed = sal_True;
2093cdf0e10cSrcweir for (nTab=0; nTab<nTabCount && bAllowed; nTab++)
2094cdf0e10cSrcweir if (pMarkData->GetTableSelect(nTab))
2095cdf0e10cSrcweir {
2096cdf0e10cSrcweir for ( SCCOLROW i=0; i<nRangeCnt && bAllowed; i++ )
2097cdf0e10cSrcweir {
2098cdf0e10cSrcweir sal_Bool bOnlyMatrix;
2099cdf0e10cSrcweir if (bWidth)
2100cdf0e10cSrcweir bAllowed = pDoc->IsBlockEditable( nTab,
2101cdf0e10cSrcweir static_cast<SCCOL>(pRanges[2*i]),0,
2102cdf0e10cSrcweir static_cast<SCCOL>(pRanges[2*i+1]),MAXROW,
2103cdf0e10cSrcweir &bOnlyMatrix ) || bOnlyMatrix;
2104cdf0e10cSrcweir else
2105cdf0e10cSrcweir bAllowed = pDoc->IsBlockEditable( nTab, 0,pRanges[2*i],
2106cdf0e10cSrcweir MAXCOL,pRanges[2*i+1], &bOnlyMatrix ) ||
2107cdf0e10cSrcweir bOnlyMatrix;
2108cdf0e10cSrcweir }
2109cdf0e10cSrcweir }
2110cdf0e10cSrcweir if ( !bAllowed )
2111cdf0e10cSrcweir {
2112cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
2113cdf0e10cSrcweir return;
2114cdf0e10cSrcweir }
2115cdf0e10cSrcweir
2116cdf0e10cSrcweir SCCOLROW nStart = pRanges[0];
2117cdf0e10cSrcweir SCCOLROW nEnd = pRanges[2*nRangeCnt-1];
2118cdf0e10cSrcweir
2119cdf0e10cSrcweir sal_Bool bFormula = sal_False;
2120cdf0e10cSrcweir if ( eMode == SC_SIZE_OPTIMAL )
2121cdf0e10cSrcweir {
2122cdf0e10cSrcweir const ScViewOptions& rOpts = GetViewData()->GetOptions();
2123cdf0e10cSrcweir bFormula = rOpts.GetOption( VOPT_FORMULAS );
2124cdf0e10cSrcweir }
2125cdf0e10cSrcweir
2126cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
2127cdf0e10cSrcweir ScOutlineTable* pUndoTab = NULL;
2128cdf0e10cSrcweir SCCOLROW* pUndoRanges = NULL;
2129cdf0e10cSrcweir
2130cdf0e10cSrcweir if ( bRecord )
2131cdf0e10cSrcweir {
2132cdf0e10cSrcweir pDoc->BeginDrawUndo(); // Drawing Updates
2133cdf0e10cSrcweir
2134cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2135cdf0e10cSrcweir for (nTab=0; nTab<nTabCount; nTab++)
2136cdf0e10cSrcweir if (pMarkData->GetTableSelect(nTab))
2137cdf0e10cSrcweir {
2138cdf0e10cSrcweir if (bWidth)
2139cdf0e10cSrcweir {
2140cdf0e10cSrcweir if ( nTab == nFirstTab )
2141cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_False );
2142cdf0e10cSrcweir else
2143cdf0e10cSrcweir pUndoDoc->AddUndoTab( nTab, nTab, sal_True, sal_False );
2144cdf0e10cSrcweir pDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
2145cdf0e10cSrcweir static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE,
2146cdf0e10cSrcweir sal_False, pUndoDoc );
2147cdf0e10cSrcweir }
2148cdf0e10cSrcweir else
2149cdf0e10cSrcweir {
2150cdf0e10cSrcweir if ( nTab == nFirstTab )
2151cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_False, sal_True );
2152cdf0e10cSrcweir else
2153cdf0e10cSrcweir pUndoDoc->AddUndoTab( nTab, nTab, sal_False, sal_True );
2154cdf0e10cSrcweir pDoc->CopyToDocument( 0, nStart, nTab, MAXCOL, nEnd, nTab, IDF_NONE, sal_False, pUndoDoc );
2155cdf0e10cSrcweir }
2156cdf0e10cSrcweir }
2157cdf0e10cSrcweir
2158cdf0e10cSrcweir pUndoRanges = new SCCOLROW[ 2*nRangeCnt ];
2159cdf0e10cSrcweir memmove( pUndoRanges, pRanges, 2*nRangeCnt*sizeof(SCCOLROW) );
2160cdf0e10cSrcweir
2161cdf0e10cSrcweir //! outlines from all tables?
2162cdf0e10cSrcweir ScOutlineTable* pTable = pDoc->GetOutlineTable( nCurTab );
2163cdf0e10cSrcweir if (pTable)
2164cdf0e10cSrcweir pUndoTab = new ScOutlineTable( *pTable );
2165cdf0e10cSrcweir }
2166cdf0e10cSrcweir
2167cdf0e10cSrcweir if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
2168cdf0e10cSrcweir pMarkData->MarkToMulti();
2169cdf0e10cSrcweir
2170cdf0e10cSrcweir sal_Bool bShow = nSizeTwips > 0 || eMode != SC_SIZE_DIRECT;
2171cdf0e10cSrcweir sal_Bool bOutline = sal_False;
2172cdf0e10cSrcweir
2173cdf0e10cSrcweir for (nTab=0; nTab<nTabCount; nTab++)
2174cdf0e10cSrcweir if (pMarkData->GetTableSelect(nTab))
2175cdf0e10cSrcweir {
2176cdf0e10cSrcweir const SCCOLROW* pTabRanges = pRanges;
2177cdf0e10cSrcweir
2178cdf0e10cSrcweir pDoc->IncSizeRecalcLevel( nTab ); // nicht fuer jede Spalte einzeln
2179cdf0e10cSrcweir pDoc->InitializeNoteCaptions( nTab );
2180cdf0e10cSrcweir for (SCCOLROW nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
2181cdf0e10cSrcweir {
2182cdf0e10cSrcweir SCCOLROW nStartNo = *(pTabRanges++);
2183cdf0e10cSrcweir SCCOLROW nEndNo = *(pTabRanges++);
2184cdf0e10cSrcweir
2185cdf0e10cSrcweir if ( !bWidth ) // Hoehen immer blockweise
2186cdf0e10cSrcweir {
2187cdf0e10cSrcweir if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
2188cdf0e10cSrcweir {
2189cdf0e10cSrcweir sal_Bool bAll = ( eMode==SC_SIZE_OPTIMAL );
2190cdf0e10cSrcweir if (!bAll)
2191cdf0e10cSrcweir {
2192cdf0e10cSrcweir // fuer alle eingeblendeten CR_MANUALSIZE loeschen,
2193cdf0e10cSrcweir // dann SetOptimalHeight mit bShrink = FALSE
2194cdf0e10cSrcweir for (SCROW nRow = nStartNo; nRow <= nEndNo; ++nRow)
2195cdf0e10cSrcweir {
2196cdf0e10cSrcweir SCROW nLastRow = nRow;
2197cdf0e10cSrcweir if (pDoc->RowHidden(nRow, nTab, NULL, &nLastRow))
2198cdf0e10cSrcweir {
2199cdf0e10cSrcweir nRow = nLastRow;
2200cdf0e10cSrcweir continue;
2201cdf0e10cSrcweir }
2202cdf0e10cSrcweir
2203cdf0e10cSrcweir sal_uInt8 nOld = pDoc->GetRowFlags(nRow, nTab);
2204cdf0e10cSrcweir if (nOld & CR_MANUALSIZE)
2205cdf0e10cSrcweir pDoc->SetRowFlags(nRow, nTab, nOld & ~CR_MANUALSIZE);
2206cdf0e10cSrcweir }
2207cdf0e10cSrcweir }
2208cdf0e10cSrcweir
2209cdf0e10cSrcweir double nPPTX = GetViewData()->GetPPTX();
2210cdf0e10cSrcweir double nPPTY = GetViewData()->GetPPTY();
2211cdf0e10cSrcweir Fraction aZoomX = GetViewData()->GetZoomX();
2212cdf0e10cSrcweir Fraction aZoomY = GetViewData()->GetZoomY();
2213cdf0e10cSrcweir
2214cdf0e10cSrcweir ScSizeDeviceProvider aProv(pDocSh);
2215cdf0e10cSrcweir if (aProv.IsPrinter())
2216cdf0e10cSrcweir {
2217cdf0e10cSrcweir nPPTX = aProv.GetPPTX();
2218cdf0e10cSrcweir nPPTY = aProv.GetPPTY();
2219cdf0e10cSrcweir aZoomX = aZoomY = Fraction( 1, 1 );
2220cdf0e10cSrcweir }
2221cdf0e10cSrcweir
2222cdf0e10cSrcweir pDoc->SetOptimalHeight( nStartNo, nEndNo, nTab, nSizeTwips, aProv.GetDevice(),
2223cdf0e10cSrcweir nPPTX, nPPTY, aZoomX, aZoomY, bAll );
2224cdf0e10cSrcweir if (bAll)
2225cdf0e10cSrcweir pDoc->ShowRows( nStartNo, nEndNo, nTab, sal_True );
2226cdf0e10cSrcweir
2227cdf0e10cSrcweir // Manual-Flag wird bei bAll=sal_True schon in SetOptimalHeight gesetzt
2228cdf0e10cSrcweir // (an bei Extra-Height, sonst aus).
2229cdf0e10cSrcweir }
2230cdf0e10cSrcweir else if ( eMode==SC_SIZE_DIRECT )
2231cdf0e10cSrcweir {
2232cdf0e10cSrcweir if (nSizeTwips)
2233cdf0e10cSrcweir {
2234cdf0e10cSrcweir pDoc->SetRowHeightRange( nStartNo, nEndNo, nTab, nSizeTwips );
2235cdf0e10cSrcweir pDoc->SetManualHeight( nStartNo, nEndNo, nTab, sal_True ); // height was set manually
2236cdf0e10cSrcweir }
2237cdf0e10cSrcweir pDoc->ShowRows( nStartNo, nEndNo, nTab, nSizeTwips != 0 );
2238cdf0e10cSrcweir }
2239cdf0e10cSrcweir else if ( eMode==SC_SIZE_SHOW )
2240cdf0e10cSrcweir {
2241cdf0e10cSrcweir pDoc->ShowRows( nStartNo, nEndNo, nTab, sal_True );
2242cdf0e10cSrcweir }
2243cdf0e10cSrcweir }
2244cdf0e10cSrcweir else // Spaltenbreiten
2245cdf0e10cSrcweir {
2246cdf0e10cSrcweir for (SCCOL nCol=static_cast<SCCOL>(nStartNo); nCol<=static_cast<SCCOL>(nEndNo); nCol++)
2247cdf0e10cSrcweir {
2248cdf0e10cSrcweir if ( eMode != SC_SIZE_VISOPT || !pDoc->ColHidden(nCol, nTab) )
2249cdf0e10cSrcweir {
2250cdf0e10cSrcweir sal_uInt16 nThisSize = nSizeTwips;
2251cdf0e10cSrcweir
2252cdf0e10cSrcweir if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
2253cdf0e10cSrcweir nThisSize = nSizeTwips + GetOptimalColWidth( nCol, nTab, bFormula );
2254cdf0e10cSrcweir if ( nThisSize )
2255cdf0e10cSrcweir pDoc->SetColWidth( nCol, nTab, nThisSize );
2256cdf0e10cSrcweir
2257cdf0e10cSrcweir pDoc->ShowCol( nCol, nTab, bShow );
2258cdf0e10cSrcweir }
2259cdf0e10cSrcweir }
2260cdf0e10cSrcweir }
2261cdf0e10cSrcweir
2262cdf0e10cSrcweir // Outline anpassen
2263cdf0e10cSrcweir
2264cdf0e10cSrcweir if (bWidth)
2265cdf0e10cSrcweir {
2266cdf0e10cSrcweir if ( pDoc->UpdateOutlineCol( static_cast<SCCOL>(nStartNo),
2267cdf0e10cSrcweir static_cast<SCCOL>(nEndNo), nTab, bShow ) )
2268cdf0e10cSrcweir bOutline = sal_True;
2269cdf0e10cSrcweir }
2270cdf0e10cSrcweir else
2271cdf0e10cSrcweir {
2272cdf0e10cSrcweir if ( pDoc->UpdateOutlineRow( nStartNo, nEndNo, nTab, bShow ) )
2273cdf0e10cSrcweir bOutline = sal_True;
2274cdf0e10cSrcweir }
2275cdf0e10cSrcweir }
2276cdf0e10cSrcweir pDoc->DecSizeRecalcLevel( nTab ); // nicht fuer jede Spalte einzeln
2277cdf0e10cSrcweir }
2278cdf0e10cSrcweir
2279cdf0e10cSrcweir
2280cdf0e10cSrcweir if (!bOutline)
2281cdf0e10cSrcweir DELETEZ(pUndoTab);
2282cdf0e10cSrcweir
2283cdf0e10cSrcweir if (bRecord)
2284cdf0e10cSrcweir {
2285cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
2286cdf0e10cSrcweir new ScUndoWidthOrHeight( pDocSh, *pMarkData,
2287cdf0e10cSrcweir nStart, nCurTab, nEnd, nCurTab,
2288cdf0e10cSrcweir pUndoDoc, nRangeCnt, pUndoRanges,
2289cdf0e10cSrcweir pUndoTab, eMode, nSizeTwips, bWidth ) );
2290cdf0e10cSrcweir }
2291cdf0e10cSrcweir
2292cdf0e10cSrcweir for (nTab=0; nTab<nTabCount; nTab++)
2293cdf0e10cSrcweir if (pMarkData->GetTableSelect(nTab))
2294cdf0e10cSrcweir pDoc->UpdatePageBreaks( nTab );
2295cdf0e10cSrcweir
2296cdf0e10cSrcweir GetViewData()->GetView()->UpdateScrollBars();
2297cdf0e10cSrcweir
2298cdf0e10cSrcweir if (bPaint)
2299cdf0e10cSrcweir {
2300cdf0e10cSrcweir HideCursor();
2301cdf0e10cSrcweir
2302cdf0e10cSrcweir for (nTab=0; nTab<nTabCount; nTab++)
2303cdf0e10cSrcweir if (pMarkData->GetTableSelect(nTab))
2304cdf0e10cSrcweir {
2305cdf0e10cSrcweir if (bWidth)
2306cdf0e10cSrcweir {
2307cdf0e10cSrcweir if (pDoc->HasAttrib( static_cast<SCCOL>(nStart),0,nTab,
2308cdf0e10cSrcweir static_cast<SCCOL>(nEnd),MAXROW,nTab,
2309cdf0e10cSrcweir HASATTR_MERGED | HASATTR_OVERLAPPED ))
2310cdf0e10cSrcweir nStart = 0;
2311cdf0e10cSrcweir if (nStart > 0) // weiter oben anfangen wegen Linien und Cursor
2312cdf0e10cSrcweir --nStart;
2313cdf0e10cSrcweir pDocSh->PostPaint( static_cast<SCCOL>(nStart), 0, nTab,
2314cdf0e10cSrcweir MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_TOP );
2315cdf0e10cSrcweir }
2316cdf0e10cSrcweir else
2317cdf0e10cSrcweir {
2318cdf0e10cSrcweir if (pDoc->HasAttrib( 0,nStart,nTab, MAXCOL,nEnd,nTab, HASATTR_MERGED | HASATTR_OVERLAPPED ))
2319cdf0e10cSrcweir nStart = 0;
2320cdf0e10cSrcweir if (nStart != 0)
2321cdf0e10cSrcweir --nStart;
2322cdf0e10cSrcweir pDocSh->PostPaint( 0, nStart, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID | PAINT_LEFT );
2323cdf0e10cSrcweir }
2324cdf0e10cSrcweir }
2325cdf0e10cSrcweir
2326cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
2327cdf0e10cSrcweir aModificator.SetDocumentModified();
2328cdf0e10cSrcweir
2329cdf0e10cSrcweir ShowCursor();
2330cdf0e10cSrcweir }
2331cdf0e10cSrcweir
2332cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
2333cdf0e10cSrcweir if ( bWidth )
2334cdf0e10cSrcweir {
2335cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
2336cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
2337cdf0e10cSrcweir {
2338cdf0e10cSrcweir ScRangeList aChangeRanges;
2339cdf0e10cSrcweir for ( nTab = 0; nTab < nTabCount; ++nTab )
2340cdf0e10cSrcweir {
2341cdf0e10cSrcweir if ( pMarkData->GetTableSelect( nTab ) )
2342cdf0e10cSrcweir {
2343cdf0e10cSrcweir const SCCOLROW* pTabRanges = pRanges;
2344cdf0e10cSrcweir for ( SCCOLROW nRange = 0; nRange < nRangeCnt; ++nRange )
2345cdf0e10cSrcweir {
2346cdf0e10cSrcweir SCCOL nStartCol = static_cast< SCCOL >( *(pTabRanges++) );
2347cdf0e10cSrcweir SCCOL nEndCol = static_cast< SCCOL >( *(pTabRanges++) );
2348cdf0e10cSrcweir for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol )
2349cdf0e10cSrcweir {
2350cdf0e10cSrcweir aChangeRanges.Append( ScRange( nCol, 0, nTab ) );
2351cdf0e10cSrcweir }
2352cdf0e10cSrcweir }
2353cdf0e10cSrcweir }
2354cdf0e10cSrcweir }
2355cdf0e10cSrcweir pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "column-resize" ) ), aChangeRanges );
2356cdf0e10cSrcweir }
2357cdf0e10cSrcweir }
2358cdf0e10cSrcweir }
2359cdf0e10cSrcweir
2360cdf0e10cSrcweir // Spaltenbreiten/Zeilenhoehen (ueber Blockmarken)
2361cdf0e10cSrcweir
SetMarkedWidthOrHeight(sal_Bool bWidth,ScSizeMode eMode,sal_uInt16 nSizeTwips,sal_Bool bRecord,sal_Bool bPaint)2362cdf0e10cSrcweir void ScViewFunc::SetMarkedWidthOrHeight( sal_Bool bWidth, ScSizeMode eMode, sal_uInt16 nSizeTwips,
2363cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bPaint )
2364cdf0e10cSrcweir {
2365cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
2366cdf0e10cSrcweir
2367cdf0e10cSrcweir rMark.MarkToMulti();
2368cdf0e10cSrcweir if (!rMark.IsMultiMarked())
2369cdf0e10cSrcweir {
2370cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
2371cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
2372cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
2373cdf0e10cSrcweir DoneBlockMode();
2374cdf0e10cSrcweir InitOwnBlockMode();
2375cdf0e10cSrcweir rMark.SetMultiMarkArea( ScRange( nCol,nRow,nTab ), sal_True );
2376cdf0e10cSrcweir MarkDataChanged();
2377cdf0e10cSrcweir }
2378cdf0e10cSrcweir
2379cdf0e10cSrcweir SCCOLROW* pRanges = new SCCOLROW[MAXCOLROWCOUNT];
2380cdf0e10cSrcweir SCCOLROW nRangeCnt = 0;
2381cdf0e10cSrcweir
2382cdf0e10cSrcweir if ( bWidth )
2383cdf0e10cSrcweir nRangeCnt = rMark.GetMarkColumnRanges( pRanges );
2384cdf0e10cSrcweir else
2385cdf0e10cSrcweir nRangeCnt = rMark.GetMarkRowRanges( pRanges );
2386cdf0e10cSrcweir
2387cdf0e10cSrcweir SetWidthOrHeight( bWidth, nRangeCnt, pRanges, eMode, nSizeTwips, bRecord, bPaint );
2388cdf0e10cSrcweir
2389cdf0e10cSrcweir delete[] pRanges;
2390cdf0e10cSrcweir rMark.MarkToSimple();
2391cdf0e10cSrcweir }
2392cdf0e10cSrcweir
ModifyCellSize(ScDirection eDir,sal_Bool bOptimal)2393cdf0e10cSrcweir void ScViewFunc::ModifyCellSize( ScDirection eDir, sal_Bool bOptimal )
2394cdf0e10cSrcweir {
2395cdf0e10cSrcweir //! Schrittweiten einstellbar
2396cdf0e10cSrcweir // Schrittweite ist auch Minimum
2397cdf0e10cSrcweir sal_uInt16 nStepX = STD_COL_WIDTH / 5;
2398cdf0e10cSrcweir sal_uInt16 nStepY = ScGlobal::nStdRowHeight;
2399cdf0e10cSrcweir
2400cdf0e10cSrcweir ScModule* pScMod = SC_MOD();
2401cdf0e10cSrcweir sal_Bool bAnyEdit = pScMod->IsInputMode();
2402cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
2403cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
2404cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
2405cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2406cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2407cdf0e10cSrcweir
2408cdf0e10cSrcweir sal_Bool bAllowed, bOnlyMatrix;
2409cdf0e10cSrcweir if ( eDir == DIR_LEFT || eDir == DIR_RIGHT )
2410cdf0e10cSrcweir bAllowed = pDoc->IsBlockEditable( nTab, nCol,0, nCol,MAXROW, &bOnlyMatrix );
2411cdf0e10cSrcweir else
2412cdf0e10cSrcweir bAllowed = pDoc->IsBlockEditable( nTab, 0,nRow, MAXCOL,nRow, &bOnlyMatrix );
2413cdf0e10cSrcweir if ( !bAllowed && !bOnlyMatrix )
2414cdf0e10cSrcweir {
2415cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
2416cdf0e10cSrcweir return;
2417cdf0e10cSrcweir }
2418cdf0e10cSrcweir
2419cdf0e10cSrcweir HideAllCursors();
2420cdf0e10cSrcweir
2421cdf0e10cSrcweir sal_uInt16 nWidth = pDoc->GetColWidth( nCol, nTab );
2422cdf0e10cSrcweir sal_uInt16 nHeight = pDoc->GetRowHeight( nRow, nTab );
2423cdf0e10cSrcweir SCCOLROW nRange[2];
2424cdf0e10cSrcweir if ( eDir == DIR_LEFT || eDir == DIR_RIGHT )
2425cdf0e10cSrcweir {
2426cdf0e10cSrcweir if (bOptimal) // Breite dieser einen Zelle
2427cdf0e10cSrcweir {
2428cdf0e10cSrcweir if ( bAnyEdit )
2429cdf0e10cSrcweir {
2430cdf0e10cSrcweir // beim Editieren die aktuelle Breite der Eingabe
2431cdf0e10cSrcweir ScInputHandler* pHdl = pScMod->GetInputHdl( GetViewData()->GetViewShell() );
2432cdf0e10cSrcweir if (pHdl)
2433cdf0e10cSrcweir {
2434cdf0e10cSrcweir long nEdit = pHdl->GetTextSize().Width(); // in 1/100mm
2435cdf0e10cSrcweir
2436cdf0e10cSrcweir const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, nTab );
2437cdf0e10cSrcweir const SvxMarginItem& rMItem =
2438cdf0e10cSrcweir (const SvxMarginItem&)pPattern->GetItem(ATTR_MARGIN);
2439cdf0e10cSrcweir sal_uInt16 nMargin = rMItem.GetLeftMargin() + rMItem.GetRightMargin();
2440cdf0e10cSrcweir if ( ((const SvxHorJustifyItem&) pPattern->
2441cdf0e10cSrcweir GetItem( ATTR_HOR_JUSTIFY )).GetValue() == SVX_HOR_JUSTIFY_LEFT )
2442cdf0e10cSrcweir nMargin = sal::static_int_cast<sal_uInt16>(
2443cdf0e10cSrcweir nMargin + ((const SfxUInt16Item&)pPattern->GetItem(ATTR_INDENT)).GetValue() );
2444cdf0e10cSrcweir
2445cdf0e10cSrcweir nWidth = (sal_uInt16)(nEdit * pDocSh->GetOutputFactor() / HMM_PER_TWIPS)
2446cdf0e10cSrcweir + nMargin + STD_EXTRA_WIDTH;
2447cdf0e10cSrcweir }
2448cdf0e10cSrcweir }
2449cdf0e10cSrcweir else
2450cdf0e10cSrcweir {
2451cdf0e10cSrcweir double nPPTX = GetViewData()->GetPPTX();
2452cdf0e10cSrcweir double nPPTY = GetViewData()->GetPPTY();
2453cdf0e10cSrcweir Fraction aZoomX = GetViewData()->GetZoomX();
2454cdf0e10cSrcweir Fraction aZoomY = GetViewData()->GetZoomY();
2455cdf0e10cSrcweir
2456cdf0e10cSrcweir ScSizeDeviceProvider aProv(pDocSh);
2457cdf0e10cSrcweir if (aProv.IsPrinter())
2458cdf0e10cSrcweir {
2459cdf0e10cSrcweir nPPTX = aProv.GetPPTX();
2460cdf0e10cSrcweir nPPTY = aProv.GetPPTY();
2461cdf0e10cSrcweir aZoomX = aZoomY = Fraction( 1, 1 );
2462cdf0e10cSrcweir }
2463cdf0e10cSrcweir
2464cdf0e10cSrcweir long nPixel = pDoc->GetNeededSize( nCol, nRow, nTab, aProv.GetDevice(),
2465cdf0e10cSrcweir nPPTX, nPPTY, aZoomX, aZoomY, sal_True );
2466cdf0e10cSrcweir sal_uInt16 nTwips = (sal_uInt16)( nPixel / nPPTX );
2467cdf0e10cSrcweir if (nTwips != 0)
2468cdf0e10cSrcweir nWidth = nTwips + STD_EXTRA_WIDTH;
2469cdf0e10cSrcweir else
2470cdf0e10cSrcweir nWidth = STD_COL_WIDTH;
2471cdf0e10cSrcweir }
2472cdf0e10cSrcweir }
2473cdf0e10cSrcweir else // vergroessern / verkleinern
2474cdf0e10cSrcweir {
2475cdf0e10cSrcweir if ( eDir == DIR_RIGHT )
2476cdf0e10cSrcweir nWidth = sal::static_int_cast<sal_uInt16>( nWidth + nStepX );
2477cdf0e10cSrcweir else if ( nWidth > nStepX )
2478cdf0e10cSrcweir nWidth = sal::static_int_cast<sal_uInt16>( nWidth - nStepX );
2479cdf0e10cSrcweir if ( nWidth < nStepX ) nWidth = nStepX;
2480cdf0e10cSrcweir if ( nWidth > MAX_COL_WIDTH ) nWidth = MAX_COL_WIDTH;
2481cdf0e10cSrcweir }
2482cdf0e10cSrcweir nRange[0] = nRange[1] = nCol;
2483cdf0e10cSrcweir SetWidthOrHeight( sal_True, 1, nRange, SC_SIZE_DIRECT, nWidth );
2484cdf0e10cSrcweir
2485cdf0e10cSrcweir // hier bei Breite auch Hoehe anpassen (nur die eine Zeile)
2486cdf0e10cSrcweir
2487cdf0e10cSrcweir if (!bAnyEdit)
2488cdf0e10cSrcweir {
2489cdf0e10cSrcweir const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, nTab );
2490cdf0e10cSrcweir sal_Bool bNeedHeight =
2491cdf0e10cSrcweir ((const SfxBoolItem&)pPattern->GetItem( ATTR_LINEBREAK )).GetValue() ||
2492cdf0e10cSrcweir ((const SvxHorJustifyItem&)pPattern->
2493cdf0e10cSrcweir GetItem( ATTR_HOR_JUSTIFY )).GetValue() == SVX_HOR_JUSTIFY_BLOCK;
2494cdf0e10cSrcweir if (bNeedHeight)
2495cdf0e10cSrcweir AdjustRowHeight( nRow, nRow );
2496cdf0e10cSrcweir }
2497cdf0e10cSrcweir }
2498cdf0e10cSrcweir else
2499cdf0e10cSrcweir {
2500cdf0e10cSrcweir ScSizeMode eMode;
2501cdf0e10cSrcweir if (bOptimal)
2502cdf0e10cSrcweir {
2503cdf0e10cSrcweir eMode = SC_SIZE_OPTIMAL;
2504cdf0e10cSrcweir nHeight = 0;
2505cdf0e10cSrcweir }
2506cdf0e10cSrcweir else
2507cdf0e10cSrcweir {
2508cdf0e10cSrcweir eMode = SC_SIZE_DIRECT;
2509cdf0e10cSrcweir if ( eDir == DIR_BOTTOM )
2510cdf0e10cSrcweir nHeight = sal::static_int_cast<sal_uInt16>( nHeight + nStepY );
2511cdf0e10cSrcweir else if ( nHeight > nStepY )
2512cdf0e10cSrcweir nHeight = sal::static_int_cast<sal_uInt16>( nHeight - nStepY );
2513cdf0e10cSrcweir if ( nHeight < nStepY ) nHeight = nStepY;
2514cdf0e10cSrcweir if ( nHeight > MAX_COL_HEIGHT ) nHeight = MAX_COL_HEIGHT;
2515cdf0e10cSrcweir //! MAX_COL_HEIGHT umbenennen in MAX_ROW_HEIGHT in global.hxx !!!!!!
2516cdf0e10cSrcweir }
2517cdf0e10cSrcweir nRange[0] = nRange[1] = nRow;
2518cdf0e10cSrcweir SetWidthOrHeight( sal_False, 1, nRange, eMode, nHeight );
2519cdf0e10cSrcweir }
2520cdf0e10cSrcweir
2521cdf0e10cSrcweir if ( bAnyEdit )
2522cdf0e10cSrcweir {
2523cdf0e10cSrcweir UpdateEditView();
2524cdf0e10cSrcweir if ( pDoc->HasAttrib( nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_NEEDHEIGHT ) )
2525cdf0e10cSrcweir {
2526cdf0e10cSrcweir ScInputHandler* pHdl = pScMod->GetInputHdl( GetViewData()->GetViewShell() );
2527cdf0e10cSrcweir if (pHdl)
2528cdf0e10cSrcweir pHdl->SetModified(); // damit bei Enter die Hoehe angepasst wird
2529cdf0e10cSrcweir }
2530cdf0e10cSrcweir }
2531cdf0e10cSrcweir
2532cdf0e10cSrcweir ShowAllCursors();
2533cdf0e10cSrcweir }
2534cdf0e10cSrcweir
ProtectSheet(SCTAB nTab,const ScTableProtection & rProtect)2535cdf0e10cSrcweir void ScViewFunc::ProtectSheet( SCTAB nTab, const ScTableProtection& rProtect )
2536cdf0e10cSrcweir {
2537cdf0e10cSrcweir if (nTab == TABLEID_DOC)
2538cdf0e10cSrcweir return;
2539cdf0e10cSrcweir
2540cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
2541cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2542cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2543cdf0e10cSrcweir ScDocFunc aFunc(*pDocSh);
2544cdf0e10cSrcweir bool bUndo(pDoc->IsUndoEnabled());
2545cdf0e10cSrcweir
2546cdf0e10cSrcweir // modifying several tables is handled here
2547cdf0e10cSrcweir
2548cdf0e10cSrcweir if (bUndo)
2549cdf0e10cSrcweir {
2550cdf0e10cSrcweir String aUndo = ScGlobal::GetRscString( STR_UNDO_PROTECT_TAB );
2551cdf0e10cSrcweir pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
2552cdf0e10cSrcweir }
2553cdf0e10cSrcweir
2554cdf0e10cSrcweir SCTAB nCount = pDocSh->GetDocument()->GetTableCount();
2555cdf0e10cSrcweir for ( SCTAB i=0; i<nCount; i++ )
2556cdf0e10cSrcweir if ( rMark.GetTableSelect(i) )
2557cdf0e10cSrcweir aFunc.ProtectSheet(i, rProtect);
2558cdf0e10cSrcweir
2559cdf0e10cSrcweir if (bUndo)
2560cdf0e10cSrcweir pDocSh->GetUndoManager()->LeaveListAction();
2561cdf0e10cSrcweir
2562cdf0e10cSrcweir UpdateLayerLocks(); //! broadcast to all views
2563cdf0e10cSrcweir }
2564cdf0e10cSrcweir
Protect(SCTAB nTab,const String & rPassword)2565cdf0e10cSrcweir void ScViewFunc::Protect( SCTAB nTab, const String& rPassword )
2566cdf0e10cSrcweir {
2567cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
2568cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2569cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2570cdf0e10cSrcweir ScDocFunc aFunc(*pDocSh);
2571cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
2572cdf0e10cSrcweir
2573cdf0e10cSrcweir if ( nTab == TABLEID_DOC || rMark.GetSelectCount() <= 1 )
2574cdf0e10cSrcweir aFunc.Protect( nTab, rPassword, sal_False );
2575cdf0e10cSrcweir else
2576cdf0e10cSrcweir {
2577cdf0e10cSrcweir // modifying several tables is handled here
2578cdf0e10cSrcweir
2579cdf0e10cSrcweir if (bUndo)
2580cdf0e10cSrcweir {
2581cdf0e10cSrcweir String aUndo = ScGlobal::GetRscString( STR_UNDO_PROTECT_TAB );
2582cdf0e10cSrcweir pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
2583cdf0e10cSrcweir }
2584cdf0e10cSrcweir
2585cdf0e10cSrcweir SCTAB nCount = pDocSh->GetDocument()->GetTableCount();
2586cdf0e10cSrcweir for ( SCTAB i=0; i<nCount; i++ )
2587cdf0e10cSrcweir if ( rMark.GetTableSelect(i) )
2588cdf0e10cSrcweir aFunc.Protect( i, rPassword, sal_False );
2589cdf0e10cSrcweir
2590cdf0e10cSrcweir if (bUndo)
2591cdf0e10cSrcweir pDocSh->GetUndoManager()->LeaveListAction();
2592cdf0e10cSrcweir }
2593cdf0e10cSrcweir
2594cdf0e10cSrcweir UpdateLayerLocks(); //! broadcast to all views
2595cdf0e10cSrcweir }
2596cdf0e10cSrcweir
Unprotect(SCTAB nTab,const String & rPassword)2597cdf0e10cSrcweir sal_Bool ScViewFunc::Unprotect( SCTAB nTab, const String& rPassword )
2598cdf0e10cSrcweir {
2599cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
2600cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2601cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2602cdf0e10cSrcweir ScDocFunc aFunc(*pDocSh);
2603cdf0e10cSrcweir sal_Bool bChanged = sal_False;
2604cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
2605cdf0e10cSrcweir
2606cdf0e10cSrcweir if ( nTab == TABLEID_DOC || rMark.GetSelectCount() <= 1 )
2607cdf0e10cSrcweir bChanged = aFunc.Unprotect( nTab, rPassword, sal_False );
2608cdf0e10cSrcweir else
2609cdf0e10cSrcweir {
2610cdf0e10cSrcweir // modifying several tables is handled here
2611cdf0e10cSrcweir
2612cdf0e10cSrcweir if (bUndo)
2613cdf0e10cSrcweir {
2614cdf0e10cSrcweir String aUndo = ScGlobal::GetRscString( STR_UNDO_UNPROTECT_TAB );
2615cdf0e10cSrcweir pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
2616cdf0e10cSrcweir }
2617cdf0e10cSrcweir
2618cdf0e10cSrcweir SCTAB nCount = pDocSh->GetDocument()->GetTableCount();
2619cdf0e10cSrcweir for ( SCTAB i=0; i<nCount; i++ )
2620cdf0e10cSrcweir if ( rMark.GetTableSelect(i) )
2621cdf0e10cSrcweir if ( aFunc.Unprotect( i, rPassword, sal_False ) )
2622cdf0e10cSrcweir bChanged = sal_True;
2623cdf0e10cSrcweir
2624cdf0e10cSrcweir if (bUndo)
2625cdf0e10cSrcweir pDocSh->GetUndoManager()->LeaveListAction();
2626cdf0e10cSrcweir }
2627cdf0e10cSrcweir
2628cdf0e10cSrcweir if (bChanged)
2629cdf0e10cSrcweir UpdateLayerLocks(); //! broadcast to all views
2630cdf0e10cSrcweir
2631cdf0e10cSrcweir return bChanged;
2632cdf0e10cSrcweir }
2633cdf0e10cSrcweir
SetNoteText(const ScAddress & rPos,const String & rNoteText)2634cdf0e10cSrcweir void ScViewFunc::SetNoteText( const ScAddress& rPos, const String& rNoteText )
2635cdf0e10cSrcweir {
2636cdf0e10cSrcweir GetViewData()->GetDocShell()->GetDocFunc().SetNoteText( rPos, rNoteText, sal_False );
2637cdf0e10cSrcweir }
2638cdf0e10cSrcweir
ReplaceNote(const ScAddress & rPos,const String & rNoteText,const String * pAuthor,const String * pDate)2639cdf0e10cSrcweir void ScViewFunc::ReplaceNote( const ScAddress& rPos, const String& rNoteText, const String* pAuthor, const String* pDate )
2640cdf0e10cSrcweir {
2641cdf0e10cSrcweir GetViewData()->GetDocShell()->GetDocFunc().ReplaceNote( rPos, rNoteText, pAuthor, pDate, sal_False );
2642cdf0e10cSrcweir }
2643cdf0e10cSrcweir
SetNumberFormat(short nFormatType,sal_uLong nAdd)2644cdf0e10cSrcweir void ScViewFunc::SetNumberFormat( short nFormatType, sal_uLong nAdd )
2645cdf0e10cSrcweir {
2646cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
2647cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
2648cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
2649cdf0e10cSrcweir {
2650cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
2651cdf0e10cSrcweir return;
2652cdf0e10cSrcweir }
2653cdf0e10cSrcweir
2654cdf0e10cSrcweir sal_uInt32 nNumberFormat = 0;
2655cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
2656cdf0e10cSrcweir ScDocument* pDoc = pViewData->GetDocument();
2657cdf0e10cSrcweir SvNumberFormatter* pNumberFormatter = pDoc->GetFormatTable();
2658cdf0e10cSrcweir LanguageType eLanguage = ScGlobal::eLnge;
2659cdf0e10cSrcweir ScPatternAttr aNewAttrs( pDoc->GetPool() );
2660cdf0e10cSrcweir
2661cdf0e10cSrcweir // #67936# always take language from cursor position, even if there is a selection
2662cdf0e10cSrcweir
2663cdf0e10cSrcweir sal_uInt32 nCurrentNumberFormat;
2664cdf0e10cSrcweir pDoc->GetNumberFormat( pViewData->GetCurX(),
2665cdf0e10cSrcweir pViewData->GetCurY(),
2666cdf0e10cSrcweir pViewData->GetTabNo(),
2667cdf0e10cSrcweir nCurrentNumberFormat );
2668cdf0e10cSrcweir const SvNumberformat* pEntry = pNumberFormatter->GetEntry( nCurrentNumberFormat );
2669cdf0e10cSrcweir if (pEntry)
2670cdf0e10cSrcweir eLanguage = pEntry->GetLanguage(); // sonst ScGlobal::eLnge behalten
2671cdf0e10cSrcweir
2672cdf0e10cSrcweir nNumberFormat = pNumberFormatter->GetStandardFormat( nFormatType, eLanguage ) + nAdd;
2673cdf0e10cSrcweir
2674cdf0e10cSrcweir SfxItemSet& rSet = aNewAttrs.GetItemSet();
2675cdf0e10cSrcweir rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumberFormat ) );
2676cdf0e10cSrcweir // ATTR_LANGUAGE_FORMAT nicht
2677cdf0e10cSrcweir ApplySelectionPattern( aNewAttrs, sal_True );
2678cdf0e10cSrcweir }
2679cdf0e10cSrcweir
SetNumFmtByStr(const String & rCode)2680cdf0e10cSrcweir void ScViewFunc::SetNumFmtByStr( const String& rCode )
2681cdf0e10cSrcweir {
2682cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
2683cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
2684cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
2685cdf0e10cSrcweir {
2686cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
2687cdf0e10cSrcweir return;
2688cdf0e10cSrcweir }
2689cdf0e10cSrcweir
2690cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
2691cdf0e10cSrcweir ScDocument* pDoc = pViewData->GetDocument();
2692cdf0e10cSrcweir SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2693cdf0e10cSrcweir
2694cdf0e10cSrcweir // Sprache immer von Cursorposition
2695cdf0e10cSrcweir
2696cdf0e10cSrcweir sal_uInt32 nCurrentNumberFormat;
2697cdf0e10cSrcweir pDoc->GetNumberFormat( pViewData->GetCurX(), pViewData->GetCurY(),
2698cdf0e10cSrcweir pViewData->GetTabNo(), nCurrentNumberFormat );
2699cdf0e10cSrcweir const SvNumberformat* pEntry = pFormatter->GetEntry( nCurrentNumberFormat );
2700cdf0e10cSrcweir LanguageType eLanguage = pEntry ? pEntry->GetLanguage() : ScGlobal::eLnge;
2701cdf0e10cSrcweir
2702cdf0e10cSrcweir // Index fuer String bestimmen
2703cdf0e10cSrcweir
2704cdf0e10cSrcweir sal_Bool bOk = sal_True;
2705cdf0e10cSrcweir sal_uInt32 nNumberFormat = pFormatter->GetEntryKey( rCode, eLanguage );
2706cdf0e10cSrcweir if ( nNumberFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
2707cdf0e10cSrcweir {
2708cdf0e10cSrcweir // neu eintragen
2709cdf0e10cSrcweir
2710cdf0e10cSrcweir String aFormat = rCode; // wird veraendert
2711cdf0e10cSrcweir xub_StrLen nErrPos = 0;
2712cdf0e10cSrcweir short nType = 0; //! ???
2713cdf0e10cSrcweir bOk = pFormatter->PutEntry( aFormat, nErrPos, nType, nNumberFormat, eLanguage );
2714cdf0e10cSrcweir }
2715cdf0e10cSrcweir
2716cdf0e10cSrcweir if ( bOk ) // gueltiges Format?
2717cdf0e10cSrcweir {
2718cdf0e10cSrcweir ScPatternAttr aNewAttrs( pDoc->GetPool() );
2719cdf0e10cSrcweir SfxItemSet& rSet = aNewAttrs.GetItemSet();
2720cdf0e10cSrcweir rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumberFormat ) );
2721cdf0e10cSrcweir rSet.Put( SvxLanguageItem( eLanguage, ATTR_LANGUAGE_FORMAT ) );
2722cdf0e10cSrcweir ApplySelectionPattern( aNewAttrs, sal_True );
2723cdf0e10cSrcweir }
2724cdf0e10cSrcweir
2725cdf0e10cSrcweir //! sonst Fehler zuerueckgeben / Meldung ausgeben ???
2726cdf0e10cSrcweir }
2727cdf0e10cSrcweir
ChangeNumFmtDecimals(sal_Bool bIncrement)2728cdf0e10cSrcweir void ScViewFunc::ChangeNumFmtDecimals( sal_Bool bIncrement )
2729cdf0e10cSrcweir {
2730cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
2731cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
2732cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
2733cdf0e10cSrcweir {
2734cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
2735cdf0e10cSrcweir return;
2736cdf0e10cSrcweir }
2737cdf0e10cSrcweir
2738cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
2739cdf0e10cSrcweir SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2740cdf0e10cSrcweir
2741cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
2742cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
2743cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
2744cdf0e10cSrcweir
2745cdf0e10cSrcweir sal_uInt32 nOldFormat;
2746cdf0e10cSrcweir pDoc->GetNumberFormat( nCol, nRow, nTab, nOldFormat );
2747cdf0e10cSrcweir const SvNumberformat* pOldEntry = pFormatter->GetEntry( nOldFormat );
2748cdf0e10cSrcweir if (!pOldEntry)
2749cdf0e10cSrcweir {
2750cdf0e10cSrcweir DBG_ERROR("Zahlformat nicht gefunden !!!");
2751cdf0e10cSrcweir return;
2752cdf0e10cSrcweir }
2753cdf0e10cSrcweir
2754cdf0e10cSrcweir // was haben wir denn da?
2755cdf0e10cSrcweir
2756cdf0e10cSrcweir sal_uInt32 nNewFormat = nOldFormat;
2757cdf0e10cSrcweir sal_Bool bError = sal_False;
2758cdf0e10cSrcweir
2759cdf0e10cSrcweir LanguageType eLanguage = pOldEntry->GetLanguage();
2760cdf0e10cSrcweir sal_Bool bThousand, bNegRed;
2761cdf0e10cSrcweir sal_uInt16 nPrecision, nLeading;
2762cdf0e10cSrcweir pOldEntry->GetFormatSpecialInfo( bThousand, bNegRed, nPrecision, nLeading );
2763cdf0e10cSrcweir
2764cdf0e10cSrcweir short nOldType = pOldEntry->GetType();
2765cdf0e10cSrcweir if ( 0 == ( nOldType & (
2766cdf0e10cSrcweir NUMBERFORMAT_NUMBER | NUMBERFORMAT_CURRENCY | NUMBERFORMAT_PERCENT ) ) )
2767cdf0e10cSrcweir {
2768cdf0e10cSrcweir // Datum, Zeit, Bruch, logisch, Text kann nicht angepasst werden
2769cdf0e10cSrcweir //! bei Wisssenschaftlich kann es der Numberformatter auch nicht
2770cdf0e10cSrcweir bError = sal_True;
2771cdf0e10cSrcweir }
2772cdf0e10cSrcweir
2773cdf0e10cSrcweir //! Das SvNumberformat hat einen Member bStandard, verraet ihn aber nicht
2774cdf0e10cSrcweir sal_Bool bWasStandard = ( nOldFormat == pFormatter->GetStandardIndex( eLanguage ) );
2775cdf0e10cSrcweir if (bWasStandard)
2776cdf0e10cSrcweir {
2777cdf0e10cSrcweir // bei "Standard" die Nachkommastellen abhaengig vom Zellinhalt
2778cdf0e10cSrcweir // 0 bei leer oder Text -> keine Nachkommastellen
2779cdf0e10cSrcweir double nVal = pDoc->GetValue( ScAddress( nCol, nRow, nTab ) );
2780cdf0e10cSrcweir
2781cdf0e10cSrcweir // Die Wege des Numberformatters sind unergruendlich, darum ausprobieren:
2782cdf0e10cSrcweir String aOut;
2783cdf0e10cSrcweir Color* pCol;
2784cdf0e10cSrcweir ((SvNumberformat*)pOldEntry)->GetOutputString( nVal, aOut, &pCol );
2785cdf0e10cSrcweir
2786cdf0e10cSrcweir nPrecision = 0;
2787cdf0e10cSrcweir // 'E' fuer Exponential ist fest im Numberformatter
2788cdf0e10cSrcweir if ( aOut.Search('E') != STRING_NOTFOUND )
2789cdf0e10cSrcweir bError = sal_True; // Exponential nicht veraendern
2790cdf0e10cSrcweir else
2791cdf0e10cSrcweir {
2792cdf0e10cSrcweir String aDecSep( pFormatter->GetFormatDecimalSep( nOldFormat ) );
2793cdf0e10cSrcweir xub_StrLen nPos = aOut.Search( aDecSep );
2794cdf0e10cSrcweir if ( nPos != STRING_NOTFOUND )
2795cdf0e10cSrcweir nPrecision = aOut.Len() - nPos - aDecSep.Len();
2796cdf0e10cSrcweir // sonst 0 behalten
2797cdf0e10cSrcweir }
2798cdf0e10cSrcweir }
2799cdf0e10cSrcweir
2800cdf0e10cSrcweir if (!bError)
2801cdf0e10cSrcweir {
2802cdf0e10cSrcweir if (bIncrement)
2803cdf0e10cSrcweir {
2804cdf0e10cSrcweir if (nPrecision<20)
2805cdf0e10cSrcweir ++nPrecision; // erhoehen
2806cdf0e10cSrcweir else
2807cdf0e10cSrcweir bError = sal_True; // 20 ist Maximum
2808cdf0e10cSrcweir }
2809cdf0e10cSrcweir else
2810cdf0e10cSrcweir {
2811cdf0e10cSrcweir if (nPrecision)
2812cdf0e10cSrcweir --nPrecision; // vermindern
2813cdf0e10cSrcweir else
2814cdf0e10cSrcweir bError = sal_True; // weniger als 0 geht nicht
2815cdf0e10cSrcweir }
2816cdf0e10cSrcweir }
2817cdf0e10cSrcweir
2818cdf0e10cSrcweir if (!bError)
2819cdf0e10cSrcweir {
2820cdf0e10cSrcweir String aNewPicture;
2821cdf0e10cSrcweir pFormatter->GenerateFormat( aNewPicture, nOldFormat, eLanguage,
2822cdf0e10cSrcweir bThousand, bNegRed, nPrecision, nLeading );
2823cdf0e10cSrcweir
2824cdf0e10cSrcweir nNewFormat = pFormatter->GetEntryKey( aNewPicture, eLanguage );
2825cdf0e10cSrcweir if ( nNewFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
2826cdf0e10cSrcweir {
2827cdf0e10cSrcweir xub_StrLen nErrPos = 0;
2828cdf0e10cSrcweir short nNewType = 0;
2829cdf0e10cSrcweir sal_Bool bOk = pFormatter->PutEntry( aNewPicture, nErrPos,
2830cdf0e10cSrcweir nNewType, nNewFormat, eLanguage );
2831cdf0e10cSrcweir DBG_ASSERT( bOk, "falsches Zahlformat generiert" );
2832cdf0e10cSrcweir if (!bOk)
2833cdf0e10cSrcweir bError = sal_True;
2834cdf0e10cSrcweir }
2835cdf0e10cSrcweir }
2836cdf0e10cSrcweir
2837cdf0e10cSrcweir if (!bError)
2838cdf0e10cSrcweir {
2839cdf0e10cSrcweir ScPatternAttr aNewAttrs( pDoc->GetPool() );
2840cdf0e10cSrcweir SfxItemSet& rSet = aNewAttrs.GetItemSet();
2841cdf0e10cSrcweir rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
2842cdf0e10cSrcweir // ATTR_LANGUAGE_FORMAT nicht
2843cdf0e10cSrcweir ApplySelectionPattern( aNewAttrs, sal_True );
2844cdf0e10cSrcweir }
2845cdf0e10cSrcweir else
2846cdf0e10cSrcweir Sound::Beep(); // war nix
2847cdf0e10cSrcweir }
2848cdf0e10cSrcweir
ChangeIndent(sal_Bool bIncrement)2849cdf0e10cSrcweir void ScViewFunc::ChangeIndent( sal_Bool bIncrement )
2850cdf0e10cSrcweir {
2851cdf0e10cSrcweir ScViewData* pViewData = GetViewData();
2852cdf0e10cSrcweir ScDocShell* pDocSh = pViewData->GetDocShell();
2853cdf0e10cSrcweir ScMarkData& rMark = pViewData->GetMarkData();
2854cdf0e10cSrcweir
2855cdf0e10cSrcweir ScMarkData aWorkMark = rMark;
2856cdf0e10cSrcweir ScViewUtil::UnmarkFiltered( aWorkMark, pDocSh->GetDocument() );
2857cdf0e10cSrcweir aWorkMark.MarkToMulti();
2858cdf0e10cSrcweir if (!aWorkMark.IsMultiMarked())
2859cdf0e10cSrcweir {
2860cdf0e10cSrcweir SCCOL nCol = pViewData->GetCurX();
2861cdf0e10cSrcweir SCROW nRow = pViewData->GetCurY();
2862cdf0e10cSrcweir SCTAB nTab = pViewData->GetTabNo();
2863cdf0e10cSrcweir aWorkMark.SetMultiMarkArea( ScRange(nCol,nRow,nTab) );
2864cdf0e10cSrcweir }
2865cdf0e10cSrcweir
2866cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().ChangeIndent( aWorkMark, bIncrement, sal_False );
2867cdf0e10cSrcweir if (bSuccess)
2868cdf0e10cSrcweir {
2869cdf0e10cSrcweir pDocSh->UpdateOle(pViewData);
2870cdf0e10cSrcweir StartFormatArea();
2871*facb16e7SArmin Le Grand
2872*facb16e7SArmin Le Grand // stuff for sidebar panels
2873*facb16e7SArmin Le Grand SfxBindings& rBindings = GetViewData()->GetBindings();
2874*facb16e7SArmin Le Grand rBindings.Invalidate( SID_H_ALIGNCELL );
2875*facb16e7SArmin Le Grand rBindings.Invalidate( SID_ATTR_ALIGN_INDENT );
2876cdf0e10cSrcweir }
2877cdf0e10cSrcweir }
2878cdf0e10cSrcweir
InsertName(const String & rName,const String & rSymbol,const String & rType)2879cdf0e10cSrcweir sal_Bool ScViewFunc::InsertName( const String& rName, const String& rSymbol,
2880cdf0e10cSrcweir const String& rType )
2881cdf0e10cSrcweir {
2882cdf0e10cSrcweir // Type = P,R,C,F (und Kombinationen)
2883cdf0e10cSrcweir //! Undo...
2884cdf0e10cSrcweir
2885cdf0e10cSrcweir sal_Bool bOk = sal_False;
2886cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2887cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2888cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
2889cdf0e10cSrcweir ScRangeName* pList = pDoc->GetRangeName();
2890cdf0e10cSrcweir
2891cdf0e10cSrcweir RangeType nType = RT_NAME;
2892cdf0e10cSrcweir ScRangeData* pNewEntry = new ScRangeData( pDoc, rName, rSymbol,
2893cdf0e10cSrcweir ScAddress( GetViewData()->GetCurX(), GetViewData()->GetCurY(),
2894cdf0e10cSrcweir nTab), nType );
2895cdf0e10cSrcweir String aUpType = rType;
2896cdf0e10cSrcweir aUpType.ToUpperAscii();
2897cdf0e10cSrcweir if ( aUpType.Search( 'P' ) != STRING_NOTFOUND )
2898cdf0e10cSrcweir nType |= RT_PRINTAREA;
2899cdf0e10cSrcweir if ( aUpType.Search( 'R' ) != STRING_NOTFOUND )
2900cdf0e10cSrcweir nType |= RT_ROWHEADER;
2901cdf0e10cSrcweir if ( aUpType.Search( 'C' ) != STRING_NOTFOUND )
2902cdf0e10cSrcweir nType |= RT_COLHEADER;
2903cdf0e10cSrcweir if ( aUpType.Search( 'F' ) != STRING_NOTFOUND )
2904cdf0e10cSrcweir nType |= RT_CRITERIA;
2905cdf0e10cSrcweir pNewEntry->AddType(nType);
2906cdf0e10cSrcweir
2907cdf0e10cSrcweir if ( !pNewEntry->GetErrCode() ) // Text gueltig?
2908cdf0e10cSrcweir {
2909cdf0e10cSrcweir ScDocShellModificator aModificator( *pDocSh );
2910cdf0e10cSrcweir
2911cdf0e10cSrcweir pDoc->CompileNameFormula( sal_True ); // CreateFormulaString
2912cdf0e10cSrcweir
2913cdf0e10cSrcweir // Eintrag bereits vorhanden? Dann vorher entfernen (=Aendern)
2914cdf0e10cSrcweir sal_uInt16 nFoundAt;
2915cdf0e10cSrcweir if ( pList->SearchName( rName, nFoundAt ) )
2916cdf0e10cSrcweir { // alten Index uebernehmen
2917cdf0e10cSrcweir pNewEntry->SetIndex( ((ScRangeData*)pList->At(nFoundAt))->GetIndex() );
2918cdf0e10cSrcweir pList->AtFree( nFoundAt );
2919cdf0e10cSrcweir }
2920cdf0e10cSrcweir
2921cdf0e10cSrcweir if ( pList->Insert( pNewEntry ) )
2922cdf0e10cSrcweir {
2923cdf0e10cSrcweir pNewEntry = NULL; // nicht loeschen
2924cdf0e10cSrcweir bOk = sal_True;
2925cdf0e10cSrcweir }
2926cdf0e10cSrcweir
2927cdf0e10cSrcweir pDoc->CompileNameFormula( sal_False ); // CompileFormulaString
2928cdf0e10cSrcweir aModificator.SetDocumentModified();
2929cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) );
2930cdf0e10cSrcweir }
2931cdf0e10cSrcweir
2932cdf0e10cSrcweir delete pNewEntry; // wenn er nicht eingefuegt wurde
2933cdf0e10cSrcweir return bOk;
2934cdf0e10cSrcweir }
2935cdf0e10cSrcweir
CreateNames(sal_uInt16 nFlags)2936cdf0e10cSrcweir void ScViewFunc::CreateNames( sal_uInt16 nFlags )
2937cdf0e10cSrcweir {
2938cdf0e10cSrcweir sal_Bool bDone = sal_False;
2939cdf0e10cSrcweir ScRange aRange;
2940cdf0e10cSrcweir if ( GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE )
2941cdf0e10cSrcweir bDone = GetViewData()->GetDocShell()->GetDocFunc().CreateNames( aRange, nFlags, sal_False );
2942cdf0e10cSrcweir
2943cdf0e10cSrcweir if (!bDone)
2944cdf0e10cSrcweir ErrorMessage(STR_CREATENAME_MARKERR);
2945cdf0e10cSrcweir }
2946cdf0e10cSrcweir
GetCreateNameFlags()2947cdf0e10cSrcweir sal_uInt16 ScViewFunc::GetCreateNameFlags()
2948cdf0e10cSrcweir {
2949cdf0e10cSrcweir sal_uInt16 nFlags = 0;
2950cdf0e10cSrcweir
2951cdf0e10cSrcweir SCCOL nStartCol, nEndCol;
2952cdf0e10cSrcweir SCROW nStartRow, nEndRow;
2953cdf0e10cSrcweir SCTAB nDummy;
2954cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nDummy,nEndCol,nEndRow,nDummy) == SC_MARK_SIMPLE)
2955cdf0e10cSrcweir {
2956cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
2957cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
2958cdf0e10cSrcweir sal_Bool bOk;
2959cdf0e10cSrcweir SCCOL i;
2960cdf0e10cSrcweir SCROW j;
2961cdf0e10cSrcweir
2962cdf0e10cSrcweir bOk = sal_True;
2963cdf0e10cSrcweir SCCOL nFirstCol = nStartCol;
2964cdf0e10cSrcweir SCCOL nLastCol = nEndCol;
2965cdf0e10cSrcweir if (nStartCol+1 < nEndCol) { ++nFirstCol; --nLastCol; }
2966cdf0e10cSrcweir for (i=nFirstCol; i<=nLastCol && bOk; i++)
2967cdf0e10cSrcweir if (!pDoc->HasStringData( i,nStartRow,nTab ))
2968cdf0e10cSrcweir bOk = sal_False;
2969cdf0e10cSrcweir if (bOk)
2970cdf0e10cSrcweir nFlags |= NAME_TOP;
2971cdf0e10cSrcweir else // Bottom nur wenn nicht Top
2972cdf0e10cSrcweir {
2973cdf0e10cSrcweir bOk = sal_True;
2974cdf0e10cSrcweir for (i=nFirstCol; i<=nLastCol && bOk; i++)
2975cdf0e10cSrcweir if (!pDoc->HasStringData( i,nEndRow,nTab ))
2976cdf0e10cSrcweir bOk = sal_False;
2977cdf0e10cSrcweir if (bOk)
2978cdf0e10cSrcweir nFlags |= NAME_BOTTOM;
2979cdf0e10cSrcweir }
2980cdf0e10cSrcweir
2981cdf0e10cSrcweir bOk = sal_True;
2982cdf0e10cSrcweir SCROW nFirstRow = nStartRow;
2983cdf0e10cSrcweir SCROW nLastRow = nEndRow;
2984cdf0e10cSrcweir if (nStartRow+1 < nEndRow) { ++nFirstRow; --nLastRow; }
2985cdf0e10cSrcweir for (j=nFirstRow; j<=nLastRow && bOk; j++)
2986cdf0e10cSrcweir if (!pDoc->HasStringData( nStartCol,j,nTab ))
2987cdf0e10cSrcweir bOk = sal_False;
2988cdf0e10cSrcweir if (bOk)
2989cdf0e10cSrcweir nFlags |= NAME_LEFT;
2990cdf0e10cSrcweir else // Right nur wenn nicht Left
2991cdf0e10cSrcweir {
2992cdf0e10cSrcweir bOk = sal_True;
2993cdf0e10cSrcweir for (j=nFirstRow; j<=nLastRow && bOk; j++)
2994cdf0e10cSrcweir if (!pDoc->HasStringData( nEndCol,j,nTab ))
2995cdf0e10cSrcweir bOk = sal_False;
2996cdf0e10cSrcweir if (bOk)
2997cdf0e10cSrcweir nFlags |= NAME_RIGHT;
2998cdf0e10cSrcweir }
2999cdf0e10cSrcweir }
3000cdf0e10cSrcweir
3001cdf0e10cSrcweir if (nStartCol == nEndCol)
3002cdf0e10cSrcweir nFlags &= ~( NAME_LEFT | NAME_RIGHT );
3003cdf0e10cSrcweir if (nStartRow == nEndRow)
3004cdf0e10cSrcweir nFlags &= ~( NAME_TOP | NAME_BOTTOM );
3005cdf0e10cSrcweir
3006cdf0e10cSrcweir return nFlags;
3007cdf0e10cSrcweir }
3008cdf0e10cSrcweir
InsertNameList()3009cdf0e10cSrcweir void ScViewFunc::InsertNameList()
3010cdf0e10cSrcweir {
3011cdf0e10cSrcweir ScAddress aPos( GetViewData()->GetCurX(), GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
3012cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
3013cdf0e10cSrcweir if ( pDocSh->GetDocFunc().InsertNameList( aPos, sal_False ) )
3014cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
3015cdf0e10cSrcweir }
3016cdf0e10cSrcweir
3017cdf0e10cSrcweir
3018cdf0e10cSrcweir
3019cdf0e10cSrcweir
3020