/**************************************************************
*
* 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 );
// Remember 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" ) ) ) );
}