1*efeef26fSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*efeef26fSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*efeef26fSAndrew Rist * or more contributor license agreements. See the NOTICE file
5*efeef26fSAndrew Rist * distributed with this work for additional information
6*efeef26fSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*efeef26fSAndrew Rist * to you under the Apache License, Version 2.0 (the
8*efeef26fSAndrew Rist * "License"); you may not use this file except in compliance
9*efeef26fSAndrew Rist * with the License. You may obtain a copy of the License at
10*efeef26fSAndrew Rist *
11*efeef26fSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*efeef26fSAndrew Rist *
13*efeef26fSAndrew Rist * Unless required by applicable law or agreed to in writing,
14*efeef26fSAndrew Rist * software distributed under the License is distributed on an
15*efeef26fSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*efeef26fSAndrew Rist * KIND, either express or implied. See the License for the
17*efeef26fSAndrew Rist * specific language governing permissions and limitations
18*efeef26fSAndrew Rist * under the License.
19*efeef26fSAndrew Rist *
20*efeef26fSAndrew Rist *************************************************************/
21*efeef26fSAndrew Rist
22*efeef26fSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sw.hxx"
26cdf0e10cSrcweir #include "hintids.hxx"
27cdf0e10cSrcweir
28cdf0e10cSrcweir //#define TEST_DELAYED_RESIZE
29cdf0e10cSrcweir
30cdf0e10cSrcweir #ifdef TEST_DELAYED_RESIZE
31cdf0e10cSrcweir #include <vcl/sound.hxx>
32cdf0e10cSrcweir #endif
33cdf0e10cSrcweir #include <vcl/wrkwin.hxx>
34cdf0e10cSrcweir #include <vcl/svapp.hxx>
35cdf0e10cSrcweir #include <sot/storage.hxx>
36cdf0e10cSrcweir #include <fmtornt.hxx>
37cdf0e10cSrcweir #include <fmtfsize.hxx>
38cdf0e10cSrcweir #include <frmfmt.hxx>
39cdf0e10cSrcweir #include <docary.hxx>
40cdf0e10cSrcweir #include "ndtxt.hxx"
41cdf0e10cSrcweir #include "doc.hxx"
42cdf0e10cSrcweir #include "swtable.hxx"
43cdf0e10cSrcweir #include "rootfrm.hxx"
44cdf0e10cSrcweir #include "docsh.hxx"
45cdf0e10cSrcweir #include "flyfrm.hxx"
46cdf0e10cSrcweir #include "poolfmt.hxx"
47cdf0e10cSrcweir #include "viewsh.hxx"
48cdf0e10cSrcweir #include "tabfrm.hxx"
49cdf0e10cSrcweir #include "viewopt.hxx"
50cdf0e10cSrcweir #include "htmltbl.hxx"
51cdf0e10cSrcweir #include "ndindex.hxx"
52cdf0e10cSrcweir #include "switerator.hxx"
53cdf0e10cSrcweir
54cdf0e10cSrcweir using namespace ::com::sun::star;
55cdf0e10cSrcweir
56cdf0e10cSrcweir
57cdf0e10cSrcweir #define COLFUZZY 20
58cdf0e10cSrcweir #define MAX_TABWIDTH (USHRT_MAX - 2001)
59cdf0e10cSrcweir
60cdf0e10cSrcweir
61cdf0e10cSrcweir class SwHTMLTableLayoutConstraints
62cdf0e10cSrcweir {
63cdf0e10cSrcweir sal_uInt16 nRow; // Start-Zeile
64cdf0e10cSrcweir sal_uInt16 nCol; // Start-Spalte
65cdf0e10cSrcweir sal_uInt16 nColSpan; // COLSPAN der Zelle
66cdf0e10cSrcweir
67cdf0e10cSrcweir SwHTMLTableLayoutConstraints *pNext; // die naechste Bedingung
68cdf0e10cSrcweir
69cdf0e10cSrcweir sal_uLong nMinNoAlign, nMaxNoAlign; // Zwischenergebnisse AL-Pass 1
70cdf0e10cSrcweir
71cdf0e10cSrcweir public:
72cdf0e10cSrcweir
73cdf0e10cSrcweir SwHTMLTableLayoutConstraints( sal_uLong nMin, sal_uLong nMax, sal_uInt16 nRow,
74cdf0e10cSrcweir sal_uInt16 nCol, sal_uInt16 nColSp );
75cdf0e10cSrcweir ~SwHTMLTableLayoutConstraints();
76cdf0e10cSrcweir
GetMinNoAlign() const77cdf0e10cSrcweir sal_uLong GetMinNoAlign() const { return nMinNoAlign; }
GetMaxNoAlign() const78cdf0e10cSrcweir sal_uLong GetMaxNoAlign() const { return nMaxNoAlign; }
79cdf0e10cSrcweir
80cdf0e10cSrcweir SwHTMLTableLayoutConstraints *InsertNext( SwHTMLTableLayoutConstraints *pNxt );
GetNext() const81cdf0e10cSrcweir SwHTMLTableLayoutConstraints* GetNext() const { return pNext; }
82cdf0e10cSrcweir
GetRow() const83cdf0e10cSrcweir sal_uInt16 GetRow() const { return nRow; }
84cdf0e10cSrcweir
GetColSpan() const85cdf0e10cSrcweir sal_uInt16 GetColSpan() const { return nColSpan; }
GetColumn() const86cdf0e10cSrcweir sal_uInt16 GetColumn() const { return nCol; }
87cdf0e10cSrcweir };
88cdf0e10cSrcweir
89cdf0e10cSrcweir /* */
90cdf0e10cSrcweir
SwHTMLTableLayoutCnts(const SwStartNode * pSttNd,SwHTMLTableLayout * pTab,sal_Bool bNoBrTag,SwHTMLTableLayoutCnts * pNxt)91cdf0e10cSrcweir SwHTMLTableLayoutCnts::SwHTMLTableLayoutCnts( const SwStartNode *pSttNd,
92cdf0e10cSrcweir SwHTMLTableLayout* pTab,
93cdf0e10cSrcweir sal_Bool bNoBrTag,
94cdf0e10cSrcweir SwHTMLTableLayoutCnts* pNxt ) :
95cdf0e10cSrcweir pNext( pNxt ), pBox( 0 ), pTable( pTab ), pStartNode( pSttNd ),
96cdf0e10cSrcweir nPass1Done( 0 ), nWidthSet( 0 ), bNoBreakTag( bNoBrTag )
97cdf0e10cSrcweir {}
98cdf0e10cSrcweir
~SwHTMLTableLayoutCnts()99cdf0e10cSrcweir SwHTMLTableLayoutCnts::~SwHTMLTableLayoutCnts()
100cdf0e10cSrcweir {
101cdf0e10cSrcweir delete pNext;
102cdf0e10cSrcweir delete pTable;
103cdf0e10cSrcweir }
104cdf0e10cSrcweir
GetStartNode() const105cdf0e10cSrcweir const SwStartNode *SwHTMLTableLayoutCnts::GetStartNode() const
106cdf0e10cSrcweir {
107cdf0e10cSrcweir return pBox ? pBox->GetSttNd() : pStartNode;
108cdf0e10cSrcweir }
109cdf0e10cSrcweir
110cdf0e10cSrcweir
111cdf0e10cSrcweir /* */
112cdf0e10cSrcweir
SwHTMLTableLayoutCell(SwHTMLTableLayoutCnts * pCnts,sal_uInt16 nRSpan,sal_uInt16 nCSpan,sal_uInt16 nWidth,sal_Bool bPrcWidth,sal_Bool bNWrapOpt)113cdf0e10cSrcweir SwHTMLTableLayoutCell::SwHTMLTableLayoutCell( SwHTMLTableLayoutCnts *pCnts,
114cdf0e10cSrcweir sal_uInt16 nRSpan, sal_uInt16 nCSpan,
115cdf0e10cSrcweir sal_uInt16 nWidth, sal_Bool bPrcWidth,
116cdf0e10cSrcweir sal_Bool bNWrapOpt ) :
117cdf0e10cSrcweir pContents( pCnts ),
118cdf0e10cSrcweir nRowSpan( nRSpan ), nColSpan( nCSpan ),
119cdf0e10cSrcweir nWidthOption( nWidth ), bPrcWidthOption( bPrcWidth ),
120cdf0e10cSrcweir bNoWrapOption( bNWrapOpt )
121cdf0e10cSrcweir {}
122cdf0e10cSrcweir
~SwHTMLTableLayoutCell()123cdf0e10cSrcweir SwHTMLTableLayoutCell::~SwHTMLTableLayoutCell()
124cdf0e10cSrcweir {
125cdf0e10cSrcweir if( nRowSpan==1 && nColSpan==1 )
126cdf0e10cSrcweir {
127cdf0e10cSrcweir delete pContents;
128cdf0e10cSrcweir }
129cdf0e10cSrcweir }
130cdf0e10cSrcweir
131cdf0e10cSrcweir /* */
132cdf0e10cSrcweir
SwHTMLTableLayoutColumn(sal_uInt16 nWidth,sal_Bool bRelWidth,sal_Bool bLBorder)133cdf0e10cSrcweir SwHTMLTableLayoutColumn::SwHTMLTableLayoutColumn( sal_uInt16 nWidth,
134cdf0e10cSrcweir sal_Bool bRelWidth,
135cdf0e10cSrcweir sal_Bool bLBorder ) :
136cdf0e10cSrcweir nMinNoAlign(MINLAY), nMaxNoAlign(MINLAY), nAbsMinNoAlign(MINLAY),
137cdf0e10cSrcweir nMin(0), nMax(0),
138cdf0e10cSrcweir nAbsColWidth(0), nRelColWidth(0),
139cdf0e10cSrcweir nWidthOption( nWidth ), bRelWidthOption( bRelWidth ),
140cdf0e10cSrcweir bLeftBorder( bLBorder )
141cdf0e10cSrcweir {}
142cdf0e10cSrcweir
143cdf0e10cSrcweir
144cdf0e10cSrcweir /* */
145cdf0e10cSrcweir
SwHTMLTableLayoutConstraints(sal_uLong nMin,sal_uLong nMax,sal_uInt16 nRw,sal_uInt16 nColumn,sal_uInt16 nColSp)146cdf0e10cSrcweir SwHTMLTableLayoutConstraints::SwHTMLTableLayoutConstraints(
147cdf0e10cSrcweir sal_uLong nMin, sal_uLong nMax, sal_uInt16 nRw, sal_uInt16 nColumn, sal_uInt16 nColSp ):
148cdf0e10cSrcweir nRow( nRw ), nCol( nColumn ), nColSpan( nColSp ),
149cdf0e10cSrcweir pNext( 0 ),
150cdf0e10cSrcweir nMinNoAlign( nMin ), nMaxNoAlign( nMax )
151cdf0e10cSrcweir {}
152cdf0e10cSrcweir
~SwHTMLTableLayoutConstraints()153cdf0e10cSrcweir SwHTMLTableLayoutConstraints::~SwHTMLTableLayoutConstraints()
154cdf0e10cSrcweir {
155cdf0e10cSrcweir delete pNext;
156cdf0e10cSrcweir }
157cdf0e10cSrcweir
InsertNext(SwHTMLTableLayoutConstraints * pNxt)158cdf0e10cSrcweir SwHTMLTableLayoutConstraints *SwHTMLTableLayoutConstraints::InsertNext(
159cdf0e10cSrcweir SwHTMLTableLayoutConstraints *pNxt )
160cdf0e10cSrcweir {
161cdf0e10cSrcweir SwHTMLTableLayoutConstraints *pPrev = 0;
162cdf0e10cSrcweir SwHTMLTableLayoutConstraints *pConstr = this;
163cdf0e10cSrcweir while( pConstr )
164cdf0e10cSrcweir {
165cdf0e10cSrcweir if( pConstr->GetRow() > pNxt->GetRow() ||
166cdf0e10cSrcweir pConstr->GetColumn() > pNxt->GetColumn() )
167cdf0e10cSrcweir break;
168cdf0e10cSrcweir pPrev = pConstr;
169cdf0e10cSrcweir pConstr = pConstr->GetNext();
170cdf0e10cSrcweir }
171cdf0e10cSrcweir
172cdf0e10cSrcweir if( pPrev )
173cdf0e10cSrcweir {
174cdf0e10cSrcweir pNxt->pNext = pPrev->GetNext();
175cdf0e10cSrcweir pPrev->pNext = pNxt;
176cdf0e10cSrcweir pConstr = this;
177cdf0e10cSrcweir }
178cdf0e10cSrcweir else
179cdf0e10cSrcweir {
180cdf0e10cSrcweir pNxt->pNext = this;
181cdf0e10cSrcweir pConstr = pNxt;
182cdf0e10cSrcweir }
183cdf0e10cSrcweir
184cdf0e10cSrcweir return pConstr;
185cdf0e10cSrcweir }
186cdf0e10cSrcweir
187cdf0e10cSrcweir /* */
188cdf0e10cSrcweir
189cdf0e10cSrcweir typedef SwHTMLTableLayoutColumn *SwHTMLTableLayoutColumnPtr;
190cdf0e10cSrcweir typedef SwHTMLTableLayoutCell *SwHTMLTableLayoutCellPtr;
191cdf0e10cSrcweir
SwHTMLTableLayout(const SwTable * pSwTbl,sal_uInt16 nRws,sal_uInt16 nCls,sal_Bool bColsOpt,sal_Bool bColTgs,sal_uInt16 nWdth,sal_Bool bPrcWdth,sal_uInt16 nBorderOpt,sal_uInt16 nCellPad,sal_uInt16 nCellSp,SvxAdjust eAdjust,sal_uInt16 nLMargin,sal_uInt16 nRMargin,sal_uInt16 nBWidth,sal_uInt16 nLeftBWidth,sal_uInt16 nRightBWidth,sal_uInt16 nInhLeftBWidth,sal_uInt16 nInhRightBWidth)192cdf0e10cSrcweir SwHTMLTableLayout::SwHTMLTableLayout(
193cdf0e10cSrcweir const SwTable * pSwTbl,
194cdf0e10cSrcweir sal_uInt16 nRws, sal_uInt16 nCls, sal_Bool bColsOpt, sal_Bool bColTgs,
195cdf0e10cSrcweir sal_uInt16 nWdth, sal_Bool bPrcWdth, sal_uInt16 nBorderOpt,
196cdf0e10cSrcweir sal_uInt16 nCellPad, sal_uInt16 nCellSp, SvxAdjust eAdjust,
197cdf0e10cSrcweir sal_uInt16 nLMargin, sal_uInt16 nRMargin,
198cdf0e10cSrcweir sal_uInt16 nBWidth, sal_uInt16 nLeftBWidth,
199cdf0e10cSrcweir sal_uInt16 nRightBWidth,
200cdf0e10cSrcweir sal_uInt16 nInhLeftBWidth, sal_uInt16 nInhRightBWidth ) :
201cdf0e10cSrcweir aColumns( new SwHTMLTableLayoutColumnPtr[nCls] ),
202cdf0e10cSrcweir aCells( new SwHTMLTableLayoutCellPtr[nRws*nCls] ),
203cdf0e10cSrcweir pSwTable( pSwTbl ), pLeftFillerBox( 0 ), pRightFillerBox( 0 ),
204cdf0e10cSrcweir nMin( 0 ), nMax( 0 ),
205cdf0e10cSrcweir nRows( nRws ), nCols( nCls ),
206cdf0e10cSrcweir nLeftMargin( nLMargin ), nRightMargin( nRMargin ),
207cdf0e10cSrcweir nInhAbsLeftSpace( 0 ), nInhAbsRightSpace( 0 ),
208cdf0e10cSrcweir nRelLeftFill( 0 ), nRelRightFill( 0 ),
209cdf0e10cSrcweir nRelTabWidth( 0 ), nWidthOption( nWdth ),
210cdf0e10cSrcweir nCellPadding( nCellPad ), nCellSpacing( nCellSp ), nBorder( nBorderOpt ),
211cdf0e10cSrcweir nLeftBorderWidth( nLeftBWidth ), nRightBorderWidth( nRightBWidth ),
212cdf0e10cSrcweir nInhLeftBorderWidth( nInhLeftBWidth ),
213cdf0e10cSrcweir nInhRightBorderWidth( nInhRightBWidth ),
214cdf0e10cSrcweir nBorderWidth( nBWidth ),
215cdf0e10cSrcweir nDelayedResizeAbsAvail( 0 ), nLastResizeAbsAvail( 0 ),
216cdf0e10cSrcweir nPass1Done( 0 ), nWidthSet( 0 ), eTableAdjust( eAdjust ),
217cdf0e10cSrcweir bColsOption( bColsOpt ), bColTags( bColTgs ),
218cdf0e10cSrcweir bPrcWidthOption( bPrcWdth ), bUseRelWidth( sal_False ),
219cdf0e10cSrcweir bMustResize( sal_True ), bExportable( sal_True ), bBordersChanged( sal_False ),
220cdf0e10cSrcweir bMustNotResize( sal_False ), bMustNotRecalc( sal_False )
221cdf0e10cSrcweir {
222cdf0e10cSrcweir aResizeTimer.SetTimeoutHdl( STATIC_LINK( this, SwHTMLTableLayout,
223cdf0e10cSrcweir DelayedResize_Impl ) );
224cdf0e10cSrcweir }
225cdf0e10cSrcweir
~SwHTMLTableLayout()226cdf0e10cSrcweir SwHTMLTableLayout::~SwHTMLTableLayout()
227cdf0e10cSrcweir {
228cdf0e10cSrcweir sal_uInt16 i;
229cdf0e10cSrcweir
230cdf0e10cSrcweir for( i = 0; i < nCols; i++ )
231cdf0e10cSrcweir delete aColumns[i];
232cdf0e10cSrcweir delete[] aColumns;
233cdf0e10cSrcweir
234cdf0e10cSrcweir sal_uInt16 nCount = nRows*nCols;
235cdf0e10cSrcweir for( i=0; i<nCount; i++ )
236cdf0e10cSrcweir delete aCells[i];
237cdf0e10cSrcweir delete[] aCells;
238cdf0e10cSrcweir }
239cdf0e10cSrcweir
240cdf0e10cSrcweir // Die Breiten der Umrandung werden zunaechst wie in Netscape berechnet:
241cdf0e10cSrcweir // Aussere Umrandung: BORDER + CELLSPACING + CELLPADDING
242cdf0e10cSrcweir // Innere Umrandung: CELLSPACING + CELLPADDING
243cdf0e10cSrcweir // Allerdings wird die Breite der Umrandung im SW trotzdem beachtet, wenn
244cdf0e10cSrcweir // bSwBorders gesetzt ist, damit nicht faellschlich umgebrochen wird.
245cdf0e10cSrcweir // MIB 27.6.97: Dabei muss auch der Abstand zum Inhalt berueckichtigt werden,
246cdf0e10cSrcweir // und zwar auch dann, wenn wenn nur die gegenueberliegende Seite
247cdf0e10cSrcweir // eine Umrandung hat.
GetLeftCellSpace(sal_uInt16 nCol,sal_uInt16 nColSpan,sal_Bool bSwBorders) const248cdf0e10cSrcweir sal_uInt16 SwHTMLTableLayout::GetLeftCellSpace( sal_uInt16 nCol, sal_uInt16 nColSpan,
249cdf0e10cSrcweir sal_Bool bSwBorders ) const
250cdf0e10cSrcweir {
251cdf0e10cSrcweir sal_uInt16 nSpace = nCellSpacing + nCellPadding;
252cdf0e10cSrcweir
253cdf0e10cSrcweir if( nCol == 0 )
254cdf0e10cSrcweir {
255cdf0e10cSrcweir nSpace = nSpace + nBorder;
256cdf0e10cSrcweir
257cdf0e10cSrcweir if( bSwBorders && nSpace < nLeftBorderWidth )
258cdf0e10cSrcweir nSpace = nLeftBorderWidth;
259cdf0e10cSrcweir }
260cdf0e10cSrcweir else if( bSwBorders )
261cdf0e10cSrcweir {
262cdf0e10cSrcweir if( GetColumn(nCol)->HasLeftBorder() )
263cdf0e10cSrcweir {
264cdf0e10cSrcweir if( nSpace < nBorderWidth )
265cdf0e10cSrcweir nSpace = nBorderWidth;
266cdf0e10cSrcweir }
267cdf0e10cSrcweir else if( nCol+nColSpan == nCols && nRightBorderWidth &&
268cdf0e10cSrcweir nSpace < MIN_BORDER_DIST )
269cdf0e10cSrcweir {
270cdf0e10cSrcweir ASSERT( !nCellPadding, "GetLeftCellSpace: CELLPADDING!=0" );
271cdf0e10cSrcweir // Wenn die Gegenueberliegende Seite umrandet ist muessen
272cdf0e10cSrcweir // wir zumindest den minimalen Abstand zum Inhalt
273cdf0e10cSrcweir // beruecksichtigen. (Koennte man zusaetzlich auch an
274cdf0e10cSrcweir // nCellPadding festmachen.)
275cdf0e10cSrcweir nSpace = MIN_BORDER_DIST;
276cdf0e10cSrcweir }
277cdf0e10cSrcweir }
278cdf0e10cSrcweir
279cdf0e10cSrcweir return nSpace;
280cdf0e10cSrcweir }
281cdf0e10cSrcweir
GetRightCellSpace(sal_uInt16 nCol,sal_uInt16 nColSpan,sal_Bool bSwBorders) const282cdf0e10cSrcweir sal_uInt16 SwHTMLTableLayout::GetRightCellSpace( sal_uInt16 nCol, sal_uInt16 nColSpan,
283cdf0e10cSrcweir sal_Bool bSwBorders ) const
284cdf0e10cSrcweir {
285cdf0e10cSrcweir sal_uInt16 nSpace = nCellPadding;
286cdf0e10cSrcweir
287cdf0e10cSrcweir if( nCol+nColSpan == nCols )
288cdf0e10cSrcweir {
289cdf0e10cSrcweir nSpace += nBorder + nCellSpacing;
290cdf0e10cSrcweir if( bSwBorders && nSpace < nRightBorderWidth )
291cdf0e10cSrcweir nSpace = nRightBorderWidth;
292cdf0e10cSrcweir }
293cdf0e10cSrcweir else if( bSwBorders && GetColumn(nCol)->HasLeftBorder() &&
294cdf0e10cSrcweir nSpace < MIN_BORDER_DIST )
295cdf0e10cSrcweir {
296cdf0e10cSrcweir ASSERT( !nCellPadding, "GetRightCellSpace: CELLPADDING!=0" );
297cdf0e10cSrcweir // Wenn die Gegenueberliegende Seite umrandet ist muessen
298cdf0e10cSrcweir // wir zumindest den minimalen Abstand zum Inhalt
299cdf0e10cSrcweir // beruecksichtigen. (Koennte man zusaetzlich auch an
300cdf0e10cSrcweir // nCellPadding festmachen.)
301cdf0e10cSrcweir nSpace = MIN_BORDER_DIST;
302cdf0e10cSrcweir }
303cdf0e10cSrcweir
304cdf0e10cSrcweir return nSpace;
305cdf0e10cSrcweir }
306cdf0e10cSrcweir
AddBorderWidth(sal_uLong & rMin,sal_uLong & rMax,sal_uLong & rAbsMin,sal_uInt16 nCol,sal_uInt16 nColSpan,sal_Bool bSwBorders) const307cdf0e10cSrcweir void SwHTMLTableLayout::AddBorderWidth( sal_uLong &rMin, sal_uLong &rMax,
308cdf0e10cSrcweir sal_uLong &rAbsMin,
309cdf0e10cSrcweir sal_uInt16 nCol, sal_uInt16 nColSpan,
310cdf0e10cSrcweir sal_Bool bSwBorders ) const
311cdf0e10cSrcweir {
312cdf0e10cSrcweir sal_uLong nAdd = GetLeftCellSpace( nCol, nColSpan, bSwBorders ) +
313cdf0e10cSrcweir GetRightCellSpace( nCol, nColSpan, bSwBorders );
314cdf0e10cSrcweir
315cdf0e10cSrcweir rMin += nAdd;
316cdf0e10cSrcweir rMax += nAdd;
317cdf0e10cSrcweir rAbsMin += nAdd;
318cdf0e10cSrcweir }
319cdf0e10cSrcweir
SetBoxWidth(SwTableBox * pBox,sal_uInt16 nCol,sal_uInt16 nColSpan) const320cdf0e10cSrcweir void SwHTMLTableLayout::SetBoxWidth( SwTableBox *pBox, sal_uInt16 nCol,
321cdf0e10cSrcweir sal_uInt16 nColSpan ) const
322cdf0e10cSrcweir {
323cdf0e10cSrcweir SwFrmFmt *pFrmFmt = pBox->GetFrmFmt();
324cdf0e10cSrcweir
325cdf0e10cSrcweir // die Breite der Box berechnen
326cdf0e10cSrcweir SwTwips nFrmWidth = 0;
327cdf0e10cSrcweir while( nColSpan-- )
328cdf0e10cSrcweir nFrmWidth += GetColumn( nCol++ )->GetRelColWidth();
329cdf0e10cSrcweir
330cdf0e10cSrcweir // und neu setzen
331cdf0e10cSrcweir
332cdf0e10cSrcweir pFrmFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nFrmWidth, 0 ));
333cdf0e10cSrcweir }
334cdf0e10cSrcweir
GetAvail(sal_uInt16 nCol,sal_uInt16 nColSpan,sal_uInt16 & rAbsAvail,sal_uInt16 & rRelAvail) const335cdf0e10cSrcweir void SwHTMLTableLayout::GetAvail( sal_uInt16 nCol, sal_uInt16 nColSpan,
336cdf0e10cSrcweir sal_uInt16& rAbsAvail, sal_uInt16& rRelAvail ) const
337cdf0e10cSrcweir {
338cdf0e10cSrcweir rAbsAvail = 0;
339cdf0e10cSrcweir rRelAvail = 0;
340cdf0e10cSrcweir for( sal_uInt16 i=nCol; i<nCol+nColSpan;i++ )
341cdf0e10cSrcweir {
342cdf0e10cSrcweir const SwHTMLTableLayoutColumn *pColumn = GetColumn(i);
343cdf0e10cSrcweir rAbsAvail = rAbsAvail + pColumn->GetAbsColWidth();
344cdf0e10cSrcweir rRelAvail = rRelAvail + pColumn->GetRelColWidth();
345cdf0e10cSrcweir }
346cdf0e10cSrcweir }
347cdf0e10cSrcweir
GetBrowseWidthByVisArea(const SwDoc & rDoc)348cdf0e10cSrcweir sal_uInt16 SwHTMLTableLayout::GetBrowseWidthByVisArea( const SwDoc& rDoc )
349cdf0e10cSrcweir {
350cdf0e10cSrcweir ViewShell *pVSh = 0;
351cdf0e10cSrcweir rDoc.GetEditShell( &pVSh );
352cdf0e10cSrcweir if( pVSh )
353cdf0e10cSrcweir {
354cdf0e10cSrcweir return (sal_uInt16)pVSh->GetBrowseWidth();
355cdf0e10cSrcweir }
356cdf0e10cSrcweir
357cdf0e10cSrcweir return 0;
358cdf0e10cSrcweir }
359cdf0e10cSrcweir
GetBrowseWidth(const SwDoc & rDoc)360cdf0e10cSrcweir sal_uInt16 SwHTMLTableLayout::GetBrowseWidth( const SwDoc& rDoc )
361cdf0e10cSrcweir {
362cdf0e10cSrcweir // Wenn ein Layout da ist, koennen wir die Breite dort herholen.
363cdf0e10cSrcweir const SwRootFrm *pRootFrm = rDoc.GetCurrentLayout(); //swmod 080218
364cdf0e10cSrcweir if( pRootFrm )
365cdf0e10cSrcweir {
366cdf0e10cSrcweir const SwFrm *pPageFrm = pRootFrm->GetLower();
367cdf0e10cSrcweir if( pPageFrm )
368cdf0e10cSrcweir return (sal_uInt16)pPageFrm->Prt().Width();
369cdf0e10cSrcweir }
370cdf0e10cSrcweir
371cdf0e10cSrcweir // --> OD 2010-05-12 #i91658#
372cdf0e10cSrcweir // Assertion removed which state that no browse width is available.
373cdf0e10cSrcweir // Investigation reveals that all calls can handle the case that no browse
374cdf0e10cSrcweir // width is provided.
375cdf0e10cSrcweir return GetBrowseWidthByVisArea( rDoc );
376cdf0e10cSrcweir // <--
377cdf0e10cSrcweir }
378cdf0e10cSrcweir
GetBrowseWidthByTabFrm(const SwTabFrm & rTabFrm) const379cdf0e10cSrcweir sal_uInt16 SwHTMLTableLayout::GetBrowseWidthByTabFrm(
380cdf0e10cSrcweir const SwTabFrm& rTabFrm ) const
381cdf0e10cSrcweir {
382cdf0e10cSrcweir SwTwips nWidth = 0;
383cdf0e10cSrcweir
384cdf0e10cSrcweir const SwFrm *pUpper = rTabFrm.GetUpper();
385cdf0e10cSrcweir if( MayBeInFlyFrame() && pUpper->IsFlyFrm() &&
386cdf0e10cSrcweir ((const SwFlyFrm *)pUpper)->GetAnchorFrm() )
387cdf0e10cSrcweir {
388cdf0e10cSrcweir // Wenn die Tabelle in einem selbst angelegten Rahmen steht, dann ist
389cdf0e10cSrcweir // die Breite Ankers und nicht die Breite Rahmens von Bedeutung.
390cdf0e10cSrcweir // Bei Absatz-gebundenen Rahmen werden Absatz-Einzuege nicht beachtet.
391cdf0e10cSrcweir const SwFrm *pAnchor = ((const SwFlyFrm *)pUpper)->GetAnchorFrm();
392cdf0e10cSrcweir if( pAnchor->IsTxtFrm() )
393cdf0e10cSrcweir nWidth = pAnchor->Frm().Width();
394cdf0e10cSrcweir else
395cdf0e10cSrcweir nWidth = pAnchor->Prt().Width();
396cdf0e10cSrcweir }
397cdf0e10cSrcweir else
398cdf0e10cSrcweir {
399cdf0e10cSrcweir nWidth = pUpper->Prt().Width();
400cdf0e10cSrcweir }
401cdf0e10cSrcweir
402cdf0e10cSrcweir SwTwips nUpperDummy = 0;
403cdf0e10cSrcweir long nRightOffset = 0,
404cdf0e10cSrcweir nLeftOffset = 0;
405cdf0e10cSrcweir rTabFrm.CalcFlyOffsets( nUpperDummy, nLeftOffset, nRightOffset );
406cdf0e10cSrcweir nWidth -= (nLeftOffset + nRightOffset);
407cdf0e10cSrcweir
408cdf0e10cSrcweir return nWidth < USHRT_MAX ? static_cast<sal_uInt16>(nWidth) : USHRT_MAX;
409cdf0e10cSrcweir }
410cdf0e10cSrcweir
GetBrowseWidthByTable(const SwDoc & rDoc) const411cdf0e10cSrcweir sal_uInt16 SwHTMLTableLayout::GetBrowseWidthByTable( const SwDoc& rDoc ) const
412cdf0e10cSrcweir {
413cdf0e10cSrcweir sal_uInt16 nBrowseWidth = 0;
414cdf0e10cSrcweir SwTabFrm* pFrm = SwIterator<SwTabFrm,SwFmt>::FirstElement( *pSwTable->GetFrmFmt() );
415cdf0e10cSrcweir if( pFrm )
416cdf0e10cSrcweir {
417cdf0e10cSrcweir nBrowseWidth = GetBrowseWidthByTabFrm( *pFrm );
418cdf0e10cSrcweir }
419cdf0e10cSrcweir else
420cdf0e10cSrcweir {
421cdf0e10cSrcweir nBrowseWidth = SwHTMLTableLayout::GetBrowseWidth( rDoc );
422cdf0e10cSrcweir }
423cdf0e10cSrcweir
424cdf0e10cSrcweir return nBrowseWidth;
425cdf0e10cSrcweir }
426cdf0e10cSrcweir
GetAnyBoxStartNode() const427cdf0e10cSrcweir const SwStartNode *SwHTMLTableLayout::GetAnyBoxStartNode() const
428cdf0e10cSrcweir {
429cdf0e10cSrcweir const SwStartNode *pBoxSttNd;
430cdf0e10cSrcweir
431cdf0e10cSrcweir const SwTableBox* pBox = pSwTable->GetTabLines()[0]->GetTabBoxes()[0];
432cdf0e10cSrcweir while( 0 == (pBoxSttNd = pBox->GetSttNd()) )
433cdf0e10cSrcweir {
434cdf0e10cSrcweir ASSERT( pBox->GetTabLines().Count() > 0,
435cdf0e10cSrcweir "Box ohne Start-Node und Lines" );
436cdf0e10cSrcweir ASSERT( pBox->GetTabLines()[0]->GetTabBoxes().Count() > 0,
437cdf0e10cSrcweir "Line ohne Boxen" );
438cdf0e10cSrcweir pBox = pBox->GetTabLines()[0]->GetTabBoxes()[0];
439cdf0e10cSrcweir }
440cdf0e10cSrcweir
441cdf0e10cSrcweir return pBoxSttNd;
442cdf0e10cSrcweir }
443cdf0e10cSrcweir
FindFlyFrmFmt() const444cdf0e10cSrcweir SwFrmFmt *SwHTMLTableLayout::FindFlyFrmFmt() const
445cdf0e10cSrcweir {
446cdf0e10cSrcweir const SwTableNode *pTblNd = GetAnyBoxStartNode()->FindTableNode();
447cdf0e10cSrcweir ASSERT( pTblNd, "Kein Table-Node?" );
448cdf0e10cSrcweir return pTblNd->GetFlyFmt();
449cdf0e10cSrcweir }
450cdf0e10cSrcweir
lcl_GetMinMaxSize(sal_uLong & rMinNoAlignCnts,sal_uLong & rMaxNoAlignCnts,sal_uLong & rAbsMinNoAlignCnts,sal_Bool & rHR,SwTxtNode * pTxtNd,sal_uLong nIdx,sal_Bool bNoBreak)451cdf0e10cSrcweir static void lcl_GetMinMaxSize( sal_uLong& rMinNoAlignCnts, sal_uLong& rMaxNoAlignCnts,
452cdf0e10cSrcweir sal_uLong& rAbsMinNoAlignCnts,
453cdf0e10cSrcweir #ifdef FIX41370
454cdf0e10cSrcweir sal_Bool& rHR,
455cdf0e10cSrcweir #endif
456cdf0e10cSrcweir SwTxtNode *pTxtNd, sal_uLong nIdx, sal_Bool bNoBreak )
457cdf0e10cSrcweir {
458cdf0e10cSrcweir pTxtNd->GetMinMaxSize( nIdx, rMinNoAlignCnts, rMaxNoAlignCnts,
459cdf0e10cSrcweir rAbsMinNoAlignCnts );
460cdf0e10cSrcweir ASSERT( rAbsMinNoAlignCnts <= rMinNoAlignCnts,
461cdf0e10cSrcweir "GetMinMaxSize: absmin > min" );
462cdf0e10cSrcweir ASSERT( rMinNoAlignCnts <= rMaxNoAlignCnts,
463cdf0e10cSrcweir "GetMinMaxSize: max > min" );
464cdf0e10cSrcweir
465cdf0e10cSrcweir //Bei einen <PRE>-Absatz entspricht die maximale Breite der
466cdf0e10cSrcweir // minimalen breite
467cdf0e10cSrcweir const SwFmtColl *pColl = &pTxtNd->GetAnyFmtColl();
468cdf0e10cSrcweir while( pColl && !pColl->IsDefault() &&
469cdf0e10cSrcweir (USER_FMT & pColl->GetPoolFmtId()) )
470cdf0e10cSrcweir {
471cdf0e10cSrcweir pColl = (const SwFmtColl *)pColl->DerivedFrom();
472cdf0e10cSrcweir }
473cdf0e10cSrcweir
474cdf0e10cSrcweir // <NOBR> in der gesamten Zelle bezieht sich auf Text, aber nicht
475cdf0e10cSrcweir // auf Tabellen. Netscape beruecksichtigt dies nur fuer Grafiken.
476cdf0e10cSrcweir if( (pColl && RES_POOLCOLL_HTML_PRE==pColl->GetPoolFmtId()) || bNoBreak )
477cdf0e10cSrcweir {
478cdf0e10cSrcweir rMinNoAlignCnts = rMaxNoAlignCnts;
479cdf0e10cSrcweir rAbsMinNoAlignCnts = rMaxNoAlignCnts;
480cdf0e10cSrcweir }
481cdf0e10cSrcweir #ifdef FIX41370
482cdf0e10cSrcweir else if( pColl && RES_POOLCOLL_HTML_HR==pColl->GetPoolFmtId() )
483cdf0e10cSrcweir {
484cdf0e10cSrcweir rHR |= !pTxtNd->HasSwAttrSet() ||
485cdf0e10cSrcweir SFX_ITEM_SET != pTxtNd->GetpSwAttrSet()
486cdf0e10cSrcweir ->GetItemState( RES_LR_SPACE, sal_False );
487cdf0e10cSrcweir }
488cdf0e10cSrcweir #endif
489cdf0e10cSrcweir }
490cdf0e10cSrcweir
AutoLayoutPass1()491cdf0e10cSrcweir void SwHTMLTableLayout::AutoLayoutPass1()
492cdf0e10cSrcweir {
493cdf0e10cSrcweir nPass1Done++;
494cdf0e10cSrcweir
495cdf0e10cSrcweir ClearPass1Info();
496cdf0e10cSrcweir
497cdf0e10cSrcweir sal_Bool bFixRelWidths = sal_False;
498cdf0e10cSrcweir sal_uInt16 i;
499cdf0e10cSrcweir
500cdf0e10cSrcweir SwHTMLTableLayoutConstraints *pConstraints = 0;
501cdf0e10cSrcweir
502cdf0e10cSrcweir for( i=0; i<nCols; i++ )
503cdf0e10cSrcweir {
504cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
505cdf0e10cSrcweir pColumn->ClearPass1Info( !HasColTags() );
506cdf0e10cSrcweir sal_uInt16 nMinColSpan = USHRT_MAX; // Spaltenzahl, auf die sich dir
507cdf0e10cSrcweir // berechnete Breite bezieht
508cdf0e10cSrcweir sal_uInt16 nColSkip = USHRT_MAX; // Wie viele Spalten muessen
509cdf0e10cSrcweir // uebersprungen werden
510cdf0e10cSrcweir
511cdf0e10cSrcweir for( sal_uInt16 j=0; j<nRows; j++ )
512cdf0e10cSrcweir {
513cdf0e10cSrcweir SwHTMLTableLayoutCell *pCell = GetCell(j,i);
514cdf0e10cSrcweir SwHTMLTableLayoutCnts *pCnts = pCell->GetContents();
515cdf0e10cSrcweir
516cdf0e10cSrcweir // fix #31488#: Zum Ermitteln der naechsten zu berechnenden
517cdf0e10cSrcweir // Spalte muessen alle Zeilen herangezogen werden
518cdf0e10cSrcweir sal_uInt16 nColSpan = pCell->GetColSpan();
519cdf0e10cSrcweir if( nColSpan < nColSkip )
520cdf0e10cSrcweir nColSkip = nColSpan;
521cdf0e10cSrcweir
522cdf0e10cSrcweir if( !pCnts || (pCnts && !pCnts->IsPass1Done(nPass1Done)) )
523cdf0e10cSrcweir {
524cdf0e10cSrcweir // die Zelle ist leer oder ihr Inhalt wurde nich nicht
525cdf0e10cSrcweir // bearbeitet
526cdf0e10cSrcweir if( nColSpan < nMinColSpan )
527cdf0e10cSrcweir nMinColSpan = nColSpan;
528cdf0e10cSrcweir
529cdf0e10cSrcweir sal_uLong nMinNoAlignCell = 0;
530cdf0e10cSrcweir sal_uLong nMaxNoAlignCell = 0;
531cdf0e10cSrcweir sal_uLong nAbsMinNoAlignCell = 0;
532cdf0e10cSrcweir sal_uLong nMaxTableCell = 0;
533cdf0e10cSrcweir sal_uLong nAbsMinTableCell = 0;
534cdf0e10cSrcweir #ifdef FIX41370
535cdf0e10cSrcweir sal_Bool bHR = sal_False;
536cdf0e10cSrcweir #endif
537cdf0e10cSrcweir
538cdf0e10cSrcweir while( pCnts )
539cdf0e10cSrcweir {
540cdf0e10cSrcweir const SwStartNode *pSttNd = pCnts->GetStartNode();
541cdf0e10cSrcweir if( pSttNd )
542cdf0e10cSrcweir {
543cdf0e10cSrcweir const SwDoc *pDoc = pSttNd->GetDoc();
544cdf0e10cSrcweir sal_uLong nIdx = pSttNd->GetIndex();
545cdf0e10cSrcweir while( !(pDoc->GetNodes()[nIdx])->IsEndNode() )
546cdf0e10cSrcweir {
547cdf0e10cSrcweir SwTxtNode *pTxtNd = (pDoc->GetNodes()[nIdx])->GetTxtNode();
548cdf0e10cSrcweir if( pTxtNd )
549cdf0e10cSrcweir {
550cdf0e10cSrcweir sal_uLong nMinNoAlignCnts = 0;
551cdf0e10cSrcweir sal_uLong nMaxNoAlignCnts = 0;
552cdf0e10cSrcweir sal_uLong nAbsMinNoAlignCnts = 0;
553cdf0e10cSrcweir
554cdf0e10cSrcweir lcl_GetMinMaxSize( nMinNoAlignCnts,
555cdf0e10cSrcweir nMaxNoAlignCnts,
556cdf0e10cSrcweir nAbsMinNoAlignCnts,
557cdf0e10cSrcweir #ifdef FIX41370
558cdf0e10cSrcweir bHR,
559cdf0e10cSrcweir #endif
560cdf0e10cSrcweir pTxtNd, nIdx,
561cdf0e10cSrcweir pCnts->HasNoBreakTag() );
562cdf0e10cSrcweir
563cdf0e10cSrcweir if( nMinNoAlignCnts > nMinNoAlignCell )
564cdf0e10cSrcweir nMinNoAlignCell = nMinNoAlignCnts;
565cdf0e10cSrcweir if( nMaxNoAlignCnts > nMaxNoAlignCell )
566cdf0e10cSrcweir nMaxNoAlignCell = nMaxNoAlignCnts;
567cdf0e10cSrcweir if( nAbsMinNoAlignCnts > nAbsMinNoAlignCell )
568cdf0e10cSrcweir nAbsMinNoAlignCell = nAbsMinNoAlignCnts;
569cdf0e10cSrcweir }
570cdf0e10cSrcweir else
571cdf0e10cSrcweir {
572cdf0e10cSrcweir SwTableNode *pTabNd = (pDoc->GetNodes()[nIdx])->GetTableNode();
573cdf0e10cSrcweir if( pTabNd )
574cdf0e10cSrcweir {
575cdf0e10cSrcweir SwHTMLTableLayout *pChild = pTabNd->GetTable().GetHTMLTableLayout();
576cdf0e10cSrcweir if( pChild )
577cdf0e10cSrcweir {
578cdf0e10cSrcweir pChild->AutoLayoutPass1();
579cdf0e10cSrcweir sal_uLong nMaxTableCnts = pChild->nMax;
580cdf0e10cSrcweir sal_uLong nAbsMinTableCnts = pChild->nMin;
581cdf0e10cSrcweir
582cdf0e10cSrcweir // Eine feste Tabellen-Breite wird als Minimum
583cdf0e10cSrcweir // und Maximum gleichzeitig uebernommen
584cdf0e10cSrcweir if( !pChild->bPrcWidthOption && pChild->nWidthOption )
585cdf0e10cSrcweir {
586cdf0e10cSrcweir sal_uLong nTabWidth = pChild->nWidthOption;
587cdf0e10cSrcweir if( nTabWidth >= nAbsMinTableCnts )
588cdf0e10cSrcweir {
589cdf0e10cSrcweir nMaxTableCnts = nTabWidth;
590cdf0e10cSrcweir nAbsMinTableCnts = nTabWidth;
591cdf0e10cSrcweir }
592cdf0e10cSrcweir else
593cdf0e10cSrcweir {
594cdf0e10cSrcweir nMaxTableCnts = nAbsMinTableCnts;
595cdf0e10cSrcweir }
596cdf0e10cSrcweir }
597cdf0e10cSrcweir
598cdf0e10cSrcweir if( nMaxTableCnts > nMaxTableCell )
599cdf0e10cSrcweir nMaxTableCell = nMaxTableCnts;
600cdf0e10cSrcweir if( nAbsMinTableCnts > nAbsMinTableCell )
601cdf0e10cSrcweir nAbsMinTableCell = nAbsMinTableCnts;
602cdf0e10cSrcweir }
603cdf0e10cSrcweir nIdx = pTabNd->EndOfSectionNode()->GetIndex();
604cdf0e10cSrcweir }
605cdf0e10cSrcweir }
606cdf0e10cSrcweir nIdx++;
607cdf0e10cSrcweir }
608cdf0e10cSrcweir }
609cdf0e10cSrcweir else
610cdf0e10cSrcweir {
611cdf0e10cSrcweir ASSERT( !this, "Sub tables in HTML import?" )
612cdf0e10cSrcweir SwHTMLTableLayout *pChild = pCnts->GetTable();
613cdf0e10cSrcweir pChild->AutoLayoutPass1();
614cdf0e10cSrcweir sal_uLong nMaxTableCnts = pChild->nMax;
615cdf0e10cSrcweir sal_uLong nAbsMinTableCnts = pChild->nMin;
616cdf0e10cSrcweir
617cdf0e10cSrcweir // Eine feste Tabellen-Breite wird als Minimum
618cdf0e10cSrcweir // und Maximum gleichzeitig uebernommen
619cdf0e10cSrcweir if( !pChild->bPrcWidthOption && pChild->nWidthOption )
620cdf0e10cSrcweir {
621cdf0e10cSrcweir sal_uLong nTabWidth = pChild->nWidthOption;
622cdf0e10cSrcweir if( nTabWidth >= nAbsMinTableCnts )
623cdf0e10cSrcweir {
624cdf0e10cSrcweir nMaxTableCnts = nTabWidth;
625cdf0e10cSrcweir nAbsMinTableCnts = nTabWidth;
626cdf0e10cSrcweir }
627cdf0e10cSrcweir else
628cdf0e10cSrcweir {
629cdf0e10cSrcweir nMaxTableCnts = nAbsMinTableCnts;
630cdf0e10cSrcweir }
631cdf0e10cSrcweir }
632cdf0e10cSrcweir
633cdf0e10cSrcweir if( nMaxTableCnts > nMaxTableCell )
634cdf0e10cSrcweir nMaxTableCell = nMaxTableCnts;
635cdf0e10cSrcweir if( nAbsMinTableCnts > nAbsMinTableCell )
636cdf0e10cSrcweir nAbsMinTableCell = nAbsMinTableCnts;
637cdf0e10cSrcweir }
638cdf0e10cSrcweir pCnts->SetPass1Done( nPass1Done );
639cdf0e10cSrcweir pCnts = pCnts->GetNext();
640cdf0e10cSrcweir }
641cdf0e10cSrcweir
642cdf0e10cSrcweir // War frueher hinter AddBorderWidth
643cdf0e10cSrcweir // Wenn die Breite einer Tabelle in der Zelle breiter ist als
644cdf0e10cSrcweir // das, was wir fuer sonstigen Inhalt berechnet haben, mussen
645cdf0e10cSrcweir // wir die Breite der Tabelle nutzen
646cdf0e10cSrcweir if( nMaxTableCell > nMaxNoAlignCell )
647cdf0e10cSrcweir nMaxNoAlignCell = nMaxTableCell;
648cdf0e10cSrcweir if( nAbsMinTableCell > nAbsMinNoAlignCell )
649cdf0e10cSrcweir {
650cdf0e10cSrcweir nAbsMinNoAlignCell = nAbsMinTableCell;
651cdf0e10cSrcweir if( nMinNoAlignCell < nAbsMinNoAlignCell )
652cdf0e10cSrcweir nMinNoAlignCell = nAbsMinNoAlignCell;
653cdf0e10cSrcweir if( nMaxNoAlignCell < nMinNoAlignCell )
654cdf0e10cSrcweir nMaxNoAlignCell = nMinNoAlignCell;
655cdf0e10cSrcweir }
656cdf0e10cSrcweir // War frueher hinter AddBorderWidth
657cdf0e10cSrcweir
658cdf0e10cSrcweir sal_Bool bRelWidth = pCell->IsPrcWidthOption();
659cdf0e10cSrcweir sal_uInt16 nWidth = pCell->GetWidthOption();
660cdf0e10cSrcweir
661cdf0e10cSrcweir // Eine NOWRAP-Option bezieht sich auf Text und auf
662cdf0e10cSrcweir // Tabellen, wird aber bei fester Zellenbreite
663cdf0e10cSrcweir // nicht uebernommen. Stattdessen wirkt die angegebene
664cdf0e10cSrcweir // Zellenbreite wie eine Mindestbreite.
665cdf0e10cSrcweir if( pCell->HasNoWrapOption() )
666cdf0e10cSrcweir {
667cdf0e10cSrcweir if( nWidth==0 || bRelWidth )
668cdf0e10cSrcweir {
669cdf0e10cSrcweir nMinNoAlignCell = nMaxNoAlignCell;
670cdf0e10cSrcweir nAbsMinNoAlignCell = nMaxNoAlignCell;
671cdf0e10cSrcweir }
672cdf0e10cSrcweir else
673cdf0e10cSrcweir {
674cdf0e10cSrcweir if( nWidth>nMinNoAlignCell )
675cdf0e10cSrcweir nMinNoAlignCell = nWidth;
676cdf0e10cSrcweir if( nWidth>nAbsMinNoAlignCell )
677cdf0e10cSrcweir nAbsMinNoAlignCell = nWidth;
678cdf0e10cSrcweir }
679cdf0e10cSrcweir }
680cdf0e10cSrcweir #ifdef FIX41370
681cdf0e10cSrcweir else if( bHR && nWidth>0 && !bRelWidth )
682cdf0e10cSrcweir {
683cdf0e10cSrcweir // Ein kleiner Hack, um einen Bug in Netscape 4.0
684cdf0e10cSrcweir // nachzubilden (siehe #41370#). Wenn eine Zelle eine
685cdf0e10cSrcweir // fixe Breite besitzt und gleichzeitig ein HR, wird
686cdf0e10cSrcweir // sie nie schmaler als die angegebene Breite.
687cdf0e10cSrcweir // (Genaugenomen scheint die Zelle nie schmaler zu werden
688cdf0e10cSrcweir // als die HR-Linie, denn wenn man fuer die Linie eine
689cdf0e10cSrcweir // Breite angibt, die breiter ist als die der Zelle, dann
690cdf0e10cSrcweir // wird die Zelle so breit wie die Linie. Das bekommen wir
691cdf0e10cSrcweir // natuerlich nicht hin.)
692cdf0e10cSrcweir if( nWidth>nMinNoAlignCell )
693cdf0e10cSrcweir nMinNoAlignCell = nWidth;
694cdf0e10cSrcweir if( nWidth>nAbsMinNoAlignCell )
695cdf0e10cSrcweir nAbsMinNoAlignCell = nWidth;
696cdf0e10cSrcweir }
697cdf0e10cSrcweir #endif
698cdf0e10cSrcweir
699cdf0e10cSrcweir // Mindestbreite fuer Inhalt einhalten
700cdf0e10cSrcweir if( nMinNoAlignCell < MINLAY )
701cdf0e10cSrcweir nMinNoAlignCell = MINLAY;
702cdf0e10cSrcweir if( nMaxNoAlignCell < MINLAY )
703cdf0e10cSrcweir nMaxNoAlignCell = MINLAY;
704cdf0e10cSrcweir if( nAbsMinNoAlignCell < MINLAY )
705cdf0e10cSrcweir nAbsMinNoAlignCell = MINLAY;
706cdf0e10cSrcweir
707cdf0e10cSrcweir // Umrandung und Abstand zum Inhalt beachten.
708cdf0e10cSrcweir AddBorderWidth( nMinNoAlignCell, nMaxNoAlignCell,
709cdf0e10cSrcweir nAbsMinNoAlignCell, i, nColSpan );
710cdf0e10cSrcweir
711cdf0e10cSrcweir if( 1==nColSpan )
712cdf0e10cSrcweir {
713cdf0e10cSrcweir // die Werte direkt uebernehmen
714cdf0e10cSrcweir pColumn->MergeMinMaxNoAlign( nMinNoAlignCell,
715cdf0e10cSrcweir nMaxNoAlignCell,
716cdf0e10cSrcweir nAbsMinNoAlignCell );
717cdf0e10cSrcweir
718cdf0e10cSrcweir // bei den WIDTH angaben gewinnt die breiteste
719cdf0e10cSrcweir if( !HasColTags() )
720cdf0e10cSrcweir pColumn->MergeCellWidthOption( nWidth, bRelWidth );
721cdf0e10cSrcweir }
722cdf0e10cSrcweir else
723cdf0e10cSrcweir {
724cdf0e10cSrcweir // die Angaben erst am Ende, und zwar zeilenweise von
725cdf0e10cSrcweir // links nach rechts bearbeiten
726cdf0e10cSrcweir
727cdf0e10cSrcweir // Wann welche Werte wie uebernommen werden ist weiter
728cdf0e10cSrcweir // unten erklaert.
729cdf0e10cSrcweir if( !HasColTags() && nWidth && !bRelWidth )
730cdf0e10cSrcweir {
731cdf0e10cSrcweir sal_uLong nAbsWidth = nWidth, nDummy = 0, nDummy2 = 0;
732cdf0e10cSrcweir AddBorderWidth( nAbsWidth, nDummy, nDummy2,
733cdf0e10cSrcweir i, nColSpan, sal_False );
734cdf0e10cSrcweir
735cdf0e10cSrcweir if( nAbsWidth >= nMinNoAlignCell )
736cdf0e10cSrcweir {
737cdf0e10cSrcweir nMaxNoAlignCell = nAbsWidth;
738cdf0e10cSrcweir if( HasColsOption() )
739cdf0e10cSrcweir nMinNoAlignCell = nAbsWidth;
740cdf0e10cSrcweir }
741cdf0e10cSrcweir else if( nAbsWidth >= nAbsMinNoAlignCell )
742cdf0e10cSrcweir {
743cdf0e10cSrcweir nMaxNoAlignCell = nAbsWidth;
744cdf0e10cSrcweir nMinNoAlignCell = nAbsWidth;
745cdf0e10cSrcweir }
746cdf0e10cSrcweir else
747cdf0e10cSrcweir {
748cdf0e10cSrcweir nMaxNoAlignCell = nAbsMinNoAlignCell;
749cdf0e10cSrcweir nMinNoAlignCell = nAbsMinNoAlignCell;
750cdf0e10cSrcweir }
751cdf0e10cSrcweir }
752cdf0e10cSrcweir else if( HasColsOption() || HasColTags() )
753cdf0e10cSrcweir nMinNoAlignCell = nAbsMinNoAlignCell;
754cdf0e10cSrcweir
755cdf0e10cSrcweir SwHTMLTableLayoutConstraints *pConstr =
756cdf0e10cSrcweir new SwHTMLTableLayoutConstraints( nMinNoAlignCell,
757cdf0e10cSrcweir nMaxNoAlignCell, j, i, nColSpan );
758cdf0e10cSrcweir if( pConstraints )
759cdf0e10cSrcweir pConstraints = pConstraints->InsertNext( pConstr );
760cdf0e10cSrcweir else
761cdf0e10cSrcweir pConstraints = pConstr;
762cdf0e10cSrcweir }
763cdf0e10cSrcweir }
764cdf0e10cSrcweir }
765cdf0e10cSrcweir
766cdf0e10cSrcweir ASSERT( nMinColSpan>0 && nColSkip>0 && nColSkip <= nMinColSpan,
767cdf0e10cSrcweir "Layout Pass 1: Da werden Spalten vergessen!" );
768cdf0e10cSrcweir ASSERT( nMinColSpan!=USHRT_MAX,
769cdf0e10cSrcweir "Layout Pass 1: unnoetiger Schleifendurchlauf oder Bug" );
770cdf0e10cSrcweir
771cdf0e10cSrcweir if( 1==nMinColSpan )
772cdf0e10cSrcweir {
773cdf0e10cSrcweir // es gibt Zellen mit COLSPAN 1 und demnach auch sinnvolle
774cdf0e10cSrcweir // Werte in pColumn
775cdf0e10cSrcweir
776cdf0e10cSrcweir // Werte anhand folgender Tabelle (Netscape 4.0 pv 3) uebernehmen:
777cdf0e10cSrcweir //
778cdf0e10cSrcweir // WIDTH: kein COLS COLS
779cdf0e10cSrcweir //
780cdf0e10cSrcweir // keine min = min min = absmin
781cdf0e10cSrcweir // max = max max = max
782cdf0e10cSrcweir //
783cdf0e10cSrcweir // >= min min = min min = width
784cdf0e10cSrcweir // max = width max = width
785cdf0e10cSrcweir //
786cdf0e10cSrcweir // >= absmin min = wdith(*) min = width
787cdf0e10cSrcweir // max = width max = width
788cdf0e10cSrcweir //
789cdf0e10cSrcweir // < absmin min = absmin min = absmin
790cdf0e10cSrcweir // max = absmin max = absmin
791cdf0e10cSrcweir //
792cdf0e10cSrcweir // (*) Netscape benutzt hier die Mindestbreite ohne einen
793cdf0e10cSrcweir // Umbruch vor der letzten Grafik. Haben wir (noch?) nicht,
794cdf0e10cSrcweir // also belassen wir es bei width.^
795cdf0e10cSrcweir
796cdf0e10cSrcweir if( pColumn->GetWidthOption() && !pColumn->IsRelWidthOption() )
797cdf0e10cSrcweir {
798cdf0e10cSrcweir // absolute Breiten als Minimal- und Maximalbreite
799cdf0e10cSrcweir // uebernehmen.
800cdf0e10cSrcweir sal_uLong nAbsWidth = pColumn->GetWidthOption();
801cdf0e10cSrcweir sal_uLong nDummy = 0, nDummy2 = 0;
802cdf0e10cSrcweir AddBorderWidth( nAbsWidth, nDummy, nDummy2, i, 1, sal_False );
803cdf0e10cSrcweir
804cdf0e10cSrcweir if( nAbsWidth >= pColumn->GetMinNoAlign() )
805cdf0e10cSrcweir {
806cdf0e10cSrcweir pColumn->SetMinMax( HasColsOption() ? nAbsWidth
807cdf0e10cSrcweir : pColumn->GetMinNoAlign(),
808cdf0e10cSrcweir nAbsWidth );
809cdf0e10cSrcweir }
810cdf0e10cSrcweir else if( nAbsWidth >= pColumn->GetAbsMinNoAlign() )
811cdf0e10cSrcweir {
812cdf0e10cSrcweir pColumn->SetMinMax( nAbsWidth, nAbsWidth );
813cdf0e10cSrcweir }
814cdf0e10cSrcweir else
815cdf0e10cSrcweir {
816cdf0e10cSrcweir pColumn->SetMinMax( pColumn->GetAbsMinNoAlign(),
817cdf0e10cSrcweir pColumn->GetAbsMinNoAlign() );
818cdf0e10cSrcweir }
819cdf0e10cSrcweir }
820cdf0e10cSrcweir else
821cdf0e10cSrcweir {
822cdf0e10cSrcweir pColumn->SetMinMax( HasColsOption() ? pColumn->GetAbsMinNoAlign()
823cdf0e10cSrcweir : pColumn->GetMinNoAlign(),
824cdf0e10cSrcweir pColumn->GetMaxNoAlign() );
825cdf0e10cSrcweir }
826cdf0e10cSrcweir }
827cdf0e10cSrcweir else if( USHRT_MAX!=nMinColSpan )
828cdf0e10cSrcweir {
829cdf0e10cSrcweir // kann irgendwas !=0 sein, weil es durch die Constraints
830cdf0e10cSrcweir // angepasst wird.
831cdf0e10cSrcweir pColumn->SetMinMax( MINLAY, MINLAY );
832cdf0e10cSrcweir
833cdf0e10cSrcweir // die naechsten Spalten muessen nicht bearbeitet werden
834cdf0e10cSrcweir i += (nColSkip-1);
835cdf0e10cSrcweir }
836cdf0e10cSrcweir
837cdf0e10cSrcweir nMin += pColumn->GetMin();
838cdf0e10cSrcweir nMax += pColumn->GetMax();
839cdf0e10cSrcweir bFixRelWidths |= pColumn->IsRelWidthOption();
840cdf0e10cSrcweir }
841cdf0e10cSrcweir
842cdf0e10cSrcweir // jetzt noch die Constrains verarbeiten
843cdf0e10cSrcweir SwHTMLTableLayoutConstraints *pConstr = pConstraints;
844cdf0e10cSrcweir while( pConstr )
845cdf0e10cSrcweir {
846cdf0e10cSrcweir // Erstmal muss die Breite analog zu den den Spaltenbreiten
847cdf0e10cSrcweir // aufbereitet werden
848cdf0e10cSrcweir sal_uInt16 nCol = pConstr->GetColumn();
849cdf0e10cSrcweir sal_uInt16 nColSpan = pConstr->GetColSpan();
850cdf0e10cSrcweir sal_uLong nConstrMin = pConstr->GetMinNoAlign();
851cdf0e10cSrcweir sal_uLong nConstrMax = pConstr->GetMaxNoAlign();
852cdf0e10cSrcweir
853cdf0e10cSrcweir // jetzt holen wir uns die bisherige Breite der ueberspannten
854cdf0e10cSrcweir // Spalten
855cdf0e10cSrcweir sal_uLong nColsMin = 0;
856cdf0e10cSrcweir sal_uLong nColsMax = 0;
857cdf0e10cSrcweir for( sal_uInt16 j=nCol; j<nCol+nColSpan; j++ )
858cdf0e10cSrcweir {
859cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( j );
860cdf0e10cSrcweir nColsMin += pColumn->GetMin();
861cdf0e10cSrcweir nColsMax += pColumn->GetMax();
862cdf0e10cSrcweir }
863cdf0e10cSrcweir
864cdf0e10cSrcweir if( nColsMin<nConstrMin )
865cdf0e10cSrcweir {
866cdf0e10cSrcweir // den Minimalwert anteilig auf die Spalten verteilen
867cdf0e10cSrcweir sal_uLong nMinD = nConstrMin-nColsMin;
868cdf0e10cSrcweir
869cdf0e10cSrcweir if( nConstrMin > nColsMax )
870cdf0e10cSrcweir {
871cdf0e10cSrcweir // Anteilig anhand der Mindestbreiten
872cdf0e10cSrcweir sal_uInt16 nEndCol = nCol+nColSpan;
873cdf0e10cSrcweir sal_uLong nDiff = nMinD;
874cdf0e10cSrcweir for( sal_uInt16 ic=nCol; ic<nEndCol; ic++ )
875cdf0e10cSrcweir {
876cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( ic );
877cdf0e10cSrcweir
878cdf0e10cSrcweir sal_uLong nColMin = pColumn->GetMin();
879cdf0e10cSrcweir sal_uLong nColMax = pColumn->GetMax();
880cdf0e10cSrcweir
881cdf0e10cSrcweir nMin -= nColMin;
882cdf0e10cSrcweir sal_uLong nAdd = ic<nEndCol-1 ? (nColMin * nMinD) / nColsMin
883cdf0e10cSrcweir : nDiff;
884cdf0e10cSrcweir nColMin += nAdd;
885cdf0e10cSrcweir nMin += nColMin;
886cdf0e10cSrcweir ASSERT( nDiff >= nAdd, "Ooops: nDiff stimmt nicht mehr" );
887cdf0e10cSrcweir nDiff -= nAdd;
888cdf0e10cSrcweir
889cdf0e10cSrcweir if( nColMax < nColMin )
890cdf0e10cSrcweir {
891cdf0e10cSrcweir nMax -= nColMax;
892cdf0e10cSrcweir nColsMax -= nColMax;
893cdf0e10cSrcweir nColMax = nColMin;
894cdf0e10cSrcweir nMax += nColMax;
895cdf0e10cSrcweir nColsMax += nColMax;
896cdf0e10cSrcweir }
897cdf0e10cSrcweir
898cdf0e10cSrcweir pColumn->SetMinMax( nColMin, nColMax );
899cdf0e10cSrcweir }
900cdf0e10cSrcweir }
901cdf0e10cSrcweir else
902cdf0e10cSrcweir {
903cdf0e10cSrcweir // Anteilig anhand der Differenz zwischen Max und Min
904cdf0e10cSrcweir for( sal_uInt16 ic=nCol; ic<nCol+nColSpan; ic++ )
905cdf0e10cSrcweir {
906cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( ic );
907cdf0e10cSrcweir
908cdf0e10cSrcweir sal_uLong nDiff = pColumn->GetMax()-pColumn->GetMin();
909cdf0e10cSrcweir if( nMinD < nDiff )
910cdf0e10cSrcweir nDiff = nMinD;
911cdf0e10cSrcweir
912cdf0e10cSrcweir pColumn->AddToMin( nDiff );
913cdf0e10cSrcweir
914cdf0e10cSrcweir ASSERT( pColumn->GetMax() >= pColumn->GetMin(),
915cdf0e10cSrcweir "Wieso ist die SPalte auf einmal zu schmal?" )
916cdf0e10cSrcweir
917cdf0e10cSrcweir nMin += nDiff;
918cdf0e10cSrcweir nMinD -= nDiff;
919cdf0e10cSrcweir }
920cdf0e10cSrcweir }
921cdf0e10cSrcweir }
922cdf0e10cSrcweir
923cdf0e10cSrcweir if( !HasColTags() && nColsMax<nConstrMax )
924cdf0e10cSrcweir {
925cdf0e10cSrcweir sal_uLong nMaxD = nConstrMax-nColsMax;
926cdf0e10cSrcweir
927cdf0e10cSrcweir for( sal_uInt16 ic=nCol; ic<nCol+nColSpan; ic++ )
928cdf0e10cSrcweir {
929cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( ic );
930cdf0e10cSrcweir
931cdf0e10cSrcweir nMax -= pColumn->GetMax();
932cdf0e10cSrcweir
933cdf0e10cSrcweir pColumn->AddToMax( (pColumn->GetMax() * nMaxD) / nColsMax );
934cdf0e10cSrcweir
935cdf0e10cSrcweir nMax += pColumn->GetMax();
936cdf0e10cSrcweir }
937cdf0e10cSrcweir }
938cdf0e10cSrcweir
939cdf0e10cSrcweir pConstr = pConstr->GetNext();
940cdf0e10cSrcweir }
941cdf0e10cSrcweir
942cdf0e10cSrcweir
943cdf0e10cSrcweir if( bFixRelWidths )
944cdf0e10cSrcweir {
945cdf0e10cSrcweir if( HasColTags() )
946cdf0e10cSrcweir {
947cdf0e10cSrcweir // Zum Anpassen der relativen Breiten werden im 1. Schritt die
948cdf0e10cSrcweir // Minmalbreiten aller anzupassenden Zellen jeweils mit der
949cdf0e10cSrcweir // relativen Breite einer Spalte multipliziert. Dadurch stimmen
950cdf0e10cSrcweir // dann die Breitenverhaeltnisse der Spalten untereinander.
951cdf0e10cSrcweir // Ausserdem wird der Faktor berechnet, um den die Zelle dadurch
952cdf0e10cSrcweir // breiter gworden ist als die Minmalbreite.
953cdf0e10cSrcweir // Im 2. Schritt werden dann die berechneten Breiten durch diesen
954cdf0e10cSrcweir // Faktor geteilt. Dadurch bleibt die Breite (nimd.) einer Zelle
955cdf0e10cSrcweir // erhalten und dient als Ausgangsbasis fuer die andern Breiten.
956cdf0e10cSrcweir // Es werden auch hier nur die Maximalbreiten beeinflusst!
957cdf0e10cSrcweir
958cdf0e10cSrcweir sal_uLong nAbsMin = 0; // absolte Min-Breite alter Spalten mit
959cdf0e10cSrcweir // relativer Breite
960cdf0e10cSrcweir sal_uLong nRel = 0; // Summe der relativen Breiten aller Spalten
961cdf0e10cSrcweir for( i=0; i<nCols; i++ )
962cdf0e10cSrcweir {
963cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
964cdf0e10cSrcweir if( pColumn->IsRelWidthOption() && pColumn->GetWidthOption() )
965cdf0e10cSrcweir {
966cdf0e10cSrcweir nAbsMin += pColumn->GetMin();
967cdf0e10cSrcweir nRel += pColumn->GetWidthOption();
968cdf0e10cSrcweir }
969cdf0e10cSrcweir }
970cdf0e10cSrcweir
971cdf0e10cSrcweir sal_uLong nQuot = ULONG_MAX;
972cdf0e10cSrcweir for( i=0; i<nCols; i++ )
973cdf0e10cSrcweir {
974cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
975cdf0e10cSrcweir if( pColumn->IsRelWidthOption() )
976cdf0e10cSrcweir {
977cdf0e10cSrcweir nMax -= pColumn->GetMax();
978cdf0e10cSrcweir if( pColumn->GetWidthOption() && pColumn->GetMin() )
979cdf0e10cSrcweir {
980cdf0e10cSrcweir pColumn->SetMax( nAbsMin * pColumn->GetWidthOption() );
981cdf0e10cSrcweir sal_uLong nColQuot = pColumn->GetMax() / pColumn->GetMin();
982cdf0e10cSrcweir if( nColQuot<nQuot )
983cdf0e10cSrcweir nQuot = nColQuot;
984cdf0e10cSrcweir }
985cdf0e10cSrcweir }
986cdf0e10cSrcweir }
987cdf0e10cSrcweir ASSERT( 0==nRel || nQuot!=ULONG_MAX,
988cdf0e10cSrcweir "Wo sind die relativen Spalten geblieben?" );
989cdf0e10cSrcweir for( i=0; i<nCols; i++ )
990cdf0e10cSrcweir {
991cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
992cdf0e10cSrcweir if( pColumn->IsRelWidthOption() )
993cdf0e10cSrcweir {
994cdf0e10cSrcweir if( pColumn->GetWidthOption() )
995cdf0e10cSrcweir pColumn->SetMax( pColumn->GetMax() / nQuot );
996cdf0e10cSrcweir else
997cdf0e10cSrcweir pColumn->SetMax( pColumn->GetMin() );
998cdf0e10cSrcweir ASSERT( pColumn->GetMax() >= pColumn->GetMin(),
999cdf0e10cSrcweir "Maximale Spaltenbreite kleiner als Minimale" );
1000cdf0e10cSrcweir nMax += pColumn->GetMax();
1001cdf0e10cSrcweir }
1002cdf0e10cSrcweir }
1003cdf0e10cSrcweir }
1004cdf0e10cSrcweir else
1005cdf0e10cSrcweir {
1006cdf0e10cSrcweir sal_uInt16 nRel = 0; // Summe der relativen Breiten aller Spalten
1007cdf0e10cSrcweir sal_uInt16 nRelCols = 0; // Anzahl Spalten mit relativer Angabe
1008cdf0e10cSrcweir sal_uLong nRelMax = 0; // Anteil am Maximum dieser Spalten
1009cdf0e10cSrcweir for( i=0; i<nCols; i++ )
1010cdf0e10cSrcweir {
1011cdf0e10cSrcweir ASSERT( nRel<=100, "relative Breite aller Spalten>100%" );
1012cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
1013cdf0e10cSrcweir if( pColumn->IsRelWidthOption() && pColumn->GetWidthOption() )
1014cdf0e10cSrcweir {
1015cdf0e10cSrcweir // Sicherstellen, dass die relativen breiten nicht
1016cdf0e10cSrcweir // ueber 100% landen
1017cdf0e10cSrcweir sal_uInt16 nColWidth = pColumn->GetWidthOption();
1018cdf0e10cSrcweir if( nRel+nColWidth > 100 )
1019cdf0e10cSrcweir {
1020cdf0e10cSrcweir nColWidth = 100 - nRel;
1021cdf0e10cSrcweir pColumn->SetWidthOption( nColWidth, sal_True, sal_False );
1022cdf0e10cSrcweir }
1023cdf0e10cSrcweir nRelMax += pColumn->GetMax();
1024cdf0e10cSrcweir nRel = nRel + nColWidth;
1025cdf0e10cSrcweir nRelCols++;
1026cdf0e10cSrcweir }
1027cdf0e10cSrcweir else if( !pColumn->GetMin() )
1028cdf0e10cSrcweir {
1029cdf0e10cSrcweir // Die Spalte ist leer (wurde also auschliesslich
1030cdf0e10cSrcweir // durch COLSPAN erzeugt) und darf deshalb auch
1031cdf0e10cSrcweir // keine %-Breite zugewiesen bekommen.
1032cdf0e10cSrcweir nRelCols++;
1033cdf0e10cSrcweir }
1034cdf0e10cSrcweir }
1035cdf0e10cSrcweir
1036cdf0e10cSrcweir // Eventuell noch vorhandene Prozente werden auf die Spalten ohne
1037cdf0e10cSrcweir // eine Breiten-Angabe verteilt. Wie in Netscape werden die
1038cdf0e10cSrcweir // verbleibenden Prozente enstprechend der Verhaeltnisse
1039cdf0e10cSrcweir // der Maximalbreiten der in Frage kommenden Spalten
1040cdf0e10cSrcweir // untereinander verteilt.
1041cdf0e10cSrcweir // ??? Wie beruecksichtigen bei den Maximalbreiten auch Spalten
1042cdf0e10cSrcweir // mit fester Breite. Ist das richtig???
1043cdf0e10cSrcweir if( nRel < 100 && nRelCols < nCols )
1044cdf0e10cSrcweir {
1045cdf0e10cSrcweir sal_uInt16 nRelLeft = 100 - nRel;
1046cdf0e10cSrcweir sal_uLong nFixMax = nMax - nRelMax;
1047cdf0e10cSrcweir for( i=0; i<nCols; i++ )
1048cdf0e10cSrcweir {
1049cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
1050cdf0e10cSrcweir if( !pColumn->IsRelWidthOption() &&
1051cdf0e10cSrcweir !pColumn->GetWidthOption() &&
1052cdf0e10cSrcweir pColumn->GetMin() )
1053cdf0e10cSrcweir {
1054cdf0e10cSrcweir // den Rest bekommt die naechste Spalte
1055cdf0e10cSrcweir sal_uInt16 nColWidth =
1056cdf0e10cSrcweir (sal_uInt16)((pColumn->GetMax() * nRelLeft) / nFixMax);
1057cdf0e10cSrcweir pColumn->SetWidthOption( nColWidth, sal_True, sal_False );
1058cdf0e10cSrcweir }
1059cdf0e10cSrcweir }
1060cdf0e10cSrcweir }
1061cdf0e10cSrcweir
1062cdf0e10cSrcweir // nun die Maximalbreiten entsprechend anpassen
1063cdf0e10cSrcweir sal_uLong nQuotMax = ULONG_MAX;
1064cdf0e10cSrcweir sal_uLong nOldMax = nMax;
1065cdf0e10cSrcweir nMax = 0;
1066cdf0e10cSrcweir for( i=0; i<nCols; i++ )
1067cdf0e10cSrcweir {
1068cdf0e10cSrcweir // Spalten mit %-Angaben werden enstprechend angepasst.
1069cdf0e10cSrcweir // Spalten, die
1070cdf0e10cSrcweir // - keine %-Angabe besitzen und in einer Tabelle mit COLS
1071cdf0e10cSrcweir // oder WIDTH vorkommen, oder
1072cdf0e10cSrcweir // - als Breite 0% angegeben haben erhalten die Minimalbreite
1073cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
1074cdf0e10cSrcweir if( pColumn->IsRelWidthOption() && pColumn->GetWidthOption() )
1075cdf0e10cSrcweir {
1076cdf0e10cSrcweir sal_uLong nNewMax;
1077cdf0e10cSrcweir sal_uLong nColQuotMax;
1078cdf0e10cSrcweir if( !nWidthOption )
1079cdf0e10cSrcweir {
1080cdf0e10cSrcweir nNewMax = nOldMax * pColumn->GetWidthOption();
1081cdf0e10cSrcweir nColQuotMax = nNewMax / pColumn->GetMax();
1082cdf0e10cSrcweir }
1083cdf0e10cSrcweir else
1084cdf0e10cSrcweir {
1085cdf0e10cSrcweir nNewMax = nMin * pColumn->GetWidthOption();
1086cdf0e10cSrcweir nColQuotMax = nNewMax / pColumn->GetMin();
1087cdf0e10cSrcweir }
1088cdf0e10cSrcweir pColumn->SetMax( nNewMax );
1089cdf0e10cSrcweir if( nColQuotMax < nQuotMax )
1090cdf0e10cSrcweir nQuotMax = nColQuotMax;
1091cdf0e10cSrcweir }
1092cdf0e10cSrcweir else if( HasColsOption() || nWidthOption ||
1093cdf0e10cSrcweir (pColumn->IsRelWidthOption() &&
1094cdf0e10cSrcweir !pColumn->GetWidthOption()) )
1095cdf0e10cSrcweir pColumn->SetMax( pColumn->GetMin() );
1096cdf0e10cSrcweir }
1097cdf0e10cSrcweir // und durch den Quotienten teilen
1098cdf0e10cSrcweir ASSERT( nQuotMax!=ULONG_MAX, "Wo sind die relativen Spalten geblieben?" );
1099cdf0e10cSrcweir for( i=0; i<nCols; i++ )
1100cdf0e10cSrcweir {
1101cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
1102cdf0e10cSrcweir if( pColumn->IsRelWidthOption() && pColumn->GetWidthOption() )
1103cdf0e10cSrcweir {
1104cdf0e10cSrcweir if( pColumn->GetWidthOption() )
1105cdf0e10cSrcweir {
1106cdf0e10cSrcweir pColumn->SetMax( pColumn->GetMax() / nQuotMax );
1107cdf0e10cSrcweir ASSERT( pColumn->GetMax() >= pColumn->GetMin(),
1108cdf0e10cSrcweir "Minimalbreite ein Spalte Groesser Maximum" );
1109cdf0e10cSrcweir if( pColumn->GetMax() < pColumn->GetMin() )
1110cdf0e10cSrcweir pColumn->SetMax( pColumn->GetMin() );
1111cdf0e10cSrcweir }
1112cdf0e10cSrcweir }
1113cdf0e10cSrcweir nMax += pColumn->GetMax();
1114cdf0e10cSrcweir }
1115cdf0e10cSrcweir }
1116cdf0e10cSrcweir }
1117cdf0e10cSrcweir
1118cdf0e10cSrcweir delete pConstraints;
1119cdf0e10cSrcweir }
1120cdf0e10cSrcweir
1121cdf0e10cSrcweir // nAbsAvail ist der verfuegbare Platz in TWIPS.
1122cdf0e10cSrcweir // nRelAvail ist der auf USHRT_MAX bezogene verfuegbare Platz oder 0
1123cdf0e10cSrcweir // nAbsSpace ist der Anteil von nAbsAvail, der durch der umgebende Zelle
1124cdf0e10cSrcweir // fur die Umrandung und den Abstand zum Inhalt reserviert ist.
AutoLayoutPass2(sal_uInt16 nAbsAvail,sal_uInt16 nRelAvail,sal_uInt16 nAbsLeftSpace,sal_uInt16 nAbsRightSpace,sal_uInt16 nParentInhAbsSpace)1125cdf0e10cSrcweir void SwHTMLTableLayout::AutoLayoutPass2( sal_uInt16 nAbsAvail, sal_uInt16 nRelAvail,
1126cdf0e10cSrcweir sal_uInt16 nAbsLeftSpace,
1127cdf0e10cSrcweir sal_uInt16 nAbsRightSpace,
1128cdf0e10cSrcweir sal_uInt16 nParentInhAbsSpace )
1129cdf0e10cSrcweir {
1130cdf0e10cSrcweir // Erstmal fuehren wie jede Menge Plausibilaets-Test durch
1131cdf0e10cSrcweir
1132cdf0e10cSrcweir // Eine abolute zur Verfuegung stehende Breite muss immer uebergeben
1133cdf0e10cSrcweir // werden.
1134cdf0e10cSrcweir ASSERT( nAbsAvail, "AutoLayout Pass 2: Keine absolute Breite gegeben" );
1135cdf0e10cSrcweir
1136cdf0e10cSrcweir // Eine realtive zur Verfuegung stehende Breite darf nur und muss fuer
1137cdf0e10cSrcweir // Tabellen in Tabellen uebergeben
1138cdf0e10cSrcweir ASSERT( IsTopTable() == (nRelAvail==0),
1139cdf0e10cSrcweir "AutoLayout Pass 2: Rel. Breite bei Tab in Tab oder umgekehrt" );
1140cdf0e10cSrcweir
1141cdf0e10cSrcweir // Die Minimalbreite der Tabelle darf natuerlich nie groesser sein
1142cdf0e10cSrcweir // als das die Maximalbreite.
1143cdf0e10cSrcweir ASSERT( nMin<=nMax, "AutoLayout Pass2: nMin > nMax" );
1144cdf0e10cSrcweir
1145cdf0e10cSrcweir // Die verfuegbare Breite, fuer die die Tabelle berechnet wurde, merken.
1146cdf0e10cSrcweir // (Dies ist ein guter Ort, denn hier kommer wir bei der Erstberechnung
1147cdf0e10cSrcweir // der Tabelle aus dem Parser und bei jedem _Resize-Aufruf vorbei.)
1148cdf0e10cSrcweir nLastResizeAbsAvail = nAbsAvail;
1149cdf0e10cSrcweir
1150cdf0e10cSrcweir // Schritt 1: Der verfuegbar Platz wird an linke/rechte Raender,
1151cdf0e10cSrcweir // vorhandene Filler-Zellen und Abstande angepasst
1152cdf0e10cSrcweir
1153cdf0e10cSrcweir // Abstand zum Inhalt und Unrandung
1154cdf0e10cSrcweir sal_uInt16 nAbsLeftFill = 0, nAbsRightFill = 0;
1155cdf0e10cSrcweir if( !IsTopTable() &&
1156cdf0e10cSrcweir GetMin() + nAbsLeftSpace + nAbsRightSpace <= nAbsAvail )
1157cdf0e10cSrcweir {
1158cdf0e10cSrcweir nAbsLeftFill = nAbsLeftSpace;
1159cdf0e10cSrcweir nAbsRightFill = nAbsRightSpace;
1160cdf0e10cSrcweir }
1161cdf0e10cSrcweir
1162cdf0e10cSrcweir // Linker und rechter Abstand
1163cdf0e10cSrcweir if( nLeftMargin || nRightMargin )
1164cdf0e10cSrcweir {
1165cdf0e10cSrcweir if( IsTopTable() )
1166cdf0e10cSrcweir {
1167cdf0e10cSrcweir // fuer die Top-Table beruecksichtigen wir die Raender immer,
1168cdf0e10cSrcweir // den die Minimalbreite der Tabelle wird hier nie unterschritten
1169cdf0e10cSrcweir nAbsAvail -= (nLeftMargin + nRightMargin);
1170cdf0e10cSrcweir }
1171cdf0e10cSrcweir else if( GetMin() + nLeftMargin + nRightMargin <= nAbsAvail )
1172cdf0e10cSrcweir {
1173cdf0e10cSrcweir // sonst beruecksichtigen wir die Raender nur, wenn auch Platz
1174cdf0e10cSrcweir // fuer sie da ist (nMin ist hier bereits berechnet!)
1175cdf0e10cSrcweir nAbsLeftFill = nAbsLeftFill + nLeftMargin;
1176cdf0e10cSrcweir nAbsRightFill = nAbsRightFill + nRightMargin;
1177cdf0e10cSrcweir }
1178cdf0e10cSrcweir }
1179cdf0e10cSrcweir
1180cdf0e10cSrcweir // Filler-Zellen
1181cdf0e10cSrcweir if( !IsTopTable() )
1182cdf0e10cSrcweir {
1183cdf0e10cSrcweir if( pLeftFillerBox && nAbsLeftFill<MINLAY+nInhLeftBorderWidth )
1184cdf0e10cSrcweir nAbsLeftFill = MINLAY+nInhLeftBorderWidth;
1185cdf0e10cSrcweir if( pRightFillerBox && nAbsRightFill<MINLAY+nInhRightBorderWidth )
1186cdf0e10cSrcweir nAbsRightFill = MINLAY+nInhRightBorderWidth;
1187cdf0e10cSrcweir }
1188cdf0e10cSrcweir
1189cdf0e10cSrcweir // Anpassen des verfuegbaren Platzes.
1190cdf0e10cSrcweir nRelLeftFill = 0;
1191cdf0e10cSrcweir nRelRightFill = 0;
1192cdf0e10cSrcweir if( !IsTopTable() && (nAbsLeftFill>0 || nAbsRightFill) )
1193cdf0e10cSrcweir {
1194cdf0e10cSrcweir sal_uLong nAbsLeftFillL = nAbsLeftFill, nAbsRightFillL = nAbsRightFill;
1195cdf0e10cSrcweir
1196cdf0e10cSrcweir nRelLeftFill = (sal_uInt16)((nAbsLeftFillL * nRelAvail) / nAbsAvail);
1197cdf0e10cSrcweir nRelRightFill = (sal_uInt16)((nAbsRightFillL * nRelAvail) / nAbsAvail);
1198cdf0e10cSrcweir
1199cdf0e10cSrcweir nAbsAvail -= (nAbsLeftFill + nAbsRightFill);
1200cdf0e10cSrcweir if( nRelAvail )
1201cdf0e10cSrcweir nRelAvail -= (nRelLeftFill + nRelRightFill);
1202cdf0e10cSrcweir }
1203cdf0e10cSrcweir
1204cdf0e10cSrcweir
1205cdf0e10cSrcweir // Schritt 2: Die absolute Tabellenbreite wird berechnet.
1206cdf0e10cSrcweir sal_uInt16 nAbsTabWidth = 0;
1207cdf0e10cSrcweir bUseRelWidth = sal_False;
1208cdf0e10cSrcweir if( nWidthOption )
1209cdf0e10cSrcweir {
1210cdf0e10cSrcweir if( bPrcWidthOption )
1211cdf0e10cSrcweir {
1212cdf0e10cSrcweir ASSERT( nWidthOption<=100, "Prozentangabe zu gross" );
1213cdf0e10cSrcweir if( nWidthOption > 100 )
1214cdf0e10cSrcweir nWidthOption = 100;
1215cdf0e10cSrcweir
1216cdf0e10cSrcweir // Die absolute Breite entspricht den angegeben Prozent der
1217cdf0e10cSrcweir // zur Verfuegung stehenden Breite.
1218cdf0e10cSrcweir // Top-Tabellen bekommen nur eine relative Breite, wenn der
1219cdf0e10cSrcweir // verfuegbare Platz *echt groesser* ist als die Minimalbreite.
1220cdf0e10cSrcweir // ACHTUNG: Das "echte groesser" ist noetig, weil der Wechsel
1221cdf0e10cSrcweir // von einer relativen Breite zu einer absoluten Breite durch
1222cdf0e10cSrcweir // Resize sonst zu einer Endlosschleife fuehrt.
1223cdf0e10cSrcweir // Weil bei Tabellen in Rahmen kein Resize aufgerufen wird,
1224cdf0e10cSrcweir // wenn der Rahmen eine nicht-relative Breite besitzt, koennen
1225cdf0e10cSrcweir // wir da solche Spielchen nicht spielen
1226cdf0e10cSrcweir // MIB 19.2.98: Wegen fix #47394# spielen wir solche Spielchen
1227cdf0e10cSrcweir // jetzt doch. Dort war eine Grafik in einer 1%-breiten
1228cdf0e10cSrcweir // Tabelle und hat da natuerlich nicht hineingepasst.
1229cdf0e10cSrcweir nAbsTabWidth = (sal_uInt16)( ((sal_uLong)nAbsAvail * nWidthOption) / 100 );
1230cdf0e10cSrcweir if( IsTopTable() &&
1231cdf0e10cSrcweir ( /*MayBeInFlyFrame() ||*/ (sal_uLong)nAbsTabWidth > nMin ) )
1232cdf0e10cSrcweir {
1233cdf0e10cSrcweir nRelAvail = USHRT_MAX;
1234cdf0e10cSrcweir bUseRelWidth = sal_True;
1235cdf0e10cSrcweir }
1236cdf0e10cSrcweir }
1237cdf0e10cSrcweir else
1238cdf0e10cSrcweir {
1239cdf0e10cSrcweir nAbsTabWidth = nWidthOption;
1240cdf0e10cSrcweir if( nAbsTabWidth > MAX_TABWIDTH )
1241cdf0e10cSrcweir nAbsTabWidth = MAX_TABWIDTH;
1242cdf0e10cSrcweir
1243cdf0e10cSrcweir // Tabellen in Tabellen duerfen niemals breiter werden als der
1244cdf0e10cSrcweir // verfuegbare Platz.
1245cdf0e10cSrcweir if( !IsTopTable() && nAbsTabWidth > nAbsAvail )
1246cdf0e10cSrcweir nAbsTabWidth = nAbsAvail;
1247cdf0e10cSrcweir }
1248cdf0e10cSrcweir }
1249cdf0e10cSrcweir
1250cdf0e10cSrcweir ASSERT( IsTopTable() || nAbsTabWidth<=nAbsAvail,
1251cdf0e10cSrcweir "AutoLayout Pass2: nAbsTabWidth > nAbsAvail fuer Tab in Tab" );
1252cdf0e10cSrcweir ASSERT( !nRelAvail || nAbsTabWidth<=nAbsAvail,
1253cdf0e10cSrcweir "AutoLayout Pass2: nAbsTabWidth > nAbsAvail fuer relative Breite" );
1254cdf0e10cSrcweir
1255cdf0e10cSrcweir // Catch fuer die beiden Asserts von oben (man weiss ja nie!)
1256cdf0e10cSrcweir if( (!IsTopTable() || nRelAvail>0) && nAbsTabWidth>nAbsAvail )
1257cdf0e10cSrcweir nAbsTabWidth = nAbsAvail;
1258cdf0e10cSrcweir
1259cdf0e10cSrcweir
1260cdf0e10cSrcweir // Schritt 3: Bestimmen der Spaltenbreiten und ggf. auch der
1261cdf0e10cSrcweir // absoluten und relativen Tabellenbreiten.
1262cdf0e10cSrcweir if( (!IsTopTable() && nMin > (sal_uLong)nAbsAvail) ||
1263cdf0e10cSrcweir nMin > MAX_TABWIDTH )
1264cdf0e10cSrcweir {
1265cdf0e10cSrcweir // Wenn
1266cdf0e10cSrcweir // - das Minumum einer inneren Tabelle groesser ist als der
1267cdf0e10cSrcweir // verfuegbare Platz, oder
1268cdf0e10cSrcweir // - das Minumum einer Top-Table groesser ist als USHRT_MAX
1269cdf0e10cSrcweir // muss die Tabelle an den verfuegbaren Platz bzw. USHRT_MAX
1270cdf0e10cSrcweir // abgepasst werden. Dabei bleiben die Verhaeltnisse der Breiten
1271cdf0e10cSrcweir // untereinander erhalten.
1272cdf0e10cSrcweir
1273cdf0e10cSrcweir nAbsTabWidth = IsTopTable() ? MAX_TABWIDTH : nAbsAvail;
1274cdf0e10cSrcweir nRelTabWidth = (nRelAvail ? nRelAvail : nAbsTabWidth );
1275cdf0e10cSrcweir
1276cdf0e10cSrcweir // First of all, we check wether we can fit the layout constrains,
1277cdf0e10cSrcweir // that are: Every cell's width excluding the borders must be at least
1278cdf0e10cSrcweir // MINLAY:
1279cdf0e10cSrcweir
1280cdf0e10cSrcweir sal_uLong nRealMin = 0;
1281cdf0e10cSrcweir for( sal_uInt16 i=0; i<nCols; i++ )
1282cdf0e10cSrcweir {
1283cdf0e10cSrcweir sal_uLong nRealColMin = MINLAY, nDummy1, nDummy2;
1284cdf0e10cSrcweir AddBorderWidth( nRealColMin, nDummy1, nDummy2, i, 1 );
1285cdf0e10cSrcweir nRealMin += nRealColMin;
1286cdf0e10cSrcweir }
1287cdf0e10cSrcweir if( (nRealMin >= nAbsTabWidth) || (nRealMin >= nMin) )
1288cdf0e10cSrcweir {
1289cdf0e10cSrcweir // "Nichts geht mehr". We cannot get the minimum column widths
1290cdf0e10cSrcweir // the layout wants to have.
1291cdf0e10cSrcweir
1292cdf0e10cSrcweir sal_uInt16 nAbs = 0, nRel = 0;
1293cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn;
1294cdf0e10cSrcweir for( sal_uInt16 i=0; i<nCols-1; i++ )
1295cdf0e10cSrcweir {
1296cdf0e10cSrcweir pColumn = GetColumn( i );
1297cdf0e10cSrcweir sal_uLong nColMin = pColumn->GetMin();
1298cdf0e10cSrcweir if( nColMin <= USHRT_MAX )
1299cdf0e10cSrcweir {
1300cdf0e10cSrcweir pColumn->SetAbsColWidth(
1301cdf0e10cSrcweir (sal_uInt16)((nColMin * nAbsTabWidth) / nMin) );
1302cdf0e10cSrcweir pColumn->SetRelColWidth(
1303cdf0e10cSrcweir (sal_uInt16)((nColMin * nRelTabWidth) / nMin) );
1304cdf0e10cSrcweir }
1305cdf0e10cSrcweir else
1306cdf0e10cSrcweir {
1307cdf0e10cSrcweir double nColMinD = nColMin;
1308cdf0e10cSrcweir pColumn->SetAbsColWidth(
1309cdf0e10cSrcweir (sal_uInt16)((nColMinD * nAbsTabWidth) / nMin) );
1310cdf0e10cSrcweir pColumn->SetRelColWidth(
1311cdf0e10cSrcweir (sal_uInt16)((nColMinD * nRelTabWidth) / nMin) );
1312cdf0e10cSrcweir }
1313cdf0e10cSrcweir
1314cdf0e10cSrcweir nAbs = nAbs + (sal_uInt16)pColumn->GetAbsColWidth();
1315cdf0e10cSrcweir nRel = nRel + (sal_uInt16)pColumn->GetRelColWidth();
1316cdf0e10cSrcweir }
1317cdf0e10cSrcweir pColumn = GetColumn( nCols-1 );
1318cdf0e10cSrcweir pColumn->SetAbsColWidth( nAbsTabWidth - nAbs );
1319cdf0e10cSrcweir pColumn->SetRelColWidth( nRelTabWidth - nRel );
1320cdf0e10cSrcweir }
1321cdf0e10cSrcweir else
1322cdf0e10cSrcweir {
1323cdf0e10cSrcweir sal_uLong nDistAbs = nAbsTabWidth - nRealMin;
1324cdf0e10cSrcweir sal_uLong nDistRel = nRelTabWidth - nRealMin;
1325cdf0e10cSrcweir sal_uLong nDistMin = nMin - nRealMin;
1326cdf0e10cSrcweir sal_uInt16 nAbs = 0, nRel = 0;
1327cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn;
1328cdf0e10cSrcweir for( sal_uInt16 i=0; i<nCols-1; i++ )
1329cdf0e10cSrcweir {
1330cdf0e10cSrcweir pColumn = GetColumn( i );
1331cdf0e10cSrcweir sal_uLong nColMin = pColumn->GetMin();
1332cdf0e10cSrcweir sal_uLong nRealColMin = MINLAY, nDummy1, nDummy2;
1333cdf0e10cSrcweir AddBorderWidth( nRealColMin, nDummy1, nDummy2, i, 1 );
1334cdf0e10cSrcweir
1335cdf0e10cSrcweir if( nColMin <= USHRT_MAX )
1336cdf0e10cSrcweir {
1337cdf0e10cSrcweir pColumn->SetAbsColWidth(
1338cdf0e10cSrcweir (sal_uInt16)((((nColMin-nRealColMin) * nDistAbs) / nDistMin) + nRealColMin) );
1339cdf0e10cSrcweir pColumn->SetRelColWidth(
1340cdf0e10cSrcweir (sal_uInt16)((((nColMin-nRealColMin) * nDistRel) / nDistMin) + nRealColMin) );
1341cdf0e10cSrcweir }
1342cdf0e10cSrcweir else
1343cdf0e10cSrcweir {
1344cdf0e10cSrcweir double nColMinD = nColMin;
1345cdf0e10cSrcweir pColumn->SetAbsColWidth(
1346cdf0e10cSrcweir (sal_uInt16)((((nColMinD-nRealColMin) * nDistAbs) / nDistMin) + nRealColMin) );
1347cdf0e10cSrcweir pColumn->SetRelColWidth(
1348cdf0e10cSrcweir (sal_uInt16)((((nColMinD-nRealColMin) * nDistRel) / nDistMin) + nRealColMin) );
1349cdf0e10cSrcweir }
1350cdf0e10cSrcweir
1351cdf0e10cSrcweir nAbs = nAbs + (sal_uInt16)pColumn->GetAbsColWidth();
1352cdf0e10cSrcweir nRel = nRel + (sal_uInt16)pColumn->GetRelColWidth();
1353cdf0e10cSrcweir }
1354cdf0e10cSrcweir pColumn = GetColumn( nCols-1 );
1355cdf0e10cSrcweir pColumn->SetAbsColWidth( nAbsTabWidth - nAbs );
1356cdf0e10cSrcweir pColumn->SetRelColWidth( nRelTabWidth - nRel );
1357cdf0e10cSrcweir }
1358cdf0e10cSrcweir }
1359cdf0e10cSrcweir else if( nMax <= (sal_uLong)(nAbsTabWidth ? nAbsTabWidth : nAbsAvail) )
1360cdf0e10cSrcweir {
1361cdf0e10cSrcweir // Wenn
1362cdf0e10cSrcweir // - die Tabelle eine fixe Breite besitzt und das Maximum der
1363cdf0e10cSrcweir // Tabelle kleiner ist, oder
1364cdf0e10cSrcweir // - das Maximum kleiner ist als der verfuegbare Platz
1365cdf0e10cSrcweir // kann das Maximum direkt uebernommen werden bzw. die Tabelle nur
1366cdf0e10cSrcweir // unter Beruecksichtigung des Maxumums an die fixe Breite
1367cdf0e10cSrcweir // angepasst werden.
1368cdf0e10cSrcweir
1369cdf0e10cSrcweir // Keine fixe Breite, dann das Maximum nehmen.
1370cdf0e10cSrcweir if( !nAbsTabWidth )
1371cdf0e10cSrcweir nAbsTabWidth = (sal_uInt16)nMax;
1372cdf0e10cSrcweir
1373cdf0e10cSrcweir // Eine Top-Table darf auch beriter werden als der verfuegbare Platz.
1374cdf0e10cSrcweir if( nAbsTabWidth > nAbsAvail )
1375cdf0e10cSrcweir {
1376cdf0e10cSrcweir ASSERT( IsTopTable(),
1377cdf0e10cSrcweir "Tabelle in Tabelle soll breiter werden als umgebende Zelle" );
1378cdf0e10cSrcweir nAbsAvail = nAbsTabWidth;
1379cdf0e10cSrcweir }
1380cdf0e10cSrcweir
1381cdf0e10cSrcweir // Nur den Anteil der relativen Breite verwenden, der auch fuer
1382cdf0e10cSrcweir // die absolute Breite verwendet wuerde.
1383cdf0e10cSrcweir sal_uLong nAbsTabWidthL = nAbsTabWidth;
1384cdf0e10cSrcweir nRelTabWidth =
1385cdf0e10cSrcweir ( nRelAvail ? (sal_uInt16)((nAbsTabWidthL * nRelAvail) / nAbsAvail)
1386cdf0e10cSrcweir : nAbsTabWidth );
1387cdf0e10cSrcweir
1388cdf0e10cSrcweir // Gibt es Spalten mit und Spalten ohne %-Angabe?
1389cdf0e10cSrcweir sal_uLong nFixMax = nMax;
1390cdf0e10cSrcweir for( sal_uInt16 i=0; i<nCols; i++ )
1391cdf0e10cSrcweir {
1392cdf0e10cSrcweir const SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
1393cdf0e10cSrcweir if( pColumn->IsRelWidthOption() && pColumn->GetWidthOption()>0 )
1394cdf0e10cSrcweir nFixMax -= pColumn->GetMax();
1395cdf0e10cSrcweir }
1396cdf0e10cSrcweir
1397cdf0e10cSrcweir if( nFixMax > 0 && nFixMax < nMax )
1398cdf0e10cSrcweir {
1399cdf0e10cSrcweir // ja, dann den zu verteilenden Platz nur auf die Spalten
1400cdf0e10cSrcweir // mit %-Angabe verteilen.
1401cdf0e10cSrcweir
1402cdf0e10cSrcweir // In diesem (und nur in diesem) Fall gibt es Spalten,
1403cdf0e10cSrcweir // die ihre Maximalbreite genau einhalten, also weder
1404cdf0e10cSrcweir // schmaler noch breiter werden. Beim zurueckrechnen der
1405cdf0e10cSrcweir // absoluten Breite aus der relativen Breite kann es
1406cdf0e10cSrcweir // zu Rundungsfehlern kommen (bug #45598#). Um die auszugeleichen
1407cdf0e10cSrcweir // werden zuerst die fixen Breiten entsprechend korrigiert
1408cdf0e10cSrcweir // eingestellt und erst danach die relativen.
1409cdf0e10cSrcweir
1410cdf0e10cSrcweir sal_uInt16 nAbs = 0, nRel = 0;
1411cdf0e10cSrcweir sal_uInt16 nFixedCols = 0;
1412cdf0e10cSrcweir sal_uInt16 i;
1413cdf0e10cSrcweir
1414cdf0e10cSrcweir for( i = 0; i < nCols; i++ )
1415cdf0e10cSrcweir {
1416cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
1417cdf0e10cSrcweir if( !pColumn->IsRelWidthOption() || !pColumn->GetWidthOption() )
1418cdf0e10cSrcweir {
1419cdf0e10cSrcweir // Die Spalte behaelt ihre Breite bei.
1420cdf0e10cSrcweir nFixedCols++;
1421cdf0e10cSrcweir sal_uLong nColMax = pColumn->GetMax();
1422cdf0e10cSrcweir pColumn->SetAbsColWidth( (sal_uInt16)nColMax );
1423cdf0e10cSrcweir
1424cdf0e10cSrcweir sal_uLong nRelColWidth =
1425cdf0e10cSrcweir (nColMax * nRelTabWidth) / nAbsTabWidth;
1426cdf0e10cSrcweir sal_uLong nChkWidth =
1427cdf0e10cSrcweir (nRelColWidth * nAbsTabWidth) / nRelTabWidth;
1428cdf0e10cSrcweir if( nChkWidth < nColMax )
1429cdf0e10cSrcweir nRelColWidth++;
1430cdf0e10cSrcweir else if( nChkWidth > nColMax )
1431cdf0e10cSrcweir nRelColWidth--;
1432cdf0e10cSrcweir pColumn->SetRelColWidth( (sal_uInt16)nRelColWidth );
1433cdf0e10cSrcweir
1434cdf0e10cSrcweir nAbs = nAbs + (sal_uInt16)nColMax;
1435cdf0e10cSrcweir nRel = nRel + (sal_uInt16)nRelColWidth;
1436cdf0e10cSrcweir }
1437cdf0e10cSrcweir }
1438cdf0e10cSrcweir
1439cdf0e10cSrcweir // Zu verteilende Anteile des Maximums und der relativen und
1440cdf0e10cSrcweir // absoluten Breiten. nFixMax entspricht an dieser Stelle
1441cdf0e10cSrcweir // nAbs, so dass man gleich nFixMax haette nehmen koennen.
1442cdf0e10cSrcweir // Der Code ist so aber verstaendlicher.
1443cdf0e10cSrcweir ASSERT( nFixMax == nAbs, "Zwei Schleifen, zwei Summen?" )
1444cdf0e10cSrcweir sal_uLong nDistMax = nMax - nFixMax;
1445cdf0e10cSrcweir sal_uInt16 nDistAbsTabWidth = nAbsTabWidth - nAbs;
1446cdf0e10cSrcweir sal_uInt16 nDistRelTabWidth = nRelTabWidth - nRel;
1447cdf0e10cSrcweir
1448cdf0e10cSrcweir for( i=0; i<nCols; i++ )
1449cdf0e10cSrcweir {
1450cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( i );
1451cdf0e10cSrcweir if( pColumn->IsRelWidthOption() && pColumn->GetWidthOption() > 0 )
1452cdf0e10cSrcweir {
1453cdf0e10cSrcweir // Die Spalte wird anteilig breiter.
1454cdf0e10cSrcweir nFixedCols++;
1455cdf0e10cSrcweir if( nFixedCols == nCols )
1456cdf0e10cSrcweir {
1457cdf0e10cSrcweir pColumn->SetAbsColWidth( nAbsTabWidth-nAbs );
1458cdf0e10cSrcweir pColumn->SetRelColWidth( nRelTabWidth-nRel );
1459cdf0e10cSrcweir }
1460cdf0e10cSrcweir else
1461cdf0e10cSrcweir {
1462cdf0e10cSrcweir sal_uLong nColMax = pColumn->GetMax();
1463cdf0e10cSrcweir pColumn->SetAbsColWidth(
1464cdf0e10cSrcweir (sal_uInt16)((nColMax * nDistAbsTabWidth) / nDistMax) );
1465cdf0e10cSrcweir pColumn->SetRelColWidth(
1466cdf0e10cSrcweir (sal_uInt16)((nColMax * nDistRelTabWidth) / nDistMax) );
1467cdf0e10cSrcweir }
1468cdf0e10cSrcweir nAbs = nAbs + pColumn->GetAbsColWidth();
1469cdf0e10cSrcweir nRel = nRel + pColumn->GetRelColWidth();
1470cdf0e10cSrcweir }
1471cdf0e10cSrcweir }
1472cdf0e10cSrcweir ASSERT( nCols==nFixedCols, "Spalte vergessen!" );
1473cdf0e10cSrcweir }
1474cdf0e10cSrcweir else
1475cdf0e10cSrcweir {
1476cdf0e10cSrcweir // nein, dann den zu verteilenden Platz auf alle Spalten
1477cdf0e10cSrcweir // gleichmaessig vertilen.
1478cdf0e10cSrcweir for( sal_uInt16 i=0; i<nCols; i++ )
1479cdf0e10cSrcweir {
1480cdf0e10cSrcweir sal_uLong nColMax = GetColumn( i )->GetMax();
1481cdf0e10cSrcweir GetColumn( i )->SetAbsColWidth(
1482cdf0e10cSrcweir (sal_uInt16)((nColMax * nAbsTabWidth) / nMax) );
1483cdf0e10cSrcweir GetColumn( i )->SetRelColWidth(
1484cdf0e10cSrcweir (sal_uInt16)((nColMax * nRelTabWidth) / nMax) );
1485cdf0e10cSrcweir }
1486cdf0e10cSrcweir }
1487cdf0e10cSrcweir }
1488cdf0e10cSrcweir else
1489cdf0e10cSrcweir {
1490cdf0e10cSrcweir // den ueber die Minimalbreite herausgehenden Platz entsprechend
1491cdf0e10cSrcweir // den einzelnen Spalten anteilig zuschlagen
1492cdf0e10cSrcweir if( !nAbsTabWidth )
1493cdf0e10cSrcweir nAbsTabWidth = nAbsAvail;
1494cdf0e10cSrcweir if( nAbsTabWidth < nMin )
1495cdf0e10cSrcweir nAbsTabWidth = (sal_uInt16)nMin;
1496cdf0e10cSrcweir
1497cdf0e10cSrcweir if( nAbsTabWidth > nAbsAvail )
1498cdf0e10cSrcweir {
1499cdf0e10cSrcweir ASSERT( IsTopTable(),
1500cdf0e10cSrcweir "Tabelle in Tabelle soll breiter werden als Platz da ist" );
1501cdf0e10cSrcweir nAbsAvail = nAbsTabWidth;
1502cdf0e10cSrcweir }
1503cdf0e10cSrcweir
1504cdf0e10cSrcweir sal_uLong nAbsTabWidthL = nAbsTabWidth;
1505cdf0e10cSrcweir nRelTabWidth =
1506cdf0e10cSrcweir ( nRelAvail ? (sal_uInt16)((nAbsTabWidthL * nRelAvail) / nAbsAvail)
1507cdf0e10cSrcweir : nAbsTabWidth );
1508cdf0e10cSrcweir double nW = nAbsTabWidth - nMin;
1509cdf0e10cSrcweir double nD = (nMax==nMin ? 1 : nMax-nMin);
1510cdf0e10cSrcweir sal_uInt16 nAbs = 0, nRel = 0;
1511cdf0e10cSrcweir for( sal_uInt16 i=0; i<nCols-1; i++ )
1512cdf0e10cSrcweir {
1513cdf0e10cSrcweir double nd = GetColumn( i )->GetMax() - GetColumn( i )->GetMin();
1514cdf0e10cSrcweir sal_uLong nAbsColWidth = GetColumn( i )->GetMin() + (sal_uLong)((nd*nW)/nD);
1515cdf0e10cSrcweir sal_uLong nRelColWidth = nRelAvail
1516cdf0e10cSrcweir ? (nAbsColWidth * nRelTabWidth) / nAbsTabWidth
1517cdf0e10cSrcweir : nAbsColWidth;
1518cdf0e10cSrcweir
1519cdf0e10cSrcweir GetColumn( i )->SetAbsColWidth( (sal_uInt16)nAbsColWidth );
1520cdf0e10cSrcweir GetColumn( i )->SetRelColWidth( (sal_uInt16)nRelColWidth );
1521cdf0e10cSrcweir nAbs = nAbs + (sal_uInt16)nAbsColWidth;
1522cdf0e10cSrcweir nRel = nRel + (sal_uInt16)nRelColWidth;
1523cdf0e10cSrcweir }
1524cdf0e10cSrcweir GetColumn( nCols-1 )->SetAbsColWidth( nAbsTabWidth - nAbs );
1525cdf0e10cSrcweir GetColumn( nCols-1 )->SetRelColWidth( nRelTabWidth - nRel );
1526cdf0e10cSrcweir
1527cdf0e10cSrcweir }
1528cdf0e10cSrcweir
1529cdf0e10cSrcweir // Schritt 4: Fuer Tabellen in Tabellen kann es links und/oder rechts
1530cdf0e10cSrcweir // noch Ausgleichzellen geben. Deren Breite wird jetzt berechnet.
1531cdf0e10cSrcweir nInhAbsLeftSpace = 0;
1532cdf0e10cSrcweir nInhAbsRightSpace = 0;
1533cdf0e10cSrcweir if( !IsTopTable() && (nRelLeftFill>0 || nRelRightFill>0 ||
1534cdf0e10cSrcweir nAbsTabWidth<nAbsAvail) )
1535cdf0e10cSrcweir {
1536cdf0e10cSrcweir // Die Breite von zusaetzlichen Zellen zur Ausrichtung der
1537cdf0e10cSrcweir // inneren Tabelle bestimmen
1538cdf0e10cSrcweir sal_uInt16 nAbsDist = (sal_uInt16)(nAbsAvail-nAbsTabWidth);
1539cdf0e10cSrcweir sal_uInt16 nRelDist = (sal_uInt16)(nRelAvail-nRelTabWidth);
1540cdf0e10cSrcweir sal_uInt16 nParentInhAbsLeftSpace = 0, nParentInhAbsRightSpace = 0;
1541cdf0e10cSrcweir
1542cdf0e10cSrcweir // Groesse und Position der zusaetzlichen Zellen bestimmen
1543cdf0e10cSrcweir switch( eTableAdjust )
1544cdf0e10cSrcweir {
1545cdf0e10cSrcweir case SVX_ADJUST_RIGHT:
1546cdf0e10cSrcweir nAbsLeftFill = nAbsLeftFill + nAbsDist;
1547cdf0e10cSrcweir nRelLeftFill = nRelLeftFill + nRelDist;
1548cdf0e10cSrcweir nParentInhAbsLeftSpace = nParentInhAbsSpace;
1549cdf0e10cSrcweir break;
1550cdf0e10cSrcweir case SVX_ADJUST_CENTER:
1551cdf0e10cSrcweir {
1552cdf0e10cSrcweir sal_uInt16 nAbsLeftDist = nAbsDist / 2;
1553cdf0e10cSrcweir nAbsLeftFill = nAbsLeftFill + nAbsLeftDist;
1554cdf0e10cSrcweir nAbsRightFill += nAbsDist - nAbsLeftDist;
1555cdf0e10cSrcweir sal_uInt16 nRelLeftDist = nRelDist / 2;
1556cdf0e10cSrcweir nRelLeftFill = nRelLeftFill + nRelLeftDist;
1557cdf0e10cSrcweir nRelRightFill += nRelDist - nRelLeftDist;
1558cdf0e10cSrcweir nParentInhAbsLeftSpace = nParentInhAbsSpace / 2;
1559cdf0e10cSrcweir nParentInhAbsRightSpace = nParentInhAbsSpace -
1560cdf0e10cSrcweir nParentInhAbsLeftSpace;
1561cdf0e10cSrcweir }
1562cdf0e10cSrcweir break;
1563cdf0e10cSrcweir case SVX_ADJUST_LEFT:
1564cdf0e10cSrcweir default:
1565cdf0e10cSrcweir nAbsRightFill = nAbsRightFill + nAbsDist;
1566cdf0e10cSrcweir nRelRightFill = nRelRightFill + nRelDist;
1567cdf0e10cSrcweir nParentInhAbsRightSpace = nParentInhAbsSpace;
1568cdf0e10cSrcweir break;
1569cdf0e10cSrcweir }
1570cdf0e10cSrcweir
1571cdf0e10cSrcweir ASSERT( !pLeftFillerBox || nRelLeftFill>0,
1572cdf0e10cSrcweir "Fuer linke Filler-Box ist keine Breite da!" );
1573cdf0e10cSrcweir ASSERT( !pRightFillerBox || nRelRightFill>0,
1574cdf0e10cSrcweir "Fuer rechte Filler-Box ist keine Breite da!" );
1575cdf0e10cSrcweir
1576cdf0e10cSrcweir // Filler-Breiten werden auf die ausseren Spalten geschlagen, wenn
1577cdf0e10cSrcweir // es nach dem ersten Durchlauf keine Boxen fuer sie gibt (nWidth>0)
1578cdf0e10cSrcweir // oder ihre Breite zu klein wuerde oder wenn es COL-Tags gibt und
1579cdf0e10cSrcweir // die Filler-Breite der Umrandung-Breite entspricht (dann haben wir
1580cdf0e10cSrcweir // die Tabelle wahrscheinlich selbst exportiert)
1581cdf0e10cSrcweir if( nRelLeftFill && !pLeftFillerBox &&
1582cdf0e10cSrcweir ( nWidthSet>0 || nAbsLeftFill<MINLAY+nInhLeftBorderWidth ||
1583cdf0e10cSrcweir (HasColTags() && nAbsLeftFill < nAbsLeftSpace+nParentInhAbsLeftSpace+20) ) )
1584cdf0e10cSrcweir // (nAbsLeftFill<MINLAY || nAbsLeftFill<=nAbsLeftSpace) )
1585cdf0e10cSrcweir {
1586cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( 0 );
1587cdf0e10cSrcweir pColumn->SetAbsColWidth( pColumn->GetAbsColWidth()+nAbsLeftFill );
1588cdf0e10cSrcweir pColumn->SetRelColWidth( pColumn->GetRelColWidth()+nRelLeftFill );
1589cdf0e10cSrcweir nRelLeftFill = 0;
1590cdf0e10cSrcweir nInhAbsLeftSpace = nAbsLeftSpace + nParentInhAbsLeftSpace;
1591cdf0e10cSrcweir }
1592cdf0e10cSrcweir if( nRelRightFill && !pRightFillerBox &&
1593cdf0e10cSrcweir ( nWidthSet>0 || nAbsRightFill<MINLAY+nInhRightBorderWidth ||
1594cdf0e10cSrcweir (HasColTags() && nAbsRightFill < nAbsRightSpace+nParentInhAbsRightSpace+20) ) )
1595cdf0e10cSrcweir // (nAbsRightFill<MINLAY || nAbsRightFill<=nAbsRightSpace) )
1596cdf0e10cSrcweir {
1597cdf0e10cSrcweir SwHTMLTableLayoutColumn *pColumn = GetColumn( nCols-1 );
1598cdf0e10cSrcweir pColumn->SetAbsColWidth( pColumn->GetAbsColWidth()+nAbsRightFill );
1599cdf0e10cSrcweir pColumn->SetRelColWidth( pColumn->GetRelColWidth()+nRelRightFill );
1600cdf0e10cSrcweir nRelRightFill = 0;
1601cdf0e10cSrcweir nInhAbsRightSpace = nAbsRightSpace + nParentInhAbsRightSpace;
1602cdf0e10cSrcweir }
1603cdf0e10cSrcweir }
1604cdf0e10cSrcweir }
1605cdf0e10cSrcweir
1606cdf0e10cSrcweir static sal_Bool lcl_ResizeLine( const SwTableLine*& rpLine, void* pPara );
1607cdf0e10cSrcweir
lcl_ResizeBox(const SwTableBox * & rpBox,void * pPara)1608cdf0e10cSrcweir static sal_Bool lcl_ResizeBox( const SwTableBox*& rpBox, void* pPara )
1609cdf0e10cSrcweir {
1610cdf0e10cSrcweir sal_uInt16 *pWidth = (sal_uInt16 *)pPara;
1611cdf0e10cSrcweir
1612cdf0e10cSrcweir if( !rpBox->GetSttNd() )
1613cdf0e10cSrcweir {
1614cdf0e10cSrcweir sal_uInt16 nWidth = 0;
1615cdf0e10cSrcweir ((SwTableBox *)rpBox)->GetTabLines().ForEach( &lcl_ResizeLine, &nWidth );
1616cdf0e10cSrcweir rpBox->GetFrmFmt()->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nWidth, 0 ));
1617cdf0e10cSrcweir *pWidth = *pWidth + nWidth;
1618cdf0e10cSrcweir }
1619cdf0e10cSrcweir else
1620cdf0e10cSrcweir {
1621cdf0e10cSrcweir *pWidth = *pWidth + (sal_uInt16)rpBox->GetFrmFmt()->GetFrmSize().GetSize().Width();
1622cdf0e10cSrcweir }
1623cdf0e10cSrcweir
1624cdf0e10cSrcweir return sal_True;
1625cdf0e10cSrcweir }
1626cdf0e10cSrcweir
lcl_ResizeLine(const SwTableLine * & rpLine,void * pPara)1627cdf0e10cSrcweir static sal_Bool lcl_ResizeLine( const SwTableLine*& rpLine, void* pPara )
1628cdf0e10cSrcweir {
1629cdf0e10cSrcweir sal_uInt16 *pWidth = (sal_uInt16 *)pPara;
1630cdf0e10cSrcweir #ifdef DBG_UTIL
1631cdf0e10cSrcweir sal_uInt16 nOldWidth = *pWidth;
1632cdf0e10cSrcweir #endif
1633cdf0e10cSrcweir *pWidth = 0;
1634cdf0e10cSrcweir ((SwTableLine *)rpLine)->GetTabBoxes().ForEach( &lcl_ResizeBox, pWidth );
1635cdf0e10cSrcweir
1636cdf0e10cSrcweir #ifdef DBG_UTIL
1637cdf0e10cSrcweir ASSERT( !nOldWidth || Abs(*pWidth-nOldWidth) < COLFUZZY,
1638cdf0e10cSrcweir "Zeilen einer Box sind unterschiedlich lang" );
1639cdf0e10cSrcweir #endif
1640cdf0e10cSrcweir
1641cdf0e10cSrcweir return sal_True;
1642cdf0e10cSrcweir }
1643cdf0e10cSrcweir
SetWidths(sal_Bool bCallPass2,sal_uInt16 nAbsAvail,sal_uInt16 nRelAvail,sal_uInt16 nAbsLeftSpace,sal_uInt16 nAbsRightSpace,sal_uInt16 nParentInhAbsSpace)1644cdf0e10cSrcweir void SwHTMLTableLayout::SetWidths( sal_Bool bCallPass2, sal_uInt16 nAbsAvail,
1645cdf0e10cSrcweir sal_uInt16 nRelAvail, sal_uInt16 nAbsLeftSpace,
1646cdf0e10cSrcweir sal_uInt16 nAbsRightSpace,
1647cdf0e10cSrcweir sal_uInt16 nParentInhAbsSpace )
1648cdf0e10cSrcweir {
1649cdf0e10cSrcweir // SetWidth muss am Ende einmal mehr fuer jede Zelle durchlaufen
1650cdf0e10cSrcweir // worden sein.
1651cdf0e10cSrcweir nWidthSet++;
1652cdf0e10cSrcweir
1653cdf0e10cSrcweir // Schritt 0: Wenn noetig, wird hier noch der Pass2 des Layout-Alogithmus
1654cdf0e10cSrcweir // aufgerufen.
1655cdf0e10cSrcweir if( bCallPass2 )
1656cdf0e10cSrcweir AutoLayoutPass2( nAbsAvail, nRelAvail, nAbsLeftSpace, nAbsRightSpace,
1657cdf0e10cSrcweir nParentInhAbsSpace );
1658cdf0e10cSrcweir
1659cdf0e10cSrcweir // Schritt 1: Setzten der neuen Breite an allen Content-Boxen.
1660cdf0e10cSrcweir // Da die Boxen nichts von der HTML-Tabellen-Struktur wissen, wird
1661cdf0e10cSrcweir // ueber die HTML-Tabellen-Struktur iteriert. Fuer Tabellen in Tabellen
1662cdf0e10cSrcweir // in Tabellen wird rekursiv SetWidth aufgerufen.
1663cdf0e10cSrcweir for( sal_uInt16 i=0; i<nRows; i++ )
1664cdf0e10cSrcweir {
1665cdf0e10cSrcweir for( sal_uInt16 j=0; j<nCols; j++ )
1666cdf0e10cSrcweir {
1667cdf0e10cSrcweir SwHTMLTableLayoutCell *pCell = GetCell( i, j );
1668cdf0e10cSrcweir
1669cdf0e10cSrcweir SwHTMLTableLayoutCnts* pCntnts = pCell->GetContents();
1670cdf0e10cSrcweir while( pCntnts && !pCntnts->IsWidthSet(nWidthSet) )
1671cdf0e10cSrcweir {
1672cdf0e10cSrcweir SwTableBox *pBox = pCntnts->GetTableBox();
1673cdf0e10cSrcweir if( pBox )
1674cdf0e10cSrcweir {
1675cdf0e10cSrcweir SetBoxWidth( pBox, j, pCell->GetColSpan() );
1676cdf0e10cSrcweir }
1677cdf0e10cSrcweir else
1678cdf0e10cSrcweir {
1679cdf0e10cSrcweir sal_uInt16 nAbs = 0, nRel = 0, nLSpace = 0, nRSpace = 0,
1680cdf0e10cSrcweir nInhSpace = 0;
1681cdf0e10cSrcweir if( bCallPass2 )
1682cdf0e10cSrcweir {
1683cdf0e10cSrcweir sal_uInt16 nColSpan = pCell->GetColSpan();
1684cdf0e10cSrcweir GetAvail( j, nColSpan, nAbs, nRel );
1685cdf0e10cSrcweir nLSpace = GetLeftCellSpace( j, nColSpan );
1686cdf0e10cSrcweir nRSpace = GetRightCellSpace( j, nColSpan );
1687cdf0e10cSrcweir nInhSpace = GetInhCellSpace( j, nColSpan );
1688cdf0e10cSrcweir }
1689cdf0e10cSrcweir pCntnts->GetTable()->SetWidths( bCallPass2, nAbs, nRel,
1690cdf0e10cSrcweir nLSpace, nRSpace,
1691cdf0e10cSrcweir nInhSpace );
1692cdf0e10cSrcweir }
1693cdf0e10cSrcweir
1694cdf0e10cSrcweir pCntnts->SetWidthSet( nWidthSet );
1695cdf0e10cSrcweir pCntnts = pCntnts->GetNext();
1696cdf0e10cSrcweir }
1697cdf0e10cSrcweir }
1698cdf0e10cSrcweir }
1699cdf0e10cSrcweir
1700cdf0e10cSrcweir // Schritt 2: Wenn eine Top-Tabelle vorliegt, werden jetzt die Formate
1701cdf0e10cSrcweir // der Nicht-Content-Boxen angepasst. Da diese aufgrund der
1702cdf0e10cSrcweir // Garbage-Collection in der HTML-Tabelle nicht bekannt sind, muessen
1703cdf0e10cSrcweir // wir hier ueber die Tabelle iterieren. Bei der Gelegenheit wird auch
1704cdf0e10cSrcweir // das Tabellen-Frameformat angepasst. Fuer Tabellen in Tabellen werden
1705cdf0e10cSrcweir // stattdessen die Breiten der Filler-Zellen gesetzt.
1706cdf0e10cSrcweir if( IsTopTable() )
1707cdf0e10cSrcweir {
1708cdf0e10cSrcweir sal_uInt16 nCalcTabWidth = 0;
1709cdf0e10cSrcweir ((SwTable *)pSwTable)->GetTabLines().ForEach( &lcl_ResizeLine,
1710cdf0e10cSrcweir &nCalcTabWidth );
1711cdf0e10cSrcweir ASSERT( Abs( nRelTabWidth-nCalcTabWidth ) < COLFUZZY,
1712cdf0e10cSrcweir "Tabellebreite stimmt nicht mit Zeilenbreite ueberein." );
1713cdf0e10cSrcweir
1714cdf0e10cSrcweir // Beim Anpassen des Tabellen-Formats dieses locken, weil sonst
1715cdf0e10cSrcweir // die Boxformate erneut angepasst werden. Ausserdem muss eine
1716cdf0e10cSrcweir // evtl. vorhandene %-Angabe in jedem Fall erhalten bleiben.
1717cdf0e10cSrcweir SwFrmFmt *pFrmFmt = pSwTable->GetFrmFmt();
1718cdf0e10cSrcweir ((SwTable *)pSwTable)->LockModify();
1719cdf0e10cSrcweir SwFmtFrmSize aFrmSize( pFrmFmt->GetFrmSize() );
1720cdf0e10cSrcweir aFrmSize.SetWidth( nRelTabWidth );
1721cdf0e10cSrcweir sal_Bool bRel = bUseRelWidth &&
1722cdf0e10cSrcweir text::HoriOrientation::FULL!=pFrmFmt->GetHoriOrient().GetHoriOrient();
1723cdf0e10cSrcweir aFrmSize.SetWidthPercent( (sal_uInt8)(bRel ? nWidthOption : 0) );
1724cdf0e10cSrcweir pFrmFmt->SetFmtAttr( aFrmSize );
1725cdf0e10cSrcweir ((SwTable *)pSwTable)->UnlockModify();
1726cdf0e10cSrcweir
1727cdf0e10cSrcweir // Wenn die Tabelle in einem Rahmen steht, muss auch noch dessen
1728cdf0e10cSrcweir // breite angepasst werden.
1729cdf0e10cSrcweir if( MayBeInFlyFrame() )
1730cdf0e10cSrcweir {
1731cdf0e10cSrcweir SwFrmFmt *pFlyFrmFmt = FindFlyFrmFmt();
1732cdf0e10cSrcweir if( pFlyFrmFmt )
1733cdf0e10cSrcweir {
1734cdf0e10cSrcweir SwFmtFrmSize aFlyFrmSize( ATT_VAR_SIZE, nRelTabWidth, MINLAY );
1735cdf0e10cSrcweir
1736cdf0e10cSrcweir if( bUseRelWidth )
1737cdf0e10cSrcweir {
1738cdf0e10cSrcweir // Bei %-Angaben wird die Breite auf das Minimum gesetzt.
1739cdf0e10cSrcweir aFlyFrmSize.SetWidth( nMin > USHRT_MAX ? USHRT_MAX
1740cdf0e10cSrcweir : nMin );
1741cdf0e10cSrcweir aFlyFrmSize.SetWidthPercent( (sal_uInt8)nWidthOption );
1742cdf0e10cSrcweir }
1743cdf0e10cSrcweir pFlyFrmFmt->SetFmtAttr( aFlyFrmSize );
1744cdf0e10cSrcweir }
1745cdf0e10cSrcweir }
1746cdf0e10cSrcweir
1747cdf0e10cSrcweir #ifdef DBG_UTIL
1748cdf0e10cSrcweir {
1749cdf0e10cSrcweir // steht im tblrwcl.cxx
1750cdf0e10cSrcweir extern void _CheckBoxWidth( const SwTableLine&, SwTwips );
1751cdf0e10cSrcweir
1752cdf0e10cSrcweir // checke doch mal ob die Tabellen korrekte Breiten haben
1753cdf0e10cSrcweir SwTwips nSize = pSwTable->GetFrmFmt()->GetFrmSize().GetWidth();
1754cdf0e10cSrcweir const SwTableLines& rLines = pSwTable->GetTabLines();
1755cdf0e10cSrcweir for( sal_uInt16 n = 0; n < rLines.Count(); ++n )
1756cdf0e10cSrcweir _CheckBoxWidth( *rLines[ n ], nSize );
1757cdf0e10cSrcweir }
1758cdf0e10cSrcweir #endif
1759cdf0e10cSrcweir
1760cdf0e10cSrcweir }
1761cdf0e10cSrcweir else
1762cdf0e10cSrcweir {
1763cdf0e10cSrcweir if( pLeftFillerBox )
1764cdf0e10cSrcweir {
1765cdf0e10cSrcweir pLeftFillerBox->GetFrmFmt()->SetFmtAttr(
1766cdf0e10cSrcweir SwFmtFrmSize( ATT_VAR_SIZE, nRelLeftFill, 0 ));
1767cdf0e10cSrcweir }
1768cdf0e10cSrcweir if( pRightFillerBox )
1769cdf0e10cSrcweir {
1770cdf0e10cSrcweir pRightFillerBox->GetFrmFmt()->SetFmtAttr(
1771cdf0e10cSrcweir SwFmtFrmSize( ATT_VAR_SIZE, nRelRightFill, 0 ));
1772cdf0e10cSrcweir }
1773cdf0e10cSrcweir }
1774cdf0e10cSrcweir }
1775cdf0e10cSrcweir
_Resize(sal_uInt16 nAbsAvail,sal_Bool bRecalc)1776cdf0e10cSrcweir void SwHTMLTableLayout::_Resize( sal_uInt16 nAbsAvail, sal_Bool bRecalc )
1777cdf0e10cSrcweir {
1778cdf0e10cSrcweir // Wenn bRecalc gestzt ist, hat sich am Inhalt der Tabelle etwas
1779cdf0e10cSrcweir // geaendert. Es muss dann der erste Pass noch einmal durchgefuehrt
1780cdf0e10cSrcweir // werden.
1781cdf0e10cSrcweir if( bRecalc )
1782cdf0e10cSrcweir AutoLayoutPass1();
1783cdf0e10cSrcweir
1784cdf0e10cSrcweir SwRootFrm *pRoot = (SwRootFrm*)GetDoc()->GetCurrentViewShell()->GetLayout();
1785cdf0e10cSrcweir if ( pRoot && pRoot->IsCallbackActionEnabled() )
1786cdf0e10cSrcweir pRoot->StartAllAction(); //swmod 071108//swmod 071225
1787cdf0e10cSrcweir
1788cdf0e10cSrcweir // Sonst koennen die Breiten gesetzt werden, wobei zuvor aber jewils
1789cdf0e10cSrcweir // noch der Pass 2 laufen muss.
1790cdf0e10cSrcweir SetWidths( sal_True, nAbsAvail );
1791cdf0e10cSrcweir
1792cdf0e10cSrcweir if ( pRoot && pRoot->IsCallbackActionEnabled() )
1793cdf0e10cSrcweir pRoot->EndAllAction( sal_True ); //True per VirDev (Browsen ruhiger) //swmod 071108//swmod 071225
1794cdf0e10cSrcweir }
1795cdf0e10cSrcweir
IMPL_STATIC_LINK(SwHTMLTableLayout,DelayedResize_Impl,void *,EMPTYARG)1796cdf0e10cSrcweir IMPL_STATIC_LINK( SwHTMLTableLayout, DelayedResize_Impl, void*, EMPTYARG )
1797cdf0e10cSrcweir {
1798cdf0e10cSrcweir #ifdef TEST_DELAYED_RESIZE
1799cdf0e10cSrcweir Sound::Beep( SOUND_WARNING );
1800cdf0e10cSrcweir #endif
1801cdf0e10cSrcweir pThis->aResizeTimer.Stop();
1802cdf0e10cSrcweir pThis->_Resize( pThis->nDelayedResizeAbsAvail,
1803cdf0e10cSrcweir pThis->bDelayedResizeRecalc );
1804cdf0e10cSrcweir
1805cdf0e10cSrcweir return 0;
1806cdf0e10cSrcweir }
1807cdf0e10cSrcweir
1808cdf0e10cSrcweir
Resize(sal_uInt16 nAbsAvail,sal_Bool bRecalc,sal_Bool bForce,sal_uLong nDelay)1809cdf0e10cSrcweir sal_Bool SwHTMLTableLayout::Resize( sal_uInt16 nAbsAvail, sal_Bool bRecalc,
1810cdf0e10cSrcweir sal_Bool bForce, sal_uLong nDelay )
1811cdf0e10cSrcweir {
1812cdf0e10cSrcweir if( 0 == nAbsAvail )
1813cdf0e10cSrcweir return sal_False;
1814cdf0e10cSrcweir ASSERT( IsTopTable(), "Resize darf nur an Top-Tabellen aufgerufen werden" );
1815cdf0e10cSrcweir
1816cdf0e10cSrcweir // Darf die Tabelle uberhaupt Resized werden oder soll sie es trotzdem?
1817cdf0e10cSrcweir if( bMustNotResize && !bForce )
1818cdf0e10cSrcweir return sal_False;
1819cdf0e10cSrcweir
1820cdf0e10cSrcweir // Darf ein Recalc der Tabelle durchgefuehrt werden?
1821cdf0e10cSrcweir if( bMustNotRecalc && !bForce )
1822cdf0e10cSrcweir bRecalc = sal_False;
1823cdf0e10cSrcweir
1824cdf0e10cSrcweir const SwDoc *pDoc = GetDoc();
1825cdf0e10cSrcweir
1826cdf0e10cSrcweir // Wenn es ein Layout gibt, wurde evtl. die Groesse der Root-Frames
1827cdf0e10cSrcweir // und nicht die der VisArea uebergeben. Wenn wir nicht in einem Rahmen
1828cdf0e10cSrcweir // stehen, muss die Tabelle allerdings fuer die VisArea berechnet werden,
1829cdf0e10cSrcweir // weil sond die Umschaltung von relativ nach absolut nicht funktioniert.
1830cdf0e10cSrcweir if( pDoc->GetCurrentViewShell() && pDoc->GetCurrentViewShell()->GetViewOptions()->getBrowseMode() )
1831cdf0e10cSrcweir {
1832cdf0e10cSrcweir const sal_uInt16 nVisAreaWidth = GetBrowseWidthByVisArea( *pDoc );
1833cdf0e10cSrcweir if( nVisAreaWidth < nAbsAvail && !FindFlyFrmFmt() )
1834cdf0e10cSrcweir nAbsAvail = nVisAreaWidth;
1835cdf0e10cSrcweir }
1836cdf0e10cSrcweir
1837cdf0e10cSrcweir if( nDelay==0 && aResizeTimer.IsActive() )
1838cdf0e10cSrcweir {
1839cdf0e10cSrcweir // Wenn beim Aufruf eines synchronen Resize noch ein asynchrones
1840cdf0e10cSrcweir // Resize aussteht, dann werden nur die neuen Werte uebernommen.
1841cdf0e10cSrcweir
1842cdf0e10cSrcweir bRecalc |= bDelayedResizeRecalc;
1843cdf0e10cSrcweir nDelayedResizeAbsAvail = nAbsAvail;
1844cdf0e10cSrcweir return sal_False;
1845cdf0e10cSrcweir }
1846cdf0e10cSrcweir
1847cdf0e10cSrcweir // Optimierung:
1848cdf0e10cSrcweir // Wenn die Minima/Maxima nicht neu berechnet werden sollen und
1849cdf0e10cSrcweir // - die Breite der Tabelle nie neu berechnet werden muss, oder
1850cdf0e10cSrcweir // - die Tabelle schon fuer die uebergebene Breite berechnet wurde, oder
1851cdf0e10cSrcweir // - der verfuegbare Platz kleiner oder gleich der Minimalbreite ist
1852cdf0e10cSrcweir // und die Tabelle bereits die Minimalbreite besitzt, oder
1853cdf0e10cSrcweir // - der verfuegbare Platz groesser ist als die Maximalbreite und
1854cdf0e10cSrcweir // die Tabelle bereits die Maximalbreite besitzt
1855cdf0e10cSrcweir // wird sich an der Tabelle nichts aendern.
1856cdf0e10cSrcweir if( !bRecalc && ( !bMustResize ||
1857cdf0e10cSrcweir (nLastResizeAbsAvail==nAbsAvail) ||
1858cdf0e10cSrcweir (nAbsAvail<=nMin && nRelTabWidth==nMin) ||
1859cdf0e10cSrcweir (!bPrcWidthOption && nAbsAvail>=nMax && nRelTabWidth==nMax) ) )
1860cdf0e10cSrcweir return sal_False;
1861cdf0e10cSrcweir
1862cdf0e10cSrcweir if( nDelay==HTMLTABLE_RESIZE_NOW )
1863cdf0e10cSrcweir {
1864cdf0e10cSrcweir if( aResizeTimer.IsActive() )
1865cdf0e10cSrcweir aResizeTimer.Stop();
1866cdf0e10cSrcweir _Resize( nAbsAvail, bRecalc );
1867cdf0e10cSrcweir }
1868cdf0e10cSrcweir else if( nDelay > 0 )
1869cdf0e10cSrcweir {
1870cdf0e10cSrcweir nDelayedResizeAbsAvail = nAbsAvail;
1871cdf0e10cSrcweir bDelayedResizeRecalc = bRecalc;
1872cdf0e10cSrcweir aResizeTimer.SetTimeout( nDelay );
1873cdf0e10cSrcweir aResizeTimer.Start();
1874cdf0e10cSrcweir #ifdef TEST_DELAYED_RESIZE
1875cdf0e10cSrcweir Sound::Beep( SOUND_DEFAULT );
1876cdf0e10cSrcweir #endif
1877cdf0e10cSrcweir }
1878cdf0e10cSrcweir else
1879cdf0e10cSrcweir {
1880cdf0e10cSrcweir _Resize( nAbsAvail, bRecalc );
1881cdf0e10cSrcweir }
1882cdf0e10cSrcweir
1883cdf0e10cSrcweir return sal_True;
1884cdf0e10cSrcweir }
1885cdf0e10cSrcweir
BordersChanged(sal_uInt16 nAbsAvail,sal_Bool bRecalc)1886cdf0e10cSrcweir void SwHTMLTableLayout::BordersChanged( sal_uInt16 nAbsAvail, sal_Bool bRecalc )
1887cdf0e10cSrcweir {
1888cdf0e10cSrcweir bBordersChanged = sal_True;
1889cdf0e10cSrcweir
1890cdf0e10cSrcweir Resize( nAbsAvail, bRecalc );
1891cdf0e10cSrcweir }
1892cdf0e10cSrcweir
1893cdf0e10cSrcweir
1894