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