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 // INCLUDE ---------------------------------------------------------------
28cdf0e10cSrcweir
29cdf0e10cSrcweir #include "scitems.hxx"
30cdf0e10cSrcweir #include <editeng/eeitem.hxx>
31cdf0e10cSrcweir
32cdf0e10cSrcweir #include <sfx2/app.hxx>
33cdf0e10cSrcweir #define _SVSTDARR_STRINGS
34cdf0e10cSrcweir #include <editeng/boxitem.hxx>
35cdf0e10cSrcweir #include <editeng/fontitem.hxx>
36cdf0e10cSrcweir #include <editeng/scripttypeitem.hxx>
37cdf0e10cSrcweir #include <svl/srchitem.hxx>
38cdf0e10cSrcweir #include <sfx2/linkmgr.hxx>
39cdf0e10cSrcweir #include <sfx2/dispatch.hxx>
40cdf0e10cSrcweir #include <sfx2/docfilt.hxx>
41cdf0e10cSrcweir #include <sfx2/docfile.hxx>
42cdf0e10cSrcweir #include <sfx2/objitem.hxx>
43cdf0e10cSrcweir #include <sfx2/viewfrm.hxx>
44cdf0e10cSrcweir #include <svl/stritem.hxx>
45cdf0e10cSrcweir #include <svl/zforlist.hxx>
46cdf0e10cSrcweir #include <svl/svstdarr.hxx>
47cdf0e10cSrcweir #include <vcl/msgbox.hxx>
48cdf0e10cSrcweir #include <vcl/sound.hxx>
49cdf0e10cSrcweir #include <vcl/waitobj.hxx>
50cdf0e10cSrcweir
51cdf0e10cSrcweir #include "viewfunc.hxx"
52cdf0e10cSrcweir
53cdf0e10cSrcweir #include "sc.hrc"
54cdf0e10cSrcweir #include "globstr.hrc"
55cdf0e10cSrcweir
56cdf0e10cSrcweir #include "attrib.hxx"
57cdf0e10cSrcweir #include "autoform.hxx"
58cdf0e10cSrcweir #include "cell.hxx" // EnterAutoSum
59cdf0e10cSrcweir #include "compiler.hxx"
60cdf0e10cSrcweir #include "docfunc.hxx"
61cdf0e10cSrcweir #include "docpool.hxx"
62cdf0e10cSrcweir #include "docsh.hxx"
63cdf0e10cSrcweir #include "global.hxx"
64cdf0e10cSrcweir #include "patattr.hxx"
65cdf0e10cSrcweir #include "printfun.hxx"
66cdf0e10cSrcweir #include "rangenam.hxx"
67cdf0e10cSrcweir #include "rangeutl.hxx"
68cdf0e10cSrcweir #include "refundo.hxx"
69cdf0e10cSrcweir #include "tablink.hxx"
70cdf0e10cSrcweir #include "tabvwsh.hxx"
71cdf0e10cSrcweir #include "uiitems.hxx"
72cdf0e10cSrcweir #include "undoblk.hxx"
73cdf0e10cSrcweir #include "undocell.hxx"
74cdf0e10cSrcweir #include "undotab.hxx"
75cdf0e10cSrcweir #include "sizedev.hxx"
76cdf0e10cSrcweir #include "editable.hxx"
77cdf0e10cSrcweir #include "scmod.hxx"
78cdf0e10cSrcweir #include "inputhdl.hxx"
79cdf0e10cSrcweir #include "inputwin.hxx"
80cdf0e10cSrcweir #include "funcdesc.hxx"
81cdf0e10cSrcweir #include "docuno.hxx"
82cdf0e10cSrcweir #include "charthelper.hxx"
83cdf0e10cSrcweir #include "tabbgcolor.hxx"
84cdf0e10cSrcweir
85cdf0e10cSrcweir #include <basic/sbstar.hxx>
86cdf0e10cSrcweir #include <com/sun/star/container/XNameContainer.hpp>
87cdf0e10cSrcweir #include <com/sun/star/script/XLibraryContainer.hpp>
88cdf0e10cSrcweir using namespace com::sun::star;
89cdf0e10cSrcweir
90cdf0e10cSrcweir // helper func defined in docfunc.cxx
91cdf0e10cSrcweir void VBA_DeleteModule( ScDocShell& rDocSh, String& sModuleName );
92cdf0e10cSrcweir
93cdf0e10cSrcweir // STATIC DATA ---------------------------------------------------------------
94cdf0e10cSrcweir
95cdf0e10cSrcweir
96cdf0e10cSrcweir //----------------------------------------------------------------------------
97cdf0e10cSrcweir
AdjustBlockHeight(sal_Bool bPaint,ScMarkData * pMarkData)98cdf0e10cSrcweir sal_Bool ScViewFunc::AdjustBlockHeight( sal_Bool bPaint, ScMarkData* pMarkData )
99cdf0e10cSrcweir {
100cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
101cdf0e10cSrcweir if (!pMarkData)
102cdf0e10cSrcweir pMarkData = &GetViewData()->GetMarkData();
103cdf0e10cSrcweir
104cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
105cdf0e10cSrcweir SCCOLROW* pRanges = new SCCOLROW[MAXCOLROWCOUNT];
106cdf0e10cSrcweir SCCOLROW nRangeCnt = pMarkData->GetMarkRowRanges( pRanges );
107cdf0e10cSrcweir if (nRangeCnt == 0)
108cdf0e10cSrcweir {
109cdf0e10cSrcweir pRanges[0] = pRanges[1] = GetViewData()->GetCurY();
110cdf0e10cSrcweir nRangeCnt = 1;
111cdf0e10cSrcweir }
112cdf0e10cSrcweir
113cdf0e10cSrcweir double nPPTX = GetViewData()->GetPPTX();
114cdf0e10cSrcweir double nPPTY = GetViewData()->GetPPTY();
115cdf0e10cSrcweir Fraction aZoomX = GetViewData()->GetZoomX();
116cdf0e10cSrcweir Fraction aZoomY = GetViewData()->GetZoomY();
117cdf0e10cSrcweir
118cdf0e10cSrcweir ScSizeDeviceProvider aProv(pDocSh);
119cdf0e10cSrcweir if (aProv.IsPrinter())
120cdf0e10cSrcweir {
121cdf0e10cSrcweir nPPTX = aProv.GetPPTX();
122cdf0e10cSrcweir nPPTY = aProv.GetPPTY();
123cdf0e10cSrcweir aZoomX = aZoomY = Fraction( 1, 1 );
124cdf0e10cSrcweir }
125cdf0e10cSrcweir
126cdf0e10cSrcweir sal_Bool bAnyChanged = sal_False;
127cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
128cdf0e10cSrcweir for (SCTAB nTab=0; nTab<nTabCount; nTab++)
129cdf0e10cSrcweir {
130cdf0e10cSrcweir if (pMarkData->GetTableSelect(nTab))
131cdf0e10cSrcweir {
132cdf0e10cSrcweir SCCOLROW* pOneRange = pRanges;
133cdf0e10cSrcweir sal_Bool bChanged = sal_False;
134cdf0e10cSrcweir SCROW nPaintY = 0;
135cdf0e10cSrcweir for (SCROW nRangeNo=0; nRangeNo<nRangeCnt; nRangeNo++)
136cdf0e10cSrcweir {
137cdf0e10cSrcweir SCROW nStartNo = *(pOneRange++);
138cdf0e10cSrcweir SCROW nEndNo = *(pOneRange++);
139cdf0e10cSrcweir if (pDoc->SetOptimalHeight( nStartNo, nEndNo, nTab, 0, aProv.GetDevice(),
140cdf0e10cSrcweir nPPTX, nPPTY, aZoomX, aZoomY, sal_False ))
141cdf0e10cSrcweir {
142cdf0e10cSrcweir if (!bChanged)
143cdf0e10cSrcweir nPaintY = nStartNo;
144cdf0e10cSrcweir bAnyChanged = bChanged = sal_True;
145cdf0e10cSrcweir }
146cdf0e10cSrcweir }
147cdf0e10cSrcweir if ( bPaint && bChanged )
148cdf0e10cSrcweir pDocSh->PostPaint( 0, nPaintY, nTab, MAXCOL, MAXROW, nTab,
149cdf0e10cSrcweir PAINT_GRID | PAINT_LEFT );
150cdf0e10cSrcweir }
151cdf0e10cSrcweir }
152cdf0e10cSrcweir delete[] pRanges;
153cdf0e10cSrcweir
154cdf0e10cSrcweir if ( bPaint && bAnyChanged )
155cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
156cdf0e10cSrcweir
157cdf0e10cSrcweir return bAnyChanged;
158cdf0e10cSrcweir }
159cdf0e10cSrcweir
160cdf0e10cSrcweir
161cdf0e10cSrcweir //----------------------------------------------------------------------------
162cdf0e10cSrcweir
AdjustRowHeight(SCROW nStartRow,SCROW nEndRow,sal_Bool bPaint)163cdf0e10cSrcweir sal_Bool ScViewFunc::AdjustRowHeight( SCROW nStartRow, SCROW nEndRow, sal_Bool bPaint )
164cdf0e10cSrcweir {
165cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
166cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
167cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
168cdf0e10cSrcweir double nPPTX = GetViewData()->GetPPTX();
169cdf0e10cSrcweir double nPPTY = GetViewData()->GetPPTY();
170cdf0e10cSrcweir Fraction aZoomX = GetViewData()->GetZoomX();
171cdf0e10cSrcweir Fraction aZoomY = GetViewData()->GetZoomY();
172cdf0e10cSrcweir sal_uInt16 nOldPixel = 0;
173cdf0e10cSrcweir if (nStartRow == nEndRow)
174cdf0e10cSrcweir nOldPixel = (sal_uInt16) (pDoc->GetRowHeight(nStartRow,nTab) * nPPTY);
175cdf0e10cSrcweir
176cdf0e10cSrcweir ScSizeDeviceProvider aProv(pDocSh);
177cdf0e10cSrcweir if (aProv.IsPrinter())
178cdf0e10cSrcweir {
179cdf0e10cSrcweir nPPTX = aProv.GetPPTX();
180cdf0e10cSrcweir nPPTY = aProv.GetPPTY();
181cdf0e10cSrcweir aZoomX = aZoomY = Fraction( 1, 1 );
182cdf0e10cSrcweir }
183cdf0e10cSrcweir sal_Bool bChanged = pDoc->SetOptimalHeight( nStartRow, nEndRow, nTab, 0, aProv.GetDevice(),
184cdf0e10cSrcweir nPPTX, nPPTY, aZoomX, aZoomY, sal_False );
185cdf0e10cSrcweir
186cdf0e10cSrcweir if (bChanged && ( nStartRow == nEndRow ))
187cdf0e10cSrcweir {
188cdf0e10cSrcweir sal_uInt16 nNewPixel = (sal_uInt16) (pDoc->GetRowHeight(nStartRow,nTab) * nPPTY);
189cdf0e10cSrcweir if ( nNewPixel == nOldPixel )
190cdf0e10cSrcweir bChanged = sal_False;
191cdf0e10cSrcweir }
192cdf0e10cSrcweir
193cdf0e10cSrcweir if ( bPaint && bChanged )
194cdf0e10cSrcweir pDocSh->PostPaint( 0, nStartRow, nTab, MAXCOL, MAXROW, nTab,
195cdf0e10cSrcweir PAINT_GRID | PAINT_LEFT );
196cdf0e10cSrcweir
197cdf0e10cSrcweir return bChanged;
198cdf0e10cSrcweir }
199cdf0e10cSrcweir
200cdf0e10cSrcweir
201cdf0e10cSrcweir //----------------------------------------------------------------------------
202cdf0e10cSrcweir
203cdf0e10cSrcweir enum ScAutoSum
204cdf0e10cSrcweir {
205cdf0e10cSrcweir ScAutoSumNone = 0,
206cdf0e10cSrcweir ScAutoSumData,
207cdf0e10cSrcweir ScAutoSumSum
208cdf0e10cSrcweir };
209cdf0e10cSrcweir
210cdf0e10cSrcweir
lcl_IsAutoSumData(ScDocument * pDoc,SCCOL nCol,SCROW nRow,SCTAB nTab,ScDirection eDir,SCCOLROW & nExtend)211cdf0e10cSrcweir ScAutoSum lcl_IsAutoSumData( ScDocument* pDoc, SCCOL nCol, SCROW nRow,
212cdf0e10cSrcweir SCTAB nTab, ScDirection eDir, SCCOLROW& nExtend )
213cdf0e10cSrcweir {
214cdf0e10cSrcweir ScBaseCell* pCell;
215cdf0e10cSrcweir pDoc->GetCell( nCol, nRow, nTab, pCell );
216cdf0e10cSrcweir if ( pCell && pCell->HasValueData() )
217cdf0e10cSrcweir {
218cdf0e10cSrcweir if ( pCell->GetCellType() == CELLTYPE_FORMULA )
219cdf0e10cSrcweir {
220cdf0e10cSrcweir ScTokenArray* pCode = ((ScFormulaCell*)pCell)->GetCode();
221cdf0e10cSrcweir if ( pCode && pCode->GetOuterFuncOpCode() == ocSum )
222cdf0e10cSrcweir {
223cdf0e10cSrcweir if ( pCode->GetAdjacentExtendOfOuterFuncRefs( nExtend,
224cdf0e10cSrcweir ScAddress( nCol, nRow, nTab ), eDir ) )
225cdf0e10cSrcweir return ScAutoSumSum;
226cdf0e10cSrcweir }
227cdf0e10cSrcweir }
228cdf0e10cSrcweir return ScAutoSumData;
229cdf0e10cSrcweir }
230cdf0e10cSrcweir return ScAutoSumNone;
231cdf0e10cSrcweir }
232cdf0e10cSrcweir
233cdf0e10cSrcweir
234cdf0e10cSrcweir //----------------------------------------------------------------------------
235cdf0e10cSrcweir
236cdf0e10cSrcweir #define SC_AUTOSUM_MAXCOUNT 20
237cdf0e10cSrcweir
lcl_SeekAutoSumData(ScDocument * pDoc,SCCOL & nCol,SCROW & nRow,SCTAB nTab,ScDirection eDir,SCCOLROW & nExtend)238cdf0e10cSrcweir ScAutoSum lcl_SeekAutoSumData( ScDocument* pDoc, SCCOL& nCol, SCROW& nRow,
239cdf0e10cSrcweir SCTAB nTab, ScDirection eDir, SCCOLROW& nExtend )
240cdf0e10cSrcweir {
241cdf0e10cSrcweir sal_uInt16 nCount = 0;
242cdf0e10cSrcweir while (nCount < SC_AUTOSUM_MAXCOUNT)
243cdf0e10cSrcweir {
244cdf0e10cSrcweir if ( eDir == DIR_TOP )
245cdf0e10cSrcweir {
246cdf0e10cSrcweir if (nRow > 0)
247cdf0e10cSrcweir --nRow;
248cdf0e10cSrcweir else
249cdf0e10cSrcweir return ScAutoSumNone;
250cdf0e10cSrcweir }
251cdf0e10cSrcweir else
252cdf0e10cSrcweir {
253cdf0e10cSrcweir if (nCol > 0)
254cdf0e10cSrcweir --nCol;
255cdf0e10cSrcweir else
256cdf0e10cSrcweir return ScAutoSumNone;
257cdf0e10cSrcweir }
258cdf0e10cSrcweir ScAutoSum eSum;
259cdf0e10cSrcweir if ( (eSum = lcl_IsAutoSumData(
260cdf0e10cSrcweir pDoc, nCol, nRow, nTab, eDir, nExtend )) != ScAutoSumNone )
261cdf0e10cSrcweir return eSum;
262cdf0e10cSrcweir ++nCount;
263cdf0e10cSrcweir }
264cdf0e10cSrcweir return ScAutoSumNone;
265cdf0e10cSrcweir }
266cdf0e10cSrcweir
267cdf0e10cSrcweir #undef SC_AUTOSUM_MAXCOUNT
268cdf0e10cSrcweir
269cdf0e10cSrcweir //----------------------------------------------------------------------------
270cdf0e10cSrcweir
lcl_FindNextSumEntryInColumn(ScDocument * pDoc,SCCOL nCol,SCROW & nRow,SCTAB nTab,SCCOLROW & nExtend,SCROW nMinRow)271cdf0e10cSrcweir bool lcl_FindNextSumEntryInColumn( ScDocument* pDoc, SCCOL nCol, SCROW& nRow,
272cdf0e10cSrcweir SCTAB nTab, SCCOLROW& nExtend, SCROW nMinRow )
273cdf0e10cSrcweir {
274cdf0e10cSrcweir const SCROW nTmp = nRow;
275cdf0e10cSrcweir ScAutoSum eSkip = ScAutoSumNone;
276cdf0e10cSrcweir while ( ( eSkip = lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_TOP, nExtend ) ) == ScAutoSumData &&
277cdf0e10cSrcweir nRow > nMinRow )
278cdf0e10cSrcweir {
279cdf0e10cSrcweir --nRow;
280cdf0e10cSrcweir }
281cdf0e10cSrcweir if ( eSkip == ScAutoSumSum && nRow < nTmp )
282cdf0e10cSrcweir {
283cdf0e10cSrcweir return true;
284cdf0e10cSrcweir }
285cdf0e10cSrcweir return false;
286cdf0e10cSrcweir }
287cdf0e10cSrcweir
288cdf0e10cSrcweir //----------------------------------------------------------------------------
289cdf0e10cSrcweir
lcl_FindNextSumEntryInRow(ScDocument * pDoc,SCCOL & nCol,SCROW nRow,SCTAB nTab,SCCOLROW & nExtend,SCROW nMinCol)290cdf0e10cSrcweir bool lcl_FindNextSumEntryInRow( ScDocument* pDoc, SCCOL& nCol, SCROW nRow,
291cdf0e10cSrcweir SCTAB nTab, SCCOLROW& nExtend, SCROW nMinCol )
292cdf0e10cSrcweir {
293cdf0e10cSrcweir const SCCOL nTmp = nCol;
294cdf0e10cSrcweir ScAutoSum eSkip = ScAutoSumNone;
295cdf0e10cSrcweir while ( ( eSkip = lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_LEFT, nExtend ) ) == ScAutoSumData &&
296cdf0e10cSrcweir nCol > nMinCol )
297cdf0e10cSrcweir {
298cdf0e10cSrcweir --nCol;
299cdf0e10cSrcweir }
300cdf0e10cSrcweir if ( eSkip == ScAutoSumSum && nCol < nTmp )
301cdf0e10cSrcweir {
302cdf0e10cSrcweir return true;
303cdf0e10cSrcweir }
304cdf0e10cSrcweir return false;
305cdf0e10cSrcweir }
306cdf0e10cSrcweir
307cdf0e10cSrcweir //----------------------------------------------------------------------------
308cdf0e10cSrcweir
lcl_GetAutoSumForColumnRange(ScDocument * pDoc,ScRangeList & rRangeList,const ScRange & rRange)309cdf0e10cSrcweir bool lcl_GetAutoSumForColumnRange( ScDocument* pDoc, ScRangeList& rRangeList, const ScRange& rRange )
310cdf0e10cSrcweir {
311cdf0e10cSrcweir const ScAddress aStart = rRange.aStart;
312cdf0e10cSrcweir const ScAddress aEnd = rRange.aEnd;
313cdf0e10cSrcweir if ( aStart.Col() != aEnd.Col() )
314cdf0e10cSrcweir {
315cdf0e10cSrcweir return false;
316cdf0e10cSrcweir }
317cdf0e10cSrcweir
318cdf0e10cSrcweir const SCTAB nTab = aEnd.Tab();
319cdf0e10cSrcweir const SCCOL nCol = aEnd.Col();
320cdf0e10cSrcweir SCROW nEndRow = aEnd.Row();
321cdf0e10cSrcweir SCROW nStartRow = nEndRow;
322cdf0e10cSrcweir SCCOLROW nExtend = 0;
323cdf0e10cSrcweir const ScAutoSum eSum = lcl_IsAutoSumData( pDoc, nCol, nEndRow, nTab, DIR_TOP, nExtend /*out*/ );
324cdf0e10cSrcweir
325cdf0e10cSrcweir if ( eSum == ScAutoSumSum )
326cdf0e10cSrcweir {
327cdf0e10cSrcweir bool bContinue = false;
328cdf0e10cSrcweir do
329cdf0e10cSrcweir {
330cdf0e10cSrcweir rRangeList.Append( ScRange( nCol, nStartRow, nTab, nCol, nEndRow, nTab ) );
331cdf0e10cSrcweir nEndRow = static_cast< SCROW >( nExtend );
332cdf0e10cSrcweir if ( ( bContinue = lcl_FindNextSumEntryInColumn( pDoc, nCol, nEndRow /*inout*/, nTab, nExtend /*out*/, aStart.Row() ) ) == true )
333cdf0e10cSrcweir {
334cdf0e10cSrcweir nStartRow = nEndRow;
335cdf0e10cSrcweir }
336cdf0e10cSrcweir } while ( bContinue );
337cdf0e10cSrcweir }
338cdf0e10cSrcweir else
339cdf0e10cSrcweir {
340cdf0e10cSrcweir while ( nStartRow > aStart.Row() &&
341cdf0e10cSrcweir lcl_IsAutoSumData( pDoc, nCol, nStartRow-1, nTab, DIR_TOP, nExtend /*out*/ ) != ScAutoSumSum )
342cdf0e10cSrcweir {
343cdf0e10cSrcweir --nStartRow;
344cdf0e10cSrcweir }
345cdf0e10cSrcweir rRangeList.Append( ScRange( nCol, nStartRow, nTab, nCol, nEndRow, nTab ) );
346cdf0e10cSrcweir }
347cdf0e10cSrcweir
348cdf0e10cSrcweir return true;
349cdf0e10cSrcweir }
350cdf0e10cSrcweir
351cdf0e10cSrcweir //----------------------------------------------------------------------------
352cdf0e10cSrcweir
lcl_GetAutoSumForRowRange(ScDocument * pDoc,ScRangeList & rRangeList,const ScRange & rRange)353cdf0e10cSrcweir bool lcl_GetAutoSumForRowRange( ScDocument* pDoc, ScRangeList& rRangeList, const ScRange& rRange )
354cdf0e10cSrcweir {
355cdf0e10cSrcweir const ScAddress aStart = rRange.aStart;
356cdf0e10cSrcweir const ScAddress aEnd = rRange.aEnd;
357cdf0e10cSrcweir if ( aStart.Row() != aEnd.Row() )
358cdf0e10cSrcweir {
359cdf0e10cSrcweir return false;
360cdf0e10cSrcweir }
361cdf0e10cSrcweir
362cdf0e10cSrcweir const SCTAB nTab = aEnd.Tab();
363cdf0e10cSrcweir const SCROW nRow = aEnd.Row();
364cdf0e10cSrcweir SCCOL nEndCol = aEnd.Col();
365cdf0e10cSrcweir SCCOL nStartCol = nEndCol;
366cdf0e10cSrcweir SCCOLROW nExtend = 0;
367cdf0e10cSrcweir const ScAutoSum eSum = lcl_IsAutoSumData( pDoc, nEndCol, nRow, nTab, DIR_LEFT, nExtend /*out*/ );
368cdf0e10cSrcweir
369cdf0e10cSrcweir if ( eSum == ScAutoSumSum )
370cdf0e10cSrcweir {
371cdf0e10cSrcweir bool bContinue = false;
372cdf0e10cSrcweir do
373cdf0e10cSrcweir {
374cdf0e10cSrcweir rRangeList.Append( ScRange( nStartCol, nRow, nTab, nEndCol, nRow, nTab ) );
375cdf0e10cSrcweir nEndCol = static_cast< SCCOL >( nExtend );
376cdf0e10cSrcweir if ( ( bContinue = lcl_FindNextSumEntryInRow( pDoc, nEndCol /*inout*/, nRow, nTab, nExtend /*out*/, aStart.Col() ) ) == true )
377cdf0e10cSrcweir {
378cdf0e10cSrcweir nStartCol = nEndCol;
379cdf0e10cSrcweir }
380cdf0e10cSrcweir } while ( bContinue );
381cdf0e10cSrcweir }
382cdf0e10cSrcweir else
383cdf0e10cSrcweir {
384cdf0e10cSrcweir while ( nStartCol > aStart.Col() &&
385cdf0e10cSrcweir lcl_IsAutoSumData( pDoc, nStartCol-1, nRow, nTab, DIR_LEFT, nExtend /*out*/ ) != ScAutoSumSum )
386cdf0e10cSrcweir {
387cdf0e10cSrcweir --nStartCol;
388cdf0e10cSrcweir }
389cdf0e10cSrcweir rRangeList.Append( ScRange( nStartCol, nRow, nTab, nEndCol, nRow, nTab ) );
390cdf0e10cSrcweir }
391cdf0e10cSrcweir
392cdf0e10cSrcweir return true;
393cdf0e10cSrcweir }
394cdf0e10cSrcweir
395cdf0e10cSrcweir //----------------------------------------------------------------------------
396cdf0e10cSrcweir
GetAutoSumArea(ScRangeList & rRangeList)397cdf0e10cSrcweir sal_Bool ScViewFunc::GetAutoSumArea( ScRangeList& rRangeList )
398cdf0e10cSrcweir {
399cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
400cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
401cdf0e10cSrcweir
402cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
403cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
404cdf0e10cSrcweir
405cdf0e10cSrcweir SCCOL nStartCol = nCol;
406cdf0e10cSrcweir SCROW nStartRow = nRow;
407cdf0e10cSrcweir SCCOL nEndCol = nCol;
408cdf0e10cSrcweir SCROW nEndRow = nRow;
409cdf0e10cSrcweir SCCOL nSeekCol = nCol;
410cdf0e10cSrcweir SCROW nSeekRow = nRow;
411cdf0e10cSrcweir SCCOLROW nExtend; // wird per Reference gueltig bei ScAutoSumSum
412cdf0e10cSrcweir
413cdf0e10cSrcweir sal_Bool bCol = sal_False;
414cdf0e10cSrcweir sal_Bool bRow = sal_False;
415cdf0e10cSrcweir
416cdf0e10cSrcweir ScAutoSum eSum;
417cdf0e10cSrcweir if ( nRow != 0
418cdf0e10cSrcweir && ((eSum = lcl_IsAutoSumData( pDoc, nCol, nRow-1, nTab,
419cdf0e10cSrcweir DIR_TOP, nExtend /*out*/ )) == ScAutoSumData )
420cdf0e10cSrcweir && ((eSum = lcl_IsAutoSumData( pDoc, nCol, nRow-1, nTab,
421cdf0e10cSrcweir DIR_LEFT, nExtend /*out*/ )) == ScAutoSumData )
422cdf0e10cSrcweir )
423cdf0e10cSrcweir {
424cdf0e10cSrcweir bRow = sal_True;
425cdf0e10cSrcweir nSeekRow = nRow - 1;
426cdf0e10cSrcweir }
427cdf0e10cSrcweir else if ( nCol != 0 && (eSum = lcl_IsAutoSumData( pDoc, nCol-1, nRow, nTab,
428cdf0e10cSrcweir DIR_LEFT, nExtend /*out*/ )) == ScAutoSumData )
429cdf0e10cSrcweir {
430cdf0e10cSrcweir bCol = sal_True;
431cdf0e10cSrcweir nSeekCol = nCol - 1;
432cdf0e10cSrcweir }
433cdf0e10cSrcweir else if ( (eSum = lcl_SeekAutoSumData( pDoc, nCol, nSeekRow, nTab, DIR_TOP, nExtend /*out*/ )) != ScAutoSumNone )
434cdf0e10cSrcweir bRow = sal_True;
435cdf0e10cSrcweir else if (( eSum = lcl_SeekAutoSumData( pDoc, nSeekCol, nRow, nTab, DIR_LEFT, nExtend /*out*/ )) != ScAutoSumNone )
436cdf0e10cSrcweir bCol = sal_True;
437cdf0e10cSrcweir
438cdf0e10cSrcweir if ( bCol || bRow )
439cdf0e10cSrcweir {
440cdf0e10cSrcweir if ( bRow )
441cdf0e10cSrcweir {
442cdf0e10cSrcweir nStartRow = nSeekRow; // nSeekRow evtl. per Reference angepasst
443cdf0e10cSrcweir if ( eSum == ScAutoSumSum )
444cdf0e10cSrcweir nEndRow = nStartRow; // nur Summen summieren
445cdf0e10cSrcweir else
446cdf0e10cSrcweir nEndRow = nRow - 1; // Datenbereich evtl. nach unten erweitern
447cdf0e10cSrcweir }
448cdf0e10cSrcweir else
449cdf0e10cSrcweir {
450cdf0e10cSrcweir nStartCol = nSeekCol; // nSeekCol evtl. per Reference angepasst
451cdf0e10cSrcweir if ( eSum == ScAutoSumSum )
452cdf0e10cSrcweir nEndCol = nStartCol; // nur Summen summieren
453cdf0e10cSrcweir else
454cdf0e10cSrcweir nEndCol = nCol - 1; // Datenbereich evtl. nach rechts erweitern
455cdf0e10cSrcweir }
456cdf0e10cSrcweir sal_Bool bContinue = sal_False;
457cdf0e10cSrcweir do
458cdf0e10cSrcweir {
459cdf0e10cSrcweir if ( eSum == ScAutoSumData )
460cdf0e10cSrcweir {
461cdf0e10cSrcweir if ( bRow )
462cdf0e10cSrcweir {
463cdf0e10cSrcweir while ( nStartRow != 0 && lcl_IsAutoSumData( pDoc, nCol,
464cdf0e10cSrcweir nStartRow-1, nTab, DIR_TOP, nExtend /*out*/ ) == eSum )
465cdf0e10cSrcweir --nStartRow;
466cdf0e10cSrcweir }
467cdf0e10cSrcweir else
468cdf0e10cSrcweir {
469cdf0e10cSrcweir while ( nStartCol != 0 && lcl_IsAutoSumData( pDoc, nStartCol-1,
470cdf0e10cSrcweir nRow, nTab, DIR_LEFT, nExtend /*out*/ ) == eSum )
471cdf0e10cSrcweir --nStartCol;
472cdf0e10cSrcweir }
473cdf0e10cSrcweir }
474cdf0e10cSrcweir rRangeList.Append(
475cdf0e10cSrcweir ScRange( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab ) );
476cdf0e10cSrcweir if ( eSum == ScAutoSumSum )
477cdf0e10cSrcweir {
478cdf0e10cSrcweir if ( bRow )
479cdf0e10cSrcweir {
480cdf0e10cSrcweir nEndRow = static_cast< SCROW >( nExtend );
481cdf0e10cSrcweir if ( ( bContinue = lcl_FindNextSumEntryInColumn( pDoc, nCol, nEndRow /*inout*/, nTab, nExtend /*out*/, 0 ) ) == true )
482cdf0e10cSrcweir {
483cdf0e10cSrcweir nStartRow = nEndRow;
484cdf0e10cSrcweir }
485cdf0e10cSrcweir }
486cdf0e10cSrcweir else
487cdf0e10cSrcweir {
488cdf0e10cSrcweir nEndCol = static_cast< SCCOL >( nExtend );
489cdf0e10cSrcweir if ( ( bContinue = lcl_FindNextSumEntryInRow( pDoc, nEndCol /*inout*/, nRow, nTab, nExtend /*out*/, 0 ) ) == true )
490cdf0e10cSrcweir {
491cdf0e10cSrcweir nStartCol = nEndCol;
492cdf0e10cSrcweir }
493cdf0e10cSrcweir }
494cdf0e10cSrcweir }
495cdf0e10cSrcweir } while ( bContinue );
496cdf0e10cSrcweir return sal_True;
497cdf0e10cSrcweir }
498cdf0e10cSrcweir return sal_False;
499cdf0e10cSrcweir }
500cdf0e10cSrcweir
501cdf0e10cSrcweir //----------------------------------------------------------------------------
502cdf0e10cSrcweir
EnterAutoSum(const ScRangeList & rRangeList,sal_Bool bSubTotal)503cdf0e10cSrcweir void ScViewFunc::EnterAutoSum(const ScRangeList& rRangeList, sal_Bool bSubTotal) // Block mit Summen fuellen
504cdf0e10cSrcweir {
505cdf0e10cSrcweir String aFormula = GetAutoSumFormula( rRangeList, bSubTotal );
506cdf0e10cSrcweir EnterBlock( aFormula, NULL );
507cdf0e10cSrcweir }
508cdf0e10cSrcweir
509cdf0e10cSrcweir //----------------------------------------------------------------------------
510cdf0e10cSrcweir
AutoSum(const ScRange & rRange,bool bSubTotal,bool bSetCursor,bool bContinue)511cdf0e10cSrcweir bool ScViewFunc::AutoSum( const ScRange& rRange, bool bSubTotal, bool bSetCursor, bool bContinue )
512cdf0e10cSrcweir {
513cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
514cdf0e10cSrcweir const SCTAB nTab = rRange.aStart.Tab();
515cdf0e10cSrcweir SCCOL nStartCol = rRange.aStart.Col();
516cdf0e10cSrcweir SCROW nStartRow = rRange.aStart.Row();
517cdf0e10cSrcweir const SCCOL nEndCol = rRange.aEnd.Col();
518cdf0e10cSrcweir const SCROW nEndRow = rRange.aEnd.Row();
519cdf0e10cSrcweir SCCOLROW nExtend = 0; // out parameter for lcl_IsAutoSumData
520cdf0e10cSrcweir
521cdf0e10cSrcweir // ignore rows at the top of the given range which don't contain autosum data
522cdf0e10cSrcweir bool bRowData = false;
523cdf0e10cSrcweir for ( SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow )
524cdf0e10cSrcweir {
525cdf0e10cSrcweir for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol )
526cdf0e10cSrcweir {
527cdf0e10cSrcweir if ( lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_TOP, nExtend ) != ScAutoSumNone )
528cdf0e10cSrcweir {
529cdf0e10cSrcweir bRowData = true;
530cdf0e10cSrcweir break;
531cdf0e10cSrcweir }
532cdf0e10cSrcweir }
533cdf0e10cSrcweir if ( bRowData )
534cdf0e10cSrcweir {
535cdf0e10cSrcweir nStartRow = nRow;
536cdf0e10cSrcweir break;
537cdf0e10cSrcweir }
538cdf0e10cSrcweir }
539cdf0e10cSrcweir if ( !bRowData )
540cdf0e10cSrcweir {
541cdf0e10cSrcweir return false;
542cdf0e10cSrcweir }
543cdf0e10cSrcweir
544cdf0e10cSrcweir // ignore columns at the left of the given range which don't contain autosum data
545cdf0e10cSrcweir bool bColData = false;
546cdf0e10cSrcweir for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol )
547cdf0e10cSrcweir {
548cdf0e10cSrcweir for ( SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow )
549cdf0e10cSrcweir {
550cdf0e10cSrcweir if ( lcl_IsAutoSumData( pDoc, nCol, nRow, nTab, DIR_LEFT, nExtend ) != ScAutoSumNone )
551cdf0e10cSrcweir {
552cdf0e10cSrcweir bColData = true;
553cdf0e10cSrcweir break;
554cdf0e10cSrcweir }
555cdf0e10cSrcweir }
556cdf0e10cSrcweir if ( bColData )
557cdf0e10cSrcweir {
558cdf0e10cSrcweir nStartCol = nCol;
559cdf0e10cSrcweir break;
560cdf0e10cSrcweir }
561cdf0e10cSrcweir }
562cdf0e10cSrcweir if ( !bColData )
563cdf0e10cSrcweir {
564cdf0e10cSrcweir return false;
565cdf0e10cSrcweir }
566cdf0e10cSrcweir
567cdf0e10cSrcweir const bool bEndRowEmpty = pDoc->IsBlockEmpty( nTab, nStartCol, nEndRow, nEndCol, nEndRow );
568cdf0e10cSrcweir const bool bEndColEmpty = pDoc->IsBlockEmpty( nTab, nEndCol, nStartRow, nEndCol, nEndRow );
569cdf0e10cSrcweir bool bRow = ( ( nStartRow != nEndRow ) && ( bEndRowEmpty || ( !bEndRowEmpty && !bEndColEmpty ) ) );
570cdf0e10cSrcweir bool bCol = ( ( nStartCol != nEndCol ) && ( bEndColEmpty || nStartRow == nEndRow ) );
571cdf0e10cSrcweir
572cdf0e10cSrcweir // find an empty row for entering the result
573cdf0e10cSrcweir SCROW nInsRow = nEndRow;
574cdf0e10cSrcweir if ( bRow && !bEndRowEmpty )
575cdf0e10cSrcweir {
576cdf0e10cSrcweir if ( nInsRow < MAXROW )
577cdf0e10cSrcweir {
578cdf0e10cSrcweir ++nInsRow;
579cdf0e10cSrcweir while ( !pDoc->IsBlockEmpty( nTab, nStartCol, nInsRow, nEndCol, nInsRow ) )
580cdf0e10cSrcweir {
581cdf0e10cSrcweir if ( nInsRow < MAXROW )
582cdf0e10cSrcweir {
583cdf0e10cSrcweir ++nInsRow;
584cdf0e10cSrcweir }
585cdf0e10cSrcweir else
586cdf0e10cSrcweir {
587cdf0e10cSrcweir bRow = false;
588cdf0e10cSrcweir break;
589cdf0e10cSrcweir }
590cdf0e10cSrcweir }
591cdf0e10cSrcweir }
592cdf0e10cSrcweir else
593cdf0e10cSrcweir {
594cdf0e10cSrcweir bRow = false;
595cdf0e10cSrcweir }
596cdf0e10cSrcweir }
597cdf0e10cSrcweir
598cdf0e10cSrcweir // find an empty column for entering the result
599cdf0e10cSrcweir SCCOL nInsCol = nEndCol;
600cdf0e10cSrcweir if ( bCol && !bEndColEmpty )
601cdf0e10cSrcweir {
602cdf0e10cSrcweir if ( nInsCol < MAXCOL )
603cdf0e10cSrcweir {
604cdf0e10cSrcweir ++nInsCol;
605cdf0e10cSrcweir while ( !pDoc->IsBlockEmpty( nTab, nInsCol, nStartRow, nInsCol, nEndRow ) )
606cdf0e10cSrcweir {
607cdf0e10cSrcweir if ( nInsCol < MAXCOL )
608cdf0e10cSrcweir {
609cdf0e10cSrcweir ++nInsCol;
610cdf0e10cSrcweir }
611cdf0e10cSrcweir else
612cdf0e10cSrcweir {
613cdf0e10cSrcweir bCol = false;
614cdf0e10cSrcweir break;
615cdf0e10cSrcweir }
616cdf0e10cSrcweir }
617cdf0e10cSrcweir }
618cdf0e10cSrcweir else
619cdf0e10cSrcweir {
620cdf0e10cSrcweir bCol = false;
621cdf0e10cSrcweir }
622cdf0e10cSrcweir }
623cdf0e10cSrcweir
624cdf0e10cSrcweir if ( !bRow && !bCol )
625cdf0e10cSrcweir {
626cdf0e10cSrcweir return false;
627cdf0e10cSrcweir }
628cdf0e10cSrcweir
629cdf0e10cSrcweir SCCOL nMarkEndCol = nEndCol;
630cdf0e10cSrcweir SCROW nMarkEndRow = nEndRow;
631cdf0e10cSrcweir
632cdf0e10cSrcweir if ( bRow )
633cdf0e10cSrcweir {
634cdf0e10cSrcweir // calculate the row sums for all columns of the given range
635cdf0e10cSrcweir
636cdf0e10cSrcweir SCROW nSumEndRow = nEndRow;
637cdf0e10cSrcweir
638cdf0e10cSrcweir if ( bEndRowEmpty )
639cdf0e10cSrcweir {
640cdf0e10cSrcweir // the last row of the given range is empty;
641cdf0e10cSrcweir // don't take into account for calculating the autosum
642cdf0e10cSrcweir --nSumEndRow;
643cdf0e10cSrcweir }
644cdf0e10cSrcweir else
645cdf0e10cSrcweir {
646cdf0e10cSrcweir // increase mark range
647cdf0e10cSrcweir ++nMarkEndRow;
648cdf0e10cSrcweir }
649cdf0e10cSrcweir
650cdf0e10cSrcweir for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol )
651cdf0e10cSrcweir {
652cdf0e10cSrcweir if ( !pDoc->IsBlockEmpty( nTab, nCol, nStartRow, nCol, nSumEndRow ) )
653cdf0e10cSrcweir {
654cdf0e10cSrcweir ScRangeList aRangeList;
655cdf0e10cSrcweir const ScRange aRange( nCol, nStartRow, nTab, nCol, nSumEndRow, nTab );
656cdf0e10cSrcweir if ( lcl_GetAutoSumForColumnRange( pDoc, aRangeList, aRange ) )
657cdf0e10cSrcweir {
658cdf0e10cSrcweir const String aFormula = GetAutoSumFormula( aRangeList, bSubTotal );
659cdf0e10cSrcweir EnterData( nCol, nInsRow, nTab, aFormula );
660cdf0e10cSrcweir }
661cdf0e10cSrcweir }
662cdf0e10cSrcweir }
663cdf0e10cSrcweir }
664cdf0e10cSrcweir
665cdf0e10cSrcweir if ( bCol )
666cdf0e10cSrcweir {
667cdf0e10cSrcweir // calculate the column sums for all rows of the given range
668cdf0e10cSrcweir
669cdf0e10cSrcweir SCCOL nSumEndCol = nEndCol;
670cdf0e10cSrcweir
671cdf0e10cSrcweir if ( bEndColEmpty )
672cdf0e10cSrcweir {
673cdf0e10cSrcweir // the last column of the given range is empty;
674cdf0e10cSrcweir // don't take into account for calculating the autosum
675cdf0e10cSrcweir --nSumEndCol;
676cdf0e10cSrcweir }
677cdf0e10cSrcweir else
678cdf0e10cSrcweir {
679cdf0e10cSrcweir // increase mark range
680cdf0e10cSrcweir ++nMarkEndCol;
681cdf0e10cSrcweir }
682cdf0e10cSrcweir
683cdf0e10cSrcweir for ( SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow )
684cdf0e10cSrcweir {
685cdf0e10cSrcweir if ( !pDoc->IsBlockEmpty( nTab, nStartCol, nRow, nSumEndCol, nRow ) )
686cdf0e10cSrcweir {
687cdf0e10cSrcweir ScRangeList aRangeList;
688cdf0e10cSrcweir const ScRange aRange( nStartCol, nRow, nTab, nSumEndCol, nRow, nTab );
689cdf0e10cSrcweir if ( lcl_GetAutoSumForRowRange( pDoc, aRangeList, aRange ) )
690cdf0e10cSrcweir {
691cdf0e10cSrcweir const String aFormula = GetAutoSumFormula( aRangeList, bSubTotal );
692cdf0e10cSrcweir EnterData( nInsCol, nRow, nTab, aFormula );
693cdf0e10cSrcweir }
694cdf0e10cSrcweir }
695cdf0e10cSrcweir }
696cdf0e10cSrcweir }
697cdf0e10cSrcweir
698cdf0e10cSrcweir // set new mark range and cursor position
699cdf0e10cSrcweir const ScRange aMarkRange( nStartCol, nStartRow, nTab, nMarkEndCol, nMarkEndRow, nTab );
700cdf0e10cSrcweir MarkRange( aMarkRange, sal_False, bContinue );
701cdf0e10cSrcweir if ( bSetCursor )
702cdf0e10cSrcweir {
703cdf0e10cSrcweir SetCursor( nMarkEndCol, nMarkEndRow );
704cdf0e10cSrcweir }
705cdf0e10cSrcweir
706cdf0e10cSrcweir return true;
707cdf0e10cSrcweir }
708cdf0e10cSrcweir
709cdf0e10cSrcweir //----------------------------------------------------------------------------
710cdf0e10cSrcweir
GetAutoSumFormula(const ScRangeList & rRangeList,bool bSubTotal)711cdf0e10cSrcweir String ScViewFunc::GetAutoSumFormula( const ScRangeList& rRangeList, bool bSubTotal )
712cdf0e10cSrcweir {
713cdf0e10cSrcweir String aFormula = '=';
714cdf0e10cSrcweir ScFunctionMgr* pFuncMgr = ScGlobal::GetStarCalcFunctionMgr();
715cdf0e10cSrcweir const ScFuncDesc* pDesc = NULL;
716cdf0e10cSrcweir if ( bSubTotal )
717cdf0e10cSrcweir {
718cdf0e10cSrcweir pDesc = pFuncMgr->Get( SC_OPCODE_SUB_TOTAL );
719cdf0e10cSrcweir }
720cdf0e10cSrcweir else
721cdf0e10cSrcweir {
722cdf0e10cSrcweir pDesc = pFuncMgr->Get( SC_OPCODE_SUM );
723cdf0e10cSrcweir }
724cdf0e10cSrcweir if ( pDesc && pDesc->pFuncName )
725cdf0e10cSrcweir {
726cdf0e10cSrcweir aFormula += *pDesc->pFuncName;
727cdf0e10cSrcweir if ( bSubTotal )
728cdf0e10cSrcweir {
729cdf0e10cSrcweir aFormula.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "(9;" ) );
730cdf0e10cSrcweir }
731cdf0e10cSrcweir else
732cdf0e10cSrcweir {
733cdf0e10cSrcweir aFormula += '(';
734cdf0e10cSrcweir }
735cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
736cdf0e10cSrcweir String aRef;
737cdf0e10cSrcweir rRangeList.Format( aRef, SCA_VALID, pDoc );
738cdf0e10cSrcweir aFormula += aRef;
739cdf0e10cSrcweir aFormula += ')';
740cdf0e10cSrcweir }
741cdf0e10cSrcweir return aFormula;
742cdf0e10cSrcweir }
743cdf0e10cSrcweir
744cdf0e10cSrcweir //----------------------------------------------------------------------------
745cdf0e10cSrcweir
EnterBlock(const String & rString,const EditTextObject * pData)746cdf0e10cSrcweir void ScViewFunc::EnterBlock( const String& rString, const EditTextObject* pData )
747cdf0e10cSrcweir {
748cdf0e10cSrcweir // Mehrfachselektion vorher abfragen...
749cdf0e10cSrcweir
750cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
751cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
752cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
753cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
754cdf0e10cSrcweir if ( rMark.IsMultiMarked() )
755cdf0e10cSrcweir {
756cdf0e10cSrcweir rMark.MarkToSimple();
757cdf0e10cSrcweir if ( rMark.IsMultiMarked() )
758cdf0e10cSrcweir { // "Einfuegen auf Mehrfachselektion nicht moeglich"
759cdf0e10cSrcweir ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
760cdf0e10cSrcweir
761cdf0e10cSrcweir // insert into single cell
762cdf0e10cSrcweir if ( pData )
763cdf0e10cSrcweir EnterData( nCol, nRow, nTab, pData );
764cdf0e10cSrcweir else
765cdf0e10cSrcweir EnterData( nCol, nRow, nTab, rString );
766cdf0e10cSrcweir return;
767cdf0e10cSrcweir }
768cdf0e10cSrcweir }
769cdf0e10cSrcweir
770cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
771cdf0e10cSrcweir String aNewStr = rString;
772cdf0e10cSrcweir if ( pData )
773cdf0e10cSrcweir {
774cdf0e10cSrcweir const ScPatternAttr* pOldPattern = pDoc->GetPattern( nCol, nRow, nTab );
775cdf0e10cSrcweir ScTabEditEngine aEngine( *pOldPattern, pDoc->GetEnginePool() );
776cdf0e10cSrcweir aEngine.SetText(*pData);
777cdf0e10cSrcweir
778cdf0e10cSrcweir ScEditAttrTester aTester( &aEngine );
779cdf0e10cSrcweir if (!aTester.NeedsObject())
780cdf0e10cSrcweir {
781cdf0e10cSrcweir aNewStr = aEngine.GetText();
782cdf0e10cSrcweir pData = NULL;
783cdf0e10cSrcweir }
784cdf0e10cSrcweir }
785cdf0e10cSrcweir
786cdf0e10cSrcweir // Einfuegen per PasteFromClip
787cdf0e10cSrcweir
788cdf0e10cSrcweir WaitObject aWait( GetFrameWin() );
789cdf0e10cSrcweir
790cdf0e10cSrcweir ScAddress aPos( nCol, nRow, nTab );
791cdf0e10cSrcweir
792cdf0e10cSrcweir ScDocument* pInsDoc = new ScDocument( SCDOCMODE_CLIP );
793cdf0e10cSrcweir pInsDoc->ResetClip( pDoc, nTab );
794cdf0e10cSrcweir
795cdf0e10cSrcweir if (aNewStr.GetChar(0) == '=') // Formel ?
796cdf0e10cSrcweir {
797cdf0e10cSrcweir // SetString geht nicht, weil in Clipboard-Dokumenten nicht kompiliert wird!
798cdf0e10cSrcweir ScFormulaCell* pFCell = new ScFormulaCell( pDoc, aPos, aNewStr );
799cdf0e10cSrcweir pInsDoc->PutCell( nCol, nRow, nTab, pFCell );
800cdf0e10cSrcweir }
801cdf0e10cSrcweir else if ( pData )
802cdf0e10cSrcweir pInsDoc->PutCell( nCol, nRow, nTab, new ScEditCell( pData, pDoc, NULL ) );
803cdf0e10cSrcweir else
804cdf0e10cSrcweir pInsDoc->SetString( nCol, nRow, nTab, aNewStr );
805cdf0e10cSrcweir
806cdf0e10cSrcweir pInsDoc->SetClipArea( ScRange(aPos) );
807cdf0e10cSrcweir // auf Block einfuegen, mit Undo etc.
808cdf0e10cSrcweir if ( PasteFromClip( IDF_CONTENTS, pInsDoc, PASTE_NOFUNC, sal_False, sal_False,
809cdf0e10cSrcweir sal_False, INS_NONE, IDF_ATTRIB ) )
810cdf0e10cSrcweir {
811cdf0e10cSrcweir const SfxUInt32Item* pItem = (SfxUInt32Item*) pInsDoc->GetAttr(
812cdf0e10cSrcweir nCol, nRow, nTab, ATTR_VALUE_FORMAT );
813cdf0e10cSrcweir if ( pItem )
814cdf0e10cSrcweir { // Numberformat setzen wenn inkompatibel
815cdf0e10cSrcweir // MarkData wurde bereits in PasteFromClip MarkToSimple'ed
816cdf0e10cSrcweir ScRange aRange;
817cdf0e10cSrcweir rMark.GetMarkArea( aRange );
818cdf0e10cSrcweir ScPatternAttr* pPattern = new ScPatternAttr( pDoc->GetPool() );
819cdf0e10cSrcweir pPattern->GetItemSet().Put( *pItem );
820cdf0e10cSrcweir short nNewType = pDoc->GetFormatTable()->GetType( pItem->GetValue() );
821cdf0e10cSrcweir pDoc->ApplyPatternIfNumberformatIncompatible( aRange, rMark,
822cdf0e10cSrcweir *pPattern, nNewType );
823cdf0e10cSrcweir delete pPattern;
824cdf0e10cSrcweir }
825cdf0e10cSrcweir }
826cdf0e10cSrcweir
827cdf0e10cSrcweir delete pInsDoc;
828cdf0e10cSrcweir }
829cdf0e10cSrcweir
830cdf0e10cSrcweir
831cdf0e10cSrcweir //----------------------------------------------------------------------------
832cdf0e10cSrcweir
833cdf0e10cSrcweir //UNUSED2008-05 void ScViewFunc::PaintWidthHeight( sal_Bool bColumns, SCCOLROW nStart, SCCOLROW nEnd )
834cdf0e10cSrcweir //UNUSED2008-05 {
835cdf0e10cSrcweir //UNUSED2008-05 SCTAB nTab = GetViewData()->GetTabNo();
836cdf0e10cSrcweir //UNUSED2008-05 ScDocument* pDoc = GetViewData()->GetDocument();
837cdf0e10cSrcweir //UNUSED2008-05
838cdf0e10cSrcweir //UNUSED2008-05 sal_uInt16 nParts = PAINT_GRID;
839cdf0e10cSrcweir //UNUSED2008-05 SCCOL nStartCol = 0;
840cdf0e10cSrcweir //UNUSED2008-05 SCROW nStartRow = 0;
841cdf0e10cSrcweir //UNUSED2008-05 SCCOL nEndCol = MAXCOL; // fuer Test auf Merge
842cdf0e10cSrcweir //UNUSED2008-05 SCROW nEndRow = MAXROW;
843cdf0e10cSrcweir //UNUSED2008-05 if ( bColumns )
844cdf0e10cSrcweir //UNUSED2008-05 {
845cdf0e10cSrcweir //UNUSED2008-05 nParts |= PAINT_TOP;
846cdf0e10cSrcweir //UNUSED2008-05 nStartCol = static_cast<SCCOL>(nStart);
847cdf0e10cSrcweir //UNUSED2008-05 nEndCol = static_cast<SCCOL>(nEnd);
848cdf0e10cSrcweir //UNUSED2008-05 }
849cdf0e10cSrcweir //UNUSED2008-05 else
850cdf0e10cSrcweir //UNUSED2008-05 {
851cdf0e10cSrcweir //UNUSED2008-05 nParts |= PAINT_LEFT;
852cdf0e10cSrcweir //UNUSED2008-05 nStartRow = nStart;
853cdf0e10cSrcweir //UNUSED2008-05 nEndRow = nEnd;
854cdf0e10cSrcweir //UNUSED2008-05 }
855cdf0e10cSrcweir //UNUSED2008-05 if (pDoc->HasAttrib( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab,
856cdf0e10cSrcweir //UNUSED2008-05 HASATTR_MERGED | HASATTR_OVERLAPPED ))
857cdf0e10cSrcweir //UNUSED2008-05 {
858cdf0e10cSrcweir //UNUSED2008-05 nStartCol = 0;
859cdf0e10cSrcweir //UNUSED2008-05 nStartRow = 0;
860cdf0e10cSrcweir //UNUSED2008-05 }
861cdf0e10cSrcweir //UNUSED2008-05 GetViewData()->GetDocShell()->PostPaint( nStartCol,nStartRow,nTab, MAXCOL,MAXROW,nTab, nParts );
862cdf0e10cSrcweir //UNUSED2008-05 }
863cdf0e10cSrcweir
864cdf0e10cSrcweir
865cdf0e10cSrcweir //----------------------------------------------------------------------------
866cdf0e10cSrcweir // manueller Seitenumbruch
867cdf0e10cSrcweir
InsertPageBreak(sal_Bool bColumn,sal_Bool bRecord,const ScAddress * pPos,sal_Bool bSetModified)868cdf0e10cSrcweir void ScViewFunc::InsertPageBreak( sal_Bool bColumn, sal_Bool bRecord, const ScAddress* pPos,
869cdf0e10cSrcweir sal_Bool bSetModified )
870cdf0e10cSrcweir {
871cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
872cdf0e10cSrcweir ScAddress aCursor;
873cdf0e10cSrcweir if (pPos)
874cdf0e10cSrcweir aCursor = *pPos;
875cdf0e10cSrcweir else
876cdf0e10cSrcweir aCursor = ScAddress( GetViewData()->GetCurX(), GetViewData()->GetCurY(), nTab );
877cdf0e10cSrcweir
878cdf0e10cSrcweir sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().
879cdf0e10cSrcweir InsertPageBreak( bColumn, aCursor, bRecord, bSetModified, sal_False );
880cdf0e10cSrcweir
881cdf0e10cSrcweir if ( bSuccess && bSetModified )
882cdf0e10cSrcweir UpdatePageBreakData( sal_True ); // fuer PageBreak-Modus
883cdf0e10cSrcweir }
884cdf0e10cSrcweir
885cdf0e10cSrcweir
886cdf0e10cSrcweir //----------------------------------------------------------------------------
887cdf0e10cSrcweir
DeletePageBreak(sal_Bool bColumn,sal_Bool bRecord,const ScAddress * pPos,sal_Bool bSetModified)888cdf0e10cSrcweir void ScViewFunc::DeletePageBreak( sal_Bool bColumn, sal_Bool bRecord, const ScAddress* pPos,
889cdf0e10cSrcweir sal_Bool bSetModified )
890cdf0e10cSrcweir {
891cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
892cdf0e10cSrcweir ScAddress aCursor;
893cdf0e10cSrcweir if (pPos)
894cdf0e10cSrcweir aCursor = *pPos;
895cdf0e10cSrcweir else
896cdf0e10cSrcweir aCursor = ScAddress( GetViewData()->GetCurX(), GetViewData()->GetCurY(), nTab );
897cdf0e10cSrcweir
898cdf0e10cSrcweir sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().
899cdf0e10cSrcweir RemovePageBreak( bColumn, aCursor, bRecord, bSetModified, sal_False );
900cdf0e10cSrcweir
901cdf0e10cSrcweir if ( bSuccess && bSetModified )
902cdf0e10cSrcweir UpdatePageBreakData( sal_True ); // fuer PageBreak-Modus
903cdf0e10cSrcweir }
904cdf0e10cSrcweir
905cdf0e10cSrcweir //----------------------------------------------------------------------------
906cdf0e10cSrcweir
RemoveManualBreaks()907cdf0e10cSrcweir void ScViewFunc::RemoveManualBreaks()
908cdf0e10cSrcweir {
909cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
910cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
911cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
912cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
913cdf0e10cSrcweir
914cdf0e10cSrcweir if (bUndo)
915cdf0e10cSrcweir {
916cdf0e10cSrcweir ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
917cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True );
918cdf0e10cSrcweir pDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, sal_False, pUndoDoc );
919cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
920cdf0e10cSrcweir new ScUndoRemoveBreaks( pDocSh, nTab, pUndoDoc ) );
921cdf0e10cSrcweir }
922cdf0e10cSrcweir
923cdf0e10cSrcweir pDoc->RemoveManualBreaks(nTab);
924cdf0e10cSrcweir pDoc->UpdatePageBreaks(nTab);
925cdf0e10cSrcweir
926cdf0e10cSrcweir UpdatePageBreakData( sal_True );
927cdf0e10cSrcweir pDocSh->SetDocumentModified();
928cdf0e10cSrcweir pDocSh->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID );
929cdf0e10cSrcweir }
930cdf0e10cSrcweir
931cdf0e10cSrcweir //----------------------------------------------------------------------------
932cdf0e10cSrcweir
SetPrintZoom(sal_uInt16 nScale,sal_uInt16 nPages)933cdf0e10cSrcweir void ScViewFunc::SetPrintZoom(sal_uInt16 nScale, sal_uInt16 nPages)
934cdf0e10cSrcweir {
935cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
936cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
937cdf0e10cSrcweir pDocSh->SetPrintZoom( nTab, nScale, nPages );
938cdf0e10cSrcweir }
939cdf0e10cSrcweir
AdjustPrintZoom()940cdf0e10cSrcweir void ScViewFunc::AdjustPrintZoom()
941cdf0e10cSrcweir {
942cdf0e10cSrcweir ScRange aRange;
943cdf0e10cSrcweir if ( GetViewData()->GetSimpleArea( aRange ) != SC_MARK_SIMPLE )
944cdf0e10cSrcweir GetViewData()->GetMarkData().GetMultiMarkArea( aRange );
945cdf0e10cSrcweir GetViewData()->GetDocShell()->AdjustPrintZoom( aRange );
946cdf0e10cSrcweir }
947cdf0e10cSrcweir
948cdf0e10cSrcweir //----------------------------------------------------------------------------
949cdf0e10cSrcweir
SetPrintRanges(sal_Bool bEntireSheet,const String * pPrint,const String * pRepCol,const String * pRepRow,sal_Bool bAddPrint)950cdf0e10cSrcweir void ScViewFunc::SetPrintRanges( sal_Bool bEntireSheet, const String* pPrint,
951cdf0e10cSrcweir const String* pRepCol, const String* pRepRow,
952cdf0e10cSrcweir sal_Bool bAddPrint )
953cdf0e10cSrcweir {
954cdf0e10cSrcweir // on all selected tables
955cdf0e10cSrcweir
956cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
957cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
958cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
959cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
960cdf0e10cSrcweir SCTAB nTab;
961cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
962cdf0e10cSrcweir
963cdf0e10cSrcweir ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver();
964cdf0e10cSrcweir
965cdf0e10cSrcweir ScAddress::Details aDetails(pDoc->GetAddressConvention(), 0, 0);
966cdf0e10cSrcweir
967cdf0e10cSrcweir for (nTab=0; nTab<nTabCount; nTab++)
968cdf0e10cSrcweir if (rMark.GetTableSelect(nTab))
969cdf0e10cSrcweir {
970cdf0e10cSrcweir ScRange aRange( 0,0,nTab );
971cdf0e10cSrcweir
972cdf0e10cSrcweir // print ranges
973cdf0e10cSrcweir
974cdf0e10cSrcweir if( !bAddPrint )
975cdf0e10cSrcweir pDoc->ClearPrintRanges( nTab );
976cdf0e10cSrcweir
977cdf0e10cSrcweir if( bEntireSheet )
978cdf0e10cSrcweir {
979cdf0e10cSrcweir pDoc->SetPrintEntireSheet( nTab );
980cdf0e10cSrcweir }
981cdf0e10cSrcweir else if ( pPrint )
982cdf0e10cSrcweir {
983cdf0e10cSrcweir if ( pPrint->Len() )
984cdf0e10cSrcweir {
985cdf0e10cSrcweir const sal_Unicode sep = ScCompiler::GetNativeSymbol(ocSep).GetChar(0);
986cdf0e10cSrcweir sal_uInt16 nTCount = pPrint->GetTokenCount(sep);
987cdf0e10cSrcweir for (sal_uInt16 i=0; i<nTCount; i++)
988cdf0e10cSrcweir {
989cdf0e10cSrcweir String aToken = pPrint->GetToken(i, sep);
990cdf0e10cSrcweir if ( aRange.ParseAny( aToken, pDoc, aDetails ) & SCA_VALID )
991cdf0e10cSrcweir pDoc->AddPrintRange( nTab, aRange );
992cdf0e10cSrcweir }
993cdf0e10cSrcweir }
994cdf0e10cSrcweir }
995cdf0e10cSrcweir else // NULL = use selection (print range is always set), use empty string to delete all ranges
996cdf0e10cSrcweir {
997cdf0e10cSrcweir if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
998cdf0e10cSrcweir {
999cdf0e10cSrcweir pDoc->AddPrintRange( nTab, aRange );
1000cdf0e10cSrcweir }
1001cdf0e10cSrcweir else if ( rMark.IsMultiMarked() )
1002cdf0e10cSrcweir {
1003cdf0e10cSrcweir rMark.MarkToMulti();
1004cdf0e10cSrcweir ScRangeListRef aList( new ScRangeList );
1005cdf0e10cSrcweir rMark.FillRangeListWithMarks( aList, sal_False );
1006cdf0e10cSrcweir sal_uInt16 nCnt = (sal_uInt16) aList->Count();
1007cdf0e10cSrcweir if ( nCnt )
1008cdf0e10cSrcweir {
1009cdf0e10cSrcweir ScRangePtr pR;
1010cdf0e10cSrcweir sal_uInt16 i;
1011cdf0e10cSrcweir for ( pR = aList->First(), i=0; i < nCnt;
1012cdf0e10cSrcweir pR = aList->Next(), i++ )
1013cdf0e10cSrcweir {
1014cdf0e10cSrcweir pDoc->AddPrintRange( nTab, *pR );
1015cdf0e10cSrcweir }
1016cdf0e10cSrcweir }
1017cdf0e10cSrcweir }
1018cdf0e10cSrcweir }
1019cdf0e10cSrcweir
1020cdf0e10cSrcweir // repeat columns
1021cdf0e10cSrcweir
1022cdf0e10cSrcweir if ( pRepCol )
1023cdf0e10cSrcweir {
1024cdf0e10cSrcweir if ( !pRepCol->Len() )
1025cdf0e10cSrcweir pDoc->SetRepeatColRange( nTab, NULL );
1026cdf0e10cSrcweir else
1027cdf0e10cSrcweir if ( aRange.ParseAny( *pRepCol, pDoc, aDetails ) & SCA_VALID )
1028cdf0e10cSrcweir pDoc->SetRepeatColRange( nTab, &aRange );
1029cdf0e10cSrcweir }
1030cdf0e10cSrcweir
1031cdf0e10cSrcweir // repeat rows
1032cdf0e10cSrcweir
1033cdf0e10cSrcweir if ( pRepRow )
1034cdf0e10cSrcweir {
1035cdf0e10cSrcweir if ( !pRepRow->Len() )
1036cdf0e10cSrcweir pDoc->SetRepeatRowRange( nTab, NULL );
1037cdf0e10cSrcweir else
1038cdf0e10cSrcweir if ( aRange.ParseAny( *pRepRow, pDoc, aDetails ) & SCA_VALID )
1039cdf0e10cSrcweir pDoc->SetRepeatRowRange( nTab, &aRange );
1040cdf0e10cSrcweir }
1041cdf0e10cSrcweir }
1042cdf0e10cSrcweir
1043cdf0e10cSrcweir // undo (for all tables)
1044cdf0e10cSrcweir if (bUndo)
1045cdf0e10cSrcweir {
1046cdf0e10cSrcweir SCTAB nCurTab = GetViewData()->GetTabNo();
1047cdf0e10cSrcweir ScPrintRangeSaver* pNewRanges = pDoc->CreatePrintRangeSaver();
1048cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1049cdf0e10cSrcweir new ScUndoPrintRange( pDocSh, nCurTab, pOldRanges, pNewRanges ) );
1050cdf0e10cSrcweir }
1051cdf0e10cSrcweir
1052cdf0e10cSrcweir // update page breaks
1053cdf0e10cSrcweir
1054cdf0e10cSrcweir for (nTab=0; nTab<nTabCount; nTab++)
1055cdf0e10cSrcweir if (rMark.GetTableSelect(nTab))
1056cdf0e10cSrcweir ScPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ).UpdatePages();
1057cdf0e10cSrcweir
1058cdf0e10cSrcweir SfxBindings& rBindings = GetViewData()->GetBindings();
1059cdf0e10cSrcweir rBindings.Invalidate( SID_DELETE_PRINTAREA );
1060cdf0e10cSrcweir
1061cdf0e10cSrcweir pDocSh->SetDocumentModified();
1062cdf0e10cSrcweir }
1063cdf0e10cSrcweir
1064cdf0e10cSrcweir //----------------------------------------------------------------------------
1065cdf0e10cSrcweir // Zellen zusammenfassen
1066cdf0e10cSrcweir
TestMergeCells()1067cdf0e10cSrcweir sal_Bool ScViewFunc::TestMergeCells() // Vorab-Test (fuer Menue)
1068cdf0e10cSrcweir {
1069cdf0e10cSrcweir // simple test: sal_True if there's a selection but no multi selection and not filtered
1070cdf0e10cSrcweir
1071cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
1072cdf0e10cSrcweir if ( rMark.IsMarked() || rMark.IsMultiMarked() )
1073cdf0e10cSrcweir {
1074cdf0e10cSrcweir ScRange aDummy;
1075cdf0e10cSrcweir return GetViewData()->GetSimpleArea( aDummy) == SC_MARK_SIMPLE;
1076cdf0e10cSrcweir }
1077cdf0e10cSrcweir else
1078cdf0e10cSrcweir return sal_False;
1079cdf0e10cSrcweir }
1080cdf0e10cSrcweir
1081cdf0e10cSrcweir
1082cdf0e10cSrcweir //----------------------------------------------------------------------------
1083cdf0e10cSrcweir
MergeCells(sal_Bool bApi,sal_Bool & rDoContents,sal_Bool bRecord)1084cdf0e10cSrcweir sal_Bool ScViewFunc::MergeCells( sal_Bool bApi, sal_Bool& rDoContents, sal_Bool bRecord )
1085cdf0e10cSrcweir {
1086cdf0e10cSrcweir // Editable- und Verschachtelungs-Abfrage muss vorneweg sein (auch in DocFunc),
1087cdf0e10cSrcweir // damit dann nicht die Inhalte-QueryBox kommt
1088cdf0e10cSrcweir ScEditableTester aTester( this );
1089cdf0e10cSrcweir if (!aTester.IsEditable())
1090cdf0e10cSrcweir {
1091cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
1092cdf0e10cSrcweir return sal_False;
1093cdf0e10cSrcweir }
1094cdf0e10cSrcweir
1095cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
1096cdf0e10cSrcweir rMark.MarkToSimple();
1097cdf0e10cSrcweir if (!rMark.IsMarked())
1098cdf0e10cSrcweir {
1099cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1100cdf0e10cSrcweir return sal_False;
1101cdf0e10cSrcweir }
1102cdf0e10cSrcweir
1103cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1104cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
1105cdf0e10cSrcweir
1106cdf0e10cSrcweir ScRange aMarkRange;
1107cdf0e10cSrcweir rMark.GetMarkArea( aMarkRange );
1108cdf0e10cSrcweir SCCOL nStartCol = aMarkRange.aStart.Col();
1109cdf0e10cSrcweir SCROW nStartRow = aMarkRange.aStart.Row();
1110cdf0e10cSrcweir SCTAB nStartTab = aMarkRange.aStart.Tab();
1111cdf0e10cSrcweir SCCOL nEndCol = aMarkRange.aEnd.Col();
1112cdf0e10cSrcweir SCROW nEndRow = aMarkRange.aEnd.Row();
1113cdf0e10cSrcweir SCTAB nEndTab = aMarkRange.aEnd.Tab();
1114cdf0e10cSrcweir if ( nStartCol == nEndCol && nStartRow == nEndRow )
1115cdf0e10cSrcweir {
1116cdf0e10cSrcweir // nichts zu tun
1117cdf0e10cSrcweir return sal_True;
1118cdf0e10cSrcweir }
1119cdf0e10cSrcweir
1120cdf0e10cSrcweir if ( pDoc->HasAttrib( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab,
1121cdf0e10cSrcweir HASATTR_MERGED | HASATTR_OVERLAPPED ) )
1122cdf0e10cSrcweir { // "Zusammenfassen nicht verschachteln !"
1123cdf0e10cSrcweir ErrorMessage(STR_MSSG_MERGECELLS_0);
1124cdf0e10cSrcweir return sal_False;
1125cdf0e10cSrcweir }
1126cdf0e10cSrcweir
1127cdf0e10cSrcweir sal_Bool bOk = sal_True;
1128cdf0e10cSrcweir
1129cdf0e10cSrcweir if ( !pDoc->IsBlockEmpty( nStartTab, nStartCol,nStartRow+1, nStartCol,nEndRow, true ) ||
1130cdf0e10cSrcweir !pDoc->IsBlockEmpty( nStartTab, nStartCol+1,nStartRow, nEndCol,nEndRow, true ) )
1131cdf0e10cSrcweir {
1132cdf0e10cSrcweir if (!bApi)
1133cdf0e10cSrcweir {
1134cdf0e10cSrcweir MessBox aBox( GetViewData()->GetDialogParent(),
1135cdf0e10cSrcweir WinBits(WB_YES_NO_CANCEL | WB_DEF_NO),
1136cdf0e10cSrcweir ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ),
1137cdf0e10cSrcweir ScGlobal::GetRscString( STR_MERGE_NOTEMPTY ) );
1138cdf0e10cSrcweir sal_uInt16 nRetVal = aBox.Execute();
1139cdf0e10cSrcweir
1140cdf0e10cSrcweir if ( nRetVal == RET_YES )
1141cdf0e10cSrcweir rDoContents = sal_True;
1142cdf0e10cSrcweir else if ( nRetVal == RET_CANCEL )
1143cdf0e10cSrcweir bOk = sal_False;
1144cdf0e10cSrcweir }
1145cdf0e10cSrcweir }
1146cdf0e10cSrcweir
1147cdf0e10cSrcweir if (bOk)
1148cdf0e10cSrcweir {
1149cdf0e10cSrcweir HideCursor();
1150cdf0e10cSrcweir bOk = pDocSh->GetDocFunc().MergeCells( aMarkRange, rDoContents, bRecord, bApi );
1151cdf0e10cSrcweir ShowCursor();
1152cdf0e10cSrcweir
1153cdf0e10cSrcweir if (bOk)
1154cdf0e10cSrcweir {
1155cdf0e10cSrcweir SetCursor( nStartCol, nStartRow );
1156cdf0e10cSrcweir //DoneBlockMode( sal_False);
1157cdf0e10cSrcweir Unmark();
1158cdf0e10cSrcweir
1159cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1160cdf0e10cSrcweir UpdateInputLine();
1161cdf0e10cSrcweir }
1162cdf0e10cSrcweir }
1163cdf0e10cSrcweir
1164cdf0e10cSrcweir return bOk;
1165cdf0e10cSrcweir }
1166cdf0e10cSrcweir
1167cdf0e10cSrcweir
1168cdf0e10cSrcweir //----------------------------------------------------------------------------
1169cdf0e10cSrcweir
TestRemoveMerge()1170cdf0e10cSrcweir sal_Bool ScViewFunc::TestRemoveMerge()
1171cdf0e10cSrcweir {
1172cdf0e10cSrcweir sal_Bool bMerged = sal_False;
1173cdf0e10cSrcweir ScRange aRange;
1174cdf0e10cSrcweir if (GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE)
1175cdf0e10cSrcweir {
1176cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
1177cdf0e10cSrcweir if ( pDoc->HasAttrib( aRange, HASATTR_MERGED ) )
1178cdf0e10cSrcweir bMerged = sal_True;
1179cdf0e10cSrcweir }
1180cdf0e10cSrcweir return bMerged;
1181cdf0e10cSrcweir }
1182cdf0e10cSrcweir
1183cdf0e10cSrcweir
1184cdf0e10cSrcweir //----------------------------------------------------------------------------
1185cdf0e10cSrcweir
RemoveMerge(sal_Bool bRecord)1186cdf0e10cSrcweir sal_Bool ScViewFunc::RemoveMerge( sal_Bool bRecord )
1187cdf0e10cSrcweir {
1188cdf0e10cSrcweir ScRange aRange;
1189cdf0e10cSrcweir ScEditableTester aTester( this );
1190cdf0e10cSrcweir if (!aTester.IsEditable())
1191cdf0e10cSrcweir {
1192cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
1193cdf0e10cSrcweir return sal_False;
1194cdf0e10cSrcweir }
1195cdf0e10cSrcweir else if (GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE)
1196cdf0e10cSrcweir {
1197cdf0e10cSrcweir ScRange aExtended( aRange );
1198cdf0e10cSrcweir GetViewData()->GetDocument()->ExtendMerge( aExtended );
1199cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1200cdf0e10cSrcweir
1201cdf0e10cSrcweir HideCursor();
1202cdf0e10cSrcweir sal_Bool bOk = pDocSh->GetDocFunc().UnmergeCells( aRange, bRecord, sal_False );
1203cdf0e10cSrcweir MarkRange( aExtended );
1204cdf0e10cSrcweir ShowCursor();
1205cdf0e10cSrcweir
1206cdf0e10cSrcweir if (bOk)
1207cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1208cdf0e10cSrcweir }
1209cdf0e10cSrcweir return sal_True; //! bOk ??
1210cdf0e10cSrcweir }
1211cdf0e10cSrcweir
1212cdf0e10cSrcweir //----------------------------------------------------------------------------
1213cdf0e10cSrcweir
FillSimple(FillDir eDir,sal_Bool bRecord)1214cdf0e10cSrcweir void ScViewFunc::FillSimple( FillDir eDir, sal_Bool bRecord )
1215cdf0e10cSrcweir {
1216cdf0e10cSrcweir ScRange aRange;
1217cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
1218cdf0e10cSrcweir {
1219cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1220cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
1221cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().FillSimple( aRange, &rMark, eDir, bRecord, sal_False );
1222cdf0e10cSrcweir if (bSuccess)
1223cdf0e10cSrcweir {
1224cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1225cdf0e10cSrcweir UpdateScrollBars();
1226cdf0e10cSrcweir }
1227cdf0e10cSrcweir }
1228cdf0e10cSrcweir else
1229cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1230cdf0e10cSrcweir }
1231cdf0e10cSrcweir
1232cdf0e10cSrcweir //----------------------------------------------------------------------------
1233cdf0e10cSrcweir
FillSeries(FillDir eDir,FillCmd eCmd,FillDateCmd eDateCmd,double fStart,double fStep,double fMax,sal_Bool bRecord)1234cdf0e10cSrcweir void ScViewFunc::FillSeries( FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,
1235cdf0e10cSrcweir double fStart, double fStep, double fMax, sal_Bool bRecord )
1236cdf0e10cSrcweir {
1237cdf0e10cSrcweir ScRange aRange;
1238cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
1239cdf0e10cSrcweir {
1240cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1241cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
1242cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().
1243cdf0e10cSrcweir FillSeries( aRange, &rMark, eDir, eCmd, eDateCmd,
1244cdf0e10cSrcweir fStart, fStep, fMax, bRecord, sal_False );
1245cdf0e10cSrcweir if (bSuccess)
1246cdf0e10cSrcweir {
1247cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1248cdf0e10cSrcweir UpdateScrollBars();
1249cdf0e10cSrcweir
1250cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
1251cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
1252cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
1253cdf0e10cSrcweir {
1254cdf0e10cSrcweir ScRangeList aChangeRanges;
1255cdf0e10cSrcweir aChangeRanges.Append( aRange );
1256cdf0e10cSrcweir pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
1257cdf0e10cSrcweir }
1258cdf0e10cSrcweir }
1259cdf0e10cSrcweir }
1260cdf0e10cSrcweir else
1261cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1262cdf0e10cSrcweir }
1263cdf0e10cSrcweir
1264cdf0e10cSrcweir //----------------------------------------------------------------------------
1265cdf0e10cSrcweir
FillAuto(FillDir eDir,SCCOL nStartCol,SCROW nStartRow,SCCOL nEndCol,SCROW nEndRow,sal_uLong nCount,sal_Bool bRecord)1266cdf0e10cSrcweir void ScViewFunc::FillAuto( FillDir eDir, SCCOL nStartCol, SCROW nStartRow,
1267cdf0e10cSrcweir SCCOL nEndCol, SCROW nEndRow, sal_uLong nCount, sal_Bool bRecord )
1268cdf0e10cSrcweir {
1269cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
1270cdf0e10cSrcweir ScRange aRange( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab );
1271cdf0e10cSrcweir ScRange aSourceRange( aRange );
1272cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1273cdf0e10cSrcweir const ScMarkData& rMark = GetViewData()->GetMarkData();
1274cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().
1275cdf0e10cSrcweir FillAuto( aRange, &rMark, eDir, nCount, bRecord, sal_False );
1276cdf0e10cSrcweir if (bSuccess)
1277cdf0e10cSrcweir {
1278cdf0e10cSrcweir MarkRange( aRange, sal_False ); // aRange ist in FillAuto veraendert worden
1279cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1280cdf0e10cSrcweir UpdateScrollBars();
1281cdf0e10cSrcweir
1282cdf0e10cSrcweir // #i97876# Spreadsheet data changes are not notified
1283cdf0e10cSrcweir ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
1284cdf0e10cSrcweir if ( pModelObj && pModelObj->HasChangesListeners() )
1285cdf0e10cSrcweir {
1286cdf0e10cSrcweir ScRangeList aChangeRanges;
1287cdf0e10cSrcweir ScRange aChangeRange( aRange );
1288cdf0e10cSrcweir switch ( eDir )
1289cdf0e10cSrcweir {
1290cdf0e10cSrcweir case FILL_TO_BOTTOM:
1291cdf0e10cSrcweir {
1292cdf0e10cSrcweir aChangeRange.aStart.SetRow( aSourceRange.aEnd.Row() + 1 );
1293cdf0e10cSrcweir }
1294cdf0e10cSrcweir break;
1295cdf0e10cSrcweir case FILL_TO_TOP:
1296cdf0e10cSrcweir {
1297cdf0e10cSrcweir aChangeRange.aEnd.SetRow( aSourceRange.aStart.Row() - 1 );
1298cdf0e10cSrcweir }
1299cdf0e10cSrcweir break;
1300cdf0e10cSrcweir case FILL_TO_RIGHT:
1301cdf0e10cSrcweir {
1302cdf0e10cSrcweir aChangeRange.aStart.SetCol( aSourceRange.aEnd.Col() + 1 );
1303cdf0e10cSrcweir }
1304cdf0e10cSrcweir break;
1305cdf0e10cSrcweir case FILL_TO_LEFT:
1306cdf0e10cSrcweir {
1307cdf0e10cSrcweir aChangeRange.aEnd.SetCol( aSourceRange.aStart.Col() - 1 );
1308cdf0e10cSrcweir }
1309cdf0e10cSrcweir break;
1310cdf0e10cSrcweir default:
1311cdf0e10cSrcweir {
1312cdf0e10cSrcweir
1313cdf0e10cSrcweir }
1314cdf0e10cSrcweir break;
1315cdf0e10cSrcweir }
1316cdf0e10cSrcweir aChangeRanges.Append( aChangeRange );
1317cdf0e10cSrcweir pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
1318cdf0e10cSrcweir }
1319cdf0e10cSrcweir }
1320cdf0e10cSrcweir }
1321cdf0e10cSrcweir
1322cdf0e10cSrcweir //----------------------------------------------------------------------------
1323cdf0e10cSrcweir
FillTab(sal_uInt16 nFlags,sal_uInt16 nFunction,sal_Bool bSkipEmpty,sal_Bool bAsLink)1324cdf0e10cSrcweir void ScViewFunc::FillTab( sal_uInt16 nFlags, sal_uInt16 nFunction, sal_Bool bSkipEmpty, sal_Bool bAsLink )
1325cdf0e10cSrcweir {
1326cdf0e10cSrcweir //! allow source sheet to be protected
1327cdf0e10cSrcweir ScEditableTester aTester( this );
1328cdf0e10cSrcweir if (!aTester.IsEditable())
1329cdf0e10cSrcweir {
1330cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
1331cdf0e10cSrcweir return;
1332cdf0e10cSrcweir }
1333cdf0e10cSrcweir
1334cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1335cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
1336cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
1337cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
1338cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
1339cdf0e10cSrcweir
1340cdf0e10cSrcweir ScRange aMarkRange;
1341cdf0e10cSrcweir rMark.MarkToSimple();
1342cdf0e10cSrcweir sal_Bool bMulti = rMark.IsMultiMarked();
1343cdf0e10cSrcweir if (bMulti)
1344cdf0e10cSrcweir rMark.GetMultiMarkArea( aMarkRange );
1345cdf0e10cSrcweir else if (rMark.IsMarked())
1346cdf0e10cSrcweir rMark.GetMarkArea( aMarkRange );
1347cdf0e10cSrcweir else
1348cdf0e10cSrcweir aMarkRange = ScRange( GetViewData()->GetCurX(), GetViewData()->GetCurY(), nTab );
1349cdf0e10cSrcweir
1350cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
1351cdf0e10cSrcweir // if ( bRecord )
1352cdf0e10cSrcweir if (bUndo)
1353cdf0e10cSrcweir {
1354cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1355cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab, nTab );
1356cdf0e10cSrcweir // pUndoDoc->SelectTable( nTab, sal_True ); // nur fuer Markierung
1357cdf0e10cSrcweir
1358cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
1359cdf0e10cSrcweir for (SCTAB i=0; i<nTabCount; i++)
1360cdf0e10cSrcweir if (i != nTab && rMark.GetTableSelect(i))
1361cdf0e10cSrcweir {
1362cdf0e10cSrcweir pUndoDoc->AddUndoTab( i, i );
1363cdf0e10cSrcweir aMarkRange.aStart.SetTab( i );
1364cdf0e10cSrcweir aMarkRange.aEnd.SetTab( i );
1365cdf0e10cSrcweir pDoc->CopyToDocument( aMarkRange, IDF_ALL, bMulti, pUndoDoc );
1366cdf0e10cSrcweir // pUndoDoc->SelectTable( i, sal_True );
1367cdf0e10cSrcweir }
1368cdf0e10cSrcweir }
1369cdf0e10cSrcweir
1370cdf0e10cSrcweir if (bMulti)
1371cdf0e10cSrcweir pDoc->FillTabMarked( nTab, rMark, nFlags, nFunction, bSkipEmpty, bAsLink );
1372cdf0e10cSrcweir else
1373cdf0e10cSrcweir {
1374cdf0e10cSrcweir aMarkRange.aStart.SetTab( nTab );
1375cdf0e10cSrcweir aMarkRange.aEnd.SetTab( nTab );
1376cdf0e10cSrcweir pDoc->FillTab( aMarkRange, rMark, nFlags, nFunction, bSkipEmpty, bAsLink );
1377cdf0e10cSrcweir }
1378cdf0e10cSrcweir
1379cdf0e10cSrcweir // if ( bRecord )
1380cdf0e10cSrcweir if (bUndo)
1381cdf0e10cSrcweir { //! fuer ChangeTrack erst zum Schluss
1382cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1383cdf0e10cSrcweir new ScUndoFillTable( pDocSh, rMark,
1384cdf0e10cSrcweir aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), nTab,
1385cdf0e10cSrcweir aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(), nTab,
1386cdf0e10cSrcweir pUndoDoc, bMulti, nTab, nFlags, nFunction, bSkipEmpty, bAsLink ) );
1387cdf0e10cSrcweir }
1388cdf0e10cSrcweir
1389cdf0e10cSrcweir pDocSh->PostPaintGridAll();
1390cdf0e10cSrcweir pDocSh->PostDataChanged();
1391cdf0e10cSrcweir }
1392cdf0e10cSrcweir
1393cdf0e10cSrcweir //----------------------------------------------------------------------------
1394cdf0e10cSrcweir
1395cdf0e10cSrcweir /** Downward fill of selected cell(s) by double-clicking cross-hair cursor
1396cdf0e10cSrcweir
1397cdf0e10cSrcweir Extends a current selection down to the last non-empty cell of an adjacent
1398cdf0e10cSrcweir column when the lower-right corner of the selection is double-clicked. It
1399cdf0e10cSrcweir uses a left-adjoining non-empty column as a guide if such is available,
1400cdf0e10cSrcweir otherwise a right-adjoining non-empty column is used.
1401cdf0e10cSrcweir
1402cdf0e10cSrcweir @author Kohei Yoshida (kohei@openoffice.org)
1403cdf0e10cSrcweir
1404cdf0e10cSrcweir @return No return value
1405cdf0e10cSrcweir
1406cdf0e10cSrcweir @see #i12313#
1407cdf0e10cSrcweir */
FillCrossDblClick()1408cdf0e10cSrcweir void ScViewFunc::FillCrossDblClick()
1409cdf0e10cSrcweir {
1410cdf0e10cSrcweir ScRange aRange;
1411cdf0e10cSrcweir GetViewData()->GetSimpleArea( aRange );
1412cdf0e10cSrcweir aRange.Justify();
1413cdf0e10cSrcweir
1414cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetCurPos().Tab();
1415cdf0e10cSrcweir SCCOL nStartX = aRange.aStart.Col();
1416cdf0e10cSrcweir SCROW nStartY = aRange.aStart.Row();
1417cdf0e10cSrcweir SCCOL nEndX = aRange.aEnd.Col();
1418cdf0e10cSrcweir SCROW nEndY = aRange.aEnd.Row();
1419cdf0e10cSrcweir
1420cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
1421cdf0e10cSrcweir
1422cdf0e10cSrcweir // Make sure the selection is not empty
1423cdf0e10cSrcweir if ( pDoc->IsBlockEmpty( nTab, nStartX, nStartY, nEndX, nEndY ) )
1424cdf0e10cSrcweir return;
1425cdf0e10cSrcweir
1426cdf0e10cSrcweir if ( nEndY < MAXROW )
1427cdf0e10cSrcweir {
1428cdf0e10cSrcweir if ( nStartX > 0 )
1429cdf0e10cSrcweir {
1430cdf0e10cSrcweir SCCOL nMovX = nStartX - 1;
1431cdf0e10cSrcweir SCROW nMovY = nStartY;
1432cdf0e10cSrcweir
1433cdf0e10cSrcweir if ( pDoc->HasData( nMovX, nStartY, nTab ) &&
1434cdf0e10cSrcweir pDoc->HasData( nMovX, nStartY + 1, nTab ) )
1435cdf0e10cSrcweir {
1436cdf0e10cSrcweir pDoc->FindAreaPos( nMovX, nMovY, nTab, 0, 1 );
1437cdf0e10cSrcweir
1438cdf0e10cSrcweir if ( nMovY > nEndY )
1439cdf0e10cSrcweir {
1440cdf0e10cSrcweir FillAuto( FILL_TO_BOTTOM, nStartX, nStartY, nEndX, nEndY,
1441cdf0e10cSrcweir nMovY - nEndY );
1442cdf0e10cSrcweir return;
1443cdf0e10cSrcweir }
1444cdf0e10cSrcweir }
1445cdf0e10cSrcweir }
1446cdf0e10cSrcweir
1447cdf0e10cSrcweir if ( nEndX < MAXCOL )
1448cdf0e10cSrcweir {
1449cdf0e10cSrcweir SCCOL nMovX = nEndX + 1;
1450cdf0e10cSrcweir SCROW nMovY = nStartY;
1451cdf0e10cSrcweir
1452cdf0e10cSrcweir if ( pDoc->HasData( nMovX, nStartY, nTab ) &&
1453cdf0e10cSrcweir pDoc->HasData( nMovX, nStartY + 1, nTab ) )
1454cdf0e10cSrcweir {
1455cdf0e10cSrcweir pDoc->FindAreaPos( nMovX, nMovY, nTab, 0, 1 );
1456cdf0e10cSrcweir
1457cdf0e10cSrcweir if ( nMovY > nEndY )
1458cdf0e10cSrcweir {
1459cdf0e10cSrcweir FillAuto( FILL_TO_BOTTOM, nStartX, nStartY, nEndX, nEndY,
1460cdf0e10cSrcweir nMovY - nEndY );
1461cdf0e10cSrcweir return;
1462cdf0e10cSrcweir }
1463cdf0e10cSrcweir }
1464cdf0e10cSrcweir }
1465cdf0e10cSrcweir }
1466cdf0e10cSrcweir }
1467cdf0e10cSrcweir
1468cdf0e10cSrcweir //----------------------------------------------------------------------------
1469cdf0e10cSrcweir
TransliterateText(sal_Int32 nType)1470cdf0e10cSrcweir void ScViewFunc::TransliterateText( sal_Int32 nType )
1471cdf0e10cSrcweir {
1472cdf0e10cSrcweir ScMarkData aFuncMark = GetViewData()->GetMarkData();
1473cdf0e10cSrcweir if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
1474cdf0e10cSrcweir {
1475cdf0e10cSrcweir // no selection -> use cursor position
1476cdf0e10cSrcweir
1477cdf0e10cSrcweir ScAddress aCursor( GetViewData()->GetCurX(), GetViewData()->GetCurY(), GetViewData()->GetTabNo() );
1478cdf0e10cSrcweir aFuncMark.SetMarkArea( ScRange( aCursor ) );
1479cdf0e10cSrcweir }
1480cdf0e10cSrcweir
1481cdf0e10cSrcweir sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().
1482cdf0e10cSrcweir TransliterateText( aFuncMark, nType, sal_True, sal_False );
1483cdf0e10cSrcweir if (bSuccess)
1484cdf0e10cSrcweir {
1485cdf0e10cSrcweir GetViewData()->GetViewShell()->UpdateInputHandler();
1486cdf0e10cSrcweir }
1487cdf0e10cSrcweir }
1488cdf0e10cSrcweir
1489cdf0e10cSrcweir //----------------------------------------------------------------------------
1490cdf0e10cSrcweir // AutoFormat
1491cdf0e10cSrcweir
CreateAutoFormatData()1492cdf0e10cSrcweir ScAutoFormatData* ScViewFunc::CreateAutoFormatData()
1493cdf0e10cSrcweir {
1494cdf0e10cSrcweir ScAutoFormatData* pData = NULL;
1495cdf0e10cSrcweir SCCOL nStartCol;
1496cdf0e10cSrcweir SCROW nStartRow;
1497cdf0e10cSrcweir SCTAB nStartTab;
1498cdf0e10cSrcweir SCCOL nEndCol;
1499cdf0e10cSrcweir SCROW nEndRow;
1500cdf0e10cSrcweir SCTAB nEndTab;
1501cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
1502cdf0e10cSrcweir {
1503cdf0e10cSrcweir if ( nEndCol-nStartCol >= 3 && nEndRow-nStartRow >= 3 )
1504cdf0e10cSrcweir {
1505cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
1506cdf0e10cSrcweir pData = new ScAutoFormatData;
1507cdf0e10cSrcweir pDoc->GetAutoFormatData( nStartTab, nStartCol,nStartRow,nEndCol,nEndRow, *pData );
1508cdf0e10cSrcweir }
1509cdf0e10cSrcweir }
1510cdf0e10cSrcweir return pData;
1511cdf0e10cSrcweir }
1512cdf0e10cSrcweir
1513cdf0e10cSrcweir
1514cdf0e10cSrcweir //----------------------------------------------------------------------------
1515cdf0e10cSrcweir
AutoFormat(sal_uInt16 nFormatNo,sal_Bool bRecord)1516cdf0e10cSrcweir void ScViewFunc::AutoFormat( sal_uInt16 nFormatNo, sal_Bool bRecord )
1517cdf0e10cSrcweir {
1518cdf0e10cSrcweir #if 1
1519cdf0e10cSrcweir
1520cdf0e10cSrcweir ScRange aRange;
1521cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
1522cdf0e10cSrcweir {
1523cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1524cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
1525cdf0e10cSrcweir
1526cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().AutoFormat( aRange, &rMark, nFormatNo, bRecord, sal_False );
1527cdf0e10cSrcweir if (bSuccess)
1528cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1529cdf0e10cSrcweir }
1530cdf0e10cSrcweir else
1531cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1532cdf0e10cSrcweir
1533cdf0e10cSrcweir #else
1534cdf0e10cSrcweir
1535cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
1536cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
1537cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
1538cdf0e10cSrcweir {
1539cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
1540cdf0e10cSrcweir return;
1541cdf0e10cSrcweir }
1542cdf0e10cSrcweir
1543cdf0e10cSrcweir SCCOL nStartCol;
1544cdf0e10cSrcweir SCROW nStartRow;
1545cdf0e10cSrcweir SCTAB nStartTab;
1546cdf0e10cSrcweir SCCOL nEndCol;
1547cdf0e10cSrcweir SCROW nEndRow;
1548cdf0e10cSrcweir SCTAB nEndTab;
1549cdf0e10cSrcweir
1550cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
1551cdf0e10cSrcweir {
1552cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1553cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
1554cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
1555cdf0e10cSrcweir sal_Bool bSize = (*ScGlobal::GetAutoFormat())[nFormatNo]->GetIncludeWidthHeight();
1556cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
1557cdf0e10cSrcweir bRecord = sal_False;
1558cdf0e10cSrcweir
1559cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
1560cdf0e10cSrcweir if ( bRecord )
1561cdf0e10cSrcweir {
1562cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1563cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab, bSize, bSize );
1564cdf0e10cSrcweir pDoc->CopyToDocument( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab,
1565cdf0e10cSrcweir IDF_ATTRIB, sal_False, pUndoDoc );
1566cdf0e10cSrcweir if (bSize)
1567cdf0e10cSrcweir {
1568cdf0e10cSrcweir pDoc->CopyToDocument( nStartCol,0,nStartTab, nEndCol,MAXROW,nEndTab,
1569cdf0e10cSrcweir IDF_NONE, sal_False, pUndoDoc );
1570cdf0e10cSrcweir pDoc->CopyToDocument( 0,nStartRow,nStartTab, MAXCOL,nEndRow,nEndTab,
1571cdf0e10cSrcweir IDF_NONE, sal_False, pUndoDoc );
1572cdf0e10cSrcweir }
1573cdf0e10cSrcweir pDoc->BeginDrawUndo();
1574cdf0e10cSrcweir }
1575cdf0e10cSrcweir
1576cdf0e10cSrcweir GetFrameWin()->EnterWait();
1577cdf0e10cSrcweir pDoc->AutoFormat( nStartCol, nStartRow, nEndCol, nEndRow, nFormatNo, rMark );
1578cdf0e10cSrcweir GetFrameWin()->LeaveWait();
1579cdf0e10cSrcweir
1580cdf0e10cSrcweir if (bSize)
1581cdf0e10cSrcweir {
1582cdf0e10cSrcweir SetMarkedWidthOrHeight( sal_True, SC_SIZE_VISOPT, STD_EXTRA_WIDTH, sal_False, sal_False );
1583cdf0e10cSrcweir SetMarkedWidthOrHeight( sal_False, SC_SIZE_VISOPT, 0, sal_False, sal_False );
1584cdf0e10cSrcweir pDocSh->PostPaint( 0,0,nStartTab, MAXCOL,MAXROW,nStartTab,
1585cdf0e10cSrcweir PAINT_GRID | PAINT_LEFT | PAINT_TOP );
1586cdf0e10cSrcweir }
1587cdf0e10cSrcweir else
1588cdf0e10cSrcweir {
1589cdf0e10cSrcweir sal_Bool bAdj = AdjustBlockHeight( sal_False );
1590cdf0e10cSrcweir if (bAdj)
1591cdf0e10cSrcweir pDocSh->PostPaint( 0,nStartRow,nStartTab, MAXCOL,MAXROW,nStartTab,
1592cdf0e10cSrcweir PAINT_GRID | PAINT_LEFT );
1593cdf0e10cSrcweir else
1594cdf0e10cSrcweir pDocSh->PostPaint( nStartCol, nStartRow, nStartTab,
1595cdf0e10cSrcweir nEndCol, nEndRow, nEndTab, PAINT_GRID );
1596cdf0e10cSrcweir }
1597cdf0e10cSrcweir
1598cdf0e10cSrcweir if ( bRecord ) // Draw-Undo erst jetzt verfuegbar
1599cdf0e10cSrcweir {
1600cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
1601cdf0e10cSrcweir new ScUndoAutoFormat( pDocSh,
1602cdf0e10cSrcweir ScRange(nStartCol,nStartRow,nStartTab, nEndCol,nEndRow,nEndTab),
1603cdf0e10cSrcweir pUndoDoc, rMark, bSize, nFormatNo ) );
1604cdf0e10cSrcweir }
1605cdf0e10cSrcweir
1606cdf0e10cSrcweir pDocSh->UpdateOle(GetViewData());
1607cdf0e10cSrcweir pDocSh->SetDocumentModified();
1608cdf0e10cSrcweir }
1609cdf0e10cSrcweir else
1610cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1611cdf0e10cSrcweir
1612cdf0e10cSrcweir #endif
1613cdf0e10cSrcweir }
1614cdf0e10cSrcweir
1615cdf0e10cSrcweir
1616cdf0e10cSrcweir //----------------------------------------------------------------------------
1617cdf0e10cSrcweir // Suchen & Ersetzen
1618cdf0e10cSrcweir
SearchAndReplace(const SvxSearchItem * pSearchItem,sal_Bool bAddUndo,sal_Bool bIsApi)1619*0deba7fbSSteve Yin sal_Bool ScViewFunc::SearchAndReplace( const SvxSearchItem* pSearchItem,
1620cdf0e10cSrcweir sal_Bool bAddUndo, sal_Bool bIsApi )
1621cdf0e10cSrcweir {
1622cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1623cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
1624cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
1625cdf0e10cSrcweir if (bAddUndo && !pDoc->IsUndoEnabled())
1626cdf0e10cSrcweir bAddUndo = sal_False;
1627cdf0e10cSrcweir
1628cdf0e10cSrcweir SCCOL nCol = GetViewData()->GetCurX();
1629cdf0e10cSrcweir SCROW nRow = GetViewData()->GetCurY();
1630cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
1631cdf0e10cSrcweir // sal_Bool bAttrib = pSearchItem->GetPattern();
1632cdf0e10cSrcweir sal_uInt16 nCommand = pSearchItem->GetCommand();
1633cdf0e10cSrcweir sal_Bool bAllTables = pSearchItem->IsAllTables();
1634cdf0e10cSrcweir sal_Bool* pOldSelectedTables = NULL;
1635cdf0e10cSrcweir sal_uInt16 nOldSelectedCount = 0;
1636cdf0e10cSrcweir SCTAB nOldTab = nTab;
1637cdf0e10cSrcweir SCTAB nLastTab = pDoc->GetTableCount() - 1;
1638cdf0e10cSrcweir SCTAB nStartTab, nEndTab;
1639cdf0e10cSrcweir if ( bAllTables )
1640cdf0e10cSrcweir {
1641cdf0e10cSrcweir nStartTab = 0;
1642cdf0e10cSrcweir nEndTab = nLastTab;
1643cdf0e10cSrcweir pOldSelectedTables = new sal_Bool [ nEndTab + 1 ];
1644cdf0e10cSrcweir for ( SCTAB j = 0; j <= nEndTab; j++ )
1645cdf0e10cSrcweir {
1646cdf0e10cSrcweir pOldSelectedTables[j] = rMark.GetTableSelect( j );
1647cdf0e10cSrcweir if ( pOldSelectedTables[j] )
1648cdf0e10cSrcweir ++nOldSelectedCount;
1649cdf0e10cSrcweir }
1650cdf0e10cSrcweir }
1651cdf0e10cSrcweir else
1652cdf0e10cSrcweir { //! mindestens eine ist immer selektiert
1653cdf0e10cSrcweir nStartTab = nEndTab = rMark.GetFirstSelected();
1654cdf0e10cSrcweir for ( SCTAB j = nStartTab + 1; j <= nLastTab; j++ )
1655cdf0e10cSrcweir {
1656cdf0e10cSrcweir if ( rMark.GetTableSelect( j ) )
1657cdf0e10cSrcweir nEndTab = j;
1658cdf0e10cSrcweir }
1659cdf0e10cSrcweir }
1660cdf0e10cSrcweir
1661cdf0e10cSrcweir if ( nCommand == SVX_SEARCHCMD_REPLACE
1662cdf0e10cSrcweir || nCommand == SVX_SEARCHCMD_REPLACE_ALL )
1663cdf0e10cSrcweir {
1664cdf0e10cSrcweir for ( SCTAB j = nStartTab; j <= nEndTab; j++ )
1665cdf0e10cSrcweir {
1666cdf0e10cSrcweir if ( (bAllTables || rMark.GetTableSelect( j )) &&
1667cdf0e10cSrcweir pDoc->IsTabProtected( j ) )
1668cdf0e10cSrcweir {
1669cdf0e10cSrcweir if ( pOldSelectedTables )
1670cdf0e10cSrcweir delete [] pOldSelectedTables;
1671cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
1672*0deba7fbSSteve Yin return sal_False;
1673cdf0e10cSrcweir }
1674cdf0e10cSrcweir }
1675cdf0e10cSrcweir }
1676cdf0e10cSrcweir
1677cdf0e10cSrcweir if ( nCommand == SVX_SEARCHCMD_FIND
1678cdf0e10cSrcweir || nCommand == SVX_SEARCHCMD_FIND_ALL)
1679cdf0e10cSrcweir bAddUndo = sal_False;
1680cdf0e10cSrcweir
1681cdf0e10cSrcweir //! bAttrib bei Undo beruecksichtigen !!!
1682cdf0e10cSrcweir
1683cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
1684cdf0e10cSrcweir ScMarkData* pUndoMark = NULL;
1685cdf0e10cSrcweir String aUndoStr;
1686cdf0e10cSrcweir if (bAddUndo)
1687cdf0e10cSrcweir {
1688cdf0e10cSrcweir pUndoMark = new ScMarkData( rMark ); // Markierung wird veraendert
1689cdf0e10cSrcweir if ( nCommand == SVX_SEARCHCMD_REPLACE_ALL )
1690cdf0e10cSrcweir {
1691cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1692cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nStartTab, nEndTab );
1693cdf0e10cSrcweir }
1694cdf0e10cSrcweir }
1695cdf0e10cSrcweir
1696cdf0e10cSrcweir if ( bAllTables )
1697cdf0e10cSrcweir { //! alles selektieren, erst nachdem pUndoMark erzeugt wurde
1698cdf0e10cSrcweir for ( SCTAB j = nStartTab; j <= nEndTab; j++ )
1699cdf0e10cSrcweir {
1700cdf0e10cSrcweir rMark.SelectTable( j, sal_True );
1701cdf0e10cSrcweir }
1702cdf0e10cSrcweir }
1703cdf0e10cSrcweir
1704cdf0e10cSrcweir DoneBlockMode(sal_True); // Markierung nicht loeschen!
1705cdf0e10cSrcweir InitOwnBlockMode();
1706cdf0e10cSrcweir
1707cdf0e10cSrcweir // wenn vom Anfang an gesucht wird, nicht nochmal fragen ob vom Anfang gesucht werden soll
1708cdf0e10cSrcweir sal_Bool bFirst = sal_True;
1709cdf0e10cSrcweir if ( nCol == 0 && nRow == 0 && nTab == nStartTab && !pSearchItem->GetBackward() )
1710cdf0e10cSrcweir bFirst = sal_False;
1711cdf0e10cSrcweir
1712cdf0e10cSrcweir sal_Bool bFound = sal_False;
1713cdf0e10cSrcweir while (sal_True)
1714cdf0e10cSrcweir {
1715cdf0e10cSrcweir GetFrameWin()->EnterWait();
1716cdf0e10cSrcweir if (pDoc->SearchAndReplace( *pSearchItem, nCol, nRow, nTab, rMark, aUndoStr, pUndoDoc ) )
1717cdf0e10cSrcweir {
1718cdf0e10cSrcweir bFound = sal_True;
1719cdf0e10cSrcweir bFirst = sal_True;
1720cdf0e10cSrcweir if (bAddUndo)
1721cdf0e10cSrcweir {
1722cdf0e10cSrcweir GetViewData()->GetDocShell()->GetUndoManager()->AddUndoAction(
1723cdf0e10cSrcweir new ScUndoReplace( GetViewData()->GetDocShell(), *pUndoMark,
1724cdf0e10cSrcweir nCol, nRow, nTab,
1725cdf0e10cSrcweir aUndoStr, pUndoDoc, pSearchItem ) );
1726cdf0e10cSrcweir pUndoDoc = NULL;
1727cdf0e10cSrcweir }
1728cdf0e10cSrcweir
1729cdf0e10cSrcweir break; // Abbruch while True
1730cdf0e10cSrcweir }
1731cdf0e10cSrcweir else if ( bFirst && (nCommand == SVX_SEARCHCMD_FIND ||
1732cdf0e10cSrcweir nCommand == SVX_SEARCHCMD_REPLACE) )
1733cdf0e10cSrcweir {
1734cdf0e10cSrcweir bFirst = sal_False;
1735cdf0e10cSrcweir sal_uInt16 nRetVal;
1736cdf0e10cSrcweir GetFrameWin()->LeaveWait();
1737cdf0e10cSrcweir if ( bIsApi )
1738cdf0e10cSrcweir nRetVal = RET_NO;
1739cdf0e10cSrcweir else
1740cdf0e10cSrcweir {
1741cdf0e10cSrcweir // Suchen-Dialog als Parent, wenn vorhanden
1742cdf0e10cSrcweir Window* pParent = GetParentOrChild(SID_SEARCH_DLG);
1743cdf0e10cSrcweir sal_uInt16 nStrId;
1744cdf0e10cSrcweir if ( pSearchItem->GetBackward() )
1745cdf0e10cSrcweir {
1746cdf0e10cSrcweir if ( nStartTab == nEndTab )
1747cdf0e10cSrcweir nStrId = STR_MSSG_SEARCHANDREPLACE_1;
1748cdf0e10cSrcweir else
1749cdf0e10cSrcweir nStrId = STR_MSSG_SEARCHANDREPLACE_4;
1750cdf0e10cSrcweir }
1751cdf0e10cSrcweir else
1752cdf0e10cSrcweir {
1753cdf0e10cSrcweir if ( nStartTab == nEndTab )
1754cdf0e10cSrcweir nStrId = STR_MSSG_SEARCHANDREPLACE_2;
1755cdf0e10cSrcweir else
1756cdf0e10cSrcweir nStrId = STR_MSSG_SEARCHANDREPLACE_5;
1757cdf0e10cSrcweir }
1758cdf0e10cSrcweir MessBox aBox( pParent, WinBits(WB_YES_NO | WB_DEF_YES),
1759cdf0e10cSrcweir ScGlobal::GetRscString( STR_MSSG_SEARCHANDREPLACE_3 ),
1760cdf0e10cSrcweir ScGlobal::GetRscString( nStrId ) );
1761cdf0e10cSrcweir nRetVal = aBox.Execute();
1762cdf0e10cSrcweir }
1763cdf0e10cSrcweir
1764cdf0e10cSrcweir if ( nRetVal == RET_YES )
1765cdf0e10cSrcweir {
1766cdf0e10cSrcweir ScDocument::GetSearchAndReplaceStart( *pSearchItem, nCol, nRow );
1767cdf0e10cSrcweir if (pSearchItem->GetBackward())
1768cdf0e10cSrcweir nTab = nEndTab;
1769cdf0e10cSrcweir else
1770cdf0e10cSrcweir nTab = nStartTab;
1771cdf0e10cSrcweir }
1772cdf0e10cSrcweir else
1773cdf0e10cSrcweir {
1774cdf0e10cSrcweir break; // Abbruch while True
1775cdf0e10cSrcweir }
1776cdf0e10cSrcweir }
1777cdf0e10cSrcweir else // nichts gefunden
1778cdf0e10cSrcweir {
1779cdf0e10cSrcweir if ( nCommand == SVX_SEARCHCMD_FIND_ALL || nCommand == SVX_SEARCHCMD_REPLACE_ALL )
1780cdf0e10cSrcweir {
1781cdf0e10cSrcweir pDocSh->PostPaintGridAll(); // Markierung
1782cdf0e10cSrcweir }
1783cdf0e10cSrcweir
1784cdf0e10cSrcweir GetFrameWin()->LeaveWait();
1785cdf0e10cSrcweir if (!bIsApi)
1786cdf0e10cSrcweir {
1787cdf0e10cSrcweir // Suchen-Dialog als Parent, wenn vorhanden
1788cdf0e10cSrcweir Window* pParent = GetParentOrChild(SID_SEARCH_DLG);
1789cdf0e10cSrcweir // "nichts gefunden"
1790cdf0e10cSrcweir InfoBox aBox( pParent, ScGlobal::GetRscString( STR_MSSG_SEARCHANDREPLACE_0 ) );
1791cdf0e10cSrcweir aBox.Execute();
1792cdf0e10cSrcweir }
1793cdf0e10cSrcweir
1794cdf0e10cSrcweir break; // Abbruch while True
1795cdf0e10cSrcweir }
1796cdf0e10cSrcweir } // of while sal_True
1797cdf0e10cSrcweir
1798cdf0e10cSrcweir if ( pOldSelectedTables )
1799cdf0e10cSrcweir { // urspruenglich selektierte Tabellen wiederherstellen
1800cdf0e10cSrcweir for ( SCTAB j = nStartTab; j <= nEndTab; j++ )
1801cdf0e10cSrcweir {
1802cdf0e10cSrcweir rMark.SelectTable( j, pOldSelectedTables[j] );
1803cdf0e10cSrcweir }
1804cdf0e10cSrcweir if ( bFound )
1805cdf0e10cSrcweir { // durch Fundstelle neu selektierte Tabelle bleibt
1806cdf0e10cSrcweir rMark.SelectTable( nTab, sal_True );
1807cdf0e10cSrcweir // wenn vorher nur eine selektiert war, ist es ein Tausch
1808cdf0e10cSrcweir //! wenn nicht, ist jetzt evtl. eine mehr selektiert
1809cdf0e10cSrcweir if ( nOldSelectedCount == 1 && nTab != nOldTab )
1810cdf0e10cSrcweir rMark.SelectTable( nOldTab, sal_False );
1811cdf0e10cSrcweir }
1812cdf0e10cSrcweir delete [] pOldSelectedTables;
1813cdf0e10cSrcweir }
1814cdf0e10cSrcweir
1815cdf0e10cSrcweir MarkDataChanged();
1816cdf0e10cSrcweir
1817cdf0e10cSrcweir if ( bFound )
1818cdf0e10cSrcweir {
1819cdf0e10cSrcweir if ( nTab != GetViewData()->GetTabNo() )
1820cdf0e10cSrcweir SetTabNo( nTab );
1821cdf0e10cSrcweir
1822cdf0e10cSrcweir // wenn nichts markiert ist, DoneBlockMode, damit von hier aus
1823cdf0e10cSrcweir // direkt per Shift-Cursor markiert werden kann:
1824cdf0e10cSrcweir if (!rMark.IsMarked() && !rMark.IsMultiMarked())
1825cdf0e10cSrcweir DoneBlockMode(sal_True);
1826cdf0e10cSrcweir
1827cdf0e10cSrcweir AlignToCursor( nCol, nRow, SC_FOLLOW_JUMP );
1828cdf0e10cSrcweir SetCursor( nCol, nRow, sal_True );
1829cdf0e10cSrcweir
1830cdf0e10cSrcweir if ( nCommand == SVX_SEARCHCMD_REPLACE
1831cdf0e10cSrcweir || nCommand == SVX_SEARCHCMD_REPLACE_ALL )
1832cdf0e10cSrcweir {
1833cdf0e10cSrcweir if ( nCommand == SVX_SEARCHCMD_REPLACE )
1834cdf0e10cSrcweir pDocSh->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID );
1835cdf0e10cSrcweir else
1836cdf0e10cSrcweir pDocSh->PostPaintGridAll();
1837cdf0e10cSrcweir pDocSh->SetDocumentModified();
1838cdf0e10cSrcweir }
1839cdf0e10cSrcweir else if ( nCommand == SVX_SEARCHCMD_FIND_ALL )
1840cdf0e10cSrcweir pDocSh->PostPaintGridAll(); // Markierung
1841cdf0e10cSrcweir GetFrameWin()->LeaveWait();
1842cdf0e10cSrcweir }
1843cdf0e10cSrcweir
1844cdf0e10cSrcweir delete pUndoDoc; // loeschen wenn nicht benutzt
1845cdf0e10cSrcweir delete pUndoMark; // kann immer geloescht werden
1846*0deba7fbSSteve Yin return bFound;
1847cdf0e10cSrcweir }
1848cdf0e10cSrcweir
1849cdf0e10cSrcweir
1850cdf0e10cSrcweir //----------------------------------------------------------------------------
1851cdf0e10cSrcweir // Zielwertsuche
1852cdf0e10cSrcweir
Solve(const ScSolveParam & rParam)1853cdf0e10cSrcweir void ScViewFunc::Solve( const ScSolveParam& rParam )
1854cdf0e10cSrcweir {
1855cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
1856cdf0e10cSrcweir
1857cdf0e10cSrcweir SCCOL nDestCol = rParam.aRefVariableCell.Col();
1858cdf0e10cSrcweir SCROW nDestRow = rParam.aRefVariableCell.Row();
1859cdf0e10cSrcweir SCTAB nDestTab = rParam.aRefVariableCell.Tab();
1860cdf0e10cSrcweir
1861cdf0e10cSrcweir ScEditableTester aTester( pDoc, nDestTab, nDestCol,nDestRow, nDestCol,nDestRow );
1862cdf0e10cSrcweir if (!aTester.IsEditable())
1863cdf0e10cSrcweir {
1864cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
1865cdf0e10cSrcweir return;
1866cdf0e10cSrcweir }
1867cdf0e10cSrcweir
1868cdf0e10cSrcweir if ( pDoc )
1869cdf0e10cSrcweir {
1870cdf0e10cSrcweir String aTargetValStr;
1871cdf0e10cSrcweir if ( rParam.pStrTargetVal != NULL )
1872cdf0e10cSrcweir aTargetValStr = *(rParam.pStrTargetVal);
1873cdf0e10cSrcweir
1874cdf0e10cSrcweir String aMsgStr;
1875cdf0e10cSrcweir String aResStr;
1876cdf0e10cSrcweir double nSolveResult;
1877cdf0e10cSrcweir
1878cdf0e10cSrcweir GetFrameWin()->EnterWait();
1879cdf0e10cSrcweir
1880cdf0e10cSrcweir sal_Bool bExact =
1881cdf0e10cSrcweir pDoc->Solver(
1882cdf0e10cSrcweir rParam.aRefFormulaCell.Col(),
1883cdf0e10cSrcweir rParam.aRefFormulaCell.Row(),
1884cdf0e10cSrcweir rParam.aRefFormulaCell.Tab(),
1885cdf0e10cSrcweir nDestCol, nDestRow, nDestTab,
1886cdf0e10cSrcweir aTargetValStr,
1887cdf0e10cSrcweir nSolveResult );
1888cdf0e10cSrcweir
1889cdf0e10cSrcweir GetFrameWin()->LeaveWait();
1890cdf0e10cSrcweir
1891cdf0e10cSrcweir SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
1892cdf0e10cSrcweir sal_uLong nFormat = 0;
1893cdf0e10cSrcweir const ScPatternAttr* pPattern = pDoc->GetPattern( nDestCol, nDestRow, nDestTab );
1894cdf0e10cSrcweir if ( pPattern )
1895cdf0e10cSrcweir nFormat = pPattern->GetNumberFormat( pFormatter );
1896cdf0e10cSrcweir Color* p;
1897cdf0e10cSrcweir pFormatter->GetOutputString( nSolveResult, nFormat, aResStr, &p );
1898cdf0e10cSrcweir
1899cdf0e10cSrcweir if ( bExact )
1900cdf0e10cSrcweir {
1901cdf0e10cSrcweir aMsgStr = ScGlobal::GetRscString( STR_MSSG_SOLVE_0 );
1902cdf0e10cSrcweir aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_1 );
1903cdf0e10cSrcweir aMsgStr += String( aResStr );
1904cdf0e10cSrcweir aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_2 );
1905cdf0e10cSrcweir }
1906cdf0e10cSrcweir else
1907cdf0e10cSrcweir {
1908cdf0e10cSrcweir aMsgStr = ScGlobal::GetRscString( STR_MSSG_SOLVE_3 );
1909cdf0e10cSrcweir aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_4 );
1910cdf0e10cSrcweir aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_5 );
1911cdf0e10cSrcweir aMsgStr += String( aResStr );
1912cdf0e10cSrcweir aMsgStr += ScGlobal::GetRscString( STR_MSSG_SOLVE_6 );
1913cdf0e10cSrcweir }
1914cdf0e10cSrcweir
1915cdf0e10cSrcweir MessBox aBox( GetViewData()->GetDialogParent(),
1916cdf0e10cSrcweir WinBits(WB_YES_NO | WB_DEF_NO),
1917cdf0e10cSrcweir ScGlobal::GetRscString( STR_MSSG_DOSUBTOTALS_0 ), aMsgStr );
1918cdf0e10cSrcweir sal_uInt16 nRetVal = aBox.Execute();
1919cdf0e10cSrcweir
1920cdf0e10cSrcweir if ( RET_YES == nRetVal )
1921cdf0e10cSrcweir EnterValue( nDestCol, nDestRow, nDestTab, nSolveResult );
1922cdf0e10cSrcweir
1923cdf0e10cSrcweir GetViewData()->GetViewShell()->UpdateInputHandler( sal_True );
1924cdf0e10cSrcweir }
1925cdf0e10cSrcweir }
1926cdf0e10cSrcweir
1927cdf0e10cSrcweir
1928cdf0e10cSrcweir //----------------------------------------------------------------------------
1929cdf0e10cSrcweir // Mehrfachoperation
1930cdf0e10cSrcweir
TabOp(const ScTabOpParam & rParam,sal_Bool bRecord)1931cdf0e10cSrcweir void ScViewFunc::TabOp( const ScTabOpParam& rParam, sal_Bool bRecord )
1932cdf0e10cSrcweir {
1933cdf0e10cSrcweir ScRange aRange;
1934cdf0e10cSrcweir if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
1935cdf0e10cSrcweir {
1936cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1937cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
1938cdf0e10cSrcweir pDocSh->GetDocFunc().TabOp( aRange, &rMark, rParam, bRecord, sal_False );
1939cdf0e10cSrcweir }
1940cdf0e10cSrcweir else
1941cdf0e10cSrcweir ErrorMessage(STR_NOMULTISELECT);
1942cdf0e10cSrcweir }
1943cdf0e10cSrcweir
1944cdf0e10cSrcweir
1945cdf0e10cSrcweir //----------------------------------------------------------------------------
1946cdf0e10cSrcweir
MakeScenario(const String & rName,const String & rComment,const Color & rColor,sal_uInt16 nFlags)1947cdf0e10cSrcweir void ScViewFunc::MakeScenario( const String& rName, const String& rComment,
1948cdf0e10cSrcweir const Color& rColor, sal_uInt16 nFlags )
1949cdf0e10cSrcweir {
1950cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1951cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
1952cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
1953cdf0e10cSrcweir
1954cdf0e10cSrcweir SCTAB nNewTab = pDocSh->MakeScenario( nTab, rName, rComment, rColor, nFlags, rMark );
1955cdf0e10cSrcweir if (nFlags & SC_SCENARIO_COPYALL)
1956cdf0e10cSrcweir SetTabNo( nNewTab, sal_True ); // SC_SCENARIO_COPYALL -> sichtbar
1957cdf0e10cSrcweir else
1958cdf0e10cSrcweir {
1959cdf0e10cSrcweir SfxBindings& rBindings = GetViewData()->GetBindings();
1960cdf0e10cSrcweir rBindings.Invalidate( SID_STATUS_DOCPOS ); // Statusbar
1961cdf0e10cSrcweir rBindings.Invalidate( SID_TABLES_COUNT );
1962cdf0e10cSrcweir rBindings.Invalidate( SID_SELECT_SCENARIO );
1963cdf0e10cSrcweir rBindings.Invalidate( FID_TABLE_SHOW );
1964cdf0e10cSrcweir }
1965cdf0e10cSrcweir }
1966cdf0e10cSrcweir
1967cdf0e10cSrcweir
1968cdf0e10cSrcweir //----------------------------------------------------------------------------
1969cdf0e10cSrcweir
ExtendScenario()1970cdf0e10cSrcweir void ScViewFunc::ExtendScenario()
1971cdf0e10cSrcweir {
1972cdf0e10cSrcweir ScEditableTester aTester( this );
1973cdf0e10cSrcweir if (!aTester.IsEditable())
1974cdf0e10cSrcweir {
1975cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
1976cdf0e10cSrcweir return;
1977cdf0e10cSrcweir }
1978cdf0e10cSrcweir
1979cdf0e10cSrcweir // Undo: Attribute anwenden
1980cdf0e10cSrcweir
1981cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
1982cdf0e10cSrcweir ScPatternAttr aPattern( pDoc->GetPool() );
1983cdf0e10cSrcweir aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) );
1984cdf0e10cSrcweir aPattern.GetItemSet().Put( ScProtectionAttr( sal_True ) );
1985cdf0e10cSrcweir ApplySelectionPattern(aPattern);
1986cdf0e10cSrcweir }
1987cdf0e10cSrcweir
1988cdf0e10cSrcweir
1989cdf0e10cSrcweir //----------------------------------------------------------------------------
1990cdf0e10cSrcweir
UseScenario(const String & rName)1991cdf0e10cSrcweir void ScViewFunc::UseScenario( const String& rName )
1992cdf0e10cSrcweir {
1993cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
1994cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
1995cdf0e10cSrcweir
1996cdf0e10cSrcweir DoneBlockMode();
1997cdf0e10cSrcweir InitOwnBlockMode();
1998cdf0e10cSrcweir pDocSh->UseScenario( nTab, rName );
1999cdf0e10cSrcweir }
2000cdf0e10cSrcweir
2001cdf0e10cSrcweir
2002cdf0e10cSrcweir //----------------------------------------------------------------------------
2003cdf0e10cSrcweir // Tabelle einfuegen
2004cdf0e10cSrcweir
InsertTable(const String & rName,SCTAB nTab,sal_Bool bRecord)2005cdf0e10cSrcweir sal_Bool ScViewFunc::InsertTable( const String& rName, SCTAB nTab, sal_Bool bRecord )
2006cdf0e10cSrcweir {
2007cdf0e10cSrcweir // Reihenfolge Tabelle/Name ist bei DocFunc umgekehrt
2008cdf0e10cSrcweir sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().
2009cdf0e10cSrcweir InsertTable( nTab, rName, bRecord, sal_False );
2010cdf0e10cSrcweir if (bSuccess)
2011cdf0e10cSrcweir SetTabNo( nTab, sal_True );
2012cdf0e10cSrcweir
2013cdf0e10cSrcweir return bSuccess;
2014cdf0e10cSrcweir }
2015cdf0e10cSrcweir
2016cdf0e10cSrcweir //----------------------------------------------------------------------------
2017cdf0e10cSrcweir // Tabellen einfuegen
2018cdf0e10cSrcweir
InsertTables(SvStrings * pNames,SCTAB nTab,SCTAB nCount,sal_Bool bRecord)2019cdf0e10cSrcweir sal_Bool ScViewFunc::InsertTables(SvStrings *pNames, SCTAB nTab,
2020cdf0e10cSrcweir SCTAB nCount, sal_Bool bRecord )
2021cdf0e10cSrcweir {
2022cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2023cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2024cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2025cdf0e10cSrcweir bRecord = sal_False;
2026cdf0e10cSrcweir
2027cdf0e10cSrcweir SvStrings *pNameList= NULL;
2028cdf0e10cSrcweir
2029cdf0e10cSrcweir WaitObject aWait( GetFrameWin() );
2030cdf0e10cSrcweir
2031cdf0e10cSrcweir if (bRecord)
2032cdf0e10cSrcweir {
2033cdf0e10cSrcweir pNameList= new SvStrings;
2034cdf0e10cSrcweir pDoc->BeginDrawUndo(); // InsertTab erzeugt ein SdrUndoNewPage
2035cdf0e10cSrcweir }
2036cdf0e10cSrcweir
2037cdf0e10cSrcweir sal_Bool bFlag=sal_False;
2038cdf0e10cSrcweir
2039cdf0e10cSrcweir String aValTabName;
2040cdf0e10cSrcweir String *pStr;
2041cdf0e10cSrcweir
2042cdf0e10cSrcweir for(SCTAB i=0;i<nCount;i++)
2043cdf0e10cSrcweir {
2044cdf0e10cSrcweir if(pNames!=NULL)
2045cdf0e10cSrcweir {
2046cdf0e10cSrcweir pStr=pNames->GetObject(static_cast<sal_uInt16>(i));
2047cdf0e10cSrcweir }
2048cdf0e10cSrcweir else
2049cdf0e10cSrcweir {
2050cdf0e10cSrcweir aValTabName.Erase();
2051cdf0e10cSrcweir pDoc->CreateValidTabName( aValTabName);
2052cdf0e10cSrcweir pStr=&aValTabName;
2053cdf0e10cSrcweir }
2054cdf0e10cSrcweir
2055cdf0e10cSrcweir if(pDoc->InsertTab( nTab+i,*pStr))
2056cdf0e10cSrcweir {
2057cdf0e10cSrcweir bFlag=sal_True;
2058cdf0e10cSrcweir pDocSh->Broadcast( ScTablesHint( SC_TAB_INSERTED, nTab+i ) );
2059cdf0e10cSrcweir }
2060cdf0e10cSrcweir else
2061cdf0e10cSrcweir {
2062cdf0e10cSrcweir break;
2063cdf0e10cSrcweir }
2064cdf0e10cSrcweir
2065cdf0e10cSrcweir if(pNameList!=NULL)
2066cdf0e10cSrcweir pNameList->Insert(new String(*pStr),pNameList->Count());
2067cdf0e10cSrcweir
2068cdf0e10cSrcweir }
2069cdf0e10cSrcweir
2070cdf0e10cSrcweir if (bFlag)
2071cdf0e10cSrcweir {
2072cdf0e10cSrcweir if (bRecord)
2073cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
2074cdf0e10cSrcweir new ScUndoInsertTables( pDocSh, nTab, sal_False, pNameList));
2075cdf0e10cSrcweir
2076cdf0e10cSrcweir // Views updaten:
2077cdf0e10cSrcweir
2078cdf0e10cSrcweir SetTabNo( nTab, sal_True );
2079cdf0e10cSrcweir pDocSh->PostPaintExtras();
2080cdf0e10cSrcweir pDocSh->SetDocumentModified();
2081cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2082cdf0e10cSrcweir return sal_True;
2083cdf0e10cSrcweir }
2084cdf0e10cSrcweir else
2085cdf0e10cSrcweir {
2086cdf0e10cSrcweir return sal_False;
2087cdf0e10cSrcweir }
2088cdf0e10cSrcweir }
2089cdf0e10cSrcweir
2090cdf0e10cSrcweir
2091cdf0e10cSrcweir //----------------------------------------------------------------------------
2092cdf0e10cSrcweir
AppendTable(const String & rName,sal_Bool bRecord)2093cdf0e10cSrcweir sal_Bool ScViewFunc::AppendTable( const String& rName, sal_Bool bRecord )
2094cdf0e10cSrcweir {
2095cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2096cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2097cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2098cdf0e10cSrcweir bRecord = sal_False;
2099cdf0e10cSrcweir
2100cdf0e10cSrcweir WaitObject aWait( GetFrameWin() );
2101cdf0e10cSrcweir
2102cdf0e10cSrcweir if (bRecord)
2103cdf0e10cSrcweir pDoc->BeginDrawUndo(); // InsertTab erzeugt ein SdrUndoNewPage
2104cdf0e10cSrcweir
2105cdf0e10cSrcweir if (pDoc->InsertTab( SC_TAB_APPEND, rName ))
2106cdf0e10cSrcweir {
2107cdf0e10cSrcweir SCTAB nTab = pDoc->GetTableCount()-1;
2108cdf0e10cSrcweir if (bRecord)
2109cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
2110cdf0e10cSrcweir new ScUndoInsertTab( pDocSh, nTab, sal_True, rName));
2111cdf0e10cSrcweir GetViewData()->InsertTab( nTab );
2112cdf0e10cSrcweir SetTabNo( nTab, sal_True );
2113cdf0e10cSrcweir pDocSh->PostPaintExtras();
2114cdf0e10cSrcweir pDocSh->SetDocumentModified();
2115cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2116cdf0e10cSrcweir return sal_True;
2117cdf0e10cSrcweir }
2118cdf0e10cSrcweir else
2119cdf0e10cSrcweir {
2120cdf0e10cSrcweir return sal_False;
2121cdf0e10cSrcweir }
2122cdf0e10cSrcweir }
2123cdf0e10cSrcweir
2124cdf0e10cSrcweir
2125cdf0e10cSrcweir //----------------------------------------------------------------------------
2126cdf0e10cSrcweir
DeleteTable(SCTAB nTab,sal_Bool bRecord)2127cdf0e10cSrcweir sal_Bool ScViewFunc::DeleteTable( SCTAB nTab, sal_Bool bRecord )
2128cdf0e10cSrcweir {
2129cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2130cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2131cdf0e10cSrcweir
2132cdf0e10cSrcweir sal_Bool bSuccess = pDocSh->GetDocFunc().DeleteTable( nTab, bRecord, sal_False );
2133cdf0e10cSrcweir if (bSuccess)
2134cdf0e10cSrcweir {
2135cdf0e10cSrcweir SCTAB nNewTab = nTab;
2136cdf0e10cSrcweir if ( nNewTab >= pDoc->GetTableCount() )
2137cdf0e10cSrcweir --nNewTab;
2138cdf0e10cSrcweir SetTabNo( nNewTab, sal_True );
2139cdf0e10cSrcweir }
2140cdf0e10cSrcweir return bSuccess;
2141cdf0e10cSrcweir }
2142cdf0e10cSrcweir
DeleteTables(const SvShorts & TheTabs,sal_Bool bRecord)2143cdf0e10cSrcweir sal_Bool ScViewFunc::DeleteTables(const SvShorts &TheTabs, sal_Bool bRecord )
2144cdf0e10cSrcweir {
2145cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2146cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2147cdf0e10cSrcweir sal_Bool bVbaEnabled = pDoc ? pDoc->IsInVBAMode() : sal_False;
2148cdf0e10cSrcweir SCTAB nNewTab = TheTabs.front();
2149cdf0e10cSrcweir WaitObject aWait( GetFrameWin() );
2150cdf0e10cSrcweir if (bRecord && !pDoc->IsUndoEnabled())
2151cdf0e10cSrcweir bRecord = sal_False;
2152cdf0e10cSrcweir
2153cdf0e10cSrcweir while ( nNewTab > 0 && !pDoc->IsVisible( nNewTab ) )
2154cdf0e10cSrcweir --nNewTab;
2155cdf0e10cSrcweir
2156cdf0e10cSrcweir sal_Bool bWasLinked = sal_False;
2157cdf0e10cSrcweir ScDocument* pUndoDoc = NULL;
2158cdf0e10cSrcweir ScRefUndoData* pUndoData = NULL;
2159cdf0e10cSrcweir if (bRecord)
2160cdf0e10cSrcweir {
2161cdf0e10cSrcweir pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
2162cdf0e10cSrcweir // pUndoDoc->InitDrawLayer( pDocSh );
2163cdf0e10cSrcweir SCTAB nCount = pDoc->GetTableCount();
2164cdf0e10cSrcweir
2165cdf0e10cSrcweir // pUndoDoc->InitUndo( pDoc, 0, nCount-1 ); // incl. Ref.
2166cdf0e10cSrcweir
2167cdf0e10cSrcweir String aOldName;
2168cdf0e10cSrcweir for (size_t i = 0; i < TheTabs.size(); i++)
2169cdf0e10cSrcweir {
2170cdf0e10cSrcweir SCTAB nTab = TheTabs[i];
2171cdf0e10cSrcweir if (i==0)
2172cdf0e10cSrcweir pUndoDoc->InitUndo( pDoc, nTab,nTab, sal_True,sal_True ); // incl. Spalten/Zeilenflags
2173cdf0e10cSrcweir else
2174cdf0e10cSrcweir pUndoDoc->AddUndoTab( nTab,nTab, sal_True,sal_True ); // incl. Spalten/Zeilenflags
2175cdf0e10cSrcweir
2176cdf0e10cSrcweir pDoc->CopyToDocument(0,0,nTab, MAXCOL,MAXROW,nTab, IDF_ALL,sal_False, pUndoDoc );
2177cdf0e10cSrcweir pDoc->GetName( nTab, aOldName );
2178cdf0e10cSrcweir pUndoDoc->RenameTab( nTab, aOldName, sal_False );
2179cdf0e10cSrcweir if (pDoc->IsLinked(nTab))
2180cdf0e10cSrcweir {
2181cdf0e10cSrcweir bWasLinked = sal_True;
2182cdf0e10cSrcweir pUndoDoc->SetLink( nTab, pDoc->GetLinkMode(nTab), pDoc->GetLinkDoc(nTab),
2183cdf0e10cSrcweir pDoc->GetLinkFlt(nTab), pDoc->GetLinkOpt(nTab),
2184cdf0e10cSrcweir pDoc->GetLinkTab(nTab),
2185cdf0e10cSrcweir pDoc->GetLinkRefreshDelay(nTab) );
2186cdf0e10cSrcweir }
2187cdf0e10cSrcweir if ( pDoc->IsScenario(nTab) )
2188cdf0e10cSrcweir {
2189cdf0e10cSrcweir pUndoDoc->SetScenario( nTab, sal_True );
2190cdf0e10cSrcweir String aComment;
2191cdf0e10cSrcweir Color aColor;
2192cdf0e10cSrcweir sal_uInt16 nScenFlags;
2193cdf0e10cSrcweir pDoc->GetScenarioData( nTab, aComment, aColor, nScenFlags );
2194cdf0e10cSrcweir pUndoDoc->SetScenarioData( nTab, aComment, aColor, nScenFlags );
2195cdf0e10cSrcweir sal_Bool bActive = pDoc->IsActiveScenario( nTab );
2196cdf0e10cSrcweir pUndoDoc->SetActiveScenario( nTab, bActive );
2197cdf0e10cSrcweir }
2198cdf0e10cSrcweir pUndoDoc->SetVisible( nTab, pDoc->IsVisible( nTab ) );
2199cdf0e10cSrcweir pUndoDoc->SetTabBgColor( nTab, pDoc->GetTabBgColor(nTab) );
2200cdf0e10cSrcweir pUndoDoc->SetSheetEvents( nTab, pDoc->GetSheetEvents( nTab ) );
2201cdf0e10cSrcweir
2202cdf0e10cSrcweir if ( pDoc->IsTabProtected( nTab ) )
2203cdf0e10cSrcweir pUndoDoc->SetTabProtection(nTab, pDoc->GetTabProtection(nTab));
2204cdf0e10cSrcweir
2205cdf0e10cSrcweir // Drawing-Layer muss sein Undo selbst in der Hand behalten !!!
2206cdf0e10cSrcweir // pUndoDoc->TransferDrawPage(pDoc, nTab,nTab);
2207cdf0e10cSrcweir }
2208cdf0e10cSrcweir
2209cdf0e10cSrcweir pUndoDoc->AddUndoTab( 0, nCount-1 ); // alle Tabs fuer Referenzen
2210cdf0e10cSrcweir
2211cdf0e10cSrcweir pDoc->BeginDrawUndo(); // DeleteTab erzeugt ein SdrUndoDelPage
2212cdf0e10cSrcweir
2213cdf0e10cSrcweir pUndoData = new ScRefUndoData( pDoc );
2214cdf0e10cSrcweir }
2215cdf0e10cSrcweir
2216cdf0e10cSrcweir sal_Bool bDelDone = sal_False;
2217cdf0e10cSrcweir
2218cdf0e10cSrcweir for (size_t i = TheTabs.size(); i > 0; i--)
2219cdf0e10cSrcweir {
2220cdf0e10cSrcweir String sCodeName;
2221cdf0e10cSrcweir sal_Bool bHasCodeName = pDoc->GetCodeName( TheTabs[i-1], sCodeName );
2222cdf0e10cSrcweir if (pDoc->DeleteTab( TheTabs[i-1], pUndoDoc ))
2223cdf0e10cSrcweir {
2224cdf0e10cSrcweir bDelDone = sal_True;
2225cdf0e10cSrcweir if( bVbaEnabled )
2226cdf0e10cSrcweir {
2227cdf0e10cSrcweir if( bHasCodeName )
2228cdf0e10cSrcweir {
2229cdf0e10cSrcweir VBA_DeleteModule( *pDocSh, sCodeName );
2230cdf0e10cSrcweir }
2231cdf0e10cSrcweir }
2232cdf0e10cSrcweir pDocSh->Broadcast( ScTablesHint( SC_TAB_DELETED, TheTabs[i-1] ) );
2233cdf0e10cSrcweir }
2234cdf0e10cSrcweir }
2235cdf0e10cSrcweir if (bRecord)
2236cdf0e10cSrcweir {
2237cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
2238cdf0e10cSrcweir new ScUndoDeleteTab( GetViewData()->GetDocShell(), TheTabs,
2239cdf0e10cSrcweir pUndoDoc, pUndoData ));
2240cdf0e10cSrcweir }
2241cdf0e10cSrcweir
2242cdf0e10cSrcweir
2243cdf0e10cSrcweir if (bDelDone)
2244cdf0e10cSrcweir {
2245cdf0e10cSrcweir if ( nNewTab >= pDoc->GetTableCount() )
2246cdf0e10cSrcweir nNewTab = pDoc->GetTableCount() - 1;
2247cdf0e10cSrcweir
2248cdf0e10cSrcweir SetTabNo( nNewTab, sal_True );
2249cdf0e10cSrcweir
2250cdf0e10cSrcweir if (bWasLinked)
2251cdf0e10cSrcweir {
2252cdf0e10cSrcweir pDocSh->UpdateLinks(); // Link-Manager updaten
2253cdf0e10cSrcweir GetViewData()->GetBindings().Invalidate(SID_LINKS);
2254cdf0e10cSrcweir }
2255cdf0e10cSrcweir
2256cdf0e10cSrcweir pDocSh->PostPaintExtras();
2257cdf0e10cSrcweir pDocSh->SetDocumentModified();
2258cdf0e10cSrcweir
2259cdf0e10cSrcweir SfxApplication* pSfxApp = SFX_APP(); // Navigator
2260cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2261cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_DBAREAS_CHANGED ) );
2262cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREALINKS_CHANGED ) );
2263cdf0e10cSrcweir }
2264cdf0e10cSrcweir else
2265cdf0e10cSrcweir {
2266cdf0e10cSrcweir delete pUndoDoc;
2267cdf0e10cSrcweir delete pUndoData;
2268cdf0e10cSrcweir }
2269cdf0e10cSrcweir return bDelDone;
2270cdf0e10cSrcweir }
2271cdf0e10cSrcweir
2272cdf0e10cSrcweir
2273cdf0e10cSrcweir //----------------------------------------------------------------------------
2274cdf0e10cSrcweir
RenameTable(const String & rName,SCTAB nTab)2275cdf0e10cSrcweir sal_Bool ScViewFunc::RenameTable( const String& rName, SCTAB nTab )
2276cdf0e10cSrcweir {
2277cdf0e10cSrcweir // Reihenfolge Tabelle/Name ist bei DocFunc umgekehrt
2278cdf0e10cSrcweir sal_Bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().
2279cdf0e10cSrcweir RenameTable( nTab, rName, sal_True, sal_False );
2280cdf0e10cSrcweir if (bSuccess)
2281cdf0e10cSrcweir {
2282cdf0e10cSrcweir // Der Tabellenname koennte in einer Formel vorkommen...
2283cdf0e10cSrcweir GetViewData()->GetViewShell()->UpdateInputHandler();
2284cdf0e10cSrcweir }
2285cdf0e10cSrcweir return bSuccess;
2286cdf0e10cSrcweir }
2287cdf0e10cSrcweir
2288cdf0e10cSrcweir
2289cdf0e10cSrcweir //----------------------------------------------------------------------------
2290cdf0e10cSrcweir
SetTabBgColor(const Color & rColor,SCTAB nTab)2291cdf0e10cSrcweir bool ScViewFunc::SetTabBgColor( const Color& rColor, SCTAB nTab )
2292cdf0e10cSrcweir {
2293cdf0e10cSrcweir bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().SetTabBgColor( nTab, rColor, sal_True, sal_False );
2294cdf0e10cSrcweir if (bSuccess)
2295cdf0e10cSrcweir {
2296cdf0e10cSrcweir GetViewData()->GetViewShell()->UpdateInputHandler();
2297cdf0e10cSrcweir }
2298cdf0e10cSrcweir return bSuccess;
2299cdf0e10cSrcweir }
2300cdf0e10cSrcweir
SetTabBgColor(ScUndoTabColorInfo::List & rUndoSetTabBgColorInfoList)2301cdf0e10cSrcweir bool ScViewFunc::SetTabBgColor( ScUndoTabColorInfo::List& rUndoSetTabBgColorInfoList )
2302cdf0e10cSrcweir {
2303cdf0e10cSrcweir bool bSuccess = GetViewData()->GetDocShell()->GetDocFunc().SetTabBgColor( rUndoSetTabBgColorInfoList, sal_True, sal_False );
2304cdf0e10cSrcweir if (bSuccess)
2305cdf0e10cSrcweir {
2306cdf0e10cSrcweir GetViewData()->GetViewShell()->UpdateInputHandler();
2307cdf0e10cSrcweir }
2308cdf0e10cSrcweir return bSuccess;
2309cdf0e10cSrcweir }
2310cdf0e10cSrcweir
2311cdf0e10cSrcweir //----------------------------------------------------------------------------
2312cdf0e10cSrcweir
InsertAreaLink(const String & rFile,const String & rFilter,const String & rOptions,const String & rSource,sal_uLong nRefresh)2313cdf0e10cSrcweir void ScViewFunc::InsertAreaLink( const String& rFile,
2314cdf0e10cSrcweir const String& rFilter, const String& rOptions,
2315cdf0e10cSrcweir const String& rSource, sal_uLong nRefresh )
2316cdf0e10cSrcweir {
2317cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2318cdf0e10cSrcweir SCCOL nPosX = GetViewData()->GetCurX();
2319cdf0e10cSrcweir SCROW nPosY = GetViewData()->GetCurY();
2320cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
2321cdf0e10cSrcweir ScAddress aPos( nPosX, nPosY, nTab );
2322cdf0e10cSrcweir
2323cdf0e10cSrcweir pDocSh->GetDocFunc().InsertAreaLink( rFile, rFilter, rOptions, rSource, aPos, nRefresh, sal_False, sal_False );
2324cdf0e10cSrcweir }
2325cdf0e10cSrcweir
2326cdf0e10cSrcweir
2327cdf0e10cSrcweir //----------------------------------------------------------------------------
2328cdf0e10cSrcweir
InsertTableLink(const String & rFile,const String & rFilter,const String & rOptions,const String & rTabName)2329cdf0e10cSrcweir void ScViewFunc::InsertTableLink( const String& rFile,
2330cdf0e10cSrcweir const String& rFilter, const String& rOptions,
2331cdf0e10cSrcweir const String& rTabName )
2332cdf0e10cSrcweir {
2333cdf0e10cSrcweir String aFilterName = rFilter;
2334cdf0e10cSrcweir String aOpt = rOptions;
2335cdf0e10cSrcweir ScDocumentLoader aLoader( rFile, aFilterName, aOpt );
2336cdf0e10cSrcweir if (!aLoader.IsError())
2337cdf0e10cSrcweir {
2338cdf0e10cSrcweir ScDocShell* pSrcSh = aLoader.GetDocShell();
2339cdf0e10cSrcweir ScDocument* pSrcDoc = pSrcSh->GetDocument();
2340cdf0e10cSrcweir SCTAB nTab = MAXTAB+1;
2341cdf0e10cSrcweir if (!rTabName.Len()) // kein Name angegeben -> erste Tabelle
2342cdf0e10cSrcweir nTab = 0;
2343cdf0e10cSrcweir else
2344cdf0e10cSrcweir {
2345cdf0e10cSrcweir String aTemp;
2346cdf0e10cSrcweir SCTAB nCount = pSrcDoc->GetTableCount();
2347cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
2348cdf0e10cSrcweir {
2349cdf0e10cSrcweir pSrcDoc->GetName( i, aTemp );
2350cdf0e10cSrcweir if ( aTemp == rTabName )
2351cdf0e10cSrcweir nTab = i;
2352cdf0e10cSrcweir }
2353cdf0e10cSrcweir }
2354cdf0e10cSrcweir
2355cdf0e10cSrcweir if ( nTab <= MAXTAB )
2356cdf0e10cSrcweir ImportTables( pSrcSh, 1, &nTab, sal_True,
2357cdf0e10cSrcweir GetViewData()->GetTabNo() );
2358cdf0e10cSrcweir }
2359cdf0e10cSrcweir }
2360cdf0e10cSrcweir
2361cdf0e10cSrcweir
2362cdf0e10cSrcweir //----------------------------------------------------------------------------
2363cdf0e10cSrcweir // Tabellen aus anderem Dokument kopieren / linken
2364cdf0e10cSrcweir
ImportTables(ScDocShell * pSrcShell,SCTAB nCount,const SCTAB * pSrcTabs,sal_Bool bLink,SCTAB nTab)2365cdf0e10cSrcweir void ScViewFunc::ImportTables( ScDocShell* pSrcShell,
2366cdf0e10cSrcweir SCTAB nCount, const SCTAB* pSrcTabs, sal_Bool bLink,SCTAB nTab )
2367cdf0e10cSrcweir {
2368cdf0e10cSrcweir ScDocument* pSrcDoc = pSrcShell->GetDocument();
2369cdf0e10cSrcweir
2370cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2371cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2372cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
2373cdf0e10cSrcweir //SCTAB nTab = GetViewData()->GetTabNo();
2374cdf0e10cSrcweir
2375cdf0e10cSrcweir sal_Bool bError = sal_False;
2376cdf0e10cSrcweir sal_Bool bRefs = sal_False;
2377cdf0e10cSrcweir sal_Bool bName = sal_False;
2378cdf0e10cSrcweir
2379cdf0e10cSrcweir if (pSrcDoc->GetDrawLayer())
2380cdf0e10cSrcweir pDocSh->MakeDrawLayer();
2381cdf0e10cSrcweir
2382cdf0e10cSrcweir if (bUndo)
2383cdf0e10cSrcweir pDoc->BeginDrawUndo(); // drawing layer must do its own undo actions
2384cdf0e10cSrcweir
2385cdf0e10cSrcweir SCTAB nInsCount = 0;
2386cdf0e10cSrcweir SCTAB i;
2387cdf0e10cSrcweir for( i=0; i<nCount; i++ )
2388cdf0e10cSrcweir { // #63304# insert sheets first and update all references
2389cdf0e10cSrcweir String aName;
2390cdf0e10cSrcweir pSrcDoc->GetName( pSrcTabs[i], aName );
2391cdf0e10cSrcweir pDoc->CreateValidTabName( aName );
2392cdf0e10cSrcweir if ( !pDoc->InsertTab( nTab+i, aName ) )
2393cdf0e10cSrcweir {
2394cdf0e10cSrcweir bError = sal_True; // total error
2395cdf0e10cSrcweir break; // for
2396cdf0e10cSrcweir }
2397cdf0e10cSrcweir ++nInsCount;
2398cdf0e10cSrcweir }
2399cdf0e10cSrcweir for (i=0; i<nCount && !bError; i++)
2400cdf0e10cSrcweir {
2401cdf0e10cSrcweir SCTAB nSrcTab = pSrcTabs[i];
2402cdf0e10cSrcweir SCTAB nDestTab1=nTab+i;
2403cdf0e10cSrcweir sal_uLong nErrVal = pDoc->TransferTab( pSrcDoc, nSrcTab, nDestTab1,
2404cdf0e10cSrcweir sal_False ); // no insert
2405cdf0e10cSrcweir
2406cdf0e10cSrcweir switch (nErrVal)
2407cdf0e10cSrcweir {
2408cdf0e10cSrcweir case 0: // interner Fehler oder voll Fehler
2409cdf0e10cSrcweir bError = sal_True;
2410cdf0e10cSrcweir break;
2411cdf0e10cSrcweir case 2:
2412cdf0e10cSrcweir bRefs = sal_True;
2413cdf0e10cSrcweir break;
2414cdf0e10cSrcweir case 3:
2415cdf0e10cSrcweir bName = sal_True;
2416cdf0e10cSrcweir break;
2417cdf0e10cSrcweir case 4:
2418cdf0e10cSrcweir bRefs = bName = sal_True;
2419cdf0e10cSrcweir break;
2420cdf0e10cSrcweir }
2421cdf0e10cSrcweir
2422cdf0e10cSrcweir // TransferTab doesn't copy drawing objects with bInsertNew=FALSE
2423cdf0e10cSrcweir if ( !bError )
2424cdf0e10cSrcweir pDoc->TransferDrawPage( pSrcDoc, nSrcTab, nDestTab1 );
2425cdf0e10cSrcweir
2426cdf0e10cSrcweir if(!bError &&pSrcDoc->IsScenario(nSrcTab))
2427cdf0e10cSrcweir {
2428cdf0e10cSrcweir String aComment;
2429cdf0e10cSrcweir Color aColor;
2430cdf0e10cSrcweir sal_uInt16 nFlags;
2431cdf0e10cSrcweir
2432cdf0e10cSrcweir pSrcDoc->GetScenarioData(nSrcTab, aComment,aColor, nFlags);
2433cdf0e10cSrcweir pDoc->SetScenario( nDestTab1,sal_True);
2434cdf0e10cSrcweir pDoc->SetScenarioData( nTab+i,aComment,aColor,nFlags);
2435cdf0e10cSrcweir sal_Bool bActive = pSrcDoc->IsActiveScenario(nSrcTab );
2436cdf0e10cSrcweir pDoc->SetActiveScenario( nDestTab1, bActive );
2437cdf0e10cSrcweir sal_Bool bVisible=pSrcDoc->IsVisible(nSrcTab);
2438cdf0e10cSrcweir pDoc->SetVisible(nDestTab1,bVisible );
2439cdf0e10cSrcweir
2440cdf0e10cSrcweir }
2441cdf0e10cSrcweir }
2442cdf0e10cSrcweir
2443cdf0e10cSrcweir if (bLink)
2444cdf0e10cSrcweir {
2445cdf0e10cSrcweir sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();
2446cdf0e10cSrcweir
2447cdf0e10cSrcweir SfxMedium* pMed = pSrcShell->GetMedium();
2448cdf0e10cSrcweir String aFileName = pMed->GetName();
2449cdf0e10cSrcweir String aFilterName;
2450cdf0e10cSrcweir if (pMed->GetFilter())
2451cdf0e10cSrcweir aFilterName = pMed->GetFilter()->GetFilterName();
2452cdf0e10cSrcweir String aOptions = ScDocumentLoader::GetOptions(*pMed);
2453cdf0e10cSrcweir
2454cdf0e10cSrcweir sal_Bool bWasThere = pDoc->HasLink( aFileName, aFilterName, aOptions );
2455cdf0e10cSrcweir
2456cdf0e10cSrcweir sal_uLong nRefresh = 0;
2457cdf0e10cSrcweir String aTabStr;
2458cdf0e10cSrcweir for (i=0; i<nInsCount; i++)
2459cdf0e10cSrcweir {
2460cdf0e10cSrcweir pSrcDoc->GetName( pSrcTabs[i], aTabStr );
2461cdf0e10cSrcweir pDoc->SetLink( nTab+i, SC_LINK_NORMAL,
2462cdf0e10cSrcweir aFileName, aFilterName, aOptions, aTabStr, nRefresh );
2463cdf0e10cSrcweir }
2464cdf0e10cSrcweir
2465cdf0e10cSrcweir if (!bWasThere) // Link pro Quelldokument nur einmal eintragen
2466cdf0e10cSrcweir {
2467cdf0e10cSrcweir ScTableLink* pLink = new ScTableLink( pDocSh, aFileName, aFilterName, aOptions, nRefresh );
2468cdf0e10cSrcweir pLink->SetInCreate( sal_True );
2469cdf0e10cSrcweir pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, aFileName, &aFilterName );
2470cdf0e10cSrcweir pLink->Update();
2471cdf0e10cSrcweir pLink->SetInCreate( sal_False );
2472cdf0e10cSrcweir
2473cdf0e10cSrcweir SfxBindings& rBindings = GetViewData()->GetBindings();
2474cdf0e10cSrcweir rBindings.Invalidate( SID_LINKS );
2475cdf0e10cSrcweir }
2476cdf0e10cSrcweir }
2477cdf0e10cSrcweir
2478cdf0e10cSrcweir
2479cdf0e10cSrcweir if (bUndo)
2480cdf0e10cSrcweir {
2481cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction(
2482cdf0e10cSrcweir new ScUndoImportTab( pDocSh, nTab, nCount, bLink ) );
2483cdf0e10cSrcweir }
2484cdf0e10cSrcweir
2485cdf0e10cSrcweir for (i=0; i<nInsCount; i++)
2486cdf0e10cSrcweir GetViewData()->InsertTab(nTab);
2487cdf0e10cSrcweir SetTabNo(nTab,sal_True);
2488cdf0e10cSrcweir pDocSh->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB,
2489cdf0e10cSrcweir PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS );
2490cdf0e10cSrcweir
2491cdf0e10cSrcweir SfxApplication* pSfxApp = SFX_APP();
2492cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2493cdf0e10cSrcweir pSfxApp->Broadcast( SfxSimpleHint( SC_HINT_AREAS_CHANGED ) );
2494cdf0e10cSrcweir
2495cdf0e10cSrcweir pDocSh->PostPaintExtras();
2496cdf0e10cSrcweir pDocSh->PostPaintGridAll();
2497cdf0e10cSrcweir pDocSh->SetDocumentModified();
2498cdf0e10cSrcweir
2499cdf0e10cSrcweir if (bRefs)
2500cdf0e10cSrcweir ErrorMessage(STR_ABSREFLOST);
2501cdf0e10cSrcweir if (bName)
2502cdf0e10cSrcweir ErrorMessage(STR_NAMECONFLICT);
2503cdf0e10cSrcweir }
2504cdf0e10cSrcweir
2505cdf0e10cSrcweir
2506cdf0e10cSrcweir //----------------------------------------------------------------------------
2507cdf0e10cSrcweir // Tabelle in anderes Dokument verschieben / kopieren
2508cdf0e10cSrcweir
MoveTable(sal_uInt16 nDestDocNo,SCTAB nDestTab,sal_Bool bCopy)2509cdf0e10cSrcweir void ScViewFunc::MoveTable( sal_uInt16 nDestDocNo, SCTAB nDestTab, sal_Bool bCopy )
2510cdf0e10cSrcweir {
2511cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
2512cdf0e10cSrcweir ScDocShell* pDocShell = GetViewData()->GetDocShell();
2513cdf0e10cSrcweir ScDocument* pDestDoc = NULL;
2514cdf0e10cSrcweir ScDocShell* pDestShell = NULL;
2515cdf0e10cSrcweir ScTabViewShell* pDestViewSh = NULL;
2516cdf0e10cSrcweir sal_Bool bUndo (pDoc->IsUndoEnabled());
2517cdf0e10cSrcweir
2518cdf0e10cSrcweir sal_Bool bNewDoc = ( nDestDocNo == SC_DOC_NEW );
2519cdf0e10cSrcweir if ( bNewDoc )
2520cdf0e10cSrcweir {
2521cdf0e10cSrcweir nDestTab = 0; // als erstes einfuegen
2522cdf0e10cSrcweir
2523cdf0e10cSrcweir // ohne SFX_CALLMODE_RECORD ausfuehren, weil schon im Move-Befehl enthalten:
2524cdf0e10cSrcweir
2525cdf0e10cSrcweir String aUrl = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("private:factory/"));
2526cdf0e10cSrcweir aUrl.AppendAscii(RTL_CONSTASCII_STRINGPARAM( STRING_SCAPP )); // "scalc"
2527cdf0e10cSrcweir SfxStringItem aItem( SID_FILE_NAME, aUrl );
2528cdf0e10cSrcweir SfxStringItem aTarget( SID_TARGETNAME, String::CreateFromAscii("_blank") );
2529cdf0e10cSrcweir
2530cdf0e10cSrcweir const SfxPoolItem* pRetItem = GetViewData()->GetDispatcher().Execute(
2531cdf0e10cSrcweir SID_OPENDOC, SFX_CALLMODE_API|SFX_CALLMODE_SYNCHRON, &aItem, &aTarget, 0L );
2532cdf0e10cSrcweir if ( pRetItem )
2533cdf0e10cSrcweir {
2534cdf0e10cSrcweir if ( pRetItem->ISA( SfxObjectItem ) )
2535cdf0e10cSrcweir pDestShell = PTR_CAST( ScDocShell, ((const SfxObjectItem*)pRetItem)->GetShell() );
2536cdf0e10cSrcweir else if ( pRetItem->ISA( SfxViewFrameItem ) )
2537cdf0e10cSrcweir {
2538cdf0e10cSrcweir SfxViewFrame* pFrm = ((const SfxViewFrameItem*)pRetItem)->GetFrame();
2539cdf0e10cSrcweir if (pFrm)
2540cdf0e10cSrcweir pDestShell = PTR_CAST( ScDocShell, pFrm->GetObjectShell() );
2541cdf0e10cSrcweir }
2542cdf0e10cSrcweir if (pDestShell)
2543cdf0e10cSrcweir pDestViewSh = pDestShell->GetBestViewShell();
2544cdf0e10cSrcweir }
2545cdf0e10cSrcweir }
2546cdf0e10cSrcweir else
2547cdf0e10cSrcweir pDestShell = ScDocShell::GetShellByNum( nDestDocNo );
2548cdf0e10cSrcweir
2549cdf0e10cSrcweir if (!pDestShell)
2550cdf0e10cSrcweir {
2551cdf0e10cSrcweir DBG_ERROR("Dest-Doc nicht gefunden !!!");
2552cdf0e10cSrcweir return;
2553cdf0e10cSrcweir }
2554cdf0e10cSrcweir
2555cdf0e10cSrcweir pDestDoc = pDestShell->GetDocument();
2556cdf0e10cSrcweir
2557cdf0e10cSrcweir SCTAB nTab = GetViewData()->GetTabNo();
2558cdf0e10cSrcweir
2559cdf0e10cSrcweir if (pDestDoc != pDoc)
2560cdf0e10cSrcweir {
2561cdf0e10cSrcweir if (bNewDoc)
2562cdf0e10cSrcweir {
2563cdf0e10cSrcweir while (pDestDoc->GetTableCount() > 1)
2564cdf0e10cSrcweir pDestDoc->DeleteTab(0);
2565cdf0e10cSrcweir pDestDoc->RenameTab( 0,
2566cdf0e10cSrcweir String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("______42_____")),
2567cdf0e10cSrcweir sal_False );
2568cdf0e10cSrcweir }
2569cdf0e10cSrcweir
2570cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
2571cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
2572cdf0e10cSrcweir SCTAB nTabSelCount = rMark.GetSelectCount();
2573cdf0e10cSrcweir
2574cdf0e10cSrcweir SvShorts TheTabs;
2575cdf0e10cSrcweir
2576cdf0e10cSrcweir for(SCTAB i=0;i<nTabCount;i++)
2577cdf0e10cSrcweir {
2578cdf0e10cSrcweir if(rMark.GetTableSelect(i))
2579cdf0e10cSrcweir {
2580cdf0e10cSrcweir String aTabName;
2581cdf0e10cSrcweir pDoc->GetName( i, aTabName);
2582cdf0e10cSrcweir TheTabs.push_back(i);
2583cdf0e10cSrcweir for(SCTAB j=i+1;j<nTabCount;j++)
2584cdf0e10cSrcweir {
2585cdf0e10cSrcweir if((!pDoc->IsVisible(j))&&(pDoc->IsScenario(j)))
2586cdf0e10cSrcweir {
2587cdf0e10cSrcweir pDoc->GetName( j, aTabName);
2588cdf0e10cSrcweir TheTabs.push_back(j);
2589cdf0e10cSrcweir i=j;
2590cdf0e10cSrcweir }
2591cdf0e10cSrcweir else break;
2592cdf0e10cSrcweir }
2593cdf0e10cSrcweir }
2594cdf0e10cSrcweir }
2595cdf0e10cSrcweir
2596cdf0e10cSrcweir GetFrameWin()->EnterWait();
2597cdf0e10cSrcweir
2598cdf0e10cSrcweir if (pDoc->GetDrawLayer())
2599cdf0e10cSrcweir pDestShell->MakeDrawLayer();
2600cdf0e10cSrcweir
2601cdf0e10cSrcweir if (!bNewDoc && bUndo)
2602cdf0e10cSrcweir pDestDoc->BeginDrawUndo(); // drawing layer must do its own undo actions
2603cdf0e10cSrcweir
2604cdf0e10cSrcweir sal_uLong nErrVal =1;
2605cdf0e10cSrcweir if(nDestTab==SC_TAB_APPEND)
2606cdf0e10cSrcweir nDestTab=pDestDoc->GetTableCount();
2607cdf0e10cSrcweir SCTAB nDestTab1=nDestTab;
2608cdf0e10cSrcweir for( size_t j=0; j<TheTabs.size(); j++, nDestTab1++ )
2609cdf0e10cSrcweir { // #63304# insert sheets first and update all references
2610cdf0e10cSrcweir String aName;
2611cdf0e10cSrcweir pDoc->GetName( TheTabs[j], aName );
2612cdf0e10cSrcweir pDestDoc->CreateValidTabName( aName );
2613cdf0e10cSrcweir if ( !pDestDoc->InsertTab( nDestTab1, aName ) )
2614cdf0e10cSrcweir {
2615cdf0e10cSrcweir nErrVal = 0; // total error
2616cdf0e10cSrcweir break; // for
2617cdf0e10cSrcweir }
2618cdf0e10cSrcweir }
2619cdf0e10cSrcweir if ( nErrVal > 0 )
2620cdf0e10cSrcweir {
2621cdf0e10cSrcweir nDestTab1 = nDestTab;
2622cdf0e10cSrcweir for(size_t i=0;i<TheTabs.size();i++)
2623cdf0e10cSrcweir {
2624cdf0e10cSrcweir nErrVal = pDestDoc->TransferTab( pDoc, TheTabs[i], nDestTab1,
2625cdf0e10cSrcweir sal_False ); // no insert
2626cdf0e10cSrcweir
2627cdf0e10cSrcweir // TransferTab doesn't copy drawing objects with bInsertNew=FALSE
2628cdf0e10cSrcweir if ( nErrVal > 0 )
2629cdf0e10cSrcweir pDestDoc->TransferDrawPage( pDoc, TheTabs[i], nDestTab1 );
2630cdf0e10cSrcweir
2631cdf0e10cSrcweir if(nErrVal>0 && pDoc->IsScenario(TheTabs[i]))
2632cdf0e10cSrcweir {
2633cdf0e10cSrcweir String aComment;
2634cdf0e10cSrcweir Color aColor;
2635cdf0e10cSrcweir sal_uInt16 nFlags;
2636cdf0e10cSrcweir
2637cdf0e10cSrcweir pDoc->GetScenarioData(TheTabs[i], aComment,aColor, nFlags);
2638cdf0e10cSrcweir pDestDoc->SetScenario(nDestTab1,sal_True);
2639cdf0e10cSrcweir pDestDoc->SetScenarioData(nDestTab1,aComment,aColor,nFlags);
2640cdf0e10cSrcweir sal_Bool bActive = pDoc->IsActiveScenario(TheTabs[i]);
2641cdf0e10cSrcweir pDestDoc->SetActiveScenario(nDestTab1, bActive );
2642cdf0e10cSrcweir
2643cdf0e10cSrcweir sal_Bool bVisible=pDoc->IsVisible(TheTabs[i]);
2644cdf0e10cSrcweir pDestDoc->SetVisible(nDestTab1,bVisible );
2645cdf0e10cSrcweir
2646cdf0e10cSrcweir }
2647cdf0e10cSrcweir
2648cdf0e10cSrcweir if ( nErrVal > 0 && pDoc->IsTabProtected( TheTabs[i] ) )
2649cdf0e10cSrcweir pDestDoc->SetTabProtection(nDestTab1, pDoc->GetTabProtection(TheTabs[i]));
2650cdf0e10cSrcweir
2651cdf0e10cSrcweir nDestTab1++;
2652cdf0e10cSrcweir }
2653cdf0e10cSrcweir }
2654cdf0e10cSrcweir String sName;
2655cdf0e10cSrcweir if (!bNewDoc && bUndo)
2656cdf0e10cSrcweir {
2657cdf0e10cSrcweir pDestDoc->GetName(nDestTab, sName);
2658cdf0e10cSrcweir pDestShell->GetUndoManager()->AddUndoAction(
2659cdf0e10cSrcweir new ScUndoImportTab( pDestShell, nDestTab,
2660cdf0e10cSrcweir static_cast<SCTAB>(TheTabs.size()), sal_False));
2661cdf0e10cSrcweir
2662cdf0e10cSrcweir }
2663cdf0e10cSrcweir else
2664cdf0e10cSrcweir {
2665cdf0e10cSrcweir pDestShell->GetUndoManager()->Clear();
2666cdf0e10cSrcweir }
2667cdf0e10cSrcweir
2668cdf0e10cSrcweir GetFrameWin()->LeaveWait();
2669cdf0e10cSrcweir switch (nErrVal)
2670cdf0e10cSrcweir {
2671cdf0e10cSrcweir case 0: // interner Fehler oder voll Fehler
2672cdf0e10cSrcweir {
2673cdf0e10cSrcweir ErrorMessage(STR_TABINSERT_ERROR);
2674cdf0e10cSrcweir return;
2675cdf0e10cSrcweir }
2676cdf0e10cSrcweir //break;
2677cdf0e10cSrcweir case 2:
2678cdf0e10cSrcweir ErrorMessage(STR_ABSREFLOST);
2679cdf0e10cSrcweir break;
2680cdf0e10cSrcweir case 3:
2681cdf0e10cSrcweir ErrorMessage(STR_NAMECONFLICT);
2682cdf0e10cSrcweir break;
2683cdf0e10cSrcweir case 4:
2684cdf0e10cSrcweir {
2685cdf0e10cSrcweir ErrorMessage(STR_ABSREFLOST);
2686cdf0e10cSrcweir ErrorMessage(STR_NAMECONFLICT);
2687cdf0e10cSrcweir }
2688cdf0e10cSrcweir break;
2689cdf0e10cSrcweir default:
2690cdf0e10cSrcweir break;
2691cdf0e10cSrcweir }
2692cdf0e10cSrcweir //pDestShell->GetUndoManager()->Clear(); //! Undo implementieren !!!
2693cdf0e10cSrcweir /*
2694cdf0e10cSrcweir String sName;
2695cdf0e10cSrcweir pDestDoc->GetName(nDestTab, sName);
2696cdf0e10cSrcweir pDestShell->GetUndoManager()->AddUndoAction(
2697cdf0e10cSrcweir new ScUndoInsertTab( pDestShell, nDestTab, sal_True, sName ) );
2698cdf0e10cSrcweir */
2699cdf0e10cSrcweir if (!bCopy)
2700cdf0e10cSrcweir {
2701cdf0e10cSrcweir if(nTabCount!=nTabSelCount)
2702cdf0e10cSrcweir DeleteTables(TheTabs);// incl. Paint & Undo
2703cdf0e10cSrcweir else
2704cdf0e10cSrcweir ErrorMessage(STR_TABREMOVE_ERROR);
2705cdf0e10cSrcweir }
2706cdf0e10cSrcweir
2707cdf0e10cSrcweir if (bNewDoc)
2708cdf0e10cSrcweir {
2709cdf0e10cSrcweir // ChartListenerCollection must be updated before DeleteTab
2710cdf0e10cSrcweir if ( pDestDoc->IsChartListenerCollectionNeedsUpdate() )
2711cdf0e10cSrcweir pDestDoc->UpdateChartListenerCollection();
2712cdf0e10cSrcweir
2713cdf0e10cSrcweir pDestDoc->DeleteTab(static_cast<SCTAB>(TheTabs.size())); // first old table
2714cdf0e10cSrcweir //? pDestDoc->SelectTable(0, sal_True); // neue erste Tabelle selektieren
2715cdf0e10cSrcweir if (pDestViewSh)
2716cdf0e10cSrcweir pDestViewSh->TabChanged(); // Pages auf dem Drawing-Layer
2717cdf0e10cSrcweir pDestShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB,
2718cdf0e10cSrcweir PAINT_GRID | PAINT_TOP | PAINT_LEFT |
2719cdf0e10cSrcweir PAINT_EXTRAS | PAINT_SIZE );
2720cdf0e10cSrcweir // PAINT_SIZE fuer Gliederung
2721cdf0e10cSrcweir }
2722cdf0e10cSrcweir else
2723cdf0e10cSrcweir {
2724cdf0e10cSrcweir pDestShell->Broadcast( ScTablesHint( SC_TAB_INSERTED, nDestTab ) );
2725cdf0e10cSrcweir pDestShell->PostPaintExtras();
2726cdf0e10cSrcweir pDestShell->PostPaintGridAll();
2727cdf0e10cSrcweir }
2728cdf0e10cSrcweir
2729cdf0e10cSrcweir TheTabs.clear();
2730cdf0e10cSrcweir
2731cdf0e10cSrcweir pDestShell->SetDocumentModified();
2732cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2733cdf0e10cSrcweir }
2734cdf0e10cSrcweir else // within the documents
2735cdf0e10cSrcweir {
2736cdf0e10cSrcweir
2737cdf0e10cSrcweir ScMarkData& rMark = GetViewData()->GetMarkData();
2738cdf0e10cSrcweir SCTAB nTabCount = pDoc->GetTableCount();
2739cdf0e10cSrcweir
2740cdf0e10cSrcweir SvShorts TheTabs;
2741cdf0e10cSrcweir SvShorts TheDestTabs;
2742cdf0e10cSrcweir SvStrings TheTabNames;
2743cdf0e10cSrcweir String aDestName;
2744cdf0e10cSrcweir String *pString;
2745cdf0e10cSrcweir
2746cdf0e10cSrcweir for(SCTAB i=0;i<nTabCount;i++)
2747cdf0e10cSrcweir {
2748cdf0e10cSrcweir if(rMark.GetTableSelect(i))
2749cdf0e10cSrcweir {
2750cdf0e10cSrcweir String aTabName;
2751cdf0e10cSrcweir pDoc->GetName( i, aTabName);
2752cdf0e10cSrcweir TheTabNames.Insert(new String(aTabName),TheTabNames.Count());
2753cdf0e10cSrcweir
2754cdf0e10cSrcweir for(SCTAB j=i+1;j<nTabCount;j++)
2755cdf0e10cSrcweir {
2756cdf0e10cSrcweir if((!pDoc->IsVisible(j))&&(pDoc->IsScenario(j)))
2757cdf0e10cSrcweir {
2758cdf0e10cSrcweir pDoc->GetName( j, aTabName);
2759cdf0e10cSrcweir TheTabNames.Insert(new String(aTabName),TheTabNames.Count());
2760cdf0e10cSrcweir i=j;
2761cdf0e10cSrcweir }
2762cdf0e10cSrcweir else break;
2763cdf0e10cSrcweir }
2764cdf0e10cSrcweir
2765cdf0e10cSrcweir }
2766cdf0e10cSrcweir }
2767cdf0e10cSrcweir
2768cdf0e10cSrcweir if (bCopy && bUndo)
2769cdf0e10cSrcweir pDoc->BeginDrawUndo(); // drawing layer must do its own undo actions
2770cdf0e10cSrcweir
2771cdf0e10cSrcweir pDoc->GetName( nDestTab, aDestName);
2772cdf0e10cSrcweir SCTAB nDestTab1=nDestTab;
2773cdf0e10cSrcweir SCTAB nMovTab=0;
2774cdf0e10cSrcweir for(int j=0;j<TheTabNames.Count();j++)
2775cdf0e10cSrcweir {
2776cdf0e10cSrcweir nTabCount = pDoc->GetTableCount();
2777cdf0e10cSrcweir pString=TheTabNames[sal::static_int_cast<sal_uInt16>(j)];
2778cdf0e10cSrcweir if(!pDoc->GetTable(*pString,nMovTab))
2779cdf0e10cSrcweir {
2780cdf0e10cSrcweir nMovTab=nTabCount;
2781cdf0e10cSrcweir }
2782cdf0e10cSrcweir if(!pDoc->GetTable(aDestName,nDestTab1))
2783cdf0e10cSrcweir {
2784cdf0e10cSrcweir nDestTab1=nTabCount;
2785cdf0e10cSrcweir }
2786cdf0e10cSrcweir pDocShell->MoveTable( nMovTab, nDestTab1, bCopy, sal_False ); // Undo ist hier
2787cdf0e10cSrcweir
2788cdf0e10cSrcweir if(bCopy && pDoc->IsScenario(nMovTab))
2789cdf0e10cSrcweir {
2790cdf0e10cSrcweir String aComment;
2791cdf0e10cSrcweir Color aColor;
2792cdf0e10cSrcweir sal_uInt16 nFlags;
2793cdf0e10cSrcweir
2794cdf0e10cSrcweir pDoc->GetScenarioData(nMovTab, aComment,aColor, nFlags);
2795cdf0e10cSrcweir pDoc->SetScenario(nDestTab1,sal_True);
2796cdf0e10cSrcweir pDoc->SetScenarioData(nDestTab1,aComment,aColor,nFlags);
2797cdf0e10cSrcweir sal_Bool bActive = pDoc->IsActiveScenario(nMovTab );
2798cdf0e10cSrcweir pDoc->SetActiveScenario( nDestTab1, bActive );
2799cdf0e10cSrcweir sal_Bool bVisible=pDoc->IsVisible(nMovTab);
2800cdf0e10cSrcweir pDoc->SetVisible(nDestTab1,bVisible );
2801cdf0e10cSrcweir }
2802cdf0e10cSrcweir
2803cdf0e10cSrcweir TheTabs.push_back(nMovTab);
2804cdf0e10cSrcweir
2805cdf0e10cSrcweir if(!bCopy)
2806cdf0e10cSrcweir {
2807cdf0e10cSrcweir if(!pDoc->GetTable(*pString,nDestTab1))
2808cdf0e10cSrcweir {
2809cdf0e10cSrcweir nDestTab1=nTabCount;
2810cdf0e10cSrcweir }
2811cdf0e10cSrcweir }
2812cdf0e10cSrcweir
2813cdf0e10cSrcweir TheDestTabs.push_back(nDestTab1);
2814cdf0e10cSrcweir delete pString;
2815cdf0e10cSrcweir }
2816cdf0e10cSrcweir
2817cdf0e10cSrcweir nTab = GetViewData()->GetTabNo();
2818cdf0e10cSrcweir
2819cdf0e10cSrcweir if (bUndo)
2820cdf0e10cSrcweir {
2821cdf0e10cSrcweir if (bCopy)
2822cdf0e10cSrcweir {
2823cdf0e10cSrcweir pDocShell->GetUndoManager()->AddUndoAction(
2824cdf0e10cSrcweir new ScUndoCopyTab( pDocShell, TheTabs, TheDestTabs));
2825cdf0e10cSrcweir }
2826cdf0e10cSrcweir else
2827cdf0e10cSrcweir {
2828cdf0e10cSrcweir pDocShell->GetUndoManager()->AddUndoAction(
2829cdf0e10cSrcweir new ScUndoMoveTab( pDocShell, TheTabs, TheDestTabs));
2830cdf0e10cSrcweir }
2831cdf0e10cSrcweir }
2832cdf0e10cSrcweir
2833cdf0e10cSrcweir SCTAB nNewTab = nDestTab;
2834cdf0e10cSrcweir if (nNewTab == SC_TAB_APPEND)
2835cdf0e10cSrcweir nNewTab = pDoc->GetTableCount()-1;
2836cdf0e10cSrcweir else if (!bCopy && nTab<nDestTab)
2837cdf0e10cSrcweir nNewTab--;
2838cdf0e10cSrcweir
2839cdf0e10cSrcweir SetTabNo( nNewTab, sal_True );
2840cdf0e10cSrcweir
2841cdf0e10cSrcweir //#i29848# adjust references to data on the copied sheet
2842cdf0e10cSrcweir if( bCopy )
2843cdf0e10cSrcweir ScChartHelper::AdjustRangesOfChartsOnDestinationPage( pDoc, pDestDoc, nTab, nNewTab );
2844cdf0e10cSrcweir }
2845cdf0e10cSrcweir }
2846cdf0e10cSrcweir
2847cdf0e10cSrcweir
2848cdf0e10cSrcweir //----------------------------------------------------------------------------
2849cdf0e10cSrcweir
ShowTable(const String & rName)2850cdf0e10cSrcweir void ScViewFunc::ShowTable( const String& rName )
2851cdf0e10cSrcweir {
2852cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2853cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2854cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
2855cdf0e10cSrcweir sal_Bool bFound = sal_False;
2856cdf0e10cSrcweir SCTAB nPos = 0;
2857cdf0e10cSrcweir String aTabName;
2858cdf0e10cSrcweir SCTAB nCount = pDoc->GetTableCount();
2859cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
2860cdf0e10cSrcweir {
2861cdf0e10cSrcweir pDoc->GetName( i, aTabName );
2862cdf0e10cSrcweir if ( aTabName == rName )
2863cdf0e10cSrcweir {
2864cdf0e10cSrcweir nPos = i;
2865cdf0e10cSrcweir bFound = sal_True;
2866cdf0e10cSrcweir }
2867cdf0e10cSrcweir }
2868cdf0e10cSrcweir
2869cdf0e10cSrcweir if (bFound)
2870cdf0e10cSrcweir {
2871cdf0e10cSrcweir pDoc->SetVisible( nPos, sal_True );
2872cdf0e10cSrcweir if (bUndo)
2873cdf0e10cSrcweir {
2874cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction( new ScUndoShowHideTab( pDocSh, nPos, sal_True ) );
2875cdf0e10cSrcweir }
2876cdf0e10cSrcweir SetTabNo( nPos, sal_True );
2877cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2878cdf0e10cSrcweir pDocSh->PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_EXTRAS);
2879cdf0e10cSrcweir pDocSh->SetDocumentModified();
2880cdf0e10cSrcweir }
2881cdf0e10cSrcweir else
2882cdf0e10cSrcweir Sound::Beep();
2883cdf0e10cSrcweir }
2884cdf0e10cSrcweir
2885cdf0e10cSrcweir
2886cdf0e10cSrcweir //----------------------------------------------------------------------------
2887cdf0e10cSrcweir
HideTable(SCTAB nTab)2888cdf0e10cSrcweir void ScViewFunc::HideTable( SCTAB nTab )
2889cdf0e10cSrcweir {
2890cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
2891cdf0e10cSrcweir ScDocument* pDoc = pDocSh->GetDocument();
2892cdf0e10cSrcweir sal_Bool bUndo(pDoc->IsUndoEnabled());
2893cdf0e10cSrcweir SCTAB nVisible = 0;
2894cdf0e10cSrcweir SCTAB nCount = pDoc->GetTableCount();
2895cdf0e10cSrcweir for (SCTAB i=0; i<nCount; i++)
2896cdf0e10cSrcweir {
2897cdf0e10cSrcweir if (pDoc->IsVisible(i))
2898cdf0e10cSrcweir ++nVisible;
2899cdf0e10cSrcweir }
2900cdf0e10cSrcweir
2901cdf0e10cSrcweir if (nVisible > 1)
2902cdf0e10cSrcweir {
2903cdf0e10cSrcweir pDoc->SetVisible( nTab, sal_False );
2904cdf0e10cSrcweir if (bUndo)
2905cdf0e10cSrcweir {
2906cdf0e10cSrcweir pDocSh->GetUndoManager()->AddUndoAction( new ScUndoShowHideTab( pDocSh, nTab, sal_False ) );
2907cdf0e10cSrcweir }
2908cdf0e10cSrcweir
2909cdf0e10cSrcweir // Views updaten:
2910cdf0e10cSrcweir pDocSh->Broadcast( ScTablesHint( SC_TAB_HIDDEN, nTab ) );
2911cdf0e10cSrcweir
2912cdf0e10cSrcweir SetTabNo( nTab, sal_True );
2913cdf0e10cSrcweir SFX_APP()->Broadcast( SfxSimpleHint( SC_HINT_TABLES_CHANGED ) );
2914cdf0e10cSrcweir pDocSh->PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB, PAINT_EXTRAS);
2915cdf0e10cSrcweir pDocSh->SetDocumentModified();
2916cdf0e10cSrcweir }
2917cdf0e10cSrcweir else
2918cdf0e10cSrcweir Sound::Beep();
2919cdf0e10cSrcweir }
2920cdf0e10cSrcweir
2921cdf0e10cSrcweir
2922cdf0e10cSrcweir //----------------------------------------------------------------------------
2923cdf0e10cSrcweir
InsertSpecialChar(const String & rStr,const Font & rFont)2924cdf0e10cSrcweir void ScViewFunc::InsertSpecialChar( const String& rStr, const Font& rFont )
2925cdf0e10cSrcweir {
2926cdf0e10cSrcweir ScEditableTester aTester( this );
2927cdf0e10cSrcweir if (!aTester.IsEditable())
2928cdf0e10cSrcweir {
2929cdf0e10cSrcweir ErrorMessage(aTester.GetMessageId());
2930cdf0e10cSrcweir return;
2931cdf0e10cSrcweir }
2932cdf0e10cSrcweir
2933cdf0e10cSrcweir const sal_Unicode* pChar = rStr.GetBuffer();
2934cdf0e10cSrcweir ScTabViewShell* pViewShell = GetViewData()->GetViewShell();
2935cdf0e10cSrcweir SvxFontItem aFontItem( rFont.GetFamily(),
2936cdf0e10cSrcweir rFont.GetName(),
2937cdf0e10cSrcweir rFont.GetStyleName(),
2938cdf0e10cSrcweir rFont.GetPitch(),
2939cdf0e10cSrcweir rFont.GetCharSet(),
2940cdf0e10cSrcweir ATTR_FONT );
2941cdf0e10cSrcweir
2942cdf0e10cSrcweir // if string contains WEAK characters, set all fonts
2943cdf0e10cSrcweir sal_uInt8 nScript;
2944cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
2945cdf0e10cSrcweir if ( pDoc->HasStringWeakCharacters( rStr ) )
2946cdf0e10cSrcweir nScript = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
2947cdf0e10cSrcweir else
2948cdf0e10cSrcweir nScript = pDoc->GetStringScriptType( rStr );
2949cdf0e10cSrcweir
2950cdf0e10cSrcweir SvxScriptSetItem aSetItem( SID_ATTR_CHAR_FONT, pViewShell->GetPool() );
2951cdf0e10cSrcweir aSetItem.PutItemForScriptType( nScript, aFontItem );
2952cdf0e10cSrcweir ApplyUserItemSet( aSetItem.GetItemSet() );
2953cdf0e10cSrcweir
2954cdf0e10cSrcweir while ( *pChar )
2955cdf0e10cSrcweir pViewShell->TabKeyInput( KeyEvent( *(pChar++), KeyCode() ) );
2956cdf0e10cSrcweir }
2957cdf0e10cSrcweir
2958cdf0e10cSrcweir
2959cdf0e10cSrcweir //----------------------------------------------------------------------------
2960cdf0e10cSrcweir
UpdateLineAttrs(SvxBorderLine & rLine,const SvxBorderLine * pDestLine,const SvxBorderLine * pSrcLine,sal_Bool bColor)2961cdf0e10cSrcweir void ScViewFunc::UpdateLineAttrs( SvxBorderLine& rLine,
2962cdf0e10cSrcweir const SvxBorderLine* pDestLine,
2963cdf0e10cSrcweir const SvxBorderLine* pSrcLine,
2964cdf0e10cSrcweir sal_Bool bColor )
2965cdf0e10cSrcweir {
2966cdf0e10cSrcweir if ( pSrcLine && pDestLine )
2967cdf0e10cSrcweir {
2968cdf0e10cSrcweir if ( bColor )
2969cdf0e10cSrcweir {
2970cdf0e10cSrcweir rLine.SetColor ( pSrcLine->GetColor() );
2971cdf0e10cSrcweir rLine.SetOutWidth ( pDestLine->GetOutWidth() );
2972cdf0e10cSrcweir rLine.SetInWidth ( pDestLine->GetInWidth() );
2973cdf0e10cSrcweir rLine.SetDistance ( pDestLine->GetDistance() );
2974cdf0e10cSrcweir }
2975cdf0e10cSrcweir else
2976cdf0e10cSrcweir {
2977cdf0e10cSrcweir rLine.SetColor ( pDestLine->GetColor() );
2978cdf0e10cSrcweir rLine.SetOutWidth ( pSrcLine->GetOutWidth() );
2979cdf0e10cSrcweir rLine.SetInWidth ( pSrcLine->GetInWidth() );
2980cdf0e10cSrcweir rLine.SetDistance ( pSrcLine->GetDistance() );
2981cdf0e10cSrcweir }
2982cdf0e10cSrcweir }
2983cdf0e10cSrcweir }
2984cdf0e10cSrcweir
2985cdf0e10cSrcweir
2986cdf0e10cSrcweir #define SET_LINE_ATTRIBUTES(LINE,BOXLINE) \
2987cdf0e10cSrcweir pBoxLine = aBoxItem.Get##LINE(); \
2988cdf0e10cSrcweir if ( pBoxLine ) \
2989cdf0e10cSrcweir { \
2990cdf0e10cSrcweir if ( pLine ) \
2991cdf0e10cSrcweir { \
2992cdf0e10cSrcweir UpdateLineAttrs( aLine, pBoxLine, pLine, bColorOnly ); \
2993cdf0e10cSrcweir aBoxItem.SetLine( &aLine, BOXLINE ); \
2994cdf0e10cSrcweir } \
2995cdf0e10cSrcweir else \
2996cdf0e10cSrcweir aBoxItem.SetLine( NULL, BOXLINE ); \
2997cdf0e10cSrcweir }
2998cdf0e10cSrcweir
2999cdf0e10cSrcweir
3000cdf0e10cSrcweir //----------------------------------------------------------------------------
3001cdf0e10cSrcweir
SetSelectionFrameLines(const SvxBorderLine * pLine,sal_Bool bColorOnly)3002cdf0e10cSrcweir void ScViewFunc::SetSelectionFrameLines( const SvxBorderLine* pLine,
3003cdf0e10cSrcweir sal_Bool bColorOnly )
3004cdf0e10cSrcweir {
3005cdf0e10cSrcweir // nur wegen Matrix nicht editierbar? Attribute trotzdem ok
3006cdf0e10cSrcweir sal_Bool bOnlyNotBecauseOfMatrix;
3007cdf0e10cSrcweir if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
3008cdf0e10cSrcweir {
3009cdf0e10cSrcweir ErrorMessage(STR_PROTECTIONERR);
3010cdf0e10cSrcweir return;
3011cdf0e10cSrcweir }
3012cdf0e10cSrcweir
3013cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
3014cdf0e10cSrcweir ScMarkData aFuncMark( GetViewData()->GetMarkData() ); // local copy for UnmarkFiltered
3015cdf0e10cSrcweir ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
3016cdf0e10cSrcweir ScDocShell* pDocSh = GetViewData()->GetDocShell();
3017cdf0e10cSrcweir const ScPatternAttr* pSelAttrs = GetSelectionPattern();
3018cdf0e10cSrcweir const SfxItemSet& rSelItemSet = pSelAttrs->GetItemSet();
3019cdf0e10cSrcweir
3020cdf0e10cSrcweir const SfxPoolItem* pBorderAttr = NULL;
3021cdf0e10cSrcweir SfxItemState eItemState = rSelItemSet.GetItemState( ATTR_BORDER, sal_True, &pBorderAttr );
3022cdf0e10cSrcweir
3023cdf0e10cSrcweir const SfxPoolItem* pTLBRItem = 0;
3024cdf0e10cSrcweir SfxItemState eTLBRState = rSelItemSet.GetItemState( ATTR_BORDER_TLBR, sal_True, &pTLBRItem );
3025cdf0e10cSrcweir
3026cdf0e10cSrcweir const SfxPoolItem* pBLTRItem = 0;
3027cdf0e10cSrcweir SfxItemState eBLTRState = rSelItemSet.GetItemState( ATTR_BORDER_BLTR, sal_True, &pBLTRItem );
3028cdf0e10cSrcweir
3029cdf0e10cSrcweir // any of the lines visible?
3030cdf0e10cSrcweir if( (eItemState != SFX_ITEM_DEFAULT) || (eTLBRState != SFX_ITEM_DEFAULT) || (eBLTRState != SFX_ITEM_DEFAULT) )
3031cdf0e10cSrcweir {
3032cdf0e10cSrcweir // none of the lines don't care?
3033cdf0e10cSrcweir if( (eItemState != SFX_ITEM_DONTCARE) && (eTLBRState != SFX_ITEM_DONTCARE) && (eBLTRState != SFX_ITEM_DONTCARE) )
3034cdf0e10cSrcweir {
3035cdf0e10cSrcweir SfxItemSet* pOldSet = new SfxItemSet(
3036cdf0e10cSrcweir *(pDoc->GetPool()),
3037cdf0e10cSrcweir ATTR_PATTERN_START,
3038cdf0e10cSrcweir ATTR_PATTERN_END );
3039cdf0e10cSrcweir SfxItemSet* pNewSet = new SfxItemSet(
3040cdf0e10cSrcweir *(pDoc->GetPool()),
3041cdf0e10cSrcweir ATTR_PATTERN_START,
3042cdf0e10cSrcweir ATTR_PATTERN_END );
3043cdf0e10cSrcweir
3044cdf0e10cSrcweir //------------------------------------------------------------
3045cdf0e10cSrcweir const SvxBorderLine* pBoxLine = NULL;
3046cdf0e10cSrcweir SvxBorderLine aLine;
3047cdf0e10cSrcweir
3048cdf0e10cSrcweir // hier wird die pBoxLine benutzt:
3049cdf0e10cSrcweir
3050cdf0e10cSrcweir if( pBorderAttr )
3051cdf0e10cSrcweir {
3052cdf0e10cSrcweir SvxBoxItem aBoxItem( *(const SvxBoxItem*)pBorderAttr );
3053cdf0e10cSrcweir SvxBoxInfoItem aBoxInfoItem( ATTR_BORDER_INNER );
3054cdf0e10cSrcweir
3055cdf0e10cSrcweir SET_LINE_ATTRIBUTES(Top,BOX_LINE_TOP)
3056cdf0e10cSrcweir SET_LINE_ATTRIBUTES(Bottom,BOX_LINE_BOTTOM)
3057cdf0e10cSrcweir SET_LINE_ATTRIBUTES(Left,BOX_LINE_LEFT)
3058cdf0e10cSrcweir SET_LINE_ATTRIBUTES(Right,BOX_LINE_RIGHT)
3059cdf0e10cSrcweir
3060cdf0e10cSrcweir aBoxInfoItem.SetLine( aBoxItem.GetTop(), BOXINFO_LINE_HORI );
3061cdf0e10cSrcweir aBoxInfoItem.SetLine( aBoxItem.GetLeft(), BOXINFO_LINE_VERT );
3062cdf0e10cSrcweir aBoxInfoItem.ResetFlags(); // Lines auf Valid setzen
3063cdf0e10cSrcweir
3064cdf0e10cSrcweir pOldSet->Put( *pBorderAttr );
3065cdf0e10cSrcweir pNewSet->Put( aBoxItem );
3066cdf0e10cSrcweir pNewSet->Put( aBoxInfoItem );
3067cdf0e10cSrcweir }
3068cdf0e10cSrcweir
3069cdf0e10cSrcweir if( pTLBRItem && ((const SvxLineItem*)pTLBRItem)->GetLine() )
3070cdf0e10cSrcweir {
3071cdf0e10cSrcweir SvxLineItem aTLBRItem( *(const SvxLineItem*)pTLBRItem );
3072cdf0e10cSrcweir UpdateLineAttrs( aLine, aTLBRItem.GetLine(), pLine, bColorOnly );
3073cdf0e10cSrcweir aTLBRItem.SetLine( &aLine );
3074cdf0e10cSrcweir pOldSet->Put( *pTLBRItem );
3075cdf0e10cSrcweir pNewSet->Put( aTLBRItem );
3076cdf0e10cSrcweir }
3077cdf0e10cSrcweir
3078cdf0e10cSrcweir if( pBLTRItem && ((const SvxLineItem*)pBLTRItem)->GetLine() )
3079cdf0e10cSrcweir {
3080cdf0e10cSrcweir SvxLineItem aBLTRItem( *(const SvxLineItem*)pBLTRItem );
3081cdf0e10cSrcweir UpdateLineAttrs( aLine, aBLTRItem.GetLine(), pLine, bColorOnly );
3082cdf0e10cSrcweir aBLTRItem.SetLine( &aLine );
3083cdf0e10cSrcweir pOldSet->Put( *pBLTRItem );
3084cdf0e10cSrcweir pNewSet->Put( aBLTRItem );
3085cdf0e10cSrcweir }
3086cdf0e10cSrcweir
3087cdf0e10cSrcweir ApplyAttributes( pNewSet, pOldSet );
3088cdf0e10cSrcweir
3089cdf0e10cSrcweir delete pOldSet;
3090cdf0e10cSrcweir delete pNewSet;
3091cdf0e10cSrcweir }
3092cdf0e10cSrcweir else // if ( eItemState == SFX_ITEM_DONTCARE )
3093cdf0e10cSrcweir {
3094cdf0e10cSrcweir aFuncMark.MarkToMulti();
3095cdf0e10cSrcweir pDoc->ApplySelectionLineStyle( aFuncMark, pLine, bColorOnly );
3096cdf0e10cSrcweir }
3097cdf0e10cSrcweir
3098cdf0e10cSrcweir ScRange aMarkRange;
3099cdf0e10cSrcweir aFuncMark.GetMultiMarkArea( aMarkRange );
3100cdf0e10cSrcweir SCCOL nStartCol = aMarkRange.aStart.Col();
3101cdf0e10cSrcweir SCROW nStartRow = aMarkRange.aStart.Row();
3102cdf0e10cSrcweir SCTAB nStartTab = aMarkRange.aStart.Tab();
3103cdf0e10cSrcweir SCCOL nEndCol = aMarkRange.aEnd.Col();
3104cdf0e10cSrcweir SCROW nEndRow = aMarkRange.aEnd.Row();
3105cdf0e10cSrcweir SCTAB nEndTab = aMarkRange.aEnd.Tab();
3106cdf0e10cSrcweir pDocSh->PostPaint( nStartCol, nStartRow, nStartTab,
3107cdf0e10cSrcweir nEndCol, nEndRow, nEndTab,
3108cdf0e10cSrcweir PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE );
3109cdf0e10cSrcweir
3110cdf0e10cSrcweir pDocSh->UpdateOle( GetViewData() );
3111cdf0e10cSrcweir pDocSh->SetDocumentModified();
3112cdf0e10cSrcweir }
3113cdf0e10cSrcweir }
3114cdf0e10cSrcweir
3115cdf0e10cSrcweir #undef SET_LINE_ATTRIBUTES
3116cdf0e10cSrcweir
3117cdf0e10cSrcweir
3118cdf0e10cSrcweir //----------------------------------------------------------------------------
3119cdf0e10cSrcweir
SetConditionalFormat(const ScConditionalFormat & rNew)3120cdf0e10cSrcweir void ScViewFunc::SetConditionalFormat( const ScConditionalFormat& rNew )
3121cdf0e10cSrcweir {
3122cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
3123cdf0e10cSrcweir sal_uLong nIndex = pDoc->AddCondFormat(rNew); // dafuer gibt's kein Undo
3124cdf0e10cSrcweir SfxUInt32Item aItem( ATTR_CONDITIONAL, nIndex );
3125cdf0e10cSrcweir
3126cdf0e10cSrcweir ApplyAttr( aItem ); // mit Paint und Undo...
3127cdf0e10cSrcweir }
3128cdf0e10cSrcweir
3129cdf0e10cSrcweir
3130cdf0e10cSrcweir //----------------------------------------------------------------------------
3131cdf0e10cSrcweir
SetValidation(const ScValidationData & rNew)3132cdf0e10cSrcweir void ScViewFunc::SetValidation( const ScValidationData& rNew )
3133cdf0e10cSrcweir {
3134cdf0e10cSrcweir ScDocument* pDoc = GetViewData()->GetDocument();
3135cdf0e10cSrcweir sal_uLong nIndex = pDoc->AddValidationEntry(rNew); // dafuer gibt's kein Undo
3136cdf0e10cSrcweir SfxUInt32Item aItem( ATTR_VALIDDATA, nIndex );
3137cdf0e10cSrcweir
3138cdf0e10cSrcweir ApplyAttr( aItem ); // mit Paint und Undo...
3139cdf0e10cSrcweir }
3140cdf0e10cSrcweir
3141cdf0e10cSrcweir
3142