| /************************************************************** |
| * |
| * 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 <rtl/ref.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <com/sun/star/i18n/XCharacterClassification.hpp> |
| #include <com/sun/star/i18n/UnicodeType.hpp> |
| #include <comphelper/processfactory.hxx> |
| #include <xmloff/nmspmap.hxx> |
| #include "xmloff/xmlnmspe.hxx" |
| #include "IgnoreTContext.hxx" |
| #include "RenameElemTContext.hxx" |
| #include "ProcAttrTContext.hxx" |
| #include "ProcAddAttrTContext.hxx" |
| #include "MergeElemTContext.hxx" |
| #include "CreateElemTContext.hxx" |
| #include "MutableAttrList.hxx" |
| #include "TransformerActions.hxx" |
| #include "ElemTransformerAction.hxx" |
| // --> OD 2005-06-29 #i50322# |
| #include "PropertyActionsOOo.hxx" |
| // <-- |
| #ifndef _XMLOFF_TRANSFORMERTOKENMAP_HXX |
| #include "TransformerTokenMap.hxx" |
| #endif |
| #include <xmloff/xmluconv.hxx> |
| |
| #ifndef _XMLOFF_TRANSFORMERBASE_HXX |
| #include "TransformerBase.hxx" |
| #endif |
| #include "TContextVector.hxx" |
| |
| using ::rtl::OUString; |
| using ::rtl::OUStringBuffer; |
| using namespace ::osl; |
| using namespace ::xmloff::token; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::i18n; |
| using namespace ::com::sun::star::xml::sax; |
| |
| // ----------------------------------------------------------------------------- |
| |
| namespace |
| { |
| bool lcl_ConvertAttr( OUString & rOutAttribute, sal_Int32 nParam ) |
| { |
| bool bResult = false; |
| enum XMLTokenEnum eTokenToRename = |
| static_cast< enum XMLTokenEnum >( nParam & 0xffff ); |
| if( eTokenToRename != XML_TOKEN_INVALID && |
| IsXMLToken( rOutAttribute, eTokenToRename )) |
| { |
| enum XMLTokenEnum eReplacementToken = |
| static_cast< enum XMLTokenEnum >( nParam >> 16 ); |
| rOutAttribute = GetXMLToken( eReplacementToken ); |
| bResult = true; |
| } |
| return bResult; |
| } |
| } // anonymous namespace |
| |
| // ----------------------------------------------------------------------------- |
| |
| XMLTransformerContext *XMLTransformerBase::CreateContext( sal_uInt16 nPrefix, |
| const OUString& rLocalName, const OUString& rQName ) |
| { |
| XMLTransformerActions::key_type aKey( nPrefix, rLocalName ); |
| XMLTransformerActions::const_iterator aIter = |
| GetElemActions().find( aKey ); |
| |
| if( !(aIter == GetElemActions().end()) ) |
| { |
| sal_uInt32 nActionType = (*aIter).second.m_nActionType; |
| if( (nActionType & XML_ETACTION_USER_DEFINED) != 0 ) |
| { |
| XMLTransformerContext *pContext = |
| CreateUserDefinedContext( (*aIter).second, |
| rQName ); |
| OSL_ENSURE( pContext && !pContext->IsPersistent(), |
| "unknown or not persistent action" ); |
| return pContext; |
| } |
| |
| switch( nActionType ) |
| { |
| case XML_ETACTION_COPY_CONTENT: |
| return new XMLIgnoreTransformerContext( *this, rQName, sal_False, |
| sal_False ); |
| case XML_ETACTION_COPY: |
| return new XMLTransformerContext( *this, rQName ); |
| case XML_ETACTION_RENAME_ELEM: |
| return new XMLRenameElemTransformerContext( *this, rQName, |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| (*aIter).second.GetQNameTokenFromParam1() ); |
| case XML_ETACTION_RENAME_ELEM_ADD_ATTR: |
| return new XMLRenameElemTransformerContext( *this, rQName, |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| (*aIter).second.GetQNameTokenFromParam1(), |
| (*aIter).second.GetQNamePrefixFromParam2(), |
| (*aIter).second.GetQNameTokenFromParam2(), |
| static_cast< XMLTokenEnum >( (*aIter).second.m_nParam3 ) ); |
| case XML_ETACTION_RENAME_ELEM_PROC_ATTRS: |
| return new XMLProcAttrTransformerContext( *this, rQName, |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| (*aIter).second.GetQNameTokenFromParam1(), |
| static_cast< sal_uInt16 >( (*aIter).second.m_nParam2 ) ); |
| case XML_ETACTION_RENAME_ELEM_ADD_PROC_ATTR: |
| return new XMLProcAddAttrTransformerContext( *this, rQName, |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| (*aIter).second.GetQNameTokenFromParam1(), |
| static_cast< sal_uInt16 >( |
| (*aIter).second.m_nParam3 >> 16 ), |
| (*aIter).second.GetQNamePrefixFromParam2(), |
| (*aIter).second.GetQNameTokenFromParam2(), |
| static_cast< XMLTokenEnum >( |
| (*aIter).second.m_nParam3 & 0xffff ) ); |
| case XML_ETACTION_RENAME_ELEM_COND: |
| { |
| const XMLTransformerContext *pCurrent = GetCurrentContext(); |
| if( pCurrent->HasQName( |
| (*aIter).second.GetQNamePrefixFromParam2(), |
| (*aIter).second.GetQNameTokenFromParam2() ) ) |
| return new XMLRenameElemTransformerContext( *this, rQName, |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| (*aIter).second.GetQNameTokenFromParam1() ); |
| } |
| break; |
| case XML_ETACTION_RENAME_ELEM_PROC_ATTRS_COND: |
| { |
| const XMLTransformerContext *pCurrent = GetCurrentContext(); |
| if( pCurrent->HasQName( |
| (*aIter).second.GetQNamePrefixFromParam3(), |
| (*aIter).second.GetQNameTokenFromParam3() ) ) |
| return new XMLProcAttrTransformerContext( *this, rQName, |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| (*aIter).second.GetQNameTokenFromParam1(), |
| static_cast< sal_uInt16 >( (*aIter).second.m_nParam2 ) ); |
| else |
| return new XMLProcAttrTransformerContext( *this, rQName, |
| static_cast< sal_uInt16 >( (*aIter).second.m_nParam2 ) ); |
| } |
| case XML_ETACTION_PROC_ATTRS: |
| return new XMLProcAttrTransformerContext( *this, rQName, |
| static_cast< sal_uInt16 >( (*aIter).second.m_nParam1 ) ); |
| case XML_ETACTION_PROC_ATTRS_COND: |
| { |
| const XMLTransformerContext *pCurrent = GetCurrentContext(); |
| if( pCurrent->HasQName( |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| (*aIter).second.GetQNameTokenFromParam1() ) ) |
| return new XMLProcAttrTransformerContext( *this, rQName, |
| static_cast< sal_uInt16 >( (*aIter).second.m_nParam2 ) ); |
| } |
| break; |
| case XML_ETACTION_MOVE_ATTRS_TO_ELEMS: |
| return new XMLCreateElemTransformerContext( *this, rQName, |
| static_cast< sal_uInt16 >( (*aIter).second.m_nParam1 ) ); |
| case XML_ETACTION_MOVE_ELEMS_TO_ATTRS: |
| return new XMLMergeElemTransformerContext( *this, rQName, |
| static_cast< sal_uInt16 >( (*aIter).second.m_nParam1 ) ); |
| default: |
| OSL_ENSURE( !this, "unknown action" ); |
| break; |
| } |
| } |
| |
| // default is copying |
| return new XMLTransformerContext( *this, rQName ); |
| } |
| |
| XMLTransformerActions *XMLTransformerBase::GetUserDefinedActions( sal_uInt16 ) |
| { |
| return 0; |
| } |
| |
| XMLTransformerBase::XMLTransformerBase( XMLTransformerActionInit *pInit, |
| ::xmloff::token::XMLTokenEnum *pTKMapInit ) |
| throw () : |
| m_pNamespaceMap( new SvXMLNamespaceMap ), |
| m_pReplaceNamespaceMap( new SvXMLNamespaceMap ), |
| m_pContexts( new XMLTransformerContextVector ), |
| m_pElemActions( new XMLTransformerActions( pInit ) ), |
| m_pTokenMap( new XMLTransformerTokenMap( pTKMapInit ) ) |
| { |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_DC), GetXMLToken(XML_N_DC), XML_NAMESPACE_DC ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_MATH), GetXMLToken(XML_N_MATH), XML_NAMESPACE_MATH ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_OOO), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_DOM), GetXMLToken(XML_N_DOM), XML_NAMESPACE_DOM ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_OOOW), GetXMLToken(XML_N_OOOW), XML_NAMESPACE_OOOW ); |
| GetNamespaceMap().Add( GetXMLToken(XML_NP_OOOC), GetXMLToken(XML_N_OOOC), XML_NAMESPACE_OOOC ); |
| } |
| |
| XMLTransformerBase::~XMLTransformerBase() throw () |
| { |
| ResetTokens(); |
| |
| delete m_pNamespaceMap; |
| delete m_pReplaceNamespaceMap; |
| delete m_pContexts; |
| delete m_pElemActions; |
| delete m_pTokenMap; |
| } |
| |
| void SAL_CALL XMLTransformerBase::startDocument( void ) |
| throw( SAXException, RuntimeException ) |
| { |
| m_xHandler->startDocument(); |
| } |
| |
| void SAL_CALL XMLTransformerBase::endDocument( void ) |
| throw( SAXException, RuntimeException) |
| { |
| m_xHandler->endDocument(); |
| } |
| |
| void SAL_CALL XMLTransformerBase::startElement( const OUString& rName, |
| const Reference< XAttributeList >& rAttrList ) |
| throw(SAXException, RuntimeException) |
| { |
| SvXMLNamespaceMap *pRewindMap = 0; |
| |
| bool bRect = rName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "presentation:show-shape" ) ); |
| (void)bRect; |
| |
| // Process namespace attributes. This must happen before creating the |
| // context, because namespace decaration apply to the element name itself. |
| XMLMutableAttributeList *pMutableAttrList = 0; |
| Reference< XAttributeList > xAttrList( rAttrList ); |
| sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; |
| for( sal_Int16 i=0; i < nAttrCount; i++ ) |
| { |
| const OUString& rAttrName = xAttrList->getNameByIndex( i ); |
| if( ( rAttrName.getLength() >= 5 ) && |
| ( rAttrName.compareTo( GetXMLToken(XML_XMLNS), 5 ) == 0 ) && |
| ( rAttrName.getLength() == 5 || ':' == rAttrName[5] ) ) |
| { |
| if( !pRewindMap ) |
| { |
| pRewindMap = m_pNamespaceMap; |
| m_pNamespaceMap = new SvXMLNamespaceMap( *m_pNamespaceMap ); |
| } |
| const OUString& rAttrValue = xAttrList->getValueByIndex( i ); |
| |
| OUString aPrefix( ( rAttrName.getLength() == 5 ) |
| ? OUString() |
| : rAttrName.copy( 6 ) ); |
| // Add namespace, but only if it is known. |
| sal_uInt16 nKey = m_pNamespaceMap->AddIfKnown( aPrefix, rAttrValue ); |
| // If namespace is unknwon, try to match a name with similar |
| // TC Id an version |
| if( XML_NAMESPACE_UNKNOWN == nKey ) |
| { |
| OUString aTestName( rAttrValue ); |
| if( SvXMLNamespaceMap::NormalizeOasisURN( aTestName ) ) |
| nKey = m_pNamespaceMap->AddIfKnown( aPrefix, aTestName ); |
| } |
| // If that namespace is not known, too, add it as unknown |
| if( XML_NAMESPACE_UNKNOWN == nKey ) |
| nKey = m_pNamespaceMap->Add( aPrefix, rAttrValue ); |
| |
| const OUString& rRepName = m_pReplaceNamespaceMap->GetNameByKey( nKey ); |
| if( rRepName.getLength() ) |
| { |
| if( !pMutableAttrList ) |
| { |
| pMutableAttrList = new XMLMutableAttributeList( xAttrList ); |
| xAttrList = pMutableAttrList; |
| } |
| |
| pMutableAttrList->SetValueByIndex( i, rRepName ); |
| } |
| } |
| } |
| |
| // Get element's namespace and local name. |
| OUString aLocalName; |
| sal_uInt16 nPrefix = |
| m_pNamespaceMap->GetKeyByAttrName( rName, &aLocalName ); |
| |
| // If there are contexts already, call a CreateChildContext at the topmost |
| // context. Otherwise, create a default context. |
| ::rtl::Reference < XMLTransformerContext > xContext; |
| if( !m_pContexts->empty() ) |
| { |
| xContext = m_pContexts->back()->CreateChildContext( nPrefix, |
| aLocalName, |
| rName, |
| xAttrList ); |
| } |
| else |
| { |
| xContext = CreateContext( nPrefix, aLocalName, rName ); |
| } |
| |
| OSL_ENSURE( xContext.is(), "XMLTransformerBase::startElement: missing context" ); |
| if( !xContext.is() ) |
| xContext = new XMLTransformerContext( *this, rName ); |
| |
| // Remeber old namespace map. |
| if( pRewindMap ) |
| xContext->SetRewindMap( pRewindMap ); |
| |
| // Push context on stack. |
| m_pContexts->push_back( xContext ); |
| |
| // Call a startElement at the new context. |
| xContext->StartElement( xAttrList ); |
| } |
| |
| void SAL_CALL XMLTransformerBase::endElement( const OUString& |
| #ifdef DBG_UTIL |
| rName |
| #endif |
| ) |
| throw(SAXException, RuntimeException) |
| { |
| if( !m_pContexts->empty() ) |
| { |
| // Get topmost context |
| ::rtl::Reference< XMLTransformerContext > xContext = m_pContexts->back(); |
| |
| #ifdef DBG_UTIL |
| OSL_ENSURE( xContext->GetQName() == rName, |
| "XMLTransformerBase::endElement: popped context has wrong lname" ); |
| #endif |
| |
| // Call a EndElement at the current context. |
| xContext->EndElement(); |
| |
| // and remove it from the stack. |
| m_pContexts->pop_back(); |
| |
| // Get a namespace map to rewind. |
| SvXMLNamespaceMap *pRewindMap = xContext->GetRewindMap(); |
| |
| // Delete the current context. |
| xContext = 0; |
| |
| // Rewind a namespace map. |
| if( pRewindMap ) |
| { |
| delete m_pNamespaceMap; |
| m_pNamespaceMap = pRewindMap; |
| } |
| } |
| } |
| |
| void SAL_CALL XMLTransformerBase::characters( const OUString& rChars ) |
| throw(SAXException, RuntimeException) |
| { |
| if( !m_pContexts->empty() ) |
| { |
| m_pContexts->back()->Characters( rChars ); |
| } |
| } |
| |
| void SAL_CALL XMLTransformerBase::ignorableWhitespace( const OUString& rWhitespaces ) |
| throw(SAXException, RuntimeException) |
| { |
| m_xHandler->ignorableWhitespace( rWhitespaces ); |
| } |
| |
| void SAL_CALL XMLTransformerBase::processingInstruction( const OUString& rTarget, |
| const OUString& rData ) |
| throw(SAXException, RuntimeException) |
| { |
| m_xHandler->processingInstruction( rTarget, rData ); |
| } |
| |
| void SAL_CALL XMLTransformerBase::setDocumentLocator( const Reference< XLocator >& rLocator ) |
| throw(SAXException, RuntimeException) |
| { |
| m_xLocator = rLocator; |
| } |
| |
| // XExtendedDocumentHandler |
| void SAL_CALL XMLTransformerBase::startCDATA( void ) throw(SAXException, RuntimeException) |
| { |
| if( m_xExtHandler.is() ) |
| m_xExtHandler->startCDATA(); |
| } |
| |
| void SAL_CALL XMLTransformerBase::endCDATA( void ) throw(RuntimeException) |
| { |
| if( m_xExtHandler.is() ) |
| m_xExtHandler->endCDATA(); |
| } |
| |
| void SAL_CALL XMLTransformerBase::comment( const OUString& rComment ) |
| throw(SAXException, RuntimeException) |
| { |
| if( m_xExtHandler.is() ) |
| m_xExtHandler->comment( rComment ); |
| } |
| |
| void SAL_CALL XMLTransformerBase::allowLineBreak( void ) |
| throw(SAXException, RuntimeException) |
| { |
| if( m_xExtHandler.is() ) |
| m_xExtHandler->allowLineBreak(); |
| } |
| |
| void SAL_CALL XMLTransformerBase::unknown( const OUString& rString ) |
| throw(SAXException, RuntimeException) |
| { |
| if( m_xExtHandler.is() ) |
| m_xExtHandler->unknown( rString ); |
| } |
| |
| // XInitialize |
| void SAL_CALL XMLTransformerBase::initialize( const Sequence< Any >& aArguments ) |
| throw(Exception, RuntimeException) |
| { |
| const sal_Int32 nAnyCount = aArguments.getLength(); |
| const Any* pAny = aArguments.getConstArray(); |
| |
| for( sal_Int32 nIndex = 0; nIndex < nAnyCount; nIndex++, pAny++ ) |
| { |
| // #b6236750# use isAssignableFrom instead of comparing the types to |
| // allow XExtendedDocumentHandler instead of XDocumentHandler (used in |
| // writeOasis2OOoLibraryElement in sfx2). |
| // The Any shift operator can't be used to query the type because it |
| // uses queryInterface, and the model also has a XPropertySet interface. |
| |
| // document handler |
| if( ::getCppuType( (const Reference< XDocumentHandler >*) 0 ).isAssignableFrom( pAny->getValueType() ) ) |
| m_xHandler.set( *pAny, UNO_QUERY ); |
| |
| // property set to transport data across |
| if( ::getCppuType( (const Reference< XPropertySet >*) 0 ).isAssignableFrom( pAny->getValueType() ) ) |
| m_xPropSet.set( *pAny, UNO_QUERY ); |
| |
| // xmodel |
| if( ::getCppuType( (const Reference< ::com::sun::star::frame::XModel >*) 0 ).isAssignableFrom( pAny->getValueType() ) ) |
| mxModel.set( *pAny, UNO_QUERY ); |
| } |
| |
| if( m_xPropSet.is() ) |
| { |
| Any aAny; |
| OUString sRelPath, sName; |
| Reference< XPropertySetInfo > xPropSetInfo = |
| m_xPropSet->getPropertySetInfo(); |
| OUString sPropName( RTL_CONSTASCII_USTRINGPARAM("StreamRelPath" ) ); |
| if( xPropSetInfo->hasPropertyByName(sPropName) ) |
| { |
| aAny = m_xPropSet->getPropertyValue(sPropName); |
| aAny >>= sRelPath; |
| } |
| sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("StreamName" ) ); |
| if( xPropSetInfo->hasPropertyByName(sPropName) ) |
| { |
| aAny = m_xPropSet->getPropertyValue(sPropName); |
| aAny >>= sName; |
| } |
| if( sName.getLength() ) |
| { |
| m_aExtPathPrefix = OUString( RTL_CONSTASCII_USTRINGPARAM("../" ) ); |
| |
| // If there is a rel path within a package, then append |
| // additional '../'. If the rel path contains an ':', then it is |
| // an absolute URI (or invalid URI, because zip files don't |
| // permit ':'), and it will be ignored. |
| if( sRelPath.getLength() ) |
| { |
| sal_Int32 nColPos = sRelPath.indexOf( ':' ); |
| OSL_ENSURE( -1 == nColPos, |
| "StreamRelPath contains ':', absolute URI?" ); |
| |
| if( -1 == nColPos ) |
| { |
| OUString sTmp = m_aExtPathPrefix; |
| sal_Int32 nPos = 0; |
| do |
| { |
| m_aExtPathPrefix += sTmp; |
| nPos = sRelPath.indexOf( '/', nPos + 1 ); |
| } |
| while( -1 != nPos ); |
| } |
| } |
| |
| } |
| } |
| } |
| |
| static MapUnit lcl_getUnit( const OUString& rValue ) |
| { |
| MapUnit nDestUnit; |
| if( rValue.endsWithIgnoreAsciiCaseAsciiL( RTL_CONSTASCII_STRINGPARAM( "cm" ) ) ) |
| nDestUnit = MAP_CM; |
| else if ( rValue.endsWithIgnoreAsciiCaseAsciiL( RTL_CONSTASCII_STRINGPARAM( "mm" ) ) ) |
| nDestUnit = MAP_MM; |
| else |
| nDestUnit = MAP_INCH; |
| return nDestUnit; |
| } |
| |
| XMLMutableAttributeList *XMLTransformerBase::ProcessAttrList( |
| Reference< XAttributeList >& rAttrList, sal_uInt16 nActionMap, |
| sal_Bool bClone ) |
| { |
| XMLMutableAttributeList *pMutableAttrList = 0; |
| XMLTransformerActions *pActions = GetUserDefinedActions( nActionMap ); |
| OSL_ENSURE( pActions, "go no actions" ); |
| if( pActions ) |
| { |
| sal_Int16 nAttrCount = rAttrList.is() ? rAttrList->getLength() : 0; |
| for( sal_Int16 i=0; i < nAttrCount; ++i ) |
| { |
| const OUString& rAttrName = rAttrList->getNameByIndex( i ); |
| const OUString& rAttrValue = rAttrList->getValueByIndex( i ); |
| OUString aLocalName; |
| sal_uInt16 nPrefix = GetNamespaceMap().GetKeyByAttrName( rAttrName, |
| &aLocalName ); |
| |
| XMLTransformerActions::key_type aKey( nPrefix, aLocalName ); |
| XMLTransformerActions::const_iterator aIter = |
| pActions->find( aKey ); |
| if( !(aIter == pActions->end() ) ) |
| { |
| if( !pMutableAttrList ) |
| { |
| pMutableAttrList = new XMLMutableAttributeList( rAttrList, |
| bClone ); |
| rAttrList = pMutableAttrList; |
| } |
| |
| sal_uInt32 nAction = (*aIter).second.m_nActionType; |
| sal_Bool bRename = sal_False; |
| switch( nAction ) |
| { |
| case XML_ATACTION_RENAME: |
| bRename = sal_True; |
| break; |
| case XML_ATACTION_COPY: |
| break; |
| case XML_ATACTION_REMOVE: |
| case XML_ATACTION_STYLE_DISPLAY_NAME: |
| pMutableAttrList->RemoveAttributeByIndex( i ); |
| --i; |
| --nAttrCount; |
| break; |
| case XML_ATACTION_RENAME_IN2INCH: |
| bRename = sal_True; |
| case XML_ATACTION_IN2INCH: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ReplaceSingleInWithInch( aAttrValue ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_INS2INCHS: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ReplaceInWithInch( aAttrValue ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_INCH2IN: |
| bRename = sal_True; |
| case XML_ATACTION_INCH2IN: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ReplaceSingleInchWithIn( aAttrValue ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_INCHS2INS: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ReplaceInchWithIn( aAttrValue ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_TWIPS2IN: |
| { |
| OUString aAttrValue( rAttrValue ); |
| |
| XMLTransformerBase::ReplaceSingleInchWithIn( aAttrValue ); |
| if( isWriter() ) |
| { |
| MapUnit nDestUnit = lcl_getUnit( aAttrValue ); |
| |
| // convert twips value to inch |
| sal_Int32 nMeasure; |
| if( SvXMLUnitConverter::convertMeasure(nMeasure, aAttrValue, MAP_100TH_MM ) ) |
| { |
| |
| // --> OD 2004-10-29 #i13778#,#i36248# |
| // apply correct twip-to-1/100mm |
| nMeasure = (sal_Int32)( nMeasure >= 0 |
| ? ((nMeasure*127+36)/72) |
| : ((nMeasure*127-36)/72) ); |
| // <-- |
| |
| rtl::OUStringBuffer aBuffer; |
| SvXMLUnitConverter::convertMeasure( aBuffer, nMeasure, MAP_100TH_MM, nDestUnit ); |
| aAttrValue = aBuffer.makeStringAndClear(); |
| } |
| } |
| |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_DECODE_STYLE_NAME_REF: |
| bRename = sal_True; |
| case XML_ATACTION_DECODE_STYLE_NAME: |
| case XML_ATACTION_DECODE_STYLE_NAME_REF: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( DecodeStyleName(aAttrValue) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_ENCODE_STYLE_NAME: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( EncodeStyleName(aAttrValue) ) |
| { |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| OUString aNewAttrQName( |
| GetNamespaceMap().GetQNameByKey( |
| nPrefix, |
| ::xmloff::token::GetXMLToken( |
| XML_DISPLAY_NAME ) ) ); |
| pMutableAttrList->AddAttribute( aNewAttrQName, |
| rAttrValue ); |
| } |
| } |
| break; |
| case XML_ATACTION_RENAME_ENCODE_STYLE_NAME_REF: |
| bRename = sal_True; |
| case XML_ATACTION_ENCODE_STYLE_NAME_REF: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( EncodeStyleName(aAttrValue) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_NEG_PERCENT: |
| bRename = sal_True; |
| case XML_ATACTION_NEG_PERCENT: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( NegPercent( aAttrValue ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_ADD_NAMESPACE_PREFIX: |
| bRename = sal_True; |
| case XML_ATACTION_ADD_NAMESPACE_PREFIX: |
| { |
| OUString aAttrValue( rAttrValue ); |
| sal_uInt16 nValPrefix = |
| static_cast<sal_uInt16>( |
| bRename ? (*aIter).second.m_nParam2 |
| : (*aIter).second.m_nParam1); |
| if( AddNamespacePrefix( aAttrValue, nValPrefix ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_ADD_APP_NAMESPACE_PREFIX: |
| { |
| OUString aAttrValue( rAttrValue ); |
| sal_uInt16 nValPrefix = |
| static_cast<sal_uInt16>((*aIter).second.m_nParam1); |
| if( IsXMLToken( GetClass(), XML_SPREADSHEET ) ) |
| nValPrefix = XML_NAMESPACE_OOOC; |
| else if( IsXMLToken( GetClass(), XML_TEXT ) ) |
| nValPrefix = XML_NAMESPACE_OOOW; |
| if( AddNamespacePrefix( aAttrValue, nValPrefix ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_REMOVE_NAMESPACE_PREFIX: |
| bRename = sal_True; |
| case XML_ATACTION_REMOVE_NAMESPACE_PREFIX: |
| { |
| OUString aAttrValue( rAttrValue ); |
| sal_uInt16 nValPrefix = |
| static_cast<sal_uInt16>( |
| bRename ? (*aIter).second.m_nParam2 |
| : (*aIter).second.m_nParam1); |
| if( RemoveNamespacePrefix( aAttrValue, nValPrefix ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_REMOVE_ANY_NAMESPACE_PREFIX: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( RemoveNamespacePrefix( aAttrValue ) ) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_URI_OOO: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ConvertURIToOASIS( aAttrValue, |
| static_cast< sal_Bool >((*aIter).second.m_nParam1))) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_URI_OASIS: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ConvertURIToOOo( aAttrValue, |
| static_cast< sal_Bool >((*aIter).second.m_nParam1))) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_ATTRIBUTE: |
| { |
| OUString aAttrValue( rAttrValue ); |
| RenameAttributeValue( |
| aAttrValue, |
| (*aIter).second.m_nParam1, |
| (*aIter).second.m_nParam2, |
| (*aIter).second.m_nParam3 ); |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RNG2ISO_DATETIME: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ConvertRNGDateTimeToISO( aAttrValue )) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_RENAME_RNG2ISO_DATETIME: |
| { |
| OUString aAttrValue( rAttrValue ); |
| if( ConvertRNGDateTimeToISO( aAttrValue )) |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| bRename = sal_True; |
| } |
| break; |
| case XML_ATACTION_IN2TWIPS: |
| { |
| OUString aAttrValue( rAttrValue ); |
| XMLTransformerBase::ReplaceSingleInWithInch( aAttrValue ); |
| |
| if( isWriter() ) |
| { |
| MapUnit nDestUnit = lcl_getUnit( aAttrValue ); |
| |
| // convert inch value to twips and export as faked inch |
| sal_Int32 nMeasure; |
| if( SvXMLUnitConverter::convertMeasure(nMeasure, aAttrValue, MAP_100TH_MM ) ) |
| { |
| |
| // --> OD 2004-10-29 #i13778#,#i36248# |
| // apply correct 1/100mm-to-twip conversion |
| nMeasure = (sal_Int32)( nMeasure >= 0 |
| ? ((nMeasure*72+63)/127) |
| : ((nMeasure*72-63)/127) ); |
| // <-- |
| |
| OUStringBuffer aBuffer; |
| SvXMLUnitConverter::convertMeasure( aBuffer, nMeasure, MAP_100TH_MM, nDestUnit ); |
| aAttrValue = aBuffer.makeStringAndClear(); |
| } |
| } |
| |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_SVG_WIDTH_HEIGHT_OOO: |
| { |
| OUString aAttrValue( rAttrValue ); |
| ReplaceSingleInchWithIn( aAttrValue ); |
| |
| MapUnit nDestUnit = lcl_getUnit( aAttrValue ); |
| |
| sal_Int32 nMeasure; |
| if( SvXMLUnitConverter::convertMeasure(nMeasure, aAttrValue, MAP_100TH_MM ) ) |
| { |
| |
| if( nMeasure > 0 ) |
| nMeasure -= 1; |
| else if( nMeasure < 0 ) |
| nMeasure += 1; |
| |
| |
| OUStringBuffer aBuffer; |
| SvXMLUnitConverter::convertMeasure( aBuffer, nMeasure, MAP_100TH_MM, nDestUnit ); |
| aAttrValue = aBuffer.makeStringAndClear(); |
| } |
| |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_SVG_WIDTH_HEIGHT_OASIS: |
| { |
| OUString aAttrValue( rAttrValue ); |
| ReplaceSingleInWithInch( aAttrValue ); |
| |
| MapUnit nDestUnit = lcl_getUnit( aAttrValue ); |
| |
| sal_Int32 nMeasure; |
| if( SvXMLUnitConverter::convertMeasure(nMeasure, aAttrValue, MAP_100TH_MM ) ) |
| { |
| |
| if( nMeasure > 0 ) |
| nMeasure += 1; |
| else if( nMeasure < 0 ) |
| nMeasure -= 1; |
| |
| |
| OUStringBuffer aBuffer; |
| SvXMLUnitConverter::convertMeasure( aBuffer, nMeasure, MAP_100TH_MM, nDestUnit ); |
| aAttrValue = aBuffer.makeStringAndClear(); |
| } |
| |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| break; |
| case XML_ATACTION_DECODE_ID: |
| { |
| OUString aAttrValue; |
| |
| const sal_Int32 nLen = rAttrValue.getLength(); |
| OUStringBuffer aBuffer; |
| |
| sal_Int32 pos; |
| for( pos = 0; pos < nLen; pos++ ) |
| { |
| sal_Unicode c = rAttrValue[pos]; |
| if( (c >= '0') && (c <= '9') ) |
| aBuffer.append( c ); |
| else |
| aBuffer.append( (sal_Int32)c ); |
| } |
| |
| pMutableAttrList->SetValueByIndex( i, aBuffer.makeStringAndClear() ); |
| } |
| break; |
| // --> OD 2005-06-10 #i50322# - special handling for the |
| // transparency of writer background graphics. |
| case XML_ATACTION_WRITER_BACK_GRAPHIC_TRANSPARENCY: |
| { |
| // determine, if it's the transparency of a document style |
| XMLTransformerContext* pFirstContext = (*m_pContexts)[0].get(); |
| OUString aFirstContextLocalName; |
| /* sal_uInt16 nFirstContextPrefix = */ |
| GetNamespaceMap().GetKeyByAttrName( pFirstContext->GetQName(), |
| &aFirstContextLocalName ); |
| bool bIsDocumentStyle( |
| ::xmloff::token::IsXMLToken( aFirstContextLocalName, |
| XML_DOCUMENT_STYLES ) ); |
| // no conversion of transparency value for document |
| // styles, because former OpenOffice.org version writes |
| // writes always a transparency value of 100% and doesn't |
| // read the value. Thus, it's intepreted as 0% |
| if ( !bIsDocumentStyle ) |
| { |
| OUString aAttrValue( rAttrValue ); |
| NegPercent(aAttrValue); |
| pMutableAttrList->SetValueByIndex( i, aAttrValue ); |
| } |
| bRename = sal_True; |
| } |
| break; |
| // <-- |
| case XML_ATACTION_SHAPEID: |
| { |
| OUString sNewValue( RTL_CONSTASCII_USTRINGPARAM( "shape" ) ); |
| sNewValue += rAttrValue; |
| pMutableAttrList->SetValueByIndex( i, sNewValue ); |
| break; |
| } |
| |
| default: |
| OSL_ENSURE( !this, "unknown action" ); |
| break; |
| } |
| |
| if( bRename ) |
| { |
| OUString aNewAttrQName( |
| GetNamespaceMap().GetQNameByKey( |
| (*aIter).second.GetQNamePrefixFromParam1(), |
| ::xmloff::token::GetXMLToken( |
| (*aIter).second.GetQNameTokenFromParam1()) ) ); |
| pMutableAttrList->RenameAttributeByIndex( i, |
| aNewAttrQName ); |
| } |
| } |
| } |
| } |
| |
| return pMutableAttrList; |
| } |
| |
| sal_Bool XMLTransformerBase::ReplaceSingleInchWithIn( OUString& rValue ) |
| { |
| sal_Bool bRet = sal_False; |
| sal_Int32 nPos = rValue.getLength(); |
| while( nPos && rValue[nPos-1] <= ' ' ) |
| --nPos; |
| if( nPos > 2 && |
| ('c'==rValue[nPos-2] || 'C'==rValue[nPos-2]) && |
| ('h'==rValue[nPos-1] || 'H'==rValue[nPos-1]) ) |
| { |
| rValue =rValue.copy( 0, nPos-2 ); |
| bRet = sal_True; |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::ReplaceInchWithIn( OUString& rValue ) |
| { |
| sal_Bool bRet = sal_False; |
| sal_Int32 nPos = 1; |
| while( nPos < rValue.getLength()-3 ) |
| { |
| sal_Unicode c = rValue[nPos]; |
| if( 'i'==c || 'I'==c ) |
| { |
| c = rValue[nPos-1]; |
| if( (c >= '0' && c <= '9') || '.' == c ) |
| { |
| c = rValue[nPos+1]; |
| if( 'n'==c || 'N'==c ) |
| { |
| c = rValue[nPos+2]; |
| if( 'c'==c || 'C'==c ) |
| { |
| c = rValue[nPos+3]; |
| if( 'h'==c || 'H'==c ) |
| { |
| rValue = rValue.replaceAt( nPos, |
| 4, GetXMLToken(XML_UNIT_INCH) ); |
| nPos += 2; |
| bRet = sal_True; |
| continue; |
| } |
| } |
| } |
| } |
| } |
| ++nPos; |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::ReplaceSingleInWithInch( OUString& rValue ) |
| { |
| sal_Bool bRet = sal_False; |
| |
| sal_Int32 nPos = rValue.getLength(); |
| while( nPos && rValue[nPos-1] <= ' ' ) |
| --nPos; |
| if( nPos > 2 && |
| ('i'==rValue[nPos-2] || |
| 'I'==rValue[nPos-2]) && |
| ('n'==rValue[nPos-1] || |
| 'N'==rValue[nPos-1]) ) |
| { |
| nPos -= 2; |
| rValue = rValue.replaceAt( nPos, rValue.getLength() - nPos, |
| GetXMLToken(XML_INCH) ); |
| bRet = sal_True; |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::ReplaceInWithInch( OUString& rValue ) |
| { |
| sal_Bool bRet = sal_False; |
| sal_Int32 nPos = 1; |
| while( nPos < rValue.getLength()-1 ) |
| { |
| sal_Unicode c = rValue[nPos]; |
| if( 'i'==c || 'I'==c ) |
| { |
| c = rValue[nPos-1]; |
| if( (c >= '0' && c <= '9') || '.' == c ) |
| { |
| c = rValue[nPos+1]; |
| if( 'n'==c || 'N'==c ) |
| { |
| rValue = rValue.replaceAt( nPos, |
| 2, GetXMLToken(XML_INCH) ); |
| nPos += 4; |
| bRet = sal_True; |
| continue; |
| } |
| } |
| } |
| ++nPos; |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::EncodeStyleName( OUString& rName ) const |
| { |
| static sal_Char aHexTab[] = "0123456789abcdef"; |
| |
| sal_Bool bEncoded = sal_False; |
| |
| sal_Int32 nLen = rName.getLength(); |
| OUStringBuffer aBuffer( nLen ); |
| |
| for( sal_Int32 i = 0; i < nLen; i++ ) |
| { |
| sal_Unicode c = rName[i]; |
| sal_Bool bValidChar = sal_False; |
| if( c < 0x00ffU ) |
| { |
| bValidChar = |
| (c >= 0x0041 && c <= 0x005a) || |
| (c >= 0x0061 && c <= 0x007a) || |
| (c >= 0x00c0 && c <= 0x00d6) || |
| (c >= 0x00d8 && c <= 0x00f6) || |
| (c >= 0x00f8 && c <= 0x00ff) || |
| ( i > 0 && ( (c >= 0x0030 && c <= 0x0039) || |
| c == 0x00b7 || c == '-' || c == '.') ); |
| } |
| else |
| { |
| if( (c >= 0xf900U && c <= 0xfffeU) || |
| (c >= 0x20ddU && c <= 0x20e0U)) |
| { |
| bValidChar = sal_False; |
| } |
| else if( (c >= 0x02bbU && c <= 0x02c1U) || c == 0x0559 || |
| c == 0x06e5 || c == 0x06e6 ) |
| { |
| bValidChar = sal_True; |
| } |
| else if( c == 0x0387 ) |
| { |
| bValidChar = i > 0; |
| } |
| else |
| { |
| if( !xCharClass.is() ) |
| { |
| Reference< XMultiServiceFactory > xFactory = |
| comphelper::getProcessServiceFactory(); |
| if( xFactory.is() ) |
| { |
| try |
| { |
| const_cast < XMLTransformerBase * >(this) |
| ->xCharClass = |
| Reference < XCharacterClassification >( |
| xFactory->createInstance( |
| OUString::createFromAscii( |
| "com.sun.star.i18n.CharacterClassification_Unicode") ), |
| UNO_QUERY ); |
| |
| OSL_ENSURE( xCharClass.is(), |
| "can't instantiate character clossification component" ); |
| } |
| catch( com::sun::star::uno::Exception& ) |
| { |
| } |
| } |
| } |
| if( xCharClass.is() ) |
| { |
| sal_Int16 nType = xCharClass->getType( rName, i ); |
| |
| switch( nType ) |
| { |
| case UnicodeType::UPPERCASE_LETTER: // Lu |
| case UnicodeType::LOWERCASE_LETTER: // Ll |
| case UnicodeType::TITLECASE_LETTER: // Lt |
| case UnicodeType::OTHER_LETTER: // Lo |
| case UnicodeType::LETTER_NUMBER: // Nl |
| bValidChar = sal_True; |
| break; |
| case UnicodeType::NON_SPACING_MARK: // Ms |
| case UnicodeType::ENCLOSING_MARK: // Me |
| case UnicodeType::COMBINING_SPACING_MARK: //Mc |
| case UnicodeType::MODIFIER_LETTER: // Lm |
| case UnicodeType::DECIMAL_DIGIT_NUMBER: // Nd |
| bValidChar = i > 0; |
| break; |
| } |
| } |
| } |
| } |
| if( bValidChar ) |
| { |
| aBuffer.append( c ); |
| } |
| else |
| { |
| aBuffer.append( static_cast< sal_Unicode >( '_' ) ); |
| if( c > 0x0fff ) |
| aBuffer.append( static_cast< sal_Unicode >( |
| aHexTab[ (c >> 12) & 0x0f ] ) ); |
| if( c > 0x00ff ) |
| aBuffer.append( static_cast< sal_Unicode >( |
| aHexTab[ (c >> 8) & 0x0f ] ) ); |
| if( c > 0x000f ) |
| aBuffer.append( static_cast< sal_Unicode >( |
| aHexTab[ (c >> 4) & 0x0f ] ) ); |
| aBuffer.append( static_cast< sal_Unicode >( |
| aHexTab[ c & 0x0f ] ) ); |
| aBuffer.append( static_cast< sal_Unicode >( '_' ) ); |
| bEncoded = sal_True; |
| } |
| } |
| |
| if( aBuffer.getLength() > (1<<15)-1 ) |
| bEncoded = sal_False; |
| |
| if( bEncoded ) |
| rName = aBuffer.makeStringAndClear(); |
| return bEncoded; |
| } |
| |
| sal_Bool XMLTransformerBase::DecodeStyleName( OUString& rName ) |
| { |
| sal_Bool bEncoded = sal_False; |
| |
| sal_Int32 nLen = rName.getLength(); |
| OUStringBuffer aBuffer( nLen ); |
| |
| sal_Bool bWithinHex = sal_False; |
| sal_Unicode cEnc = 0; |
| for( sal_Int32 i = 0; i < nLen; i++ ) |
| { |
| sal_Unicode c = rName[i]; |
| if( '_' == c ) |
| { |
| if( bWithinHex ) |
| { |
| aBuffer.append( cEnc ); |
| cEnc = 0; |
| } |
| else |
| { |
| bEncoded = sal_True; |
| } |
| bWithinHex = !bWithinHex; |
| } |
| else if( bWithinHex ) |
| { |
| sal_Unicode cDigit; |
| if( c >= '0' && c <= '9' ) |
| { |
| cDigit = c - '0'; |
| } |
| else if( c >= 'a' && c <= 'f' ) |
| { |
| cDigit = c - 'a' + 10; |
| } |
| else if( c >= 'A' && c <= 'F' ) |
| { |
| cDigit = c - 'A' + 10; |
| } |
| else |
| { |
| // error |
| bEncoded = sal_False; |
| break; |
| } |
| cEnc = (cEnc << 4) + cDigit; |
| } |
| else |
| { |
| aBuffer.append( c ); |
| } |
| } |
| |
| if( bEncoded ) |
| rName = aBuffer.makeStringAndClear(); |
| return bEncoded; |
| } |
| |
| sal_Bool XMLTransformerBase::NegPercent( OUString& rValue ) |
| { |
| sal_Bool bRet = sal_False; |
| sal_Bool bNeg = sal_False; |
| double nVal = 0; |
| |
| sal_Int32 nPos = 0; |
| sal_Int32 nLen = rValue.getLength(); |
| |
| // skip white space |
| while( nPos < nLen && sal_Unicode(' ') == rValue[nPos] ) |
| nPos++; |
| |
| if( nPos < nLen && sal_Unicode('-') == rValue[nPos] ) |
| { |
| bNeg = sal_True; |
| nPos++; |
| } |
| |
| // get number |
| while( nPos < nLen && |
| sal_Unicode('0') <= rValue[nPos] && |
| sal_Unicode('9') >= rValue[nPos] ) |
| { |
| // TODO: check overflow! |
| nVal *= 10; |
| nVal += (rValue[nPos] - sal_Unicode('0')); |
| nPos++; |
| } |
| double nDiv = 1.; |
| if( nPos < nLen && sal_Unicode('.') == rValue[nPos] ) |
| { |
| nPos++; |
| |
| while( nPos < nLen && |
| sal_Unicode('0') <= rValue[nPos] && |
| sal_Unicode('9') >= rValue[nPos] ) |
| { |
| // TODO: check overflow! |
| nDiv *= 10; |
| nVal += ( static_cast<double>(rValue[nPos] - sal_Unicode('0')) / nDiv ); |
| nPos++; |
| } |
| } |
| |
| // skip white space |
| while( nPos < nLen && sal_Unicode(' ') == rValue[nPos] ) |
| nPos++; |
| |
| if( nPos < nLen && sal_Unicode('%') == rValue[nPos] ) |
| { |
| if( bNeg ) |
| nVal = -nVal; |
| nVal += .5; |
| |
| sal_Int32 nIntVal = 100 - static_cast<sal_Int32>( nVal ); |
| |
| OUStringBuffer aNewValBuffer; |
| aNewValBuffer.append( nIntVal ); |
| aNewValBuffer.append( sal_Unicode('%' ) ); |
| |
| rValue = aNewValBuffer.makeStringAndClear(); |
| bRet = sal_True; |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::AddNamespacePrefix( ::rtl::OUString& rName, |
| sal_uInt16 nPrefix ) const |
| { |
| rName = GetNamespaceMap().GetQNameByKey( nPrefix, rName, sal_False ); |
| return sal_True; |
| } |
| |
| sal_Bool XMLTransformerBase::RemoveNamespacePrefix( ::rtl::OUString& rName, |
| sal_uInt16 nPrefixOnly ) const |
| { |
| OUString aLocalName; |
| sal_uInt16 nPrefix = |
| GetNamespaceMap()._GetKeyByAttrName( rName, &aLocalName, sal_False ); |
| sal_Bool bRet = XML_NAMESPACE_UNKNOWN != nPrefix && |
| (USHRT_MAX == nPrefixOnly || nPrefix == nPrefixOnly); |
| if( bRet ) |
| rName = aLocalName; |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::ConvertURIToOASIS( ::rtl::OUString& rURI, |
| sal_Bool bSupportPackage ) const |
| { |
| sal_Bool bRet = sal_False; |
| if( m_aExtPathPrefix.getLength() && rURI.getLength() ) |
| { |
| sal_Bool bRel = sal_False; |
| switch( rURI[0] ) |
| { |
| case '#': |
| // no rel path, but |
| // for package URIs, the '#' has to be removed |
| if( bSupportPackage ) |
| { |
| rURI = rURI.copy( 1 ); |
| bRet = sal_True; |
| } |
| break; |
| case '/': |
| // no rel path; nothing to do |
| break; |
| case '.': |
| // a rel path; to keep URI simple, remove './', if there |
| bRel = sal_True; |
| if( rURI.getLength() > 1 && '/' == rURI[1] ) |
| { |
| rURI = rURI.copy( 2 ); |
| bRet = sal_True; |
| } |
| break; |
| default: |
| // check for a RFC2396 schema |
| { |
| bRel = sal_True; |
| sal_Int32 nPos = 1; |
| sal_Int32 nLen = rURI.getLength(); |
| while( nPos < nLen ) |
| { |
| switch( rURI[nPos] ) |
| { |
| case '/': |
| // a relative path segement |
| nPos = nLen; // leave loop |
| break; |
| case ':': |
| // a schema |
| bRel = sal_False; |
| nPos = nLen; // leave loop |
| break; |
| default: |
| // we don't care about any other characters |
| break; |
| } |
| ++nPos; |
| } |
| } |
| } |
| |
| if( bRel ) |
| { |
| OUString sTmp( m_aExtPathPrefix ); |
| sTmp += rURI; |
| rURI = sTmp; |
| bRet = sal_True; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::ConvertURIToOOo( ::rtl::OUString& rURI, |
| sal_Bool bSupportPackage ) const |
| { |
| sal_Bool bRet = sal_False; |
| if( rURI.getLength() ) |
| { |
| sal_Bool bPackage = sal_False; |
| switch( rURI[0] ) |
| { |
| case '/': |
| // no rel path; nothing to to |
| break; |
| case '.': |
| // a rel path |
| if( 0 == rURI.compareTo( m_aExtPathPrefix, |
| m_aExtPathPrefix.getLength() ) ) |
| { |
| // an external URI; remove '../' |
| rURI = rURI.copy( m_aExtPathPrefix.getLength() ); |
| bRet = sal_True; |
| } |
| else |
| { |
| bPackage = sal_True; |
| } |
| break; |
| default: |
| // check for a RFC2396 schema |
| { |
| bPackage = sal_True; |
| sal_Int32 nPos = 1; |
| sal_Int32 nLen = rURI.getLength(); |
| while( nPos < nLen ) |
| { |
| switch( rURI[nPos] ) |
| { |
| case '/': |
| // a relative path segement within the package |
| nPos = nLen; // leave loop |
| break; |
| case ':': |
| // a schema |
| bPackage = sal_False; |
| nPos = nLen; // leave loop |
| break; |
| default: |
| // we don't care about any other characters |
| break; |
| } |
| ++nPos; |
| } |
| } |
| } |
| |
| if( bPackage && bSupportPackage ) |
| { |
| OUString sTmp( OUString::valueOf( sal_Unicode( '#' ) ) ); |
| if( 0 == rURI.compareToAscii( "./", 2 ) ) |
| rURI = rURI.copy( 2 ); |
| sTmp += rURI; |
| rURI = sTmp; |
| bRet = sal_True; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTransformerBase::RenameAttributeValue( |
| OUString& rOutAttributeValue, |
| sal_Int32 nParam1, |
| sal_Int32 nParam2, |
| sal_Int32 nParam3 ) |
| { |
| return ( lcl_ConvertAttr( rOutAttributeValue, nParam1) || |
| lcl_ConvertAttr( rOutAttributeValue, nParam2) || |
| lcl_ConvertAttr( rOutAttributeValue, nParam3) ); |
| } |
| |
| // static |
| bool XMLTransformerBase::ConvertRNGDateTimeToISO( ::rtl::OUString& rDateTime ) |
| { |
| if( rDateTime.getLength() > 0 && |
| rDateTime.indexOf( sal_Unicode('.')) != -1 ) |
| { |
| rDateTime = rDateTime.replace( sal_Unicode('.'), sal_Unicode(',')); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| XMLTokenEnum XMLTransformerBase::GetToken( const OUString& rStr ) const |
| { |
| XMLTransformerTokenMap::const_iterator aIter = |
| m_pTokenMap->find( rStr ); |
| if( aIter == m_pTokenMap->end() ) |
| return XML_TOKEN_END; |
| else |
| return (*aIter).second; |
| } |
| |
| |
| |
| const XMLTransformerContext *XMLTransformerBase::GetCurrentContext() const |
| { |
| OSL_ENSURE( !m_pContexts->empty(), "empty stack" ); |
| |
| |
| return m_pContexts->empty() ? 0 : m_pContexts->back().get(); |
| } |
| |
| const XMLTransformerContext *XMLTransformerBase::GetAncestorContext( |
| sal_uInt32 n ) const |
| { |
| XMLTransformerContextVector::size_type nSize = |
| m_pContexts->size(); |
| XMLTransformerContextVector::size_type nPos = |
| static_cast<XMLTransformerContextVector::size_type>( n ); |
| |
| OSL_ENSURE( nSize >nPos+2 , "invalid context" ); |
| |
| return nSize > nPos+2 ? (*m_pContexts)[nSize-(nPos+2)].get() : 0; |
| } |
| |
| bool XMLTransformerBase::isWriter() const |
| { |
| Reference< XServiceInfo > xSI( mxModel, UNO_QUERY ); |
| return xSI.is() && |
| ( xSI->supportsService( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.text.TextDocument" ) ) ) || |
| xSI->supportsService( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.text.WebDocument" ) ) ) || |
| xSI->supportsService( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.text.GlobalDocument" ) ) ) ); |
| } |
