| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| |
| //---------------------------------------------------------------------------- |
| |
| #define _SV_NOXSOUND |
| |
| #define _BASE_DLGS_HXX |
| #define _BIGINT_HXX |
| #define _CACHESTR_HXX |
| #define _CONFIG_HXX |
| #define _CURSOR_HXX |
| #define _CTRLTOOL_HXX |
| #define _DLGCFG_HXX |
| #define _DYNARR_HXX |
| #define _EXTATTR_HXX |
| #define _FILDLG_HXX |
| #define _FONTDLG_HXX |
| #define _FRM3D_HXX |
| #define _INTRO_HXX |
| #define _ISETBWR_HXX |
| #define _NO_SVRTF_PARSER_HXX |
| #define _MACRODLG_HXX |
| #define _MODALDLG_HXX |
| #define _MOREBUTTON_HXX |
| #define _OUTLINER_HXX |
| //#define _PRNDLG_HXX |
| //#define _POLY_HXX |
| #define _PVRWIN_HXX |
| //#define _QUEUE_HXX |
| #define _RULER_HXX |
| #define _SCRWIN_HXX |
| #define _SETBRW_HXX |
| //#define _STACK_HXX |
| //#define _STATUS_HXX *** |
| #define _STDCTRL_HXX |
| #define _STDMENU_HXX |
| //#define _TAB_HXX |
| #define _TABBAR_HXX |
| #define _TREELIST_HXX |
| #define _VALUESET_HXX |
| #define _VCATTR_HXX |
| #define _VCBRW_HXX |
| #define _VCTRLS_HXX |
| #define _VCSBX_HXX |
| #define _VCONT_HXX |
| #define _VDRWOBJ_HXX |
| |
| //#define _SELENG_HXX |
| //#define _SOUND_HXX |
| //#define _SYSDLG_HXX |
| |
| |
| |
| |
| #define _PASSWD_HXX |
| |
| #define _SFX_DOCFILE_HXX |
| //#define _SFX_DOCFILT_HXX |
| #define _SFX_DOCINF_HXX |
| #define _SFX_DOCSH_HXX |
| //#define _SFXDOCFILT_HXX |
| //#define _SFXDOCINF_HXX |
| //#define _SFXDOCSH_HXX |
| #define _SFX_PRNMON_HXX |
| #define _SFX_RESMGR_HXX |
| #define _SFX_TEMPLDLG_HXX |
| //#define _SFXAPPWIN_HXX |
| #define _SFXBASIC_HXX |
| #define _SFXCTRLITEM |
| #define _SFXDLGCFG_HXX |
| //#define _SFXDISPATCH_HXX |
| #define _SFXFILEDLG_HXX |
| //#define _SFXIMGMGR_HXX |
| #define _SFXIPFRM_HXX |
| #define _SFX_MACRO_HXX |
| #define _SFXMNUITEM_HXX |
| #define _SFXMNUMGR_HXX |
| #define _SFXMULTISEL_HXX |
| //#define _SFXMSG_HXX |
| #define _SFXMSGDESCR_HXX |
| #define _SFXMSGPOOL_HXX |
| #define _SFX_MINFITEM_HXX |
| #define _SFXOBJFACE_HXX |
| #define _SFXOBJFAC_HXX |
| #define _SFX_SAVEOPT_HXX |
| #define _SFXSTBITEM_HXX |
| #define _SFXSTBMGR_HXX |
| #define _SFXTBXCTRL_HXX |
| #define _SFXTBXMGR_HXX |
| |
| #define _SI_HXX |
| //#define _SI_DLL_HXX |
| //#define _SIDLL_HXX |
| //#define _SI_NOITEMS |
| //#define _SI_NOOTHERFORMS |
| //#define _SI_NOSBXCONTROLS |
| //#define _SINOSBXCONTROLS |
| //#define _SI_NODRW |
| //#define _SI_NOCONTROL |
| |
| #define _SVBOXITM_HXX |
| #define _SVCONTNR_HXX // |
| |
| #define _SDR_NOTRANSFORM |
| |
| #define _SVDRAG_HXX |
| #define _SVINCVW_HXX |
| //#define _SV_MULTISEL_HXX |
| #define _SVRTV_HXX |
| #define _SVTABBX_HXX |
| #define _SVTREEBOX_HXX |
| #define _SVTREELIST_HXX |
| |
| #define _SVX_DAILDLL_HXX |
| #define _SVX_HYPHEN_HXX |
| #define _SVX_IMPGRF_HXX |
| #define _SVX_LAYCTRL_HXX |
| #define _SVX_OPTITEMS_HXX |
| #define _SVX_OPTGERL_HXX |
| #define _SVX_OPTSAVE_HXX |
| #define _SVX_OPTSPELL_HXX |
| #define _SVX_OPTPATH_HXX |
| #define _SVX_OPTLINGU_HXX |
| #define _SVX_RULER_HXX |
| #define _SVX_RULRITEM_HXX |
| #define _SVX_SELCTRL_HXX |
| #define _SVX_SPLWRAP_HXX |
| #define _SVX_SPLDLG_HXX |
| #define _SVX_STDDLG_HXX |
| #define _SVX_THESDLG_HXX |
| |
| // INCLUDE ------------------------------------------------------------------- |
| |
| #include "scitems.hxx" |
| #include <svx/dbexch.hrc> |
| #include <svx/svdetc.hxx> |
| #include <svx/svditer.hxx> |
| #include <svx/svdoole2.hxx> |
| #include <svx/svdpage.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <svl/stritem.hxx> |
| #include <svl/ptitem.hxx> |
| #include <svl/urlbmk.hxx> |
| #include <sot/clsids.hxx> |
| #include <sot/formats.hxx> |
| #include <vcl/graph.hxx> |
| #include <vcl/virdev.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <tools/urlobj.hxx> |
| #include <sot/exchange.hxx> |
| #include <memory> |
| |
| #include "attrib.hxx" |
| #include "patattr.hxx" |
| #include "dociter.hxx" |
| #include "viewfunc.hxx" |
| #include "tabvwsh.hxx" |
| #include "docsh.hxx" |
| #include "docfunc.hxx" |
| #include "undoblk.hxx" |
| #include "refundo.hxx" |
| #include "globstr.hrc" |
| #include "global.hxx" |
| #include "transobj.hxx" |
| #include "drwtrans.hxx" |
| #include "rangenam.hxx" |
| #include "dbcolect.hxx" |
| #include "impex.hxx" // Sylk-ID fuer CB |
| #include "chgtrack.hxx" |
| #include "waitoff.hxx" |
| #include "scmod.hxx" |
| #include "sc.hrc" |
| #include "inputopt.hxx" |
| #include "warnbox.hxx" |
| #include "drwlayer.hxx" |
| #include "editable.hxx" |
| #include "transobj.hxx" |
| #include "drwtrans.hxx" |
| #include "docuno.hxx" |
| #include "clipparam.hxx" |
| #include "drawview.hxx" |
| #include "chartlis.hxx" |
| #include "charthelper.hxx" |
| |
| |
| using namespace com::sun::star; |
| |
| // STATIC DATA --------------------------------------------------------------- |
| |
| |
| //============================================================================ |
| |
| // GlobalName der Writer-DocShell kommt jetzt aus comphelper/classids.hxx |
| |
| //---------------------------------------------------------------------------- |
| // C U T |
| |
| void ScViewFunc::CutToClip( ScDocument* pClipDoc, sal_Bool bIncludeObjects ) |
| { |
| UpdateInputLine(); |
| |
| ScEditableTester aTester( this ); |
| if (!aTester.IsEditable()) // selection editable? |
| { |
| ErrorMessage( aTester.GetMessageId() ); |
| return; |
| } |
| |
| ScRange aRange; // zu loeschender Bereich |
| if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE ) |
| { |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| ScDocShell* pDocSh = GetViewData()->GetDocShell(); |
| ScMarkData& rMark = GetViewData()->GetMarkData(); |
| const sal_Bool bRecord(pDoc->IsUndoEnabled()); // Undo/Redo |
| |
| ScDocShellModificator aModificator( *pDocSh ); |
| |
| if ( !rMark.IsMarked() && !rMark.IsMultiMarked() ) // mark the range if not marked yet |
| { |
| DoneBlockMode(); |
| InitOwnBlockMode(); |
| rMark.SetMarkArea( aRange ); |
| MarkDataChanged(); |
| } |
| |
| CopyToClip( pClipDoc, sal_True, sal_False, bIncludeObjects ); // Ab ins Clipboard |
| |
| ScAddress aOldEnd( aRange.aEnd ); // Zusammengefasste Zellen im Bereich? |
| pDoc->ExtendMerge( aRange, sal_True ); |
| |
| ScDocument* pUndoDoc = NULL; |
| if ( bRecord ) |
| { |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pUndoDoc->InitUndoSelected( pDoc, rMark ); |
| // all sheets - CopyToDocument skips those that don't exist in pUndoDoc |
| ScRange aCopyRange = aRange; |
| aCopyRange.aStart.SetTab(0); |
| aCopyRange.aEnd.SetTab(pDoc->GetTableCount()-1); |
| pDoc->CopyToDocument( aCopyRange, (IDF_ALL & ~IDF_OBJECTS) | IDF_NOCAPTIONS, sal_False, pUndoDoc ); |
| pDoc->BeginDrawUndo(); |
| } |
| |
| sal_uInt16 nExtFlags = 0; |
| pDocSh->UpdatePaintExt( nExtFlags, aRange ); |
| |
| HideCursor(); // Cursor aendert sich ! |
| |
| rMark.MarkToMulti(); |
| pDoc->DeleteSelection( IDF_ALL, rMark ); |
| if ( bIncludeObjects ) |
| pDoc->DeleteObjectsInSelection( rMark ); |
| rMark.MarkToSimple(); |
| |
| if ( !AdjustRowHeight( aRange.aStart.Row(), aRange.aEnd.Row() ) ) |
| pDocSh->PostPaint( aRange, PAINT_GRID, nExtFlags ); |
| |
| if ( bRecord ) // erst jetzt ist Draw-Undo verfuegbar |
| pDocSh->GetUndoManager()->AddUndoAction( |
| new ScUndoCut( pDocSh, aRange, aOldEnd, rMark, pUndoDoc ) ); |
| |
| aModificator.SetDocumentModified(); |
| ShowCursor(); // Cursor aendert sich ! |
| pDocSh->UpdateOle(GetViewData()); |
| |
| CellContentChanged(); |
| } |
| else |
| ErrorMessage( STR_NOMULTISELECT ); |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // C O P Y |
| |
| sal_Bool ScViewFunc::CopyToClip( ScDocument* pClipDoc, sal_Bool bCut, sal_Bool bApi, sal_Bool bIncludeObjects, sal_Bool bStopEdit ) |
| { |
| sal_Bool bDone = sal_False; |
| if ( bStopEdit ) |
| UpdateInputLine(); |
| |
| ScRange aRange; |
| ScMarkType eMarkType = GetViewData()->GetSimpleArea( aRange ); |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| ScMarkData& rMark = GetViewData()->GetMarkData(); |
| if ( eMarkType == SC_MARK_SIMPLE || eMarkType == SC_MARK_SIMPLE_FILTERED ) |
| { |
| if ( !pDoc->HasSelectedBlockMatrixFragment( |
| aRange.aStart.Col(), aRange.aStart.Row(), |
| aRange.aEnd.Col(), aRange.aEnd.Row(), |
| rMark ) ) |
| { |
| sal_Bool bSysClip = sal_False; |
| if ( !pClipDoc ) // no clip doc specified |
| { |
| pClipDoc = new ScDocument( SCDOCMODE_CLIP ); // create one (deleted by ScTransferObj) |
| bSysClip = sal_True; // and copy into system |
| } |
| |
| if ( !bCut ) |
| { |
| ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack(); |
| if ( pChangeTrack ) |
| pChangeTrack->ResetLastCut(); // kein CutMode mehr |
| } |
| |
| if ( bSysClip && bIncludeObjects ) |
| { |
| sal_Bool bAnyOle = pDoc->HasOLEObjectsInArea( aRange, &rMark ); |
| // update ScGlobal::pDrawClipDocShellRef |
| ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle ) ); |
| } |
| |
| ScClipParam aClipParam(aRange, bCut); |
| aClipParam.setSourceDocID( pDoc->GetDocumentID() ); |
| pDoc->CopyToClip(aClipParam, pClipDoc, &rMark, false, false, bIncludeObjects); |
| |
| if ( pDoc && pClipDoc ) |
| { |
| ScDrawLayer* pDrawLayer = pClipDoc->GetDrawLayer(); |
| if ( pDrawLayer ) |
| { |
| ScClipParam& rClipParam = pClipDoc->GetClipParam(); |
| ScRangeListVector& rRangesVector = rClipParam.maProtectedChartRangesVector; |
| SCTAB nTabCount = pClipDoc->GetTableCount(); |
| for ( SCTAB nTab = 0; nTab < nTabCount; ++nTab ) |
| { |
| SdrPage* pPage = pDrawLayer->GetPage( static_cast< sal_uInt16 >( nTab ) ); |
| if ( pPage ) |
| { |
| ScChartHelper::FillProtectedChartRangesVector( rRangesVector, pDoc, pPage ); |
| } |
| } |
| } |
| } |
| |
| if (bSysClip) |
| { |
| ScDrawLayer::SetGlobalDrawPersist(NULL); |
| |
| ScGlobal::SetClipDocName( pDoc->GetDocumentShell()->GetTitle( SFX_TITLE_FULLNAME ) ); |
| } |
| pClipDoc->ExtendMerge( aRange, sal_True ); |
| |
| if (bSysClip) |
| { |
| ScDocShell* pDocSh = GetViewData()->GetDocShell(); |
| TransferableObjectDescriptor aObjDesc; |
| pDocSh->FillTransferableObjectDescriptor( aObjDesc ); |
| aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass(); |
| // maSize is set in ScTransferObj ctor |
| |
| ScTransferObj* pTransferObj = new ScTransferObj( pClipDoc, aObjDesc ); |
| uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj ); |
| |
| if ( ScGlobal::pDrawClipDocShellRef ) |
| { |
| SfxObjectShellRef aPersistRef( &(*ScGlobal::pDrawClipDocShellRef) ); |
| pTransferObj->SetDrawPersist( aPersistRef ); // keep persist for ole objects alive |
| } |
| |
| pTransferObj->CopyToClipboard( GetActiveWin() ); // system clipboard |
| SC_MOD()->SetClipObject( pTransferObj, NULL ); // internal clipboard |
| } |
| |
| bDone = sal_True; |
| } |
| else |
| { |
| if (!bApi) |
| ErrorMessage(STR_MATRIXFRAGMENTERR); |
| } |
| } |
| else if (eMarkType == SC_MARK_MULTI) |
| { |
| bool bSuccess = false; |
| ScClipParam aClipParam; |
| aClipParam.mbCutMode = false; |
| rMark.MarkToSimple(); |
| rMark.FillRangeListWithMarks(&aClipParam.maRanges, false); |
| |
| do |
| { |
| if (bCut) |
| // We con't support cutting of multi-selections. |
| break; |
| |
| if (pClipDoc) |
| // TODO: What's this for? |
| break; |
| |
| ::std::auto_ptr<ScDocument> pDocClip(new ScDocument(SCDOCMODE_CLIP)); |
| |
| // Check for geometrical feasibility of the ranges. |
| bool bValidRanges = true; |
| ScRangePtr p = aClipParam.maRanges.First(); |
| SCCOL nPrevColDelta = 0; |
| SCROW nPrevRowDelta = 0; |
| SCCOL nPrevCol = p->aStart.Col(); |
| SCROW nPrevRow = p->aStart.Row(); |
| SCCOL nPrevColSize = p->aEnd.Col() - p->aStart.Col() + 1; |
| SCROW nPrevRowSize = p->aEnd.Row() - p->aStart.Row() + 1; |
| for (p = aClipParam.maRanges.Next(); p; p = aClipParam.maRanges.Next()) |
| { |
| if (pDoc->HasSelectedBlockMatrixFragment( |
| p->aStart.Col(), p->aStart.Row(), p->aEnd.Col(), p->aEnd.Row(), rMark)) |
| { |
| if (!bApi) |
| ErrorMessage(STR_MATRIXFRAGMENTERR); |
| return false; |
| } |
| |
| SCCOL nColDelta = p->aStart.Col() - nPrevCol; |
| SCROW nRowDelta = p->aStart.Row() - nPrevRow; |
| |
| if ((nColDelta && nRowDelta) || (nPrevColDelta && nRowDelta) || (nPrevRowDelta && nColDelta)) |
| { |
| bValidRanges = false; |
| break; |
| } |
| |
| if (aClipParam.meDirection == ScClipParam::Unspecified) |
| { |
| if (nColDelta) |
| aClipParam.meDirection = ScClipParam::Column; |
| if (nRowDelta) |
| aClipParam.meDirection = ScClipParam::Row; |
| } |
| |
| SCCOL nColSize = p->aEnd.Col() - p->aStart.Col() + 1; |
| SCROW nRowSize = p->aEnd.Row() - p->aStart.Row() + 1; |
| |
| if (aClipParam.meDirection == ScClipParam::Column && nRowSize != nPrevRowSize) |
| { |
| // column-oriented ranges must have identical row size. |
| bValidRanges = false; |
| break; |
| } |
| if (aClipParam.meDirection == ScClipParam::Row && nColSize != nPrevColSize) |
| { |
| // likewise, row-oriented ranges must have identical |
| // column size. |
| bValidRanges = false; |
| break; |
| } |
| |
| nPrevCol = p->aStart.Col(); |
| nPrevRow = p->aStart.Row(); |
| nPrevColDelta = nColDelta; |
| nPrevRowDelta = nRowDelta; |
| nPrevColSize = nColSize; |
| nPrevRowSize = nRowSize; |
| } |
| if (!bValidRanges) |
| break; |
| |
| pDoc->CopyToClip(aClipParam, pDocClip.get(), &rMark, false, false, bIncludeObjects); |
| |
| ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack(); |
| if ( pChangeTrack ) |
| pChangeTrack->ResetLastCut(); // kein CutMode mehr |
| |
| { |
| ScDocShell* pDocSh = GetViewData()->GetDocShell(); |
| TransferableObjectDescriptor aObjDesc; |
| pDocSh->FillTransferableObjectDescriptor( aObjDesc ); |
| aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass(); |
| // maSize is set in ScTransferObj ctor |
| |
| ScTransferObj* pTransferObj = new ScTransferObj( pDocClip.release(), aObjDesc ); |
| uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj ); |
| |
| if ( ScGlobal::pDrawClipDocShellRef ) |
| { |
| SfxObjectShellRef aPersistRef( &(*ScGlobal::pDrawClipDocShellRef) ); |
| pTransferObj->SetDrawPersist( aPersistRef ); // keep persist for ole objects alive |
| } |
| |
| pTransferObj->CopyToClipboard( GetActiveWin() ); // system clipboard |
| SC_MOD()->SetClipObject( pTransferObj, NULL ); // internal clipboard |
| } |
| |
| bSuccess = true; |
| } |
| while (false); |
| |
| if (!bSuccess && !bApi) |
| ErrorMessage(STR_NOMULTISELECT); |
| |
| bDone = bSuccess; |
| } |
| else |
| { |
| if (!bApi) |
| ErrorMessage(STR_NOMULTISELECT); |
| } |
| |
| return bDone; |
| } |
| |
| ScTransferObj* ScViewFunc::CopyToTransferable() |
| { |
| ScRange aRange; |
| if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE ) |
| { |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| ScMarkData& rMark = GetViewData()->GetMarkData(); |
| if ( !pDoc->HasSelectedBlockMatrixFragment( |
| aRange.aStart.Col(), aRange.aStart.Row(), |
| aRange.aEnd.Col(), aRange.aEnd.Row(), |
| rMark ) ) |
| { |
| ScDocument *pClipDoc = new ScDocument( SCDOCMODE_CLIP ); // create one (deleted by ScTransferObj) |
| |
| sal_Bool bAnyOle = pDoc->HasOLEObjectsInArea( aRange, &rMark ); |
| ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle ) ); |
| |
| ScClipParam aClipParam(aRange, false); |
| pDoc->CopyToClip(aClipParam, pClipDoc, &rMark, false, false, true); |
| |
| ScDrawLayer::SetGlobalDrawPersist(NULL); |
| pClipDoc->ExtendMerge( aRange, sal_True ); |
| |
| ScDocShell* pDocSh = GetViewData()->GetDocShell(); |
| TransferableObjectDescriptor aObjDesc; |
| pDocSh->FillTransferableObjectDescriptor( aObjDesc ); |
| aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass(); |
| ScTransferObj* pTransferObj = new ScTransferObj( pClipDoc, aObjDesc ); |
| return pTransferObj; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| //---------------------------------------------------------------------------- |
| // P A S T E |
| |
| void ScViewFunc::PasteDraw() |
| { |
| ScViewData* pViewData = GetViewData(); |
| SCCOL nPosX = pViewData->GetCurX(); |
| SCROW nPosY = pViewData->GetCurY(); |
| Window* pWin = GetActiveWin(); |
| Point aPos = pWin->PixelToLogic( pViewData->GetScrPos( nPosX, nPosY, |
| pViewData->GetActivePart() ) ); |
| ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard( pWin ); |
| if (pDrawClip) |
| PasteDraw( aPos, pDrawClip->GetModel(), sal_False, |
| pDrawClip->GetSourceDocID() == pViewData->GetDocument()->GetDocumentID() ); |
| } |
| |
| void ScViewFunc::PasteFromSystem() |
| { |
| UpdateInputLine(); |
| |
| Window* pWin = GetActiveWin(); |
| ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( pWin ); |
| ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard( pWin ); |
| |
| if (pOwnClip) |
| { |
| // #129384# keep a reference in case the clipboard is changed during PasteFromClip |
| uno::Reference<datatransfer::XTransferable> aOwnClipRef( pOwnClip ); |
| PasteFromClip( IDF_ALL, pOwnClip->GetDocument(), |
| PASTE_NOFUNC, sal_False, sal_False, sal_False, INS_NONE, IDF_NONE, |
| sal_True ); // allow warning dialog |
| } |
| else if (pDrawClip) |
| PasteDraw(); |
| else |
| { |
| TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pWin ) ); |
| |
| // if (pClipObj.Is()) |
| { |
| sal_uLong nBiff8 = SotExchange::RegisterFormatName( |
| String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff8"))); |
| sal_uLong nBiff5 = SotExchange::RegisterFormatName( |
| String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff5"))); |
| |
| // als erstes SvDraw-Model, dann Grafik |
| // (Grafik darf nur bei einzelner Grafik drinstehen) |
| |
| if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING )) |
| { |
| // special case for tables from drawing |
| if( aDataHelper.HasFormat( SOT_FORMAT_RTF ) ) |
| { |
| PasteFromSystem( FORMAT_RTF ); |
| } |
| else |
| { |
| PasteFromSystem( SOT_FORMATSTR_ID_DRAWING ); |
| } |
| } |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB )) |
| PasteFromSystem( SOT_FORMATSTR_ID_SVXB ); |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE )) |
| { |
| // If it's a Writer object, insert RTF instead of OLE |
| |
| sal_Bool bDoRtf = sal_False; |
| TransferableObjectDescriptor aObjDesc; |
| if( aDataHelper.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) ) |
| { |
| bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) || |
| aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) ) |
| && aDataHelper.HasFormat( SOT_FORMAT_RTF ) ); |
| } |
| if ( bDoRtf ) |
| PasteFromSystem( FORMAT_RTF ); |
| else |
| PasteFromSystem( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| } |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE )) |
| PasteFromSystem( SOT_FORMATSTR_ID_LINK_SOURCE ); |
| // the following format can not affect scenario from #89579# |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE )) |
| PasteFromSystem( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE ); |
| // FORMAT_PRIVATE no longer here (can't work if pOwnClip is NULL) |
| else if (aDataHelper.HasFormat(nBiff8)) // before xxx_OLE formats |
| PasteFromSystem(nBiff8); |
| else if (aDataHelper.HasFormat(nBiff5)) |
| PasteFromSystem(nBiff5); |
| else if (aDataHelper.HasFormat(FORMAT_RTF)) |
| PasteFromSystem(FORMAT_RTF); |
| else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML)) |
| PasteFromSystem(SOT_FORMATSTR_ID_HTML); |
| else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML_SIMPLE)) |
| PasteFromSystem(SOT_FORMATSTR_ID_HTML_SIMPLE); |
| else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_SYLK)) |
| PasteFromSystem(SOT_FORMATSTR_ID_SYLK); |
| else if (aDataHelper.HasFormat(FORMAT_STRING)) |
| PasteFromSystem(FORMAT_STRING); |
| else if (aDataHelper.HasFormat(FORMAT_GDIMETAFILE)) |
| PasteFromSystem(FORMAT_GDIMETAFILE); |
| else if (aDataHelper.HasFormat(FORMAT_BITMAP)) |
| PasteFromSystem(FORMAT_BITMAP); |
| // #89579# xxx_OLE formats come last, like in SotExchange tables |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE )) |
| PasteFromSystem( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE ); |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE_OLE )) |
| PasteFromSystem( SOT_FORMATSTR_ID_LINK_SOURCE_OLE ); |
| // else |
| // ErrorMessage(STR_PASTE_ERROR); |
| } |
| // else |
| // ErrorMessage(STR_PASTE_ERROR); |
| } |
| |
| // keine Fehlermeldung, weil SID_PASTE in der idl das FastCall-Flag hat, |
| // also auch gerufen wird, wenn nichts im Clipboard steht (#42531#) |
| } |
| |
| void ScViewFunc::PasteFromTransferable( const uno::Reference<datatransfer::XTransferable>& rxTransferable ) |
| { |
| ScTransferObj *pOwnClip=0; |
| ScDrawTransferObj *pDrawClip=0; |
| uno::Reference<lang::XUnoTunnel> xTunnel( rxTransferable, uno::UNO_QUERY ); |
| if ( xTunnel.is() ) |
| { |
| sal_Int64 nHandle = xTunnel->getSomething( ScTransferObj::getUnoTunnelId() ); |
| if ( nHandle ) |
| pOwnClip = (ScTransferObj*) (sal_IntPtr) nHandle; |
| else |
| { |
| nHandle = xTunnel->getSomething( ScDrawTransferObj::getUnoTunnelId() ); |
| if ( nHandle ) |
| pDrawClip = (ScDrawTransferObj*) (sal_IntPtr) nHandle; |
| } |
| } |
| |
| if (pOwnClip) |
| { |
| PasteFromClip( IDF_ALL, pOwnClip->GetDocument(), |
| PASTE_NOFUNC, sal_False, sal_False, sal_False, INS_NONE, IDF_NONE, |
| sal_True ); // allow warning dialog |
| } |
| else if (pDrawClip) |
| { |
| ScViewData* pViewData = GetViewData(); |
| SCCOL nPosX = pViewData->GetCurX(); |
| SCROW nPosY = pViewData->GetCurY(); |
| Window* pWin = GetActiveWin(); |
| Point aPos = pWin->PixelToLogic( pViewData->GetScrPos( nPosX, nPosY, pViewData->GetActivePart() ) ); |
| PasteDraw( aPos, pDrawClip->GetModel(), sal_False, pDrawClip->GetSourceDocID() == pViewData->GetDocument()->GetDocumentID() ); |
| } |
| else |
| { |
| TransferableDataHelper aDataHelper( rxTransferable ); |
| { |
| sal_uLong nBiff8 = SotExchange::RegisterFormatName( |
| String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff8"))); |
| sal_uLong nBiff5 = SotExchange::RegisterFormatName( |
| String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff5"))); |
| sal_uLong nFormatId = 0; |
| // als erstes SvDraw-Model, dann Grafik |
| // (Grafik darf nur bei einzelner Grafik drinstehen) |
| |
| if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING )) |
| nFormatId = SOT_FORMATSTR_ID_DRAWING; |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB )) |
| nFormatId = SOT_FORMATSTR_ID_SVXB; |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE )) |
| { |
| // If it's a Writer object, insert RTF instead of OLE |
| sal_Bool bDoRtf = sal_False; |
| TransferableObjectDescriptor aObjDesc; |
| if( aDataHelper.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) ) |
| { |
| bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) || |
| aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) ) |
| && aDataHelper.HasFormat( SOT_FORMAT_RTF ) ); |
| } |
| if ( bDoRtf ) |
| nFormatId = FORMAT_RTF; |
| else |
| nFormatId = SOT_FORMATSTR_ID_EMBED_SOURCE; |
| } |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE )) |
| nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE; |
| // the following format can not affect scenario from #89579# |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE )) |
| nFormatId = SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE; |
| // FORMAT_PRIVATE no longer here (can't work if pOwnClip is NULL) |
| else if (aDataHelper.HasFormat(nBiff8)) // before xxx_OLE formats |
| nFormatId = nBiff8; |
| else if (aDataHelper.HasFormat(nBiff5)) |
| nFormatId = nBiff5; |
| else if (aDataHelper.HasFormat(FORMAT_RTF)) |
| nFormatId = FORMAT_RTF; |
| else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML)) |
| nFormatId = SOT_FORMATSTR_ID_HTML; |
| else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML_SIMPLE)) |
| nFormatId = SOT_FORMATSTR_ID_HTML_SIMPLE; |
| else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_SYLK)) |
| nFormatId = SOT_FORMATSTR_ID_SYLK; |
| else if (aDataHelper.HasFormat(FORMAT_STRING)) |
| nFormatId = FORMAT_STRING; |
| else if (aDataHelper.HasFormat(FORMAT_GDIMETAFILE)) |
| nFormatId = FORMAT_GDIMETAFILE; |
| else if (aDataHelper.HasFormat(FORMAT_BITMAP)) |
| nFormatId = FORMAT_BITMAP; |
| // #89579# xxx_OLE formats come last, like in SotExchange tables |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE )) |
| nFormatId = SOT_FORMATSTR_ID_EMBED_SOURCE_OLE; |
| else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE_OLE )) |
| nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE_OLE; |
| else |
| return; |
| |
| PasteDataFormat( nFormatId, aDataHelper.GetTransferable(), |
| GetViewData()->GetCurX(), GetViewData()->GetCurY(), |
| NULL, sal_False, sal_False ); |
| } |
| } |
| } |
| |
| sal_Bool ScViewFunc::PasteFromSystem( sal_uLong nFormatId, sal_Bool bApi ) |
| { |
| UpdateInputLine(); |
| |
| sal_Bool bRet = sal_True; |
| Window* pWin = GetActiveWin(); |
| ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( pWin ); |
| if ( nFormatId == 0 && pOwnClip ) |
| { |
| // #129384# keep a reference in case the clipboard is changed during PasteFromClip |
| uno::Reference<datatransfer::XTransferable> aOwnClipRef( pOwnClip ); |
| PasteFromClip( IDF_ALL, pOwnClip->GetDocument(), |
| PASTE_NOFUNC, sal_False, sal_False, sal_False, INS_NONE, IDF_NONE, |
| !bApi ); // allow warning dialog |
| } |
| else |
| { |
| TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pWin ) ); |
| if ( !aDataHelper.GetTransferable().is() ) |
| return sal_False; |
| |
| bRet = PasteDataFormat( nFormatId, aDataHelper.GetTransferable(), |
| GetViewData()->GetCurX(), GetViewData()->GetCurY(), |
| NULL, sal_False, !bApi ); // allow warning dialog |
| |
| if ( !bRet && !bApi ) |
| ErrorMessage(STR_PASTE_ERROR); |
| } |
| return bRet; |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // P A S T E |
| |
| sal_Bool ScViewFunc::PasteOnDrawObjectLinked( |
| const uno::Reference<datatransfer::XTransferable>& rxTransferable, |
| SdrObject& rHitObj) |
| { |
| TransferableDataHelper aDataHelper( rxTransferable ); |
| |
| if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ) ) |
| { |
| SotStorageStreamRef xStm; |
| ScDrawView* pScDrawView = GetScDrawView(); |
| |
| if( pScDrawView && aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_SVXB, xStm ) ) |
| { |
| Graphic aGraphic; |
| |
| *xStm >> aGraphic; |
| |
| const String aEmpty; |
| const String aBeginUndo(ScGlobal::GetRscString(STR_UNDO_DRAGDROP)); |
| |
| if(pScDrawView->ApplyGraphicToObject( rHitObj, aGraphic, aBeginUndo, aEmpty, aEmpty )) |
| { |
| return sal_True; |
| } |
| } |
| } |
| else if ( aDataHelper.HasFormat( SOT_FORMAT_GDIMETAFILE ) ) |
| { |
| GDIMetaFile aMtf; |
| ScDrawView* pScDrawView = GetScDrawView(); |
| |
| if( pScDrawView && aDataHelper.GetGDIMetaFile( FORMAT_GDIMETAFILE, aMtf ) ) |
| { |
| const String aEmpty; |
| const String aBeginUndo(ScGlobal::GetRscString(STR_UNDO_DRAGDROP)); |
| |
| if(pScDrawView->ApplyGraphicToObject( rHitObj, Graphic(aMtf), aBeginUndo, aEmpty, aEmpty )) |
| { |
| return sal_True; |
| } |
| } |
| } |
| else if ( aDataHelper.HasFormat( SOT_FORMAT_BITMAP ) || aDataHelper.HasFormat( SOT_FORMATSTR_ID_PNG ) ) |
| { |
| BitmapEx aBmpEx; |
| ScDrawView* pScDrawView = GetScDrawView(); |
| |
| if( pScDrawView && aDataHelper.GetBitmapEx( FORMAT_BITMAP, aBmpEx ) ) |
| { |
| const String aEmpty; |
| const String aBeginUndo(ScGlobal::GetRscString(STR_UNDO_DRAGDROP)); |
| |
| if(pScDrawView->ApplyGraphicToObject( rHitObj, Graphic(aBmpEx), aBeginUndo, aEmpty, aEmpty )) |
| { |
| return sal_True; |
| } |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| sal_Bool lcl_SelHasAttrib( ScDocument* pDoc, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, |
| const ScMarkData& rTabSelection, sal_uInt16 nMask ) |
| { |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| for (SCTAB nTab=0; nTab<nTabCount; nTab++) |
| if ( rTabSelection.GetTableSelect(nTab) && pDoc->HasAttrib( nCol1, nRow1, nTab, nCol2, nRow2, nTab, nMask ) ) |
| return sal_True; |
| return sal_False; |
| } |
| |
| // |
| // Einfuegen auf Tabelle: |
| // |
| |
| // internes Paste |
| |
| namespace { |
| |
| class CursorSwitcher |
| { |
| public: |
| CursorSwitcher(ScViewFunc* pViewFunc) : |
| mpViewFunc(pViewFunc) |
| { |
| mpViewFunc->HideCursor(); |
| } |
| |
| ~CursorSwitcher() |
| { |
| mpViewFunc->ShowCursor(); |
| } |
| private: |
| ScViewFunc* mpViewFunc; |
| }; |
| |
| bool lcl_checkDestRangeForOverwrite(const ScRange& rDestRange, const ScDocument* pDoc, const ScMarkData& rMark, Window* pParentWnd) |
| { |
| bool bIsEmpty = true; |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| for (SCTAB nTab=0; nTab < nTabCount && bIsEmpty; ++nTab) |
| { |
| if (!rMark.GetTableSelect(nTab)) |
| continue; |
| |
| bIsEmpty = pDoc->IsBlockEmpty(nTab, rDestRange.aStart.Col(), rDestRange.aStart.Row(), |
| rDestRange.aEnd.Col(), rDestRange.aEnd.Row()); |
| } |
| |
| if (!bIsEmpty) |
| { |
| ScReplaceWarnBox aBox(pParentWnd); |
| if (aBox.Execute() != RET_YES) |
| { |
| // changing the configuration is within the ScReplaceWarnBox |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| } |
| |
| sal_Bool ScViewFunc::PasteFromClip( sal_uInt16 nFlags, ScDocument* pClipDoc, |
| sal_uInt16 nFunction, sal_Bool bSkipEmpty, |
| sal_Bool bTranspose, sal_Bool bAsLink, |
| InsCellCmd eMoveMode, sal_uInt16 nUndoExtraFlags, |
| sal_Bool bAllowDialogs ) |
| { |
| if (!pClipDoc) |
| { |
| DBG_ERROR("PasteFromClip: pClipDoc=0 not allowed"); |
| return sal_False; |
| } |
| |
| // fuer Undo etc. immer alle oder keine Inhalte sichern |
| sal_uInt16 nContFlags = IDF_NONE; |
| if (nFlags & IDF_CONTENTS) |
| nContFlags |= IDF_CONTENTS; |
| if (nFlags & IDF_ATTRIB) |
| nContFlags |= IDF_ATTRIB; |
| // evtl. Attribute ins Undo ohne sie vom Clip ins Doc zu kopieren |
| sal_uInt16 nUndoFlags = nContFlags; |
| if (nUndoExtraFlags & IDF_ATTRIB) |
| nUndoFlags |= IDF_ATTRIB; |
| // do not copy note captions into undo document |
| nUndoFlags |= IDF_NOCAPTIONS; |
| |
| ScClipParam& rClipParam = pClipDoc->GetClipParam(); |
| if (rClipParam.isMultiRange()) |
| return PasteMultiRangesFromClip( |
| nFlags, pClipDoc, nFunction, bSkipEmpty, bTranspose, bAsLink, bAllowDialogs, |
| eMoveMode, nContFlags, nUndoFlags); |
| |
| sal_Bool bCutMode = pClipDoc->IsCutMode(); // if transposing, take from original clipdoc |
| sal_Bool bIncludeFiltered = bCutMode; |
| |
| // paste drawing: also if IDF_NOTE is set (to create drawing layer for note captions) |
| sal_Bool bPasteDraw = ( pClipDoc->GetDrawLayer() && ( nFlags & (IDF_OBJECTS|IDF_NOTE) ) ); |
| |
| ScDocShellRef aTransShellRef; // for objects in xTransClip - must remain valid as long as xTransClip |
| ScDocument* pOrigClipDoc = NULL; |
| ::std::auto_ptr< ScDocument > xTransClip; |
| if ( bTranspose ) |
| { |
| SCCOL nX; |
| SCROW nY; |
| // include filtered rows until TransposeClip can skip them |
| bIncludeFiltered = sal_True; |
| pClipDoc->GetClipArea( nX, nY, sal_True ); |
| if ( nY > static_cast<sal_Int32>(MAXCOL) ) // zuviele Zeilen zum Transponieren |
| { |
| ErrorMessage(STR_PASTE_FULL); |
| return sal_False; |
| } |
| pOrigClipDoc = pClipDoc; // fuer Referenzen |
| |
| if ( bPasteDraw ) |
| { |
| aTransShellRef = new ScDocShell; // DocShell needs a Ref immediately |
| aTransShellRef->DoInitNew(NULL); |
| } |
| ScDrawLayer::SetGlobalDrawPersist(aTransShellRef); |
| |
| xTransClip.reset( new ScDocument( SCDOCMODE_CLIP )); |
| pClipDoc->TransposeClip( xTransClip.get(), nFlags, bAsLink ); |
| pClipDoc = xTransClip.get(); |
| |
| ScDrawLayer::SetGlobalDrawPersist(NULL); |
| } |
| |
| SCCOL nStartCol; |
| SCROW nStartRow; |
| SCTAB nStartTab; |
| SCCOL nEndCol; |
| SCROW nEndRow; |
| SCTAB nEndTab; |
| SCCOL nClipSizeX; |
| SCROW nClipSizeY; |
| pClipDoc->GetClipArea( nClipSizeX, nClipSizeY, sal_True ); // size in clipboard doc |
| |
| // size in target doc: include filtered rows only if CutMode is set |
| SCCOL nDestSizeX; |
| SCROW nDestSizeY; |
| pClipDoc->GetClipArea( nDestSizeX, nDestSizeY, bIncludeFiltered ); |
| |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| ScDocShell* pDocSh = GetViewData()->GetDocShell(); |
| ScMarkData& rMark = GetViewData()->GetMarkData(); |
| ::svl::IUndoManager* pUndoMgr = pDocSh->GetUndoManager(); |
| const sal_Bool bRecord(pDoc->IsUndoEnabled()); |
| |
| ScDocShellModificator aModificator( *pDocSh ); |
| |
| ScRange aMarkRange; |
| ScMarkData aFilteredMark( rMark); // local copy for all modifications |
| ScMarkType eMarkType = GetViewData()->GetSimpleArea( aMarkRange, aFilteredMark); |
| bool bMarkIsFiltered = (eMarkType == SC_MARK_SIMPLE_FILTERED); |
| bool bNoPaste = ((eMarkType != SC_MARK_SIMPLE && !bMarkIsFiltered) || |
| (bMarkIsFiltered && (eMoveMode != INS_NONE || bAsLink))); |
| if (!bNoPaste && !rMark.IsMarked()) |
| { |
| // Create a selection with clipboard row count and check that for |
| // filtered. |
| nStartCol = GetViewData()->GetCurX(); |
| nStartRow = GetViewData()->GetCurY(); |
| nStartTab = GetViewData()->GetTabNo(); |
| nEndCol = nStartCol + nDestSizeX; |
| nEndRow = nStartRow + nDestSizeY; |
| nEndTab = nStartTab; |
| aMarkRange = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab); |
| if (ScViewUtil::HasFiltered( aMarkRange, pDoc)) |
| { |
| bMarkIsFiltered = true; |
| // Fit to clipboard's row count unfiltered rows. If there is no |
| // fit assume that pasting is not possible. Note that nDestSizeY is |
| // size-1 (difference). |
| if (!ScViewUtil::FitToUnfilteredRows( aMarkRange, pDoc, nDestSizeY+1)) |
| bNoPaste = true; |
| } |
| aFilteredMark.SetMarkArea( aMarkRange); |
| } |
| if (bNoPaste) |
| { |
| ErrorMessage(STR_MSSG_PASTEFROMCLIP_0); |
| return sal_False; |
| } |
| |
| SCROW nUnfilteredRows = aMarkRange.aEnd.Row() - aMarkRange.aStart.Row() + 1; |
| ScRangeList aRangeList; |
| if (bMarkIsFiltered) |
| { |
| ScViewUtil::UnmarkFiltered( aFilteredMark, pDoc); |
| aFilteredMark.FillRangeListWithMarks( &aRangeList, sal_False); |
| nUnfilteredRows = 0; |
| for (ScRange* p = aRangeList.First(); p; p = aRangeList.Next()) |
| { |
| nUnfilteredRows += p->aEnd.Row() - p->aStart.Row() + 1; |
| } |
| #if 0 |
| /* This isn't needed but could be a desired restriction. */ |
| // For filtered, destination rows have to be an exact multiple of |
| // source rows. Note that nDestSizeY is size-1 (difference), so |
| // nDestSizeY==0 fits always. |
| if ((nUnfilteredRows % (nDestSizeY+1)) != 0) |
| { |
| /* FIXME: this should be a more descriptive error message then. */ |
| ErrorMessage(STR_MSSG_PASTEFROMCLIP_0); |
| return sal_False; |
| } |
| #endif |
| } |
| |
| SCCOL nMarkAddX = 0; |
| SCROW nMarkAddY = 0; |
| |
| // Also for a filtered selection the area is used, for undo et al. |
| if ( aFilteredMark.IsMarked() || bMarkIsFiltered ) |
| { |
| aMarkRange.GetVars( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab); |
| SCCOL nBlockAddX = nEndCol-nStartCol; |
| SCROW nBlockAddY = nEndRow-nStartRow; |
| |
| // #58422# Nachfrage, wenn die Selektion groesser als 1 Zeile/Spalte, aber kleiner |
| // als das Clipboard ist (dann wird ueber die Selektion hinaus eingefuegt) |
| |
| // ClipSize is not size, but difference |
| if ( ( nBlockAddX != 0 && nBlockAddX < nDestSizeX ) || |
| ( nBlockAddY != 0 && nBlockAddY < nDestSizeY ) || |
| ( bMarkIsFiltered && nUnfilteredRows < nDestSizeY+1 ) ) |
| { |
| ScWaitCursorOff aWaitOff( GetFrameWin() ); |
| String aMessage = ScGlobal::GetRscString( STR_PASTE_BIGGER ); |
| QueryBox aBox( GetViewData()->GetDialogParent(), |
| WinBits(WB_YES_NO | WB_DEF_NO), aMessage ); |
| if ( aBox.Execute() != RET_YES ) |
| { |
| return sal_False; |
| } |
| } |
| |
| if (nBlockAddX > nDestSizeX) |
| nMarkAddX = nBlockAddX - nDestSizeX; // fuer Merge-Test |
| else |
| { |
| nEndCol = nStartCol + nDestSizeX; |
| if (nEndCol > aMarkRange.aEnd.Col()) |
| { |
| // #i113553# larger range has to be included in aFilteredMark (for undo), but extending columns can't changed the filtered status |
| aMarkRange = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ); |
| aFilteredMark.SetMarkArea( aMarkRange ); |
| if (bMarkIsFiltered) |
| { |
| ScViewUtil::UnmarkFiltered( aFilteredMark, pDoc ); |
| aFilteredMark.FillRangeListWithMarks( &aRangeList, sal_True ); |
| } |
| } |
| } |
| |
| if (nBlockAddY > nDestSizeY) |
| nMarkAddY = nBlockAddY - nDestSizeY; // fuer Merge-Test |
| else |
| { |
| nEndRow = nStartRow + nDestSizeY; |
| if (bMarkIsFiltered || nEndRow > aMarkRange.aEnd.Row()) |
| { |
| // Same as above if nothing was marked: re-fit selection to |
| // unfiltered rows. Extending the selection actually may |
| // introduce filtered rows where there weren't any before, so |
| // we also need to test for that. |
| aMarkRange = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab); |
| if (bMarkIsFiltered || ScViewUtil::HasFiltered( aMarkRange, pDoc)) |
| { |
| bMarkIsFiltered = true; |
| // Worst case: all rows up to the end of the sheet are filtered. |
| if (!ScViewUtil::FitToUnfilteredRows( aMarkRange, pDoc, nDestSizeY+1)) |
| { |
| ErrorMessage(STR_PASTE_FULL); |
| return sal_False; |
| } |
| } |
| aMarkRange.GetVars( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab); |
| aFilteredMark.SetMarkArea( aMarkRange); |
| if (bMarkIsFiltered) |
| { |
| ScViewUtil::UnmarkFiltered( aFilteredMark, pDoc); |
| aFilteredMark.FillRangeListWithMarks( &aRangeList, sal_True); |
| } |
| } |
| } |
| } |
| else |
| { |
| nStartCol = GetViewData()->GetCurX(); |
| nStartRow = GetViewData()->GetCurY(); |
| nStartTab = GetViewData()->GetTabNo(); |
| nEndCol = nStartCol + nDestSizeX; |
| nEndRow = nStartRow + nDestSizeY; |
| nEndTab = nStartTab; |
| } |
| |
| bool bOffLimits = !ValidCol(nEndCol) || !ValidRow(nEndRow); |
| |
| // Zielbereich, wie er angezeigt wird: |
| ScRange aUserRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ); |
| |
| // Sollen Zellen eingefuegt werden? |
| // (zu grosse nEndCol/nEndRow werden weiter unten erkannt) |
| sal_Bool bInsertCells = ( eMoveMode != INS_NONE && !bOffLimits ); |
| if ( bInsertCells ) |
| { |
| // #94115# Instead of EnterListAction, the paste undo action is merged into the |
| // insert action, so Repeat can insert the right cells |
| |
| MarkRange( aUserRange ); // wird vor CopyFromClip sowieso gesetzt |
| |
| // #72930# CutMode is reset on insertion of cols/rows but needed again on cell move |
| sal_Bool bCut = pClipDoc->IsCutMode(); |
| if (!InsertCells( eMoveMode, bRecord, sal_True )) // is inserting possible? |
| { |
| return sal_False; |
| // #i21036# EnterListAction isn't used, and InsertCells doesn't insert |
| // its undo action on failure, so no undo handling is needed here |
| } |
| if ( bCut ) |
| pClipDoc->SetCutMode( bCut ); |
| } |
| else if (!bOffLimits) |
| { |
| sal_Bool bAskIfNotEmpty = bAllowDialogs && |
| ( nFlags & IDF_CONTENTS ) && |
| nFunction == PASTE_NOFUNC && |
| SC_MOD()->GetInputOptions().GetReplaceCellsWarn(); |
| if ( bAskIfNotEmpty ) |
| { |
| if (!lcl_checkDestRangeForOverwrite(aUserRange, pDoc, aFilteredMark, GetViewData()->GetDialogParent())) |
| return false; |
| } |
| } |
| |
| SCCOL nClipStartX; // Clipboard-Bereich erweitern |
| SCROW nClipStartY; |
| pClipDoc->GetClipStart( nClipStartX, nClipStartY ); |
| SCCOL nUndoEndCol = nClipStartX + nClipSizeX; |
| SCROW nUndoEndRow = nClipStartY + nClipSizeY; // end of source area in clipboard document |
| sal_Bool bClipOver = sal_False; |
| // #i68690# ExtendMerge for the clip doc must be called with the clipboard's sheet numbers. |
| // The same end column/row can be used for all calls because the clip doc doesn't contain |
| // content outside the clip area. |
| for (SCTAB nClipTab=0; nClipTab<=MAXTAB; nClipTab++) |
| if ( pClipDoc->HasTable(nClipTab) ) |
| if ( pClipDoc->ExtendMerge( nClipStartX,nClipStartY, nUndoEndCol,nUndoEndRow, nClipTab, sal_False ) ) |
| bClipOver = sal_True; |
| nUndoEndCol -= nClipStartX + nClipSizeX; |
| nUndoEndRow -= nClipStartY + nClipSizeY; // now contains only the difference added by ExtendMerge |
| nUndoEndCol = sal::static_int_cast<SCCOL>( nUndoEndCol + nEndCol ); |
| nUndoEndRow = sal::static_int_cast<SCROW>( nUndoEndRow + nEndRow ); // destination area, expanded for merged cells |
| |
| // if (nUndoEndCol < nEndCol) nUndoEndCol = nEndCol; |
| // if (nUndoEndRow < nEndRow) nUndoEndRow = nEndRow; |
| |
| // nUndoEndCol += nMarkAddX; |
| // nUndoEndRow += nMarkAddY; |
| |
| if (nUndoEndCol>MAXCOL || nUndoEndRow>MAXROW) |
| { |
| ErrorMessage(STR_PASTE_FULL); |
| return sal_False; |
| } |
| |
| pDoc->ExtendMergeSel( nStartCol,nStartRow, nUndoEndCol,nUndoEndRow, aFilteredMark, sal_False ); |
| |
| // Test auf Zellschutz |
| |
| ScEditableTester aTester( pDoc, nStartTab, nStartCol,nStartRow, nUndoEndCol,nUndoEndRow ); |
| if (!aTester.IsEditable()) |
| { |
| ErrorMessage(aTester.GetMessageId()); |
| return sal_False; |
| } |
| |
| //! Test auf Ueberlappung |
| //! nur wirkliche Schnittmenge testen !!!!!!! |
| |
| // pDoc->HasCommonAttr( StartCol,nStartRow, nUndoEndCol,nUndoEndRow, nStartTab, |
| // pClipDoc, nClipStartX, nClipStartY ); |
| |
| ScDocFunc& rDocFunc = pDocSh->GetDocFunc(); |
| if ( bRecord ) |
| { |
| String aUndo = ScGlobal::GetRscString( pClipDoc->IsCutMode() ? STR_UNDO_MOVE : STR_UNDO_COPY ); |
| pUndoMgr->EnterListAction( aUndo, aUndo ); |
| } |
| |
| if (bClipOver) |
| if (lcl_SelHasAttrib( pDoc, nStartCol,nStartRow, nUndoEndCol,nUndoEndRow, aFilteredMark, HASATTR_OVERLAPPED )) |
| { // "Cell merge not possible if cells already merged" |
| ScDocAttrIterator aIter( pDoc, nStartTab, nStartCol, nStartRow, nUndoEndCol, nUndoEndRow ); |
| const ScPatternAttr* pPattern = NULL; |
| const ScMergeAttr* pMergeFlag = NULL; |
| const ScMergeFlagAttr* pMergeFlagAttr = NULL; |
| SCCOL nCol = -1; |
| SCROW nRow1 = -1; |
| SCROW nRow2 = -1; |
| while ( ( pPattern = aIter.GetNext( nCol, nRow1, nRow2 ) ) != NULL ) |
| { |
| pMergeFlag = (const ScMergeAttr*) &pPattern->GetItem(ATTR_MERGE); |
| pMergeFlagAttr = (const ScMergeFlagAttr*) &pPattern->GetItem(ATTR_MERGE_FLAG); |
| if( ( pMergeFlag && pMergeFlag->IsMerged() ) || ( pMergeFlagAttr && pMergeFlagAttr->IsOverlapped() ) ) |
| { |
| ScRange aRange(nCol, nRow1, nStartTab); |
| pDoc->ExtendOverlapped(aRange); |
| pDoc->ExtendMerge(aRange, sal_True, sal_True); |
| rDocFunc.UnmergeCells(aRange, bRecord, sal_True); |
| } |
| } |
| } |
| |
| if ( !bCutMode ) |
| { |
| ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack(); |
| if ( pChangeTrack ) |
| pChangeTrack->ResetLastCut(); // kein CutMode mehr |
| } |
| |
| sal_Bool bColInfo = ( nStartRow==0 && nEndRow==MAXROW ); |
| sal_Bool bRowInfo = ( nStartCol==0 && nEndCol==MAXCOL ); |
| |
| ScDocument* pUndoDoc = NULL; |
| ScDocument* pRefUndoDoc = NULL; |
| ScDocument* pRedoDoc = NULL; |
| ScRefUndoData* pUndoData = NULL; |
| |
| if ( bRecord ) |
| { |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pUndoDoc->InitUndoSelected( pDoc, aFilteredMark, bColInfo, bRowInfo ); |
| |
| // all sheets - CopyToDocument skips those that don't exist in pUndoDoc |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| pDoc->CopyToDocument( nStartCol, nStartRow, 0, nUndoEndCol, nUndoEndRow, nTabCount-1, |
| nUndoFlags, sal_False, pUndoDoc ); |
| |
| if ( bCutMode ) |
| { |
| pRefUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pRefUndoDoc->InitUndo( pDoc, 0, nTabCount-1, sal_False, sal_False ); |
| |
| pUndoData = new ScRefUndoData( pDoc ); |
| } |
| } |
| |
| sal_uInt16 nExtFlags = 0; |
| pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab, |
| nEndCol, nEndRow, nEndTab ); // content before the change |
| |
| if (GetViewData()->IsActive()) |
| { |
| DoneBlockMode(); |
| InitOwnBlockMode(); |
| } |
| rMark.SetMarkArea( aUserRange ); |
| MarkDataChanged(); |
| |
| HideCursor(); // Cursor aendert sich ! |
| |
| // |
| // Aus Clipboard kopieren, |
| // wenn gerechnet werden soll, Originaldaten merken |
| // |
| |
| ScDocument* pMixDoc = NULL; |
| if ( bSkipEmpty || nFunction ) |
| { |
| if ( nFlags & IDF_CONTENTS ) |
| { |
| pMixDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pMixDoc->InitUndo( pDoc, nStartTab, nEndTab ); |
| pDoc->CopyToDocument( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab, |
| IDF_CONTENTS, sal_False, pMixDoc ); |
| } |
| } |
| |
| /* Make draw layer and start drawing undo. |
| - Needed before AdjustBlockHeight to track moved drawing objects. |
| - Needed before pDoc->CopyFromClip to track inserted note caption objects. |
| */ |
| if ( bPasteDraw ) |
| pDocSh->MakeDrawLayer(); |
| if ( bRecord ) |
| pDoc->BeginDrawUndo(); |
| |
| sal_uInt16 nNoObjFlags = nFlags & ~IDF_OBJECTS; |
| if (!bAsLink) |
| { |
| // copy normally (original range) |
| pDoc->CopyFromClip( aUserRange, aFilteredMark, nNoObjFlags, |
| pRefUndoDoc, pClipDoc, sal_True, sal_False, bIncludeFiltered, |
| bSkipEmpty, (bMarkIsFiltered ? &aRangeList : NULL) ); |
| |
| // bei Transpose Referenzen per Hand anpassen |
| if ( bTranspose && bCutMode && (nFlags & IDF_CONTENTS) ) |
| pDoc->UpdateTranspose( aUserRange.aStart, pOrigClipDoc, aFilteredMark, pRefUndoDoc ); |
| } |
| else if (!bTranspose) |
| { |
| // copy with bAsLink=TRUE |
| pDoc->CopyFromClip( aUserRange, aFilteredMark, nNoObjFlags, pRefUndoDoc, pClipDoc, |
| sal_True, sal_True, bIncludeFiltered, bSkipEmpty ); |
| } |
| else |
| { |
| // alle Inhalte kopieren (im TransClipDoc stehen nur Formeln) |
| pDoc->CopyFromClip( aUserRange, aFilteredMark, nContFlags, pRefUndoDoc, pClipDoc ); |
| } |
| |
| // skipped rows and merged cells don't mix |
| if ( !bIncludeFiltered && pClipDoc->HasClipFilteredRows() ) |
| rDocFunc.UnmergeCells( aUserRange, sal_False, sal_True ); |
| |
| pDoc->ExtendMergeSel( nStartCol, nStartRow, nEndCol, nEndRow, aFilteredMark, sal_True ); // Refresh |
| // und Bereich neu |
| |
| if ( pMixDoc ) // Rechenfunktionen mit Original-Daten auszufuehren ? |
| { |
| pDoc->MixDocument( aUserRange, nFunction, bSkipEmpty, pMixDoc ); |
| } |
| delete pMixDoc; |
| |
| AdjustBlockHeight(); // update row heights before pasting objects |
| |
| ::std::vector< ::rtl::OUString > aExcludedChartNames; |
| SdrPage* pPage = NULL; |
| |
| if ( nFlags & IDF_OBJECTS ) |
| { |
| ScDrawView* pScDrawView = GetScDrawView(); |
| SdrModel* pModel = ( pScDrawView ? pScDrawView->GetModel() : NULL ); |
| pPage = ( pModel ? pModel->GetPage( static_cast< sal_uInt16 >( nStartTab ) ) : NULL ); |
| if ( pPage ) |
| { |
| ScChartHelper::GetChartNames( aExcludedChartNames, pPage ); |
| } |
| |
| // Paste the drawing objects after the row heights have been updated. |
| |
| pDoc->CopyFromClip( aUserRange, aFilteredMark, IDF_OBJECTS, pRefUndoDoc, pClipDoc, |
| sal_True, sal_False, bIncludeFiltered ); |
| } |
| |
| // |
| // |
| // |
| |
| pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab, |
| nEndCol, nEndRow, nEndTab ); // content after the change |
| |
| |
| // ggf. Autofilter-Koepfe loeschen |
| if (bCutMode) |
| if (pDoc->RefreshAutoFilter( nClipStartX,nClipStartY, nClipStartX+nClipSizeX, |
| nClipStartY+nClipSizeY, nStartTab )) |
| pDocSh->PostPaint( nClipStartX,nClipStartY,nStartTab, |
| nClipStartX+nClipSizeX,nClipStartY,nStartTab, |
| PAINT_GRID ); |
| |
| ShowCursor(); // Cursor aendert sich ! |
| |
| //! Block-Bereich bei RefUndoDoc weglassen !!! |
| |
| if ( bRecord ) |
| { |
| // Redo-Daten werden erst beim ersten Undo kopiert |
| // ohne RefUndoDoc muss das Redo-Doc noch nicht angelegt werden |
| |
| if (pRefUndoDoc) |
| { |
| pRedoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pRedoDoc->InitUndo( pDoc, nStartTab, nEndTab, bColInfo, bRowInfo ); |
| |
| // angepasste Referenzen ins Redo-Doc |
| |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| pRedoDoc->AddUndoTab( 0, nTabCount-1 ); |
| pDoc->CopyUpdated( pRefUndoDoc, pRedoDoc ); |
| |
| // alte Referenzen ins Undo-Doc |
| |
| //! Tabellen selektieren ? |
| pUndoDoc->AddUndoTab( 0, nTabCount-1 ); |
| pRefUndoDoc->DeleteArea( nStartCol, nStartRow, nEndCol, nEndRow, aFilteredMark, IDF_ALL ); |
| pRefUndoDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1, |
| IDF_FORMULA, sal_False, pUndoDoc ); |
| delete pRefUndoDoc; |
| } |
| |
| // DeleteUnchanged for pUndoData is in ScUndoPaste ctor, |
| // UndoData for redo is made during first undo |
| |
| ScUndoPasteOptions aOptions; // store options for repeat |
| aOptions.nFunction = nFunction; |
| aOptions.bSkipEmpty = bSkipEmpty; |
| aOptions.bTranspose = bTranspose; |
| aOptions.bAsLink = bAsLink; |
| aOptions.eMoveMode = eMoveMode; |
| |
| SfxUndoAction* pUndo = new ScUndoPaste( pDocSh, |
| nStartCol, nStartRow, nStartTab, |
| nUndoEndCol, nUndoEndRow, nEndTab, aFilteredMark, |
| pUndoDoc, pRedoDoc, nFlags | nUndoFlags, |
| pUndoData, NULL, NULL, NULL, |
| sal_False, &aOptions ); // sal_False = Redo data not yet copied |
| |
| if ( bInsertCells ) |
| { |
| // Merge the paste undo action into the insert action. |
| // Use ScUndoWrapper so the ScUndoPaste pointer can be stored in the insert action. |
| |
| pUndoMgr->AddUndoAction( new ScUndoWrapper( pUndo ), sal_True ); |
| } |
| else |
| pUndoMgr->AddUndoAction( pUndo ); |
| pUndoMgr->LeaveListAction(); |
| } |
| |
| sal_uInt16 nPaint = PAINT_GRID; |
| if (bColInfo) |
| { |
| nPaint |= PAINT_TOP; |
| nUndoEndCol = MAXCOL; // nur zum Zeichnen ! |
| } |
| if (bRowInfo) |
| { |
| nPaint |= PAINT_LEFT; |
| nUndoEndRow = MAXROW; // nur zum Zeichnen ! |
| } |
| pDocSh->PostPaint( nStartCol, nStartRow, nStartTab, |
| nUndoEndCol, nUndoEndRow, nEndTab, nPaint, nExtFlags ); |
| // AdjustBlockHeight has already been called above |
| |
| aModificator.SetDocumentModified(); |
| PostPasteFromClip(aUserRange, rMark); |
| |
| if ( nFlags & IDF_OBJECTS ) |
| { |
| ScModelObj* pModelObj = ( pDocSh ? ScModelObj::getImplementation( pDocSh->GetModel() ) : NULL ); |
| if ( pDoc && pPage && pModelObj ) |
| { |
| bool bSameDoc = ( rClipParam.getSourceDocID() == pDoc->GetDocumentID() ); |
| const ScRangeListVector& rProtectedChartRangesVector( rClipParam.maProtectedChartRangesVector ); |
| ScChartHelper::CreateProtectedChartListenersAndNotify( pDoc, pPage, pModelObj, nStartTab, |
| rProtectedChartRangesVector, aExcludedChartNames, bSameDoc ); |
| } |
| } |
| |
| return sal_True; |
| } |
| |
| bool ScViewFunc::PasteMultiRangesFromClip( |
| sal_uInt16 nFlags, ScDocument* pClipDoc, sal_uInt16 nFunction, |
| bool bSkipEmpty, bool bTranspose, bool bAsLink, bool bAllowDialogs, |
| InsCellCmd eMoveMode, sal_uInt16 /*nContFlags*/, sal_uInt16 nUndoFlags) |
| { |
| ScViewData& rViewData = *GetViewData(); |
| ScDocument* pDoc = rViewData.GetDocument(); |
| ScDocShell* pDocSh = rViewData.GetDocShell(); |
| ScMarkData aMark(rViewData.GetMarkData()); |
| const ScAddress& rCurPos = rViewData.GetCurPos(); |
| ScClipParam& rClipParam = pClipDoc->GetClipParam(); |
| SCCOL nColSize = rClipParam.getPasteColSize(); |
| SCROW nRowSize = rClipParam.getPasteRowSize(); |
| |
| if (bTranspose) |
| { |
| if (static_cast<SCROW>(rCurPos.Col()) + nRowSize-1 > static_cast<SCROW>(MAXCOL)) |
| { |
| ErrorMessage(STR_PASTE_FULL); |
| return false; |
| } |
| |
| ::std::auto_ptr<ScDocument> pTransClip(new ScDocument(SCDOCMODE_CLIP)); |
| pClipDoc->TransposeClip(pTransClip.get(), nFlags, bAsLink); |
| pClipDoc = pTransClip.release(); |
| SCCOL nTempColSize = nColSize; |
| nColSize = static_cast<SCCOL>(nRowSize); |
| nRowSize = static_cast<SCROW>(nTempColSize); |
| } |
| |
| if (!ValidCol(rCurPos.Col()+nColSize-1) || !ValidRow(rCurPos.Row()+nRowSize-1)) |
| { |
| ErrorMessage(STR_PASTE_FULL); |
| return false; |
| } |
| |
| // Determine the first and last selected sheet numbers. |
| SCTAB nTab1 = aMark.GetFirstSelected(); |
| SCTAB nTab2 = nTab1; |
| for (SCTAB i = nTab1+1; i <= MAXTAB; ++i) |
| if (aMark.GetTableSelect(i)) |
| nTab2 = i; |
| |
| ScDocShellModificator aModificator(*pDocSh); |
| |
| // For multi-selection paste, we don't support cell duplication for larger |
| // destination range. In case the destination is marked, we reset it to |
| // the clip size. |
| ScRange aMarkedRange(rCurPos.Col(), rCurPos.Row(), nTab1, |
| rCurPos.Col()+nColSize-1, rCurPos.Row()+nRowSize-1, nTab2); |
| |
| // Extend the marked range to account for filtered rows in the destination |
| // area. |
| if (ScViewUtil::HasFiltered(aMarkedRange, pDoc)) |
| { |
| if (!ScViewUtil::FitToUnfilteredRows(aMarkedRange, pDoc, nRowSize)) |
| return false; |
| } |
| |
| bool bAskIfNotEmpty = |
| bAllowDialogs && (nFlags & IDF_CONTENTS) && |
| nFunction == PASTE_NOFUNC && SC_MOD()->GetInputOptions().GetReplaceCellsWarn(); |
| |
| if (bAskIfNotEmpty) |
| { |
| if (!lcl_checkDestRangeForOverwrite(aMarkedRange, pDoc, aMark, rViewData.GetDialogParent())) |
| return false; |
| } |
| |
| aMark.SetMarkArea(aMarkedRange); |
| MarkRange(aMarkedRange); |
| |
| bool bInsertCells = (eMoveMode != INS_NONE); |
| if (bInsertCells) |
| { |
| if (!InsertCells(eMoveMode, pDoc->IsUndoEnabled(), true)) |
| return false; |
| } |
| |
| ::std::auto_ptr<ScDocument> pUndoDoc; |
| if (pDoc->IsUndoEnabled()) |
| { |
| pUndoDoc.reset(new ScDocument(SCDOCMODE_UNDO)); |
| pUndoDoc->InitUndoSelected(pDoc, aMark, false, false); |
| pDoc->CopyToDocument(aMarkedRange, nUndoFlags, false, pUndoDoc.get(), &aMark, true); |
| } |
| |
| ::std::auto_ptr<ScDocument> pMixDoc; |
| if ( bSkipEmpty || nFunction ) |
| { |
| if ( nFlags & IDF_CONTENTS ) |
| { |
| pMixDoc.reset(new ScDocument(SCDOCMODE_UNDO)); |
| pMixDoc->InitUndoSelected(pDoc, aMark, false, false); |
| pDoc->CopyToDocument(aMarkedRange, IDF_CONTENTS, false, pMixDoc.get(), &aMark, true); |
| } |
| } |
| |
| /* Make draw layer and start drawing undo. |
| - Needed before AdjustBlockHeight to track moved drawing objects. |
| - Needed before pDoc->CopyFromClip to track inserted note caption objects. |
| */ |
| if (nFlags & IDF_OBJECTS) |
| pDocSh->MakeDrawLayer(); |
| if (pDoc->IsUndoEnabled()) |
| pDoc->BeginDrawUndo(); |
| |
| CursorSwitcher aCursorSwitch(this); |
| sal_uInt16 nNoObjFlags = nFlags & ~IDF_OBJECTS; |
| pDoc->CopyMultiRangeFromClip(rCurPos, aMark, nNoObjFlags, pClipDoc, |
| true, bAsLink, false, bSkipEmpty); |
| |
| if (pMixDoc.get()) |
| pDoc->MixDocument(aMarkedRange, nFunction, bSkipEmpty, pMixDoc.get()); |
| |
| AdjustBlockHeight(); // update row heights before pasting objects |
| |
| if (nFlags & IDF_OBJECTS) |
| { |
| // Paste the drawing objects after the row heights have been updated. |
| pDoc->CopyMultiRangeFromClip(rCurPos, aMark, IDF_OBJECTS, pClipDoc, |
| true, false, false, true); |
| } |
| |
| pDocSh->PostPaint( |
| aMarkedRange.aStart.Col(), aMarkedRange.aStart.Row(), nTab1, |
| aMarkedRange.aEnd.Col(), aMarkedRange.aEnd.Row(), nTab1, PAINT_GRID); |
| |
| if (pDoc->IsUndoEnabled()) |
| { |
| ::svl::IUndoManager* pUndoMgr = pDocSh->GetUndoManager(); |
| String aUndo = ScGlobal::GetRscString( |
| pClipDoc->IsCutMode() ? STR_UNDO_CUT : STR_UNDO_COPY); |
| pUndoMgr->EnterListAction(aUndo, aUndo); |
| |
| ScUndoPasteOptions aOptions; // store options for repeat |
| aOptions.nFunction = nFunction; |
| aOptions.bSkipEmpty = bSkipEmpty; |
| aOptions.bTranspose = bTranspose; |
| aOptions.bAsLink = bAsLink; |
| aOptions.eMoveMode = eMoveMode; |
| |
| ScUndoPaste* pUndo = new ScUndoPaste(pDocSh, |
| aMarkedRange.aStart.Col(), |
| aMarkedRange.aStart.Row(), |
| aMarkedRange.aStart.Tab(), |
| aMarkedRange.aEnd.Col(), |
| aMarkedRange.aEnd.Row(), |
| aMarkedRange.aEnd.Tab(), |
| aMark, pUndoDoc.release(), NULL, nFlags|nUndoFlags, NULL, NULL, NULL, NULL, false, &aOptions); |
| |
| if (bInsertCells) |
| pUndoMgr->AddUndoAction(new ScUndoWrapper(pUndo), true); |
| else |
| pUndoMgr->AddUndoAction(pUndo, false); |
| |
| pUndoMgr->LeaveListAction(); |
| } |
| aModificator.SetDocumentModified(); |
| PostPasteFromClip(aMarkedRange, aMark); |
| return true; |
| } |
| |
| void ScViewFunc::PostPasteFromClip(const ScRange& rPasteRange, const ScMarkData& rMark) |
| { |
| ScViewData* pViewData = GetViewData(); |
| ScDocShell* pDocSh = pViewData->GetDocShell(); |
| ScDocument* pDoc = pViewData->GetDocument(); |
| pDocSh->UpdateOle(pViewData); |
| |
| SelectionChanged(); |
| |
| // #i97876# Spreadsheet data changes are not notified |
| ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() ); |
| if ( pModelObj && pModelObj->HasChangesListeners() ) |
| { |
| ScRangeList aChangeRanges; |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| for ( SCTAB i = 0; i < nTabCount; ++i ) |
| { |
| if ( rMark.GetTableSelect( i ) ) |
| { |
| ScRange aChangeRange(rPasteRange); |
| aChangeRange.aStart.SetTab( i ); |
| aChangeRange.aEnd.SetTab( i ); |
| aChangeRanges.Append( aChangeRange ); |
| } |
| } |
| pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges ); |
| } |
| } |
| |
| |
| //---------------------------------------------------------------------------- |
| // D R A G A N D D R O P |
| // |
| // innerhalb des Dokuments |
| |
| sal_Bool ScViewFunc::MoveBlockTo( const ScRange& rSource, const ScAddress& rDestPos, |
| sal_Bool bCut, sal_Bool bRecord, sal_Bool bPaint, sal_Bool bApi ) |
| { |
| ScDocShell* pDocSh = GetViewData()->GetDocShell(); |
| HideAllCursors(); // wegen zusammengefassten |
| |
| sal_Bool bSuccess = sal_True; |
| SCTAB nDestTab = rDestPos.Tab(); |
| const ScMarkData& rMark = GetViewData()->GetMarkData(); |
| if ( rSource.aStart.Tab() == nDestTab && rSource.aEnd.Tab() == nDestTab && rMark.GetSelectCount() > 1 ) |
| { |
| // moving within one table and several tables selected -> apply to all selected tables |
| |
| if ( bRecord ) |
| { |
| String aUndo = ScGlobal::GetRscString( bCut ? STR_UNDO_MOVE : STR_UNDO_COPY ); |
| pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo ); |
| } |
| |
| // collect ranges of consecutive selected tables |
| |
| ScRange aLocalSource = rSource; |
| ScAddress aLocalDest = rDestPos; |
| SCTAB nTabCount = pDocSh->GetDocument()->GetTableCount(); |
| SCTAB nStartTab = 0; |
| while ( nStartTab < nTabCount && bSuccess ) |
| { |
| while ( nStartTab < nTabCount && !rMark.GetTableSelect(nStartTab) ) |
| ++nStartTab; |
| if ( nStartTab < nTabCount ) |
| { |
| SCTAB nEndTab = nStartTab; |
| while ( nEndTab+1 < nTabCount && rMark.GetTableSelect(nEndTab+1) ) |
| ++nEndTab; |
| |
| aLocalSource.aStart.SetTab( nStartTab ); |
| aLocalSource.aEnd.SetTab( nEndTab ); |
| aLocalDest.SetTab( nStartTab ); |
| |
| bSuccess = pDocSh->GetDocFunc().MoveBlock( |
| aLocalSource, aLocalDest, bCut, bRecord, bPaint, bApi ); |
| |
| nStartTab = nEndTab + 1; |
| } |
| } |
| |
| if ( bRecord ) |
| pDocSh->GetUndoManager()->LeaveListAction(); |
| } |
| else |
| { |
| // move the block as specified |
| bSuccess = pDocSh->GetDocFunc().MoveBlock( |
| rSource, rDestPos, bCut, bRecord, bPaint, bApi ); |
| } |
| |
| ShowAllCursors(); |
| if (bSuccess) |
| { |
| // Zielbereich markieren |
| ScAddress aDestEnd( |
| rDestPos.Col() + rSource.aEnd.Col() - rSource.aStart.Col(), |
| rDestPos.Row() + rSource.aEnd.Row() - rSource.aStart.Row(), |
| nDestTab ); |
| |
| sal_Bool bIncludeFiltered = bCut; |
| if ( !bIncludeFiltered ) |
| { |
| // find number of non-filtered rows |
| SCROW nPastedCount = pDocSh->GetDocument()->CountNonFilteredRows( |
| rSource.aStart.Row(), rSource.aEnd.Row(), rSource.aStart.Tab()); |
| |
| if ( nPastedCount == 0 ) |
| nPastedCount = 1; |
| aDestEnd.SetRow( rDestPos.Row() + nPastedCount - 1 ); |
| } |
| |
| MarkRange( ScRange( rDestPos, aDestEnd ), sal_False ); //! sal_False ??? |
| |
| pDocSh->UpdateOle(GetViewData()); |
| SelectionChanged(); |
| } |
| return bSuccess; |
| } |
| |
| // Link innerhalb des Dokuments |
| |
| sal_Bool ScViewFunc::LinkBlock( const ScRange& rSource, const ScAddress& rDestPos, sal_Bool bApi ) |
| { |
| // Test auf Ueberlappung |
| |
| if ( rSource.aStart.Tab() == rDestPos.Tab() ) |
| { |
| SCCOL nDestEndCol = rDestPos.Col() + ( rSource.aEnd.Col() - rSource.aStart.Col() ); |
| SCROW nDestEndRow = rDestPos.Row() + ( rSource.aEnd.Row() - rSource.aStart.Row() ); |
| |
| if ( rSource.aStart.Col() <= nDestEndCol && rDestPos.Col() <= rSource.aEnd.Col() && |
| rSource.aStart.Row() <= nDestEndRow && rDestPos.Row() <= rSource.aEnd.Row() ) |
| { |
| if (!bApi) |
| ErrorMessage( STR_ERR_LINKOVERLAP ); |
| return sal_False; |
| } |
| } |
| |
| // Ausfuehren per Paste |
| |
| ScDocument* pDoc = GetViewData()->GetDocument(); |
| ScDocument* pClipDoc = new ScDocument( SCDOCMODE_CLIP ); |
| pDoc->CopyTabToClip( rSource.aStart.Col(), rSource.aStart.Row(), |
| rSource.aEnd.Col(), rSource.aEnd.Row(), |
| rSource.aStart.Tab(), pClipDoc ); |
| |
| // Zielbereich markieren (Cursor setzen, keine Markierung) |
| |
| if ( GetViewData()->GetTabNo() != rDestPos.Tab() ) |
| SetTabNo( rDestPos.Tab() ); |
| |
| MoveCursorAbs( rDestPos.Col(), rDestPos.Row(), SC_FOLLOW_NONE, sal_False, sal_False ); |
| |
| // Paste |
| |
| PasteFromClip( IDF_ALL, pClipDoc, PASTE_NOFUNC, sal_False, sal_False, sal_True ); // als Link |
| |
| delete pClipDoc; |
| |
| return sal_True; |
| } |
| |
| |
| |
| |
