Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "refupdat.hxx"
21 : #include "document.hxx"
22 : #include "compiler.hxx"
23 : #include "bigrange.hxx"
24 : #include "chgtrack.hxx"
25 :
26 : template< typename R, typename S, typename U >
27 6572 : static bool lcl_MoveStart( R& rRef, U nStart, S nDelta, U nMask )
28 : {
29 6572 : bool bCut = false;
30 6572 : if ( rRef >= nStart )
31 6272 : rRef = sal::static_int_cast<R>( rRef + nDelta );
32 300 : else if ( nDelta < 0 && rRef >= nStart + nDelta )
33 30 : rRef = nStart + nDelta; //! begrenzen ???
34 6572 : if ( rRef < 0 )
35 : {
36 160 : rRef = 0;
37 160 : bCut = true;
38 : }
39 6412 : else if ( rRef > nMask )
40 : {
41 14 : rRef = nMask;
42 14 : bCut = true;
43 : }
44 6572 : return bCut;
45 : }
46 :
47 : template< typename R, typename S, typename U >
48 6572 : static bool lcl_MoveEnd( R& rRef, U nStart, S nDelta, U nMask )
49 : {
50 6572 : bool bCut = false;
51 6572 : if ( rRef >= nStart )
52 6354 : rRef = sal::static_int_cast<R>( rRef + nDelta );
53 218 : else if ( nDelta < 0 && rRef >= nStart + nDelta )
54 34 : rRef = nStart + nDelta - 1; //! begrenzen ???
55 6572 : if ( rRef < 0 )
56 : {
57 162 : rRef = 0;
58 162 : bCut = true;
59 : }
60 6410 : else if ( rRef > nMask )
61 : {
62 26 : rRef = nMask;
63 26 : bCut = true;
64 : }
65 6572 : return bCut;
66 : }
67 :
68 : template< typename R, typename S, typename U >
69 16 : static bool lcl_MoveReorder( R& rRef, U nStart, U nEnd, S nDelta )
70 : {
71 16 : if ( rRef >= nStart && rRef <= nEnd )
72 : {
73 8 : rRef = sal::static_int_cast<R>( rRef + nDelta );
74 8 : return true;
75 : }
76 :
77 8 : if ( nDelta > 0 ) // nach hinten schieben
78 : {
79 0 : if ( rRef >= nStart && rRef <= nEnd + nDelta )
80 : {
81 0 : if ( rRef <= nEnd )
82 0 : rRef = sal::static_int_cast<R>( rRef + nDelta ); // in the moved range
83 : else
84 0 : rRef -= nEnd - nStart + 1; // nachruecken
85 0 : return true;
86 : }
87 : }
88 : else // nach vorne schieben
89 : {
90 8 : if ( rRef >= nStart + nDelta && rRef <= nEnd )
91 : {
92 8 : if ( rRef >= nStart )
93 0 : rRef = sal::static_int_cast<R>( rRef + nDelta ); // in the moved range
94 : else
95 8 : rRef += nEnd - nStart + 1; // nachruecken
96 8 : return true;
97 : }
98 : }
99 :
100 0 : return false;
101 : }
102 :
103 : template< typename R, typename S, typename U >
104 28 : static bool lcl_MoveItCut( R& rRef, S nDelta, U nMask )
105 : {
106 28 : bool bCut = false;
107 28 : rRef = sal::static_int_cast<R>( rRef + nDelta );
108 28 : if ( rRef < 0 )
109 : {
110 0 : rRef = 0;
111 0 : bCut = true;
112 : }
113 28 : else if ( rRef > nMask )
114 : {
115 0 : rRef = nMask;
116 0 : bCut = true;
117 : }
118 28 : return bCut;
119 : }
120 :
121 : template< typename R, typename S, typename U >
122 2888 : static void lcl_MoveItWrap( R& rRef, S nDelta, U nMask )
123 : {
124 2888 : rRef = sal::static_int_cast<R>( rRef + nDelta );
125 2888 : if ( rRef < 0 )
126 0 : rRef += nMask+1;
127 2888 : else if ( rRef > nMask )
128 0 : rRef -= nMask+1;
129 2888 : }
130 :
131 : template< typename R, typename S, typename U >
132 262 : bool IsExpand( R n1, R n2, U nStart, S nD )
133 : { //! vor normalem Move...
134 : return
135 : nD > 0 // Insert
136 : && n1 < n2 // mindestens zwei Cols/Rows/Tabs in Ref
137 : && (
138 : (nStart <= n1 && n1 < nStart + nD) // n1 innerhalb des Insert
139 : || (n2 + 1 == nStart) // n2 direkt vor Insert
140 262 : ); // n1 < nStart <= n2 wird sowieso expanded!
141 : }
142 :
143 : template< typename R, typename S, typename U >
144 30 : void Expand( R& n1, R& n2, U nStart, S nD )
145 : { //! nach normalem Move..., nur wenn IsExpand vorher true war!
146 : //! erst das Ende
147 30 : if ( n2 + 1 == nStart )
148 : { // am Ende
149 12 : n2 = sal::static_int_cast<R>( n2 + nD );
150 42 : return;
151 : }
152 : // am Anfang
153 18 : n1 = sal::static_int_cast<R>( n1 - nD );
154 : }
155 :
156 0 : static bool lcl_IsWrapBig( sal_Int32 nRef, sal_Int32 nDelta )
157 : {
158 0 : if ( nRef > 0 && nDelta > 0 )
159 0 : return nRef + nDelta <= 0;
160 0 : else if ( nRef < 0 && nDelta < 0 )
161 0 : return nRef + nDelta >= 0;
162 0 : return false;
163 : }
164 :
165 576 : static bool lcl_MoveBig( sal_Int32& rRef, sal_Int32 nStart, sal_Int32 nDelta )
166 : {
167 576 : bool bCut = false;
168 576 : if ( rRef >= nStart )
169 : {
170 0 : if ( nDelta > 0 )
171 0 : bCut = lcl_IsWrapBig( rRef, nDelta );
172 0 : if ( bCut )
173 0 : rRef = nInt32Max;
174 : else
175 0 : rRef += nDelta;
176 : }
177 576 : return bCut;
178 : }
179 :
180 0 : static bool lcl_MoveItCutBig( sal_Int32& rRef, sal_Int32 nDelta )
181 : {
182 0 : bool bCut = lcl_IsWrapBig( rRef, nDelta );
183 0 : rRef += nDelta;
184 0 : return bCut;
185 : }
186 :
187 8140 : ScRefUpdateRes ScRefUpdate::Update( ScDocument* pDoc, UpdateRefMode eUpdateRefMode,
188 : SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
189 : SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
190 : SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
191 : SCCOL& theCol1, SCROW& theRow1, SCTAB& theTab1,
192 : SCCOL& theCol2, SCROW& theRow2, SCTAB& theTab2 )
193 : {
194 8140 : ScRefUpdateRes eRet = UR_NOTHING;
195 :
196 8140 : SCCOL oldCol1 = theCol1;
197 8140 : SCROW oldRow1 = theRow1;
198 8140 : SCTAB oldTab1 = theTab1;
199 8140 : SCCOL oldCol2 = theCol2;
200 8140 : SCROW oldRow2 = theRow2;
201 8140 : SCTAB oldTab2 = theTab2;
202 :
203 : bool bCut1, bCut2;
204 :
205 8140 : if (eUpdateRefMode == URM_INSDEL)
206 : {
207 6892 : bool bExpand = pDoc->IsExpandRefs();
208 7648 : if ( nDx && (theRow1 >= nRow1) && (theRow2 <= nRow2) &&
209 1512 : (theTab1 >= nTab1) && (theTab2 <= nTab2) )
210 : {
211 756 : bool bExp = (bExpand && IsExpand( theCol1, theCol2, nCol1, nDx ));
212 756 : bCut1 = lcl_MoveStart( theCol1, nCol1, nDx, MAXCOL );
213 756 : bCut2 = lcl_MoveEnd( theCol2, nCol1, nDx, MAXCOL );
214 756 : if ( theCol2 < theCol1 )
215 : {
216 0 : eRet = UR_INVALID;
217 0 : theCol2 = theCol1;
218 : }
219 756 : else if ( bCut1 || bCut2 )
220 20 : eRet = UR_UPDATED;
221 756 : if ( bExp )
222 : {
223 12 : Expand( theCol1, theCol2, nCol1, nDx );
224 12 : eRet = UR_UPDATED;
225 : }
226 : }
227 7144 : if ( nDy && (theCol1 >= nCol1) && (theCol2 <= nCol2) &&
228 504 : (theTab1 >= nTab1) && (theTab2 <= nTab2) )
229 : {
230 252 : bool bExp = (bExpand && IsExpand( theRow1, theRow2, nRow1, nDy ));
231 252 : bCut1 = lcl_MoveStart( theRow1, nRow1, nDy, MAXROW );
232 252 : bCut2 = lcl_MoveEnd( theRow2, nRow1, nDy, MAXROW );
233 252 : if ( theRow2 < theRow1 )
234 : {
235 0 : eRet = UR_INVALID;
236 0 : theRow2 = theRow1;
237 : }
238 252 : else if ( bCut1 || bCut2 )
239 6 : eRet = UR_UPDATED;
240 252 : if ( bExp )
241 : {
242 18 : Expand( theRow1, theRow2, nRow1, nDy );
243 18 : eRet = UR_UPDATED;
244 : }
245 : }
246 12456 : if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) &&
247 11128 : (theRow1 >= nRow1) && (theRow2 <= nRow2) )
248 : {
249 5564 : SCsTAB nMaxTab = pDoc->GetTableCount() - 1;
250 5564 : nMaxTab = sal::static_int_cast<SCsTAB>(nMaxTab + nDz); // adjust to new count
251 5564 : bool bExp = (bExpand && IsExpand( theTab1, theTab2, nTab1, nDz ));
252 5564 : bCut1 = lcl_MoveStart( theTab1, nTab1, nDz, static_cast<SCTAB>(nMaxTab) );
253 5564 : bCut2 = lcl_MoveEnd( theTab2, nTab1, nDz, static_cast<SCTAB>(nMaxTab) );
254 5564 : if ( theTab2 < theTab1 )
255 : {
256 4 : eRet = UR_INVALID;
257 4 : theTab2 = theTab1;
258 : }
259 5560 : else if ( bCut1 || bCut2 )
260 162 : eRet = UR_UPDATED;
261 5564 : if ( bExp )
262 : {
263 0 : Expand( theTab1, theTab2, nTab1, nDz );
264 0 : eRet = UR_UPDATED;
265 : }
266 : }
267 : }
268 1248 : else if (eUpdateRefMode == URM_MOVE)
269 : {
270 2402 : if ((theCol1 >= nCol1-nDx) && (theRow1 >= nRow1-nDy) && (theTab1 >= nTab1-nDz) &&
271 2336 : (theCol2 <= nCol2-nDx) && (theRow2 <= nRow2-nDy) && (theTab2 <= nTab2-nDz))
272 : {
273 1166 : if ( nDx )
274 : {
275 6 : bCut1 = lcl_MoveItCut( theCol1, nDx, MAXCOL );
276 6 : bCut2 = lcl_MoveItCut( theCol2, nDx, MAXCOL );
277 6 : if ( bCut1 || bCut2 )
278 0 : eRet = UR_UPDATED;
279 : }
280 1166 : if ( nDy )
281 : {
282 6 : bCut1 = lcl_MoveItCut( theRow1, nDy, MAXROW );
283 6 : bCut2 = lcl_MoveItCut( theRow2, nDy, MAXROW );
284 6 : if ( bCut1 || bCut2 )
285 0 : eRet = UR_UPDATED;
286 : }
287 1166 : if ( nDz )
288 : {
289 2 : SCsTAB nMaxTab = (SCsTAB) pDoc->GetTableCount() - 1;
290 2 : bCut1 = lcl_MoveItCut( theTab1, nDz, static_cast<SCTAB>(nMaxTab) );
291 2 : bCut2 = lcl_MoveItCut( theTab2, nDz, static_cast<SCTAB>(nMaxTab) );
292 2 : if ( bCut1 || bCut2 )
293 0 : eRet = UR_UPDATED;
294 : }
295 : }
296 : }
297 16 : else if (eUpdateRefMode == URM_REORDER)
298 : {
299 : // bisher nur fuer nDz (MoveTab)
300 : OSL_ENSURE ( !nDx && !nDy, "URM_REORDER for x and y not yet implemented" );
301 :
302 16 : if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) &&
303 16 : (theRow1 >= nRow1) && (theRow2 <= nRow2) )
304 : {
305 8 : bCut1 = lcl_MoveReorder( theTab1, nTab1, nTab2, nDz );
306 8 : bCut2 = lcl_MoveReorder( theTab2, nTab1, nTab2, nDz );
307 8 : if ( bCut1 || bCut2 )
308 8 : eRet = UR_UPDATED;
309 : }
310 : }
311 :
312 8140 : if ( eRet == UR_NOTHING )
313 : {
314 7916 : if (oldCol1 != theCol1
315 7290 : || oldRow1 != theRow1
316 7214 : || oldTab1 != theTab1
317 1820 : || oldCol2 != theCol2
318 1784 : || oldRow2 != theRow2
319 1724 : || oldTab2 != theTab2
320 : )
321 6192 : eRet = UR_UPDATED;
322 : }
323 8140 : return eRet;
324 : }
325 :
326 : // simples UpdateReference fuer ScBigRange (ScChangeAction/ScChangeTrack)
327 : // Referenzen koennen auch ausserhalb des Dokuments liegen!
328 : // Ganze Spalten/Zeilen (nInt32Min..nInt32Max) bleiben immer solche!
329 288 : ScRefUpdateRes ScRefUpdate::Update( UpdateRefMode eUpdateRefMode,
330 : const ScBigRange& rWhere, sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz,
331 : ScBigRange& rWhat )
332 : {
333 288 : ScRefUpdateRes eRet = UR_NOTHING;
334 288 : const ScBigRange aOldRange( rWhat );
335 :
336 : sal_Int32 nCol1, nRow1, nTab1, nCol2, nRow2, nTab2;
337 : sal_Int32 theCol1, theRow1, theTab1, theCol2, theRow2, theTab2;
338 288 : rWhere.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
339 288 : rWhat.GetVars( theCol1, theRow1, theTab1, theCol2, theRow2, theTab2 );
340 :
341 : bool bCut1, bCut2;
342 :
343 288 : if (eUpdateRefMode == URM_INSDEL)
344 : {
345 288 : if ( nDx && (theRow1 >= nRow1) && (theRow2 <= nRow2) &&
346 0 : (theTab1 >= nTab1) && (theTab2 <= nTab2) &&
347 0 : !(theCol1 == nInt32Min && theCol2 == nInt32Max) )
348 : {
349 0 : bCut1 = lcl_MoveBig( theCol1, nCol1, nDx );
350 0 : bCut2 = lcl_MoveBig( theCol2, nCol1, nDx );
351 0 : if ( bCut1 || bCut2 )
352 0 : eRet = UR_UPDATED;
353 0 : rWhat.aStart.SetCol( theCol1 );
354 0 : rWhat.aEnd.SetCol( theCol2 );
355 : }
356 576 : if ( nDy && (theCol1 >= nCol1) && (theCol2 <= nCol2) &&
357 864 : (theTab1 >= nTab1) && (theTab2 <= nTab2) &&
358 288 : !(theRow1 == nInt32Min && theRow2 == nInt32Max) )
359 : {
360 288 : bCut1 = lcl_MoveBig( theRow1, nRow1, nDy );
361 288 : bCut2 = lcl_MoveBig( theRow2, nRow1, nDy );
362 288 : if ( bCut1 || bCut2 )
363 0 : eRet = UR_UPDATED;
364 288 : rWhat.aStart.SetRow( theRow1 );
365 288 : rWhat.aEnd.SetRow( theRow2 );
366 : }
367 288 : if ( nDz && (theCol1 >= nCol1) && (theCol2 <= nCol2) &&
368 0 : (theRow1 >= nRow1) && (theRow2 <= nRow2) &&
369 0 : !(theTab1 == nInt32Min && theTab2 == nInt32Max) )
370 : {
371 0 : bCut1 = lcl_MoveBig( theTab1, nTab1, nDz );
372 0 : bCut2 = lcl_MoveBig( theTab2, nTab1, nDz );
373 0 : if ( bCut1 || bCut2 )
374 0 : eRet = UR_UPDATED;
375 0 : rWhat.aStart.SetTab( theTab1 );
376 0 : rWhat.aEnd.SetTab( theTab2 );
377 : }
378 : }
379 0 : else if (eUpdateRefMode == URM_MOVE)
380 : {
381 0 : if ( rWhere.In( rWhat ) )
382 : {
383 0 : if ( nDx && !(theCol1 == nInt32Min && theCol2 == nInt32Max) )
384 : {
385 0 : bCut1 = lcl_MoveItCutBig( theCol1, nDx );
386 0 : bCut2 = lcl_MoveItCutBig( theCol2, nDx );
387 0 : if ( bCut1 || bCut2 )
388 0 : eRet = UR_UPDATED;
389 0 : rWhat.aStart.SetCol( theCol1 );
390 0 : rWhat.aEnd.SetCol( theCol2 );
391 : }
392 0 : if ( nDy && !(theRow1 == nInt32Min && theRow2 == nInt32Max) )
393 : {
394 0 : bCut1 = lcl_MoveItCutBig( theRow1, nDy );
395 0 : bCut2 = lcl_MoveItCutBig( theRow2, nDy );
396 0 : if ( bCut1 || bCut2 )
397 0 : eRet = UR_UPDATED;
398 0 : rWhat.aStart.SetRow( theRow1 );
399 0 : rWhat.aEnd.SetRow( theRow2 );
400 : }
401 0 : if ( nDz && !(theTab1 == nInt32Min && theTab2 == nInt32Max) )
402 : {
403 0 : bCut1 = lcl_MoveItCutBig( theTab1, nDz );
404 0 : bCut2 = lcl_MoveItCutBig( theTab2, nDz );
405 0 : if ( bCut1 || bCut2 )
406 0 : eRet = UR_UPDATED;
407 0 : rWhat.aStart.SetTab( theTab1 );
408 0 : rWhat.aEnd.SetTab( theTab2 );
409 : }
410 : }
411 : }
412 :
413 288 : if ( eRet == UR_NOTHING && rWhat != aOldRange )
414 0 : eRet = UR_UPDATED;
415 :
416 288 : return eRet;
417 : }
418 :
419 1420 : void ScRefUpdate::MoveRelWrap( ScDocument* pDoc, const ScAddress& rPos,
420 : SCCOL nMaxCol, SCROW nMaxRow, ScComplexRefData& rRef )
421 : {
422 1420 : ScRange aAbsRange = rRef.toAbs(rPos);
423 1420 : if( rRef.Ref1.IsColRel() )
424 : {
425 360 : SCCOL nCol = aAbsRange.aStart.Col();
426 360 : lcl_MoveItWrap(nCol, static_cast<SCsCOL>(0), nMaxCol);
427 360 : aAbsRange.aStart.SetCol(nCol);
428 : }
429 1420 : if( rRef.Ref2.IsColRel() )
430 : {
431 360 : SCCOL nCol = aAbsRange.aEnd.Col();
432 360 : lcl_MoveItWrap(nCol, static_cast<SCsCOL>(0), nMaxCol);
433 360 : aAbsRange.aEnd.SetCol(nCol);
434 : }
435 1420 : if( rRef.Ref1.IsRowRel() )
436 : {
437 360 : SCROW nRow = aAbsRange.aStart.Row();
438 360 : lcl_MoveItWrap(nRow, static_cast<SCsROW>(0), nMaxRow);
439 360 : aAbsRange.aStart.SetRow(nRow);
440 : }
441 1420 : if( rRef.Ref2.IsRowRel() )
442 : {
443 360 : SCROW nRow = aAbsRange.aEnd.Row();
444 360 : lcl_MoveItWrap(nRow, static_cast<SCsROW>(0), nMaxRow);
445 360 : aAbsRange.aEnd.SetRow(nRow);
446 : }
447 1420 : SCsTAB nMaxTab = (SCsTAB) pDoc->GetTableCount() - 1;
448 1420 : if( rRef.Ref1.IsTabRel() )
449 : {
450 724 : SCTAB nTab = aAbsRange.aStart.Tab();
451 724 : lcl_MoveItWrap(nTab, static_cast<SCsTAB>(0), static_cast<SCTAB>(nMaxTab));
452 724 : aAbsRange.aStart.SetTab(nTab);
453 : }
454 1420 : if( rRef.Ref2.IsTabRel() )
455 : {
456 724 : SCTAB nTab = aAbsRange.aEnd.Tab();
457 724 : lcl_MoveItWrap(nTab, static_cast<SCsTAB>(0), static_cast<SCTAB>(nMaxTab));
458 724 : aAbsRange.aEnd.SetTab(nTab);
459 : }
460 :
461 1420 : aAbsRange.PutInOrder();
462 1420 : rRef.SetRange(aAbsRange, rPos);
463 1420 : }
464 :
465 0 : void ScRefUpdate::DoTranspose( SCsCOL& rCol, SCsROW& rRow, SCsTAB& rTab,
466 : ScDocument* pDoc, const ScRange& rSource, const ScAddress& rDest )
467 : {
468 0 : SCsTAB nDz = ((SCsTAB)rDest.Tab())-(SCsTAB)rSource.aStart.Tab();
469 0 : if (nDz)
470 : {
471 0 : SCsTAB nNewTab = rTab+nDz;
472 0 : SCsTAB nCount = pDoc->GetTableCount();
473 0 : while (nNewTab<0) nNewTab = sal::static_int_cast<SCsTAB>( nNewTab + nCount );
474 0 : while (nNewTab>=nCount) nNewTab = sal::static_int_cast<SCsTAB>( nNewTab - nCount );
475 0 : rTab = nNewTab;
476 : }
477 : OSL_ENSURE( rCol>=rSource.aStart.Col() && rRow>=rSource.aStart.Row(),
478 : "UpdateTranspose: Pos. falsch" );
479 :
480 0 : SCsCOL nRelX = rCol - (SCsCOL)rSource.aStart.Col();
481 0 : SCsROW nRelY = rRow - (SCsROW)rSource.aStart.Row();
482 :
483 0 : rCol = static_cast<SCsCOL>(static_cast<SCsCOLROW>(rDest.Col()) +
484 0 : static_cast<SCsCOLROW>(nRelY));
485 0 : rRow = static_cast<SCsROW>(static_cast<SCsCOLROW>(rDest.Row()) +
486 0 : static_cast<SCsCOLROW>(nRelX));
487 0 : }
488 :
489 0 : ScRefUpdateRes ScRefUpdate::UpdateTranspose(
490 : ScDocument* pDoc, const ScRange& rSource, const ScAddress& rDest, ScRange& rRef )
491 : {
492 0 : ScRefUpdateRes eRet = UR_NOTHING;
493 0 : if (rRef.aStart.Col() >= rSource.aStart.Col() && rRef.aEnd.Col() <= rSource.aEnd.Col() &&
494 0 : rRef.aStart.Row() >= rSource.aStart.Row() && rRef.aEnd.Row() <= rSource.aEnd.Row() &&
495 0 : rRef.aStart.Tab() >= rSource.aStart.Tab() && rRef.aEnd.Tab() <= rSource.aEnd.Tab())
496 : {
497 : // Source range contains the reference range.
498 0 : SCCOL nCol1 = rRef.aStart.Col(), nCol2 = rRef.aEnd.Col();
499 0 : SCROW nRow1 = rRef.aStart.Row(), nRow2 = rRef.aEnd.Row();
500 0 : SCTAB nTab1 = rRef.aStart.Tab(), nTab2 = rRef.aEnd.Tab();
501 0 : DoTranspose(nCol1, nRow1, nTab1, pDoc, rSource, rDest);
502 0 : DoTranspose(nCol2, nRow2, nTab2, pDoc, rSource, rDest);
503 0 : rRef.aStart = ScAddress(nCol1, nRow1, nTab1);
504 0 : rRef.aEnd = ScAddress(nCol2, nRow2, nTab2);
505 0 : eRet = UR_UPDATED;
506 : }
507 0 : return eRet;
508 : }
509 :
510 : // UpdateGrow - erweitert Referenzen, die genau auf den Bereich zeigen
511 : // kommt ohne Dokument aus
512 :
513 0 : ScRefUpdateRes ScRefUpdate::UpdateGrow(
514 : const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY, ScRange& rRef )
515 : {
516 0 : ScRefUpdateRes eRet = UR_NOTHING;
517 :
518 : // in Y-Richtung darf die Ref auch eine Zeile weiter unten anfangen,
519 : // falls ein Bereich Spaltenkoepfe enthaelt
520 :
521 0 : bool bUpdateX = ( nGrowX &&
522 0 : rRef.aStart.Col() == rArea.aStart.Col() && rRef.aEnd.Col() == rArea.aEnd.Col() &&
523 0 : rRef.aStart.Row() >= rArea.aStart.Row() && rRef.aEnd.Row() <= rArea.aEnd.Row() &&
524 0 : rRef.aStart.Tab() >= rArea.aStart.Tab() && rRef.aEnd.Tab() <= rArea.aEnd.Tab() );
525 0 : bool bUpdateY = ( nGrowY &&
526 0 : rRef.aStart.Col() >= rArea.aStart.Col() && rRef.aEnd.Col() <= rArea.aEnd.Col() &&
527 0 : (rRef.aStart.Row() == rArea.aStart.Row() || rRef.aStart.Row() == rArea.aStart.Row()+1) &&
528 0 : rRef.aEnd.Row() == rArea.aEnd.Row() &&
529 0 : rRef.aStart.Tab() >= rArea.aStart.Tab() && rRef.aEnd.Tab() <= rArea.aEnd.Tab() );
530 :
531 0 : if ( bUpdateX )
532 : {
533 0 : rRef.aEnd.SetCol(sal::static_int_cast<SCsCOL>(rRef.aEnd.Col() + nGrowX));
534 0 : eRet = UR_UPDATED;
535 : }
536 0 : if ( bUpdateY )
537 : {
538 0 : rRef.aEnd.SetRow(sal::static_int_cast<SCsROW>(rRef.aEnd.Row() + nGrowY));
539 0 : eRet = UR_UPDATED;
540 : }
541 :
542 0 : return eRet;
543 228 : }
544 :
545 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
