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