| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| #include <com/sun/star/table/XMergeableCell.hpp> |
| #include <com/sun/star/awt/XLayoutConstrains.hpp> |
| #include <boost/bind.hpp> |
| |
| #include "cell.hxx" |
| #include "cellrange.hxx" |
| #include "tablemodel.hxx" |
| #include "tablerow.hxx" |
| #include "tablerows.hxx" |
| #include "tablecolumn.hxx" |
| #include "tablecolumns.hxx" |
| #include "tablelayouter.hxx" |
| #include "svx/svdotable.hxx" |
| #include "editeng/borderline.hxx" |
| #include "editeng/boxitem.hxx" |
| #include "svx/svdmodel.hxx" |
| #include "svx/svdstr.hrc" |
| #include "svx/svdglob.hxx" |
| |
| using ::rtl::OUString; |
| using ::com::sun::star::awt::XLayoutConstrains; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::table; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::table; |
| using namespace ::com::sun::star::text; |
| |
| // ----------------------------------------------------------------------------- |
| |
| namespace sdr { namespace table { |
| |
| // ----------------------------------------------------------------------------- |
| |
| static SvxBorderLine gEmptyBorder; |
| |
| // ----------------------------------------------------------------------------- |
| |
| TableLayouter::TableLayouter( const TableModelRef& xTableModel ) |
| : mxTable( xTableModel ) |
| , meWritingMode( WritingMode_LR_TB ) |
| , msSize( RTL_CONSTASCII_USTRINGPARAM( "Size" ) ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| TableLayouter::~TableLayouter() |
| { |
| ClearBorderLayout(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| basegfx::B2ITuple TableLayouter::getCellSize( const CellPos& rPos ) const |
| { |
| sal_Int32 width = 0; |
| sal_Int32 height = 0; |
| |
| try |
| { |
| CellRef xCell( getCell( rPos ) ); |
| if( xCell.is() && !xCell->isMerged() ) |
| { |
| CellPos aPos( rPos ); |
| |
| sal_Int32 nRowCount = getRowCount(); |
| sal_Int32 nRowSpan = std::max( xCell->getRowSpan(), (sal_Int32)1 ); |
| while( nRowSpan && (aPos.mnRow < nRowCount) ) |
| { |
| if( ((sal_Int32)maRows.size()) <= aPos.mnRow ) |
| break; |
| |
| height += maRows[aPos.mnRow++].mnSize; |
| nRowSpan--; |
| } |
| |
| sal_Int32 nColCount = getColumnCount(); |
| sal_Int32 nColSpan = std::max( xCell->getColumnSpan(), (sal_Int32)1 ); |
| while( nColSpan && (aPos.mnCol < nColCount ) ) |
| { |
| if( ((sal_Int32)maColumns.size()) <= aPos.mnCol ) |
| break; |
| |
| width += maColumns[aPos.mnCol++].mnSize; |
| nColSpan--; |
| } |
| } |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR( "TableLayouter::getCellSize(), exception caught!" ); |
| } |
| |
| return basegfx::B2ITuple( width, height ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| bool TableLayouter::getCellArea( const CellPos& rPos, basegfx::B2IRectangle& rArea ) const |
| { |
| try |
| { |
| CellRef xCell( getCell( rPos ) ); |
| if( xCell.is() && !xCell->isMerged() && isValid(rPos) ) |
| { |
| const basegfx::B2ITuple aCellSize( getCellSize( rPos ) ); |
| |
| if( (rPos.mnCol < ((sal_Int32)maColumns.size()) && (rPos.mnRow < ((sal_Int32)maRows.size()) ) ) ) |
| { |
| const sal_Int32 x = maColumns[rPos.mnCol].mnPos; |
| const sal_Int32 y = maRows[rPos.mnRow].mnPos; |
| |
| rArea = basegfx::B2IRectangle( x, y, x + aCellSize.getX(), y + aCellSize.getY() ); |
| return true; |
| } |
| } |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR( "TableLayouter::getCellSize(), exception caught!" ); |
| } |
| return false; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::getRowHeight( sal_Int32 nRow ) |
| { |
| if( isValidRow(nRow) ) |
| return maRows[nRow].mnSize; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::setRowHeight( sal_Int32 nRow, sal_Int32 nHeight ) |
| { |
| if( isValidRow(nRow) ) |
| { |
| maRows[nRow].mnSize = nHeight; |
| } |
| else |
| { |
| DBG_ERROR( "TableLayouter::setRowHeight(), row out of range!" ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::getColumnWidth( sal_Int32 nColumn ) |
| { |
| if( isValidColumn(nColumn) ) |
| return maColumns[nColumn].mnSize; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::setColumnWidth( sal_Int32 nColumn, sal_Int32 nWidth ) |
| { |
| if( isValidColumn(nColumn) ) |
| maColumns[nColumn].mnSize = nWidth; |
| else |
| DBG_ERROR( "TableLayouter::setColumnWidth(), column out of range!" ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| bool TableLayouter::isEdgeVisible( sal_Int32 nEdgeX, sal_Int32 nEdgeY, bool bHorizontal ) const |
| { |
| const BorderLineMap& rMap = bHorizontal ? maHorizontalBorders : maVerticalBorders; |
| |
| if( (nEdgeX >= 0) && (nEdgeX < sal::static_int_cast<sal_Int32>(rMap.size())) && |
| (nEdgeY >= 0) && (nEdgeY < sal::static_int_cast<sal_Int32>(rMap[nEdgeX].size())) ) |
| { |
| return rMap[nEdgeX][nEdgeY] != 0; |
| } |
| else |
| { |
| OSL_ENSURE( false, "sdr::table::TableLayouter::getBorderLine(), invalid edge!" ); |
| } |
| |
| return false; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| /** returns the requested borderline in rpBorderLine or a null pointer if there is no border at this edge */ |
| SvxBorderLine* TableLayouter::getBorderLine( sal_Int32 nEdgeX, sal_Int32 nEdgeY, bool bHorizontal )const |
| { |
| SvxBorderLine* pLine = 0; |
| |
| const BorderLineMap& rMap = bHorizontal ? maHorizontalBorders : maVerticalBorders; |
| |
| if( (nEdgeX >= 0) && (nEdgeX < sal::static_int_cast<sal_Int32>(rMap.size())) && |
| (nEdgeY >= 0) && (nEdgeY < sal::static_int_cast<sal_Int32>(rMap[nEdgeX].size())) ) |
| { |
| pLine = rMap[nEdgeX][nEdgeY]; |
| if( pLine == &gEmptyBorder ) |
| pLine = 0; |
| } |
| else |
| { |
| OSL_ENSURE( false, "sdr::table::TableLayouter::getBorderLine(), invalid edge!" ); |
| } |
| |
| return pLine; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::getHorizontalEdge( int nEdgeY, sal_Int32* pnMin /*= 0*/, sal_Int32* pnMax /*= 0*/ ) |
| { |
| sal_Int32 nRet = 0; |
| if( (nEdgeY >= 0) && (nEdgeY <= getRowCount() ) ) |
| nRet = maRows[std::min((sal_Int32)nEdgeY,getRowCount()-1)].mnPos; |
| |
| if( nEdgeY == getRowCount() ) |
| nRet += maRows[nEdgeY - 1].mnSize; |
| |
| if( pnMin ) |
| { |
| if( (nEdgeY > 0) && (nEdgeY <= getRowCount() ) ) |
| { |
| *pnMin = maRows[nEdgeY-1].mnPos + 600; // todo |
| } |
| else |
| { |
| *pnMin = nRet; |
| } |
| } |
| |
| if( pnMax ) |
| { |
| *pnMax = 0x0fffffff; |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::getVerticalEdge( int nEdgeX, sal_Int32* pnMin /*= 0*/, sal_Int32* pnMax /*= 0*/ ) |
| { |
| sal_Int32 nRet = 0; |
| |
| const sal_Int32 nColCount = getColumnCount(); |
| if( (nEdgeX >= 0) && (nEdgeX <= nColCount ) ) |
| nRet = maColumns[std::min((sal_Int32)nEdgeX,nColCount-1)].mnPos; |
| |
| const bool bRTL = meWritingMode == WritingMode_RL_TB; |
| if( bRTL ) |
| { |
| if( (nEdgeX >= 0) && (nEdgeX < nColCount) ) |
| nRet += maColumns[nEdgeX].mnSize; |
| } |
| else |
| { |
| if( nEdgeX == getColumnCount() ) |
| nRet += maColumns[nEdgeX - 1].mnSize; |
| } |
| |
| if( pnMin ) |
| { |
| *pnMin = nRet; |
| if( bRTL ) |
| { |
| if( nEdgeX < nColCount ) |
| *pnMin = nRet - maColumns[nEdgeX].mnSize + getMinimumColumnWidth(nEdgeX); |
| } |
| else |
| { |
| if( (nEdgeX > 0) && (nEdgeX <= nColCount ) ) |
| *pnMin = maColumns[nEdgeX-1].mnPos + getMinimumColumnWidth( nEdgeX-1 ); |
| } |
| } |
| |
| if( pnMax ) |
| { |
| *pnMax = 0x0fffffff; // todo |
| if( bRTL ) |
| { |
| if( nEdgeX > 0 ) |
| *pnMax = nRet + maColumns[nEdgeX-1].mnSize - getMinimumColumnWidth( nEdgeX-1 ); |
| } |
| else |
| { |
| if( (nEdgeX >= 0) && (nEdgeX < nColCount ) ) |
| *pnMax = maColumns[nEdgeX].mnPos + maColumns[nEdgeX].mnSize - getMinimumColumnWidth( nEdgeX ); |
| } |
| } |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| static bool checkMergeOrigin( const TableModelRef& xTable, sal_Int32 nMergedX, sal_Int32 nMergedY, sal_Int32 nCellX, sal_Int32 nCellY, bool& bRunning ) |
| { |
| Reference< XMergeableCell > xCell( xTable->getCellByPosition( nCellX, nCellY ), UNO_QUERY ); |
| if( xCell.is() && !xCell->isMerged() ) |
| { |
| const sal_Int32 nRight = xCell->getColumnSpan() + nCellX; |
| const sal_Int32 nBottom = xCell->getRowSpan() + nCellY; |
| if( (nMergedX < nRight) && (nMergedY < nBottom) ) |
| return true; |
| |
| bRunning = false; |
| } |
| return false; |
| } |
| |
| /** returns true if the cell(nMergedX,nMergedY) is merged with other cells. |
| the returned cell( rOriginX, rOriginY ) is the origin( top left cell ) of the merge. |
| */ |
| bool findMergeOrigin( const TableModelRef& xTable, sal_Int32 nMergedX, sal_Int32 nMergedY, sal_Int32& rOriginX, sal_Int32& rOriginY ) |
| { |
| rOriginX = nMergedX; |
| rOriginY = nMergedY; |
| |
| if( xTable.is() ) try |
| { |
| // check if this cell already the origin or not merged at all |
| Reference< XMergeableCell > xCell( xTable->getCellByPosition( nMergedX, nMergedY ), UNO_QUERY_THROW ); |
| if( !xCell.is() || !xCell->isMerged() ) |
| return true; |
| |
| bool bCheckVert = true; |
| bool bCheckHorz = true; |
| |
| sal_Int32 nMinCol = 0; |
| sal_Int32 nMinRow = 0; |
| |
| sal_Int32 nStep = 1, i; |
| |
| sal_Int32 nRow, nCol; |
| do |
| { |
| if( bCheckVert ) |
| { |
| nRow = nMergedY - nStep; |
| if( nRow >= nMinRow ) |
| { |
| nCol = nMergedX; |
| for( i = 0; (i <= nStep) && (nCol >= nMinCol); i++, nCol-- ) |
| { |
| if( checkMergeOrigin( xTable, nMergedX, nMergedY, nCol, nRow, bCheckVert ) ) |
| { |
| rOriginX = nCol; rOriginY = nRow; |
| return true; |
| } |
| |
| if( !bCheckVert ) |
| { |
| if( nCol == nMergedX ) |
| { |
| nMinRow = nRow+1; |
| } |
| else |
| { |
| bCheckVert = true; |
| } |
| break; |
| } |
| } |
| } |
| else |
| { |
| bCheckVert = false; |
| } |
| } |
| |
| if( bCheckHorz ) |
| { |
| nCol = nMergedX - nStep; |
| if( nCol >= nMinCol ) |
| { |
| nRow = nMergedY; |
| for( i = 0; (i < nStep) && (nRow >= nMinRow); i++, nRow-- ) |
| { |
| if( checkMergeOrigin( xTable, nMergedX, nMergedY, nCol, nRow, bCheckHorz ) ) |
| { |
| rOriginX = nCol; rOriginY = nRow; |
| return true; |
| } |
| |
| if( !bCheckHorz ) |
| { |
| if( nRow == nMergedY ) |
| { |
| nMinCol = nCol+1; |
| } |
| else |
| { |
| bCheckHorz = true; |
| } |
| break; |
| } |
| } |
| } |
| else |
| { |
| bCheckHorz = false; |
| } |
| } |
| nStep++; |
| } |
| while( bCheckVert || bCheckHorz ); |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR("sdr::table::TableLayouter::findMergeOrigin(), exception caught!"); |
| } |
| return false; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::getMinimumColumnWidth( sal_Int32 nColumn ) |
| { |
| if( isValidColumn( nColumn ) ) |
| { |
| return maColumns[nColumn].mnMinSize; |
| } |
| else |
| { |
| DBG_ERROR( "TableLayouter::getMinimumColumnWidth(), column out of range!" ); |
| return 0; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::distribute( LayoutVector& rLayouts, sal_Int32 nDistribute ) |
| { |
| // break loops after 100 runs to avoid freezing office due to developer error |
| sal_Int32 nSafe = 100; |
| |
| const sal_Size nCount = rLayouts.size(); |
| sal_Size nIndex; |
| |
| bool bConstrainsBroken = false; |
| |
| do |
| { |
| // first enforce minimum size constrains on all entities |
| for( nIndex = 0; nIndex < nCount; ++nIndex ) |
| { |
| Layout& rLayout = rLayouts[nIndex]; |
| if( rLayout.mnSize < rLayout.mnMinSize ) |
| { |
| nDistribute -= rLayout.mnMinSize - rLayout.mnSize; |
| rLayout.mnSize = rLayout.mnMinSize; |
| } |
| } |
| |
| // calculate current width |
| // if nDistribute is < 0 (shrinking), entities that are already |
| // at minimum width are not counted |
| sal_Int32 nCurrentWidth = 0; |
| for( nIndex = 0; nIndex < nCount; ++nIndex ) |
| { |
| Layout& rLayout = rLayouts[nIndex]; |
| if( (nDistribute > 0) || (rLayout.mnSize > rLayout.mnMinSize) ) |
| nCurrentWidth += rLayout.mnSize; |
| } |
| |
| bConstrainsBroken = false; |
| |
| // now distribute over entities |
| if( (nCurrentWidth != 0) && (nDistribute != 0) ) |
| { |
| sal_Int32 nDistributed = nDistribute; |
| for( nIndex = 0; nIndex < nCount; ++nIndex ) |
| { |
| Layout& rLayout = rLayouts[nIndex]; |
| if( (nDistribute > 0) || (rLayout.mnSize > rLayout.mnMinSize) ) |
| { |
| sal_Int32 n; |
| if( nIndex == (nCount-1) ) |
| n = nDistributed; // for last entitie, use up rest |
| else |
| n = (nDistribute * rLayout.mnSize) / nCurrentWidth; // |
| |
| nDistributed -= n; |
| rLayout.mnSize += n; |
| |
| if( rLayout.mnSize < rLayout.mnMinSize ) |
| bConstrainsBroken = true; |
| } |
| } |
| } |
| } while( bConstrainsBroken && --nSafe ); |
| |
| sal_Int32 nSize = 0; |
| for( nIndex = 0; nIndex < nCount; ++nIndex ) |
| nSize += rLayouts[nIndex].mnSize; |
| |
| return nSize; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| typedef std::vector< CellRef > MergeableCellVector; |
| typedef std::vector< MergeableCellVector > MergeVector; |
| typedef std::vector< sal_Int32 > Int32Vector; |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::LayoutTableWidth( Rectangle& rArea, bool bFit ) |
| { |
| const sal_Int32 nColCount = getColumnCount(); |
| const sal_Int32 nRowCount = getRowCount(); |
| if( nColCount == 0 ) |
| return; |
| |
| MergeVector aMergedCells( nColCount ); |
| Int32Vector aOptimalColumns; |
| |
| const OUString sOptimalSize( RTL_CONSTASCII_USTRINGPARAM("OptimalSize") ); |
| |
| if( sal::static_int_cast< sal_Int32 >( maColumns.size() ) != nColCount ) |
| maColumns.resize( nColCount ); |
| |
| Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_QUERY_THROW ); |
| |
| // first calculate current width and initial minimum width per column, |
| // merged cells will be counted later |
| sal_Int32 nCurrentWidth = 0; |
| sal_Int32 nCol = 0, nRow = 0; |
| for( nCol = 0; nCol < nColCount; nCol++ ) |
| { |
| sal_Int32 nMinWidth = 0; |
| |
| bool bIsEmpty = true; // check if all cells in this column are merged |
| |
| for( nRow = 0; nRow < nRowCount; ++nRow ) |
| { |
| CellRef xCell( getCell( CellPos( nCol, nRow ) ) ); |
| if( xCell.is() && !xCell->isMerged() ) |
| { |
| bIsEmpty = false; |
| |
| sal_Int32 nColSpan = xCell->getColumnSpan(); |
| if( nColSpan > 1 ) |
| { |
| // merged cells will be evaluated later |
| aMergedCells[nCol+nColSpan-1].push_back( xCell ); |
| } |
| else |
| { |
| nMinWidth = std::max( nMinWidth, xCell->getMinimumSize().Width ); |
| } |
| } |
| } |
| |
| maColumns[nCol].mnMinSize = nMinWidth; |
| |
| if( bIsEmpty ) |
| { |
| maColumns[nCol].mnSize = 0; |
| } |
| else |
| { |
| sal_Int32 nColWidth = 0; |
| Reference< XPropertySet > xColSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW ); |
| sal_Bool bOptimal = sal_False; |
| xColSet->getPropertyValue( sOptimalSize ) >>= bOptimal; |
| if( bOptimal ) |
| { |
| aOptimalColumns.push_back(nCol); |
| } |
| else |
| { |
| xColSet->getPropertyValue( msSize ) >>= nColWidth; |
| } |
| |
| maColumns[nCol].mnSize = nColWidth; |
| |
| if( maColumns[nCol].mnSize < nMinWidth ) |
| maColumns[nCol].mnSize = nMinWidth; |
| |
| nCurrentWidth += maColumns[nCol].mnSize; |
| } |
| } |
| |
| // if we have optimal sized rows, distribute what is given (left) |
| if( !bFit && !aOptimalColumns.empty() && (nCurrentWidth < rArea.getWidth()) ) |
| { |
| sal_Int32 nLeft = rArea.getWidth() - nCurrentWidth; |
| sal_Int32 nDistribute = nLeft / aOptimalColumns.size(); |
| |
| Int32Vector::iterator iter( aOptimalColumns.begin() ); |
| while( iter != aOptimalColumns.end() ) |
| { |
| sal_Int32 nOptCol = (*iter++); |
| if( iter == aOptimalColumns.end() ) |
| nDistribute = nLeft; |
| |
| maColumns[nOptCol].mnSize += nDistribute; |
| nLeft -= nDistribute; |
| } |
| |
| DBG_ASSERT( nLeft == 0, "svx::TableLayouter::LayoutTableWidtht(), layouting failed!" ); |
| } |
| |
| // now check if merged cells fit |
| for( nCol = 1; nCol < nColCount; ++nCol ) |
| { |
| bool bChanges = false; |
| MergeableCellVector::iterator iter( aMergedCells[nCol].begin() ); |
| |
| const sal_Int32 nOldSize = maColumns[nCol].mnSize; |
| |
| while( iter != aMergedCells[nCol].end() ) |
| { |
| CellRef xCell( (*iter++) ); |
| sal_Int32 nMinWidth = xCell->getMinimumSize().Width; |
| |
| for( sal_Int32 nMCol = nCol - xCell->getColumnSpan() + 1; (nMCol > 0) && (nMCol < nCol); ++nMCol ) |
| nMinWidth -= maColumns[nMCol].mnSize; |
| |
| if( nMinWidth > maColumns[nCol].mnMinSize ) |
| maColumns[nCol].mnMinSize = nMinWidth; |
| |
| if( nMinWidth > maColumns[nCol].mnSize ) |
| { |
| maColumns[nCol].mnSize = nMinWidth; |
| bChanges = true; |
| } |
| } |
| |
| if( bChanges ) |
| nCurrentWidth += maColumns[nCol].mnSize - nOldSize; |
| } |
| |
| // now scale if wanted and needed |
| if( bFit && (nCurrentWidth != rArea.getWidth()) ) |
| distribute( maColumns, rArea.getWidth() - nCurrentWidth ); |
| |
| // last step, update left edges |
| sal_Int32 nNewWidth = 0; |
| |
| const bool bRTL = meWritingMode == WritingMode_RL_TB; |
| RangeIterator<sal_Int32> coliter( 0, nColCount, !bRTL ); |
| while( coliter.next(nCol ) ) |
| { |
| maColumns[nCol].mnPos = nNewWidth; |
| nNewWidth += maColumns[nCol].mnSize; |
| if( bFit ) |
| { |
| Reference< XPropertySet > xColSet( xCols->getByIndex(nCol), UNO_QUERY_THROW ); |
| xColSet->setPropertyValue( msSize, Any( maColumns[nCol].mnSize ) ); |
| } |
| } |
| |
| rArea.SetSize( Size( nNewWidth, rArea.GetHeight() ) ); |
| updateCells( rArea ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::LayoutTableHeight( Rectangle& rArea, bool bFit ) |
| { |
| const sal_Int32 nColCount = getColumnCount(); |
| const sal_Int32 nRowCount = getRowCount(); |
| if( nRowCount == 0 ) |
| return; |
| |
| Reference< XTableRows > xRows( mxTable->getRows() ); |
| |
| MergeVector aMergedCells( nRowCount ); |
| Int32Vector aOptimalRows; |
| |
| const OUString sOptimalSize( RTL_CONSTASCII_USTRINGPARAM("OptimalSize") ); |
| |
| // first calculate current height and initial minimum size per column, |
| // merged cells will be counted later |
| sal_Int32 nCurrentHeight = 0; |
| sal_Int32 nCol, nRow; |
| for( nRow = 0; nRow < nRowCount; ++nRow ) |
| { |
| sal_Int32 nMinHeight = 0; |
| |
| bool bIsEmpty = true; // check if all cells in this row are merged |
| |
| for( nCol = 0; nCol < nColCount; ++nCol ) |
| { |
| CellRef xCell( getCell( CellPos( nCol, nRow ) ) ); |
| if( xCell.is() && !xCell->isMerged() ) |
| { |
| bIsEmpty = false; |
| |
| sal_Int32 nRowSpan = xCell->getRowSpan(); |
| if( nRowSpan > 1 ) |
| { |
| // merged cells will be evaluated later |
| aMergedCells[nRow+nRowSpan-1].push_back( xCell ); |
| } |
| else |
| { |
| nMinHeight = std::max( nMinHeight, xCell->getMinimumSize().Height ); |
| } |
| } |
| } |
| |
| maRows[nRow].mnMinSize = nMinHeight; |
| |
| if( bIsEmpty ) |
| { |
| maRows[nRow].mnSize = 0; |
| } |
| else |
| { |
| sal_Int32 nRowHeight = 0; |
| Reference< XPropertySet > xRowSet( xRows->getByIndex(nRow), UNO_QUERY_THROW ); |
| |
| sal_Bool bOptimal = sal_False; |
| xRowSet->getPropertyValue( sOptimalSize ) >>= bOptimal; |
| if( bOptimal ) |
| { |
| aOptimalRows.push_back( nRow ); |
| } |
| else |
| { |
| xRowSet->getPropertyValue( msSize ) >>= nRowHeight; |
| } |
| |
| maRows[nRow].mnSize = nRowHeight; |
| |
| if( maRows[nRow].mnSize < nMinHeight ) |
| maRows[nRow].mnSize = nMinHeight; |
| |
| nCurrentHeight += maRows[nRow].mnSize; |
| } |
| } |
| |
| // if we have optimal sized rows, distribute what is given (left) |
| if( !bFit && !aOptimalRows.empty() && (nCurrentHeight < rArea.getHeight()) ) |
| { |
| sal_Int32 nLeft = rArea.getHeight() - nCurrentHeight; |
| sal_Int32 nDistribute = nLeft / aOptimalRows.size(); |
| |
| Int32Vector::iterator iter( aOptimalRows.begin() ); |
| while( iter != aOptimalRows.end() ) |
| { |
| sal_Int32 nOptRow = (*iter++); |
| if( iter == aOptimalRows.end() ) |
| nDistribute = nLeft; |
| |
| maRows[nOptRow].mnSize += nDistribute; |
| nLeft -= nDistribute; |
| |
| } |
| |
| DBG_ASSERT( nLeft == 0, "svx::TableLayouter::LayoutTableHeight(), layouting failed!" ); |
| } |
| |
| // now check if merged cells fit |
| for( nRow = 1; nRow < nRowCount; ++nRow ) |
| { |
| bool bChanges = false; |
| sal_Int32 nOldSize = maRows[nRow].mnSize; |
| |
| MergeableCellVector::iterator iter( aMergedCells[nRow].begin() ); |
| while( iter != aMergedCells[nRow].end() ) |
| { |
| CellRef xCell( (*iter++) ); |
| sal_Int32 nMinHeight = xCell->getMinimumSize().Height; |
| |
| for( sal_Int32 nMRow = nRow - xCell->getRowSpan() + 1; (nMRow > 0) && (nMRow < nRow); ++nMRow ) |
| nMinHeight -= maRows[nMRow].mnSize; |
| |
| if( nMinHeight > maRows[nRow].mnMinSize ) |
| maRows[nRow].mnMinSize = nMinHeight; |
| |
| if( nMinHeight > maRows[nRow].mnSize ) |
| { |
| maRows[nRow].mnSize = nMinHeight; |
| bChanges = true; |
| } |
| } |
| if( bChanges ) |
| nCurrentHeight += maRows[nRow].mnSize - nOldSize; |
| } |
| |
| // now scale if wanted and needed |
| if( bFit && nCurrentHeight != rArea.getHeight() ) |
| distribute( maRows, rArea.getHeight() - nCurrentHeight ); |
| |
| // last step, update left edges |
| sal_Int32 nNewHeight = 0; |
| for( nRow = 0; nRow < nRowCount; ++nRow ) |
| { |
| maRows[nRow].mnPos = nNewHeight; |
| nNewHeight += maRows[nRow].mnSize; |
| |
| if( bFit ) |
| { |
| Reference< XPropertySet > xRowSet( xRows->getByIndex(nRow), UNO_QUERY_THROW ); |
| xRowSet->setPropertyValue( msSize, Any( maRows[nRow].mnSize ) ); |
| } |
| } |
| |
| rArea.SetSize( Size( rArea.GetWidth(), nNewHeight ) ); |
| updateCells( rArea ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| /** try to fit the table into the given rectangle. |
| If the rectangle is to small, it will be grown to fit the table. */ |
| void TableLayouter::LayoutTable( Rectangle& rRectangle, bool bFitWidth, bool bFitHeight ) |
| { |
| if( !mxTable.is() ) |
| return; |
| |
| const sal_Int32 nRowCount = mxTable->getRowCount(); |
| const sal_Int32 nColCount = mxTable->getColumnCount(); |
| |
| if( (nRowCount != getRowCount()) || (nColCount != getColumnCount()) ) |
| { |
| if( static_cast< sal_Int32 >( maRows.size() ) != nRowCount ) |
| maRows.resize( nRowCount ); |
| |
| Reference< XTableRows > xRows( mxTable->getRows() ); |
| for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ ) |
| maRows[nRow].clear(); |
| |
| if( static_cast< sal_Int32 >( maColumns.size() ) != nColCount ) |
| maColumns.resize( nColCount ); |
| |
| for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ ) |
| maColumns[nCol].clear(); |
| } |
| |
| LayoutTableWidth( rRectangle, bFitWidth ); |
| LayoutTableHeight( rRectangle, bFitHeight ); |
| UpdateBorderLayout(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::updateCells( Rectangle& rRectangle ) |
| { |
| const sal_Int32 nColCount = getColumnCount(); |
| const sal_Int32 nRowCount = getRowCount(); |
| |
| CellPos aPos; |
| for( aPos.mnRow = 0; aPos.mnRow < nRowCount; aPos.mnRow++ ) |
| { |
| for( aPos.mnCol = 0; aPos.mnCol < nColCount; aPos.mnCol++ ) |
| { |
| CellRef xCell( getCell( aPos ) ); |
| if( xCell.is() ) |
| { |
| basegfx::B2IRectangle aCellArea; |
| getCellArea( aPos, aCellArea ); |
| |
| Rectangle aCellRect; |
| aCellRect.nLeft = aCellArea.getMinX(); |
| aCellRect.nRight = aCellArea.getMaxX(); |
| aCellRect.nTop = aCellArea.getMinY(); |
| aCellRect.nBottom = aCellArea.getMaxY(); |
| aCellRect.Move( rRectangle.nLeft, rRectangle.nTop ); |
| xCell->setCellRect( aCellRect ); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| CellRef TableLayouter::getCell( const CellPos& rPos ) const |
| { |
| CellRef xCell; |
| if( mxTable.is() ) try |
| { |
| xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( rPos.mnCol, rPos.mnRow ).get() ) ); |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR( "sdr::table::TableLayouter::getCell(), exception caught!" ); |
| } |
| return xCell; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| bool TableLayouter::HasPriority( const SvxBorderLine* pThis, const SvxBorderLine* pOther ) |
| { |
| if (!pThis || ((pThis == &gEmptyBorder) && (pOther != 0))) |
| return false; |
| if (!pOther || (pOther == &gEmptyBorder)) |
| return true; |
| |
| sal_uInt16 nThisSize = pThis->GetOutWidth() + pThis->GetDistance() + pThis->GetInWidth(); |
| sal_uInt16 nOtherSize = pOther->GetOutWidth() + pOther->GetDistance() + pOther->GetInWidth(); |
| |
| if (nThisSize > nOtherSize) |
| return true; |
| |
| else if (nThisSize < nOtherSize) |
| { |
| return false; |
| } |
| else |
| { |
| if ( pOther->GetInWidth() && !pThis->GetInWidth() ) |
| { |
| return true; |
| } |
| else if ( pThis->GetInWidth() && !pOther->GetInWidth() ) |
| { |
| return false; |
| } |
| else |
| { |
| return true; //! ??? |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::SetBorder( sal_Int32 nCol, sal_Int32 nRow, bool bHorizontal, const SvxBorderLine* pLine ) |
| { |
| if( pLine == 0 ) |
| pLine = &gEmptyBorder; |
| |
| SvxBorderLine *pOld = bHorizontal ? maHorizontalBorders[nCol][nRow] : maVerticalBorders[nCol][nRow]; |
| |
| if( HasPriority( pLine, pOld ) ) |
| { |
| if( (pOld != 0) && (pOld != &gEmptyBorder) ) |
| delete pOld; |
| |
| SvxBorderLine* pNew = ( pLine != &gEmptyBorder ) ? new SvxBorderLine(*pLine) : &gEmptyBorder; |
| |
| if( bHorizontal ) |
| maHorizontalBorders[nCol][nRow] = pNew; |
| else |
| maVerticalBorders[nCol][nRow] = pNew; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::ClearBorderLayout() |
| { |
| ClearBorderLayout(maHorizontalBorders); |
| ClearBorderLayout(maVerticalBorders); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::ClearBorderLayout(BorderLineMap& rMap) |
| { |
| const sal_Int32 nColCount = rMap.size(); |
| |
| for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ ) |
| { |
| const sal_Int32 nRowCount = rMap[nCol].size(); |
| for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ ) |
| { |
| SvxBorderLine* pLine = rMap[nCol][nRow]; |
| if( pLine ) |
| { |
| if( pLine != &gEmptyBorder ) |
| delete pLine; |
| |
| rMap[nCol][nRow] = 0; |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::ResizeBorderLayout() |
| { |
| ClearBorderLayout(); |
| ResizeBorderLayout(maHorizontalBorders); |
| ResizeBorderLayout(maVerticalBorders); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::ResizeBorderLayout( BorderLineMap& rMap ) |
| { |
| const sal_Int32 nColCount = getColumnCount() + 1; |
| const sal_Int32 nRowCount = getRowCount() + 1; |
| |
| if( sal::static_int_cast<sal_Int32>(rMap.size()) != nColCount ) |
| rMap.resize( nColCount ); |
| |
| for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ ) |
| { |
| if( sal::static_int_cast<sal_Int32>(rMap[nCol].size()) != nRowCount ) |
| rMap[nCol].resize( nRowCount ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::UpdateBorderLayout() |
| { |
| // make sure old border layout is cleared and border maps have correct size |
| ResizeBorderLayout(); |
| |
| const sal_Int32 nColCount = getColumnCount(); |
| const sal_Int32 nRowCount = getRowCount(); |
| |
| CellPos aPos; |
| for( aPos.mnRow = 0; aPos.mnRow < nRowCount; aPos.mnRow++ ) |
| { |
| for( aPos.mnCol = 0; aPos.mnCol < nColCount; aPos.mnCol++ ) |
| { |
| CellRef xCell( getCell( aPos ) ); |
| if( !xCell.is() || xCell->isMerged() ) |
| continue; |
| |
| const SvxBoxItem* pThisAttr = (const SvxBoxItem*)xCell->GetItemSet().GetItem( SDRATTR_TABLE_BORDER ); |
| OSL_ENSURE(pThisAttr,"sdr::table::TableLayouter::UpdateBorderLayout(), no border attribute?"); |
| |
| if( !pThisAttr ) |
| continue; |
| |
| const sal_Int32 nLastRow = xCell->getRowSpan() + aPos.mnRow; |
| const sal_Int32 nLastCol = xCell->getColumnSpan() + aPos.mnCol; |
| |
| for( sal_Int32 nRow = aPos.mnRow; nRow < nLastRow; nRow++ ) |
| { |
| SetBorder( aPos.mnCol, nRow, false, pThisAttr->GetLeft() ); |
| SetBorder( nLastCol, nRow, false, pThisAttr->GetRight() ); |
| } |
| |
| for( sal_Int32 nCol = aPos.mnCol; nCol < nLastCol; nCol++ ) |
| { |
| SetBorder( nCol, aPos.mnRow, true, pThisAttr->GetTop() ); |
| SetBorder( nCol, nLastRow, true, pThisAttr->GetBottom() ); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| /* |
| void TableLayouter::SetLayoutToModel() |
| { |
| const sal_Int32 nRowCount = getRowCount(); |
| const sal_Int32 nColCount = getColumnCount(); |
| |
| try |
| { |
| sal_Int32 nOldSize = 0; |
| |
| Reference< XIndexAccess > xRows( mxTable->getRows(), UNO_QUERY_THROW ); |
| for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ ) |
| { |
| Reference< XPropertySet > xRowSet( xRows->getByIndex( nRow ), UNO_QUERY_THROW ); |
| xRowSet->getPropertyValue( msSize ) >>= nOldSize; |
| if( maRows[nRow].mnSize != nOldSize ) |
| xRowSet->setPropertyValue( msSize, Any( maRows[nRow].mnSize ) ); |
| } |
| |
| for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ ) |
| { |
| Reference< XPropertySet > xColSet( getColumnByIndex( nCol ), UNO_QUERY_THROW ); |
| xColSet->getPropertyValue( msSize ) >>= nOldSize; |
| if( maColumns[nCol].mnSize != nOldSize ) |
| xColSet->setPropertyValue( msSize, Any( maColumns[nCol].mnSize ) ); |
| } |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR("sdr::table::TableLayouter::SetLayoutToModel(), exception caught!"); |
| } |
| } |
| */ |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::DistributeColumns( ::Rectangle& rArea, sal_Int32 nFirstCol, sal_Int32 nLastCol ) |
| { |
| if( mxTable.is() ) try |
| { |
| const sal_Int32 nColCount = getColumnCount(); |
| |
| if( (nFirstCol < 0) || (nFirstCol>= nLastCol) || (nLastCol >= nColCount) ) |
| return; |
| |
| sal_Int32 nAllWidth = 0; |
| for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol ) |
| nAllWidth += getColumnWidth(nCol); |
| |
| sal_Int32 nWidth = nAllWidth / (nLastCol-nFirstCol+1); |
| |
| Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_QUERY_THROW ); |
| |
| for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol ) |
| { |
| if( nCol == nLastCol ) |
| nWidth = nAllWidth; // last column get round errors |
| |
| Reference< XPropertySet > xColSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW ); |
| xColSet->setPropertyValue( msSize, Any( nWidth ) ); |
| |
| nAllWidth -= nWidth; |
| } |
| |
| LayoutTable( rArea, true, false ); |
| } |
| catch( Exception& e ) |
| { |
| (void)e; |
| DBG_ERROR("sdr::table::TableLayouter::DistributeColumns(), exception caught!"); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::DistributeRows( ::Rectangle& rArea, sal_Int32 nFirstRow, sal_Int32 nLastRow ) |
| { |
| if( mxTable.is() ) try |
| { |
| const sal_Int32 nRowCount = mxTable->getRowCount(); |
| |
| if( (nFirstRow < 0) || (nFirstRow>= nLastRow) || (nLastRow >= nRowCount) ) |
| return; |
| |
| sal_Int32 nAllHeight = 0; |
| sal_Int32 nMinHeight = 0; |
| |
| for( sal_Int32 nRow = nFirstRow; nRow <= nLastRow; ++nRow ) |
| { |
| nMinHeight = std::max( maRows[nRow].mnMinSize, nMinHeight ); |
| nAllHeight += maRows[nRow].mnSize; |
| } |
| |
| const sal_Int32 nRows = (nLastRow-nFirstRow+1); |
| sal_Int32 nHeight = nAllHeight / nRows; |
| |
| if( nHeight < nMinHeight ) |
| { |
| sal_Int32 nNeededHeight = nRows * nMinHeight; |
| rArea.nBottom += nNeededHeight - nAllHeight; |
| nHeight = nMinHeight; |
| nAllHeight = nRows * nMinHeight; |
| } |
| |
| Reference< XTableRows > xRows( mxTable->getRows(), UNO_QUERY_THROW ); |
| for( sal_Int32 nRow = nFirstRow; nRow <= nLastRow; ++nRow ) |
| { |
| if( nRow == nLastRow ) |
| nHeight = nAllHeight; // last row get round errors |
| |
| Reference< XPropertySet > xRowSet( xRows->getByIndex( nRow ), UNO_QUERY_THROW ); |
| xRowSet->setPropertyValue( msSize, Any( nHeight ) ); |
| |
| nAllHeight -= nHeight; |
| } |
| |
| LayoutTable( rArea, false, true ); |
| } |
| catch( Exception& e ) |
| { |
| (void)e; |
| DBG_ERROR("sdr::table::TableLayouter::DistributeRows(), exception caught!"); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableLayouter::SetWritingMode( com::sun::star::text::WritingMode eWritingMode ) |
| { |
| meWritingMode = eWritingMode; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::getColumnStart( sal_Int32 nColumn ) const |
| { |
| if( isValidColumn(nColumn) ) |
| return maColumns[nColumn].mnPos; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int32 TableLayouter::getRowStart( sal_Int32 nRow ) const |
| { |
| if( isValidRow(nRow) ) |
| return maRows[nRow].mnPos; |
| else |
| return 0; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| /* |
| sal_Int32 TableLayouter::detectInsertedOrRemovedRows() |
| { |
| sal_Int32 nHeightChange = 0; |
| |
| try |
| { |
| Reference< XIndexAccess > xRows( mxTable->getRows(), UNO_QUERY_THROW ); |
| std::vector< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > >::iterator oldIter( mxRows.begin() ); |
| sal_Int32 nCount = xRows->getCount(); |
| for( sal_Int32 nRow = 0; nRow < nCount; nRow++ ) |
| { |
| Reference< XInterface > xRow( xRows->getByIndex(nRow), UNO_QUERY ); |
| |
| std::vector< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > >::iterator searchIter = mxRows.end(); |
| if( oldIter != mxRows.end() ) |
| searchIter = std::find( oldIter,mxRows.end(), xRow ); |
| |
| if( searchIter == mxRows.end() ) |
| { |
| // new row |
| Reference< XPropertySet > xSet( xRow, UNO_QUERY_THROW ); |
| sal_Int32 nSize = 0; |
| xSet->getPropertyValue( msSize ) >>= nSize; |
| nHeightChange += nSize; |
| } |
| else if( searchIter == oldIter ) |
| { |
| // no change |
| oldIter++; |
| } |
| else |
| { |
| // rows removed |
| do |
| { |
| Reference< XPropertySet > xSet( (*oldIter), UNO_QUERY_THROW ); |
| sal_Int32 nSize = 0; |
| xSet->getPropertyValue( msSize ) >>= nSize; |
| nHeightChange -= nSize; |
| } |
| while( oldIter++ != searchIter ); |
| } |
| } |
| |
| while( oldIter != mxRows.end() ) |
| { |
| // rows removed |
| Reference< XPropertySet > xSet( (*oldIter++), UNO_QUERY_THROW ); |
| sal_Int32 nSize = 0; |
| xSet->getPropertyValue( msSize ) >>= nSize; |
| nHeightChange -= nSize; |
| } |
| } |
| catch( Exception& e ) |
| { |
| (void)e; |
| DBG_ERROR("svx::TableLayouter::detectInsertedOrRemovedRows(), exception caught!"); |
| } |
| |
| return nHeightChange; |
| } |
| */ |
| |
| // ----------------------------------------------------------------------------- |
| |
| } } |
