xref: /aoo42x/main/sw/source/core/table/swnewtable.cxx (revision fde29386)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 #include <swtable.hxx>
28 #include <tblsel.hxx>
29 #include <tblrwcl.hxx>
30 #include <node.hxx>
31 #include <UndoTable.hxx>
32 #include <pam.hxx>
33 #include <frmfmt.hxx>
34 #include <frmatr.hxx>
35 #include <cellfrm.hxx>
36 #include <fmtfsize.hxx>
37 #include <doc.hxx>
38 #include <IDocumentUndoRedo.hxx>
39 #include <vector>
40 #include <set>
41 #include <list>
42 #include <memory>
43 #include <editeng/boxitem.hxx>
44 #include <editeng/protitem.hxx>
45 #include <swtblfmt.hxx>
46 #include <switerator.hxx>
47 
48 #ifndef DBG_UTIL
49 #define CHECK_TABLE(t)
50 #else
51 #ifdef DEBUG
52 #define CHECK_TABLE(t) (t).CheckConsistency();
53 #else
54 #define CHECK_TABLE(t)
55 #endif
56 #endif
57 
58 // ---------------------------------------------------------------
59 
60 /** SwBoxSelection is a small helperclass (structure) to handle selections
61     of cells (boxes) between table functions
62 
63     It contains an "array" of table boxes, a rectangulare selection of table boxes.
64     To be more specific, it contains a vector of box selections,
65     every box selection (SwSelBoxes) contains the selected boxes inside one row.
66     The member mnMergeWidth contains the width of the selected boxes
67 */
68 
69 class SwBoxSelection
70 {
71 public:
72     std::vector<const SwSelBoxes*> aBoxes;
73     long mnMergeWidth;
SwBoxSelection()74     SwBoxSelection() : mnMergeWidth(0) {}
isEmpty() const75     bool isEmpty() const { return aBoxes.size() == 0; }
insertBoxes(const SwSelBoxes * pNew)76     void insertBoxes( const SwSelBoxes* pNew ){ aBoxes.insert( aBoxes.end(), pNew ); }
77 };
78 
79 /** NewMerge(..) removes the superfluous cells after cell merge
80 
81 SwTable::NewMerge(..) does some cleaning up,
82 it simply deletes the superfluous cells ("cell span")
83 and notifies the Undo about it.
84 The main work has been done by SwTable::PrepareMerge(..) already.
85 
86 @param rBoxes
87 the boxes to remove
88 
89 @param pUndo
90 the undo object to notify, maybe empty
91 
92 @return sal_True for compatibility reasons with OldMerge(..)
93 */
94 
NewMerge(SwDoc * pDoc,const SwSelBoxes & rBoxes,const SwSelBoxes & rMerged,SwTableBox *,SwUndoTblMerge * pUndo)95 sal_Bool SwTable::NewMerge( SwDoc* pDoc, const SwSelBoxes& rBoxes,
96      const SwSelBoxes& rMerged, SwTableBox*, SwUndoTblMerge* pUndo )
97 {
98     if( pUndo )
99 		pUndo->SetSelBoxes( rBoxes );
100 	DeleteSel( pDoc, rBoxes, &rMerged, 0, sal_True, sal_True );
101 
102     CHECK_TABLE( *this )
103     return sal_True;
104 }
105 
106 /** lcl_CheckMinMax helps evaluating (horizontal) min/max of boxes
107 
108 lcl_CheckMinMax(..) compares the left border and the right border
109 of a given cell with the given range and sets it accordingly.
110 
111 @param rMin
112 will be decremented if necessary to the left border of the cell
113 
114 @param rMax
115 will be incremented if necessary to the right border of the cell
116 
117 @param rLine
118 the row (table line) of the interesting box
119 
120 @param nCheck
121 the index of the box in the table box array of the given row
122 
123 @param bSet
124 if bSet is false, rMin and rMax will be manipulated if necessary
125 if bSet is true, rMin and rMax will be set to the left and right border of the box
126 
127 */
128 
lcl_CheckMinMax(long & rMin,long & rMax,const SwTableLine & rLine,sal_uInt16 nCheck,bool bSet)129 void lcl_CheckMinMax( long& rMin, long& rMax, const SwTableLine& rLine, sal_uInt16 nCheck, bool bSet )
130 {
131     ++nCheck;
132     if( rLine.GetTabBoxes().Count() < nCheck )
133     {   // robust
134         ASSERT( false, "Box out of table line" );
135         nCheck = rLine.GetTabBoxes().Count();
136     }
137 
138     long nNew = 0; // will be the right border of the current box
139     long nWidth = 0; // the width of the current box
140     for( sal_uInt16 nCurrBox = 0; nCurrBox < nCheck; ++nCurrBox )
141     {
142         SwTableBox* pBox = rLine.GetTabBoxes()[nCurrBox];
143         ASSERT( pBox, "Missing table box" );
144         nWidth = pBox->GetFrmFmt()->GetFrmSize().GetWidth();
145         nNew += nWidth;
146     }
147     // nNew is the right border of the wished box
148     if( bSet || nNew > rMax )
149         rMax = nNew;
150     nNew -= nWidth; // nNew becomes the left border of the wished box
151     if( bSet || nNew < rMin )
152         rMin = nNew;
153 }
154 
155 /** lcl_Box2LeftBorder(..) delivers the left (logical) border of a table box
156 
157 The left logical border of a table box is the sum of the cell width before this
158 box.
159 
160 @param rBox
161 is the requested table box
162 
163 @return is the left logical border (long, even it cannot be negative)
164 
165 */
166 
lcl_Box2LeftBorder(const SwTableBox & rBox)167 long lcl_Box2LeftBorder( const SwTableBox& rBox )
168 {
169     if( !rBox.GetUpper() )
170         return 0;
171     long nLeft = 0;
172     const SwTableLine &rLine = *rBox.GetUpper();
173     sal_uInt16 nCount = rLine.GetTabBoxes().Count();
174     for( sal_uInt16 nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
175     {
176         SwTableBox* pBox = rLine.GetTabBoxes()[nCurrBox];
177         ASSERT( pBox, "Missing table box" );
178         if( pBox == &rBox )
179             return nLeft;
180         nLeft += pBox->GetFrmFmt()->GetFrmSize().GetWidth();
181     }
182     ASSERT( false, "Box not found in own upper?" );
183     return nLeft;
184 }
185 
186 /** lcl_LeftBorder2Box delivers the box to a given left border
187 
188 It's used to find the master/follow table boxes in previous/next rows.
189 Don't call this function to check if there is such a box,
190 call it if you know there has to be such box.
191 
192 @param nLeft
193 the left border (logical x-value) of the demanded box
194 
195 @param rLine
196 the row (table line) to be scanned
197 
198 @return a pointer to the table box inside the given row with the wished left border
199 
200 */
201 
lcl_LeftBorder2Box(long nLeft,const SwTableLine * pLine)202 SwTableBox* lcl_LeftBorder2Box( long nLeft, const SwTableLine* pLine )
203 {
204     if( !pLine )
205         return 0;
206     long nCurrLeft = 0;
207     sal_uInt16 nCount = pLine->GetTabBoxes().Count();
208     for( sal_uInt16 nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
209     {
210         SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
211         ASSERT( pBox, "Missing table box" );
212         if( nCurrLeft >= nLeft && pBox->GetFrmFmt()->GetFrmSize().GetWidth() )
213         {
214             ASSERT( nCurrLeft == nLeft, "Wrong box found" );
215             return pBox;
216         }
217         nCurrLeft += pBox->GetFrmFmt()->GetFrmSize().GetWidth();
218     }
219     ASSERT( false, "Didn't find wished box" );
220     return 0;
221 }
222 
223 /** lcl_ChangeRowSpan corrects row span after insertion/deletion of rows
224 
225 lcl_ChangeRowSpan(..) has to be called after an insertion or deletion of rows
226 to adjust the row spans of previous rows accordingly.
227 If rows are deleted, the previous rows with row spans into the deleted area
228 have to be decremented by the number of _overlapped_ inserted rows.
229 If rows are inserted, the previous rows with row span into the inserted area
230 have to be incremented by the number of inserted rows.
231 For those row spans which ends exactly above the inserted area it has to be
232 decided by the parameter bSingle if they have to be expanded or not.
233 
234 @param rTable
235 the table to manipulate (has to be a new model table)
236 
237 @param nDiff
238 the number of rows which has been inserted (nDiff > 0) or deleted (nDiff < 0)
239 
240 @param nRowIdx
241 the index of the first row which has to be checked
242 
243 @param bSingle
244 true if the new inserted row should not extend row spans which ends in the row above
245 this is for rows inserted by UI "insert row"
246 false if all cells of an inserted row has to be overlapped by the previous row
247 this is for rows inserted by "split row"
248 false is also needed for deleted rows
249 
250 */
251 
lcl_ChangeRowSpan(const SwTable & rTable,const long nDiff,sal_uInt16 nRowIdx,const bool bSingle)252 void lcl_ChangeRowSpan( const SwTable& rTable, const long nDiff,
253                         sal_uInt16 nRowIdx, const bool bSingle )
254 {
255     if( !nDiff || nRowIdx >= rTable.GetTabLines().Count() )
256         return;
257     ASSERT( !bSingle || nDiff > 0, "Don't set bSingle when deleting lines!" );
258     bool bGoOn;
259     // nDistance is the distance between the current row and the critical row,
260     // e.g. the deleted rows or the inserted rows.
261     // If the row span is lower than the distance there is nothing to do
262     // because the row span ends before the critical area.
263     // When the inserted rows should not be overlapped by row spans which ends
264     // exactly in the row above, the trick is to start with a distance of 1.
265     long nDistance = bSingle ? 1 : 0;
266     do
267     {
268         bGoOn = false; // will be set to true if we found a non-master cell
269         // which has to be manipulated => we have to check the previous row, too.
270         const SwTableLine* pLine = rTable.GetTabLines()[ nRowIdx ];
271         sal_uInt16 nBoxCount = pLine->GetTabBoxes().Count();
272         for( sal_uInt16 nCurrBox = 0; nCurrBox < nBoxCount; ++nCurrBox )
273         {
274             long nRowSpan = pLine->GetTabBoxes()[nCurrBox]->getRowSpan();
275             long nAbsSpan = nRowSpan > 0 ? nRowSpan : -nRowSpan;
276             // Check if the last overlapped cell is above or below
277             // the critical area
278             if( nAbsSpan > nDistance )
279             {
280                 if( nDiff > 0 )
281                 {
282                     if( nRowSpan > 0 )
283                         nRowSpan += nDiff; // increment row span of master cell
284                     else
285                     {
286                         nRowSpan -= nDiff; // increment row span of non-master cell
287                         bGoOn = true;
288                     }
289                 }
290                 else
291                 {
292                     if( nRowSpan > 0 )
293                     {   // A master cell
294                          // end of row span behind the deleted area...
295                         if( nRowSpan - nDistance > -nDiff )
296                             nRowSpan += nDiff;
297                         else // ...or inside the deleted area
298                             nRowSpan = nDistance + 1;
299                     }
300                     else
301                     {   // Same for a non-master cell
302                         if( nRowSpan + nDistance < nDiff )
303                             nRowSpan -= nDiff;
304                         else
305                             nRowSpan = -nDistance - 1;
306                         bGoOn = true; // We have to continue
307                     }
308                 }
309                 pLine->GetTabBoxes()[ nCurrBox ]->setRowSpan( nRowSpan );
310             }
311         }
312         ++nDistance;
313         if( nRowIdx )
314             --nRowIdx;
315         else
316             bGoOn = false; // robust
317     } while( bGoOn );
318 }
319 
320 /** CollectBoxSelection(..) create a rectangular selection based on the given SwPaM
321     and prepares the selected cells for merging
322 */
323 
CollectBoxSelection(const SwPaM & rPam) const324 SwBoxSelection* SwTable::CollectBoxSelection( const SwPaM& rPam ) const
325 {
326     ASSERT( bNewModel, "Don't call me for old tables" );
327     if( !aLines.Count() )
328         return 0;
329     const SwNode* pStartNd = rPam.Start()->nNode.GetNode().FindTableBoxStartNode();
330     const SwNode* pEndNd = rPam.End()->nNode.GetNode().FindTableBoxStartNode();
331     if( !pStartNd || !pEndNd || pStartNd == pEndNd )
332         return 0;
333 
334     sal_uInt16 nLines = aLines.Count();
335     sal_uInt16 nTop = 0, nBottom = 0;
336     long nMin = 0, nMax = 0;
337     int nFound = 0;
338     for( sal_uInt16 nRow = 0; nFound < 2 && nRow < nLines; ++nRow )
339     {
340         SwTableLine* pLine = aLines[nRow];
341         ASSERT( pLine, "Missing table line" );
342         sal_uInt16 nCols = pLine->GetTabBoxes().Count();
343         for( sal_uInt16 nCol = 0; nCol < nCols; ++nCol )
344         {
345             SwTableBox* pBox = pLine->GetTabBoxes()[nCol];
346             ASSERT( pBox, "Missing table box" );
347             if( nFound )
348             {
349                 if( pBox->GetSttNd() == pEndNd )
350                 {
351                     nBottom = nRow;
352                     lcl_CheckMinMax( nMin, nMax, *pLine, nCol, false );
353                     ++nFound;
354                     break;
355                 }
356             }
357             else if( pBox->GetSttNd() == pStartNd )
358             {
359                 nTop = nRow;
360                 lcl_CheckMinMax( nMin, nMax, *pLine, nCol, true );
361                 ++nFound;
362             }
363         }
364     }
365     if( nFound < 2 )
366         return 0;
367 
368     bool bOkay = true;
369     long nMid = ( nMin + nMax ) / 2;
370 
371     SwBoxSelection* pRet = new SwBoxSelection();
372     std::list< std::pair< SwTableBox*, long > > aNewWidthList;
373     sal_uInt16 nCheckBottom = nBottom;
374     long nLeftSpan = 0;
375     long nRightSpan = 0;
376     long nLeftSpanCnt = 0;
377     long nRightSpanCnt = 0;
378     for( sal_uInt16 nRow = nTop; nRow <= nBottom && bOkay; ++nRow )
379     {
380         SwTableLine* pLine = aLines[nRow];
381         ASSERT( pLine, "Missing table line" );
382         SwSelBoxes *pBoxes = new SwSelBoxes();
383         long nLeft = 0;
384         long nRight = 0;
385         long nRowSpan = 1;
386         sal_uInt16 nCount = pLine->GetTabBoxes().Count();
387         for( sal_uInt16 nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
388         {
389             SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
390             ASSERT( pBox, "Missing table box" );
391             nLeft = nRight;
392             nRight += pBox->GetFrmFmt()->GetFrmSize().GetWidth();
393             nRowSpan = pBox->getRowSpan();
394             if( nRight <= nMin )
395             {
396                 if( nRight == nMin && nLeftSpanCnt )
397                     bOkay = false;
398                 continue;
399             }
400             SwTableBox* pInnerBox = 0;
401             SwTableBox* pLeftBox = 0;
402             SwTableBox* pRightBox = 0;
403             long nDiff = 0;
404             long nDiff2 = 0;
405             if( nLeft < nMin )
406             {
407                 if( nRight >= nMid || nRight + nLeft >= nMin + nMin )
408                 {
409                     if( nCurrBox )
410                     {
411                         pBoxes->Insert( pBox );
412                         pInnerBox = pBox;
413                         pLeftBox = pLine->GetTabBoxes()[nCurrBox-1];
414                         nDiff = nMin - nLeft;
415                         if( nRight > nMax )
416                         {
417                             if( nCurrBox+1 < nCount )
418                             {
419                                 pRightBox = pLine->GetTabBoxes()[nCurrBox+1];
420                                 nDiff2 = nRight - nMax;
421                             }
422                             else
423                                 bOkay = false;
424                         }
425                         else if( nRightSpanCnt && nRight == nMax )
426                             bOkay = false;
427                     }
428                     else
429                         bOkay = false;
430                 }
431                 else if( nCurrBox+1 < nCount )
432                 {
433                     pLeftBox = pBox;
434                     pInnerBox = pLine->GetTabBoxes()[nCurrBox+1];
435                     nDiff = nMin - nRight;
436                 }
437                 else
438                     bOkay = false;
439             }
440             else if( nRight <= nMax )
441             {
442                 pBoxes->Insert( pBox );
443                 if( nRow == nTop && nRowSpan < 0 )
444                 {
445                     bOkay = false;
446                     break;
447                 }
448                 if( nRowSpan > 1 && nRow + nRowSpan - 1 > nBottom )
449                     nBottom = nRow + (sal_uInt16)nRowSpan - 1;
450                 if( nRowSpan < -1 && nRow - nRowSpan - 1 > nBottom )
451                     nBottom = (sal_uInt16)(nRow - nRowSpan - 1);
452                 if( nRightSpanCnt && nRight == nMax )
453                     bOkay = false;
454             }
455             else if( nLeft < nMax )
456             {
457                 if( nLeft <= nMid || nRight + nLeft <= nMax )
458                 {
459                     if( nCurrBox+1 < nCount )
460                     {
461                         pBoxes->Insert( pBox );
462                         pInnerBox = pBox;
463                         pRightBox = pLine->GetTabBoxes()[nCurrBox+1];
464                         nDiff = nRight - nMax;
465                     }
466                     else
467                         bOkay = false;
468                 }
469                 else if( nCurrBox )
470                 {
471                     pRightBox = pBox;
472                     pInnerBox = pLine->GetTabBoxes()[nCurrBox-1];
473                     nDiff = nLeft - nMax;
474                 }
475                 else
476                     bOkay = false;
477             }
478             else
479                 break;
480             if( pInnerBox )
481             {
482                 if( nRow == nBottom )
483                 {
484                     long nTmpSpan = pInnerBox->getRowSpan();
485                     if( nTmpSpan > 1 )
486                         nBottom += (sal_uInt16)nTmpSpan - 1;
487                     else if( nTmpSpan < -1 )
488                         nBottom = (sal_uInt16)( nBottom - nTmpSpan - 1 );
489                 }
490                 SwTableBox* pOuterBox = pLeftBox;
491                 do
492                 {
493                     if( pOuterBox )
494                     {
495                         long nOutSpan = pOuterBox->getRowSpan();
496                         if( nOutSpan != 1 )
497                         {
498                             sal_uInt16 nCheck = nRow;
499                             if( nOutSpan < 0 )
500                             {
501                                 const SwTableBox& rBox =
502                                     pOuterBox->FindStartOfRowSpan( *this, USHRT_MAX );
503                                 nOutSpan = rBox.getRowSpan();
504                                 const SwTableLine* pTmpL = rBox.GetUpper();
505                                 nCheck = GetTabLines().C40_GETPOS( SwTableLine, pTmpL );
506                                 if( nCheck < nTop )
507                                     bOkay = false;
508                                 if( pOuterBox == pLeftBox )
509                                 {
510                                     if( !nLeftSpanCnt || nMin - nDiff != nLeftSpan )
511                                         bOkay = false;
512                                 }
513                                 else
514                                 {
515                                     if( !nRightSpanCnt || nMax + nDiff != nRightSpan )
516                                         bOkay = false;
517                                 }
518                             }
519                             else
520                             {
521                                 if( pOuterBox == pLeftBox )
522                                 {
523                                     if( nLeftSpanCnt )
524                                         bOkay = false;
525                                     nLeftSpan = nMin - nDiff;
526                                     nLeftSpanCnt = nOutSpan;
527                                 }
528                                 else
529                                 {
530                                     if( nRightSpanCnt )
531                                         bOkay = false;
532                                     nRightSpan = nMax + nDiff;
533                                     nRightSpanCnt = nOutSpan;
534                                 }
535                             }
536                             nCheck += (sal_uInt16)nOutSpan - 1;
537                             if( nCheck > nCheckBottom )
538                                 nCheckBottom = nCheck;
539                         }
540                         else if( ( nLeftSpanCnt && pLeftBox == pOuterBox ) ||
541                             ( nRightSpanCnt && pRightBox == pOuterBox ) )
542                             bOkay = false;
543                         std::pair< SwTableBox*, long > aTmp;
544                         aTmp.first = pInnerBox;
545                         aTmp.second = -nDiff;
546                         aNewWidthList.push_back( aTmp );
547                         aTmp.first = pOuterBox;
548                         aTmp.second = nDiff;
549                         aNewWidthList.push_back( aTmp );
550                     }
551 					pOuterBox = pOuterBox == pRightBox ? 0 : pRightBox;
552                     if( nDiff2 )
553                         nDiff = nDiff2;
554                 } while( pOuterBox );
555             }
556         }
557         if( nLeftSpanCnt )
558             --nLeftSpanCnt;
559         if( nRightSpanCnt )
560             --nRightSpanCnt;
561         pRet->insertBoxes( pBoxes );
562     }
563     pRet->mnMergeWidth = nMax - nMin;
564     if( nCheckBottom > nBottom )
565         bOkay = false;
566     if( bOkay )
567     {
568         std::list< std::pair< SwTableBox*, long > >::iterator
569             pCurr = aNewWidthList.begin();
570         while( pCurr != aNewWidthList.end() )
571         {
572             SwFrmFmt* pFmt = pCurr->first->ClaimFrmFmt();
573             long nNewWidth = pFmt->GetFrmSize().GetWidth() + pCurr->second;
574             pFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nNewWidth, 0 ) );
575             ++pCurr;
576         }
577     }
578     else
579     {
580         delete pRet;
581         pRet = 0;
582     }
583     return pRet;
584 }
585 
586 /** lcl_InvalidateCellFrm(..) invalidates all layout representations of a given cell
587     to initiate a reformatting
588 */
589 
lcl_InvalidateCellFrm(const SwTableBox & rBox)590 void lcl_InvalidateCellFrm( const SwTableBox& rBox )
591 {
592 	SwIterator<SwCellFrm,SwFmt> aIter( *rBox.GetFrmFmt() );
593 	for( SwCellFrm* pCell = aIter.First(); pCell; pCell = aIter.Next() )
594 	{
595 		if( pCell->GetTabBox() == &rBox )
596         {
597 			pCell->InvalidateSize();
598             SwFrm* pLower = pCell->GetLower();
599             if( pLower )
600                 pLower->_InvalidateSize();
601         }
602     }
603 }
604 
605 /** lcl_InsertPosition(..) evaluates the insert positions in every table line,
606     when a selection of cells is given and returns the average cell widths
607 */
608 
lcl_InsertPosition(SwTable & rTable,std::vector<sal_uInt16> & rInsPos,const SwSelBoxes & rBoxes,sal_Bool bBehind)609 long lcl_InsertPosition( SwTable &rTable, std::vector<sal_uInt16>& rInsPos,
610     const SwSelBoxes& rBoxes, sal_Bool bBehind )
611 {
612     sal_Int32 nAddWidth = 0;
613     long nCount = 0;
614     for( sal_uInt16 j = 0; j < rBoxes.Count(); ++j )
615     {
616         SwTableBox *pBox = rBoxes[j];
617         SwTableLine* pLine = pBox->GetUpper();
618         long nWidth = rBoxes[j]->GetFrmFmt()->GetFrmSize().GetWidth();
619         nAddWidth += nWidth;
620         sal_uInt16 nCurrBox = pLine->GetTabBoxes().C40_GETPOS(SwTableBox, pBox );
621         sal_uInt16 nCurrLine = rTable.GetTabLines().C40_GETPOS(SwTableLine, pLine );
622         ASSERT( nCurrLine != USHRT_MAX, "Time to say goodbye..." );
623         if( rInsPos[ nCurrLine ] == USHRT_MAX )
624         {
625             rInsPos[ nCurrLine ] = nCurrBox;
626             ++nCount;
627         }
628         else if( ( rInsPos[ nCurrLine ] > nCurrBox ) == !bBehind )
629             rInsPos[ nCurrLine ] = nCurrBox;
630     }
631     if( nCount )
632         nAddWidth /= nCount;
633     return nAddWidth;
634 }
635 
636 /** SwTable::NewInsertCol(..) insert new column(s) into a table
637 
638 
639 @param pDoc
640 the document
641 
642 @param rBoxes
643 the selected boxes
644 
645 @param nCnt
646 the number of columns to insert
647 
648 @param bBehind
649 insertion behind (true) or before (false) the selected boxes
650 
651 @return true, if any insertion has been done successfully
652 
653 */
654 
NewInsertCol(SwDoc * pDoc,const SwSelBoxes & rBoxes,sal_uInt16 nCnt,sal_Bool bBehind)655 sal_Bool SwTable::NewInsertCol( SwDoc* pDoc, const SwSelBoxes& rBoxes,
656     sal_uInt16 nCnt, sal_Bool bBehind )
657 {
658     if( !aLines.Count() || !nCnt )
659         return sal_False;
660 
661     CHECK_TABLE( *this )
662     long nNewBoxWidth = 0;
663     std::vector< sal_uInt16 > aInsPos( aLines.Count(), USHRT_MAX );
664     { // Calculation of the insert positions and the width of the new boxes
665         sal_uInt64 nTableWidth = 0;
666         for( sal_uInt16 i = 0; i < aLines[0]->GetTabBoxes().Count(); ++i )
667             nTableWidth += aLines[0]->GetTabBoxes()[i]->GetFrmFmt()->GetFrmSize().GetWidth();
668 
669         // Fill the vector of insert positions and the (average) width to insert
670         sal_uInt64 nAddWidth = lcl_InsertPosition( *this, aInsPos, rBoxes, bBehind );
671 
672         // Given is the (average) width of the selected boxes, if we would
673         // insert nCnt of columns the table would grow
674         // So we will shrink the table first, then insert the new boxes and
675         // get a table with the same width than before.
676         // But we will not shrink the table by the full already calculated value,
677         // we will reduce this value proportional to the old table width
678         nAddWidth *= nCnt; // we have to insert nCnt boxes per line
679         sal_uInt64 nResultingWidth = nAddWidth + nTableWidth;
680         if( !nResultingWidth )
681             return sal_False;
682         nAddWidth = (nAddWidth * nTableWidth) / nResultingWidth;
683         nNewBoxWidth = long( nAddWidth / nCnt ); // Rounding
684         nAddWidth = nNewBoxWidth * nCnt; // Rounding
685         if( !nAddWidth || nAddWidth >= nTableWidth )
686             return sal_False;
687         AdjustWidths( static_cast< long >(nTableWidth), static_cast< long >(nTableWidth - nAddWidth) );
688     }
689 
690 	_FndBox aFndBox( 0, 0 );
691 	aFndBox.SetTableLines( rBoxes, *this );
692 	aFndBox.DelFrms( *this );
693 // 	aFndBox.SaveChartData( *this );
694 
695     SwTableNode* pTblNd = GetTableNode();
696     std::vector<SwTableBoxFmt*> aInsFormat( nCnt, 0 );
697     sal_uInt16 nLastLine = USHRT_MAX;
698     long nLastRowSpan = 1;
699 
700     for( sal_uInt16 i = 0; i < aLines.Count(); ++i )
701     {
702         SwTableLine* pLine = aLines[ i ];
703         sal_uInt16 nInsPos = aInsPos[i];
704         ASSERT( nInsPos != USHRT_MAX, "Didn't find insert position" );
705         SwTableBox* pBox = pLine->GetTabBoxes()[ nInsPos ];
706         if( bBehind )
707             ++nInsPos;
708         SwTableBoxFmt* pBoxFrmFmt = (SwTableBoxFmt*)pBox->GetFrmFmt();
709         ::_InsTblBox( pDoc, pTblNd, pLine, pBoxFrmFmt, pBox, nInsPos, nCnt );
710         long nRowSpan = pBox->getRowSpan();
711         long nDiff = i - nLastLine;
712         bool bNewSpan = false;
713         if( nLastLine != USHRT_MAX && nDiff <= nLastRowSpan &&
714             nRowSpan != nDiff - nLastRowSpan )
715         {
716             bNewSpan = true;
717             while( nLastLine < i )
718             {
719                 SwTableLine* pTmpLine = aLines[ nLastLine ];
720                 sal_uInt16 nTmpPos = aInsPos[nLastLine];
721                 if( bBehind )
722                     ++nTmpPos;
723                 for( sal_uInt16 j = 0; j < nCnt; ++j )
724                     pTmpLine->GetTabBoxes()[nTmpPos+j]->setRowSpan( nDiff );
725                 if( nDiff > 0 )
726                     nDiff = -nDiff;
727                 ++nDiff;
728                 ++nLastLine;
729             }
730         }
731         if( nRowSpan > 0 )
732             bNewSpan = true;
733         if( bNewSpan )
734         {
735             nLastLine = i;
736             if( nRowSpan < 0 )
737                 nLastRowSpan = -nRowSpan;
738             else
739                 nLastRowSpan = nRowSpan;
740         }
741 		const SvxBoxItem& aSelBoxItem = pBoxFrmFmt->GetBox();
742 		SvxBoxItem* pNoRightBorder = 0;
743         if( aSelBoxItem.GetRight() )
744         {
745             pNoRightBorder = new SvxBoxItem( aSelBoxItem );
746 			pNoRightBorder->SetLine( 0, BOX_LINE_RIGHT );
747         }
748         for( sal_uInt16 j = 0; j < nCnt; ++j )
749         {
750             SwTableBox *pCurrBox = pLine->GetTabBoxes()[nInsPos+j];
751             if( bNewSpan )
752             {
753                 pCurrBox->setRowSpan( nLastRowSpan );
754                 SwFrmFmt* pFrmFmt = pCurrBox->ClaimFrmFmt();
755                 SwFmtFrmSize aFrmSz( pFrmFmt->GetFrmSize() );
756                 aFrmSz.SetWidth( nNewBoxWidth );
757                 pFrmFmt->SetFmtAttr( aFrmSz );
758                 if( pNoRightBorder && ( !bBehind || j+1 < nCnt ) )
759                     pFrmFmt->SetFmtAttr( *pNoRightBorder );
760                 aInsFormat[j] = (SwTableBoxFmt*)pFrmFmt;
761             }
762             else
763                 pCurrBox->ChgFrmFmt( aInsFormat[j] );
764         }
765         if( bBehind && pNoRightBorder )
766         {
767             SwFrmFmt* pFrmFmt = pBox->ClaimFrmFmt();
768             pFrmFmt->SetFmtAttr( *pNoRightBorder );
769         }
770         delete pNoRightBorder;
771     }
772 
773 	aFndBox.MakeFrms( *this );
774 // 	aFndBox.RestoreChartData( *this );
775 #ifdef DBG_UTIL
776     {
777         const SwTableBoxes &rTabBoxes = aLines[0]->GetTabBoxes();
778         long nNewWidth = 0;
779         for( sal_uInt16 i = 0; i < rTabBoxes.Count(); ++i )
780             nNewWidth += rTabBoxes[i]->GetFrmFmt()->GetFrmSize().GetWidth();
781         ASSERT( nNewWidth > 0, "Very small" );
782     }
783 #endif
784     CHECK_TABLE( *this )
785 
786     return sal_True;
787 }
788 
789 /** SwTable::PrepareMerge(..) some preparation for the coming Merge(..)
790 
791 For the old table model, ::GetMergeSel(..) is called only,
792 for the new table model, PrepareMerge does the main work.
793 It modifies all cells to merge (width, border, rowspan etc.) and collects
794 the cells which have to be deleted by Merge(..) afterwards.
795 If there are superfluous rows, these cells are put into the deletion list as well.
796 
797 @param rPam
798 the selection to merge
799 
800 @param rBoxes
801 should be empty at the beginning, at the end it is filled with boxes to delete.
802 
803 @param ppMergeBox
804 will be set to the master cell box
805 
806 @param pUndo
807 the undo object to record all changes
808 can be Null, e.g. when called by Redo(..)
809 
810 @return
811 
812 */
813 
PrepareMerge(const SwPaM & rPam,SwSelBoxes & rBoxes,SwSelBoxes & rMerged,SwTableBox ** ppMergeBox,SwUndoTblMerge * pUndo)814 bool SwTable::PrepareMerge( const SwPaM& rPam, SwSelBoxes& rBoxes,
815    SwSelBoxes& rMerged, SwTableBox** ppMergeBox, SwUndoTblMerge* pUndo )
816 {
817     if( !bNewModel )
818     {
819         ::GetMergeSel( rPam, rBoxes, ppMergeBox, pUndo );
820         return rBoxes.Count() > 1;
821     }
822     CHECK_TABLE( *this )
823     // We have to assert a "rectangular" box selection before we start to merge
824     std::auto_ptr< SwBoxSelection > pSel( CollectBoxSelection( rPam ) );
825     if( !pSel.get() || pSel->isEmpty() )
826         return false;
827     // Now we should have a rectangle of boxes,
828     // i.e. contiguous cells in contiguous rows
829     bool bMerge = false; // will be set if any content is transferred from
830     // a "not already overlapped" cell into the new master cell.
831     SwTableBox *pMergeBox = (*pSel->aBoxes[0])[0]; // the master cell box
832     if( !pMergeBox )
833         return false;
834     (*ppMergeBox) = pMergeBox;
835     // The new master box will get the left and the top border of the top-left
836     // box of the selection and because the new master cell _is_ the top-left
837     // box, the left and right border does not need to be changed.
838     // The right and bottom border instead has to be derived from the right-
839     // bottom box of the selection. If this is a overlapped cell,
840     // the appropriate master box.
841     SwTableBox* pLastBox = 0; // the right-bottom (master) cell
842     SwDoc* pDoc = GetFrmFmt()->GetDoc();
843     SwPosition aInsPos( *pMergeBox->GetSttNd()->EndOfSectionNode() );
844     SwPaM aChkPam( aInsPos );
845     // The number of lines in the selection rectangle: nLineCount
846     const sal_uInt16 nLineCount = sal_uInt16(pSel->aBoxes.size());
847     // BTW: nLineCount is the rowspan of the new master cell
848     long nRowSpan = nLineCount;
849     // We will need the first and last line of the selection
850     // to check if there any superfluous row after merging
851     SwTableLine* pFirstLn = 0;
852     SwTableLine* pLastLn = 0;
853     // Iteration over the lines of the selection...
854     for( sal_uInt16 nCurrLine = 0; nCurrLine < nLineCount; ++nCurrLine )
855     {
856         // The selected boxes in the current line
857         const SwSelBoxes* pBoxes = pSel->aBoxes[ nCurrLine ];
858         sal_uInt16 nColCount = pBoxes->Count();
859         // Iteration over the selected cell in the current row
860         for( sal_uInt16 nCurrCol = 0; nCurrCol < nColCount; ++nCurrCol )
861         {
862             SwTableBox* pBox = (*pBoxes)[nCurrCol];
863             rMerged.Insert( pBox );
864             // Only the first selected cell in every row will be alive,
865             // the other will be deleted => put into rBoxes
866             if( nCurrCol )
867                 rBoxes.Insert( pBox );
868             else
869             {
870                 if( nCurrLine == 1 )
871                     pFirstLn = pBox->GetUpper(); // we need this line later on
872                 if( nCurrLine + 1 == nLineCount )
873                     pLastLn = pBox->GetUpper(); // and this one, too.
874             }
875             // A box has to be merged if it's not the master box itself,
876             // but an already overlapped cell must not be merged as well.
877             bool bDoMerge = pBox != pMergeBox && pBox->getRowSpan() > 0;
878             // The last box has to be in the last "column" of the selection
879             // and it has to be a master cell
880             if( nCurrCol+1 == nColCount && pBox->getRowSpan() > 0 )
881                 pLastBox = pBox;
882             if( bDoMerge )
883             {
884                 bMerge = true;
885                 // If the cell to merge contains only one empty paragraph,
886                 // we do not transfer this paragraph.
887                 if( !IsEmptyBox( *pBox, aChkPam ) )
888                 {
889                     SwNodeIndex& rInsPosNd = aInsPos.nNode;
890                     SwPaM aPam( aInsPos );
891                     aPam.GetPoint()->nNode.Assign( *pBox->GetSttNd()->EndOfSectionNode(), -1 );
892                     SwCntntNode* pCNd = aPam.GetCntntNode();
893                     sal_uInt16 nL = pCNd ? pCNd->Len() : 0;
894                     aPam.GetPoint()->nContent.Assign( pCNd, nL );
895                     SwNodeIndex aSttNdIdx( *pBox->GetSttNd(), 1 );
896                     bool const bUndo = pDoc->GetIDocumentUndoRedo().DoesUndo();
897                     if( pUndo )
898                     {
899                         pDoc->GetIDocumentUndoRedo().DoUndo(false);
900                     }
901                     pDoc->AppendTxtNode( *aPam.GetPoint() );
902                     if( pUndo )
903                     {
904                         pDoc->GetIDocumentUndoRedo().DoUndo(bUndo);
905                     }
906                     SwNodeRange aRg( aSttNdIdx, aPam.GetPoint()->nNode );
907                     if( pUndo )
908                         pUndo->MoveBoxCntnt( pDoc, aRg, rInsPosNd );
909                     else
910                     {
911                         pDoc->MoveNodeRange( aRg, rInsPosNd,
912                             IDocumentContentOperations::DOC_NO_DELFRMS );
913                     }
914                 }
915             }
916             // Only the cell of the first selected column will stay alive
917             // and got a new row span
918             if( !nCurrCol )
919                 pBox->setRowSpan( nRowSpan );
920         }
921         if( nRowSpan > 0 ) // the master cell is done, from now on we set
922             nRowSpan = -nRowSpan; // negative row spans
923         ++nRowSpan; // ... -3, -2, -1
924     }
925     if( bMerge )
926     {
927         // A row containing overlapped cells is superfluous,
928         // these cells can be put into rBoxes for deletion
929         _FindSuperfluousRows( rBoxes, pFirstLn, pLastLn );
930         // pNewFmt will be set to the new master box and the overlapped cells
931         SwFrmFmt* pNewFmt = pMergeBox->ClaimFrmFmt();
932         pNewFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, pSel->mnMergeWidth, 0 ) );
933         for( sal_uInt16 nCurrLine = 0; nCurrLine < nLineCount; ++nCurrLine )
934         {
935             const SwSelBoxes* pBoxes = pSel->aBoxes[ nCurrLine ];
936             sal_uInt16 nColCount = pBoxes->Count();
937             for( sal_uInt16 nCurrCol = 0; nCurrCol < nColCount; ++nCurrCol )
938             {
939                 SwTableBox* pBox = (*pBoxes)[nCurrCol];
940                 if( nCurrCol )
941                 {
942                     // Even this box will be deleted soon,
943                     // we have to correct the width to avoid side effects
944                     SwFrmFmt* pFmt = pBox->ClaimFrmFmt();
945                     pFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, 0, 0 ) );
946                 }
947                 else
948                     pBox->ChgFrmFmt( (SwTableBoxFmt*)pNewFmt );
949             }
950         }
951         if( pLastBox ) // Robust
952         {
953             // The new borders of the master cell...
954             SvxBoxItem aBox( pMergeBox->GetFrmFmt()->GetBox() );
955             bool bOld = aBox.GetRight() || aBox.GetBottom();
956             const SvxBoxItem& rBox = pLastBox->GetFrmFmt()->GetBox();
957             aBox.SetLine( rBox.GetRight(), BOX_LINE_RIGHT );
958             aBox.SetLine( rBox.GetBottom(), BOX_LINE_BOTTOM );
959             if( bOld || aBox.GetLeft() || aBox.GetTop() || aBox.GetRight() || aBox.GetBottom() )
960                 (*ppMergeBox)->GetFrmFmt()->SetFmtAttr( aBox );
961         }
962 
963         if( pUndo )
964             pUndo->AddNewBox( pMergeBox->GetSttIdx() );
965     }
966     return bMerge;
967 }
968 
969 /** SwTable::_FindSuperfluousRows(..) is looking for superfluous rows, i.e. rows
970     containing overlapped cells only.
971 */
972 
_FindSuperfluousRows(SwSelBoxes & rBoxes,SwTableLine * pFirstLn,SwTableLine * pLastLn)973 void SwTable::_FindSuperfluousRows( SwSelBoxes& rBoxes,
974     SwTableLine* pFirstLn, SwTableLine* pLastLn )
975 {
976     if( !pFirstLn || !pLastLn )
977     {
978         if( !rBoxes.Count() )
979             return;
980         pFirstLn = rBoxes[0]->GetUpper();
981         pLastLn = rBoxes[ rBoxes.Count() - 1 ]->GetUpper();
982     }
983     sal_uInt16 nFirstLn = GetTabLines().C40_GETPOS(SwTableLine, pFirstLn );
984     sal_uInt16 nLastLn = GetTabLines().C40_GETPOS(SwTableLine, pLastLn );
985     for( sal_uInt16 nRow = nFirstLn; nRow <= nLastLn; ++nRow )
986     {
987         SwTableLine* pLine = aLines[nRow];
988         ASSERT( pLine, "Missing table line" );
989         sal_uInt16 nCols = pLine->GetTabBoxes().Count();
990         bool bSuperfl = true;
991         for( sal_uInt16 nCol = 0; nCol < nCols; ++nCol )
992         {
993             SwTableBox *pBox = pLine->GetTabBoxes()[nCol];
994             if( pBox->getRowSpan() > 0 &&
995                 USHRT_MAX == rBoxes.GetPos( pBox ) )
996             {
997                 bSuperfl = false;
998                 break;
999             }
1000         }
1001         if( bSuperfl )
1002         {
1003             for( sal_uInt16 nCol = 0; nCol < nCols; ++nCol )
1004             {
1005                 SwTableBox* pBox = pLine->GetTabBoxes()[nCol];
1006                 rBoxes.Insert( pBox );
1007             }
1008         }
1009     }
1010 }
1011 
1012 /** SwTableBox::FindStartOfRowSpan(..) returns the "master" cell, the cell which
1013     overlaps the given cell, it maybe the cell itself.
1014 */
1015 
FindStartOfRowSpan(const SwTable & rTable,sal_uInt16 nMaxStep)1016 SwTableBox& SwTableBox::FindStartOfRowSpan( const SwTable& rTable, sal_uInt16 nMaxStep )
1017 {
1018     if( getRowSpan() > 0 || !nMaxStep )
1019         return *this;
1020 
1021     long nLeftBorder = lcl_Box2LeftBorder( *this );
1022     SwTableBox* pBox = this;
1023     const SwTableLine* pMyUpper = GetUpper();
1024     sal_uInt16 nLine = rTable.GetTabLines().C40_GETPOS(SwTableLine, pMyUpper );
1025     if( nLine && nLine < rTable.GetTabLines().Count() )
1026     {
1027         SwTableBox* pNext;
1028         do
1029         {
1030             pNext = lcl_LeftBorder2Box( nLeftBorder, rTable.GetTabLines()[--nLine] );
1031             if( pNext )
1032                 pBox = pNext;
1033         } while( nLine && --nMaxStep && pNext && pBox->getRowSpan() < 1 );
1034     }
1035 
1036     return *pBox;
1037 }
1038 
1039 /** SwTableBox::FindEndOfRowSpan(..) returns the last overlapped cell if there is
1040     any. Otherwise the cell itself will returned.
1041 */
1042 
FindEndOfRowSpan(const SwTable & rTable,sal_uInt16 nMaxStep)1043 SwTableBox& SwTableBox::FindEndOfRowSpan( const SwTable& rTable, sal_uInt16 nMaxStep )
1044 {
1045     long nAbsSpan = getRowSpan();
1046     if( nAbsSpan < 0 )
1047         nAbsSpan = -nAbsSpan;
1048     if( nAbsSpan == 1 || !nMaxStep )
1049         return *this;
1050 
1051     if( nMaxStep > --nAbsSpan )
1052         nMaxStep = (sal_uInt16)nAbsSpan;
1053     const SwTableLine* pMyUpper = GetUpper();
1054     sal_uInt16 nLine = rTable.GetTabLines().C40_GETPOS(SwTableLine, pMyUpper );
1055     nMaxStep = nLine + nMaxStep;
1056     if( nMaxStep >= rTable.GetTabLines().Count() )
1057         nMaxStep = rTable.GetTabLines().Count() - 1;
1058     long nLeftBorder = lcl_Box2LeftBorder( *this );
1059     SwTableBox* pBox =
1060         lcl_LeftBorder2Box( nLeftBorder, rTable.GetTabLines()[ nMaxStep ] );
1061     if ( !pBox )
1062         pBox = this;
1063 
1064     return *pBox;
1065 }
1066 
1067 /** lcl_getAllMergedBoxes(..) collects all overlapped boxes to a given (master) box
1068 */
1069 
lcl_getAllMergedBoxes(const SwTable & rTable,SwSelBoxes & rBoxes,SwTableBox & rBox)1070 void lcl_getAllMergedBoxes( const SwTable& rTable, SwSelBoxes& rBoxes, SwTableBox& rBox )
1071 {
1072     SwTableBox* pBox = &rBox;
1073     ASSERT( pBox == &rBox.FindStartOfRowSpan( rTable, USHRT_MAX ), "Not a master box" );
1074     rBoxes.Insert( pBox );
1075     if( pBox->getRowSpan() == 1 )
1076         return;
1077     const SwTableLine* pMyUpper = pBox->GetUpper();
1078     sal_uInt16 nLine = rTable.GetTabLines().C40_GETPOS(SwTableLine, pMyUpper );
1079     long nLeftBorder = lcl_Box2LeftBorder( *pBox );
1080     sal_uInt16 nCount = rTable.GetTabLines().Count();
1081     while( ++nLine < nCount && pBox && pBox->getRowSpan() != -1 )
1082     {
1083         pBox = lcl_LeftBorder2Box( nLeftBorder, rTable.GetTabLines()[nLine] );
1084         if( pBox )
1085             rBoxes.Insert( pBox );
1086     };
1087 }
1088 
1089 /** lcl_UnMerge(..) manipulates the row span attribute of a given master cell
1090     and its overlapped cells to split them into several pieces.
1091 */
1092 
lcl_UnMerge(const SwTable & rTable,SwTableBox & rBox,sal_uInt16 nCnt,sal_Bool bSameHeight)1093 void lcl_UnMerge( const SwTable& rTable, SwTableBox& rBox, sal_uInt16 nCnt,
1094     sal_Bool bSameHeight )
1095 {
1096     SwSelBoxes aBoxes;
1097     lcl_getAllMergedBoxes( rTable, aBoxes, rBox );
1098     sal_uInt16 nCount = aBoxes.Count();
1099     if( nCount < 2 )
1100         return;
1101     if( nCnt > nCount )
1102         nCnt = nCount;
1103     sal_uInt16 *pSplitIdx = new sal_uInt16[ nCnt ];
1104     if( bSameHeight )
1105     {
1106         SwTwips *pHeights = new SwTwips[ nCount ];
1107         SwTwips nHeight = 0;
1108         for( sal_uInt16 i = 0; i < nCount; ++i )
1109         {
1110             SwTableLine* pLine = aBoxes[ i ]->GetUpper();
1111             SwFrmFmt *pRowFmt = pLine->GetFrmFmt();
1112             pHeights[ i ] = pRowFmt->GetFrmSize().GetHeight();
1113             nHeight += pHeights[ i ];
1114         }
1115         SwTwips nSumH = 0;
1116         sal_uInt16 nIdx = 0;
1117         for( sal_uInt16 i = 1; i <= nCnt; ++i )
1118         {
1119             SwTwips nSplit = ( i * nHeight ) / nCnt;
1120             while( nSumH < nSplit && nIdx < nCount )
1121                 nSumH += pHeights[ nIdx++ ];
1122             pSplitIdx[ i - 1 ] = nIdx;
1123         }
1124         delete[] pHeights;
1125     }
1126     else
1127     {
1128         for( long i = 1; i <= nCnt; ++i )
1129             pSplitIdx[ i - 1 ] = (sal_uInt16)( ( i * nCount ) / nCnt );
1130     }
1131     sal_uInt16 nIdx = 0;
1132     for( long i = 0; i < nCnt; ++i )
1133     {
1134         sal_uInt16 nNextIdx = pSplitIdx[ i ];
1135         aBoxes[ nIdx ]->setRowSpan( nNextIdx - nIdx );
1136         lcl_InvalidateCellFrm( *aBoxes[ nIdx ] );
1137         while( ++nIdx < nNextIdx )
1138             aBoxes[ nIdx ]->setRowSpan( nIdx - nNextIdx );
1139     }
1140     delete[] pSplitIdx;
1141 }
1142 
1143 /** lcl_FillSelBoxes(..) puts all boxes of a given line into the selection structure
1144 */
1145 
lcl_FillSelBoxes(SwSelBoxes & rBoxes,SwTableLine & rLine)1146 void lcl_FillSelBoxes( SwSelBoxes &rBoxes, SwTableLine &rLine )
1147 {
1148     sal_uInt16 nBoxCount = rLine.GetTabBoxes().Count();
1149     sal_uInt16 nCurrBox;
1150     for( nCurrBox = 0; nCurrBox < nBoxCount; ++nCurrBox )
1151         rBoxes.Insert( rLine.GetTabBoxes()[nCurrBox] );
1152 }
1153 
1154 /** SwTable::InsertSpannedRow(..) inserts "superfluous" rows, i.e. rows containing
1155     overlapped cells only. This is a preparation for an upcoming split.
1156 */
1157 
InsertSpannedRow(SwDoc * pDoc,sal_uInt16 nRowIdx,sal_uInt16 nCnt)1158 void SwTable::InsertSpannedRow( SwDoc* pDoc, sal_uInt16 nRowIdx, sal_uInt16 nCnt )
1159 {
1160     CHECK_TABLE( *this )
1161     ASSERT( nCnt && nRowIdx < GetTabLines().Count(), "Wrong call of InsertSpannedRow" );
1162     SwSelBoxes aBoxes;
1163     SwTableLine& rLine = *GetTabLines()[ nRowIdx ];
1164     lcl_FillSelBoxes( aBoxes, rLine );
1165     SwFmtFrmSize aFSz( rLine.GetFrmFmt()->GetFrmSize() );
1166     if( ATT_VAR_SIZE != aFSz.GetHeightSizeType() )
1167     {
1168         SwFrmFmt* pFrmFmt = rLine.ClaimFrmFmt();
1169         long nNewHeight = aFSz.GetHeight() / ( nCnt + 1 );
1170         if( !nNewHeight )
1171             ++nNewHeight;
1172         aFSz.SetHeight( nNewHeight );
1173         pFrmFmt->SetFmtAttr( aFSz );
1174     }
1175     _InsertRow( pDoc, aBoxes, nCnt, sal_True );
1176     sal_uInt16 nBoxCount = rLine.GetTabBoxes().Count();
1177     for( sal_uInt16 n = 0; n < nCnt; ++n )
1178     {
1179         SwTableLine *pNewLine = GetTabLines()[ nRowIdx + nCnt - n ];
1180         for( sal_uInt16 nCurrBox = 0; nCurrBox < nBoxCount; ++nCurrBox )
1181         {
1182             long nRowSpan = rLine.GetTabBoxes()[nCurrBox]->getRowSpan();
1183             if( nRowSpan > 0 )
1184                 nRowSpan = - nRowSpan;
1185             pNewLine->GetTabBoxes()[ nCurrBox ]->setRowSpan( nRowSpan - n );
1186         }
1187     }
1188     lcl_ChangeRowSpan( *this, nCnt, nRowIdx, false );
1189     CHECK_TABLE( *this )
1190 }
1191 
1192 typedef std::pair< sal_uInt16, sal_uInt16 > SwLineOffset;
1193 typedef std::list< SwLineOffset > SwLineOffsetArray;
1194 
1195 /******************************************************************************
1196 When a couple of table boxes has to be split,
1197 lcl_SophisticatedFillLineIndices delivers the information where and how many
1198 rows have to be inserted.
1199 Input
1200     rTable: the table to manipulate
1201     rBoxes: an array of boxes to split
1202     nCnt:   how many parts are wanted
1203 Output
1204     rArr:   a list of pairs ( line index, number of lines to insert )
1205 
1206 ******************************************************************************/
1207 
lcl_SophisticatedFillLineIndices(SwLineOffsetArray & rArr,const SwTable & rTable,const SwSelBoxes & rBoxes,sal_uInt16 nCnt)1208 void lcl_SophisticatedFillLineIndices( SwLineOffsetArray &rArr,
1209     const SwTable& rTable, const SwSelBoxes& rBoxes, sal_uInt16 nCnt )
1210 {
1211     std::list< SwLineOffset > aBoxes;
1212     SwLineOffset aLnOfs( USHRT_MAX, USHRT_MAX );
1213     for( sal_uInt16 i = 0; i < rBoxes.Count(); ++i )
1214     {   // Collect all end line indices and the row spans
1215         const SwTableBox &rBox = rBoxes[ i ]->FindStartOfRowSpan( rTable );
1216         ASSERT( rBox.getRowSpan() > 0, "Didn't I say 'StartOfRowSpan' ??" )
1217         if( nCnt > rBox.getRowSpan() )
1218         {
1219             const SwTableLine *pLine = rBox.GetUpper();
1220             const sal_uInt16 nEnd = sal_uInt16( rBox.getRowSpan() +
1221                 rTable.GetTabLines().C40_GETPOS( SwTableLine, pLine ) );
1222             // The next if statement is a small optimization
1223             if( aLnOfs.first != nEnd || aLnOfs.second != rBox.getRowSpan() )
1224             {
1225                 aLnOfs.first = nEnd; // ok, this is the line behind the box
1226                 aLnOfs.second = sal_uInt16( rBox.getRowSpan() ); // the row span
1227                 aBoxes.insert( aBoxes.end(), aLnOfs );
1228             }
1229         }
1230     }
1231     // As I said, I noted the line index _behind_ the last line of the boxes
1232     // in the resulting array the index has to be _on_ the line
1233     // nSum is to evaluate the wished value
1234     sal_uInt16 nSum = 1;
1235     while( aBoxes.size() )
1236     {
1237         // I. step:
1238         // Looking for the "smallest" line end with the smallest row span
1239         std::list< SwLineOffset >::iterator pCurr = aBoxes.begin();
1240         aLnOfs = *pCurr; // the line end and row span of the first box
1241         while( ++pCurr != aBoxes.end() )
1242         {
1243             if( aLnOfs.first > pCurr->first )
1244             {   // Found a smaller line end
1245                 aLnOfs.first = pCurr->first;
1246                 aLnOfs.second = pCurr->second; // row span
1247             }
1248             else if( aLnOfs.first == pCurr->first &&
1249                      aLnOfs.second < pCurr->second )
1250                 aLnOfs.second = pCurr->second; // Found a smaller row span
1251         }
1252         ASSERT( aLnOfs.second < nCnt, "Clean-up failed" )
1253         aLnOfs.second = nCnt - aLnOfs.second; // the number of rows to insert
1254         rArr.insert( rArr.end(),
1255             SwLineOffset( aLnOfs.first - nSum, aLnOfs.second ) );
1256         // the correction has to be incremented because in the following
1257         // loops the line ends were manipulated
1258         nSum = nSum + aLnOfs.second;
1259 
1260         pCurr = aBoxes.begin();
1261         while( pCurr != aBoxes.end() )
1262         {
1263             if( pCurr->first == aLnOfs.first )
1264             {   // These boxes can be removed because the last insertion
1265                 // of rows will expand their row span above the needed value
1266                 std::list< SwLineOffset >::iterator pDel = pCurr;
1267                 ++pCurr;
1268                 aBoxes.erase( pDel );
1269             }
1270             else
1271             {
1272                 bool bBefore = ( pCurr->first - pCurr->second < aLnOfs.first );
1273                 // Manipulation of the end line indices as if the rows are
1274                 // already inserted
1275                 pCurr->first = pCurr->first + aLnOfs.second;
1276                 if( bBefore )
1277                 {   // If the insertion is inside the box,
1278                     // its row span has to be incremented
1279                     pCurr->second = pCurr->second + aLnOfs.second;
1280                     if( pCurr->second >= nCnt )
1281                     {   // if the row span is bigger than the split factor
1282                         // this box is done
1283                         std::list< SwLineOffset >::iterator pDel = pCurr;
1284                         ++pCurr;
1285                         aBoxes.erase( pDel );
1286                     }
1287                     else
1288                         ++pCurr;
1289                 }
1290                 else
1291                     ++pCurr;
1292             }
1293         }
1294     }
1295 }
1296 
1297 typedef std::set< SwTwips > SwSplitLines;
1298 
1299 /** lcl_CalculateSplitLineHeights(..) delivers all y-positions where table rows have
1300     to be splitted to fulfill the requested "split same height"
1301 */
1302 
lcl_CalculateSplitLineHeights(SwSplitLines & rCurr,SwSplitLines & rNew,const SwTable & rTable,const SwSelBoxes & rBoxes,sal_uInt16 nCnt)1303 sal_uInt16 lcl_CalculateSplitLineHeights( SwSplitLines &rCurr, SwSplitLines &rNew,
1304     const SwTable& rTable, const SwSelBoxes& rBoxes, sal_uInt16 nCnt )
1305 {
1306     if( nCnt < 2 )
1307         return 0;
1308     std::list< SwLineOffset > aBoxes;
1309     SwLineOffset aLnOfs( USHRT_MAX, USHRT_MAX );
1310     sal_uInt16 nFirst = USHRT_MAX; // becomes the index of the first line
1311     sal_uInt16 nLast = 0; // becomes the index of the last line of the splitting
1312     for( sal_uInt16 i = 0; i < rBoxes.Count(); ++i )
1313     {   // Collect all pairs (start+end) of line indices to split
1314         const SwTableBox &rBox = rBoxes[ i ]->FindStartOfRowSpan( rTable );
1315         ASSERT( rBox.getRowSpan() > 0, "Didn't I say 'StartOfRowSpan' ??" )
1316         const SwTableLine *pLine = rBox.GetUpper();
1317         const sal_uInt16 nStart = rTable.GetTabLines().C40_GETPOS( SwTableLine, pLine );
1318         const sal_uInt16 nEnd = sal_uInt16( rBox.getRowSpan() + nStart - 1 );
1319         // The next if statement is a small optimization
1320         if( aLnOfs.first != nStart || aLnOfs.second != nEnd )
1321         {
1322             aLnOfs.first = nStart;
1323             aLnOfs.second = nEnd;
1324             aBoxes.insert( aBoxes.end(), aLnOfs );
1325             if( nStart < nFirst )
1326                 nFirst = nStart;
1327             if( nEnd > nLast )
1328                 nLast = nEnd;
1329         }
1330     }
1331 
1332     if( aBoxes.empty() )
1333         return 0;
1334     SwTwips nHeight = 0;
1335     SwTwips* pLines = new SwTwips[ nLast + 1 - nFirst ];
1336     for( sal_uInt16 i = nFirst; i <= nLast; ++i )
1337     {
1338         bool bLayoutAvailable = false;
1339         nHeight += rTable.GetTabLines()[ i ]->GetTableLineHeight( bLayoutAvailable );
1340         rCurr.insert( rCurr.end(), nHeight );
1341         pLines[ i - nFirst ] = nHeight;
1342     }
1343     std::list< SwLineOffset >::iterator pSplit = aBoxes.begin();
1344     while( pSplit != aBoxes.end() )
1345     {
1346         SwTwips nBase = pSplit->first <= nFirst ? 0 :
1347                         pLines[ pSplit->first - nFirst - 1 ];
1348         SwTwips nDiff = pLines[ pSplit->second - nFirst ] - nBase;
1349         for( sal_uInt16 i = 1; i < nCnt; ++i )
1350         {
1351             SwTwips nSplit = nBase + ( i * nDiff ) / nCnt;
1352             rNew.insert( nSplit );
1353         }
1354         ++pSplit;
1355     }
1356     delete[] pLines;
1357     return nFirst;
1358 }
1359 
1360 /** lcl_LineIndex(..) delivers the line index of the line behind or above
1361     the box selection.
1362 */
1363 
lcl_LineIndex(const SwTable & rTable,const SwSelBoxes & rBoxes,bool bBehind)1364 sal_uInt16 lcl_LineIndex( const SwTable& rTable, const SwSelBoxes& rBoxes,
1365                       bool bBehind )
1366 {
1367     sal_uInt16 nDirect = USHRT_MAX;
1368     sal_uInt16 nSpan = USHRT_MAX;
1369     for( sal_uInt16 i = 0; i < rBoxes.Count(); ++i )
1370     {
1371         SwTableBox *pBox = rBoxes[i];
1372         const SwTableLine* pLine = rBoxes[i]->GetUpper();
1373         sal_uInt16 nPos = rTable.GetTabLines().C40_GETPOS( SwTableLine, pLine );
1374         if( USHRT_MAX != nPos )
1375         {
1376             if( bBehind )
1377             {
1378                 if( nPos > nDirect || nDirect == USHRT_MAX )
1379                     nDirect = nPos;
1380                 long nRowSpan = pBox->getRowSpan();
1381                 if( nRowSpan < 2 )
1382                     nSpan = 0;
1383                 else if( nSpan )
1384                 {
1385                     sal_uInt16 nEndOfRowSpan = (sal_uInt16)(nPos + nRowSpan - 1);
1386                     if( nEndOfRowSpan > nSpan || nSpan == USHRT_MAX )
1387                         nSpan = nEndOfRowSpan;
1388                 }
1389             }
1390             else if( nPos < nDirect )
1391                 nDirect = nPos;
1392         }
1393     }
1394     if( nSpan && nSpan < USHRT_MAX )
1395         return nSpan;
1396     return nDirect;
1397 }
1398 
1399 /** SwTable::NewSplitRow(..) splits all selected boxes horizontally.
1400 */
1401 
NewSplitRow(SwDoc * pDoc,const SwSelBoxes & rBoxes,sal_uInt16 nCnt,sal_Bool bSameHeight)1402 sal_Bool SwTable::NewSplitRow( SwDoc* pDoc, const SwSelBoxes& rBoxes, sal_uInt16 nCnt,
1403     sal_Bool bSameHeight )
1404 {
1405     CHECK_TABLE( *this )
1406     ++nCnt;
1407 	_FndBox aFndBox( 0, 0 );
1408 	aFndBox.SetTableLines( rBoxes, *this );
1409 
1410     if( bSameHeight && pDoc->GetCurrentViewShell() ) // swmod 071108 // swmod 071225
1411     {
1412         SwSplitLines aRowLines;
1413         SwSplitLines aSplitLines;
1414         sal_uInt16 nFirst = lcl_CalculateSplitLineHeights( aRowLines, aSplitLines,
1415             *this, rBoxes, nCnt );
1416         aFndBox.DelFrms( *this );
1417         SwTwips nLast = 0;
1418         SwSplitLines::iterator pSplit = aSplitLines.begin();
1419         SwSplitLines::iterator pCurr = aRowLines.begin();
1420         while( pCurr != aRowLines.end() )
1421         {
1422             while( pSplit != aSplitLines.end() && *pSplit < *pCurr )
1423             {
1424                 InsertSpannedRow( pDoc, nFirst, 1 );
1425                 SwTableLine* pRow = GetTabLines()[ nFirst ];
1426                 SwFrmFmt* pRowFmt = pRow->ClaimFrmFmt();
1427                 SwFmtFrmSize aFSz( pRowFmt->GetFrmSize() );
1428                 aFSz.SetHeightSizeType( ATT_MIN_SIZE );
1429                 aFSz.SetHeight( *pSplit - nLast );
1430                 pRowFmt->SetFmtAttr( aFSz );
1431                 nLast = *pSplit;
1432                 ++pSplit;
1433                 ++nFirst;
1434             }
1435             if( pSplit != aSplitLines.end() && *pCurr == *pSplit )
1436                 ++pSplit;
1437             SwTableLine* pRow = GetTabLines()[ nFirst ];
1438             SwFrmFmt* pRowFmt = pRow->ClaimFrmFmt();
1439             SwFmtFrmSize aFSz( pRowFmt->GetFrmSize() );
1440             aFSz.SetHeightSizeType( ATT_MIN_SIZE );
1441             aFSz.SetHeight( *pCurr - nLast );
1442             pRowFmt->SetFmtAttr( aFSz );
1443             nLast = *pCurr;
1444             ++pCurr;
1445             ++nFirst;
1446         }
1447     }
1448     else
1449     {
1450         aFndBox.DelFrms( *this );
1451         bSameHeight = sal_False;
1452     }
1453     if( !bSameHeight )
1454     {
1455         SwLineOffsetArray aLineOffs;
1456         lcl_SophisticatedFillLineIndices( aLineOffs, *this, rBoxes, nCnt );
1457         SwLineOffsetArray::reverse_iterator pCurr( aLineOffs.rbegin() );
1458         while( pCurr != aLineOffs.rend() )
1459         {
1460             InsertSpannedRow( pDoc, pCurr->first, pCurr->second );
1461             ++pCurr;
1462         }
1463     }
1464 
1465     std::set< sal_uInt16> aIndices;
1466     for( sal_uInt16 i = 0; i < rBoxes.Count(); ++i )
1467     {
1468         ASSERT( rBoxes[i]->getRowSpan() != 1, "Forgot to split?" )
1469         if( rBoxes[i]->getRowSpan() > 1 )
1470             aIndices.insert( i );
1471     }
1472 
1473     std::set< sal_uInt16 >::iterator pCurrBox = aIndices.begin();
1474     while( pCurrBox != aIndices.end() )
1475         lcl_UnMerge( *this, *rBoxes[*pCurrBox++], nCnt, bSameHeight );
1476 
1477     CHECK_TABLE( *this )
1478 	// update layout
1479 	aFndBox.MakeFrms( *this );
1480 
1481     return sal_True;
1482 }
1483 
1484 /** SwTable::InsertRow(..) inserts one or more rows before or behind the selected
1485     boxes.
1486 */
1487 
InsertRow(SwDoc * pDoc,const SwSelBoxes & rBoxes,sal_uInt16 nCnt,sal_Bool bBehind)1488 sal_Bool SwTable::InsertRow( SwDoc* pDoc, const SwSelBoxes& rBoxes,
1489 						sal_uInt16 nCnt, sal_Bool bBehind )
1490 {
1491     bool bRet = false;
1492     if( IsNewModel() )
1493     {
1494         CHECK_TABLE( *this )
1495         sal_uInt16 nRowIdx = lcl_LineIndex( *this, rBoxes, bBehind );
1496         if( nRowIdx < USHRT_MAX )
1497         {
1498             _FndBox aFndBox( 0, 0 );
1499             aFndBox.SetTableLines( rBoxes, *this );
1500             aFndBox.DelFrms( *this );
1501 //             aFndBox.SaveChartData( *this );
1502 
1503             bRet = true;
1504             SwTableLine *pLine = GetTabLines()[ nRowIdx ];
1505             SwSelBoxes aLineBoxes;
1506             lcl_FillSelBoxes( aLineBoxes, *pLine );
1507             _InsertRow( pDoc, aLineBoxes, nCnt, bBehind );
1508             sal_uInt16 nBoxCount = pLine->GetTabBoxes().Count();
1509             sal_uInt16 nOfs = bBehind ? 0 : 1;
1510             for( sal_uInt16 n = 0; n < nCnt; ++n )
1511             {
1512                 SwTableLine *pNewLine = GetTabLines()[ nRowIdx+nCnt-n-nOfs];
1513                 for( sal_uInt16 nCurrBox = 0; nCurrBox < nBoxCount; ++nCurrBox )
1514                 {
1515                     long nRowSpan = pLine->GetTabBoxes()[nCurrBox]->getRowSpan();
1516                     if( bBehind )
1517                     {
1518                         if( nRowSpan == 1 || nRowSpan == -1 )
1519                             nRowSpan = n + 1;
1520                         else if( nRowSpan > 1 )
1521                             nRowSpan = - nRowSpan;
1522                     }
1523                     else
1524                     {
1525                         if( nRowSpan > 0 )
1526                             nRowSpan = n + 1;
1527                         else
1528                             --nRowSpan;
1529                     }
1530                     pNewLine->GetTabBoxes()[ nCurrBox ]->setRowSpan( nRowSpan - n );
1531                 }
1532             }
1533             if( bBehind )
1534                 ++nRowIdx;
1535             if( nRowIdx )
1536                 lcl_ChangeRowSpan( *this, nCnt, --nRowIdx, true );
1537             // update layout
1538             aFndBox.MakeFrms( *this );
1539 //             aFndBox.RestoreChartData( *this );
1540         }
1541         CHECK_TABLE( *this )
1542     }
1543     else
1544         bRet = _InsertRow( pDoc, rBoxes, nCnt, bBehind );
1545     return bRet;
1546 }
1547 
1548 /** SwTable::PrepareDelBoxes(..) adjusts the row span attributes for an upcoming
1549     deletion of table cells and invalidates the layout of these cells.
1550 */
1551 
PrepareDelBoxes(const SwSelBoxes & rBoxes)1552 void SwTable::PrepareDelBoxes( const SwSelBoxes& rBoxes )
1553 {
1554     if( IsNewModel() )
1555     {
1556         for( sal_uInt16 i = 0; i < rBoxes.Count(); ++i )
1557         {
1558             SwTableBox* pBox = rBoxes[i];
1559             long nRowSpan = pBox->getRowSpan();
1560             if( nRowSpan != 1 && pBox->GetFrmFmt()->GetFrmSize().GetWidth() )
1561             {
1562                 long nLeft = lcl_Box2LeftBorder( *pBox );
1563                 SwTableLine *pLine = pBox->GetUpper();
1564                 sal_uInt16 nLinePos = GetTabLines().C40_GETPOS(SwTableLine, pLine);
1565                 ASSERT( nLinePos < USHRT_MAX, "Box/table mismatch" )
1566                 if( nRowSpan > 1 )
1567                 {
1568                     if( ++nLinePos < GetTabLines().Count() )
1569                     {
1570                         pLine = GetTabLines()[ nLinePos ];
1571                         pBox = lcl_LeftBorder2Box( nLeft, pLine );
1572                         ASSERT( pBox, "RowSpan irritation I" )
1573                         if( pBox )
1574                             pBox->setRowSpan( --nRowSpan );
1575                     }
1576                 }
1577                 else if( nLinePos > 0 )
1578                 {
1579                     do
1580                     {
1581                         pLine = GetTabLines()[ --nLinePos ];
1582                         pBox = lcl_LeftBorder2Box( nLeft, pLine );
1583                         ASSERT( pBox, "RowSpan irritation II" )
1584                         if( pBox )
1585                         {
1586                             nRowSpan = pBox->getRowSpan();
1587                             if( nRowSpan > 1 )
1588                             {
1589                                 lcl_InvalidateCellFrm( *pBox );
1590                                 --nRowSpan;
1591                             }
1592                             else
1593                                 ++nRowSpan;
1594                             pBox->setRowSpan( nRowSpan );
1595                         }
1596                         else
1597                             nRowSpan = 1;
1598                     }
1599                     while( nRowSpan < 0 && nLinePos > 0 );
1600                 }
1601             }
1602         }
1603     }
1604 }
1605 
1606 /** lcl_SearchSelBox(..) adds cells of a given table row to the selection structure
1607     if it overlaps with the given x-position range
1608 */
1609 
lcl_SearchSelBox(const SwTable & rTable,SwSelBoxes & rBoxes,long nMin,long nMax,SwTableLine & rLine,bool bChkProtected,bool bColumn)1610 void lcl_SearchSelBox( const SwTable &rTable, SwSelBoxes& rBoxes, long nMin, long nMax,
1611                        SwTableLine& rLine, bool bChkProtected, bool bColumn )
1612 {
1613     long nLeft = 0;
1614     long nRight = 0;
1615     long nMid = ( nMax + nMin )/ 2;
1616     sal_uInt16 nCount = rLine.GetTabBoxes().Count();
1617     for( sal_uInt16 nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
1618     {
1619         SwTableBox* pBox = rLine.GetTabBoxes()[nCurrBox];
1620         ASSERT( pBox, "Missing table box" );
1621         long nWidth = pBox->GetFrmFmt()->GetFrmSize().GetWidth();
1622         nRight += nWidth;
1623         if( nRight > nMin )
1624         {
1625             bool bAdd = false;
1626             if( nRight <= nMax )
1627                 bAdd = nLeft >= nMin || nRight >= nMid ||
1628                        nRight - nMin > nMin - nLeft;
1629             else
1630                 bAdd = nLeft <= nMid || nRight - nMax < nMax - nLeft;
1631             long nRowSpan = pBox->getRowSpan();
1632             if( bAdd &&
1633                 //( bColumn || nRowSpan > 0 ) &&
1634                 ( !bChkProtected ||
1635                 !pBox->GetFrmFmt()->GetProtect().IsCntntProtected() ) )
1636             {
1637                 sal_uInt16 nOldCnt = rBoxes.Count();
1638                 rBoxes.Insert( pBox );
1639                 if( bColumn && nRowSpan != 1 && nOldCnt < rBoxes.Count() )
1640                 {
1641                     SwTableBox *pMasterBox = pBox->getRowSpan() > 0 ? pBox
1642                         : &pBox->FindStartOfRowSpan( rTable, USHRT_MAX );
1643                     lcl_getAllMergedBoxes( rTable, rBoxes, *pMasterBox );
1644                 }
1645             }
1646         }
1647         if( nRight >= nMax )
1648             break;
1649         nLeft = nRight;
1650     }
1651 }
1652 
1653 /** void SwTable::CreateSelection(..) fills the selection structure with table cells
1654     for a given SwPaM, i.e. start and end position inside a table
1655 */
1656 
CreateSelection(const SwPaM & rPam,SwSelBoxes & rBoxes,const SearchType eSearch,bool bChkProtected) const1657 void SwTable::CreateSelection( const SwPaM& rPam, SwSelBoxes& rBoxes,
1658     const SearchType eSearch, bool bChkProtected ) const
1659 {
1660     ASSERT( bNewModel, "Don't call me for old tables" );
1661     if( !aLines.Count() )
1662         return;
1663     const SwNode* pStartNd = rPam.GetPoint()->nNode.GetNode().FindTableBoxStartNode();
1664     const SwNode* pEndNd = rPam.GetMark()->nNode.GetNode().FindTableBoxStartNode();
1665     if( !pStartNd || !pEndNd )
1666         return;
1667     CreateSelection( pStartNd, pEndNd, rBoxes, eSearch, bChkProtected );
1668 }
1669 
1670 /** void SwTable::CreateSelection(..) fills the selection structure with table cells
1671     for given start and end nodes inside a table
1672 */
CreateSelection(const SwNode * pStartNd,const SwNode * pEndNd,SwSelBoxes & rBoxes,const SearchType eSearch,bool bChkProtected) const1673 void SwTable::CreateSelection( const SwNode* pStartNd, const SwNode* pEndNd,
1674     SwSelBoxes& rBoxes, const SearchType eSearch, bool bChkProtected ) const
1675 {
1676     // SwSelBoxes aKeepBoxes;
1677     if( rBoxes.Count() )
1678     {
1679         // aKeepBoxes.Insert( &rBoxes );
1680 		rBoxes.Remove( sal_uInt16(0), rBoxes.Count() );
1681     }
1682     // Looking for start and end of the selection given by SwNode-pointer
1683     sal_uInt16 nLines = aLines.Count();
1684     // nTop becomes the line number of the upper box
1685     // nBottom becomes the line number of the lower box
1686     sal_uInt16 nTop = 0, nBottom = 0;
1687     // nUpperMin becomes the left border value of the upper box
1688     // nUpperMax becomes the right border of the upper box
1689     // nLowerMin and nLowerMax the borders of the lower box
1690     long nUpperMin = 0, nUpperMax = 0;
1691     long nLowerMin = 0, nLowerMax = 0;
1692     // nFound will incremented if a box is found
1693     // 0 => no box found; 1 => the upper box has been found; 2 => both found
1694     int nFound = 0;
1695     for( sal_uInt16 nRow = 0; nFound < 2 && nRow < nLines; ++nRow )
1696     {
1697         SwTableLine* pLine = aLines[nRow];
1698         ASSERT( pLine, "Missing table line" );
1699         sal_uInt16 nCols = pLine->GetTabBoxes().Count();
1700         for( sal_uInt16 nCol = 0; nCol < nCols; ++nCol )
1701         {
1702             SwTableBox* pBox = pLine->GetTabBoxes()[nCol];
1703             ASSERT( pBox, "Missing table box" );
1704             if( pBox->GetSttNd() == pEndNd || pBox->GetSttNd() == pStartNd )
1705             {
1706                 if( !bChkProtected ||
1707                     !pBox->GetFrmFmt()->GetProtect().IsCntntProtected() )
1708                     rBoxes.Insert( pBox );
1709                 if( nFound )
1710                 {
1711                     nBottom = nRow;
1712                     lcl_CheckMinMax( nLowerMin, nLowerMax, *pLine, nCol, true );
1713                     ++nFound;
1714                     break;
1715                 }
1716                 else
1717                 {
1718                     nTop = nRow;
1719                     lcl_CheckMinMax( nUpperMin, nUpperMax, *pLine, nCol, true );
1720                     ++nFound;
1721                      // If start and end node are identical, we're nearly done...
1722                     if( pEndNd == pStartNd )
1723                     {
1724                         nBottom = nTop;
1725                         nLowerMin = nUpperMin;
1726                         nLowerMax = nUpperMax;
1727                         ++nFound;
1728                     }
1729                 }
1730             }
1731         }
1732     }
1733     if( nFound < 2 )
1734         return; // At least one node was not a part of the given table
1735     if( eSearch == SEARCH_ROW )
1736     {
1737         // Selection of a row is quiet easy:
1738         // every (unprotected) box between start and end line
1739         // with a positive row span will be collected
1740         for( sal_uInt16 nRow = nTop; nRow <= nBottom; ++nRow )
1741         {
1742             SwTableLine* pLine = aLines[nRow];
1743             ASSERT( pLine, "Missing table line" );
1744             sal_uInt16 nCount = pLine->GetTabBoxes().Count();
1745             for( sal_uInt16 nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
1746             {
1747                 SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
1748                 ASSERT( pBox, "Missing table box" );
1749 				if( pBox->getRowSpan() > 0 && ( !bChkProtected ||
1750                     !pBox->GetFrmFmt()->GetProtect().IsCntntProtected() ) )
1751                     rBoxes.Insert( pBox );
1752             }
1753         }
1754         return;
1755     }
1756     bool bCombine = nTop == nBottom;
1757     if( !bCombine )
1758     {
1759         long nMinWidth = nUpperMax - nUpperMin;
1760         long nTmp = nLowerMax - nLowerMin;
1761         if( nMinWidth > nTmp )
1762             nMinWidth = nTmp;
1763         nTmp = nLowerMax < nUpperMax ? nLowerMax : nUpperMax;
1764         nTmp -= ( nLowerMin < nUpperMin ) ? nUpperMin : nLowerMin;
1765         // If the overlapping between upper and lower box is less than half
1766         // of the width (of the smaller cell), bCombine is set,
1767         // e.g. if upper and lower cell are in different columns
1768         bCombine = ( nTmp + nTmp < nMinWidth );
1769     }
1770     if( bCombine )
1771     {
1772         if( nUpperMin < nLowerMin )
1773             nLowerMin = nUpperMin;
1774         else
1775             nUpperMin = nLowerMin;
1776         if( nUpperMax > nLowerMax )
1777             nLowerMax = nUpperMax;
1778         else
1779             nUpperMax = nLowerMax;
1780     }
1781     const bool bColumn = eSearch == SEARCH_COL;
1782     if( bColumn )
1783     {
1784         for( sal_uInt16 i = 0; i < nTop; ++i )
1785             lcl_SearchSelBox( *this, rBoxes, nUpperMin, nUpperMax,
1786                               *aLines[i], bChkProtected, bColumn );
1787     }
1788 
1789     {
1790         long nMin = nUpperMin < nLowerMin ? nUpperMin : nLowerMin;
1791         long nMax = nUpperMax < nLowerMax ? nLowerMax : nUpperMax;
1792         for( sal_uInt16 i = nTop; i <= nBottom; ++i )
1793             lcl_SearchSelBox( *this, rBoxes, nMin, nMax, *aLines[i],
1794                               bChkProtected, bColumn );
1795     }
1796     /* if( nTop + 1 < nBottom )
1797     {
1798         long nInnerMin = nUpperMin < nLowerMin ? nLowerMin : nUpperMin;
1799         long nInnerMax = nUpperMax < nLowerMax ? nUpperMax : nLowerMax;
1800         for( sal_uInt16 i = nTop + 1; i < nBottom; ++i )
1801             lcl_SearchSelBox( *this, rBoxes, nInnerMin, nInnerMax, *aLines[i],
1802                               bChkProtected, bColumn );
1803     }
1804     if( bCombine ) // => nUpperMin == nLowerMin, nUpperMax == nLowerMax
1805     {
1806         if( nBottom > nTop )
1807             lcl_SearchSelBox( *this, rBoxes, nUpperMin, nUpperMax, *aLines[nTop],
1808                               bChkProtected, bColumn );
1809         lcl_SearchSelBox( *this, rBoxes, nLowerMin, nLowerMax, *aLines[nBottom],
1810                           bChkProtected, bColumn );
1811     }
1812     else if( aKeepBoxes.Count() )
1813     {
1814         long nMin = nUpperMin < nLowerMin ? nUpperMin : nLowerMin;
1815         long nMax = nUpperMax < nLowerMax ? nLowerMax : nUpperMax;
1816         SwSelBoxes aCandidates;
1817         for( sal_uInt16 i = nTop; i <= nBottom; ++i )
1818             lcl_SearchSelBox( *this, aCandidates, nMin, nMax, *aLines[i],
1819                               bChkProtected, bColumn );
1820         sal_uInt16 nOld = 0, nNew = 0;
1821         while ( nOld < aKeepBoxes.Count() && nNew < aCandidates.Count() )
1822         {
1823             const SwTableBox* pPOld = *( aKeepBoxes.GetData() + nOld );
1824             SwTableBox* pPNew = *( aCandidates.GetData() + nNew );
1825             if( pPOld == pPNew )
1826             {   // this box will stay
1827                 rBoxes.Insert( pPNew );
1828                 ++nOld;
1829                 ++nNew;
1830             }
1831             else if( pPOld->GetSttIdx() < pPNew->GetSttIdx() )
1832                 ++nOld;
1833             else
1834                 ++nNew;
1835         }
1836     } */
1837     if( bColumn )
1838     {
1839         for( sal_uInt16 i = nBottom + 1; i < nLines; ++i )
1840             lcl_SearchSelBox( *this, rBoxes, nLowerMin, nLowerMax, *aLines[i],
1841                               bChkProtected, true );
1842     }
1843 }
1844 
1845 /** void SwTable::ExpandColumnSelection(..) adds cell to the give selection to
1846     assure that at least one cell of every row is part of the selection.
1847 */
1848 
ExpandColumnSelection(SwSelBoxes & rBoxes,long & rMin,long & rMax) const1849 void SwTable::ExpandColumnSelection( SwSelBoxes& rBoxes, long &rMin, long &rMax ) const
1850 {
1851     ASSERT( bNewModel, "Don't call me for old tables" );
1852     rMin = 0;
1853     rMax = 0;
1854     if( !aLines.Count() || !rBoxes.Count() )
1855         return;
1856 
1857     sal_uInt16 nLineCnt = aLines.Count();
1858     sal_uInt16 nBoxCnt = rBoxes.Count();
1859     sal_uInt16 nBox = 0;
1860     for( sal_uInt16 nRow = 0; nRow < nLineCnt && nBox < nBoxCnt; ++nRow )
1861     {
1862         SwTableLine* pLine = aLines[nRow];
1863         ASSERT( pLine, "Missing table line" );
1864         sal_uInt16 nCols = pLine->GetTabBoxes().Count();
1865         for( sal_uInt16 nCol = 0; nCol < nCols; ++nCol )
1866         {
1867             SwTableBox* pBox = pLine->GetTabBoxes()[nCol];
1868             ASSERT( pBox, "Missing table box" );
1869             if( pBox == rBoxes[nBox] )
1870             {
1871                 lcl_CheckMinMax( rMin, rMax, *pLine, nCol, nBox == 0 );
1872                 if( ++nBox >= nBoxCnt )
1873                     break;
1874             }
1875         }
1876     }
1877     nBox = 0;
1878     for( sal_uInt16 nRow = 0; nRow < nLineCnt; ++nRow )
1879     {
1880         SwTableLine* pLine = aLines[nRow];
1881         sal_uInt16 nCols = pLine->GetTabBoxes().Count();
1882         long nLeft = 0;
1883         long nRight = 0;
1884         for( sal_uInt16 nCurrBox = 0; nCurrBox < nCols; ++nCurrBox )
1885         {
1886             nLeft = nRight;
1887             SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
1888             nRight += pBox->GetFrmFmt()->GetFrmSize().GetWidth();
1889             if( nLeft >= rMin && nRight <= rMax )
1890                 rBoxes.Insert( pBox );
1891         }
1892     }
1893 }
1894 
1895 /** SwTable::PrepareDeleteCol(..) adjusts the widths of the neighbour cells of
1896     a cell selection for an upcoming (column) deletion
1897 */
PrepareDeleteCol(long nMin,long nMax)1898 void SwTable::PrepareDeleteCol( long nMin, long nMax )
1899 {
1900     ASSERT( bNewModel, "Don't call me for old tables" );
1901     if( !aLines.Count() || nMax < nMin )
1902         return;
1903     long nMid = nMin ? ( nMin + nMax ) / 2 : 0;
1904 	const SwTwips nTabSize = GetFrmFmt()->GetFrmSize().GetWidth();
1905     if( nTabSize == nMax )
1906         nMid = nMax;
1907     sal_uInt16 nLineCnt = aLines.Count();
1908     for( sal_uInt16 nRow = 0; nRow < nLineCnt; ++nRow )
1909     {
1910         SwTableLine* pLine = aLines[nRow];
1911         sal_uInt16 nCols = pLine->GetTabBoxes().Count();
1912         long nLeft = 0;
1913         long nRight = 0;
1914         for( sal_uInt16 nCurrBox = 0; nCurrBox < nCols; ++nCurrBox )
1915         {
1916             nLeft = nRight;
1917             SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
1918             nRight += pBox->GetFrmFmt()->GetFrmSize().GetWidth();
1919             if( nRight < nMin )
1920                 continue;
1921             if( nLeft > nMax )
1922                 break;
1923             long nNewWidth = -1;
1924             if( nLeft < nMin )
1925             {
1926                 if( nRight <= nMax )
1927                     nNewWidth = nMid - nLeft;
1928             }
1929             else if( nRight > nMax )
1930                 nNewWidth = nRight - nMid;
1931             else
1932                 nNewWidth = 0;
1933             if( nNewWidth >= 0 )
1934             {
1935                 SwFrmFmt* pFrmFmt = pBox->ClaimFrmFmt();
1936                 SwFmtFrmSize aFrmSz( pFrmFmt->GetFrmSize() );
1937                 aFrmSz.SetWidth( nNewWidth );
1938                 pFrmFmt->SetFmtAttr( aFrmSz );
1939             }
1940         }
1941     }
1942 }
1943 
1944 
1945 
1946 /** SwTable::ExpandSelection(..) adds all boxes to the box selections which are
1947     overlapped by it.
1948 */
1949 
ExpandSelection(SwSelBoxes & rBoxes) const1950 void SwTable::ExpandSelection( SwSelBoxes& rBoxes ) const
1951 {
1952     for( sal_uInt16 i = 0; i < rBoxes.Count(); ++i )
1953     {
1954         SwTableBox *pBox = rBoxes[i];
1955         long nRowSpan = pBox->getRowSpan();
1956         if( nRowSpan != 1 )
1957         {
1958             SwTableBox *pMasterBox = nRowSpan > 0 ? pBox
1959                     : &pBox->FindStartOfRowSpan( *this, USHRT_MAX );
1960             lcl_getAllMergedBoxes( *this, rBoxes, *pMasterBox );
1961         }
1962     }
1963 }
1964 
1965 /** SwTable::CheckRowSpan(..) looks for the next line without an overlapping to
1966     the previous line.
1967 */
1968 
CheckRowSpan(SwTableLinePtr & rpLine,bool bUp) const1969 void SwTable::CheckRowSpan( SwTableLinePtr &rpLine, bool bUp ) const
1970 {
1971     ASSERT( IsNewModel(), "Don't call me for old tables" );
1972     sal_uInt16 nLineIdx = GetTabLines().C40_GETPOS( SwTableLine, rpLine );
1973     ASSERT( nLineIdx < GetTabLines().Count(), "Start line out of range" );
1974     bool bChange = true;
1975     if( bUp )
1976     {
1977         while( bChange )
1978         {
1979             bChange = false;
1980             rpLine = GetTabLines()[ nLineIdx ];
1981             sal_uInt16 nCols = rpLine->GetTabBoxes().Count();
1982             for( sal_uInt16 nCol = 0; !bChange && nCol < nCols; ++nCol )
1983             {
1984                 SwTableBox* pBox = rpLine->GetTabBoxes()[nCol];
1985                 if( pBox->getRowSpan() > 1 || pBox->getRowSpan() < -1 )
1986                     bChange = true;
1987             }
1988             if( bChange )
1989             {
1990                 if( nLineIdx )
1991                     --nLineIdx;
1992                 else
1993                 {
1994                     bChange = false;
1995                     rpLine = 0;
1996                 }
1997             }
1998         }
1999     }
2000     else
2001     {
2002         sal_uInt16 nMaxLine = GetTabLines().Count();
2003         while( bChange )
2004         {
2005             bChange = false;
2006             rpLine = GetTabLines()[ nLineIdx ];
2007             sal_uInt16 nCols = rpLine->GetTabBoxes().Count();
2008             for( sal_uInt16 nCol = 0; !bChange && nCol < nCols; ++nCol )
2009             {
2010                 SwTableBox* pBox = rpLine->GetTabBoxes()[nCol];
2011                 if( pBox->getRowSpan() < 0 )
2012                     bChange = true;
2013             }
2014             if( bChange )
2015             {
2016                 ++nLineIdx;
2017                 if( nLineIdx >= nMaxLine )
2018                 {
2019                     bChange = false;
2020                     rpLine = 0;
2021                 }
2022             }
2023         }
2024     }
2025 }
2026 
2027 // This structure corrects the row span attributes for a top line of a table
2028 // In a top line no negative row span is allowed, so these have to be corrected.
2029 // If there has been at least one correction, all values are stored
2030 // and can be used by undo of table split
SwSaveRowSpan(SwTableBoxes & rBoxes,sal_uInt16 nSplitLn)2031 SwSaveRowSpan::SwSaveRowSpan( SwTableBoxes& rBoxes, sal_uInt16 nSplitLn )
2032     : mnSplitLine( nSplitLn )
2033 {
2034     bool bDontSave = true; // nothing changed, nothing to save
2035     sal_uInt16 nColCount = rBoxes.Count();
2036     ASSERT( nColCount, "Empty Table Line" )
2037     mnRowSpans.resize( nColCount );
2038     for( sal_uInt16 nCurrCol = 0; nCurrCol < nColCount; ++nCurrCol )
2039     {
2040         SwTableBox* pBox = rBoxes[nCurrCol];
2041         ASSERT( pBox, "Missing Table Box" );
2042         long nRowSp = pBox->getRowSpan();
2043         mnRowSpans[ nCurrCol ] = nRowSp;
2044         if( nRowSp < 0 )
2045         {
2046             bDontSave = false;
2047             nRowSp = -nRowSp;
2048             pBox->setRowSpan( nRowSp ); // correction needed
2049         }
2050     }
2051     if( bDontSave )
2052         mnRowSpans.clear();
2053 }
2054 
2055 // This function is called by undo of table split to restore the old row span
2056 // values at the split line
RestoreRowSpan(const SwSaveRowSpan & rSave)2057 void SwTable::RestoreRowSpan( const SwSaveRowSpan& rSave )
2058 {
2059     if( !IsNewModel() ) // for new model only
2060         return;
2061     sal_uInt16 nLineCount = GetTabLines().Count();
2062     ASSERT( rSave.mnSplitLine < nLineCount, "Restore behind last line?" )
2063     if( rSave.mnSplitLine < nLineCount )
2064     {
2065         SwTableLine* pLine = GetTabLines()[rSave.mnSplitLine];
2066         sal_uInt16 nColCount = pLine->GetTabBoxes().Count();
2067         ASSERT( nColCount, "Empty Table Line" )
2068         ASSERT( nColCount == rSave.mnRowSpans.size(), "Wrong row span store" )
2069         if( nColCount == rSave.mnRowSpans.size() )
2070         {
2071             for( sal_uInt16 nCurrCol = 0; nCurrCol < nColCount; ++nCurrCol )
2072             {
2073                 SwTableBox* pBox = pLine->GetTabBoxes()[nCurrCol];
2074                 ASSERT( pBox, "Missing Table Box" );
2075                 long nRowSp = pBox->getRowSpan();
2076                 if( nRowSp != rSave.mnRowSpans[ nCurrCol ] )
2077                 {
2078                     ASSERT( -nRowSp == rSave.mnRowSpans[ nCurrCol ], "Pardon me?!" )
2079                     ASSERT( rSave.mnRowSpans[ nCurrCol ] < 0, "Pardon me?!" )
2080                     pBox->setRowSpan( -nRowSp );
2081 
2082                     sal_uInt16 nLine = rSave.mnSplitLine;
2083                     if( nLine )
2084                     {
2085                         long nLeftBorder = lcl_Box2LeftBorder( *pBox );
2086                         SwTableBox* pNext;
2087                         do
2088                         {
2089                             pNext = lcl_LeftBorder2Box( nLeftBorder, GetTabLines()[--nLine] );
2090                             if( pNext )
2091                             {
2092                                 pBox = pNext;
2093                                 long nNewSpan = pBox->getRowSpan();
2094                                 if( pBox->getRowSpan() < 1 )
2095                                     nNewSpan -= nRowSp;
2096                                 else
2097                                 {
2098                                     nNewSpan += nRowSp;
2099                                     pNext = 0;
2100                                 }
2101                                 pBox->setRowSpan( nNewSpan );
2102                             }
2103                         } while( nLine && pNext );
2104                     }
2105                 }
2106             }
2107         }
2108     }
2109 }
2110 
CleanUpTopRowSpan(sal_uInt16 nSplitLine)2111 SwSaveRowSpan* SwTable::CleanUpTopRowSpan( sal_uInt16 nSplitLine )
2112 {
2113     SwSaveRowSpan* pRet = 0;
2114     if( !IsNewModel() )
2115         return pRet;
2116     pRet = new SwSaveRowSpan( GetTabLines()[0]->GetTabBoxes(), nSplitLine );
2117     if( pRet->mnRowSpans.size() == 0 )
2118     {
2119         delete pRet;
2120         pRet = 0;
2121     }
2122     return pRet;
2123 }
2124 
CleanUpBottomRowSpan(sal_uInt16 nDelLines)2125 void SwTable::CleanUpBottomRowSpan( sal_uInt16 nDelLines )
2126 {
2127     if( !IsNewModel() )
2128         return;
2129     sal_uInt16 nLastLine = GetTabLines().Count()-1;
2130     SwTableLine* pLine = GetTabLines()[nLastLine];
2131     sal_uInt16 nColCount = pLine->GetTabBoxes().Count();
2132     ASSERT( nColCount, "Empty Table Line" )
2133     for( sal_uInt16 nCurrCol = 0; nCurrCol < nColCount; ++nCurrCol )
2134     {
2135         SwTableBox* pBox = pLine->GetTabBoxes()[nCurrCol];
2136         ASSERT( pBox, "Missing Table Box" );
2137         long nRowSp = pBox->getRowSpan();
2138         if( nRowSp < 0 )
2139             nRowSp = -nRowSp;
2140         if( nRowSp > 1 )
2141         {
2142             lcl_ChangeRowSpan( *this, -static_cast<long>(nDelLines), nLastLine, false );
2143             break;
2144         }
2145     }
2146 }
2147 
2148 #ifdef DBG_UTIL
2149 
2150 struct RowSpanCheck
2151 {
2152     long nRowSpan;
2153     SwTwips nLeft;
2154     SwTwips nRight;
2155 };
2156 
CheckConsistency() const2157 void SwTable::CheckConsistency() const
2158 {
2159     if( !IsNewModel() )
2160         return;
2161     sal_uInt16 nLineCount = GetTabLines().Count();
2162 	const SwTwips nTabSize = GetFrmFmt()->GetFrmSize().GetWidth();
2163     SwTwips nLineWidth = 0;
2164     std::list< RowSpanCheck > aRowSpanCells;
2165     std::list< RowSpanCheck >::iterator aIter = aRowSpanCells.end();
2166     for( sal_uInt16 nCurrLine = 0; nCurrLine < nLineCount; ++nCurrLine )
2167     {
2168         SwTwips nWidth = 0;
2169         SwTableLine* pLine = GetTabLines()[nCurrLine];
2170         ASSERT( pLine, "Missing Table Line" )
2171         sal_uInt16 nColCount = pLine->GetTabBoxes().Count();
2172         ASSERT( nColCount, "Empty Table Line" )
2173         for( sal_uInt16 nCurrCol = 0; nCurrCol < nColCount; ++nCurrCol )
2174         {
2175             SwTableBox* pBox = pLine->GetTabBoxes()[nCurrCol];
2176             ASSERT( pBox, "Missing Table Box" );
2177             SwTwips nNewWidth = pBox->GetFrmFmt()->GetFrmSize().GetWidth() + nWidth;
2178             long nRowSp = pBox->getRowSpan();
2179             if( nRowSp < 0 )
2180             {
2181                 ASSERT( aIter != aRowSpanCells.end(), "Missing master box" )
2182 #ifdef DBG_UTIL
2183                 //RowSpanCheck &rCheck = *aIter;
2184 #endif
2185                 ASSERT( aIter->nLeft == nWidth && aIter->nRight == nNewWidth,
2186                     "Wrong position/size of overlapped table box" );
2187                 --(aIter->nRowSpan);
2188                 ASSERT( aIter->nRowSpan == -nRowSp, "Wrong row span value" );
2189                 if( nRowSp == -1 )
2190                 {
2191                     std::list< RowSpanCheck >::iterator aEraseIter = aIter;
2192                     ++aIter;
2193                     aRowSpanCells.erase( aEraseIter );
2194                 }
2195                 else
2196                     ++aIter;
2197             }
2198             else if( nRowSp != 1 )
2199             {
2200                 ASSERT( nRowSp, "Zero row span?!" );
2201                 RowSpanCheck aEntry;
2202                 aEntry.nLeft = nWidth;
2203                 aEntry.nRight = nNewWidth;
2204                 aEntry.nRowSpan = nRowSp;
2205                 aRowSpanCells.insert( aIter, aEntry );
2206             }
2207             nWidth = nNewWidth;
2208         }
2209         if( !nCurrLine )
2210             nLineWidth = nWidth;
2211         ASSERT( nWidth == nLineWidth, "Different Line Widths" )
2212         ASSERT( nWidth == nTabSize, "Boxen der Line zu klein/gross" )
2213         ASSERT( nWidth >= 0 && nWidth <= USHRT_MAX, "Width out of range" )
2214         ASSERT( aIter == aRowSpanCells.end(), "Missing overlapped box" )
2215         aIter = aRowSpanCells.begin();
2216     }
2217     bool bEmpty = aRowSpanCells.empty();
2218     ASSERT( bEmpty, "Open row span detected" )
2219 }
2220 
2221 #endif
2222 
2223 
2224 #ifdef FINDSTARTENDOFROWSPANCACHE
2225 /*
2226  * A small optimization for FindStartEndOfRowSpan START
2227  *
2228  * NOTE: Results of some measurement revealed that this cache
2229  * does not improve performance!
2230  */
2231 
2232 class SwFindRowSpanCache
2233 {
2234 private:
2235 
2236     struct SwFindRowSpanCacheObj
2237     {
2238         const SwTableBox* mpKeyBox;
2239         const SwTableBox* mpCacheBox;
2240         sal_uInt16 mnSteps;
2241         bool mbStart;
2242 
SwFindRowSpanCacheObjSwFindRowSpanCache::SwFindRowSpanCacheObj2243         SwFindRowSpanCacheObj( const SwTableBox& rKeyBox, const SwTableBox& rCacheBox, sal_uInt16 nSteps, bool bStart ) :
2244             mpKeyBox( &rKeyBox ), mpCacheBox( &rCacheBox ), mnSteps( nSteps ), mbStart( bStart ) {}
2245     };
2246 
2247     std::list< SwFindRowSpanCacheObj > aCache;
2248     bool mbUseCache;
2249     static SwFindRowSpanCache* mpFindRowSpanCache;
2250     SwFindRowSpanCache();
2251 
2252 public:
2253 
2254     static SwFindRowSpanCache& getSwFindRowSpanCache();
2255     const SwTableBox* FindCachedStartEndOfRowSpan( const SwTableBox& rKeyBox, sal_uInt16 nSteps, bool bStart );
2256     void SetCachedStartEndOfRowSpan( const SwTableBox& rKeyBox, const SwTableBox& rCacheBox, sal_uInt16 nSteps, bool bStart );
2257     void SetUseCache( bool bNew );
2258 };
2259 
2260 SwFindRowSpanCache* SwFindRowSpanCache::mpFindRowSpanCache = 0;
getSwFindRowSpanCache()2261 SwFindRowSpanCache& SwFindRowSpanCache::getSwFindRowSpanCache()
2262 {
2263     if ( !mpFindRowSpanCache ) mpFindRowSpanCache = new SwFindRowSpanCache;
2264     return *mpFindRowSpanCache;
2265 }
2266 
SwFindRowSpanCache()2267 SwFindRowSpanCache::SwFindRowSpanCache() : mbUseCache( false )
2268 {
2269 }
2270 
SetUseCache(bool bNew)2271 void SwFindRowSpanCache::SetUseCache( bool bNew )
2272 {
2273     mbUseCache = bNew; aCache.clear();
2274 }
2275 
FindCachedStartEndOfRowSpan(const SwTableBox & rKeyBox,sal_uInt16 nSteps,bool bStart)2276 const SwTableBox* SwFindRowSpanCache::FindCachedStartEndOfRowSpan( const SwTableBox& rKeyBox,
2277                                                                    sal_uInt16 nSteps,
2278                                                                    bool bStart )
2279 {
2280     static nCallCount = 0;
2281     static nSuccessCount = 0;
2282     ++nCallCount;
2283 
2284     if ( !mbUseCache ) return 0;
2285 
2286     const SwTableBox* pRet = 0;
2287 
2288     std::list< SwFindRowSpanCacheObj >::const_iterator aIter;
2289     for ( aIter = aCache.begin(); aIter != aCache.end(); ++aIter )
2290     {
2291         if ( aIter->mpKeyBox == &rKeyBox &&
2292              aIter->mnSteps == nSteps &&
2293              aIter->mbStart == bStart )
2294         {
2295             pRet = aIter->mpCacheBox;
2296             ++nSuccessCount;
2297             break;
2298         }
2299     }
2300 
2301     return pRet;
2302 }
2303 
2304 const int FindBoxCacheSize = 2;
2305 
SetCachedStartEndOfRowSpan(const SwTableBox & rKeyBox,const SwTableBox & rCacheBox,sal_uInt16 nSteps,bool bStart)2306 void SwFindRowSpanCache::SetCachedStartEndOfRowSpan( const SwTableBox& rKeyBox,
2307                                                      const SwTableBox& rCacheBox,
2308                                                      sal_uInt16 nSteps,
2309                                                      bool bStart )
2310 {
2311     if ( !mbUseCache ) return;
2312 
2313     const SwFindRowSpanCacheObj aNew( rKeyBox, rCacheBox, nSteps, bStart );
2314     aCache.push_front( aNew );
2315     if ( aCache.size() > FindBoxCacheSize )
2316         aCache.pop_back();
2317 }
2318 
2319 /*
2320  * A small optimization for FindStartEndOfRowSpan END
2321  */
2322 
2323 #endif
2324 
2325