| /************************************************************** | |
| * | |
| * 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_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 <com/sun/star/drawing/FillStyle.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 "xmloff/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, sal_uInt16 nPrfx, const OUString& rLName ); | |
| virtual SvXMLImportContext *CreateChildContext( sal_uInt16 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, sal_uInt16 nPrfx, const OUString& rLName, Reference< XColumnRowRange >& xColumnRowRange ); | |
| virtual ~XMLTableImportContext(); | |
| virtual SvXMLImportContext *CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList ); | |
| virtual void StartElement( const Reference< XAttributeList >& xAttrList ); | |
| virtual void EndElement(); | |
| void InitColumns(); | |
| SvXMLImportContext * ImportColumn( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList ); | |
| SvXMLImportContext * ImportRow( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList ); | |
| SvXMLImportContext * ImportCell( sal_uInt16 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, | |
| sal_uInt16 nPrfx, const OUString& rLName, | |
| const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList ); | |
| virtual ~XMLCellImportContext(); | |
| virtual SvXMLImportContext *CreateChildContext( sal_uInt16 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, sal_uInt16 nPrfx, const OUString& rLName, const Reference< XAttributeList >& xAttrList ); | |
| virtual SvXMLImportContext *CreateChildContext( sal_uInt16 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, sal_uInt16 nPrfx, const OUString& rLName ) | |
| : SvXMLImportContext( rImport, nPrfx, rLName ) | |
| , mxParent( xParent ) | |
| { | |
| } | |
| // -------------------------------------------------------------------- | |
| SvXMLImportContext * XMLProxyContext::CreateChildContext( sal_uInt16 nPrefix, const OUString& rLocalName, const Reference< XAttributeList >& xAttrList ) | |
| { | |
| if( mxParent.Is() ) | |
| return mxParent->CreateChildContext( nPrefix, rLocalName, xAttrList ); | |
| else | |
| return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList ); | |
| } | |
| // -------------------------------------------------------------------- | |
| // fo:background-color in style:table-cell-properties is a solid fill; chained before the text mapper, whose finished() ends the chain | |
| class XMLTableCellImportPropertyMapper : public SvXMLImportPropertyMapper | |
| { | |
| public: | |
| XMLTableCellImportPropertyMapper( const UniReference< XMLPropertySetMapper >& rMapper, SvXMLImport& rImport ) : SvXMLImportPropertyMapper( rMapper, rImport ) {} | |
| virtual void finished( ::std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const; | |
| }; | |
| void XMLTableCellImportPropertyMapper::finished( ::std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const | |
| { | |
| bool bHasBackground = false; | |
| bool bHasFillStyle = false; | |
| for( ::std::vector< XMLPropertyState >::const_iterator aIter( rProperties.begin() ); aIter != rProperties.end(); ++aIter ) | |
| { | |
| if( aIter->mnIndex == -1 ) | |
| continue; | |
| if( ( maPropMapper->GetEntryFlags( aIter->mnIndex ) & XML_TYPE_PROP_MASK ) == XML_TYPE_PROP_TABLE_CELL ) | |
| bHasBackground = true; | |
| else if( maPropMapper->GetEntryAPIName( aIter->mnIndex ).equalsAscii( "FillStyle" ) ) | |
| bHasFillStyle = true; | |
| } | |
| if( bHasBackground && !bHasFillStyle ) | |
| { | |
| const sal_Int32 nFillStyle = maPropMapper->FindEntryIndex( "FillStyle", XML_NAMESPACE_DRAW, GetXMLToken( XML_FILL ) ); | |
| if( nFillStyle != -1 ) | |
| rProperties.push_back( XMLPropertyState( nFillStyle, Any( ::com::sun::star::drawing::FillStyle_SOLID ) ) ); | |
| } | |
| SvXMLImportPropertyMapper::finished( rProperties, nStartIndex, nEndIndex ); | |
| } | |
| // -------------------------------------------------------------------- | |
| // 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(new XMLTableCellImportPropertyMapper( new XMLPropertySetMapper( getCellPropertiesMap(), xFactoryRef.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( sal_uInt16 nPrfx, const OUString& rLName, Reference< XColumnRowRange >& xColumnRowRange ) | |
| { | |
| rtl::Reference< XMLTableImport > xThis( this ); | |
| return new XMLTableImportContext( xThis, nPrfx, rLName, xColumnRowRange ); | |
| } | |
| // -------------------------------------------------------------------- | |
| SvXMLStyleContext* XMLTableImport::CreateTableTemplateContext( sal_uInt16 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, sal_uInt16 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( sal_uInt16 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( sal_uInt16 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( sal_uInt16 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( sal_uInt16 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, sal_uInt16 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( sal_uInt16 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, sal_uInt16 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; | |
| sal_uInt16 nAttrPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( i ), &sAttrName ); | |
| if( ( (nAttrPrefix == XML_NAMESPACE_TEXT ) && IsXMLToken( sAttrName, XML_STYLE_NAME ) ) || | |
| ( (nAttrPrefix == XML_NAMESPACE_TABLE ) && IsXMLToken( sAttrName, XML_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( sal_uInt16 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; | |
| sal_uInt16 nAttrPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( i ), &sAttrName ); | |
| if( ( (nAttrPrefix == XML_NAMESPACE_TEXT) || (nAttrPrefix == XML_NAMESPACE_TABLE) ) && IsXMLToken( sAttrName, XML_STYLE_NAME ) ) | |
| { | |
| maTableTemplate[pElements->msStyleName] = xAttrList->getValueByIndex( i ); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList ); | |
| } | |
| // -------------------------------------------------------------------- |