| /************************************************************** |
| * |
| * 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 "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 ); |
| } |
| |
| // -------------------------------------------------------------------- |
| // 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( 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 ) ) |
| { |
| 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) && IsXMLToken( sAttrName, XML_STYLE_NAME ) ) |
| { |
| maTableTemplate[pElements->msStyleName] = xAttrList->getValueByIndex( i ); |
| break; |
| } |
| } |
| } |
| } |
| |
| return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList ); |
| } |
| |
| // -------------------------------------------------------------------- |