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