| /************************************************************** |
| * |
| * 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/xml/sax/SAXParseException.hpp> |
| #include <com/sun/star/xml/sax/SAXException.hpp> |
| #include <com/sun/star/xml/sax/XDocumentHandler.hpp> |
| #include <com/sun/star/xml/sax/XAttributeList.hpp> |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/xmltoken.hxx> |
| #include "xmloff/xmlnmspe.hxx" |
| #include "PropType.hxx" |
| #include "DeepTContext.hxx" |
| #include "RenameElemTContext.hxx" |
| #include "ProcAttrTContext.hxx" |
| #include "ActionMapTypesOOo.hxx" |
| #include "MutableAttrList.hxx" |
| #include "TransformerActions.hxx" |
| #include "PropertyActionsOOo.hxx" |
| #ifndef _XMLOFF_TRANSFORMERBASE_HXX |
| #include "TransformerBase.hxx" |
| #endif |
| |
| #ifndef _XMLOFF_STYLEOASISTCONTEXT_HXX |
| #include "StyleOOoTContext.hxx" |
| #endif |
| #include <xmloff/xmluconv.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/math.hxx> |
| |
| using ::rtl::OUString; |
| using namespace ::xmloff::token; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::xml::sax; |
| |
| const sal_uInt16 MAX_PROP_TYPES = 4; |
| #define ENTRY4(a,b,c,d) \ |
| { XML_PROP_TYPE_##a, XML_PROP_TYPE_##b, \ |
| XML_PROP_TYPE_##c, XML_PROP_TYPE_##d } |
| #define ENTRY3(a,b,c) \ |
| { XML_PROP_TYPE_##a, XML_PROP_TYPE_##b, \ |
| XML_PROP_TYPE_##c, XML_PROP_TYPE_END } |
| #define ENTRY2(a,b) \ |
| { XML_PROP_TYPE_##a, XML_PROP_TYPE_##b, \ |
| XML_PROP_TYPE_END, XML_PROP_TYPE_END } |
| #define ENTRY1(a) \ |
| { XML_PROP_TYPE_##a, XML_PROP_TYPE_##END, \ |
| XML_PROP_TYPE_END, XML_PROP_TYPE_END } |
| |
| static XMLPropType aPropTypes[XML_FAMILY_TYPE_END][MAX_PROP_TYPES] = |
| { |
| ENTRY3( GRAPHIC, PARAGRAPH, TEXT ), // XML_FAMILY_TYPE_GRAPHIC, |
| ENTRY3( GRAPHIC, PARAGRAPH, TEXT ), // XML_FAMILY_TYPE_PRESENTATION, |
| ENTRY1( DRAWING_PAGE ), // XML_FAMILY_TYPE_DRAWING_PAGE, |
| ENTRY1( END ), // XML_FAMILY_TYPE_MASTER_PAGE |
| ENTRY1( PAGE_LAYOUT ), // XML_FAMILY_TYPE_PAGE_LAYOUT, |
| ENTRY1( HEADER_FOOTER ), // XML_FAMILY_TYPE_HEADER_FOOTER |
| ENTRY1( TEXT ), // XML_FAMILY_TYPE_TEXT, |
| ENTRY2( PARAGRAPH, TEXT ), // XML_FAMILY_TYPE_PARAGRAPH, |
| ENTRY1( RUBY ), //XML_FAMILY_TYPE_RUBY, |
| ENTRY1( SECTION ), // XML_FAMILY_TYPE_SECTION, |
| ENTRY1( TABLE ), // XML_FAMILY_TYPE_TABLE, |
| ENTRY1( TABLE_COLUMN ), // XML_FAMILY_TYPE_TABLE_COLUMN, |
| ENTRY1( TABLE_ROW ), // XML_FAMILY_TYPE_TABLE_ROW, |
| ENTRY3( TABLE_CELL, PARAGRAPH, TEXT ), // XML_FAMILY_TYPE_TABLE_CELL, |
| ENTRY1( LIST_LEVEL ), // XML_FAMILY_TYPE_LIST, |
| ENTRY4( CHART, GRAPHIC, PARAGRAPH, TEXT ), // XML_FAMILY_TYPE_CHART, |
| ENTRY1( TEXT ), // XML_FAMILY_TYPE_DATA, |
| ENTRY1( END ), // XML_FAMILY_TYPE_GRADIENT, |
| ENTRY1( END ), // XML_FAMILY_TYPE_HATCH, |
| ENTRY1( END ), // XML_FAMILY_TYPE_FILL_IMAGE, |
| ENTRY1( END ), // XML_FAMILY_TYPE_STROKE_DASH, |
| ENTRY1( END ), // XML_FAMILY_TYPE_MARKER, |
| ENTRY1( END ) // XML_FAMILY_TYPE_PRESENTATION_PAGE_LAYOUT, |
| }; |
| |
| static XMLTokenEnum aPropTokens[XML_PROP_TYPE_END] = |
| { |
| XML_GRAPHIC_PROPERTIES, |
| XML_DRAWING_PAGE_PROPERTIES, |
| XML_PAGE_LAYOUT_PROPERTIES, |
| XML_HEADER_FOOTER_PROPERTIES, |
| XML_TEXT_PROPERTIES, |
| XML_PARAGRAPH_PROPERTIES, |
| XML_RUBY_PROPERTIES, |
| XML_SECTION_PROPERTIES, |
| XML_TABLE_PROPERTIES, |
| XML_TABLE_COLUMN_PROPERTIES, |
| XML_TABLE_ROW_PROPERTIES, |
| XML_TABLE_CELL_PROPERTIES, |
| XML_LIST_LEVEL_PROPERTIES, |
| XML_CHART_PROPERTIES |
| }; |
| |
| static sal_uInt16 aAttrActionMaps[XML_PROP_TYPE_END] = |
| { |
| PROP_OOO_GRAPHIC_ATTR_ACTIONS, |
| PROP_OOO_DRAWING_PAGE_ATTR_ACTIONS, // DRAWING_PAGE |
| PROP_OOO_PAGE_LAYOUT_ATTR_ACTIONS, |
| PROP_OOO_HEADER_FOOTER_ATTR_ACTIONS, |
| PROP_OOO_TEXT_ATTR_ACTIONS, |
| PROP_OOO_PARAGRAPH_ATTR_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, // RUBY |
| PROP_OOO_SECTION_ATTR_ACTIONS, |
| PROP_OOO_TABLE_ATTR_ACTIONS, |
| PROP_OOO_TABLE_COLUMN_ATTR_ACTIONS, |
| PROP_OOO_TABLE_ROW_ATTR_ACTIONS, |
| PROP_OOO_TABLE_CELL_ATTR_ACTIONS, |
| PROP_OOO_LIST_LEVEL_ATTR_ACTIONS, |
| PROP_OOO_CHART_ATTR_ACTIONS |
| }; |
| |
| static sal_uInt16 aElemActionMaps[XML_PROP_TYPE_END] = |
| { |
| PROP_OOO_GRAPHIC_ELEM_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| PROP_OOO_TEXT_ELEM_ACTIONS, |
| PROP_OOO_PARAGRAPH_ELEM_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| PROP_OOO_TABLE_CELL_ELEM_ACTIONS, |
| MAX_OOO_PROP_ACTIONS, |
| PROP_OOO_CHART_ELEM_ACTIONS |
| }; |
| |
| |
| //------------------------------------------------------------------------------ |
| |
| class XMLTypedPropertiesOOoTContext_Impl : public XMLPersElemContentTContext |
| { |
| ::com::sun::star::uno::Reference< |
| ::com::sun::star::xml::sax::XAttributeList > m_xAttrList; |
| |
| public: |
| |
| TYPEINFO(); |
| |
| XMLTypedPropertiesOOoTContext_Impl( XMLTransformerBase& rTransformer, |
| const ::rtl::OUString& rQName ); |
| |
| virtual ~XMLTypedPropertiesOOoTContext_Impl(); |
| |
| using XMLPersAttrListTContext::AddAttribute; |
| void AddAttribute( const ::rtl::OUString &sName , |
| const ::rtl::OUString &sValue ); |
| void AddAttribute( sal_uInt16 nPrefix, XMLTokenEnum eToken, |
| const ::rtl::OUString &sValue ); |
| |
| virtual void StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& rAttrList ); |
| |
| virtual void Export(); |
| }; |
| |
| TYPEINIT1( XMLTypedPropertiesOOoTContext_Impl, XMLPersElemContentTContext ); |
| |
| XMLTypedPropertiesOOoTContext_Impl::XMLTypedPropertiesOOoTContext_Impl( |
| XMLTransformerBase& rImp, |
| const OUString& rQName ) : |
| XMLPersElemContentTContext( rImp, rQName ), |
| m_xAttrList( new XMLMutableAttributeList() ) |
| { |
| } |
| |
| XMLTypedPropertiesOOoTContext_Impl::~XMLTypedPropertiesOOoTContext_Impl() |
| { |
| } |
| |
| void XMLTypedPropertiesOOoTContext_Impl::AddAttribute( |
| const ::rtl::OUString &sName , |
| const ::rtl::OUString &sValue ) |
| { |
| static_cast< XMLMutableAttributeList * >( m_xAttrList.get() ) |
| ->AddAttribute( sName, sValue ); |
| } |
| |
| void XMLTypedPropertiesOOoTContext_Impl::AddAttribute( |
| sal_uInt16 nPrefix, XMLTokenEnum eToken, |
| const ::rtl::OUString &sValue ) |
| { |
| OUString sName( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| nPrefix, ::xmloff::token::GetXMLToken( eToken ) ) ); |
| static_cast< XMLMutableAttributeList * >( m_xAttrList.get() ) |
| ->AddAttribute( sName, sValue ); |
| } |
| |
| void XMLTypedPropertiesOOoTContext_Impl::StartElement( |
| const Reference< XAttributeList >& ) |
| { |
| // empty, ignore even the attribute list |
| } |
| |
| void XMLTypedPropertiesOOoTContext_Impl::Export() |
| { |
| if( m_xAttrList->getLength() || HasElementContent() ) |
| { |
| GetTransformer().GetDocHandler()->startElement( GetQName(), m_xAttrList ); |
| ExportContent(); |
| GetTransformer().GetDocHandler()->endElement( GetQName() ); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| |
| class XMLPropertiesOOoTContext_Impl : public XMLTransformerContext |
| { |
| ::rtl::Reference < XMLTypedPropertiesOOoTContext_Impl > |
| m_aPropContexts[MAX_PROP_TYPES]; |
| |
| typedef XMLPropType XMLPropTypes[MAX_PROP_TYPES]; |
| |
| XMLPropTypes m_aPropTypes; |
| |
| sal_Bool m_bPersistent; |
| |
| XMLTypedPropertiesOOoTContext_Impl *GetPropContextAndAction( |
| TransformerAction_Impl& rAction, |
| sal_uInt16 nPrefix, const OUString& rLocalName, |
| sal_Bool bElem ); |
| |
| XMLTypedPropertiesOOoTContext_Impl *GetPropContext( |
| XMLPropType eType ); |
| |
| |
| public: |
| |
| TYPEINFO(); |
| |
| XMLPropertiesOOoTContext_Impl( XMLTransformerBase& rTransformer, |
| const ::rtl::OUString& rQName, |
| XMLPropTypes& rTypes, |
| sal_Bool bPersistent ); |
| |
| virtual ~XMLPropertiesOOoTContext_Impl(); |
| |
| XMLTransformerContext *CreateChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const OUString& rQName, |
| const Reference< XAttributeList >& rAttrList ); |
| |
| virtual void StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& rAttrList ); |
| |
| virtual void EndElement(); |
| |
| virtual void Characters( const ::rtl::OUString& rChars ); |
| |
| virtual void Export(); |
| |
| virtual sal_Bool IsPersistent() const; |
| }; |
| |
| TYPEINIT1( XMLPropertiesOOoTContext_Impl, XMLTransformerContext ); |
| |
| XMLTypedPropertiesOOoTContext_Impl |
| *XMLPropertiesOOoTContext_Impl::GetPropContext( |
| XMLPropType eType ) |
| { |
| sal_uInt16 nIndex = MAX_PROP_TYPES; |
| for( sal_uInt16 i=0; i< MAX_PROP_TYPES; i++ ) |
| { |
| if( m_aPropTypes[i] == eType ) |
| { |
| nIndex = i; |
| break; |
| } |
| } |
| if( MAX_PROP_TYPES == nIndex ) |
| return 0; |
| |
| if( !m_aPropContexts[nIndex].is() ) |
| { |
| m_aPropContexts[nIndex] = |
| new XMLTypedPropertiesOOoTContext_Impl( |
| GetTransformer(), |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| ::xmloff::token::GetXMLToken( |
| aPropTokens[m_aPropTypes[nIndex]] ) )); |
| } |
| |
| return m_aPropContexts[nIndex].get(); |
| } |
| |
| |
| XMLTypedPropertiesOOoTContext_Impl |
| *XMLPropertiesOOoTContext_Impl::GetPropContextAndAction( |
| TransformerAction_Impl& rAction, |
| sal_uInt16 nPrefix, const OUString& rLocalName, |
| sal_Bool bElem ) |
| { |
| rAction.m_nActionType = XML_ATACTION_COPY; |
| sal_uInt16 nIndex = 0; |
| |
| XMLTransformerActions::key_type aKey( nPrefix, rLocalName ); |
| sal_uInt16 i=0; |
| while( i < MAX_PROP_TYPES && XML_PROP_TYPE_END!=m_aPropTypes[i]) |
| { |
| sal_uInt16 nActionMap = |
| (bElem ? aElemActionMaps : aAttrActionMaps)[m_aPropTypes[i]]; |
| if( nActionMap < MAX_OOO_PROP_ACTIONS ) |
| { |
| XMLTransformerActions *pActions = |
| GetTransformer().GetUserDefinedActions( nActionMap ); |
| OSL_ENSURE( pActions, "go no actions" ); |
| if( pActions ) |
| { |
| XMLTransformerActions::const_iterator aIter = |
| pActions->find( aKey ); |
| |
| if( !(aIter == pActions->end()) ) |
| { |
| rAction = (*aIter).second; |
| nIndex = i; |
| break; |
| } |
| } |
| } |
| ++i; |
| } |
| |
| #ifdef DBG_UTIL |
| if( !( XML_NAMESPACE_NONE == nPrefix || |
| (XML_NAMESPACE_UNKNOWN_FLAG & nPrefix) || |
| XML_PROP_TYPE_END==m_aPropTypes[1] || |
| (i<MAX_PROP_TYPES && XML_PROP_TYPE_END!=m_aPropTypes[i]) ) ) |
| { |
| ::rtl::OString aTmp("Didnt't find property: "); |
| const ::rtl::OUString& rPrefix = |
| GetTransformer().GetNamespaceMap().GetPrefixByKey( nPrefix ); |
| aTmp += ::rtl::OString( rPrefix.getStr(), rPrefix.getLength(), |
| RTL_TEXTENCODING_ASCII_US ); |
| aTmp += ::rtl::OString::valueOf( ':' ); |
| aTmp += ::rtl::OString( rLocalName.getStr(), rLocalName.getLength(), |
| RTL_TEXTENCODING_ASCII_US ); |
| aTmp += ::rtl::OString(", assuming <style:"); |
| const ::rtl::OUString& rName = |
| ::xmloff::token::GetXMLToken( aPropTokens[m_aPropTypes[0]] ); |
| aTmp += ::rtl::OString( rName.getStr(), rName.getLength(), |
| RTL_TEXTENCODING_ASCII_US ); |
| aTmp += ::rtl::OString::valueOf( '>' ); |
| |
| OSL_ENSURE( !this, aTmp ); |
| } |
| #endif |
| |
| if( !m_aPropContexts[nIndex].is() ) |
| { |
| m_aPropContexts[nIndex] = |
| new XMLTypedPropertiesOOoTContext_Impl( |
| GetTransformer(), |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| ::xmloff::token::GetXMLToken( |
| aPropTokens[m_aPropTypes[nIndex]] ) )); |
| } |
| |
| return m_aPropContexts[nIndex].get(); |
| } |
| |
| XMLPropertiesOOoTContext_Impl::XMLPropertiesOOoTContext_Impl( |
| XMLTransformerBase& rImp, |
| const OUString& rQName, |
| XMLPropTypes& rTypes, |
| sal_Bool bPersistent ) : |
| XMLTransformerContext( rImp, rQName ), |
| m_bPersistent( bPersistent ) |
| { |
| for( sal_uInt16 i=0; i < MAX_PROP_TYPES; ++i ) |
| { |
| // remember the types that belong to the attribute and element lists |
| m_aPropTypes[i] = rTypes[i]; |
| } |
| } |
| |
| XMLPropertiesOOoTContext_Impl::~XMLPropertiesOOoTContext_Impl() |
| { |
| } |
| |
| XMLTransformerContext *XMLPropertiesOOoTContext_Impl::CreateChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const OUString& rQName, |
| const Reference< XAttributeList >& rAttrList ) |
| { |
| TransformerAction_Impl aAction; |
| return GetPropContextAndAction( aAction, nPrefix, rLocalName, sal_True ) |
| ->CreateChildContext( nPrefix, rLocalName, rQName, rAttrList ); |
| } |
| |
| |
| void XMLPropertiesOOoTContext_Impl::StartElement( |
| const Reference< XAttributeList >& rAttrList ) |
| { |
| Reference< XAttributeList > xAttrList( rAttrList ); |
| |
| XMLTypedPropertiesOOoTContext_Impl * pIntervalMinorDivisorContext = 0; |
| double fIntervalMajor = 0.0; |
| double fIntervalMinor = 0.0; |
| sal_Bool bMoveProtect = sal_False; |
| sal_Bool bSizeProtect = sal_False; |
| OUString aProtectAttrValue; |
| XMLTypedPropertiesOOoTContext_Impl * pProtectContext = 0; |
| |
| // --> OD 2005-05-13 #i49139# - attribute <style:mirror> has to be priority |
| // over attribute <style:draw>. The filter from OpenDocument file format |
| // to OpenOffice.org file format produces styles with both attributes. |
| sal_Bool bExistStyleMirror( sal_False ); |
| OUString aStyleMirrorAttrValue; |
| sal_Bool bExistDrawMirror( sal_False ); |
| OUString aDrawMirrorAttrValue; |
| XMLTypedPropertiesOOoTContext_Impl* pMirrorContext( 0L ); |
| // <-- |
| |
| sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; |
| for( sal_Int16 i=0; i < nAttrCount; i++ ) |
| { |
| const OUString sAttrName = xAttrList->getNameByIndex( i ); |
| const OUString sAttrValue = xAttrList->getValueByIndex( i ); |
| OUString aLocalName; |
| sal_uInt16 nPrefix = |
| GetTransformer().GetNamespaceMap().GetKeyByAttrName( sAttrName, |
| &aLocalName ); |
| TransformerAction_Impl aAction; |
| XMLTypedPropertiesOOoTContext_Impl *pContext = |
| GetPropContextAndAction( aAction, nPrefix, aLocalName, sal_False ); |
| switch( aAction.m_nActionType ) |
| { |
| case XML_ATACTION_REMOVE: |
| break; |
| case XML_ATACTION_COPY: |
| pContext->AddAttribute( sAttrName, sAttrValue ); |
| break; |
| case XML_ATACTION_COPY_DUPLICATE: |
| { |
| pContext->AddAttribute( sAttrName, sAttrValue ); |
| XMLTypedPropertiesOOoTContext_Impl *pContext2 = |
| GetPropContext( (XMLPropType)aAction.m_nParam1 ); |
| if( pContext2 ) |
| pContext2->AddAttribute( sAttrName, sAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME: |
| { |
| pContext->AddAttribute( aAction.GetQNamePrefixFromParam1(), |
| aAction.GetQNameTokenFromParam1(), |
| sAttrValue ); |
| } |
| break; |
| case XML_ATACTION_ENCODE_STYLE_NAME_REF: |
| { |
| OUString aAttrValue( sAttrValue ); |
| GetTransformer().EncodeStyleName(aAttrValue); |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_ENCODE_STYLE_NAME_REF: |
| { |
| OUString aAttrValue( sAttrValue ); |
| GetTransformer().EncodeStyleName(aAttrValue); |
| pContext->AddAttribute( aAction.GetQNamePrefixFromParam1(), |
| aAction.GetQNameTokenFromParam1(), |
| aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_NEG_PERCENT: |
| { |
| OUString aAttrValue( sAttrValue ); |
| GetTransformer().NegPercent(aAttrValue); |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_NEG_PERCENT: |
| { |
| OUString aAttrValue( sAttrValue ); |
| GetTransformer().NegPercent(aAttrValue); |
| pContext->AddAttribute( aAction.GetQNamePrefixFromParam1(), |
| aAction.GetQNameTokenFromParam1(), |
| aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_INCH2IN: |
| { |
| OUString aAttrValue( sAttrValue ); |
| XMLTransformerBase::ReplaceSingleInchWithIn( aAttrValue ); |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_INCH2IN_DUPLICATE: |
| { |
| OUString aAttrValue( sAttrValue ); |
| XMLTransformerBase::ReplaceSingleInchWithIn( aAttrValue ); |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| XMLTypedPropertiesOOoTContext_Impl *pContext2 = |
| GetPropContext( (XMLPropType)aAction.m_nParam1 ); |
| if( pContext2 ) |
| pContext2->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_INCHS2INS: |
| { |
| OUString aAttrValue( sAttrValue ); |
| XMLTransformerBase::ReplaceInchWithIn( aAttrValue ); |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_PTACTION_LINE_MODE: |
| { |
| OUString aAttrValue( GetXMLToken( |
| IsXMLToken( sAttrValue, XML_TRUE ) |
| ? XML_CONTINUOUS |
| : XML_SKIP_WHITE_SPACE) ); |
| OUString aAttrQName( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_UNDERLINE_MODE ) ) ); |
| pContext->AddAttribute( aAttrQName, aAttrValue ); |
| |
| aAttrQName = |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_LINE_THROUGH_MODE ) ); |
| pContext->AddAttribute( aAttrQName, aAttrValue ); |
| } |
| break; |
| case XML_PTACTION_KEEP_WITH_NEXT: |
| { |
| OUString aAttrValue( GetXMLToken( |
| IsXMLToken( sAttrValue, XML_TRUE ) |
| ? XML_ALWAYS |
| : XML_AUTO) ); |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_PTACTION_UNDERLINE: |
| { |
| XMLTokenEnum eToken = GetTransformer().GetToken( sAttrValue ); |
| sal_Bool bBold = sal_False, bDouble = sal_False; |
| switch( eToken ) |
| { |
| case XML_SINGLE: |
| eToken = XML_SOLID; |
| break; |
| case XML_DOUBLE: |
| eToken = XML_SOLID; |
| bDouble = sal_True; |
| break; |
| case XML_BOLD: |
| eToken = XML_SOLID; |
| bBold = sal_True; |
| break; |
| case XML_BOLD_DOTTED: |
| eToken = XML_DOTTED; |
| bBold = sal_True; |
| break; |
| case XML_BOLD_DASH: |
| eToken = XML_DASH; |
| bBold = sal_True; |
| break; |
| case XML_BOLD_LONG_DASH: |
| eToken = XML_LONG_DASH; |
| bBold = sal_True; |
| break; |
| case XML_BOLD_DOT_DASH: |
| eToken = XML_DOT_DASH; |
| bBold = sal_True; |
| break; |
| case XML_BOLD_DOT_DOT_DASH: |
| eToken = XML_DOT_DOT_DASH; |
| bBold = sal_True; |
| break; |
| case XML_BOLD_WAVE: |
| eToken = XML_WAVE; |
| bBold = sal_True; |
| break; |
| case XML_DOUBLE_WAVE: |
| eToken = XML_WAVE; |
| bDouble = sal_True; |
| break; |
| case XML_NONE: |
| eToken = XML_NONE; |
| bDouble = sal_False; |
| break; |
| default: |
| OSL_ENSURE( false, "xmloff::XMLPropertiesOOoTContext_Impl::StartElement(), unknown underline token!" ); |
| break; |
| } |
| pContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_UNDERLINE_STYLE ) ), |
| eToken != XML_TOKEN_END ? GetXMLToken( eToken ) |
| : sAttrValue ); |
| if( bDouble ) |
| pContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_UNDERLINE_TYPE ) ), |
| GetXMLToken( XML_DOUBLE ) ); |
| if( bBold ) |
| pContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_UNDERLINE_WIDTH ) ), |
| GetXMLToken( XML_BOLD ) ); |
| } |
| break; |
| case XML_PTACTION_LINETHROUGH: |
| { |
| XMLTokenEnum eToken = GetTransformer().GetToken( sAttrValue ); |
| sal_Bool bBold = sal_False, bDouble = sal_False; |
| sal_Unicode c = 0; |
| switch( eToken ) |
| { |
| case XML_SINGLE_LINE: |
| eToken = XML_SOLID; |
| break; |
| case XML_DOUBLE_LINE: |
| eToken = XML_SOLID; |
| bDouble = sal_True; |
| break; |
| case XML_THICK_LINE: |
| eToken = XML_SOLID; |
| bBold = sal_True; |
| break; |
| case XML_SLASH: |
| eToken = XML_SOLID; |
| c = '/'; |
| break; |
| case XML_uX: |
| eToken = XML_SOLID; |
| c = 'X'; |
| break; |
| default: |
| break; |
| } |
| pContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_LINE_THROUGH_STYLE ) ), |
| eToken != XML_TOKEN_END ? GetXMLToken( eToken ) |
| : sAttrValue ); |
| if( bDouble ) |
| pContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_LINE_THROUGH_TYPE ) ), |
| GetXMLToken( XML_DOUBLE ) ); |
| if( bBold ) |
| pContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_LINE_THROUGH_WIDTH ) ), |
| GetXMLToken( XML_BOLD ) ); |
| if( c ) |
| pContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, |
| GetXMLToken( XML_TEXT_LINE_THROUGH_TEXT ) ), |
| OUString::valueOf( c ) ); |
| } |
| break; |
| case XML_PTACTION_SPLINES: |
| { |
| sal_Int32 nSplineType = sAttrValue.toInt32(); |
| OUString aNewAttrName = GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_CHART, GetXMLToken( XML_INTERPOLATION ) ); |
| |
| switch( nSplineType ) |
| { |
| // straight lines |
| case 0: |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_NONE )); |
| break; |
| // cubic spline |
| case 1: |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_CUBIC_SPLINE )); |
| break; |
| // B-spline |
| case 2: |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_B_SPLINE )); |
| break; |
| |
| default: |
| OSL_ENSURE( false, "invalid spline type" ); |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_NONE )); |
| break; |
| } |
| } |
| break; |
| case XML_PTACTION_INTERVAL_MAJOR: |
| pContext->AddAttribute( sAttrName, sAttrValue ); |
| SvXMLUnitConverter::convertDouble( fIntervalMajor, sAttrValue ); |
| break; |
| case XML_PTACTION_INTERVAL_MINOR: |
| SvXMLUnitConverter::convertDouble( fIntervalMinor, sAttrValue ); |
| pIntervalMinorDivisorContext = pContext; |
| break; |
| case XML_PTACTION_SYMBOL: |
| { |
| sal_Int32 nSymbolType = sAttrValue.toInt32(); |
| OUString aNewAttrName = GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_CHART, GetXMLToken( XML_SYMBOL_TYPE ) ); |
| |
| if( nSymbolType >= 0 ) |
| { |
| pContext->AddAttribute( aNewAttrName, GetXMLToken( XML_NAMED_SYMBOL )); |
| enum XMLTokenEnum eToken = XML_TOKEN_INVALID; |
| switch( nSymbolType ) |
| { |
| // SYMBOL0 |
| case 0: |
| // "square" has an awkward token name |
| eToken = XML_GRADIENTSTYLE_SQUARE; |
| break; |
| // SYMBOL1 |
| case 1: |
| eToken = XML_DIAMOND; |
| break; |
| // SYMBOL2 |
| case 2: |
| eToken = XML_ARROW_DOWN; |
| break; |
| // SYMBOL3 |
| case 3: |
| eToken = XML_ARROW_UP; |
| break; |
| // SYMBOL4 |
| case 4: |
| eToken = XML_ARROW_RIGHT; |
| break; |
| // SYMBOL5 |
| case 5: |
| eToken = XML_ARROW_LEFT; |
| break; |
| // SYMBOL6 |
| case 6: |
| eToken = XML_BOW_TIE; |
| break; |
| // SYMBOL7 |
| case 7: |
| eToken = XML_HOURGLASS; |
| break; |
| case 8: |
| eToken = XML_CIRCLE; |
| break; |
| case 9: |
| eToken = XML_STAR; |
| break; |
| case 10: |
| eToken = XML_X; |
| break; |
| case 11: |
| eToken = XML_PLUS; |
| break; |
| case 12: |
| eToken = XML_ASTERISK; |
| break; |
| case 13: |
| eToken = XML_HORIZONTAL_BAR; |
| break; |
| case 14: |
| eToken = XML_VERTICAL_BAR; |
| break; |
| default: |
| OSL_ENSURE( false, "invalid named symbol" ); |
| break; |
| } |
| |
| if( eToken != XML_TOKEN_INVALID ) |
| { |
| pContext->AddAttribute( GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_CHART, GetXMLToken( XML_SYMBOL_NAME )), |
| GetXMLToken( eToken )); |
| } |
| } |
| else |
| { |
| switch( nSymbolType ) |
| { |
| // NONE |
| case -3: |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_NONE )); |
| break; |
| // AUTO |
| case -2: |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_AUTOMATIC )); |
| break; |
| // BITMAPURL |
| case -1: |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_IMAGE )); |
| break; |
| default: |
| OSL_ENSURE( false, "invalid symbol type" ); |
| pContext->AddAttribute( |
| aNewAttrName, GetXMLToken( XML_NONE )); |
| break; |
| } |
| } |
| } |
| break; |
| case XML_PTACTION_SYMBOL_IMAGE_NAME: |
| { |
| // create an xlink:href element for URI attribute |
| XMLPersAttrListTContext *pSymbolImageContext = new XMLPersAttrListTContext( |
| GetTransformer(), GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_CHART, GetXMLToken( XML_SYMBOL_IMAGE ))); |
| |
| OUString aAttrValue( sAttrValue ); |
| if( GetTransformer().ConvertURIToOASIS( aAttrValue, sal_True )) |
| { |
| pSymbolImageContext->AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aAttrValue ); |
| pContext->AddContent( pSymbolImageContext ); |
| } |
| } |
| break; |
| |
| // #i25616# |
| case XML_PTACTION_TRANSPARENCY : |
| { |
| OUString aAttrValue( sAttrValue ); |
| GetTransformer().NegPercent(aAttrValue); |
| pContext->AddAttribute( XML_NAMESPACE_DRAW, |
| XML_OPACITY, |
| aAttrValue ); |
| pContext->AddAttribute( XML_NAMESPACE_DRAW, |
| XML_IMAGE_OPACITY, |
| aAttrValue ); |
| } |
| break; |
| |
| case XML_PTACTION_BREAK_INSIDE: |
| { |
| pContext->AddAttribute( |
| XML_NAMESPACE_FO, XML_KEEP_TOGETHER, |
| GetXMLToken( |
| IsXMLToken( sAttrValue, XML_COLUMNSPLIT_AVOID ) |
| ? XML_ALWAYS |
| : XML_AUTO ) ); |
| } |
| break; |
| case XML_ATACTION_CAPTION_ESCAPE_OOO: |
| { |
| OUString aAttrValue( sAttrValue ); |
| if( aAttrValue.indexOf( sal_Unicode('%') ) != -1 ) |
| { |
| sal_Int32 nValue = 0; |
| SvXMLUnitConverter::convertPercent( nValue, sAttrValue ); |
| if( nValue ) |
| { |
| nValue /= 100; |
| rtl::OUStringBuffer aOut; |
| SvXMLUnitConverter::convertPercent( aOut, nValue ); |
| aAttrValue = aOut.makeStringAndClear(); |
| } |
| } |
| else |
| { |
| XMLTransformerBase::ReplaceSingleInchWithIn( aAttrValue ); |
| } |
| |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_MOVE_PROTECT: |
| bMoveProtect = IsXMLToken( sAttrValue, XML_TRUE ); |
| pProtectContext = pContext; |
| break; |
| case XML_ATACTION_SIZE_PROTECT: |
| bSizeProtect = IsXMLToken( sAttrValue, XML_TRUE ); |
| pProtectContext = pContext; |
| break; |
| case XML_ATACTION_PROTECT: |
| aProtectAttrValue = sAttrValue; |
| pProtectContext = pContext; |
| break; |
| case XML_ATACTION_DRAW_MIRROR_OOO: // renames draw:mirror to style:mirror and adapts values |
| { |
| // --> OD 2005-05-13 #i49139# |
| aDrawMirrorAttrValue = |
| GetXMLToken( IsXMLToken( sAttrValue, XML_TRUE ) |
| ? XML_HORIZONTAL : XML_NONE ); |
| bExistDrawMirror = sal_True; |
| pMirrorContext = pContext; |
| // <-- |
| } |
| break; |
| // --> OD 2005-05-12 #i49139# |
| case XML_ATACTION_STYLE_MIRROR_OOO: // adapts style:mirror values |
| { |
| SvXMLTokenEnumerator aTokenEnum( sAttrValue ); |
| OUString aToken; |
| while( aTokenEnum.getNextToken( aToken ) ) |
| { |
| if ( aStyleMirrorAttrValue.getLength() > 0 ) |
| { |
| aStyleMirrorAttrValue += rtl::OUString::createFromAscii( " " ); |
| } |
| |
| if ( IsXMLToken( aToken, XML_HORIZONTAL_ON_LEFT_PAGES ) ) |
| { |
| aStyleMirrorAttrValue += GetXMLToken( XML_HORIZONTAL_ON_EVEN ); |
| } |
| else if ( IsXMLToken( aToken, XML_HORIZONTAL_ON_RIGHT_PAGES ) ) |
| { |
| aStyleMirrorAttrValue += GetXMLToken( XML_HORIZONTAL_ON_ODD ); |
| } |
| else |
| { |
| aStyleMirrorAttrValue += aToken; |
| } |
| } |
| bExistStyleMirror = sal_True; |
| pMirrorContext = pContext; |
| } |
| break; |
| // <-- |
| case XML_ATACTION_GAMMA_OOO: // converts double value to percentage |
| { |
| double fValue = sAttrValue.toDouble(); |
| sal_Int32 nValue = (sal_Int32)((fValue * 100.0) + ( fValue > 0 ? 0.5 : - 0.5 ) ); |
| |
| rtl::OUStringBuffer aOut; |
| SvXMLUnitConverter::convertPercent( aOut, nValue ); |
| OUString aAttrValue( aOut.makeStringAndClear() ); |
| pContext->AddAttribute( sAttrName, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_OPACITY_FIX: |
| { |
| sal_Int32 nValue; |
| if( sAttrValue.indexOf( sal_Unicode('%') ) != -1 ) |
| { |
| SvXMLUnitConverter::convertPercent( nValue, sAttrValue ); |
| } |
| else |
| { |
| nValue = sal_Int32( sAttrValue.toDouble() * 100.0 ); |
| } |
| nValue = 100 - nValue; |
| |
| rtl::OUStringBuffer aOut; |
| SvXMLUnitConverter::convertPercent( aOut, nValue ); |
| pContext->AddAttribute( sAttrName, aOut.makeStringAndClear() ); |
| } |
| break; |
| default: |
| OSL_ENSURE( !this, "unknown action" ); |
| break; |
| } |
| } |
| |
| // --> OD 2005-05-13 #i49139# |
| if ( bExistStyleMirror ) |
| { |
| pMirrorContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, GetXMLToken( XML_MIRROR ) ), |
| aStyleMirrorAttrValue); |
| } |
| else if ( bExistDrawMirror ) |
| { |
| pMirrorContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_STYLE, GetXMLToken( XML_MIRROR ) ), |
| aDrawMirrorAttrValue); |
| } |
| // <-- |
| |
| if( bMoveProtect || bSizeProtect || aProtectAttrValue.getLength() ) |
| { |
| if( (bMoveProtect ||bSizeProtect) && IsXMLToken( aProtectAttrValue, XML_NONE ) ) |
| aProtectAttrValue = OUString(); |
| |
| const OUString& rPosition = GetXMLToken( XML_POSITION ); |
| if( bMoveProtect && -1 == aProtectAttrValue.indexOf( rPosition ) ) |
| { |
| if( aProtectAttrValue.getLength() ) |
| aProtectAttrValue += OUString::valueOf( sal_Unicode( ' ' ) ); |
| aProtectAttrValue += rPosition; |
| } |
| |
| const OUString& rSize = GetXMLToken( XML_SIZE ); |
| if( bSizeProtect && -1 == aProtectAttrValue.indexOf( rSize ) ) |
| { |
| if( aProtectAttrValue.getLength() ) |
| aProtectAttrValue += OUString::valueOf( sal_Unicode( ' ' ) ); |
| aProtectAttrValue += rSize; |
| } |
| |
| pProtectContext->AddAttribute( GetTransformer().GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_STYLE, GetXMLToken( XML_PROTECT ) ), aProtectAttrValue ); |
| } |
| |
| if( pIntervalMinorDivisorContext ) |
| { |
| if( fIntervalMinor != 0.0 ) |
| { |
| sal_Int32 nIntervalMinorDivisor = static_cast< sal_Int32 >( |
| ::rtl::math::round( fIntervalMajor / fIntervalMinor )); |
| |
| ::rtl::OUStringBuffer aBuf; |
| SvXMLUnitConverter::convertNumber( aBuf, nIntervalMinorDivisor ); |
| pIntervalMinorDivisorContext->AddAttribute( |
| GetTransformer().GetNamespaceMap().GetQNameByKey( |
| XML_NAMESPACE_CHART, |
| GetXMLToken( XML_INTERVAL_MINOR_DIVISOR )), |
| aBuf.makeStringAndClear()); |
| } |
| } |
| } |
| |
| void XMLPropertiesOOoTContext_Impl::EndElement() |
| { |
| if( !m_bPersistent ) |
| Export(); |
| } |
| |
| void XMLPropertiesOOoTContext_Impl::Characters( const OUString& ) |
| { |
| // ignore them |
| } |
| |
| void XMLPropertiesOOoTContext_Impl::Export() |
| { |
| |
| for( sal_uInt16 i=0; i < MAX_PROP_TYPES; i++ ) |
| { |
| if( m_aPropContexts[i].is() ) |
| m_aPropContexts[i]->Export(); |
| } |
| } |
| |
| sal_Bool XMLPropertiesOOoTContext_Impl::IsPersistent() const |
| { |
| return m_bPersistent; |
| } |
| |
| |
| //------------------------------------------------------------------------------ |
| |
| TYPEINIT1( XMLStyleOOoTContext, XMLPersElemContentTContext ); |
| |
| XMLStyleOOoTContext::XMLStyleOOoTContext( XMLTransformerBase& rImp, |
| const OUString& rQName, |
| XMLFamilyType eT, |
| sal_Bool bPersistent ) : |
| XMLPersElemContentTContext( rImp, rQName ), |
| m_eFamily( eT ), |
| m_bPersistent( bPersistent ) |
| { |
| } |
| |
| XMLStyleOOoTContext::XMLStyleOOoTContext( |
| XMLTransformerBase& rImp, |
| const OUString& rQName, |
| XMLFamilyType eT, |
| sal_uInt16 nPrefix, |
| ::xmloff::token::XMLTokenEnum eToken, |
| sal_Bool bPersistent ) : |
| XMLPersElemContentTContext( rImp, rQName, nPrefix, eToken ), |
| m_eFamily( eT ), |
| m_bPersistent( bPersistent ) |
| { |
| } |
| |
| XMLStyleOOoTContext::~XMLStyleOOoTContext() |
| { |
| } |
| |
| XMLTransformerContext *XMLStyleOOoTContext::CreateChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const OUString& rQName, |
| const Reference< XAttributeList >& rAttrList ) |
| { |
| XMLTransformerContext *pContext = 0; |
| |
| if( XML_NAMESPACE_STYLE == nPrefix && |
| IsXMLToken( rLocalName, XML_PROPERTIES ) ) |
| { |
| if( aPropTypes[m_eFamily][0] == XML_PROP_TYPE_END ) |
| { |
| OSL_ENSURE( !this, "unexpected properties element" ); |
| pContext = m_bPersistent |
| ? XMLPersElemContentTContext::CreateChildContext( |
| nPrefix, rLocalName, rQName, rAttrList ) |
| : XMLTransformerContext::CreateChildContext( |
| nPrefix, rLocalName, rQName, rAttrList ); |
| } |
| else if( aPropTypes[m_eFamily][1] == XML_PROP_TYPE_END ) |
| { |
| sal_uInt16 nActionMap = |
| aAttrActionMaps[aPropTypes[m_eFamily][0]]; |
| if( nActionMap < MAX_OOO_PROP_ACTIONS ) |
| { |
| pContext = new XMLPropertiesOOoTContext_Impl( |
| GetTransformer(), rQName, |
| aPropTypes[m_eFamily], m_bPersistent ); |
| } |
| else |
| { |
| if( m_bPersistent ) |
| pContext = new XMLPersElemContentTContext( |
| GetTransformer(), rQName, |
| XML_NAMESPACE_STYLE, |
| aPropTokens[aPropTypes[m_eFamily][0]] ); |
| else |
| pContext = new XMLRenameElemTransformerContext( |
| GetTransformer(), rQName, |
| XML_NAMESPACE_STYLE, |
| aPropTokens[aPropTypes[m_eFamily][0]] ); |
| } |
| } |
| else |
| { |
| pContext = new XMLPropertiesOOoTContext_Impl( |
| GetTransformer(), rQName, |
| aPropTypes[m_eFamily], m_bPersistent); |
| } |
| |
| if( m_bPersistent ) |
| AddContent( pContext ); |
| } |
| else |
| { |
| pContext = m_bPersistent |
| ? XMLPersElemContentTContext::CreateChildContext( |
| nPrefix, rLocalName, rQName, rAttrList ) |
| : XMLTransformerContext::CreateChildContext( |
| nPrefix, rLocalName, rQName, rAttrList ); |
| } |
| |
| return pContext; |
| } |
| |
| void XMLStyleOOoTContext::StartElement( |
| const Reference< XAttributeList >& rAttrList ) |
| { |
| XMLTransformerActions *pActions = |
| GetTransformer().GetUserDefinedActions( OOO_STYLE_ACTIONS ); |
| OSL_ENSURE( pActions, "go no actions" ); |
| |
| Reference< XAttributeList > xAttrList( rAttrList ); |
| XMLMutableAttributeList *pMutableAttrList = 0; |
| sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; |
| for( sal_Int16 i=0; i < nAttrCount; i++ ) |
| { |
| const OUString sAttrName = xAttrList->getNameByIndex( i ); |
| OUString aLocalName; |
| sal_uInt16 nPrefix = |
| GetTransformer().GetNamespaceMap().GetKeyByAttrName( sAttrName, |
| &aLocalName ); |
| XMLTransformerActions::key_type aKey( nPrefix, aLocalName ); |
| XMLTransformerActions::const_iterator aIter = |
| pActions->find( aKey ); |
| if( !(aIter == pActions->end() ) ) |
| { |
| if( !pMutableAttrList ) |
| { |
| pMutableAttrList = |
| new XMLMutableAttributeList( xAttrList ); |
| xAttrList = pMutableAttrList; |
| } |
| const OUString sAttrValue = xAttrList->getValueByIndex( i ); |
| switch( (*aIter).second.m_nActionType ) |
| { |
| case XML_ATACTION_STYLE_FAMILY: |
| { |
| sal_Bool bControl = sal_False; |
| if( XML_FAMILY_TYPE_END == m_eFamily ) |
| { |
| if( IsXMLToken( sAttrValue, XML_GRAPHICS ) ) |
| m_eFamily = XML_FAMILY_TYPE_GRAPHIC; |
| else if( IsXMLToken( sAttrValue, XML_PRESENTATION ) ) |
| m_eFamily = XML_FAMILY_TYPE_PRESENTATION; |
| else if( IsXMLToken( sAttrValue, XML_DRAWING_PAGE ) ) |
| m_eFamily = XML_FAMILY_TYPE_DRAWING_PAGE; |
| else if( IsXMLToken( sAttrValue, XML_TEXT) ) |
| m_eFamily = XML_FAMILY_TYPE_TEXT; |
| else if( IsXMLToken( sAttrValue, XML_PARAGRAPH) ) |
| m_eFamily = XML_FAMILY_TYPE_PARAGRAPH; |
| else if( IsXMLToken( sAttrValue, XML_RUBY) ) |
| m_eFamily = XML_FAMILY_TYPE_RUBY; |
| else if( IsXMLToken( sAttrValue, XML_SECTION) ) |
| m_eFamily = XML_FAMILY_TYPE_SECTION; |
| else if( IsXMLToken( sAttrValue, XML_TABLE) ) |
| m_eFamily = XML_FAMILY_TYPE_TABLE; |
| else if( IsXMLToken( sAttrValue, XML_TABLE_COLUMN) ) |
| m_eFamily = XML_FAMILY_TYPE_TABLE_COLUMN; |
| else if( IsXMLToken( sAttrValue, XML_TABLE_ROW) ) |
| m_eFamily = XML_FAMILY_TYPE_TABLE_ROW; |
| else if( IsXMLToken( sAttrValue, XML_TABLE_CELL) ) |
| m_eFamily = XML_FAMILY_TYPE_TABLE_CELL; |
| else if( IsXMLToken( sAttrValue, XML_CHART) ) |
| m_eFamily = XML_FAMILY_TYPE_CHART; |
| else if( IsXMLToken( sAttrValue, XML_CONTROL) ) |
| { |
| m_eFamily = XML_FAMILY_TYPE_PARAGRAPH; |
| bControl = sal_True; |
| } |
| } |
| if( XML_FAMILY_TYPE_GRAPHIC == m_eFamily ) |
| { |
| pMutableAttrList->SetValueByIndex( i, |
| GetXMLToken( XML_GRAPHIC ) ); |
| } |
| else if( bControl ) |
| { |
| pMutableAttrList->SetValueByIndex( i, |
| GetXMLToken( XML_PARAGRAPH ) ); |
| } |
| } |
| break; |
| case XML_ATACTION_INCH2IN: |
| { |
| OUString aAttrValue( sAttrValue ); |
| if( XMLTransformerBase::ReplaceSingleInchWithIn( |
| aAttrValue ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_ENCODE_STYLE_NAME: |
| { |
| OUString aAttrValue( sAttrValue ); |
| if( GetTransformer().EncodeStyleName(aAttrValue) ) |
| { |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| OUString aNewAttrQName( |
| GetTransformer().GetNamespaceMap(). |
| GetQNameByKey( |
| nPrefix, ::xmloff::token::GetXMLToken( |
| XML_DISPLAY_NAME ) ) ); |
| pMutableAttrList->AddAttribute( aNewAttrQName, |
| sAttrValue ); |
| } |
| } |
| break; |
| case XML_ATACTION_ENCODE_STYLE_NAME_REF: |
| { |
| OUString aAttrValue( sAttrValue ); |
| if( GetTransformer().EncodeStyleName(aAttrValue) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_NEG_PERCENT: |
| { |
| OUString aAttrValue( sAttrValue ); |
| if( GetTransformer().NegPercent(aAttrValue) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_URI_OOO: |
| { |
| OUString aAttrValue( sAttrValue ); |
| if( GetTransformer().ConvertURIToOASIS( aAttrValue, |
| static_cast< sal_Bool >((*aIter).second.m_nParam1))) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| default: |
| OSL_ENSURE( !this, "unknown action" ); |
| break; |
| } |
| } |
| } |
| if( XML_FAMILY_TYPE_END == m_eFamily ) |
| m_eFamily = XML_FAMILY_TYPE_TEXT; |
| if( m_bPersistent ) |
| XMLPersElemContentTContext::StartElement( xAttrList ); |
| else |
| GetTransformer().GetDocHandler()->startElement( GetExportQName(), |
| xAttrList ); |
| } |
| |
| void XMLStyleOOoTContext::EndElement() |
| { |
| if( m_bPersistent ) |
| XMLPersElemContentTContext::EndElement(); |
| else |
| GetTransformer().GetDocHandler()->endElement( GetExportQName() ); |
| } |
| |
| void XMLStyleOOoTContext::Characters( const OUString& ) |
| { |
| // element content only: |
| } |
| |
| sal_Bool XMLStyleOOoTContext::IsPersistent() const |
| { |
| return m_bPersistent; |
| } |
| |
| XMLTransformerActions *XMLStyleOOoTContext::CreateTransformerActions( |
| sal_uInt16 nType ) |
| { |
| XMLTransformerActionInit *pInit = 0; |
| |
| switch( nType ) |
| { |
| case PROP_OOO_GRAPHIC_ATTR_ACTIONS: |
| pInit = aGraphicPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_GRAPHIC_ELEM_ACTIONS: |
| pInit = aGraphicPropertyOOoElemActionTable; |
| break; |
| case PROP_OOO_DRAWING_PAGE_ATTR_ACTIONS: |
| pInit = aDrawingPagePropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_PAGE_LAYOUT_ATTR_ACTIONS: |
| pInit = aPageLayoutPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_HEADER_FOOTER_ATTR_ACTIONS: |
| pInit = aHeaderFooterPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_TEXT_ATTR_ACTIONS: |
| pInit = aTextPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_TEXT_ELEM_ACTIONS: |
| pInit = aTextPropertyOOoElemActionTable; |
| break; |
| case PROP_OOO_PARAGRAPH_ATTR_ACTIONS: |
| pInit = aParagraphPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_PARAGRAPH_ELEM_ACTIONS: |
| pInit = aParagraphPropertyOOoElemActionTable; |
| break; |
| case PROP_OOO_SECTION_ATTR_ACTIONS: |
| pInit = aSectionPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_TABLE_ATTR_ACTIONS: |
| pInit = aTablePropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_TABLE_COLUMN_ATTR_ACTIONS: |
| pInit = aTableColumnPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_TABLE_ROW_ATTR_ACTIONS: |
| pInit = aTableRowPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_TABLE_CELL_ATTR_ACTIONS: |
| pInit = aTableCellPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_TABLE_CELL_ELEM_ACTIONS: |
| pInit = aTableCellPropertyOOoElemActionTable; |
| break; |
| case PROP_OOO_LIST_LEVEL_ATTR_ACTIONS: |
| pInit = aListLevelPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_CHART_ATTR_ACTIONS: |
| pInit = aChartPropertyOOoAttrActionTable; |
| break; |
| case PROP_OOO_CHART_ELEM_ACTIONS: |
| pInit = aChartPropertyOOoElemActionTable; |
| break; |
| } |
| |
| XMLTransformerActions *pActions = 0; |
| if( pInit ) |
| pActions = new XMLTransformerActions( pInit ); |
| |
| return pActions; |
| } |
