LCOV - code coverage report
Current view: top level - sw/source/core/docnode - ndtbl1.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 827 0.0 %
Date: 2014-04-14 Functions: 0 36 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "hintids.hxx"
      21             : #include <editeng/lrspitem.hxx>
      22             : #include <editeng/boxitem.hxx>
      23             : #include <editeng/brushitem.hxx>
      24             : #include <editeng/frmdiritem.hxx>
      25             : #include <fmtornt.hxx>
      26             : #include <fmtfsize.hxx>
      27             : #include <fmtlsplt.hxx>
      28             : #include <fmtrowsplt.hxx>
      29             : #include <tabcol.hxx>
      30             : #include <frmatr.hxx>
      31             : #include <cellfrm.hxx>
      32             : #include <tabfrm.hxx>
      33             : #include <cntfrm.hxx>
      34             : #include <txtfrm.hxx>
      35             : #include <svx/svxids.hrc>
      36             : #include <doc.hxx>
      37             : #include <IDocumentUndoRedo.hxx>
      38             : #include "pam.hxx"
      39             : #include "swcrsr.hxx"
      40             : #include "viscrs.hxx"
      41             : #include "swtable.hxx"
      42             : #include "htmltbl.hxx"
      43             : #include "tblsel.hxx"
      44             : #include "swtblfmt.hxx"
      45             : #include "docary.hxx"
      46             : #include "ndindex.hxx"
      47             : #include "undobj.hxx"
      48             : #include "switerator.hxx"
      49             : #include <UndoTable.hxx>
      50             : #include <boost/foreach.hpp>
      51             : 
      52             : using ::editeng::SvxBorderLine;
      53             : using namespace ::com::sun::star;
      54             : 
      55             : extern void ClearFEShellTabCols();
      56             : 
      57             : // See swtable.cxx too
      58             : #define COLFUZZY 20L
      59             : 
      60           0 : inline bool IsSame( long nA, long nB ) { return  std::abs(nA-nB) <= COLFUZZY; }
      61             : 
      62             : class SwTblFmtCmp
      63             : {
      64             : public:
      65             :     SwFrmFmt *pOld,
      66             :              *pNew;
      67             :     sal_Int16     nType;
      68             : 
      69             :     SwTblFmtCmp( SwFrmFmt *pOld, SwFrmFmt *pNew, sal_Int16 nType );
      70             : 
      71             :     static SwFrmFmt *FindNewFmt( std::vector<SwTblFmtCmp*> &rArr, SwFrmFmt*pOld, sal_Int16 nType );
      72             :     static void Delete( std::vector<SwTblFmtCmp*> &rArr );
      73             : };
      74             : 
      75           0 : SwTblFmtCmp::SwTblFmtCmp( SwFrmFmt *pO, SwFrmFmt *pN, sal_Int16 nT )
      76           0 :     : pOld ( pO ), pNew ( pN ), nType( nT )
      77             : {
      78           0 : }
      79             : 
      80           0 : SwFrmFmt *SwTblFmtCmp::FindNewFmt( std::vector<SwTblFmtCmp*> &rArr, SwFrmFmt *pOld, sal_Int16 nType )
      81             : {
      82           0 :     for ( sal_uInt16 i = 0; i < rArr.size(); ++i )
      83             :     {
      84           0 :         SwTblFmtCmp *pCmp = rArr[i];
      85           0 :         if ( pCmp->pOld == pOld && pCmp->nType == nType )
      86           0 :             return pCmp->pNew;
      87             :     }
      88           0 :     return 0;
      89             : }
      90             : 
      91           0 : void SwTblFmtCmp::Delete( std::vector<SwTblFmtCmp*> &rArr )
      92             : {
      93           0 :     for ( sal_uInt16 i = 0; i < rArr.size(); ++i )
      94           0 :         delete rArr[i];
      95           0 : }
      96             : 
      97           0 : static void lcl_GetStartEndCell( const SwCursor& rCrsr,
      98             :                         SwLayoutFrm *&prStart, SwLayoutFrm *&prEnd )
      99             : {
     100             :     OSL_ENSURE( rCrsr.GetCntntNode() && rCrsr.GetCntntNode( false ),
     101             :             "Tab selection not at ContentNode" );
     102             : 
     103           0 :     Point aPtPos, aMkPos;
     104           0 :     const SwShellCrsr* pShCrsr = dynamic_cast<const SwShellCrsr*>(&rCrsr);
     105           0 :     if( pShCrsr )
     106             :     {
     107           0 :         aPtPos = pShCrsr->GetPtPos();
     108           0 :         aMkPos = pShCrsr->GetMkPos();
     109             :     }
     110             : 
     111             :     // Robust:
     112           0 :     SwCntntNode* pPointNd = rCrsr.GetCntntNode();
     113           0 :     SwCntntNode* pMarkNd  = rCrsr.GetCntntNode(false);
     114             : 
     115           0 :     SwFrm* pPointFrm = pPointNd ? pPointNd->getLayoutFrm( pPointNd->GetDoc()->GetCurrentLayout(), &aPtPos ) : 0;
     116           0 :     SwFrm* pMarkFrm  = pMarkNd  ? pMarkNd->getLayoutFrm( pMarkNd->GetDoc()->GetCurrentLayout(), &aMkPos )  : 0;
     117             : 
     118           0 :     prStart = pPointFrm ? pPointFrm->GetUpper() : 0;
     119           0 :     prEnd   = pMarkFrm  ? pMarkFrm->GetUpper() : 0;
     120           0 : }
     121             : 
     122           0 : static bool lcl_GetBoxSel( const SwCursor& rCursor, SwSelBoxes& rBoxes,
     123             :                     bool bAllCrsr = false )
     124             : {
     125             :     const SwTableCursor* pTblCrsr =
     126           0 :         dynamic_cast<const SwTableCursor*>(&rCursor);
     127           0 :     if( pTblCrsr )
     128           0 :         ::GetTblSelCrs( *pTblCrsr, rBoxes );
     129             :     else
     130             :     {
     131           0 :         const SwPaM *pCurPam = &rCursor, *pSttPam = pCurPam;
     132           0 :         do {
     133           0 :             const SwNode* pNd = pCurPam->GetNode()->FindTableBoxStartNode();
     134           0 :             if( pNd )
     135             :             {
     136           0 :                 SwTableBox* pBox = (SwTableBox*)pNd->FindTableNode()->GetTable().
     137           0 :                                             GetTblBox( pNd->GetIndex() );
     138           0 :                 rBoxes.insert( pBox );
     139             :             }
     140           0 :         } while( bAllCrsr &&
     141           0 :                 pSttPam != ( pCurPam = (SwPaM*)pCurPam->GetNext()) );
     142             :     }
     143           0 :     return !rBoxes.empty();
     144             : }
     145             : 
     146           0 : inline void InsertLine( std::vector<SwTableLine*>& rLineArr, SwTableLine* pLine )
     147             : {
     148           0 :     if( rLineArr.end() == std::find( rLineArr.begin(), rLineArr.end(), pLine ) )
     149           0 :         rLineArr.push_back( pLine );
     150           0 : }
     151             : 
     152           0 : static bool lcl_IsAnLower( const SwTableLine *pLine, const SwTableLine *pAssumed )
     153             : {
     154           0 :     const SwTableLine *pTmp = pAssumed->GetUpper() ?
     155           0 :                                     pAssumed->GetUpper()->GetUpper() : 0;
     156           0 :     while ( pTmp )
     157             :     {
     158           0 :         if ( pTmp == pLine )
     159           0 :             return true;
     160           0 :         pTmp = pTmp->GetUpper() ? pTmp->GetUpper()->GetUpper() : 0;
     161             :     }
     162           0 :     return false;
     163             : }
     164             : 
     165             : struct LinesAndTable
     166             : {
     167             :     std::vector<SwTableLine*> &rLines;
     168             :     const SwTable             &rTable;
     169             :     bool                      bInsertLines;
     170             : 
     171           0 :     LinesAndTable( std::vector<SwTableLine*> &rL, const SwTable &rTbl ) :
     172           0 :           rLines( rL ), rTable( rTbl ), bInsertLines( true ) {}
     173             : };
     174             : 
     175             : bool _FindLine( _FndLine & rLine, LinesAndTable* pPara );
     176             : 
     177           0 : bool _FindBox( _FndBox & rBox, LinesAndTable* pPara )
     178             : {
     179           0 :     if (!rBox.GetLines().empty())
     180             :     {
     181           0 :         pPara->bInsertLines = true;
     182           0 :         BOOST_FOREACH( _FndLine & rFndLine, rBox.GetLines() )
     183           0 :             _FindLine( rFndLine, pPara );
     184           0 :         if ( pPara->bInsertLines )
     185             :         {
     186           0 :             const SwTableLines &rLines = (rBox.GetBox())
     187           0 :                                     ? rBox.GetBox()->GetTabLines()
     188           0 :                                     : pPara->rTable.GetTabLines();
     189           0 :             if (rBox.GetLines().size() == rLines.size())
     190             :             {
     191           0 :                 for ( sal_uInt16 i = 0; i < rLines.size(); ++i )
     192             :                     ::InsertLine( pPara->rLines,
     193           0 :                                   (SwTableLine*)rLines[i] );
     194             :             }
     195             :             else
     196           0 :                 pPara->bInsertLines = false;
     197             :         }
     198             :     }
     199           0 :     else if (rBox.GetBox())
     200             :     {
     201             :         ::InsertLine( pPara->rLines,
     202           0 :                       static_cast<SwTableLine*>(rBox.GetBox()->GetUpper()));
     203             :     }
     204           0 :     return true;
     205             : }
     206             : 
     207           0 : bool _FindLine( _FndLine& rLine, LinesAndTable* pPara )
     208             : {
     209           0 :     for (_FndBoxes::iterator it = rLine.GetBoxes().begin();
     210           0 :          it != rLine.GetBoxes().end(); ++it)
     211             :     {
     212           0 :         _FindBox(*it, pPara);
     213             :     }
     214           0 :     return true;
     215             : }
     216             : 
     217           0 : static void lcl_CollectLines( std::vector<SwTableLine*> &rArr, const SwCursor& rCursor, bool bRemoveLines )
     218             : {
     219             :     // Collect the selected Boxes first
     220           0 :     SwSelBoxes aBoxes;
     221           0 :     if( !::lcl_GetBoxSel( rCursor, aBoxes ))
     222           0 :         return ;
     223             : 
     224             :     // Copy the selected structure
     225           0 :     const SwTable &rTable = aBoxes[0]->GetSttNd()->FindTableNode()->GetTable();
     226           0 :     LinesAndTable aPara( rArr, rTable );
     227           0 :     _FndBox aFndBox( 0, 0 );
     228             :     {
     229           0 :         _FndPara aTmpPara( aBoxes, &aFndBox );
     230           0 :         ForEach_FndLineCopyCol( (SwTableLines&)rTable.GetTabLines(), &aTmpPara );
     231             :     }
     232             : 
     233             :     // Collect the Lines which only contain selected Boxes
     234           0 :     ::_FindBox(aFndBox, &aPara);
     235             : 
     236             :     // Remove lines, that have a common superordinate row.
     237             :     // (Not for row split)
     238           0 :     if ( bRemoveLines )
     239             :     {
     240           0 :         for ( sal_uInt16 i = 0; i < rArr.size(); ++i )
     241             :         {
     242           0 :             SwTableLine *pUpLine = rArr[i];
     243           0 :             for ( sal_uInt16 k = 0; k < rArr.size(); ++k )
     244             :             {
     245           0 :                 if ( k != i && ::lcl_IsAnLower( pUpLine, rArr[k] ) )
     246             :                 {
     247           0 :                     rArr.erase( rArr.begin() + k );
     248           0 :                     if ( k <= i )
     249           0 :                         --i;
     250           0 :                     --k;
     251             :                 }
     252             :             }
     253             :         }
     254           0 :     }
     255             : }
     256             : 
     257           0 : static void lcl_ProcessRowAttr( std::vector<SwTblFmtCmp*>& rFmtCmp, SwTableLine* pLine, const SfxPoolItem& rNew )
     258             : {
     259             :     SwFrmFmt *pNewFmt;
     260           0 :     if ( 0 != (pNewFmt = SwTblFmtCmp::FindNewFmt( rFmtCmp, pLine->GetFrmFmt(), 0 )))
     261           0 :         pLine->ChgFrmFmt( (SwTableLineFmt*)pNewFmt );
     262             :     else
     263             :     {
     264           0 :         SwFrmFmt *pOld = pLine->GetFrmFmt();
     265           0 :         SwFrmFmt *pNew = pLine->ClaimFrmFmt();
     266           0 :         pNew->SetFmtAttr( rNew );
     267           0 :         rFmtCmp.push_back( new SwTblFmtCmp( pOld, pNew, 0 ) );
     268             :     }
     269           0 : }
     270             : 
     271             : static void lcl_ProcessBoxSize( std::vector<SwTblFmtCmp*> &rFmtCmp, SwTableBox *pBox, const SwFmtFrmSize &rNew );
     272             : 
     273           0 : static void lcl_ProcessRowSize( std::vector<SwTblFmtCmp*> &rFmtCmp, SwTableLine *pLine, const SwFmtFrmSize &rNew )
     274             : {
     275           0 :     lcl_ProcessRowAttr( rFmtCmp, pLine, rNew );
     276           0 :     SwTableBoxes &rBoxes = pLine->GetTabBoxes();
     277           0 :     for ( sal_uInt16 i = 0; i < rBoxes.size(); ++i )
     278           0 :         ::lcl_ProcessBoxSize( rFmtCmp, rBoxes[i], rNew );
     279           0 : }
     280             : 
     281           0 : static void lcl_ProcessBoxSize( std::vector<SwTblFmtCmp*> &rFmtCmp, SwTableBox *pBox, const SwFmtFrmSize &rNew )
     282             : {
     283           0 :     SwTableLines &rLines = pBox->GetTabLines();
     284           0 :     if ( !rLines.empty() )
     285             :     {
     286           0 :         SwFmtFrmSize aSz( rNew );
     287           0 :         aSz.SetHeight( rNew.GetHeight() ? rNew.GetHeight() / rLines.size() : 0 );
     288           0 :         for ( sal_uInt16 i = 0; i < rLines.size(); ++i )
     289           0 :             ::lcl_ProcessRowSize( rFmtCmp, rLines[i], aSz );
     290             :     }
     291           0 : }
     292             : 
     293           0 : void SwDoc::SetRowSplit( const SwCursor& rCursor, const SwFmtRowSplit &rNew )
     294             : {
     295           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
     296           0 :     if( pTblNd )
     297             :     {
     298           0 :         std::vector<SwTableLine*> aRowArr; // For Lines collecting
     299           0 :         ::lcl_CollectLines( aRowArr, rCursor, false );
     300             : 
     301           0 :         if( !aRowArr.empty() )
     302             :         {
     303           0 :             if (GetIDocumentUndoRedo().DoesUndo())
     304             :             {
     305           0 :                 GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTbl(*pTblNd));
     306             :             }
     307             : 
     308           0 :             std::vector<SwTblFmtCmp*> aFmtCmp;
     309           0 :             aFmtCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
     310             : 
     311           0 :             for( sal_uInt16 i = 0; i < aRowArr.size(); ++i )
     312           0 :                 ::lcl_ProcessRowAttr( aFmtCmp, aRowArr[i], rNew );
     313             : 
     314           0 :             SwTblFmtCmp::Delete( aFmtCmp );
     315           0 :             SetModified();
     316           0 :         }
     317             :     }
     318           0 : }
     319             : 
     320           0 : void SwDoc::GetRowSplit( const SwCursor& rCursor, SwFmtRowSplit *& rpSz ) const
     321             : {
     322           0 :     rpSz = 0;
     323             : 
     324           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
     325           0 :     if( pTblNd )
     326             :     {
     327           0 :         std::vector<SwTableLine*> aRowArr; // For Lines collecting
     328           0 :         ::lcl_CollectLines( aRowArr, rCursor, false );
     329             : 
     330           0 :         if( !aRowArr.empty() )
     331             :         {
     332           0 :             rpSz = &(SwFmtRowSplit&)aRowArr[0]->GetFrmFmt()->GetRowSplit();
     333             : 
     334           0 :             for ( sal_uInt16 i = 1; i < aRowArr.size() && rpSz; ++i )
     335             :             {
     336           0 :                 if ( (*rpSz).GetValue() != aRowArr[i]->GetFrmFmt()->GetRowSplit().GetValue() )
     337           0 :                     rpSz = 0;
     338             :             }
     339           0 :             if ( rpSz )
     340           0 :                 rpSz = new SwFmtRowSplit( *rpSz );
     341           0 :         }
     342             :     }
     343           0 : }
     344             : 
     345             : /* Class:  SwDoc
     346             :  * Methods:  SetRowHeight(), GetRowHeight()
     347             :  *
     348             :  * The line height is calculated from the Selection.
     349             :  * Starting with every Cell within the Selection, all Cells are iterated
     350             :  * through in an upwards fashion.
     351             :  *
     352             :  * The topmost Line gets the requested value, all Lines below it get
     353             :  * a respective value that is calculated from the relation of the old and
     354             :  * new size of the topmost Line in the lower line's own size.
     355             :  *
     356             :  * All changed Lines may get an own FrmFmt.
     357             :  * Of course we can only touch every Line once.
     358             :  */
     359             : 
     360           0 : void SwDoc::SetRowHeight( const SwCursor& rCursor, const SwFmtFrmSize &rNew )
     361             : {
     362           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
     363           0 :     if( pTblNd )
     364             :     {
     365           0 :         std::vector<SwTableLine*> aRowArr; // For Lines collecting
     366           0 :         ::lcl_CollectLines( aRowArr, rCursor, true );
     367             : 
     368           0 :         if( !aRowArr.empty() )
     369             :         {
     370           0 :             if (GetIDocumentUndoRedo().DoesUndo())
     371             :             {
     372           0 :                 GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTbl(*pTblNd));
     373             :             }
     374             : 
     375           0 :             std::vector<SwTblFmtCmp*> aFmtCmp;
     376           0 :             aFmtCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
     377           0 :             for ( sal_uInt16 i = 0; i < aRowArr.size(); ++i )
     378           0 :                 ::lcl_ProcessRowSize( aFmtCmp, aRowArr[i], rNew );
     379           0 :             SwTblFmtCmp::Delete( aFmtCmp );
     380             : 
     381           0 :             SetModified();
     382           0 :         }
     383             :     }
     384           0 : }
     385             : 
     386           0 : void SwDoc::GetRowHeight( const SwCursor& rCursor, SwFmtFrmSize *& rpSz ) const
     387             : {
     388           0 :     rpSz = 0;
     389             : 
     390           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
     391           0 :     if( pTblNd )
     392             :     {
     393           0 :         std::vector<SwTableLine*> aRowArr; // For Lines collecting
     394           0 :         ::lcl_CollectLines( aRowArr, rCursor, true );
     395             : 
     396           0 :         if( !aRowArr.empty() )
     397             :         {
     398           0 :             rpSz = &(SwFmtFrmSize&)aRowArr[0]->GetFrmFmt()->GetFrmSize();
     399             : 
     400           0 :             for ( sal_uInt16 i = 1; i < aRowArr.size() && rpSz; ++i )
     401             :             {
     402           0 :                 if ( *rpSz != aRowArr[i]->GetFrmFmt()->GetFrmSize() )
     403           0 :                     rpSz = 0;
     404             :             }
     405           0 :             if ( rpSz )
     406           0 :                 rpSz = new SwFmtFrmSize( *rpSz );
     407           0 :         }
     408             :     }
     409           0 : }
     410             : 
     411           0 : sal_Bool SwDoc::BalanceRowHeight( const SwCursor& rCursor, sal_Bool bTstOnly )
     412             : {
     413           0 :     sal_Bool bRet = sal_False;
     414           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
     415           0 :     if( pTblNd )
     416             :     {
     417           0 :         std::vector<SwTableLine*> aRowArr; // For Lines collecting
     418           0 :         ::lcl_CollectLines( aRowArr, rCursor, true );
     419             : 
     420           0 :         if( 1 < aRowArr.size() )
     421             :         {
     422           0 :             if( !bTstOnly )
     423             :             {
     424           0 :                 long nHeight = 0;
     425             :                 sal_uInt16 i;
     426             : 
     427           0 :                 for ( i = 0; i < aRowArr.size(); ++i )
     428             :                 {
     429           0 :                     SwIterator<SwFrm,SwFmt> aIter( *aRowArr[i]->GetFrmFmt() );
     430           0 :                     SwFrm* pFrm = aIter.First();
     431           0 :                     while ( pFrm )
     432             :                     {
     433           0 :                         nHeight = std::max( nHeight, pFrm->Frm().Height() );
     434           0 :                         pFrm = aIter.Next();
     435             :                     }
     436           0 :                 }
     437           0 :                 SwFmtFrmSize aNew( ATT_MIN_SIZE, 0, nHeight );
     438             : 
     439           0 :                 if (GetIDocumentUndoRedo().DoesUndo())
     440             :                 {
     441           0 :                     GetIDocumentUndoRedo().AppendUndo(
     442           0 :                             new SwUndoAttrTbl(*pTblNd));
     443             :                 }
     444             : 
     445           0 :                 std::vector<SwTblFmtCmp*> aFmtCmp;
     446           0 :                 aFmtCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
     447           0 :                 for( i = 0; i < aRowArr.size(); ++i )
     448           0 :                     ::lcl_ProcessRowSize( aFmtCmp, (SwTableLine*)aRowArr[i], aNew );
     449           0 :                 SwTblFmtCmp::Delete( aFmtCmp );
     450             : 
     451           0 :                 SetModified();
     452             :             }
     453           0 :             bRet = sal_True;
     454           0 :         }
     455             :     }
     456           0 :     return bRet;
     457             : }
     458             : 
     459           0 : void SwDoc::SetRowBackground( const SwCursor& rCursor, const SvxBrushItem &rNew )
     460             : {
     461           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
     462           0 :     if( pTblNd )
     463             :     {
     464           0 :         std::vector<SwTableLine*> aRowArr; // For Lines collecting
     465           0 :         ::lcl_CollectLines( aRowArr, rCursor, true );
     466             : 
     467           0 :         if( !aRowArr.empty() )
     468             :         {
     469           0 :             if (GetIDocumentUndoRedo().DoesUndo())
     470             :             {
     471           0 :                 GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTbl(*pTblNd));
     472             :             }
     473             : 
     474           0 :             std::vector<SwTblFmtCmp*> aFmtCmp;
     475           0 :             aFmtCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
     476             : 
     477           0 :             for( sal_uInt16 i = 0; i < aRowArr.size(); ++i )
     478           0 :                 ::lcl_ProcessRowAttr( aFmtCmp, aRowArr[i], rNew );
     479             : 
     480           0 :             SwTblFmtCmp::Delete( aFmtCmp );
     481           0 :             SetModified();
     482           0 :         }
     483             :     }
     484           0 : }
     485             : 
     486           0 : sal_Bool SwDoc::GetRowBackground( const SwCursor& rCursor, SvxBrushItem &rToFill ) const
     487             : {
     488           0 :     sal_Bool bRet = sal_False;
     489           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
     490           0 :     if( pTblNd )
     491             :     {
     492           0 :         std::vector<SwTableLine*> aRowArr; // For Lines collecting
     493           0 :         ::lcl_CollectLines( aRowArr, rCursor, true );
     494             : 
     495           0 :         if( !aRowArr.empty() )
     496             :         {
     497           0 :             rToFill = aRowArr[0]->GetFrmFmt()->GetBackground();
     498             : 
     499           0 :             bRet = sal_True;
     500           0 :             for ( sal_uInt16 i = 1; i < aRowArr.size(); ++i )
     501           0 :                 if ( rToFill != aRowArr[i]->GetFrmFmt()->GetBackground() )
     502             :                 {
     503           0 :                     bRet = sal_False;
     504           0 :                     break;
     505             :                 }
     506           0 :         }
     507             :     }
     508           0 :     return bRet;
     509             : }
     510             : 
     511           0 : inline void InsertCell( std::vector<SwCellFrm*>& rCellArr, SwCellFrm* pCellFrm )
     512             : {
     513           0 :     if( rCellArr.end() == std::find( rCellArr.begin(), rCellArr.end(), pCellFrm ) )
     514           0 :         rCellArr.push_back( pCellFrm );
     515           0 : }
     516             : 
     517           0 : static void lcl_CollectCells( std::vector<SwCellFrm*> &rArr, const SwRect &rUnion,
     518             :                           SwTabFrm *pTab )
     519             : {
     520           0 :     SwLayoutFrm *pCell = pTab->FirstCell();
     521           0 :     do
     522             :     {
     523             :         // If the Cell contains a CellFrame, we need to use it
     524             :         // in order to get to the Cell
     525           0 :         while ( !pCell->IsCellFrm() )
     526           0 :             pCell = pCell->GetUpper();
     527             :         OSL_ENSURE( pCell, "Frame is not a Cell" );
     528           0 :         if ( rUnion.IsOver( pCell->Frm() ) )
     529           0 :             ::InsertCell( rArr, (SwCellFrm*)pCell );
     530             : 
     531             :         // Make sure the Cell is left (Areas)
     532           0 :         SwLayoutFrm *pTmp = pCell;
     533           0 :         do
     534           0 :         {   pTmp = pTmp->GetNextLayoutLeaf();
     535           0 :         } while ( pCell->IsAnLower( pTmp ) );
     536           0 :         pCell = pTmp;
     537           0 :     } while( pCell && pTab->IsAnLower( pCell ) );
     538           0 : }
     539             : 
     540           0 : void SwDoc::SetTabBorders( const SwCursor& rCursor, const SfxItemSet& rSet )
     541             : {
     542           0 :     SwCntntNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetCntntNode();
     543           0 :     SwTableNode* pTblNd = pCntNd ? pCntNd->FindTableNode() : 0;
     544           0 :     if( !pTblNd )
     545           0 :         return ;
     546             : 
     547             :     SwLayoutFrm *pStart, *pEnd;
     548           0 :     ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
     549             : 
     550           0 :     SwSelUnions aUnions;
     551           0 :     ::MakeSelUnions( aUnions, pStart, pEnd );
     552             : 
     553           0 :     if( !aUnions.empty() )
     554             :     {
     555           0 :         SwTable& rTable = pTblNd->GetTable();
     556           0 :         if (GetIDocumentUndoRedo().DoesUndo())
     557             :         {
     558           0 :             GetIDocumentUndoRedo().AppendUndo( new SwUndoAttrTbl(*pTblNd) );
     559             :         }
     560             : 
     561           0 :         std::vector<SwTblFmtCmp*> aFmtCmp;
     562           0 :         aFmtCmp.reserve( 255 );
     563             :         const SvxBoxItem* pSetBox;
     564             :         const SvxBoxInfoItem *pSetBoxInfo;
     565             : 
     566           0 :         const SvxBorderLine* pLeft = 0;
     567           0 :         const SvxBorderLine* pRight = 0;
     568           0 :         const SvxBorderLine* pTop = 0;
     569           0 :         const SvxBorderLine* pBottom = 0;
     570           0 :         const SvxBorderLine* pHori = 0;
     571           0 :         const SvxBorderLine* pVert = 0;
     572           0 :         sal_Bool bHoriValid = sal_True, bVertValid = sal_True,
     573           0 :              bTopValid = sal_True, bBottomValid = sal_True,
     574           0 :              bLeftValid = sal_True, bRightValid = sal_True;
     575             : 
     576             :         // The Flags in the BoxInfo Item decide whether a BorderLine is valid!
     577           0 :         if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_BORDER_INNER, false,
     578           0 :             (const SfxPoolItem**)&pSetBoxInfo) )
     579             :         {
     580           0 :             pHori = pSetBoxInfo->GetHori();
     581           0 :             pVert = pSetBoxInfo->GetVert();
     582             : 
     583           0 :             bHoriValid = pSetBoxInfo->IsValid(VALID_HORI);
     584           0 :             bVertValid = pSetBoxInfo->IsValid(VALID_VERT);
     585             : 
     586             :             // Do we want to evaluate these?
     587           0 :             bTopValid = pSetBoxInfo->IsValid(VALID_TOP);
     588           0 :             bBottomValid = pSetBoxInfo->IsValid(VALID_BOTTOM);
     589           0 :             bLeftValid = pSetBoxInfo->IsValid(VALID_LEFT);
     590           0 :             bRightValid = pSetBoxInfo->IsValid(VALID_RIGHT);
     591             :         }
     592             : 
     593           0 :         if( SFX_ITEM_SET == rSet.GetItemState( RES_BOX, false,
     594           0 :             (const SfxPoolItem**)&pSetBox) )
     595             :         {
     596           0 :             pLeft = pSetBox->GetLeft();
     597           0 :             pRight = pSetBox->GetRight();
     598           0 :             pTop = pSetBox->GetTop();
     599           0 :             pBottom = pSetBox->GetBottom();
     600             :         }
     601             :         else
     602             :         {
     603             :             // Not set, thus not valid values
     604           0 :             bTopValid = bBottomValid = bLeftValid = bRightValid = sal_False;
     605           0 :             pSetBox = 0;
     606             :         }
     607             : 
     608           0 :         bool bFirst = true;
     609           0 :         for ( sal_uInt16 i = 0; i < aUnions.size(); ++i )
     610             :         {
     611           0 :             SwSelUnion *pUnion = &aUnions[i];
     612           0 :             SwTabFrm *pTab = pUnion->GetTable();
     613           0 :             const SwRect &rUnion = pUnion->GetUnion();
     614           0 :             const bool bLast  = (i == aUnions.size() - 1);
     615             : 
     616           0 :             std::vector<SwCellFrm*> aCellArr;
     617           0 :             aCellArr.reserve( 255 );
     618           0 :             ::lcl_CollectCells( aCellArr, pUnion->GetUnion(), pTab );
     619             : 
     620             :             // All Cell Borders that match the UnionRect or extend it are
     621             :             // Outer Borders. All others are Inner Borders.
     622             : 
     623             :             // New: The Outer Borders can, depending on whether it's a
     624             :             // Start/Middle/Follow Table (for Selection via FollowTabs),
     625             :             // also not be Outer Borders.
     626             :             // Outer Borders are set on the left, right, at the top and at the bottom.
     627             :             // Inner Borders are only set at the top and on the left.
     628           0 :             for ( sal_uInt16 j = 0; j < aCellArr.size(); ++j )
     629             :             {
     630           0 :                 SwCellFrm *pCell = aCellArr[j];
     631           0 :                 const sal_Bool bVert = pTab->IsVertical();
     632           0 :                 const sal_Bool bRTL = pTab->IsRightToLeft();
     633             :                 sal_Bool bTopOver, bLeftOver, bRightOver, bBottomOver;
     634           0 :                 if ( bVert )
     635             :                 {
     636           0 :                     bTopOver = pCell->Frm().Right() >= rUnion.Right();
     637           0 :                     bLeftOver = pCell->Frm().Top() <= rUnion.Top();
     638           0 :                     bRightOver = pCell->Frm().Bottom() >= rUnion.Bottom();
     639           0 :                     bBottomOver = pCell->Frm().Left() <= rUnion.Left();
     640             :                 }
     641             :                 else
     642             :                 {
     643           0 :                     bTopOver = pCell->Frm().Top() <= rUnion.Top();
     644           0 :                     bLeftOver = pCell->Frm().Left() <= rUnion.Left();
     645           0 :                     bRightOver = pCell->Frm().Right() >= rUnion.Right();
     646           0 :                     bBottomOver = pCell->Frm().Bottom() >= rUnion.Bottom();
     647             :                 }
     648             : 
     649           0 :                 if ( bRTL )
     650             :                 {
     651           0 :                     sal_Bool bTmp = bRightOver;
     652           0 :                     bRightOver = bLeftOver;
     653           0 :                     bLeftOver = bTmp;
     654             :                 }
     655             : 
     656             :                 // Do not set anything by default in HeadlineRepeats
     657           0 :                 if ( pTab->IsFollow() &&
     658           0 :                      ( pTab->IsInHeadline( *pCell ) ||
     659             :                        // Same holds for follow flow rows
     660           0 :                        pCell->IsInFollowFlowRow() ) )
     661           0 :                     continue;
     662             : 
     663           0 :                 SvxBoxItem aBox( pCell->GetFmt()->GetBox() );
     664             : 
     665           0 :                 sal_Int16 nType = 0;
     666             : 
     667             :                 // Top Border
     668           0 :                 if( bTopValid )
     669             :                 {
     670           0 :                     if ( bFirst && bTopOver )
     671             :                     {
     672           0 :                         aBox.SetLine( pTop, BOX_LINE_TOP );
     673           0 :                         nType |= 0x0001;
     674             :                     }
     675           0 :                     else if ( bHoriValid )
     676             :                     {
     677           0 :                         aBox.SetLine( 0, BOX_LINE_TOP );
     678           0 :                         nType |= 0x0002;
     679             :                     }
     680             :                 }
     681             : 
     682             :                 // Fix fdo#62470 correct the input for RTL table
     683           0 :                 if (bRTL)
     684             :                 {
     685           0 :                         if( bLeftOver && bRightOver)
     686             :                         {
     687           0 :                             if ( bLeftValid )
     688             :                             {
     689           0 :                                 aBox.SetLine( pLeft, BOX_LINE_RIGHT );
     690           0 :                                 nType |= 0x0010;
     691             :                             }
     692           0 :                             if ( bRightValid )
     693             :                             {
     694           0 :                                 aBox.SetLine( pRight, BOX_LINE_LEFT );
     695           0 :                                 nType |= 0x0004;
     696             :                             }
     697             :                         }
     698             :                         else
     699             :                         {
     700           0 :                             if ( bLeftValid )
     701             :                             {
     702           0 :                                 aBox.SetLine( bRightOver ? pLeft : 0, BOX_LINE_RIGHT );
     703           0 :                                 bVertValid ? nType |= 0x0020 : nType |= 0x0010;
     704             :                             }
     705           0 :                             if ( bLeftOver )
     706             :                             {
     707           0 :                                 if ( bRightValid )
     708             :                                 {
     709           0 :                                     aBox.SetLine( pRight, BOX_LINE_LEFT );
     710           0 :                                     nType |= 0x0004;
     711             :                                 }
     712             :                             }
     713           0 :                             else if ( bVertValid )
     714             :                             {
     715           0 :                                 aBox.SetLine( pVert, BOX_LINE_LEFT );
     716           0 :                                 nType |= 0x0008;
     717             :                             }
     718             :                         }
     719             :                 }
     720             :                 else
     721             :                 {
     722             :                     // Left Border
     723           0 :                     if ( bLeftOver )
     724             :                     {
     725           0 :                         if( bLeftValid )
     726             :                         {
     727           0 :                             aBox.SetLine( pLeft, BOX_LINE_LEFT );
     728           0 :                             nType |= 0x0004;
     729             :                         }
     730             :                     }
     731           0 :                     else if( bVertValid )
     732             :                     {
     733           0 :                         aBox.SetLine( pVert, BOX_LINE_LEFT );
     734           0 :                         nType |= 0x0008;
     735             :                     }
     736             : 
     737             :                     // Right Border
     738           0 :                     if( bRightValid )
     739             :                     {
     740           0 :                         if ( bRightOver )
     741             :                         {
     742           0 :                             aBox.SetLine( pRight, BOX_LINE_RIGHT );
     743           0 :                             nType |= 0x0010;
     744             :                         }
     745           0 :                         else if ( bVertValid )
     746             :                         {
     747           0 :                             aBox.SetLine( 0, BOX_LINE_RIGHT );
     748           0 :                             nType |= 0x0020;
     749             :                         }
     750             :                     }
     751             :                 }
     752             : 
     753             :                 // Bottom Border
     754           0 :                 if ( bLast && bBottomOver )
     755             :                 {
     756           0 :                     if( bBottomValid )
     757             :                     {
     758           0 :                         aBox.SetLine( pBottom, BOX_LINE_BOTTOM );
     759           0 :                         nType |= 0x0040;
     760             :                     }
     761             :                 }
     762           0 :                 else if( bHoriValid )
     763             :                 {
     764           0 :                     aBox.SetLine( pHori, BOX_LINE_BOTTOM );
     765           0 :                     nType |= 0x0080;
     766             :                 }
     767             : 
     768           0 :                 if( pSetBox )
     769             :                 {
     770             :                     static sal_uInt16 const aBorders[] = {
     771             :                         BOX_LINE_BOTTOM, BOX_LINE_TOP,
     772             :                         BOX_LINE_RIGHT, BOX_LINE_LEFT };
     773           0 :                     const sal_uInt16* pBrd = aBorders;
     774           0 :                     for( int k = 0; k < 4; ++k, ++pBrd )
     775           0 :                         aBox.SetDistance( pSetBox->GetDistance( *pBrd ), *pBrd );
     776             :                 }
     777             : 
     778           0 :                 SwTableBox *pBox = (SwTableBox*)pCell->GetTabBox();
     779             :                 SwFrmFmt *pNewFmt;
     780           0 :                 if ( 0 != (pNewFmt = SwTblFmtCmp::FindNewFmt( aFmtCmp, pBox->GetFrmFmt(), nType )))
     781           0 :                     pBox->ChgFrmFmt( (SwTableBoxFmt*)pNewFmt );
     782             :                 else
     783             :                 {
     784           0 :                     SwFrmFmt *pOld = pBox->GetFrmFmt();
     785           0 :                     SwFrmFmt *pNew = pBox->ClaimFrmFmt();
     786           0 :                     pNew->SetFmtAttr( aBox );
     787           0 :                     aFmtCmp.push_back( new SwTblFmtCmp( pOld, pNew, nType ) );
     788             :                 }
     789           0 :             }
     790             : 
     791           0 :             bFirst = false;
     792           0 :         }
     793             : 
     794           0 :         SwHTMLTableLayout *pTableLayout = rTable.GetHTMLTableLayout();
     795           0 :         if( pTableLayout )
     796             :         {
     797           0 :             SwCntntFrm* pFrm = rCursor.GetCntntNode()->getLayoutFrm( rCursor.GetCntntNode()->GetDoc()->GetCurrentLayout() );
     798           0 :             SwTabFrm* pTabFrm = pFrm->ImplFindTabFrm();
     799             : 
     800             :             pTableLayout->BordersChanged(
     801           0 :                 pTableLayout->GetBrowseWidthByTabFrm( *pTabFrm ), sal_True );
     802             :         }
     803           0 :         SwTblFmtCmp::Delete( aFmtCmp );
     804           0 :         ::ClearFEShellTabCols();
     805           0 :         SetModified();
     806           0 :     }
     807             : }
     808             : 
     809           0 : static void lcl_SetLineStyle( SvxBorderLine *pToSet,
     810             :                           const Color *pColor, const SvxBorderLine *pBorderLine)
     811             : {
     812           0 :     if ( pBorderLine )
     813             :     {
     814           0 :         if ( !pColor )
     815             :         {
     816           0 :             Color aTmp( pToSet->GetColor() );
     817           0 :             *pToSet = *pBorderLine;
     818           0 :             pToSet->SetColor( aTmp );
     819             :         }
     820             :         else
     821           0 :             *pToSet = *pBorderLine;
     822             :     }
     823           0 :     if ( pColor )
     824           0 :         pToSet->SetColor( *pColor );
     825           0 : }
     826             : 
     827           0 : void SwDoc::SetTabLineStyle( const SwCursor& rCursor,
     828             :                              const Color* pColor, sal_Bool bSetLine,
     829             :                              const SvxBorderLine* pBorderLine )
     830             : {
     831           0 :     SwCntntNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetCntntNode();
     832           0 :     SwTableNode* pTblNd = pCntNd ? pCntNd->FindTableNode() : 0;
     833           0 :     if( !pTblNd )
     834           0 :         return ;
     835             : 
     836             :     SwLayoutFrm *pStart, *pEnd;
     837           0 :     ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
     838             : 
     839           0 :     SwSelUnions aUnions;
     840           0 :     ::MakeSelUnions( aUnions, pStart, pEnd );
     841             : 
     842           0 :     if( !aUnions.empty() )
     843             :     {
     844           0 :         SwTable& rTable = pTblNd->GetTable();
     845           0 :         if (GetIDocumentUndoRedo().DoesUndo())
     846             :         {
     847           0 :             GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTbl(*pTblNd));
     848             :         }
     849             : 
     850           0 :         for( sal_uInt16 i = 0; i < aUnions.size(); ++i )
     851             :         {
     852           0 :             SwSelUnion *pUnion = &aUnions[i];
     853           0 :             SwTabFrm *pTab = pUnion->GetTable();
     854           0 :             std::vector<SwCellFrm*> aCellArr;
     855           0 :             aCellArr.reserve( 255 );
     856           0 :             ::lcl_CollectCells( aCellArr, pUnion->GetUnion(), pTab );
     857             : 
     858           0 :             for ( sal_uInt16 j = 0; j < aCellArr.size(); ++j )
     859             :             {
     860           0 :                 SwCellFrm *pCell = aCellArr[j];
     861             : 
     862             :                 // Do not set anything by default in HeadlineRepeats
     863           0 :                 if ( pTab->IsFollow() && pTab->IsInHeadline( *pCell ) )
     864           0 :                     continue;
     865             : 
     866           0 :                 ((SwTableBox*)pCell->GetTabBox())->ClaimFrmFmt();
     867           0 :                 SwFrmFmt *pFmt = pCell->GetFmt();
     868           0 :                 SvxBoxItem aBox( pFmt->GetBox() );
     869             : 
     870           0 :                 if ( !pBorderLine && bSetLine )
     871           0 :                     aBox = *(SvxBoxItem*)::GetDfltAttr( RES_BOX );
     872             :                 else
     873             :                 {
     874           0 :                     if ( aBox.GetTop() )
     875           0 :                         ::lcl_SetLineStyle( (SvxBorderLine*)aBox.GetTop(),
     876           0 :                                         pColor, pBorderLine );
     877           0 :                     if ( aBox.GetBottom() )
     878           0 :                         ::lcl_SetLineStyle( (SvxBorderLine*)aBox.GetBottom(),
     879           0 :                                         pColor, pBorderLine );
     880           0 :                     if ( aBox.GetLeft() )
     881           0 :                         ::lcl_SetLineStyle( (SvxBorderLine*)aBox.GetLeft(),
     882           0 :                                         pColor, pBorderLine );
     883           0 :                     if ( aBox.GetRight() )
     884           0 :                         ::lcl_SetLineStyle( (SvxBorderLine*)aBox.GetRight(),
     885           0 :                                         pColor, pBorderLine );
     886             :                 }
     887           0 :                 pFmt->SetFmtAttr( aBox );
     888           0 :             }
     889           0 :         }
     890             : 
     891           0 :         SwHTMLTableLayout *pTableLayout = rTable.GetHTMLTableLayout();
     892           0 :         if( pTableLayout )
     893             :         {
     894           0 :             SwCntntFrm* pFrm = rCursor.GetCntntNode()->getLayoutFrm( rCursor.GetCntntNode()->GetDoc()->GetCurrentLayout() );
     895           0 :             SwTabFrm* pTabFrm = pFrm->ImplFindTabFrm();
     896             : 
     897             :             pTableLayout->BordersChanged(
     898           0 :                 pTableLayout->GetBrowseWidthByTabFrm( *pTabFrm ), sal_True );
     899             :         }
     900           0 :         ::ClearFEShellTabCols();
     901           0 :         SetModified();
     902           0 :     }
     903             : }
     904             : 
     905           0 : void SwDoc::GetTabBorders( const SwCursor& rCursor, SfxItemSet& rSet ) const
     906             : {
     907           0 :     SwCntntNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetCntntNode();
     908           0 :     SwTableNode* pTblNd = pCntNd ? pCntNd->FindTableNode() : 0;
     909           0 :     if( !pTblNd )
     910           0 :         return ;
     911             : 
     912             :     SwLayoutFrm *pStart, *pEnd;
     913           0 :     ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
     914             : 
     915           0 :     SwSelUnions aUnions;
     916           0 :     ::MakeSelUnions( aUnions, pStart, pEnd );
     917             : 
     918           0 :     if( !aUnions.empty() )
     919             :     {
     920           0 :         SvxBoxItem     aSetBox    ((const SvxBoxItem    &) rSet.Get(RES_BOX    ));
     921           0 :         SvxBoxInfoItem aSetBoxInfo((const SvxBoxInfoItem&) rSet.Get(SID_ATTR_BORDER_INNER));
     922             : 
     923           0 :         sal_Bool bTopSet      = sal_False,
     924           0 :              bBottomSet   = sal_False,
     925           0 :              bLeftSet     = sal_False,
     926           0 :              bRightSet    = sal_False,
     927           0 :              bHoriSet     = sal_False,
     928           0 :              bVertSet     = sal_False,
     929           0 :              bDistanceSet = sal_False,
     930           0 :              bRTLTab      = sal_False;
     931             : 
     932           0 :         aSetBoxInfo.ResetFlags();
     933             : 
     934           0 :         for ( sal_uInt16 i = 0; i < aUnions.size(); ++i )
     935             :         {
     936           0 :             SwSelUnion *pUnion = &aUnions[i];
     937           0 :             const SwTabFrm *pTab = pUnion->GetTable();
     938           0 :             const SwRect &rUnion = pUnion->GetUnion();
     939           0 :             const bool bFirst = i == 0;
     940           0 :             const bool bLast  = (i == aUnions.size() - 1);
     941             : 
     942           0 :             std::vector<SwCellFrm*> aCellArr;
     943           0 :             aCellArr.reserve(255);
     944           0 :             ::lcl_CollectCells( aCellArr, rUnion, (SwTabFrm*)pTab );
     945             : 
     946           0 :             for ( sal_uInt16 j = 0; j < aCellArr.size(); ++j )
     947             :             {
     948           0 :                 SwCellFrm *pCell = aCellArr[j];
     949           0 :                 const sal_Bool bVert = pTab->IsVertical();
     950           0 :                 const sal_Bool bRTL = bRTLTab = pTab->IsRightToLeft();
     951             :                 sal_Bool bTopOver, bLeftOver, bRightOver, bBottomOver;
     952           0 :                 if ( bVert )
     953             :                 {
     954           0 :                     bTopOver = pCell->Frm().Right() >= rUnion.Right();
     955           0 :                     bLeftOver = pCell->Frm().Top() <= rUnion.Top();
     956           0 :                     bRightOver = pCell->Frm().Bottom() >= rUnion.Bottom();
     957           0 :                     bBottomOver = pCell->Frm().Left() <= rUnion.Left();
     958             :                 }
     959             :                 else
     960             :                 {
     961           0 :                     bTopOver = pCell->Frm().Top() <= rUnion.Top();
     962           0 :                     bLeftOver = pCell->Frm().Left() <= rUnion.Left();
     963           0 :                     bRightOver = pCell->Frm().Right() >= rUnion.Right();
     964           0 :                     bBottomOver = pCell->Frm().Bottom() >= rUnion.Bottom();
     965             :                 }
     966             : 
     967           0 :                 if ( bRTL )
     968             :                 {
     969           0 :                     sal_Bool bTmp = bRightOver;
     970           0 :                     bRightOver = bLeftOver;
     971           0 :                     bLeftOver = bTmp;
     972             :                 }
     973             : 
     974           0 :                 const SwFrmFmt  *pFmt  = pCell->GetFmt();
     975           0 :                 const SvxBoxItem  &rBox  = pFmt->GetBox();
     976             : 
     977             :                 // Top Border
     978           0 :                 if ( bFirst && bTopOver )
     979             :                 {
     980           0 :                     if (aSetBoxInfo.IsValid(VALID_TOP))
     981             :                     {
     982           0 :                         if ( !bTopSet )
     983           0 :                         {   bTopSet = sal_True;
     984           0 :                             aSetBox.SetLine( rBox.GetTop(), BOX_LINE_TOP );
     985             :                         }
     986           0 :                         else if ((aSetBox.GetTop() && rBox.GetTop() &&
     987           0 :                                  !(*aSetBox.GetTop() == *rBox.GetTop())) ||
     988           0 :                                  ((!aSetBox.GetTop()) != (!rBox.GetTop()))) // XOR expression is sal_True, if one of the two pointers is 0
     989             :                         {
     990           0 :                             aSetBoxInfo.SetValid(VALID_TOP, false );
     991           0 :                             aSetBox.SetLine( 0, BOX_LINE_TOP );
     992             :                         }
     993             :                     }
     994             :                 }
     995             : 
     996             :                 // Left Border
     997           0 :                 if ( bLeftOver )
     998             :                 {
     999           0 :                     if (aSetBoxInfo.IsValid(VALID_LEFT))
    1000             :                     {
    1001           0 :                         if ( !bLeftSet )
    1002           0 :                         {   bLeftSet = sal_True;
    1003           0 :                             aSetBox.SetLine( rBox.GetLeft(), BOX_LINE_LEFT );
    1004             :                         }
    1005           0 :                         else if ((aSetBox.GetLeft() && rBox.GetLeft() &&
    1006           0 :                                  !(*aSetBox.GetLeft() == *rBox.GetLeft())) ||
    1007           0 :                                  ((!aSetBox.GetLeft()) != (!rBox.GetLeft())))
    1008             :                         {
    1009           0 :                             aSetBoxInfo.SetValid(VALID_LEFT, false );
    1010           0 :                             aSetBox.SetLine( 0, BOX_LINE_LEFT );
    1011             :                         }
    1012             :                     }
    1013             :                 }
    1014             :                 else
    1015             :                 {
    1016           0 :                     if (aSetBoxInfo.IsValid(VALID_VERT))
    1017             :                     {
    1018           0 :                         if ( !bVertSet )
    1019           0 :                         {   bVertSet = sal_True;
    1020           0 :                             aSetBoxInfo.SetLine( rBox.GetLeft(), BOXINFO_LINE_VERT );
    1021             :                         }
    1022           0 :                         else if ((aSetBoxInfo.GetVert() && rBox.GetLeft() &&
    1023           0 :                                  !(*aSetBoxInfo.GetVert() == *rBox.GetLeft())) ||
    1024           0 :                                  ((!aSetBoxInfo.GetVert()) != (!rBox.GetLeft())))
    1025           0 :                         {   aSetBoxInfo.SetValid( VALID_VERT, false );
    1026           0 :                             aSetBoxInfo.SetLine( 0, BOXINFO_LINE_VERT );
    1027             :                         }
    1028             :                     }
    1029             :                 }
    1030             : 
    1031             :                 // Right Border
    1032           0 :                 if ( aSetBoxInfo.IsValid(VALID_RIGHT) && bRightOver )
    1033             :                 {
    1034           0 :                     if ( !bRightSet )
    1035           0 :                     {   bRightSet = sal_True;
    1036           0 :                         aSetBox.SetLine( rBox.GetRight(), BOX_LINE_RIGHT );
    1037             :                     }
    1038           0 :                     else if ((aSetBox.GetRight() && rBox.GetRight() &&
    1039           0 :                              !(*aSetBox.GetRight() == *rBox.GetRight())) ||
    1040           0 :                              (!aSetBox.GetRight() != !rBox.GetRight()))
    1041           0 :                     {   aSetBoxInfo.SetValid( VALID_RIGHT, false );
    1042           0 :                         aSetBox.SetLine( 0, BOX_LINE_RIGHT );
    1043             :                     }
    1044             :                 }
    1045             : 
    1046             :                 // Bottom Border
    1047           0 :                 if ( bLast && bBottomOver )
    1048             :                 {
    1049           0 :                     if ( aSetBoxInfo.IsValid(VALID_BOTTOM) )
    1050             :                     {
    1051           0 :                         if ( !bBottomSet )
    1052           0 :                         {   bBottomSet = sal_True;
    1053           0 :                             aSetBox.SetLine( rBox.GetBottom(), BOX_LINE_BOTTOM );
    1054             :                         }
    1055           0 :                         else if ((aSetBox.GetBottom() && rBox.GetBottom() &&
    1056           0 :                                  !(*aSetBox.GetBottom() == *rBox.GetBottom())) ||
    1057           0 :                                  (!aSetBox.GetBottom() != !rBox.GetBottom()))
    1058           0 :                         {   aSetBoxInfo.SetValid( VALID_BOTTOM, false );
    1059           0 :                             aSetBox.SetLine( 0, BOX_LINE_BOTTOM );
    1060             :                         }
    1061             :                     }
    1062             :                 }
    1063             :                 // In all Lines, except for the last one, the horizontal Line
    1064             :                 // is taken from the Bottom Line.
    1065             :                 else
    1066             :                 {
    1067           0 :                     if (aSetBoxInfo.IsValid(VALID_HORI))
    1068             :                     {
    1069           0 :                         if ( !bHoriSet )
    1070           0 :                         {   bHoriSet = sal_True;
    1071           0 :                             aSetBoxInfo.SetLine( rBox.GetBottom(), BOXINFO_LINE_HORI );
    1072             :                         }
    1073           0 :                         else if ((aSetBoxInfo.GetHori() && rBox.GetBottom() &&
    1074           0 :                                  !(*aSetBoxInfo.GetHori() == *rBox.GetBottom())) ||
    1075           0 :                                  ((!aSetBoxInfo.GetHori()) != (!rBox.GetBottom())))
    1076             :                         {
    1077           0 :                             aSetBoxInfo.SetValid( VALID_HORI, false );
    1078           0 :                             aSetBoxInfo.SetLine( 0, BOXINFO_LINE_HORI );
    1079             :                         }
    1080             :                     }
    1081             :                 }
    1082             : 
    1083             :                 // Distance to text
    1084           0 :                 if (aSetBoxInfo.IsValid(VALID_DISTANCE))
    1085             :                 {
    1086             :                     static sal_uInt16 const aBorders[] = {
    1087             :                         BOX_LINE_BOTTOM, BOX_LINE_TOP,
    1088             :                         BOX_LINE_RIGHT, BOX_LINE_LEFT };
    1089           0 :                     const sal_uInt16* pBrd = aBorders;
    1090             : 
    1091           0 :                     if( !bDistanceSet ) // Set on first iteration
    1092             :                     {
    1093           0 :                         bDistanceSet = sal_True;
    1094           0 :                         for( int k = 0; k < 4; ++k, ++pBrd )
    1095           0 :                             aSetBox.SetDistance( rBox.GetDistance( *pBrd ), *pBrd );
    1096             :                     }
    1097             :                     else
    1098             :                     {
    1099           0 :                         for( int k = 0; k < 4; ++k, ++pBrd )
    1100           0 :                             if( aSetBox.GetDistance( *pBrd ) !=
    1101           0 :                                 rBox.GetDistance( *pBrd ) )
    1102             :                             {
    1103           0 :                                 aSetBoxInfo.SetValid( VALID_DISTANCE, false );
    1104           0 :                                 aSetBox.SetDistance( (sal_uInt16) 0 );
    1105           0 :                                 break;
    1106             :                             }
    1107             :                     }
    1108             :                 }
    1109             :             }
    1110           0 :         }
    1111             : 
    1112             :         // fdo#62470 fix the reading for table format.
    1113           0 :         if ( bRTLTab )
    1114             :         {
    1115           0 :             SvxBoxItem     aTempBox    ((const SvxBoxItem    &) rSet.Get(RES_BOX    ));
    1116           0 :             SvxBoxInfoItem aTempBoxInfo((const SvxBoxInfoItem&) rSet.Get(SID_ATTR_BORDER_INNER));
    1117             : 
    1118           0 :             aTempBox.SetLine( aSetBox.GetRight(), BOX_LINE_RIGHT);
    1119           0 :             aSetBox.SetLine( aSetBox.GetLeft(), BOX_LINE_RIGHT);
    1120           0 :             aSetBox.SetLine( aTempBox.GetRight(), BOX_LINE_LEFT);
    1121             : 
    1122           0 :             aTempBoxInfo.SetValid( VALID_LEFT, aSetBoxInfo.IsValid(VALID_LEFT) );
    1123           0 :             aSetBoxInfo.SetValid( VALID_LEFT, aSetBoxInfo.IsValid(VALID_RIGHT) );
    1124           0 :             aSetBoxInfo.SetValid( VALID_RIGHT, aTempBoxInfo.IsValid(VALID_LEFT) );
    1125             :         }
    1126             : 
    1127           0 :         rSet.Put( aSetBox );
    1128           0 :         rSet.Put( aSetBoxInfo );
    1129           0 :     }
    1130             : }
    1131             : 
    1132           0 : void SwDoc::SetBoxAttr( const SwCursor& rCursor, const SfxPoolItem &rNew )
    1133             : {
    1134           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
    1135           0 :     SwSelBoxes aBoxes;
    1136           0 :     if( pTblNd && ::lcl_GetBoxSel( rCursor, aBoxes, true ) )
    1137             :     {
    1138           0 :         SwTable& rTable = pTblNd->GetTable();
    1139           0 :         if (GetIDocumentUndoRedo().DoesUndo())
    1140             :         {
    1141           0 :             GetIDocumentUndoRedo().AppendUndo( new SwUndoAttrTbl(*pTblNd) );
    1142             :         }
    1143             : 
    1144           0 :         std::vector<SwTblFmtCmp*> aFmtCmp;
    1145           0 :         aFmtCmp.reserve(std::max<size_t>(255, aBoxes.size()));
    1146           0 :         for (size_t i = 0; i < aBoxes.size(); ++i)
    1147             :         {
    1148           0 :             SwTableBox *pBox = aBoxes[i];
    1149             : 
    1150             :             SwFrmFmt *pNewFmt;
    1151           0 :             if ( 0 != (pNewFmt = SwTblFmtCmp::FindNewFmt( aFmtCmp, pBox->GetFrmFmt(), 0 )))
    1152           0 :                 pBox->ChgFrmFmt( (SwTableBoxFmt*)pNewFmt );
    1153             :             else
    1154             :             {
    1155           0 :                 SwFrmFmt *pOld = pBox->GetFrmFmt();
    1156           0 :                 SwFrmFmt *pNew = pBox->ClaimFrmFmt();
    1157           0 :                 pNew->SetFmtAttr( rNew );
    1158           0 :                 aFmtCmp.push_back( new SwTblFmtCmp( pOld, pNew, 0 ) );
    1159             :             }
    1160             :         }
    1161             : 
    1162           0 :         SwHTMLTableLayout *pTableLayout = rTable.GetHTMLTableLayout();
    1163           0 :         if( pTableLayout )
    1164             :         {
    1165           0 :             SwCntntFrm* pFrm = rCursor.GetCntntNode()->getLayoutFrm( rCursor.GetCntntNode()->GetDoc()->GetCurrentLayout() );
    1166           0 :             SwTabFrm* pTabFrm = pFrm->ImplFindTabFrm();
    1167             : 
    1168             :             pTableLayout->Resize(
    1169           0 :                 pTableLayout->GetBrowseWidthByTabFrm( *pTabFrm ), sal_True );
    1170             :         }
    1171           0 :         SwTblFmtCmp::Delete( aFmtCmp );
    1172           0 :         SetModified();
    1173           0 :     }
    1174           0 : }
    1175             : 
    1176           0 : sal_Bool SwDoc::GetBoxAttr( const SwCursor& rCursor, SfxPoolItem& rToFill ) const
    1177             : {
    1178           0 :     sal_Bool bRet = sal_False;
    1179           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
    1180           0 :     SwSelBoxes aBoxes;
    1181           0 :     if( pTblNd && lcl_GetBoxSel( rCursor, aBoxes ))
    1182             :     {
    1183           0 :         bRet = sal_True;
    1184           0 :         bool bOneFound = false;
    1185           0 :         const sal_uInt16 nWhich = rToFill.Which();
    1186           0 :         for (size_t i = 0; i < aBoxes.size(); ++i)
    1187             :         {
    1188           0 :             switch ( nWhich )
    1189             :             {
    1190             :                 case RES_BACKGROUND:
    1191             :                 {
    1192             :                     const SvxBrushItem &rBack =
    1193           0 :                                     aBoxes[i]->GetFrmFmt()->GetBackground();
    1194           0 :                     if( !bOneFound )
    1195             :                     {
    1196           0 :                         (SvxBrushItem&)rToFill = rBack;
    1197           0 :                         bOneFound = true;
    1198             :                     }
    1199           0 :                     else if( rToFill != rBack )
    1200           0 :                         bRet = sal_False;
    1201             :                 }
    1202           0 :                 break;
    1203             : 
    1204             :                 case RES_FRAMEDIR:
    1205             :                 {
    1206             :                     const SvxFrameDirectionItem& rDir =
    1207           0 :                                     aBoxes[i]->GetFrmFmt()->GetFrmDir();
    1208           0 :                     if( !bOneFound )
    1209             :                     {
    1210           0 :                         (SvxFrameDirectionItem&)rToFill = rDir;
    1211           0 :                         bOneFound = true;
    1212             :                     }
    1213           0 :                     else if( rToFill != rDir )
    1214           0 :                         bRet = sal_False;
    1215             :                 }
    1216             :             }
    1217             : 
    1218           0 :             if ( sal_False == bRet )
    1219           0 :                 break;
    1220             :         }
    1221             :     }
    1222           0 :     return bRet;
    1223             : }
    1224             : 
    1225           0 : void SwDoc::SetBoxAlign( const SwCursor& rCursor, sal_uInt16 nAlign )
    1226             : {
    1227             :     OSL_ENSURE( nAlign == text::VertOrientation::NONE   ||
    1228             :             nAlign == text::VertOrientation::CENTER ||
    1229             :             nAlign == text::VertOrientation::BOTTOM, "Wrong alignment" );
    1230           0 :     SwFmtVertOrient aVertOri( 0, nAlign );
    1231           0 :     SetBoxAttr( rCursor, aVertOri );
    1232           0 : }
    1233             : 
    1234           0 : sal_uInt16 SwDoc::GetBoxAlign( const SwCursor& rCursor ) const
    1235             : {
    1236           0 :     sal_uInt16 nAlign = USHRT_MAX;
    1237           0 :     SwTableNode* pTblNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
    1238           0 :     SwSelBoxes aBoxes;
    1239           0 :     if( pTblNd && ::lcl_GetBoxSel( rCursor, aBoxes ))
    1240             :     {
    1241           0 :         for (size_t i = 0; i < aBoxes.size(); ++i)
    1242             :         {
    1243             :             const SwFmtVertOrient &rOri =
    1244           0 :                             aBoxes[i]->GetFrmFmt()->GetVertOrient();
    1245           0 :             if( USHRT_MAX == nAlign )
    1246           0 :                 nAlign = static_cast<sal_uInt16>(rOri.GetVertOrient());
    1247           0 :             else if( rOri.GetVertOrient() != nAlign )
    1248             :             {
    1249           0 :                 nAlign = USHRT_MAX;
    1250           0 :                 break;
    1251             :             }
    1252             :         }
    1253             :     }
    1254           0 :     return nAlign;
    1255             : }
    1256             : 
    1257           0 : static sal_uInt16 lcl_CalcCellFit( const SwLayoutFrm *pCell )
    1258             : {
    1259           0 :     SwTwips nRet = 0;
    1260           0 :     const SwFrm *pFrm = pCell->Lower(); // The whole Line
    1261           0 :     SWRECTFN( pCell )
    1262           0 :     while ( pFrm )
    1263             :     {
    1264           0 :         const SwTwips nAdd = (pFrm->Frm().*fnRect->fnGetWidth)() -
    1265           0 :                              (pFrm->Prt().*fnRect->fnGetWidth)();
    1266             : 
    1267             :         // pFrm does not necessarily have to be a SwTxtFrm!
    1268           0 :         const SwTwips nCalcFitToContent = pFrm->IsTxtFrm() ?
    1269             :                                           ((SwTxtFrm*)pFrm)->CalcFitToContent() :
    1270           0 :                                           (pFrm->Prt().*fnRect->fnGetWidth)();
    1271             : 
    1272           0 :         nRet = std::max( nRet, nCalcFitToContent + nAdd );
    1273           0 :         pFrm = pFrm->GetNext();
    1274             :     }
    1275             :     // Surrounding border as well as left and Right Border also need to be respected
    1276           0 :     nRet += (pCell->Frm().*fnRect->fnGetWidth)() -
    1277           0 :             (pCell->Prt().*fnRect->fnGetWidth)();
    1278             : 
    1279             :     // To compensate for the accuracy of calculation later on in SwTable::SetTabCols
    1280             :     // we keep adding up a little.
    1281           0 :     nRet += COLFUZZY;
    1282           0 :     return (sal_uInt16)std::max( long(MINLAY), nRet );
    1283             : }
    1284             : 
    1285             : /* The Line is within the Selection but not outlined by the TabCols.
    1286             :  *
    1287             :  * That means that the Line has been "split" by other Cells due to the
    1288             :  * two-dimensional representation used. Thus, we have to distribute the cell's
    1289             :  * default or minium value amongst the Cell it has been split by.
    1290             :  *
    1291             :  * First, we collect the Columns (not the Column separators) which overlap
    1292             :  * with the Cell. We then distribute the desired value according to the
    1293             :  * amount of overlapping amongst the Cells.
    1294             :  *
    1295             :  * A Cell's default value stays the same if it already has a larger value than
    1296             :  * the desired one. It's overwritten if it's smaller.
    1297             :  */
    1298           0 : static void lcl_CalcSubColValues( std::vector<sal_uInt16> &rToFill, const SwTabCols &rCols,
    1299             :                               const SwLayoutFrm *pCell, const SwLayoutFrm *pTab,
    1300             :                               sal_Bool bWishValues )
    1301             : {
    1302             :     const sal_uInt16 nWish = bWishValues ?
    1303             :                     ::lcl_CalcCellFit( pCell ) :
    1304           0 :                     MINLAY + sal_uInt16(pCell->Frm().Width() - pCell->Prt().Width());
    1305             : 
    1306           0 :     SWRECTFN( pTab )
    1307             : 
    1308           0 :     for ( size_t i = 0 ; i <= rCols.Count(); ++i )
    1309             :     {
    1310           0 :         long nColLeft  = i == 0             ? rCols.GetLeft()  : rCols[i-1];
    1311           0 :         long nColRight = i == rCols.Count() ? rCols.GetRight() : rCols[i];
    1312           0 :         nColLeft  += rCols.GetLeftMin();
    1313           0 :         nColRight += rCols.GetLeftMin();
    1314             : 
    1315             :         // Adapt values to the proportions of the Table (Follows)
    1316           0 :         if ( rCols.GetLeftMin() != (pTab->Frm().*fnRect->fnGetLeft)() )
    1317             :         {
    1318           0 :             const long nDiff = (pTab->Frm().*fnRect->fnGetLeft)() - rCols.GetLeftMin();
    1319           0 :             nColLeft  += nDiff;
    1320           0 :             nColRight += nDiff;
    1321             :         }
    1322           0 :         const long nCellLeft  = (pCell->Frm().*fnRect->fnGetLeft)();
    1323           0 :         const long nCellRight = (pCell->Frm().*fnRect->fnGetRight)();
    1324             : 
    1325             :         // Calculate overlapping value
    1326           0 :         long nWidth = 0;
    1327           0 :         if ( nColLeft <= nCellLeft && nColRight >= (nCellLeft+COLFUZZY) )
    1328           0 :             nWidth = nColRight - nCellLeft;
    1329           0 :         else if ( nColLeft <= (nCellRight-COLFUZZY) && nColRight >= nCellRight )
    1330           0 :             nWidth = nCellRight - nColLeft;
    1331           0 :         else if ( nColLeft >= nCellLeft && nColRight <= nCellRight )
    1332           0 :             nWidth = nColRight - nColLeft;
    1333           0 :         if ( nWidth && pCell->Frm().Width() )
    1334             :         {
    1335           0 :             long nTmp = nWidth * nWish / pCell->Frm().Width();
    1336           0 :             if ( sal_uInt16(nTmp) > rToFill[i] )
    1337           0 :                 rToFill[i] = sal_uInt16(nTmp);
    1338             :         }
    1339             :     }
    1340           0 : }
    1341             : 
    1342             : /**
    1343             :  * Retrievs new values to set the TabCols.
    1344             :  *
    1345             :  * We do not iterate over the TabCols' entries, but over the gaps that describe Cells.
    1346             :  *
    1347             :  * @param bWishValues == sal_True: We calculate the desired value of all affected
    1348             :  *                                 Cells for the current Selection/current Cell.
    1349             :  *                                 If more Cells are within a Column, the highest
    1350             :  *                                 desired value is returned.
    1351             :  *                                 We set TabCol entries for which we did not calculate
    1352             :  *                                 Cells to 0.
    1353             :  *
    1354             :  * @param bWishValues == sal_False: The Selection is expanded vertically.
    1355             :  *                                  We calculate the minimum value for every
    1356             :  *                                  Column in the TabCols that intersects with the
    1357             :  *                                  Selection.
    1358             :  */
    1359           0 : static void lcl_CalcColValues( std::vector<sal_uInt16> &rToFill, const SwTabCols &rCols,
    1360             :                            const SwLayoutFrm *pStart, const SwLayoutFrm *pEnd,
    1361             :                            sal_Bool bWishValues )
    1362             : {
    1363           0 :     SwSelUnions aUnions;
    1364             :     ::MakeSelUnions( aUnions, pStart, pEnd,
    1365           0 :                     bWishValues ? nsSwTblSearchType::TBLSEARCH_NONE : nsSwTblSearchType::TBLSEARCH_COL );
    1366             : 
    1367           0 :     for ( sal_uInt16 i2 = 0; i2 < aUnions.size(); ++i2 )
    1368             :     {
    1369           0 :         SwSelUnion *pSelUnion = &aUnions[i2];
    1370           0 :         const SwTabFrm *pTab = pSelUnion->GetTable();
    1371           0 :         const SwRect &rUnion = pSelUnion->GetUnion();
    1372             : 
    1373           0 :         SWRECTFN( pTab )
    1374           0 :         sal_Bool bRTL = pTab->IsRightToLeft();
    1375             : 
    1376           0 :         const SwLayoutFrm *pCell = pTab->FirstCell();
    1377           0 :         do
    1378             :         {
    1379           0 :             if ( pCell->IsCellFrm() && pCell->FindTabFrm() == pTab && ::IsFrmInTblSel( rUnion, pCell ) )
    1380             :             {
    1381           0 :                 const long nCLeft  = (pCell->Frm().*fnRect->fnGetLeft)();
    1382           0 :                 const long nCRight = (pCell->Frm().*fnRect->fnGetRight)();
    1383             : 
    1384           0 :                 bool bNotInCols = true;
    1385             : 
    1386           0 :                 for ( size_t i = 0; i <= rCols.Count(); ++i )
    1387             :                 {
    1388           0 :                     sal_uInt16 nFit = rToFill[i];
    1389           0 :                     long nColLeft  = i == 0             ? rCols.GetLeft()  : rCols[i-1];
    1390           0 :                     long nColRight = i == rCols.Count() ? rCols.GetRight() : rCols[i];
    1391             : 
    1392           0 :                     if ( bRTL )
    1393             :                     {
    1394           0 :                         long nTmpRight = nColRight;
    1395           0 :                         nColRight = rCols.GetRight() - nColLeft;
    1396           0 :                         nColLeft = rCols.GetRight() - nTmpRight;
    1397             :                     }
    1398             : 
    1399           0 :                     nColLeft  += rCols.GetLeftMin();
    1400           0 :                     nColRight += rCols.GetLeftMin();
    1401             : 
    1402             :                     // Adapt values to the proportions of the Table (Follows)
    1403           0 :                     long nLeftA  = nColLeft;
    1404           0 :                     long nRightA = nColRight;
    1405           0 :                     if ( rCols.GetLeftMin() !=  sal_uInt16((pTab->Frm().*fnRect->fnGetLeft)()) )
    1406             :                     {
    1407           0 :                         const long nDiff = (pTab->Frm().*fnRect->fnGetLeft)() - rCols.GetLeftMin();
    1408           0 :                         nLeftA  += nDiff;
    1409           0 :                         nRightA += nDiff;
    1410             :                     }
    1411             : 
    1412             :                     // We don't want to take a too close look
    1413           0 :                     if ( ::IsSame(nCLeft, nLeftA) && ::IsSame(nCRight, nRightA))
    1414             :                     {
    1415           0 :                         bNotInCols = false;
    1416           0 :                         if ( bWishValues )
    1417             :                         {
    1418           0 :                             const sal_uInt16 nWish = ::lcl_CalcCellFit( pCell );
    1419           0 :                             if ( nWish > nFit )
    1420           0 :                                 nFit = nWish;
    1421             :                         }
    1422             :                         else
    1423           0 :                         {   const sal_uInt16 nMin = MINLAY + sal_uInt16(pCell->Frm().Width() -
    1424           0 :                                                                 pCell->Prt().Width());
    1425           0 :                             if ( !nFit || nMin < nFit )
    1426           0 :                                 nFit = nMin;
    1427             :                         }
    1428           0 :                         if ( rToFill[i] < nFit )
    1429           0 :                             rToFill[i] = nFit;
    1430             :                     }
    1431             :                 }
    1432           0 :                 if ( bNotInCols )
    1433           0 :                     ::lcl_CalcSubColValues( rToFill, rCols, pCell, pTab, bWishValues );
    1434             :             }
    1435           0 :             do {
    1436           0 :                 pCell = pCell->GetNextLayoutLeaf();
    1437           0 :             } while( pCell && pCell->Frm().Width() == 0 );
    1438           0 :         } while ( pCell && pTab->IsAnLower( pCell ) );
    1439           0 :     }
    1440           0 : }
    1441             : 
    1442           0 : void SwDoc::AdjustCellWidth( const SwCursor& rCursor, sal_Bool bBalance )
    1443             : {
    1444             :     // Check whether the current Crsr has it's Point/Mark in a Table
    1445           0 :     SwCntntNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetCntntNode();
    1446           0 :     SwTableNode* pTblNd = pCntNd ? pCntNd->FindTableNode() : 0;
    1447           0 :     if( !pTblNd )
    1448           0 :         return ;
    1449             : 
    1450             :     SwLayoutFrm *pStart, *pEnd;
    1451           0 :     ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
    1452             : 
    1453             :     // Collect TabCols; we reset the Table with them
    1454           0 :     SwFrm* pBoxFrm = pStart;
    1455           0 :     while( pBoxFrm && !pBoxFrm->IsCellFrm() )
    1456           0 :         pBoxFrm = pBoxFrm->GetUpper();
    1457             : 
    1458           0 :     if ( !pBoxFrm )
    1459           0 :         return; // Robust
    1460             : 
    1461           0 :     SwTabCols aTabCols;
    1462           0 :     GetTabCols( aTabCols, 0, (SwCellFrm*)pBoxFrm );
    1463             : 
    1464           0 :     if ( ! aTabCols.Count() )
    1465           0 :         return;
    1466             : 
    1467           0 :     std::vector<sal_uInt16> aWish(aTabCols.Count() + 1);
    1468           0 :     std::vector<sal_uInt16> aMins(aTabCols.Count() + 1);
    1469             : 
    1470           0 :     ::lcl_CalcColValues( aWish, aTabCols, pStart, pEnd, sal_True  );
    1471             : 
    1472             :     // It's more robust if we calculate the minimum values for the whole Table
    1473           0 :     const SwTabFrm *pTab = pStart->ImplFindTabFrm();
    1474           0 :     pStart = (SwLayoutFrm*)pTab->FirstCell();
    1475           0 :     pEnd   = (SwLayoutFrm*)pTab->FindLastCntnt()->GetUpper();
    1476           0 :     while( !pEnd->IsCellFrm() )
    1477           0 :         pEnd = pEnd->GetUpper();
    1478           0 :     ::lcl_CalcColValues( aMins, aTabCols, pStart, pEnd, sal_False );
    1479             : 
    1480           0 :     if( bBalance )
    1481             :     {
    1482             :         // All Columns, which are now selected, have a desired value.
    1483             :         // We add up the current values, divide the result by their
    1484             :         // count and get a desired value for balancing.
    1485           0 :         sal_uInt16 nWish = 0, nCnt = 0;
    1486           0 :         for ( size_t i = 0; i <= aTabCols.Count(); ++i )
    1487             :         {
    1488           0 :             int nDiff = aWish[i];
    1489           0 :             if ( nDiff )
    1490             :             {
    1491           0 :                 if ( i == 0 )
    1492           0 :                     nWish += aTabCols[i] - aTabCols.GetLeft();
    1493           0 :                 else if ( i == aTabCols.Count() )
    1494           0 :                     nWish += aTabCols.GetRight() - aTabCols[i-1];
    1495             :                 else
    1496           0 :                     nWish += aTabCols[i] - aTabCols[i-1];
    1497           0 :                 ++nCnt;
    1498             :             }
    1499             :         }
    1500           0 :         nWish /= nCnt;
    1501           0 :         for ( size_t i = 0; i < aWish.size(); ++i )
    1502           0 :             if ( aWish[i] )
    1503           0 :                 aWish[i] = nWish;
    1504             :     }
    1505             : 
    1506           0 :     const long nOldRight = aTabCols.GetRight();
    1507             : 
    1508             :     // In order to make the implementation easier, but still use the available
    1509             :     // space properly, we do this twice.
    1510             : 
    1511             :     // The problem: The first column is getting wider, the others get slimmer
    1512             :     // only afterwards.
    1513             :     // The first column's desired width would be discarded as it would cause
    1514             :     // the Table's width to exceed the maximum width.
    1515           0 :     for ( sal_uInt16 k = 0; k < 2; ++k )
    1516             :     {
    1517           0 :         for ( size_t i = 0; i <= aTabCols.Count(); ++i )
    1518             :         {
    1519           0 :             int nDiff = aWish[i];
    1520           0 :             if ( nDiff )
    1521             :             {
    1522           0 :                 int nMin = aMins[i];
    1523           0 :                 if ( nMin > nDiff )
    1524           0 :                     nDiff = nMin;
    1525             : 
    1526           0 :                 if ( i == 0 )
    1527             :                 {
    1528           0 :                     if( aTabCols.Count() )
    1529           0 :                         nDiff -= aTabCols[0] - aTabCols.GetLeft();
    1530             :                     else
    1531           0 :                         nDiff -= aTabCols.GetRight() - aTabCols.GetLeft();
    1532             :                 }
    1533           0 :                 else if ( i == aTabCols.Count() )
    1534           0 :                     nDiff -= aTabCols.GetRight() - aTabCols[i-1];
    1535             :                 else
    1536           0 :                     nDiff -= aTabCols[i] - aTabCols[i-1];
    1537             : 
    1538           0 :                 long nTabRight = aTabCols.GetRight() + nDiff;
    1539             : 
    1540             :                 // If the Table would become too wide, we restrict the
    1541             :                 // adjusted amount to the allowed maximum.
    1542           0 :                 if ( !bBalance && nTabRight > aTabCols.GetRightMax() )
    1543             :                 {
    1544           0 :                     const long nTmpD = nTabRight - aTabCols.GetRightMax();
    1545           0 :                     nDiff     -= nTmpD;
    1546           0 :                     nTabRight -= nTmpD;
    1547             :                 }
    1548           0 :                 for ( size_t i2 = i; i2 < aTabCols.Count(); ++i2 )
    1549           0 :                     aTabCols[i2] += nDiff;
    1550           0 :                 aTabCols.SetRight( nTabRight );
    1551             :             }
    1552             :         }
    1553             :     }
    1554             : 
    1555           0 :     const long nNewRight = aTabCols.GetRight();
    1556             : 
    1557           0 :     SwFrmFmt *pFmt = pTblNd->GetTable().GetFrmFmt();
    1558           0 :     const sal_Int16 nOriHori = pFmt->GetHoriOrient().GetHoriOrient();
    1559             : 
    1560             :     // We can leave the "real" work to the SwTable now
    1561           0 :     SetTabCols( aTabCols, sal_False, 0, (SwCellFrm*)pBoxFrm );
    1562             : 
    1563             :     // Alignment might have been changed in SetTabCols; restore old value
    1564           0 :     const SwFmtHoriOrient &rHori = pFmt->GetHoriOrient();
    1565           0 :     SwFmtHoriOrient aHori( rHori );
    1566           0 :     if ( aHori.GetHoriOrient() != nOriHori )
    1567             :     {
    1568           0 :         aHori.SetHoriOrient( nOriHori );
    1569           0 :         pFmt->SetFmtAttr( aHori );
    1570             :     }
    1571             : 
    1572             :     // We switch to left-adjusted for automatic width
    1573             :     // We adjust the right border for Border attributes
    1574           0 :     if( !bBalance && nNewRight < nOldRight )
    1575             :     {
    1576           0 :         if( aHori.GetHoriOrient() == text::HoriOrientation::FULL )
    1577             :         {
    1578           0 :             aHori.SetHoriOrient( text::HoriOrientation::LEFT );
    1579           0 :             pFmt->SetFmtAttr( aHori );
    1580             :         }
    1581             :     }
    1582             : 
    1583           0 :     SetModified();
    1584             : }
    1585             : 
    1586             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10