| /************************************************************** |
| * |
| * 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" |
| |
| // INCLUDE --------------------------------------------------------------- |
| |
| #include <tools/debug.hxx> |
| |
| #include "refupdat.hxx" |
| #include "document.hxx" |
| #include "compiler.hxx" |
| #include "bigrange.hxx" |
| #include "chgtrack.hxx" |
| |
| //------------------------------------------------------------------------ |
| |
| template< typename R, typename S, typename U > |
| sal_Bool lcl_MoveStart( R& rRef, U nStart, S nDelta, U nMask ) |
| { |
| sal_Bool bCut = sal_False; |
| if ( rRef >= nStart ) |
| rRef = sal::static_int_cast<R>( rRef + nDelta ); |
| else if ( nDelta < 0 && rRef >= nStart + nDelta ) |
| rRef = nStart + nDelta; //! begrenzen ??? |
| if ( rRef < 0 ) |
| { |
| rRef = 0; |
| bCut = sal_True; |
| } |
| else if ( rRef > nMask ) |
| { |
| rRef = nMask; |
| bCut = sal_True; |
| } |
| return bCut; |
| } |
| |
| template< typename R, typename S, typename U > |
| sal_Bool lcl_MoveEnd( R& rRef, U nStart, S nDelta, U nMask ) |
| { |
| sal_Bool bCut = sal_False; |
| if ( rRef >= nStart ) |
| rRef = sal::static_int_cast<R>( rRef + nDelta ); |
| else if ( nDelta < 0 && rRef >= nStart + nDelta ) |
| rRef = nStart + nDelta - 1; //! begrenzen ??? |
| if ( rRef < 0 ) |
| { |
| rRef = 0; |
| bCut = sal_True; |
| } |
| else if ( rRef > nMask ) |
| { |
| rRef = nMask; |
| bCut = sal_True; |
| } |
| return bCut; |
| } |
| |
| template< typename R, typename S, typename U > |
| sal_Bool lcl_MoveReorder( R& rRef, U nStart, U nEnd, S nDelta ) |
| { |
| if ( rRef >= nStart && rRef <= nEnd ) |
| { |
| rRef = sal::static_int_cast<R>( rRef + nDelta ); |
| return sal_True; |
| } |
| |
| if ( nDelta > 0 ) // nach hinten schieben |
| { |
| if ( rRef >= nStart && rRef <= nEnd + nDelta ) |
| { |
| if ( rRef <= nEnd ) |
| rRef = sal::static_int_cast<R>( rRef + nDelta ); // in the moved range |
| else |
| rRef -= nEnd - nStart + 1; // nachruecken |
| return sal_True; |
| } |
| } |
| else // nach vorne schieben |
| { |
| if ( rRef >= nStart + nDelta && rRef <= nEnd ) |
| { |
| if ( rRef >= nStart ) |
| rRef = sal::static_int_cast<R>( rRef + nDelta ); // in the moved range |
| else |
| rRef += nEnd - nStart + 1; // nachruecken |
| return sal_True; |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| template< typename R, typename S, typename U > |
| sal_Bool lcl_MoveItCut( R& rRef, S nDelta, U nMask ) |
| { |
| sal_Bool bCut = sal_False; |
| rRef = sal::static_int_cast<R>( rRef + nDelta ); |
| if ( rRef < 0 ) |
| { |
| rRef = 0; |
| bCut = sal_True; |
| } |
| else if ( rRef > nMask ) |
| { |
| rRef = nMask; |
| bCut = sal_True; |
| } |
| return bCut; |
| } |
| |
| template< typename R, typename S, typename U > |
| void lcl_MoveItWrap( R& rRef, S nDelta, U nMask ) |
| { |
| rRef = sal::static_int_cast<R>( rRef + nDelta ); |
| if ( rRef < 0 ) |
| rRef += nMask+1; |
| else if ( rRef > nMask ) |
| rRef -= nMask+1; |
| } |
| |
| template< typename R, typename S, typename U > |
| sal_Bool lcl_MoveRefPart( R& rRef1Val, sal_Bool& rRef1Del, sal_Bool bDo1, |
| R& rRef2Val, sal_Bool& rRef2Del, sal_Bool bDo2, |
| U nStart, U nEnd, S nDelta, U nMask ) |
| { |
| if ( nDelta ) |
| { |
| sal_Bool bDel, bCut1, bCut2; |
| bDel = bCut1 = bCut2 = sal_False; |
| S n; |
| if (bDo1 && bDo2) |
| { |
| if ( nDelta < 0 ) |
| { |
| n = nStart + nDelta; |
| if ( n <= rRef1Val && rRef1Val < nStart |
| && n <= rRef2Val && rRef2Val < nStart ) |
| bDel = sal_True; |
| } |
| else |
| { |
| n = nEnd + nDelta; |
| if ( nEnd < rRef1Val && rRef1Val <= n |
| && nEnd < rRef2Val && rRef2Val <= n ) |
| bDel = sal_True; |
| } |
| } |
| if ( bDel ) |
| { // move deleted along |
| rRef1Val = sal::static_int_cast<R>( rRef1Val + nDelta ); |
| rRef2Val = sal::static_int_cast<R>( rRef2Val + nDelta ); |
| } |
| else |
| { |
| if (bDo1) |
| { |
| if ( rRef1Del ) |
| rRef1Val = sal::static_int_cast<R>( rRef1Val + nDelta ); |
| else |
| bCut1 = lcl_MoveStart( rRef1Val, nStart, nDelta, nMask ); |
| } |
| if (bDo2) |
| { |
| if ( rRef2Del ) |
| rRef2Val = sal::static_int_cast<R>( rRef2Val + nDelta ); |
| else |
| bCut2 = lcl_MoveEnd( rRef2Val, nStart, nDelta, nMask ); |
| } |
| } |
| if ( bDel || (bCut1 && bCut2) ) |
| rRef1Del = rRef2Del = sal_True; |
| return bDel || bCut1 || bCut2 || rRef1Del || rRef2Del; |
| } |
| else |
| return sal_False; |
| } |
| |
| template< typename R, typename S, typename U > |
| sal_Bool IsExpand( R n1, R n2, U nStart, S nD ) |
| { //! vor normalem Move... |
| return |
| nD > 0 // Insert |
| && n1 < n2 // mindestens zwei Cols/Rows/Tabs in Ref |
| && ( |
| (nStart <= n1 && n1 < nStart + nD) // n1 innerhalb des Insert |
| || (n2 + 1 == nStart) // n2 direkt vor Insert |
| ); // n1 < nStart <= n2 wird sowieso expanded! |
| } |
| |
| |
| template< typename R, typename S, typename U > |
| void Expand( R& n1, R& n2, U nStart, S nD ) |
| { //! nach normalem Move..., nur wenn IsExpand vorher sal_True war! |
| //! erst das Ende |
| if ( n2 + 1 == nStart ) |
| { // am Ende |
| n2 = sal::static_int_cast<R>( n2 + nD ); |
| return; |
| } |
| // am Anfang |
| n1 = sal::static_int_cast<R>( n1 - nD ); |
| } |
| |
| |
| sal_Bool lcl_IsWrapBig( sal_Int32 nRef, sal_Int32 nDelta ) |
| { |
| if ( nRef > 0 && nDelta > 0 ) |
| return nRef + nDelta <= 0; |
| else if ( nRef < 0 && nDelta < 0 ) |
| return nRef + nDelta >= 0; |
| return sal_False; |
| } |
| |
| |
| sal_Bool lcl_MoveBig( sal_Int32& rRef, sal_Int32 nStart, sal_Int32 nDelta ) |
| { |
| sal_Bool bCut = sal_False; |
| if ( rRef >= nStart ) |
| { |
| if ( nDelta > 0 ) |
| bCut = lcl_IsWrapBig( rRef, nDelta ); |
| if ( bCut ) |
| rRef = nInt32Max; |
| else |
| rRef += nDelta; |
| } |
| return bCut; |
| } |
| |
| sal_Bool lcl_MoveItCutBig( sal_Int32& rRef, sal_Int32 nDelta ) |
| { |
| sal_Bool bCut = lcl_IsWrapBig( rRef, nDelta ); |
| rRef += nDelta; |
| return bCut; |
| } |
| |
| |
| ScRefUpdateRes ScRefUpdate::Update( ScDocument* pDoc, UpdateRefMode eUpdateRefMode, |
| SCCOL nCol1, SCROW nRow1, SCTAB nTab1, |
| SCCOL nCol2, SCROW nRow2, SCTAB nTab2, |
| SCsCOL nDx, SCsROW nDy, SCsTAB nDz, |
| SCCOL& theCol1, SCROW& theRow1, SCTAB& theTab1, |
| SCCOL& theCol2, SCROW& theRow2, SCTAB& theTab2 ) |
| { |
| ScRefUpdateRes eRet = UR_NOTHING; |
| |
| SCCOL oldCol1 = theCol1; |
| SCROW oldRow1 = theRow1; |
| SCTAB oldTab1 = theTab1; |
| SCCOL oldCol2 = theCol2; |
| SCROW oldRow2 = theRow2; |
| SCTAB oldTab2 = theTab2; |
| |
| sal_Bool bCut1, bCut2; |
| |
| if (eUpdateRefMode == URM_INSDEL) |
| { |
| sal_Bool bExpand = pDoc->IsExpandRefs(); |
| if ( nDx && (theRow1 >= nRow1) && (theRow2 <= nRow2) && |
| (theTab1 >= nTab1) && (theTab2 <= nTab2) ) |
| { |
| sal_Bool bExp = (bExpand && IsExpand( theCol1, theCol2, nCol1, nDx )); |
| bCut1 = lcl_MoveStart( theCol1, nCol1, nDx, MAXCOL ); |
| bCut2 = lcl_MoveEnd( theCol2, nCol1, nDx, MAXCOL ); |
| if ( theCol2 < theCol1 ) |
| { |
| eRet = UR_INVALID; |
| theCol2 = theCol1; |
| } |
| else if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| if ( bExp ) |
| { |
| Expand( theCol1, theCol2, nCol1, nDx ); |
| eRet = UR_UPDATED; |
| } |
| } |
| if ( nDy && (theCol1 >= nCol1) && (theCol2 <= nCol2) && |
| (theTab1 >= nTab1) && (theTab2 <= nTab2) ) |
| { |
| sal_Bool bExp = (bExpand && IsExpand( theRow1, theRow2, nRow1, nDy )); |
| bCut1 = lcl_MoveStart( theRow1, nRow1, nDy, MAXROW ); |
| bCut2 = lcl_MoveEnd( theRow2, nRow1, nDy, MAXROW ); |
| if ( theRow2 < theRow1 ) |
| { |
| eRet = UR_INVALID; |
| theRow2 = theRow1; |
| } |
| else if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| if ( bExp ) |
| { |
| Expand( theRow1, theRow2, nRow1, nDy ); |
| eRet = UR_UPDATED; |
| } |
| } |
| if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) && |
| (theRow1 >= nRow1) && (theRow2 <= nRow2) ) |
| { |
| SCsTAB nMaxTab = pDoc->GetTableCount() - 1; |
| nMaxTab = sal::static_int_cast<SCsTAB>(nMaxTab + nDz); // adjust to new count |
| sal_Bool bExp = (bExpand && IsExpand( theTab1, theTab2, nTab1, nDz )); |
| bCut1 = lcl_MoveStart( theTab1, nTab1, nDz, static_cast<SCTAB>(nMaxTab) ); |
| bCut2 = lcl_MoveEnd( theTab2, nTab1, nDz, static_cast<SCTAB>(nMaxTab) ); |
| if ( theTab2 < theTab1 ) |
| { |
| eRet = UR_INVALID; |
| theTab2 = theTab1; |
| } |
| else if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| if ( bExp ) |
| { |
| Expand( theTab1, theTab2, nTab1, nDz ); |
| eRet = UR_UPDATED; |
| } |
| } |
| } |
| else if (eUpdateRefMode == URM_MOVE) |
| { |
| if ((theCol1 >= nCol1-nDx) && (theRow1 >= nRow1-nDy) && (theTab1 >= nTab1-nDz) && |
| (theCol2 <= nCol2-nDx) && (theRow2 <= nRow2-nDy) && (theTab2 <= nTab2-nDz)) |
| { |
| if ( nDx ) |
| { |
| bCut1 = lcl_MoveItCut( theCol1, nDx, MAXCOL ); |
| bCut2 = lcl_MoveItCut( theCol2, nDx, MAXCOL ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| } |
| if ( nDy ) |
| { |
| bCut1 = lcl_MoveItCut( theRow1, nDy, MAXROW ); |
| bCut2 = lcl_MoveItCut( theRow2, nDy, MAXROW ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| } |
| if ( nDz ) |
| { |
| SCsTAB nMaxTab = (SCsTAB) pDoc->GetTableCount() - 1; |
| bCut1 = lcl_MoveItCut( theTab1, nDz, static_cast<SCTAB>(nMaxTab) ); |
| bCut2 = lcl_MoveItCut( theTab2, nDz, static_cast<SCTAB>(nMaxTab) ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| } |
| } |
| } |
| else if (eUpdateRefMode == URM_REORDER) |
| { |
| // bisher nur fuer nDz (MoveTab) |
| DBG_ASSERT ( !nDx && !nDy, "URM_REORDER fuer x und y noch nicht implementiert" ); |
| |
| if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) && |
| (theRow1 >= nRow1) && (theRow2 <= nRow2) ) |
| { |
| bCut1 = lcl_MoveReorder( theTab1, nTab1, nTab2, nDz ); |
| bCut2 = lcl_MoveReorder( theTab2, nTab1, nTab2, nDz ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| } |
| } |
| |
| if ( eRet == UR_NOTHING ) |
| { |
| if (oldCol1 != theCol1 |
| || oldRow1 != theRow1 |
| || oldTab1 != theTab1 |
| || oldCol2 != theCol2 |
| || oldRow2 != theRow2 |
| || oldTab2 != theTab2 |
| ) |
| eRet = UR_UPDATED; |
| } |
| return eRet; |
| } |
| |
| |
| // simples UpdateReference fuer ScBigRange (ScChangeAction/ScChangeTrack) |
| // Referenzen koennen auch ausserhalb des Dokuments liegen! |
| // Ganze Spalten/Zeilen (nInt32Min..nInt32Max) bleiben immer solche! |
| ScRefUpdateRes ScRefUpdate::Update( UpdateRefMode eUpdateRefMode, |
| const ScBigRange& rWhere, sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz, |
| ScBigRange& rWhat ) |
| { |
| ScRefUpdateRes eRet = UR_NOTHING; |
| const ScBigRange aOldRange( rWhat ); |
| |
| sal_Int32 nCol1, nRow1, nTab1, nCol2, nRow2, nTab2; |
| sal_Int32 theCol1, theRow1, theTab1, theCol2, theRow2, theTab2; |
| rWhere.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 ); |
| rWhat.GetVars( theCol1, theRow1, theTab1, theCol2, theRow2, theTab2 ); |
| |
| sal_Bool bCut1, bCut2; |
| |
| if (eUpdateRefMode == URM_INSDEL) |
| { |
| if ( nDx && (theRow1 >= nRow1) && (theRow2 <= nRow2) && |
| (theTab1 >= nTab1) && (theTab2 <= nTab2) && |
| !(theCol1 == nInt32Min && theCol2 == nInt32Max) ) |
| { |
| bCut1 = lcl_MoveBig( theCol1, nCol1, nDx ); |
| bCut2 = lcl_MoveBig( theCol2, nCol1, nDx ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| rWhat.aStart.SetCol( theCol1 ); |
| rWhat.aEnd.SetCol( theCol2 ); |
| } |
| if ( nDy && (theCol1 >= nCol1) && (theCol2 <= nCol2) && |
| (theTab1 >= nTab1) && (theTab2 <= nTab2) && |
| !(theRow1 == nInt32Min && theRow2 == nInt32Max) ) |
| { |
| bCut1 = lcl_MoveBig( theRow1, nRow1, nDy ); |
| bCut2 = lcl_MoveBig( theRow2, nRow1, nDy ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| rWhat.aStart.SetRow( theRow1 ); |
| rWhat.aEnd.SetRow( theRow2 ); |
| } |
| if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) && |
| (theRow1 >= nRow1) && (theRow2 <= nRow2) && |
| !(theTab1 == nInt32Min && theTab2 == nInt32Max) ) |
| { |
| bCut1 = lcl_MoveBig( theTab1, nTab1, nDz ); |
| bCut2 = lcl_MoveBig( theTab2, nTab1, nDz ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| rWhat.aStart.SetTab( theTab1 ); |
| rWhat.aEnd.SetTab( theTab2 ); |
| } |
| } |
| else if (eUpdateRefMode == URM_MOVE) |
| { |
| if ( rWhere.In( rWhat ) ) |
| { |
| if ( nDx && !(theCol1 == nInt32Min && theCol2 == nInt32Max) ) |
| { |
| bCut1 = lcl_MoveItCutBig( theCol1, nDx ); |
| bCut2 = lcl_MoveItCutBig( theCol2, nDx ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| rWhat.aStart.SetCol( theCol1 ); |
| rWhat.aEnd.SetCol( theCol2 ); |
| } |
| if ( nDy && !(theRow1 == nInt32Min && theRow2 == nInt32Max) ) |
| { |
| bCut1 = lcl_MoveItCutBig( theRow1, nDy ); |
| bCut2 = lcl_MoveItCutBig( theRow2, nDy ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| rWhat.aStart.SetRow( theRow1 ); |
| rWhat.aEnd.SetRow( theRow2 ); |
| } |
| if ( nDz && !(theTab1 == nInt32Min && theTab2 == nInt32Max) ) |
| { |
| bCut1 = lcl_MoveItCutBig( theTab1, nDz ); |
| bCut2 = lcl_MoveItCutBig( theTab2, nDz ); |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| rWhat.aStart.SetTab( theTab1 ); |
| rWhat.aEnd.SetTab( theTab2 ); |
| } |
| } |
| } |
| |
| if ( eRet == UR_NOTHING && rWhat != aOldRange ) |
| eRet = UR_UPDATED; |
| |
| return eRet; |
| } |
| |
| |
| ScRefUpdateRes ScRefUpdate::Update( ScDocument* pDoc, UpdateRefMode eMode, |
| const ScAddress& rPos, const ScRange& r, |
| SCsCOL nDx, SCsROW nDy, SCsTAB nDz, |
| ScComplexRefData& rRef, WhatType eWhat ) |
| { |
| ScRefUpdateRes eRet = UR_NOTHING; |
| |
| SCCOL nCol1 = r.aStart.Col(); |
| SCROW nRow1 = r.aStart.Row(); |
| SCTAB nTab1 = r.aStart.Tab(); |
| SCCOL nCol2 = r.aEnd.Col(); |
| SCROW nRow2 = r.aEnd.Row(); |
| SCTAB nTab2 = r.aEnd.Tab(); |
| |
| if( eMode == URM_INSDEL ) |
| { |
| sal_Bool bExpand = pDoc->IsExpandRefs(); |
| |
| const ScChangeTrack* pChangeTrack = pDoc->GetChangeTrack(); |
| sal_Bool bInDeleteUndo = |
| ( pChangeTrack ? pChangeTrack->IsInDeleteUndo() : sal_False ); |
| |
| SCCOL oldCol1 = rRef.Ref1.nCol; |
| SCROW oldRow1 = rRef.Ref1.nRow; |
| SCTAB oldTab1 = rRef.Ref1.nTab; |
| SCCOL oldCol2 = rRef.Ref2.nCol; |
| SCROW oldRow2 = rRef.Ref2.nRow; |
| SCTAB oldTab2 = rRef.Ref2.nTab; |
| |
| sal_Bool bRef1ColDel = rRef.Ref1.IsColDeleted(); |
| sal_Bool bRef2ColDel = rRef.Ref2.IsColDeleted(); |
| sal_Bool bRef1RowDel = rRef.Ref1.IsRowDeleted(); |
| sal_Bool bRef2RowDel = rRef.Ref2.IsRowDeleted(); |
| sal_Bool bRef1TabDel = rRef.Ref1.IsTabDeleted(); |
| sal_Bool bRef2TabDel = rRef.Ref2.IsTabDeleted(); |
| |
| if( nDx && |
| ((rRef.Ref1.nRow >= nRow1 |
| && rRef.Ref2.nRow <= nRow2) || (bRef1RowDel || bRef2RowDel)) |
| && |
| ((rRef.Ref1.nTab >= nTab1 |
| && rRef.Ref2.nTab <= nTab2) || (bRef1TabDel || bRef2TabDel)) |
| ) |
| { |
| sal_Bool bExp = (bExpand && !bInDeleteUndo && IsExpand( rRef.Ref1.nCol, |
| rRef.Ref2.nCol, nCol1, nDx )); |
| sal_Bool bDo1 = (eWhat == ScRefUpdate::ALL || (eWhat == |
| ScRefUpdate::ABSOLUTE && !rRef.Ref1.IsColRel())); |
| sal_Bool bDo2 = (eWhat == ScRefUpdate::ALL || (eWhat == |
| ScRefUpdate::ABSOLUTE && !rRef.Ref2.IsColRel())); |
| if ( lcl_MoveRefPart( rRef.Ref1.nCol, bRef1ColDel, bDo1, |
| rRef.Ref2.nCol, bRef2ColDel, bDo2, |
| nCol1, nCol2, nDx, MAXCOL ) ) |
| { |
| eRet = UR_UPDATED; |
| if ( bInDeleteUndo && (bRef1ColDel || bRef2ColDel) ) |
| { |
| if ( bRef1ColDel && nCol1 <= rRef.Ref1.nCol && |
| rRef.Ref1.nCol <= nCol1 + nDx ) |
| rRef.Ref1.SetColDeleted( sal_False ); |
| if ( bRef2ColDel && nCol1 <= rRef.Ref2.nCol && |
| rRef.Ref2.nCol <= nCol1 + nDx ) |
| rRef.Ref2.SetColDeleted( sal_False ); |
| } |
| else |
| { |
| if ( bRef1ColDel ) |
| rRef.Ref1.SetColDeleted( sal_True ); |
| if ( bRef2ColDel ) |
| rRef.Ref2.SetColDeleted( sal_True ); |
| } |
| } |
| if ( bExp ) |
| { |
| Expand( rRef.Ref1.nCol, rRef.Ref2.nCol, nCol1, nDx ); |
| eRet = UR_UPDATED; |
| } |
| } |
| if( nDy && |
| ((rRef.Ref1.nCol >= nCol1 |
| && rRef.Ref2.nCol <= nCol2) || (bRef1ColDel || bRef2ColDel)) |
| && |
| ((rRef.Ref1.nTab >= nTab1 |
| && rRef.Ref2.nTab <= nTab2) || (bRef1TabDel || bRef2TabDel)) |
| ) |
| { |
| sal_Bool bExp = (bExpand && !bInDeleteUndo && IsExpand( rRef.Ref1.nRow, |
| rRef.Ref2.nRow, nRow1, nDy )); |
| sal_Bool bDo1 = (eWhat == ScRefUpdate::ALL || (eWhat == |
| ScRefUpdate::ABSOLUTE && !rRef.Ref1.IsRowRel())); |
| sal_Bool bDo2 = (eWhat == ScRefUpdate::ALL || (eWhat == |
| ScRefUpdate::ABSOLUTE && !rRef.Ref2.IsRowRel())); |
| if ( lcl_MoveRefPart( rRef.Ref1.nRow, bRef1RowDel, bDo1, |
| rRef.Ref2.nRow, bRef2RowDel, bDo2, |
| nRow1, nRow2, nDy, MAXROW ) ) |
| { |
| eRet = UR_UPDATED; |
| if ( bInDeleteUndo && (bRef1RowDel || bRef2RowDel) ) |
| { |
| if ( bRef1RowDel && nRow1 <= rRef.Ref1.nRow && |
| rRef.Ref1.nRow <= nRow1 + nDy ) |
| rRef.Ref1.SetRowDeleted( sal_False ); |
| if ( bRef2RowDel && nRow1 <= rRef.Ref2.nRow && |
| rRef.Ref2.nRow <= nRow1 + nDy ) |
| rRef.Ref2.SetRowDeleted( sal_False ); |
| } |
| else |
| { |
| if ( bRef1RowDel ) |
| rRef.Ref1.SetRowDeleted( sal_True ); |
| if ( bRef2RowDel ) |
| rRef.Ref2.SetRowDeleted( sal_True ); |
| } |
| } |
| if ( bExp ) |
| { |
| Expand( rRef.Ref1.nRow, rRef.Ref2.nRow, nRow1, nDy ); |
| eRet = UR_UPDATED; |
| } |
| } |
| if( nDz && |
| ((rRef.Ref1.nCol >= nCol1 |
| && rRef.Ref2.nCol <= nCol2) || (bRef1ColDel || bRef2ColDel)) |
| && |
| ((rRef.Ref1.nRow >= nRow1 |
| && rRef.Ref2.nRow <= nRow2) || (bRef1RowDel || bRef2RowDel)) |
| ) |
| { |
| sal_Bool bExp = (bExpand && !bInDeleteUndo && IsExpand( rRef.Ref1.nTab, |
| rRef.Ref2.nTab, nTab1, nDz )); |
| SCTAB nMaxTab = pDoc->GetTableCount() - 1; |
| sal_Bool bDo1 = (eWhat == ScRefUpdate::ALL || (eWhat == |
| ScRefUpdate::ABSOLUTE && !rRef.Ref1.IsTabRel())); |
| sal_Bool bDo2 = (eWhat == ScRefUpdate::ALL || (eWhat == |
| ScRefUpdate::ABSOLUTE && !rRef.Ref2.IsTabRel())); |
| if ( lcl_MoveRefPart( rRef.Ref1.nTab, bRef1TabDel, bDo1, |
| rRef.Ref2.nTab, bRef2TabDel, bDo2, |
| nTab1, nTab2, nDz, nMaxTab ) ) |
| { |
| eRet = UR_UPDATED; |
| if ( bInDeleteUndo && (bRef1TabDel || bRef2TabDel) ) |
| { |
| if ( bRef1TabDel && nTab1 <= rRef.Ref1.nTab && |
| rRef.Ref1.nTab <= nTab1 + nDz ) |
| rRef.Ref1.SetTabDeleted( sal_False ); |
| if ( bRef2TabDel && nTab1 <= rRef.Ref2.nTab && |
| rRef.Ref2.nTab <= nTab1 + nDz ) |
| rRef.Ref2.SetTabDeleted( sal_False ); |
| } |
| else |
| { |
| if ( bRef1TabDel ) |
| rRef.Ref1.SetTabDeleted( sal_True ); |
| if ( bRef2TabDel ) |
| rRef.Ref2.SetTabDeleted( sal_True ); |
| } |
| } |
| if ( bExp ) |
| { |
| Expand( rRef.Ref1.nTab, rRef.Ref2.nTab, nTab1, nDz ); |
| eRet = UR_UPDATED; |
| } |
| } |
| if ( eRet == UR_NOTHING ) |
| { |
| if (oldCol1 != rRef.Ref1.nCol |
| || oldRow1 != rRef.Ref1.nRow |
| || oldTab1 != rRef.Ref1.nTab |
| || oldCol2 != rRef.Ref2.nCol |
| || oldRow2 != rRef.Ref2.nRow |
| || oldTab2 != rRef.Ref2.nTab |
| ) |
| eRet = UR_UPDATED; |
| } |
| if (eWhat != ScRefUpdate::ABSOLUTE) |
| rRef.CalcRelFromAbs( rPos ); |
| } |
| else |
| { |
| if( eMode == URM_MOVE ) |
| { |
| if ( rRef.Ref1.nCol >= nCol1-nDx |
| && rRef.Ref1.nRow >= nRow1-nDy |
| && rRef.Ref1.nTab >= nTab1-nDz |
| && rRef.Ref2.nCol <= nCol2-nDx |
| && rRef.Ref2.nRow <= nRow2-nDy |
| && rRef.Ref2.nTab <= nTab2-nDz ) |
| { |
| eRet = Move( pDoc, rPos, nDx, nDy, nDz, rRef, sal_False, sal_True ); // immer verschieben |
| } |
| else if ( nDz && r.In( rPos ) ) |
| { |
| rRef.Ref1.SetFlag3D( sal_True ); |
| rRef.Ref2.SetFlag3D( sal_True ); |
| eRet = UR_UPDATED; |
| if (eWhat != ScRefUpdate::ABSOLUTE) |
| rRef.CalcRelFromAbs( rPos ); |
| } |
| else if (eWhat != ScRefUpdate::ABSOLUTE) |
| rRef.CalcRelFromAbs( rPos ); |
| } |
| else if( eMode == URM_COPY && r.In( rPos ) ) |
| eRet = Move( pDoc, rPos, nDx, nDy, nDz, rRef, sal_False, sal_False ); // nur relative |
| // sollte nicht mehr verwendet werden muessen |
| else if (eWhat != ScRefUpdate::ABSOLUTE) |
| rRef.CalcRelFromAbs( rPos ); |
| } |
| return eRet; |
| } |
| |
| |
| ScRefUpdateRes ScRefUpdate::Move( ScDocument* pDoc, const ScAddress& rPos, |
| SCsCOL nDx, SCsROW nDy, SCsTAB nDz, |
| ScComplexRefData& rRef, sal_Bool bWrap, sal_Bool bAbsolute ) |
| { |
| ScRefUpdateRes eRet = UR_NOTHING; |
| |
| SCCOL oldCol1 = rRef.Ref1.nCol; |
| SCROW oldRow1 = rRef.Ref1.nRow; |
| SCTAB oldTab1 = rRef.Ref1.nTab; |
| SCCOL oldCol2 = rRef.Ref2.nCol; |
| SCROW oldRow2 = rRef.Ref2.nRow; |
| SCTAB oldTab2 = rRef.Ref2.nTab; |
| |
| sal_Bool bCut1, bCut2; |
| if ( nDx ) |
| { |
| bCut1 = bCut2 = sal_False; |
| if( bAbsolute || rRef.Ref1.IsColRel() ) |
| { |
| if( bWrap ) |
| lcl_MoveItWrap( rRef.Ref1.nCol, nDx, MAXCOL ); |
| else |
| bCut1 = lcl_MoveItCut( rRef.Ref1.nCol, nDx, MAXCOL ); |
| } |
| if( bAbsolute || rRef.Ref2.IsColRel() ) |
| { |
| if( bWrap ) |
| lcl_MoveItWrap( rRef.Ref2.nCol, nDx, MAXCOL ); |
| else |
| bCut2 = lcl_MoveItCut( rRef.Ref2.nCol, nDx, MAXCOL ); |
| } |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| if ( bCut1 && bCut2 ) |
| { |
| rRef.Ref1.SetColDeleted( sal_True ); |
| rRef.Ref2.SetColDeleted( sal_True ); |
| } |
| } |
| if ( nDy ) |
| { |
| bCut1 = bCut2 = sal_False; |
| if( bAbsolute || rRef.Ref1.IsRowRel() ) |
| { |
| if( bWrap ) |
| lcl_MoveItWrap( rRef.Ref1.nRow, nDy, MAXROW ); |
| else |
| bCut1 = lcl_MoveItCut( rRef.Ref1.nRow, nDy, MAXROW ); |
| } |
| if( bAbsolute || rRef.Ref2.IsRowRel() ) |
| { |
| if( bWrap ) |
| lcl_MoveItWrap( rRef.Ref2.nRow, nDy, MAXROW ); |
| else |
| bCut2 = lcl_MoveItCut( rRef.Ref2.nRow, nDy, MAXROW ); |
| } |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| if ( bCut1 && bCut2 ) |
| { |
| rRef.Ref1.SetRowDeleted( sal_True ); |
| rRef.Ref2.SetRowDeleted( sal_True ); |
| } |
| } |
| if ( nDz ) |
| { |
| bCut1 = bCut2 = sal_False; |
| SCsTAB nMaxTab = (SCsTAB) pDoc->GetTableCount() - 1; |
| if( bAbsolute || rRef.Ref1.IsTabRel() ) |
| { |
| if( bWrap ) |
| lcl_MoveItWrap( rRef.Ref1.nTab, nDz, static_cast<SCTAB>(nMaxTab) ); |
| else |
| bCut1 = lcl_MoveItCut( rRef.Ref1.nTab, nDz, static_cast<SCTAB>(nMaxTab) ); |
| rRef.Ref1.SetFlag3D( rPos.Tab() != rRef.Ref1.nTab ); |
| } |
| if( bAbsolute || rRef.Ref2.IsTabRel() ) |
| { |
| if( bWrap ) |
| lcl_MoveItWrap( rRef.Ref2.nTab, nDz, static_cast<SCTAB>(nMaxTab) ); |
| else |
| bCut2 = lcl_MoveItCut( rRef.Ref2.nTab, nDz, static_cast<SCTAB>(nMaxTab) ); |
| rRef.Ref2.SetFlag3D( rPos.Tab() != rRef.Ref2.nTab ); |
| } |
| if ( bCut1 || bCut2 ) |
| eRet = UR_UPDATED; |
| if ( bCut1 && bCut2 ) |
| { |
| rRef.Ref1.SetTabDeleted( sal_True ); |
| rRef.Ref2.SetTabDeleted( sal_True ); |
| } |
| } |
| |
| if ( eRet == UR_NOTHING ) |
| { |
| if (oldCol1 != rRef.Ref1.nCol |
| || oldRow1 != rRef.Ref1.nRow |
| || oldTab1 != rRef.Ref1.nTab |
| || oldCol2 != rRef.Ref2.nCol |
| || oldRow2 != rRef.Ref2.nRow |
| || oldTab2 != rRef.Ref2.nTab |
| ) |
| eRet = UR_UPDATED; |
| } |
| if ( bWrap && eRet != UR_NOTHING ) |
| rRef.PutInOrder(); |
| rRef.CalcRelFromAbs( rPos ); |
| return eRet; |
| } |
| |
| void ScRefUpdate::MoveRelWrap( ScDocument* pDoc, const ScAddress& rPos, |
| SCCOL nMaxCol, SCROW nMaxRow, ScComplexRefData& rRef ) |
| { |
| if( rRef.Ref1.IsColRel() ) |
| { |
| rRef.Ref1.nCol = rRef.Ref1.nRelCol + rPos.Col(); |
| lcl_MoveItWrap( rRef.Ref1.nCol, static_cast<SCsCOL>(0), nMaxCol ); |
| } |
| if( rRef.Ref2.IsColRel() ) |
| { |
| rRef.Ref2.nCol = rRef.Ref2.nRelCol + rPos.Col(); |
| lcl_MoveItWrap( rRef.Ref2.nCol, static_cast<SCsCOL>(0), nMaxCol ); |
| } |
| if( rRef.Ref1.IsRowRel() ) |
| { |
| rRef.Ref1.nRow = rRef.Ref1.nRelRow + rPos.Row(); |
| lcl_MoveItWrap( rRef.Ref1.nRow, static_cast<SCsROW>(0), nMaxRow ); |
| } |
| if( rRef.Ref2.IsRowRel() ) |
| { |
| rRef.Ref2.nRow = rRef.Ref2.nRelRow + rPos.Row(); |
| lcl_MoveItWrap( rRef.Ref2.nRow, static_cast<SCsROW>(0), nMaxRow ); |
| } |
| SCsTAB nMaxTab = (SCsTAB) pDoc->GetTableCount() - 1; |
| if( rRef.Ref1.IsTabRel() ) |
| { |
| rRef.Ref1.nTab = rRef.Ref1.nRelTab + rPos.Tab(); |
| lcl_MoveItWrap( rRef.Ref1.nTab, static_cast<SCsTAB>(0), static_cast<SCTAB>(nMaxTab) ); |
| } |
| if( rRef.Ref2.IsTabRel() ) |
| { |
| rRef.Ref2.nTab = rRef.Ref2.nRelTab + rPos.Tab(); |
| lcl_MoveItWrap( rRef.Ref2.nTab, static_cast<SCsTAB>(0), static_cast<SCTAB>(nMaxTab) ); |
| } |
| rRef.PutInOrder(); |
| rRef.CalcRelFromAbs( rPos ); |
| } |
| |
| //------------------------------------------------------------------ |
| |
| void ScRefUpdate::DoTranspose( SCsCOL& rCol, SCsROW& rRow, SCsTAB& rTab, |
| ScDocument* pDoc, const ScRange& rSource, const ScAddress& rDest ) |
| { |
| SCsTAB nDz = ((SCsTAB)rDest.Tab())-(SCsTAB)rSource.aStart.Tab(); |
| if (nDz) |
| { |
| SCsTAB nNewTab = rTab+nDz; |
| SCsTAB nCount = pDoc->GetTableCount(); |
| while (nNewTab<0) nNewTab = sal::static_int_cast<SCsTAB>( nNewTab + nCount ); |
| while (nNewTab>=nCount) nNewTab = sal::static_int_cast<SCsTAB>( nNewTab - nCount ); |
| rTab = nNewTab; |
| } |
| DBG_ASSERT( rCol>=rSource.aStart.Col() && rRow>=rSource.aStart.Row(), |
| "UpdateTranspose: Pos. falsch" ); |
| |
| SCsCOL nRelX = rCol - (SCsCOL)rSource.aStart.Col(); |
| SCsROW nRelY = rRow - (SCsROW)rSource.aStart.Row(); |
| |
| rCol = static_cast<SCsCOL>(static_cast<SCsCOLROW>(rDest.Col()) + |
| static_cast<SCsCOLROW>(nRelY)); |
| rRow = static_cast<SCsROW>(static_cast<SCsCOLROW>(rDest.Row()) + |
| static_cast<SCsCOLROW>(nRelX)); |
| } |
| |
| |
| ScRefUpdateRes ScRefUpdate::UpdateTranspose( ScDocument* pDoc, |
| const ScRange& rSource, const ScAddress& rDest, |
| ScComplexRefData& rRef ) |
| { |
| ScRefUpdateRes eRet = UR_NOTHING; |
| if ( rRef.Ref1.nCol >= rSource.aStart.Col() && rRef.Ref2.nCol <= rSource.aEnd.Col() && |
| rRef.Ref1.nRow >= rSource.aStart.Row() && rRef.Ref2.nRow <= rSource.aEnd.Row() && |
| rRef.Ref1.nTab >= rSource.aStart.Tab() && rRef.Ref2.nTab <= rSource.aEnd.Tab() ) |
| { |
| DoTranspose( rRef.Ref1.nCol, rRef.Ref1.nRow, rRef.Ref1.nTab, pDoc, rSource, rDest ); |
| DoTranspose( rRef.Ref2.nCol, rRef.Ref2.nRow, rRef.Ref2.nTab, pDoc, rSource, rDest ); |
| eRet = UR_UPDATED; |
| } |
| return eRet; |
| } |
| |
| //------------------------------------------------------------------ |
| |
| // UpdateGrow - erweitert Referenzen, die genau auf den Bereich zeigen |
| // kommt ohne Dokument aus |
| |
| |
| ScRefUpdateRes ScRefUpdate::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY, |
| ScComplexRefData& rRef ) |
| { |
| ScRefUpdateRes eRet = UR_NOTHING; |
| |
| // in Y-Richtung darf die Ref auch eine Zeile weiter unten anfangen, |
| // falls ein Bereich Spaltenkoepfe enthaelt |
| |
| sal_Bool bUpdateX = ( nGrowX && |
| rRef.Ref1.nCol == rArea.aStart.Col() && rRef.Ref2.nCol == rArea.aEnd.Col() && |
| rRef.Ref1.nRow >= rArea.aStart.Row() && rRef.Ref2.nRow <= rArea.aEnd.Row() && |
| rRef.Ref1.nTab >= rArea.aStart.Tab() && rRef.Ref2.nTab <= rArea.aEnd.Tab() ); |
| sal_Bool bUpdateY = ( nGrowY && |
| rRef.Ref1.nCol >= rArea.aStart.Col() && rRef.Ref2.nCol <= rArea.aEnd.Col() && |
| ( rRef.Ref1.nRow == rArea.aStart.Row() || rRef.Ref1.nRow == rArea.aStart.Row()+1 ) && |
| rRef.Ref2.nRow == rArea.aEnd.Row() && |
| rRef.Ref1.nTab >= rArea.aStart.Tab() && rRef.Ref2.nTab <= rArea.aEnd.Tab() ); |
| |
| if ( bUpdateX ) |
| { |
| rRef.Ref2.nCol = sal::static_int_cast<SCsCOL>( rRef.Ref2.nCol + nGrowX ); |
| eRet = UR_UPDATED; |
| } |
| if ( bUpdateY ) |
| { |
| rRef.Ref2.nRow = sal::static_int_cast<SCsROW>( rRef.Ref2.nRow + nGrowY ); |
| eRet = UR_UPDATED; |
| } |
| |
| return eRet; |
| } |
| |
| |
