1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_svx.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski #include <com/sun/star/table/XMergeableCell.hpp>
28*b1cdbd2cSJim Jagielski #include <com/sun/star/awt/XLayoutConstrains.hpp>
29*b1cdbd2cSJim Jagielski #include <boost/bind.hpp>
30*b1cdbd2cSJim Jagielski
31*b1cdbd2cSJim Jagielski #include "cell.hxx"
32*b1cdbd2cSJim Jagielski #include "cellrange.hxx"
33*b1cdbd2cSJim Jagielski #include "tablemodel.hxx"
34*b1cdbd2cSJim Jagielski #include "tablerow.hxx"
35*b1cdbd2cSJim Jagielski #include "tablerows.hxx"
36*b1cdbd2cSJim Jagielski #include "tablecolumn.hxx"
37*b1cdbd2cSJim Jagielski #include "tablecolumns.hxx"
38*b1cdbd2cSJim Jagielski #include "tablelayouter.hxx"
39*b1cdbd2cSJim Jagielski #include "svx/svdotable.hxx"
40*b1cdbd2cSJim Jagielski #include "editeng/borderline.hxx"
41*b1cdbd2cSJim Jagielski #include "editeng/boxitem.hxx"
42*b1cdbd2cSJim Jagielski #include "svx/svdmodel.hxx"
43*b1cdbd2cSJim Jagielski #include "svx/svdstr.hrc"
44*b1cdbd2cSJim Jagielski #include "svx/svdglob.hxx"
45*b1cdbd2cSJim Jagielski
46*b1cdbd2cSJim Jagielski using ::rtl::OUString;
47*b1cdbd2cSJim Jagielski using ::com::sun::star::awt::XLayoutConstrains;
48*b1cdbd2cSJim Jagielski using namespace ::com::sun::star::uno;
49*b1cdbd2cSJim Jagielski using namespace ::com::sun::star::table;
50*b1cdbd2cSJim Jagielski using namespace ::com::sun::star::lang;
51*b1cdbd2cSJim Jagielski using namespace ::com::sun::star::container;
52*b1cdbd2cSJim Jagielski using namespace ::com::sun::star::beans;
53*b1cdbd2cSJim Jagielski using namespace ::com::sun::star::table;
54*b1cdbd2cSJim Jagielski using namespace ::com::sun::star::text;
55*b1cdbd2cSJim Jagielski
56*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
57*b1cdbd2cSJim Jagielski
58*b1cdbd2cSJim Jagielski namespace sdr { namespace table {
59*b1cdbd2cSJim Jagielski
60*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
61*b1cdbd2cSJim Jagielski
62*b1cdbd2cSJim Jagielski static SvxBorderLine gEmptyBorder;
63*b1cdbd2cSJim Jagielski
64*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
65*b1cdbd2cSJim Jagielski
TableLayouter(const TableModelRef & xTableModel)66*b1cdbd2cSJim Jagielski TableLayouter::TableLayouter( const TableModelRef& xTableModel )
67*b1cdbd2cSJim Jagielski : mxTable( xTableModel )
68*b1cdbd2cSJim Jagielski , meWritingMode( WritingMode_LR_TB )
69*b1cdbd2cSJim Jagielski , msSize( RTL_CONSTASCII_USTRINGPARAM( "Size" ) )
70*b1cdbd2cSJim Jagielski {
71*b1cdbd2cSJim Jagielski }
72*b1cdbd2cSJim Jagielski
73*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
74*b1cdbd2cSJim Jagielski
~TableLayouter()75*b1cdbd2cSJim Jagielski TableLayouter::~TableLayouter()
76*b1cdbd2cSJim Jagielski {
77*b1cdbd2cSJim Jagielski ClearBorderLayout();
78*b1cdbd2cSJim Jagielski }
79*b1cdbd2cSJim Jagielski
80*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
81*b1cdbd2cSJim Jagielski
getCellSize(const CellPos & rPos) const82*b1cdbd2cSJim Jagielski basegfx::B2ITuple TableLayouter::getCellSize( const CellPos& rPos ) const
83*b1cdbd2cSJim Jagielski {
84*b1cdbd2cSJim Jagielski sal_Int32 width = 0;
85*b1cdbd2cSJim Jagielski sal_Int32 height = 0;
86*b1cdbd2cSJim Jagielski
87*b1cdbd2cSJim Jagielski try
88*b1cdbd2cSJim Jagielski {
89*b1cdbd2cSJim Jagielski CellRef xCell( getCell( rPos ) );
90*b1cdbd2cSJim Jagielski if( xCell.is() && !xCell->isMerged() )
91*b1cdbd2cSJim Jagielski {
92*b1cdbd2cSJim Jagielski CellPos aPos( rPos );
93*b1cdbd2cSJim Jagielski
94*b1cdbd2cSJim Jagielski sal_Int32 nRowCount = getRowCount();
95*b1cdbd2cSJim Jagielski sal_Int32 nRowSpan = std::max( xCell->getRowSpan(), (sal_Int32)1 );
96*b1cdbd2cSJim Jagielski while( nRowSpan && (aPos.mnRow < nRowCount) )
97*b1cdbd2cSJim Jagielski {
98*b1cdbd2cSJim Jagielski if( ((sal_Int32)maRows.size()) <= aPos.mnRow )
99*b1cdbd2cSJim Jagielski break;
100*b1cdbd2cSJim Jagielski
101*b1cdbd2cSJim Jagielski height += maRows[aPos.mnRow++].mnSize;
102*b1cdbd2cSJim Jagielski nRowSpan--;
103*b1cdbd2cSJim Jagielski }
104*b1cdbd2cSJim Jagielski
105*b1cdbd2cSJim Jagielski sal_Int32 nColCount = getColumnCount();
106*b1cdbd2cSJim Jagielski sal_Int32 nColSpan = std::max( xCell->getColumnSpan(), (sal_Int32)1 );
107*b1cdbd2cSJim Jagielski while( nColSpan && (aPos.mnCol < nColCount ) )
108*b1cdbd2cSJim Jagielski {
109*b1cdbd2cSJim Jagielski if( ((sal_Int32)maColumns.size()) <= aPos.mnCol )
110*b1cdbd2cSJim Jagielski break;
111*b1cdbd2cSJim Jagielski
112*b1cdbd2cSJim Jagielski width += maColumns[aPos.mnCol++].mnSize;
113*b1cdbd2cSJim Jagielski nColSpan--;
114*b1cdbd2cSJim Jagielski }
115*b1cdbd2cSJim Jagielski }
116*b1cdbd2cSJim Jagielski }
117*b1cdbd2cSJim Jagielski catch( Exception& )
118*b1cdbd2cSJim Jagielski {
119*b1cdbd2cSJim Jagielski DBG_ERROR( "TableLayouter::getCellSize(), exception caught!" );
120*b1cdbd2cSJim Jagielski }
121*b1cdbd2cSJim Jagielski
122*b1cdbd2cSJim Jagielski return basegfx::B2ITuple( width, height );
123*b1cdbd2cSJim Jagielski }
124*b1cdbd2cSJim Jagielski
125*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
126*b1cdbd2cSJim Jagielski
getCellArea(const CellPos & rPos,basegfx::B2IRectangle & rArea) const127*b1cdbd2cSJim Jagielski bool TableLayouter::getCellArea( const CellPos& rPos, basegfx::B2IRectangle& rArea ) const
128*b1cdbd2cSJim Jagielski {
129*b1cdbd2cSJim Jagielski try
130*b1cdbd2cSJim Jagielski {
131*b1cdbd2cSJim Jagielski CellRef xCell( getCell( rPos ) );
132*b1cdbd2cSJim Jagielski if( xCell.is() && !xCell->isMerged() && isValid(rPos) )
133*b1cdbd2cSJim Jagielski {
134*b1cdbd2cSJim Jagielski const basegfx::B2ITuple aCellSize( getCellSize( rPos ) );
135*b1cdbd2cSJim Jagielski
136*b1cdbd2cSJim Jagielski if( (rPos.mnCol < ((sal_Int32)maColumns.size()) && (rPos.mnRow < ((sal_Int32)maRows.size()) ) ) )
137*b1cdbd2cSJim Jagielski {
138*b1cdbd2cSJim Jagielski const sal_Int32 x = maColumns[rPos.mnCol].mnPos;
139*b1cdbd2cSJim Jagielski const sal_Int32 y = maRows[rPos.mnRow].mnPos;
140*b1cdbd2cSJim Jagielski
141*b1cdbd2cSJim Jagielski rArea = basegfx::B2IRectangle( x, y, x + aCellSize.getX(), y + aCellSize.getY() );
142*b1cdbd2cSJim Jagielski return true;
143*b1cdbd2cSJim Jagielski }
144*b1cdbd2cSJim Jagielski }
145*b1cdbd2cSJim Jagielski }
146*b1cdbd2cSJim Jagielski catch( Exception& )
147*b1cdbd2cSJim Jagielski {
148*b1cdbd2cSJim Jagielski DBG_ERROR( "TableLayouter::getCellSize(), exception caught!" );
149*b1cdbd2cSJim Jagielski }
150*b1cdbd2cSJim Jagielski return false;
151*b1cdbd2cSJim Jagielski }
152*b1cdbd2cSJim Jagielski
153*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
154*b1cdbd2cSJim Jagielski
getRowHeight(sal_Int32 nRow)155*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::getRowHeight( sal_Int32 nRow )
156*b1cdbd2cSJim Jagielski {
157*b1cdbd2cSJim Jagielski if( isValidRow(nRow) )
158*b1cdbd2cSJim Jagielski return maRows[nRow].mnSize;
159*b1cdbd2cSJim Jagielski else
160*b1cdbd2cSJim Jagielski return 0;
161*b1cdbd2cSJim Jagielski }
162*b1cdbd2cSJim Jagielski
163*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
164*b1cdbd2cSJim Jagielski
setRowHeight(sal_Int32 nRow,sal_Int32 nHeight)165*b1cdbd2cSJim Jagielski void TableLayouter::setRowHeight( sal_Int32 nRow, sal_Int32 nHeight )
166*b1cdbd2cSJim Jagielski {
167*b1cdbd2cSJim Jagielski if( isValidRow(nRow) )
168*b1cdbd2cSJim Jagielski {
169*b1cdbd2cSJim Jagielski maRows[nRow].mnSize = nHeight;
170*b1cdbd2cSJim Jagielski }
171*b1cdbd2cSJim Jagielski else
172*b1cdbd2cSJim Jagielski {
173*b1cdbd2cSJim Jagielski DBG_ERROR( "TableLayouter::setRowHeight(), row out of range!" );
174*b1cdbd2cSJim Jagielski }
175*b1cdbd2cSJim Jagielski }
176*b1cdbd2cSJim Jagielski
177*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
178*b1cdbd2cSJim Jagielski
getColumnWidth(sal_Int32 nColumn)179*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::getColumnWidth( sal_Int32 nColumn )
180*b1cdbd2cSJim Jagielski {
181*b1cdbd2cSJim Jagielski if( isValidColumn(nColumn) )
182*b1cdbd2cSJim Jagielski return maColumns[nColumn].mnSize;
183*b1cdbd2cSJim Jagielski else
184*b1cdbd2cSJim Jagielski return 0;
185*b1cdbd2cSJim Jagielski }
186*b1cdbd2cSJim Jagielski
187*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
188*b1cdbd2cSJim Jagielski
setColumnWidth(sal_Int32 nColumn,sal_Int32 nWidth)189*b1cdbd2cSJim Jagielski void TableLayouter::setColumnWidth( sal_Int32 nColumn, sal_Int32 nWidth )
190*b1cdbd2cSJim Jagielski {
191*b1cdbd2cSJim Jagielski if( isValidColumn(nColumn) )
192*b1cdbd2cSJim Jagielski maColumns[nColumn].mnSize = nWidth;
193*b1cdbd2cSJim Jagielski else
194*b1cdbd2cSJim Jagielski DBG_ERROR( "TableLayouter::setColumnWidth(), column out of range!" );
195*b1cdbd2cSJim Jagielski }
196*b1cdbd2cSJim Jagielski
197*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
198*b1cdbd2cSJim Jagielski
isEdgeVisible(sal_Int32 nEdgeX,sal_Int32 nEdgeY,bool bHorizontal) const199*b1cdbd2cSJim Jagielski bool TableLayouter::isEdgeVisible( sal_Int32 nEdgeX, sal_Int32 nEdgeY, bool bHorizontal ) const
200*b1cdbd2cSJim Jagielski {
201*b1cdbd2cSJim Jagielski const BorderLineMap& rMap = bHorizontal ? maHorizontalBorders : maVerticalBorders;
202*b1cdbd2cSJim Jagielski
203*b1cdbd2cSJim Jagielski if( (nEdgeX >= 0) && (nEdgeX < sal::static_int_cast<sal_Int32>(rMap.size())) &&
204*b1cdbd2cSJim Jagielski (nEdgeY >= 0) && (nEdgeY < sal::static_int_cast<sal_Int32>(rMap[nEdgeX].size())) )
205*b1cdbd2cSJim Jagielski {
206*b1cdbd2cSJim Jagielski return rMap[nEdgeX][nEdgeY] != 0;
207*b1cdbd2cSJim Jagielski }
208*b1cdbd2cSJim Jagielski else
209*b1cdbd2cSJim Jagielski {
210*b1cdbd2cSJim Jagielski OSL_ENSURE( false, "sdr::table::TableLayouter::getBorderLine(), invalid edge!" );
211*b1cdbd2cSJim Jagielski }
212*b1cdbd2cSJim Jagielski
213*b1cdbd2cSJim Jagielski return false;
214*b1cdbd2cSJim Jagielski }
215*b1cdbd2cSJim Jagielski
216*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
217*b1cdbd2cSJim Jagielski
218*b1cdbd2cSJim Jagielski /** returns the requested borderline in rpBorderLine or a null pointer if there is no border at this edge */
getBorderLine(sal_Int32 nEdgeX,sal_Int32 nEdgeY,bool bHorizontal) const219*b1cdbd2cSJim Jagielski SvxBorderLine* TableLayouter::getBorderLine( sal_Int32 nEdgeX, sal_Int32 nEdgeY, bool bHorizontal )const
220*b1cdbd2cSJim Jagielski {
221*b1cdbd2cSJim Jagielski SvxBorderLine* pLine = 0;
222*b1cdbd2cSJim Jagielski
223*b1cdbd2cSJim Jagielski const BorderLineMap& rMap = bHorizontal ? maHorizontalBorders : maVerticalBorders;
224*b1cdbd2cSJim Jagielski
225*b1cdbd2cSJim Jagielski if( (nEdgeX >= 0) && (nEdgeX < sal::static_int_cast<sal_Int32>(rMap.size())) &&
226*b1cdbd2cSJim Jagielski (nEdgeY >= 0) && (nEdgeY < sal::static_int_cast<sal_Int32>(rMap[nEdgeX].size())) )
227*b1cdbd2cSJim Jagielski {
228*b1cdbd2cSJim Jagielski pLine = rMap[nEdgeX][nEdgeY];
229*b1cdbd2cSJim Jagielski if( pLine == &gEmptyBorder )
230*b1cdbd2cSJim Jagielski pLine = 0;
231*b1cdbd2cSJim Jagielski }
232*b1cdbd2cSJim Jagielski else
233*b1cdbd2cSJim Jagielski {
234*b1cdbd2cSJim Jagielski OSL_ENSURE( false, "sdr::table::TableLayouter::getBorderLine(), invalid edge!" );
235*b1cdbd2cSJim Jagielski }
236*b1cdbd2cSJim Jagielski
237*b1cdbd2cSJim Jagielski return pLine;
238*b1cdbd2cSJim Jagielski }
239*b1cdbd2cSJim Jagielski
240*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
241*b1cdbd2cSJim Jagielski
getHorizontalEdge(int nEdgeY,sal_Int32 * pnMin,sal_Int32 * pnMax)242*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::getHorizontalEdge( int nEdgeY, sal_Int32* pnMin /*= 0*/, sal_Int32* pnMax /*= 0*/ )
243*b1cdbd2cSJim Jagielski {
244*b1cdbd2cSJim Jagielski sal_Int32 nRet = 0;
245*b1cdbd2cSJim Jagielski if( (nEdgeY >= 0) && (nEdgeY <= getRowCount() ) )
246*b1cdbd2cSJim Jagielski nRet = maRows[std::min((sal_Int32)nEdgeY,getRowCount()-1)].mnPos;
247*b1cdbd2cSJim Jagielski
248*b1cdbd2cSJim Jagielski if( nEdgeY == getRowCount() )
249*b1cdbd2cSJim Jagielski nRet += maRows[nEdgeY - 1].mnSize;
250*b1cdbd2cSJim Jagielski
251*b1cdbd2cSJim Jagielski if( pnMin )
252*b1cdbd2cSJim Jagielski {
253*b1cdbd2cSJim Jagielski if( (nEdgeY > 0) && (nEdgeY <= getRowCount() ) )
254*b1cdbd2cSJim Jagielski {
255*b1cdbd2cSJim Jagielski *pnMin = maRows[nEdgeY-1].mnPos + 600; // todo
256*b1cdbd2cSJim Jagielski }
257*b1cdbd2cSJim Jagielski else
258*b1cdbd2cSJim Jagielski {
259*b1cdbd2cSJim Jagielski *pnMin = nRet;
260*b1cdbd2cSJim Jagielski }
261*b1cdbd2cSJim Jagielski }
262*b1cdbd2cSJim Jagielski
263*b1cdbd2cSJim Jagielski if( pnMax )
264*b1cdbd2cSJim Jagielski {
265*b1cdbd2cSJim Jagielski *pnMax = 0x0fffffff;
266*b1cdbd2cSJim Jagielski }
267*b1cdbd2cSJim Jagielski return nRet;
268*b1cdbd2cSJim Jagielski }
269*b1cdbd2cSJim Jagielski
270*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
271*b1cdbd2cSJim Jagielski
getVerticalEdge(int nEdgeX,sal_Int32 * pnMin,sal_Int32 * pnMax)272*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::getVerticalEdge( int nEdgeX, sal_Int32* pnMin /*= 0*/, sal_Int32* pnMax /*= 0*/ )
273*b1cdbd2cSJim Jagielski {
274*b1cdbd2cSJim Jagielski sal_Int32 nRet = 0;
275*b1cdbd2cSJim Jagielski
276*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount();
277*b1cdbd2cSJim Jagielski if( (nEdgeX >= 0) && (nEdgeX <= nColCount ) )
278*b1cdbd2cSJim Jagielski nRet = maColumns[std::min((sal_Int32)nEdgeX,nColCount-1)].mnPos;
279*b1cdbd2cSJim Jagielski
280*b1cdbd2cSJim Jagielski const bool bRTL = meWritingMode == WritingMode_RL_TB;
281*b1cdbd2cSJim Jagielski if( bRTL )
282*b1cdbd2cSJim Jagielski {
283*b1cdbd2cSJim Jagielski if( (nEdgeX >= 0) && (nEdgeX < nColCount) )
284*b1cdbd2cSJim Jagielski nRet += maColumns[nEdgeX].mnSize;
285*b1cdbd2cSJim Jagielski }
286*b1cdbd2cSJim Jagielski else
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski if( nEdgeX == getColumnCount() )
289*b1cdbd2cSJim Jagielski nRet += maColumns[nEdgeX - 1].mnSize;
290*b1cdbd2cSJim Jagielski }
291*b1cdbd2cSJim Jagielski
292*b1cdbd2cSJim Jagielski if( pnMin )
293*b1cdbd2cSJim Jagielski {
294*b1cdbd2cSJim Jagielski *pnMin = nRet;
295*b1cdbd2cSJim Jagielski if( bRTL )
296*b1cdbd2cSJim Jagielski {
297*b1cdbd2cSJim Jagielski if( nEdgeX < nColCount )
298*b1cdbd2cSJim Jagielski *pnMin = nRet - maColumns[nEdgeX].mnSize + getMinimumColumnWidth(nEdgeX);
299*b1cdbd2cSJim Jagielski }
300*b1cdbd2cSJim Jagielski else
301*b1cdbd2cSJim Jagielski {
302*b1cdbd2cSJim Jagielski if( (nEdgeX > 0) && (nEdgeX <= nColCount ) )
303*b1cdbd2cSJim Jagielski *pnMin = maColumns[nEdgeX-1].mnPos + getMinimumColumnWidth( nEdgeX-1 );
304*b1cdbd2cSJim Jagielski }
305*b1cdbd2cSJim Jagielski }
306*b1cdbd2cSJim Jagielski
307*b1cdbd2cSJim Jagielski if( pnMax )
308*b1cdbd2cSJim Jagielski {
309*b1cdbd2cSJim Jagielski *pnMax = 0x0fffffff; // todo
310*b1cdbd2cSJim Jagielski if( bRTL )
311*b1cdbd2cSJim Jagielski {
312*b1cdbd2cSJim Jagielski if( nEdgeX > 0 )
313*b1cdbd2cSJim Jagielski *pnMax = nRet + maColumns[nEdgeX-1].mnSize - getMinimumColumnWidth( nEdgeX-1 );
314*b1cdbd2cSJim Jagielski }
315*b1cdbd2cSJim Jagielski else
316*b1cdbd2cSJim Jagielski {
317*b1cdbd2cSJim Jagielski if( (nEdgeX >= 0) && (nEdgeX < nColCount ) )
318*b1cdbd2cSJim Jagielski *pnMax = maColumns[nEdgeX].mnPos + maColumns[nEdgeX].mnSize - getMinimumColumnWidth( nEdgeX );
319*b1cdbd2cSJim Jagielski }
320*b1cdbd2cSJim Jagielski }
321*b1cdbd2cSJim Jagielski
322*b1cdbd2cSJim Jagielski return nRet;
323*b1cdbd2cSJim Jagielski }
324*b1cdbd2cSJim Jagielski
325*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
326*b1cdbd2cSJim Jagielski
checkMergeOrigin(const TableModelRef & xTable,sal_Int32 nMergedX,sal_Int32 nMergedY,sal_Int32 nCellX,sal_Int32 nCellY,bool & bRunning)327*b1cdbd2cSJim Jagielski static bool checkMergeOrigin( const TableModelRef& xTable, sal_Int32 nMergedX, sal_Int32 nMergedY, sal_Int32 nCellX, sal_Int32 nCellY, bool& bRunning )
328*b1cdbd2cSJim Jagielski {
329*b1cdbd2cSJim Jagielski Reference< XMergeableCell > xCell( xTable->getCellByPosition( nCellX, nCellY ), UNO_QUERY );
330*b1cdbd2cSJim Jagielski if( xCell.is() && !xCell->isMerged() )
331*b1cdbd2cSJim Jagielski {
332*b1cdbd2cSJim Jagielski const sal_Int32 nRight = xCell->getColumnSpan() + nCellX;
333*b1cdbd2cSJim Jagielski const sal_Int32 nBottom = xCell->getRowSpan() + nCellY;
334*b1cdbd2cSJim Jagielski if( (nMergedX < nRight) && (nMergedY < nBottom) )
335*b1cdbd2cSJim Jagielski return true;
336*b1cdbd2cSJim Jagielski
337*b1cdbd2cSJim Jagielski bRunning = false;
338*b1cdbd2cSJim Jagielski }
339*b1cdbd2cSJim Jagielski return false;
340*b1cdbd2cSJim Jagielski }
341*b1cdbd2cSJim Jagielski
342*b1cdbd2cSJim Jagielski /** returns true if the cell(nMergedX,nMergedY) is merged with other cells.
343*b1cdbd2cSJim Jagielski the returned cell( rOriginX, rOriginY ) is the origin( top left cell ) of the merge.
344*b1cdbd2cSJim Jagielski */
findMergeOrigin(const TableModelRef & xTable,sal_Int32 nMergedX,sal_Int32 nMergedY,sal_Int32 & rOriginX,sal_Int32 & rOriginY)345*b1cdbd2cSJim Jagielski bool findMergeOrigin( const TableModelRef& xTable, sal_Int32 nMergedX, sal_Int32 nMergedY, sal_Int32& rOriginX, sal_Int32& rOriginY )
346*b1cdbd2cSJim Jagielski {
347*b1cdbd2cSJim Jagielski rOriginX = nMergedX;
348*b1cdbd2cSJim Jagielski rOriginY = nMergedY;
349*b1cdbd2cSJim Jagielski
350*b1cdbd2cSJim Jagielski if( xTable.is() ) try
351*b1cdbd2cSJim Jagielski {
352*b1cdbd2cSJim Jagielski // check if this cell already the origin or not merged at all
353*b1cdbd2cSJim Jagielski Reference< XMergeableCell > xCell( xTable->getCellByPosition( nMergedX, nMergedY ), UNO_QUERY_THROW );
354*b1cdbd2cSJim Jagielski if( !xCell.is() || !xCell->isMerged() )
355*b1cdbd2cSJim Jagielski return true;
356*b1cdbd2cSJim Jagielski
357*b1cdbd2cSJim Jagielski bool bCheckVert = true;
358*b1cdbd2cSJim Jagielski bool bCheckHorz = true;
359*b1cdbd2cSJim Jagielski
360*b1cdbd2cSJim Jagielski sal_Int32 nMinCol = 0;
361*b1cdbd2cSJim Jagielski sal_Int32 nMinRow = 0;
362*b1cdbd2cSJim Jagielski
363*b1cdbd2cSJim Jagielski sal_Int32 nStep = 1, i;
364*b1cdbd2cSJim Jagielski
365*b1cdbd2cSJim Jagielski sal_Int32 nRow, nCol;
366*b1cdbd2cSJim Jagielski do
367*b1cdbd2cSJim Jagielski {
368*b1cdbd2cSJim Jagielski if( bCheckVert )
369*b1cdbd2cSJim Jagielski {
370*b1cdbd2cSJim Jagielski nRow = nMergedY - nStep;
371*b1cdbd2cSJim Jagielski if( nRow >= nMinRow )
372*b1cdbd2cSJim Jagielski {
373*b1cdbd2cSJim Jagielski nCol = nMergedX;
374*b1cdbd2cSJim Jagielski for( i = 0; (i <= nStep) && (nCol >= nMinCol); i++, nCol-- )
375*b1cdbd2cSJim Jagielski {
376*b1cdbd2cSJim Jagielski if( checkMergeOrigin( xTable, nMergedX, nMergedY, nCol, nRow, bCheckVert ) )
377*b1cdbd2cSJim Jagielski {
378*b1cdbd2cSJim Jagielski rOriginX = nCol; rOriginY = nRow;
379*b1cdbd2cSJim Jagielski return true;
380*b1cdbd2cSJim Jagielski }
381*b1cdbd2cSJim Jagielski
382*b1cdbd2cSJim Jagielski if( !bCheckVert )
383*b1cdbd2cSJim Jagielski {
384*b1cdbd2cSJim Jagielski if( nCol == nMergedX )
385*b1cdbd2cSJim Jagielski {
386*b1cdbd2cSJim Jagielski nMinRow = nRow+1;
387*b1cdbd2cSJim Jagielski }
388*b1cdbd2cSJim Jagielski else
389*b1cdbd2cSJim Jagielski {
390*b1cdbd2cSJim Jagielski bCheckVert = true;
391*b1cdbd2cSJim Jagielski }
392*b1cdbd2cSJim Jagielski break;
393*b1cdbd2cSJim Jagielski }
394*b1cdbd2cSJim Jagielski }
395*b1cdbd2cSJim Jagielski }
396*b1cdbd2cSJim Jagielski else
397*b1cdbd2cSJim Jagielski {
398*b1cdbd2cSJim Jagielski bCheckVert = false;
399*b1cdbd2cSJim Jagielski }
400*b1cdbd2cSJim Jagielski }
401*b1cdbd2cSJim Jagielski
402*b1cdbd2cSJim Jagielski if( bCheckHorz )
403*b1cdbd2cSJim Jagielski {
404*b1cdbd2cSJim Jagielski nCol = nMergedX - nStep;
405*b1cdbd2cSJim Jagielski if( nCol >= nMinCol )
406*b1cdbd2cSJim Jagielski {
407*b1cdbd2cSJim Jagielski nRow = nMergedY;
408*b1cdbd2cSJim Jagielski for( i = 0; (i < nStep) && (nRow >= nMinRow); i++, nRow-- )
409*b1cdbd2cSJim Jagielski {
410*b1cdbd2cSJim Jagielski if( checkMergeOrigin( xTable, nMergedX, nMergedY, nCol, nRow, bCheckHorz ) )
411*b1cdbd2cSJim Jagielski {
412*b1cdbd2cSJim Jagielski rOriginX = nCol; rOriginY = nRow;
413*b1cdbd2cSJim Jagielski return true;
414*b1cdbd2cSJim Jagielski }
415*b1cdbd2cSJim Jagielski
416*b1cdbd2cSJim Jagielski if( !bCheckHorz )
417*b1cdbd2cSJim Jagielski {
418*b1cdbd2cSJim Jagielski if( nRow == nMergedY )
419*b1cdbd2cSJim Jagielski {
420*b1cdbd2cSJim Jagielski nMinCol = nCol+1;
421*b1cdbd2cSJim Jagielski }
422*b1cdbd2cSJim Jagielski else
423*b1cdbd2cSJim Jagielski {
424*b1cdbd2cSJim Jagielski bCheckHorz = true;
425*b1cdbd2cSJim Jagielski }
426*b1cdbd2cSJim Jagielski break;
427*b1cdbd2cSJim Jagielski }
428*b1cdbd2cSJim Jagielski }
429*b1cdbd2cSJim Jagielski }
430*b1cdbd2cSJim Jagielski else
431*b1cdbd2cSJim Jagielski {
432*b1cdbd2cSJim Jagielski bCheckHorz = false;
433*b1cdbd2cSJim Jagielski }
434*b1cdbd2cSJim Jagielski }
435*b1cdbd2cSJim Jagielski nStep++;
436*b1cdbd2cSJim Jagielski }
437*b1cdbd2cSJim Jagielski while( bCheckVert || bCheckHorz );
438*b1cdbd2cSJim Jagielski }
439*b1cdbd2cSJim Jagielski catch( Exception& )
440*b1cdbd2cSJim Jagielski {
441*b1cdbd2cSJim Jagielski DBG_ERROR("sdr::table::TableLayouter::findMergeOrigin(), exception caught!");
442*b1cdbd2cSJim Jagielski }
443*b1cdbd2cSJim Jagielski return false;
444*b1cdbd2cSJim Jagielski }
445*b1cdbd2cSJim Jagielski
446*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
447*b1cdbd2cSJim Jagielski
getMinimumColumnWidth(sal_Int32 nColumn)448*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::getMinimumColumnWidth( sal_Int32 nColumn )
449*b1cdbd2cSJim Jagielski {
450*b1cdbd2cSJim Jagielski if( isValidColumn( nColumn ) )
451*b1cdbd2cSJim Jagielski {
452*b1cdbd2cSJim Jagielski return maColumns[nColumn].mnMinSize;
453*b1cdbd2cSJim Jagielski }
454*b1cdbd2cSJim Jagielski else
455*b1cdbd2cSJim Jagielski {
456*b1cdbd2cSJim Jagielski DBG_ERROR( "TableLayouter::getMinimumColumnWidth(), column out of range!" );
457*b1cdbd2cSJim Jagielski return 0;
458*b1cdbd2cSJim Jagielski }
459*b1cdbd2cSJim Jagielski }
460*b1cdbd2cSJim Jagielski
461*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
462*b1cdbd2cSJim Jagielski
distribute(LayoutVector & rLayouts,sal_Int32 nDistribute)463*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::distribute( LayoutVector& rLayouts, sal_Int32 nDistribute )
464*b1cdbd2cSJim Jagielski {
465*b1cdbd2cSJim Jagielski // break loops after 100 runs to avoid freezing office due to developer error
466*b1cdbd2cSJim Jagielski sal_Int32 nSafe = 100;
467*b1cdbd2cSJim Jagielski
468*b1cdbd2cSJim Jagielski const sal_Size nCount = rLayouts.size();
469*b1cdbd2cSJim Jagielski sal_Size nIndex;
470*b1cdbd2cSJim Jagielski
471*b1cdbd2cSJim Jagielski bool bConstrainsBroken = false;
472*b1cdbd2cSJim Jagielski
473*b1cdbd2cSJim Jagielski do
474*b1cdbd2cSJim Jagielski {
475*b1cdbd2cSJim Jagielski // first enforce minimum size constrains on all entities
476*b1cdbd2cSJim Jagielski for( nIndex = 0; nIndex < nCount; ++nIndex )
477*b1cdbd2cSJim Jagielski {
478*b1cdbd2cSJim Jagielski Layout& rLayout = rLayouts[nIndex];
479*b1cdbd2cSJim Jagielski if( rLayout.mnSize < rLayout.mnMinSize )
480*b1cdbd2cSJim Jagielski {
481*b1cdbd2cSJim Jagielski nDistribute -= rLayout.mnMinSize - rLayout.mnSize;
482*b1cdbd2cSJim Jagielski rLayout.mnSize = rLayout.mnMinSize;
483*b1cdbd2cSJim Jagielski }
484*b1cdbd2cSJim Jagielski }
485*b1cdbd2cSJim Jagielski
486*b1cdbd2cSJim Jagielski // calculate current width
487*b1cdbd2cSJim Jagielski // if nDistribute is < 0 (shrinking), entities that are already
488*b1cdbd2cSJim Jagielski // at minimum width are not counted
489*b1cdbd2cSJim Jagielski sal_Int32 nCurrentWidth = 0;
490*b1cdbd2cSJim Jagielski for( nIndex = 0; nIndex < nCount; ++nIndex )
491*b1cdbd2cSJim Jagielski {
492*b1cdbd2cSJim Jagielski Layout& rLayout = rLayouts[nIndex];
493*b1cdbd2cSJim Jagielski if( (nDistribute > 0) || (rLayout.mnSize > rLayout.mnMinSize) )
494*b1cdbd2cSJim Jagielski nCurrentWidth += rLayout.mnSize;
495*b1cdbd2cSJim Jagielski }
496*b1cdbd2cSJim Jagielski
497*b1cdbd2cSJim Jagielski bConstrainsBroken = false;
498*b1cdbd2cSJim Jagielski
499*b1cdbd2cSJim Jagielski // now distribute over entities
500*b1cdbd2cSJim Jagielski if( (nCurrentWidth != 0) && (nDistribute != 0) )
501*b1cdbd2cSJim Jagielski {
502*b1cdbd2cSJim Jagielski sal_Int32 nDistributed = nDistribute;
503*b1cdbd2cSJim Jagielski for( nIndex = 0; nIndex < nCount; ++nIndex )
504*b1cdbd2cSJim Jagielski {
505*b1cdbd2cSJim Jagielski Layout& rLayout = rLayouts[nIndex];
506*b1cdbd2cSJim Jagielski if( (nDistribute > 0) || (rLayout.mnSize > rLayout.mnMinSize) )
507*b1cdbd2cSJim Jagielski {
508*b1cdbd2cSJim Jagielski sal_Int32 n;
509*b1cdbd2cSJim Jagielski if( nIndex == (nCount-1) )
510*b1cdbd2cSJim Jagielski n = nDistributed; // for last entitie, use up rest
511*b1cdbd2cSJim Jagielski else
512*b1cdbd2cSJim Jagielski n = (nDistribute * rLayout.mnSize) / nCurrentWidth; //
513*b1cdbd2cSJim Jagielski
514*b1cdbd2cSJim Jagielski nDistributed -= n;
515*b1cdbd2cSJim Jagielski rLayout.mnSize += n;
516*b1cdbd2cSJim Jagielski
517*b1cdbd2cSJim Jagielski if( rLayout.mnSize < rLayout.mnMinSize )
518*b1cdbd2cSJim Jagielski bConstrainsBroken = true;
519*b1cdbd2cSJim Jagielski }
520*b1cdbd2cSJim Jagielski }
521*b1cdbd2cSJim Jagielski }
522*b1cdbd2cSJim Jagielski } while( bConstrainsBroken && --nSafe );
523*b1cdbd2cSJim Jagielski
524*b1cdbd2cSJim Jagielski sal_Int32 nSize = 0;
525*b1cdbd2cSJim Jagielski for( nIndex = 0; nIndex < nCount; ++nIndex )
526*b1cdbd2cSJim Jagielski nSize += rLayouts[nIndex].mnSize;
527*b1cdbd2cSJim Jagielski
528*b1cdbd2cSJim Jagielski return nSize;
529*b1cdbd2cSJim Jagielski }
530*b1cdbd2cSJim Jagielski
531*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
532*b1cdbd2cSJim Jagielski
533*b1cdbd2cSJim Jagielski typedef std::vector< CellRef > MergeableCellVector;
534*b1cdbd2cSJim Jagielski typedef std::vector< MergeableCellVector > MergeVector;
535*b1cdbd2cSJim Jagielski typedef std::vector< sal_Int32 > Int32Vector;
536*b1cdbd2cSJim Jagielski
537*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
538*b1cdbd2cSJim Jagielski
LayoutTableWidth(Rectangle & rArea,bool bFit)539*b1cdbd2cSJim Jagielski void TableLayouter::LayoutTableWidth( Rectangle& rArea, bool bFit )
540*b1cdbd2cSJim Jagielski {
541*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount();
542*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = getRowCount();
543*b1cdbd2cSJim Jagielski if( nColCount == 0 )
544*b1cdbd2cSJim Jagielski return;
545*b1cdbd2cSJim Jagielski
546*b1cdbd2cSJim Jagielski MergeVector aMergedCells( nColCount );
547*b1cdbd2cSJim Jagielski Int32Vector aOptimalColumns;
548*b1cdbd2cSJim Jagielski
549*b1cdbd2cSJim Jagielski const OUString sOptimalSize( RTL_CONSTASCII_USTRINGPARAM("OptimalSize") );
550*b1cdbd2cSJim Jagielski
551*b1cdbd2cSJim Jagielski if( sal::static_int_cast< sal_Int32 >( maColumns.size() ) != nColCount )
552*b1cdbd2cSJim Jagielski maColumns.resize( nColCount );
553*b1cdbd2cSJim Jagielski
554*b1cdbd2cSJim Jagielski Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_QUERY_THROW );
555*b1cdbd2cSJim Jagielski
556*b1cdbd2cSJim Jagielski // first calculate current width and initial minimum width per column,
557*b1cdbd2cSJim Jagielski // merged cells will be counted later
558*b1cdbd2cSJim Jagielski sal_Int32 nCurrentWidth = 0;
559*b1cdbd2cSJim Jagielski sal_Int32 nCol = 0, nRow = 0;
560*b1cdbd2cSJim Jagielski for( nCol = 0; nCol < nColCount; nCol++ )
561*b1cdbd2cSJim Jagielski {
562*b1cdbd2cSJim Jagielski sal_Int32 nMinWidth = 0;
563*b1cdbd2cSJim Jagielski
564*b1cdbd2cSJim Jagielski bool bIsEmpty = true; // check if all cells in this column are merged
565*b1cdbd2cSJim Jagielski
566*b1cdbd2cSJim Jagielski for( nRow = 0; nRow < nRowCount; ++nRow )
567*b1cdbd2cSJim Jagielski {
568*b1cdbd2cSJim Jagielski CellRef xCell( getCell( CellPos( nCol, nRow ) ) );
569*b1cdbd2cSJim Jagielski if( xCell.is() && !xCell->isMerged() )
570*b1cdbd2cSJim Jagielski {
571*b1cdbd2cSJim Jagielski bIsEmpty = false;
572*b1cdbd2cSJim Jagielski
573*b1cdbd2cSJim Jagielski sal_Int32 nColSpan = xCell->getColumnSpan();
574*b1cdbd2cSJim Jagielski if( nColSpan > 1 )
575*b1cdbd2cSJim Jagielski {
576*b1cdbd2cSJim Jagielski // merged cells will be evaluated later
577*b1cdbd2cSJim Jagielski aMergedCells[nCol+nColSpan-1].push_back( xCell );
578*b1cdbd2cSJim Jagielski }
579*b1cdbd2cSJim Jagielski else
580*b1cdbd2cSJim Jagielski {
581*b1cdbd2cSJim Jagielski nMinWidth = std::max( nMinWidth, xCell->getMinimumSize().Width );
582*b1cdbd2cSJim Jagielski }
583*b1cdbd2cSJim Jagielski }
584*b1cdbd2cSJim Jagielski }
585*b1cdbd2cSJim Jagielski
586*b1cdbd2cSJim Jagielski maColumns[nCol].mnMinSize = nMinWidth;
587*b1cdbd2cSJim Jagielski
588*b1cdbd2cSJim Jagielski if( bIsEmpty )
589*b1cdbd2cSJim Jagielski {
590*b1cdbd2cSJim Jagielski maColumns[nCol].mnSize = 0;
591*b1cdbd2cSJim Jagielski }
592*b1cdbd2cSJim Jagielski else
593*b1cdbd2cSJim Jagielski {
594*b1cdbd2cSJim Jagielski sal_Int32 nColWidth = 0;
595*b1cdbd2cSJim Jagielski Reference< XPropertySet > xColSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
596*b1cdbd2cSJim Jagielski sal_Bool bOptimal = sal_False;
597*b1cdbd2cSJim Jagielski xColSet->getPropertyValue( sOptimalSize ) >>= bOptimal;
598*b1cdbd2cSJim Jagielski if( bOptimal )
599*b1cdbd2cSJim Jagielski {
600*b1cdbd2cSJim Jagielski aOptimalColumns.push_back(nCol);
601*b1cdbd2cSJim Jagielski }
602*b1cdbd2cSJim Jagielski else
603*b1cdbd2cSJim Jagielski {
604*b1cdbd2cSJim Jagielski xColSet->getPropertyValue( msSize ) >>= nColWidth;
605*b1cdbd2cSJim Jagielski }
606*b1cdbd2cSJim Jagielski
607*b1cdbd2cSJim Jagielski maColumns[nCol].mnSize = nColWidth;
608*b1cdbd2cSJim Jagielski
609*b1cdbd2cSJim Jagielski if( maColumns[nCol].mnSize < nMinWidth )
610*b1cdbd2cSJim Jagielski maColumns[nCol].mnSize = nMinWidth;
611*b1cdbd2cSJim Jagielski
612*b1cdbd2cSJim Jagielski nCurrentWidth += maColumns[nCol].mnSize;
613*b1cdbd2cSJim Jagielski }
614*b1cdbd2cSJim Jagielski }
615*b1cdbd2cSJim Jagielski
616*b1cdbd2cSJim Jagielski // if we have optimal sized rows, distribute what is given (left)
617*b1cdbd2cSJim Jagielski if( !bFit && !aOptimalColumns.empty() && (nCurrentWidth < rArea.getWidth()) )
618*b1cdbd2cSJim Jagielski {
619*b1cdbd2cSJim Jagielski sal_Int32 nLeft = rArea.getWidth() - nCurrentWidth;
620*b1cdbd2cSJim Jagielski sal_Int32 nDistribute = nLeft / aOptimalColumns.size();
621*b1cdbd2cSJim Jagielski
622*b1cdbd2cSJim Jagielski Int32Vector::iterator iter( aOptimalColumns.begin() );
623*b1cdbd2cSJim Jagielski while( iter != aOptimalColumns.end() )
624*b1cdbd2cSJim Jagielski {
625*b1cdbd2cSJim Jagielski sal_Int32 nOptCol = (*iter++);
626*b1cdbd2cSJim Jagielski if( iter == aOptimalColumns.end() )
627*b1cdbd2cSJim Jagielski nDistribute = nLeft;
628*b1cdbd2cSJim Jagielski
629*b1cdbd2cSJim Jagielski maColumns[nOptCol].mnSize += nDistribute;
630*b1cdbd2cSJim Jagielski nLeft -= nDistribute;
631*b1cdbd2cSJim Jagielski }
632*b1cdbd2cSJim Jagielski
633*b1cdbd2cSJim Jagielski DBG_ASSERT( nLeft == 0, "svx::TableLayouter::LayoutTableWidtht(), layouting failed!" );
634*b1cdbd2cSJim Jagielski }
635*b1cdbd2cSJim Jagielski
636*b1cdbd2cSJim Jagielski // now check if merged cells fit
637*b1cdbd2cSJim Jagielski for( nCol = 1; nCol < nColCount; ++nCol )
638*b1cdbd2cSJim Jagielski {
639*b1cdbd2cSJim Jagielski bool bChanges = false;
640*b1cdbd2cSJim Jagielski MergeableCellVector::iterator iter( aMergedCells[nCol].begin() );
641*b1cdbd2cSJim Jagielski
642*b1cdbd2cSJim Jagielski const sal_Int32 nOldSize = maColumns[nCol].mnSize;
643*b1cdbd2cSJim Jagielski
644*b1cdbd2cSJim Jagielski while( iter != aMergedCells[nCol].end() )
645*b1cdbd2cSJim Jagielski {
646*b1cdbd2cSJim Jagielski CellRef xCell( (*iter++) );
647*b1cdbd2cSJim Jagielski sal_Int32 nMinWidth = xCell->getMinimumSize().Width;
648*b1cdbd2cSJim Jagielski
649*b1cdbd2cSJim Jagielski for( sal_Int32 nMCol = nCol - xCell->getColumnSpan() + 1; (nMCol > 0) && (nMCol < nCol); ++nMCol )
650*b1cdbd2cSJim Jagielski nMinWidth -= maColumns[nMCol].mnSize;
651*b1cdbd2cSJim Jagielski
652*b1cdbd2cSJim Jagielski if( nMinWidth > maColumns[nCol].mnMinSize )
653*b1cdbd2cSJim Jagielski maColumns[nCol].mnMinSize = nMinWidth;
654*b1cdbd2cSJim Jagielski
655*b1cdbd2cSJim Jagielski if( nMinWidth > maColumns[nCol].mnSize )
656*b1cdbd2cSJim Jagielski {
657*b1cdbd2cSJim Jagielski maColumns[nCol].mnSize = nMinWidth;
658*b1cdbd2cSJim Jagielski bChanges = true;
659*b1cdbd2cSJim Jagielski }
660*b1cdbd2cSJim Jagielski }
661*b1cdbd2cSJim Jagielski
662*b1cdbd2cSJim Jagielski if( bChanges )
663*b1cdbd2cSJim Jagielski nCurrentWidth += maColumns[nCol].mnSize - nOldSize;
664*b1cdbd2cSJim Jagielski }
665*b1cdbd2cSJim Jagielski
666*b1cdbd2cSJim Jagielski // now scale if wanted and needed
667*b1cdbd2cSJim Jagielski if( bFit && (nCurrentWidth != rArea.getWidth()) )
668*b1cdbd2cSJim Jagielski distribute( maColumns, rArea.getWidth() - nCurrentWidth );
669*b1cdbd2cSJim Jagielski
670*b1cdbd2cSJim Jagielski // last step, update left edges
671*b1cdbd2cSJim Jagielski sal_Int32 nNewWidth = 0;
672*b1cdbd2cSJim Jagielski
673*b1cdbd2cSJim Jagielski const bool bRTL = meWritingMode == WritingMode_RL_TB;
674*b1cdbd2cSJim Jagielski RangeIterator<sal_Int32> coliter( 0, nColCount, !bRTL );
675*b1cdbd2cSJim Jagielski while( coliter.next(nCol ) )
676*b1cdbd2cSJim Jagielski {
677*b1cdbd2cSJim Jagielski maColumns[nCol].mnPos = nNewWidth;
678*b1cdbd2cSJim Jagielski nNewWidth += maColumns[nCol].mnSize;
679*b1cdbd2cSJim Jagielski if( bFit )
680*b1cdbd2cSJim Jagielski {
681*b1cdbd2cSJim Jagielski Reference< XPropertySet > xColSet( xCols->getByIndex(nCol), UNO_QUERY_THROW );
682*b1cdbd2cSJim Jagielski xColSet->setPropertyValue( msSize, Any( maColumns[nCol].mnSize ) );
683*b1cdbd2cSJim Jagielski }
684*b1cdbd2cSJim Jagielski }
685*b1cdbd2cSJim Jagielski
686*b1cdbd2cSJim Jagielski rArea.SetSize( Size( nNewWidth, rArea.GetHeight() ) );
687*b1cdbd2cSJim Jagielski updateCells( rArea );
688*b1cdbd2cSJim Jagielski }
689*b1cdbd2cSJim Jagielski
690*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
691*b1cdbd2cSJim Jagielski
LayoutTableHeight(Rectangle & rArea,bool bFit)692*b1cdbd2cSJim Jagielski void TableLayouter::LayoutTableHeight( Rectangle& rArea, bool bFit )
693*b1cdbd2cSJim Jagielski {
694*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount();
695*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = getRowCount();
696*b1cdbd2cSJim Jagielski if( nRowCount == 0 )
697*b1cdbd2cSJim Jagielski return;
698*b1cdbd2cSJim Jagielski
699*b1cdbd2cSJim Jagielski Reference< XTableRows > xRows( mxTable->getRows() );
700*b1cdbd2cSJim Jagielski
701*b1cdbd2cSJim Jagielski MergeVector aMergedCells( nRowCount );
702*b1cdbd2cSJim Jagielski Int32Vector aOptimalRows;
703*b1cdbd2cSJim Jagielski
704*b1cdbd2cSJim Jagielski const OUString sOptimalSize( RTL_CONSTASCII_USTRINGPARAM("OptimalSize") );
705*b1cdbd2cSJim Jagielski
706*b1cdbd2cSJim Jagielski // first calculate current height and initial minimum size per column,
707*b1cdbd2cSJim Jagielski // merged cells will be counted later
708*b1cdbd2cSJim Jagielski sal_Int32 nCurrentHeight = 0;
709*b1cdbd2cSJim Jagielski sal_Int32 nCol, nRow;
710*b1cdbd2cSJim Jagielski for( nRow = 0; nRow < nRowCount; ++nRow )
711*b1cdbd2cSJim Jagielski {
712*b1cdbd2cSJim Jagielski sal_Int32 nMinHeight = 0;
713*b1cdbd2cSJim Jagielski
714*b1cdbd2cSJim Jagielski bool bIsEmpty = true; // check if all cells in this row are merged
715*b1cdbd2cSJim Jagielski
716*b1cdbd2cSJim Jagielski for( nCol = 0; nCol < nColCount; ++nCol )
717*b1cdbd2cSJim Jagielski {
718*b1cdbd2cSJim Jagielski CellRef xCell( getCell( CellPos( nCol, nRow ) ) );
719*b1cdbd2cSJim Jagielski if( xCell.is() && !xCell->isMerged() )
720*b1cdbd2cSJim Jagielski {
721*b1cdbd2cSJim Jagielski bIsEmpty = false;
722*b1cdbd2cSJim Jagielski
723*b1cdbd2cSJim Jagielski sal_Int32 nRowSpan = xCell->getRowSpan();
724*b1cdbd2cSJim Jagielski if( nRowSpan > 1 )
725*b1cdbd2cSJim Jagielski {
726*b1cdbd2cSJim Jagielski // merged cells will be evaluated later
727*b1cdbd2cSJim Jagielski aMergedCells[nRow+nRowSpan-1].push_back( xCell );
728*b1cdbd2cSJim Jagielski }
729*b1cdbd2cSJim Jagielski else
730*b1cdbd2cSJim Jagielski {
731*b1cdbd2cSJim Jagielski nMinHeight = std::max( nMinHeight, xCell->getMinimumSize().Height );
732*b1cdbd2cSJim Jagielski }
733*b1cdbd2cSJim Jagielski }
734*b1cdbd2cSJim Jagielski }
735*b1cdbd2cSJim Jagielski
736*b1cdbd2cSJim Jagielski maRows[nRow].mnMinSize = nMinHeight;
737*b1cdbd2cSJim Jagielski
738*b1cdbd2cSJim Jagielski if( bIsEmpty )
739*b1cdbd2cSJim Jagielski {
740*b1cdbd2cSJim Jagielski maRows[nRow].mnSize = 0;
741*b1cdbd2cSJim Jagielski }
742*b1cdbd2cSJim Jagielski else
743*b1cdbd2cSJim Jagielski {
744*b1cdbd2cSJim Jagielski sal_Int32 nRowHeight = 0;
745*b1cdbd2cSJim Jagielski Reference< XPropertySet > xRowSet( xRows->getByIndex(nRow), UNO_QUERY_THROW );
746*b1cdbd2cSJim Jagielski
747*b1cdbd2cSJim Jagielski sal_Bool bOptimal = sal_False;
748*b1cdbd2cSJim Jagielski xRowSet->getPropertyValue( sOptimalSize ) >>= bOptimal;
749*b1cdbd2cSJim Jagielski if( bOptimal )
750*b1cdbd2cSJim Jagielski {
751*b1cdbd2cSJim Jagielski aOptimalRows.push_back( nRow );
752*b1cdbd2cSJim Jagielski }
753*b1cdbd2cSJim Jagielski else
754*b1cdbd2cSJim Jagielski {
755*b1cdbd2cSJim Jagielski xRowSet->getPropertyValue( msSize ) >>= nRowHeight;
756*b1cdbd2cSJim Jagielski }
757*b1cdbd2cSJim Jagielski
758*b1cdbd2cSJim Jagielski maRows[nRow].mnSize = nRowHeight;
759*b1cdbd2cSJim Jagielski
760*b1cdbd2cSJim Jagielski if( maRows[nRow].mnSize < nMinHeight )
761*b1cdbd2cSJim Jagielski maRows[nRow].mnSize = nMinHeight;
762*b1cdbd2cSJim Jagielski
763*b1cdbd2cSJim Jagielski nCurrentHeight += maRows[nRow].mnSize;
764*b1cdbd2cSJim Jagielski }
765*b1cdbd2cSJim Jagielski }
766*b1cdbd2cSJim Jagielski
767*b1cdbd2cSJim Jagielski // if we have optimal sized rows, distribute what is given (left)
768*b1cdbd2cSJim Jagielski if( !bFit && !aOptimalRows.empty() && (nCurrentHeight < rArea.getHeight()) )
769*b1cdbd2cSJim Jagielski {
770*b1cdbd2cSJim Jagielski sal_Int32 nLeft = rArea.getHeight() - nCurrentHeight;
771*b1cdbd2cSJim Jagielski sal_Int32 nDistribute = nLeft / aOptimalRows.size();
772*b1cdbd2cSJim Jagielski
773*b1cdbd2cSJim Jagielski Int32Vector::iterator iter( aOptimalRows.begin() );
774*b1cdbd2cSJim Jagielski while( iter != aOptimalRows.end() )
775*b1cdbd2cSJim Jagielski {
776*b1cdbd2cSJim Jagielski sal_Int32 nOptRow = (*iter++);
777*b1cdbd2cSJim Jagielski if( iter == aOptimalRows.end() )
778*b1cdbd2cSJim Jagielski nDistribute = nLeft;
779*b1cdbd2cSJim Jagielski
780*b1cdbd2cSJim Jagielski maRows[nOptRow].mnSize += nDistribute;
781*b1cdbd2cSJim Jagielski nLeft -= nDistribute;
782*b1cdbd2cSJim Jagielski
783*b1cdbd2cSJim Jagielski }
784*b1cdbd2cSJim Jagielski
785*b1cdbd2cSJim Jagielski DBG_ASSERT( nLeft == 0, "svx::TableLayouter::LayoutTableHeight(), layouting failed!" );
786*b1cdbd2cSJim Jagielski }
787*b1cdbd2cSJim Jagielski
788*b1cdbd2cSJim Jagielski // now check if merged cells fit
789*b1cdbd2cSJim Jagielski for( nRow = 1; nRow < nRowCount; ++nRow )
790*b1cdbd2cSJim Jagielski {
791*b1cdbd2cSJim Jagielski bool bChanges = false;
792*b1cdbd2cSJim Jagielski sal_Int32 nOldSize = maRows[nRow].mnSize;
793*b1cdbd2cSJim Jagielski
794*b1cdbd2cSJim Jagielski MergeableCellVector::iterator iter( aMergedCells[nRow].begin() );
795*b1cdbd2cSJim Jagielski while( iter != aMergedCells[nRow].end() )
796*b1cdbd2cSJim Jagielski {
797*b1cdbd2cSJim Jagielski CellRef xCell( (*iter++) );
798*b1cdbd2cSJim Jagielski sal_Int32 nMinHeight = xCell->getMinimumSize().Height;
799*b1cdbd2cSJim Jagielski
800*b1cdbd2cSJim Jagielski for( sal_Int32 nMRow = nRow - xCell->getRowSpan() + 1; (nMRow > 0) && (nMRow < nRow); ++nMRow )
801*b1cdbd2cSJim Jagielski nMinHeight -= maRows[nMRow].mnSize;
802*b1cdbd2cSJim Jagielski
803*b1cdbd2cSJim Jagielski if( nMinHeight > maRows[nRow].mnMinSize )
804*b1cdbd2cSJim Jagielski maRows[nRow].mnMinSize = nMinHeight;
805*b1cdbd2cSJim Jagielski
806*b1cdbd2cSJim Jagielski if( nMinHeight > maRows[nRow].mnSize )
807*b1cdbd2cSJim Jagielski {
808*b1cdbd2cSJim Jagielski maRows[nRow].mnSize = nMinHeight;
809*b1cdbd2cSJim Jagielski bChanges = true;
810*b1cdbd2cSJim Jagielski }
811*b1cdbd2cSJim Jagielski }
812*b1cdbd2cSJim Jagielski if( bChanges )
813*b1cdbd2cSJim Jagielski nCurrentHeight += maRows[nRow].mnSize - nOldSize;
814*b1cdbd2cSJim Jagielski }
815*b1cdbd2cSJim Jagielski
816*b1cdbd2cSJim Jagielski // now scale if wanted and needed
817*b1cdbd2cSJim Jagielski if( bFit && nCurrentHeight != rArea.getHeight() )
818*b1cdbd2cSJim Jagielski distribute( maRows, rArea.getHeight() - nCurrentHeight );
819*b1cdbd2cSJim Jagielski
820*b1cdbd2cSJim Jagielski // last step, update left edges
821*b1cdbd2cSJim Jagielski sal_Int32 nNewHeight = 0;
822*b1cdbd2cSJim Jagielski for( nRow = 0; nRow < nRowCount; ++nRow )
823*b1cdbd2cSJim Jagielski {
824*b1cdbd2cSJim Jagielski maRows[nRow].mnPos = nNewHeight;
825*b1cdbd2cSJim Jagielski nNewHeight += maRows[nRow].mnSize;
826*b1cdbd2cSJim Jagielski
827*b1cdbd2cSJim Jagielski if( bFit )
828*b1cdbd2cSJim Jagielski {
829*b1cdbd2cSJim Jagielski Reference< XPropertySet > xRowSet( xRows->getByIndex(nRow), UNO_QUERY_THROW );
830*b1cdbd2cSJim Jagielski xRowSet->setPropertyValue( msSize, Any( maRows[nRow].mnSize ) );
831*b1cdbd2cSJim Jagielski }
832*b1cdbd2cSJim Jagielski }
833*b1cdbd2cSJim Jagielski
834*b1cdbd2cSJim Jagielski rArea.SetSize( Size( rArea.GetWidth(), nNewHeight ) );
835*b1cdbd2cSJim Jagielski updateCells( rArea );
836*b1cdbd2cSJim Jagielski }
837*b1cdbd2cSJim Jagielski
838*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
839*b1cdbd2cSJim Jagielski
840*b1cdbd2cSJim Jagielski /** try to fit the table into the given rectangle.
841*b1cdbd2cSJim Jagielski If the rectangle is to small, it will be grown to fit the table. */
LayoutTable(Rectangle & rRectangle,bool bFitWidth,bool bFitHeight)842*b1cdbd2cSJim Jagielski void TableLayouter::LayoutTable( Rectangle& rRectangle, bool bFitWidth, bool bFitHeight )
843*b1cdbd2cSJim Jagielski {
844*b1cdbd2cSJim Jagielski if( !mxTable.is() )
845*b1cdbd2cSJim Jagielski return;
846*b1cdbd2cSJim Jagielski
847*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = mxTable->getRowCount();
848*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = mxTable->getColumnCount();
849*b1cdbd2cSJim Jagielski
850*b1cdbd2cSJim Jagielski if( (nRowCount != getRowCount()) || (nColCount != getColumnCount()) )
851*b1cdbd2cSJim Jagielski {
852*b1cdbd2cSJim Jagielski if( static_cast< sal_Int32 >( maRows.size() ) != nRowCount )
853*b1cdbd2cSJim Jagielski maRows.resize( nRowCount );
854*b1cdbd2cSJim Jagielski
855*b1cdbd2cSJim Jagielski Reference< XTableRows > xRows( mxTable->getRows() );
856*b1cdbd2cSJim Jagielski for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
857*b1cdbd2cSJim Jagielski maRows[nRow].clear();
858*b1cdbd2cSJim Jagielski
859*b1cdbd2cSJim Jagielski if( static_cast< sal_Int32 >( maColumns.size() ) != nColCount )
860*b1cdbd2cSJim Jagielski maColumns.resize( nColCount );
861*b1cdbd2cSJim Jagielski
862*b1cdbd2cSJim Jagielski for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
863*b1cdbd2cSJim Jagielski maColumns[nCol].clear();
864*b1cdbd2cSJim Jagielski }
865*b1cdbd2cSJim Jagielski
866*b1cdbd2cSJim Jagielski LayoutTableWidth( rRectangle, bFitWidth );
867*b1cdbd2cSJim Jagielski LayoutTableHeight( rRectangle, bFitHeight );
868*b1cdbd2cSJim Jagielski UpdateBorderLayout();
869*b1cdbd2cSJim Jagielski }
870*b1cdbd2cSJim Jagielski
871*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
872*b1cdbd2cSJim Jagielski
updateCells(Rectangle & rRectangle)873*b1cdbd2cSJim Jagielski void TableLayouter::updateCells( Rectangle& rRectangle )
874*b1cdbd2cSJim Jagielski {
875*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount();
876*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = getRowCount();
877*b1cdbd2cSJim Jagielski
878*b1cdbd2cSJim Jagielski CellPos aPos;
879*b1cdbd2cSJim Jagielski for( aPos.mnRow = 0; aPos.mnRow < nRowCount; aPos.mnRow++ )
880*b1cdbd2cSJim Jagielski {
881*b1cdbd2cSJim Jagielski for( aPos.mnCol = 0; aPos.mnCol < nColCount; aPos.mnCol++ )
882*b1cdbd2cSJim Jagielski {
883*b1cdbd2cSJim Jagielski CellRef xCell( getCell( aPos ) );
884*b1cdbd2cSJim Jagielski if( xCell.is() )
885*b1cdbd2cSJim Jagielski {
886*b1cdbd2cSJim Jagielski basegfx::B2IRectangle aCellArea;
887*b1cdbd2cSJim Jagielski getCellArea( aPos, aCellArea );
888*b1cdbd2cSJim Jagielski
889*b1cdbd2cSJim Jagielski Rectangle aCellRect;
890*b1cdbd2cSJim Jagielski aCellRect.nLeft = aCellArea.getMinX();
891*b1cdbd2cSJim Jagielski aCellRect.nRight = aCellArea.getMaxX();
892*b1cdbd2cSJim Jagielski aCellRect.nTop = aCellArea.getMinY();
893*b1cdbd2cSJim Jagielski aCellRect.nBottom = aCellArea.getMaxY();
894*b1cdbd2cSJim Jagielski aCellRect.Move( rRectangle.nLeft, rRectangle.nTop );
895*b1cdbd2cSJim Jagielski xCell->setCellRect( aCellRect );
896*b1cdbd2cSJim Jagielski }
897*b1cdbd2cSJim Jagielski }
898*b1cdbd2cSJim Jagielski }
899*b1cdbd2cSJim Jagielski }
900*b1cdbd2cSJim Jagielski
901*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
902*b1cdbd2cSJim Jagielski
getCell(const CellPos & rPos) const903*b1cdbd2cSJim Jagielski CellRef TableLayouter::getCell( const CellPos& rPos ) const
904*b1cdbd2cSJim Jagielski {
905*b1cdbd2cSJim Jagielski CellRef xCell;
906*b1cdbd2cSJim Jagielski if( mxTable.is() ) try
907*b1cdbd2cSJim Jagielski {
908*b1cdbd2cSJim Jagielski xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ).get() ) );
909*b1cdbd2cSJim Jagielski }
910*b1cdbd2cSJim Jagielski catch( Exception& )
911*b1cdbd2cSJim Jagielski {
912*b1cdbd2cSJim Jagielski DBG_ERROR( "sdr::table::TableLayouter::getCell(), exception caught!" );
913*b1cdbd2cSJim Jagielski }
914*b1cdbd2cSJim Jagielski return xCell;
915*b1cdbd2cSJim Jagielski }
916*b1cdbd2cSJim Jagielski
917*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
918*b1cdbd2cSJim Jagielski
HasPriority(const SvxBorderLine * pThis,const SvxBorderLine * pOther)919*b1cdbd2cSJim Jagielski bool TableLayouter::HasPriority( const SvxBorderLine* pThis, const SvxBorderLine* pOther )
920*b1cdbd2cSJim Jagielski {
921*b1cdbd2cSJim Jagielski if (!pThis || ((pThis == &gEmptyBorder) && (pOther != 0)))
922*b1cdbd2cSJim Jagielski return false;
923*b1cdbd2cSJim Jagielski if (!pOther || (pOther == &gEmptyBorder))
924*b1cdbd2cSJim Jagielski return true;
925*b1cdbd2cSJim Jagielski
926*b1cdbd2cSJim Jagielski sal_uInt16 nThisSize = pThis->GetOutWidth() + pThis->GetDistance() + pThis->GetInWidth();
927*b1cdbd2cSJim Jagielski sal_uInt16 nOtherSize = pOther->GetOutWidth() + pOther->GetDistance() + pOther->GetInWidth();
928*b1cdbd2cSJim Jagielski
929*b1cdbd2cSJim Jagielski if (nThisSize > nOtherSize)
930*b1cdbd2cSJim Jagielski return true;
931*b1cdbd2cSJim Jagielski
932*b1cdbd2cSJim Jagielski else if (nThisSize < nOtherSize)
933*b1cdbd2cSJim Jagielski {
934*b1cdbd2cSJim Jagielski return false;
935*b1cdbd2cSJim Jagielski }
936*b1cdbd2cSJim Jagielski else
937*b1cdbd2cSJim Jagielski {
938*b1cdbd2cSJim Jagielski if ( pOther->GetInWidth() && !pThis->GetInWidth() )
939*b1cdbd2cSJim Jagielski {
940*b1cdbd2cSJim Jagielski return true;
941*b1cdbd2cSJim Jagielski }
942*b1cdbd2cSJim Jagielski else if ( pThis->GetInWidth() && !pOther->GetInWidth() )
943*b1cdbd2cSJim Jagielski {
944*b1cdbd2cSJim Jagielski return false;
945*b1cdbd2cSJim Jagielski }
946*b1cdbd2cSJim Jagielski else
947*b1cdbd2cSJim Jagielski {
948*b1cdbd2cSJim Jagielski return true; //! ???
949*b1cdbd2cSJim Jagielski }
950*b1cdbd2cSJim Jagielski }
951*b1cdbd2cSJim Jagielski }
952*b1cdbd2cSJim Jagielski
953*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
954*b1cdbd2cSJim Jagielski
SetBorder(sal_Int32 nCol,sal_Int32 nRow,bool bHorizontal,const SvxBorderLine * pLine)955*b1cdbd2cSJim Jagielski void TableLayouter::SetBorder( sal_Int32 nCol, sal_Int32 nRow, bool bHorizontal, const SvxBorderLine* pLine )
956*b1cdbd2cSJim Jagielski {
957*b1cdbd2cSJim Jagielski if( pLine == 0 )
958*b1cdbd2cSJim Jagielski pLine = &gEmptyBorder;
959*b1cdbd2cSJim Jagielski
960*b1cdbd2cSJim Jagielski SvxBorderLine *pOld = bHorizontal ? maHorizontalBorders[nCol][nRow] : maVerticalBorders[nCol][nRow];
961*b1cdbd2cSJim Jagielski
962*b1cdbd2cSJim Jagielski if( HasPriority( pLine, pOld ) )
963*b1cdbd2cSJim Jagielski {
964*b1cdbd2cSJim Jagielski if( (pOld != 0) && (pOld != &gEmptyBorder) )
965*b1cdbd2cSJim Jagielski delete pOld;
966*b1cdbd2cSJim Jagielski
967*b1cdbd2cSJim Jagielski SvxBorderLine* pNew = ( pLine != &gEmptyBorder ) ? new SvxBorderLine(*pLine) : &gEmptyBorder;
968*b1cdbd2cSJim Jagielski
969*b1cdbd2cSJim Jagielski if( bHorizontal )
970*b1cdbd2cSJim Jagielski maHorizontalBorders[nCol][nRow] = pNew;
971*b1cdbd2cSJim Jagielski else
972*b1cdbd2cSJim Jagielski maVerticalBorders[nCol][nRow] = pNew;
973*b1cdbd2cSJim Jagielski }
974*b1cdbd2cSJim Jagielski }
975*b1cdbd2cSJim Jagielski
976*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
977*b1cdbd2cSJim Jagielski
ClearBorderLayout()978*b1cdbd2cSJim Jagielski void TableLayouter::ClearBorderLayout()
979*b1cdbd2cSJim Jagielski {
980*b1cdbd2cSJim Jagielski ClearBorderLayout(maHorizontalBorders);
981*b1cdbd2cSJim Jagielski ClearBorderLayout(maVerticalBorders);
982*b1cdbd2cSJim Jagielski }
983*b1cdbd2cSJim Jagielski
984*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
985*b1cdbd2cSJim Jagielski
ClearBorderLayout(BorderLineMap & rMap)986*b1cdbd2cSJim Jagielski void TableLayouter::ClearBorderLayout(BorderLineMap& rMap)
987*b1cdbd2cSJim Jagielski {
988*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = rMap.size();
989*b1cdbd2cSJim Jagielski
990*b1cdbd2cSJim Jagielski for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
991*b1cdbd2cSJim Jagielski {
992*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = rMap[nCol].size();
993*b1cdbd2cSJim Jagielski for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
994*b1cdbd2cSJim Jagielski {
995*b1cdbd2cSJim Jagielski SvxBorderLine* pLine = rMap[nCol][nRow];
996*b1cdbd2cSJim Jagielski if( pLine )
997*b1cdbd2cSJim Jagielski {
998*b1cdbd2cSJim Jagielski if( pLine != &gEmptyBorder )
999*b1cdbd2cSJim Jagielski delete pLine;
1000*b1cdbd2cSJim Jagielski
1001*b1cdbd2cSJim Jagielski rMap[nCol][nRow] = 0;
1002*b1cdbd2cSJim Jagielski }
1003*b1cdbd2cSJim Jagielski }
1004*b1cdbd2cSJim Jagielski }
1005*b1cdbd2cSJim Jagielski }
1006*b1cdbd2cSJim Jagielski
1007*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1008*b1cdbd2cSJim Jagielski
ResizeBorderLayout()1009*b1cdbd2cSJim Jagielski void TableLayouter::ResizeBorderLayout()
1010*b1cdbd2cSJim Jagielski {
1011*b1cdbd2cSJim Jagielski ClearBorderLayout();
1012*b1cdbd2cSJim Jagielski ResizeBorderLayout(maHorizontalBorders);
1013*b1cdbd2cSJim Jagielski ResizeBorderLayout(maVerticalBorders);
1014*b1cdbd2cSJim Jagielski }
1015*b1cdbd2cSJim Jagielski
1016*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1017*b1cdbd2cSJim Jagielski
ResizeBorderLayout(BorderLineMap & rMap)1018*b1cdbd2cSJim Jagielski void TableLayouter::ResizeBorderLayout( BorderLineMap& rMap )
1019*b1cdbd2cSJim Jagielski {
1020*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount() + 1;
1021*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = getRowCount() + 1;
1022*b1cdbd2cSJim Jagielski
1023*b1cdbd2cSJim Jagielski if( sal::static_int_cast<sal_Int32>(rMap.size()) != nColCount )
1024*b1cdbd2cSJim Jagielski rMap.resize( nColCount );
1025*b1cdbd2cSJim Jagielski
1026*b1cdbd2cSJim Jagielski for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
1027*b1cdbd2cSJim Jagielski {
1028*b1cdbd2cSJim Jagielski if( sal::static_int_cast<sal_Int32>(rMap[nCol].size()) != nRowCount )
1029*b1cdbd2cSJim Jagielski rMap[nCol].resize( nRowCount );
1030*b1cdbd2cSJim Jagielski }
1031*b1cdbd2cSJim Jagielski }
1032*b1cdbd2cSJim Jagielski
1033*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1034*b1cdbd2cSJim Jagielski
UpdateBorderLayout()1035*b1cdbd2cSJim Jagielski void TableLayouter::UpdateBorderLayout()
1036*b1cdbd2cSJim Jagielski {
1037*b1cdbd2cSJim Jagielski // make sure old border layout is cleared and border maps have correct size
1038*b1cdbd2cSJim Jagielski ResizeBorderLayout();
1039*b1cdbd2cSJim Jagielski
1040*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount();
1041*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = getRowCount();
1042*b1cdbd2cSJim Jagielski
1043*b1cdbd2cSJim Jagielski CellPos aPos;
1044*b1cdbd2cSJim Jagielski for( aPos.mnRow = 0; aPos.mnRow < nRowCount; aPos.mnRow++ )
1045*b1cdbd2cSJim Jagielski {
1046*b1cdbd2cSJim Jagielski for( aPos.mnCol = 0; aPos.mnCol < nColCount; aPos.mnCol++ )
1047*b1cdbd2cSJim Jagielski {
1048*b1cdbd2cSJim Jagielski CellRef xCell( getCell( aPos ) );
1049*b1cdbd2cSJim Jagielski if( !xCell.is() || xCell->isMerged() )
1050*b1cdbd2cSJim Jagielski continue;
1051*b1cdbd2cSJim Jagielski
1052*b1cdbd2cSJim Jagielski const SvxBoxItem* pThisAttr = (const SvxBoxItem*)xCell->GetItemSet().GetItem( SDRATTR_TABLE_BORDER );
1053*b1cdbd2cSJim Jagielski OSL_ENSURE(pThisAttr,"sdr::table::TableLayouter::UpdateBorderLayout(), no border attribute?");
1054*b1cdbd2cSJim Jagielski
1055*b1cdbd2cSJim Jagielski if( !pThisAttr )
1056*b1cdbd2cSJim Jagielski continue;
1057*b1cdbd2cSJim Jagielski
1058*b1cdbd2cSJim Jagielski const sal_Int32 nLastRow = xCell->getRowSpan() + aPos.mnRow;
1059*b1cdbd2cSJim Jagielski const sal_Int32 nLastCol = xCell->getColumnSpan() + aPos.mnCol;
1060*b1cdbd2cSJim Jagielski
1061*b1cdbd2cSJim Jagielski for( sal_Int32 nRow = aPos.mnRow; nRow < nLastRow; nRow++ )
1062*b1cdbd2cSJim Jagielski {
1063*b1cdbd2cSJim Jagielski SetBorder( aPos.mnCol, nRow, false, pThisAttr->GetLeft() );
1064*b1cdbd2cSJim Jagielski SetBorder( nLastCol, nRow, false, pThisAttr->GetRight() );
1065*b1cdbd2cSJim Jagielski }
1066*b1cdbd2cSJim Jagielski
1067*b1cdbd2cSJim Jagielski for( sal_Int32 nCol = aPos.mnCol; nCol < nLastCol; nCol++ )
1068*b1cdbd2cSJim Jagielski {
1069*b1cdbd2cSJim Jagielski SetBorder( nCol, aPos.mnRow, true, pThisAttr->GetTop() );
1070*b1cdbd2cSJim Jagielski SetBorder( nCol, nLastRow, true, pThisAttr->GetBottom() );
1071*b1cdbd2cSJim Jagielski }
1072*b1cdbd2cSJim Jagielski }
1073*b1cdbd2cSJim Jagielski }
1074*b1cdbd2cSJim Jagielski }
1075*b1cdbd2cSJim Jagielski
1076*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1077*b1cdbd2cSJim Jagielski /*
1078*b1cdbd2cSJim Jagielski void TableLayouter::SetLayoutToModel()
1079*b1cdbd2cSJim Jagielski {
1080*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = getRowCount();
1081*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount();
1082*b1cdbd2cSJim Jagielski
1083*b1cdbd2cSJim Jagielski try
1084*b1cdbd2cSJim Jagielski {
1085*b1cdbd2cSJim Jagielski sal_Int32 nOldSize = 0;
1086*b1cdbd2cSJim Jagielski
1087*b1cdbd2cSJim Jagielski Reference< XIndexAccess > xRows( mxTable->getRows(), UNO_QUERY_THROW );
1088*b1cdbd2cSJim Jagielski for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
1089*b1cdbd2cSJim Jagielski {
1090*b1cdbd2cSJim Jagielski Reference< XPropertySet > xRowSet( xRows->getByIndex( nRow ), UNO_QUERY_THROW );
1091*b1cdbd2cSJim Jagielski xRowSet->getPropertyValue( msSize ) >>= nOldSize;
1092*b1cdbd2cSJim Jagielski if( maRows[nRow].mnSize != nOldSize )
1093*b1cdbd2cSJim Jagielski xRowSet->setPropertyValue( msSize, Any( maRows[nRow].mnSize ) );
1094*b1cdbd2cSJim Jagielski }
1095*b1cdbd2cSJim Jagielski
1096*b1cdbd2cSJim Jagielski for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
1097*b1cdbd2cSJim Jagielski {
1098*b1cdbd2cSJim Jagielski Reference< XPropertySet > xColSet( getColumnByIndex( nCol ), UNO_QUERY_THROW );
1099*b1cdbd2cSJim Jagielski xColSet->getPropertyValue( msSize ) >>= nOldSize;
1100*b1cdbd2cSJim Jagielski if( maColumns[nCol].mnSize != nOldSize )
1101*b1cdbd2cSJim Jagielski xColSet->setPropertyValue( msSize, Any( maColumns[nCol].mnSize ) );
1102*b1cdbd2cSJim Jagielski }
1103*b1cdbd2cSJim Jagielski }
1104*b1cdbd2cSJim Jagielski catch( Exception& )
1105*b1cdbd2cSJim Jagielski {
1106*b1cdbd2cSJim Jagielski DBG_ERROR("sdr::table::TableLayouter::SetLayoutToModel(), exception caught!");
1107*b1cdbd2cSJim Jagielski }
1108*b1cdbd2cSJim Jagielski }
1109*b1cdbd2cSJim Jagielski */
1110*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1111*b1cdbd2cSJim Jagielski
DistributeColumns(::Rectangle & rArea,sal_Int32 nFirstCol,sal_Int32 nLastCol)1112*b1cdbd2cSJim Jagielski void TableLayouter::DistributeColumns( ::Rectangle& rArea, sal_Int32 nFirstCol, sal_Int32 nLastCol )
1113*b1cdbd2cSJim Jagielski {
1114*b1cdbd2cSJim Jagielski if( mxTable.is() ) try
1115*b1cdbd2cSJim Jagielski {
1116*b1cdbd2cSJim Jagielski const sal_Int32 nColCount = getColumnCount();
1117*b1cdbd2cSJim Jagielski
1118*b1cdbd2cSJim Jagielski if( (nFirstCol < 0) || (nFirstCol>= nLastCol) || (nLastCol >= nColCount) )
1119*b1cdbd2cSJim Jagielski return;
1120*b1cdbd2cSJim Jagielski
1121*b1cdbd2cSJim Jagielski sal_Int32 nAllWidth = 0;
1122*b1cdbd2cSJim Jagielski for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol )
1123*b1cdbd2cSJim Jagielski nAllWidth += getColumnWidth(nCol);
1124*b1cdbd2cSJim Jagielski
1125*b1cdbd2cSJim Jagielski sal_Int32 nWidth = nAllWidth / (nLastCol-nFirstCol+1);
1126*b1cdbd2cSJim Jagielski
1127*b1cdbd2cSJim Jagielski Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_QUERY_THROW );
1128*b1cdbd2cSJim Jagielski
1129*b1cdbd2cSJim Jagielski for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol )
1130*b1cdbd2cSJim Jagielski {
1131*b1cdbd2cSJim Jagielski if( nCol == nLastCol )
1132*b1cdbd2cSJim Jagielski nWidth = nAllWidth; // last column get round errors
1133*b1cdbd2cSJim Jagielski
1134*b1cdbd2cSJim Jagielski Reference< XPropertySet > xColSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
1135*b1cdbd2cSJim Jagielski xColSet->setPropertyValue( msSize, Any( nWidth ) );
1136*b1cdbd2cSJim Jagielski
1137*b1cdbd2cSJim Jagielski nAllWidth -= nWidth;
1138*b1cdbd2cSJim Jagielski }
1139*b1cdbd2cSJim Jagielski
1140*b1cdbd2cSJim Jagielski LayoutTable( rArea, true, false );
1141*b1cdbd2cSJim Jagielski }
1142*b1cdbd2cSJim Jagielski catch( Exception& e )
1143*b1cdbd2cSJim Jagielski {
1144*b1cdbd2cSJim Jagielski (void)e;
1145*b1cdbd2cSJim Jagielski DBG_ERROR("sdr::table::TableLayouter::DistributeColumns(), exception caught!");
1146*b1cdbd2cSJim Jagielski }
1147*b1cdbd2cSJim Jagielski }
1148*b1cdbd2cSJim Jagielski
1149*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1150*b1cdbd2cSJim Jagielski
DistributeRows(::Rectangle & rArea,sal_Int32 nFirstRow,sal_Int32 nLastRow)1151*b1cdbd2cSJim Jagielski void TableLayouter::DistributeRows( ::Rectangle& rArea, sal_Int32 nFirstRow, sal_Int32 nLastRow )
1152*b1cdbd2cSJim Jagielski {
1153*b1cdbd2cSJim Jagielski if( mxTable.is() ) try
1154*b1cdbd2cSJim Jagielski {
1155*b1cdbd2cSJim Jagielski const sal_Int32 nRowCount = mxTable->getRowCount();
1156*b1cdbd2cSJim Jagielski
1157*b1cdbd2cSJim Jagielski if( (nFirstRow < 0) || (nFirstRow>= nLastRow) || (nLastRow >= nRowCount) )
1158*b1cdbd2cSJim Jagielski return;
1159*b1cdbd2cSJim Jagielski
1160*b1cdbd2cSJim Jagielski sal_Int32 nAllHeight = 0;
1161*b1cdbd2cSJim Jagielski sal_Int32 nMinHeight = 0;
1162*b1cdbd2cSJim Jagielski
1163*b1cdbd2cSJim Jagielski for( sal_Int32 nRow = nFirstRow; nRow <= nLastRow; ++nRow )
1164*b1cdbd2cSJim Jagielski {
1165*b1cdbd2cSJim Jagielski nMinHeight = std::max( maRows[nRow].mnMinSize, nMinHeight );
1166*b1cdbd2cSJim Jagielski nAllHeight += maRows[nRow].mnSize;
1167*b1cdbd2cSJim Jagielski }
1168*b1cdbd2cSJim Jagielski
1169*b1cdbd2cSJim Jagielski const sal_Int32 nRows = (nLastRow-nFirstRow+1);
1170*b1cdbd2cSJim Jagielski sal_Int32 nHeight = nAllHeight / nRows;
1171*b1cdbd2cSJim Jagielski
1172*b1cdbd2cSJim Jagielski if( nHeight < nMinHeight )
1173*b1cdbd2cSJim Jagielski {
1174*b1cdbd2cSJim Jagielski sal_Int32 nNeededHeight = nRows * nMinHeight;
1175*b1cdbd2cSJim Jagielski rArea.nBottom += nNeededHeight - nAllHeight;
1176*b1cdbd2cSJim Jagielski nHeight = nMinHeight;
1177*b1cdbd2cSJim Jagielski nAllHeight = nRows * nMinHeight;
1178*b1cdbd2cSJim Jagielski }
1179*b1cdbd2cSJim Jagielski
1180*b1cdbd2cSJim Jagielski Reference< XTableRows > xRows( mxTable->getRows(), UNO_QUERY_THROW );
1181*b1cdbd2cSJim Jagielski for( sal_Int32 nRow = nFirstRow; nRow <= nLastRow; ++nRow )
1182*b1cdbd2cSJim Jagielski {
1183*b1cdbd2cSJim Jagielski if( nRow == nLastRow )
1184*b1cdbd2cSJim Jagielski nHeight = nAllHeight; // last row get round errors
1185*b1cdbd2cSJim Jagielski
1186*b1cdbd2cSJim Jagielski Reference< XPropertySet > xRowSet( xRows->getByIndex( nRow ), UNO_QUERY_THROW );
1187*b1cdbd2cSJim Jagielski xRowSet->setPropertyValue( msSize, Any( nHeight ) );
1188*b1cdbd2cSJim Jagielski
1189*b1cdbd2cSJim Jagielski nAllHeight -= nHeight;
1190*b1cdbd2cSJim Jagielski }
1191*b1cdbd2cSJim Jagielski
1192*b1cdbd2cSJim Jagielski LayoutTable( rArea, false, true );
1193*b1cdbd2cSJim Jagielski }
1194*b1cdbd2cSJim Jagielski catch( Exception& e )
1195*b1cdbd2cSJim Jagielski {
1196*b1cdbd2cSJim Jagielski (void)e;
1197*b1cdbd2cSJim Jagielski DBG_ERROR("sdr::table::TableLayouter::DistributeRows(), exception caught!");
1198*b1cdbd2cSJim Jagielski }
1199*b1cdbd2cSJim Jagielski }
1200*b1cdbd2cSJim Jagielski
1201*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1202*b1cdbd2cSJim Jagielski
SetWritingMode(com::sun::star::text::WritingMode eWritingMode)1203*b1cdbd2cSJim Jagielski void TableLayouter::SetWritingMode( com::sun::star::text::WritingMode eWritingMode )
1204*b1cdbd2cSJim Jagielski {
1205*b1cdbd2cSJim Jagielski meWritingMode = eWritingMode;
1206*b1cdbd2cSJim Jagielski }
1207*b1cdbd2cSJim Jagielski
1208*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1209*b1cdbd2cSJim Jagielski
getColumnStart(sal_Int32 nColumn) const1210*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::getColumnStart( sal_Int32 nColumn ) const
1211*b1cdbd2cSJim Jagielski {
1212*b1cdbd2cSJim Jagielski if( isValidColumn(nColumn) )
1213*b1cdbd2cSJim Jagielski return maColumns[nColumn].mnPos;
1214*b1cdbd2cSJim Jagielski else
1215*b1cdbd2cSJim Jagielski return 0;
1216*b1cdbd2cSJim Jagielski }
1217*b1cdbd2cSJim Jagielski
1218*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1219*b1cdbd2cSJim Jagielski
getRowStart(sal_Int32 nRow) const1220*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::getRowStart( sal_Int32 nRow ) const
1221*b1cdbd2cSJim Jagielski {
1222*b1cdbd2cSJim Jagielski if( isValidRow(nRow) )
1223*b1cdbd2cSJim Jagielski return maRows[nRow].mnPos;
1224*b1cdbd2cSJim Jagielski else
1225*b1cdbd2cSJim Jagielski return 0;
1226*b1cdbd2cSJim Jagielski }
1227*b1cdbd2cSJim Jagielski
1228*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1229*b1cdbd2cSJim Jagielski
1230*b1cdbd2cSJim Jagielski /*
1231*b1cdbd2cSJim Jagielski sal_Int32 TableLayouter::detectInsertedOrRemovedRows()
1232*b1cdbd2cSJim Jagielski {
1233*b1cdbd2cSJim Jagielski sal_Int32 nHeightChange = 0;
1234*b1cdbd2cSJim Jagielski
1235*b1cdbd2cSJim Jagielski try
1236*b1cdbd2cSJim Jagielski {
1237*b1cdbd2cSJim Jagielski Reference< XIndexAccess > xRows( mxTable->getRows(), UNO_QUERY_THROW );
1238*b1cdbd2cSJim Jagielski std::vector< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > >::iterator oldIter( mxRows.begin() );
1239*b1cdbd2cSJim Jagielski sal_Int32 nCount = xRows->getCount();
1240*b1cdbd2cSJim Jagielski for( sal_Int32 nRow = 0; nRow < nCount; nRow++ )
1241*b1cdbd2cSJim Jagielski {
1242*b1cdbd2cSJim Jagielski Reference< XInterface > xRow( xRows->getByIndex(nRow), UNO_QUERY );
1243*b1cdbd2cSJim Jagielski
1244*b1cdbd2cSJim Jagielski std::vector< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > >::iterator searchIter = mxRows.end();
1245*b1cdbd2cSJim Jagielski if( oldIter != mxRows.end() )
1246*b1cdbd2cSJim Jagielski searchIter = std::find( oldIter,mxRows.end(), xRow );
1247*b1cdbd2cSJim Jagielski
1248*b1cdbd2cSJim Jagielski if( searchIter == mxRows.end() )
1249*b1cdbd2cSJim Jagielski {
1250*b1cdbd2cSJim Jagielski // new row
1251*b1cdbd2cSJim Jagielski Reference< XPropertySet > xSet( xRow, UNO_QUERY_THROW );
1252*b1cdbd2cSJim Jagielski sal_Int32 nSize = 0;
1253*b1cdbd2cSJim Jagielski xSet->getPropertyValue( msSize ) >>= nSize;
1254*b1cdbd2cSJim Jagielski nHeightChange += nSize;
1255*b1cdbd2cSJim Jagielski }
1256*b1cdbd2cSJim Jagielski else if( searchIter == oldIter )
1257*b1cdbd2cSJim Jagielski {
1258*b1cdbd2cSJim Jagielski // no change
1259*b1cdbd2cSJim Jagielski oldIter++;
1260*b1cdbd2cSJim Jagielski }
1261*b1cdbd2cSJim Jagielski else
1262*b1cdbd2cSJim Jagielski {
1263*b1cdbd2cSJim Jagielski // rows removed
1264*b1cdbd2cSJim Jagielski do
1265*b1cdbd2cSJim Jagielski {
1266*b1cdbd2cSJim Jagielski Reference< XPropertySet > xSet( (*oldIter), UNO_QUERY_THROW );
1267*b1cdbd2cSJim Jagielski sal_Int32 nSize = 0;
1268*b1cdbd2cSJim Jagielski xSet->getPropertyValue( msSize ) >>= nSize;
1269*b1cdbd2cSJim Jagielski nHeightChange -= nSize;
1270*b1cdbd2cSJim Jagielski }
1271*b1cdbd2cSJim Jagielski while( oldIter++ != searchIter );
1272*b1cdbd2cSJim Jagielski }
1273*b1cdbd2cSJim Jagielski }
1274*b1cdbd2cSJim Jagielski
1275*b1cdbd2cSJim Jagielski while( oldIter != mxRows.end() )
1276*b1cdbd2cSJim Jagielski {
1277*b1cdbd2cSJim Jagielski // rows removed
1278*b1cdbd2cSJim Jagielski Reference< XPropertySet > xSet( (*oldIter++), UNO_QUERY_THROW );
1279*b1cdbd2cSJim Jagielski sal_Int32 nSize = 0;
1280*b1cdbd2cSJim Jagielski xSet->getPropertyValue( msSize ) >>= nSize;
1281*b1cdbd2cSJim Jagielski nHeightChange -= nSize;
1282*b1cdbd2cSJim Jagielski }
1283*b1cdbd2cSJim Jagielski }
1284*b1cdbd2cSJim Jagielski catch( Exception& e )
1285*b1cdbd2cSJim Jagielski {
1286*b1cdbd2cSJim Jagielski (void)e;
1287*b1cdbd2cSJim Jagielski DBG_ERROR("svx::TableLayouter::detectInsertedOrRemovedRows(), exception caught!");
1288*b1cdbd2cSJim Jagielski }
1289*b1cdbd2cSJim Jagielski
1290*b1cdbd2cSJim Jagielski return nHeightChange;
1291*b1cdbd2cSJim Jagielski }
1292*b1cdbd2cSJim Jagielski */
1293*b1cdbd2cSJim Jagielski
1294*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------------
1295*b1cdbd2cSJim Jagielski
1296*b1cdbd2cSJim Jagielski } }
1297