| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| |
| #include <hintids.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <tblrwcl.hxx> |
| #include <swtblfmt.hxx> |
| |
| |
| inline const SvxBorderLine* GetLineTB( const SvxBoxItem* pBox, sal_Bool bTop ) |
| { |
| return bTop ? pBox->GetTop() : pBox->GetBottom(); |
| } |
| |
| |
| sal_Bool _SwGCBorder_BoxBrd::CheckLeftBorderOfFormat( const SwFrmFmt& rFmt ) |
| { |
| const SvxBorderLine* pBrd; |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rFmt.GetItemState( RES_BOX, sal_True, &pItem ) && |
| 0 != ( pBrd = ((SvxBoxItem*)pItem)->GetLeft() ) ) |
| { |
| if( *pBrdLn == *pBrd ) |
| bAnyBorderFnd = sal_True; |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| |
| |
| sal_Bool lcl_GCBorder_ChkBoxBrd_L( const SwTableLine*& rpLine, void* pPara ) |
| { |
| const SwTableBox* pBox = rpLine->GetTabBoxes()[ 0 ]; |
| return lcl_GCBorder_ChkBoxBrd_B( pBox, pPara ); |
| } |
| |
| sal_Bool lcl_GCBorder_ChkBoxBrd_B( const SwTableBox*& rpBox, void* pPara ) |
| { |
| sal_Bool bRet = sal_True; |
| if( rpBox->GetTabLines().Count() ) |
| { |
| for( sal_uInt16 n = 0, nLines = rpBox->GetTabLines().Count(); |
| n < nLines && bRet; ++n ) |
| { |
| const SwTableLine* pLine = rpBox->GetTabLines()[ n ]; |
| bRet = lcl_GCBorder_ChkBoxBrd_L( pLine, pPara ); |
| } |
| } |
| else |
| { |
| _SwGCBorder_BoxBrd* pBPara = (_SwGCBorder_BoxBrd*)pPara; |
| bRet = pBPara->CheckLeftBorderOfFormat( *rpBox->GetFrmFmt() ); |
| } |
| return bRet; |
| } |
| |
| sal_Bool lcl_GCBorder_GetLastBox_L( const SwTableLine*& rpLine, void* pPara ) |
| { |
| const SwTableBoxes& rBoxes = rpLine->GetTabBoxes(); |
| const SwTableBox* pBox = rBoxes[ rBoxes.Count()-1 ]; |
| ::lcl_GCBorder_GetLastBox_B( pBox, pPara ); |
| return sal_True; |
| } |
| |
| sal_Bool lcl_GCBorder_GetLastBox_B( const SwTableBox*& rpBox, void* pPara ) |
| { |
| SwTableLines& rLines = (SwTableLines&)rpBox->GetTabLines(); |
| if( rLines.Count() ) |
| rLines.ForEach( &lcl_GCBorder_GetLastBox_L, pPara ); |
| else |
| ((SwTableBoxes*)pPara)->Insert( rpBox, ((SwTableBoxes*)pPara)->Count() ); |
| return sal_True; |
| } |
| |
| // suche das "Ende" der vorgegebene BorderLine. Returnt wird die "Layout"Pos! |
| sal_uInt16 lcl_FindEndPosOfBorder( const SwCollectTblLineBoxes& rCollTLB, |
| const SvxBorderLine& rBrdLn, sal_uInt16& rStt, sal_Bool bTop ) |
| { |
| sal_uInt16 nPos, nLastPos = 0; |
| for( sal_uInt16 nEnd = rCollTLB.Count(); rStt < nEnd; ++rStt ) |
| { |
| const SfxPoolItem* pItem; |
| const SvxBorderLine* pBrd; |
| const SwTableBox& rBox = rCollTLB.GetBox( rStt, &nPos ); |
| |
| if( SFX_ITEM_SET != rBox.GetFrmFmt()->GetItemState(RES_BOX,sal_True, &pItem ) |
| || 0 == ( pBrd = GetLineTB( (SvxBoxItem*)pItem, bTop )) |
| || !( *pBrd == rBrdLn )) |
| break; |
| nLastPos = nPos; |
| } |
| return nLastPos; |
| } |
| |
| inline const SvxBorderLine* lcl_GCBorder_GetBorder( const SwTableBox& rBox, |
| sal_Bool bTop, |
| const SfxPoolItem** ppItem ) |
| { |
| return SFX_ITEM_SET == rBox.GetFrmFmt()->GetItemState( RES_BOX, sal_True, ppItem ) |
| ? GetLineTB( (SvxBoxItem*)*ppItem, bTop ) |
| : 0; |
| } |
| |
| void lcl_GCBorder_DelBorder( const SwCollectTblLineBoxes& rCollTLB, |
| sal_uInt16& rStt, sal_Bool bTop, |
| const SvxBorderLine& rLine, |
| const SfxPoolItem* pItem, |
| sal_uInt16 nEndPos, |
| SwShareBoxFmts* pShareFmts ) |
| { |
| SwTableBox* pBox = (SwTableBox*)&rCollTLB.GetBox( rStt ); |
| sal_uInt16 nNextPos; |
| const SvxBorderLine* pLn = &rLine; |
| |
| do { |
| if( pLn && *pLn == rLine ) |
| { |
| SvxBoxItem aBox( *(SvxBoxItem*)pItem ); |
| if( bTop ) |
| aBox.SetLine( 0, BOX_LINE_TOP ); |
| else |
| aBox.SetLine( 0, BOX_LINE_BOTTOM ); |
| |
| if( pShareFmts ) |
| pShareFmts->SetAttr( *pBox, aBox ); |
| else |
| pBox->ClaimFrmFmt()->SetFmtAttr( aBox ); |
| } |
| |
| if( ++rStt >= rCollTLB.Count() ) |
| break; |
| |
| pBox = (SwTableBox*)&rCollTLB.GetBox( rStt, &nNextPos ); |
| if( nNextPos > nEndPos ) |
| break; |
| |
| pLn = lcl_GCBorder_GetBorder( *pBox, bTop, &pItem ); |
| |
| } while( sal_True ); |
| } |
| |
| |
| sal_Bool lcl_GC_Line_Border( const SwTableLine*& rpLine, void* pPara ) |
| { |
| _SwGCLineBorder* pGCPara = (_SwGCLineBorder*)pPara; |
| |
| // zuerst die rechte Kante mit der linken Kante der naechsten Box |
| // innerhalb dieser Line |
| { |
| _SwGCBorder_BoxBrd aBPara; |
| const SvxBorderLine* pBrd; |
| const SfxPoolItem* pItem; |
| const SwTableBoxes& rBoxes = rpLine->GetTabBoxes(); |
| for( sal_uInt16 n = 0, nBoxes = rBoxes.Count() - 1; n < nBoxes; ++n ) |
| { |
| SwTableBoxes aBoxes; |
| { |
| const SwTableBox* pBox = rBoxes[ n ]; |
| if( pBox->GetSttNd() ) |
| aBoxes.Insert( pBox, 0 ); |
| else |
| lcl_GCBorder_GetLastBox_B( pBox, &aBoxes ); |
| } |
| |
| SwTableBox* pBox; |
| for( sal_uInt16 i = aBoxes.Count(); i; ) |
| if( SFX_ITEM_SET == (pBox = aBoxes[ --i ])->GetFrmFmt()-> |
| GetItemState( RES_BOX, sal_True, &pItem ) && |
| 0 != ( pBrd = ((SvxBoxItem*)pItem)->GetRight() ) ) |
| { |
| aBPara.SetBorder( *pBrd ); |
| const SwTableBox* pNextBox = rBoxes[n+1]; |
| if( lcl_GCBorder_ChkBoxBrd_B( pNextBox, &aBPara ) && |
| aBPara.IsAnyBorderFound() ) |
| { |
| SvxBoxItem aBox( *(SvxBoxItem*)pItem ); |
| aBox.SetLine( 0, BOX_LINE_RIGHT ); |
| if( pGCPara->pShareFmts ) |
| pGCPara->pShareFmts->SetAttr( *pBox, aBox ); |
| else |
| pBox->ClaimFrmFmt()->SetFmtAttr( aBox ); |
| } |
| } |
| |
| aBoxes.Remove( 0, aBoxes.Count() ); |
| } |
| } |
| |
| // und jetzt die eigene untere Kante mit der nachfolgenden oberen Kante |
| if( !pGCPara->IsLastLine() ) |
| { |
| SwCollectTblLineBoxes aBottom( sal_False ); |
| SwCollectTblLineBoxes aTop( sal_True ); |
| |
| ::lcl_Line_CollectBox( rpLine, &aBottom ); |
| |
| const SwTableLine* pNextLine = (*pGCPara->pLines)[ pGCPara->nLinePos+1 ]; |
| ::lcl_Line_CollectBox( pNextLine, &aTop ); |
| |
| // dann entferne mal alle "doppelten" gleichen Lines |
| sal_uInt16 nBtmPos, nTopPos, |
| nSttBtm = 0, nSttTop = 0, |
| nEndBtm = aBottom.Count(), nEndTop = aTop.Count(); |
| |
| const SwTableBox *pBtmBox = &aBottom.GetBox( nSttBtm++, &nBtmPos ), |
| *pTopBox = &aTop.GetBox( nSttTop++, &nTopPos ); |
| const SfxPoolItem *pBtmItem = 0, *pTopItem = 0; |
| const SvxBorderLine *pBtmLine(0), *pTopLine(0); |
| sal_Bool bGetTopItem = sal_True, bGetBtmItem = sal_True; |
| |
| do { |
| if( bGetBtmItem ) |
| pBtmLine = lcl_GCBorder_GetBorder( *pBtmBox, sal_False, &pBtmItem ); |
| if( bGetTopItem ) |
| pTopLine = lcl_GCBorder_GetBorder( *pTopBox, sal_True, &pTopItem ); |
| |
| if( pTopLine && pBtmLine && *pTopLine == *pBtmLine ) |
| { |
| // dann kann einer entfernt werden, aber welche? |
| sal_uInt16 nSavSttBtm = nSttBtm, nSavSttTop = nSttTop; |
| sal_uInt16 nBtmEndPos = ::lcl_FindEndPosOfBorder( aBottom, |
| *pTopLine, nSttBtm, sal_False ); |
| if( !nBtmEndPos ) nBtmEndPos = nBtmPos; |
| sal_uInt16 nTopEndPos = ::lcl_FindEndPosOfBorder( aTop, |
| *pTopLine, nSttTop, sal_True ); |
| if( !nTopEndPos ) nTopEndPos = nTopPos; |
| |
| |
| if( nTopEndPos <= nBtmEndPos ) |
| { |
| // dann die TopBorder bis zur BottomEndPos loeschen |
| nSttTop = nSavSttTop; |
| if( nTopPos <= nBtmEndPos ) |
| lcl_GCBorder_DelBorder( aTop, --nSttTop, sal_True, |
| *pBtmLine, pTopItem, nBtmEndPos, |
| pGCPara->pShareFmts ); |
| else |
| nSttBtm = nSavSttBtm; |
| } |
| else |
| { |
| // sonst die BottomBorder bis zur TopEndPos loeschen |
| nSttBtm = nSavSttBtm; |
| if( nBtmPos <= nTopEndPos ) |
| lcl_GCBorder_DelBorder( aBottom, --nSttBtm, sal_False, |
| *pTopLine, pBtmItem, nTopEndPos, |
| pGCPara->pShareFmts ); |
| else |
| nSttTop = nSavSttTop; |
| } |
| nTopPos = nBtmPos; |
| } |
| |
| if( nTopPos == nBtmPos ) |
| { |
| if( nSttBtm >= nEndBtm || nSttTop >= nEndTop ) |
| break; |
| |
| pBtmBox = &aBottom.GetBox( nSttBtm++, &nBtmPos ); |
| pTopBox = &aTop.GetBox( nSttTop++, &nTopPos ); |
| bGetTopItem = bGetBtmItem = sal_True; |
| } |
| else if( nTopPos < nBtmPos ) |
| { |
| if( nSttTop >= nEndTop ) |
| break; |
| pTopBox = &aTop.GetBox( nSttTop++, &nTopPos ); |
| bGetTopItem = sal_True; |
| bGetBtmItem = sal_False; |
| } |
| else |
| { |
| if( nSttBtm >= nEndBtm ) |
| break; |
| pBtmBox = &aBottom.GetBox( nSttBtm++, &nBtmPos ); |
| bGetTopItem = sal_False; |
| bGetBtmItem = sal_True; |
| } |
| |
| } while( sal_True ); |
| } |
| |
| ((SwTableLine*)rpLine)->GetTabBoxes().ForEach( &lcl_GC_Box_Border, pPara ); |
| |
| ++pGCPara->nLinePos; |
| |
| return sal_True; |
| } |
| |
| sal_Bool lcl_GC_Box_Border( const SwTableBox*& rpBox, void* pPara ) |
| { |
| if( rpBox->GetTabLines().Count() ) |
| { |
| _SwGCLineBorder aPara( *rpBox ); |
| aPara.pShareFmts = ((_SwGCLineBorder*)pPara)->pShareFmts; |
| ((SwTableBox*)rpBox)->GetTabLines().ForEach( &lcl_GC_Line_Border, &aPara ); |
| } |
| return sal_True; |
| } |
| |
| struct _GCLinePara |
| { |
| SwTableLines* pLns; |
| SwShareBoxFmts* pShareFmts; |
| |
| _GCLinePara( SwTableLines& rLns, _GCLinePara* pPara = 0 ) |
| : pLns( &rLns ), pShareFmts( pPara ? pPara->pShareFmts : 0 ) |
| {} |
| }; |
| |
| sal_Bool lcl_MergeGCBox( const SwTableBox*& rpTblBox, void* pPara ) |
| { |
| SwTableBox*& rpBox = (SwTableBox*&)rpTblBox; |
| sal_uInt16 n, nLen = rpBox->GetTabLines().Count(); |
| if( nLen ) |
| { |
| // ACHTUNG: die Anzahl der Lines kann sich aendern! |
| _GCLinePara aPara( rpBox->GetTabLines(), (_GCLinePara*)pPara ); |
| for( n = 0; n < rpBox->GetTabLines().Count() && |
| lcl_MergeGCLine( *(rpBox->GetTabLines().GetData() + n), &aPara ); |
| ++n ) |
| ; |
| |
| if( 1 == rpBox->GetTabLines().Count() ) |
| { |
| // Box mit einer Line, dann verschiebe alle Boxen der Line |
| // hinter diese Box in der Parent-Line und loesche diese Box |
| SwTableLine* pInsLine = rpBox->GetUpper(); |
| SwTableLine* pCpyLine = rpBox->GetTabLines()[0]; |
| sal_uInt16 nInsPos = pInsLine->GetTabBoxes().C40_GETPOS( SwTableBox, rpBox ); |
| for( n = 0; n < pCpyLine->GetTabBoxes().Count(); ++n ) |
| pCpyLine->GetTabBoxes()[n]->SetUpper( pInsLine ); |
| |
| pInsLine->GetTabBoxes().Insert( &pCpyLine->GetTabBoxes(), nInsPos+1 ); |
| pCpyLine->GetTabBoxes().Remove( 0, n ); |
| // loesche alte die Box mit der Line |
| pInsLine->GetTabBoxes().DeleteAndDestroy( nInsPos ); |
| |
| return sal_False; // neu aufsetzen |
| } |
| } |
| return sal_True; |
| } |
| |
| sal_Bool lcl_MergeGCLine( const SwTableLine*& rpLine, void* pPara ) |
| { |
| SwTableLine* pLn = (SwTableLine*)rpLine; |
| sal_uInt16 nLen = pLn->GetTabBoxes().Count(); |
| if( nLen ) |
| { |
| _GCLinePara* pGCPara = (_GCLinePara*)pPara; |
| while( 1 == nLen ) |
| { |
| // es gibt eine Box mit Lines |
| SwTableBox* pBox = pLn->GetTabBoxes()[0]; |
| if( !pBox->GetTabLines().Count() ) |
| break; |
| |
| SwTableLine* pLine = pBox->GetTabLines()[0]; |
| |
| // pLine wird zu der aktuellen, also der rpLine, |
| // die restlichen werden ins LinesArray hinter der akt. |
| // verschoben. |
| // Das LinesArray ist im pPara! |
| nLen = pBox->GetTabLines().Count(); |
| |
| SwTableLines& rLns = *pGCPara->pLns; |
| const SwTableLine* pTmp = pLn; |
| sal_uInt16 nInsPos = rLns.GetPos( pTmp ); |
| ASSERT( USHRT_MAX != nInsPos, "Line nicht gefunden!" ); |
| |
| SwTableBox* pUpper = pLn->GetUpper(); |
| |
| rLns.Remove( nInsPos, 1 ); // die Line dem aus Array loeschen |
| rLns.Insert( &pBox->GetTabLines(), nInsPos ); |
| |
| // JP 31.03.99: Bug 60000 - die Attribute der zu loeschenden |
| // Line an die "eingefuegten" uebertragen |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == pLn->GetFrmFmt()->GetItemState( |
| RES_BACKGROUND, sal_True, &pItem )) |
| { |
| SwTableLines& rBoxLns = pBox->GetTabLines(); |
| for( sal_uInt16 nLns = 0; nLns < nLen; ++nLns ) |
| if( SFX_ITEM_SET != rBoxLns[ nLns ]->GetFrmFmt()-> |
| GetItemState( RES_BACKGROUND, sal_True )) |
| pGCPara->pShareFmts->SetAttr( *rBoxLns[ nLns ], *pItem ); |
| } |
| |
| pBox->GetTabLines().Remove( 0, nLen ); // Lines aus Array loeschen |
| |
| delete pLn; |
| |
| // Abhaengigkeit neu setzen |
| while( nLen-- ) |
| rLns[ nInsPos++ ]->SetUpper( pUpper ); |
| |
| pLn = pLine; // und neu setzen |
| nLen = pLn->GetTabBoxes().Count(); |
| } |
| |
| // ACHTUNG: die Anzahl der Boxen kann sich aendern! |
| for( nLen = 0; nLen < pLn->GetTabBoxes().Count(); ++nLen ) |
| if( !lcl_MergeGCBox( *(pLn->GetTabBoxes().GetData() + nLen ), pPara )) |
| --nLen; |
| } |
| return sal_True; |
| } |
| |
| // Struktur ein wenig aufraeumen |
| void SwTable::GCLines() |
| { |
| // ACHTUNG: die Anzahl der Lines kann sich aendern! |
| _GCLinePara aPara( GetTabLines() ); |
| SwShareBoxFmts aShareFmts; |
| aPara.pShareFmts = &aShareFmts; |
| for( sal_uInt16 n = 0; n < GetTabLines().Count() && |
| lcl_MergeGCLine( *(GetTabLines().GetData() + n ), &aPara ); ++n ) |
| ; |
| } |
| |
| |