summaryrefslogtreecommitdiff
path: root/xmloff/source/table
diff options
context:
space:
mode:
Diffstat (limited to 'xmloff/source/table')
-rw-r--r--xmloff/source/table/XMLTableExport.cxx595
-rw-r--r--xmloff/source/table/XMLTableImport.cxx826
-rw-r--r--xmloff/source/table/makefile.mk48
-rw-r--r--xmloff/source/table/table.hxx45
-rw-r--r--xmloff/source/table/tabledesignsimporter.cxx103
5 files changed, 1617 insertions, 0 deletions
diff --git a/xmloff/source/table/XMLTableExport.cxx b/xmloff/source/table/XMLTableExport.cxx
new file mode 100644
index 000000000000..ad3a1f96752f
--- /dev/null
+++ b/xmloff/source/table/XMLTableExport.cxx
@@ -0,0 +1,595 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org 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 version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_xmloff.hxx"
+#include "xmloff/dllapi.h"
+
+#include "sal/config.h"
+#include <osl/diagnose.h>
+
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/text/XText.hpp>
+#include <com/sun/star/container/XNamed.hpp>
+#include <com/sun/star/container/XEnumerationAccess.hpp>
+#include <com/sun/star/table/XCellRange.hpp>
+#include <com/sun/star/table/XColumnRowRange.hpp>
+#include <com/sun/star/table/CellContentType.hpp>
+#include <com/sun/star/table/XMergeableCell.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+
+#include "xmloff/table/XMLTableExport.hxx"
+#include "xmlnmspe.hxx"
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmlexppr.hxx>
+#include <xmloff/xmlexp.hxx>
+#include "table.hxx"
+
+using ::rtl::OUString;
+using namespace ::xmloff::token;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::table;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::style;
+using namespace ::xmloff::token;
+
+// --------------------------------------------------------------------
+
+#define _MAP(name,prefix,token,type,context) { name, sizeof(name)-1, prefix, token, type, context, SvtSaveOptions::ODFVER_010 }
+#define CMAP(name,prefix,token,type,context) _MAP(name,prefix,token,type|XML_TYPE_PROP_TABLE_COLUMN,context)
+#define RMAP(name,prefix,token,type,context) _MAP(name,prefix,token,type|XML_TYPE_PROP_TABLE_ROW,context)
+#define MAP_END { 0L, 0, 0, XML_EMPTY, 0, 0, SvtSaveOptions::ODFVER_010 }
+
+// --------------------------------------------------------------------
+
+const XMLPropertyMapEntry* getColumnPropertiesMap()
+{
+ static const XMLPropertyMapEntry aXMLColumnProperties[] =
+ {
+ CMAP( "Width", XML_NAMESPACE_STYLE, XML_COLUMN_WIDTH, XML_TYPE_MEASURE, 0 ),
+ CMAP( "OptimalWidth", XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_COLUMN_WIDTH, XML_TYPE_BOOL, 0 ),
+ MAP_END
+ };
+
+ return &aXMLColumnProperties[0];
+}
+
+// --------------------------------------------------------------------
+
+const XMLPropertyMapEntry* getRowPropertiesMap()
+{
+ static const XMLPropertyMapEntry aXMLRowProperties[] =
+ {
+ RMAP( "Height", XML_NAMESPACE_STYLE, XML_ROW_HEIGHT, XML_TYPE_MEASURE, 0 ),
+ RMAP( "OptimalHeight", XML_NAMESPACE_STYLE, XML_MIN_ROW_HEIGHT, XML_TYPE_MEASURE, 0 ),
+ RMAP( "OptimalWidth", XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_ROW_HEIGHT, XML_TYPE_BOOL, 0 ),
+ MAP_END
+ };
+
+ return &aXMLRowProperties[0];
+}
+
+// --------------------------------------------------------------------
+
+class StringStatisticHelper : public std::map< OUString, sal_Int32 >
+{
+public:
+ void add( const OUString& rStyleName );
+ void clear() { std::map< OUString, sal_Int32 >::clear(); }
+
+ sal_Int32 getModeString( /* out */ OUString& rModeString );
+};
+
+// --------------------------------------------------------------------
+
+void StringStatisticHelper::add( const OUString& rStyleName )
+{
+ std::map< OUString, sal_Int32 >::iterator iter( find( rStyleName ) );
+ if( iter == end() )
+ {
+ (*this)[rStyleName] = 1;
+ }
+ else
+ {
+ (*iter).second += 1;
+ }
+}
+
+// --------------------------------------------------------------------
+
+sal_Int32 StringStatisticHelper::getModeString( OUString& rStyleName )
+{
+ sal_Int32 nMax = 0;
+ for( std::map< OUString, sal_Int32 >::iterator iter( begin() ); iter != end(); iter++ )
+ {
+ if( (*iter).second > nMax )
+ {
+ rStyleName = (*iter).first;
+ nMax = (*iter).second;
+ }
+ }
+
+ return nMax;
+}
+
+// --------------------------------------------------------------------
+// class XMLTableExport
+// --------------------------------------------------------------------
+
+XMLTableExport::XMLTableExport(SvXMLExport& rExp, const rtl::Reference< SvXMLExportPropertyMapper >& xExportPropertyMapper, const rtl::Reference< XMLPropertyHandlerFactory >& xFactoryRef )
+: mrExport( rExp )
+, mbExportTables( false )
+{
+ Reference< XMultiServiceFactory > xFac( rExp.GetModel(), UNO_QUERY );
+ if( xFac.is() ) try
+ {
+ Sequence< OUString > sSNS( xFac->getAvailableServiceNames() );
+ sal_Int32 n = sSNS.getLength();
+ const OUString* pSNS( sSNS.getConstArray() );
+ while( --n > 0 )
+ {
+ if( (*pSNS++).equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.TableShape") ) )
+ {
+ mbExportTables = true;
+ break;
+ }
+ }
+ }
+ catch( Exception& e )
+ {
+ (void)e;
+ }
+
+ mxCellExportPropertySetMapper = xExportPropertyMapper;
+ mxCellExportPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(rExp));
+
+ mxRowExportPropertySetMapper = new SvXMLExportPropertyMapper( new XMLPropertySetMapper( getRowPropertiesMap(), xFactoryRef.get() ) );
+ mxColumnExportPropertySetMapper = new SvXMLExportPropertyMapper( new XMLPropertySetMapper( getColumnPropertiesMap(), xFactoryRef.get() ) );
+
+ mrExport.GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_COLUMN,
+ OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_NAME)),
+ mxColumnExportPropertySetMapper.get(),
+ OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_PREFIX)));
+ mrExport.GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_ROW,
+ OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_NAME)),
+ mxRowExportPropertySetMapper.get(),
+ OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_PREFIX)));
+// mrExport.GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_TABLE
+// OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_NAME)),
+// xTableStylesExportPropertySetMapper,
+// OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_PREFIX)));
+ mrExport.GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_CELL,
+ OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)),
+ mxCellExportPropertySetMapper.get(),
+ OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX)));
+}
+
+// --------------------------------------------------------------------
+
+XMLTableExport::~XMLTableExport ()
+{
+}
+
+// --------------------------------------------------------------------
+
+static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
+{
+ if( !xPropStates.empty() )
+ {
+ std::vector< XMLPropertyState >::const_iterator aIter( xPropStates.begin() );
+ std::vector< XMLPropertyState >::const_iterator aEnd( xPropStates.end() );
+ while( aIter != aEnd )
+ {
+ if( aIter->mnIndex != -1 )
+ return true;
+ aIter++;
+ }
+ }
+ return false;
+}
+
+// --------------------------------------------------------------------
+
+ void XMLTableExport::collectTableAutoStyles(const Reference < XColumnRowRange >& xColumnRowRange)
+ {
+ if( !mbExportTables )
+ return;
+
+ boost::shared_ptr< XMLTableInfo > pTableInfo( new XMLTableInfo() );
+ maTableInfoMap[xColumnRowRange] = pTableInfo;
+
+ try
+ {
+ Reference< XIndexAccess > xIndexAccessCols( xColumnRowRange->getColumns(), UNO_QUERY_THROW );
+ const sal_Int32 nColumnCount = xIndexAccessCols->getCount();
+ for( sal_Int32 nColumn = 0; nColumn < nColumnCount; ++nColumn ) try
+ {
+ Reference< XPropertySet > xPropSet( xIndexAccessCols->getByIndex(nColumn) , UNO_QUERY_THROW );
+ std::vector< XMLPropertyState > xPropStates( mxColumnExportPropertySetMapper->Filter( xPropSet ) );
+
+ if( has_states( xPropStates ) )
+ {
+ const OUString sStyleName( mrExport.GetAutoStylePool()->Add(XML_STYLE_FAMILY_TABLE_COLUMN, xPropStates) );
+ Reference< XInterface > xKey( xPropSet, UNO_QUERY );
+ pTableInfo->maColumnStyleMap[xKey] = sStyleName;
+ }
+ }
+ catch( Exception& )
+ {
+ DBG_ERROR("xmloff::XMLTableExport::collectTableAutoStyles(), exception during column style collection!");
+ }
+
+ Reference< XIndexAccess > xIndexAccessRows( xColumnRowRange->getRows(), UNO_QUERY_THROW );
+ const sal_Int32 nRowCount = xIndexAccessRows->getCount();
+ pTableInfo->maDefaultRowCellStyles.resize(nRowCount);
+
+ StringStatisticHelper aStringStatistic;
+
+ for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow ) try
+ {
+ Reference< XPropertySet > xPropSet( xIndexAccessRows->getByIndex(nRow) , UNO_QUERY_THROW );
+ std::vector< XMLPropertyState > xRowPropStates( mxRowExportPropertySetMapper->Filter( xPropSet ) );
+
+ if( has_states( xRowPropStates ) )
+ {
+ const OUString sStyleName( mrExport.GetAutoStylePool()->Add(XML_STYLE_FAMILY_TABLE_ROW, xRowPropStates) );
+ Reference< XInterface > xKey( xPropSet, UNO_QUERY );
+ pTableInfo->maRowStyleMap[xKey] = sStyleName;
+ }
+
+ // get the current row
+ Reference< XCellRange > xCellRange( xPropSet, UNO_QUERY_THROW );
+ for ( sal_Int32 nColumn = 0; nColumn < nColumnCount; ++nColumn )
+ {
+ // get current cell, remarks row index is 0, because we get the range for each row seperate
+ Reference< XPropertySet > xCellSet( xCellRange->getCellByPosition(nColumn, 0), UNO_QUERY_THROW );
+
+ // get style
+ OUString sParentStyleName;
+ Reference< XPropertySetInfo > xPropertySetInfo( xCellSet->getPropertySetInfo() );
+ if( xPropertySetInfo.is() && xPropertySetInfo->hasPropertyByName( OUString(RTL_CONSTASCII_USTRINGPARAM("Style"))) )
+ {
+ Reference< XStyle > xStyle( xCellSet->getPropertyValue(OUString(RTL_CONSTASCII_USTRINGPARAM("Style"))), UNO_QUERY );
+ if( xStyle.is() )
+ sParentStyleName = xStyle->getName();
+ }
+
+ // create auto style, if needed
+ OUString sStyleName;
+ std::vector< XMLPropertyState > xCellPropStates( mxCellExportPropertySetMapper->Filter( xCellSet ) );
+ if( has_states( xCellPropStates ) )
+ sStyleName = mrExport.GetAutoStylePool()->Add(XML_STYLE_FAMILY_TABLE_CELL, xCellPropStates);
+ else
+ sStyleName = sParentStyleName;
+
+ if( sStyleName.getLength() )
+ {
+ Reference< XInterface > xKey( xCellSet, UNO_QUERY );
+ pTableInfo->maCellStyleMap[xKey] = sStyleName;
+ }
+
+ // create auto style for text
+ Reference< XText > xText(xCellSet, UNO_QUERY);
+ if(xText.is() && xText->getString().getLength())
+ GetExport().GetTextParagraphExport()->collectTextAutoStyles( xText );
+
+ aStringStatistic.add( sStyleName );
+ }
+
+ OUString sDefaultCellStyle;
+ if( aStringStatistic.getModeString( sDefaultCellStyle ) > 1 )
+ pTableInfo->maDefaultRowCellStyles[nRow] = sDefaultCellStyle;
+
+ aStringStatistic.clear();
+ }
+ catch( Exception& )
+ {
+ DBG_ERROR("xmloff::XMLTableExport::collectTableAutoStyles(), exception during column style collection!");
+ }
+ }
+ catch( Exception& )
+ {
+ DBG_ERROR("xmloff::XMLTableExport::collectTableAutoStyles(), exception caught!");
+ }
+ }
+
+ // --------------------------------------------------------------------
+
+ void XMLTableExport::exportTable( const Reference < XColumnRowRange >& xColumnRowRange )
+ {
+ if( !mbExportTables )
+ return;
+
+ try
+ {
+ boost::shared_ptr< XMLTableInfo > pTableInfo( maTableInfoMap[xColumnRowRange] );
+
+ // get row and column count
+ Reference< XIndexAccess > xIndexAccess( xColumnRowRange->getRows(), UNO_QUERY_THROW );
+ Reference< XIndexAccess > xIndexAccessCols( xColumnRowRange->getColumns(), UNO_QUERY_THROW );
+
+ const sal_Int32 rowCount = xIndexAccess->getCount();
+ const sal_Int32 columnCount = xIndexAccessCols->getCount();
+
+ SvXMLElementExport tableElement( mrExport, XML_NAMESPACE_TABLE, XML_TABLE, sal_True, sal_True );
+
+ // export table columns
+ ExportTableColumns( xIndexAccessCols, pTableInfo );
+
+ // start iterating rows and columns
+ for ( sal_Int32 rowIndex = 0; rowIndex < rowCount; rowIndex++ )
+ {
+ // get the current row
+ Reference< XCellRange > xCellRange( xIndexAccess->getByIndex(rowIndex), UNO_QUERY_THROW );
+
+ OUString sDefaultCellStyle;
+
+ // table:style-name
+ if( pTableInfo.get() )
+ {
+ Reference< XInterface > xKey( xCellRange, UNO_QUERY );
+ const OUString sStyleName( pTableInfo->maRowStyleMap[xKey] );
+ if( sStyleName.getLength() )
+ mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sStyleName );
+
+ sDefaultCellStyle = pTableInfo->maDefaultRowCellStyles[rowIndex];
+ if( sDefaultCellStyle.getLength() )
+ mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME, sDefaultCellStyle );
+ }
+
+ // write row element
+ SvXMLElementExport tableRowElement( mrExport, XML_NAMESPACE_TABLE, XML_TABLE_ROW, sal_True, sal_True );
+
+ for ( sal_Int32 columnIndex = 0; columnIndex < columnCount; columnIndex++ )
+ {
+ // get current cell, remarks row index is 0, because we get the range for each row seperate
+ Reference< XCell > xCell( xCellRange->getCellByPosition(columnIndex, 0), UNO_QUERY_THROW );
+
+ // use XMergeableCell interface from offapi
+ Reference< XMergeableCell > xMergeableCell( xCell, UNO_QUERY_THROW );
+
+ // export cell
+ ExportCell( xCell, pTableInfo, sDefaultCellStyle );
+ }
+ }
+ }
+ catch( Exception )
+ {
+ DBG_ERROR( "XMLTableExport::exportTable(), exception cought!" );
+ }
+ }
+
+// --------------------------------------------------------------------
+// Export the table columns
+// --------------------------------------------------------------------
+
+ void XMLTableExport::ExportTableColumns( const Reference < XIndexAccess >& xtableColumnsIndexAccess, const boost::shared_ptr< XMLTableInfo >& pTableInfo )
+ {
+ const sal_Int32 nColumnCount = xtableColumnsIndexAccess->getCount();
+ for( sal_Int32 nColumn = 0; nColumn < nColumnCount; ++nColumn )
+ {
+ Reference< XPropertySet > xColumnProperties( xtableColumnsIndexAccess->getByIndex(nColumn) , UNO_QUERY );
+ if ( xColumnProperties.is() )
+ {
+ // table:style-name
+ if( pTableInfo.get() )
+ {
+ Reference< XInterface > xKey( xColumnProperties, UNO_QUERY );
+ const OUString sStyleName( pTableInfo->maColumnStyleMap[xKey] );
+ if( sStyleName.getLength() )
+ mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sStyleName );
+ }
+
+ // TODO: All columns first have to be checked if some ones
+ // have identical properties. If yes, attr table:number-columns-repeated
+ // has to be written.
+ SvXMLElementExport tableColumnElement( mrExport, XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, sal_True, sal_True );
+ }
+ }
+ }
+
+// --------------------------------------------------------------------
+// ODF export for a table cell.
+// --------------------------------------------------------------------
+
+ void XMLTableExport::ExportCell( const Reference < XCell >& xCell, const boost::shared_ptr< XMLTableInfo >& pTableInfo, const OUString& rDefaultCellStyle )
+ {
+ bool bIsMerged = false;
+ sal_Int32 nRowSpan = 0;
+ sal_Int32 nColSpan = 0;
+
+ try
+ {
+ if( pTableInfo.get() )
+ {
+ // table:style-name
+ Reference< XInterface > xKey( xCell, UNO_QUERY );
+ const OUString sStyleName( pTableInfo->maCellStyleMap[xKey] );
+ if( sStyleName.getLength() && (sStyleName != rDefaultCellStyle) )
+ mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sStyleName );
+ }
+
+ Reference< XMergeableCell > xMerge( xCell, UNO_QUERY );
+ if( xMerge.is() )
+ {
+ bIsMerged = xMerge->isMerged();
+ nRowSpan = xMerge->getRowSpan();
+ nColSpan = xMerge->getColumnSpan();
+ }
+ DBG_ASSERT( (nRowSpan >= 1) && (nColSpan >= 1), "xmloff::XMLTableExport::ExportCell(), illegal row or col span < 1?" );
+ }
+ catch ( Exception )
+ {
+ DBG_ERROR( "exception while exporting a table cell" );
+ }
+
+ // table:number-columns-repeated
+ // todo
+
+ // table:number-columns-spanned
+ if( nColSpan > 1 )
+ mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED, OUString::valueOf( nColSpan ) );
+
+ // table:number-rows-spanned
+ if( nRowSpan > 1 )
+ mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED, OUString::valueOf( nRowSpan ) );
+
+ // <table:table-cell> or <table:covered-table-cell>
+ SvXMLElementExport tableCellElement( mrExport, XML_NAMESPACE_TABLE, bIsMerged ? XML_COVERED_TABLE_CELL : XML_TABLE_CELL, sal_True, sal_True );
+
+ // export cells text content
+ ImpExportText( xCell );
+ }
+
+// --------------------------------------------------------------------
+// ODF export of the text contents of a table cell.
+// Remarks: Up to now we only export text contents!
+// TODO: Check against nested tables ....
+// --------------------------------------------------------------------
+
+ void XMLTableExport::ImpExportText( const Reference< XCell >& xCell )
+ {
+ Reference< XText > xText( xCell, UNO_QUERY );
+ if( xText.is() && xText->getString().getLength())
+ mrExport.GetTextParagraphExport()->exportText( xText );
+ }
+
+// --------------------------------------------------------------------
+
+void XMLTableExport::exportTableStyles()
+{
+ if( !mbExportTables )
+ return;
+
+ XMLStyleExport aStEx(mrExport, OUString(), mrExport.GetAutoStylePool().get());
+
+ // write graphic family styles
+ aStEx.exportStyleFamily("cell", OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)), mxCellExportPropertySetMapper.get(), TRUE, XML_STYLE_FAMILY_TABLE_CELL);
+
+ exportTableTemplates();
+}
+
+// --------------------------------------------------------------------
+// Export the collected automatic styles
+// --------------------------------------------------------------------
+
+void XMLTableExport::exportAutoStyles()
+{
+ if( !mbExportTables )
+ return;
+
+ mrExport.GetAutoStylePool()->exportXML( XML_STYLE_FAMILY_TABLE_COLUMN, mrExport.GetDocHandler(), mrExport.GetMM100UnitConverter(), mrExport.GetNamespaceMap() );
+ mrExport.GetAutoStylePool()->exportXML( XML_STYLE_FAMILY_TABLE_ROW, mrExport.GetDocHandler(), mrExport.GetMM100UnitConverter(), mrExport.GetNamespaceMap() );
+ mrExport.GetAutoStylePool()->exportXML( XML_STYLE_FAMILY_TABLE_CELL, mrExport.GetDocHandler(), mrExport.GetMM100UnitConverter(), mrExport.GetNamespaceMap() );
+}
+
+// --------------------------------------------------------------------
+
+const TableStyleElement* getTableStyleMap()
+{
+ static struct TableStyleElement gTableStyleElements[] =
+ {
+ { XML_FIRST_ROW, OUString( RTL_CONSTASCII_USTRINGPARAM( "first-row" ) ) },
+ { XML_LAST_ROW, OUString( RTL_CONSTASCII_USTRINGPARAM( "last-row" ) ) },
+ { XML_FIRST_COLUMN, OUString( RTL_CONSTASCII_USTRINGPARAM( "first-column" ) ) },
+ { XML_LAST_COLUMN, OUString( RTL_CONSTASCII_USTRINGPARAM( "last-column" ) ) },
+ { XML_EVEN_ROWS, OUString( RTL_CONSTASCII_USTRINGPARAM( "even-rows" ) ) },
+ { XML_ODD_ROWS, OUString( RTL_CONSTASCII_USTRINGPARAM( "odd-rows" ) ) },
+ { XML_EVEN_COLUMNS, OUString( RTL_CONSTASCII_USTRINGPARAM( "even-columns" ) ) },
+ { XML_ODD_COLUMNS, OUString( RTL_CONSTASCII_USTRINGPARAM( "odd-columns" ) ) },
+ { XML_BODY, OUString( RTL_CONSTASCII_USTRINGPARAM( "body" ) ) },
+ { XML_TOKEN_END, OUString() }
+ };
+
+ return &gTableStyleElements[0];
+}
+
+// --------------------------------------------------------------------
+
+void XMLTableExport::exportTableTemplates()
+{
+ if( !mbExportTables )
+ return;
+
+ try
+ {
+ Reference< XStyleFamiliesSupplier > xFamiliesSupp( mrExport.GetModel(), UNO_QUERY_THROW );
+ Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
+ const OUString sFamilyName( RTL_CONSTASCII_USTRINGPARAM("table" ) );
+ Reference< XIndexAccess > xTableFamily( xFamilies->getByName( sFamilyName ), UNO_QUERY_THROW );
+
+ for( sal_Int32 nIndex = 0; nIndex < xTableFamily->getCount(); nIndex++ ) try
+ {
+ Reference< XStyle > xTableStyle( xTableFamily->getByIndex( nIndex ), UNO_QUERY_THROW );
+ if( !xTableStyle->isInUse() )
+ continue;
+
+ Reference< XNameAccess > xStyleNames( xTableStyle, UNO_QUERY_THROW );
+
+ mrExport.AddAttribute(XML_NAMESPACE_TEXT, XML_STYLE_NAME, GetExport().EncodeStyleName( xTableStyle->getName() ) );
+ SvXMLElementExport tableTemplate( mrExport, XML_NAMESPACE_TABLE, XML_TABLE_TEMPLATE, sal_True, sal_True );
+
+ const TableStyleElement* pElements = getTableStyleMap();
+ while( pElements->meElement != XML_TOKEN_END )
+ {
+ try
+ {
+ Reference< XStyle > xStyle( xStyleNames->getByName( pElements->msStyleName ), UNO_QUERY );
+ if( xStyle.is() )
+ {
+ mrExport.AddAttribute(XML_NAMESPACE_TEXT, XML_STYLE_NAME, GetExport().EncodeStyleName( xStyle->getName() ) );
+ SvXMLElementExport element( mrExport, XML_NAMESPACE_TABLE, pElements->meElement, sal_True, sal_True );
+ }
+ }
+ catch( Exception& )
+ {
+ DBG_ERROR("xmloff::XMLTableExport::exportTableTemplates(), exception caught!");
+ }
+
+ pElements++;
+ }
+ }
+ catch( Exception& )
+ {
+ DBG_ERROR("xmloff::XMLTableExport::exportTableDesigns(), exception caught while exporting a table design!");
+ }
+ }
+ catch( Exception& )
+ {
+ DBG_ERROR("xmloff::XMLTableExport::exportTableDesigns(), exception caught!");
+ }
+}
+
+// --------------------------------------------------------------------
+
diff --git a/xmloff/source/table/XMLTableImport.cxx b/xmloff/source/table/XMLTableImport.cxx
new file mode 100644
index 000000000000..875c17aa91fc
--- /dev/null
+++ b/xmloff/source/table/XMLTableImport.cxx
@@ -0,0 +1,826 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org 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 version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// 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;
+ bool mbListContextPushed;
+
+ 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++)
+ {
+ const OUString sAttrName( xAttrList->getNameByIndex( i ) );
+ const OUString sValue( xAttrList->getValueByIndex( i ) );
+ OUString aLocalName;
+
+ sal_uInt16 nPrefix2 = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
+ if( XML_NAMESPACE_TABLE == nPrefix2 )
+ {
+ 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 );
+ }
+ }
+ else if ( (XML_NAMESPACE_XML == nPrefix2) &&
+ IsXMLToken(aLocalName, XML_ID) )
+ {
+ (void) sValue;
+//FIXME: TODO
+ }
+ }
+
+ 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++)
+ {
+ const OUString sAttrName( xAttrList->getNameByIndex( i ) );
+ const OUString sValue( xAttrList->getValueByIndex( i ) );
+ OUString aLocalName;
+
+ sal_uInt16 nPrefix2 = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
+ if( nPrefix2 == XML_NAMESPACE_TABLE )
+ {
+ 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 );
+ }
+ }
+ else if ( (XML_NAMESPACE_XML == nPrefix2) &&
+ IsXMLToken(aLocalName, XML_ID) )
+ {
+ (void) sValue;
+//FIXME: TODO
+ }
+ }
+
+ 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 )
+, mbListContextPushed( false )
+, mnColSpan( 1 )
+, mnRowSpan( 1 )
+, mnRepeated( 1 )
+{
+ OUString sStyleName;
+
+ // read attributes for the table-cell
+ sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+ for(sal_Int16 i=0; i < nAttrCount; i++)
+ {
+ const OUString sAttrName( xAttrList->getNameByIndex( i ) );
+ const OUString sValue( xAttrList->getValueByIndex( i ) );
+ OUString aLocalName;
+
+ sal_uInt16 nPrefix2 = GetImport().GetNamespaceMap().GetKeyByAttrName( sAttrName, &aLocalName );
+ if( XML_NAMESPACE_TABLE == nPrefix2 )
+ {
+ 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;
+ }
+ }
+ else if ( (XML_NAMESPACE_XML == nPrefix2) &&
+ IsXMLToken(aLocalName, XML_ID) )
+ {
+ (void) sValue;
+//FIXME: TODO
+ }
+//FIXME: RDFa (table:table-cell)
+ }
+
+ // 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
+ xTxtImport->PushListContext();
+ mbListContextPushed = true;
+ }
+ }
+
+ 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 (mbListContextPushed) {
+ GetImport().GetTextImport()->PopListContext();
+ }
+}
+
+// --------------------------------------------------------------------
+// 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 );
+}
+
+// --------------------------------------------------------------------
diff --git a/xmloff/source/table/makefile.mk b/xmloff/source/table/makefile.mk
new file mode 100644
index 000000000000..6f8c8efab7b6
--- /dev/null
+++ b/xmloff/source/table/makefile.mk
@@ -0,0 +1,48 @@
+#*************************************************************************
+#
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# Copyright 2000, 2010 Oracle and/or its affiliates.
+#
+# OpenOffice.org - a multi-platform office productivity suite
+#
+# This file is part of OpenOffice.org.
+#
+# OpenOffice.org is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# only, as published by the Free Software Foundation.
+#
+# OpenOffice.org 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 version 3 for more details
+# (a copy is included in the LICENSE file that accompanied this code).
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with OpenOffice.org. If not, see
+# <http://www.openoffice.org/license.html>
+# for a copy of the LGPLv3 License.
+#
+#*************************************************************************
+
+PRJ=..$/..
+PRJNAME=xmloff
+TARGET=table
+AUTOSEG=true
+ENABLE_EXCEPTIONS=TRUE
+
+# --- Settings -----------------------------------------------------
+
+.INCLUDE : settings.mk
+.INCLUDE: $(PRJ)$/util$/makefile.pmk
+
+# --- Files --------------------------------------------------------
+
+SLOFILES = \
+ $(SLO)$/XMLTableExport.obj\
+ $(SLO)$/XMLTableImport.obj
+
+# --- Targets --------------------------------------------------------------
+
+.INCLUDE : target.mk
+
diff --git a/xmloff/source/table/table.hxx b/xmloff/source/table/table.hxx
new file mode 100644
index 000000000000..cee34e1ee9b5
--- /dev/null
+++ b/xmloff/source/table/table.hxx
@@ -0,0 +1,45 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org 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 version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef _XMLOFF_TABLE_TABLE_HXX_
+#define _XMLOFF_TABLE_TABLE_HXX_
+
+#include "xmloff/xmltoken.hxx"
+
+struct XMLPropertyMapEntry;
+
+struct TableStyleElement
+{
+ ::xmloff::token::XMLTokenEnum meElement;
+ ::rtl::OUString msStyleName;
+};
+
+extern const TableStyleElement* getTableStyleMap();
+extern const XMLPropertyMapEntry* getColumnPropertiesMap();
+extern const XMLPropertyMapEntry* getRowPropertiesMap();
+
+#endif
diff --git a/xmloff/source/table/tabledesignsimporter.cxx b/xmloff/source/table/tabledesignsimporter.cxx
new file mode 100644
index 000000000000..7c4002df3013
--- /dev/null
+++ b/xmloff/source/table/tabledesignsimporter.cxx
@@ -0,0 +1,103 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org 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 version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// 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;
+
+// --------------------------------------------------------------------
+
+class TabelDesignsImporter : public SvXMLImport
+{
+ TabelDesignsImporter( const Reference< XMultiServiceFactory > & rSMgr );
+ ~TabelDesignsImporter() throw ();
+
+ SvXMLImportContext* CreateContext(USHORT nPrefix, const OUString& rLocalName, const Reference<XAttributeList>& xAttrList);
+}
+
+// --------------------------------------------------------------------
+
+TabelDesignsImporter::TabelDesignsImporter( const Reference< XMultiServiceFactory > & rSMgr )
+: SvXMLImport( rSMgr, true )
+{
+ // add namespaces
+ GetNamespaceMap().Add(
+ GetXMLToken(XML_NP_PRESENTATION),
+ GetXMLToken(XML_N_PRESENTATION),
+ XML_NAMESPACE_PRESENTATION);
+}
+
+// --------------------------------------------------------------------
+
+TabelDesignsImporter::~TabelDesignsImporter()
+{
+}
+
+// --------------------------------------------------------------------
+
+SvXMLImportContext* TabelDesignsImporter::CreateContext(USHORT nPrefix, const OUString& rLocalName, const Reference<XAttributeList>& xAttrList)
+{
+}
+
+// --------------------------------------------------------------------
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-15 06:44:16 +0000