INTEGRATION: CWS impresstables2 (1.1.2); FILE ADDED

2007/12/02 01:05:01 cl 1.1.2.5: fixing namespace problems
2007/11/29 18:51:29 cl 1.1.2.4: #i68103# working on table templates
2007/07/27 09:28:58 cl 1.1.2.3: added missing pch include
2007/05/31 11:07:12 cl 1.1.2.2: working on tables in drawings
2007/05/07 10:24:23 larsbehr 1.1.2.1: initial impress table support

1 files changed, 816 insertions, 0 deletions

diff --git a/xmloff/source/table/XMLTableImport.cxx b/xmloff/source/table/XMLTableImport.cxx
new file mode 100644
index 000000000000..fbebe6e5a1b5
--- /dev/null
+++ b/xmloff/source/table/XMLTableImport.cxx
@@ -0,0 +1,816 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: XMLTableImport.cxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: rt $ $Date: 2008-03-12 10:59:28 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_xmloff.hxx"
+
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/table/XTableRows.hpp>
+#include <com/sun/star/table/XMergeableCell.hpp>
+#include <com/sun/star/table/XMergeableCellRange.hpp>
+#include <com/sun/star/table/XTable.hpp>
+#include <com/sun/star/text/XText.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+
+#include "xmloff/table/XMLTableImport.hxx"
+#include "xmloff/xmltkmap.hxx"
+#include "xmloff/maptype.hxx"
+#include "xmloff/xmlprmap.hxx"
+#include "xmloff/txtimp.hxx"
+#include "xmloff/xmlimp.hxx"
+#include "xmloff/nmspmap.hxx"
+#include "xmloff/xmlstyle.hxx"
+#include "xmloff/prstylei.hxx"
+#include "xmloff/xmlimp.hxx"
+
+#include "xmlnmspe.hxx"
+#include "table.hxx"
+
+#include <boost/shared_ptr.hpp>
+
+// --------------------------------------------------------------------
+
+using ::rtl::OUString;
+using namespace ::xmloff::token;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::table;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+
+// --------------------------------------------------------------------
+
+struct ColumnInfo
+{
+    OUString msStyleName;
+    sal_Bool mbVisibility;
+    OUString msDefaultCellStyleName;
+};
+
+// --------------------------------------------------------------------
+
+class XMLProxyContext : public SvXMLImportContext
+{
+public:
+    XMLProxyContext( SvXMLImport& rImport, const SvXMLImportContextRef& xParent, USHORT nPrfx, const OUString& rLName );
+
+    virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
+
+private:
+    SvXMLImportContextRef mxParent;
+};
+
+// --------------------------------------------------------------------
+
+struct MergeInfo
+{
+    sal_Int32 mnStartColumn;
+    sal_Int32 mnStartRow;
+    sal_Int32 mnEndColumn;
+    sal_Int32 mnEndRow;
+
+    MergeInfo( sal_Int32 nStartColumn, sal_Int32 nStartRow, sal_Int32 nColumnSpan, sal_Int32 nRowSpan )
+        : mnStartColumn( nStartColumn ), mnStartRow( nStartRow ), mnEndColumn( nStartColumn + nColumnSpan - 1 ), mnEndRow( nStartRow + nRowSpan - 1 ) {};
+};
+
+typedef std::vector< boost::shared_ptr< MergeInfo > > MergeInfoVector;
+
+// --------------------------------------------------------------------
+
+class XMLTableImportContext : public SvXMLImportContext
+{
+public:
+    XMLTableImportContext( const rtl::Reference< XMLTableImport >& xThis, USHORT nPrfx, const OUString& rLName, Reference< XColumnRowRange >& xColumnRowRange );
+    virtual ~XMLTableImportContext();
+
+    virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
+
+    virtual void StartElement( const Reference< XAttributeList >& xAttrList );
+
+    virtual void EndElement();
+
+    void InitColumns();
+
+    SvXMLImportContext * ImportColumn( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
+    SvXMLImportContext * ImportRow( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
+    SvXMLImportContext * ImportCell( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
+
+    OUString GetDefaultCellStyleName() const;
+
+    rtl::Reference< XMLTableImport > mxTableImporter;
+    ::com::sun::star::uno::Reference< ::com::sun::star::table::XTable > mxTable;
+    Reference< XTableColumns > mxColumns;
+    Reference< XTableRows > mxRows;
+
+    std::vector< boost::shared_ptr< ColumnInfo > > maColumnInfos;
+    sal_Int32 mnCurrentRow;
+    sal_Int32 mnCurrentColumn;
+
+    // default cell style name for the current row
+    OUString msDefaultCellStyleName;
+
+    MergeInfoVector maMergeInfos;
+};
+
+// --------------------------------------------------------------------
+
+class XMLCellImportContext : public SvXMLImportContext
+{
+public:
+    XMLCellImportContext( SvXMLImport& rImport,
+                          const Reference< XMergeableCell >& xCell,
+                          const OUString& sDefaultCellStyleName,
+                          USHORT nPrfx, const OUString& rLName,
+                          const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList );
+
+    virtual ~XMLCellImportContext();
+
+    virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
+
+    virtual void EndElement();
+
+    sal_Int32 getColumnSpan() const { return mnColSpan; }
+    sal_Int32 getRowSpan() const { return mnRowSpan; }
+    sal_Int32 getRepeated() const { return mnRepeated; }
+
+    Reference< XMergeableCell > mxCell;
+    Reference< XTextCursor >    mxCursor;
+    Reference< XTextCursor >    mxOldCursor;
+    SvXMLImportContextRef       mxOldListBlock;
+    SvXMLImportContextRef       mxOldListItem;
+
+    sal_Int32 mnColSpan, mnRowSpan, mnRepeated;
+};
+
+// --------------------------------------------------------------------
+
+class XMLTableTemplateContext : public SvXMLStyleContext
+{
+public:
+    XMLTableTemplateContext( SvXMLImport& rImport, USHORT nPrfx, const OUString& rLName, const Reference< XAttributeList >& xAttrList );
+
+    virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList );
+
+    virtual void StartElement( const Reference< XAttributeList >& xAttrList );
+
+    virtual void EndElement();
+
+private:
+    XMLTableTemplate maTableTemplate;
+    OUString msTemplateStyleName;
+};
+
+// --------------------------------------------------------------------
+// class XMLProxyContext
+// --------------------------------------------------------------------
+
+XMLProxyContext::XMLProxyContext( SvXMLImport& rImport, const SvXMLImportContextRef& xParent, USHORT nPrfx, const OUString& rLName )
+: SvXMLImportContext( rImport, nPrfx, rLName )
+, mxParent( xParent )
+{
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext * XMLProxyContext::CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    if( mxParent.Is() )
+        return mxParent->CreateChildContext( nPrefix, rLocalName, xAttrList );
+    else
+        return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
+}
+
+// --------------------------------------------------------------------
+// class XMLTableImport
+// --------------------------------------------------------------------
+
+XMLTableImport::XMLTableImport( SvXMLImport& rImport, const rtl::Reference< XMLPropertySetMapper >& xCellPropertySetMapper, const rtl::Reference< XMLPropertyHandlerFactory >& xFactoryRef )
+: mrImport( rImport )
+{
+    mxCellImportPropertySetMapper = new SvXMLImportPropertyMapper( xCellPropertySetMapper.get(), rImport );
+    mxCellImportPropertySetMapper->ChainImportMapper(XMLTextImportHelper::CreateParaExtPropMapper(rImport));
+
+
+    UniReference < XMLPropertySetMapper > xRowMapper( new XMLPropertySetMapper( getRowPropertiesMap(), xFactoryRef.get() ) );
+    mxRowImportPropertySetMapper = new SvXMLImportPropertyMapper( xRowMapper, rImport );
+
+    UniReference < XMLPropertySetMapper > xColMapper( new XMLPropertySetMapper( getColumnPropertiesMap(), xFactoryRef.get() ) );
+    mxColumnImportPropertySetMapper = new SvXMLImportPropertyMapper( xColMapper, rImport );
+}
+
+// --------------------------------------------------------------------
+
+XMLTableImport::~XMLTableImport()
+{
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext* XMLTableImport::CreateTableContext( USHORT nPrfx, const OUString& rLName, Reference< XColumnRowRange >& xColumnRowRange )
+{
+    rtl::Reference< XMLTableImport > xThis( this );
+    return new XMLTableImportContext( xThis, nPrfx, rLName, xColumnRowRange );
+}
+
+// --------------------------------------------------------------------
+
+SvXMLStyleContext* XMLTableImport::CreateTableTemplateContext( USHORT nPrfx, const OUString& rLName, const Reference< XAttributeList >& xAttrList )
+{
+    return new XMLTableTemplateContext( mrImport, nPrfx, rLName, xAttrList );
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableImport::addTableTemplate( const rtl::OUString& rsStyleName, XMLTableTemplate& xTableTemplate )
+{
+    boost::shared_ptr< XMLTableTemplate > xPtr( new XMLTableTemplate );
+    xPtr->swap( xTableTemplate );
+    maTableTemplates[rsStyleName] = xPtr;
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableImport::finishStyles()
+{
+    if( !maTableTemplates.empty() ) try
+    {
+        Reference< XStyleFamiliesSupplier > xFamiliesSupp( mrImport.GetModel(), UNO_QUERY_THROW );
+        Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
+        const OUString sFamilyName( RTL_CONSTASCII_USTRINGPARAM("table" ) );
+        const OUString sCellFamilyName( RTL_CONSTASCII_USTRINGPARAM("cell") );
+
+        Reference< XNameContainer > xTableFamily( xFamilies->getByName( sFamilyName ), UNO_QUERY_THROW );
+        Reference< XNameAccess > xCellFamily( xFamilies->getByName( sCellFamilyName ), UNO_QUERY_THROW );
+
+        Reference< XSingleServiceFactory > xFactory( xTableFamily, UNO_QUERY_THROW );
+
+        for( XMLTableTemplateMap::iterator aTemplateIter( maTableTemplates.begin() ); aTemplateIter != maTableTemplates.end(); aTemplateIter++ ) try
+        {
+            const OUString sTemplateName( (*aTemplateIter).first );
+            Reference< XNameReplace > xTemplate( xFactory->createInstance(), UNO_QUERY_THROW );
+
+            boost::shared_ptr< XMLTableTemplate > xT( (*aTemplateIter).second );
+
+            for( XMLTableTemplate::iterator aStyleIter( xT->begin() ); aStyleIter != xT->end(); aStyleIter++ ) try
+            {
+                const OUString sPropName( (*aStyleIter).first );
+                const OUString sStyleName( (*aStyleIter).second );
+                xTemplate->replaceByName( sPropName, xCellFamily->getByName( sStyleName ) );
+            }
+            catch( Exception& )
+            {
+                DBG_ERROR("xmloff::XMLTableImport::finishStyles(), exception caught!");
+            }
+
+            if( xTemplate.is() )
+            {
+                if( xTableFamily->hasByName( sTemplateName ) )
+                    xTableFamily->replaceByName( sTemplateName, Any( xTemplate ) );
+                else
+                    xTableFamily->insertByName( sTemplateName, Any( xTemplate ) );
+            }
+
+        }
+        catch( Exception& )
+        {
+            DBG_ERROR("xmloff::XMLTableImport::finishStyles(), exception caught!");
+        }
+    }
+    catch( Exception& )
+    {
+        DBG_ERROR("xmloff::XMLTableImport::finishStyles(), exception caught!");
+    }
+}
+
+// --------------------------------------------------------------------
+// class XMLTableImport
+// --------------------------------------------------------------------
+
+
+XMLTableImportContext::XMLTableImportContext( const rtl::Reference< XMLTableImport >& xImporter, USHORT nPrfx, const OUString& rLName,  Reference< XColumnRowRange >& xColumnRowRange )
+: SvXMLImportContext( xImporter->mrImport, nPrfx, rLName )
+, mxTableImporter( xImporter )
+, mxTable( xColumnRowRange, UNO_QUERY )
+, mxColumns( xColumnRowRange->getColumns() )
+, mxRows( xColumnRowRange->getRows() )
+, mnCurrentRow( -1 )
+, mnCurrentColumn( -1 )
+{
+}
+
+// --------------------------------------------------------------------
+
+XMLTableImportContext::~XMLTableImportContext()
+{
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext * XMLTableImportContext::ImportColumn( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    if( mxColumns.is() && (mnCurrentRow == -1) ) try
+    {
+        boost::shared_ptr< ColumnInfo > xInfo ( new ColumnInfo );
+
+        sal_Int32 nRepeated = 1;
+
+        // read attributes for the table-column
+        sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+        for(sal_Int16 i=0; i < nAttrCount; i++)
+        {
+            OUString sAttrName = xAttrList->getNameByIndex( i );
+            OUString aLocalName;
+            if( GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName ) == XML_NAMESPACE_TABLE )
+            {
+                const OUString sValue( xAttrList->getValueByIndex( i ) );
+                if( IsXMLToken( aLocalName, XML_NUMBER_COLUMNS_REPEATED ) )
+                {
+                    nRepeated = sValue.toInt32();
+                }
+                else if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
+                {
+                    xInfo->msStyleName = sValue;
+                }
+                else if( IsXMLToken( aLocalName, XML_DEFAULT_CELL_STYLE_NAME ) )
+                {
+                    xInfo->msDefaultCellStyleName = sValue;
+                }
+                else if( IsXMLToken( aLocalName, XML_VISIBILITY ) )
+                {
+                    xInfo->mbVisibility = IsXMLToken( sValue, XML_VISIBLE );
+                }
+            }
+        }
+
+        if( nRepeated <= 1 )
+        {
+            maColumnInfos.push_back( xInfo );
+        }
+        else
+        {
+            maColumnInfos.insert( maColumnInfos.end(), nRepeated, xInfo );
+        }
+    }
+    catch( Exception& )
+    {
+        DBG_ERROR("xmloff::XMLTableImportContext::ImportTableColumn(), exception caught!");
+    }
+
+    return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableImportContext::InitColumns()
+{
+    if( mxColumns.is() ) try
+    {
+        const sal_Int32 nCount1 = mxColumns->getCount();
+        const sal_Int32 nCount2 = sal::static_int_cast< sal_Int32 >( maColumnInfos.size() );
+        if( nCount1 < nCount2 )
+            mxColumns->insertByIndex( nCount1, nCount2 - nCount1 );
+
+        SvXMLStylesContext * pAutoStyles = GetImport().GetShapeImport()->GetAutoStylesContext();
+
+        for( sal_Int32 nCol = 0; nCol < nCount2; nCol++ )
+        {
+            boost::shared_ptr< ColumnInfo > xInfo( maColumnInfos[nCol] );
+
+            if( pAutoStyles && xInfo->msStyleName.getLength() )
+            {
+                const XMLPropStyleContext* pStyle =
+                    dynamic_cast< const XMLPropStyleContext* >(
+                        pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_TABLE_COLUMN, xInfo->msStyleName) );
+
+                if( pStyle )
+                {
+                    Reference< XPropertySet > xColProps( mxColumns->getByIndex(nCol), UNO_QUERY_THROW );
+                    const_cast< XMLPropStyleContext* >( pStyle )->FillPropertySet( xColProps );
+                }
+            }
+
+        }
+    }
+    catch( Exception& )
+    {
+        DBG_ERROR("xmloff::XMLTableImportContext::ImportTableColumn(), exception caught!");
+    }
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext * XMLTableImportContext::ImportRow( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    if( mxRows.is() )
+    {
+        mnCurrentRow++;
+        if( mnCurrentRow == 0 )
+            InitColumns();      // first init columns
+
+        mnCurrentColumn = -1;
+
+        const sal_Int32 nRowCount = mxRows->getCount();
+        if( ( nRowCount - 1) < mnCurrentRow )
+        {
+            const sal_Int32 nCount = mnCurrentRow - nRowCount + 1;
+            mxRows->insertByIndex( nRowCount, nCount );
+        }
+
+        Reference< XPropertySet > xRowSet( mxRows->getByIndex(mnCurrentRow), UNO_QUERY );
+
+        sal_Int32 nRepeated = 1;
+        OUString sStyleName;
+        sal_Bool bVisibility = sal_True;
+
+        // read attributes for the table-row
+        sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+        for(sal_Int16 i=0; i < nAttrCount; i++)
+        {
+            OUString sAttrName = xAttrList->getNameByIndex( i );
+            OUString aLocalName;
+
+            sal_uInt16 nPrefix2 = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
+            if( nPrefix2 == XML_NAMESPACE_TABLE )
+            {
+                const OUString sValue( xAttrList->getValueByIndex( i ) );
+                if( IsXMLToken( aLocalName, XML_NUMBER_ROWS_REPEATED ) )
+                {
+                    nRepeated = sValue.toInt32();
+                }
+                else if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
+                {
+                    sStyleName = sValue;
+                }
+                else if( IsXMLToken( aLocalName, XML_DEFAULT_CELL_STYLE_NAME ) )
+                {
+                    msDefaultCellStyleName = sValue;
+                }
+                else if( IsXMLToken( aLocalName, XML_VISIBILITY ) )
+                {
+                    bVisibility = IsXMLToken( sValue, XML_VISIBLE );
+                }
+            }
+        }
+
+        if( sStyleName.getLength() )
+        {
+            SvXMLStylesContext * pAutoStyles = GetImport().GetShapeImport()->GetAutoStylesContext();
+            if( pAutoStyles )
+            {
+                const XMLPropStyleContext* pStyle =
+                    dynamic_cast< const XMLPropStyleContext* >(
+                        pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_TABLE_ROW, sStyleName) );
+
+                if( pStyle )
+                {
+                    const_cast< XMLPropStyleContext* >( pStyle )->FillPropertySet( xRowSet );
+                }
+            }
+        }
+    }
+
+    SvXMLImportContextRef xThis( this );
+    return new XMLProxyContext( GetImport(), xThis, nPrefix, rLocalName );
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext * XMLTableImportContext::ImportCell( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    mnCurrentColumn++;
+    if( mxColumns.is() ) try
+    {
+        if( mxColumns->getCount() <= mnCurrentColumn )
+            mxColumns->insertByIndex( mxColumns->getCount(), mnCurrentColumn - mxColumns->getCount() + 1 );
+
+        Reference< XMergeableCell > xCell( mxTable->getCellByPosition( mnCurrentColumn, mnCurrentRow ), UNO_QUERY_THROW );
+        XMLCellImportContext* pCellContext = new XMLCellImportContext( GetImport(), xCell, GetDefaultCellStyleName(), nPrefix, rLocalName, xAttrList );
+
+        const sal_Int32 nColumnSpan = pCellContext->getColumnSpan();
+        const sal_Int32 nRowSpan = pCellContext->getRowSpan();
+        if( (nColumnSpan > 1) || (nRowSpan > 1) )
+            maMergeInfos.push_back( boost::shared_ptr< MergeInfo >( new MergeInfo( mnCurrentColumn, mnCurrentRow, nColumnSpan, nRowSpan ) ) );
+
+        const sal_Int32 nRepeated = pCellContext->getRepeated();
+        if( nRepeated > 1 )
+        {
+            DBG_ERROR("xmloff::XMLTableImportContext::ImportCell(), import of repeated Cells not implemented (TODO)");
+            mnCurrentColumn  += nRepeated - 1;
+        }
+
+        return pCellContext;
+    }
+    catch( Exception& )
+    {
+        DBG_ERROR("xmloff::XMLTableImportContext::ImportCell(), exception caught!");
+    }
+
+    return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext *XMLTableImportContext::CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    if( nPrefix == XML_NAMESPACE_TABLE )
+    {
+        if( IsXMLToken( rLocalName, XML_TABLE_COLUMN ) )
+            return ImportColumn( nPrefix, rLocalName, xAttrList );
+        else if( IsXMLToken( rLocalName, XML_TABLE_ROW ) )
+            return ImportRow( nPrefix, rLocalName, xAttrList );
+        else if( IsXMLToken( rLocalName, XML_TABLE_CELL ) || IsXMLToken( rLocalName, XML_COVERED_TABLE_CELL ) )
+            return ImportCell( nPrefix, rLocalName, xAttrList );
+        else if( IsXMLToken( rLocalName, XML_TABLE_COLUMNS ) || IsXMLToken( rLocalName, XML_TABLE_ROWS ) )
+        {
+            SvXMLImportContextRef xThis( this );
+            return new XMLProxyContext( GetImport(), xThis, nPrefix, rLocalName );
+        }
+    }
+
+    return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableImportContext::StartElement( const Reference< XAttributeList >& /*xAttrList*/ )
+{
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableImportContext::EndElement()
+{
+    if( !maMergeInfos.empty() )
+    {
+        MergeInfoVector::iterator aIter( maMergeInfos.begin() );
+        while( aIter != maMergeInfos.end() )
+        {
+            boost::shared_ptr< MergeInfo > xInfo( (*aIter++) );
+
+            if( xInfo.get() ) try
+            {
+                Reference< XCellRange > xRange( mxTable->getCellRangeByPosition( xInfo->mnStartColumn, xInfo->mnStartRow, xInfo->mnEndColumn, xInfo->mnEndRow ) );
+                Reference< XMergeableCellRange > xCursor( mxTable->createCursorByRange( xRange ), UNO_QUERY_THROW );
+                xCursor->merge();
+            }
+            catch( Exception& )
+            {
+                DBG_ERROR("XMLTableImportContext::EndElement(), exception caught while merging cells!");
+            }
+        }
+    }
+}
+
+// --------------------------------------------------------------------
+
+OUString XMLTableImportContext::GetDefaultCellStyleName() const
+{
+    OUString sStyleName( msDefaultCellStyleName );
+
+    // if there is still no style name, try default style name from column
+    if( (sStyleName.getLength() == 0) && (mnCurrentColumn < sal::static_int_cast<sal_Int32>(maColumnInfos.size())) )
+        sStyleName = maColumnInfos[mnCurrentColumn]->msDefaultCellStyleName;
+
+    return sStyleName;
+}
+
+// --------------------------------------------------------------------
+// XMLCellImportContext
+// --------------------------------------------------------------------
+
+XMLCellImportContext::XMLCellImportContext( SvXMLImport& rImport, const Reference< XMergeableCell >& xCell, const OUString& sDefaultCellStyleName, USHORT nPrfx, const OUString& rLName, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList )
+: SvXMLImportContext( rImport, nPrfx, rLName )
+, mxCell( xCell )
+, mnColSpan( 1 )
+, mnRowSpan( 1 )
+, mnRepeated( 1 )
+{
+    OUString sStyleName;
+
+    // read attributes for the table-row
+    sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+    for(sal_Int16 i=0; i < nAttrCount; i++)
+    {
+        OUString sAttrName = xAttrList->getNameByIndex( i );
+        OUString aLocalName;
+
+        if( GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName ) == XML_NAMESPACE_TABLE )
+        {
+            const OUString sValue( xAttrList->getValueByIndex( i ) );
+            if( IsXMLToken( aLocalName, XML_NUMBER_COLUMNS_REPEATED ) )
+            {
+                mnRepeated = sValue.toInt32();
+            }
+            else if( IsXMLToken( aLocalName, XML_NUMBER_COLUMNS_SPANNED ) )
+            {
+                mnColSpan = sValue.toInt32();
+            }
+            else if( IsXMLToken( aLocalName, XML_NUMBER_ROWS_SPANNED ) )
+            {
+                mnRowSpan = sValue.toInt32();
+            }
+            else if( IsXMLToken( aLocalName, XML_STYLE_NAME ) )
+            {
+                sStyleName = sValue;
+            }
+        }
+    }
+
+    // if there is no style name at the cell, try default style name from row
+    if( sStyleName.getLength() == 0 )
+        sStyleName = sDefaultCellStyleName;
+
+    if( sStyleName.getLength() )
+    {
+        SvXMLStylesContext * pAutoStyles = GetImport().GetShapeImport()->GetAutoStylesContext();
+        if( pAutoStyles )
+        {
+            const XMLPropStyleContext* pStyle =
+                dynamic_cast< const XMLPropStyleContext* >(
+                    pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_TABLE_CELL, sStyleName) );
+
+            if( pStyle )
+            {
+                Reference< XPropertySet > xCellSet( mxCell, UNO_QUERY );
+                if( xCellSet.is() )
+                    const_cast< XMLPropStyleContext* >( pStyle )->FillPropertySet( xCellSet );
+            }
+        }
+    }
+}
+
+// --------------------------------------------------------------------
+
+XMLCellImportContext::~XMLCellImportContext()
+{
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext * XMLCellImportContext::CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    // create text cursor on demand
+    if( !mxCursor.is() )
+    {
+        Reference< XText > xText( mxCell, UNO_QUERY );
+        if( xText.is() )
+        {
+            UniReference < XMLTextImportHelper > xTxtImport( GetImport().GetTextImport() );
+            mxOldCursor = xTxtImport->GetCursor();
+            mxCursor = xText->createTextCursor();
+            if( mxCursor.is() )
+                xTxtImport->SetCursor( mxCursor );
+
+            // remember old list item and block (#91964#) and reset them
+            // for the text frame
+            mxOldListBlock = xTxtImport->_GetListBlock();
+            mxOldListItem = xTxtImport->_GetListItem();
+            xTxtImport->_SetListBlock( NULL );
+            xTxtImport->_SetListItem( NULL );
+        }
+    }
+
+    SvXMLImportContext * pContext = 0;
+
+    // if we have a text cursor, lets  try to import some text
+    if( mxCursor.is() )
+    {
+        pContext = GetImport().GetTextImport()->CreateTextChildContext( GetImport(), nPrefix, rLocalName, xAttrList );
+    }
+
+    if( pContext )
+        return pContext;
+    else
+        return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList);
+}
+
+// --------------------------------------------------------------------
+
+// --------------------------------------------------------------------
+
+void XMLCellImportContext::EndElement()
+{
+    if(mxCursor.is())
+    {
+        // delete addition newline
+        const OUString aEmpty;
+        mxCursor->gotoEnd( sal_False );
+        mxCursor->goLeft( 1, sal_True );
+        mxCursor->setString( aEmpty );
+
+        // reset cursor
+        GetImport().GetTextImport()->ResetCursor();
+    }
+
+    if(mxOldCursor.is())
+        GetImport().GetTextImport()->SetCursor( mxOldCursor );
+
+    // reinstall old list item (if necessary) #91964#
+    if ( mxOldListBlock.Is() )
+    {
+        GetImport().GetTextImport()->_SetListBlock( mxOldListBlock );
+        GetImport().GetTextImport()->_SetListItem( mxOldListItem );
+    }
+}
+
+// --------------------------------------------------------------------
+// class XMLTableTemplateContext
+// --------------------------------------------------------------------
+
+XMLTableTemplateContext::XMLTableTemplateContext( SvXMLImport& rImport, USHORT nPrfx, const OUString& rLName, const Reference< XAttributeList >& xAttrList )
+: SvXMLStyleContext( rImport, nPrfx, rLName, xAttrList, XML_STYLE_FAMILY_TABLE_TEMPLATE_ID, sal_False )
+{
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableTemplateContext::StartElement( const Reference< XAttributeList >& xAttrList )
+{
+    sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+    for(sal_Int16 i=0; i < nAttrCount; i++)
+    {
+        OUString sAttrName;
+        USHORT nAttrPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( i ), &sAttrName );
+        if( (nAttrPrefix == XML_NAMESPACE_TEXT ) && IsXMLToken( sAttrName, XML_STYLE_NAME ) )
+        {
+            msTemplateStyleName = xAttrList->getValueByIndex( i );
+            break;
+        }
+    }
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableTemplateContext::EndElement()
+{
+    rtl::Reference< XMLTableImport > xTableImport( GetImport().GetShapeImport()->GetShapeTableImport() );
+    if( xTableImport.is() )
+        xTableImport->addTableTemplate( msTemplateStyleName, maTableTemplate );
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext * XMLTableTemplateContext::CreateChildContext( USHORT nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList )
+{
+    if( nPrefix == XML_NAMESPACE_TABLE )
+    {
+        const TableStyleElement* pElements = getTableStyleMap();
+        while( (pElements->meElement != XML_TOKEN_END) && !IsXMLToken( rLocalName, pElements->meElement ) )
+            pElements++;
+
+        if( pElements->meElement != XML_TOKEN_END )
+        {
+            sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+            for(sal_Int16 i=0; i < nAttrCount; i++)
+            {
+                OUString sAttrName;
+                USHORT nAttrPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( i ), &sAttrName );
+                if( (nAttrPrefix == XML_NAMESPACE_TEXT) && IsXMLToken( sAttrName, XML_STYLE_NAME ) )
+                {
+                    maTableTemplate[pElements->msStyleName] = xAttrList->getValueByIndex( i );
+                    break;
+                }
+            }
+        }
+    }
+
+    return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
+}
+
+// --------------------------------------------------------------------