xref: /aoo42x/main/xmloff/source/transform/StyleOOoTContext.cxx (revision 3a5971bb)

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