AOO410/main/svx/source/table/tablertfimporter.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * 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 <vector>
 #include <boost/shared_ptr.hpp>

 #include <com/sun/star/table/XTable.hpp>

 #include <tools/stream.hxx>
 #include <svtools/rtftoken.h>

 #include <editeng/eeitem.hxx>
 #include <svx/svdetc.hxx>
 #include <editeng/fhgtitem.hxx>
 #include <editeng/outlobj.hxx>

 #include "cell.hxx"
 #include "celltypes.hxx"
 #include "svx/svdotable.hxx"
 #include "svx/svdoutl.hxx"
 #include "editeng/editeng.hxx"
 #include "editeng/editdata.hxx"
 #include "svx/svdmodel.hxx"
 #include "editeng/svxrtf.hxx"

 using ::rtl::OUString;
 using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::table;
 using namespace ::com::sun::star::container;
 using namespace ::com::sun::star::beans;

 namespace sdr { namespace table {

 struct RTFCellDefault
 {
 	SfxItemSet			maItemSet;
 	sal_Int32			mnCol;
 	sal_uInt16				mnTwips;         // right border of the cell
 	sal_Int32			mnColSpan;	 // MergeCell if >1, merged cells if 0

 	RTFCellDefault( SfxItemPool* pPool ) : maItemSet( *pPool ), mnCol(0), mnTwips(0 ), mnColSpan(1) {}
 };

 typedef std::vector< boost::shared_ptr< RTFCellDefault > > RTFCellDefaultVector;

 struct RTFCellInfo
 {
 	SfxItemSet			maItemSet;
 	sal_Int32			mnStartPara;
 	sal_Int32			mnParaCount;
 	sal_Int32			mnColSpan;

 	RTFCellInfo( SfxItemPool& rPool ) : maItemSet(  rPool ), mnStartPara(0), mnParaCount(0), mnColSpan(0) {}
 };

 typedef boost::shared_ptr< RTFCellInfo > RTFCellInfoPtr;
 typedef std::vector< RTFCellInfoPtr > RTFColumnVector;

 typedef boost::shared_ptr< RTFColumnVector > RTFColumnVectorPtr;

 typedef std::vector< RTFColumnVectorPtr > RTFRowVector;

 class SdrTableRTFParser
 {
 public:
 	SdrTableRTFParser( SdrTableObj& rTableObj );
 	~SdrTableRTFParser();

 	void Read( SvStream& rStream );

 	void ProcToken( ImportInfo* pInfo );

 	void NextRow();
 	void NextColumn();
 	void NewCellRow();

 	void InsertCell( ImportInfo* pInfo );

 	void FillTable();

 	DECL_LINK( RTFImportHdl, ImportInfo* );

 private:
 	SdrTableObj&	mrTableObj;
 	SdrOutliner*	mpOutliner;
 	SfxItemPool&	mrItemPool;

 	RTFCellDefaultVector maDefaultList;
 	RTFCellDefaultVector::iterator maDefaultIterator;

 	int				mnLastToken;
 	sal_Int32		mnLastWidth;
 	bool			mbNewDef;

 	sal_uInt16			mnStartPara;

 	sal_Int32		mnColCnt;
 	sal_Int32		mnRowCnt;
 	sal_Int32		mnColMax;

 	std::vector< sal_Int32 > maColumnEdges;

 	RTFRowVector	maRows;

 	RTFCellDefault*	mpInsDefault;
 	RTFCellDefault*	mpActDefault;
 	RTFCellDefault*	mpDefMerge;

 	Reference< XTable > mxTable;
 };

 SdrTableRTFParser::SdrTableRTFParser( SdrTableObj& rTableObj )
 : mrTableObj( rTableObj )
 , mpOutliner( SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, rTableObj.GetModel() ) )
 , mrItemPool( rTableObj.GetModel()->GetItemPool() )
 , mnLastToken( 0 )
 , mnLastWidth( 0 )
 , mbNewDef( false )
 , mnStartPara( 0 )
 , mnColCnt( 0 )
 , mnRowCnt( 0 )
 , mnColMax( 0 )
 , mpActDefault( 0 )
 , mpDefMerge( 0 )
 , mxTable( rTableObj.getTable() )
 {
 	mpOutliner->SetUpdateMode(sal_True);
 	mpOutliner->SetStyleSheet( 0, mrTableObj.GetStyleSheet() );
 	mpInsDefault = new RTFCellDefault( &mrItemPool );
 }

 SdrTableRTFParser::~SdrTableRTFParser()
 {
 	delete mpOutliner;
 	delete mpInsDefault;
 }

 void SdrTableRTFParser::Read( SvStream& rStream )
 {
 	EditEngine& rEdit = const_cast< EditEngine& >( mpOutliner->GetEditEngine() );

 	Link aOldLink( rEdit.GetImportHdl() );
 	rEdit.SetImportHdl( LINK( this, SdrTableRTFParser, RTFImportHdl ) );
 	mpOutliner->Read( rStream, String(), EE_FORMAT_RTF );
 	rEdit.SetImportHdl( aOldLink );

 	FillTable();
 }

 IMPL_LINK( SdrTableRTFParser, RTFImportHdl, ImportInfo*, pInfo )
 {
 	switch ( pInfo->eState )
 	{
 		case RTFIMP_NEXTTOKEN:
 			ProcToken( pInfo );
 			break;
 		case RTFIMP_UNKNOWNATTR:
 			ProcToken( pInfo );
 			break;
 		case RTFIMP_START:
 		{
 			SvxRTFParser* pParser = (SvxRTFParser*) pInfo->pParser;
 			pParser->SetAttrPool( &mrItemPool );
 			RTFPardAttrMapIds& rMap = pParser->GetPardMap();
 			rMap.nBox = SDRATTR_TABLE_BORDER;
 		}
 			break;
 		case RTFIMP_END:
 			if ( pInfo->aSelection.nEndPos )
 			{
 				mpActDefault = NULL;
 				pInfo->nToken = RTF_PAR;
 				pInfo->aSelection.nEndPara++;
 				ProcToken( pInfo );
 			}
 			break;
 		case RTFIMP_SETATTR:
 			break;
 		case RTFIMP_INSERTTEXT:
 			break;
 		case RTFIMP_INSERTPARA:
 			break;
 		default:
 			DBG_ERRORFILE("unknown ImportInfo.eState");
 	}
 	return 0;
 }

 void SdrTableRTFParser::NextRow()
 {
 	++mnRowCnt;
 }

 void SdrTableRTFParser::InsertCell( ImportInfo* pInfo )
 {
 	sal_Int32 nCol = mpActDefault->mnCol;

 	RTFCellInfoPtr xCellInfo( new RTFCellInfo(mrItemPool) );

 	xCellInfo->mnStartPara = mnStartPara;
 	xCellInfo->mnParaCount = pInfo->aSelection.nEndPara - 1 - mnStartPara;

 	if( !maRows.empty() )
 	{
 		RTFColumnVectorPtr xColumn( maRows.back() );

 		if( xColumn->size() <= (size_t)nCol )
 			xColumn->resize( nCol+1 );

 		(*xColumn)[nCol] = xCellInfo;
 	}

 	mnStartPara = pInfo->aSelection.nEndPara - 1;
 }

 void SdrTableRTFParser::FillTable()
 {
 	try
 	{
 		sal_Int32 nColCount = mxTable->getColumnCount();
 		Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_QUERY_THROW );

 		if( nColCount < mnColMax )
 		{
 			xCols->insertByIndex( nColCount, mnColMax - nColCount );
 			nColCount = mxTable->getColumnCount();
 		}

 		const OUString sWidth( RTL_CONSTASCII_USTRINGPARAM("Width") );
 		sal_Int32 nCol, nLastEdge = 0;
 		for( nCol = 0; nCol < nColCount; nCol++ )
 		{
 			Reference< XPropertySet > xSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
 			sal_Int32 nWidth = maColumnEdges[nCol] - nLastEdge;

 			xSet->setPropertyValue( sWidth, Any( nWidth ) );
 			nLastEdge += nWidth;
 		}

 		const sal_Int32 nRowCount = mxTable->getRowCount();
 		if( nRowCount < mnRowCnt )
 		{
 			Reference< XTableRows > xRows( mxTable->getRows(), UNO_QUERY_THROW );
 			xRows->insertByIndex( nRowCount, mnRowCnt - nRowCount );
 		}

 		for( sal_Int32 nRow = 0; nRow < (sal_Int32)maRows.size(); nRow++ )
 		{
 			RTFColumnVectorPtr xColumn( maRows[nRow] );
 			for( nCol = 0; nCol < (sal_Int32)xColumn->size(); nCol++ )
 			{
 				RTFCellInfoPtr xCellInfo( (*xColumn)[nCol] );

 				CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 				if( xCell.is() && xCellInfo.get() )
 				{
 					const SfxPoolItem *pPoolItem = 0;
 					if( xCellInfo->maItemSet.GetItemState(SDRATTR_TABLE_BORDER,sal_False,&pPoolItem)==SFX_ITEM_SET)
 						xCell->SetMergedItem( *pPoolItem );

 					String sDebug = mpOutliner->GetText( mpOutliner->GetParagraph( xCellInfo->mnStartPara ), xCellInfo->mnParaCount );

 					OutlinerParaObject* pTextObject = mpOutliner->CreateParaObject( (sal_uInt16)xCellInfo->mnStartPara, (sal_uInt16)xCellInfo->mnParaCount );
 					if( pTextObject )
 					{
 						SdrOutliner& rOutliner=mrTableObj.ImpGetDrawOutliner();
 						rOutliner.SetUpdateMode(sal_True);
 						rOutliner.SetText( *pTextObject );
 						mrTableObj.NbcSetOutlinerParaObjectForText( rOutliner.CreateParaObject(), xCell.get() );
 						delete pTextObject;
 					}
 				}
 			}
 		}

 		Rectangle aRect( mrTableObj.GetSnapRect() );
 		aRect.nRight = aRect.nLeft + nLastEdge;
 		mrTableObj.NbcSetSnapRect( aRect );

 	}
 	catch( Exception& e )
 	{
 		(void)e;
 		DBG_ERROR("sdr::table::SdrTableRTFParser::InsertCell(), exception caught!" );
 	}
 }

 void SdrTableRTFParser::NewCellRow()
 {
 	if( mbNewDef )
 	{
 		mbNewDef = sal_False;

 		maRows.push_back( RTFColumnVectorPtr( new RTFColumnVector() ) );
 	}
 	mpDefMerge = NULL;
 	maDefaultIterator = maDefaultList.begin();

 	NextColumn();

 	DBG_ASSERT( mpActDefault, "NewCellRow: pActDefault==0" );
 }

 void SdrTableRTFParser::NextColumn()
 {
 	if( maDefaultIterator != maDefaultList.end() )
 		mpActDefault = (*maDefaultIterator++).get();
 	else
 		mpActDefault = 0;
 }

 long TwipsToHundMM( long nIn )
 {
 	long nRet = OutputDevice::LogicToLogic( nIn, MAP_TWIP, MAP_100TH_MM );
 	return nRet;
 }

 void SdrTableRTFParser::ProcToken( ImportInfo* pInfo )
 {
 	switch ( pInfo->nToken )
 	{
 		case RTF_TROWD:			// denotes table row defauls, before RTF_CELLX
 		{
 			mnColCnt = 0;
 			maDefaultList.clear();
 			mpDefMerge = NULL;
 			mnLastToken = pInfo->nToken;
 		}
 		break;
 		case RTF_CLMGF:			// The first cell of cells to be merged
 		{
 			mpDefMerge = mpInsDefault;
 			mnLastToken = pInfo->nToken;
 		}
 		break;
 		case RTF_CLMRG:			// A cell to be merged with the preceding cell
 		{
 			if ( !mpDefMerge )
 				mpDefMerge = maDefaultList.back().get();
 			DBG_ASSERT( mpDefMerge, "RTF_CLMRG: pDefMerge==0" );
 			if( mpDefMerge )
 				mpDefMerge->mnColSpan++;
 			mpInsDefault->mnColSpan = 0;
 			mnLastToken = pInfo->nToken;
 		}
 		break;
 		case RTF_CELLX:			// closes cell default
 		{
 			mbNewDef = sal_True;
 			mpInsDefault->mnCol = mnColCnt;
 			maDefaultList.push_back( boost::shared_ptr< RTFCellDefault >( mpInsDefault ) );

 			if( (sal_Int32)maColumnEdges.size() <= mnColCnt )
 				maColumnEdges.resize( mnColCnt + 1 );

 			const sal_Int32 nSize = TwipsToHundMM( pInfo->nTokenValue );
 			maColumnEdges[mnColCnt] = std::max( maColumnEdges[mnColCnt], nSize );

 			mpInsDefault = new RTFCellDefault( &mrItemPool );
 			if ( ++mnColCnt > mnColMax )
 				mnColMax = mnColCnt;
 			mnLastToken = pInfo->nToken;
 		}
 		break;
 		case RTF_INTBL:			// before the first RTF_CELL
 		{
 			if ( mnLastToken != RTF_INTBL && mnLastToken != RTF_CELL && mnLastToken != RTF_PAR )
 			{
 				NewCellRow();
 				mnLastToken = pInfo->nToken;
 			}
 		}
 		break;
 		case RTF_CELL:			// denotes the end of a cell.
 		{
 			DBG_ASSERT( mpActDefault, "RTF_CELL: pActDefault==0" );
 			if ( mbNewDef || !mpActDefault )
 				NewCellRow();
 			if ( !mpActDefault )
 				mpActDefault = mpInsDefault;
 			if ( mpActDefault->mnColSpan > 0 )
 			{
 				InsertCell(pInfo);
 			}
 			NextColumn();
 			mnLastToken = pInfo->nToken;
 		}
 		break;
 		case RTF_ROW:			// means the end of a row
 		{
 			NextRow();
 			mnLastToken = pInfo->nToken;
 		}
 		break;
 		case RTF_PAR:			// Paragraph
 			mnLastToken = pInfo->nToken;
 			break;
 		default:
 		{	// do not set nLastToken
 			switch ( pInfo->nToken & ~(0xff | RTF_TABLEDEF) )
 			{
 				case RTF_SHADINGDEF:
 //					((SvxRTFParser*)pInfo->pParser)->ReadBackgroundAttr(pInfo->nToken, mpInsDefault->maItemSet, sal_True );
 				break;
 				case RTF_BRDRDEF:
 					((SvxRTFParser*)pInfo->pParser)->ReadBorderAttr(pInfo->nToken, mpInsDefault->maItemSet, sal_True );
 				break;
 			}
 		}
 	}
 }

 void SdrTableObj::ImportAsRTF( SvStream& rStream, SdrTableObj& rObj )
 {
 	SdrTableRTFParser aParser( rObj );
 	aParser.Read( rStream );
 }

 } }
	/**************************************************************
	*
	* 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 <vector>
	#include <boost/shared_ptr.hpp>

	#include <com/sun/star/table/XTable.hpp>

	#include <tools/stream.hxx>
	#include <svtools/rtftoken.h>

	#include <editeng/eeitem.hxx>
	#include <svx/svdetc.hxx>
	#include <editeng/fhgtitem.hxx>
	#include <editeng/outlobj.hxx>

	#include "cell.hxx"
	#include "celltypes.hxx"
	#include "svx/svdotable.hxx"
	#include "svx/svdoutl.hxx"
	#include "editeng/editeng.hxx"
	#include "editeng/editdata.hxx"
	#include "svx/svdmodel.hxx"
	#include "editeng/svxrtf.hxx"

	using ::rtl::OUString;
	using namespace ::com::sun::star::uno;
	using namespace ::com::sun::star::table;
	using namespace ::com::sun::star::container;
	using namespace ::com::sun::star::beans;

	namespace sdr { namespace table {

	struct RTFCellDefault
	{
	SfxItemSet maItemSet;
	sal_Int32 mnCol;
	sal_uInt16 mnTwips; // right border of the cell
	sal_Int32 mnColSpan; // MergeCell if >1, merged cells if 0

	RTFCellDefault( SfxItemPool* pPool ) : maItemSet( *pPool ), mnCol(0), mnTwips(0 ), mnColSpan(1) {}
	};

	typedef std::vector< boost::shared_ptr< RTFCellDefault > > RTFCellDefaultVector;

	struct RTFCellInfo
	{
	SfxItemSet maItemSet;
	sal_Int32 mnStartPara;
	sal_Int32 mnParaCount;
	sal_Int32 mnColSpan;

	RTFCellInfo( SfxItemPool& rPool ) : maItemSet( rPool ), mnStartPara(0), mnParaCount(0), mnColSpan(0) {}
	};

	typedef boost::shared_ptr< RTFCellInfo > RTFCellInfoPtr;
	typedef std::vector< RTFCellInfoPtr > RTFColumnVector;

	typedef boost::shared_ptr< RTFColumnVector > RTFColumnVectorPtr;

	typedef std::vector< RTFColumnVectorPtr > RTFRowVector;

	class SdrTableRTFParser
	{
	public:
	SdrTableRTFParser( SdrTableObj& rTableObj );
	~SdrTableRTFParser();

	void Read( SvStream& rStream );

	void ProcToken( ImportInfo* pInfo );

	void NextRow();
	void NextColumn();
	void NewCellRow();

	void InsertCell( ImportInfo* pInfo );

	void FillTable();

	DECL_LINK( RTFImportHdl, ImportInfo* );

	private:
	SdrTableObj& mrTableObj;
	SdrOutliner* mpOutliner;
	SfxItemPool& mrItemPool;

	RTFCellDefaultVector maDefaultList;
	RTFCellDefaultVector::iterator maDefaultIterator;

	int mnLastToken;
	sal_Int32 mnLastWidth;
	bool mbNewDef;

	sal_uInt16 mnStartPara;

	sal_Int32 mnColCnt;
	sal_Int32 mnRowCnt;
	sal_Int32 mnColMax;

	std::vector< sal_Int32 > maColumnEdges;

	RTFRowVector maRows;

	RTFCellDefault* mpInsDefault;
	RTFCellDefault* mpActDefault;
	RTFCellDefault* mpDefMerge;

	Reference< XTable > mxTable;
	};

	SdrTableRTFParser::SdrTableRTFParser( SdrTableObj& rTableObj )
	: mrTableObj( rTableObj )
	, mpOutliner( SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, rTableObj.GetModel() ) )
	, mrItemPool( rTableObj.GetModel()->GetItemPool() )
	, mnLastToken( 0 )
	, mnLastWidth( 0 )
	, mbNewDef( false )
	, mnStartPara( 0 )
	, mnColCnt( 0 )
	, mnRowCnt( 0 )
	, mnColMax( 0 )
	, mpActDefault( 0 )
	, mpDefMerge( 0 )
	, mxTable( rTableObj.getTable() )
	{
	mpOutliner->SetUpdateMode(sal_True);
	mpOutliner->SetStyleSheet( 0, mrTableObj.GetStyleSheet() );
	mpInsDefault = new RTFCellDefault( &mrItemPool );
	}

	SdrTableRTFParser::~SdrTableRTFParser()
	{
	delete mpOutliner;
	delete mpInsDefault;
	}

	void SdrTableRTFParser::Read( SvStream& rStream )
	{
	EditEngine& rEdit = const_cast< EditEngine& >( mpOutliner->GetEditEngine() );

	Link aOldLink( rEdit.GetImportHdl() );
	rEdit.SetImportHdl( LINK( this, SdrTableRTFParser, RTFImportHdl ) );
	mpOutliner->Read( rStream, String(), EE_FORMAT_RTF );
	rEdit.SetImportHdl( aOldLink );

	FillTable();
	}

	IMPL_LINK( SdrTableRTFParser, RTFImportHdl, ImportInfo*, pInfo )
	{
	switch ( pInfo->eState )
	{
	case RTFIMP_NEXTTOKEN:
	ProcToken( pInfo );
	break;
	case RTFIMP_UNKNOWNATTR:
	ProcToken( pInfo );
	break;
	case RTFIMP_START:
	{
	SvxRTFParser* pParser = (SvxRTFParser*) pInfo->pParser;
	pParser->SetAttrPool( &mrItemPool );
	RTFPardAttrMapIds& rMap = pParser->GetPardMap();
	rMap.nBox = SDRATTR_TABLE_BORDER;
	}
	break;
	case RTFIMP_END:
	if ( pInfo->aSelection.nEndPos )
	{
	mpActDefault = NULL;
	pInfo->nToken = RTF_PAR;
	pInfo->aSelection.nEndPara++;
	ProcToken( pInfo );
	}
	break;
	case RTFIMP_SETATTR:
	break;
	case RTFIMP_INSERTTEXT:
	break;
	case RTFIMP_INSERTPARA:
	break;
	default:
	DBG_ERRORFILE("unknown ImportInfo.eState");
	}
	return 0;
	}

	void SdrTableRTFParser::NextRow()
	{
	++mnRowCnt;
	}

	void SdrTableRTFParser::InsertCell( ImportInfo* pInfo )
	{
	sal_Int32 nCol = mpActDefault->mnCol;

	RTFCellInfoPtr xCellInfo( new RTFCellInfo(mrItemPool) );

	xCellInfo->mnStartPara = mnStartPara;
	xCellInfo->mnParaCount = pInfo->aSelection.nEndPara - 1 - mnStartPara;

	if( !maRows.empty() )
	{
	RTFColumnVectorPtr xColumn( maRows.back() );

	if( xColumn->size() <= (size_t)nCol )
	xColumn->resize( nCol+1 );

	(*xColumn)[nCol] = xCellInfo;
	}

	mnStartPara = pInfo->aSelection.nEndPara - 1;
	}

	void SdrTableRTFParser::FillTable()
	{
	try
	{
	sal_Int32 nColCount = mxTable->getColumnCount();
	Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_QUERY_THROW );

	if( nColCount < mnColMax )
	{
	xCols->insertByIndex( nColCount, mnColMax - nColCount );
	nColCount = mxTable->getColumnCount();
	}

	const OUString sWidth( RTL_CONSTASCII_USTRINGPARAM("Width") );
	sal_Int32 nCol, nLastEdge = 0;
	for( nCol = 0; nCol < nColCount; nCol++ )
	{
	Reference< XPropertySet > xSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
	sal_Int32 nWidth = maColumnEdges[nCol] - nLastEdge;

	xSet->setPropertyValue( sWidth, Any( nWidth ) );
	nLastEdge += nWidth;
	}

	const sal_Int32 nRowCount = mxTable->getRowCount();
	if( nRowCount < mnRowCnt )
	{
	Reference< XTableRows > xRows( mxTable->getRows(), UNO_QUERY_THROW );
	xRows->insertByIndex( nRowCount, mnRowCnt - nRowCount );
	}

	for( sal_Int32 nRow = 0; nRow < (sal_Int32)maRows.size(); nRow++ )
	{
	RTFColumnVectorPtr xColumn( maRows[nRow] );
	for( nCol = 0; nCol < (sal_Int32)xColumn->size(); nCol++ )
	{
	RTFCellInfoPtr xCellInfo( (*xColumn)[nCol] );

	CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
	if( xCell.is() && xCellInfo.get() )
	{
	const SfxPoolItem *pPoolItem = 0;
	if( xCellInfo->maItemSet.GetItemState(SDRATTR_TABLE_BORDER,sal_False,&pPoolItem)==SFX_ITEM_SET)
	xCell->SetMergedItem( *pPoolItem );

	String sDebug = mpOutliner->GetText( mpOutliner->GetParagraph( xCellInfo->mnStartPara ), xCellInfo->mnParaCount );

	OutlinerParaObject* pTextObject = mpOutliner->CreateParaObject( (sal_uInt16)xCellInfo->mnStartPara, (sal_uInt16)xCellInfo->mnParaCount );
	if( pTextObject )
	{
	SdrOutliner& rOutliner=mrTableObj.ImpGetDrawOutliner();
	rOutliner.SetUpdateMode(sal_True);
	rOutliner.SetText( *pTextObject );
	mrTableObj.NbcSetOutlinerParaObjectForText( rOutliner.CreateParaObject(), xCell.get() );
	delete pTextObject;
	}
	}
	}
	}

	Rectangle aRect( mrTableObj.GetSnapRect() );
	aRect.nRight = aRect.nLeft + nLastEdge;
	mrTableObj.NbcSetSnapRect( aRect );

	}
	catch( Exception& e )
	{
	(void)e;
	DBG_ERROR("sdr::table::SdrTableRTFParser::InsertCell(), exception caught!" );
	}
	}

	void SdrTableRTFParser::NewCellRow()
	{
	if( mbNewDef )
	{
	mbNewDef = sal_False;

	maRows.push_back( RTFColumnVectorPtr( new RTFColumnVector() ) );
	}
	mpDefMerge = NULL;
	maDefaultIterator = maDefaultList.begin();

	NextColumn();

	DBG_ASSERT( mpActDefault, "NewCellRow: pActDefault==0" );
	}

	void SdrTableRTFParser::NextColumn()
	{
	if( maDefaultIterator != maDefaultList.end() )
	mpActDefault = (*maDefaultIterator++).get();
	else
	mpActDefault = 0;
	}

	long TwipsToHundMM( long nIn )
	{
	long nRet = OutputDevice::LogicToLogic( nIn, MAP_TWIP, MAP_100TH_MM );
	return nRet;
	}

	void SdrTableRTFParser::ProcToken( ImportInfo* pInfo )
	{
	switch ( pInfo->nToken )
	{
	case RTF_TROWD: // denotes table row defauls, before RTF_CELLX
	{
	mnColCnt = 0;
	maDefaultList.clear();
	mpDefMerge = NULL;
	mnLastToken = pInfo->nToken;
	}
	break;
	case RTF_CLMGF: // The first cell of cells to be merged
	{
	mpDefMerge = mpInsDefault;
	mnLastToken = pInfo->nToken;
	}
	break;
	case RTF_CLMRG: // A cell to be merged with the preceding cell
	{
	if ( !mpDefMerge )
	mpDefMerge = maDefaultList.back().get();
	DBG_ASSERT( mpDefMerge, "RTF_CLMRG: pDefMerge==0" );
	if( mpDefMerge )
	mpDefMerge->mnColSpan++;
	mpInsDefault->mnColSpan = 0;
	mnLastToken = pInfo->nToken;
	}
	break;
	case RTF_CELLX: // closes cell default
	{
	mbNewDef = sal_True;
	mpInsDefault->mnCol = mnColCnt;
	maDefaultList.push_back( boost::shared_ptr< RTFCellDefault >( mpInsDefault ) );

	if( (sal_Int32)maColumnEdges.size() <= mnColCnt )
	maColumnEdges.resize( mnColCnt + 1 );

	const sal_Int32 nSize = TwipsToHundMM( pInfo->nTokenValue );
	maColumnEdges[mnColCnt] = std::max( maColumnEdges[mnColCnt], nSize );

	mpInsDefault = new RTFCellDefault( &mrItemPool );
	if ( ++mnColCnt > mnColMax )
	mnColMax = mnColCnt;
	mnLastToken = pInfo->nToken;
	}
	break;
	case RTF_INTBL: // before the first RTF_CELL
	{
	if ( mnLastToken != RTF_INTBL && mnLastToken != RTF_CELL && mnLastToken != RTF_PAR )
	{
	NewCellRow();
	mnLastToken = pInfo->nToken;
	}
	}
	break;
	case RTF_CELL: // denotes the end of a cell.
	{
	DBG_ASSERT( mpActDefault, "RTF_CELL: pActDefault==0" );
	if ( mbNewDef \|\| !mpActDefault )
	NewCellRow();
	if ( !mpActDefault )
	mpActDefault = mpInsDefault;
	if ( mpActDefault->mnColSpan > 0 )
	{
	InsertCell(pInfo);
	}
	NextColumn();
	mnLastToken = pInfo->nToken;
	}
	break;
	case RTF_ROW: // means the end of a row
	{
	NextRow();
	mnLastToken = pInfo->nToken;
	}
	break;
	case RTF_PAR: // Paragraph
	mnLastToken = pInfo->nToken;
	break;
	default:
	{ // do not set nLastToken
	switch ( pInfo->nToken & ~(0xff \| RTF_TABLEDEF) )
	{
	case RTF_SHADINGDEF:
	// ((SvxRTFParser*)pInfo->pParser)->ReadBackgroundAttr(pInfo->nToken, mpInsDefault->maItemSet, sal_True );
	break;
	case RTF_BRDRDEF:
	((SvxRTFParser*)pInfo->pParser)->ReadBorderAttr(pInfo->nToken, mpInsDefault->maItemSet, sal_True );
	break;
	}
	}
	}
	}

	void SdrTableObj::ImportAsRTF( SvStream& rStream, SdrTableObj& rObj )
	{
	SdrTableRTFParser aParser( rObj );
	aParser.Read( rStream );
	}

	} }