1b3f79822SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3b3f79822SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4b3f79822SAndrew Rist * or more contributor license agreements. See the NOTICE file
5b3f79822SAndrew Rist * distributed with this work for additional information
6b3f79822SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7b3f79822SAndrew Rist * to you under the Apache License, Version 2.0 (the
8b3f79822SAndrew Rist * "License"); you may not use this file except in compliance
9b3f79822SAndrew Rist * with the License. You may obtain a copy of the License at
10b3f79822SAndrew Rist *
11b3f79822SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12b3f79822SAndrew Rist *
13b3f79822SAndrew Rist * Unless required by applicable law or agreed to in writing,
14b3f79822SAndrew Rist * software distributed under the License is distributed on an
15b3f79822SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16b3f79822SAndrew Rist * KIND, either express or implied. See the License for the
17b3f79822SAndrew Rist * specific language governing permissions and limitations
18b3f79822SAndrew Rist * under the License.
19b3f79822SAndrew Rist *
20b3f79822SAndrew Rist *************************************************************/
21b3f79822SAndrew Rist
22b3f79822SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sc.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir
28cdf0e10cSrcweir
29cdf0e10cSrcweir // INCLUDE ---------------------------------------------------------------
30cdf0e10cSrcweir
31cdf0e10cSrcweir #include "scitems.hxx"
32cdf0e10cSrcweir #include <editeng/eeitem.hxx>
33cdf0e10cSrcweir
34cdf0e10cSrcweir #include <sfx2/app.hxx>
35cdf0e10cSrcweir #include <editeng/editobj.hxx>
36cdf0e10cSrcweir #include <sfx2/linkmgr.hxx>
37cdf0e10cSrcweir #include <svx/svdundo.hxx>
38cdf0e10cSrcweir #include <sfx2/bindings.hxx>
39cdf0e10cSrcweir #include <sfx2/printer.hxx>
40cdf0e10cSrcweir #include <vcl/msgbox.hxx>
41cdf0e10cSrcweir #include <vcl/sound.hxx>
42cdf0e10cSrcweir #include <vcl/virdev.hxx>
43cdf0e10cSrcweir #include <vcl/waitobj.hxx>
44cdf0e10cSrcweir #include <svl/zforlist.hxx>
45cdf0e10cSrcweir #include <svl/PasswordHelper.hxx>
46cdf0e10cSrcweir
47cdf0e10cSrcweir #include <basic/sbstar.hxx>
48cdf0e10cSrcweir #include <com/sun/star/container/XNameContainer.hpp>
49cdf0e10cSrcweir #include <com/sun/star/script/ModuleType.hpp>
50cdf0e10cSrcweir #include <com/sun/star/script/XLibraryContainer.hpp>
51cdf0e10cSrcweir #include <com/sun/star/script/vba/XVBAModuleInfo.hpp>
52cdf0e10cSrcweir
53cdf0e10cSrcweir #include <list>
54cdf0e10cSrcweir
55cdf0e10cSrcweir #include "docfunc.hxx"
56cdf0e10cSrcweir
57cdf0e10cSrcweir #include "sc.hrc"
58cdf0e10cSrcweir
59cdf0e10cSrcweir #include "arealink.hxx"
60cdf0e10cSrcweir #include "attrib.hxx"
61cdf0e10cSrcweir #include "dociter.hxx"
62cdf0e10cSrcweir #include "autoform.hxx"
63cdf0e10cSrcweir #include "cell.hxx"
64cdf0e10cSrcweir #include "detdata.hxx"
65cdf0e10cSrcweir #include "detfunc.hxx"
66cdf0e10cSrcweir #include "docpool.hxx"
67cdf0e10cSrcweir #include "docsh.hxx"
68cdf0e10cSrcweir #include "drwlayer.hxx"
69cdf0e10cSrcweir #include "editutil.hxx"
70cdf0e10cSrcweir #include "globstr.hrc"
71cdf0e10cSrcweir //CHINA001 #include "namecrea.hxx" // NAME_TOP etc.
72cdf0e10cSrcweir #include "olinetab.hxx"
73cdf0e10cSrcweir #include "patattr.hxx"
74cdf0e10cSrcweir #include "rangenam.hxx"
75cdf0e10cSrcweir #include "rangeutl.hxx"
76cdf0e10cSrcweir #include "refundo.hxx"
77cdf0e10cSrcweir #include "scresid.hxx"
78cdf0e10cSrcweir #include "stlpool.hxx"
79cdf0e10cSrcweir #include "stlsheet.hxx"
80cdf0e10cSrcweir #include "tablink.hxx"
81cdf0e10cSrcweir #include "tabvwsh.hxx"
82cdf0e10cSrcweir #include "uiitems.hxx"
83cdf0e10cSrcweir #include "undoblk.hxx"
84cdf0e10cSrcweir #include "undocell.hxx"
85cdf0e10cSrcweir #include "undodraw.hxx"
86cdf0e10cSrcweir #include "undotab.hxx"
87cdf0e10cSrcweir #include "waitoff.hxx"
88cdf0e10cSrcweir #include "sizedev.hxx"
89cdf0e10cSrcweir #include "scmod.hxx"
90cdf0e10cSrcweir #include "inputhdl.hxx"
91cdf0e10cSrcweir #include "inputwin.hxx"
92cdf0e10cSrcweir #include "editable.hxx"
93cdf0e10cSrcweir #include "compiler.hxx"
94cdf0e10cSrcweir #include "scui_def.hxx" //CHINA001
95cdf0e10cSrcweir #include "tabprotection.hxx"
96cdf0e10cSrcweir #include "clipparam.hxx"
97cdf0e10cSrcweir #include "externalrefmgr.hxx"
98cdf0e10cSrcweir
99cdf0e10cSrcweir #include <memory>
100cdf0e10cSrcweir #include <basic/basmgr.hxx>
101cdf0e10cSrcweir #include <boost/scoped_ptr.hpp>
102cdf0e10cSrcweir
103cdf0e10cSrcweir using namespace com::sun::star;
104cdf0e10cSrcweir using ::com::sun::star::uno::Sequence;
105cdf0e10cSrcweir
106cdf0e10cSrcweir // STATIC DATA -----------------------------------------------------------
107cdf0e10cSrcweir
108cdf0e10cSrcweir //========================================================================
109cdf0e10cSrcweir
IMPL_LINK(ScDocFunc,NotifyDrawUndo,SdrUndoAction *,pUndoAction)110cdf0e10cSrcweir IMPL_LINK( ScDocFunc, NotifyDrawUndo, SdrUndoAction*, pUndoAction )
111cdf0e10cSrcweir {
112cdf0e10cSrcweir // #i101118# if drawing layer collects the undo actions, add it there
113cdf0e10cSrcweir ScDrawLayer* pDrawLayer = rDocShell.GetDocument()->GetDrawLayer();
114577c0052SWang Lei if( pDrawLayer && pDrawLayer->IsUndoAllowed() && pDrawLayer->IsRecording() )
115cdf0e10cSrcweir pDrawLayer->AddCalcUndo( pUndoAction );
116cdf0e10cSrcweir else
117cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( new ScUndoDraw( pUndoAction, &rDocShell ) );
118cdf0e10cSrcweir rDocShell.SetDrawModified();
119cdf0e10cSrcweir
120cdf0e10cSrcweir // the affected sheet isn't known, so all stream positions are invalidated
121cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
122cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
123cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nTabCount; nTab++)
124cdf0e10cSrcweir if (pDoc->IsStreamValid(nTab))
125cdf0e10cSrcweir pDoc->SetStreamValid(nTab, sal_False);
126cdf0e10cSrcweir
127cdf0e10cSrcweir return 0;
128cdf0e10cSrcweir }
129cdf0e10cSrcweir
130cdf0e10cSrcweir //------------------------------------------------------------------------
131cdf0e10cSrcweir
132cdf0e10cSrcweir // Zeile ueber dem Range painten (fuer Linien nach AdjustRowHeight)
133cdf0e10cSrcweir
lcl_PaintAbove(ScDocShell & rDocShell,const ScRange & rRange)134cdf0e10cSrcweir void lcl_PaintAbove( ScDocShell& rDocShell, const ScRange& rRange )
135cdf0e10cSrcweir {
136cdf0e10cSrcweir SCROW nRow = rRange.aStart.Row();
137cdf0e10cSrcweir if ( nRow > 0 )
138cdf0e10cSrcweir {
139cdf0e10cSrcweir SCTAB nTab = rRange.aStart.Tab(); //! alle?
140cdf0e10cSrcweir --nRow;
141cdf0e10cSrcweir rDocShell.PostPaint( ScRange(0,nRow,nTab, MAXCOL,nRow,nTab), PAINT_GRID );
142cdf0e10cSrcweir }
143cdf0e10cSrcweir }
144cdf0e10cSrcweir
145cdf0e10cSrcweir //------------------------------------------------------------------------
146cdf0e10cSrcweir
AdjustRowHeight(const ScRange & rRange,sal_Bool bPaint)147cdf0e10cSrcweir sal_Bool ScDocFunc::AdjustRowHeight( const ScRange& rRange, sal_Bool bPaint )
148cdf0e10cSrcweir {
149cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
150cdf0e10cSrcweir if ( pDoc->IsImportingXML() )
151cdf0e10cSrcweir {
152cdf0e10cSrcweir // for XML import, all row heights are updated together after importing
153cdf0e10cSrcweir return sal_False;
154cdf0e10cSrcweir }
155cdf0e10cSrcweir if ( !pDoc->IsAdjustHeightEnabled() )
156cdf0e10cSrcweir {
157cdf0e10cSrcweir return sal_False;
158cdf0e10cSrcweir }
159cdf0e10cSrcweir
160cdf0e10cSrcweir SCTAB nTab = rRange.aStart.Tab();
161cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
162cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
163cdf0e10cSrcweir
164cdf0e10cSrcweir ScSizeDeviceProvider aProv( &rDocShell );
165cdf0e10cSrcweir Fraction aOne(1,1);
166cdf0e10cSrcweir
167cdf0e10cSrcweir sal_Bool bChanged = pDoc->SetOptimalHeight( nStartRow, nEndRow, nTab, 0, aProv.GetDevice(),
168cdf0e10cSrcweir aProv.GetPPTX(), aProv.GetPPTY(), aOne, aOne, sal_False );
169cdf0e10cSrcweir
170cdf0e10cSrcweir if ( bPaint && bChanged )
171cdf0e10cSrcweir rDocShell.PostPaint( 0, nStartRow, nTab, MAXCOL, MAXROW, nTab,
172cdf0e10cSrcweir PAINT_GRID | PAINT_LEFT );
173cdf0e10cSrcweir
174cdf0e10cSrcweir return bChanged;
175cdf0e10cSrcweir }
176cdf0e10cSrcweir
177cdf0e10cSrcweir
178cdf0e10cSrcweir //------------------------------------------------------------------------
179cdf0e10cSrcweir
DetectiveAddPred(const ScAddress & rPos)180cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveAddPred(const ScAddress& rPos)
181cdf0e10cSrcweir {
182cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
183cdf0e10cSrcweir
184cdf0e10cSrcweir rDocShell.MakeDrawLayer();
185cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
186cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
187cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
188cdf0e10cSrcweir SCCOL nCol = rPos.Col();
189cdf0e10cSrcweir SCROW nRow = rPos.Row();
190cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
191cdf0e10cSrcweir
192cdf0e10cSrcweir if (bUndo)
193a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
194cdf0e10cSrcweir sal_Bool bDone = ScDetectiveFunc( pDoc,nTab ).ShowPred( nCol, nRow );
195cdf0e10cSrcweir SdrUndoGroup* pUndo = NULL;
196cdf0e10cSrcweir if (bUndo)
197cdf0e10cSrcweir pUndo = pModel->GetCalcUndo();
198cdf0e10cSrcweir if (bDone)
199cdf0e10cSrcweir {
200cdf0e10cSrcweir ScDetOpData aOperation( ScAddress(nCol,nRow,nTab), SCDETOP_ADDPRED );
201cdf0e10cSrcweir pDoc->AddDetectiveOperation( aOperation );
202cdf0e10cSrcweir if (bUndo)
203cdf0e10cSrcweir {
204cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
205cdf0e10cSrcweir new ScUndoDetective( &rDocShell, pUndo, &aOperation ) );
206cdf0e10cSrcweir }
207cdf0e10cSrcweir aModificator.SetDocumentModified();
208cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
209cdf0e10cSrcweir if (pBindings)
210cdf0e10cSrcweir pBindings->Invalidate( SID_DETECTIVE_REFRESH );
211cdf0e10cSrcweir }
212cdf0e10cSrcweir else
213cdf0e10cSrcweir delete pUndo;
214cdf0e10cSrcweir
215cdf0e10cSrcweir return bDone;
216cdf0e10cSrcweir }
217cdf0e10cSrcweir
DetectiveDelPred(const ScAddress & rPos)218cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveDelPred(const ScAddress& rPos)
219cdf0e10cSrcweir {
220cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
221cdf0e10cSrcweir
222cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
223cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
224cdf0e10cSrcweir if (!pModel)
225cdf0e10cSrcweir return sal_False;
226cdf0e10cSrcweir
227cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
228cdf0e10cSrcweir
229cdf0e10cSrcweir SCCOL nCol = rPos.Col();
230cdf0e10cSrcweir SCROW nRow = rPos.Row();
231cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
232cdf0e10cSrcweir
233cdf0e10cSrcweir if (bUndo)
234a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
235cdf0e10cSrcweir sal_Bool bDone = ScDetectiveFunc( pDoc,nTab ).DeletePred( nCol, nRow );
236cdf0e10cSrcweir SdrUndoGroup* pUndo = NULL;
237cdf0e10cSrcweir if (bUndo)
238cdf0e10cSrcweir pUndo = pModel->GetCalcUndo();
239cdf0e10cSrcweir if (bDone)
240cdf0e10cSrcweir {
241cdf0e10cSrcweir ScDetOpData aOperation( ScAddress(nCol,nRow,nTab), SCDETOP_DELPRED );
242cdf0e10cSrcweir pDoc->AddDetectiveOperation( aOperation );
243cdf0e10cSrcweir if (bUndo)
244cdf0e10cSrcweir {
245cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
246cdf0e10cSrcweir new ScUndoDetective( &rDocShell, pUndo, &aOperation ) );
247cdf0e10cSrcweir }
248cdf0e10cSrcweir aModificator.SetDocumentModified();
249cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
250cdf0e10cSrcweir if (pBindings)
251cdf0e10cSrcweir pBindings->Invalidate( SID_DETECTIVE_REFRESH );
252cdf0e10cSrcweir }
253cdf0e10cSrcweir else
254cdf0e10cSrcweir delete pUndo;
255cdf0e10cSrcweir
256cdf0e10cSrcweir return bDone;
257cdf0e10cSrcweir }
258cdf0e10cSrcweir
DetectiveAddSucc(const ScAddress & rPos)259cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveAddSucc(const ScAddress& rPos)
260cdf0e10cSrcweir {
261cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
262cdf0e10cSrcweir
263cdf0e10cSrcweir rDocShell.MakeDrawLayer();
264cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
265cdf0e10cSrcweir
266cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
267cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
268cdf0e10cSrcweir SCCOL nCol = rPos.Col();
269cdf0e10cSrcweir SCROW nRow = rPos.Row();
270cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
271cdf0e10cSrcweir
272cdf0e10cSrcweir if (bUndo)
273a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
274cdf0e10cSrcweir sal_Bool bDone = ScDetectiveFunc( pDoc,nTab ).ShowSucc( nCol, nRow );
275cdf0e10cSrcweir SdrUndoGroup* pUndo = NULL;
276cdf0e10cSrcweir if (bUndo)
277cdf0e10cSrcweir pUndo = pModel->GetCalcUndo();
278cdf0e10cSrcweir if (bDone)
279cdf0e10cSrcweir {
280cdf0e10cSrcweir ScDetOpData aOperation( ScAddress(nCol,nRow,nTab), SCDETOP_ADDSUCC );
281cdf0e10cSrcweir pDoc->AddDetectiveOperation( aOperation );
282cdf0e10cSrcweir if (bUndo)
283cdf0e10cSrcweir {
284cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
285cdf0e10cSrcweir new ScUndoDetective( &rDocShell, pUndo, &aOperation ) );
286cdf0e10cSrcweir }
287cdf0e10cSrcweir aModificator.SetDocumentModified();
288cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
289cdf0e10cSrcweir if (pBindings)
290cdf0e10cSrcweir pBindings->Invalidate( SID_DETECTIVE_REFRESH );
291cdf0e10cSrcweir }
292cdf0e10cSrcweir else
293cdf0e10cSrcweir delete pUndo;
294cdf0e10cSrcweir
295cdf0e10cSrcweir return bDone;
296cdf0e10cSrcweir }
297cdf0e10cSrcweir
DetectiveDelSucc(const ScAddress & rPos)298cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveDelSucc(const ScAddress& rPos)
299cdf0e10cSrcweir {
300cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
301cdf0e10cSrcweir
302cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
303cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
304cdf0e10cSrcweir if (!pModel)
305cdf0e10cSrcweir return sal_False;
306cdf0e10cSrcweir
307cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
308cdf0e10cSrcweir
309cdf0e10cSrcweir SCCOL nCol = rPos.Col();
310cdf0e10cSrcweir SCROW nRow = rPos.Row();
311cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
312cdf0e10cSrcweir
313cdf0e10cSrcweir if (bUndo)
314a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
315cdf0e10cSrcweir sal_Bool bDone = ScDetectiveFunc( pDoc,nTab ).DeleteSucc( nCol, nRow );
316cdf0e10cSrcweir SdrUndoGroup* pUndo = NULL;
317cdf0e10cSrcweir if (bUndo)
318cdf0e10cSrcweir pUndo = pModel->GetCalcUndo();
319cdf0e10cSrcweir if (bDone)
320cdf0e10cSrcweir {
321cdf0e10cSrcweir ScDetOpData aOperation( ScAddress(nCol,nRow,nTab), SCDETOP_DELSUCC );
322cdf0e10cSrcweir pDoc->AddDetectiveOperation( aOperation );
323cdf0e10cSrcweir if (bUndo)
324cdf0e10cSrcweir {
325cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
326cdf0e10cSrcweir new ScUndoDetective( &rDocShell, pUndo, &aOperation ) );
327cdf0e10cSrcweir }
328cdf0e10cSrcweir aModificator.SetDocumentModified();
329cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
330cdf0e10cSrcweir if (pBindings)
331cdf0e10cSrcweir pBindings->Invalidate( SID_DETECTIVE_REFRESH );
332cdf0e10cSrcweir }
333cdf0e10cSrcweir else
334cdf0e10cSrcweir delete pUndo;
335cdf0e10cSrcweir
336cdf0e10cSrcweir return bDone;
337cdf0e10cSrcweir }
338cdf0e10cSrcweir
DetectiveAddError(const ScAddress & rPos)339cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveAddError(const ScAddress& rPos)
340cdf0e10cSrcweir {
341cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
342cdf0e10cSrcweir
343cdf0e10cSrcweir rDocShell.MakeDrawLayer();
344cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
345cdf0e10cSrcweir
346cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
347cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
348cdf0e10cSrcweir SCCOL nCol = rPos.Col();
349cdf0e10cSrcweir SCROW nRow = rPos.Row();
350cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
351cdf0e10cSrcweir
352cdf0e10cSrcweir if (bUndo)
353a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
354cdf0e10cSrcweir sal_Bool bDone = ScDetectiveFunc( pDoc,nTab ).ShowError( nCol, nRow );
355cdf0e10cSrcweir SdrUndoGroup* pUndo = NULL;
356cdf0e10cSrcweir if (bUndo)
357cdf0e10cSrcweir pUndo = pModel->GetCalcUndo();
358cdf0e10cSrcweir if (bDone)
359cdf0e10cSrcweir {
360cdf0e10cSrcweir ScDetOpData aOperation( ScAddress(nCol,nRow,nTab), SCDETOP_ADDERROR );
361cdf0e10cSrcweir pDoc->AddDetectiveOperation( aOperation );
362cdf0e10cSrcweir if (bUndo)
363cdf0e10cSrcweir {
364cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
365cdf0e10cSrcweir new ScUndoDetective( &rDocShell, pUndo, &aOperation ) );
366cdf0e10cSrcweir }
367cdf0e10cSrcweir aModificator.SetDocumentModified();
368cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
369cdf0e10cSrcweir if (pBindings)
370cdf0e10cSrcweir pBindings->Invalidate( SID_DETECTIVE_REFRESH );
371cdf0e10cSrcweir }
372cdf0e10cSrcweir else
373cdf0e10cSrcweir delete pUndo;
374cdf0e10cSrcweir
375cdf0e10cSrcweir return bDone;
376cdf0e10cSrcweir }
377cdf0e10cSrcweir
DetectiveMarkInvalid(SCTAB nTab)378cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveMarkInvalid(SCTAB nTab)
379cdf0e10cSrcweir {
380cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
381cdf0e10cSrcweir
382cdf0e10cSrcweir rDocShell.MakeDrawLayer();
383cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
384cdf0e10cSrcweir
385cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
386cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
387cdf0e10cSrcweir
388cdf0e10cSrcweir Window* pWaitWin = rDocShell.GetActiveDialogParent();
389cdf0e10cSrcweir if (pWaitWin)
390cdf0e10cSrcweir pWaitWin->EnterWait();
391cdf0e10cSrcweir if (bUndo)
392a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
393cdf0e10cSrcweir sal_Bool bOverflow;
394cdf0e10cSrcweir sal_Bool bDone = ScDetectiveFunc( pDoc,nTab ).MarkInvalid( bOverflow );
395cdf0e10cSrcweir SdrUndoGroup* pUndo = NULL;
396cdf0e10cSrcweir if (bUndo)
397cdf0e10cSrcweir pUndo = pModel->GetCalcUndo();
398cdf0e10cSrcweir if (pWaitWin)
399cdf0e10cSrcweir pWaitWin->LeaveWait();
400cdf0e10cSrcweir if (bDone)
401cdf0e10cSrcweir {
402cdf0e10cSrcweir if (pUndo && bUndo)
403cdf0e10cSrcweir {
404cdf0e10cSrcweir pUndo->SetComment( ScGlobal::GetRscString( STR_UNDO_DETINVALID ) );
405cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( pUndo );
406cdf0e10cSrcweir }
407cdf0e10cSrcweir aModificator.SetDocumentModified();
408cdf0e10cSrcweir if ( bOverflow )
409cdf0e10cSrcweir {
410cdf0e10cSrcweir InfoBox( NULL,
411cdf0e10cSrcweir ScGlobal::GetRscString( STR_DETINVALID_OVERFLOW ) ).Execute();
412cdf0e10cSrcweir }
413cdf0e10cSrcweir }
414cdf0e10cSrcweir else
415cdf0e10cSrcweir delete pUndo;
416cdf0e10cSrcweir
417cdf0e10cSrcweir return bDone;
418cdf0e10cSrcweir }
419cdf0e10cSrcweir
DetectiveDelAll(SCTAB nTab)420cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveDelAll(SCTAB nTab)
421cdf0e10cSrcweir {
422cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
423cdf0e10cSrcweir
424cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
425cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
426cdf0e10cSrcweir if (!pModel)
427cdf0e10cSrcweir return sal_False;
428cdf0e10cSrcweir
429cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
430cdf0e10cSrcweir
431cdf0e10cSrcweir if (bUndo)
432a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
433cdf0e10cSrcweir sal_Bool bDone = ScDetectiveFunc( pDoc,nTab ).DeleteAll( SC_DET_DETECTIVE );
434cdf0e10cSrcweir SdrUndoGroup* pUndo = NULL;
435cdf0e10cSrcweir if (bUndo)
436cdf0e10cSrcweir pUndo = pModel->GetCalcUndo();
437cdf0e10cSrcweir if (bDone)
438cdf0e10cSrcweir {
439cdf0e10cSrcweir ScDetOpList* pOldList = pDoc->GetDetOpList();
440cdf0e10cSrcweir ScDetOpList* pUndoList = NULL;
441cdf0e10cSrcweir if (bUndo)
442cdf0e10cSrcweir pUndoList = pOldList ? new ScDetOpList(*pOldList) : NULL;
443cdf0e10cSrcweir
444cdf0e10cSrcweir pDoc->ClearDetectiveOperations();
445cdf0e10cSrcweir
446cdf0e10cSrcweir if (bUndo)
447cdf0e10cSrcweir {
448cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
449cdf0e10cSrcweir new ScUndoDetective( &rDocShell, pUndo, NULL, pUndoList ) );
450cdf0e10cSrcweir }
451cdf0e10cSrcweir aModificator.SetDocumentModified();
452cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
453cdf0e10cSrcweir if (pBindings)
454cdf0e10cSrcweir pBindings->Invalidate( SID_DETECTIVE_REFRESH );
455cdf0e10cSrcweir }
456cdf0e10cSrcweir else
457cdf0e10cSrcweir delete pUndo;
458cdf0e10cSrcweir
459cdf0e10cSrcweir return bDone;
460cdf0e10cSrcweir }
461cdf0e10cSrcweir
DetectiveRefresh(sal_Bool bAutomatic)462cdf0e10cSrcweir sal_Bool ScDocFunc::DetectiveRefresh( sal_Bool bAutomatic )
463cdf0e10cSrcweir {
464cdf0e10cSrcweir sal_Bool bDone = sal_False;
465cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
466cdf0e10cSrcweir
467cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
468cdf0e10cSrcweir ScDetOpList* pList = pDoc->GetDetOpList();
469cdf0e10cSrcweir if ( pList && pList->Count() )
470cdf0e10cSrcweir {
471cdf0e10cSrcweir rDocShell.MakeDrawLayer();
472cdf0e10cSrcweir ScDrawLayer* pModel = pDoc->GetDrawLayer();
473cdf0e10cSrcweir if (bUndo)
474a840a559SArmin Le Grand pModel->BeginCalcUndo(false);
475cdf0e10cSrcweir
476cdf0e10cSrcweir // Loeschen auf allen Tabellen
477cdf0e10cSrcweir
478cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
479cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nTabCount; nTab++)
480cdf0e10cSrcweir ScDetectiveFunc( pDoc,nTab ).DeleteAll( SC_DET_ARROWS ); // don't remove circles
481cdf0e10cSrcweir
482cdf0e10cSrcweir // Wiederholen
483cdf0e10cSrcweir
484cdf0e10cSrcweir sal_uInt16 nCount = pList->Count();
485cdf0e10cSrcweir for (sal_uInt16 i=0; i<nCount; i++)
486cdf0e10cSrcweir {
487cdf0e10cSrcweir ScDetOpData* pData = (*pList)[i];
488cdf0e10cSrcweir if (pData)
489cdf0e10cSrcweir {
490cdf0e10cSrcweir ScAddress aPos = pData->GetPos();
491cdf0e10cSrcweir ScDetectiveFunc aFunc( pDoc, aPos.Tab() );
492cdf0e10cSrcweir SCCOL nCol = aPos.Col();
493cdf0e10cSrcweir SCROW nRow = aPos.Row();
494cdf0e10cSrcweir switch (pData->GetOperation())
495cdf0e10cSrcweir {
496cdf0e10cSrcweir case SCDETOP_ADDSUCC:
497cdf0e10cSrcweir aFunc.ShowSucc( nCol, nRow );
498cdf0e10cSrcweir break;
499cdf0e10cSrcweir case SCDETOP_DELSUCC:
500cdf0e10cSrcweir aFunc.DeleteSucc( nCol, nRow );
501cdf0e10cSrcweir break;
502cdf0e10cSrcweir case SCDETOP_ADDPRED:
503cdf0e10cSrcweir aFunc.ShowPred( nCol, nRow );
504cdf0e10cSrcweir break;
505cdf0e10cSrcweir case SCDETOP_DELPRED:
506cdf0e10cSrcweir aFunc.DeletePred( nCol, nRow );
507cdf0e10cSrcweir break;
508cdf0e10cSrcweir case SCDETOP_ADDERROR:
509cdf0e10cSrcweir aFunc.ShowError( nCol, nRow );
510cdf0e10cSrcweir break;
511cdf0e10cSrcweir default:
512cdf0e10cSrcweir DBG_ERROR("falsche Op bei DetectiveRefresh");
513cdf0e10cSrcweir }
514cdf0e10cSrcweir }
515cdf0e10cSrcweir }
516cdf0e10cSrcweir
517cdf0e10cSrcweir if (bUndo)
518cdf0e10cSrcweir {
519cdf0e10cSrcweir SdrUndoGroup* pUndo = pModel->GetCalcUndo();
520cdf0e10cSrcweir if (pUndo)
521cdf0e10cSrcweir {
522cdf0e10cSrcweir pUndo->SetComment( ScGlobal::GetRscString( STR_UNDO_DETREFRESH ) );
523cdf0e10cSrcweir // wenn automatisch, an letzte Aktion anhaengen
524cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
525cdf0e10cSrcweir new ScUndoDraw( pUndo, &rDocShell ),
526cdf0e10cSrcweir bAutomatic );
527cdf0e10cSrcweir }
528cdf0e10cSrcweir }
529cdf0e10cSrcweir rDocShell.SetDrawModified();
530cdf0e10cSrcweir bDone = sal_True;
531cdf0e10cSrcweir }
532cdf0e10cSrcweir return bDone;
533cdf0e10cSrcweir }
534cdf0e10cSrcweir
535cdf0e10cSrcweir //------------------------------------------------------------------------
536cdf0e10cSrcweir
DeleteContents(const ScMarkData & rMark,sal_uInt16 nFlags,sal_Bool bRecord,sal_Bool bApi)537cdf0e10cSrcweir sal_Bool ScDocFunc::DeleteContents( const ScMarkData& rMark, sal_uInt16 nFlags,
538cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi )
539cdf0e10cSrcweir {
540cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
541cdf0e10cSrcweir
542cdf0e10cSrcweir if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
543cdf0e10cSrcweir {
544cdf0e10cSrcweir DBG_ERROR("ScDocFunc::DeleteContents ohne Markierung");
545cdf0e10cSrcweir return sal_False;
546cdf0e10cSrcweir }
547cdf0e10cSrcweir
548cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
549cdf0e10cSrcweir
550cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
551cdf0e10cSrcweir bRecord = sal_False;
552cdf0e10cSrcweir
553cdf0e10cSrcweir ScEditableTester aTester( pDoc, rMark );
554cdf0e10cSrcweir if (!aTester.IsEditable())
555cdf0e10cSrcweir {
556cdf0e10cSrcweir if (!bApi)
557cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
558cdf0e10cSrcweir return sal_False;
559cdf0e10cSrcweir }
560cdf0e10cSrcweir
561cdf0e10cSrcweir ScRange aMarkRange;
562cdf0e10cSrcweir sal_Bool bSimple = sal_False;
563cdf0e10cSrcweir
564cdf0e10cSrcweir ScMarkData aMultiMark = rMark;
565cdf0e10cSrcweir aMultiMark.SetMarking(sal_False); // fuer MarkToMulti
566cdf0e10cSrcweir
567cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
568cdf0e10cSrcweir sal_Bool bMulti = !bSimple && aMultiMark.IsMultiMarked();
569cdf0e10cSrcweir if (!bSimple)
570cdf0e10cSrcweir {
571cdf0e10cSrcweir aMultiMark.MarkToMulti();
572cdf0e10cSrcweir aMultiMark.GetMultiMarkArea( aMarkRange );
573cdf0e10cSrcweir }
574cdf0e10cSrcweir ScRange aExtendedRange(aMarkRange);
575cdf0e10cSrcweir if (!bSimple)
576cdf0e10cSrcweir {
577cdf0e10cSrcweir if ( pDoc->ExtendMerge( aExtendedRange, sal_True ) )
578cdf0e10cSrcweir bMulti = sal_False;
579cdf0e10cSrcweir }
580cdf0e10cSrcweir
581cdf0e10cSrcweir // keine Objekte auf geschuetzten Tabellen
582cdf0e10cSrcweir sal_Bool bObjects = sal_False;
583cdf0e10cSrcweir if ( nFlags & IDF_OBJECTS )
584cdf0e10cSrcweir {
585cdf0e10cSrcweir bObjects = sal_True;
586cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
587cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nTabCount; nTab++)
588cdf0e10cSrcweir if (aMultiMark.GetTableSelect(nTab) && pDoc->IsTabProtected(nTab))
589cdf0e10cSrcweir bObjects = sal_False;
590cdf0e10cSrcweir }
591cdf0e10cSrcweir
592cdf0e10cSrcweir sal_uInt16 nExtFlags = 0; // extra flags are needed only if attributes are deleted
593cdf0e10cSrcweir if ( nFlags & IDF_ATTRIB )
594cdf0e10cSrcweir rDocShell.UpdatePaintExt( nExtFlags, aMarkRange );
595cdf0e10cSrcweir
596cdf0e10cSrcweir // Reihenfolge:
597cdf0e10cSrcweir // 1) BeginDrawUndo
598cdf0e10cSrcweir // 2) Objekte loeschen (DrawUndo wird gefuellt)
599cdf0e10cSrcweir // 3) Inhalte fuer Undo kopieren und Undo-Aktion anlegen
600cdf0e10cSrcweir // 4) Inhalte loeschen
601cdf0e10cSrcweir
602cdf0e10cSrcweir bool bDrawUndo = bObjects || (nFlags & IDF_NOTE);
603cdf0e10cSrcweir if (bRecord && bDrawUndo)
604cdf0e10cSrcweir pDoc->BeginDrawUndo();
605cdf0e10cSrcweir
606cdf0e10cSrcweir if (bObjects)
607cdf0e10cSrcweir {
608cdf0e10cSrcweir if (bMulti)
609cdf0e10cSrcweir pDoc->DeleteObjectsInSelection( aMultiMark );
610cdf0e10cSrcweir else
611cdf0e10cSrcweir pDoc->DeleteObjectsInArea( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
612cdf0e10cSrcweir aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(),
613cdf0e10cSrcweir aMultiMark );
614cdf0e10cSrcweir }
615cdf0e10cSrcweir
616cdf0e10cSrcweir if ( bRecord )
617cdf0e10cSrcweir {
618cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
619cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, aMarkRange.aStart.Tab(), aMarkRange.aEnd.Tab() );
620cdf0e10cSrcweir
621cdf0e10cSrcweir // bei "Format/Standard" alle Attribute kopieren, weil CopyToDocument
622cdf0e10cSrcweir // nur mit IDF_HARDATTR zu langsam ist:
623cdf0e10cSrcweir sal_uInt16 nUndoDocFlags = nFlags;
624cdf0e10cSrcweir if (nFlags & IDF_ATTRIB)
625cdf0e10cSrcweir nUndoDocFlags |= IDF_ATTRIB;
626cdf0e10cSrcweir if (nFlags & IDF_EDITATTR) // Edit-Engine-Attribute
627cdf0e10cSrcweir nUndoDocFlags |= IDF_STRING; // -> Zellen werden geaendert
628cdf0e10cSrcweir if (nFlags & IDF_NOTE)
629cdf0e10cSrcweir nUndoDocFlags |= IDF_CONTENTS; // #68795# copy all cells with their notes
630cdf0e10cSrcweir // note captions are handled in drawing undo
631cdf0e10cSrcweir nUndoDocFlags |= IDF_NOCAPTIONS;
632cdf0e10cSrcweir pDoc->CopyToDocument( aExtendedRange, nUndoDocFlags, bMulti, pUndoDoc, &aMultiMark );
633cdf0e10cSrcweir }
634cdf0e10cSrcweir
635cdf0e10cSrcweir //! HideAllCursors(); // falls Zusammenfassung aufgehoben wird
636cdf0e10cSrcweir if (bSimple)
637cdf0e10cSrcweir pDoc->DeleteArea( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
638cdf0e10cSrcweir aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(),
639cdf0e10cSrcweir aMultiMark, nFlags );
640cdf0e10cSrcweir else
641cdf0e10cSrcweir {
642cdf0e10cSrcweir pDoc->DeleteSelection( nFlags, aMultiMark );
643cdf0e10cSrcweir // aMultiMark.MarkToSimple();
644cdf0e10cSrcweir }
645cdf0e10cSrcweir
646cdf0e10cSrcweir // add undo action after drawing undo is complete (objects and note captions)
647cdf0e10cSrcweir if( bRecord )
648cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
649cdf0e10cSrcweir new ScUndoDeleteContents( &rDocShell, aMultiMark, aExtendedRange,
650cdf0e10cSrcweir pUndoDoc, bMulti, nFlags, bDrawUndo ) );
651cdf0e10cSrcweir
652cdf0e10cSrcweir if (!AdjustRowHeight( aExtendedRange ))
653cdf0e10cSrcweir rDocShell.PostPaint( aExtendedRange, PAINT_GRID, nExtFlags );
654cdf0e10cSrcweir else if (nExtFlags & SC_PF_LINES)
655cdf0e10cSrcweir lcl_PaintAbove( rDocShell, aExtendedRange ); // fuer Linien ueber dem Bereich
656cdf0e10cSrcweir
657cdf0e10cSrcweir // rDocShell.UpdateOle(GetViewData()); //! an der View?
658cdf0e10cSrcweir aModificator.SetDocumentModified();
659cdf0e10cSrcweir //! CellContentChanged();
660cdf0e10cSrcweir //! ShowAllCursors();
661cdf0e10cSrcweir
662cdf0e10cSrcweir #if 0
663cdf0e10cSrcweir //! muss an der View bleiben !!!!
664cdf0e10cSrcweir if ( nFlags & IDF_ATTRIB )
665cdf0e10cSrcweir {
666cdf0e10cSrcweir if ( nFlags & IDF_CONTENTS )
667cdf0e10cSrcweir ForgetFormatArea();
668cdf0e10cSrcweir else
669cdf0e10cSrcweir StartFormatArea(); // Attribute loeschen ist auch Attributierung
670cdf0e10cSrcweir }
671cdf0e10cSrcweir #endif
672cdf0e10cSrcweir
673cdf0e10cSrcweir return sal_True;
674cdf0e10cSrcweir }
675cdf0e10cSrcweir
676cdf0e10cSrcweir //------------------------------------------------------------------------
677cdf0e10cSrcweir
TransliterateText(const ScMarkData & rMark,sal_Int32 nType,sal_Bool bRecord,sal_Bool bApi)678cdf0e10cSrcweir sal_Bool ScDocFunc::TransliterateText( const ScMarkData& rMark, sal_Int32 nType,
679cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi )
680cdf0e10cSrcweir {
681cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
682cdf0e10cSrcweir
683cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
684cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
685cdf0e10cSrcweir bRecord = sal_False;
686cdf0e10cSrcweir
687cdf0e10cSrcweir ScEditableTester aTester( pDoc, rMark );
688cdf0e10cSrcweir if (!aTester.IsEditable())
689cdf0e10cSrcweir {
690cdf0e10cSrcweir if (!bApi)
691cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
692cdf0e10cSrcweir return sal_False;
693cdf0e10cSrcweir }
694cdf0e10cSrcweir
695cdf0e10cSrcweir ScRange aMarkRange;
696cdf0e10cSrcweir ScMarkData aMultiMark = rMark;
697cdf0e10cSrcweir aMultiMark.SetMarking(sal_False); // for MarkToMulti
698cdf0e10cSrcweir aMultiMark.MarkToMulti();
699cdf0e10cSrcweir aMultiMark.GetMultiMarkArea( aMarkRange );
700cdf0e10cSrcweir
701cdf0e10cSrcweir if (bRecord)
702cdf0e10cSrcweir {
703cdf0e10cSrcweir SCTAB nStartTab = aMarkRange.aStart.Tab();
704cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
705cdf0e10cSrcweir
706cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
707cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
708cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
709cdf0e10cSrcweir if (i != nStartTab && rMark.GetTableSelect(i))
710cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
711cdf0e10cSrcweir
712cdf0e10cSrcweir ScRange aCopyRange = aMarkRange;
713cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
714cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
715cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_CONTENTS, sal_True, pUndoDoc, &aMultiMark );
716cdf0e10cSrcweir
717cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
718cdf0e10cSrcweir new ScUndoTransliterate( &rDocShell, aMultiMark, pUndoDoc, nType ) );
719cdf0e10cSrcweir }
720cdf0e10cSrcweir
721cdf0e10cSrcweir pDoc->TransliterateText( aMultiMark, nType );
722cdf0e10cSrcweir
723cdf0e10cSrcweir if (!AdjustRowHeight( aMarkRange ))
724cdf0e10cSrcweir rDocShell.PostPaint( aMarkRange, PAINT_GRID );
725cdf0e10cSrcweir
726cdf0e10cSrcweir aModificator.SetDocumentModified();
727cdf0e10cSrcweir
728cdf0e10cSrcweir return sal_True;
729cdf0e10cSrcweir }
730cdf0e10cSrcweir
731cdf0e10cSrcweir //------------------------------------------------------------------------
732cdf0e10cSrcweir
SetNormalString(const ScAddress & rPos,const String & rText,sal_Bool bApi)733cdf0e10cSrcweir sal_Bool ScDocFunc::SetNormalString( const ScAddress& rPos, const String& rText, sal_Bool bApi )
734cdf0e10cSrcweir {
735cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
736cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
737cdf0e10cSrcweir
738cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
739cdf0e10cSrcweir ScEditableTester aTester( pDoc, rPos.Tab(), rPos.Col(),rPos.Row(), rPos.Col(),rPos.Row() );
740cdf0e10cSrcweir if (!aTester.IsEditable())
741cdf0e10cSrcweir {
742cdf0e10cSrcweir if (!bApi)
743cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
744cdf0e10cSrcweir return sal_False;
745cdf0e10cSrcweir }
746cdf0e10cSrcweir
747cdf0e10cSrcweir SCTAB* pTabs = NULL;
748cdf0e10cSrcweir ScBaseCell** ppOldCells = NULL;
749cdf0e10cSrcweir sal_Bool* pHasFormat = NULL;
750cdf0e10cSrcweir sal_uLong* pOldFormats = NULL;
751cdf0e10cSrcweir ScBaseCell* pDocCell = pDoc->GetCell( rPos );
752cdf0e10cSrcweir sal_Bool bEditDeleted = (pDocCell && pDocCell->GetCellType() == CELLTYPE_EDIT);
753cdf0e10cSrcweir if (bUndo)
754cdf0e10cSrcweir {
755cdf0e10cSrcweir pTabs = new SCTAB[1];
756cdf0e10cSrcweir pTabs[0] = rPos.Tab();
757cdf0e10cSrcweir ppOldCells = new ScBaseCell*[1];
758cdf0e10cSrcweir ppOldCells[0] = pDocCell ? pDocCell->CloneWithoutNote( *pDoc ) : 0;
759cdf0e10cSrcweir
760cdf0e10cSrcweir pHasFormat = new sal_Bool[1];
761cdf0e10cSrcweir pOldFormats = new sal_uLong[1];
762cdf0e10cSrcweir const SfxPoolItem* pItem;
763cdf0e10cSrcweir const ScPatternAttr* pPattern = pDoc->GetPattern( rPos.Col(),rPos.Row(),rPos.Tab() );
764cdf0e10cSrcweir if ( SFX_ITEM_SET == pPattern->GetItemSet().GetItemState(
765cdf0e10cSrcweir ATTR_VALUE_FORMAT,sal_False,&pItem) )
766cdf0e10cSrcweir {
767cdf0e10cSrcweir pHasFormat[0] = sal_True;
768cdf0e10cSrcweir pOldFormats[0] = ((const SfxUInt32Item*)pItem)->GetValue();
769cdf0e10cSrcweir }
770cdf0e10cSrcweir else
771cdf0e10cSrcweir pHasFormat[0] = sal_False;
772cdf0e10cSrcweir }
773cdf0e10cSrcweir
774cdf0e10cSrcweir pDoc->SetString( rPos.Col(), rPos.Row(), rPos.Tab(), rText );
775cdf0e10cSrcweir
776cdf0e10cSrcweir if (bUndo)
777cdf0e10cSrcweir {
778cdf0e10cSrcweir // wegen ChangeTracking darf UndoAction erst nach SetString angelegt werden
779cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(new ScUndoEnterData( &rDocShell, rPos.Col(),rPos.Row(),rPos.Tab(), 1,pTabs,
780cdf0e10cSrcweir ppOldCells, pHasFormat, pOldFormats, rText, NULL ) );
781cdf0e10cSrcweir }
782cdf0e10cSrcweir
783cdf0e10cSrcweir if ( bEditDeleted || pDoc->HasAttrib( ScRange(rPos), HASATTR_NEEDHEIGHT ) )
784cdf0e10cSrcweir AdjustRowHeight( ScRange(rPos) );
785cdf0e10cSrcweir
786cdf0e10cSrcweir rDocShell.PostPaintCell( rPos );
787cdf0e10cSrcweir aModificator.SetDocumentModified();
788cdf0e10cSrcweir
789cdf0e10cSrcweir // #107160# notify input handler here the same way as in PutCell
790cdf0e10cSrcweir if (bApi)
791cdf0e10cSrcweir NotifyInputHandler( rPos );
792cdf0e10cSrcweir
793cdf0e10cSrcweir return sal_True;
794cdf0e10cSrcweir }
795cdf0e10cSrcweir
PutCell(const ScAddress & rPos,ScBaseCell * pNewCell,sal_Bool bApi)796cdf0e10cSrcweir sal_Bool ScDocFunc::PutCell( const ScAddress& rPos, ScBaseCell* pNewCell, sal_Bool bApi )
797cdf0e10cSrcweir {
798cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
799cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
800cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
801cdf0e10cSrcweir sal_Bool bXMLLoading(pDoc->IsImportingXML());
802cdf0e10cSrcweir
80386e1cf34SPedro Giffuni // #i925#; it is not necessary to test whether the cell is editable on loading a XML document
804cdf0e10cSrcweir if (!bXMLLoading)
805cdf0e10cSrcweir {
806cdf0e10cSrcweir ScEditableTester aTester( pDoc, rPos.Tab(), rPos.Col(),rPos.Row(), rPos.Col(),rPos.Row() );
807cdf0e10cSrcweir if (!aTester.IsEditable())
808cdf0e10cSrcweir {
809cdf0e10cSrcweir if (!bApi)
810cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
811cdf0e10cSrcweir pNewCell->Delete();
812cdf0e10cSrcweir return sal_False;
813cdf0e10cSrcweir }
814cdf0e10cSrcweir }
815cdf0e10cSrcweir
816cdf0e10cSrcweir sal_Bool bEditCell = ( pNewCell->GetCellType() == CELLTYPE_EDIT );
817cdf0e10cSrcweir ScBaseCell* pDocCell = pDoc->GetCell( rPos );
818cdf0e10cSrcweir sal_Bool bEditDeleted = (pDocCell && pDocCell->GetCellType() == CELLTYPE_EDIT);
819cdf0e10cSrcweir sal_Bool bHeight = ( bEditDeleted || bEditCell ||
820cdf0e10cSrcweir pDoc->HasAttrib( ScRange(rPos), HASATTR_NEEDHEIGHT ) );
821cdf0e10cSrcweir
822cdf0e10cSrcweir ScBaseCell* pUndoCell = (bUndo && pDocCell) ? pDocCell->CloneWithoutNote( *pDoc, rPos ) : 0;
823cdf0e10cSrcweir ScBaseCell* pRedoCell = (bUndo && pNewCell) ? pNewCell->CloneWithoutNote( *pDoc, rPos ) : 0;
824cdf0e10cSrcweir
825cdf0e10cSrcweir pDoc->PutCell( rPos, pNewCell );
826cdf0e10cSrcweir
827cdf0e10cSrcweir // wegen ChangeTracking darf UndoAction erst nach PutCell angelegt werden
828cdf0e10cSrcweir if (bUndo)
829cdf0e10cSrcweir {
830cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
831cdf0e10cSrcweir new ScUndoPutCell( &rDocShell, rPos, pUndoCell, pRedoCell, bHeight ) );
832cdf0e10cSrcweir }
833cdf0e10cSrcweir
834cdf0e10cSrcweir if (bHeight)
835cdf0e10cSrcweir AdjustRowHeight( ScRange(rPos) );
836cdf0e10cSrcweir
837cdf0e10cSrcweir if (!bXMLLoading)
838cdf0e10cSrcweir rDocShell.PostPaintCell( rPos );
839cdf0e10cSrcweir
840cdf0e10cSrcweir aModificator.SetDocumentModified();
841cdf0e10cSrcweir
84286e1cf34SPedro Giffuni // #i925#; it is not necessary to notify on loading a XML document
843cdf0e10cSrcweir // #103934#; notify editline and cell in edit mode
844cdf0e10cSrcweir if (bApi && !bXMLLoading)
845cdf0e10cSrcweir NotifyInputHandler( rPos );
846cdf0e10cSrcweir
847cdf0e10cSrcweir return sal_True;
848cdf0e10cSrcweir }
849cdf0e10cSrcweir
NotifyInputHandler(const ScAddress & rPos)850cdf0e10cSrcweir void ScDocFunc::NotifyInputHandler( const ScAddress& rPos )
851cdf0e10cSrcweir {
852cdf0e10cSrcweir ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
853cdf0e10cSrcweir if ( pViewSh && pViewSh->GetViewData()->GetDocShell() == &rDocShell )
854cdf0e10cSrcweir {
855cdf0e10cSrcweir ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl();
856cdf0e10cSrcweir if ( pInputHdl && pInputHdl->GetCursorPos() == rPos )
857cdf0e10cSrcweir {
858cdf0e10cSrcweir sal_Bool bIsEditMode(pInputHdl->IsEditMode());
859cdf0e10cSrcweir
860cdf0e10cSrcweir // set modified if in editmode, because so the string is not set in the InputWindow like in the cell
861cdf0e10cSrcweir // (the cell shows the same like the InputWindow)
862cdf0e10cSrcweir if (bIsEditMode)
863cdf0e10cSrcweir pInputHdl->SetModified();
864cdf0e10cSrcweir pViewSh->UpdateInputHandler(sal_False, !bIsEditMode);
865cdf0e10cSrcweir }
866cdf0e10cSrcweir }
867cdf0e10cSrcweir }
868cdf0e10cSrcweir
869cdf0e10cSrcweir struct ScMyRememberItem
870cdf0e10cSrcweir {
871*7a980842SDamjanJovanovic sal_uInt32 nIndex;
872cdf0e10cSrcweir SfxItemSet aItemSet;
873cdf0e10cSrcweir
ScMyRememberItemScMyRememberItem874*7a980842SDamjanJovanovic ScMyRememberItem(const SfxItemSet& rItemSet, sal_uInt32 nTempIndex) :
875cdf0e10cSrcweir nIndex(nTempIndex), aItemSet(rItemSet) {}
876cdf0e10cSrcweir };
877cdf0e10cSrcweir
878cdf0e10cSrcweir typedef ::std::list<ScMyRememberItem*> ScMyRememberItemList;
879cdf0e10cSrcweir
PutData(const ScAddress & rPos,ScEditEngineDefaulter & rEngine,sal_Bool bInterpret,sal_Bool bApi)880cdf0e10cSrcweir sal_Bool ScDocFunc::PutData( const ScAddress& rPos, ScEditEngineDefaulter& rEngine, sal_Bool bInterpret, sal_Bool bApi )
881cdf0e10cSrcweir {
882cdf0e10cSrcweir // PutData ruft PutCell oder SetNormalString
883cdf0e10cSrcweir
884cdf0e10cSrcweir sal_Bool bRet = sal_False;
885cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
886cdf0e10cSrcweir ScEditAttrTester aTester( &rEngine );
887cdf0e10cSrcweir sal_Bool bEditCell = aTester.NeedsObject();
888cdf0e10cSrcweir if ( bEditCell )
889cdf0e10cSrcweir {
890cdf0e10cSrcweir // #i61702# With bLoseContent set, the content of rEngine isn't restored
891cdf0e10cSrcweir // (used in loading XML, where after the removeActionLock call the API obejct's
892cdf0e10cSrcweir // EditEngine isn't accessed again.
893cdf0e10cSrcweir sal_Bool bLoseContent = pDoc->IsImportingXML();
894cdf0e10cSrcweir
895cdf0e10cSrcweir sal_Bool bUpdateMode(rEngine.GetUpdateMode());
896cdf0e10cSrcweir if (bUpdateMode)
897cdf0e10cSrcweir rEngine.SetUpdateMode(sal_False);
898cdf0e10cSrcweir
899cdf0e10cSrcweir ScMyRememberItemList aRememberItems;
900cdf0e10cSrcweir ScMyRememberItem* pRememberItem = NULL;
901cdf0e10cSrcweir
902cdf0e10cSrcweir // All paragraph attributes must be removed before calling CreateTextObject,
903cdf0e10cSrcweir // not only alignment, so the object doesn't contain the cell attributes as
904cdf0e10cSrcweir // paragraph attributes. Before remove the attributes store they in a list to
905cdf0e10cSrcweir // set they back to the EditEngine.
906*7a980842SDamjanJovanovic sal_uInt32 nCount = rEngine.GetParagraphCount();
907*7a980842SDamjanJovanovic for (sal_uInt32 i=0; i<nCount; i++)
908cdf0e10cSrcweir {
909cdf0e10cSrcweir const SfxItemSet& rOld = rEngine.GetParaAttribs( i );
910cdf0e10cSrcweir if ( rOld.Count() )
911cdf0e10cSrcweir {
912cdf0e10cSrcweir if ( !bLoseContent )
913cdf0e10cSrcweir {
914cdf0e10cSrcweir pRememberItem = new ScMyRememberItem(rEngine.GetParaAttribs(i), i);
915cdf0e10cSrcweir aRememberItems.push_back(pRememberItem);
916cdf0e10cSrcweir }
917cdf0e10cSrcweir rEngine.SetParaAttribs( i, SfxItemSet( *rOld.GetPool(), rOld.GetRanges() ) );
918cdf0e10cSrcweir }
919cdf0e10cSrcweir }
920cdf0e10cSrcweir
921cdf0e10cSrcweir EditTextObject* pNewData = rEngine.CreateTextObject();
922cdf0e10cSrcweir bRet = PutCell( rPos,
923cdf0e10cSrcweir new ScEditCell( pNewData, pDoc, rEngine.GetEditTextObjectPool() ),
924cdf0e10cSrcweir bApi );
925cdf0e10cSrcweir delete pNewData;
926cdf0e10cSrcweir
927cdf0e10cSrcweir // Set the paragraph attributes back to the EditEngine.
928cdf0e10cSrcweir if (!aRememberItems.empty())
929cdf0e10cSrcweir {
930cdf0e10cSrcweir // ScMyRememberItem* pRememberItem = NULL;
931cdf0e10cSrcweir ScMyRememberItemList::iterator aItr = aRememberItems.begin();
932cdf0e10cSrcweir while (aItr != aRememberItems.end())
933cdf0e10cSrcweir {
934cdf0e10cSrcweir pRememberItem = *aItr;
935cdf0e10cSrcweir rEngine.SetParaAttribs(pRememberItem->nIndex, pRememberItem->aItemSet);
936cdf0e10cSrcweir delete pRememberItem;
937cdf0e10cSrcweir aItr = aRememberItems.erase(aItr);
938cdf0e10cSrcweir }
939cdf0e10cSrcweir }
940cdf0e10cSrcweir
941cdf0e10cSrcweir // #i61702# if the content isn't accessed, there's no need to set the UpdateMode again
942cdf0e10cSrcweir if ( bUpdateMode && !bLoseContent )
943cdf0e10cSrcweir rEngine.SetUpdateMode(sal_True);
944cdf0e10cSrcweir }
945cdf0e10cSrcweir else
946cdf0e10cSrcweir {
947cdf0e10cSrcweir String aText = rEngine.GetText();
948cdf0e10cSrcweir if ( bInterpret || !aText.Len() )
949cdf0e10cSrcweir bRet = SetNormalString( rPos, aText, bApi );
950cdf0e10cSrcweir else
951cdf0e10cSrcweir bRet = PutCell( rPos, new ScStringCell( aText ), bApi );
952cdf0e10cSrcweir }
953cdf0e10cSrcweir
954cdf0e10cSrcweir if ( bRet && aTester.NeedsCellAttr() )
955cdf0e10cSrcweir {
956cdf0e10cSrcweir const SfxItemSet& rEditAttr = aTester.GetAttribs();
957cdf0e10cSrcweir ScPatternAttr aPattern( pDoc->GetPool() );
958cdf0e10cSrcweir aPattern.GetFromEditItemSet( &rEditAttr );
959cdf0e10cSrcweir aPattern.DeleteUnchanged( pDoc->GetPattern( rPos.Col(), rPos.Row(), rPos.Tab() ) );
960cdf0e10cSrcweir aPattern.GetItemSet().ClearItem( ATTR_HOR_JUSTIFY ); // wasn't removed above if no edit object
961cdf0e10cSrcweir if ( aPattern.GetItemSet().Count() > 0 )
962cdf0e10cSrcweir {
963cdf0e10cSrcweir ScMarkData aMark;
964cdf0e10cSrcweir aMark.SelectTable( rPos.Tab(), sal_True );
965cdf0e10cSrcweir aMark.SetMarkArea( ScRange( rPos ) );
966cdf0e10cSrcweir ApplyAttributes( aMark, aPattern, sal_True, bApi );
967cdf0e10cSrcweir }
968cdf0e10cSrcweir }
969cdf0e10cSrcweir
970cdf0e10cSrcweir return bRet;
971cdf0e10cSrcweir }
972cdf0e10cSrcweir
973cdf0e10cSrcweir
lcl_ScDocFunc_CreateTokenArrayXML(const String & rText,const String & rFormulaNmsp,const formula::FormulaGrammar::Grammar eGrammar)974cdf0e10cSrcweir ScTokenArray* lcl_ScDocFunc_CreateTokenArrayXML( const String& rText, const String& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar )
975cdf0e10cSrcweir {
976cdf0e10cSrcweir ScTokenArray* pCode = new ScTokenArray;
977cdf0e10cSrcweir pCode->AddString( rText );
978cdf0e10cSrcweir if( (eGrammar == formula::FormulaGrammar::GRAM_EXTERNAL) && (rFormulaNmsp.Len() > 0) )
979cdf0e10cSrcweir pCode->AddString( rFormulaNmsp );
980cdf0e10cSrcweir return pCode;
981cdf0e10cSrcweir }
982cdf0e10cSrcweir
983cdf0e10cSrcweir
InterpretEnglishString(const ScAddress & rPos,const String & rText,const String & rFormulaNmsp,const formula::FormulaGrammar::Grammar eGrammar,short * pRetFormatType)984cdf0e10cSrcweir ScBaseCell* ScDocFunc::InterpretEnglishString( const ScAddress& rPos,
985cdf0e10cSrcweir const String& rText, const String& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar, short* pRetFormatType )
986cdf0e10cSrcweir {
987cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
988cdf0e10cSrcweir ScBaseCell* pNewCell = NULL;
989cdf0e10cSrcweir
990cdf0e10cSrcweir if ( rText.Len() > 1 && rText.GetChar(0) == '=' )
991cdf0e10cSrcweir {
992cdf0e10cSrcweir ScTokenArray* pCode;
993cdf0e10cSrcweir if ( pDoc->IsImportingXML() )
994cdf0e10cSrcweir { // temporary formula string as string tokens
995cdf0e10cSrcweir pCode = lcl_ScDocFunc_CreateTokenArrayXML( rText, rFormulaNmsp, eGrammar );
996cdf0e10cSrcweir pDoc->IncXMLImportedFormulaCount( rText.Len() );
997cdf0e10cSrcweir }
998cdf0e10cSrcweir else
999cdf0e10cSrcweir {
1000cdf0e10cSrcweir ScCompiler aComp( pDoc, rPos );
1001cdf0e10cSrcweir aComp.SetGrammar(eGrammar);
1002cdf0e10cSrcweir pCode = aComp.CompileString( rText );
1003cdf0e10cSrcweir }
1004cdf0e10cSrcweir pNewCell = new ScFormulaCell( pDoc, rPos, pCode, eGrammar, MM_NONE );
1005cdf0e10cSrcweir delete pCode; // Zell-ctor hat das TokenArray kopiert
1006cdf0e10cSrcweir }
1007cdf0e10cSrcweir else if ( rText.Len() > 1 && rText.GetChar(0) == '\'' )
1008cdf0e10cSrcweir {
1009cdf0e10cSrcweir // for bEnglish, "'" at the beginning is always interpreted as text
1010cdf0e10cSrcweir // marker and stripped
1011cdf0e10cSrcweir pNewCell = ScBaseCell::CreateTextCell( rText.Copy( 1 ), pDoc );
1012cdf0e10cSrcweir }
1013cdf0e10cSrcweir else // (nur) auf englisches Zahlformat testen
1014cdf0e10cSrcweir {
1015cdf0e10cSrcweir SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
1016cdf0e10cSrcweir sal_uInt32 nEnglish = pFormatter->GetStandardIndex(LANGUAGE_ENGLISH_US);
1017cdf0e10cSrcweir double fVal;
1018cdf0e10cSrcweir if ( pFormatter->IsNumberFormat( rText, nEnglish, fVal ) )
1019cdf0e10cSrcweir {
1020cdf0e10cSrcweir pNewCell = new ScValueCell( fVal );
1021cdf0e10cSrcweir // return the format type from the English format, so a localized format can be created
1022cdf0e10cSrcweir if ( pRetFormatType )
1023cdf0e10cSrcweir *pRetFormatType = pFormatter->GetType( nEnglish );
1024cdf0e10cSrcweir }
1025cdf0e10cSrcweir else if ( rText.Len() )
1026cdf0e10cSrcweir pNewCell = ScBaseCell::CreateTextCell( rText, pDoc );
1027cdf0e10cSrcweir
1028cdf0e10cSrcweir // das (englische) Zahlformat wird nicht gesetzt
1029cdf0e10cSrcweir //! passendes lokales Format suchen und setzen???
1030cdf0e10cSrcweir }
1031cdf0e10cSrcweir
1032cdf0e10cSrcweir return pNewCell;
1033cdf0e10cSrcweir }
1034cdf0e10cSrcweir
1035cdf0e10cSrcweir
SetCellText(const ScAddress & rPos,const String & rText,sal_Bool bInterpret,sal_Bool bEnglish,sal_Bool bApi,const String & rFormulaNmsp,const formula::FormulaGrammar::Grammar eGrammar)1036cdf0e10cSrcweir sal_Bool ScDocFunc::SetCellText( const ScAddress& rPos, const String& rText,
1037cdf0e10cSrcweir sal_Bool bInterpret, sal_Bool bEnglish, sal_Bool bApi,
1038cdf0e10cSrcweir const String& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar )
1039cdf0e10cSrcweir {
1040cdf0e10cSrcweir // SetCellText ruft PutCell oder SetNormalString
1041cdf0e10cSrcweir
1042cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
1043cdf0e10cSrcweir ScBaseCell* pNewCell = NULL;
1044cdf0e10cSrcweir if ( bInterpret )
1045cdf0e10cSrcweir {
1046cdf0e10cSrcweir if ( bEnglish )
1047cdf0e10cSrcweir {
1048cdf0e10cSrcweir ::boost::scoped_ptr<ScExternalRefManager::ApiGuard> pExtRefGuard;
1049cdf0e10cSrcweir if (bApi)
1050cdf0e10cSrcweir pExtRefGuard.reset(new ScExternalRefManager::ApiGuard(pDoc));
1051cdf0e10cSrcweir
1052cdf0e10cSrcweir // code moved to own method InterpretEnglishString because it is also used in
1053cdf0e10cSrcweir // ScCellRangeObj::setFormulaArray
1054cdf0e10cSrcweir
1055cdf0e10cSrcweir pNewCell = InterpretEnglishString( rPos, rText, rFormulaNmsp, eGrammar );
1056cdf0e10cSrcweir }
1057cdf0e10cSrcweir // sonst Null behalten -> SetString mit lokalen Formeln/Zahlformat
1058cdf0e10cSrcweir }
1059cdf0e10cSrcweir else if ( rText.Len() )
1060cdf0e10cSrcweir {
1061cdf0e10cSrcweir OSL_ENSURE( rFormulaNmsp.Len() == 0, "ScDocFunc::SetCellText - formula namespace, but do not interpret?" );
1062cdf0e10cSrcweir pNewCell = ScBaseCell::CreateTextCell( rText, pDoc ); // immer Text
1063cdf0e10cSrcweir }
1064cdf0e10cSrcweir
1065cdf0e10cSrcweir if (pNewCell)
1066cdf0e10cSrcweir return PutCell( rPos, pNewCell, bApi );
1067cdf0e10cSrcweir else
1068cdf0e10cSrcweir return SetNormalString( rPos, rText, bApi );
1069cdf0e10cSrcweir }
1070cdf0e10cSrcweir
1071cdf0e10cSrcweir //------------------------------------------------------------------------
1072cdf0e10cSrcweir
ShowNote(const ScAddress & rPos,bool bShow)1073cdf0e10cSrcweir bool ScDocFunc::ShowNote( const ScAddress& rPos, bool bShow )
1074cdf0e10cSrcweir {
1075cdf0e10cSrcweir ScDocument& rDoc = *rDocShell.GetDocument();
1076cdf0e10cSrcweir ScPostIt* pNote = rDoc.GetNote( rPos );
1077cdf0e10cSrcweir if( !pNote || (bShow == pNote->IsCaptionShown()) ) return false;
1078cdf0e10cSrcweir
1079cdf0e10cSrcweir // move the caption to internal or hidden layer and create undo action
1080cdf0e10cSrcweir pNote->ShowCaption( rPos, bShow );
1081cdf0e10cSrcweir if( rDoc.IsUndoEnabled() )
1082cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( new ScUndoShowHideNote( rDocShell, rPos, bShow ) );
1083cdf0e10cSrcweir
1084cdf0e10cSrcweir if (rDoc.IsStreamValid(rPos.Tab()))
1085cdf0e10cSrcweir rDoc.SetStreamValid(rPos.Tab(), sal_False);
1086cdf0e10cSrcweir
1087cdf0e10cSrcweir rDocShell.SetDocumentModified();
1088cdf0e10cSrcweir
1089cdf0e10cSrcweir return true;
1090cdf0e10cSrcweir }
1091cdf0e10cSrcweir
1092cdf0e10cSrcweir //------------------------------------------------------------------------
1093cdf0e10cSrcweir
SetNoteText(const ScAddress & rPos,const String & rText,sal_Bool bApi)1094cdf0e10cSrcweir bool ScDocFunc::SetNoteText( const ScAddress& rPos, const String& rText, sal_Bool bApi )
1095cdf0e10cSrcweir {
1096cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
1097cdf0e10cSrcweir
1098cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
1099cdf0e10cSrcweir ScEditableTester aTester( pDoc, rPos.Tab(), rPos.Col(),rPos.Row(), rPos.Col(),rPos.Row() );
1100cdf0e10cSrcweir if (!aTester.IsEditable())
1101cdf0e10cSrcweir {
1102cdf0e10cSrcweir if (!bApi)
1103cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
1104cdf0e10cSrcweir return false;
1105cdf0e10cSrcweir }
1106cdf0e10cSrcweir
1107cdf0e10cSrcweir String aNewText = rText;
1108cdf0e10cSrcweir aNewText.ConvertLineEnd(); //! ist das noetig ???
1109cdf0e10cSrcweir
1110cdf0e10cSrcweir if( ScPostIt* pNote = (aNewText.Len() > 0) ? pDoc->GetOrCreateNote( rPos ) : pDoc->GetNote( rPos ) )
1111cdf0e10cSrcweir pNote->SetText( rPos, aNewText );
1112cdf0e10cSrcweir
1113cdf0e10cSrcweir //! Undo !!!
1114cdf0e10cSrcweir
1115cdf0e10cSrcweir if (pDoc->IsStreamValid(rPos.Tab()))
1116cdf0e10cSrcweir pDoc->SetStreamValid(rPos.Tab(), sal_False);
1117cdf0e10cSrcweir
1118cdf0e10cSrcweir rDocShell.PostPaintCell( rPos );
1119cdf0e10cSrcweir aModificator.SetDocumentModified();
1120cdf0e10cSrcweir
1121cdf0e10cSrcweir return true;
1122cdf0e10cSrcweir }
1123cdf0e10cSrcweir
1124cdf0e10cSrcweir //------------------------------------------------------------------------
1125cdf0e10cSrcweir
ReplaceNote(const ScAddress & rPos,const String & rNoteText,const String * pAuthor,const String * pDate,sal_Bool bApi)1126cdf0e10cSrcweir bool ScDocFunc::ReplaceNote( const ScAddress& rPos, const String& rNoteText, const String* pAuthor, const String* pDate, sal_Bool bApi )
1127cdf0e10cSrcweir {
1128cdf0e10cSrcweir bool bDone = false;
1129cdf0e10cSrcweir
1130cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
1131cdf0e10cSrcweir ScDocument& rDoc = *rDocShell.GetDocument();
1132cdf0e10cSrcweir ScEditableTester aTester( &rDoc, rPos.Tab(), rPos.Col(),rPos.Row(), rPos.Col(),rPos.Row() );
1133cdf0e10cSrcweir if (aTester.IsEditable())
1134cdf0e10cSrcweir {
1135cdf0e10cSrcweir ScDrawLayer* pDrawLayer = rDoc.GetDrawLayer();
1136cdf0e10cSrcweir ::svl::IUndoManager* pUndoMgr = (pDrawLayer && rDoc.IsUndoEnabled()) ? rDocShell.GetUndoManager() : 0;
1137cdf0e10cSrcweir
1138cdf0e10cSrcweir ScNoteData aOldData;
1139cdf0e10cSrcweir ScPostIt* pOldNote = rDoc.ReleaseNote( rPos );
1140cdf0e10cSrcweir if( pOldNote )
1141cdf0e10cSrcweir {
1142cdf0e10cSrcweir // ensure existing caption object before draw undo tracking starts
1143cdf0e10cSrcweir pOldNote->GetOrCreateCaption( rPos );
1144cdf0e10cSrcweir // rescue note data for undo
1145cdf0e10cSrcweir aOldData = pOldNote->GetNoteData();
1146cdf0e10cSrcweir }
1147cdf0e10cSrcweir
1148cdf0e10cSrcweir // collect drawing undo actions for deleting/inserting caption obejcts
1149cdf0e10cSrcweir if( pUndoMgr )
1150a840a559SArmin Le Grand pDrawLayer->BeginCalcUndo(false);
1151cdf0e10cSrcweir
1152cdf0e10cSrcweir // delete the note (creates drawing undo action for the caption object)
1153cdf0e10cSrcweir delete pOldNote;
1154cdf0e10cSrcweir
1155cdf0e10cSrcweir // create new note (creates drawing undo action for the new caption object)
1156cdf0e10cSrcweir ScNoteData aNewData;
1157cdf0e10cSrcweir if( ScPostIt* pNewNote = ScNoteUtil::CreateNoteFromString( rDoc, rPos, rNoteText, false, true ) )
1158cdf0e10cSrcweir {
1159cdf0e10cSrcweir if( pAuthor ) pNewNote->SetAuthor( *pAuthor );
1160cdf0e10cSrcweir if( pDate ) pNewNote->SetDate( *pDate );
1161cdf0e10cSrcweir // rescue note data for undo
1162cdf0e10cSrcweir aNewData = pNewNote->GetNoteData();
1163cdf0e10cSrcweir }
1164cdf0e10cSrcweir
1165cdf0e10cSrcweir // create the undo action
1166cdf0e10cSrcweir if( pUndoMgr && (aOldData.mpCaption || aNewData.mpCaption) )
1167cdf0e10cSrcweir pUndoMgr->AddUndoAction( new ScUndoReplaceNote( rDocShell, rPos, aOldData, aNewData, pDrawLayer->GetCalcUndo() ) );
1168cdf0e10cSrcweir
1169cdf0e10cSrcweir // repaint cell (to make note marker visible)
1170cdf0e10cSrcweir rDocShell.PostPaintCell( rPos );
1171cdf0e10cSrcweir
1172cdf0e10cSrcweir if (rDoc.IsStreamValid(rPos.Tab()))
1173cdf0e10cSrcweir rDoc.SetStreamValid(rPos.Tab(), sal_False);
1174cdf0e10cSrcweir
1175cdf0e10cSrcweir aModificator.SetDocumentModified();
1176cdf0e10cSrcweir bDone = true;
1177cdf0e10cSrcweir }
1178cdf0e10cSrcweir else if (!bApi)
1179cdf0e10cSrcweir {
1180cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
1181cdf0e10cSrcweir }
1182cdf0e10cSrcweir
1183cdf0e10cSrcweir return bDone;
1184cdf0e10cSrcweir }
1185cdf0e10cSrcweir
1186cdf0e10cSrcweir //------------------------------------------------------------------------
1187cdf0e10cSrcweir
ApplyAttributes(const ScMarkData & rMark,const ScPatternAttr & rPattern,sal_Bool bRecord,sal_Bool bApi)1188cdf0e10cSrcweir sal_Bool ScDocFunc::ApplyAttributes( const ScMarkData& rMark, const ScPatternAttr& rPattern,
1189cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi )
1190cdf0e10cSrcweir {
1191cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
1192cdf0e10cSrcweir if ( bRecord && !pDoc->IsUndoEnabled() )
1193cdf0e10cSrcweir bRecord = sal_False;
1194cdf0e10cSrcweir
1195cdf0e10cSrcweir sal_Bool bImportingXML = pDoc->IsImportingXML();
1196cdf0e10cSrcweir // Cell formats can still be set if the range isn't editable only because of matrix formulas.
1197cdf0e10cSrcweir // #i62483# When loading XML, the check can be skipped altogether.
1198cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1199cdf0e10cSrcweir if ( !bImportingXML && !pDoc->IsSelectionEditable( rMark, &bOnlyNotBecauseOfMatrix )
1200cdf0e10cSrcweir && !bOnlyNotBecauseOfMatrix )
1201cdf0e10cSrcweir {
1202cdf0e10cSrcweir if (!bApi)
1203cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR);
1204cdf0e10cSrcweir return sal_False;
1205cdf0e10cSrcweir }
1206cdf0e10cSrcweir
1207cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
1208cdf0e10cSrcweir
1209cdf0e10cSrcweir //! Umrandung
1210cdf0e10cSrcweir
1211cdf0e10cSrcweir ScRange aMultiRange;
1212cdf0e10cSrcweir sal_Bool bMulti = rMark.IsMultiMarked();
1213cdf0e10cSrcweir if ( bMulti )
1214cdf0e10cSrcweir rMark.GetMultiMarkArea( aMultiRange );
1215cdf0e10cSrcweir else
1216cdf0e10cSrcweir rMark.GetMarkArea( aMultiRange );
1217cdf0e10cSrcweir
1218cdf0e10cSrcweir if ( bRecord )
1219cdf0e10cSrcweir {
1220cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1221cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, aMultiRange.aStart.Tab(), aMultiRange.aEnd.Tab() );
1222cdf0e10cSrcweir pDoc->CopyToDocument( aMultiRange, IDF_ATTRIB, bMulti, pUndoDoc, &rMark );
1223cdf0e10cSrcweir
1224cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
1225cdf0e10cSrcweir new ScUndoSelectionAttr(
1226cdf0e10cSrcweir &rDocShell, rMark,
1227cdf0e10cSrcweir aMultiRange.aStart.Col(), aMultiRange.aStart.Row(), aMultiRange.aStart.Tab(),
1228cdf0e10cSrcweir aMultiRange.aEnd.Col(), aMultiRange.aEnd.Row(), aMultiRange.aEnd.Tab(),
1229cdf0e10cSrcweir pUndoDoc, bMulti, &rPattern ) );
1230cdf0e10cSrcweir }
1231cdf0e10cSrcweir
123286e1cf34SPedro Giffuni // While loading XML it is not necessary to ask HasAttrib. It needs too much time.
1233cdf0e10cSrcweir sal_uInt16 nExtFlags = 0;
1234cdf0e10cSrcweir if ( !bImportingXML )
1235cdf0e10cSrcweir rDocShell.UpdatePaintExt( nExtFlags, aMultiRange ); // content before the change
1236cdf0e10cSrcweir pDoc->ApplySelectionPattern( rPattern, rMark );
1237cdf0e10cSrcweir if ( !bImportingXML )
1238cdf0e10cSrcweir rDocShell.UpdatePaintExt( nExtFlags, aMultiRange ); // content after the change
1239cdf0e10cSrcweir
1240cdf0e10cSrcweir if (!AdjustRowHeight( aMultiRange ))
1241cdf0e10cSrcweir rDocShell.PostPaint( aMultiRange, PAINT_GRID, nExtFlags );
1242cdf0e10cSrcweir else if (nExtFlags & SC_PF_LINES)
1243cdf0e10cSrcweir lcl_PaintAbove( rDocShell, aMultiRange ); // fuer Linien ueber dem Bereich
1244cdf0e10cSrcweir
1245cdf0e10cSrcweir aModificator.SetDocumentModified();
1246cdf0e10cSrcweir
1247cdf0e10cSrcweir return sal_True;
1248cdf0e10cSrcweir }
1249cdf0e10cSrcweir
1250cdf0e10cSrcweir
ApplyStyle(const ScMarkData & rMark,const String & rStyleName,sal_Bool bRecord,sal_Bool bApi)1251cdf0e10cSrcweir sal_Bool ScDocFunc::ApplyStyle( const ScMarkData& rMark, const String& rStyleName,
1252cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi )
1253cdf0e10cSrcweir {
1254cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
1255cdf0e10cSrcweir if ( bRecord && !pDoc->IsUndoEnabled() )
1256cdf0e10cSrcweir bRecord = sal_False;
1257cdf0e10cSrcweir
1258cdf0e10cSrcweir sal_Bool bImportingXML = pDoc->IsImportingXML();
1259cdf0e10cSrcweir // Cell formats can still be set if the range isn't editable only because of matrix formulas.
1260cdf0e10cSrcweir // #i62483# When loading XML, the check can be skipped altogether.
1261cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1262cdf0e10cSrcweir if ( !bImportingXML && !pDoc->IsSelectionEditable( rMark, &bOnlyNotBecauseOfMatrix )
1263cdf0e10cSrcweir && !bOnlyNotBecauseOfMatrix )
1264cdf0e10cSrcweir {
1265cdf0e10cSrcweir if (!bApi)
1266cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR);
1267cdf0e10cSrcweir return sal_False;
1268cdf0e10cSrcweir }
1269cdf0e10cSrcweir
1270cdf0e10cSrcweir ScStyleSheet* pStyleSheet = (ScStyleSheet*) pDoc->GetStyleSheetPool()->Find(
1271cdf0e10cSrcweir rStyleName, SFX_STYLE_FAMILY_PARA );
1272cdf0e10cSrcweir if (!pStyleSheet)
1273cdf0e10cSrcweir return sal_False;
1274cdf0e10cSrcweir
1275cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
1276cdf0e10cSrcweir
1277cdf0e10cSrcweir ScRange aMultiRange;
1278cdf0e10cSrcweir sal_Bool bMulti = rMark.IsMultiMarked();
1279cdf0e10cSrcweir if ( bMulti )
1280cdf0e10cSrcweir rMark.GetMultiMarkArea( aMultiRange );
1281cdf0e10cSrcweir else
1282cdf0e10cSrcweir rMark.GetMarkArea( aMultiRange );
1283cdf0e10cSrcweir
1284cdf0e10cSrcweir if ( bRecord )
1285cdf0e10cSrcweir {
1286cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1287cdf0e10cSrcweir SCTAB nStartTab = aMultiRange.aStart.Tab();
1288cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1289cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
1290cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1291cdf0e10cSrcweir if (i != nStartTab && rMark.GetTableSelect(i))
1292cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
1293cdf0e10cSrcweir
1294cdf0e10cSrcweir ScRange aCopyRange = aMultiRange;
1295cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
1296cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
1297cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, bMulti, pUndoDoc, &rMark );
1298cdf0e10cSrcweir
1299cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
1300cdf0e10cSrcweir new ScUndoSelectionStyle(
1301cdf0e10cSrcweir &rDocShell, rMark, aMultiRange, rStyleName, pUndoDoc ) );
1302cdf0e10cSrcweir
1303cdf0e10cSrcweir }
1304cdf0e10cSrcweir
1305cdf0e10cSrcweir // sal_Bool bPaintExt = pDoc->HasAttrib( aMultiRange, HASATTR_PAINTEXT );
1306cdf0e10cSrcweir // pDoc->ApplySelectionPattern( rPattern, rMark );
1307cdf0e10cSrcweir
1308cdf0e10cSrcweir pDoc->ApplySelectionStyle( (ScStyleSheet&)*pStyleSheet, rMark );
1309cdf0e10cSrcweir
1310cdf0e10cSrcweir // if (!bPaintExt)
1311cdf0e10cSrcweir // bPaintExt = pDoc->HasAttrib( aMultiRange, HASATTR_PAINTEXT );
1312cdf0e10cSrcweir // sal_uInt16 nExtFlags = bPaintExt ? SC_PF_LINES : 0;
1313cdf0e10cSrcweir sal_uInt16 nExtFlags = 0;
1314cdf0e10cSrcweir if (!AdjustRowHeight( aMultiRange ))
1315cdf0e10cSrcweir rDocShell.PostPaint( aMultiRange, PAINT_GRID, nExtFlags );
1316cdf0e10cSrcweir else if (nExtFlags & SC_PF_LINES)
1317cdf0e10cSrcweir lcl_PaintAbove( rDocShell, aMultiRange ); // fuer Linien ueber dem Bereich
1318cdf0e10cSrcweir
1319cdf0e10cSrcweir aModificator.SetDocumentModified();
1320cdf0e10cSrcweir
1321cdf0e10cSrcweir return sal_True;
1322cdf0e10cSrcweir }
1323cdf0e10cSrcweir
1324cdf0e10cSrcweir //------------------------------------------------------------------------
1325cdf0e10cSrcweir
InsertCells(const ScRange & rRange,const ScMarkData * pTabMark,InsCellCmd eCmd,sal_Bool bRecord,sal_Bool bApi,sal_Bool bPartOfPaste)1326cdf0e10cSrcweir sal_Bool ScDocFunc::InsertCells( const ScRange& rRange, const ScMarkData* pTabMark, InsCellCmd eCmd,
1327cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi, sal_Bool bPartOfPaste )
1328cdf0e10cSrcweir {
1329cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
1330cdf0e10cSrcweir
1331cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
1332cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
1333cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
1334cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
1335cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
1336cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
1337cdf0e10cSrcweir
1338cdf0e10cSrcweir if ( !ValidRow(nStartRow) || !ValidRow(nEndRow) )
1339cdf0e10cSrcweir {
1340cdf0e10cSrcweir DBG_ERROR("invalid row in InsertCells");
1341cdf0e10cSrcweir return sal_False;
1342cdf0e10cSrcweir }
1343cdf0e10cSrcweir
1344cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
1345cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1346cdf0e10cSrcweir SCCOL nPaintStartX = nStartCol;
1347cdf0e10cSrcweir SCROW nPaintStartY = nStartRow;
1348cdf0e10cSrcweir SCCOL nPaintEndX = nEndCol;
1349cdf0e10cSrcweir SCROW nPaintEndY = nEndRow;
1350cdf0e10cSrcweir sal_uInt16 nPaintFlags = PAINT_GRID;
1351cdf0e10cSrcweir sal_Bool bSuccess;
1352cdf0e10cSrcweir SCTAB i;
1353cdf0e10cSrcweir
1354cdf0e10cSrcweir ScTabViewShell* pViewSh = rDocShell.GetBestViewShell(); //preserve current cursor position
1355cdf0e10cSrcweir SCCOL nCursorCol = 0;
1356cdf0e10cSrcweir SCROW nCursorRow = 0;
1357cdf0e10cSrcweir if( pViewSh )
1358cdf0e10cSrcweir {
1359cdf0e10cSrcweir nCursorCol = pViewSh->GetViewData()->GetCurX();
1360cdf0e10cSrcweir nCursorRow = pViewSh->GetViewData()->GetCurY();
1361cdf0e10cSrcweir }
1362cdf0e10cSrcweir
1363cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1364cdf0e10cSrcweir bRecord = sal_False;
1365cdf0e10cSrcweir
1366cdf0e10cSrcweir ScMarkData aMark;
1367cdf0e10cSrcweir if (pTabMark)
1368cdf0e10cSrcweir aMark = *pTabMark;
1369cdf0e10cSrcweir else
1370cdf0e10cSrcweir {
1371cdf0e10cSrcweir SCTAB nCount = 0;
1372cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1373cdf0e10cSrcweir {
1374cdf0e10cSrcweir if( !pDoc->IsScenario(i) )
1375cdf0e10cSrcweir {
1376cdf0e10cSrcweir nCount++;
1377cdf0e10cSrcweir if( nCount == nEndTab+1 )
1378cdf0e10cSrcweir {
1379cdf0e10cSrcweir aMark.SelectTable( i, sal_True );
1380cdf0e10cSrcweir break;
1381cdf0e10cSrcweir }
1382cdf0e10cSrcweir }
1383cdf0e10cSrcweir }
1384cdf0e10cSrcweir }
1385cdf0e10cSrcweir
1386cdf0e10cSrcweir ScMarkData aFullMark( aMark ); // including scenario sheets
1387cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1388cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
1389cdf0e10cSrcweir {
1390cdf0e10cSrcweir for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
1391cdf0e10cSrcweir aFullMark.SelectTable( j, sal_True );
1392cdf0e10cSrcweir }
1393cdf0e10cSrcweir
1394cdf0e10cSrcweir SCTAB nSelCount = aMark.GetSelectCount();
1395cdf0e10cSrcweir
1396cdf0e10cSrcweir // zugehoerige Szenarien auch anpassen
1397cdf0e10cSrcweir // Test zusammengefasste
1398cdf0e10cSrcweir
1399cdf0e10cSrcweir SCCOL nMergeTestStartX = nStartCol;
1400cdf0e10cSrcweir SCROW nMergeTestStartY = nStartRow;
1401cdf0e10cSrcweir SCCOL nMergeTestEndX = nEndCol;
1402cdf0e10cSrcweir SCROW nMergeTestEndY = nEndRow;
1403cdf0e10cSrcweir
1404cdf0e10cSrcweir ScRange aExtendMergeRange( rRange );
1405cdf0e10cSrcweir
1406cdf0e10cSrcweir if( rRange.aStart == rRange.aEnd && pDoc->HasAttrib(rRange, HASATTR_MERGED) )
1407cdf0e10cSrcweir {
1408cdf0e10cSrcweir pDoc->ExtendMerge( aExtendMergeRange );
1409cdf0e10cSrcweir pDoc->ExtendOverlapped( aExtendMergeRange );
1410cdf0e10cSrcweir nMergeTestEndX = aExtendMergeRange.aEnd.Col();
1411cdf0e10cSrcweir nMergeTestEndY = aExtendMergeRange.aEnd.Row();
1412cdf0e10cSrcweir nPaintEndX = nMergeTestEndX;
1413cdf0e10cSrcweir nPaintEndY = nMergeTestEndY;
1414cdf0e10cSrcweir }
1415cdf0e10cSrcweir
1416cdf0e10cSrcweir if ( eCmd == INS_INSROWS )
1417cdf0e10cSrcweir {
1418cdf0e10cSrcweir nMergeTestStartX = 0;
1419cdf0e10cSrcweir nMergeTestEndX = MAXCOL;
1420cdf0e10cSrcweir }
1421cdf0e10cSrcweir if ( eCmd == INS_INSCOLS )
1422cdf0e10cSrcweir {
1423cdf0e10cSrcweir nMergeTestStartY = 0;
1424cdf0e10cSrcweir nMergeTestEndY = MAXROW;
1425cdf0e10cSrcweir }
1426cdf0e10cSrcweir if ( eCmd == INS_CELLSDOWN )
1427cdf0e10cSrcweir nMergeTestEndY = MAXROW;
1428cdf0e10cSrcweir if ( eCmd == INS_CELLSRIGHT )
1429cdf0e10cSrcweir nMergeTestEndX = MAXCOL;
1430cdf0e10cSrcweir
1431cdf0e10cSrcweir sal_Bool bNeedRefresh = sal_False;
1432cdf0e10cSrcweir
1433cdf0e10cSrcweir SCCOL nEditTestEndX = (eCmd==INS_INSCOLS) ? MAXCOL : nMergeTestEndX;
1434cdf0e10cSrcweir SCROW nEditTestEndY = (eCmd==INS_INSROWS) ? MAXROW : nMergeTestEndY;
1435cdf0e10cSrcweir ScEditableTester aTester( pDoc, nMergeTestStartX, nMergeTestStartY, nEditTestEndX, nEditTestEndY, aMark );
1436cdf0e10cSrcweir if (!aTester.IsEditable())
1437cdf0e10cSrcweir {
1438cdf0e10cSrcweir if (!bApi)
1439cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
1440cdf0e10cSrcweir return sal_False;
1441cdf0e10cSrcweir }
1442cdf0e10cSrcweir
1443cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() ); // wichtig wegen TrackFormulas bei UpdateReference
1444cdf0e10cSrcweir
1445cdf0e10cSrcweir ScDocument* pRefUndoDoc = NULL;
1446cdf0e10cSrcweir ScRefUndoData* pUndoData = NULL;
1447cdf0e10cSrcweir if ( bRecord )
1448cdf0e10cSrcweir {
1449cdf0e10cSrcweir pRefUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1450cdf0e10cSrcweir pRefUndoDoc->InitUndo( pDoc, 0, nTabCount-1, sal_False, sal_False );
1451cdf0e10cSrcweir
1452cdf0e10cSrcweir // pRefUndoDoc is filled in InsertCol / InsertRow
1453cdf0e10cSrcweir
1454cdf0e10cSrcweir pUndoData = new ScRefUndoData( pDoc );
1455cdf0e10cSrcweir
1456cdf0e10cSrcweir pDoc->BeginDrawUndo();
1457cdf0e10cSrcweir }
1458cdf0e10cSrcweir
1459cdf0e10cSrcweir // #i8302 : we unmerge overwhelming ranges, before insertion all the actions are put in the same ListAction
1460cdf0e10cSrcweir // the patch comes from mloiseleur and maoyg
1461cdf0e10cSrcweir sal_Bool bInsertMerge = sal_False;
1462cdf0e10cSrcweir std::vector<ScRange> qIncreaseRange;
1463cdf0e10cSrcweir String aUndo = ScGlobal::GetRscString( STR_UNDO_INSERTCELLS );
1464cdf0e10cSrcweir if (bRecord)
1465cdf0e10cSrcweir rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo );
1466cdf0e10cSrcweir
1467cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1468cdf0e10cSrcweir {
1469cdf0e10cSrcweir if( aMark.GetTableSelect(i) )
1470cdf0e10cSrcweir {
1471cdf0e10cSrcweir if( pDoc->HasAttrib( nMergeTestStartX, nMergeTestStartY, i, nMergeTestEndX, nMergeTestEndY, i, HASATTR_MERGED | HASATTR_OVERLAPPED ) )
1472cdf0e10cSrcweir {
1473cdf0e10cSrcweir if (eCmd==INS_CELLSRIGHT)
1474cdf0e10cSrcweir bNeedRefresh = sal_True;
1475cdf0e10cSrcweir
1476cdf0e10cSrcweir SCCOL nMergeStartX = nMergeTestStartX;
1477cdf0e10cSrcweir SCROW nMergeStartY = nMergeTestStartY;
1478cdf0e10cSrcweir SCCOL nMergeEndX = nMergeTestEndX;
1479cdf0e10cSrcweir SCROW nMergeEndY = nMergeTestEndY;
1480cdf0e10cSrcweir
1481cdf0e10cSrcweir pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
1482cdf0e10cSrcweir pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
1483cdf0e10cSrcweir
1484cdf0e10cSrcweir if(( eCmd == INS_CELLSDOWN && ( nMergeStartX != nMergeTestStartX || nMergeEndX != nMergeTestEndX )) ||
1485cdf0e10cSrcweir (eCmd == INS_CELLSRIGHT && ( nMergeStartY != nMergeTestStartY || nMergeEndY != nMergeTestEndY )) )
1486cdf0e10cSrcweir {
1487cdf0e10cSrcweir if (!bApi)
1488cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
1489cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
1490cdf0e10cSrcweir return sal_False;
1491cdf0e10cSrcweir }
1492cdf0e10cSrcweir
1493cdf0e10cSrcweir SCCOL nTestCol = -1;
1494cdf0e10cSrcweir SCROW nTestRow1 = -1;
1495cdf0e10cSrcweir SCROW nTestRow2 = -1;
1496cdf0e10cSrcweir
1497cdf0e10cSrcweir ScDocAttrIterator aTestIter( pDoc, i, nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY );
1498cdf0e10cSrcweir ScRange aExtendRange( nMergeTestStartX, nMergeTestStartY, i, nMergeTestEndX, nMergeTestEndY, i );
1499cdf0e10cSrcweir const ScPatternAttr* pPattern = NULL;
1500cdf0e10cSrcweir const ScMergeAttr* pMergeFlag = NULL;
1501cdf0e10cSrcweir const ScMergeFlagAttr* pMergeFlagAttr = NULL;
1502cdf0e10cSrcweir while ( ( pPattern = aTestIter.GetNext( nTestCol, nTestRow1, nTestRow2 ) ) != NULL )
1503cdf0e10cSrcweir {
1504cdf0e10cSrcweir pMergeFlag = (const ScMergeAttr*) &pPattern->GetItem(ATTR_MERGE);
1505cdf0e10cSrcweir pMergeFlagAttr = (const ScMergeFlagAttr*) &pPattern->GetItem(ATTR_MERGE_FLAG);
1506cdf0e10cSrcweir sal_Int16 nNewFlags = pMergeFlagAttr->GetValue() & ( SC_MF_HOR | SC_MF_VER );
1507cdf0e10cSrcweir if( ( pMergeFlag && pMergeFlag->IsMerged() ) || nNewFlags == SC_MF_HOR || nNewFlags == SC_MF_VER )
1508cdf0e10cSrcweir {
1509cdf0e10cSrcweir ScRange aRange( nTestCol, nTestRow1, i );
1510cdf0e10cSrcweir pDoc->ExtendOverlapped(aRange);
1511cdf0e10cSrcweir pDoc->ExtendMerge(aRange, sal_True, sal_True);
1512cdf0e10cSrcweir
1513cdf0e10cSrcweir if( nTestRow1 < nTestRow2 && nNewFlags == SC_MF_HOR )
1514cdf0e10cSrcweir {
1515cdf0e10cSrcweir for( SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
1516cdf0e10cSrcweir {
1517cdf0e10cSrcweir ScRange aTestRange( nTestCol, nTestRow, i );
1518cdf0e10cSrcweir pDoc->ExtendOverlapped( aTestRange );
1519cdf0e10cSrcweir pDoc->ExtendMerge( aTestRange, sal_True, sal_True);
1520cdf0e10cSrcweir ScRange aMergeRange( aTestRange.aStart.Col(),aTestRange.aStart.Row(), i );
1521cdf0e10cSrcweir if( !aExtendRange.In( aMergeRange ) )
1522cdf0e10cSrcweir {
1523cdf0e10cSrcweir qIncreaseRange.push_back( aTestRange );
1524cdf0e10cSrcweir bInsertMerge = sal_True;
1525cdf0e10cSrcweir }
1526cdf0e10cSrcweir }
1527cdf0e10cSrcweir }
1528cdf0e10cSrcweir else
1529cdf0e10cSrcweir {
1530cdf0e10cSrcweir ScRange aMergeRange( aRange.aStart.Col(),aRange.aStart.Row(), i );
1531cdf0e10cSrcweir if( !aExtendRange.In( aMergeRange ) )
1532cdf0e10cSrcweir {
1533cdf0e10cSrcweir qIncreaseRange.push_back( aRange );
1534cdf0e10cSrcweir }
1535cdf0e10cSrcweir bInsertMerge = sal_True;
1536cdf0e10cSrcweir }
1537cdf0e10cSrcweir }
1538cdf0e10cSrcweir }
1539cdf0e10cSrcweir
1540cdf0e10cSrcweir if( bInsertMerge )
1541cdf0e10cSrcweir {
1542cdf0e10cSrcweir if( eCmd == INS_INSROWS || eCmd == INS_CELLSDOWN )
1543cdf0e10cSrcweir {
1544cdf0e10cSrcweir nStartRow = aExtendMergeRange.aStart.Row();
1545cdf0e10cSrcweir nEndRow = aExtendMergeRange.aEnd.Row();
1546cdf0e10cSrcweir
1547cdf0e10cSrcweir if( eCmd == INS_CELLSDOWN )
1548cdf0e10cSrcweir nEndCol = nMergeTestEndX;
1549cdf0e10cSrcweir else
1550cdf0e10cSrcweir {
1551cdf0e10cSrcweir nStartCol = 0;
1552cdf0e10cSrcweir nEndCol = MAXCOL;
1553cdf0e10cSrcweir }
1554cdf0e10cSrcweir }
1555cdf0e10cSrcweir else if( eCmd == INS_CELLSRIGHT || eCmd == INS_INSCOLS )
1556cdf0e10cSrcweir {
1557cdf0e10cSrcweir
1558cdf0e10cSrcweir nStartCol = aExtendMergeRange.aStart.Col();
1559cdf0e10cSrcweir nEndCol = aExtendMergeRange.aEnd.Col();
1560cdf0e10cSrcweir if( eCmd == INS_CELLSRIGHT )
1561cdf0e10cSrcweir {
1562cdf0e10cSrcweir nEndRow = nMergeTestEndY;
1563cdf0e10cSrcweir }
1564cdf0e10cSrcweir else
1565cdf0e10cSrcweir {
1566cdf0e10cSrcweir nStartRow = 0;
1567cdf0e10cSrcweir nEndRow = MAXROW;
1568cdf0e10cSrcweir }
1569cdf0e10cSrcweir }
1570cdf0e10cSrcweir
1571cdf0e10cSrcweir if( !qIncreaseRange.empty() )
1572cdf0e10cSrcweir {
1573cdf0e10cSrcweir for( ::std::vector<ScRange>::const_iterator iIter( qIncreaseRange.begin()); iIter != qIncreaseRange.end(); iIter++ )
1574cdf0e10cSrcweir {
1575cdf0e10cSrcweir ScRange aRange( *iIter );
1576cdf0e10cSrcweir if( pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
1577cdf0e10cSrcweir {
1578cdf0e10cSrcweir UnmergeCells( aRange, sal_True, sal_True );
1579cdf0e10cSrcweir }
1580cdf0e10cSrcweir }
1581cdf0e10cSrcweir }
1582cdf0e10cSrcweir }
1583cdf0e10cSrcweir else
1584cdf0e10cSrcweir {
1585cdf0e10cSrcweir if (!bApi)
1586cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
1587cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
1588cdf0e10cSrcweir return sal_False;
1589cdf0e10cSrcweir }
1590cdf0e10cSrcweir }
1591cdf0e10cSrcweir }
1592cdf0e10cSrcweir }
1593cdf0e10cSrcweir
1594cdf0e10cSrcweir switch (eCmd)
1595cdf0e10cSrcweir {
1596cdf0e10cSrcweir case INS_CELLSDOWN:
1597cdf0e10cSrcweir bSuccess = pDoc->InsertRow( nStartCol, 0, nEndCol, MAXTAB, nStartRow, static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc, &aFullMark );
1598cdf0e10cSrcweir nPaintEndY = MAXROW;
1599cdf0e10cSrcweir break;
1600cdf0e10cSrcweir case INS_INSROWS:
1601cdf0e10cSrcweir bSuccess = pDoc->InsertRow( 0, 0, MAXCOL, MAXTAB, nStartRow, static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc, &aFullMark );
1602cdf0e10cSrcweir nPaintStartX = 0;
1603cdf0e10cSrcweir nPaintEndX = MAXCOL;
1604cdf0e10cSrcweir nPaintEndY = MAXROW;
1605cdf0e10cSrcweir nPaintFlags |= PAINT_LEFT;
1606cdf0e10cSrcweir break;
1607cdf0e10cSrcweir case INS_CELLSRIGHT:
1608cdf0e10cSrcweir bSuccess = pDoc->InsertCol( nStartRow, 0, nEndRow, MAXTAB, nStartCol, static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc, &aFullMark );
1609cdf0e10cSrcweir nPaintEndX = MAXCOL;
1610cdf0e10cSrcweir break;
1611cdf0e10cSrcweir case INS_INSCOLS:
1612cdf0e10cSrcweir bSuccess = pDoc->InsertCol( 0, 0, MAXROW, MAXTAB, nStartCol, static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc, &aFullMark );
1613cdf0e10cSrcweir nPaintStartY = 0;
1614cdf0e10cSrcweir nPaintEndY = MAXROW;
1615cdf0e10cSrcweir nPaintEndX = MAXCOL;
1616cdf0e10cSrcweir nPaintFlags |= PAINT_TOP;
1617cdf0e10cSrcweir break;
1618cdf0e10cSrcweir default:
1619cdf0e10cSrcweir DBG_ERROR("Falscher Code beim Einfuegen");
1620cdf0e10cSrcweir bSuccess = sal_False;
1621cdf0e10cSrcweir break;
1622cdf0e10cSrcweir }
1623cdf0e10cSrcweir
1624cdf0e10cSrcweir if ( bSuccess )
1625cdf0e10cSrcweir {
1626cdf0e10cSrcweir SCTAB* pTabs = NULL;
1627cdf0e10cSrcweir SCTAB* pScenarios = NULL;
1628cdf0e10cSrcweir SCTAB nUndoPos = 0;
1629cdf0e10cSrcweir
1630cdf0e10cSrcweir if ( bRecord )
1631cdf0e10cSrcweir {
1632cdf0e10cSrcweir pTabs = new SCTAB[nSelCount];
1633cdf0e10cSrcweir pScenarios = new SCTAB[nSelCount];
1634cdf0e10cSrcweir nUndoPos = 0;
1635cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1636cdf0e10cSrcweir {
1637cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
1638cdf0e10cSrcweir {
1639cdf0e10cSrcweir SCTAB nCount = 0;
1640cdf0e10cSrcweir for( SCTAB j=i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
1641cdf0e10cSrcweir nCount ++;
1642cdf0e10cSrcweir
1643cdf0e10cSrcweir pScenarios[nUndoPos] = nCount;
1644cdf0e10cSrcweir pTabs[nUndoPos] = i;
1645cdf0e10cSrcweir nUndoPos ++;
1646cdf0e10cSrcweir }
1647cdf0e10cSrcweir }
1648cdf0e10cSrcweir
1649cdf0e10cSrcweir if( !bInsertMerge )
1650cdf0e10cSrcweir {
1651cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
1652cdf0e10cSrcweir }
1653cdf0e10cSrcweir
1654cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( new ScUndoInsertCells(
1655cdf0e10cSrcweir &rDocShell, ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ),
1656cdf0e10cSrcweir nUndoPos, pTabs, pScenarios, eCmd, pRefUndoDoc, pUndoData, bPartOfPaste ) );
1657cdf0e10cSrcweir }
1658cdf0e10cSrcweir
1659cdf0e10cSrcweir // #i8302 : we remerge growing ranges, with the new part inserted
1660cdf0e10cSrcweir
1661cdf0e10cSrcweir while( !qIncreaseRange.empty() )
1662cdf0e10cSrcweir {
1663cdf0e10cSrcweir ScRange aRange = qIncreaseRange.back();
1664cdf0e10cSrcweir if( !pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
1665cdf0e10cSrcweir {
1666cdf0e10cSrcweir switch (eCmd)
1667cdf0e10cSrcweir {
1668cdf0e10cSrcweir case INS_CELLSDOWN:
1669cdf0e10cSrcweir case INS_INSROWS:
1670cdf0e10cSrcweir aRange.aEnd.IncRow(static_cast<SCsCOL>(nEndRow-nStartRow+1));
1671cdf0e10cSrcweir break;
1672cdf0e10cSrcweir case INS_CELLSRIGHT:
1673cdf0e10cSrcweir case INS_INSCOLS:
1674cdf0e10cSrcweir aRange.aEnd.IncCol(static_cast<SCsCOL>(nEndCol-nStartCol+1));
1675cdf0e10cSrcweir break;
1676cdf0e10cSrcweir default:
1677cdf0e10cSrcweir break;
1678cdf0e10cSrcweir }
1679cdf0e10cSrcweir MergeCells(aRange, sal_False, sal_True, sal_True);
1680cdf0e10cSrcweir }
1681cdf0e10cSrcweir qIncreaseRange.pop_back();
1682cdf0e10cSrcweir }
1683cdf0e10cSrcweir
1684cdf0e10cSrcweir if( bInsertMerge )
1685cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
1686cdf0e10cSrcweir
1687cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1688cdf0e10cSrcweir {
1689cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
1690cdf0e10cSrcweir {
1691cdf0e10cSrcweir if (bNeedRefresh)
1692cdf0e10cSrcweir pDoc->ExtendMerge( nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY, i, sal_True );
1693cdf0e10cSrcweir else
1694cdf0e10cSrcweir pDoc->RefreshAutoFilter( nMergeTestStartX, nMergeTestStartY, nMergeTestEndX, nMergeTestEndY, i );
1695cdf0e10cSrcweir
1696cdf0e10cSrcweir if ( eCmd == INS_INSROWS || eCmd == INS_INSCOLS )
1697cdf0e10cSrcweir pDoc->UpdatePageBreaks( i );
1698cdf0e10cSrcweir
1699cdf0e10cSrcweir sal_uInt16 nExtFlags = 0;
1700cdf0e10cSrcweir rDocShell.UpdatePaintExt( nExtFlags, nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i );
1701cdf0e10cSrcweir
1702cdf0e10cSrcweir SCTAB nScenarioCount = 0;
1703cdf0e10cSrcweir
1704cdf0e10cSrcweir for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
1705cdf0e10cSrcweir nScenarioCount ++;
1706cdf0e10cSrcweir
1707cdf0e10cSrcweir sal_Bool bAdjusted = ( eCmd == INS_INSROWS ) ? AdjustRowHeight(ScRange(0, nStartRow, i, MAXCOL, nEndRow, i+nScenarioCount )) :
1708cdf0e10cSrcweir AdjustRowHeight(ScRange(0, nPaintStartY, i, MAXCOL, nPaintEndY, i+nScenarioCount ));
1709cdf0e10cSrcweir if (bAdjusted)
1710cdf0e10cSrcweir {
1711cdf0e10cSrcweir // paint only what is not done by AdjustRowHeight
1712cdf0e10cSrcweir if (nPaintFlags & PAINT_TOP)
1713cdf0e10cSrcweir rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, PAINT_TOP );
1714cdf0e10cSrcweir }
1715cdf0e10cSrcweir else
1716cdf0e10cSrcweir rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, nPaintFlags, nExtFlags );
1717cdf0e10cSrcweir }
1718cdf0e10cSrcweir }
1719cdf0e10cSrcweir //aModificator.SetDocumentModified();
1720cdf0e10cSrcweir }
1721cdf0e10cSrcweir else
1722cdf0e10cSrcweir {
1723cdf0e10cSrcweir if( bInsertMerge )
1724cdf0e10cSrcweir {
1725cdf0e10cSrcweir while( !qIncreaseRange.empty() )
1726cdf0e10cSrcweir {
1727cdf0e10cSrcweir ScRange aRange = qIncreaseRange.back();
1728cdf0e10cSrcweir MergeCells(aRange, sal_False, sal_True, sal_True);
1729cdf0e10cSrcweir qIncreaseRange.pop_back();
1730cdf0e10cSrcweir }
1731cdf0e10cSrcweir
1732cdf0e10cSrcweir if( pViewSh )
1733cdf0e10cSrcweir {
1734cdf0e10cSrcweir pViewSh->MarkRange( rRange, sal_False );
1735cdf0e10cSrcweir pViewSh->SetCursor( nCursorCol, nCursorRow );
1736cdf0e10cSrcweir }
1737cdf0e10cSrcweir }
1738cdf0e10cSrcweir
1739cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
1740cdf0e10cSrcweir rDocShell.GetUndoManager()->RemoveLastUndoAction();
1741cdf0e10cSrcweir
1742cdf0e10cSrcweir delete pRefUndoDoc;
1743cdf0e10cSrcweir delete pUndoData;
1744cdf0e10cSrcweir if (!bApi)
1745cdf0e10cSrcweir rDocShell.ErrorMessage(STR_INSERT_FULL); // Spalte/Zeile voll
1746cdf0e10cSrcweir }
1747cdf0e10cSrcweir
1748cdf0e10cSrcweir aModificator.SetDocumentModified();
1749cdf0e10cSrcweir
1750cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
1751cdf0e10cSrcweir return bSuccess;
1752cdf0e10cSrcweir }
1753cdf0e10cSrcweir
DeleteCells(const ScRange & rRange,const ScMarkData * pTabMark,DelCellCmd eCmd,sal_Bool bRecord,sal_Bool bApi)1754cdf0e10cSrcweir sal_Bool ScDocFunc::DeleteCells( const ScRange& rRange, const ScMarkData* pTabMark, DelCellCmd eCmd,
1755cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi )
1756cdf0e10cSrcweir {
1757cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
1758cdf0e10cSrcweir
1759cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
1760cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
1761cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
1762cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
1763cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
1764cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
1765cdf0e10cSrcweir
1766cdf0e10cSrcweir if ( !ValidRow(nStartRow) || !ValidRow(nEndRow) )
1767cdf0e10cSrcweir {
1768cdf0e10cSrcweir DBG_ERROR("invalid row in DeleteCells");
1769cdf0e10cSrcweir return sal_False;
1770cdf0e10cSrcweir }
1771cdf0e10cSrcweir
1772cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
1773cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1774cdf0e10cSrcweir SCCOL nPaintStartX = nStartCol;
1775cdf0e10cSrcweir SCROW nPaintStartY = nStartRow;
1776cdf0e10cSrcweir SCCOL nPaintEndX = nEndCol;
1777cdf0e10cSrcweir SCROW nPaintEndY = nEndRow;
1778cdf0e10cSrcweir sal_uInt16 nPaintFlags = PAINT_GRID;
1779cdf0e10cSrcweir SCTAB i;
1780cdf0e10cSrcweir
1781cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1782cdf0e10cSrcweir bRecord = sal_False;
1783cdf0e10cSrcweir
1784cdf0e10cSrcweir ScMarkData aMark;
1785cdf0e10cSrcweir if (pTabMark)
1786cdf0e10cSrcweir aMark = *pTabMark;
1787cdf0e10cSrcweir else
1788cdf0e10cSrcweir {
1789cdf0e10cSrcweir SCTAB nCount = 0;
1790cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1791cdf0e10cSrcweir {
1792cdf0e10cSrcweir if( !pDoc->IsScenario(i) )
1793cdf0e10cSrcweir {
1794cdf0e10cSrcweir nCount++;
1795cdf0e10cSrcweir if( nCount == nEndTab+1 )
1796cdf0e10cSrcweir {
1797cdf0e10cSrcweir aMark.SelectTable( i, sal_True );
1798cdf0e10cSrcweir break;
1799cdf0e10cSrcweir }
1800cdf0e10cSrcweir }
1801cdf0e10cSrcweir }
1802cdf0e10cSrcweir }
1803cdf0e10cSrcweir
1804cdf0e10cSrcweir ScMarkData aFullMark( aMark ); // including scenario sheets
1805cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1806cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
1807cdf0e10cSrcweir {
1808cdf0e10cSrcweir for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
1809cdf0e10cSrcweir aFullMark.SelectTable( j, sal_True );
1810cdf0e10cSrcweir }
1811cdf0e10cSrcweir
1812cdf0e10cSrcweir SCTAB nSelCount = aMark.GetSelectCount();
1813cdf0e10cSrcweir
1814cdf0e10cSrcweir SCCOL nUndoStartX = nStartCol;
1815cdf0e10cSrcweir SCROW nUndoStartY = nStartRow;
1816cdf0e10cSrcweir SCCOL nUndoEndX = nEndCol;
1817cdf0e10cSrcweir SCROW nUndoEndY = nEndRow;
1818cdf0e10cSrcweir
1819cdf0e10cSrcweir ScRange aExtendMergeRange( rRange );
1820cdf0e10cSrcweir
1821cdf0e10cSrcweir if( rRange.aStart == rRange.aEnd && pDoc->HasAttrib(rRange, HASATTR_MERGED) )
1822cdf0e10cSrcweir {
1823cdf0e10cSrcweir pDoc->ExtendMerge( aExtendMergeRange );
1824cdf0e10cSrcweir pDoc->ExtendOverlapped( aExtendMergeRange );
1825cdf0e10cSrcweir nUndoEndX = aExtendMergeRange.aEnd.Col();
1826cdf0e10cSrcweir nUndoEndY = aExtendMergeRange.aEnd.Row();
1827cdf0e10cSrcweir nPaintEndX = nUndoEndX;
1828cdf0e10cSrcweir nPaintEndY = nUndoEndY;
1829cdf0e10cSrcweir }
1830cdf0e10cSrcweir
1831cdf0e10cSrcweir if (eCmd==DEL_DELROWS)
1832cdf0e10cSrcweir {
1833cdf0e10cSrcweir nUndoStartX = 0;
1834cdf0e10cSrcweir nUndoEndX = MAXCOL;
1835cdf0e10cSrcweir }
1836cdf0e10cSrcweir if (eCmd==DEL_DELCOLS)
1837cdf0e10cSrcweir {
1838cdf0e10cSrcweir nUndoStartY = 0;
1839cdf0e10cSrcweir nUndoEndY = MAXROW;
1840cdf0e10cSrcweir }
1841cdf0e10cSrcweir // Test Zellschutz
1842cdf0e10cSrcweir
1843cdf0e10cSrcweir SCCOL nEditTestEndX = nUndoEndX;
1844cdf0e10cSrcweir if ( eCmd==DEL_DELCOLS || eCmd==DEL_CELLSLEFT )
1845cdf0e10cSrcweir nEditTestEndX = MAXCOL;
1846cdf0e10cSrcweir SCROW nEditTestEndY = nUndoEndY;
1847cdf0e10cSrcweir if ( eCmd==DEL_DELROWS || eCmd==DEL_CELLSUP )
1848cdf0e10cSrcweir nEditTestEndY = MAXROW;
1849cdf0e10cSrcweir ScEditableTester aTester( pDoc, nUndoStartX, nUndoStartY, nEditTestEndX, nEditTestEndY, aMark );
1850cdf0e10cSrcweir if (!aTester.IsEditable())
1851cdf0e10cSrcweir {
1852cdf0e10cSrcweir if (!bApi)
1853cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
1854cdf0e10cSrcweir return sal_False;
1855cdf0e10cSrcweir }
1856cdf0e10cSrcweir
1857cdf0e10cSrcweir // Test zusammengefasste
1858cdf0e10cSrcweir
1859cdf0e10cSrcweir SCCOL nMergeTestEndX = (eCmd==DEL_CELLSLEFT) ? MAXCOL : nUndoEndX;
1860cdf0e10cSrcweir SCROW nMergeTestEndY = (eCmd==DEL_CELLSUP) ? MAXROW : nUndoEndY;
1861cdf0e10cSrcweir SCCOL nExtendStartCol = nUndoStartX;
1862cdf0e10cSrcweir SCROW nExtendStartRow = nUndoStartY;
1863cdf0e10cSrcweir sal_Bool bNeedRefresh = sal_False;
1864cdf0e10cSrcweir
1865cdf0e10cSrcweir //Issue 8302 want to be able to insert into the middle of merged cells
1866cdf0e10cSrcweir //the patch comes from maoyg
1867cdf0e10cSrcweir ::std::vector<ScRange> qDecreaseRange;
1868cdf0e10cSrcweir sal_Bool bDeletingMerge = sal_False;
1869cdf0e10cSrcweir String aUndo = ScGlobal::GetRscString( STR_UNDO_DELETECELLS );
1870cdf0e10cSrcweir if (bRecord)
1871cdf0e10cSrcweir rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo );
1872cdf0e10cSrcweir
1873cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
1874cdf0e10cSrcweir {
1875cdf0e10cSrcweir if( aMark.GetTableSelect(i) )
1876cdf0e10cSrcweir {
1877cdf0e10cSrcweir if ( pDoc->HasAttrib( nUndoStartX, nUndoStartY, i, nMergeTestEndX, nMergeTestEndY, i, HASATTR_MERGED | HASATTR_OVERLAPPED ))
1878cdf0e10cSrcweir {
1879cdf0e10cSrcweir SCCOL nMergeStartX = nUndoStartX;
1880cdf0e10cSrcweir SCROW nMergeStartY = nUndoStartY;
1881cdf0e10cSrcweir SCCOL nMergeEndX = nMergeTestEndX;
1882cdf0e10cSrcweir SCROW nMergeEndY = nMergeTestEndY;
1883cdf0e10cSrcweir
1884cdf0e10cSrcweir pDoc->ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
1885cdf0e10cSrcweir pDoc->ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, i );
1886cdf0e10cSrcweir if( ( eCmd == DEL_CELLSUP && ( nMergeStartX != nUndoStartX || nMergeEndX != nMergeTestEndX))||
1887cdf0e10cSrcweir ( eCmd == DEL_CELLSLEFT && ( nMergeStartY != nUndoStartY || nMergeEndY != nMergeTestEndY)))
1888cdf0e10cSrcweir {
1889cdf0e10cSrcweir if (!bApi)
1890cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
1891cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
1892cdf0e10cSrcweir return sal_False;
1893cdf0e10cSrcweir }
1894cdf0e10cSrcweir
1895cdf0e10cSrcweir nExtendStartCol = nMergeStartX;
1896cdf0e10cSrcweir nExtendStartRow = nMergeStartY;
1897cdf0e10cSrcweir SCCOL nTestCol = -1;
1898cdf0e10cSrcweir SCROW nTestRow1 = -1;
1899cdf0e10cSrcweir SCROW nTestRow2 = -1;
1900cdf0e10cSrcweir
1901cdf0e10cSrcweir ScDocAttrIterator aTestIter( pDoc, i, nUndoStartX, nUndoStartY, nMergeTestEndX, nMergeTestEndY );
1902cdf0e10cSrcweir ScRange aExtendRange( nUndoStartX, nUndoStartY, i, nMergeTestEndX, nMergeTestEndY, i );
1903cdf0e10cSrcweir const ScPatternAttr* pPattern = NULL;
1904cdf0e10cSrcweir const ScMergeAttr* pMergeFlag = NULL;
1905cdf0e10cSrcweir const ScMergeFlagAttr* pMergeFlagAttr = NULL;
1906cdf0e10cSrcweir while ( ( pPattern = aTestIter.GetNext( nTestCol, nTestRow1, nTestRow2 ) ) != NULL )
1907cdf0e10cSrcweir {
1908cdf0e10cSrcweir pMergeFlag = (const ScMergeAttr*) &pPattern->GetItem( ATTR_MERGE );
1909cdf0e10cSrcweir pMergeFlagAttr = (const ScMergeFlagAttr*) &pPattern->GetItem( ATTR_MERGE_FLAG );
1910cdf0e10cSrcweir sal_Int16 nNewFlags = pMergeFlagAttr->GetValue() & ( SC_MF_HOR | SC_MF_VER );
1911cdf0e10cSrcweir if( ( pMergeFlag && pMergeFlag->IsMerged() ) || nNewFlags == SC_MF_HOR || nNewFlags == SC_MF_VER )
1912cdf0e10cSrcweir {
1913cdf0e10cSrcweir ScRange aRange( nTestCol, nTestRow1, i );
1914cdf0e10cSrcweir pDoc->ExtendOverlapped( aRange );
1915cdf0e10cSrcweir pDoc->ExtendMerge( aRange, sal_True, sal_True );
1916cdf0e10cSrcweir
1917cdf0e10cSrcweir if( nTestRow1 < nTestRow2 && nNewFlags == SC_MF_HOR )
1918cdf0e10cSrcweir {
1919cdf0e10cSrcweir for( SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
1920cdf0e10cSrcweir {
1921cdf0e10cSrcweir ScRange aTestRange( nTestCol, nTestRow, i );
1922cdf0e10cSrcweir pDoc->ExtendOverlapped( aTestRange );
1923cdf0e10cSrcweir pDoc->ExtendMerge( aTestRange, sal_True, sal_True);
1924cdf0e10cSrcweir ScRange aMergeRange( aTestRange.aStart.Col(),aTestRange.aStart.Row(), i );
1925cdf0e10cSrcweir if( !aExtendRange.In( aMergeRange ) )
1926cdf0e10cSrcweir {
1927cdf0e10cSrcweir qDecreaseRange.push_back( aTestRange );
1928cdf0e10cSrcweir bDeletingMerge = sal_True;
1929cdf0e10cSrcweir }
1930cdf0e10cSrcweir }
1931cdf0e10cSrcweir }
1932cdf0e10cSrcweir else
1933cdf0e10cSrcweir {
1934cdf0e10cSrcweir ScRange aMergeRange( aRange.aStart.Col(),aRange.aStart.Row(), i );
1935cdf0e10cSrcweir if( !aExtendRange.In( aMergeRange ) )
1936cdf0e10cSrcweir {
1937cdf0e10cSrcweir qDecreaseRange.push_back( aRange );
1938cdf0e10cSrcweir }
1939cdf0e10cSrcweir bDeletingMerge = sal_True;
1940cdf0e10cSrcweir }
1941cdf0e10cSrcweir }
1942cdf0e10cSrcweir }
1943cdf0e10cSrcweir
1944cdf0e10cSrcweir if( bDeletingMerge )
1945cdf0e10cSrcweir {
1946cdf0e10cSrcweir
1947cdf0e10cSrcweir if( eCmd == DEL_DELROWS || eCmd == DEL_CELLSUP )
1948cdf0e10cSrcweir {
1949cdf0e10cSrcweir nStartRow = aExtendMergeRange.aStart.Row();
1950cdf0e10cSrcweir nEndRow = aExtendMergeRange.aEnd.Row();
1951cdf0e10cSrcweir bNeedRefresh = sal_True;
1952cdf0e10cSrcweir
1953cdf0e10cSrcweir if( eCmd == DEL_CELLSUP )
1954cdf0e10cSrcweir {
1955cdf0e10cSrcweir nEndCol = aExtendMergeRange.aEnd.Col();
1956cdf0e10cSrcweir }
1957cdf0e10cSrcweir else
1958cdf0e10cSrcweir {
1959cdf0e10cSrcweir nStartCol = 0;
1960cdf0e10cSrcweir nEndCol = MAXCOL;
1961cdf0e10cSrcweir }
1962cdf0e10cSrcweir }
1963cdf0e10cSrcweir else if( eCmd == DEL_CELLSLEFT || eCmd == DEL_DELCOLS )
1964cdf0e10cSrcweir {
1965cdf0e10cSrcweir
1966cdf0e10cSrcweir nStartCol = aExtendMergeRange.aStart.Col();
1967cdf0e10cSrcweir nEndCol = aExtendMergeRange.aEnd.Col();
1968cdf0e10cSrcweir if( eCmd == DEL_CELLSLEFT )
1969cdf0e10cSrcweir {
1970cdf0e10cSrcweir nEndRow = aExtendMergeRange.aEnd.Row();
1971cdf0e10cSrcweir bNeedRefresh = sal_True;
1972cdf0e10cSrcweir }
1973cdf0e10cSrcweir else
1974cdf0e10cSrcweir {
1975cdf0e10cSrcweir nStartRow = 0;
1976cdf0e10cSrcweir nEndRow = MAXROW;
1977cdf0e10cSrcweir }
1978cdf0e10cSrcweir }
1979cdf0e10cSrcweir
1980cdf0e10cSrcweir if( !qDecreaseRange.empty() )
1981cdf0e10cSrcweir {
1982cdf0e10cSrcweir for( ::std::vector<ScRange>::const_iterator iIter( qDecreaseRange.begin()); iIter != qDecreaseRange.end(); iIter++ )
1983cdf0e10cSrcweir {
1984cdf0e10cSrcweir ScRange aRange( *iIter );
1985cdf0e10cSrcweir if( pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
1986cdf0e10cSrcweir {
1987cdf0e10cSrcweir UnmergeCells( aRange, sal_True, sal_True );
1988cdf0e10cSrcweir }
1989cdf0e10cSrcweir }
1990cdf0e10cSrcweir }
1991cdf0e10cSrcweir }
1992cdf0e10cSrcweir else
1993cdf0e10cSrcweir {
1994cdf0e10cSrcweir if (!bApi)
1995cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
1996cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
1997cdf0e10cSrcweir return sal_False;
1998cdf0e10cSrcweir }
1999cdf0e10cSrcweir }
2000cdf0e10cSrcweir }
2001cdf0e10cSrcweir }
2002cdf0e10cSrcweir
2003cdf0e10cSrcweir //
2004cdf0e10cSrcweir // ausfuehren
2005cdf0e10cSrcweir //
2006cdf0e10cSrcweir
2007cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() ); // wichtig wegen TrackFormulas bei UpdateReference
2008cdf0e10cSrcweir
2009cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
2010cdf0e10cSrcweir ScDocument* pRefUndoDoc = NULL;
2011cdf0e10cSrcweir ScRefUndoData* pUndoData = NULL;
2012cdf0e10cSrcweir if ( bRecord )
2013cdf0e10cSrcweir {
2014cdf0e10cSrcweir // With the fix for #101329#, UpdateRef always puts cells into pRefUndoDoc at their old position,
2015cdf0e10cSrcweir // so it's no longer necessary to copy more than the deleted range into pUndoDoc.
2016cdf0e10cSrcweir
2017cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2018cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, 0, nTabCount-1, (eCmd==DEL_DELCOLS), (eCmd==DEL_DELROWS) );
2019cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
2020cdf0e10cSrcweir {
2021cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
2022cdf0e10cSrcweir {
2023cdf0e10cSrcweir SCTAB nScenarioCount = 0;
2024cdf0e10cSrcweir
2025cdf0e10cSrcweir for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
2026cdf0e10cSrcweir nScenarioCount ++;
2027cdf0e10cSrcweir
2028cdf0e10cSrcweir pDoc->CopyToDocument( nUndoStartX, nUndoStartY, i, nUndoEndX, nUndoEndY, i+nScenarioCount,
2029cdf0e10cSrcweir IDF_ALL | IDF_NOCAPTIONS, sal_False, pUndoDoc );
2030cdf0e10cSrcweir }
2031cdf0e10cSrcweir }
2032cdf0e10cSrcweir
2033cdf0e10cSrcweir pRefUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2034cdf0e10cSrcweir pRefUndoDoc->InitUndo( pDoc, 0, nTabCount-1, sal_False, sal_False );
2035cdf0e10cSrcweir
2036cdf0e10cSrcweir pUndoData = new ScRefUndoData( pDoc );
2037cdf0e10cSrcweir
2038cdf0e10cSrcweir pDoc->BeginDrawUndo();
2039cdf0e10cSrcweir }
2040cdf0e10cSrcweir
2041cdf0e10cSrcweir sal_uInt16 nExtFlags = 0;
2042cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
2043cdf0e10cSrcweir {
2044cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
2045cdf0e10cSrcweir rDocShell.UpdatePaintExt( nExtFlags, nStartCol, nStartRow, i, nEndCol, nEndRow, i );
2046cdf0e10cSrcweir }
2047cdf0e10cSrcweir
2048cdf0e10cSrcweir sal_Bool bUndoOutline = sal_False;
2049cdf0e10cSrcweir switch (eCmd)
2050cdf0e10cSrcweir {
2051cdf0e10cSrcweir case DEL_CELLSUP:
2052cdf0e10cSrcweir pDoc->DeleteRow( nStartCol, 0, nEndCol, MAXTAB, nStartRow, static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc, NULL, &aFullMark );
2053cdf0e10cSrcweir nPaintEndY = MAXROW;
2054cdf0e10cSrcweir break;
2055cdf0e10cSrcweir case DEL_DELROWS:
2056cdf0e10cSrcweir pDoc->DeleteRow( 0, 0, MAXCOL, MAXTAB, nStartRow, static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc, &bUndoOutline, &aFullMark );
2057cdf0e10cSrcweir nPaintStartX = 0;
2058cdf0e10cSrcweir nPaintEndX = MAXCOL;
2059cdf0e10cSrcweir nPaintEndY = MAXROW;
2060cdf0e10cSrcweir nPaintFlags |= PAINT_LEFT;
2061cdf0e10cSrcweir break;
2062cdf0e10cSrcweir case DEL_CELLSLEFT:
2063cdf0e10cSrcweir pDoc->DeleteCol( nStartRow, 0, nEndRow, MAXTAB, nStartCol, static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc, NULL, &aFullMark );
2064cdf0e10cSrcweir nPaintEndX = MAXCOL;
2065cdf0e10cSrcweir break;
2066cdf0e10cSrcweir case DEL_DELCOLS:
2067cdf0e10cSrcweir pDoc->DeleteCol( 0, 0, MAXROW, MAXTAB, nStartCol, static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc, &bUndoOutline, &aFullMark );
2068cdf0e10cSrcweir nPaintStartY = 0;
2069cdf0e10cSrcweir nPaintEndY = MAXROW;
2070cdf0e10cSrcweir nPaintEndX = MAXCOL;
2071cdf0e10cSrcweir nPaintFlags |= PAINT_TOP;
2072cdf0e10cSrcweir break;
2073cdf0e10cSrcweir default:
2074cdf0e10cSrcweir DBG_ERROR("Falscher Code beim Loeschen");
2075cdf0e10cSrcweir break;
2076cdf0e10cSrcweir }
2077cdf0e10cSrcweir
2078cdf0e10cSrcweir //! Test, ob Outline in Groesse geaendert
2079cdf0e10cSrcweir
2080cdf0e10cSrcweir if ( bRecord )
2081cdf0e10cSrcweir {
2082cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
2083cdf0e10cSrcweir if( aFullMark.GetTableSelect( i ) )
2084cdf0e10cSrcweir pRefUndoDoc->DeleteAreaTab(nUndoStartX,nUndoStartY,nUndoEndX,nUndoEndY, i, IDF_ALL);
2085cdf0e10cSrcweir
2086cdf0e10cSrcweir // alle Tabellen anlegen, damit Formeln kopiert werden koennen:
2087cdf0e10cSrcweir pUndoDoc->AddUndoTab( 0, nTabCount-1, sal_False, sal_False );
2088cdf0e10cSrcweir
2089cdf0e10cSrcweir // kopieren mit bColRowFlags=sal_False (#54194#)
2090cdf0e10cSrcweir pRefUndoDoc->CopyToDocument(0,0,0,MAXCOL,MAXROW,MAXTAB,IDF_FORMULA,sal_False,pUndoDoc,NULL,sal_False);
2091cdf0e10cSrcweir delete pRefUndoDoc;
2092cdf0e10cSrcweir
2093cdf0e10cSrcweir SCTAB* pTabs = new SCTAB[nSelCount];
2094cdf0e10cSrcweir SCTAB* pScenarios = new SCTAB[nSelCount];
2095cdf0e10cSrcweir SCTAB nUndoPos = 0;
2096cdf0e10cSrcweir
2097cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
2098cdf0e10cSrcweir {
2099cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
2100cdf0e10cSrcweir {
2101cdf0e10cSrcweir SCTAB nCount = 0;
2102cdf0e10cSrcweir for( SCTAB j=i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
2103cdf0e10cSrcweir nCount ++;
2104cdf0e10cSrcweir
2105cdf0e10cSrcweir pScenarios[nUndoPos] = nCount;
2106cdf0e10cSrcweir pTabs[nUndoPos] = i;
2107cdf0e10cSrcweir nUndoPos ++;
2108cdf0e10cSrcweir }
2109cdf0e10cSrcweir }
2110cdf0e10cSrcweir
2111cdf0e10cSrcweir if( !bDeletingMerge )
2112cdf0e10cSrcweir {
2113cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
2114cdf0e10cSrcweir }
2115cdf0e10cSrcweir
2116cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( new ScUndoDeleteCells(
2117cdf0e10cSrcweir &rDocShell, ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ),nUndoPos, pTabs, pScenarios,
2118cdf0e10cSrcweir eCmd, pUndoDoc, pUndoData ) );
2119cdf0e10cSrcweir }
2120cdf0e10cSrcweir
2121cdf0e10cSrcweir // #i8302 want to be able to insert into the middle of merged cells
2122cdf0e10cSrcweir // the patch comes from maoyg
2123cdf0e10cSrcweir
2124cdf0e10cSrcweir while( !qDecreaseRange.empty() )
2125cdf0e10cSrcweir {
2126cdf0e10cSrcweir ScRange aRange = qDecreaseRange.back();
2127cdf0e10cSrcweir
2128cdf0e10cSrcweir long nDecreaseRowCount = 0;
2129cdf0e10cSrcweir long nDecreaseColCount = 0;
2130cdf0e10cSrcweir if( eCmd == DEL_CELLSUP || eCmd == DEL_DELROWS )
2131cdf0e10cSrcweir {
2132cdf0e10cSrcweir if( nStartRow >= aRange.aStart.Row() && nStartRow <= aRange.aEnd.Row() && nEndRow>= aRange.aStart.Row() && nEndRow <= aRange.aEnd.Row() )
2133cdf0e10cSrcweir nDecreaseRowCount = nEndRow-nStartRow+1;
2134cdf0e10cSrcweir else if( nStartRow >= aRange.aStart.Row() && nStartRow <= aRange.aEnd.Row() && nEndRow >= aRange.aStart.Row() && nEndRow >= aRange.aEnd.Row() )
2135cdf0e10cSrcweir nDecreaseRowCount = aRange.aEnd.Row()-nStartRow+1;
2136cdf0e10cSrcweir else if( nStartRow >= aRange.aStart.Row() && nStartRow >= aRange.aEnd.Row() && nEndRow>= aRange.aStart.Row() && nEndRow <= aRange.aEnd.Row() )
2137cdf0e10cSrcweir nDecreaseRowCount = aRange.aEnd.Row()-nEndRow+1;
2138cdf0e10cSrcweir }
2139cdf0e10cSrcweir else if( eCmd == DEL_CELLSLEFT || eCmd == DEL_DELCOLS )
2140cdf0e10cSrcweir {
2141cdf0e10cSrcweir if( nStartCol >= aRange.aStart.Col() && nStartCol <= aRange.aEnd.Col() && nEndCol>= aRange.aStart.Col() && nEndCol <= aRange.aEnd.Col() )
2142cdf0e10cSrcweir nDecreaseColCount = nEndCol-nStartCol+1;
2143cdf0e10cSrcweir else if( nStartCol >= aRange.aStart.Col() && nStartCol <= aRange.aEnd.Col() && nEndCol >= aRange.aStart.Col() && nEndCol >= aRange.aEnd.Col() )
2144cdf0e10cSrcweir nDecreaseColCount = aRange.aEnd.Col()-nStartCol+1;
2145cdf0e10cSrcweir else if( nStartCol >= aRange.aStart.Col() && nStartCol >= aRange.aEnd.Col() && nEndCol>= aRange.aStart.Col() && nEndCol <= aRange.aEnd.Col() )
2146cdf0e10cSrcweir nDecreaseColCount = aRange.aEnd.Col()-nEndCol+1;
2147cdf0e10cSrcweir }
2148cdf0e10cSrcweir
2149cdf0e10cSrcweir switch (eCmd)
2150cdf0e10cSrcweir {
2151cdf0e10cSrcweir case DEL_CELLSUP:
2152cdf0e10cSrcweir case DEL_DELROWS:
2153cdf0e10cSrcweir aRange.aEnd.SetRow(static_cast<SCsCOL>( aRange.aEnd.Row()-nDecreaseRowCount));
2154cdf0e10cSrcweir break;
2155cdf0e10cSrcweir case DEL_CELLSLEFT:
2156cdf0e10cSrcweir case DEL_DELCOLS:
2157cdf0e10cSrcweir aRange.aEnd.SetCol(static_cast<SCsCOL>( aRange.aEnd.Col()-nDecreaseColCount));
2158cdf0e10cSrcweir break;
2159cdf0e10cSrcweir default:
2160cdf0e10cSrcweir break;
2161cdf0e10cSrcweir }
2162cdf0e10cSrcweir
2163cdf0e10cSrcweir if( !pDoc->HasAttrib( aRange, HASATTR_OVERLAPPED | HASATTR_MERGED ) )
2164cdf0e10cSrcweir {
2165cdf0e10cSrcweir MergeCells( aRange, sal_False, sal_True, sal_True );
2166cdf0e10cSrcweir }
2167cdf0e10cSrcweir qDecreaseRange.pop_back();
2168cdf0e10cSrcweir }
2169cdf0e10cSrcweir
2170cdf0e10cSrcweir if( bDeletingMerge )
2171cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
2172cdf0e10cSrcweir
2173cdf0e10cSrcweir if ( bNeedRefresh )
2174cdf0e10cSrcweir {
2175cdf0e10cSrcweir // #i51445# old merge flag attributes must be deleted also for single cells,
2176cdf0e10cSrcweir // not only for whole columns/rows
2177cdf0e10cSrcweir
2178cdf0e10cSrcweir if ( eCmd==DEL_DELCOLS || eCmd==DEL_CELLSLEFT )
2179cdf0e10cSrcweir nMergeTestEndX = MAXCOL;
2180cdf0e10cSrcweir if ( eCmd==DEL_DELROWS || eCmd==DEL_CELLSUP )
2181cdf0e10cSrcweir nMergeTestEndY = MAXROW;
2182cdf0e10cSrcweir ScPatternAttr aPattern( pDoc->GetPool() );
2183cdf0e10cSrcweir aPattern.GetItemSet().Put( ScMergeFlagAttr() );
2184cdf0e10cSrcweir
2185cdf0e10cSrcweir pDoc->ApplyPatternArea( nExtendStartCol, nExtendStartRow, nMergeTestEndX, nMergeTestEndY, aMark, aPattern );
2186cdf0e10cSrcweir
2187cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
2188cdf0e10cSrcweir {
2189cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
2190cdf0e10cSrcweir {
2191cdf0e10cSrcweir SCTAB nScenarioCount = 0;
2192cdf0e10cSrcweir
2193cdf0e10cSrcweir for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
2194cdf0e10cSrcweir nScenarioCount ++;
2195cdf0e10cSrcweir
2196cdf0e10cSrcweir ScRange aMergedRange( nExtendStartCol, nExtendStartRow, i, nMergeTestEndX, nMergeTestEndY, i+nScenarioCount );
2197cdf0e10cSrcweir pDoc->ExtendMerge( aMergedRange, sal_True );
2198cdf0e10cSrcweir }
2199cdf0e10cSrcweir }
2200cdf0e10cSrcweir }
2201cdf0e10cSrcweir
2202cdf0e10cSrcweir for( i=0; i<nTabCount; i++ )
2203cdf0e10cSrcweir {
2204cdf0e10cSrcweir if( aMark.GetTableSelect( i ) )
2205cdf0e10cSrcweir {
2206cdf0e10cSrcweir if ( eCmd == DEL_DELCOLS || eCmd == DEL_DELROWS )
2207cdf0e10cSrcweir pDoc->UpdatePageBreaks( i );
2208cdf0e10cSrcweir
2209cdf0e10cSrcweir rDocShell.UpdatePaintExt( nExtFlags, nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i );
2210cdf0e10cSrcweir
2211cdf0e10cSrcweir SCTAB nScenarioCount = 0;
2212cdf0e10cSrcweir
2213cdf0e10cSrcweir for( SCTAB j = i+1; j<nTabCount && pDoc->IsScenario(j); j++ )
2214cdf0e10cSrcweir nScenarioCount ++;
2215cdf0e10cSrcweir
2216cdf0e10cSrcweir // ganze Zeilen loeschen: nichts anpassen
2217cdf0e10cSrcweir if ( eCmd == DEL_DELROWS || !AdjustRowHeight(ScRange( 0, nPaintStartY, i, MAXCOL, nPaintEndY, i+nScenarioCount )) )
2218cdf0e10cSrcweir rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, nPaintFlags, nExtFlags );
2219cdf0e10cSrcweir else
2220cdf0e10cSrcweir {
2221cdf0e10cSrcweir // paint only what is not done by AdjustRowHeight
2222cdf0e10cSrcweir if (nExtFlags & SC_PF_LINES)
2223cdf0e10cSrcweir lcl_PaintAbove( rDocShell, ScRange( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount) );
2224cdf0e10cSrcweir if (nPaintFlags & PAINT_TOP)
2225cdf0e10cSrcweir rDocShell.PostPaint( nPaintStartX, nPaintStartY, i, nPaintEndX, nPaintEndY, i+nScenarioCount, PAINT_TOP );
2226cdf0e10cSrcweir }
2227cdf0e10cSrcweir }
2228cdf0e10cSrcweir }
2229cdf0e10cSrcweir aModificator.SetDocumentModified();
2230cdf0e10cSrcweir
2231cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
2232cdf0e10cSrcweir
2233cdf0e10cSrcweir return sal_True;
2234cdf0e10cSrcweir }
2235cdf0e10cSrcweir
MoveBlock(const ScRange & rSource,const ScAddress & rDestPos,sal_Bool bCut,sal_Bool bRecord,sal_Bool bPaint,sal_Bool bApi)2236cdf0e10cSrcweir sal_Bool ScDocFunc::MoveBlock( const ScRange& rSource, const ScAddress& rDestPos,
2237cdf0e10cSrcweir sal_Bool bCut, sal_Bool bRecord, sal_Bool bPaint, sal_Bool bApi )
2238cdf0e10cSrcweir {
2239cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
2240cdf0e10cSrcweir
2241cdf0e10cSrcweir SCCOL nStartCol = rSource.aStart.Col();
2242cdf0e10cSrcweir SCROW nStartRow = rSource.aStart.Row();
2243cdf0e10cSrcweir SCTAB nStartTab = rSource.aStart.Tab();
2244cdf0e10cSrcweir SCCOL nEndCol = rSource.aEnd.Col();
2245cdf0e10cSrcweir SCROW nEndRow = rSource.aEnd.Row();
2246cdf0e10cSrcweir SCTAB nEndTab = rSource.aEnd.Tab();
2247cdf0e10cSrcweir SCCOL nDestCol = rDestPos.Col();
2248cdf0e10cSrcweir SCROW nDestRow = rDestPos.Row();
2249cdf0e10cSrcweir SCTAB nDestTab = rDestPos.Tab();
2250cdf0e10cSrcweir
2251cdf0e10cSrcweir if ( !ValidRow(nStartRow) || !ValidRow(nEndRow) || !ValidRow(nDestRow) )
2252cdf0e10cSrcweir {
2253cdf0e10cSrcweir DBG_ERROR("invalid row in MoveBlock");
2254cdf0e10cSrcweir return sal_False;
2255cdf0e10cSrcweir }
2256cdf0e10cSrcweir
2257cdf0e10cSrcweir // zugehoerige Szenarien auch anpassen - nur wenn innerhalb einer Tabelle verschoben wird!
2258cdf0e10cSrcweir sal_Bool bScenariosAdded = sal_False;
2259cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
2260cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2261cdf0e10cSrcweir bRecord = sal_False;
2262cdf0e10cSrcweir
2263cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
2264cdf0e10cSrcweir if ( nDestTab == nStartTab && !pDoc->IsScenario(nEndTab) )
2265cdf0e10cSrcweir while ( nEndTab+1 < nTabCount && pDoc->IsScenario(nEndTab+1) )
2266cdf0e10cSrcweir {
2267cdf0e10cSrcweir ++nEndTab;
2268cdf0e10cSrcweir bScenariosAdded = sal_True;
2269cdf0e10cSrcweir }
2270cdf0e10cSrcweir
2271cdf0e10cSrcweir SCTAB nSrcTabCount = nEndTab-nStartTab+1;
2272cdf0e10cSrcweir SCTAB nDestEndTab = nDestTab+nSrcTabCount-1;
2273cdf0e10cSrcweir SCTAB nTab;
2274cdf0e10cSrcweir
2275cdf0e10cSrcweir ScDocument* pClipDoc = new ScDocument( SCDOCMODE_CLIP );
2276cdf0e10cSrcweir
2277cdf0e10cSrcweir ScMarkData aSourceMark;
2278cdf0e10cSrcweir for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2279cdf0e10cSrcweir aSourceMark.SelectTable( nTab, sal_True ); // Source selektieren
2280cdf0e10cSrcweir aSourceMark.SetMarkArea( rSource );
2281cdf0e10cSrcweir
2282cdf0e10cSrcweir ScDocShellRef aDragShellRef;
2283cdf0e10cSrcweir if ( pDoc->HasOLEObjectsInArea( rSource ) )
2284cdf0e10cSrcweir {
2285cdf0e10cSrcweir aDragShellRef = new ScDocShell; // DocShell needs a Ref immediately
2286cdf0e10cSrcweir aDragShellRef->DoInitNew(NULL);
2287cdf0e10cSrcweir }
2288cdf0e10cSrcweir ScDrawLayer::SetGlobalDrawPersist(aDragShellRef);
2289cdf0e10cSrcweir
2290cdf0e10cSrcweir ScClipParam aClipParam(ScRange(nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nStartTab), bCut);
2291cdf0e10cSrcweir pDoc->CopyToClip(aClipParam, pClipDoc, &aSourceMark, false, bScenariosAdded, true);
2292cdf0e10cSrcweir
2293cdf0e10cSrcweir ScDrawLayer::SetGlobalDrawPersist(NULL);
2294cdf0e10cSrcweir
2295cdf0e10cSrcweir SCCOL nOldEndCol = nEndCol;
2296cdf0e10cSrcweir SCROW nOldEndRow = nEndRow;
2297cdf0e10cSrcweir sal_Bool bClipOver = sal_False;
2298cdf0e10cSrcweir for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2299cdf0e10cSrcweir {
2300cdf0e10cSrcweir SCCOL nTmpEndCol = nOldEndCol;
2301cdf0e10cSrcweir SCROW nTmpEndRow = nOldEndRow;
2302cdf0e10cSrcweir if (pDoc->ExtendMerge( nStartCol, nStartRow, nTmpEndCol, nTmpEndRow, nTab ))
2303cdf0e10cSrcweir bClipOver = sal_True;
2304cdf0e10cSrcweir if ( nTmpEndCol > nEndCol ) nEndCol = nTmpEndCol;
2305cdf0e10cSrcweir if ( nTmpEndRow > nEndRow ) nEndRow = nTmpEndRow;
2306cdf0e10cSrcweir }
2307cdf0e10cSrcweir
2308cdf0e10cSrcweir SCCOL nDestEndCol = nDestCol + ( nOldEndCol-nStartCol );
2309cdf0e10cSrcweir SCROW nDestEndRow = nDestRow + ( nOldEndRow-nStartRow );
2310cdf0e10cSrcweir
2311cdf0e10cSrcweir SCCOL nUndoEndCol = nDestCol + ( nEndCol-nStartCol ); // erweitert im Zielblock
2312cdf0e10cSrcweir SCROW nUndoEndRow = nDestRow + ( nEndRow-nStartRow );
2313cdf0e10cSrcweir
2314cdf0e10cSrcweir sal_Bool bIncludeFiltered = bCut;
2315cdf0e10cSrcweir if ( !bIncludeFiltered )
2316cdf0e10cSrcweir {
2317cdf0e10cSrcweir // adjust sizes to include only non-filtered rows
2318cdf0e10cSrcweir
2319cdf0e10cSrcweir SCCOL nClipX;
2320cdf0e10cSrcweir SCROW nClipY;
2321cdf0e10cSrcweir pClipDoc->GetClipArea( nClipX, nClipY, sal_False );
2322cdf0e10cSrcweir SCROW nUndoAdd = nUndoEndRow - nDestEndRow;
2323cdf0e10cSrcweir nDestEndRow = nDestRow + nClipY;
2324cdf0e10cSrcweir nUndoEndRow = nDestEndRow + nUndoAdd;
2325cdf0e10cSrcweir }
2326cdf0e10cSrcweir
2327cdf0e10cSrcweir if (!ValidCol(nUndoEndCol) || !ValidRow(nUndoEndRow))
2328cdf0e10cSrcweir {
2329cdf0e10cSrcweir if (!bApi)
2330cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PASTE_FULL);
2331cdf0e10cSrcweir delete pClipDoc;
2332cdf0e10cSrcweir return sal_False;
2333cdf0e10cSrcweir }
2334cdf0e10cSrcweir
2335cdf0e10cSrcweir // Test auf Zellschutz
2336cdf0e10cSrcweir
2337cdf0e10cSrcweir ScEditableTester aTester;
2338cdf0e10cSrcweir for (nTab=nDestTab; nTab<=nDestEndTab; nTab++)
2339cdf0e10cSrcweir aTester.TestBlock( pDoc, nTab, nDestCol,nDestRow, nUndoEndCol,nUndoEndRow );
2340cdf0e10cSrcweir if (bCut)
2341cdf0e10cSrcweir for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2342cdf0e10cSrcweir aTester.TestBlock( pDoc, nTab, nStartCol,nStartRow, nEndCol,nEndRow );
2343cdf0e10cSrcweir
2344cdf0e10cSrcweir if (!aTester.IsEditable())
2345cdf0e10cSrcweir {
2346cdf0e10cSrcweir if (!bApi)
2347cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
2348cdf0e10cSrcweir delete pClipDoc;
2349cdf0e10cSrcweir return sal_False;
2350cdf0e10cSrcweir }
2351cdf0e10cSrcweir
2352cdf0e10cSrcweir // Test auf zusammengefasste - beim Verschieben erst nach dem Loeschen
2353cdf0e10cSrcweir
2354cdf0e10cSrcweir if (bClipOver && !bCut)
2355cdf0e10cSrcweir if (pDoc->HasAttrib( nDestCol,nDestRow,nDestTab, nUndoEndCol,nUndoEndRow,nDestEndTab,
2356cdf0e10cSrcweir HASATTR_MERGED | HASATTR_OVERLAPPED ))
2357cdf0e10cSrcweir { // "Zusammenfassen nicht verschachteln !"
2358cdf0e10cSrcweir if (!bApi)
2359cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MSSG_MOVEBLOCKTO_0);
2360cdf0e10cSrcweir delete pClipDoc;
2361cdf0e10cSrcweir return sal_False;
2362cdf0e10cSrcweir }
2363cdf0e10cSrcweir
2364cdf0e10cSrcweir // Are there borders in the cells? (for painting)
2365cdf0e10cSrcweir
2366cdf0e10cSrcweir sal_uInt16 nSourceExt = 0;
2367cdf0e10cSrcweir rDocShell.UpdatePaintExt( nSourceExt, nStartCol,nStartRow,nStartTab, nEndCol,nEndRow,nEndTab );
2368cdf0e10cSrcweir sal_uInt16 nDestExt = 0;
2369cdf0e10cSrcweir rDocShell.UpdatePaintExt( nDestExt, nDestCol,nDestRow,nDestTab, nDestEndCol,nDestEndRow,nDestEndTab );
2370cdf0e10cSrcweir
2371cdf0e10cSrcweir //
2372cdf0e10cSrcweir // ausfuehren
2373cdf0e10cSrcweir //
2374cdf0e10cSrcweir
2375cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
2376cdf0e10cSrcweir ScDocument* pRefUndoDoc = NULL;
2377cdf0e10cSrcweir ScRefUndoData* pUndoData = NULL;
2378cdf0e10cSrcweir if (bRecord)
2379cdf0e10cSrcweir {
2380cdf0e10cSrcweir sal_Bool bWholeCols = ( nStartRow == 0 && nEndRow == MAXROW );
2381cdf0e10cSrcweir sal_Bool bWholeRows = ( nStartCol == 0 && nEndCol == MAXCOL );
2382cdf0e10cSrcweir sal_uInt16 nUndoFlags = (IDF_ALL & ~IDF_OBJECTS) | IDF_NOCAPTIONS;
2383cdf0e10cSrcweir
2384cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2385cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab, bWholeCols, bWholeRows );
2386cdf0e10cSrcweir
2387cdf0e10cSrcweir if (bCut)
2388cdf0e10cSrcweir {
2389cdf0e10cSrcweir pDoc->CopyToDocument( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab,
2390cdf0e10cSrcweir nUndoFlags, sal_False, pUndoDoc );
2391cdf0e10cSrcweir pRefUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2392cdf0e10cSrcweir pRefUndoDoc->InitUndo( pDoc, 0, nTabCount-1, sal_False, sal_False );
2393cdf0e10cSrcweir }
2394cdf0e10cSrcweir
2395cdf0e10cSrcweir if ( nDestTab != nStartTab )
2396cdf0e10cSrcweir pUndoDoc->AddUndoTab( nDestTab, nDestEndTab, bWholeCols, bWholeRows );
2397cdf0e10cSrcweir pDoc->CopyToDocument( nDestCol, nDestRow, nDestTab,
2398cdf0e10cSrcweir nDestEndCol, nDestEndRow, nDestEndTab,
2399cdf0e10cSrcweir nUndoFlags, sal_False, pUndoDoc );
2400cdf0e10cSrcweir
2401cdf0e10cSrcweir pUndoData = new ScRefUndoData( pDoc );
2402cdf0e10cSrcweir
2403cdf0e10cSrcweir pDoc->BeginDrawUndo();
2404cdf0e10cSrcweir }
2405cdf0e10cSrcweir
2406cdf0e10cSrcweir sal_Bool bSourceHeight = sal_False; // Hoehen angepasst?
2407cdf0e10cSrcweir if (bCut)
2408cdf0e10cSrcweir {
2409cdf0e10cSrcweir ScMarkData aDelMark; // only for tables
2410cdf0e10cSrcweir for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2411cdf0e10cSrcweir {
2412cdf0e10cSrcweir pDoc->DeleteAreaTab( nStartCol,nStartRow, nOldEndCol,nOldEndRow, nTab, IDF_ALL );
2413cdf0e10cSrcweir aDelMark.SelectTable( nTab, sal_True );
2414cdf0e10cSrcweir }
2415cdf0e10cSrcweir pDoc->DeleteObjectsInArea( nStartCol,nStartRow, nOldEndCol,nOldEndRow, aDelMark );
2416cdf0e10cSrcweir
2417cdf0e10cSrcweir // Test auf zusammengefasste
2418cdf0e10cSrcweir
2419cdf0e10cSrcweir if (bClipOver)
2420cdf0e10cSrcweir if (pDoc->HasAttrib( nDestCol,nDestRow,nDestTab,
2421cdf0e10cSrcweir nUndoEndCol,nUndoEndRow,nDestEndTab,
2422cdf0e10cSrcweir HASATTR_MERGED | HASATTR_OVERLAPPED ))
2423cdf0e10cSrcweir {
2424cdf0e10cSrcweir pDoc->CopyFromClip( rSource, aSourceMark, IDF_ALL, pRefUndoDoc, pClipDoc );
2425cdf0e10cSrcweir for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2426cdf0e10cSrcweir {
2427cdf0e10cSrcweir SCCOL nTmpEndCol = nEndCol;
2428cdf0e10cSrcweir SCROW nTmpEndRow = nEndRow;
2429cdf0e10cSrcweir pDoc->ExtendMerge( nStartCol, nStartRow, nTmpEndCol, nTmpEndRow, nTab, sal_True );
2430cdf0e10cSrcweir }
2431cdf0e10cSrcweir
2432cdf0e10cSrcweir // Fehlermeldung erst nach dem Wiederherstellen des Inhalts
2433cdf0e10cSrcweir if (!bApi) // "Zusammenfassen nicht verschachteln !"
2434cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MSSG_MOVEBLOCKTO_0);
2435cdf0e10cSrcweir
2436cdf0e10cSrcweir delete pUndoDoc;
2437cdf0e10cSrcweir delete pRefUndoDoc;
2438cdf0e10cSrcweir delete pUndoData;
2439cdf0e10cSrcweir delete pClipDoc;
2440cdf0e10cSrcweir return sal_False;
2441cdf0e10cSrcweir }
2442cdf0e10cSrcweir
2443cdf0e10cSrcweir bSourceHeight = AdjustRowHeight( rSource, sal_False );
2444cdf0e10cSrcweir }
2445cdf0e10cSrcweir
2446cdf0e10cSrcweir ScRange aPasteDest( nDestCol, nDestRow, nDestTab, nDestEndCol, nDestEndRow, nDestEndTab );
2447cdf0e10cSrcweir
2448cdf0e10cSrcweir ScMarkData aDestMark;
2449cdf0e10cSrcweir for (nTab=nDestTab; nTab<=nDestEndTab; nTab++)
2450cdf0e10cSrcweir aDestMark.SelectTable( nTab, sal_True ); // Destination selektieren
2451cdf0e10cSrcweir aDestMark.SetMarkArea( aPasteDest );
2452cdf0e10cSrcweir
2453cdf0e10cSrcweir /* Do not copy cell notes and drawing objects here. While pasting, the
2454cdf0e10cSrcweir function ScDocument::UpdateReference() is called which calls
2455cdf0e10cSrcweir ScDrawLayer::MoveCells() which may move away inserted objects to wrong
2456cdf0e10cSrcweir positions (e.g. if source and destination range overlaps). Cell notes
2457cdf0e10cSrcweir and drawing objects are pasted below after doing all adjusting. */
2458cdf0e10cSrcweir pDoc->CopyFromClip( aPasteDest, aDestMark, IDF_ALL & ~(IDF_NOTE | IDF_OBJECTS),
2459cdf0e10cSrcweir pRefUndoDoc, pClipDoc, sal_True, sal_False, bIncludeFiltered );
2460cdf0e10cSrcweir
2461cdf0e10cSrcweir // skipped rows and merged cells don't mix
2462cdf0e10cSrcweir if ( !bIncludeFiltered && pClipDoc->HasClipFilteredRows() )
2463cdf0e10cSrcweir UnmergeCells( aPasteDest, sal_False, sal_True );
2464cdf0e10cSrcweir
2465cdf0e10cSrcweir VirtualDevice aVirtDev;
2466cdf0e10cSrcweir sal_Bool bDestHeight = AdjustRowHeight(
2467cdf0e10cSrcweir ScRange( 0,nDestRow,nDestTab, MAXCOL,nDestEndRow,nDestEndTab ),
2468cdf0e10cSrcweir sal_False );
2469cdf0e10cSrcweir
2470cdf0e10cSrcweir /* Paste cell notes and drawing objects after adjusting formula references
2471cdf0e10cSrcweir and row heights. There are no cell notes or drawing objects, if the
2472cdf0e10cSrcweir clipdoc does not contain a drawing layer.
2473cdf0e10cSrcweir #i102056# Passing IDF_NOTE only would overwrite cell contents with
2474cdf0e10cSrcweir empty note cells, therefore the special modifier IDF_ADDNOTES is passed
2475cdf0e10cSrcweir here too which changes the behaviour of ScColumn::CopyFromClip() to not
2476cdf0e10cSrcweir touch existing cells. */
2477cdf0e10cSrcweir if ( pClipDoc->GetDrawLayer() )
2478cdf0e10cSrcweir pDoc->CopyFromClip( aPasteDest, aDestMark, IDF_NOTE | IDF_ADDNOTES | IDF_OBJECTS,
2479cdf0e10cSrcweir pRefUndoDoc, pClipDoc, sal_True, sal_False, bIncludeFiltered );
2480cdf0e10cSrcweir
2481cdf0e10cSrcweir if (bRecord)
2482cdf0e10cSrcweir {
2483cdf0e10cSrcweir if (pRefUndoDoc)
2484cdf0e10cSrcweir {
2485cdf0e10cSrcweir // alle Tabellen anlegen, damit Formeln kopiert werden koennen:
2486cdf0e10cSrcweir pUndoDoc->AddUndoTab( 0, nTabCount-1, sal_False, sal_False );
2487cdf0e10cSrcweir
2488cdf0e10cSrcweir pRefUndoDoc->DeleteArea( nDestCol, nDestRow, nDestEndCol, nDestEndRow, aSourceMark, IDF_ALL );
2489cdf0e10cSrcweir // kopieren mit bColRowFlags=sal_False (#54194#)
2490cdf0e10cSrcweir pRefUndoDoc->CopyToDocument( 0, 0, 0, MAXCOL, MAXROW, MAXTAB,
2491cdf0e10cSrcweir IDF_FORMULA, sal_False, pUndoDoc, NULL, sal_False );
2492cdf0e10cSrcweir delete pRefUndoDoc;
2493cdf0e10cSrcweir }
2494cdf0e10cSrcweir
2495cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
2496cdf0e10cSrcweir new ScUndoDragDrop( &rDocShell, ScRange(
2497cdf0e10cSrcweir nStartCol, nStartRow, nStartTab,
2498cdf0e10cSrcweir nOldEndCol, nOldEndRow, nEndTab ),
2499cdf0e10cSrcweir ScAddress( nDestCol, nDestRow, nDestTab ),
2500cdf0e10cSrcweir bCut, pUndoDoc, pUndoData, bScenariosAdded ) );
2501cdf0e10cSrcweir }
2502cdf0e10cSrcweir
2503cdf0e10cSrcweir SCCOL nDestPaintEndCol = nDestEndCol;
2504cdf0e10cSrcweir SCROW nDestPaintEndRow = nDestEndRow;
2505cdf0e10cSrcweir for (nTab=nDestTab; nTab<=nDestEndTab; nTab++)
2506cdf0e10cSrcweir {
2507cdf0e10cSrcweir SCCOL nTmpEndCol = nDestEndCol;
2508cdf0e10cSrcweir SCROW nTmpEndRow = nDestEndRow;
2509cdf0e10cSrcweir pDoc->ExtendMerge( nDestCol, nDestRow, nTmpEndCol, nTmpEndRow, nTab, sal_True );
2510cdf0e10cSrcweir if (nTmpEndCol > nDestPaintEndCol) nDestPaintEndCol = nTmpEndCol;
2511cdf0e10cSrcweir if (nTmpEndRow > nDestPaintEndRow) nDestPaintEndRow = nTmpEndRow;
2512cdf0e10cSrcweir }
2513cdf0e10cSrcweir
2514cdf0e10cSrcweir if (bCut)
2515cdf0e10cSrcweir for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2516cdf0e10cSrcweir pDoc->RefreshAutoFilter( nStartCol, nStartRow, nEndCol, nEndRow, nTab );
2517cdf0e10cSrcweir
2518cdf0e10cSrcweir if (bPaint)
2519cdf0e10cSrcweir {
2520cdf0e10cSrcweir // Zielbereich:
2521cdf0e10cSrcweir
2522cdf0e10cSrcweir SCCOL nPaintStartX = nDestCol;
2523cdf0e10cSrcweir SCROW nPaintStartY = nDestRow;
2524cdf0e10cSrcweir SCCOL nPaintEndX = nDestPaintEndCol;
2525cdf0e10cSrcweir SCROW nPaintEndY = nDestPaintEndRow;
2526cdf0e10cSrcweir sal_uInt16 nFlags = PAINT_GRID;
2527cdf0e10cSrcweir
2528cdf0e10cSrcweir if ( nStartRow==0 && nEndRow==MAXROW ) // Breiten mitkopiert?
2529cdf0e10cSrcweir {
2530cdf0e10cSrcweir nPaintEndX = MAXCOL;
2531cdf0e10cSrcweir nPaintStartY = 0;
2532cdf0e10cSrcweir nPaintEndY = MAXROW;
2533cdf0e10cSrcweir nFlags |= PAINT_TOP;
2534cdf0e10cSrcweir }
2535cdf0e10cSrcweir if ( bDestHeight || ( nStartCol == 0 && nEndCol == MAXCOL ) )
2536cdf0e10cSrcweir {
2537cdf0e10cSrcweir nPaintEndY = MAXROW;
2538cdf0e10cSrcweir nPaintStartX = 0;
2539cdf0e10cSrcweir nPaintEndX = MAXCOL;
2540cdf0e10cSrcweir nFlags |= PAINT_LEFT;
2541cdf0e10cSrcweir }
2542cdf0e10cSrcweir if ( bScenariosAdded )
2543cdf0e10cSrcweir {
2544cdf0e10cSrcweir nPaintStartX = 0;
2545cdf0e10cSrcweir nPaintStartY = 0;
2546cdf0e10cSrcweir nPaintEndX = MAXCOL;
2547cdf0e10cSrcweir nPaintEndY = MAXROW;
2548cdf0e10cSrcweir }
2549cdf0e10cSrcweir
2550cdf0e10cSrcweir rDocShell.PostPaint( nPaintStartX,nPaintStartY,nDestTab,
2551cdf0e10cSrcweir nPaintEndX,nPaintEndY,nDestEndTab, nFlags, nSourceExt | nDestExt );
2552cdf0e10cSrcweir
2553cdf0e10cSrcweir if ( bCut )
2554cdf0e10cSrcweir {
2555cdf0e10cSrcweir // Quellbereich:
2556cdf0e10cSrcweir
2557cdf0e10cSrcweir nPaintStartX = nStartCol;
2558cdf0e10cSrcweir nPaintStartY = nStartRow;
2559cdf0e10cSrcweir nPaintEndX = nEndCol;
2560cdf0e10cSrcweir nPaintEndY = nEndRow;
2561cdf0e10cSrcweir nFlags = PAINT_GRID;
2562cdf0e10cSrcweir
2563cdf0e10cSrcweir if ( bSourceHeight )
2564cdf0e10cSrcweir {
2565cdf0e10cSrcweir nPaintEndY = MAXROW;
2566cdf0e10cSrcweir nPaintStartX = 0;
2567cdf0e10cSrcweir nPaintEndX = MAXCOL;
2568cdf0e10cSrcweir nFlags |= PAINT_LEFT;
2569cdf0e10cSrcweir }
2570cdf0e10cSrcweir if ( bScenariosAdded )
2571cdf0e10cSrcweir {
2572cdf0e10cSrcweir nPaintStartX = 0;
2573cdf0e10cSrcweir nPaintStartY = 0;
2574cdf0e10cSrcweir nPaintEndX = MAXCOL;
2575cdf0e10cSrcweir nPaintEndY = MAXROW;
2576cdf0e10cSrcweir }
2577cdf0e10cSrcweir
2578cdf0e10cSrcweir rDocShell.PostPaint( nPaintStartX,nPaintStartY,nStartTab,
2579cdf0e10cSrcweir nPaintEndX,nPaintEndY,nEndTab, nFlags, nSourceExt );
2580cdf0e10cSrcweir }
2581cdf0e10cSrcweir }
2582cdf0e10cSrcweir
2583cdf0e10cSrcweir aModificator.SetDocumentModified();
2584cdf0e10cSrcweir
2585cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
2586cdf0e10cSrcweir
2587cdf0e10cSrcweir delete pClipDoc;
2588cdf0e10cSrcweir return sal_True;
2589cdf0e10cSrcweir }
2590cdf0e10cSrcweir
2591cdf0e10cSrcweir //------------------------------------------------------------------------
GetDocModuleObject(SfxObjectShell & rDocSh,String & sCodeName)2592cdf0e10cSrcweir uno::Reference< uno::XInterface > GetDocModuleObject( SfxObjectShell& rDocSh, String& sCodeName )
2593cdf0e10cSrcweir {
2594cdf0e10cSrcweir uno::Reference< lang::XMultiServiceFactory> xSF(rDocSh.GetModel(), uno::UNO_QUERY);
2595cdf0e10cSrcweir uno::Reference< container::XNameAccess > xVBACodeNamedObjectAccess;
2596cdf0e10cSrcweir uno::Reference< uno::XInterface > xDocModuleApiObject;
2597cdf0e10cSrcweir if ( xSF.is() )
2598cdf0e10cSrcweir {
2599cdf0e10cSrcweir xVBACodeNamedObjectAccess.set( xSF->createInstance( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "ooo.vba.VBAObjectModuleObjectProvider"))), uno::UNO_QUERY );
2600cdf0e10cSrcweir xDocModuleApiObject.set( xVBACodeNamedObjectAccess->getByName( sCodeName ), uno::UNO_QUERY );
2601cdf0e10cSrcweir }
2602cdf0e10cSrcweir return xDocModuleApiObject;
2603cdf0e10cSrcweir
2604cdf0e10cSrcweir }
2605cdf0e10cSrcweir
lcl_InitModuleInfo(SfxObjectShell & rDocSh,String & sModule)2606cdf0e10cSrcweir script::ModuleInfo lcl_InitModuleInfo( SfxObjectShell& rDocSh, String& sModule )
2607cdf0e10cSrcweir {
2608cdf0e10cSrcweir script::ModuleInfo sModuleInfo;
2609cdf0e10cSrcweir sModuleInfo.ModuleType = script::ModuleType::DOCUMENT;
2610cdf0e10cSrcweir sModuleInfo.ModuleObject = GetDocModuleObject( rDocSh, sModule );
2611cdf0e10cSrcweir return sModuleInfo;
2612cdf0e10cSrcweir }
2613cdf0e10cSrcweir
VBA_InsertModule(ScDocument & rDoc,SCTAB nTab,String & sModuleName,String & sSource)2614cdf0e10cSrcweir void VBA_InsertModule( ScDocument& rDoc, SCTAB nTab, String& sModuleName, String& sSource )
2615cdf0e10cSrcweir {
2616cdf0e10cSrcweir SfxObjectShell& rDocSh = *rDoc.GetDocumentShell();
2617cdf0e10cSrcweir uno::Reference< script::XLibraryContainer > xLibContainer = rDocSh.GetBasicContainer();
2618cdf0e10cSrcweir DBG_ASSERT( xLibContainer.is(), "No BasicContainer!" );
2619cdf0e10cSrcweir
2620cdf0e10cSrcweir uno::Reference< container::XNameContainer > xLib;
2621cdf0e10cSrcweir if( xLibContainer.is() )
2622cdf0e10cSrcweir {
2623cdf0e10cSrcweir String aLibName( RTL_CONSTASCII_USTRINGPARAM( "Standard" ) );
2624cdf0e10cSrcweir if ( rDocSh.GetBasicManager() && rDocSh.GetBasicManager()->GetName().Len() )
2625cdf0e10cSrcweir aLibName = rDocSh.GetBasicManager()->GetName();
2626cdf0e10cSrcweir uno::Any aLibAny = xLibContainer->getByName( aLibName );
2627cdf0e10cSrcweir aLibAny >>= xLib;
2628cdf0e10cSrcweir }
2629cdf0e10cSrcweir if( xLib.is() )
2630cdf0e10cSrcweir {
2631cdf0e10cSrcweir // if the Module with codename exists then find a new name
2632cdf0e10cSrcweir sal_Int32 nNum = 0;
2633cdf0e10cSrcweir String genModuleName;
2634cdf0e10cSrcweir if ( sModuleName.Len() )
2635cdf0e10cSrcweir sModuleName = sModuleName;
2636cdf0e10cSrcweir else
2637cdf0e10cSrcweir {
2638cdf0e10cSrcweir genModuleName = String::CreateFromAscii( "Sheet1" );
2639cdf0e10cSrcweir nNum = 1;
2640cdf0e10cSrcweir }
2641cdf0e10cSrcweir while( xLib->hasByName( genModuleName ) )
2642cdf0e10cSrcweir genModuleName = rtl::OUString::createFromAscii( "Sheet" ) + rtl::OUString::valueOf( ++nNum );
2643cdf0e10cSrcweir
2644cdf0e10cSrcweir uno::Any aSourceAny;
2645cdf0e10cSrcweir rtl::OUString sTmpSource = sSource;
2646cdf0e10cSrcweir if ( sTmpSource.getLength() == 0 )
2647cdf0e10cSrcweir sTmpSource = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Rem Attribute VBA_ModuleType=VBADocumentModule\nOption VBASupport 1\n" ));
2648cdf0e10cSrcweir aSourceAny <<= sTmpSource;
2649cdf0e10cSrcweir uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY );
2650cdf0e10cSrcweir if ( xVBAModuleInfo.is() )
2651cdf0e10cSrcweir {
2652cdf0e10cSrcweir rDoc.SetCodeName( nTab, genModuleName );
2653cdf0e10cSrcweir script::ModuleInfo sModuleInfo = lcl_InitModuleInfo( rDocSh, genModuleName );
2654cdf0e10cSrcweir xVBAModuleInfo->insertModuleInfo( genModuleName, sModuleInfo );
2655cdf0e10cSrcweir xLib->insertByName( genModuleName, aSourceAny );
2656cdf0e10cSrcweir }
2657cdf0e10cSrcweir
2658cdf0e10cSrcweir }
2659cdf0e10cSrcweir }
2660cdf0e10cSrcweir
VBA_DeleteModule(ScDocShell & rDocSh,String & sModuleName)2661cdf0e10cSrcweir void VBA_DeleteModule( ScDocShell& rDocSh, String& sModuleName )
2662cdf0e10cSrcweir {
2663cdf0e10cSrcweir uno::Reference< script::XLibraryContainer > xLibContainer = rDocSh.GetBasicContainer();
2664cdf0e10cSrcweir DBG_ASSERT( xLibContainer.is(), "No BasicContainer!" );
2665cdf0e10cSrcweir
2666cdf0e10cSrcweir uno::Reference< container::XNameContainer > xLib;
2667cdf0e10cSrcweir if( xLibContainer.is() )
2668cdf0e10cSrcweir {
2669cdf0e10cSrcweir String aLibName( RTL_CONSTASCII_USTRINGPARAM( "Standard" ) );
2670cdf0e10cSrcweir if ( rDocSh.GetBasicManager() && rDocSh.GetBasicManager()->GetName().Len() )
2671cdf0e10cSrcweir aLibName = rDocSh.GetBasicManager()->GetName();
2672cdf0e10cSrcweir uno::Any aLibAny = xLibContainer->getByName( aLibName );
2673cdf0e10cSrcweir aLibAny >>= xLib;
2674cdf0e10cSrcweir }
2675cdf0e10cSrcweir if( xLib.is() )
2676cdf0e10cSrcweir {
2677cdf0e10cSrcweir uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY );
2678cdf0e10cSrcweir if( xLib->hasByName( sModuleName ) )
2679cdf0e10cSrcweir xLib->removeByName( sModuleName );
2680cdf0e10cSrcweir if ( xVBAModuleInfo.is() )
2681cdf0e10cSrcweir xVBAModuleInfo->removeModuleInfo( sModuleName );
2682cdf0e10cSrcweir
2683cdf0e10cSrcweir }
2684cdf0e10cSrcweir }
2685cdf0e10cSrcweir
2686cdf0e10cSrcweir
InsertTable(SCTAB nTab,const String & rName,sal_Bool bRecord,sal_Bool bApi)2687cdf0e10cSrcweir sal_Bool ScDocFunc::InsertTable( SCTAB nTab, const String& rName, sal_Bool bRecord, sal_Bool bApi )
2688cdf0e10cSrcweir {
2689cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
2690cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
2691cdf0e10cSrcweir
2692cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
2693cdf0e10cSrcweir
2694cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
2695cdf0e10cSrcweir
2696cdf0e10cSrcweir
2697cdf0e10cSrcweir // Strange loop, also basic is loaded too early ( InsertTable )
2698cdf0e10cSrcweir // is called via the xml import for sheets in described in odf
2699cdf0e10cSrcweir sal_Bool bInsertDocModule = false;
2700cdf0e10cSrcweir
2701cdf0e10cSrcweir if( !rDocShell.GetDocument()->IsImportingXML() )
2702cdf0e10cSrcweir {
2703cdf0e10cSrcweir bInsertDocModule = pDoc ? pDoc->IsInVBAMode() : false;
2704cdf0e10cSrcweir }
2705cdf0e10cSrcweir if ( bInsertDocModule || ( bRecord && !pDoc->IsUndoEnabled() ) )
2706cdf0e10cSrcweir bRecord = sal_False;
2707cdf0e10cSrcweir
2708cdf0e10cSrcweir if (bRecord)
2709cdf0e10cSrcweir pDoc->BeginDrawUndo(); // InsertTab erzeugt ein SdrUndoNewPage
2710cdf0e10cSrcweir
2711cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
2712cdf0e10cSrcweir sal_Bool bAppend = ( nTab >= nTabCount );
2713cdf0e10cSrcweir if ( bAppend )
2714cdf0e10cSrcweir nTab = nTabCount; // wichtig fuer Undo
2715cdf0e10cSrcweir
2716cdf0e10cSrcweir if (pDoc->InsertTab( nTab, rName ))
2717cdf0e10cSrcweir {
2718cdf0e10cSrcweir String sCodeName;
2719cdf0e10cSrcweir if (bRecord)
2720cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
2721cdf0e10cSrcweir new ScUndoInsertTab( &rDocShell, nTab, bAppend, rName));
2722cdf0e10cSrcweir // Views updaten:
2723cdf0e10cSrcweir // Only insert vba modules if vba mode ( and not currently importing XML )
2724cdf0e10cSrcweir if( bInsertDocModule )
2725cdf0e10cSrcweir {
2726cdf0e10cSrcweir String sSource;
2727cdf0e10cSrcweir VBA_InsertModule( *pDoc, nTab, sCodeName, sSource );
2728cdf0e10cSrcweir }
2729cdf0e10cSrcweir rDocShell.Broadcast( ScTablesHint( SC_TAB_INSERTED, nTab ) );
2730cdf0e10cSrcweir
2731cdf0e10cSrcweir rDocShell.PostPaintExtras();
2732cdf0e10cSrcweir aModificator.SetDocumentModified();
2733cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2734cdf0e10cSrcweir bSuccess = sal_True;
2735cdf0e10cSrcweir }
2736cdf0e10cSrcweir else if (!bApi)
2737cdf0e10cSrcweir rDocShell.ErrorMessage(STR_TABINSERT_ERROR);
2738cdf0e10cSrcweir
2739cdf0e10cSrcweir return bSuccess;
2740cdf0e10cSrcweir }
2741cdf0e10cSrcweir
DeleteTable(SCTAB nTab,sal_Bool bRecord,sal_Bool)2742cdf0e10cSrcweir sal_Bool ScDocFunc::DeleteTable( SCTAB nTab, sal_Bool bRecord, sal_Bool /* bApi */ )
2743cdf0e10cSrcweir {
2744cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
2745cdf0e10cSrcweir
2746cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
2747cdf0e10cSrcweir
2748cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
2749cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
2750cdf0e10cSrcweir sal_Bool bVbaEnabled = pDoc ? pDoc->IsInVBAMode() : false;
2751cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2752cdf0e10cSrcweir bRecord = sal_False;
2753cdf0e10cSrcweir if ( bVbaEnabled )
2754cdf0e10cSrcweir bRecord = sal_False;
2755cdf0e10cSrcweir sal_Bool bWasLinked = pDoc->IsLinked(nTab);
2756cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
2757cdf0e10cSrcweir ScRefUndoData* pUndoData = NULL;
2758cdf0e10cSrcweir if (bRecord)
2759cdf0e10cSrcweir {
2760cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2761cdf0e10cSrcweir SCTAB nCount = pDoc->GetTableCount();
2762cdf0e10cSrcweir
2763cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True ); // nur nTab mit Flags
2764cdf0e10cSrcweir pUndoDoc->AddUndoTab( 0, nCount-1 ); // alle Tabs fuer Referenzen
2765cdf0e10cSrcweir
2766cdf0e10cSrcweir pDoc->CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,sal_False, pUndoDoc );
2767cdf0e10cSrcweir String aOldName;
2768cdf0e10cSrcweir pDoc->GetName( nTab, aOldName );
2769cdf0e10cSrcweir pUndoDoc->RenameTab( nTab, aOldName, sal_False );
2770cdf0e10cSrcweir if (bWasLinked)
2771cdf0e10cSrcweir pUndoDoc->SetLink( nTab, pDoc->GetLinkMode(nTab), pDoc->GetLinkDoc(nTab),
2772cdf0e10cSrcweir pDoc->GetLinkFlt(nTab), pDoc->GetLinkOpt(nTab),
2773cdf0e10cSrcweir pDoc->GetLinkTab(nTab),
2774cdf0e10cSrcweir pDoc->GetLinkRefreshDelay(nTab) );
2775cdf0e10cSrcweir
2776cdf0e10cSrcweir if ( pDoc->IsScenario(nTab) )
2777cdf0e10cSrcweir {
2778cdf0e10cSrcweir pUndoDoc->SetScenario( nTab, sal_True );
2779cdf0e10cSrcweir String aComment;
2780cdf0e10cSrcweir Color aColor;
2781cdf0e10cSrcweir sal_uInt16 nScenFlags;
2782cdf0e10cSrcweir pDoc->GetScenarioData( nTab, aComment, aColor, nScenFlags );
2783cdf0e10cSrcweir pUndoDoc->SetScenarioData( nTab, aComment, aColor, nScenFlags );
2784cdf0e10cSrcweir sal_Bool bActive = pDoc->IsActiveScenario( nTab );
2785cdf0e10cSrcweir pUndoDoc->SetActiveScenario( nTab, bActive );
2786cdf0e10cSrcweir }
2787cdf0e10cSrcweir pUndoDoc->SetVisible( nTab, pDoc->IsVisible( nTab ) );
2788cdf0e10cSrcweir pUndoDoc->SetTabBgColor( nTab, pDoc->GetTabBgColor(nTab) );
2789cdf0e10cSrcweir pUndoDoc->SetSheetEvents( nTab, pDoc->GetSheetEvents( nTab ) );
2790cdf0e10cSrcweir
2791cdf0e10cSrcweir // Drawing-Layer muss sein Undo selbst in der Hand behalten !!!
2792cdf0e10cSrcweir pDoc->BeginDrawUndo(); // DeleteTab erzeugt ein SdrUndoDelPage
2793cdf0e10cSrcweir
2794cdf0e10cSrcweir pUndoData = new ScRefUndoData( pDoc );
2795cdf0e10cSrcweir }
2796cdf0e10cSrcweir
2797cdf0e10cSrcweir String sCodeName;
2798cdf0e10cSrcweir sal_Bool bHasCodeName = pDoc->GetCodeName( nTab, sCodeName );
2799cdf0e10cSrcweir if (pDoc->DeleteTab( nTab, pUndoDoc ))
2800cdf0e10cSrcweir {
2801cdf0e10cSrcweir if (bRecord)
2802cdf0e10cSrcweir {
2803cdf0e10cSrcweir SvShorts theTabs;
2804cdf0e10cSrcweir theTabs.push_back(nTab);
2805cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
2806cdf0e10cSrcweir new ScUndoDeleteTab( &rDocShell, theTabs, pUndoDoc, pUndoData ));
2807cdf0e10cSrcweir }
2808cdf0e10cSrcweir // Views updaten:
2809cdf0e10cSrcweir if( bVbaEnabled )
2810cdf0e10cSrcweir {
2811cdf0e10cSrcweir if( bHasCodeName )
2812cdf0e10cSrcweir {
2813cdf0e10cSrcweir VBA_DeleteModule( rDocShell, sCodeName );
2814cdf0e10cSrcweir }
2815cdf0e10cSrcweir }
2816cdf0e10cSrcweir rDocShell.Broadcast( ScTablesHint( SC_TAB_DELETED, nTab ) );
2817cdf0e10cSrcweir
2818cdf0e10cSrcweir if (bWasLinked)
2819cdf0e10cSrcweir {
2820cdf0e10cSrcweir rDocShell.UpdateLinks(); // Link-Manager updaten
2821cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
2822cdf0e10cSrcweir if (pBindings)
2823cdf0e10cSrcweir pBindings->Invalidate(SID_LINKS);
2824cdf0e10cSrcweir }
2825cdf0e10cSrcweir
2826cdf0e10cSrcweir rDocShell.PostPaintExtras();
2827cdf0e10cSrcweir aModificator.SetDocumentModified();
2828cdf0e10cSrcweir
2829cdf0e10cSrcweir SfxApplication* pSfxApp = SFX_APP(); // Navigator
2830cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2831cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
2832cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
2833cdf0e10cSrcweir
2834cdf0e10cSrcweir bSuccess = sal_True;
2835cdf0e10cSrcweir }
2836cdf0e10cSrcweir else
2837cdf0e10cSrcweir {
2838cdf0e10cSrcweir delete pUndoDoc;
2839cdf0e10cSrcweir delete pUndoData;
2840cdf0e10cSrcweir }
2841cdf0e10cSrcweir return bSuccess;
2842cdf0e10cSrcweir }
2843cdf0e10cSrcweir
SetTableVisible(SCTAB nTab,sal_Bool bVisible,sal_Bool bApi)2844cdf0e10cSrcweir sal_Bool ScDocFunc::SetTableVisible( SCTAB nTab, sal_Bool bVisible, sal_Bool bApi )
2845cdf0e10cSrcweir {
2846cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
2847cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
2848cdf0e10cSrcweir if ( pDoc->IsVisible( nTab ) == bVisible )
2849cdf0e10cSrcweir return sal_True; // nichts zu tun - ok
2850cdf0e10cSrcweir
2851cdf0e10cSrcweir if ( !pDoc->IsDocEditable() )
2852cdf0e10cSrcweir {
2853cdf0e10cSrcweir if (!bApi)
2854cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR);
2855cdf0e10cSrcweir return sal_False;
2856cdf0e10cSrcweir }
2857cdf0e10cSrcweir
2858cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
2859cdf0e10cSrcweir
2860cdf0e10cSrcweir if ( !bVisible && !pDoc->IsImportingXML() ) // #i57869# allow hiding in any order for loading
2861cdf0e10cSrcweir {
2862cdf0e10cSrcweir // nicht alle Tabellen ausblenden
2863cdf0e10cSrcweir
2864cdf0e10cSrcweir sal_uInt16 nVisCount = 0;
2865cdf0e10cSrcweir SCTAB nCount = pDoc->GetTableCount();
2866cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
2867cdf0e10cSrcweir if (pDoc->IsVisible(i))
2868cdf0e10cSrcweir ++nVisCount;
2869cdf0e10cSrcweir
2870cdf0e10cSrcweir if (nVisCount <= 1)
2871cdf0e10cSrcweir {
2872cdf0e10cSrcweir if (!bApi)
2873cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR); //! eigene Meldung?
2874cdf0e10cSrcweir return sal_False;
2875cdf0e10cSrcweir }
2876cdf0e10cSrcweir }
2877cdf0e10cSrcweir
2878cdf0e10cSrcweir pDoc->SetVisible( nTab, bVisible );
2879cdf0e10cSrcweir if (bUndo)
2880cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( new ScUndoShowHideTab( &rDocShell, nTab, bVisible ) );
2881cdf0e10cSrcweir
2882cdf0e10cSrcweir // Views updaten:
2883cdf0e10cSrcweir if (!bVisible)
2884cdf0e10cSrcweir rDocShell.Broadcast( ScTablesHint( SC_TAB_HIDDEN, nTab ) );
2885cdf0e10cSrcweir
2886cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2887cdf0e10cSrcweir rDocShell.PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_EXTRAS);
2888cdf0e10cSrcweir aModificator.SetDocumentModified();
2889cdf0e10cSrcweir
2890cdf0e10cSrcweir return sal_True;
2891cdf0e10cSrcweir }
2892cdf0e10cSrcweir
SetLayoutRTL(SCTAB nTab,sal_Bool bRTL,sal_Bool)2893cdf0e10cSrcweir sal_Bool ScDocFunc::SetLayoutRTL( SCTAB nTab, sal_Bool bRTL, sal_Bool /* bApi */ )
2894cdf0e10cSrcweir {
2895cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
2896cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
2897cdf0e10cSrcweir if ( pDoc->IsLayoutRTL( nTab ) == bRTL )
2898cdf0e10cSrcweir return sal_True; // nothing to do - ok
2899cdf0e10cSrcweir
2900cdf0e10cSrcweir //! protection (sheet or document?)
2901cdf0e10cSrcweir
2902cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
2903cdf0e10cSrcweir
2904cdf0e10cSrcweir pDoc->SetLayoutRTL( nTab, bRTL );
2905cdf0e10cSrcweir
2906cdf0e10cSrcweir if (bUndo)
2907cdf0e10cSrcweir {
2908cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( new ScUndoLayoutRTL( &rDocShell, nTab, bRTL ) );
2909cdf0e10cSrcweir }
2910cdf0e10cSrcweir
2911cdf0e10cSrcweir rDocShell.PostPaint( 0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_ALL );
2912cdf0e10cSrcweir aModificator.SetDocumentModified();
2913cdf0e10cSrcweir
2914cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
2915cdf0e10cSrcweir if (pBindings)
2916cdf0e10cSrcweir {
2917cdf0e10cSrcweir pBindings->Invalidate( FID_TAB_RTL );
2918cdf0e10cSrcweir pBindings->Invalidate( SID_ATTR_SIZE );
2919cdf0e10cSrcweir }
2920cdf0e10cSrcweir
2921cdf0e10cSrcweir return sal_True;
2922cdf0e10cSrcweir }
2923cdf0e10cSrcweir
2924cdf0e10cSrcweir //UNUSED2009-05 sal_Bool ScDocFunc::SetGrammar( formula::FormulaGrammar::Grammar eGrammar )
2925cdf0e10cSrcweir //UNUSED2009-05 {
2926cdf0e10cSrcweir //UNUSED2009-05 ScDocument* pDoc = rDocShell.GetDocument();
2927cdf0e10cSrcweir //UNUSED2009-05
2928cdf0e10cSrcweir //UNUSED2009-05 if ( pDoc->GetGrammar() == eGrammar )
2929cdf0e10cSrcweir //UNUSED2009-05 return sal_True;
2930cdf0e10cSrcweir //UNUSED2009-05
2931cdf0e10cSrcweir //UNUSED2009-05 sal_Bool bUndo(pDoc->IsUndoEnabled());
2932cdf0e10cSrcweir //UNUSED2009-05 ScDocShellModificator aModificator( rDocShell );
2933cdf0e10cSrcweir //UNUSED2009-05
2934cdf0e10cSrcweir //UNUSED2009-05 pDoc->SetGrammar( eGrammar );
2935cdf0e10cSrcweir //UNUSED2009-05
2936cdf0e10cSrcweir //UNUSED2009-05 if (bUndo)
2937cdf0e10cSrcweir //UNUSED2009-05 {
2938cdf0e10cSrcweir //UNUSED2009-05 rDocShell.GetUndoManager()->AddUndoAction( new ScUndoSetGrammar( &rDocShell, eGrammar ) );
2939cdf0e10cSrcweir //UNUSED2009-05 }
2940cdf0e10cSrcweir //UNUSED2009-05
2941cdf0e10cSrcweir //UNUSED2009-05 rDocShell.PostPaint( 0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_ALL );
2942cdf0e10cSrcweir //UNUSED2009-05
2943cdf0e10cSrcweir //UNUSED2009-05 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
2944cdf0e10cSrcweir //UNUSED2009-05 if (NULL != pViewSh)
2945cdf0e10cSrcweir //UNUSED2009-05 {
2946cdf0e10cSrcweir //UNUSED2009-05 pViewSh->UpdateInputHandler( sal_False, sal_False );
2947cdf0e10cSrcweir //UNUSED2009-05 }
2948cdf0e10cSrcweir //UNUSED2009-05
2949cdf0e10cSrcweir //UNUSED2009-05 aModificator.SetDocumentModified();
2950cdf0e10cSrcweir //UNUSED2009-05
2951cdf0e10cSrcweir //UNUSED2009-05 SfxBindings* pBindings = rDocShell.GetViewBindings();
2952cdf0e10cSrcweir //UNUSED2009-05 if (pBindings)
2953cdf0e10cSrcweir //UNUSED2009-05 {
2954cdf0e10cSrcweir //UNUSED2009-05 // erAck: 2006-09-07T22:19+0200 commented out in CWS scr1c1
2955cdf0e10cSrcweir //UNUSED2009-05 //pBindings->Invalidate( FID_TAB_USE_R1C1 );
2956cdf0e10cSrcweir //UNUSED2009-05 }
2957cdf0e10cSrcweir //UNUSED2009-05
2958cdf0e10cSrcweir //UNUSED2009-05 return sal_True;
2959cdf0e10cSrcweir //UNUSED2009-05 }
2960cdf0e10cSrcweir
RenameTable(SCTAB nTab,const String & rName,sal_Bool bRecord,sal_Bool bApi)2961cdf0e10cSrcweir sal_Bool ScDocFunc::RenameTable( SCTAB nTab, const String& rName, sal_Bool bRecord, sal_Bool bApi )
2962cdf0e10cSrcweir {
2963cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
2964cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2965cdf0e10cSrcweir bRecord = sal_False;
2966cdf0e10cSrcweir if ( !pDoc->IsDocEditable() )
2967cdf0e10cSrcweir {
2968cdf0e10cSrcweir if (!bApi)
2969cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR);
2970cdf0e10cSrcweir return sal_False;
2971cdf0e10cSrcweir }
2972cdf0e10cSrcweir
2973cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
2974cdf0e10cSrcweir
2975cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
2976cdf0e10cSrcweir String sOldName;
2977cdf0e10cSrcweir pDoc->GetName(nTab, sOldName);
2978cdf0e10cSrcweir if (pDoc->RenameTab( nTab, rName ))
2979cdf0e10cSrcweir {
2980cdf0e10cSrcweir if (bRecord)
2981cdf0e10cSrcweir {
2982cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
2983cdf0e10cSrcweir new ScUndoRenameTab( &rDocShell, nTab, sOldName, rName));
2984cdf0e10cSrcweir }
2985cdf0e10cSrcweir rDocShell.PostPaintExtras();
2986cdf0e10cSrcweir aModificator.SetDocumentModified();
2987cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2988cdf0e10cSrcweir
2989cdf0e10cSrcweir bSuccess = sal_True;
2990cdf0e10cSrcweir }
2991cdf0e10cSrcweir return bSuccess;
2992cdf0e10cSrcweir }
2993cdf0e10cSrcweir
SetTabBgColor(SCTAB nTab,const Color & rColor,bool bRecord,bool bApi)2994cdf0e10cSrcweir bool ScDocFunc::SetTabBgColor( SCTAB nTab, const Color& rColor, bool bRecord, bool bApi )
2995cdf0e10cSrcweir {
2996cdf0e10cSrcweir
2997cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
2998cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2999cdf0e10cSrcweir bRecord = false;
3000cdf0e10cSrcweir if ( !pDoc->IsDocEditable() || pDoc->IsTabProtected(nTab) )
3001cdf0e10cSrcweir {
3002cdf0e10cSrcweir if (!bApi)
3003cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR); //TODO Check to see what this string is...
3004cdf0e10cSrcweir return false;
3005cdf0e10cSrcweir }
3006cdf0e10cSrcweir
3007cdf0e10cSrcweir Color aOldTabBgColor;
3008cdf0e10cSrcweir aOldTabBgColor = pDoc->GetTabBgColor(nTab);
3009cdf0e10cSrcweir
3010cdf0e10cSrcweir bool bSuccess = false;
3011cdf0e10cSrcweir pDoc->SetTabBgColor(nTab, rColor);
3012cdf0e10cSrcweir if ( pDoc->GetTabBgColor(nTab) == rColor)
3013cdf0e10cSrcweir bSuccess = true;
3014cdf0e10cSrcweir if (bSuccess)
3015cdf0e10cSrcweir {
3016cdf0e10cSrcweir if (bRecord)
3017cdf0e10cSrcweir {
3018cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3019cdf0e10cSrcweir new ScUndoTabColor( &rDocShell, nTab, aOldTabBgColor, rColor));
3020cdf0e10cSrcweir }
3021cdf0e10cSrcweir rDocShell.PostPaintExtras();
3022cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3023cdf0e10cSrcweir aModificator.SetDocumentModified();
3024cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
3025cdf0e10cSrcweir
3026cdf0e10cSrcweir bSuccess = true;
3027cdf0e10cSrcweir }
3028cdf0e10cSrcweir return bSuccess;
3029cdf0e10cSrcweir }
3030cdf0e10cSrcweir
SetTabBgColor(ScUndoTabColorInfo::List & rUndoTabColorList,bool bRecord,bool bApi)3031cdf0e10cSrcweir bool ScDocFunc::SetTabBgColor(
3032cdf0e10cSrcweir ScUndoTabColorInfo::List& rUndoTabColorList, bool bRecord, bool bApi )
3033cdf0e10cSrcweir {
3034cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3035cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
3036cdf0e10cSrcweir bRecord = false;
3037cdf0e10cSrcweir
3038cdf0e10cSrcweir if ( !pDoc->IsDocEditable() )
3039cdf0e10cSrcweir {
3040cdf0e10cSrcweir if (!bApi)
3041cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR); //TODO Get a better String Error...
3042cdf0e10cSrcweir return false;
3043cdf0e10cSrcweir }
3044cdf0e10cSrcweir
3045cdf0e10cSrcweir sal_uInt16 nTab;
3046cdf0e10cSrcweir Color aNewTabBgColor;
3047cdf0e10cSrcweir bool bSuccess = true;
3048cdf0e10cSrcweir size_t nTabProtectCount = 0;
3049cdf0e10cSrcweir size_t nTabListCount = rUndoTabColorList.size();
3050cdf0e10cSrcweir for ( size_t i = 0; i < nTabListCount; ++i )
3051cdf0e10cSrcweir {
3052cdf0e10cSrcweir ScUndoTabColorInfo& rInfo = rUndoTabColorList[i];
3053cdf0e10cSrcweir nTab = rInfo.mnTabId;
3054cdf0e10cSrcweir if ( !pDoc->IsTabProtected(nTab) )
3055cdf0e10cSrcweir {
3056cdf0e10cSrcweir aNewTabBgColor = rInfo.maNewTabBgColor;
3057cdf0e10cSrcweir rInfo.maOldTabBgColor = pDoc->GetTabBgColor(nTab);
3058cdf0e10cSrcweir pDoc->SetTabBgColor(nTab, aNewTabBgColor);
3059cdf0e10cSrcweir if ( pDoc->GetTabBgColor(nTab) != aNewTabBgColor)
3060cdf0e10cSrcweir {
3061cdf0e10cSrcweir bSuccess = false;
3062cdf0e10cSrcweir break;
3063cdf0e10cSrcweir }
3064cdf0e10cSrcweir }
3065cdf0e10cSrcweir else
3066cdf0e10cSrcweir {
3067cdf0e10cSrcweir nTabProtectCount++;
3068cdf0e10cSrcweir }
3069cdf0e10cSrcweir }
3070cdf0e10cSrcweir
3071cdf0e10cSrcweir if ( nTabProtectCount == nTabListCount )
3072cdf0e10cSrcweir {
3073cdf0e10cSrcweir if (!bApi)
3074cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR); //TODO Get a better String Error...
3075cdf0e10cSrcweir return false;
3076cdf0e10cSrcweir }
3077cdf0e10cSrcweir
3078cdf0e10cSrcweir if (bSuccess)
3079cdf0e10cSrcweir {
3080cdf0e10cSrcweir if (bRecord)
3081cdf0e10cSrcweir {
3082cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3083cdf0e10cSrcweir new ScUndoTabColor( &rDocShell, rUndoTabColorList));
3084cdf0e10cSrcweir }
3085cdf0e10cSrcweir rDocShell.PostPaintExtras();
3086cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3087cdf0e10cSrcweir aModificator.SetDocumentModified();
3088cdf0e10cSrcweir }
3089cdf0e10cSrcweir return bSuccess;
3090cdf0e10cSrcweir }
3091cdf0e10cSrcweir
3092cdf0e10cSrcweir //------------------------------------------------------------------------
3093cdf0e10cSrcweir
3094cdf0e10cSrcweir //! SetWidthOrHeight - noch doppelt zu ViewFunc !!!!!!
3095cdf0e10cSrcweir //! Probleme:
3096cdf0e10cSrcweir //! - Optimale Hoehe fuer Edit-Zellen ist unterschiedlich zwischen Drucker und Bildschirm
3097cdf0e10cSrcweir //! - Optimale Breite braucht Selektion, um evtl. nur selektierte Zellen zu beruecksichtigen
3098cdf0e10cSrcweir
lcl_GetOptimalColWidth(ScDocShell & rDocShell,SCCOL nCol,SCTAB nTab,sal_Bool bFormula)3099cdf0e10cSrcweir sal_uInt16 lcl_GetOptimalColWidth( ScDocShell& rDocShell, SCCOL nCol, SCTAB nTab, sal_Bool bFormula )
3100cdf0e10cSrcweir {
3101cdf0e10cSrcweir sal_uInt16 nTwips = 0;
3102cdf0e10cSrcweir
3103cdf0e10cSrcweir ScSizeDeviceProvider aProv(&rDocShell);
3104cdf0e10cSrcweir OutputDevice* pDev = aProv.GetDevice(); // has pixel MapMode
3105cdf0e10cSrcweir double nPPTX = aProv.GetPPTX();
3106cdf0e10cSrcweir double nPPTY = aProv.GetPPTY();
3107cdf0e10cSrcweir
3108cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3109cdf0e10cSrcweir Fraction aOne(1,1);
3110cdf0e10cSrcweir nTwips = pDoc->GetOptimalColWidth( nCol, nTab, pDev, nPPTX, nPPTY, aOne, aOne,
3111cdf0e10cSrcweir bFormula, NULL );
3112cdf0e10cSrcweir
3113cdf0e10cSrcweir return nTwips;
3114cdf0e10cSrcweir }
3115cdf0e10cSrcweir
SetWidthOrHeight(sal_Bool bWidth,SCCOLROW nRangeCnt,SCCOLROW * pRanges,SCTAB nTab,ScSizeMode eMode,sal_uInt16 nSizeTwips,sal_Bool bRecord,sal_Bool bApi)3116cdf0e10cSrcweir sal_Bool ScDocFunc::SetWidthOrHeight( sal_Bool bWidth, SCCOLROW nRangeCnt, SCCOLROW* pRanges, SCTAB nTab,
3117cdf0e10cSrcweir ScSizeMode eMode, sal_uInt16 nSizeTwips,
3118cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi )
3119cdf0e10cSrcweir {
3120cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3121cdf0e10cSrcweir
3122cdf0e10cSrcweir if (!nRangeCnt)
3123cdf0e10cSrcweir return sal_True;
3124cdf0e10cSrcweir
3125cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3126cdf0e10cSrcweir if ( bRecord && !pDoc->IsUndoEnabled() )
3127cdf0e10cSrcweir bRecord = sal_False;
3128cdf0e10cSrcweir
3129cdf0e10cSrcweir // import into read-only document is possible
3130cdf0e10cSrcweir if ( !pDoc->IsChangeReadOnlyEnabled() && !rDocShell.IsEditable() )
3131cdf0e10cSrcweir {
3132cdf0e10cSrcweir if (!bApi)
3133cdf0e10cSrcweir rDocShell.ErrorMessage(STR_PROTECTIONERR); //! eigene Meldung?
3134cdf0e10cSrcweir return sal_False;
3135cdf0e10cSrcweir }
3136cdf0e10cSrcweir
3137cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
3138cdf0e10cSrcweir SCCOLROW nStart = pRanges[0];
3139cdf0e10cSrcweir SCCOLROW nEnd = pRanges[2*nRangeCnt-1];
3140cdf0e10cSrcweir
3141cdf0e10cSrcweir sal_Bool bFormula = sal_False;
3142cdf0e10cSrcweir if ( eMode == SC_SIZE_OPTIMAL )
3143cdf0e10cSrcweir {
3144cdf0e10cSrcweir //! Option "Formeln anzeigen" - woher nehmen?
3145cdf0e10cSrcweir }
3146cdf0e10cSrcweir
3147cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
3148cdf0e10cSrcweir ScOutlineTable* pUndoTab = NULL;
3149cdf0e10cSrcweir SCCOLROW* pUndoRanges = NULL;
3150cdf0e10cSrcweir
3151cdf0e10cSrcweir if ( bRecord )
3152cdf0e10cSrcweir {
3153cdf0e10cSrcweir pDoc->BeginDrawUndo(); // Drawing Updates
3154cdf0e10cSrcweir
3155cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
3156cdf0e10cSrcweir if (bWidth)
3157cdf0e10cSrcweir {
3158cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_False );
3159cdf0e10cSrcweir pDoc->CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab, static_cast<SCCOL>(nEnd), MAXROW, nTab, IDF_NONE, sal_False, pUndoDoc );
3160cdf0e10cSrcweir }
3161cdf0e10cSrcweir else
3162cdf0e10cSrcweir {
3163cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_False, sal_True );
3164cdf0e10cSrcweir pDoc->CopyToDocument( 0, static_cast<SCROW>(nStart), nTab, MAXCOL, static_cast<SCROW>(nEnd), nTab, IDF_NONE, sal_False, pUndoDoc );
3165cdf0e10cSrcweir }
3166cdf0e10cSrcweir
3167cdf0e10cSrcweir pUndoRanges = new SCCOLROW[ 2*nRangeCnt ];
3168cdf0e10cSrcweir memmove( pUndoRanges, pRanges, 2*nRangeCnt*sizeof(SCCOLROW) );
3169cdf0e10cSrcweir
3170cdf0e10cSrcweir ScOutlineTable* pTable = pDoc->GetOutlineTable( nTab );
3171cdf0e10cSrcweir if (pTable)
3172cdf0e10cSrcweir pUndoTab = new ScOutlineTable( *pTable );
3173cdf0e10cSrcweir }
3174cdf0e10cSrcweir
3175cdf0e10cSrcweir sal_Bool bShow = nSizeTwips > 0 || eMode != SC_SIZE_DIRECT;
3176cdf0e10cSrcweir sal_Bool bOutline = sal_False;
3177cdf0e10cSrcweir
3178cdf0e10cSrcweir pDoc->IncSizeRecalcLevel( nTab ); // nicht fuer jede Spalte einzeln
3179cdf0e10cSrcweir for (SCCOLROW nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
3180cdf0e10cSrcweir {
3181cdf0e10cSrcweir SCCOLROW nStartNo = *(pRanges++);
3182cdf0e10cSrcweir SCCOLROW nEndNo = *(pRanges++);
3183cdf0e10cSrcweir
3184cdf0e10cSrcweir if ( !bWidth ) // Hoehen immer blockweise
3185cdf0e10cSrcweir {
3186cdf0e10cSrcweir if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
3187cdf0e10cSrcweir {
3188cdf0e10cSrcweir sal_Bool bAll = ( eMode==SC_SIZE_OPTIMAL );
3189cdf0e10cSrcweir if (!bAll)
3190cdf0e10cSrcweir {
3191cdf0e10cSrcweir // fuer alle eingeblendeten CR_MANUALSIZE loeschen,
3192cdf0e10cSrcweir // dann SetOptimalHeight mit bShrink = FALSE
3193cdf0e10cSrcweir for (SCROW nRow=nStartNo; nRow<=nEndNo; nRow++)
3194cdf0e10cSrcweir {
3195cdf0e10cSrcweir sal_uInt8 nOld = pDoc->GetRowFlags(nRow,nTab);
3196cdf0e10cSrcweir SCROW nLastRow = -1;
3197cdf0e10cSrcweir bool bHidden = pDoc->RowHidden(nRow, nTab, nLastRow);
3198cdf0e10cSrcweir if ( !bHidden && ( nOld & CR_MANUALSIZE ) )
3199cdf0e10cSrcweir pDoc->SetRowFlags( nRow, nTab, nOld & ~CR_MANUALSIZE );
3200cdf0e10cSrcweir }
3201cdf0e10cSrcweir }
3202cdf0e10cSrcweir
3203cdf0e10cSrcweir ScSizeDeviceProvider aProv( &rDocShell );
3204cdf0e10cSrcweir Fraction aOne(1,1);
3205cdf0e10cSrcweir pDoc->SetOptimalHeight( nStartNo, nEndNo, nTab, 0, aProv.GetDevice(),
3206cdf0e10cSrcweir aProv.GetPPTX(), aProv.GetPPTY(), aOne, aOne, bAll );
3207cdf0e10cSrcweir
3208cdf0e10cSrcweir if (bAll)
3209cdf0e10cSrcweir pDoc->ShowRows( nStartNo, nEndNo, nTab, sal_True );
3210cdf0e10cSrcweir
3211cdf0e10cSrcweir // Manual-Flag wird bei bAll=sal_True schon in SetOptimalHeight gesetzt
3212cdf0e10cSrcweir // (an bei Extra-Height, sonst aus).
3213cdf0e10cSrcweir }
3214cdf0e10cSrcweir else if ( eMode==SC_SIZE_DIRECT || eMode==SC_SIZE_ORIGINAL )
3215cdf0e10cSrcweir {
3216cdf0e10cSrcweir if (nSizeTwips)
3217cdf0e10cSrcweir {
3218cdf0e10cSrcweir pDoc->SetRowHeightRange( nStartNo, nEndNo, nTab, nSizeTwips );
3219cdf0e10cSrcweir pDoc->SetManualHeight( nStartNo, nEndNo, nTab, sal_True ); // height was set manually
3220cdf0e10cSrcweir }
3221cdf0e10cSrcweir if ( eMode != SC_SIZE_ORIGINAL )
3222cdf0e10cSrcweir pDoc->ShowRows( nStartNo, nEndNo, nTab, nSizeTwips != 0 );
3223cdf0e10cSrcweir }
3224cdf0e10cSrcweir else if ( eMode==SC_SIZE_SHOW )
3225cdf0e10cSrcweir {
3226cdf0e10cSrcweir pDoc->ShowRows( nStartNo, nEndNo, nTab, sal_True );
3227cdf0e10cSrcweir }
3228cdf0e10cSrcweir }
3229cdf0e10cSrcweir else // Spaltenbreiten
3230cdf0e10cSrcweir {
3231cdf0e10cSrcweir for (SCCOL nCol=static_cast<SCCOL>(nStartNo); nCol<=static_cast<SCCOL>(nEndNo); nCol++)
3232cdf0e10cSrcweir {
3233cdf0e10cSrcweir SCCOL nLastCol = -1;
3234cdf0e10cSrcweir if ( eMode != SC_SIZE_VISOPT || !pDoc->ColHidden(nCol, nTab, nLastCol) )
3235cdf0e10cSrcweir {
3236cdf0e10cSrcweir sal_uInt16 nThisSize = nSizeTwips;
3237cdf0e10cSrcweir
3238cdf0e10cSrcweir if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
3239cdf0e10cSrcweir nThisSize = nSizeTwips +
3240cdf0e10cSrcweir lcl_GetOptimalColWidth( rDocShell, nCol, nTab, bFormula );
3241cdf0e10cSrcweir if ( nThisSize )
3242cdf0e10cSrcweir pDoc->SetColWidth( nCol, nTab, nThisSize );
3243cdf0e10cSrcweir
3244cdf0e10cSrcweir if ( eMode != SC_SIZE_ORIGINAL )
3245cdf0e10cSrcweir pDoc->ShowCol( nCol, nTab, bShow );
3246cdf0e10cSrcweir }
3247cdf0e10cSrcweir }
3248cdf0e10cSrcweir }
3249cdf0e10cSrcweir
3250cdf0e10cSrcweir // adjust outlines
3251cdf0e10cSrcweir
3252cdf0e10cSrcweir if ( eMode != SC_SIZE_ORIGINAL )
3253cdf0e10cSrcweir {
3254cdf0e10cSrcweir if (bWidth)
3255cdf0e10cSrcweir bOutline = bOutline || pDoc->UpdateOutlineCol(
3256cdf0e10cSrcweir static_cast<SCCOL>(nStartNo),
3257cdf0e10cSrcweir static_cast<SCCOL>(nEndNo), nTab, bShow );
3258cdf0e10cSrcweir else
3259cdf0e10cSrcweir bOutline = bOutline || pDoc->UpdateOutlineRow(
3260cdf0e10cSrcweir static_cast<SCROW>(nStartNo),
3261cdf0e10cSrcweir static_cast<SCROW>(nEndNo), nTab, bShow );
3262cdf0e10cSrcweir }
3263cdf0e10cSrcweir }
3264cdf0e10cSrcweir pDoc->DecSizeRecalcLevel( nTab ); // nicht fuer jede Spalte einzeln
3265cdf0e10cSrcweir
3266cdf0e10cSrcweir if (!bOutline)
3267cdf0e10cSrcweir DELETEZ(pUndoTab);
3268cdf0e10cSrcweir
3269cdf0e10cSrcweir if (bRecord)
3270cdf0e10cSrcweir {
3271cdf0e10cSrcweir ScMarkData aMark;
3272cdf0e10cSrcweir aMark.SelectOneTable( nTab );
3273cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3274cdf0e10cSrcweir new ScUndoWidthOrHeight( &rDocShell, aMark,
3275cdf0e10cSrcweir nStart, nTab, nEnd, nTab,
3276cdf0e10cSrcweir pUndoDoc, nRangeCnt, pUndoRanges,
3277cdf0e10cSrcweir pUndoTab, eMode, nSizeTwips, bWidth ) );
3278cdf0e10cSrcweir }
3279cdf0e10cSrcweir
3280cdf0e10cSrcweir pDoc->UpdatePageBreaks( nTab );
3281cdf0e10cSrcweir
3282cdf0e10cSrcweir rDocShell.PostPaint(0,0,nTab,MAXCOL,MAXROW,nTab,PAINT_ALL);
3283cdf0e10cSrcweir aModificator.SetDocumentModified();
3284cdf0e10cSrcweir
3285cdf0e10cSrcweir return bSuccess;
3286cdf0e10cSrcweir }
3287cdf0e10cSrcweir
3288cdf0e10cSrcweir
InsertPageBreak(sal_Bool bColumn,const ScAddress & rPos,sal_Bool bRecord,sal_Bool bSetModified,sal_Bool)3289cdf0e10cSrcweir sal_Bool ScDocFunc::InsertPageBreak( sal_Bool bColumn, const ScAddress& rPos,
3290cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bSetModified, sal_Bool /* bApi */ )
3291cdf0e10cSrcweir {
3292cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3293cdf0e10cSrcweir
3294cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3295cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
3296cdf0e10cSrcweir bRecord = sal_False;
3297cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
3298cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
3299cdf0e10cSrcweir
3300cdf0e10cSrcweir SCCOLROW nPos = bColumn ? static_cast<SCCOLROW>(rPos.Col()) :
3301cdf0e10cSrcweir static_cast<SCCOLROW>(rPos.Row());
3302cdf0e10cSrcweir if (nPos == 0)
3303cdf0e10cSrcweir return sal_False; // erste Spalte / Zeile
3304cdf0e10cSrcweir
3305cdf0e10cSrcweir ScBreakType nBreak = bColumn ?
3306cdf0e10cSrcweir pDoc->HasColBreak(static_cast<SCCOL>(nPos), nTab) :
3307cdf0e10cSrcweir pDoc->HasRowBreak(static_cast<SCROW>(nPos), nTab);
3308cdf0e10cSrcweir if (nBreak & BREAK_MANUAL)
3309cdf0e10cSrcweir return true;
3310cdf0e10cSrcweir
3311cdf0e10cSrcweir if (bRecord)
3312cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3313cdf0e10cSrcweir new ScUndoPageBreak( &rDocShell, rPos.Col(), rPos.Row(), nTab, bColumn, sal_True ) );
3314cdf0e10cSrcweir
3315cdf0e10cSrcweir if (bColumn)
3316cdf0e10cSrcweir pDoc->SetColBreak(static_cast<SCCOL>(nPos), nTab, false, true);
3317cdf0e10cSrcweir else
3318cdf0e10cSrcweir pDoc->SetRowBreak(static_cast<SCROW>(nPos), nTab, false, true);
3319cdf0e10cSrcweir
3320cdf0e10cSrcweir pDoc->InvalidatePageBreaks(nTab);
3321cdf0e10cSrcweir pDoc->UpdatePageBreaks( nTab );
3322cdf0e10cSrcweir
3323cdf0e10cSrcweir if (pDoc->IsStreamValid(nTab))
3324cdf0e10cSrcweir pDoc->SetStreamValid(nTab, sal_False);
3325cdf0e10cSrcweir
3326cdf0e10cSrcweir if (bColumn)
3327cdf0e10cSrcweir {
3328cdf0e10cSrcweir rDocShell.PostPaint( static_cast<SCCOL>(nPos)-1, 0, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID );
3329cdf0e10cSrcweir if (pBindings)
3330cdf0e10cSrcweir {
3331cdf0e10cSrcweir pBindings->Invalidate( FID_INS_COLBRK );
3332cdf0e10cSrcweir pBindings->Invalidate( FID_DEL_COLBRK );
3333cdf0e10cSrcweir }
3334cdf0e10cSrcweir }
3335cdf0e10cSrcweir else
3336cdf0e10cSrcweir {
3337cdf0e10cSrcweir rDocShell.PostPaint( 0, static_cast<SCROW>(nPos)-1, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID );
3338cdf0e10cSrcweir if (pBindings)
3339cdf0e10cSrcweir {
3340cdf0e10cSrcweir pBindings->Invalidate( FID_INS_ROWBRK );
3341cdf0e10cSrcweir pBindings->Invalidate( FID_DEL_ROWBRK );
3342cdf0e10cSrcweir }
3343cdf0e10cSrcweir }
3344cdf0e10cSrcweir if (pBindings)
3345cdf0e10cSrcweir pBindings->Invalidate( FID_DEL_MANUALBREAKS );
3346cdf0e10cSrcweir
3347cdf0e10cSrcweir if (bSetModified)
3348cdf0e10cSrcweir aModificator.SetDocumentModified();
3349cdf0e10cSrcweir
3350cdf0e10cSrcweir return sal_True;
3351cdf0e10cSrcweir }
3352cdf0e10cSrcweir
RemovePageBreak(sal_Bool bColumn,const ScAddress & rPos,sal_Bool bRecord,sal_Bool bSetModified,sal_Bool)3353cdf0e10cSrcweir sal_Bool ScDocFunc::RemovePageBreak( sal_Bool bColumn, const ScAddress& rPos,
3354cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bSetModified, sal_Bool /* bApi */ )
3355cdf0e10cSrcweir {
3356cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3357cdf0e10cSrcweir
3358cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3359cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
3360cdf0e10cSrcweir bRecord = sal_False;
3361cdf0e10cSrcweir SCTAB nTab = rPos.Tab();
3362cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
3363cdf0e10cSrcweir
3364cdf0e10cSrcweir SCCOLROW nPos = bColumn ? static_cast<SCCOLROW>(rPos.Col()) :
3365cdf0e10cSrcweir static_cast<SCCOLROW>(rPos.Row());
3366cdf0e10cSrcweir
3367cdf0e10cSrcweir ScBreakType nBreak;
3368cdf0e10cSrcweir if (bColumn)
3369cdf0e10cSrcweir nBreak = pDoc->HasColBreak(static_cast<SCCOL>(nPos), nTab);
3370cdf0e10cSrcweir else
3371cdf0e10cSrcweir nBreak = pDoc->HasRowBreak(static_cast<SCROW>(nPos), nTab);
3372cdf0e10cSrcweir if ((nBreak & BREAK_MANUAL) == 0)
3373cdf0e10cSrcweir // There is no manual break.
3374cdf0e10cSrcweir return false;
3375cdf0e10cSrcweir
3376cdf0e10cSrcweir if (bRecord)
3377cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3378cdf0e10cSrcweir new ScUndoPageBreak( &rDocShell, rPos.Col(), rPos.Row(), nTab, bColumn, sal_False ) );
3379cdf0e10cSrcweir
3380cdf0e10cSrcweir if (bColumn)
3381cdf0e10cSrcweir pDoc->RemoveColBreak(static_cast<SCCOL>(nPos), nTab, false, true);
3382cdf0e10cSrcweir else
3383cdf0e10cSrcweir pDoc->RemoveRowBreak(static_cast<SCROW>(nPos), nTab, false, true);
3384cdf0e10cSrcweir
3385cdf0e10cSrcweir pDoc->UpdatePageBreaks( nTab );
3386cdf0e10cSrcweir
3387cdf0e10cSrcweir if (pDoc->IsStreamValid(nTab))
3388cdf0e10cSrcweir pDoc->SetStreamValid(nTab, sal_False);
3389cdf0e10cSrcweir
3390cdf0e10cSrcweir if (bColumn)
3391cdf0e10cSrcweir {
3392cdf0e10cSrcweir rDocShell.PostPaint( static_cast<SCCOL>(nPos)-1, 0, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID );
3393cdf0e10cSrcweir if (pBindings)
3394cdf0e10cSrcweir {
3395cdf0e10cSrcweir pBindings->Invalidate( FID_INS_COLBRK );
3396cdf0e10cSrcweir pBindings->Invalidate( FID_DEL_COLBRK );
3397cdf0e10cSrcweir }
3398cdf0e10cSrcweir }
3399cdf0e10cSrcweir else
3400cdf0e10cSrcweir {
3401cdf0e10cSrcweir rDocShell.PostPaint( 0, nPos-1, nTab, MAXCOL, MAXROW, nTab, PAINT_GRID );
3402cdf0e10cSrcweir if (pBindings)
3403cdf0e10cSrcweir {
3404cdf0e10cSrcweir pBindings->Invalidate( FID_INS_ROWBRK );
3405cdf0e10cSrcweir pBindings->Invalidate( FID_DEL_ROWBRK );
3406cdf0e10cSrcweir }
3407cdf0e10cSrcweir }
3408cdf0e10cSrcweir if (pBindings)
3409cdf0e10cSrcweir pBindings->Invalidate( FID_DEL_MANUALBREAKS );
3410cdf0e10cSrcweir
3411cdf0e10cSrcweir if (bSetModified)
3412cdf0e10cSrcweir aModificator.SetDocumentModified();
3413cdf0e10cSrcweir
3414cdf0e10cSrcweir return sal_True;
3415cdf0e10cSrcweir }
3416cdf0e10cSrcweir
3417cdf0e10cSrcweir //------------------------------------------------------------------------
3418cdf0e10cSrcweir
ProtectSheet(SCTAB nTab,const ScTableProtection & rProtect)3419cdf0e10cSrcweir void ScDocFunc::ProtectSheet( SCTAB nTab, const ScTableProtection& rProtect )
3420cdf0e10cSrcweir {
3421cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3422cdf0e10cSrcweir
3423cdf0e10cSrcweir pDoc->SetTabProtection(nTab, &rProtect);
3424cdf0e10cSrcweir if (pDoc->IsUndoEnabled())
3425cdf0e10cSrcweir {
3426cdf0e10cSrcweir ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
3427cdf0e10cSrcweir DBG_ASSERT(pProtect, "ScDocFunc::Unprotect: ScTableProtection pointer is NULL!");
3428cdf0e10cSrcweir if (pProtect)
3429cdf0e10cSrcweir {
3430cdf0e10cSrcweir ::std::auto_ptr<ScTableProtection> p(new ScTableProtection(*pProtect));
3431cdf0e10cSrcweir p->setProtected(true); // just in case ...
3432cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3433cdf0e10cSrcweir new ScUndoTabProtect(&rDocShell, nTab, p) );
3434cdf0e10cSrcweir
3435cdf0e10cSrcweir // ownership of auto_ptr now transferred to ScUndoTabProtect.
3436cdf0e10cSrcweir }
3437cdf0e10cSrcweir }
3438cdf0e10cSrcweir
3439cdf0e10cSrcweir rDocShell.PostPaintGridAll();
3440cdf0e10cSrcweir ScDocShellModificator aModificator(rDocShell);
3441cdf0e10cSrcweir aModificator.SetDocumentModified();
3442cdf0e10cSrcweir }
3443cdf0e10cSrcweir
Protect(SCTAB nTab,const String & rPassword,sal_Bool)3444cdf0e10cSrcweir sal_Bool ScDocFunc::Protect( SCTAB nTab, const String& rPassword, sal_Bool /*bApi*/ )
3445cdf0e10cSrcweir {
3446cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3447cdf0e10cSrcweir if (nTab == TABLEID_DOC)
3448cdf0e10cSrcweir {
3449cdf0e10cSrcweir // document protection
3450cdf0e10cSrcweir ScDocProtection aProtection;
3451cdf0e10cSrcweir aProtection.setProtected(true);
3452cdf0e10cSrcweir aProtection.setPassword(rPassword);
3453cdf0e10cSrcweir pDoc->SetDocProtection(&aProtection);
3454cdf0e10cSrcweir if (pDoc->IsUndoEnabled())
3455cdf0e10cSrcweir {
3456cdf0e10cSrcweir ScDocProtection* pProtect = pDoc->GetDocProtection();
3457cdf0e10cSrcweir DBG_ASSERT(pProtect, "ScDocFunc::Unprotect: ScDocProtection pointer is NULL!");
3458cdf0e10cSrcweir if (pProtect)
3459cdf0e10cSrcweir {
3460cdf0e10cSrcweir ::std::auto_ptr<ScDocProtection> p(new ScDocProtection(*pProtect));
3461cdf0e10cSrcweir p->setProtected(true); // just in case ...
3462cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3463cdf0e10cSrcweir new ScUndoDocProtect(&rDocShell, p) );
3464cdf0e10cSrcweir // ownership of auto_ptr is transferred to ScUndoDocProtect.
3465cdf0e10cSrcweir }
3466cdf0e10cSrcweir }
3467cdf0e10cSrcweir }
3468cdf0e10cSrcweir else
3469cdf0e10cSrcweir {
3470cdf0e10cSrcweir // sheet protection
3471cdf0e10cSrcweir
3472cdf0e10cSrcweir ScTableProtection aProtection;
3473cdf0e10cSrcweir aProtection.setProtected(true);
3474cdf0e10cSrcweir aProtection.setPassword(rPassword);
3475cdf0e10cSrcweir pDoc->SetTabProtection(nTab, &aProtection);
3476cdf0e10cSrcweir if (pDoc->IsUndoEnabled())
3477cdf0e10cSrcweir {
3478cdf0e10cSrcweir ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
3479cdf0e10cSrcweir DBG_ASSERT(pProtect, "ScDocFunc::Unprotect: ScTableProtection pointer is NULL!");
3480cdf0e10cSrcweir if (pProtect)
3481cdf0e10cSrcweir {
3482cdf0e10cSrcweir ::std::auto_ptr<ScTableProtection> p(new ScTableProtection(*pProtect));
3483cdf0e10cSrcweir p->setProtected(true); // just in case ...
3484cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3485cdf0e10cSrcweir new ScUndoTabProtect(&rDocShell, nTab, p) );
3486cdf0e10cSrcweir // ownership of auto_ptr now transferred to ScUndoTabProtect.
3487cdf0e10cSrcweir }
3488cdf0e10cSrcweir }
3489cdf0e10cSrcweir }
3490cdf0e10cSrcweir
3491cdf0e10cSrcweir rDocShell.PostPaintGridAll();
3492cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3493cdf0e10cSrcweir aModificator.SetDocumentModified();
3494cdf0e10cSrcweir
3495cdf0e10cSrcweir return true;
3496cdf0e10cSrcweir }
3497cdf0e10cSrcweir
Unprotect(SCTAB nTab,const String & rPassword,sal_Bool bApi)3498cdf0e10cSrcweir sal_Bool ScDocFunc::Unprotect( SCTAB nTab, const String& rPassword, sal_Bool bApi )
3499cdf0e10cSrcweir {
3500cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3501cdf0e10cSrcweir
3502cdf0e10cSrcweir if (nTab == TABLEID_DOC)
3503cdf0e10cSrcweir {
3504cdf0e10cSrcweir // document protection
3505cdf0e10cSrcweir
3506cdf0e10cSrcweir ScDocProtection* pDocProtect = pDoc->GetDocProtection();
3507cdf0e10cSrcweir if (!pDocProtect || !pDocProtect->isProtected())
3508cdf0e10cSrcweir // already unprotected (should not happen)!
3509cdf0e10cSrcweir return true;
3510cdf0e10cSrcweir
3511cdf0e10cSrcweir // save the protection state before unprotect (for undo).
3512cdf0e10cSrcweir ::std::auto_ptr<ScDocProtection> pProtectCopy(new ScDocProtection(*pDocProtect));
3513cdf0e10cSrcweir
3514cdf0e10cSrcweir if (!pDocProtect->verifyPassword(rPassword))
3515cdf0e10cSrcweir {
3516cdf0e10cSrcweir if (!bApi)
3517cdf0e10cSrcweir {
3518cdf0e10cSrcweir InfoBox aBox( rDocShell.GetActiveDialogParent(), String( ScResId( SCSTR_WRONGPASSWORD ) ) );
3519cdf0e10cSrcweir aBox.Execute();
3520cdf0e10cSrcweir }
3521cdf0e10cSrcweir return false;
3522cdf0e10cSrcweir }
3523cdf0e10cSrcweir
3524cdf0e10cSrcweir pDoc->SetDocProtection(NULL);
3525cdf0e10cSrcweir if (pDoc->IsUndoEnabled())
3526cdf0e10cSrcweir {
3527cdf0e10cSrcweir pProtectCopy->setProtected(false);
3528cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3529cdf0e10cSrcweir new ScUndoDocProtect(&rDocShell, pProtectCopy) );
3530cdf0e10cSrcweir // ownership of auto_ptr now transferred to ScUndoDocProtect.
3531cdf0e10cSrcweir }
3532cdf0e10cSrcweir }
3533cdf0e10cSrcweir else
3534cdf0e10cSrcweir {
3535cdf0e10cSrcweir // sheet protection
3536cdf0e10cSrcweir
3537cdf0e10cSrcweir ScTableProtection* pTabProtect = pDoc->GetTabProtection(nTab);
3538cdf0e10cSrcweir if (!pTabProtect || !pTabProtect->isProtected())
3539cdf0e10cSrcweir // already unprotected (should not happen)!
3540cdf0e10cSrcweir return true;
3541cdf0e10cSrcweir
3542cdf0e10cSrcweir // save the protection state before unprotect (for undo).
3543cdf0e10cSrcweir ::std::auto_ptr<ScTableProtection> pProtectCopy(new ScTableProtection(*pTabProtect));
3544cdf0e10cSrcweir if (!pTabProtect->verifyPassword(rPassword))
3545cdf0e10cSrcweir {
3546cdf0e10cSrcweir if (!bApi)
3547cdf0e10cSrcweir {
3548cdf0e10cSrcweir InfoBox aBox( rDocShell.GetActiveDialogParent(), String( ScResId( SCSTR_WRONGPASSWORD ) ) );
3549cdf0e10cSrcweir aBox.Execute();
3550cdf0e10cSrcweir }
3551cdf0e10cSrcweir return false;
3552cdf0e10cSrcweir }
3553cdf0e10cSrcweir
3554cdf0e10cSrcweir pDoc->SetTabProtection(nTab, NULL);
3555cdf0e10cSrcweir if (pDoc->IsUndoEnabled())
3556cdf0e10cSrcweir {
3557cdf0e10cSrcweir pProtectCopy->setProtected(false);
3558cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3559cdf0e10cSrcweir new ScUndoTabProtect(&rDocShell, nTab, pProtectCopy) );
3560cdf0e10cSrcweir // ownership of auto_ptr now transferred to ScUndoTabProtect.
3561cdf0e10cSrcweir }
3562cdf0e10cSrcweir }
3563cdf0e10cSrcweir
3564cdf0e10cSrcweir rDocShell.PostPaintGridAll();
3565cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3566cdf0e10cSrcweir aModificator.SetDocumentModified();
3567cdf0e10cSrcweir
3568cdf0e10cSrcweir return true;
3569cdf0e10cSrcweir }
3570cdf0e10cSrcweir
3571cdf0e10cSrcweir //------------------------------------------------------------------------
3572cdf0e10cSrcweir
ClearItems(const ScMarkData & rMark,const sal_uInt16 * pWhich,sal_Bool bApi)3573cdf0e10cSrcweir sal_Bool ScDocFunc::ClearItems( const ScMarkData& rMark, const sal_uInt16* pWhich, sal_Bool bApi )
3574cdf0e10cSrcweir {
3575cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3576cdf0e10cSrcweir
3577cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3578cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
3579cdf0e10cSrcweir ScEditableTester aTester( pDoc, rMark );
3580cdf0e10cSrcweir if (!aTester.IsEditable())
3581cdf0e10cSrcweir {
3582cdf0e10cSrcweir if (!bApi)
3583cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
3584cdf0e10cSrcweir return sal_False;
3585cdf0e10cSrcweir }
3586cdf0e10cSrcweir
3587cdf0e10cSrcweir // #i12940# ClearItems is called (from setPropertyToDefault) directly with uno object's cached
3588cdf0e10cSrcweir // MarkData (GetMarkData), so rMark must be changed to multi selection for ClearSelectionItems
3589cdf0e10cSrcweir // here.
3590cdf0e10cSrcweir
3591cdf0e10cSrcweir ScRange aMarkRange;
3592cdf0e10cSrcweir ScMarkData aMultiMark = rMark;
3593cdf0e10cSrcweir aMultiMark.SetMarking(sal_False); // for MarkToMulti
3594cdf0e10cSrcweir aMultiMark.MarkToMulti();
3595cdf0e10cSrcweir aMultiMark.GetMultiMarkArea( aMarkRange );
3596cdf0e10cSrcweir
3597cdf0e10cSrcweir // if (bRecord)
3598cdf0e10cSrcweir if (bUndo)
3599cdf0e10cSrcweir {
3600cdf0e10cSrcweir SCTAB nStartTab = aMarkRange.aStart.Tab();
3601cdf0e10cSrcweir SCTAB nEndTab = aMarkRange.aEnd.Tab();
3602cdf0e10cSrcweir
3603cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
3604cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab );
3605cdf0e10cSrcweir pDoc->CopyToDocument( aMarkRange, IDF_ATTRIB, sal_True, pUndoDoc, (ScMarkData*)&aMultiMark );
3606cdf0e10cSrcweir
3607cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3608cdf0e10cSrcweir new ScUndoClearItems( &rDocShell, aMultiMark, pUndoDoc, pWhich ) );
3609cdf0e10cSrcweir }
3610cdf0e10cSrcweir
3611cdf0e10cSrcweir pDoc->ClearSelectionItems( pWhich, aMultiMark );
3612cdf0e10cSrcweir
3613cdf0e10cSrcweir rDocShell.PostPaint( aMarkRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
3614cdf0e10cSrcweir aModificator.SetDocumentModified();
3615cdf0e10cSrcweir
3616cdf0e10cSrcweir //! Bindings-Invalidate etc.?
3617cdf0e10cSrcweir
3618cdf0e10cSrcweir return sal_True;
3619cdf0e10cSrcweir }
3620cdf0e10cSrcweir
ChangeIndent(const ScMarkData & rMark,sal_Bool bIncrement,sal_Bool bApi)3621cdf0e10cSrcweir sal_Bool ScDocFunc::ChangeIndent( const ScMarkData& rMark, sal_Bool bIncrement, sal_Bool bApi )
3622cdf0e10cSrcweir {
3623cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3624cdf0e10cSrcweir
3625cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3626cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
3627cdf0e10cSrcweir ScEditableTester aTester( pDoc, rMark );
3628cdf0e10cSrcweir if (!aTester.IsEditable())
3629cdf0e10cSrcweir {
3630cdf0e10cSrcweir if (!bApi)
3631cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
3632cdf0e10cSrcweir return sal_False;
3633cdf0e10cSrcweir }
3634cdf0e10cSrcweir
3635cdf0e10cSrcweir ScRange aMarkRange;
3636cdf0e10cSrcweir rMark.GetMultiMarkArea( aMarkRange );
3637cdf0e10cSrcweir
3638cdf0e10cSrcweir // if (bRecord)
3639cdf0e10cSrcweir if (bUndo)
3640cdf0e10cSrcweir {
3641cdf0e10cSrcweir SCTAB nStartTab = aMarkRange.aStart.Tab();
3642cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
3643cdf0e10cSrcweir
3644cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
3645cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
3646cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
3647cdf0e10cSrcweir if (i != nStartTab && rMark.GetTableSelect(i))
3648cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
3649cdf0e10cSrcweir
3650cdf0e10cSrcweir ScRange aCopyRange = aMarkRange;
3651cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
3652cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
3653cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, sal_True, pUndoDoc, (ScMarkData*)&rMark );
3654cdf0e10cSrcweir
3655cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3656cdf0e10cSrcweir new ScUndoIndent( &rDocShell, rMark, pUndoDoc, bIncrement ) );
3657cdf0e10cSrcweir }
3658cdf0e10cSrcweir
3659cdf0e10cSrcweir pDoc->ChangeSelectionIndent( bIncrement, rMark );
3660cdf0e10cSrcweir
3661cdf0e10cSrcweir rDocShell.PostPaint( aMarkRange, PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
3662cdf0e10cSrcweir aModificator.SetDocumentModified();
3663cdf0e10cSrcweir
3664cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
3665cdf0e10cSrcweir if (pBindings)
3666cdf0e10cSrcweir {
3667cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGNLEFT ); // ChangeIndent setzt auf links
3668cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGNRIGHT );
3669cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGNBLOCK );
3670cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGNCENTERHOR );
3671512ec161SZheng Fan pBindings->Invalidate( SID_ATTR_LRSPACE );
3672766ce4d0SZheng Fan pBindings->Invalidate( SID_ATTR_PARA_ADJUST_LEFT );
3673766ce4d0SZheng Fan pBindings->Invalidate( SID_ATTR_PARA_ADJUST_RIGHT );
3674766ce4d0SZheng Fan pBindings->Invalidate( SID_ATTR_PARA_ADJUST_BLOCK );
3675766ce4d0SZheng Fan pBindings->Invalidate( SID_ATTR_PARA_ADJUST_CENTER);
3676cdf0e10cSrcweir // pseudo slots for Format menu
3677cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGN_ANY_HDEFAULT );
3678cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGN_ANY_LEFT );
3679cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGN_ANY_HCENTER );
3680cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGN_ANY_RIGHT );
3681cdf0e10cSrcweir pBindings->Invalidate( SID_ALIGN_ANY_JUSTIFIED );
3682cdf0e10cSrcweir }
3683cdf0e10cSrcweir
3684cdf0e10cSrcweir return sal_True;
3685cdf0e10cSrcweir }
3686cdf0e10cSrcweir
AutoFormat(const ScRange & rRange,const ScMarkData * pTabMark,sal_uInt16 nFormatNo,sal_Bool bRecord,sal_Bool bApi)3687cdf0e10cSrcweir sal_Bool ScDocFunc::AutoFormat( const ScRange& rRange, const ScMarkData* pTabMark,
3688cdf0e10cSrcweir sal_uInt16 nFormatNo, sal_Bool bRecord, sal_Bool bApi )
3689cdf0e10cSrcweir {
3690cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3691cdf0e10cSrcweir
3692cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
3693cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3694cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
3695cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
3696cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
3697cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
3698cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
3699cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
3700cdf0e10cSrcweir
3701cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
3702cdf0e10cSrcweir bRecord = sal_False;
3703cdf0e10cSrcweir ScMarkData aMark;
3704cdf0e10cSrcweir if (pTabMark)
3705cdf0e10cSrcweir aMark = *pTabMark;
3706cdf0e10cSrcweir else
3707cdf0e10cSrcweir {
3708cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
3709cdf0e10cSrcweir aMark.SelectTable( nTab, sal_True );
3710cdf0e10cSrcweir }
3711cdf0e10cSrcweir
3712cdf0e10cSrcweir ScAutoFormat* pAutoFormat = ScGlobal::GetAutoFormat();
3713cdf0e10cSrcweir ScEditableTester aTester( pDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
3714cdf0e10cSrcweir if ( pAutoFormat && nFormatNo < pAutoFormat->GetCount() && aTester.IsEditable() )
3715cdf0e10cSrcweir {
3716cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
3717cdf0e10cSrcweir
3718cdf0e10cSrcweir sal_Bool bSize = (*pAutoFormat)[nFormatNo]->GetIncludeWidthHeight();
3719cdf0e10cSrcweir
3720cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
3721cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
3722cdf0e10cSrcweir if ( bRecord )
3723cdf0e10cSrcweir {
3724cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
3725cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab, bSize, bSize );
3726cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
3727cdf0e10cSrcweir if (i != nStartTab && aMark.GetTableSelect(i))
3728cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i, bSize, bSize );
3729cdf0e10cSrcweir
3730cdf0e10cSrcweir ScRange aCopyRange = rRange;
3731cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
3732cdf0e10cSrcweir aCopyRange.aStart.SetTab(nTabCount-1);
3733cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_ATTRIB, sal_False, pUndoDoc, &aMark );
3734cdf0e10cSrcweir if (bSize)
3735cdf0e10cSrcweir {
3736cdf0e10cSrcweir pDoc->CopyToDocument( nStartCol,0,0, nEndCol,MAXROW,nTabCount-1,
3737cdf0e10cSrcweir IDF_NONE, sal_False, pUndoDoc, &aMark );
3738cdf0e10cSrcweir pDoc->CopyToDocument( 0,nStartRow,0, MAXCOL,nEndRow,nTabCount-1,
3739cdf0e10cSrcweir IDF_NONE, sal_False, pUndoDoc, &aMark );
3740cdf0e10cSrcweir }
3741cdf0e10cSrcweir pDoc->BeginDrawUndo();
3742cdf0e10cSrcweir }
3743cdf0e10cSrcweir
3744cdf0e10cSrcweir pDoc->AutoFormat( nStartCol, nStartRow, nEndCol, nEndRow, nFormatNo, aMark );
3745cdf0e10cSrcweir
3746cdf0e10cSrcweir if (bSize)
3747cdf0e10cSrcweir {
3748cdf0e10cSrcweir /* SCCOL nCols[2];
3749cdf0e10cSrcweir nCols[0] = nStartCol;
3750cdf0e10cSrcweir nCols[1] = nEndCol;
3751cdf0e10cSrcweir SCROW nRows[2];
3752cdf0e10cSrcweir nRows[0] = nStartRow;
3753cdf0e10cSrcweir nRows[1] = nEndRow;
3754cdf0e10cSrcweir */
3755cdf0e10cSrcweir SCCOLROW nCols[2] = { nStartCol, nEndCol };
3756cdf0e10cSrcweir SCCOLROW nRows[2] = { nStartRow, nEndRow };
3757cdf0e10cSrcweir
3758cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nTabCount; nTab++)
3759cdf0e10cSrcweir if (aMark.GetTableSelect(nTab))
3760cdf0e10cSrcweir {
3761cdf0e10cSrcweir SetWidthOrHeight( sal_True, 1,nCols, nTab, SC_SIZE_VISOPT, STD_EXTRA_WIDTH, sal_False, sal_True);
3762cdf0e10cSrcweir SetWidthOrHeight( sal_False,1,nRows, nTab, SC_SIZE_VISOPT, 0, sal_False, sal_False);
3763cdf0e10cSrcweir rDocShell.PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab,
3764cdf0e10cSrcweir PAINT_GRID | PAINT_LEFT | PAINT_TOP );
3765cdf0e10cSrcweir }
3766cdf0e10cSrcweir }
3767cdf0e10cSrcweir else
3768cdf0e10cSrcweir {
3769cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nTabCount; nTab++)
3770cdf0e10cSrcweir if (aMark.GetTableSelect(nTab))
3771cdf0e10cSrcweir {
3772cdf0e10cSrcweir sal_Bool bAdj = AdjustRowHeight( ScRange(nStartCol, nStartRow, nTab,
3773cdf0e10cSrcweir nEndCol, nEndRow, nTab), sal_False );
3774cdf0e10cSrcweir if (bAdj)
3775cdf0e10cSrcweir rDocShell.PostPaint( 0,nStartRow,nTab, MAXCOL,MAXROW,nTab,
3776cdf0e10cSrcweir PAINT_GRID | PAINT_LEFT );
3777cdf0e10cSrcweir else
3778cdf0e10cSrcweir rDocShell.PostPaint( nStartCol, nStartRow, nTab,
3779cdf0e10cSrcweir nEndCol, nEndRow, nTab, PAINT_GRID );
3780cdf0e10cSrcweir }
3781cdf0e10cSrcweir }
3782cdf0e10cSrcweir
3783cdf0e10cSrcweir if ( bRecord ) // Draw-Undo erst jetzt verfuegbar
3784cdf0e10cSrcweir {
3785cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3786cdf0e10cSrcweir new ScUndoAutoFormat( &rDocShell, rRange, pUndoDoc, aMark, bSize, nFormatNo ) );
3787cdf0e10cSrcweir }
3788cdf0e10cSrcweir
3789cdf0e10cSrcweir aModificator.SetDocumentModified();
3790cdf0e10cSrcweir }
3791cdf0e10cSrcweir else if (!bApi)
3792cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
3793cdf0e10cSrcweir
3794cdf0e10cSrcweir return bSuccess;
3795cdf0e10cSrcweir }
3796cdf0e10cSrcweir
3797cdf0e10cSrcweir //------------------------------------------------------------------------
3798cdf0e10cSrcweir
EnterMatrix(const ScRange & rRange,const ScMarkData * pTabMark,const ScTokenArray * pTokenArray,const String & rString,sal_Bool bApi,sal_Bool bEnglish,const String & rFormulaNmsp,const formula::FormulaGrammar::Grammar eGrammar)3799cdf0e10cSrcweir sal_Bool ScDocFunc::EnterMatrix( const ScRange& rRange, const ScMarkData* pTabMark,
3800cdf0e10cSrcweir const ScTokenArray* pTokenArray, const String& rString, sal_Bool bApi, sal_Bool bEnglish,
3801cdf0e10cSrcweir const String& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar )
3802cdf0e10cSrcweir {
3803cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3804cdf0e10cSrcweir
3805cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
3806cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3807cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
3808cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
3809cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
3810cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
3811cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
3812cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
3813cdf0e10cSrcweir
3814cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
3815cdf0e10cSrcweir
3816cdf0e10cSrcweir ScMarkData aMark;
3817cdf0e10cSrcweir if (pTabMark)
3818cdf0e10cSrcweir aMark = *pTabMark;
3819cdf0e10cSrcweir else
3820cdf0e10cSrcweir {
3821cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
3822cdf0e10cSrcweir aMark.SelectTable( nTab, sal_True );
3823cdf0e10cSrcweir }
3824cdf0e10cSrcweir
3825cdf0e10cSrcweir ScEditableTester aTester( pDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
3826cdf0e10cSrcweir if ( aTester.IsEditable() )
3827cdf0e10cSrcweir {
3828cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
3829cdf0e10cSrcweir
3830cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
3831cdf0e10cSrcweir // if (bRecord) // immer
3832cdf0e10cSrcweir if (bUndo)
3833cdf0e10cSrcweir {
3834cdf0e10cSrcweir //! auch bei Undo selektierte Tabellen beruecksichtigen
3835cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
3836cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab );
3837cdf0e10cSrcweir pDoc->CopyToDocument( rRange, IDF_ALL & ~IDF_NOTE, sal_False, pUndoDoc );
3838cdf0e10cSrcweir }
3839cdf0e10cSrcweir
3840cdf0e10cSrcweir // use TokenArray if given, string (and flags) otherwise
3841cdf0e10cSrcweir if ( pTokenArray )
3842cdf0e10cSrcweir {
3843cdf0e10cSrcweir pDoc->InsertMatrixFormula( nStartCol, nStartRow, nEndCol, nEndRow,
3844cdf0e10cSrcweir aMark, EMPTY_STRING, pTokenArray, eGrammar);
3845cdf0e10cSrcweir }
3846cdf0e10cSrcweir else if ( pDoc->IsImportingXML() )
3847cdf0e10cSrcweir {
3848cdf0e10cSrcweir ScTokenArray* pCode = lcl_ScDocFunc_CreateTokenArrayXML( rString, rFormulaNmsp, eGrammar );
3849cdf0e10cSrcweir pDoc->InsertMatrixFormula( nStartCol, nStartRow, nEndCol, nEndRow,
3850cdf0e10cSrcweir aMark, EMPTY_STRING, pCode, eGrammar);
3851cdf0e10cSrcweir delete pCode;
3852cdf0e10cSrcweir pDoc->IncXMLImportedFormulaCount( rString.Len() );
3853cdf0e10cSrcweir }
3854cdf0e10cSrcweir else if (bEnglish)
3855cdf0e10cSrcweir {
3856cdf0e10cSrcweir ScCompiler aComp( pDoc, rRange.aStart);
3857cdf0e10cSrcweir aComp.SetGrammar(eGrammar);
3858cdf0e10cSrcweir ScTokenArray* pCode = aComp.CompileString( rString );
3859cdf0e10cSrcweir pDoc->InsertMatrixFormula( nStartCol, nStartRow, nEndCol, nEndRow,
3860cdf0e10cSrcweir aMark, EMPTY_STRING, pCode, eGrammar);
3861cdf0e10cSrcweir delete pCode;
3862cdf0e10cSrcweir }
3863cdf0e10cSrcweir else
3864cdf0e10cSrcweir pDoc->InsertMatrixFormula( nStartCol, nStartRow, nEndCol, nEndRow,
3865cdf0e10cSrcweir aMark, rString, NULL, eGrammar);
3866cdf0e10cSrcweir
3867cdf0e10cSrcweir // if (bRecord) // immer
3868cdf0e10cSrcweir if (bUndo)
3869cdf0e10cSrcweir {
3870cdf0e10cSrcweir //! auch bei Undo selektierte Tabellen beruecksichtigen
3871cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3872cdf0e10cSrcweir new ScUndoEnterMatrix( &rDocShell, rRange, pUndoDoc, rString ) );
3873cdf0e10cSrcweir }
3874cdf0e10cSrcweir
3875cdf0e10cSrcweir // Err522 beim Paint von DDE-Formeln werden jetzt beim Interpretieren abgefangen
3876cdf0e10cSrcweir rDocShell.PostPaint( nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab, PAINT_GRID );
3877cdf0e10cSrcweir aModificator.SetDocumentModified();
3878cdf0e10cSrcweir
3879cdf0e10cSrcweir bSuccess = sal_True;
3880cdf0e10cSrcweir }
3881cdf0e10cSrcweir else if (!bApi)
3882cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
3883cdf0e10cSrcweir
3884cdf0e10cSrcweir return bSuccess;
3885cdf0e10cSrcweir }
3886cdf0e10cSrcweir
3887cdf0e10cSrcweir //------------------------------------------------------------------------
3888cdf0e10cSrcweir
TabOp(const ScRange & rRange,const ScMarkData * pTabMark,const ScTabOpParam & rParam,sal_Bool bRecord,sal_Bool bApi)3889cdf0e10cSrcweir sal_Bool ScDocFunc::TabOp( const ScRange& rRange, const ScMarkData* pTabMark,
3890cdf0e10cSrcweir const ScTabOpParam& rParam, sal_Bool bRecord, sal_Bool bApi )
3891cdf0e10cSrcweir {
3892cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3893cdf0e10cSrcweir
3894cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
3895cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3896cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
3897cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
3898cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
3899cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
3900cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
3901cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
3902cdf0e10cSrcweir
3903cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
3904cdf0e10cSrcweir bRecord = sal_False;
3905cdf0e10cSrcweir
3906cdf0e10cSrcweir ScMarkData aMark;
3907cdf0e10cSrcweir if (pTabMark)
3908cdf0e10cSrcweir aMark = *pTabMark;
3909cdf0e10cSrcweir else
3910cdf0e10cSrcweir {
3911cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
3912cdf0e10cSrcweir aMark.SelectTable( nTab, sal_True );
3913cdf0e10cSrcweir }
3914cdf0e10cSrcweir
3915cdf0e10cSrcweir ScEditableTester aTester( pDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
3916cdf0e10cSrcweir if ( aTester.IsEditable() )
3917cdf0e10cSrcweir {
3918cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
3919cdf0e10cSrcweir pDoc->SetDirty( rRange );
3920cdf0e10cSrcweir if ( bRecord )
3921cdf0e10cSrcweir {
3922cdf0e10cSrcweir //! auch bei Undo selektierte Tabellen beruecksichtigen
3923cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
3924cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab );
3925cdf0e10cSrcweir pDoc->CopyToDocument( rRange, IDF_ALL & ~IDF_NOTE, sal_False, pUndoDoc );
3926cdf0e10cSrcweir
3927cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
3928cdf0e10cSrcweir new ScUndoTabOp( &rDocShell,
3929cdf0e10cSrcweir nStartCol, nStartRow, nStartTab,
3930cdf0e10cSrcweir nEndCol, nEndRow, nEndTab, pUndoDoc,
3931cdf0e10cSrcweir rParam.aRefFormulaCell,
3932cdf0e10cSrcweir rParam.aRefFormulaEnd,
3933cdf0e10cSrcweir rParam.aRefRowCell,
3934cdf0e10cSrcweir rParam.aRefColCell,
3935cdf0e10cSrcweir rParam.nMode) );
3936cdf0e10cSrcweir }
3937cdf0e10cSrcweir pDoc->InsertTableOp(rParam, nStartCol, nStartRow, nEndCol, nEndRow, aMark);
3938cdf0e10cSrcweir rDocShell.PostPaintGridAll();
3939cdf0e10cSrcweir aModificator.SetDocumentModified();
3940cdf0e10cSrcweir bSuccess = sal_True;
3941cdf0e10cSrcweir }
3942cdf0e10cSrcweir else if (!bApi)
3943cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
3944cdf0e10cSrcweir
3945cdf0e10cSrcweir return bSuccess;
3946cdf0e10cSrcweir }
3947cdf0e10cSrcweir
3948cdf0e10cSrcweir //------------------------------------------------------------------------
3949cdf0e10cSrcweir
DirFromFillDir(FillDir eDir)3950cdf0e10cSrcweir inline ScDirection DirFromFillDir( FillDir eDir )
3951cdf0e10cSrcweir {
3952cdf0e10cSrcweir if (eDir==FILL_TO_BOTTOM)
3953cdf0e10cSrcweir return DIR_BOTTOM;
3954cdf0e10cSrcweir else if (eDir==FILL_TO_RIGHT)
3955cdf0e10cSrcweir return DIR_RIGHT;
3956cdf0e10cSrcweir else if (eDir==FILL_TO_TOP)
3957cdf0e10cSrcweir return DIR_TOP;
3958cdf0e10cSrcweir else // if (eDir==FILL_TO_LEFT)
3959cdf0e10cSrcweir return DIR_LEFT;
3960cdf0e10cSrcweir }
3961cdf0e10cSrcweir
FillSimple(const ScRange & rRange,const ScMarkData * pTabMark,FillDir eDir,sal_Bool bRecord,sal_Bool bApi)3962cdf0e10cSrcweir sal_Bool ScDocFunc::FillSimple( const ScRange& rRange, const ScMarkData* pTabMark,
3963cdf0e10cSrcweir FillDir eDir, sal_Bool bRecord, sal_Bool bApi )
3964cdf0e10cSrcweir {
3965cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
3966cdf0e10cSrcweir
3967cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
3968cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
3969cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
3970cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
3971cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
3972cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
3973cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
3974cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
3975cdf0e10cSrcweir
3976cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
3977cdf0e10cSrcweir bRecord = sal_False;
3978cdf0e10cSrcweir
3979cdf0e10cSrcweir ScMarkData aMark;
3980cdf0e10cSrcweir if (pTabMark)
3981cdf0e10cSrcweir aMark = *pTabMark;
3982cdf0e10cSrcweir else
3983cdf0e10cSrcweir {
3984cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
3985cdf0e10cSrcweir aMark.SelectTable( nTab, sal_True );
3986cdf0e10cSrcweir }
3987cdf0e10cSrcweir
3988cdf0e10cSrcweir ScEditableTester aTester( pDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
3989cdf0e10cSrcweir if ( aTester.IsEditable() )
3990cdf0e10cSrcweir {
3991cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
3992cdf0e10cSrcweir
3993cdf0e10cSrcweir ScRange aSourceArea = rRange;
3994cdf0e10cSrcweir ScRange aDestArea = rRange;
3995cdf0e10cSrcweir
3996cdf0e10cSrcweir SCCOLROW nCount = 0;
3997cdf0e10cSrcweir switch (eDir)
3998cdf0e10cSrcweir {
3999cdf0e10cSrcweir case FILL_TO_BOTTOM:
4000cdf0e10cSrcweir nCount = aSourceArea.aEnd.Row()-aSourceArea.aStart.Row();
4001cdf0e10cSrcweir aSourceArea.aEnd.SetRow( aSourceArea.aStart.Row() );
4002cdf0e10cSrcweir break;
4003cdf0e10cSrcweir case FILL_TO_RIGHT:
4004cdf0e10cSrcweir nCount = aSourceArea.aEnd.Col()-aSourceArea.aStart.Col();
4005cdf0e10cSrcweir aSourceArea.aEnd.SetCol( aSourceArea.aStart.Col() );
4006cdf0e10cSrcweir break;
4007cdf0e10cSrcweir case FILL_TO_TOP:
4008cdf0e10cSrcweir nCount = aSourceArea.aEnd.Row()-aSourceArea.aStart.Row();
4009cdf0e10cSrcweir aSourceArea.aStart.SetRow( aSourceArea.aEnd.Row() );
4010cdf0e10cSrcweir break;
4011cdf0e10cSrcweir case FILL_TO_LEFT:
4012cdf0e10cSrcweir nCount = aSourceArea.aEnd.Col()-aSourceArea.aStart.Col();
4013cdf0e10cSrcweir aSourceArea.aStart.SetCol( aSourceArea.aEnd.Col() );
4014cdf0e10cSrcweir break;
4015cdf0e10cSrcweir }
4016cdf0e10cSrcweir
4017cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
4018cdf0e10cSrcweir if ( bRecord )
4019cdf0e10cSrcweir {
4020cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
4021cdf0e10cSrcweir SCTAB nDestStartTab = aDestArea.aStart.Tab();
4022cdf0e10cSrcweir
4023cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
4024cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nDestStartTab, nDestStartTab );
4025cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
4026cdf0e10cSrcweir if (i != nDestStartTab && aMark.GetTableSelect(i))
4027cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
4028cdf0e10cSrcweir
4029cdf0e10cSrcweir ScRange aCopyRange = aDestArea;
4030cdf0e10cSrcweir aCopyRange.aStart.SetTab(0);
4031cdf0e10cSrcweir aCopyRange.aEnd.SetTab(nTabCount-1);
4032cdf0e10cSrcweir pDoc->CopyToDocument( aCopyRange, IDF_AUTOFILL, sal_False, pUndoDoc, &aMark );
4033cdf0e10cSrcweir }
4034cdf0e10cSrcweir
4035cdf0e10cSrcweir pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
4036cdf0e10cSrcweir aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
4037cdf0e10cSrcweir nCount, eDir, FILL_SIMPLE );
4038cdf0e10cSrcweir AdjustRowHeight(rRange);
4039cdf0e10cSrcweir
4040cdf0e10cSrcweir if ( bRecord ) // Draw-Undo erst jetzt verfuegbar
4041cdf0e10cSrcweir {
4042cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4043cdf0e10cSrcweir new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
4044cdf0e10cSrcweir eDir, FILL_SIMPLE, FILL_DAY, MAXDOUBLE, 1.0, 1e307,
4045cdf0e10cSrcweir pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
4046cdf0e10cSrcweir }
4047cdf0e10cSrcweir
4048cdf0e10cSrcweir rDocShell.PostPaintGridAll();
4049cdf0e10cSrcweir // rDocShell.PostPaintDataChanged();
4050cdf0e10cSrcweir aModificator.SetDocumentModified();
4051cdf0e10cSrcweir
4052cdf0e10cSrcweir bSuccess = sal_True;
4053cdf0e10cSrcweir }
4054cdf0e10cSrcweir else if (!bApi)
4055cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
4056cdf0e10cSrcweir
4057cdf0e10cSrcweir return bSuccess;
4058cdf0e10cSrcweir }
4059cdf0e10cSrcweir
FillSeries(const ScRange & rRange,const ScMarkData * pTabMark,FillDir eDir,FillCmd eCmd,FillDateCmd eDateCmd,double fStart,double fStep,double fMax,sal_Bool bRecord,sal_Bool bApi)4060cdf0e10cSrcweir sal_Bool ScDocFunc::FillSeries( const ScRange& rRange, const ScMarkData* pTabMark,
4061cdf0e10cSrcweir FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,
4062cdf0e10cSrcweir double fStart, double fStep, double fMax,
4063cdf0e10cSrcweir sal_Bool bRecord, sal_Bool bApi )
4064cdf0e10cSrcweir {
4065cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
4066cdf0e10cSrcweir
4067cdf0e10cSrcweir sal_Bool bSuccess = sal_False;
4068cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4069cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
4070cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
4071cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
4072cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
4073cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
4074cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
4075cdf0e10cSrcweir
4076cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
4077cdf0e10cSrcweir bRecord = sal_False;
4078cdf0e10cSrcweir
4079cdf0e10cSrcweir ScMarkData aMark;
4080cdf0e10cSrcweir if (pTabMark)
4081cdf0e10cSrcweir aMark = *pTabMark;
4082cdf0e10cSrcweir else
4083cdf0e10cSrcweir {
4084cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4085cdf0e10cSrcweir aMark.SelectTable( nTab, sal_True );
4086cdf0e10cSrcweir }
4087cdf0e10cSrcweir
4088cdf0e10cSrcweir ScEditableTester aTester( pDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
4089cdf0e10cSrcweir if ( aTester.IsEditable() )
4090cdf0e10cSrcweir {
4091cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
4092cdf0e10cSrcweir
4093cdf0e10cSrcweir ScRange aSourceArea = rRange;
4094cdf0e10cSrcweir ScRange aDestArea = rRange;
4095cdf0e10cSrcweir
4096cdf0e10cSrcweir SCSIZE nCount = pDoc->GetEmptyLinesInBlock(
4097cdf0e10cSrcweir aSourceArea.aStart.Col(), aSourceArea.aStart.Row(), aSourceArea.aStart.Tab(),
4098cdf0e10cSrcweir aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aSourceArea.aEnd.Tab(),
4099cdf0e10cSrcweir DirFromFillDir(eDir) );
4100cdf0e10cSrcweir
4101cdf0e10cSrcweir // #27665# mindestens eine Zeile/Spalte als Quellbereich behalten:
4102cdf0e10cSrcweir SCSIZE nTotLines = ( eDir == FILL_TO_BOTTOM || eDir == FILL_TO_TOP ) ?
4103cdf0e10cSrcweir static_cast<SCSIZE>( aSourceArea.aEnd.Row() - aSourceArea.aStart.Row() + 1 ) :
4104cdf0e10cSrcweir static_cast<SCSIZE>( aSourceArea.aEnd.Col() - aSourceArea.aStart.Col() + 1 );
4105cdf0e10cSrcweir if ( nCount >= nTotLines )
4106cdf0e10cSrcweir nCount = nTotLines - 1;
4107cdf0e10cSrcweir
4108cdf0e10cSrcweir switch (eDir)
4109cdf0e10cSrcweir {
4110cdf0e10cSrcweir case FILL_TO_BOTTOM:
4111cdf0e10cSrcweir aSourceArea.aEnd.SetRow( sal::static_int_cast<SCROW>( aSourceArea.aEnd.Row() - nCount ) );
4112cdf0e10cSrcweir break;
4113cdf0e10cSrcweir case FILL_TO_RIGHT:
4114cdf0e10cSrcweir aSourceArea.aEnd.SetCol( sal::static_int_cast<SCCOL>( aSourceArea.aEnd.Col() - nCount ) );
4115cdf0e10cSrcweir break;
4116cdf0e10cSrcweir case FILL_TO_TOP:
4117cdf0e10cSrcweir aSourceArea.aStart.SetRow( sal::static_int_cast<SCROW>( aSourceArea.aStart.Row() + nCount ) );
4118cdf0e10cSrcweir break;
4119cdf0e10cSrcweir case FILL_TO_LEFT:
4120cdf0e10cSrcweir aSourceArea.aStart.SetCol( sal::static_int_cast<SCCOL>( aSourceArea.aStart.Col() + nCount ) );
4121cdf0e10cSrcweir break;
4122cdf0e10cSrcweir }
4123cdf0e10cSrcweir
4124cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
4125cdf0e10cSrcweir if ( bRecord )
4126cdf0e10cSrcweir {
4127cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
4128cdf0e10cSrcweir SCTAB nDestStartTab = aDestArea.aStart.Tab();
4129cdf0e10cSrcweir
4130cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
4131cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nDestStartTab, nDestStartTab );
4132cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
4133cdf0e10cSrcweir if (i != nDestStartTab && aMark.GetTableSelect(i))
4134cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
4135cdf0e10cSrcweir
4136cdf0e10cSrcweir pDoc->CopyToDocument(
4137cdf0e10cSrcweir aDestArea.aStart.Col(), aDestArea.aStart.Row(), 0,
4138cdf0e10cSrcweir aDestArea.aEnd.Col(), aDestArea.aEnd.Row(), nTabCount-1,
4139cdf0e10cSrcweir IDF_AUTOFILL, sal_False, pUndoDoc, &aMark );
4140cdf0e10cSrcweir }
4141cdf0e10cSrcweir
4142cdf0e10cSrcweir if (aDestArea.aStart.Col() <= aDestArea.aEnd.Col() &&
4143cdf0e10cSrcweir aDestArea.aStart.Row() <= aDestArea.aEnd.Row())
4144cdf0e10cSrcweir {
4145cdf0e10cSrcweir if ( fStart != MAXDOUBLE )
4146cdf0e10cSrcweir {
4147cdf0e10cSrcweir SCCOL nValX = (eDir == FILL_TO_LEFT) ? aDestArea.aEnd.Col() : aDestArea.aStart.Col();
4148cdf0e10cSrcweir SCROW nValY = (eDir == FILL_TO_TOP ) ? aDestArea.aEnd.Row() : aDestArea.aStart.Row();
4149cdf0e10cSrcweir SCTAB nTab = aDestArea.aStart.Tab();
4150cdf0e10cSrcweir pDoc->SetValue( nValX, nValY, nTab, fStart );
4151cdf0e10cSrcweir }
4152cdf0e10cSrcweir pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
4153cdf0e10cSrcweir aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
4154cdf0e10cSrcweir nCount, eDir, eCmd, eDateCmd, fStep, fMax );
4155cdf0e10cSrcweir AdjustRowHeight(rRange);
4156cdf0e10cSrcweir
4157cdf0e10cSrcweir rDocShell.PostPaintGridAll();
4158cdf0e10cSrcweir // rDocShell.PostPaintDataChanged();
4159cdf0e10cSrcweir aModificator.SetDocumentModified();
4160cdf0e10cSrcweir }
4161cdf0e10cSrcweir
4162cdf0e10cSrcweir if ( bRecord ) // Draw-Undo erst jetzt verfuegbar
4163cdf0e10cSrcweir {
4164cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4165cdf0e10cSrcweir new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
4166cdf0e10cSrcweir eDir, eCmd, eDateCmd, fStart, fStep, fMax,
4167cdf0e10cSrcweir pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
4168cdf0e10cSrcweir }
4169cdf0e10cSrcweir
4170cdf0e10cSrcweir bSuccess = sal_True;
4171cdf0e10cSrcweir }
4172cdf0e10cSrcweir else if (!bApi)
4173cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
4174cdf0e10cSrcweir
4175cdf0e10cSrcweir return bSuccess;
4176cdf0e10cSrcweir }
4177cdf0e10cSrcweir
FillAuto(ScRange & rRange,const ScMarkData * pTabMark,FillDir eDir,sal_uLong nCount,sal_Bool bRecord,sal_Bool bApi)4178cdf0e10cSrcweir sal_Bool ScDocFunc::FillAuto( ScRange& rRange, const ScMarkData* pTabMark,
4179cdf0e10cSrcweir FillDir eDir, sal_uLong nCount, sal_Bool bRecord, sal_Bool bApi )
4180cdf0e10cSrcweir {
4181cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
4182cdf0e10cSrcweir
4183cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4184cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
4185cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
4186cdf0e10cSrcweir SCTAB nStartTab = rRange.aStart.Tab();
4187cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
4188cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
4189cdf0e10cSrcweir SCTAB nEndTab = rRange.aEnd.Tab();
4190cdf0e10cSrcweir
4191cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
4192cdf0e10cSrcweir bRecord = sal_False;
4193cdf0e10cSrcweir
4194cdf0e10cSrcweir ScMarkData aMark;
4195cdf0e10cSrcweir if (pTabMark)
4196cdf0e10cSrcweir aMark = *pTabMark;
4197cdf0e10cSrcweir else
4198cdf0e10cSrcweir {
4199cdf0e10cSrcweir for (SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4200cdf0e10cSrcweir aMark.SelectTable( nTab, sal_True );
4201cdf0e10cSrcweir }
4202cdf0e10cSrcweir
4203cdf0e10cSrcweir ScRange aSourceArea = rRange;
4204cdf0e10cSrcweir ScRange aDestArea = rRange;
4205cdf0e10cSrcweir
4206cdf0e10cSrcweir FillCmd eCmd = FILL_AUTO;
4207cdf0e10cSrcweir FillDateCmd eDateCmd = FILL_DAY;
4208cdf0e10cSrcweir double fStep = 1.0;
4209cdf0e10cSrcweir double fMax = MAXDOUBLE;
4210cdf0e10cSrcweir
4211cdf0e10cSrcweir switch (eDir)
4212cdf0e10cSrcweir {
4213cdf0e10cSrcweir case FILL_TO_BOTTOM:
4214cdf0e10cSrcweir aDestArea.aEnd.SetRow( sal::static_int_cast<SCROW>( aSourceArea.aEnd.Row() + nCount ) );
4215cdf0e10cSrcweir break;
4216cdf0e10cSrcweir case FILL_TO_TOP:
4217cdf0e10cSrcweir if (nCount > sal::static_int_cast<sal_uLong>( aSourceArea.aStart.Row() ))
4218cdf0e10cSrcweir {
4219cdf0e10cSrcweir DBG_ERROR("FillAuto: Row < 0");
4220cdf0e10cSrcweir nCount = aSourceArea.aStart.Row();
4221cdf0e10cSrcweir }
4222cdf0e10cSrcweir aDestArea.aStart.SetRow( sal::static_int_cast<SCROW>( aSourceArea.aStart.Row() - nCount ) );
4223cdf0e10cSrcweir break;
4224cdf0e10cSrcweir case FILL_TO_RIGHT:
4225cdf0e10cSrcweir aDestArea.aEnd.SetCol( sal::static_int_cast<SCCOL>( aSourceArea.aEnd.Col() + nCount ) );
4226cdf0e10cSrcweir break;
4227cdf0e10cSrcweir case FILL_TO_LEFT:
4228cdf0e10cSrcweir if (nCount > sal::static_int_cast<sal_uLong>( aSourceArea.aStart.Col() ))
4229cdf0e10cSrcweir {
4230cdf0e10cSrcweir DBG_ERROR("FillAuto: Col < 0");
4231cdf0e10cSrcweir nCount = aSourceArea.aStart.Col();
4232cdf0e10cSrcweir }
4233cdf0e10cSrcweir aDestArea.aStart.SetCol( sal::static_int_cast<SCCOL>( aSourceArea.aStart.Col() - nCount ) );
4234cdf0e10cSrcweir break;
4235cdf0e10cSrcweir default:
4236cdf0e10cSrcweir DBG_ERROR("Falsche Richtung bei FillAuto");
4237cdf0e10cSrcweir break;
4238cdf0e10cSrcweir }
4239cdf0e10cSrcweir
4240cdf0e10cSrcweir // Zellschutz testen
4241cdf0e10cSrcweir //! Quellbereich darf geschuetzt sein !!!
4242cdf0e10cSrcweir //! aber kein Matrixfragment enthalten !!!
4243cdf0e10cSrcweir
4244cdf0e10cSrcweir ScEditableTester aTester( pDoc, aDestArea );
4245cdf0e10cSrcweir if ( !aTester.IsEditable() )
4246cdf0e10cSrcweir {
4247cdf0e10cSrcweir if (!bApi)
4248cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
4249cdf0e10cSrcweir return sal_False;
4250cdf0e10cSrcweir }
4251cdf0e10cSrcweir
4252cdf0e10cSrcweir if ( pDoc->HasSelectedBlockMatrixFragment( nStartCol, nStartRow,
4253cdf0e10cSrcweir nEndCol, nEndRow, aMark ) )
4254cdf0e10cSrcweir {
4255cdf0e10cSrcweir if (!bApi)
4256cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MATRIXFRAGMENTERR);
4257cdf0e10cSrcweir return sal_False;
4258cdf0e10cSrcweir }
4259cdf0e10cSrcweir
4260cdf0e10cSrcweir WaitObject aWait( rDocShell.GetActiveDialogParent() );
4261cdf0e10cSrcweir
4262cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
4263cdf0e10cSrcweir if ( bRecord )
4264cdf0e10cSrcweir {
4265cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
4266cdf0e10cSrcweir SCTAB nDestStartTab = aDestArea.aStart.Tab();
4267cdf0e10cSrcweir
4268cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
4269cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nDestStartTab, nDestStartTab );
4270cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
4271cdf0e10cSrcweir if (i != nDestStartTab && aMark.GetTableSelect(i))
4272cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
4273cdf0e10cSrcweir
4274cdf0e10cSrcweir // do not clone note captions in undo document
4275cdf0e10cSrcweir pDoc->CopyToDocument(
4276cdf0e10cSrcweir aDestArea.aStart.Col(), aDestArea.aStart.Row(), 0,
4277cdf0e10cSrcweir aDestArea.aEnd.Col(), aDestArea.aEnd.Row(), nTabCount-1,
4278cdf0e10cSrcweir IDF_AUTOFILL, sal_False, pUndoDoc, &aMark );
4279cdf0e10cSrcweir }
4280cdf0e10cSrcweir
4281cdf0e10cSrcweir pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
4282cdf0e10cSrcweir aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
4283cdf0e10cSrcweir nCount, eDir, eCmd, eDateCmd, fStep, fMax );
4284cdf0e10cSrcweir
4285cdf0e10cSrcweir AdjustRowHeight(aDestArea);
4286cdf0e10cSrcweir
4287cdf0e10cSrcweir if ( bRecord ) // Draw-Undo erst jetzt verfuegbar
4288cdf0e10cSrcweir {
4289cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4290cdf0e10cSrcweir new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
4291cdf0e10cSrcweir eDir, eCmd, eDateCmd, MAXDOUBLE, fStep, fMax,
4292cdf0e10cSrcweir pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
4293cdf0e10cSrcweir }
4294cdf0e10cSrcweir
4295cdf0e10cSrcweir rDocShell.PostPaintGridAll();
4296cdf0e10cSrcweir // rDocShell.PostPaintDataChanged();
4297cdf0e10cSrcweir aModificator.SetDocumentModified();
4298cdf0e10cSrcweir
4299cdf0e10cSrcweir rRange = aDestArea; // Zielbereich zurueckgeben (zum Markieren)
4300cdf0e10cSrcweir return sal_True;
4301cdf0e10cSrcweir }
4302cdf0e10cSrcweir
4303cdf0e10cSrcweir //------------------------------------------------------------------------
4304cdf0e10cSrcweir
MergeCells(const ScRange & rRange,sal_Bool bContents,sal_Bool bRecord,sal_Bool bApi)4305cdf0e10cSrcweir sal_Bool ScDocFunc::MergeCells( const ScRange& rRange, sal_Bool bContents, sal_Bool bRecord, sal_Bool bApi )
4306cdf0e10cSrcweir {
4307cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
4308cdf0e10cSrcweir
4309cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4310cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
4311cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
4312cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
4313cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
4314cdf0e10cSrcweir SCTAB nTab = rRange.aStart.Tab();
4315cdf0e10cSrcweir
4316cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
4317cdf0e10cSrcweir bRecord = sal_False;
4318cdf0e10cSrcweir
4319cdf0e10cSrcweir ScEditableTester aTester( pDoc, nTab, nStartCol, nStartRow, nEndCol, nEndRow );
4320cdf0e10cSrcweir if (!aTester.IsEditable())
4321cdf0e10cSrcweir {
4322cdf0e10cSrcweir if (!bApi)
4323cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
4324cdf0e10cSrcweir return sal_False;
4325cdf0e10cSrcweir }
4326cdf0e10cSrcweir
4327cdf0e10cSrcweir if ( nStartCol == nEndCol && nStartRow == nEndRow )
4328cdf0e10cSrcweir {
4329cdf0e10cSrcweir // nichts zu tun
4330cdf0e10cSrcweir return sal_True;
4331cdf0e10cSrcweir }
4332cdf0e10cSrcweir
4333cdf0e10cSrcweir if ( pDoc->HasAttrib( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab,
4334cdf0e10cSrcweir HASATTR_MERGED | HASATTR_OVERLAPPED ) )
4335cdf0e10cSrcweir {
4336cdf0e10cSrcweir // "Zusammenfassen nicht verschachteln !"
4337cdf0e10cSrcweir if (!bApi)
4338cdf0e10cSrcweir rDocShell.ErrorMessage(STR_MSSG_MERGECELLS_0);
4339cdf0e10cSrcweir return sal_False;
4340cdf0e10cSrcweir }
4341cdf0e10cSrcweir
4342cdf0e10cSrcweir sal_Bool bNeedContents = bContents &&
4343cdf0e10cSrcweir ( !pDoc->IsBlockEmpty( nTab, nStartCol,nStartRow+1, nStartCol,nEndRow, true ) ||
4344cdf0e10cSrcweir !pDoc->IsBlockEmpty( nTab, nStartCol+1,nStartRow, nEndCol,nEndRow, true ) );
4345cdf0e10cSrcweir
4346cdf0e10cSrcweir ScDocument* pUndoDoc = 0;
4347cdf0e10cSrcweir if (bRecord)
4348cdf0e10cSrcweir {
4349cdf0e10cSrcweir // test if the range contains other notes which also implies that we need an undo document
4350cdf0e10cSrcweir bool bHasNotes = false;
4351cdf0e10cSrcweir for( ScAddress aPos( nStartCol, nStartRow, nTab ); !bHasNotes && (aPos.Col() <= nEndCol); aPos.IncCol() )
4352cdf0e10cSrcweir for( aPos.SetRow( nStartRow ); !bHasNotes && (aPos.Row() <= nEndRow); aPos.IncRow() )
4353cdf0e10cSrcweir bHasNotes = ((aPos.Col() != nStartCol) || (aPos.Row() != nStartRow)) && (pDoc->GetNote( aPos ) != 0);
4354cdf0e10cSrcweir
4355cdf0e10cSrcweir if (bNeedContents || bHasNotes)
4356cdf0e10cSrcweir {
4357cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
4358cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab );
4359cdf0e10cSrcweir // note captions are collected by drawing undo
4360cdf0e10cSrcweir pDoc->CopyToDocument( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab,
4361cdf0e10cSrcweir IDF_ALL|IDF_NOCAPTIONS, sal_False, pUndoDoc );
4362cdf0e10cSrcweir }
4363cdf0e10cSrcweir if( bHasNotes )
4364cdf0e10cSrcweir pDoc->BeginDrawUndo();
4365cdf0e10cSrcweir }
4366cdf0e10cSrcweir
4367cdf0e10cSrcweir if (bNeedContents)
4368cdf0e10cSrcweir pDoc->DoMergeContents( nTab, nStartCol,nStartRow, nEndCol,nEndRow );
4369cdf0e10cSrcweir pDoc->DoMerge( nTab, nStartCol,nStartRow, nEndCol,nEndRow );
4370cdf0e10cSrcweir
4371cdf0e10cSrcweir if( bRecord )
4372cdf0e10cSrcweir {
4373cdf0e10cSrcweir SdrUndoGroup* pDrawUndo = pDoc->GetDrawLayer() ? pDoc->GetDrawLayer()->GetCalcUndo() : 0;
4374cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4375cdf0e10cSrcweir new ScUndoMerge( &rDocShell,
4376cdf0e10cSrcweir nStartCol, nStartRow, nTab,
4377cdf0e10cSrcweir nEndCol, nEndRow, nTab, bNeedContents, pUndoDoc, pDrawUndo ) );
4378cdf0e10cSrcweir }
4379cdf0e10cSrcweir
4380cdf0e10cSrcweir if ( !AdjustRowHeight( ScRange( 0,nStartRow,nTab, MAXCOL,nEndRow,nTab ) ) )
4381cdf0e10cSrcweir rDocShell.PostPaint( nStartCol, nStartRow, nTab,
4382cdf0e10cSrcweir nEndCol, nEndRow, nTab, PAINT_GRID );
4383cdf0e10cSrcweir if (bNeedContents)
4384cdf0e10cSrcweir pDoc->SetDirty( rRange );
4385cdf0e10cSrcweir aModificator.SetDocumentModified();
4386cdf0e10cSrcweir
4387cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
4388cdf0e10cSrcweir if (pBindings)
4389cdf0e10cSrcweir {
4390cdf0e10cSrcweir pBindings->Invalidate( FID_MERGE_ON );
4391cdf0e10cSrcweir pBindings->Invalidate( FID_MERGE_OFF );
4392cdf0e10cSrcweir pBindings->Invalidate( FID_MERGE_TOGGLE );
4393cdf0e10cSrcweir }
4394cdf0e10cSrcweir
4395cdf0e10cSrcweir return sal_True;
4396cdf0e10cSrcweir }
4397cdf0e10cSrcweir
UnmergeCells(const ScRange & rRange,sal_Bool bRecord,sal_Bool bApi)4398cdf0e10cSrcweir sal_Bool ScDocFunc::UnmergeCells( const ScRange& rRange, sal_Bool bRecord, sal_Bool bApi )
4399cdf0e10cSrcweir {
4400cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
4401cdf0e10cSrcweir
4402cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4403cdf0e10cSrcweir SCTAB nTab = rRange.aStart.Tab();
4404cdf0e10cSrcweir
4405cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
4406cdf0e10cSrcweir bRecord = sal_False;
4407cdf0e10cSrcweir
4408cdf0e10cSrcweir if ( pDoc->HasAttrib( rRange, HASATTR_MERGED ) )
4409cdf0e10cSrcweir {
4410cdf0e10cSrcweir ScRange aExtended = rRange;
4411cdf0e10cSrcweir pDoc->ExtendMerge( aExtended );
4412cdf0e10cSrcweir ScRange aRefresh = aExtended;
4413cdf0e10cSrcweir pDoc->ExtendOverlapped( aRefresh );
4414cdf0e10cSrcweir
4415cdf0e10cSrcweir if (bRecord)
4416cdf0e10cSrcweir {
4417cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
4418cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab );
4419cdf0e10cSrcweir pDoc->CopyToDocument( aExtended, IDF_ATTRIB, sal_False, pUndoDoc );
4420cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4421cdf0e10cSrcweir new ScUndoRemoveMerge( &rDocShell, rRange, pUndoDoc ) );
4422cdf0e10cSrcweir }
4423cdf0e10cSrcweir
4424cdf0e10cSrcweir const SfxPoolItem& rDefAttr = pDoc->GetPool()->GetDefaultItem( ATTR_MERGE );
4425cdf0e10cSrcweir ScPatternAttr aPattern( pDoc->GetPool() );
4426cdf0e10cSrcweir aPattern.GetItemSet().Put( rDefAttr );
4427cdf0e10cSrcweir pDoc->ApplyPatternAreaTab( rRange.aStart.Col(), rRange.aStart.Row(),
4428cdf0e10cSrcweir rRange.aEnd.Col(), rRange.aEnd.Row(), nTab,
4429cdf0e10cSrcweir aPattern );
4430cdf0e10cSrcweir
4431cdf0e10cSrcweir pDoc->RemoveFlagsTab( aExtended.aStart.Col(), aExtended.aStart.Row(),
4432cdf0e10cSrcweir aExtended.aEnd.Col(), aExtended.aEnd.Row(), nTab,
4433cdf0e10cSrcweir SC_MF_HOR | SC_MF_VER );
4434cdf0e10cSrcweir
4435cdf0e10cSrcweir pDoc->ExtendMerge( aRefresh, sal_True, sal_False );
4436cdf0e10cSrcweir
4437cdf0e10cSrcweir if ( !AdjustRowHeight( aExtended ) )
4438cdf0e10cSrcweir rDocShell.PostPaint( aExtended, PAINT_GRID );
4439cdf0e10cSrcweir aModificator.SetDocumentModified();
4440cdf0e10cSrcweir }
4441cdf0e10cSrcweir else if (!bApi)
4442cdf0e10cSrcweir Sound::Beep(); //! sal_False zurueck???
4443cdf0e10cSrcweir
4444cdf0e10cSrcweir return sal_True;
4445cdf0e10cSrcweir }
4446cdf0e10cSrcweir
4447cdf0e10cSrcweir //------------------------------------------------------------------------
4448cdf0e10cSrcweir
ModifyRangeNames(const ScRangeName & rNewRanges,sal_Bool bApi)4449cdf0e10cSrcweir sal_Bool ScDocFunc::ModifyRangeNames( const ScRangeName& rNewRanges, sal_Bool bApi )
4450cdf0e10cSrcweir {
4451cdf0e10cSrcweir return SetNewRangeNames( new ScRangeName( rNewRanges ), bApi );
4452cdf0e10cSrcweir }
4453cdf0e10cSrcweir
SetNewRangeNames(ScRangeName * pNewRanges,sal_Bool)4454cdf0e10cSrcweir sal_Bool ScDocFunc::SetNewRangeNames( ScRangeName* pNewRanges, sal_Bool /* bApi */ ) // takes ownership of pNewRanges
4455cdf0e10cSrcweir {
4456cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
4457cdf0e10cSrcweir
4458cdf0e10cSrcweir DBG_ASSERT( pNewRanges, "pNewRanges is 0" );
4459cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4460cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
4461cdf0e10cSrcweir
4462cdf0e10cSrcweir if (bUndo)
4463cdf0e10cSrcweir {
4464cdf0e10cSrcweir ScRangeName* pOld = pDoc->GetRangeName();
4465cdf0e10cSrcweir ScRangeName* pUndoRanges = new ScRangeName(*pOld);
4466cdf0e10cSrcweir ScRangeName* pRedoRanges = new ScRangeName(*pNewRanges);
4467cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4468cdf0e10cSrcweir new ScUndoRangeNames( &rDocShell, pUndoRanges, pRedoRanges ) );
4469cdf0e10cSrcweir }
4470cdf0e10cSrcweir
4471cdf0e10cSrcweir // #i55926# While loading XML, formula cells only have a single string token,
4472cdf0e10cSrcweir // so CompileNameFormula would never find any name (index) tokens, and would
4473cdf0e10cSrcweir // unnecessarily loop through all cells.
4474cdf0e10cSrcweir sal_Bool bCompile = ( !pDoc->IsImportingXML() && pDoc->GetNamedRangesLockCount() == 0 );
4475cdf0e10cSrcweir
4476cdf0e10cSrcweir if ( bCompile )
4477cdf0e10cSrcweir pDoc->CompileNameFormula( sal_True ); // CreateFormulaString
4478cdf0e10cSrcweir pDoc->SetRangeName( pNewRanges ); // takes ownership
4479cdf0e10cSrcweir if ( bCompile )
4480cdf0e10cSrcweir pDoc->CompileNameFormula( sal_False ); // CompileFormulaString
4481cdf0e10cSrcweir
4482cdf0e10cSrcweir aModificator.SetDocumentModified();
4483cdf0e10cSrcweir
4484cdf0e10cSrcweir // #i114072# don't broadcast while loading a file
4485cdf0e10cSrcweir // (navigator and input line for other open documents would be notified)
4486cdf0e10cSrcweir if ( bCompile )
4487cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) );
4488cdf0e10cSrcweir
4489cdf0e10cSrcweir return sal_True;
4490cdf0e10cSrcweir }
4491cdf0e10cSrcweir
4492cdf0e10cSrcweir //------------------------------------------------------------------------
4493cdf0e10cSrcweir
CreateOneName(ScRangeName & rList,SCCOL nPosX,SCROW nPosY,SCTAB nTab,SCCOL nX1,SCROW nY1,SCCOL nX2,SCROW nY2,sal_Bool & rCancel,sal_Bool bApi)4494cdf0e10cSrcweir void ScDocFunc::CreateOneName( ScRangeName& rList,
4495cdf0e10cSrcweir SCCOL nPosX, SCROW nPosY, SCTAB nTab,
4496cdf0e10cSrcweir SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2,
4497cdf0e10cSrcweir sal_Bool& rCancel, sal_Bool bApi )
4498cdf0e10cSrcweir {
4499cdf0e10cSrcweir if (rCancel)
4500cdf0e10cSrcweir return;
4501cdf0e10cSrcweir
4502cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4503cdf0e10cSrcweir if (!pDoc->HasValueData( nPosX, nPosY, nTab ))
4504cdf0e10cSrcweir {
4505cdf0e10cSrcweir String aName;
4506cdf0e10cSrcweir pDoc->GetString( nPosX, nPosY, nTab, aName );
4507cdf0e10cSrcweir ScRangeData::MakeValidName(aName);
4508cdf0e10cSrcweir if (aName.Len())
4509cdf0e10cSrcweir {
4510cdf0e10cSrcweir String aContent;
4511cdf0e10cSrcweir ScRange( nX1, nY1, nTab, nX2, nY2, nTab ).Format( aContent, SCR_ABS_3D, pDoc );
4512cdf0e10cSrcweir
4513cdf0e10cSrcweir sal_Bool bInsert = sal_False;
4514cdf0e10cSrcweir sal_uInt16 nOldPos;
4515cdf0e10cSrcweir if (rList.SearchName( aName, nOldPos )) // vorhanden ?
4516cdf0e10cSrcweir {
4517cdf0e10cSrcweir ScRangeData* pOld = rList[nOldPos];
4518cdf0e10cSrcweir String aOldStr;
4519cdf0e10cSrcweir pOld->GetSymbol( aOldStr );
4520cdf0e10cSrcweir if (aOldStr != aContent)
4521cdf0e10cSrcweir {
4522cdf0e10cSrcweir if (bApi)
4523cdf0e10cSrcweir bInsert = sal_True; // per API nicht nachfragen
4524cdf0e10cSrcweir else
4525cdf0e10cSrcweir {
4526cdf0e10cSrcweir String aTemplate = ScGlobal::GetRscString( STR_CREATENAME_REPLACE );
4527cdf0e10cSrcweir
4528cdf0e10cSrcweir String aMessage = aTemplate.GetToken( 0, '#' );
4529cdf0e10cSrcweir aMessage += aName;
4530cdf0e10cSrcweir aMessage += aTemplate.GetToken( 1, '#' );
4531cdf0e10cSrcweir
4532cdf0e10cSrcweir short nResult = QueryBox( rDocShell.GetActiveDialogParent(),
4533cdf0e10cSrcweir WinBits(WB_YES_NO_CANCEL | WB_DEF_YES),
4534cdf0e10cSrcweir aMessage ).Execute();
4535cdf0e10cSrcweir if ( nResult == RET_YES )
4536cdf0e10cSrcweir {
4537cdf0e10cSrcweir rList.AtFree(nOldPos);
4538cdf0e10cSrcweir bInsert = sal_True;
4539cdf0e10cSrcweir }
4540cdf0e10cSrcweir else if ( nResult == RET_CANCEL )
4541cdf0e10cSrcweir rCancel = sal_True;
4542cdf0e10cSrcweir }
4543cdf0e10cSrcweir }
4544cdf0e10cSrcweir }
4545cdf0e10cSrcweir else
4546cdf0e10cSrcweir bInsert = sal_True;
4547cdf0e10cSrcweir
4548cdf0e10cSrcweir if (bInsert)
4549cdf0e10cSrcweir {
4550cdf0e10cSrcweir ScRangeData* pData = new ScRangeData( pDoc, aName, aContent,
4551cdf0e10cSrcweir ScAddress( nPosX, nPosY, nTab));
4552cdf0e10cSrcweir if (!rList.Insert(pData))
4553cdf0e10cSrcweir {
4554cdf0e10cSrcweir DBG_ERROR("nanu?");
4555cdf0e10cSrcweir delete pData;
4556cdf0e10cSrcweir }
4557cdf0e10cSrcweir }
4558cdf0e10cSrcweir }
4559cdf0e10cSrcweir }
4560cdf0e10cSrcweir }
4561cdf0e10cSrcweir
CreateNames(const ScRange & rRange,sal_uInt16 nFlags,sal_Bool bApi)4562cdf0e10cSrcweir sal_Bool ScDocFunc::CreateNames( const ScRange& rRange, sal_uInt16 nFlags, sal_Bool bApi )
4563cdf0e10cSrcweir {
4564cdf0e10cSrcweir if (!nFlags)
4565cdf0e10cSrcweir return sal_False; // war nix
4566cdf0e10cSrcweir
4567cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
4568cdf0e10cSrcweir
4569cdf0e10cSrcweir sal_Bool bDone = sal_False;
4570cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
4571cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
4572cdf0e10cSrcweir SCCOL nEndCol = rRange.aEnd.Col();
4573cdf0e10cSrcweir SCROW nEndRow = rRange.aEnd.Row();
4574cdf0e10cSrcweir SCTAB nTab = rRange.aStart.Tab();
4575cdf0e10cSrcweir DBG_ASSERT(rRange.aEnd.Tab() == nTab, "CreateNames: mehrere Tabellen geht nicht");
4576cdf0e10cSrcweir
4577cdf0e10cSrcweir sal_Bool bValid = sal_True;
4578cdf0e10cSrcweir if ( nFlags & ( NAME_TOP | NAME_BOTTOM ) )
4579cdf0e10cSrcweir if ( nStartRow == nEndRow )
4580cdf0e10cSrcweir bValid = sal_False;
4581cdf0e10cSrcweir if ( nFlags & ( NAME_LEFT | NAME_RIGHT ) )
4582cdf0e10cSrcweir if ( nStartCol == nEndCol )
4583cdf0e10cSrcweir bValid = sal_False;
4584cdf0e10cSrcweir
4585cdf0e10cSrcweir if (bValid)
4586cdf0e10cSrcweir {
4587cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4588cdf0e10cSrcweir ScRangeName* pNames = pDoc->GetRangeName();
4589cdf0e10cSrcweir if (!pNames)
4590cdf0e10cSrcweir return sal_False; // soll nicht sein
4591cdf0e10cSrcweir ScRangeName aNewRanges( *pNames );
4592cdf0e10cSrcweir
4593cdf0e10cSrcweir sal_Bool bTop = ( ( nFlags & NAME_TOP ) != 0 );
4594cdf0e10cSrcweir sal_Bool bLeft = ( ( nFlags & NAME_LEFT ) != 0 );
4595cdf0e10cSrcweir sal_Bool bBottom = ( ( nFlags & NAME_BOTTOM ) != 0 );
4596cdf0e10cSrcweir sal_Bool bRight = ( ( nFlags & NAME_RIGHT ) != 0 );
4597cdf0e10cSrcweir
4598cdf0e10cSrcweir SCCOL nContX1 = nStartCol;
4599cdf0e10cSrcweir SCROW nContY1 = nStartRow;
4600cdf0e10cSrcweir SCCOL nContX2 = nEndCol;
4601cdf0e10cSrcweir SCROW nContY2 = nEndRow;
4602cdf0e10cSrcweir
4603cdf0e10cSrcweir if ( bTop )
4604cdf0e10cSrcweir ++nContY1;
4605cdf0e10cSrcweir if ( bLeft )
4606cdf0e10cSrcweir ++nContX1;
4607cdf0e10cSrcweir if ( bBottom )
4608cdf0e10cSrcweir --nContY2;
4609cdf0e10cSrcweir if ( bRight )
4610cdf0e10cSrcweir --nContX2;
4611cdf0e10cSrcweir
4612cdf0e10cSrcweir sal_Bool bCancel = sal_False;
4613cdf0e10cSrcweir SCCOL i;
4614cdf0e10cSrcweir SCROW j;
4615cdf0e10cSrcweir
4616cdf0e10cSrcweir if ( bTop )
4617cdf0e10cSrcweir for (i=nContX1; i<=nContX2; i++)
4618cdf0e10cSrcweir CreateOneName( aNewRanges, i,nStartRow,nTab, i,nContY1,i,nContY2, bCancel, bApi );
4619cdf0e10cSrcweir if ( bLeft )
4620cdf0e10cSrcweir for (j=nContY1; j<=nContY2; j++)
4621cdf0e10cSrcweir CreateOneName( aNewRanges, nStartCol,j,nTab, nContX1,j,nContX2,j, bCancel, bApi );
4622cdf0e10cSrcweir if ( bBottom )
4623cdf0e10cSrcweir for (i=nContX1; i<=nContX2; i++)
4624cdf0e10cSrcweir CreateOneName( aNewRanges, i,nEndRow,nTab, i,nContY1,i,nContY2, bCancel, bApi );
4625cdf0e10cSrcweir if ( bRight )
4626cdf0e10cSrcweir for (j=nContY1; j<=nContY2; j++)
4627cdf0e10cSrcweir CreateOneName( aNewRanges, nEndCol,j,nTab, nContX1,j,nContX2,j, bCancel, bApi );
4628cdf0e10cSrcweir
4629cdf0e10cSrcweir if ( bTop && bLeft )
4630cdf0e10cSrcweir CreateOneName( aNewRanges, nStartCol,nStartRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
4631cdf0e10cSrcweir if ( bTop && bRight )
4632cdf0e10cSrcweir CreateOneName( aNewRanges, nEndCol,nStartRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
4633cdf0e10cSrcweir if ( bBottom && bLeft )
4634cdf0e10cSrcweir CreateOneName( aNewRanges, nStartCol,nEndRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
4635cdf0e10cSrcweir if ( bBottom && bRight )
4636cdf0e10cSrcweir CreateOneName( aNewRanges, nEndCol,nEndRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
4637cdf0e10cSrcweir
4638cdf0e10cSrcweir bDone = ModifyRangeNames( aNewRanges, bApi );
4639cdf0e10cSrcweir
4640cdf0e10cSrcweir aModificator.SetDocumentModified();
4641cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) );
4642cdf0e10cSrcweir }
4643cdf0e10cSrcweir
4644cdf0e10cSrcweir return bDone;
4645cdf0e10cSrcweir }
4646cdf0e10cSrcweir
4647cdf0e10cSrcweir //------------------------------------------------------------------------
4648cdf0e10cSrcweir
InsertNameList(const ScAddress & rStartPos,sal_Bool bApi)4649cdf0e10cSrcweir sal_Bool ScDocFunc::InsertNameList( const ScAddress& rStartPos, sal_Bool bApi )
4650cdf0e10cSrcweir {
4651cdf0e10cSrcweir ScDocShellModificator aModificator( rDocShell );
4652cdf0e10cSrcweir
4653cdf0e10cSrcweir
4654cdf0e10cSrcweir sal_Bool bDone = sal_False;
4655cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4656cdf0e10cSrcweir const sal_Bool bRecord = pDoc->IsUndoEnabled();
4657cdf0e10cSrcweir SCTAB nTab = rStartPos.Tab();
4658cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
4659cdf0e10cSrcweir
4660cdf0e10cSrcweir ScRangeName* pList = pDoc->GetRangeName();
4661cdf0e10cSrcweir sal_uInt16 nCount = pList->GetCount();
4662cdf0e10cSrcweir sal_uInt16 nValidCount = 0;
4663cdf0e10cSrcweir sal_uInt16 i;
4664cdf0e10cSrcweir for (i=0; i<nCount; i++)
4665cdf0e10cSrcweir {
4666cdf0e10cSrcweir ScRangeData* pData = (*pList)[i];
4667cdf0e10cSrcweir if ( !pData->HasType( RT_DATABASE ) && !pData->HasType( RT_SHARED ) )
4668cdf0e10cSrcweir ++nValidCount;
4669cdf0e10cSrcweir }
4670cdf0e10cSrcweir
4671cdf0e10cSrcweir if (nValidCount)
4672cdf0e10cSrcweir {
4673cdf0e10cSrcweir SCCOL nStartCol = rStartPos.Col();
4674cdf0e10cSrcweir SCROW nStartRow = rStartPos.Row();
4675cdf0e10cSrcweir SCCOL nEndCol = nStartCol + 1;
4676cdf0e10cSrcweir SCROW nEndRow = nStartRow + static_cast<SCROW>(nValidCount) - 1;
4677cdf0e10cSrcweir
4678cdf0e10cSrcweir ScEditableTester aTester( pDoc, nTab, nStartCol,nStartRow, nEndCol,nEndRow );
4679cdf0e10cSrcweir if (aTester.IsEditable())
4680cdf0e10cSrcweir {
4681cdf0e10cSrcweir if (bRecord)
4682cdf0e10cSrcweir {
4683cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
4684cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab );
4685cdf0e10cSrcweir pDoc->CopyToDocument( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab,
4686cdf0e10cSrcweir IDF_ALL, sal_False, pUndoDoc );
4687cdf0e10cSrcweir
4688cdf0e10cSrcweir pDoc->BeginDrawUndo(); // wegen Hoehenanpassung
4689cdf0e10cSrcweir }
4690cdf0e10cSrcweir
4691cdf0e10cSrcweir ScRangeData** ppSortArray = new ScRangeData* [ nValidCount ];
4692cdf0e10cSrcweir sal_uInt16 j = 0;
4693cdf0e10cSrcweir for (i=0; i<nCount; i++)
4694cdf0e10cSrcweir {
4695cdf0e10cSrcweir ScRangeData* pData = (*pList)[i];
4696cdf0e10cSrcweir if ( !pData->HasType( RT_DATABASE ) && !pData->HasType( RT_SHARED ) )
4697cdf0e10cSrcweir ppSortArray[j++] = pData;
4698cdf0e10cSrcweir }
4699cdf0e10cSrcweir #ifndef ICC
4700cdf0e10cSrcweir qsort( (void*)ppSortArray, nValidCount, sizeof(ScRangeData*),
4701cdf0e10cSrcweir &ScRangeData_QsortNameCompare );
4702cdf0e10cSrcweir #else
4703cdf0e10cSrcweir qsort( (void*)ppSortArray, nValidCount, sizeof(ScRangeData*),
4704cdf0e10cSrcweir ICCQsortNameCompare );
4705cdf0e10cSrcweir #endif
4706cdf0e10cSrcweir String aName;
4707cdf0e10cSrcweir rtl::OUStringBuffer aContent;
4708cdf0e10cSrcweir String aFormula;
4709cdf0e10cSrcweir SCROW nOutRow = nStartRow;
4710cdf0e10cSrcweir for (j=0; j<nValidCount; j++)
4711cdf0e10cSrcweir {
4712cdf0e10cSrcweir ScRangeData* pData = ppSortArray[j];
4713cdf0e10cSrcweir pData->GetName(aName);
4714cdf0e10cSrcweir // relative Referenzen Excel-konform auf die linke Spalte anpassen:
4715cdf0e10cSrcweir pData->UpdateSymbol(aContent, ScAddress( nStartCol, nOutRow, nTab ));
4716cdf0e10cSrcweir aFormula = '=';
4717cdf0e10cSrcweir aFormula += aContent;
4718cdf0e10cSrcweir pDoc->PutCell( nStartCol,nOutRow,nTab, new ScStringCell( aName ) );
4719cdf0e10cSrcweir pDoc->PutCell( nEndCol ,nOutRow,nTab, new ScStringCell( aFormula ) );
4720cdf0e10cSrcweir ++nOutRow;
4721cdf0e10cSrcweir }
4722cdf0e10cSrcweir
4723cdf0e10cSrcweir delete [] ppSortArray;
4724cdf0e10cSrcweir
4725cdf0e10cSrcweir if (bRecord)
4726cdf0e10cSrcweir {
4727cdf0e10cSrcweir ScDocument* pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
4728cdf0e10cSrcweir pRedoDoc->InitUndo( pDoc, nTab, nTab );
4729cdf0e10cSrcweir pDoc->CopyToDocument( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab,
4730cdf0e10cSrcweir IDF_ALL, sal_False, pRedoDoc );
4731cdf0e10cSrcweir
4732cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4733cdf0e10cSrcweir new ScUndoListNames( &rDocShell,
4734cdf0e10cSrcweir ScRange( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab ),
4735cdf0e10cSrcweir pUndoDoc, pRedoDoc ) );
4736cdf0e10cSrcweir }
4737cdf0e10cSrcweir
4738cdf0e10cSrcweir if (!AdjustRowHeight(ScRange(0,nStartRow,nTab,MAXCOL,nEndRow,nTab)))
4739cdf0e10cSrcweir rDocShell.PostPaint( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab, PAINT_GRID );
4740cdf0e10cSrcweir //! rDocShell.UpdateOle(GetViewData());
4741cdf0e10cSrcweir aModificator.SetDocumentModified();
4742cdf0e10cSrcweir bDone = sal_True;
4743cdf0e10cSrcweir }
4744cdf0e10cSrcweir else if (!bApi)
4745cdf0e10cSrcweir rDocShell.ErrorMessage(aTester.GetMessageId());
4746cdf0e10cSrcweir }
4747cdf0e10cSrcweir return bDone;
4748cdf0e10cSrcweir }
4749cdf0e10cSrcweir
4750cdf0e10cSrcweir //------------------------------------------------------------------------
4751cdf0e10cSrcweir
ResizeMatrix(const ScRange & rOldRange,const ScAddress & rNewEnd,sal_Bool bApi)4752cdf0e10cSrcweir sal_Bool ScDocFunc::ResizeMatrix( const ScRange& rOldRange, const ScAddress& rNewEnd, sal_Bool bApi )
4753cdf0e10cSrcweir {
4754cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4755cdf0e10cSrcweir SCCOL nStartCol = rOldRange.aStart.Col();
4756cdf0e10cSrcweir SCROW nStartRow = rOldRange.aStart.Row();
4757cdf0e10cSrcweir SCTAB nTab = rOldRange.aStart.Tab();
4758cdf0e10cSrcweir
4759cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
4760cdf0e10cSrcweir
4761cdf0e10cSrcweir sal_Bool bRet = sal_False;
4762cdf0e10cSrcweir
4763cdf0e10cSrcweir String aFormula;
4764cdf0e10cSrcweir pDoc->GetFormula( nStartCol, nStartRow, nTab, aFormula );
4765cdf0e10cSrcweir if ( aFormula.GetChar(0) == '{' && aFormula.GetChar(aFormula.Len()-1) == '}' )
4766cdf0e10cSrcweir {
4767cdf0e10cSrcweir String aUndo = ScGlobal::GetRscString( STR_UNDO_RESIZEMATRIX );
4768cdf0e10cSrcweir if (bUndo)
4769cdf0e10cSrcweir rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo );
4770cdf0e10cSrcweir
4771cdf0e10cSrcweir aFormula.Erase(0,1);
4772cdf0e10cSrcweir aFormula.Erase(aFormula.Len()-1,1);
4773cdf0e10cSrcweir
4774cdf0e10cSrcweir ScMarkData aMark;
4775cdf0e10cSrcweir aMark.SetMarkArea( rOldRange );
4776cdf0e10cSrcweir aMark.SelectTable( nTab, sal_True );
4777cdf0e10cSrcweir ScRange aNewRange( rOldRange.aStart, rNewEnd );
4778cdf0e10cSrcweir
4779cdf0e10cSrcweir if ( DeleteContents( aMark, IDF_CONTENTS, sal_True, bApi ) )
4780cdf0e10cSrcweir {
4781cdf0e10cSrcweir // GRAM_PODF_A1 for API compatibility.
4782cdf0e10cSrcweir bRet = EnterMatrix( aNewRange, &aMark, NULL, aFormula, bApi, sal_False, EMPTY_STRING, formula::FormulaGrammar::GRAM_PODF_A1 );
4783cdf0e10cSrcweir if (!bRet)
4784cdf0e10cSrcweir {
4785cdf0e10cSrcweir // versuchen, alten Zustand wiederherzustellen
4786cdf0e10cSrcweir EnterMatrix( rOldRange, &aMark, NULL, aFormula, bApi, sal_False, EMPTY_STRING, formula::FormulaGrammar::GRAM_PODF_A1 );
4787cdf0e10cSrcweir }
4788cdf0e10cSrcweir }
4789cdf0e10cSrcweir
4790cdf0e10cSrcweir if (bUndo)
4791cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction();
4792cdf0e10cSrcweir }
4793cdf0e10cSrcweir
4794cdf0e10cSrcweir return bRet;
4795cdf0e10cSrcweir }
4796cdf0e10cSrcweir
4797cdf0e10cSrcweir //------------------------------------------------------------------------
4798cdf0e10cSrcweir
InsertAreaLink(const String & rFile,const String & rFilter,const String & rOptions,const String & rSource,const ScRange & rDestRange,sal_uLong nRefresh,sal_Bool bFitBlock,sal_Bool bApi)4799cdf0e10cSrcweir sal_Bool ScDocFunc::InsertAreaLink( const String& rFile, const String& rFilter,
4800cdf0e10cSrcweir const String& rOptions, const String& rSource,
4801cdf0e10cSrcweir const ScRange& rDestRange, sal_uLong nRefresh,
4802cdf0e10cSrcweir sal_Bool bFitBlock, sal_Bool bApi )
4803cdf0e10cSrcweir {
4804cdf0e10cSrcweir //! auch fuer ScViewFunc::InsertAreaLink benutzen!
4805cdf0e10cSrcweir
4806cdf0e10cSrcweir ScDocument* pDoc = rDocShell.GetDocument();
4807cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
4808cdf0e10cSrcweir
4809cdf0e10cSrcweir sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();
4810cdf0e10cSrcweir
4811cdf0e10cSrcweir // #i52120# if other area links exist at the same start position,
4812cdf0e10cSrcweir // remove them first (file format specifies only one link definition
4813cdf0e10cSrcweir // for a cell)
4814cdf0e10cSrcweir
4815cdf0e10cSrcweir sal_uInt16 nLinkCount = pLinkManager->GetLinks().Count();
4816cdf0e10cSrcweir sal_uInt16 nRemoved = 0;
4817cdf0e10cSrcweir sal_uInt16 nLinkPos = 0;
4818cdf0e10cSrcweir while (nLinkPos<nLinkCount)
4819cdf0e10cSrcweir {
4820cdf0e10cSrcweir ::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[nLinkPos];
4821cdf0e10cSrcweir if ( pBase->ISA(ScAreaLink) &&
4822cdf0e10cSrcweir static_cast<ScAreaLink*>(pBase)->GetDestArea().aStart == rDestRange.aStart )
4823cdf0e10cSrcweir {
4824cdf0e10cSrcweir if ( bUndo )
4825cdf0e10cSrcweir {
4826cdf0e10cSrcweir if ( !nRemoved )
4827cdf0e10cSrcweir {
4828cdf0e10cSrcweir // group all remove and the insert action
4829cdf0e10cSrcweir String aUndo = ScGlobal::GetRscString( STR_UNDO_INSERTAREALINK );
4830cdf0e10cSrcweir rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo );
4831cdf0e10cSrcweir }
4832cdf0e10cSrcweir
4833cdf0e10cSrcweir ScAreaLink* pOldArea = static_cast<ScAreaLink*>(pBase);
4834cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction(
4835cdf0e10cSrcweir new ScUndoRemoveAreaLink( &rDocShell,
4836cdf0e10cSrcweir pOldArea->GetFile(), pOldArea->GetFilter(), pOldArea->GetOptions(),
4837cdf0e10cSrcweir pOldArea->GetSource(), pOldArea->GetDestArea(), pOldArea->GetRefreshDelay() ) );
4838cdf0e10cSrcweir }
4839cdf0e10cSrcweir pLinkManager->Remove( pBase );
4840cdf0e10cSrcweir nLinkCount = pLinkManager->GetLinks().Count();
4841cdf0e10cSrcweir ++nRemoved;
4842cdf0e10cSrcweir }
4843cdf0e10cSrcweir else
4844cdf0e10cSrcweir ++nLinkPos;
4845cdf0e10cSrcweir }
4846cdf0e10cSrcweir
4847cdf0e10cSrcweir String aFilterName = rFilter;
4848cdf0e10cSrcweir String aNewOptions = rOptions;
4849cdf0e10cSrcweir if (!aFilterName.Len())
4850cdf0e10cSrcweir ScDocumentLoader::GetFilterName( rFile, aFilterName, aNewOptions, sal_True, !bApi );
4851cdf0e10cSrcweir
4852cdf0e10cSrcweir // remove application prefix from filter name here, so the filter options
4853cdf0e10cSrcweir // aren't reset when the filter name is changed in ScAreaLink::DataChanged
4854cdf0e10cSrcweir ScDocumentLoader::RemoveAppPrefix( aFilterName );
4855cdf0e10cSrcweir
4856cdf0e10cSrcweir ScAreaLink* pLink = new ScAreaLink( &rDocShell, rFile, aFilterName,
4857cdf0e10cSrcweir aNewOptions, rSource, rDestRange, nRefresh );
4858cdf0e10cSrcweir pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, rFile, &aFilterName, &rSource );
4859cdf0e10cSrcweir
4860cdf0e10cSrcweir // Undo fuer den leeren Link
4861cdf0e10cSrcweir
4862cdf0e10cSrcweir if (bUndo)
4863cdf0e10cSrcweir {
4864cdf0e10cSrcweir rDocShell.GetUndoManager()->AddUndoAction( new ScUndoInsertAreaLink( &rDocShell,
4865cdf0e10cSrcweir rFile, aFilterName, aNewOptions,
4866cdf0e10cSrcweir rSource, rDestRange, nRefresh ) );
4867cdf0e10cSrcweir if ( nRemoved )
4868cdf0e10cSrcweir rDocShell.GetUndoManager()->LeaveListAction(); // undo for link update is still separate
4869cdf0e10cSrcweir }
4870cdf0e10cSrcweir
4871cdf0e10cSrcweir // Update hat sein eigenes Undo
4872cdf0e10cSrcweir if (pDoc->IsExecuteLinkEnabled())
4873cdf0e10cSrcweir {
4874cdf0e10cSrcweir pLink->SetDoInsert(bFitBlock); // beim ersten Update ggf. nichts einfuegen
4875cdf0e10cSrcweir pLink->Update(); // kein SetInCreate -> Update ausfuehren
4876cdf0e10cSrcweir }
4877cdf0e10cSrcweir pLink->SetDoInsert(sal_True); // Default = sal_True
4878cdf0e10cSrcweir
4879cdf0e10cSrcweir SfxBindings* pBindings = rDocShell.GetViewBindings();
4880cdf0e10cSrcweir if (pBindings)
4881cdf0e10cSrcweir pBindings->Invalidate( SID_LINKS );
4882cdf0e10cSrcweir
4883cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) ); // Navigator
4884cdf0e10cSrcweir
4885cdf0e10cSrcweir return sal_True;
4886cdf0e10cSrcweir }
4887cdf0e10cSrcweir
4888cdf0e10cSrcweir
4889cdf0e10cSrcweir
4890cdf0e10cSrcweir
4891