?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update git submodules
[LibreOffice.git] / sc / source / ui / view / viewfun3.cxx
blob3100441093b7c4e0b966b3b1ba127163cbf552ee
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <scitems.hxx>
21 #include <svx/svdpage.hxx>
22 #include <sfx2/docfile.hxx>
23 #include <comphelper/classids.hxx>
24 #include <comphelper/lok.hxx>
25 #include <sot/formats.hxx>
26 #include <sot/storage.hxx>
27 #include <vcl/graph.hxx>
28 #include <vcl/svapp.hxx>
29 #include <vcl/weld.hxx>
30 #include <tools/urlobj.hxx>
31 #include <sot/exchange.hxx>
32 #include <memory>
33 #include <vcl/uitest/logger.hxx>
34 #include <vcl/uitest/eventdescription.hxx>
35 #include <vcl/TypeSerializer.hxx>
36 #include <osl/diagnose.h>
37
38 #include <attrib.hxx>
39 #include <patattr.hxx>
40 #include <dociter.hxx>
41 #include <viewfunc.hxx>
42 #include <tabvwsh.hxx>
43 #include <docsh.hxx>
44 #include <docfunc.hxx>
45 #include <undoblk.hxx>
46 #include <refundo.hxx>
47 #include <globstr.hrc>
48 #include <scresid.hxx>
49 #include <global.hxx>
50 #include <transobj.hxx>
51 #include <drwtrans.hxx>
52 #include <chgtrack.hxx>
53 #include <waitoff.hxx>
54 #include <scmod.hxx>
55 #include <inputopt.hxx>
56 #include <warnbox.hxx>
57 #include <drwlayer.hxx>
58 #include <editable.hxx>
59 #include <docuno.hxx>
60 #include <clipparam.hxx>
61 #include <undodat.hxx>
62 #include <drawview.hxx>
63 #include <cliputil.hxx>
64 #include <clipoptions.hxx>
65 #include <gridwin.hxx>
66 #include <com/sun/star/util/XCloneable.hpp>
67
68 using namespace com::sun::star;
69
70 namespace {
71
72 void collectUIInformation(std::map<OUString, OUString>&& aParameters, const OUString& action)
73 {
74 EventDescription aDescription;
75 aDescription.aID = "grid_window";
76 aDescription.aAction = action;
77 aDescription.aParameters = std::move(aParameters);
78 aDescription.aParent = "MainWindow";
79 aDescription.aKeyWord = "ScGridWinUIObject";
80
81 UITestLogger::getInstance().logEvent(aDescription);
82 }
83
84 }
85
86 // GlobalName of writer-DocShell from comphelper/classids.hxx
87
88 // C U T
89
90 void ScViewFunc::CutToClip()
91 {
92 UpdateInputLine();
93
94 ScEditableTester aTester( this );
95 if (!aTester.IsEditable()) // selection editable?
96 {
97 ErrorMessage( aTester.GetMessageId() );
98 return;
99 }
100
101 ScRange aRange; // delete this range
102 if ( GetViewData().GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
103 {
104 ScDocument& rDoc = GetViewData().GetDocument();
105 ScDocShell* pDocSh = GetViewData().GetDocShell();
106 ScMarkData& rMark = GetViewData().GetMarkData();
107 const bool bRecord(rDoc.IsUndoEnabled()); // Undo/Redo
108
109 ScDocShellModificator aModificator( *pDocSh );
110
111 if ( !rMark.IsMarked() && !rMark.IsMultiMarked() ) // mark the range if not marked yet
112 {
113 DoneBlockMode();
114 InitOwnBlockMode( aRange );
115 rMark.SetMarkArea( aRange );
116 MarkDataChanged();
117 }
118
119 CopyToClip( nullptr, true, false, true/*bIncludeObjects*/ ); // copy to clipboard
120
121 ScAddress aOldEnd( aRange.aEnd ); // combined cells in this range?
122 rDoc.ExtendMerge( aRange, true );
123
124 ScDocumentUniquePtr pUndoDoc;
125 if ( bRecord )
126 {
127 pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
128 pUndoDoc->InitUndoSelected( rDoc, rMark );
129 // all sheets - CopyToDocument skips those that don't exist in pUndoDoc
130 ScRange aCopyRange = aRange;
131 aCopyRange.aStart.SetTab(0);
132 aCopyRange.aEnd.SetTab(rDoc.GetTableCount()-1);
133 rDoc.CopyToDocument( aCopyRange, (InsertDeleteFlags::ALL & ~InsertDeleteFlags::OBJECTS) | InsertDeleteFlags::NOCAPTIONS, false, *pUndoDoc );
134 rDoc.BeginDrawUndo();
135 }
136
137 sal_uInt16 nExtFlags = 0;
138 pDocSh->UpdatePaintExt( nExtFlags, aRange );
139
140 rMark.MarkToMulti();
141 rDoc.DeleteSelection( InsertDeleteFlags::ALL, rMark );
142 rDoc.DeleteObjectsInSelection( rMark );
143 rMark.MarkToSimple();
144
145 if ( !AdjustRowHeight( aRange.aStart.Row(), aRange.aEnd.Row(), true ) )
146 pDocSh->PostPaint( aRange, PaintPartFlags::Grid, nExtFlags );
147
148 if ( bRecord ) // Draw-Undo now available
149 pDocSh->GetUndoManager()->AddUndoAction(
150 std::make_unique<ScUndoCut>( pDocSh, aRange, aOldEnd, rMark, std::move(pUndoDoc) ) );
151
152 aModificator.SetDocumentModified();
153 pDocSh->UpdateOle(GetViewData());
154
155 CellContentChanged();
156
157 OUString aStartAddress = aRange.aStart.GetColRowString();
158 OUString aEndAddress = aRange.aEnd.GetColRowString();
159
160 collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, u"CUT"_ustr);
161 }
162 else
163 ErrorMessage( STR_NOMULTISELECT );
164 }
165
166 // C O P Y
167
168 bool ScViewFunc::CopyToClip( ScDocument* pClipDoc, bool bCut, bool bApi, bool bIncludeObjects, bool bStopEdit )
169 {
170 ScRange aRange;
171 ScMarkType eMarkType = GetViewData().GetSimpleArea( aRange );
172 ScMarkData& rMark = GetViewData().GetMarkData();
173 bool bDone = false;
174
175 if ( eMarkType == SC_MARK_SIMPLE || eMarkType == SC_MARK_SIMPLE_FILTERED )
176 {
177 ScRangeList aRangeList( aRange );
178 bDone = CopyToClip( pClipDoc, aRangeList, bCut, bApi, bIncludeObjects, bStopEdit );
179 }
180 else if (eMarkType == SC_MARK_MULTI)
181 {
182 ScRangeList aRangeList;
183 rMark.MarkToSimple();
184 rMark.FillRangeListWithMarks(&aRangeList, false);
185 bDone = CopyToClip( pClipDoc, aRangeList, bCut, bApi, bIncludeObjects, bStopEdit );
186 }
187 else
188 {
189 if (!bApi)
190 ErrorMessage(STR_NOMULTISELECT);
191 }
192 if( !bCut ){
193 OUString aStartAddress = aRange.aStart.GetColRowString();
194 OUString aEndAddress = aRange.aEnd.GetColRowString();
195 collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, u"COPY"_ustr);
196 }
197 return bDone;
198 }
199
200 // Copy the content of the Range into clipboard.
201 bool ScViewFunc::CopyToClip( ScDocument* pClipDoc, const ScRangeList& rRanges, bool bCut, bool bApi, bool bIncludeObjects, bool bStopEdit )
202 {
203 if ( rRanges.empty() )
204 return false;
205 if ( bStopEdit )
206 UpdateInputLine();
207
208 bool bDone;
209 if (rRanges.size() > 1) // isMultiRange
210 bDone = CopyToClipMultiRange(pClipDoc, rRanges, bCut, bApi, bIncludeObjects);
211 else
212 bDone = CopyToClipSingleRange(pClipDoc, rRanges, bCut, bIncludeObjects);
213
214 return bDone;
215 }
216
217 bool ScViewFunc::CopyToClipSingleRange( ScDocument* pClipDoc, const ScRangeList& rRanges, bool bCut, bool bIncludeObjects )
218 {
219 ScRange aRange = rRanges[0];
220 ScClipParam aClipParam( aRange, bCut );
221 aClipParam.maRanges = rRanges;
222 ScDocument& rDoc = GetViewData().GetDocument();
223 ScMarkData& rMark = GetViewData().GetMarkData();
224
225 if (rDoc.HasSelectedBlockMatrixFragment( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), rMark ) )
226 return false;
227
228 std::shared_ptr<ScDocument> pSysClipDoc;
229 if ( !pClipDoc ) // no clip doc specified
230 {
231 // Create one (deleted by ScTransferObj), and copy into system.
232 pSysClipDoc = std::make_shared<ScDocument>( SCDOCMODE_CLIP );
233 pClipDoc = pSysClipDoc.get();
234 }
235 if ( !bCut )
236 {
237 ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
238 if ( pChangeTrack )
239 pChangeTrack->ResetLastCut();
240 }
241
242 if ( pSysClipDoc && bIncludeObjects )
243 {
244 bool bAnyOle = rDoc.HasOLEObjectsInArea( aRange );
245 // Update ScGlobal::xDrawClipDocShellRef.
246 ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle, pSysClipDoc ) );
247 }
248
249 // is this necessary?, will setting the doc id upset the
250 // following paste operation with range? would be nicer to just set this always
251 // and lose the 'if' above
252 aClipParam.setSourceDocID( rDoc.GetDocumentID() );
253
254 if (ScDocShell* pObjectShell = rDoc.GetDocumentShell())
255 {
256 // Copy document properties from pObjectShell to pClipDoc (to its clip options, as it has no object shell).
257 uno::Reference<util::XCloneable> xCloneable(pObjectShell->getDocProperties(), uno::UNO_QUERY_THROW);
258 std::unique_ptr<ScClipOptions> pOptions(new ScClipOptions);
259 pOptions->m_xDocumentProperties.set(xCloneable->createClone(), uno::UNO_QUERY);
260 pClipDoc->SetClipOptions(std::move(pOptions));
261 }
262
263 rDoc.CopyToClip( aClipParam, pClipDoc, &rMark, false, bIncludeObjects );
264 if (ScDrawLayer* pDrawLayer = pClipDoc->GetDrawLayer())
265 {
266 ScClipParam& rClipDocClipParam = pClipDoc->GetClipParam();
267 ScRangeListVector& rRangesVector = rClipDocClipParam.maProtectedChartRangesVector;
268 SCTAB nTabCount = pClipDoc->GetTableCount();
269 for ( SCTAB nTab = 0; nTab < nTabCount; ++nTab )
270 {
271 SdrPage* pPage = pDrawLayer->GetPage( static_cast< sal_uInt16 >( nTab ) );
272 if ( pPage )
273 {
274 ScChartHelper::FillProtectedChartRangesVector( rRangesVector, rDoc, pPage );
275 }
276 }
277 }
278
279 if ( pSysClipDoc )
280 {
281 ScDrawLayer::SetGlobalDrawPersist(nullptr);
282 ScGlobal::SetClipDocName( rDoc.GetDocumentShell()->GetTitle( SFX_TITLE_FULLNAME ) );
283 }
284 pClipDoc->ExtendMerge( aRange, true );
285
286 if ( pSysClipDoc )
287 {
288 ScDocShell* pDocSh = GetViewData().GetDocShell();
289 TransferableObjectDescriptor aObjDesc;
290 pDocSh->FillTransferableObjectDescriptor( aObjDesc );
291 aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
292 // maSize is set in ScTransferObj ctor
293
294 rtl::Reference<ScTransferObj> pTransferObj(new ScTransferObj( pSysClipDoc, std::move(aObjDesc) ));
295 if ( ScGlobal::xDrawClipDocShellRef.is() )
296 {
297 SfxObjectShellRef aPersistRef(ScGlobal::xDrawClipDocShellRef);
298 pTransferObj->SetDrawPersist( aPersistRef );// keep persist for ole objects alive
299 }
300 pTransferObj->CopyToClipboard( GetActiveWin() );
301 }
302
303 return true;
304 }
305
306 bool ScViewFunc::CopyToClipMultiRange( const ScDocument* pInputClipDoc, const ScRangeList& rRanges, bool bCut, bool bApi, bool bIncludeObjects )
307 {
308 if (bCut)
309 {
310 // We don't support cutting of multi-selections.
311 if (!bApi)
312 ErrorMessage(STR_NOMULTISELECT);
313 return false;
314 }
315 if (pInputClipDoc)
316 {
317 // TODO: What's this for?
318 if (!bApi)
319 ErrorMessage(STR_NOMULTISELECT);
320 return false;
321 }
322
323 ScClipParam aClipParam( rRanges[0], bCut );
324 aClipParam.maRanges = rRanges;
325 ScDocument& rDoc = GetViewData().GetDocument();
326 ScMarkData& rMark = GetViewData().GetMarkData();
327 bool bDone = false;
328 bool bSuccess = false;
329 aClipParam.mbCutMode = false;
330
331 do
332 {
333 ScDocumentUniquePtr pDocClip(new ScDocument(SCDOCMODE_CLIP));
334
335 // Check for geometrical feasibility of the ranges.
336 bool bValidRanges = true;
337 ScRange const * p = &aClipParam.maRanges.front();
338 SCCOL nPrevColDelta = 0;
339 SCROW nPrevRowDelta = 0;
340 SCCOL nPrevCol = p->aStart.Col();
341 SCROW nPrevRow = p->aStart.Row();
342 SCCOL nPrevColSize = p->aEnd.Col() - p->aStart.Col() + 1;
343 SCROW nPrevRowSize = p->aEnd.Row() - p->aStart.Row() + 1;
344 for ( size_t i = 1; i < aClipParam.maRanges.size(); ++i )
345 {
346 p = &aClipParam.maRanges[i];
347 if ( rDoc.HasSelectedBlockMatrixFragment(
348 p->aStart.Col(), p->aStart.Row(), p->aEnd.Col(), p->aEnd.Row(), rMark) )
349 {
350 if (!bApi)
351 ErrorMessage(STR_MATRIXFRAGMENTERR);
352 return false;
353 }
354
355 SCCOL nColDelta = p->aStart.Col() - nPrevCol;
356 SCROW nRowDelta = p->aStart.Row() - nPrevRow;
357
358 if ((nColDelta && nRowDelta) || (nPrevColDelta && nRowDelta) || (nPrevRowDelta && nColDelta))
359 {
360 bValidRanges = false;
361 break;
362 }
363
364 if (aClipParam.meDirection == ScClipParam::Unspecified)
365 {
366 if (nColDelta)
367 aClipParam.meDirection = ScClipParam::Column;
368 if (nRowDelta)
369 aClipParam.meDirection = ScClipParam::Row;
370 }
371
372 SCCOL nColSize = p->aEnd.Col() - p->aStart.Col() + 1;
373 SCROW nRowSize = p->aEnd.Row() - p->aStart.Row() + 1;
374
375 if (aClipParam.meDirection == ScClipParam::Column && nRowSize != nPrevRowSize)
376 {
377 // column-oriented ranges must have identical row size.
378 bValidRanges = false;
379 break;
380 }
381 if (aClipParam.meDirection == ScClipParam::Row && nColSize != nPrevColSize)
382 {
383 // likewise, row-oriented ranges must have identical
384 // column size.
385 bValidRanges = false;
386 break;
387 }
388
389 nPrevCol = p->aStart.Col();
390 nPrevRow = p->aStart.Row();
391 nPrevColDelta = nColDelta;
392 nPrevRowDelta = nRowDelta;
393 nPrevColSize = nColSize;
394 nPrevRowSize = nRowSize;
395 }
396 if (!bValidRanges)
397 break;
398 rDoc.CopyToClip(aClipParam, pDocClip.get(), &rMark, false, bIncludeObjects );
399
400 ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
401 if ( pChangeTrack )
402 pChangeTrack->ResetLastCut(); // no more cut-mode
403
404 ScDocShell* pDocSh = GetViewData().GetDocShell();
405 TransferableObjectDescriptor aObjDesc;
406 pDocSh->FillTransferableObjectDescriptor( aObjDesc );
407 aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
408 // maSize is set in ScTransferObj ctor
409
410 rtl::Reference<ScTransferObj> pTransferObj(new ScTransferObj( std::move(pDocClip), std::move(aObjDesc) ));
411 if ( ScGlobal::xDrawClipDocShellRef.is() )
412 {
413 SfxObjectShellRef aPersistRef(ScGlobal::xDrawClipDocShellRef);
414 pTransferObj->SetDrawPersist( aPersistRef ); // keep persist for ole objects alive
415 }
416 pTransferObj->CopyToClipboard( GetActiveWin() ); // system clipboard
417
418 bSuccess = true;
419 }
420 while (false);
421
422 if (!bSuccess && !bApi)
423 ErrorMessage(STR_NOMULTISELECT);
424
425 bDone = bSuccess;
426
427 return bDone;
428 }
429
430 rtl::Reference<ScTransferObj> ScViewFunc::CopyToTransferable()
431 {
432 ScRange aRange;
433 auto eMarkType = GetViewData().GetSimpleArea( aRange );
434 if ( eMarkType == SC_MARK_SIMPLE || eMarkType == SC_MARK_SIMPLE_FILTERED )
435 {
436 ScDocument& rDoc = GetViewData().GetDocument();
437 ScMarkData& rMark = GetViewData().GetMarkData();
438 if ( !rDoc.HasSelectedBlockMatrixFragment(
439 aRange.aStart.Col(), aRange.aStart.Row(),
440 aRange.aEnd.Col(), aRange.aEnd.Row(),
441 rMark ) )
442 {
443 ScDocumentUniquePtr pClipDoc(new ScDocument( SCDOCMODE_CLIP )); // create one (deleted by ScTransferObj)
444
445 bool bAnyOle = rDoc.HasOLEObjectsInArea( aRange, &rMark );
446 ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle ) );
447
448 ScClipParam aClipParam(aRange, false);
449 rDoc.CopyToClip(aClipParam, pClipDoc.get(), &rMark, false, true);
450
451 ScDrawLayer::SetGlobalDrawPersist(nullptr);
452 pClipDoc->ExtendMerge( aRange, true );
453
454 ScDocShell* pDocSh = GetViewData().GetDocShell();
455 TransferableObjectDescriptor aObjDesc;
456 pDocSh->FillTransferableObjectDescriptor( aObjDesc );
457 aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
458 return new ScTransferObj( std::move(pClipDoc), std::move(aObjDesc) );
459 }
460 }
461 else if (eMarkType == SC_MARK_MULTI)
462 {
463 ScDocumentUniquePtr pClipDoc(new ScDocument(SCDOCMODE_CLIP));
464 // This takes care of the input line and calls CopyToClipMultiRange() for us.
465 CopyToClip(pClipDoc.get(), aRange, /*bCut=*/false, /*bApi=*/true);
466 TransferableObjectDescriptor aObjDesc;
467 return new ScTransferObj(std::move(pClipDoc), std::move(aObjDesc));
468 }
469
470 return nullptr;
471 }
472
473 // P A S T E
474
475 void ScViewFunc::PasteDraw()
476 {
477 ScViewData& rViewData = GetViewData();
478 SCCOL nPosX = rViewData.GetCurX();
479 SCROW nPosY = rViewData.GetCurY();
480 vcl::Window* pWin = GetActiveWin();
481 Point aPos = pWin->PixelToLogic( rViewData.GetScrPos( nPosX, nPosY,
482 rViewData.GetActivePart() ) );
483 const ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard(ScTabViewShell::GetClipData(rViewData.GetActiveWin()));
484 if (pDrawClip)
485 {
486 const OUString& aSrcShellID = pDrawClip->GetShellID();
487 OUString aDestShellID = SfxObjectShell::CreateShellID(rViewData.GetDocShell());
488 PasteDraw(aPos, pDrawClip->GetModel(), false, aSrcShellID, aDestShellID);
489 }
490 }
491
492 void ScViewFunc::PasteFromSystem()
493 {
494 UpdateInputLine();
495
496 vcl::Window* pWin = GetActiveWin();
497 css::uno::Reference<css::datatransfer::XTransferable2> xTransferable2(ScTabViewShell::GetClipData(pWin));
498 const ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard(xTransferable2);
499 // keep a reference in case the clipboard is changed during PasteFromClip
500 const ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard(xTransferable2);
501 if (pOwnClip)
502 {
503 PasteFromClip( InsertDeleteFlags::ALL, pOwnClip->GetDocument(),
504 ScPasteFunc::NONE, false, false, false, INS_NONE, InsertDeleteFlags::NONE,
505 true ); // allow warning dialog
506 }
507 else if (pDrawClip)
508 PasteDraw();
509 else
510 {
511 TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pWin ) );
512
513 {
514 SotClipboardFormatId nBiff8 = SotExchange::RegisterFormatName(u"Biff8"_ustr);
515 SotClipboardFormatId nBiff5 = SotExchange::RegisterFormatName(u"Biff5"_ustr);
516
517 SotClipboardFormatId nFormat; // output param for GetExchangeAction
518 sal_uInt8 nEventAction; // output param for GetExchangeAction
519
520 uno::Reference<css::datatransfer::XTransferable> xTransferable( aDataHelper.GetXTransferable() );
521 sal_uInt8 nAction = SotExchange::GetExchangeAction(
522 aDataHelper.GetDataFlavorExVector(),
523 SotExchangeDest::SCDOC_FREE_AREA,
524 EXCHG_IN_ACTION_COPY,
525 EXCHG_IN_ACTION_DEFAULT,
526 nFormat, nEventAction, SotClipboardFormatId::NONE,
527 &xTransferable );
528
529 if ( nAction != EXCHG_INOUT_ACTION_NONE )
530 {
531 switch( nAction )
532 {
533 case EXCHG_OUT_ACTION_INSERT_SVXB:
534 case EXCHG_OUT_ACTION_INSERT_GDIMETAFILE:
535 case EXCHG_OUT_ACTION_INSERT_BITMAP:
536 case EXCHG_OUT_ACTION_INSERT_GRAPH:
537 // SotClipboardFormatId::BITMAP
538 // SotClipboardFormatId::PNG
539 // SotClipboardFormatId::GDIMETAFILE
540 // SotClipboardFormatId::SVXB
541 PasteFromSystem(nFormat);
542 break;
543 default:
544 nAction = EXCHG_INOUT_ACTION_NONE;
545 }
546 }
547
548 if ( nAction == EXCHG_INOUT_ACTION_NONE )
549 {
550 // first SvDraw-model, then drawing
551 // (only one drawing is allowed)
552
553 if (aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ))
554 {
555 // special case for tables from drawing
556 if( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) )
557 {
558 PasteFromSystem( SotClipboardFormatId::RTF );
559 }
560 else if( aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) )
561 {
562 PasteFromSystem( SotClipboardFormatId::RICHTEXT );
563 }
564 else
565 {
566 PasteFromSystem( SotClipboardFormatId::DRAWING );
567 }
568 }
569 else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBED_SOURCE ))
570 {
571 // If it's a Writer object, insert RTF instead of OLE
572
573 // Else, if the class id is all-zero, and SYLK is available,
574 // it probably is spreadsheet cells that have been put
575 // on the clipboard by OOo, so use the SYLK. (fdo#31077)
576
577 bool bDoRtf = false;
578 TransferableObjectDescriptor aObjDesc;
579 if( aDataHelper.GetTransferableObjectDescriptor( SotClipboardFormatId::OBJECTDESCRIPTOR, aObjDesc ) )
580 {
581 bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) ||
582 aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) )
583 && ( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) || aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) ) );
584 }
585 if ( bDoRtf )
586 PasteFromSystem( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) ? SotClipboardFormatId::RTF : SotClipboardFormatId::RICHTEXT );
587 else if ( aObjDesc.maClassName == SvGlobalName( 0,0,0,0,0,0,0,0,0,0,0 )
588 && aDataHelper.HasFormat( SotClipboardFormatId::SYLK ))
589 PasteFromSystem( SotClipboardFormatId::SYLK );
590 else
591 PasteFromSystem( SotClipboardFormatId::EMBED_SOURCE );
592 }
593 else if (aDataHelper.HasFormat( SotClipboardFormatId::LINK_SOURCE ))
594 PasteFromSystem( SotClipboardFormatId::LINK_SOURCE );
595 // the following format can not affect scenario from #89579#
596 else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBEDDED_OBJ_OLE ))
597 PasteFromSystem( SotClipboardFormatId::EMBEDDED_OBJ_OLE );
598 // SotClipboardFormatId::PRIVATE no longer here (can't work if pOwnClip is NULL)
599 else if (aDataHelper.HasFormat(nBiff8)) // before xxx_OLE formats
600 PasteFromSystem(nBiff8);
601 else if (aDataHelper.HasFormat(nBiff5))
602 PasteFromSystem(nBiff5);
603 else if (aDataHelper.HasFormat(SotClipboardFormatId::RTF))
604 PasteFromSystem(SotClipboardFormatId::RTF);
605 else if (aDataHelper.HasFormat(SotClipboardFormatId::RICHTEXT))
606 PasteFromSystem(SotClipboardFormatId::RICHTEXT);
607 else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML))
608 PasteFromSystem(SotClipboardFormatId::HTML);
609 else if (aDataHelper.HasFormat(SotClipboardFormatId::BITMAP))
610 PasteFromSystem(SotClipboardFormatId::BITMAP);
611 else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML_SIMPLE))
612 PasteFromSystem(SotClipboardFormatId::HTML_SIMPLE);
613 else if (aDataHelper.HasFormat(SotClipboardFormatId::SYLK))
614 PasteFromSystem(SotClipboardFormatId::SYLK);
615 else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING_TSVC))
616 PasteFromSystem(SotClipboardFormatId::STRING_TSVC);
617 else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING))
618 PasteFromSystem(SotClipboardFormatId::STRING);
619 // xxx_OLE formats come last, like in SotExchange tables
620 else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBED_SOURCE_OLE ))
621 PasteFromSystem( SotClipboardFormatId::EMBED_SOURCE_OLE );
622 else if (aDataHelper.HasFormat( SotClipboardFormatId::LINK_SOURCE_OLE ))
623 PasteFromSystem( SotClipboardFormatId::LINK_SOURCE_OLE );
624 }
625 }
626 }
627 // no exception-> SID_PASTE has FastCall-flag from idl
628 // will be called in case of empty clipboard (#42531#)
629 }
630
631 void ScViewFunc::PasteFromTransferable( const uno::Reference<datatransfer::XTransferable>& rxTransferable )
632 {
633 if (auto pOwnClip = dynamic_cast<ScTransferObj*>(rxTransferable.get()))
634 {
635 PasteFromClip( InsertDeleteFlags::ALL, pOwnClip->GetDocument(),
636 ScPasteFunc::NONE, false, false, false, INS_NONE, InsertDeleteFlags::NONE,
637 true ); // allow warning dialog
638 }
639 else if (auto pDrawClip = dynamic_cast<ScDrawTransferObj*>(rxTransferable.get()))
640 {
641 ScViewData& rViewData = GetViewData();
642 SCCOL nPosX = rViewData.GetCurX();
643 SCROW nPosY = rViewData.GetCurY();
644 vcl::Window* pWin = GetActiveWin();
645 Point aPos = pWin->PixelToLogic( rViewData.GetScrPos( nPosX, nPosY, rViewData.GetActivePart() ) );
646 PasteDraw(
647 aPos, pDrawClip->GetModel(), false,
648 pDrawClip->GetShellID(), SfxObjectShell::CreateShellID(rViewData.GetDocShell()));
649 }
650 else
651 {
652 TransferableDataHelper aDataHelper( rxTransferable );
653 SotClipboardFormatId nBiff8 = SotExchange::RegisterFormatName(u"Biff8"_ustr);
654 SotClipboardFormatId nBiff5 = SotExchange::RegisterFormatName(u"Biff5"_ustr);
655 SotClipboardFormatId nFormatId = SotClipboardFormatId::NONE;
656 // first SvDraw-model, then drawing
657 // (only one drawing is allowed)
658
659 if (aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ))
660 nFormatId = SotClipboardFormatId::DRAWING;
661 else if (aDataHelper.HasFormat( SotClipboardFormatId::SVXB ))
662 nFormatId = SotClipboardFormatId::SVXB;
663 else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBED_SOURCE ))
664 {
665 // If it's a Writer object, insert RTF instead of OLE
666 bool bDoRtf = false;
667 TransferableObjectDescriptor aObjDesc;
668 if( aDataHelper.GetTransferableObjectDescriptor( SotClipboardFormatId::OBJECTDESCRIPTOR, aObjDesc ) )
669 {
670 bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) ||
671 aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) )
672 && ( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) || aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) ));
673 }
674 if ( bDoRtf )
675 nFormatId = aDataHelper.HasFormat( SotClipboardFormatId::RTF ) ? SotClipboardFormatId::RTF : SotClipboardFormatId::RICHTEXT;
676 else
677 nFormatId = SotClipboardFormatId::EMBED_SOURCE;
678 }
679 else if (aDataHelper.HasFormat( SotClipboardFormatId::LINK_SOURCE ))
680 nFormatId = SotClipboardFormatId::LINK_SOURCE;
681 // the following format can not affect scenario from #89579#
682 else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBEDDED_OBJ_OLE ))
683 nFormatId = SotClipboardFormatId::EMBEDDED_OBJ_OLE;
684 // SotClipboardFormatId::PRIVATE no longer here (can't work if pOwnClip is NULL)
685 else if (aDataHelper.HasFormat(nBiff8)) // before xxx_OLE formats
686 nFormatId = nBiff8;
687 else if (aDataHelper.HasFormat(nBiff5))
688 nFormatId = nBiff5;
689 else if (aDataHelper.HasFormat(SotClipboardFormatId::RTF))
690 nFormatId = SotClipboardFormatId::RTF;
691 else if (aDataHelper.HasFormat(SotClipboardFormatId::RICHTEXT))
692 nFormatId = SotClipboardFormatId::RICHTEXT;
693 else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML))
694 nFormatId = SotClipboardFormatId::HTML;
695 else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML_SIMPLE))
696 nFormatId = SotClipboardFormatId::HTML_SIMPLE;
697 else if (aDataHelper.HasFormat(SotClipboardFormatId::SYLK))
698 nFormatId = SotClipboardFormatId::SYLK;
699 else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING_TSVC))
700 nFormatId = SotClipboardFormatId::STRING_TSVC;
701 else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING))
702 nFormatId = SotClipboardFormatId::STRING;
703 else if (aDataHelper.HasFormat(SotClipboardFormatId::GDIMETAFILE))
704 nFormatId = SotClipboardFormatId::GDIMETAFILE;
705 else if (aDataHelper.HasFormat(SotClipboardFormatId::BITMAP))
706 nFormatId = SotClipboardFormatId::BITMAP;
707 // xxx_OLE formats come last, like in SotExchange tables
708 else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBED_SOURCE_OLE ))
709 nFormatId = SotClipboardFormatId::EMBED_SOURCE_OLE;
710 else if (aDataHelper.HasFormat( SotClipboardFormatId::LINK_SOURCE_OLE ))
711 nFormatId = SotClipboardFormatId::LINK_SOURCE_OLE;
712 else
713 return;
714
715 PasteDataFormat( nFormatId, aDataHelper.GetTransferable(),
716 GetViewData().GetCurX(), GetViewData().GetCurY(), nullptr );
717 }
718 }
719
720 bool ScViewFunc::PasteFromSystem( SotClipboardFormatId nFormatId, bool bApi )
721 {
722 UpdateInputLine();
723
724 bool bRet = true;
725 vcl::Window* pWin = GetActiveWin();
726 // keep a reference in case the clipboard is changed during PasteFromClip
727 const ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard(ScTabViewShell::GetClipData(pWin));
728 if ( nFormatId == SotClipboardFormatId::NONE && pOwnClip )
729 {
730 PasteFromClip( InsertDeleteFlags::ALL, pOwnClip->GetDocument(),
731 ScPasteFunc::NONE, false, false, false, INS_NONE, InsertDeleteFlags::NONE,
732 !bApi ); // allow warning dialog
733 }
734 else
735 {
736 TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pWin ) );
737 if ( !aDataHelper.GetTransferable().is() )
738 return false;
739
740 SCCOL nPosX = 0;
741 SCROW nPosY = 0;
742
743 ScViewData& rViewData = GetViewData();
744 ScRange aRange;
745 if ( rViewData.GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
746 {
747 nPosX = aRange.aStart.Col();
748 nPosY = aRange.aStart.Row();
749 }
750 else
751 {
752 nPosX = rViewData.GetCurX();
753 nPosY = rViewData.GetCurY();
754 }
755
756 bRet = PasteDataFormat( nFormatId, aDataHelper.GetTransferable(),
757 nPosX, nPosY,
758 nullptr, false, !bApi ); // allow warning dialog
759
760 if ( !bRet && !bApi )
761 {
762 ErrorMessage(STR_PASTE_ERROR);
763 }
764 else if (comphelper::LibreOfficeKit::isActive())
765 {
766 ScTabViewShell* pTabViewShell = rViewData.GetViewShell();
767 pTabViewShell->OnLOKSetWidthOrHeight(rViewData.GetCurX(), true);
768 pTabViewShell->OnLOKSetWidthOrHeight(rViewData.GetCurY(), false);
769
770 ScTabViewShell::notifyAllViewsSheetGeomInvalidation(pTabViewShell, true /* bColumns */, true /* bRows */,
771 true /* bSizes */, false /* bHidden */, false /* bFiltered */, false /* bGroups */, rViewData.GetTabNo());
772 }
773 }
774 return bRet;
775 }
776
777 // P A S T E
778
779 bool ScViewFunc::PasteOnDrawObjectLinked(
780 const uno::Reference<datatransfer::XTransferable>& rxTransferable,
781 SdrObject& rHitObj)
782 {
783 TransferableDataHelper aDataHelper( rxTransferable );
784
785 if ( aDataHelper.HasFormat( SotClipboardFormatId::SVXB ) )
786 {
787 if (ScDrawView* pScDrawView = GetScDrawView())
788 if (std::unique_ptr<SvStream> xStm = aDataHelper.GetSotStorageStream( SotClipboardFormatId::SVXB ) )
789 {
790 Graphic aGraphic;
791 TypeSerializer aSerializer(*xStm);
792 aSerializer.readGraphic(aGraphic);
793
794 const OUString aBeginUndo(ScResId(STR_UNDO_DRAGDROP));
795
796 if(pScDrawView->ApplyGraphicToObject( rHitObj, aGraphic, aBeginUndo, u""_ustr ))
797 {
798 return true;
799 }
800 }
801 }
802 else if ( aDataHelper.HasFormat( SotClipboardFormatId::GDIMETAFILE ) )
803 {
804 GDIMetaFile aMtf;
805 ScDrawView* pScDrawView = GetScDrawView();
806
807 if( pScDrawView && aDataHelper.GetGDIMetaFile( SotClipboardFormatId::GDIMETAFILE, aMtf ) )
808 {
809 const OUString aBeginUndo(ScResId(STR_UNDO_DRAGDROP));
810
811 if(pScDrawView->ApplyGraphicToObject( rHitObj, Graphic(aMtf), aBeginUndo, u""_ustr ))
812 {
813 return true;
814 }
815 }
816 }
817 else if ( aDataHelper.HasFormat( SotClipboardFormatId::BITMAP ) || aDataHelper.HasFormat( SotClipboardFormatId::PNG ) )
818 {
819 BitmapEx aBmpEx;
820 ScDrawView* pScDrawView = GetScDrawView();
821
822 if( pScDrawView && aDataHelper.GetBitmapEx( SotClipboardFormatId::BITMAP, aBmpEx ) )
823 {
824 const OUString aBeginUndo(ScResId(STR_UNDO_DRAGDROP));
825
826 if(pScDrawView->ApplyGraphicToObject( rHitObj, Graphic(aBmpEx), aBeginUndo, u""_ustr ))
827 {
828 return true;
829 }
830 }
831 }
832
833 return false;
834 }
835
836 static bool lcl_SelHasAttrib( const ScDocument& rDoc, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
837 const ScMarkData& rTabSelection, HasAttrFlags nMask )
838 {
839 return std::any_of(rTabSelection.begin(), rTabSelection.end(),
840 [&](const SCTAB& rTab) { return rDoc.HasAttrib( nCol1, nRow1, rTab, nCol2, nRow2, rTab, nMask ); });
841 }
842
843 // paste into sheet:
844
845 // internal paste
846
847 namespace {
848
849 bool checkDestRangeForOverwrite(InsertDeleteFlags nFlags, const ScRangeList& rDestRanges,
850 const ScDocument& rDoc, const ScMarkData& rMark,
851 weld::Window* pParentWnd)
852 {
853 bool bIsEmpty = true;
854 size_t nRangeSize = rDestRanges.size();
855
856 for (const auto& rTab : rMark)
857 {
858 for (size_t i = 0; i < nRangeSize && bIsEmpty; ++i)
859 {
860 const ScRange& rRange = rDestRanges[i];
861 // tdf#158110 - check if just the ADDNOTES flag is present without any other content
862 if ((nFlags & InsertDeleteFlags::ADDNOTES) == InsertDeleteFlags::ADDNOTES
863 && (nFlags & (InsertDeleteFlags::CONTENTS & ~InsertDeleteFlags::NOTE))
864 == InsertDeleteFlags::NONE)
865 bIsEmpty = rDoc.IsNotesBlockEmpty(rRange.aStart.Col(), rRange.aStart.Row(),
866 rRange.aEnd.Col(), rRange.aEnd.Row(), rTab);
867 else
868 bIsEmpty = rDoc.IsBlockEmpty(rRange.aStart.Col(), rRange.aStart.Row(),
869 rRange.aEnd.Col(), rRange.aEnd.Row(), rTab);
870 }
871 if (!bIsEmpty)
872 break;
873 }
874
875 if (!bIsEmpty)
876 {
877 ScReplaceWarnBox aBox(pParentWnd);
878 if (aBox.run() != RET_YES)
879 {
880 // changing the configuration is within the ScReplaceWarnBox
881 return false;
882 }
883 }
884 return true;
885 }
886
887 }
888
889 bool ScViewFunc::PasteFromClip( InsertDeleteFlags nFlags, ScDocument* pClipDoc,
890 ScPasteFunc nFunction, bool bSkipEmptyCells,
891 bool bTranspose, bool bAsLink,
892 InsCellCmd eMoveMode, InsertDeleteFlags nUndoExtraFlags,
893 bool bAllowDialogs )
894 {
895 if (!pClipDoc)
896 {
897 OSL_FAIL("PasteFromClip: pClipDoc=0 not allowed");
898 return false;
899 }
900
901 if (GetViewData().SelectionForbidsPaste(pClipDoc))
902 return false;
903
904 // undo: save all or no content
905 InsertDeleteFlags nContFlags = InsertDeleteFlags::NONE;
906 if (nFlags & InsertDeleteFlags::CONTENTS)
907 nContFlags |= InsertDeleteFlags::CONTENTS;
908 if (nFlags & InsertDeleteFlags::ATTRIB)
909 nContFlags |= InsertDeleteFlags::ATTRIB;
910 // move attributes to undo without copying them from clip to doc
911 InsertDeleteFlags nUndoFlags = nContFlags;
912 if (nUndoExtraFlags & InsertDeleteFlags::ATTRIB)
913 nUndoFlags |= InsertDeleteFlags::ATTRIB;
914 // do not copy note captions into undo document
915 nUndoFlags |= InsertDeleteFlags::NOCAPTIONS;
916
917 ScClipParam& rClipParam = pClipDoc->GetClipParam();
918 if (rClipParam.isMultiRange())
919 {
920 // Source data is multi-range.
921 return PasteMultiRangesFromClip(nFlags, pClipDoc, nFunction, bSkipEmptyCells, bTranspose,
922 bAsLink, bAllowDialogs, eMoveMode, nUndoFlags);
923 }
924
925 ScMarkData& rMark = GetViewData().GetMarkData();
926 if (rMark.IsMultiMarked())
927 {
928 // Source data is single-range but destination is multi-range.
929 return PasteFromClipToMultiRanges(
930 nFlags, pClipDoc, nFunction, bSkipEmptyCells, bTranspose, bAsLink, bAllowDialogs,
931 eMoveMode, nUndoFlags);
932 }
933
934 bool bCutMode = pClipDoc->IsCutMode(); // if transposing, take from original clipdoc
935 bool bIncludeFiltered = bCutMode;
936
937 // paste drawing: also if InsertDeleteFlags::NOTE is set (to create drawing layer for note captions)
938 bool bPasteDraw = ( pClipDoc->GetDrawLayer() && ( nFlags & (InsertDeleteFlags::OBJECTS|InsertDeleteFlags::NOTE) ) );
939
940 ScDocShellRef aTransShellRef; // for objects in xTransClip - must remain valid as long as xTransClip
941 ScDocument* pOrigClipDoc = nullptr;
942 ScDocumentUniquePtr xTransClip;
943 if ( bTranspose )
944 {
945 SCCOL nX;
946 SCROW nY;
947 // include filtered rows until TransposeClip can skip them
948 pClipDoc->GetClipArea( nX, nY, true );
949 if ( nY > static_cast<sal_Int32>(pClipDoc->MaxCol()) ) // too many lines for transpose
950 {
951 ErrorMessage(STR_PASTE_FULL);
952 return false;
953 }
954 pOrigClipDoc = pClipDoc; // refs
955
956 if ( bPasteDraw )
957 {
958 aTransShellRef = new ScDocShell; // DocShell needs a Ref immediately
959 aTransShellRef->DoInitNew();
960 }
961 ScDrawLayer::SetGlobalDrawPersist( aTransShellRef.get() );
962
963 xTransClip.reset( new ScDocument( SCDOCMODE_CLIP ));
964 pClipDoc->TransposeClip(xTransClip.get(), nFlags, bAsLink, bIncludeFiltered);
965 pClipDoc = xTransClip.get();
966
967 ScDrawLayer::SetGlobalDrawPersist(nullptr);
968 }
969
970 // TODO: position this call better for performance.
971 ResetAutoSpellForContentChange();
972
973 SCCOL nStartCol;
974 SCROW nStartRow;
975 SCTAB nStartTab;
976 SCCOL nEndCol;
977 SCROW nEndRow;
978 SCTAB nEndTab;
979 SCCOL nClipSizeX;
980 SCROW nClipSizeY;
981 pClipDoc->GetClipArea( nClipSizeX, nClipSizeY, true ); // size in clipboard doc
982
983 // size in target doc: include filtered rows only if CutMode is set
984 SCCOL nDestSizeX;
985 SCROW nDestSizeY;
986 pClipDoc->GetClipArea( nDestSizeX, nDestSizeY, bIncludeFiltered );
987
988 ScDocument& rDoc = GetViewData().GetDocument();
989 ScDocShell* pDocSh = GetViewData().GetDocShell();
990 SfxUndoManager* pUndoMgr = pDocSh->GetUndoManager();
991 const bool bRecord(rDoc.IsUndoEnabled());
992
993 ScDocShellModificator aModificator( *pDocSh );
994
995 ScRange aMarkRange;
996 ScMarkData aFilteredMark( rMark); // local copy for all modifications
997 ScMarkType eMarkType = GetViewData().GetSimpleArea( aMarkRange, aFilteredMark);
998 bool bMarkIsFiltered = (eMarkType == SC_MARK_SIMPLE_FILTERED);
999 bool bNoPaste = ((eMarkType != SC_MARK_SIMPLE && !bMarkIsFiltered) ||
1000 (bMarkIsFiltered && (eMoveMode != INS_NONE || bAsLink)));
1001
1002 if (!bNoPaste)
1003 {
1004 if (!rMark.IsMarked())
1005 {
1006 // Create a selection with clipboard row count and check that for
1007 // filtered.
1008 nStartCol = GetViewData().GetCurX();
1009 nStartRow = GetViewData().GetCurY();
1010 nStartTab = GetViewData().GetTabNo();
1011 nEndCol = nStartCol + nDestSizeX;
1012 nEndRow = nStartRow + nDestSizeY;
1013 nEndTab = nStartTab;
1014 aMarkRange = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1015 if (ScViewUtil::HasFiltered(aMarkRange, rDoc))
1016 {
1017 bMarkIsFiltered = true;
1018 // Fit to clipboard's row count unfiltered rows. If there is no
1019 // fit assume that pasting is not possible. Note that nDestSizeY is
1020 // size-1 (difference).
1021 if (!ScViewUtil::FitToUnfilteredRows(aMarkRange, rDoc, nDestSizeY+1))
1022 bNoPaste = true;
1023 }
1024 aFilteredMark.SetMarkArea( aMarkRange);
1025 }
1026 else
1027 {
1028 // Expand the marked area when the destination area is larger than the
1029 // current selection, to get the undo do the right thing. (i#106711)
1030 ScRange aRange = aFilteredMark.GetMarkArea();
1031 if( (aRange.aEnd.Col() - aRange.aStart.Col()) < nDestSizeX )
1032 {
1033 aRange.aEnd.SetCol(aRange.aStart.Col() + nDestSizeX);
1034 aFilteredMark.SetMarkArea(aRange);
1035 }
1036 }
1037 }
1038
1039 if (bNoPaste)
1040 {
1041 ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1042 return false;
1043 }
1044
1045 SCROW nUnfilteredRows = aMarkRange.aEnd.Row() - aMarkRange.aStart.Row() + 1;
1046 ScRangeList aRangeList;
1047 if (bMarkIsFiltered)
1048 {
1049 ScViewUtil::UnmarkFiltered(aFilteredMark, rDoc);
1050 aFilteredMark.FillRangeListWithMarks( &aRangeList, false);
1051 nUnfilteredRows = 0;
1052 size_t ListSize = aRangeList.size();
1053 for ( size_t i = 0; i < ListSize; ++i )
1054 {
1055 ScRange & r = aRangeList[i];
1056 nUnfilteredRows += r.aEnd.Row() - r.aStart.Row() + 1;
1057 }
1058 #if 0
1059 /* This isn't needed but could be a desired restriction. */
1060 // For filtered, destination rows have to be an exact multiple of
1061 // source rows. Note that nDestSizeY is size-1 (difference), so
1062 // nDestSizeY==0 fits always.
1063 if ((nUnfilteredRows % (nDestSizeY+1)) != 0)
1064 {
1065 /* FIXME: this should be a more descriptive error message then. */
1066 ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1067 return false;
1068 }
1069 #endif
1070 }
1071
1072 // Also for a filtered selection the area is used, for undo et al.
1073 if ( aFilteredMark.IsMarked() || bMarkIsFiltered )
1074 {
1075 aMarkRange.GetVars( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1076 SCCOL nBlockAddX = nEndCol-nStartCol;
1077 SCROW nBlockAddY = nEndRow-nStartRow;
1078
1079 // request, if the selection is greater than one row/column, but smaller
1080 // as the Clipboard (then inserting is done beyond the selection)
1081
1082 // ClipSize is not size, but difference
1083 if ( ( nBlockAddX != 0 && nBlockAddX < nDestSizeX ) ||
1084 ( nBlockAddY != 0 && nBlockAddY < nDestSizeY ) ||
1085 ( bMarkIsFiltered && nUnfilteredRows < nDestSizeY+1 ) )
1086 {
1087 ScWaitCursorOff aWaitOff( GetFrameWin() );
1088 OUString aMessage = ScResId( STR_PASTE_BIGGER );
1089
1090 std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(GetViewData().GetDialogParent(),
1091 VclMessageType::Question, VclButtonsType::YesNo,
1092 aMessage));
1093 xQueryBox->set_default_response(RET_NO);
1094 if (xQueryBox->run() != RET_YES)
1095 {
1096 return false;
1097 }
1098 }
1099
1100 if (nBlockAddX <= nDestSizeX)
1101 nEndCol = nStartCol + nDestSizeX;
1102
1103 if (nBlockAddY <= nDestSizeY)
1104 {
1105 nEndRow = nStartRow + nDestSizeY;
1106 if (bMarkIsFiltered || nEndRow > aMarkRange.aEnd.Row())
1107 {
1108 // Same as above if nothing was marked: re-fit selection to
1109 // unfiltered rows. Extending the selection actually may
1110 // introduce filtered rows where there weren't any before, so
1111 // we also need to test for that.
1112 aMarkRange = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1113 if (bMarkIsFiltered || ScViewUtil::HasFiltered(aMarkRange, rDoc))
1114 {
1115 bMarkIsFiltered = true;
1116 // Worst case: all rows up to the end of the sheet are filtered.
1117 if (!ScViewUtil::FitToUnfilteredRows(aMarkRange, rDoc, nDestSizeY+1))
1118 {
1119 ErrorMessage(STR_PASTE_FULL);
1120 return false;
1121 }
1122 }
1123 aMarkRange.GetVars( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1124 aFilteredMark.SetMarkArea( aMarkRange);
1125 if (bMarkIsFiltered)
1126 {
1127 ScViewUtil::UnmarkFiltered(aFilteredMark, rDoc);
1128 aFilteredMark.FillRangeListWithMarks( &aRangeList, true);
1129 }
1130 }
1131 }
1132 }
1133 else
1134 {
1135 nStartCol = GetViewData().GetCurX();
1136 nStartRow = GetViewData().GetCurY();
1137 nStartTab = GetViewData().GetTabNo();
1138 nEndCol = nStartCol + nDestSizeX;
1139 nEndRow = nStartRow + nDestSizeY;
1140 nEndTab = nStartTab;
1141 }
1142
1143 bool bOffLimits = !rDoc.ValidCol(nEndCol) || !rDoc.ValidRow(nEndRow);
1144
1145 // target-range, as displayed:
1146 ScRange aUserRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab );
1147
1148 // should lines be inserted?
1149 // ( too large nEndCol/nEndRow are detected below)
1150 bool bInsertCells = ( eMoveMode != INS_NONE && !bOffLimits );
1151 if ( bInsertCells )
1152 {
1153 // Instead of EnterListAction, the paste undo action is merged into the
1154 // insert action, so Repeat can insert the right cells
1155
1156 MarkRange( aUserRange ); // set through CopyFromClip
1157
1158 // CutMode is reset on insertion of cols/rows but needed again on cell move
1159 bool bCut = pClipDoc->IsCutMode();
1160 if (!InsertCells( eMoveMode, bRecord, true )) // is inserting possible?
1161 {
1162 return false;
1163 // #i21036# EnterListAction isn't used, and InsertCells doesn't insert
1164 // its undo action on failure, so no undo handling is needed here
1165 }
1166 if ( bCut )
1167 pClipDoc->SetCutMode( bCut );
1168 }
1169 else if (!bOffLimits)
1170 {
1171 bool bAskIfNotEmpty = bAllowDialogs &&
1172 ( nFlags & InsertDeleteFlags::CONTENTS ) &&
1173 nFunction == ScPasteFunc::NONE &&
1174 SC_MOD()->GetInputOptions().GetReplaceCellsWarn();
1175 if ( bAskIfNotEmpty )
1176 {
1177 ScRangeList aTestRanges(aUserRange);
1178 if (!checkDestRangeForOverwrite(nFlags, aTestRanges, rDoc, aFilteredMark, GetViewData().GetDialogParent()))
1179 return false;
1180 }
1181 }
1182
1183 SCCOL nClipStartX; // enlarge clipboard-range
1184 SCROW nClipStartY;
1185 pClipDoc->GetClipStart( nClipStartX, nClipStartY );
1186 SCCOL nUndoEndCol = nClipStartX + nClipSizeX;
1187 SCROW nUndoEndRow = nClipStartY + nClipSizeY; // end of source area in clipboard document
1188 bool bClipOver = false;
1189 // #i68690# ExtendMerge for the clip doc must be called with the clipboard's sheet numbers.
1190 // The same end column/row can be used for all calls because the clip doc doesn't contain
1191 // content outside the clip area.
1192 for (SCTAB nClipTab=0; nClipTab < pClipDoc->GetTableCount(); nClipTab++)
1193 if ( pClipDoc->HasTable(nClipTab) )
1194 if ( pClipDoc->ExtendMerge( nClipStartX,nClipStartY, nUndoEndCol,nUndoEndRow, nClipTab ) )
1195 bClipOver = true;
1196 nUndoEndCol -= nClipStartX + nClipSizeX;
1197 nUndoEndRow -= nClipStartY + nClipSizeY; // now contains only the difference added by ExtendMerge
1198 nUndoEndCol = sal::static_int_cast<SCCOL>( nUndoEndCol + nEndCol );
1199 nUndoEndRow = sal::static_int_cast<SCROW>( nUndoEndRow + nEndRow ); // destination area, expanded for merged cells
1200
1201 if (nUndoEndCol>pClipDoc->MaxCol() || nUndoEndRow>pClipDoc->MaxRow())
1202 {
1203 ErrorMessage(STR_PASTE_FULL);
1204 return false;
1205 }
1206
1207 rDoc.ExtendMergeSel( nStartCol,nStartRow, nUndoEndCol,nUndoEndRow, aFilteredMark );
1208
1209 // check cell-protection
1210
1211 ScEditableTester aTester( rDoc, nStartTab, nStartCol,nStartRow, nUndoEndCol,nUndoEndRow );
1212 if (!aTester.IsEditable())
1213 {
1214 ErrorMessage(aTester.GetMessageId());
1215 return false;
1216 }
1217
1218 //! check overlapping
1219 //! just check truly intersection !!!!!!!
1220
1221 ScDocFunc& rDocFunc = pDocSh->GetDocFunc();
1222 if ( bRecord )
1223 {
1224 OUString aUndo = ScResId( pClipDoc->IsCutMode() ? STR_UNDO_MOVE : STR_UNDO_COPY );
1225 pUndoMgr->EnterListAction( aUndo, aUndo, 0, GetViewData().GetViewShell()->GetViewShellId() );
1226 }
1227
1228 if (bClipOver)
1229 if (lcl_SelHasAttrib( rDoc, nStartCol,nStartRow, nUndoEndCol,nUndoEndRow, aFilteredMark, HasAttrFlags::Overlapped ))
1230 { // "Cell merge not possible if cells already merged"
1231 ScDocAttrIterator aIter( rDoc, nStartTab, nStartCol, nStartRow, nUndoEndCol, nUndoEndRow );
1232 const ScPatternAttr* pPattern = nullptr;
1233 SCCOL nCol = -1;
1234 SCROW nRow1 = -1;
1235 SCROW nRow2 = -1;
1236 while ( ( pPattern = aIter.GetNext( nCol, nRow1, nRow2 ) ) != nullptr )
1237 {
1238 const ScMergeAttr& rMergeFlag = pPattern->GetItem(ATTR_MERGE);
1239 const ScMergeFlagAttr& rMergeFlagAttr = pPattern->GetItem(ATTR_MERGE_FLAG);
1240 if (rMergeFlag.IsMerged() || rMergeFlagAttr.IsOverlapped())
1241 {
1242 ScRange aRange(nCol, nRow1, nStartTab);
1243 rDoc.ExtendOverlapped(aRange);
1244 rDoc.ExtendMerge(aRange, true);
1245 rDocFunc.UnmergeCells(aRange, bRecord, nullptr /*TODO: should pass combined UndoDoc if bRecord*/);
1246 }
1247 }
1248 }
1249
1250 if ( !bCutMode )
1251 {
1252 ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1253 if ( pChangeTrack )
1254 pChangeTrack->ResetLastCut(); // no more cut-mode
1255 }
1256
1257 bool bColInfo = ( nStartRow==0 && nEndRow==rDoc.MaxRow() );
1258 bool bRowInfo = ( nStartCol==0 && nEndCol==rDoc.MaxCol() );
1259
1260 ScDocumentUniquePtr pUndoDoc;
1261 std::unique_ptr<ScDocument> pRefUndoDoc;
1262 std::unique_ptr<ScRefUndoData> pUndoData;
1263
1264 if ( bRecord )
1265 {
1266 pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
1267 pUndoDoc->InitUndoSelected( rDoc, aFilteredMark, bColInfo, bRowInfo );
1268
1269 // all sheets - CopyToDocument skips those that don't exist in pUndoDoc
1270 SCTAB nTabCount = rDoc.GetTableCount();
1271 rDoc.CopyToDocument( nStartCol, nStartRow, 0, nUndoEndCol, nUndoEndRow, nTabCount-1,
1272 nUndoFlags, false, *pUndoDoc );
1273
1274 if ( bCutMode )
1275 {
1276 pRefUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
1277 pRefUndoDoc->InitUndo( rDoc, 0, nTabCount-1 );
1278
1279 pUndoData.reset(new ScRefUndoData( &rDoc ));
1280 }
1281 }
1282
1283 const bool bSingleCellBefore = nStartCol == nEndCol &&
1284 nStartRow == nEndRow &&
1285 nStartTab == nEndTab;
1286 tools::Long nBeforeHint(bSingleCellBefore ? pDocSh->GetTwipWidthHint(ScAddress(nStartCol, nStartRow, nStartTab)) : -1);
1287
1288 sal_uInt16 nExtFlags = 0;
1289 pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab,
1290 nEndCol, nEndRow, nEndTab ); // content before the change
1291
1292 if (GetViewData().IsActive())
1293 {
1294 DoneBlockMode();
1295 InitOwnBlockMode( aUserRange );
1296 }
1297 rMark.SetMarkArea( aUserRange );
1298 MarkDataChanged();
1299
1300 // copy from clipboard
1301 // save original data in case of calculation
1302
1303 ScDocumentUniquePtr pMixDoc;
1304 if (nFunction != ScPasteFunc::NONE)
1305 {
1306 bSkipEmptyCells = false;
1307 if ( nFlags & InsertDeleteFlags::CONTENTS )
1308 {
1309 pMixDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
1310 pMixDoc->InitUndo( rDoc, nStartTab, nEndTab );
1311 rDoc.CopyToDocument(nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab,
1312 InsertDeleteFlags::CONTENTS, false, *pMixDoc);
1313 }
1314 }
1315
1316 /* Make draw layer and start drawing undo.
1317 - Needed before AdjustBlockHeight to track moved drawing objects.
1318 - Needed before rDoc.CopyFromClip to track inserted note caption objects.
1319 */
1320 if ( bPasteDraw )
1321 pDocSh->MakeDrawLayer();
1322 if ( bRecord )
1323 rDoc.BeginDrawUndo();
1324
1325 InsertDeleteFlags nNoObjFlags = nFlags & ~InsertDeleteFlags::OBJECTS;
1326 if (!bAsLink)
1327 {
1328 // copy normally (original range)
1329 rDoc.CopyFromClip( aUserRange, aFilteredMark, nNoObjFlags,
1330 pRefUndoDoc.get(), pClipDoc, true, false, bIncludeFiltered,
1331 bSkipEmptyCells, (bMarkIsFiltered ? &aRangeList : nullptr) );
1332
1333 // adapt refs manually in case of transpose
1334 if ( bTranspose && bCutMode && (nFlags & InsertDeleteFlags::CONTENTS) )
1335 rDoc.UpdateTranspose( aUserRange.aStart, pOrigClipDoc, aFilteredMark, pRefUndoDoc.get() );
1336 }
1337 else if (!bTranspose)
1338 {
1339 // copy with bAsLink=TRUE
1340 rDoc.CopyFromClip( aUserRange, aFilteredMark, nNoObjFlags, pRefUndoDoc.get(), pClipDoc,
1341 true, true, bIncludeFiltered, bSkipEmptyCells );
1342 }
1343 else
1344 {
1345 // copy all content (TransClipDoc contains only formula)
1346 rDoc.CopyFromClip( aUserRange, aFilteredMark, nContFlags, pRefUndoDoc.get(), pClipDoc );
1347 }
1348
1349 // skipped rows and merged cells don't mix
1350 if ( !bIncludeFiltered && pClipDoc->HasClipFilteredRows() )
1351 rDocFunc.UnmergeCells( aUserRange, false, nullptr );
1352
1353 rDoc.ExtendMergeSel( nStartCol, nStartRow, nEndCol, nEndRow, aFilteredMark, true ); // refresh
1354 // new range
1355
1356 if ( pMixDoc ) // calculate with original data?
1357 {
1358 rDoc.MixDocument( aUserRange, nFunction, bSkipEmptyCells, *pMixDoc );
1359 }
1360 pMixDoc.reset();
1361
1362 AdjustBlockHeight(); // update row heights before pasting objects
1363
1364 ::std::vector< OUString > aExcludedChartNames;
1365 SdrPage* pPage = nullptr;
1366
1367 if ( nFlags & InsertDeleteFlags::OBJECTS )
1368 {
1369 ScDrawView* pScDrawView = GetScDrawView();
1370 SdrModel* pModel = ( pScDrawView ? &pScDrawView->GetModel() : nullptr );
1371 pPage = ( pModel ? pModel->GetPage( static_cast< sal_uInt16 >( nStartTab ) ) : nullptr );
1372 if ( pPage )
1373 {
1374 ScChartHelper::GetChartNames( aExcludedChartNames, pPage );
1375 }
1376
1377 // Paste the drawing objects after the row heights have been updated.
1378
1379 rDoc.CopyFromClip( aUserRange, aFilteredMark, InsertDeleteFlags::OBJECTS, pRefUndoDoc.get(), pClipDoc,
1380 true, false, bIncludeFiltered );
1381 }
1382
1383 pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab,
1384 nEndCol, nEndRow, nEndTab ); // content after the change
1385
1386 // if necessary, delete autofilter-heads
1387 if (bCutMode)
1388 if (rDoc.RefreshAutoFilter( nClipStartX,nClipStartY, nClipStartX+nClipSizeX,
1389 nClipStartY+nClipSizeY, nStartTab ))
1390 {
1391 pDocSh->PostPaint(
1392 ScRange(nClipStartX, nClipStartY, nStartTab, nClipStartX+nClipSizeX, nClipStartY, nStartTab),
1393 PaintPartFlags::Grid );
1394 }
1395
1396 //! remove block-range on RefUndoDoc !!!
1397
1398 if ( bRecord )
1399 {
1400 ScDocumentUniquePtr pRedoDoc;
1401 // copy redo data after appearance of the first undo
1402 // don't create Redo-Doc without RefUndoDoc
1403
1404 if (pRefUndoDoc)
1405 {
1406 pRedoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
1407 pRedoDoc->InitUndo( rDoc, nStartTab, nEndTab, bColInfo, bRowInfo );
1408
1409 // move adapted refs to Redo-Doc
1410
1411 SCTAB nTabCount = rDoc.GetTableCount();
1412 pRedoDoc->AddUndoTab( 0, nTabCount-1 );
1413 rDoc.CopyUpdated( pRefUndoDoc.get(), pRedoDoc.get() );
1414
1415 // move old refs to Undo-Doc
1416
1417 // not charts?
1418 pUndoDoc->AddUndoTab( 0, nTabCount-1 );
1419 pRefUndoDoc->DeleteArea( nStartCol, nStartRow, nEndCol, nEndRow, aFilteredMark, InsertDeleteFlags::ALL );
1420 pRefUndoDoc->CopyToDocument( 0,0,0, pUndoDoc->MaxCol(), pUndoDoc->MaxRow(), nTabCount-1,
1421 InsertDeleteFlags::FORMULA, false, *pUndoDoc );
1422 pRefUndoDoc.reset();
1423 }
1424
1425 // DeleteUnchanged for pUndoData is in ScUndoPaste ctor,
1426 // UndoData for redo is made during first undo
1427
1428 ScUndoPasteOptions aOptions; // store options for repeat
1429 aOptions.nFunction = nFunction;
1430 aOptions.bSkipEmptyCells = bSkipEmptyCells;
1431 aOptions.bTranspose = bTranspose;
1432 aOptions.bAsLink = bAsLink;
1433 aOptions.eMoveMode = eMoveMode;
1434
1435 std::unique_ptr<SfxUndoAction> pUndo(new ScUndoPaste(
1436 pDocSh, ScRange(nStartCol, nStartRow, nStartTab, nUndoEndCol, nUndoEndRow, nEndTab),
1437 aFilteredMark, std::move(pUndoDoc), std::move(pRedoDoc), nFlags | nUndoFlags, std::move(pUndoData),
1438 false, &aOptions )); // false = Redo data not yet copied
1439
1440 if ( bInsertCells )
1441 {
1442 // Merge the paste undo action into the insert action.
1443 // Use ScUndoWrapper so the ScUndoPaste pointer can be stored in the insert action.
1444
1445 pUndoMgr->AddUndoAction( std::make_unique<ScUndoWrapper>( std::move(pUndo) ), true );
1446 }
1447 else
1448 pUndoMgr->AddUndoAction( std::move(pUndo) );
1449 pUndoMgr->LeaveListAction();
1450 }
1451
1452 PaintPartFlags nPaint = PaintPartFlags::Grid;
1453 if (bColInfo)
1454 {
1455 nPaint |= PaintPartFlags::Top;
1456 nUndoEndCol = rDoc.MaxCol(); // just for drawing !
1457 }
1458 if (bRowInfo)
1459 {
1460 nPaint |= PaintPartFlags::Left;
1461 nUndoEndRow = rDoc.MaxRow(); // just for drawing !
1462 }
1463
1464 tools::Long nMaxWidthAffectedHint = -1;
1465 const bool bSingleCellAfter = nStartCol == nUndoEndCol &&
1466 nStartRow == nUndoEndRow &&
1467 nStartTab == nEndTab;
1468 if (bSingleCellBefore && bSingleCellAfter)
1469 {
1470 tools::Long nAfterHint(pDocSh->GetTwipWidthHint(ScAddress(nStartCol, nStartRow, nStartTab)));
1471 nMaxWidthAffectedHint = std::max(nBeforeHint, nAfterHint);
1472 }
1473
1474 pDocSh->PostPaint(
1475 ScRange(nStartCol, nStartRow, nStartTab, nUndoEndCol, nUndoEndRow, nEndTab),
1476 nPaint, nExtFlags, nMaxWidthAffectedHint);
1477 // AdjustBlockHeight has already been called above
1478
1479 aModificator.SetDocumentModified();
1480 PostPasteFromClip(aUserRange, rMark);
1481
1482 if ( nFlags & InsertDeleteFlags::OBJECTS )
1483 {
1484 ScModelObj* pModelObj = pDocSh->GetModel();
1485 if ( pPage && pModelObj )
1486 {
1487 bool bSameDoc = ( rClipParam.getSourceDocID() == rDoc.GetDocumentID() );
1488 const ScRangeListVector& rProtectedChartRangesVector( rClipParam.maProtectedChartRangesVector );
1489 ScChartHelper::CreateProtectedChartListenersAndNotify( rDoc, pPage, pModelObj, nStartTab,
1490 rProtectedChartRangesVector, aExcludedChartNames, bSameDoc );
1491 }
1492 }
1493 OUString aStartAddress = aMarkRange.aStart.GetColRowString();
1494 OUString aEndAddress = aMarkRange.aEnd.GetColRowString();
1495 collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, u"PASTE"_ustr);
1496 return true;
1497 }
1498
1499 bool ScViewFunc::PasteMultiRangesFromClip(InsertDeleteFlags nFlags, ScDocument* pClipDoc,
1500 ScPasteFunc nFunction, bool bSkipEmptyCells,
1501 bool bTranspose, bool bAsLink,
1502 bool bAllowDialogs, InsCellCmd eMoveMode,
1503 InsertDeleteFlags nUndoFlags)
1504 {
1505 ScViewData& rViewData = GetViewData();
1506 ScDocument& rDoc = rViewData.GetDocument();
1507 ScDocShell* pDocSh = rViewData.GetDocShell();
1508 ScMarkData aMark(rViewData.GetMarkData());
1509 const ScAddress aCurPos = rViewData.GetCurPos();
1510 ScClipParam& rClipParam = pClipDoc->GetClipParam();
1511 SCCOL nColSize = rClipParam.getPasteColSize();
1512 SCROW nRowSize = rClipParam.getPasteRowSize(*pClipDoc, /*bIncludeFiltered*/false);
1513
1514 if (bTranspose)
1515 {
1516 if (static_cast<SCROW>(aCurPos.Col()) + nRowSize-1 > static_cast<SCROW>(pClipDoc->MaxCol()))
1517 {
1518 ErrorMessage(STR_PASTE_FULL);
1519 return false;
1520 }
1521
1522 ScDocumentUniquePtr pTransClip(new ScDocument(SCDOCMODE_CLIP));
1523 pClipDoc->TransposeClip(pTransClip.get(), nFlags, bAsLink, /*bIncludeFiltered*/false);
1524 pClipDoc = pTransClip.release();
1525 SCCOL nTempColSize = nColSize;
1526 nColSize = static_cast<SCCOL>(nRowSize);
1527 nRowSize = static_cast<SCROW>(nTempColSize);
1528 }
1529
1530 if (!rDoc.ValidCol(aCurPos.Col()+nColSize-1) || !rDoc.ValidRow(aCurPos.Row()+nRowSize-1))
1531 {
1532 ErrorMessage(STR_PASTE_FULL);
1533 return false;
1534 }
1535
1536 // Determine the first and last selected sheet numbers.
1537 SCTAB nTab1 = aMark.GetFirstSelected();
1538 SCTAB nTab2 = aMark.GetLastSelected();
1539
1540 ScDocShellModificator aModificator(*pDocSh);
1541
1542 // For multi-selection paste, we don't support cell duplication for larger
1543 // destination range. In case the destination is marked, we reset it to
1544 // the clip size.
1545 ScRange aMarkedRange(aCurPos.Col(), aCurPos.Row(), nTab1,
1546 aCurPos.Col()+nColSize-1, aCurPos.Row()+nRowSize-1, nTab2);
1547
1548 // Extend the marked range to account for filtered rows in the destination
1549 // area.
1550 if (ScViewUtil::HasFiltered(aMarkedRange, rDoc))
1551 {
1552 if (!ScViewUtil::FitToUnfilteredRows(aMarkedRange, rDoc, nRowSize))
1553 return false;
1554 }
1555
1556 bool bAskIfNotEmpty =
1557 bAllowDialogs && (nFlags & InsertDeleteFlags::CONTENTS) &&
1558 nFunction == ScPasteFunc::NONE && SC_MOD()->GetInputOptions().GetReplaceCellsWarn();
1559
1560 if (bAskIfNotEmpty)
1561 {
1562 ScRangeList aTestRanges(aMarkedRange);
1563 if (!checkDestRangeForOverwrite(nFlags, aTestRanges, rDoc, aMark, GetViewData().GetDialogParent()))
1564 return false;
1565 }
1566
1567 aMark.SetMarkArea(aMarkedRange);
1568 MarkRange(aMarkedRange);
1569
1570 bool bInsertCells = (eMoveMode != INS_NONE);
1571 if (bInsertCells)
1572 {
1573 if (!InsertCells(eMoveMode, rDoc.IsUndoEnabled(), true))
1574 return false;
1575 }
1576
1577 // TODO: position this call better for performance.
1578 ResetAutoSpellForContentChange();
1579
1580 bool bRowInfo = ( aMarkedRange.aStart.Col()==0 && aMarkedRange.aEnd.Col()==pClipDoc->MaxCol() );
1581 ScDocumentUniquePtr pUndoDoc;
1582 if (rDoc.IsUndoEnabled())
1583 {
1584 pUndoDoc.reset(new ScDocument(SCDOCMODE_UNDO));
1585 pUndoDoc->InitUndoSelected(rDoc, aMark, false, bRowInfo);
1586 rDoc.CopyToDocument(aMarkedRange, nUndoFlags, false, *pUndoDoc, &aMark);
1587 }
1588
1589 ScDocumentUniquePtr pMixDoc;
1590 if ( bSkipEmptyCells || nFunction != ScPasteFunc::NONE)
1591 {
1592 if ( nFlags & InsertDeleteFlags::CONTENTS )
1593 {
1594 pMixDoc.reset(new ScDocument(SCDOCMODE_UNDO));
1595 pMixDoc->InitUndoSelected(rDoc, aMark);
1596 rDoc.CopyToDocument(aMarkedRange, InsertDeleteFlags::CONTENTS, false, *pMixDoc, &aMark);
1597 }
1598 }
1599
1600 /* Make draw layer and start drawing undo.
1601 - Needed before AdjustBlockHeight to track moved drawing objects.
1602 - Needed before rDoc.CopyFromClip to track inserted note caption objects.
1603 */
1604 if (nFlags & InsertDeleteFlags::OBJECTS)
1605 pDocSh->MakeDrawLayer();
1606 if (rDoc.IsUndoEnabled())
1607 rDoc.BeginDrawUndo();
1608
1609 InsertDeleteFlags nCopyFlags = nFlags & ~InsertDeleteFlags::OBJECTS;
1610 // in case of transpose, links were added in TransposeClip()
1611 if (bAsLink && bTranspose)
1612 nCopyFlags |= InsertDeleteFlags::FORMULA;
1613 rDoc.CopyMultiRangeFromClip(aCurPos, aMark, nCopyFlags, pClipDoc, true, bAsLink && !bTranspose,
1614 /*bIncludeFiltered*/false, bSkipEmptyCells);
1615
1616 if (pMixDoc)
1617 rDoc.MixDocument(aMarkedRange, nFunction, bSkipEmptyCells, *pMixDoc);
1618
1619 AdjustBlockHeight(); // update row heights before pasting objects
1620
1621 if (nFlags & InsertDeleteFlags::OBJECTS)
1622 {
1623 // Paste the drawing objects after the row heights have been updated.
1624 rDoc.CopyMultiRangeFromClip(aCurPos, aMark, InsertDeleteFlags::OBJECTS, pClipDoc, true,
1625 false, /*bIncludeFiltered*/false, true);
1626 }
1627
1628 if (bRowInfo)
1629 pDocSh->PostPaint(aMarkedRange.aStart.Col(), aMarkedRange.aStart.Row(), nTab1, pClipDoc->MaxCol(), pClipDoc->MaxRow(), nTab1, PaintPartFlags::Grid|PaintPartFlags::Left);
1630 else
1631 {
1632 ScRange aTmp = aMarkedRange;
1633 aTmp.aStart.SetTab(nTab1);
1634 aTmp.aEnd.SetTab(nTab1);
1635 pDocSh->PostPaint(aTmp, PaintPartFlags::Grid);
1636 }
1637
1638 if (rDoc.IsUndoEnabled())
1639 {
1640 SfxUndoManager* pUndoMgr = pDocSh->GetUndoManager();
1641 OUString aUndo = ScResId(
1642 pClipDoc->IsCutMode() ? STR_UNDO_CUT : STR_UNDO_COPY);
1643 pUndoMgr->EnterListAction(aUndo, aUndo, 0, GetViewData().GetViewShell()->GetViewShellId());
1644
1645 ScUndoPasteOptions aOptions; // store options for repeat
1646 aOptions.nFunction = nFunction;
1647 aOptions.bSkipEmptyCells = bSkipEmptyCells;
1648 aOptions.bTranspose = bTranspose;
1649 aOptions.bAsLink = bAsLink;
1650 aOptions.eMoveMode = eMoveMode;
1651
1652 std::unique_ptr<ScUndoPaste> pUndo(new ScUndoPaste(pDocSh,
1653 aMarkedRange, aMark, std::move(pUndoDoc), nullptr, nFlags|nUndoFlags, nullptr, false, &aOptions));
1654
1655 if (bInsertCells)
1656 pUndoMgr->AddUndoAction(std::make_unique<ScUndoWrapper>(std::move(pUndo)), true);
1657 else
1658 pUndoMgr->AddUndoAction(std::move(pUndo));
1659
1660 pUndoMgr->LeaveListAction();
1661 }
1662
1663 aModificator.SetDocumentModified();
1664 PostPasteFromClip(aMarkedRange, aMark);
1665 return true;
1666 }
1667
1668 bool ScViewFunc::PasteFromClipToMultiRanges(
1669 InsertDeleteFlags nFlags, ScDocument* pClipDoc, ScPasteFunc nFunction,
1670 bool bSkipEmptyCells, bool bTranspose, bool bAsLink, bool bAllowDialogs,
1671 InsCellCmd eMoveMode, InsertDeleteFlags nUndoFlags )
1672 {
1673 if (bTranspose)
1674 {
1675 // We don't allow transpose for this yet.
1676 ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1677 return false;
1678 }
1679
1680 if (eMoveMode != INS_NONE)
1681 {
1682 // We don't allow insertion mode either. Too complicated.
1683 ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1684 return false;
1685 }
1686
1687 ScViewData& rViewData = GetViewData();
1688 ScClipParam& rClipParam = pClipDoc->GetClipParam();
1689 if (rClipParam.mbCutMode)
1690 {
1691 // No cut and paste with this, please.
1692 ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1693 return false;
1694 }
1695
1696 const ScAddress aCurPos = rViewData.GetCurPos();
1697 ScDocument& rDoc = rViewData.GetDocument();
1698
1699 ScRange aSrcRange = rClipParam.getWholeRange();
1700 SCROW nRowSize = aSrcRange.aEnd.Row() - aSrcRange.aStart.Row() + 1;
1701 SCCOL nColSize = aSrcRange.aEnd.Col() - aSrcRange.aStart.Col() + 1;
1702
1703 if (!rDoc.ValidCol(aCurPos.Col()+nColSize-1) || !rDoc.ValidRow(aCurPos.Row()+nRowSize-1))
1704 {
1705 ErrorMessage(STR_PASTE_FULL);
1706 return false;
1707 }
1708
1709 ScMarkData aMark(rViewData.GetMarkData());
1710
1711 ScRangeList aRanges;
1712 aMark.MarkToSimple();
1713 aMark.FillRangeListWithMarks(&aRanges, false);
1714 if (!ScClipUtil::CheckDestRanges(rDoc, nColSize, nRowSize, aMark, aRanges))
1715 {
1716 ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1717 return false;
1718 }
1719
1720 ScDocShell* pDocSh = rViewData.GetDocShell();
1721
1722 ScDocShellModificator aModificator(*pDocSh);
1723
1724 bool bAskIfNotEmpty =
1725 bAllowDialogs && (nFlags & InsertDeleteFlags::CONTENTS) &&
1726 nFunction == ScPasteFunc::NONE && SC_MOD()->GetInputOptions().GetReplaceCellsWarn();
1727
1728 if (bAskIfNotEmpty)
1729 {
1730 if (!checkDestRangeForOverwrite(nFlags, aRanges, rDoc, aMark, GetViewData().GetDialogParent()))
1731 return false;
1732 }
1733
1734 // TODO: position this call better for performance.
1735 ResetAutoSpellForContentChange();
1736
1737 ScDocumentUniquePtr pUndoDoc;
1738 if (rDoc.IsUndoEnabled())
1739 {
1740 pUndoDoc.reset(new ScDocument(SCDOCMODE_UNDO));
1741 pUndoDoc->InitUndoSelected(rDoc, aMark);
1742 for (size_t i = 0, n = aRanges.size(); i < n; ++i)
1743 {
1744 rDoc.CopyToDocument(
1745 aRanges[i], nUndoFlags, false, *pUndoDoc, &aMark);
1746 }
1747 }
1748
1749 ScDocumentUniquePtr pMixDoc;
1750 if (bSkipEmptyCells || nFunction != ScPasteFunc::NONE)
1751 {
1752 if (nFlags & InsertDeleteFlags::CONTENTS)
1753 {
1754 pMixDoc.reset(new ScDocument(SCDOCMODE_UNDO));
1755 pMixDoc->InitUndoSelected(rDoc, aMark);
1756 for (size_t i = 0, n = aRanges.size(); i < n; ++i)
1757 {
1758 rDoc.CopyToDocument(
1759 aRanges[i], InsertDeleteFlags::CONTENTS, false, *pMixDoc, &aMark);
1760 }
1761 }
1762 }
1763
1764 if (nFlags & InsertDeleteFlags::OBJECTS)
1765 pDocSh->MakeDrawLayer();
1766 if (rDoc.IsUndoEnabled())
1767 rDoc.BeginDrawUndo();
1768
1769 // First, paste everything but the drawing objects.
1770 for (size_t i = 0, n = aRanges.size(); i < n; ++i)
1771 {
1772 rDoc.CopyFromClip(
1773 aRanges[i], aMark, (nFlags & ~InsertDeleteFlags::OBJECTS), nullptr, pClipDoc,
1774 false, false, true, bSkipEmptyCells);
1775 }
1776
1777 if (pMixDoc)
1778 {
1779 for (size_t i = 0, n = aRanges.size(); i < n; ++i)
1780 rDoc.MixDocument(aRanges[i], nFunction, bSkipEmptyCells, *pMixDoc);
1781 }
1782
1783 AdjustBlockHeight(); // update row heights before pasting objects
1784
1785 // Then paste the objects.
1786 if (nFlags & InsertDeleteFlags::OBJECTS)
1787 {
1788 for (size_t i = 0, n = aRanges.size(); i < n; ++i)
1789 {
1790 rDoc.CopyFromClip(
1791 aRanges[i], aMark, InsertDeleteFlags::OBJECTS, nullptr, pClipDoc,
1792 false, false, true, bSkipEmptyCells);
1793 }
1794 }
1795
1796 // Refresh the range that includes all pasted ranges. We only need to
1797 // refresh the current sheet.
1798 PaintPartFlags nPaint = PaintPartFlags::Grid;
1799 bool bRowInfo = (aSrcRange.aStart.Col()==0 && aSrcRange.aEnd.Col()==pClipDoc->MaxCol());
1800 if (bRowInfo)
1801 nPaint |= PaintPartFlags::Left;
1802 pDocSh->PostPaint(aRanges, nPaint);
1803
1804 if (rDoc.IsUndoEnabled())
1805 {
1806 SfxUndoManager* pUndoMgr = pDocSh->GetUndoManager();
1807 OUString aUndo = ScResId(
1808 pClipDoc->IsCutMode() ? STR_UNDO_CUT : STR_UNDO_COPY);
1809 pUndoMgr->EnterListAction(aUndo, aUndo, 0, GetViewData().GetViewShell()->GetViewShellId());
1810
1811 ScUndoPasteOptions aOptions; // store options for repeat
1812 aOptions.nFunction = nFunction;
1813 aOptions.bSkipEmptyCells = bSkipEmptyCells;
1814 aOptions.bTranspose = bTranspose;
1815 aOptions.bAsLink = bAsLink;
1816 aOptions.eMoveMode = eMoveMode;
1817
1818
1819 pUndoMgr->AddUndoAction(
1820 std::make_unique<ScUndoPaste>(
1821 pDocSh, aRanges, aMark, std::move(pUndoDoc), nullptr, nFlags|nUndoFlags, nullptr, false, &aOptions));
1822 pUndoMgr->LeaveListAction();
1823 }
1824
1825 aModificator.SetDocumentModified();
1826 PostPasteFromClip(aRanges, aMark);
1827
1828 return false;
1829 }
1830
1831 void ScViewFunc::PostPasteFromClip(const ScRangeList& rPasteRanges, const ScMarkData& rMark)
1832 {
1833 ScViewData& rViewData = GetViewData();
1834 ScDocShell* pDocSh = rViewData.GetDocShell();
1835 pDocSh->UpdateOle(rViewData);
1836
1837 SelectionChanged(true);
1838
1839 ScModelObj* pModelObj = pDocSh->GetModel();
1840
1841 ScRangeList aChangeRanges;
1842 for (size_t i = 0, n = rPasteRanges.size(); i < n; ++i)
1843 {
1844 const ScRange& r = rPasteRanges[i];
1845 for (const auto& rTab : rMark)
1846 {
1847 ScRange aChangeRange(r);
1848 aChangeRange.aStart.SetTab(rTab);
1849 aChangeRange.aEnd.SetTab(rTab);
1850 aChangeRanges.push_back(aChangeRange);
1851 }
1852 }
1853
1854 if (HelperNotifyChanges::getMustPropagateChangesModel(pModelObj))
1855 HelperNotifyChanges::Notify(*pModelObj, aChangeRanges, u"paste"_ustr);
1856 else if (pModelObj)
1857 HelperNotifyChanges::Notify(*pModelObj, aChangeRanges, u"data-area-invalidate"_ustr);
1858 }
1859
1860 // D R A G A N D D R O P
1861
1862 // inside the doc
1863
1864 bool ScViewFunc::MoveBlockTo( const ScRange& rSource, const ScAddress& rDestPos,
1865 bool bCut )
1866 {
1867 ScDocShell* pDocSh = GetViewData().GetDocShell();
1868 HideAllCursors();
1869
1870 ResetAutoSpellForContentChange();
1871
1872 bool bSuccess = true;
1873 SCTAB nDestTab = rDestPos.Tab();
1874 const ScMarkData& rMark = GetViewData().GetMarkData();
1875 if ( rSource.aStart.Tab() == nDestTab && rSource.aEnd.Tab() == nDestTab && rMark.GetSelectCount() > 1 )
1876 {
1877 // moving within one table and several tables selected -> apply to all selected tables
1878
1879 OUString aUndo = ScResId( bCut ? STR_UNDO_MOVE : STR_UNDO_COPY );
1880 pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, GetViewData().GetViewShell()->GetViewShellId() );
1881
1882 // collect ranges of consecutive selected tables
1883
1884 ScRange aLocalSource = rSource;
1885 ScAddress aLocalDest = rDestPos;
1886 SCTAB nTabCount = pDocSh->GetDocument().GetTableCount();
1887 SCTAB nStartTab = 0;
1888 while ( nStartTab < nTabCount && bSuccess )
1889 {
1890 while ( nStartTab < nTabCount && !rMark.GetTableSelect(nStartTab) )
1891 ++nStartTab;
1892 if ( nStartTab < nTabCount )
1893 {
1894 SCTAB nEndTab = nStartTab;
1895 while ( nEndTab+1 < nTabCount && rMark.GetTableSelect(nEndTab+1) )
1896 ++nEndTab;
1897
1898 aLocalSource.aStart.SetTab( nStartTab );
1899 aLocalSource.aEnd.SetTab( nEndTab );
1900 aLocalDest.SetTab( nStartTab );
1901
1902 bSuccess = pDocSh->GetDocFunc().MoveBlock(
1903 aLocalSource, aLocalDest, bCut, true/*bRecord*/, true/*bPaint*/, true/*bApi*/ );
1904
1905 nStartTab = nEndTab + 1;
1906 }
1907 }
1908
1909 pDocSh->GetUndoManager()->LeaveListAction();
1910 }
1911 else
1912 {
1913 // move the block as specified
1914 bSuccess = pDocSh->GetDocFunc().MoveBlock(
1915 rSource, rDestPos, bCut, true/*bRecord*/, true/*bPaint*/, true/*bApi*/ );
1916 }
1917
1918 ShowAllCursors();
1919 if (bSuccess)
1920 {
1921 // mark destination range
1922 ScAddress aDestEnd(
1923 rDestPos.Col() + rSource.aEnd.Col() - rSource.aStart.Col(),
1924 rDestPos.Row() + rSource.aEnd.Row() - rSource.aStart.Row(),
1925 nDestTab );
1926
1927 bool bIncludeFiltered = bCut;
1928 if ( !bIncludeFiltered )
1929 {
1930 // find number of non-filtered rows
1931 SCROW nPastedCount = pDocSh->GetDocument().CountNonFilteredRows(
1932 rSource.aStart.Row(), rSource.aEnd.Row(), rSource.aStart.Tab());
1933
1934 if ( nPastedCount == 0 )
1935 nPastedCount = 1;
1936 aDestEnd.SetRow( rDestPos.Row() + nPastedCount - 1 );
1937 }
1938
1939 MarkRange( ScRange( rDestPos, aDestEnd ), false ); //! sal_False ???
1940
1941 pDocSh->UpdateOle(GetViewData());
1942 SelectionChanged();
1943 }
1944 return bSuccess;
1945 }
1946
1947 // link inside the doc
1948
1949 bool ScViewFunc::LinkBlock( const ScRange& rSource, const ScAddress& rDestPos )
1950 {
1951 // check overlapping
1952
1953 if ( rSource.aStart.Tab() == rDestPos.Tab() )
1954 {
1955 SCCOL nDestEndCol = rDestPos.Col() + ( rSource.aEnd.Col() - rSource.aStart.Col() );
1956 SCROW nDestEndRow = rDestPos.Row() + ( rSource.aEnd.Row() - rSource.aStart.Row() );
1957
1958 if ( rSource.aStart.Col() <= nDestEndCol && rDestPos.Col() <= rSource.aEnd.Col() &&
1959 rSource.aStart.Row() <= nDestEndRow && rDestPos.Row() <= rSource.aEnd.Row() )
1960 {
1961 return false;
1962 }
1963 }
1964
1965 // run with paste
1966
1967 ScDocument& rDoc = GetViewData().GetDocument();
1968 ScDocumentUniquePtr pClipDoc(new ScDocument( SCDOCMODE_CLIP ));
1969 rDoc.CopyTabToClip( rSource.aStart.Col(), rSource.aStart.Row(),
1970 rSource.aEnd.Col(), rSource.aEnd.Row(),
1971 rSource.aStart.Tab(), pClipDoc.get() );
1972
1973 // mark destination area (set cursor, no marks)
1974
1975 if ( GetViewData().GetTabNo() != rDestPos.Tab() )
1976 SetTabNo( rDestPos.Tab() );
1977
1978 MoveCursorAbs( rDestPos.Col(), rDestPos.Row(), SC_FOLLOW_NONE, false, false );
1979
1980 // Paste
1981
1982 PasteFromClip( InsertDeleteFlags::ALL, pClipDoc.get(), ScPasteFunc::NONE, false, false, true ); // as a link
1983
1984 return true;
1985 }
1986
1987 void ScViewFunc::DataFormPutData( SCROW nCurrentRow ,
1988 SCROW nStartRow , SCCOL nStartCol ,
1989 SCROW nEndRow , SCCOL nEndCol ,
1990 std::vector<std::unique_ptr<ScDataFormFragment>>& rEdits,
1991 sal_uInt16 aColLength )
1992 {
1993 ScDocument& rDoc = GetViewData().GetDocument();
1994 ScDocShell* pDocSh = GetViewData().GetDocShell();
1995 ScMarkData& rMark = GetViewData().GetMarkData();
1996 ScDocShellModificator aModificator( *pDocSh );
1997 SfxUndoManager* pUndoMgr = pDocSh->GetUndoManager();
1998
1999 const bool bRecord( rDoc.IsUndoEnabled());
2000 ScDocumentUniquePtr pUndoDoc;
2001 ScDocumentUniquePtr pRedoDoc;
2002 std::unique_ptr<ScRefUndoData> pUndoData;
2003 SCTAB nTab = GetViewData().GetTabNo();
2004 SCTAB nStartTab = nTab;
2005 SCTAB nEndTab = nTab;
2006
2007 {
2008 ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
2009 if ( pChangeTrack )
2010 pChangeTrack->ResetLastCut(); // no more cut-mode
2011 }
2012 ScRange aUserRange( nStartCol, nCurrentRow, nStartTab, nEndCol, nCurrentRow, nEndTab );
2013 bool bColInfo = ( nStartRow==0 && nEndRow==rDoc.MaxRow() );
2014 bool bRowInfo = ( nStartCol==0 && nEndCol==rDoc.MaxCol() );
2015 SCCOL nUndoEndCol = nStartCol+aColLength-1;
2016 SCROW nUndoEndRow = nCurrentRow;
2017
2018 if ( bRecord )
2019 {
2020 pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
2021 pUndoDoc->InitUndoSelected( rDoc , rMark , bColInfo , bRowInfo );
2022 rDoc.CopyToDocument( aUserRange , InsertDeleteFlags::VALUE , false, *pUndoDoc );
2023 }
2024 sal_uInt16 nExtFlags = 0;
2025 pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab , nEndCol, nEndRow, nEndTab ); // content before the change
2026 rDoc.BeginDrawUndo();
2027
2028 for(sal_uInt16 i = 0; i < aColLength; i++)
2029 {
2030 if (rEdits[i] != nullptr)
2031 {
2032 OUString aFieldName = rEdits[i]->m_xEdit->get_text();
2033 rDoc.SetString( nStartCol + i, nCurrentRow, nTab, aFieldName );
2034 }
2035 }
2036 pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nCurrentRow, nStartTab, nEndCol, nCurrentRow, nEndTab ); // content after the change
2037 std::unique_ptr<SfxUndoAction> pUndo( new ScUndoDataForm( pDocSh,
2038 nStartCol, nCurrentRow, nStartTab,
2039 nUndoEndCol, nUndoEndRow, nEndTab, rMark,
2040 std::move(pUndoDoc), std::move(pRedoDoc),
2041 std::move(pUndoData) ) );
2042 pUndoMgr->AddUndoAction( std::make_unique<ScUndoWrapper>( std::move(pUndo) ), true );
2043
2044 PaintPartFlags nPaint = PaintPartFlags::Grid;
2045 if (bColInfo)
2046 {
2047 nPaint |= PaintPartFlags::Top;
2048 nUndoEndCol = rDoc.MaxCol(); // just for drawing !
2049 }
2050 if (bRowInfo)
2051 {
2052 nPaint |= PaintPartFlags::Left;
2053 nUndoEndRow = rDoc.MaxRow(); // just for drawing !
2054 }
2055
2056 pDocSh->PostPaint(
2057 ScRange(nStartCol, nCurrentRow, nStartTab, nUndoEndCol, nUndoEndRow, nEndTab),
2058 nPaint, nExtFlags);
2059 pDocSh->UpdateOle(GetViewData());
2060 }
2061
2062 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE