sc/source/ui/view/viewfun3.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: viewfun3.cxx,v $
  10  * $Revision: 1.41.126.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35
  36 //----------------------------------------------------------------------------
  37
  38 #define _SV_NOXSOUND
  39
  40 #ifdef WIN
  41         #define _MENUBTN_HXX
  42 #endif
  43
  44 #define _BASE_DLGS_HXX
  45 #define _BIGINT_HXX
  46 #define _CACHESTR_HXX
  47 #define _CONFIG_HXX
  48 #define _CURSOR_HXX
  49 #define _CTRLTOOL_HXX
  50 #define _DLGCFG_HXX
  51 #define _DYNARR_HXX
  52 #define _EXTATTR_HXX
  53 #define _FILDLG_HXX
  54 #define _FONTDLG_HXX
  55 #define _FRM3D_HXX
  56 #define _INTRO_HXX
  57 #define _ISETBWR_HXX
  58 #define _NO_SVRTF_PARSER_HXX
  59 #define _MACRODLG_HXX
  60 #define _MODALDLG_HXX
  61 #define _MOREBUTTON_HXX
  62 #define _OUTLINER_HXX
  63 //#define _PRNDLG_HXX
  64 //#define _POLY_HXX
  65 #define _PVRWIN_HXX
  66 //#define _QUEUE_HXX
  67 #define _RULER_HXX
  68 #define _SCRWIN_HXX
  69 #define _SETBRW_HXX
  70 //#define _STACK_HXX
  71 //#define _STATUS_HXX ***
  72 #define _STDCTRL_HXX
  73 #define _STDMENU_HXX
  74 //#define _TAB_HXX
  75 #define _TABBAR_HXX
  76 #define _TREELIST_HXX
  77 #define _VALUESET_HXX
  78 #define _VCATTR_HXX
  79 #define _VCBRW_HXX
  80 #define _VCTRLS_HXX
  81 #define _VCSBX_HXX
  82 #define _VCONT_HXX
  83 #define _VDRWOBJ_HXX
  84
  85 //#define _SELENG_HXX
  86 //#define _SOUND_HXX
  87 //#define _SYSDLG_HXX
  88
  89
  90
  91
  92 #define _PASSWD_HXX
  93
  94 #define _SFX_DOCFILE_HXX
  95 //#define _SFX_DOCFILT_HXX
  96 #define _SFX_DOCINF_HXX
  97 #define _SFX_DOCSH_HXX
  98 //#define _SFXDOCFILT_HXX
  99 //#define _SFXDOCINF_HXX
 100 //#define _SFXDOCSH_HXX
 101 #define _SFX_PRNMON_HXX
 102 #define _SFX_RESMGR_HXX
 103 #define _SFX_TEMPLDLG_HXX
 104 //#define _SFXAPPWIN_HXX
 105 #define _SFXBASIC_HXX
 106 #define _SFXCTRLITEM
 107 #define _SFXDLGCFG_HXX
 108 //#define _SFXDISPATCH_HXX
 109 #define _SFXFILEDLG_HXX
 110 //#define _SFXIMGMGR_HXX
 111 #define _SFXIPFRM_HXX
 112 #define _SFX_MACRO_HXX
 113 #define _SFXMNUITEM_HXX
 114 #define _SFXMNUMGR_HXX
 115 #define _SFXMULTISEL_HXX
 116 //#define _SFXMSG_HXX
 117 #define _SFXMSGDESCR_HXX
 118 #define _SFXMSGPOOL_HXX
 119 #define _SFX_MINFITEM_HXX
 120 #define _SFXOBJFACE_HXX
 121 #define _SFXOBJFAC_HXX
 122 #define _SFX_SAVEOPT_HXX
 123 #define _SFXSTBITEM_HXX
 124 #define _SFXSTBMGR_HXX
 125 #define _SFXTBXCTRL_HXX
 126 #define _SFXTBXMGR_HXX
 127
 128 #define _SI_HXX
 129 //#define _SI_DLL_HXX
 130 //#define _SIDLL_HXX
 131 //#define _SI_NOITEMS
 132 //#define _SI_NOOTHERFORMS
 133 //#define _SI_NOSBXCONTROLS
 134 //#define _SINOSBXCONTROLS
 135 //#define _SI_NODRW
 136 //#define _SI_NOCONTROL
 137
 138 #define _SVBOXITM_HXX
 139 #define _SVCONTNR_HXX     //
 140
 141 #define _SDR_NOTRANSFORM
 142
 143 #define _SVDRAG_HXX
 144 #define _SVINCVW_HXX
 145 #define _SV_MULTISEL_HXX
 146 #define _SVRTV_HXX
 147 #define _SVTABBX_HXX
 148 #define _SVTREEBOX_HXX
 149 #define _SVTREELIST_HXX
 150
 151 #define _SVX_DAILDLL_HXX
 152 #define _SVX_HYPHEN_HXX
 153 #define _SVX_IMPGRF_HXX
 154 #define _SVX_LAYCTRL_HXX
 155 #define _SVX_OPTITEMS_HXX
 156 #define _SVX_OPTGERL_HXX
 157 #define _SVX_OPTSAVE_HXX
 158 #define _SVX_OPTSPELL_HXX
 159 #define _SVX_OPTPATH_HXX
 160 #define _SVX_OPTLINGU_HXX
 161 #define _SVX_RULER_HXX
 162 #define _SVX_RULRITEM_HXX
 163 #define _SVX_SELCTRL_HXX
 164 #define _SVX_SPLWRAP_HXX
 165 #define _SVX_SPLDLG_HXX
 166 #define _SVX_STDDLG_HXX
 167 #define _SVX_THESDLG_HXX
 168
 169 // INCLUDE -------------------------------------------------------------------
 170
 171 #include "scitems.hxx"
 172 #include <svx/dbexch.hrc>
 173 #include <svx/svdetc.hxx>
 174 #include <sfx2/dispatch.hxx>
 175 #include <sfx2/docfile.hxx>
 176 #include <svtools/stritem.hxx>
 177 #include <svtools/ptitem.hxx>
 178 #include <svtools/urlbmk.hxx>
 179 #include <sot/clsids.hxx>
 180 #include <sot/formats.hxx>
 181 #include <vcl/graph.hxx>
 182 #include <vcl/virdev.hxx>
 183 #include <vcl/msgbox.hxx>
 184 #include <tools/urlobj.hxx>
 185 #include <sot/exchange.hxx>
 186 #include <memory>
 187
 188 #include "viewfunc.hxx"
 189 #include "tabvwsh.hxx"
 190 #include "docsh.hxx"
 191 #include "docfunc.hxx"
 192 #include "undoblk.hxx"
 193 #include "refundo.hxx"
 194 #include "globstr.hrc"
 195 #include "global.hxx"
 196 #include "transobj.hxx"
 197 #include "drwtrans.hxx"
 198 #include "rangenam.hxx"
 199 #include "dbcolect.hxx"
 200 #include "impex.hxx"                    // Sylk-ID fuer CB
 201 #include "chgtrack.hxx"
 202 #include "waitoff.hxx"
 203 #include "scmod.hxx"
 204 #include "sc.hrc"
 205 #include "inputopt.hxx"
 206 #include "warnbox.hxx"
 207 #include "drwlayer.hxx"
 208 #include "editable.hxx"
 209 #include "transobj.hxx"
 210 #include "drwtrans.hxx"
 211 #include "docuno.hxx"
 212 #include "undodat.hxx"   // Amelia Wang
 213 #include "clipparam.hxx"
 214
 215 using namespace com::sun::star;
 216
 217 // STATIC DATA ---------------------------------------------------------------
 218
 219
 220 //============================================================================
 221
 222 //      GlobalName der Writer-DocShell kommt jetzt aus comphelper/classids.hxx
 223
 224 //----------------------------------------------------------------------------
 225 //              C U T
 226
 227 void ScViewFunc::CutToClip( ScDocument* pClipDoc, BOOL bIncludeObjects )
 228 {
 229         UpdateInputLine();
 230
 231         ScEditableTester aTester( this );
 232         if (!aTester.IsEditable())                                      // selection editable?
 233         {
 234                 ErrorMessage( aTester.GetMessageId() );
 235                 return;
 236         }
 237
 238         ScRange aRange;                                                         // zu loeschender Bereich
 239         if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
 240         {
 241                 ScDocument* pDoc = GetViewData()->GetDocument();
 242                 ScDocShell* pDocSh = GetViewData()->GetDocShell();
 243                 ScMarkData& rMark = GetViewData()->GetMarkData();
 244                 const BOOL bRecord(pDoc->IsUndoEnabled());                                      // Undo/Redo
 245
 246                 ScDocShellModificator aModificator( *pDocSh );
 247
 248                 if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )                      // mark the range if not marked yet
 249                 {
 250                         DoneBlockMode();
 251                         InitOwnBlockMode();
 252                         rMark.SetMarkArea( aRange );
 253             MarkDataChanged();
 254                 }
 255
 256                 CopyToClip( pClipDoc, TRUE, FALSE, bIncludeObjects );                   // Ab ins Clipboard
 257
 258                 ScAddress aOldEnd( aRange.aEnd );               // Zusammengefasste Zellen im Bereich?
 259                 pDoc->ExtendMerge( aRange, TRUE );
 260
 261                 ScDocument* pUndoDoc = NULL;
 262                 if ( bRecord )
 263                 {
 264                         pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
 265             pUndoDoc->InitUndoSelected( pDoc, rMark );
 266             // all sheets - CopyToDocument skips those that don't exist in pUndoDoc
 267             ScRange aCopyRange = aRange;
 268             aCopyRange.aStart.SetTab(0);
 269             aCopyRange.aEnd.SetTab(pDoc->GetTableCount()-1);
 270             pDoc->CopyToDocument( aCopyRange, (IDF_ALL & ~IDF_OBJECTS) | IDF_NOCAPTIONS, FALSE, pUndoDoc );
 271                         pDoc->BeginDrawUndo();
 272                 }
 273
 274                 USHORT nExtFlags = 0;
 275                 pDocSh->UpdatePaintExt( nExtFlags, aRange );
 276
 277                 HideCursor();                                                   // Cursor aendert sich !
 278
 279                 rMark.MarkToMulti();
 280                 pDoc->DeleteSelection( IDF_ALL, rMark );
 281                 if ( bIncludeObjects )
 282                         pDoc->DeleteObjectsInSelection( rMark );
 283                 rMark.MarkToSimple();
 284
 285                 if ( !AdjustRowHeight( aRange.aStart.Row(), aRange.aEnd.Row() ) )
 286                         pDocSh->PostPaint( aRange, PAINT_GRID, nExtFlags );
 287
 288                 if ( bRecord )                                                  // erst jetzt ist Draw-Undo verfuegbar
 289                         pDocSh->GetUndoManager()->AddUndoAction(
 290                                 new ScUndoCut( pDocSh, aRange, aOldEnd, rMark, pUndoDoc ) );
 291
 292                 aModificator.SetDocumentModified();
 293                 ShowCursor();                                                   // Cursor aendert sich !
 294                 pDocSh->UpdateOle(GetViewData());
 295
 296                 CellContentChanged();
 297         }
 298         else
 299                 ErrorMessage( STR_NOMULTISELECT );
 300 }
 301
 302
 303 //----------------------------------------------------------------------------
 304 //              C O P Y
 305
 306 BOOL ScViewFunc::CopyToClip( ScDocument* pClipDoc, BOOL bCut, BOOL bApi, BOOL bIncludeObjects, BOOL bStopEdit )
 307 {
 308         BOOL bDone = FALSE;
 309         if ( bStopEdit )
 310                 UpdateInputLine();
 311
 312         ScRange aRange;
 313         ScMarkType eMarkType = GetViewData()->GetSimpleArea( aRange );
 314     ScDocument* pDoc = GetViewData()->GetDocument();
 315     ScMarkData& rMark = GetViewData()->GetMarkData();
 316         if ( eMarkType == SC_MARK_SIMPLE || eMarkType == SC_MARK_SIMPLE_FILTERED )
 317         {
 318                 if ( !pDoc->HasSelectedBlockMatrixFragment(
 319                                                 aRange.aStart.Col(), aRange.aStart.Row(),
 320                                                 aRange.aEnd.Col(),   aRange.aEnd.Row(),
 321                                                 rMark ) )
 322                 {
 323                         BOOL bSysClip = FALSE;
 324                         if ( !pClipDoc )                                                                        // no clip doc specified
 325                         {
 326                                 pClipDoc = new ScDocument( SCDOCMODE_CLIP );    // create one (deleted by ScTransferObj)
 327                                 bSysClip = TRUE;                                                                // and copy into system
 328                         }
 329
 330                         if ( !bCut )
 331                         {
 332                                 ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 333                                 if ( pChangeTrack )
 334                                         pChangeTrack->ResetLastCut();   // kein CutMode mehr
 335                         }
 336
 337                         if ( bSysClip && bIncludeObjects )
 338                         {
 339                                 BOOL bAnyOle = pDoc->HasOLEObjectsInArea( aRange, &rMark );
 340                                 // update ScGlobal::pDrawClipDocShellRef
 341                                 ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle ) );
 342                         }
 343
 344                         pDoc->CopyToClip( aRange.aStart.Col(), aRange.aStart.Row(),
 345                                                           aRange.aEnd.Col(),   aRange.aEnd.Row(),
 346                                                           bCut, pClipDoc, FALSE, &rMark, FALSE, bIncludeObjects );
 347                         if (bSysClip)
 348                         {
 349                                 ScDrawLayer::SetGlobalDrawPersist(NULL);
 350
 351                                 ScGlobal::SetClipDocName( pDoc->GetDocumentShell()->GetTitle( SFX_TITLE_FULLNAME ) );
 352                         }
 353                         pClipDoc->ExtendMerge( aRange, TRUE );
 354
 355                         if (bSysClip)
 356                         {
 357                                 ScDocShell* pDocSh = GetViewData()->GetDocShell();
 358                                 TransferableObjectDescriptor aObjDesc;
 359                                 pDocSh->FillTransferableObjectDescriptor( aObjDesc );
 360                                 aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 361                                 // maSize is set in ScTransferObj ctor
 362
 363                                 ScTransferObj* pTransferObj = new ScTransferObj( pClipDoc, aObjDesc );
 364                                 uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
 365
 366                                 if ( ScGlobal::pDrawClipDocShellRef )
 367                                 {
 368                     SfxObjectShellRef aPersistRef( &(*ScGlobal::pDrawClipDocShellRef) );
 369                                         pTransferObj->SetDrawPersist( aPersistRef );    // keep persist for ole objects alive
 370                                 }
 371
 372                                 pTransferObj->CopyToClipboard( GetActiveWin() );        // system clipboard
 373                                 SC_MOD()->SetClipObject( pTransferObj, NULL );          // internal clipboard
 374                         }
 375
 376                         bDone = TRUE;
 377                 }
 378                 else
 379                 {
 380                         if (!bApi)
 381                                 ErrorMessage(STR_MATRIXFRAGMENTERR);
 382                 }
 383         }
 384     else if (eMarkType == SC_MARK_MULTI)
 385     {
 386         bool bSuccess = false;
 387         ScClipParam aClipParam;
 388         aClipParam.mbCutMode = false;
 389         rMark.FillRangeListWithMarks(&aClipParam.maRanges, false);
 390
 391         do
 392         {
 393             if (bCut)
 394                 // We con't support cutting of multi-selections.
 395                 break;
 396
 397             if (pClipDoc)
 398                 // TODO: What's this for?
 399                 break;
 400
 401             ::std::auto_ptr<ScDocument> pDocClip(new ScDocument(SCDOCMODE_CLIP));
 402
 403             // Check for geometrical feasibility of the ranges.
 404             bool bValidRanges = true;
 405             ScRangePtr p = aClipParam.maRanges.First();
 406             SCCOL nPrevColDelta = 0;
 407             SCROW nPrevRowDelta = 0;
 408             SCCOL nPrevCol = p->aStart.Col();
 409             SCROW nPrevRow = p->aStart.Row();
 410             SCCOL nPrevColSize = p->aEnd.Col() - p->aStart.Col() + 1;
 411             SCROW nPrevRowSize = p->aEnd.Row() - p->aStart.Row() + 1;
 412             for (p = aClipParam.maRanges.Next(); p; p = aClipParam.maRanges.Next())
 413             {
 414                 if (pDoc->HasSelectedBlockMatrixFragment(
 415                     p->aStart.Col(), p->aStart.Row(), p->aEnd.Col(), p->aEnd.Row(), rMark))
 416                 {
 417                     bValidRanges = false;
 418                     break;
 419                 }
 420
 421                 SCCOL nColDelta = p->aStart.Col() - nPrevCol;
 422                 SCROW nRowDelta = p->aStart.Row() - nPrevRow;
 423
 424                 if ((nColDelta && nRowDelta) || (nPrevColDelta && nRowDelta) || (nPrevRowDelta && nColDelta))
 425                 {
 426                     bValidRanges = false;
 427                     break;
 428                 }
 429
 430                 if (aClipParam.meDirection == ScClipParam::Unspecified)
 431                 {
 432                     if (nColDelta)
 433                         aClipParam.meDirection = ScClipParam::Column;
 434                     if (nRowDelta)
 435                         aClipParam.meDirection = ScClipParam::Row;
 436                 }
 437
 438                 SCCOL nColSize = p->aEnd.Col() - p->aStart.Col() + 1;
 439                 SCROW nRowSize = p->aEnd.Row() - p->aStart.Row() + 1;
 440
 441                 if (aClipParam.meDirection == ScClipParam::Column && nRowSize != nPrevRowSize)
 442                 {
 443                     // column-oriented ranges must have identical row size.
 444                     bValidRanges = false;
 445                     break;
 446                 }
 447                 if (aClipParam.meDirection == ScClipParam::Row && nColSize != nPrevColSize)
 448                 {
 449                     // likewise, row-oriented ranges must have identical
 450                     // column size.
 451                     bValidRanges = false;
 452                     break;
 453                 }
 454
 455                 nPrevCol = p->aStart.Col();
 456                 nPrevRow = p->aStart.Row();
 457                 nPrevColDelta = nColDelta;
 458                 nPrevRowDelta = nRowDelta;
 459                 nPrevColSize  = nColSize;
 460                 nPrevRowSize  = nRowSize;
 461             }
 462             if (!bValidRanges)
 463                 break;
 464
 465             pDoc->CopyToClip(aClipParam, pDocClip.get(), &rMark, false, bIncludeObjects);
 466
 467             ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
 468             if ( pChangeTrack )
 469                 pChangeTrack->ResetLastCut();   // kein CutMode mehr
 470
 471                         {
 472                                 ScDocShell* pDocSh = GetViewData()->GetDocShell();
 473                                 TransferableObjectDescriptor aObjDesc;
 474                                 pDocSh->FillTransferableObjectDescriptor( aObjDesc );
 475                                 aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 476                                 // maSize is set in ScTransferObj ctor
 477
 478                                 ScTransferObj* pTransferObj = new ScTransferObj( pDocClip.release(), aObjDesc );
 479                                 uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
 480
 481                                 if ( ScGlobal::pDrawClipDocShellRef )
 482                                 {
 483                     SfxObjectShellRef aPersistRef( &(*ScGlobal::pDrawClipDocShellRef) );
 484                                         pTransferObj->SetDrawPersist( aPersistRef );    // keep persist for ole objects alive
 485                                 }
 486
 487                                 pTransferObj->CopyToClipboard( GetActiveWin() );        // system clipboard
 488                                 SC_MOD()->SetClipObject( pTransferObj, NULL );          // internal clipboard
 489                         }
 490
 491             bSuccess = true;
 492         }
 493         while (false);
 494
 495         if (!bSuccess && !bApi)
 496             ErrorMessage(STR_NOMULTISELECT);
 497
 498         bDone = bSuccess;
 499     }
 500         else
 501         {
 502                 if (!bApi)
 503                         ErrorMessage(STR_NOMULTISELECT);
 504         }
 505
 506         return bDone;
 507 }
 508
 509 ScTransferObj* ScViewFunc::CopyToTransferable()
 510 {
 511         ScRange aRange;
 512         if ( GetViewData()->GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
 513         {
 514                 ScDocument* pDoc = GetViewData()->GetDocument();
 515                 ScMarkData& rMark = GetViewData()->GetMarkData();
 516                 if ( !pDoc->HasSelectedBlockMatrixFragment(
 517                                                 aRange.aStart.Col(), aRange.aStart.Row(),
 518                                                 aRange.aEnd.Col(),   aRange.aEnd.Row(),
 519                                                 rMark ) )
 520                 {
 521             ScDocument *pClipDoc = new ScDocument( SCDOCMODE_CLIP );    // create one (deleted by ScTransferObj)
 522
 523             BOOL bAnyOle = pDoc->HasOLEObjectsInArea( aRange, &rMark );
 524             ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle ) );
 525
 526                         pDoc->CopyToClip( aRange.aStart.Col(), aRange.aStart.Row(),
 527                                                           aRange.aEnd.Col(),   aRange.aEnd.Row(),
 528                               FALSE, pClipDoc, FALSE, &rMark, FALSE, TRUE );
 529
 530             ScDrawLayer::SetGlobalDrawPersist(NULL);
 531                         pClipDoc->ExtendMerge( aRange, TRUE );
 532
 533             ScDocShell* pDocSh = GetViewData()->GetDocShell();
 534             TransferableObjectDescriptor aObjDesc;
 535             pDocSh->FillTransferableObjectDescriptor( aObjDesc );
 536             aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 537             ScTransferObj* pTransferObj = new ScTransferObj( pClipDoc, aObjDesc );
 538             return pTransferObj;
 539         }
 540     }
 541
 542     return NULL;
 543 }
 544
 545 //----------------------------------------------------------------------------
 546 //              P A S T E
 547
 548 void ScViewFunc::PasteDraw()
 549 {
 550         ScViewData* pViewData = GetViewData();
 551         SCCOL nPosX = pViewData->GetCurX();
 552         SCROW nPosY = pViewData->GetCurY();
 553         Window* pWin = GetActiveWin();
 554         Point aPos = pWin->PixelToLogic( pViewData->GetScrPos( nPosX, nPosY,
 555                                                                          pViewData->GetActivePart() ) );
 556         ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard( pWin );
 557         if (pDrawClip)
 558         PasteDraw( aPos, pDrawClip->GetModel(), FALSE,
 559             pDrawClip->GetSourceDocID() == pViewData->GetDocument()->GetDocumentID() );
 560 }
 561
 562 void ScViewFunc::PasteFromSystem()
 563 {
 564         UpdateInputLine();
 565
 566         Window* pWin = GetActiveWin();
 567         ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( pWin );
 568         ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard( pWin );
 569
 570         if (pOwnClip)
 571     {
 572         // #129384# keep a reference in case the clipboard is changed during PasteFromClip
 573         uno::Reference<datatransfer::XTransferable> aOwnClipRef( pOwnClip );
 574                 PasteFromClip( IDF_ALL, pOwnClip->GetDocument(),
 575                                                 PASTE_NOFUNC, FALSE, FALSE, FALSE, INS_NONE, IDF_NONE,
 576                                                 TRUE );         // allow warning dialog
 577     }
 578         else if (pDrawClip)
 579                 PasteDraw();
 580         else
 581         {
 582                 TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pWin ) );
 583
 584 //              if (pClipObj.Is())
 585                 {
 586             ULONG nBiff8 = SotExchange::RegisterFormatName(
 587                     String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff8")));
 588             ULONG nBiff5 = SotExchange::RegisterFormatName(
 589                                         String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff5")));
 590
 591                                 //      als erstes SvDraw-Model, dann Grafik
 592                                 //      (Grafik darf nur bei einzelner Grafik drinstehen)
 593
 594                         if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING ))
 595                         {
 596                                 // special case for tables from drawing
 597                                 if( aDataHelper.HasFormat( SOT_FORMAT_RTF ) )
 598                                 {
 599                                         PasteFromSystem( FORMAT_RTF );
 600                                 }
 601                                 else
 602                                 {
 603                                         PasteFromSystem( SOT_FORMATSTR_ID_DRAWING );
 604                                 }
 605                         }
 606                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ))
 607                                 PasteFromSystem( SOT_FORMATSTR_ID_SVXB );
 608                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ))
 609                         {
 610                                 //      If it's a Writer object, insert RTF instead of OLE
 611
 612                                 BOOL bDoRtf = FALSE;
 613                                 SotStorageStreamRef xStm;
 614                                 TransferableObjectDescriptor aObjDesc;
 615                                 if( aDataHelper.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) &&
 616                                         aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_EMBED_SOURCE, xStm ) )
 617                                 {
 618                                         SotStorageRef xStore( new SotStorage( *xStm ) );
 619                                         bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) ||
 620                                                                  aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) )
 621                                                            && aDataHelper.HasFormat( SOT_FORMAT_RTF ) );
 622                                 }
 623                                 if ( bDoRtf )
 624                                         PasteFromSystem( FORMAT_RTF );
 625                                 else
 626                                         PasteFromSystem( SOT_FORMATSTR_ID_EMBED_SOURCE );
 627                         }
 628                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE ))
 629                                 PasteFromSystem( SOT_FORMATSTR_ID_LINK_SOURCE );
 630                         // the following format can not affect scenario from #89579#
 631                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE ))
 632                                 PasteFromSystem( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE );
 633                         // FORMAT_PRIVATE no longer here (can't work if pOwnClip is NULL)
 634             else if (aDataHelper.HasFormat(nBiff8))      // before xxx_OLE formats
 635                 PasteFromSystem(nBiff8);
 636             else if (aDataHelper.HasFormat(nBiff5))
 637                 PasteFromSystem(nBiff5);
 638                         else if (aDataHelper.HasFormat(FORMAT_RTF))
 639                                 PasteFromSystem(FORMAT_RTF);
 640                         else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML))
 641                                 PasteFromSystem(SOT_FORMATSTR_ID_HTML);
 642                         else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML_SIMPLE))
 643                                 PasteFromSystem(SOT_FORMATSTR_ID_HTML_SIMPLE);
 644                         else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_SYLK))
 645                                 PasteFromSystem(SOT_FORMATSTR_ID_SYLK);
 646                         else if (aDataHelper.HasFormat(FORMAT_STRING))
 647                                 PasteFromSystem(FORMAT_STRING);
 648                         else if (aDataHelper.HasFormat(FORMAT_GDIMETAFILE))
 649                                 PasteFromSystem(FORMAT_GDIMETAFILE);
 650                         else if (aDataHelper.HasFormat(FORMAT_BITMAP))
 651                                 PasteFromSystem(FORMAT_BITMAP);
 652                         // #89579# xxx_OLE formats come last, like in SotExchange tables
 653                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE ))
 654                                 PasteFromSystem( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE );
 655                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE_OLE ))
 656                                 PasteFromSystem( SOT_FORMATSTR_ID_LINK_SOURCE_OLE );
 657 //                      else
 658 //                              ErrorMessage(STR_PASTE_ERROR);
 659                 }
 660 //              else
 661 //                      ErrorMessage(STR_PASTE_ERROR);
 662         }
 663
 664         //      keine Fehlermeldung, weil SID_PASTE in der idl das FastCall-Flag hat,
 665         //      also auch gerufen wird, wenn nichts im Clipboard steht (#42531#)
 666 }
 667
 668 void ScViewFunc::PasteFromTransferable( const uno::Reference<datatransfer::XTransferable>& rxTransferable )
 669 {
 670     ScTransferObj *pOwnClip=0;
 671     ScDrawTransferObj *pDrawClip=0;
 672     uno::Reference<lang::XUnoTunnel> xTunnel( rxTransferable, uno::UNO_QUERY );
 673     if ( xTunnel.is() )
 674     {
 675         sal_Int64 nHandle = xTunnel->getSomething( ScTransferObj::getUnoTunnelId() );
 676         if ( nHandle )
 677             pOwnClip = (ScTransferObj*) (sal_IntPtr) nHandle;
 678         else
 679         {
 680             nHandle = xTunnel->getSomething( ScDrawTransferObj::getUnoTunnelId() );
 681             if ( nHandle )
 682                 pDrawClip = (ScDrawTransferObj*) (sal_IntPtr) nHandle;
 683         }
 684     }
 685
 686         if (pOwnClip)
 687     {
 688                 PasteFromClip( IDF_ALL, pOwnClip->GetDocument(),
 689                                                 PASTE_NOFUNC, FALSE, FALSE, FALSE, INS_NONE, IDF_NONE,
 690                                                 TRUE );         // allow warning dialog
 691     }
 692         else if (pDrawClip)
 693     {
 694         ScViewData* pViewData = GetViewData();
 695         SCCOL nPosX = pViewData->GetCurX();
 696         SCROW nPosY = pViewData->GetCurY();
 697         Window* pWin = GetActiveWin();
 698         Point aPos = pWin->PixelToLogic( pViewData->GetScrPos( nPosX, nPosY, pViewData->GetActivePart() ) );
 699         PasteDraw( aPos, pDrawClip->GetModel(), FALSE, pDrawClip->GetSourceDocID() == pViewData->GetDocument()->GetDocumentID() );
 700     }
 701         else
 702     {
 703             TransferableDataHelper aDataHelper( rxTransferable );
 704                 {
 705             ULONG nBiff8 = SotExchange::RegisterFormatName(
 706                     String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff8")));
 707             ULONG nBiff5 = SotExchange::RegisterFormatName(
 708                                         String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Biff5")));
 709                         ULONG nFormatId = 0;
 710                                 //      als erstes SvDraw-Model, dann Grafik
 711                                 //      (Grafik darf nur bei einzelner Grafik drinstehen)
 712
 713                         if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING ))
 714                                 nFormatId = SOT_FORMATSTR_ID_DRAWING;
 715                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ))
 716                                 nFormatId = SOT_FORMATSTR_ID_SVXB;
 717                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ))
 718                         {
 719                                 //      If it's a Writer object, insert RTF instead of OLE
 720                                 BOOL bDoRtf = FALSE;
 721                                 SotStorageStreamRef xStm;
 722                                 TransferableObjectDescriptor aObjDesc;
 723                                 if( aDataHelper.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) &&
 724                                         aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_EMBED_SOURCE, xStm ) )
 725                                 {
 726                                         SotStorageRef xStore( new SotStorage( *xStm ) );
 727                                         bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) ||
 728                                                                  aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) )
 729                                                            && aDataHelper.HasFormat( SOT_FORMAT_RTF ) );
 730                                 }
 731                                 if ( bDoRtf )
 732                                         nFormatId = FORMAT_RTF;
 733                                 else
 734                                         nFormatId = SOT_FORMATSTR_ID_EMBED_SOURCE;
 735                         }
 736                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE ))
 737                                 nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE;
 738                         // the following format can not affect scenario from #89579#
 739                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE ))
 740                                 nFormatId = SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE;
 741                         // FORMAT_PRIVATE no longer here (can't work if pOwnClip is NULL)
 742             else if (aDataHelper.HasFormat(nBiff8))      // before xxx_OLE formats
 743                 nFormatId = nBiff8;
 744             else if (aDataHelper.HasFormat(nBiff5))
 745                 nFormatId = nBiff5;
 746                         else if (aDataHelper.HasFormat(FORMAT_RTF))
 747                                 nFormatId = FORMAT_RTF;
 748                         else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML))
 749                                 nFormatId = SOT_FORMATSTR_ID_HTML;
 750                         else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_HTML_SIMPLE))
 751                                 nFormatId = SOT_FORMATSTR_ID_HTML_SIMPLE;
 752                         else if (aDataHelper.HasFormat(SOT_FORMATSTR_ID_SYLK))
 753                                 nFormatId = SOT_FORMATSTR_ID_SYLK;
 754                         else if (aDataHelper.HasFormat(FORMAT_STRING))
 755                                 nFormatId = FORMAT_STRING;
 756                         else if (aDataHelper.HasFormat(FORMAT_GDIMETAFILE))
 757                                 nFormatId = FORMAT_GDIMETAFILE;
 758                         else if (aDataHelper.HasFormat(FORMAT_BITMAP))
 759                                 nFormatId = FORMAT_BITMAP;
 760                         // #89579# xxx_OLE formats come last, like in SotExchange tables
 761                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE ))
 762                                 nFormatId = SOT_FORMATSTR_ID_EMBED_SOURCE_OLE;
 763                         else if (aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE_OLE ))
 764                                 nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE_OLE;
 765                         else
 766                                 return;
 767
 768                         PasteDataFormat( nFormatId, aDataHelper.GetTransferable(),
 769                                 GetViewData()->GetCurX(), GetViewData()->GetCurY(),
 770                                 NULL, FALSE, FALSE );
 771                 }
 772         }
 773 }
 774
 775 BOOL ScViewFunc::PasteFromSystem( ULONG nFormatId, BOOL bApi )
 776 {
 777         UpdateInputLine();
 778
 779         BOOL bRet = TRUE;
 780         Window* pWin = GetActiveWin();
 781         ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard( pWin );
 782         if ( nFormatId == 0 && pOwnClip )
 783     {
 784         // #129384# keep a reference in case the clipboard is changed during PasteFromClip
 785         uno::Reference<datatransfer::XTransferable> aOwnClipRef( pOwnClip );
 786                 PasteFromClip( IDF_ALL, pOwnClip->GetDocument(),
 787                                                 PASTE_NOFUNC, FALSE, FALSE, FALSE, INS_NONE, IDF_NONE,
 788                                                 !bApi );                // allow warning dialog
 789     }
 790         else
 791         {
 792                 TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pWin ) );
 793                 if ( !aDataHelper.GetTransferable().is() )
 794                         return FALSE;
 795
 796                 bRet = PasteDataFormat( nFormatId, aDataHelper.GetTransferable(),
 797                                                                 GetViewData()->GetCurX(), GetViewData()->GetCurY(),
 798                                                                 NULL, FALSE, !bApi );           // allow warning dialog
 799
 800                 if ( !bRet && !bApi )
 801                         ErrorMessage(STR_PASTE_ERROR);
 802         }
 803         return bRet;
 804 }
 805
 806
 807 //----------------------------------------------------------------------------
 808 //              P A S T E
 809
 810 BOOL ScViewFunc::PasteOnDrawObject( const uno::Reference<datatransfer::XTransferable>& rxTransferable,
 811                                                                         SdrObject* pHitObj, BOOL bLink )
 812 {
 813         BOOL bRet = FALSE;
 814         if ( bLink )
 815         {
 816                 TransferableDataHelper aDataHelper( rxTransferable );
 817                 if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ) )
 818                 {
 819                         SotStorageStreamRef xStm;
 820                         if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_SVXB, xStm ) )
 821                         {
 822                                 Graphic aGraphic;
 823                                 *xStm >> aGraphic;
 824                                 bRet = ApplyGraphicToObject( pHitObj, aGraphic );
 825                         }
 826                 }
 827                 else if ( aDataHelper.HasFormat( SOT_FORMAT_GDIMETAFILE ) )
 828                 {
 829                         GDIMetaFile aMtf;
 830                         if( aDataHelper.GetGDIMetaFile( FORMAT_GDIMETAFILE, aMtf ) )
 831                                 bRet = ApplyGraphicToObject( pHitObj, Graphic(aMtf) );
 832                 }
 833                 else if ( aDataHelper.HasFormat( SOT_FORMAT_BITMAP ) )
 834                 {
 835                         Bitmap aBmp;
 836                         if( aDataHelper.GetBitmap( FORMAT_BITMAP, aBmp ) )
 837                                 bRet = ApplyGraphicToObject( pHitObj, Graphic(aBmp) );
 838                 }
 839         }
 840         else
 841         {
 842                 //      ham' wa noch nich
 843         }
 844         return bRet;
 845 }
 846
 847 BOOL lcl_SelHasAttrib( ScDocument* pDoc, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
 848                         const ScMarkData& rTabSelection, USHORT nMask )
 849 {
 850     SCTAB nTabCount = pDoc->GetTableCount();
 851     for (SCTAB nTab=0; nTab<nTabCount; nTab++)
 852         if ( rTabSelection.GetTableSelect(nTab) && pDoc->HasAttrib( nCol1, nRow1, nTab, nCol2, nRow2, nTab, nMask ) )
 853             return TRUE;
 854     return FALSE;
 855 }
 856
 857 //
 858 //              Einfuegen auf Tabelle:
 859 //
 860
 861 //      internes Paste
 862
 863 namespace {
 864
 865 class CursorSwitcher
 866 {
 867 public:
 868     CursorSwitcher(ScViewFunc* pViewFunc) :
 869         mpViewFunc(pViewFunc)
 870     {
 871         mpViewFunc->HideCursor();
 872     }
 873
 874     ~CursorSwitcher()
 875     {
 876         mpViewFunc->ShowCursor();
 877     }
 878 private:
 879     ScViewFunc* mpViewFunc;
 880 };
 881
 882 bool lcl_checkDestRangeForOverwrite(const ScRange& rDestRange, const ScDocument* pDoc, const ScMarkData& rMark, Window* pParentWnd)
 883 {
 884     bool bIsEmpty = true;
 885     SCTAB nTabCount = pDoc->GetTableCount();
 886     for (SCTAB nTab=0; nTab < nTabCount && bIsEmpty; ++nTab)
 887     {
 888         if (!rMark.GetTableSelect(nTab))
 889             continue;
 890
 891         bIsEmpty = pDoc->IsBlockEmpty(nTab, rDestRange.aStart.Col(), rDestRange.aStart.Row(),
 892                                       rDestRange.aEnd.Col(), rDestRange.aEnd.Row());
 893     }
 894
 895     if (!bIsEmpty)
 896     {
 897         ScReplaceWarnBox aBox(pParentWnd);
 898         if (aBox.Execute() != RET_YES)
 899         {
 900             //  changing the configuration is within the ScReplaceWarnBox
 901             return false;
 902         }
 903     }
 904     return true;
 905 }
 906
 907 }
 908
 909 BOOL ScViewFunc::PasteFromClip( USHORT nFlags, ScDocument* pClipDoc,
 910                                                                         USHORT nFunction, BOOL bSkipEmpty,
 911                                                                         BOOL bTranspose, BOOL bAsLink,
 912                                                                         InsCellCmd eMoveMode, USHORT nUndoExtraFlags,
 913                                                                         BOOL bAllowDialogs )
 914 {
 915         if (!pClipDoc)
 916         {
 917                 DBG_ERROR("PasteFromClip: pClipDoc=0 not allowed");
 918                 return FALSE;
 919         }
 920
 921         //      fuer Undo etc. immer alle oder keine Inhalte sichern
 922         USHORT nContFlags = IDF_NONE;
 923         if (nFlags & IDF_CONTENTS)
 924                 nContFlags |= IDF_CONTENTS;
 925         if (nFlags & IDF_ATTRIB)
 926                 nContFlags |= IDF_ATTRIB;
 927         // evtl. Attribute ins Undo ohne sie vom Clip ins Doc zu kopieren
 928         USHORT nUndoFlags = nContFlags;
 929         if (nUndoExtraFlags & IDF_ATTRIB)
 930                 nUndoFlags |= IDF_ATTRIB;
 931     // do not copy note captions into undo document
 932     nUndoFlags |= IDF_NOCAPTIONS;
 933
 934     ScClipParam& rClipParam = pClipDoc->GetClipParam();
 935     if (rClipParam.isMultiRange())
 936         return PasteMultiRangesFromClip(
 937             nFlags, pClipDoc, nFunction, bSkipEmpty, bTranspose, bAsLink, bAllowDialogs,
 938             eMoveMode, nContFlags, nUndoFlags);
 939
 940         BOOL bCutMode = pClipDoc->IsCutMode();          // if transposing, take from original clipdoc
 941         BOOL bIncludeFiltered = bCutMode;
 942
 943     // paste drawing: also if IDF_NOTE is set (to create drawing layer for note captions)
 944         BOOL bPasteDraw = ( pClipDoc->GetDrawLayer() && ( nFlags & (IDF_OBJECTS|IDF_NOTE) ) );
 945
 946         ScDocShellRef aTransShellRef;   // for objects in xTransClip - must remain valid as long as xTransClip
 947         ScDocument* pOrigClipDoc = NULL;
 948         ::std::auto_ptr< ScDocument > xTransClip;
 949         if ( bTranspose )
 950         {
 951         SCCOL nX;
 952         SCROW nY;
 953         // include filtered rows until TransposeClip can skip them
 954                 bIncludeFiltered = TRUE;
 955                 pClipDoc->GetClipArea( nX, nY, TRUE );
 956                 if ( nY > static_cast<sal_Int32>(MAXCOL) )                                              // zuviele Zeilen zum Transponieren
 957                 {
 958                         ErrorMessage(STR_PASTE_FULL);
 959                         return FALSE;
 960                 }
 961                 pOrigClipDoc = pClipDoc;                // fuer Referenzen
 962
 963                 if ( bPasteDraw )
 964                 {
 965                         aTransShellRef = new ScDocShell;                // DocShell needs a Ref immediately
 966                         aTransShellRef->DoInitNew(NULL);
 967                 }
 968                 ScDrawLayer::SetGlobalDrawPersist(aTransShellRef);
 969
 970                 xTransClip.reset( new ScDocument( SCDOCMODE_CLIP ));
 971                 pClipDoc->TransposeClip( xTransClip.get(), nFlags, bAsLink );
 972                 pClipDoc = xTransClip.get();
 973
 974                 ScDrawLayer::SetGlobalDrawPersist(NULL);
 975         }
 976
 977         SCCOL nStartCol;
 978         SCROW nStartRow;
 979         SCTAB nStartTab;
 980         SCCOL nEndCol;
 981         SCROW nEndRow;
 982         SCTAB nEndTab;
 983         SCCOL nClipSizeX;
 984         SCROW nClipSizeY;
 985         pClipDoc->GetClipArea( nClipSizeX, nClipSizeY, TRUE );          // size in clipboard doc
 986
 987         //      size in target doc: include filtered rows only if CutMode is set
 988         SCCOL nDestSizeX;
 989         SCROW nDestSizeY;
 990         pClipDoc->GetClipArea( nDestSizeX, nDestSizeY, bIncludeFiltered );
 991
 992         ScDocument* pDoc = GetViewData()->GetDocument();
 993         ScDocShell* pDocSh = GetViewData()->GetDocShell();
 994         ScMarkData& rMark = GetViewData()->GetMarkData();
 995         SfxUndoManager* pUndoMgr = pDocSh->GetUndoManager();
 996         const BOOL bRecord(pDoc->IsUndoEnabled());
 997
 998         ScDocShellModificator aModificator( *pDocSh );
 999
1000     ScRange aMarkRange;
1001     ScMarkData aFilteredMark( rMark);   // local copy for all modifications
1002     ScMarkType eMarkType = GetViewData()->GetSimpleArea( aMarkRange, aFilteredMark);
1003     bool bMarkIsFiltered = (eMarkType == SC_MARK_SIMPLE_FILTERED);
1004     bool bNoPaste = ((eMarkType != SC_MARK_SIMPLE && !bMarkIsFiltered) ||
1005             (bMarkIsFiltered && (eMoveMode != INS_NONE || bAsLink)));
1006     if (!bNoPaste && !rMark.IsMarked())
1007     {
1008         // Create a selection with clipboard row count and check that for
1009         // filtered.
1010                 nStartCol = GetViewData()->GetCurX();
1011                 nStartRow = GetViewData()->GetCurY();
1012                 nStartTab = GetViewData()->GetTabNo();
1013                 nEndCol = nStartCol + nDestSizeX;
1014                 nEndRow = nStartRow + nDestSizeY;
1015                 nEndTab = nStartTab;
1016         aMarkRange = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1017         if (ScViewUtil::HasFiltered( aMarkRange, pDoc))
1018         {
1019             bMarkIsFiltered = true;
1020             // Fit to clipboard's row count unfiltered rows. If there is no
1021             // fit assume that pasting is not possible. Note that nDestSizeY is
1022             // size-1 (difference).
1023             if (!ScViewUtil::FitToUnfilteredRows( aMarkRange, pDoc, nDestSizeY+1))
1024                 bNoPaste = true;
1025         }
1026         aFilteredMark.SetMarkArea( aMarkRange);
1027     }
1028     if (bNoPaste)
1029     {
1030         ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1031         return FALSE;
1032     }
1033
1034     SCROW nUnfilteredRows = aMarkRange.aEnd.Row() - aMarkRange.aStart.Row() + 1;
1035     ScRangeList aRangeList;
1036     if (bMarkIsFiltered)
1037     {
1038         ScViewUtil::UnmarkFiltered( aFilteredMark, pDoc);
1039         aFilteredMark.FillRangeListWithMarks( &aRangeList, FALSE);
1040         nUnfilteredRows = 0;
1041         for (ScRange* p = aRangeList.First(); p; p = aRangeList.Next())
1042         {
1043             nUnfilteredRows += p->aEnd.Row() - p->aStart.Row() + 1;
1044         }
1045 #if 0
1046         /* This isn't needed but could be a desired restriction. */
1047         // For filtered, destination rows have to be an exact multiple of
1048         // source rows. Note that nDestSizeY is size-1 (difference), so
1049         // nDestSizeY==0 fits always.
1050         if ((nUnfilteredRows % (nDestSizeY+1)) != 0)
1051         {
1052             /* FIXME: this should be a more descriptive error message then. */
1053             ErrorMessage(STR_MSSG_PASTEFROMCLIP_0);
1054             return FALSE;
1055         }
1056 #endif
1057     }
1058
1059         SCCOL nMarkAddX = 0;
1060         SCROW nMarkAddY = 0;
1061
1062     // Also for a filtered selection the area is used, for undo et al.
1063         if ( aFilteredMark.IsMarked() || bMarkIsFiltered )
1064         {
1065         aMarkRange.GetVars( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1066                 SCCOL nBlockAddX = nEndCol-nStartCol;
1067                 SCROW nBlockAddY = nEndRow-nStartRow;
1068
1069                 //      #58422# Nachfrage, wenn die Selektion groesser als 1 Zeile/Spalte, aber kleiner
1070                 //      als das Clipboard ist (dann wird ueber die Selektion hinaus eingefuegt)
1071
1072                 //      ClipSize is not size, but difference
1073                 if ( ( nBlockAddX != 0 && nBlockAddX < nDestSizeX ) ||
1074                          ( nBlockAddY != 0 && nBlockAddY < nDestSizeY ) ||
1075              ( bMarkIsFiltered && nUnfilteredRows < nDestSizeY+1 ) )
1076                 {
1077                         ScWaitCursorOff aWaitOff( GetFrameWin() );
1078                         String aMessage = ScGlobal::GetRscString( STR_PASTE_BIGGER );
1079                         QueryBox aBox( GetViewData()->GetDialogParent(),
1080                                                         WinBits(WB_YES_NO | WB_DEF_NO), aMessage );
1081                         if ( aBox.Execute() != RET_YES )
1082                         {
1083                                 return FALSE;
1084                         }
1085                 }
1086
1087                 if (nBlockAddX > nDestSizeX)
1088                         nMarkAddX = nBlockAddX - nDestSizeX;                    // fuer Merge-Test
1089                 else
1090                         nEndCol = nStartCol + nDestSizeX;
1091
1092                 if (nBlockAddY > nDestSizeY)
1093                         nMarkAddY = nBlockAddY - nDestSizeY;                    // fuer Merge-Test
1094                 else
1095         {
1096             nEndRow = nStartRow + nDestSizeY;
1097             if (bMarkIsFiltered || nEndRow > aMarkRange.aEnd.Row())
1098             {
1099                 // Same as above if nothing was marked: re-fit selection to
1100                 // unfiltered rows. Extending the selection actually may
1101                 // introduce filtered rows where there weren't any before, so
1102                 // we also need to test for that.
1103                 aMarkRange = ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1104                 if (bMarkIsFiltered || ScViewUtil::HasFiltered( aMarkRange, pDoc))
1105                 {
1106                     bMarkIsFiltered = true;
1107                     // Worst case: all rows up to the end of the sheet are filtered.
1108                     if (!ScViewUtil::FitToUnfilteredRows( aMarkRange, pDoc, nDestSizeY+1))
1109                     {
1110                         ErrorMessage(STR_PASTE_FULL);
1111                         return FALSE;
1112                     }
1113                 }
1114                 aMarkRange.GetVars( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab);
1115                 aFilteredMark.SetMarkArea( aMarkRange);
1116                 if (bMarkIsFiltered)
1117                 {
1118                     ScViewUtil::UnmarkFiltered( aFilteredMark, pDoc);
1119                     aFilteredMark.FillRangeListWithMarks( &aRangeList, TRUE);
1120                 }
1121             }
1122         }
1123         }
1124         else
1125         {
1126                 nStartCol = GetViewData()->GetCurX();
1127                 nStartRow = GetViewData()->GetCurY();
1128                 nStartTab = GetViewData()->GetTabNo();
1129                 nEndCol = nStartCol + nDestSizeX;
1130                 nEndRow = nStartRow + nDestSizeY;
1131                 nEndTab = nStartTab;
1132         }
1133
1134     bool bOffLimits = !ValidCol(nEndCol) || !ValidRow(nEndRow);
1135
1136         //      Zielbereich, wie er angezeigt wird:
1137         ScRange aUserRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab );
1138
1139         //      Sollen Zellen eingefuegt werden?
1140         //      (zu grosse nEndCol/nEndRow werden weiter unten erkannt)
1141         BOOL bInsertCells = ( eMoveMode != INS_NONE && !bOffLimits );
1142         if ( bInsertCells )
1143         {
1144                 //      #94115# Instead of EnterListAction, the paste undo action is merged into the
1145                 //      insert action, so Repeat can insert the right cells
1146
1147                 MarkRange( aUserRange );                        // wird vor CopyFromClip sowieso gesetzt
1148
1149                 // #72930# CutMode is reset on insertion of cols/rows but needed again on cell move
1150                 BOOL bCut = pClipDoc->IsCutMode();
1151                 if (!InsertCells( eMoveMode, bRecord, TRUE ))   // is inserting possible?
1152                 {
1153                         return FALSE;
1154                         //      #i21036# EnterListAction isn't used, and InsertCells doesn't insert
1155                         //      its undo action on failure, so no undo handling is needed here
1156                 }
1157                 if ( bCut )
1158                         pClipDoc->SetCutMode( bCut );
1159         }
1160         else if (!bOffLimits)
1161         {
1162                 BOOL bAskIfNotEmpty = bAllowDialogs &&
1163                                                                 ( nFlags & IDF_CONTENTS ) &&
1164                                                                 nFunction == PASTE_NOFUNC &&
1165                                                                 SC_MOD()->GetInputOptions().GetReplaceCellsWarn();
1166                 if ( bAskIfNotEmpty )
1167                 {
1168             if (!lcl_checkDestRangeForOverwrite(aUserRange, pDoc, aFilteredMark, GetViewData()->GetDialogParent()))
1169                 return false;
1170                 }
1171         }
1172
1173         SCCOL nClipStartX;                                              // Clipboard-Bereich erweitern
1174         SCROW nClipStartY;
1175         pClipDoc->GetClipStart( nClipStartX, nClipStartY );
1176         SCCOL nUndoEndCol = nClipStartX + nClipSizeX;
1177         SCROW nUndoEndRow = nClipStartY + nClipSizeY;   // end of source area in clipboard document
1178     BOOL bClipOver = FALSE;
1179     // #i68690# ExtendMerge for the clip doc must be called with the clipboard's sheet numbers.
1180     // The same end column/row can be used for all calls because the clip doc doesn't contain
1181     // content outside the clip area.
1182     for (SCTAB nClipTab=0; nClipTab<=MAXTAB; nClipTab++)
1183         if ( pClipDoc->HasTable(nClipTab) )
1184             if ( pClipDoc->ExtendMerge( nClipStartX,nClipStartY, nUndoEndCol,nUndoEndRow, nClipTab, FALSE ) )
1185                 bClipOver = TRUE;
1186         nUndoEndCol -= nClipStartX + nClipSizeX;
1187         nUndoEndRow -= nClipStartY + nClipSizeY;                // now contains only the difference added by ExtendMerge
1188     nUndoEndCol = sal::static_int_cast<SCCOL>( nUndoEndCol + nEndCol );
1189     nUndoEndRow = sal::static_int_cast<SCROW>( nUndoEndRow + nEndRow ); // destination area, expanded for merged cells
1190
1191 //      if (nUndoEndCol < nEndCol) nUndoEndCol = nEndCol;
1192 //      if (nUndoEndRow < nEndRow) nUndoEndRow = nEndRow;
1193
1194 //      nUndoEndCol += nMarkAddX;
1195 //      nUndoEndRow += nMarkAddY;
1196
1197         if (nUndoEndCol>MAXCOL || nUndoEndRow>MAXROW)
1198         {
1199                 ErrorMessage(STR_PASTE_FULL);
1200                 return FALSE;
1201         }
1202
1203     pDoc->ExtendMergeSel( nStartCol,nStartRow, nUndoEndCol,nUndoEndRow, aFilteredMark, FALSE );
1204
1205                 //      Test auf Zellschutz
1206
1207         ScEditableTester aTester( pDoc, nStartTab, nStartCol,nStartRow, nUndoEndCol,nUndoEndRow );
1208         if (!aTester.IsEditable())
1209         {
1210                 ErrorMessage(aTester.GetMessageId());
1211                 return FALSE;
1212         }
1213
1214         ScDocFunc& rDocFunc = pDocSh->GetDocFunc();
1215         if ( bRecord )
1216         {
1217                 String aUndo = ScGlobal::GetRscString( pClipDoc->IsCutMode() ? STR_UNDO_MOVE : STR_UNDO_COPY );
1218                 pUndoMgr->EnterListAction( aUndo, aUndo );
1219         }
1220
1221         if (bClipOver)
1222         if (lcl_SelHasAttrib( pDoc, nStartCol,nStartRow, nUndoEndCol,nUndoEndRow, aFilteredMark, HASATTR_OVERLAPPED ))
1223         {       // "Cell merge are possible if we unmerge cells before insertion"
1224                         ScRange destRange( nStartCol, nStartRow, nStartTab, nUndoEndCol, nUndoEndRow, nEndTab );
1225                     rDocFunc.UnmergeCells(destRange, bRecord, TRUE);
1226                         for (SCCOL i = nStartCol; i <= nUndoEndCol; i++)
1227                                 for (SCROW j = nStartRow; j <= nUndoEndRow; j++)
1228                                         {
1229                                                 ScRange rrRange (i, j, nEndTab);
1230                                                 pDoc->ExtendOverlapped(rrRange);
1231                                                 pDoc->ExtendMerge(rrRange);
1232                                                 // we can have merged range in the selection,
1233                                                 // so we take only those which are in the way
1234                                                 if (rrRange.aStart.Col() < nStartCol || rrRange.aEnd.Col() > nEndCol ||
1235                                                         rrRange.aStart.Row() < nStartRow || rrRange.aEnd.Row() > nEndRow)
1236                                                 {
1237                                                         rDocFunc.UnmergeCells(rrRange, bRecord, TRUE);
1238                                                 }
1239                                         }
1240                 }
1241
1242         if ( !bCutMode )
1243         {
1244                 ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
1245                 if ( pChangeTrack )
1246                         pChangeTrack->ResetLastCut();   // kein CutMode mehr
1247         }
1248
1249         BOOL bColInfo = ( nStartRow==0 && nEndRow==MAXROW );
1250         BOOL bRowInfo = ( nStartCol==0 && nEndCol==MAXCOL );
1251
1252         ScDocument* pUndoDoc    = NULL;
1253         ScDocument* pRefUndoDoc = NULL;
1254         ScDocument* pRedoDoc    = NULL;
1255         ScRefUndoData* pUndoData = NULL;
1256
1257         if ( bRecord )
1258         {
1259                 pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1260                 pUndoDoc->InitUndoSelected( pDoc, aFilteredMark, bColInfo, bRowInfo );
1261
1262                 // all sheets - CopyToDocument skips those that don't exist in pUndoDoc
1263                 SCTAB nTabCount = pDoc->GetTableCount();
1264                 pDoc->CopyToDocument( nStartCol, nStartRow, 0, nUndoEndCol, nUndoEndRow, nTabCount-1,
1265                                                                 nUndoFlags, FALSE, pUndoDoc );
1266
1267                 if ( bCutMode )
1268                 {
1269                         pRefUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1270                         pRefUndoDoc->InitUndo( pDoc, 0, nTabCount-1, FALSE, FALSE );
1271
1272                         pUndoData = new ScRefUndoData( pDoc );
1273                 }
1274         }
1275
1276         USHORT nExtFlags = 0;
1277         pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab,
1278                                                                            nEndCol,   nEndRow,   nEndTab );             // content before the change
1279
1280         if (GetViewData()->IsActive())
1281         {
1282                 DoneBlockMode();
1283                 InitOwnBlockMode();
1284         }
1285         rMark.SetMarkArea( aUserRange );
1286     MarkDataChanged();
1287
1288         HideCursor();                                                   // Cursor aendert sich !
1289
1290                 //
1291                 //      Aus Clipboard kopieren,
1292                 //      wenn gerechnet werden soll, Originaldaten merken
1293                 //
1294
1295         ScDocument* pMixDoc = NULL;
1296         if ( bSkipEmpty || nFunction )
1297         {
1298                 if ( nFlags & IDF_CONTENTS )
1299                 {
1300                         pMixDoc = new ScDocument( SCDOCMODE_UNDO );
1301                         pMixDoc->InitUndo( pDoc, nStartTab, nEndTab );
1302                         pDoc->CopyToDocument( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab,
1303                                                                         IDF_CONTENTS, FALSE, pMixDoc );
1304                 }
1305         }
1306
1307     /*  Make draw layer and start drawing undo.
1308         - Needed before AdjustBlockHeight to track moved drawing objects.
1309         - Needed before pDoc->CopyFromClip to track inserted note caption objects.
1310      */
1311         if ( bPasteDraw )
1312                 pDocSh->MakeDrawLayer();
1313         if ( bRecord )
1314                 pDoc->BeginDrawUndo();
1315
1316         USHORT nNoObjFlags = nFlags & ~IDF_OBJECTS;
1317         if (!bAsLink)
1318         {
1319                 //      copy normally (original range)
1320         pDoc->CopyFromClip( aUserRange, aFilteredMark, nNoObjFlags,
1321                 pRefUndoDoc, pClipDoc, TRUE, FALSE, bIncludeFiltered,
1322                 bSkipEmpty, (bMarkIsFiltered ? &aRangeList : NULL) );
1323
1324                 // bei Transpose Referenzen per Hand anpassen
1325                 if ( bTranspose && bCutMode && (nFlags & IDF_CONTENTS) )
1326                         pDoc->UpdateTranspose( aUserRange.aStart, pOrigClipDoc, aFilteredMark, pRefUndoDoc );
1327         }
1328         else if (!bTranspose)
1329         {
1330                 //      copy with bAsLink=TRUE
1331                 pDoc->CopyFromClip( aUserRange, aFilteredMark, nNoObjFlags, pRefUndoDoc, pClipDoc,
1332                                                                 TRUE, TRUE, bIncludeFiltered, bSkipEmpty );
1333         }
1334         else
1335         {
1336                 //      alle Inhalte kopieren (im TransClipDoc stehen nur Formeln)
1337                 pDoc->CopyFromClip( aUserRange, aFilteredMark, nContFlags, pRefUndoDoc, pClipDoc );
1338         }
1339
1340         // skipped rows and merged cells don't mix
1341         if ( !bIncludeFiltered && pClipDoc->HasClipFilteredRows() )
1342                 rDocFunc.UnmergeCells( aUserRange, FALSE, TRUE );
1343
1344     pDoc->ExtendMergeSel( nStartCol, nStartRow, nEndCol, nEndRow, aFilteredMark, TRUE );    // Refresh
1345                                                                                                                                                                         // und Bereich neu
1346
1347         if ( pMixDoc )                          // Rechenfunktionen mit Original-Daten auszufuehren ?
1348         {
1349                 pDoc->MixDocument( aUserRange, nFunction, bSkipEmpty, pMixDoc );
1350         }
1351         delete pMixDoc;
1352
1353         AdjustBlockHeight();                    // update row heights before pasting objects
1354
1355         if ( nFlags & IDF_OBJECTS )
1356         {
1357                 //      Paste the drawing objects after the row heights have been updated.
1358
1359                 pDoc->CopyFromClip( aUserRange, aFilteredMark, IDF_OBJECTS, pRefUndoDoc, pClipDoc,
1360                                                                 TRUE, FALSE, bIncludeFiltered );
1361         }
1362
1363         //
1364         //
1365         //
1366
1367         pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab,
1368                                                                            nEndCol,   nEndRow,   nEndTab );             // content after the change
1369
1370
1371                 //      ggf. Autofilter-Koepfe loeschen
1372         if (bCutMode)
1373                 if (pDoc->RefreshAutoFilter( nClipStartX,nClipStartY, nClipStartX+nClipSizeX,
1374                                                                                 nClipStartY+nClipSizeY, nStartTab ))
1375                         pDocSh->PostPaint( nClipStartX,nClipStartY,nStartTab,
1376                                                                 nClipStartX+nClipSizeX,nClipStartY,nStartTab,
1377                                                                 PAINT_GRID );
1378
1379         ShowCursor();                                                   // Cursor aendert sich !
1380
1381         //!     Block-Bereich bei RefUndoDoc weglassen !!!
1382
1383         if ( bRecord )
1384         {
1385                 // Redo-Daten werden erst beim ersten Undo kopiert
1386                 // ohne RefUndoDoc muss das Redo-Doc noch nicht angelegt werden
1387
1388                 if (pRefUndoDoc)
1389                 {
1390                         pRedoDoc = new ScDocument( SCDOCMODE_UNDO );
1391                         pRedoDoc->InitUndo( pDoc, nStartTab, nEndTab, bColInfo, bRowInfo );
1392
1393                         //              angepasste Referenzen ins Redo-Doc
1394
1395                         SCTAB nTabCount = pDoc->GetTableCount();
1396                         pRedoDoc->AddUndoTab( 0, nTabCount-1 );
1397                         pDoc->CopyUpdated( pRefUndoDoc, pRedoDoc );
1398
1399                         //              alte Referenzen ins Undo-Doc
1400
1401                         //! Tabellen selektieren ?
1402                         pUndoDoc->AddUndoTab( 0, nTabCount-1 );
1403                         pRefUndoDoc->DeleteArea( nStartCol, nStartRow, nEndCol, nEndRow, aFilteredMark, IDF_ALL );
1404                         pRefUndoDoc->CopyToDocument( 0,0,0, MAXCOL,MAXROW,nTabCount-1,
1405                                                                                         IDF_FORMULA, FALSE, pUndoDoc );
1406                         delete pRefUndoDoc;
1407                 }
1408
1409                 //      DeleteUnchanged for pUndoData is in ScUndoPaste ctor,
1410                 //      UndoData for redo is made during first undo
1411
1412                 ScUndoPasteOptions aOptions;                    // store options for repeat
1413                 aOptions.nFunction  = nFunction;
1414                 aOptions.bSkipEmpty = bSkipEmpty;
1415                 aOptions.bTranspose = bTranspose;
1416                 aOptions.bAsLink    = bAsLink;
1417                 aOptions.eMoveMode  = eMoveMode;
1418
1419                 SfxUndoAction* pUndo = new ScUndoPaste( pDocSh,
1420                                                                 nStartCol, nStartRow, nStartTab,
1421                                                                 nUndoEndCol, nUndoEndRow, nEndTab, aFilteredMark,
1422                                                                 pUndoDoc, pRedoDoc, nFlags | nUndoFlags,
1423                                                                 pUndoData, NULL, NULL, NULL,
1424                                                                 FALSE, &aOptions );             // FALSE = Redo data not yet copied
1425
1426                 if ( bInsertCells )
1427                 {
1428                         //      Merge the paste undo action into the insert action.
1429                         //      Use ScUndoWrapper so the ScUndoPaste pointer can be stored in the insert action.
1430
1431                         pUndoMgr->AddUndoAction( new ScUndoWrapper( pUndo ), TRUE );
1432                 }
1433                 else
1434                         pUndoMgr->AddUndoAction( pUndo );
1435
1436                 pUndoMgr->LeaveListAction();
1437         }
1438
1439         USHORT nPaint = PAINT_GRID;
1440         if (bColInfo)
1441         {
1442                 nPaint |= PAINT_TOP;
1443                 nUndoEndCol = MAXCOL;                           // nur zum Zeichnen !
1444         }
1445         if (bRowInfo)
1446         {
1447                 nPaint |= PAINT_LEFT;
1448                 nUndoEndRow = MAXROW;                           // nur zum Zeichnen !
1449         }
1450         pDocSh->PostPaint( nStartCol, nStartRow, nStartTab,
1451                                                 nUndoEndCol, nUndoEndRow, nEndTab, nPaint, nExtFlags );
1452         // AdjustBlockHeight has already been called above
1453
1454         aModificator.SetDocumentModified();
1455     PostPasteFromClip(aUserRange, rMark);
1456         return TRUE;
1457 }
1458
1459 bool ScViewFunc::PasteMultiRangesFromClip(
1460     sal_uInt16 nFlags, ScDocument* pClipDoc, sal_uInt16 nFunction,
1461     bool bSkipEmpty, bool bTranspose, bool bAsLink, bool bAllowDialogs,
1462     InsCellCmd eMoveMode, sal_uInt16 /*nContFlags*/, sal_uInt16 nUndoFlags)
1463 {
1464     ScViewData& rViewData = *GetViewData();
1465     ScDocument* pDoc = rViewData.GetDocument();
1466     ScDocShell* pDocSh = rViewData.GetDocShell();
1467     ScMarkData aMark(rViewData.GetMarkData());
1468     const ScAddress& rCurPos = rViewData.GetCurPos();
1469     ScClipParam& rClipParam = pClipDoc->GetClipParam();
1470     SCCOL nColSize = rClipParam.getPasteColSize();
1471     SCROW nRowSize = rClipParam.getPasteRowSize();
1472
1473     if (bTranspose)
1474     {
1475         if (static_cast<SCROW>(rCurPos.Col()) + nRowSize-1 > static_cast<SCROW>(MAXCOL))
1476         {
1477             ErrorMessage(STR_PASTE_FULL);
1478             return false;
1479         }
1480
1481         ::std::auto_ptr<ScDocument> pTransClip(new ScDocument(SCDOCMODE_CLIP));
1482         pClipDoc->TransposeClip(pTransClip.get(), nFlags, bAsLink);
1483         pClipDoc = pTransClip.release();
1484         SCCOL nTempColSize = nColSize;
1485         nColSize = static_cast<SCCOL>(nRowSize);
1486         nRowSize = static_cast<SCROW>(nTempColSize);
1487     }
1488
1489     if (!ValidCol(rCurPos.Col()+nColSize-1) || !ValidRow(rCurPos.Row()+nRowSize-1))
1490     {
1491         ErrorMessage(STR_PASTE_FULL);
1492         return false;
1493     }
1494
1495     // Determine the first and last selected sheet numbers.
1496     SCTAB nTab1 = aMark.GetFirstSelected();
1497     SCTAB nTab2 = nTab1;
1498     for (SCTAB i = nTab1+1; i <= MAXTAB; ++i)
1499         if (aMark.GetTableSelect(i))
1500             nTab2 = i;
1501
1502     ScDocShellModificator aModificator(*pDocSh);
1503
1504     // For multi-selection paste, we don't support cell duplication for larger
1505     // destination range.  In case the destination is marked, we reset it to
1506     // the clip size.
1507     ScRange aMarkedRange(rCurPos.Col(), rCurPos.Row(), nTab1,
1508                          rCurPos.Col()+nColSize-1, rCurPos.Row()+nRowSize-1, nTab2);
1509
1510     bool bAskIfNotEmpty =
1511         bAllowDialogs && (nFlags & IDF_CONTENTS) &&
1512         nFunction == PASTE_NOFUNC && SC_MOD()->GetInputOptions().GetReplaceCellsWarn();
1513
1514     if (bAskIfNotEmpty)
1515     {
1516         if (!lcl_checkDestRangeForOverwrite(aMarkedRange, pDoc, aMark, rViewData.GetDialogParent()))
1517             return false;
1518     }
1519
1520     aMark.SetMarkArea(aMarkedRange);
1521     MarkRange(aMarkedRange);
1522
1523     bool bInsertCells = (eMoveMode != INS_NONE);
1524     if (bInsertCells)
1525     {
1526         if (!InsertCells(eMoveMode, pDoc->IsUndoEnabled(), true))
1527             return false;
1528     }
1529
1530     ::std::auto_ptr<ScDocument> pUndoDoc;
1531     if (pDoc->IsUndoEnabled())
1532     {
1533         pUndoDoc.reset(new ScDocument(SCDOCMODE_UNDO));
1534         pUndoDoc->InitUndoSelected(pDoc, aMark, false, false);
1535         pDoc->CopyToDocument(aMarkedRange, IDF_ALL, false, pUndoDoc.get(), &aMark, true);
1536     }
1537
1538     ::std::auto_ptr<ScDocument> pMixDoc;
1539     if ( bSkipEmpty || nFunction )
1540     {
1541         if ( nFlags & IDF_CONTENTS )
1542         {
1543             pMixDoc.reset(new ScDocument(SCDOCMODE_UNDO));
1544             pMixDoc->InitUndoSelected(pDoc, aMark, false, false);
1545             pDoc->CopyToDocument(aMarkedRange, IDF_CONTENTS, false, pMixDoc.get(), &aMark, true);
1546         }
1547     }
1548
1549     /*  Make draw layer and start drawing undo.
1550         - Needed before AdjustBlockHeight to track moved drawing objects.
1551         - Needed before pDoc->CopyFromClip to track inserted note caption objects.
1552      */
1553         if (nFlags & IDF_OBJECTS)
1554                 pDocSh->MakeDrawLayer();
1555         if (pDoc->IsUndoEnabled())
1556                 pDoc->BeginDrawUndo();
1557
1558     CursorSwitcher aCursorSwitch(this);
1559     sal_uInt16 nNoObjFlags = nFlags & ~IDF_OBJECTS;
1560     pDoc->CopyMultiRangeFromClip(rCurPos, aMark, nNoObjFlags, pClipDoc,
1561                                  true, bAsLink, false, bSkipEmpty);
1562
1563     if (pMixDoc.get())
1564         pDoc->MixDocument(aMarkedRange, nFunction, bSkipEmpty, pMixDoc.get());
1565
1566     AdjustBlockHeight();            // update row heights before pasting objects
1567
1568     if (nFlags & IDF_OBJECTS)
1569     {
1570         //  Paste the drawing objects after the row heights have been updated.
1571         pDoc->CopyMultiRangeFromClip(rCurPos, aMark, IDF_OBJECTS, pClipDoc,
1572                                      true, false, false, true);
1573     }
1574
1575     pDocSh->PostPaint(rCurPos.Col(), rCurPos.Row(), rCurPos.Tab(),
1576                       rCurPos.Col()+nColSize-1, rCurPos.Row()+nRowSize-1, rCurPos.Tab(),
1577                       PAINT_GRID);
1578
1579     if (pDoc->IsUndoEnabled())
1580     {
1581         SfxUndoManager* pUndoMgr = pDocSh->GetUndoManager();
1582         String aUndo = ScGlobal::GetRscString(
1583             pClipDoc->IsCutMode() ? STR_UNDO_CUT : STR_UNDO_COPY);
1584         pUndoMgr->EnterListAction(aUndo, aUndo);
1585
1586         ScUndoPasteOptions aOptions;            // store options for repeat
1587         aOptions.nFunction  = nFunction;
1588         aOptions.bSkipEmpty = bSkipEmpty;
1589         aOptions.bTranspose = bTranspose;
1590         aOptions.bAsLink    = bAsLink;
1591         aOptions.eMoveMode  = eMoveMode;
1592
1593         ScUndoPaste* pUndo = new ScUndoPaste(pDocSh,
1594             aMarkedRange.aStart.Col(),
1595             aMarkedRange.aStart.Row(),
1596             aMarkedRange.aStart.Tab(),
1597             aMarkedRange.aEnd.Col(),
1598             aMarkedRange.aEnd.Row(),
1599             aMarkedRange.aEnd.Tab(),
1600             aMark, pUndoDoc.release(), NULL, nFlags|nUndoFlags, NULL, NULL, NULL, NULL, false, &aOptions);
1601
1602         if (bInsertCells)
1603             pUndoMgr->AddUndoAction(new ScUndoWrapper(pUndo), true);
1604         else
1605             pUndoMgr->AddUndoAction(pUndo, false);
1606
1607         pUndoMgr->LeaveListAction();
1608     }
1609     aModificator.SetDocumentModified();
1610     PostPasteFromClip(aMarkedRange, aMark);
1611     return true;
1612 }
1613
1614 void ScViewFunc::PostPasteFromClip(const ScRange& rPasteRange, const ScMarkData& rMark)
1615 {
1616     ScViewData* pViewData = GetViewData();
1617     ScDocShell* pDocSh = pViewData->GetDocShell();
1618     ScDocument* pDoc = pViewData->GetDocument();
1619     pDocSh->UpdateOle(pViewData);
1620
1621         SelectionChanged();
1622
1623     // #i97876# Spreadsheet data changes are not notified
1624     ScModelObj* pModelObj = ScModelObj::getImplementation( pDocSh->GetModel() );
1625     if ( pModelObj && pModelObj->HasChangesListeners() )
1626     {
1627         ScRangeList aChangeRanges;
1628         SCTAB nTabCount = pDoc->GetTableCount();
1629         for ( SCTAB i = 0; i < nTabCount; ++i )
1630         {
1631             if ( rMark.GetTableSelect( i ) )
1632             {
1633                 ScRange aChangeRange(rPasteRange);
1634                 aChangeRange.aStart.SetTab( i );
1635                 aChangeRange.aEnd.SetTab( i );
1636                 aChangeRanges.Append( aChangeRange );
1637             }
1638         }
1639         pModelObj->NotifyChanges( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "cell-change" ) ), aChangeRanges );
1640     }
1641 }
1642
1643
1644 //----------------------------------------------------------------------------
1645 //              D R A G   A N D   D R O P
1646 //
1647 //      innerhalb des Dokuments
1648
1649 BOOL ScViewFunc::MoveBlockTo( const ScRange& rSource, const ScAddress& rDestPos,
1650                                                                 BOOL bCut, BOOL bRecord, BOOL bPaint, BOOL bApi )
1651 {
1652         ScDocShell* pDocSh = GetViewData()->GetDocShell();
1653         HideAllCursors();               // wegen zusammengefassten
1654
1655         BOOL bSuccess = TRUE;
1656         SCTAB nDestTab = rDestPos.Tab();
1657         const ScMarkData& rMark = GetViewData()->GetMarkData();
1658         if ( rSource.aStart.Tab() == nDestTab && rSource.aEnd.Tab() == nDestTab && rMark.GetSelectCount() > 1 )
1659         {
1660                 //      moving within one table and several tables selected -> apply to all selected tables
1661
1662                 if ( bRecord )
1663                 {
1664                         String aUndo = ScGlobal::GetRscString( bCut ? STR_UNDO_MOVE : STR_UNDO_COPY );
1665                         pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
1666                 }
1667
1668                 //      collect ranges of consecutive selected tables
1669
1670                 ScRange aLocalSource = rSource;
1671                 ScAddress aLocalDest = rDestPos;
1672                 SCTAB nTabCount = pDocSh->GetDocument()->GetTableCount();
1673                 SCTAB nStartTab = 0;
1674                 while ( nStartTab < nTabCount && bSuccess )
1675                 {
1676                         while ( nStartTab < nTabCount && !rMark.GetTableSelect(nStartTab) )
1677                                 ++nStartTab;
1678                         if ( nStartTab < nTabCount )
1679                         {
1680                                 SCTAB nEndTab = nStartTab;
1681                                 while ( nEndTab+1 < nTabCount && rMark.GetTableSelect(nEndTab+1) )
1682                                         ++nEndTab;
1683
1684                                 aLocalSource.aStart.SetTab( nStartTab );
1685                                 aLocalSource.aEnd.SetTab( nEndTab );
1686                                 aLocalDest.SetTab( nStartTab );
1687
1688                                 bSuccess = pDocSh->GetDocFunc().MoveBlock(
1689                                                                 aLocalSource, aLocalDest, bCut, bRecord, bPaint, bApi );
1690
1691                                 nStartTab = nEndTab + 1;
1692                         }
1693                 }
1694
1695                 if ( bRecord )
1696                         pDocSh->GetUndoManager()->LeaveListAction();
1697         }
1698         else
1699         {
1700                 //      move the block as specified
1701                 bSuccess = pDocSh->GetDocFunc().MoveBlock(
1702                                                                 rSource, rDestPos, bCut, bRecord, bPaint, bApi );
1703         }
1704
1705         ShowAllCursors();
1706         if (bSuccess)
1707         {
1708                 //      Zielbereich markieren
1709                 ScAddress aDestEnd(
1710                                         rDestPos.Col() + rSource.aEnd.Col() - rSource.aStart.Col(),
1711                                         rDestPos.Row() + rSource.aEnd.Row() - rSource.aStart.Row(),
1712                                         nDestTab );
1713
1714                 BOOL bIncludeFiltered = bCut;
1715                 if ( !bIncludeFiltered )
1716                 {
1717                         // find number of non-filtered rows
1718             SCROW nPastedCount = pDocSh->GetDocument()->CountNonFilteredRows(
1719                 rSource.aStart.Row(), rSource.aEnd.Row(), rSource.aStart.Tab());
1720
1721                         if ( nPastedCount == 0 )
1722                                 nPastedCount = 1;
1723                         aDestEnd.SetRow( rDestPos.Row() + nPastedCount - 1 );
1724                 }
1725
1726                 MarkRange( ScRange( rDestPos, aDestEnd ), FALSE );                      //! FALSE ???
1727
1728                 pDocSh->UpdateOle(GetViewData());
1729                 SelectionChanged();
1730         }
1731         return bSuccess;
1732 }
1733
1734 //      Link innerhalb des Dokuments
1735
1736 BOOL ScViewFunc::LinkBlock( const ScRange& rSource, const ScAddress& rDestPos, BOOL bApi )
1737 {
1738         //      Test auf Ueberlappung
1739
1740         if ( rSource.aStart.Tab() == rDestPos.Tab() )
1741         {
1742                 SCCOL nDestEndCol = rDestPos.Col() + ( rSource.aEnd.Col() - rSource.aStart.Col() );
1743                 SCROW nDestEndRow = rDestPos.Row() + ( rSource.aEnd.Row() - rSource.aStart.Row() );
1744
1745                 if ( rSource.aStart.Col() <= nDestEndCol && rDestPos.Col() <= rSource.aEnd.Col() &&
1746                          rSource.aStart.Row() <= nDestEndRow && rDestPos.Row() <= rSource.aEnd.Row() )
1747                 {
1748                         if (!bApi)
1749                                 ErrorMessage( STR_ERR_LINKOVERLAP );
1750                         return FALSE;
1751                 }
1752         }
1753
1754         //      Ausfuehren per Paste
1755
1756         ScDocument* pDoc = GetViewData()->GetDocument();
1757         ScDocument* pClipDoc = new ScDocument( SCDOCMODE_CLIP );
1758         pDoc->CopyTabToClip( rSource.aStart.Col(), rSource.aStart.Row(),
1759                                                         rSource.aEnd.Col(), rSource.aEnd.Row(),
1760                                                         rSource.aStart.Tab(), pClipDoc );
1761
1762         //      Zielbereich markieren (Cursor setzen, keine Markierung)
1763
1764         if ( GetViewData()->GetTabNo() != rDestPos.Tab() )
1765                 SetTabNo( rDestPos.Tab() );
1766
1767         MoveCursorAbs( rDestPos.Col(), rDestPos.Row(), SC_FOLLOW_NONE, FALSE, FALSE );
1768
1769         //      Paste
1770
1771         PasteFromClip( IDF_ALL, pClipDoc, PASTE_NOFUNC, FALSE, FALSE, TRUE );           // als Link
1772
1773         delete pClipDoc;
1774
1775         return TRUE;
1776 }
1777
1778 void ScViewFunc::DataFormPutData( SCROW nCurrentRow ,
1779                                   SCROW nStartRow , SCCOL nStartCol ,
1780                                   SCROW nEndRow , SCCOL nEndCol ,
1781                                   Edit** pEdits ,
1782                                   sal_uInt16 aColLength )
1783 {
1784     ScDocument* pDoc = GetViewData()->GetDocument();
1785     ScDocShell* pDocSh = GetViewData()->GetDocShell();
1786     ScMarkData& rMark = GetViewData()->GetMarkData();
1787     ScDocShellModificator aModificator( *pDocSh );
1788     SfxUndoManager* pUndoMgr = pDocSh->GetUndoManager();
1789     if ( pDoc )
1790     {
1791         const BOOL bRecord( pDoc->IsUndoEnabled());
1792         ScDocument* pUndoDoc = NULL;
1793         ScDocument* pRedoDoc = NULL;
1794         ScRefUndoData* pUndoData = NULL;
1795         SCTAB nTab = GetViewData()->GetTabNo();
1796         SCTAB nStartTab = nTab;
1797         SCTAB nEndTab = nTab;
1798
1799         {
1800                 ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack();
1801                 if ( pChangeTrack )
1802                         pChangeTrack->ResetLastCut();   // kein CutMode mehr
1803         }
1804         ScRange aUserRange( nStartCol, nCurrentRow, nStartTab, nEndCol, nCurrentRow, nEndTab );
1805         BOOL bColInfo = ( nStartRow==0 && nEndRow==MAXROW );
1806         BOOL bRowInfo = ( nStartCol==0 && nEndCol==MAXCOL );
1807         SCCOL nUndoEndCol = nStartCol+aColLength-1;
1808         SCROW nUndoEndRow = nCurrentRow;
1809         USHORT nUndoFlags = IDF_NONE;
1810
1811         if ( bRecord )
1812         {
1813             pUndoDoc = new ScDocument( SCDOCMODE_UNDO );
1814             pUndoDoc->InitUndoSelected( pDoc , rMark , bColInfo , bRowInfo );
1815             pDoc->CopyToDocument( aUserRange , 1 , FALSE , pUndoDoc );
1816         }
1817         USHORT nExtFlags = 0;
1818         pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nStartRow, nStartTab , nEndCol, nEndRow, nEndTab ); // content before the change
1819         //rMark.SetMarkArea( aUserRange );
1820         pDoc->BeginDrawUndo();
1821
1822         for(sal_uInt16 i = 0; i < aColLength; i++)
1823         {
1824             if (pEdits[i])
1825             {
1826                 String  aFieldName=pEdits[i]->GetText();
1827                 pDoc->SetString( nStartCol + i, nCurrentRow, nTab, aFieldName );
1828             }
1829         }
1830         //pDoc->ExtendMergeSel( nStartCol, nStartRow, nEndCol, nEndRow, rMark, TRUE );    // Refresh
1831         pDocSh->UpdatePaintExt( nExtFlags, nStartCol, nCurrentRow, nStartTab, nEndCol, nCurrentRow, nEndTab );  // content after the change
1832         SfxUndoAction* pUndo = new ScUndoDataForm( pDocSh,
1833                                                                 nStartCol, nCurrentRow, nStartTab,
1834                                                                 nUndoEndCol, nUndoEndRow, nEndTab, rMark,
1835                                                                 pUndoDoc, pRedoDoc, nUndoFlags,
1836                                                                 pUndoData, NULL, NULL, NULL,
1837                                                                 FALSE );           // FALSE = Redo data not yet copied
1838         pUndoMgr->AddUndoAction( new ScUndoWrapper( pUndo ), TRUE );
1839
1840         USHORT nPaint = PAINT_GRID;
1841         if (bColInfo)
1842         {
1843                 nPaint |= PAINT_TOP;
1844                 nUndoEndCol = MAXCOL;                           // nur zum Zeichnen !
1845         }
1846         if (bRowInfo)
1847         {
1848                 nPaint |= PAINT_LEFT;
1849                 nUndoEndRow = MAXROW;                           // nur zum Zeichnen !
1850         }
1851
1852         pDocSh->PostPaint( nStartCol, nCurrentRow, nStartTab,
1853                                                 nUndoEndCol, nUndoEndRow, nEndTab, nPaint, nExtFlags );
1854         pDocSh->UpdateOle(GetViewData());
1855     }
1856 }
1857
1858