/**************************************************************
 * 
 * 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 <rtl/ustrbuf.hxx>
#include <xmloff/nmspmap.hxx>
#include <xmloff/xmltoken.hxx>
#include "xmloff/xmlnmspe.hxx"
#include "PropType.hxx"
#include "DeepTContext.hxx"
#include "ProcAttrTContext.hxx"
#ifndef _XMLOFF_TRANSFOERMERBASE_HXX
#include "TransformerBase.hxx"
#endif
#include "TransformerActions.hxx"
#include "ActionMapTypesOASIS.hxx"
#include "MutableAttrList.hxx"
#include "PropertyActionsOASIS.hxx"
#include "StyleOASISTContext.hxx"
#include <xmloff/xmluconv.hxx>
#include <rtl/ustrbuf.hxx>

using ::rtl::OUString;
using namespace ::xmloff::token;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::xml::sax;
//------------------------------------------------------------------------------

static sal_uInt16 aAttrActionMaps[XML_PROP_TYPE_END] =
{
	PROP_OASIS_GRAPHIC_ATTR_ACTIONS,
	PROP_OASIS_DRAWING_PAGE_ATTR_ACTIONS,				// DRAWING_PAGE
	PROP_OASIS_PAGE_LAYOUT_ATTR_ACTIONS,
	PROP_OASIS_HEADER_FOOTER_ATTR_ACTIONS,
	PROP_OASIS_TEXT_ATTR_ACTIONS,
	PROP_OASIS_PARAGRAPH_ATTR_ACTIONS,
	MAX_OASIS_PROP_ACTIONS,				// RUBY
	PROP_OASIS_SECTION_ATTR_ACTIONS,
	PROP_OASIS_TABLE_ATTR_ACTIONS,
	PROP_OASIS_TABLE_COLUMN_ATTR_ACTIONS,
	PROP_OASIS_TABLE_ROW_ATTR_ACTIONS,
	PROP_OASIS_TABLE_CELL_ATTR_ACTIONS,
	PROP_OASIS_LIST_LEVEL_ATTR_ACTIONS,
	PROP_OASIS_CHART_ATTR_ACTIONS
};

//------------------------------------------------------------------------------

class XMLPropertiesTContext_Impl : public XMLPersElemContentTContext
{
	::com::sun::star::uno::Reference<
		::com::sun::star::xml::sax::XAttributeList > m_xAttrList;

	XMLPropType m_ePropType;
    sal_Bool    m_bControlStyle;
	::rtl::OUString m_aStyleFamily;

public:

	void SetQNameAndPropType( const ::rtl::OUString& rQName,
		   					  XMLPropType ePropType	)
	{
		m_ePropType = ePropType;
		XMLTransformerContext::SetQName( rQName );
	};

	TYPEINFO();

	XMLPropertiesTContext_Impl( XMLTransformerBase& rTransformer,
						   const ::rtl::OUString& rQName,
						   XMLPropType eP,
                           const ::rtl::OUString& rStyleFamily,
                           sal_Bool _bControlStyle = sal_False );

	virtual ~XMLPropertiesTContext_Impl();

	virtual void StartElement( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttrList );

	virtual void Export();

	static XMLPropType GetPropType( const OUString& rLocalName );

	static OUString MergeUnderline( XMLTokenEnum eUnderline,
		   								sal_Bool bBold, sal_Bool bDouble );
	static OUString MergeLineThrough( XMLTokenEnum eLineThrough,
										sal_Bool bBold, sal_Bool bDouble,
	   									sal_Unicode c );
};

TYPEINIT1( XMLPropertiesTContext_Impl, XMLPersElemContentTContext );

XMLPropertiesTContext_Impl::XMLPropertiesTContext_Impl(
	XMLTransformerBase& rImp, const OUString& rQName, XMLPropType eP,
        const ::rtl::OUString& rStyleFamily, sal_Bool _bControlStyle ) :
	XMLPersElemContentTContext( rImp, rQName, XML_NAMESPACE_STYLE,
								XML_PROPERTIES),
	m_ePropType( eP ),
    m_bControlStyle( _bControlStyle ),
	m_aStyleFamily( rStyleFamily )
{
}

XMLPropertiesTContext_Impl::~XMLPropertiesTContext_Impl()
{
}

void XMLPropertiesTContext_Impl::StartElement(
		const Reference< XAttributeList >& rAttrList )
{
	XMLTransformerActions *pActions =  0;
	sal_uInt16 nActionMap = aAttrActionMaps[m_ePropType];
	if( nActionMap < MAX_OASIS_PROP_ACTIONS )
	{
		pActions = GetTransformer().GetUserDefinedActions( nActionMap );
		OSL_ENSURE( pActions, "go no actions" );
	}

	if( pActions )
	{
		XMLMutableAttributeList *pAttrList = 0;
		if( !m_xAttrList.is() )
		{
			pAttrList = new XMLMutableAttributeList();
			m_xAttrList = pAttrList;
		}
		else
		{
			pAttrList =
				static_cast< XMLMutableAttributeList * >( m_xAttrList.get() );
		}

		XMLTokenEnum eUnderline = XML_TOKEN_END;
		sal_Bool bBoldUnderline = sal_False, bDoubleUnderline = sal_False;
		XMLTokenEnum eLineThrough = XML_TOKEN_END;
		sal_Bool bBoldLineThrough = sal_False, bDoubleLineThrough = sal_False;
		sal_Unicode cLineThroughChar = 0;

        bool bIntervalMinorFound = false;
        double fIntervalMajor = 0.0;
        sal_Int32 nIntervalMinorDivisor = 0;

		// #i25616#
		OUString aOpacityValueRemember;
		OUString aImageOpacityValueRemember;

		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 =
				GetTransformer().GetNamespaceMap().GetKeyByAttrName( rAttrName,
																 &aLocalName );

			XMLTransformerActions::key_type aKey( nPrefix, aLocalName );
			XMLTransformerActions::const_iterator aIter =
				pActions->find( aKey );
			if( !(aIter == pActions->end() ) )
			{
				switch( (*aIter).second.m_nActionType )
				{
                case XML_ATACTION_REMOVE:
                    break;
				case XML_ATACTION_COPY:
					pAttrList->AddAttribute( rAttrName, rAttrValue );
					break;
				case XML_ATACTION_RENAME:
					{
						OUString aNewAttrQName(
							GetTransformer().GetNamespaceMap().GetQNameByKey(
								(*aIter).second.GetQNamePrefixFromParam1(),
								::xmloff::token::GetXMLToken(
								(*aIter).second.GetQNameTokenFromParam1()) ) );
						pAttrList->AddAttribute( aNewAttrQName, rAttrValue );
					}
					break;
				case XML_ATACTION_IN2INCH:
					{
						OUString aAttrValue( rAttrValue );
						XMLTransformerBase::ReplaceSingleInWithInch(
								aAttrValue );
						pAttrList->AddAttribute( rAttrName, aAttrValue );
					}
					break;
				case XML_ATACTION_INS2INCHS:
					{
						OUString aAttrValue( rAttrValue );
						XMLTransformerBase::ReplaceInWithInch(
								aAttrValue );
						pAttrList->AddAttribute( rAttrName, aAttrValue );
					}
					break;
				case XML_ATACTION_DECODE_STYLE_NAME_REF:
					{
						OUString aAttrValue( rAttrValue );
						GetTransformer().DecodeStyleName(aAttrValue);
						pAttrList->AddAttribute( rAttrName, aAttrValue );
					}
					break;
				case XML_ATACTION_RENAME_DECODE_STYLE_NAME_REF:
					{
						OUString aNewAttrQName(
							GetTransformer().GetNamespaceMap().GetQNameByKey(
								(*aIter).second.GetQNamePrefixFromParam1(),
								::xmloff::token::GetXMLToken(
								(*aIter).second.GetQNameTokenFromParam1()) ) );
						OUString aAttrValue( rAttrValue );
						GetTransformer().DecodeStyleName(aAttrValue);
						pAttrList->AddAttribute( aNewAttrQName, aAttrValue );
					}
					break;
				case XML_ATACTION_NEG_PERCENT:
					{
						OUString aAttrValue( rAttrValue );
						GetTransformer().NegPercent(aAttrValue);
						pAttrList->AddAttribute( rAttrName, aAttrValue );
					}
					break;
				case XML_ATACTION_RENAME_NEG_PERCENT:
					{
						OUString aNewAttrQName(
							GetTransformer().GetNamespaceMap().GetQNameByKey(
								(*aIter).second.GetQNamePrefixFromParam1(),
								::xmloff::token::GetXMLToken(
								(*aIter).second.GetQNameTokenFromParam1()) ) );
						OUString aAttrValue( rAttrValue );
						GetTransformer().NegPercent(aAttrValue);
						pAttrList->AddAttribute( aNewAttrQName, aAttrValue );
					}
					break;
				case XML_OPTACTION_LINE_MODE:
					{
						sal_Bool bWordMode =
							IsXMLToken( rAttrValue, XML_SKIP_WHITE_SPACE );
						OUString aAttrQName(
							GetTransformer().GetNamespaceMap().GetQNameByKey(
								XML_NAMESPACE_FO,
								GetXMLToken( XML_SCORE_SPACES ) ) );
						sal_Int16 nIndex =
							pAttrList->GetIndexByName( aAttrQName );
						if( -1 != nIndex )
						{
							if( bWordMode )
							{
								const OUString& rOldValue =
									pAttrList->getValueByIndex( nIndex );
								if( !IsXMLToken( rOldValue, XML_TRUE ) )
								{
									pAttrList->SetValueByIndex( nIndex,
											GetXMLToken( XML_TRUE ) );
								}
							}
						}
						else
						{
							OUString aAttrValue( GetXMLToken( bWordMode
										? XML_FALSE
										: XML_TRUE ) );
							pAttrList->AddAttribute( aAttrQName, aAttrValue );
						}
					}
					break;
				case XML_OPTACTION_KEEP_WITH_NEXT:
					{
						OUString aAttrValue( GetXMLToken(
										IsXMLToken( rAttrValue, XML_ALWAYS )
													? XML_TRUE
													: XML_FALSE) );
						pAttrList->AddAttribute( rAttrName, aAttrValue );
					}
					break;
				case XML_OPTACTION_UNDERLINE_WIDTH:
					if( IsXMLToken( rAttrValue, XML_BOLD ) )
						bBoldUnderline = sal_True;
					break;
				case XML_OPTACTION_UNDERLINE_TYPE:
					if( IsXMLToken( rAttrValue, XML_DOUBLE ) )
						bDoubleUnderline = sal_True;
					break;
				case XML_OPTACTION_UNDERLINE_STYLE:
					eUnderline = GetTransformer().GetToken( rAttrValue );
					break;
				case XML_OPTACTION_LINETHROUGH_WIDTH:
					if( IsXMLToken( rAttrValue, XML_BOLD ) )
						bBoldLineThrough = sal_True;
					break;
				case XML_OPTACTION_LINETHROUGH_TYPE:
					if( IsXMLToken( rAttrValue, XML_DOUBLE ) )
						bDoubleLineThrough = sal_True;
					break;
				case XML_OPTACTION_LINETHROUGH_STYLE:
					eLineThrough = GetTransformer().GetToken( rAttrValue );
					break;
				case XML_OPTACTION_LINETHROUGH_TEXT:
					if( rAttrValue.getLength() )
						cLineThroughChar = rAttrValue[0];
					break;
				case XML_OPTACTION_INTERPOLATION:
                    {
                        // 0: none
                        sal_Int32 nSplineType = 0;
                        if( IsXMLToken( rAttrValue, XML_CUBIC_SPLINE ))
                            nSplineType = 1;
                        else if( IsXMLToken( rAttrValue, XML_B_SPLINE ))
                            nSplineType = 2;

                        pAttrList->AddAttribute(
                            GetTransformer().GetNamespaceMap().GetQNameByKey(
                                XML_NAMESPACE_CHART,
                                GetXMLToken( XML_SPLINES )),
                            OUString::valueOf( nSplineType ));
                    }
					break;
                case XML_OPTACTION_INTERVAL_MAJOR:
                    pAttrList->AddAttribute( rAttrName, rAttrValue );
                    SvXMLUnitConverter::convertDouble( fIntervalMajor, rAttrValue );
                    break;
                case XML_OPTACTION_INTERVAL_MINOR_DIVISOR:
                    SvXMLUnitConverter::convertNumber( nIntervalMinorDivisor, rAttrValue );
                    bIntervalMinorFound = true;
					break;
				case XML_OPTACTION_SYMBOL_TYPE:
                    {
                        // if symbol_type is "named-symbol" the "symbol"
                        // property is set in the action XML_OPTACTION_SYMBOL_NAME
                        sal_Int32 nSymbolType = 0;
                        if( IsXMLToken( rAttrValue, XML_NONE ))
                            nSymbolType = -3;
                        else if( IsXMLToken( rAttrValue, XML_AUTOMATIC ))
                            nSymbolType = -2;
                        else if( IsXMLToken( rAttrValue, XML_IMAGE ))
                            nSymbolType = -1;

                        if( nSymbolType < 0 )
                            pAttrList->AddAttribute(
                                GetTransformer().GetNamespaceMap().GetQNameByKey(
                                    XML_NAMESPACE_CHART,
                                    GetXMLToken( XML_SYMBOL )),
                                OUString::valueOf( nSymbolType ));
                    }
                    break;
                case XML_OPTACTION_SYMBOL_NAME:
                    {
                        // assume "symbol-type" == "named-symbol"
                        sal_Int32 nSymbolType = -3; // NONE
                        // "square" just has an awkward token-name
                        if( IsXMLToken( rAttrValue, XML_GRADIENTSTYLE_SQUARE ))
                            nSymbolType = 0;
                        else if( IsXMLToken( rAttrValue, XML_DIAMOND ))
                            nSymbolType = 1;
                        else if( IsXMLToken( rAttrValue, XML_ARROW_DOWN ))
                            nSymbolType = 2;
                        else if( IsXMLToken( rAttrValue, XML_ARROW_UP ))
                            nSymbolType = 3;
                        else if( IsXMLToken( rAttrValue, XML_ARROW_RIGHT ))
                            nSymbolType = 4;
                        else if( IsXMLToken( rAttrValue, XML_ARROW_LEFT ))
                            nSymbolType = 5;
                        else if( IsXMLToken( rAttrValue, XML_BOW_TIE ))
                            nSymbolType = 6;
                        else if( IsXMLToken( rAttrValue, XML_HOURGLASS ))
                            nSymbolType = 7;
                        else if( IsXMLToken( rAttrValue, XML_CIRCLE ))
                            nSymbolType = 8;
                        else if( IsXMLToken( rAttrValue, XML_STAR ))
                            nSymbolType = 9;
                        else if( IsXMLToken( rAttrValue, XML_X ))
                            nSymbolType = 10;
                        else if( IsXMLToken( rAttrValue, XML_PLUS ))
                            nSymbolType = 11;
                        else if( IsXMLToken( rAttrValue, XML_ASTERISK ))
                            nSymbolType = 12;
                        else if( IsXMLToken( rAttrValue, XML_HORIZONTAL_BAR ))
                            nSymbolType = 13;
                        else if( IsXMLToken( rAttrValue, XML_VERTICAL_BAR ))
                            nSymbolType = 14;

                        if( nSymbolType >= 0 )
                            pAttrList->AddAttribute(
                                GetTransformer().GetNamespaceMap().GetQNameByKey(
                                    XML_NAMESPACE_CHART,
                                    GetXMLToken( XML_SYMBOL )),
                                OUString::valueOf( nSymbolType ));
                    }
                    break;
				// #i25616#
                case XML_OPTACTION_OPACITY:
					aOpacityValueRemember = rAttrValue;
					GetTransformer().NegPercent(aOpacityValueRemember);
					break;

				// #i25616#
                case XML_OPTACTION_IMAGE_OPACITY:
					aImageOpacityValueRemember = rAttrValue;
					GetTransformer().NegPercent(aImageOpacityValueRemember);
					break;

                case XML_OPTACTION_KEEP_TOGETHER:
                    pAttrList->AddAttribute(
                        GetTransformer().GetNamespaceMap().GetQNameByKey(
                            XML_NAMESPACE_STYLE,GetXMLToken(XML_BREAK_INSIDE)),
                        GetXMLToken(
                            IsXMLToken( rAttrValue, XML_ALWAYS )
                            ? XML_COLUMNSPLIT_AVOID
                            : XML_COLUMNSPLIT_AUTO ) );
                    break;

                case XML_OPTACTION_CONTROL_TEXT_ALIGN:
                    if ( m_bControlStyle )
                    {
						OUString aNewAttrQName(
							GetTransformer().GetNamespaceMap().GetQNameByKey(
								XML_NAMESPACE_STYLE,
								::xmloff::token::GetXMLToken(
								XML_TEXT_ALIGN ) ) );
						pAttrList->AddAttribute( aNewAttrQName, rAttrValue );
                    }
                    else
                    {
						OUString aNewAttrQName(
							GetTransformer().GetNamespaceMap().GetQNameByKey(
								XML_NAMESPACE_FO,
								::xmloff::token::GetXMLToken(
								XML_TEXT_ALIGN ) ) );
						pAttrList->AddAttribute( aNewAttrQName, rAttrValue );
                    }
                    break;

				case XML_OPTACTION_DRAW_WRITING_MODE:
					if( IsXMLToken( m_aStyleFamily, XML_GRAPHICS ) )
					{
						pAttrList->AddAttribute(
							GetTransformer().GetNamespaceMap().GetQNameByKey(
									XML_NAMESPACE_DRAW,
									GetXMLToken( XML_WRITING_MODE ) ), rAttrValue );
					}
					pAttrList->AddAttribute( rAttrName, rAttrValue );
					break;

				case XML_ATACTION_CAPTION_ESCAPE_OASIS:
					{
						OUString aAttrValue( rAttrValue );
						if( aAttrValue.indexOf( sal_Unicode('%') ) != -1 )
						{
							sal_Int32 nValue = 0;
							SvXMLUnitConverter::convertPercent( nValue, rAttrValue );
							if( nValue )
							{
								nValue *= 100;
								rtl::OUStringBuffer aOut;
					 			SvXMLUnitConverter::convertPercent( aOut, nValue );
								aAttrValue = aOut.makeStringAndClear();
							}
						}
						else
						{
							XMLTransformerBase::ReplaceSingleInWithInch( aAttrValue );
						}

						pAttrList->AddAttribute( rAttrName, aAttrValue );
					}
					break;

				case XML_ATACTION_DECODE_PROTECT:
					{
						pAttrList->AddAttribute( rAttrName, rAttrValue );

						if( rAttrValue.indexOf( GetXMLToken( XML_SIZE ) ) != -1 )
							pAttrList->AddAttribute( GetTransformer().GetNamespaceMap().GetQNameByKey(
                                    XML_NAMESPACE_DRAW,
                                    GetXMLToken( XML_SIZE_PROTECT )), GetXMLToken( XML_TRUE ) );

						if( rAttrValue.indexOf( GetXMLToken( XML_POSITION ) ) != -1 )
							pAttrList->AddAttribute( GetTransformer().GetNamespaceMap().GetQNameByKey(
                                    XML_NAMESPACE_DRAW,
                                    GetXMLToken( XML_MOVE_PROTECT )), GetXMLToken( XML_TRUE ) );
					}
					break;

				case XML_ATACTION_DRAW_MIRROR_OASIS: // renames style:mirror to draw:mirror and adapts values
					{
						// keep original for writer graphic objects
                        // --> OD 2005-05-12 #i49139# - adapts attribute values,
                        OUString aNewAttrValue;
                        SvXMLTokenEnumerator aTokenEnum( rAttrValue );
                        OUString aToken;
                        while( aTokenEnum.getNextToken( aToken ) )
                        {
                            if ( aNewAttrValue.getLength() > 0 )
                            {
                                aNewAttrValue += rtl::OUString::createFromAscii( " " );
                            }

                            if ( IsXMLToken( aToken, XML_HORIZONTAL_ON_EVEN ) )
                            {
                                aNewAttrValue += GetXMLToken( XML_HORIZONTAL_ON_LEFT_PAGES );
                            }
                            else if ( IsXMLToken( aToken, XML_HORIZONTAL_ON_ODD ) )
                            {
                                aNewAttrValue += GetXMLToken( XML_HORIZONTAL_ON_RIGHT_PAGES );
                            }
                            else
                            {
                                aNewAttrValue += aToken;
                            }
                        }
                        pAttrList->AddAttribute( rAttrName, aNewAttrValue );
                        // <--

						// create old draw:mirror for drawing graphic objects
						OUString aAttrValue( GetXMLToken( IsXMLToken( rAttrValue, XML_HORIZONTAL ) ? XML_TRUE : XML_FALSE ) );
						pAttrList->AddAttribute( GetTransformer().GetNamespaceMap().GetQNameByKey(
                                    XML_NAMESPACE_DRAW,
                                    GetXMLToken( XML_MIRROR )), aAttrValue );
					}
					break;
				case XML_ATACTION_GAMMA_OASIS:		 // converts percentage value to double
					{
						sal_Int32 nValue;
						SvXMLUnitConverter::convertPercent( nValue, rAttrValue );
						const double fValue = ((double)nValue) / 100.0;
						pAttrList->AddAttribute( rAttrName, OUString::valueOf( fValue ) );
					}
					break;
				case XML_ATACTION_OPACITY_FIX:
					{
						sal_Int32 nValue;
						if( rAttrValue.indexOf( sal_Unicode('%') ) != -1 )
						{
							SvXMLUnitConverter::convertPercent( nValue, rAttrValue );
						}
						else
						{
							nValue = sal_Int32( rAttrValue.toDouble() * 100.0 );
						}
						nValue = 100 - nValue;

						rtl::OUStringBuffer aOut;
						SvXMLUnitConverter::convertPercent( aOut, nValue );
						pAttrList->AddAttribute( rAttrName, aOut.makeStringAndClear() );
					}
					break;
				default:
					OSL_ENSURE( sal_False, "unknown action" );
					break;
				}
			}
			else
			{
				pAttrList->AddAttribute( rAttrName, rAttrValue );
			}
		}
		if( XML_TOKEN_END != eUnderline )
			pAttrList->AddAttribute(
					GetTransformer().GetNamespaceMap().GetQNameByKey(
						XML_NAMESPACE_STYLE,
						GetXMLToken( XML_TEXT_UNDERLINE ) ),
					MergeUnderline( eUnderline, bBoldUnderline,
									bDoubleUnderline ) );
		if( XML_TOKEN_END != eLineThrough )
			pAttrList->AddAttribute(
					GetTransformer().GetNamespaceMap().GetQNameByKey(
						XML_NAMESPACE_STYLE,
						GetXMLToken( XML_TEXT_CROSSING_OUT ) ),
					MergeLineThrough( eLineThrough, bBoldLineThrough,
									bDoubleLineThrough, cLineThroughChar ) );
        if( bIntervalMinorFound )
        {
            double fIntervalMinor = 0.0;
            if( nIntervalMinorDivisor != 0)
                fIntervalMinor = fIntervalMajor / static_cast< double >( nIntervalMinorDivisor );

            ::rtl::OUStringBuffer aBuf;
            SvXMLUnitConverter::convertDouble( aBuf, fIntervalMinor );
            pAttrList->AddAttribute(
                GetTransformer().GetNamespaceMap().GetQNameByKey(
                    XML_NAMESPACE_CHART,
                    GetXMLToken( XML_INTERVAL_MINOR )),
                aBuf.makeStringAndClear());
        }

		// #i25616#
		if(aOpacityValueRemember.getLength() || aImageOpacityValueRemember.getLength())
		{
			pAttrList->AddAttribute(
					GetTransformer().GetNamespaceMap().GetQNameByKey(
						XML_NAMESPACE_DRAW,
						GetXMLToken( XML_TRANSPARENCY ) ),
					aImageOpacityValueRemember.getLength()
					? aImageOpacityValueRemember : aOpacityValueRemember );
		}
	}
	else
	{
		if( !m_xAttrList.is() )
		{
			m_xAttrList = new XMLMutableAttributeList( rAttrList, sal_True );
		}
		else
		{
			static_cast< XMLMutableAttributeList * >( m_xAttrList.get() )
				->AppendAttributeList( rAttrList );
		}
	}
}

void XMLPropertiesTContext_Impl::Export()
{
	OUString aNewQName( GetTransformer().GetNamespaceMap().GetQNameByKey(
				XML_NAMESPACE_STYLE,
				::xmloff::token::GetXMLToken( XML_PROPERTIES ) ) );
	GetTransformer().GetDocHandler()->startElement( GetExportQName(),
													m_xAttrList );
	ExportContent();
	GetTransformer().GetDocHandler()->endElement( GetExportQName() );
}

XMLPropType XMLPropertiesTContext_Impl::GetPropType( const OUString& rLocalName )
{
	XMLPropType eProp = XML_PROP_TYPE_END;
	if( IsXMLToken( rLocalName, XML_GRAPHIC_PROPERTIES )  )
		eProp = XML_PROP_TYPE_GRAPHIC;
	else if( IsXMLToken( rLocalName, XML_DRAWING_PAGE_PROPERTIES ) )
		eProp = XML_PROP_TYPE_DRAWING_PAGE;
	else if( IsXMLToken( rLocalName, XML_PAGE_LAYOUT_PROPERTIES ) )
		eProp = XML_PROP_TYPE_PAGE_LAYOUT;
	else if( IsXMLToken( rLocalName, XML_HEADER_FOOTER_PROPERTIES ) )
		eProp = XML_PROP_TYPE_HEADER_FOOTER;
	else if( IsXMLToken( rLocalName, XML_TEXT_PROPERTIES ) )
		eProp = XML_PROP_TYPE_TEXT;
	else if( IsXMLToken( rLocalName, XML_PARAGRAPH_PROPERTIES ) )
		eProp = XML_PROP_TYPE_PARAGRAPH;
	else if( IsXMLToken( rLocalName, XML_RUBY_PROPERTIES ) )
		eProp = XML_PROP_TYPE_RUBY;
	else if( IsXMLToken( rLocalName, XML_SECTION_PROPERTIES ) )
		eProp = XML_PROP_TYPE_SECTION;
	else if( IsXMLToken( rLocalName, XML_TABLE_PROPERTIES ) )
		eProp = XML_PROP_TYPE_TABLE;
	else if( IsXMLToken( rLocalName, XML_TABLE_COLUMN_PROPERTIES ) )
		eProp = XML_PROP_TYPE_TABLE_COLUMN;
	else if( IsXMLToken( rLocalName, XML_TABLE_ROW_PROPERTIES ) )
		eProp = XML_PROP_TYPE_TABLE_ROW;
	else if( IsXMLToken( rLocalName, XML_TABLE_CELL_PROPERTIES ) )
		eProp = XML_PROP_TYPE_TABLE_CELL;
	else if( IsXMLToken( rLocalName, XML_LIST_LEVEL_PROPERTIES ) )
		eProp = XML_PROP_TYPE_LIST_LEVEL;
	else if( IsXMLToken( rLocalName, XML_CHART_PROPERTIES ) )
		eProp = XML_PROP_TYPE_CHART;

	return eProp;
}

OUString XMLPropertiesTContext_Impl::MergeUnderline(
			XMLTokenEnum eUnderline, sal_Bool bBold, sal_Bool bDouble )
{
	if( bDouble )
	{
		switch( eUnderline )
		{
		case XML_WAVE:
			eUnderline = XML_DOUBLE_WAVE;
			break;
		default:
			eUnderline = XML_DOUBLE;
			break;
		}
	}
	else if( bBold )
	{
		switch( eUnderline )
		{
		case XML_NONE:
		case XML_SOLID:
			eUnderline = XML_BOLD;
			break;
		case XML_DOTTED:
			eUnderline = XML_BOLD_DOTTED;
			break;
		case XML_DASH:
			eUnderline = XML_BOLD_DASH;
			break;
		case XML_LONG_DASH:
			eUnderline = XML_BOLD_LONG_DASH;
			break;
		case XML_DOT_DASH:
			eUnderline = XML_BOLD_DOT_DASH;
			break;
		case XML_DOT_DOT_DASH:
			eUnderline = XML_BOLD_DOT_DOT_DASH;
			break;
		case XML_WAVE:
			eUnderline = XML_BOLD_WAVE;
			break;
		default:
			OSL_ENSURE( false, "xmloff::XMLPropertiesTContext_Impl::MergeUnderline(), missing underline case!" );
			break;
		}
	}
	else
	{
		switch( eUnderline )
		{
		case XML_SOLID:
			eUnderline = XML_SINGLE;
			break;
		case XML_NONE:
			eUnderline = XML_NONE;
			break;
		default:
			OSL_ENSURE( false, "xmloff::XMLPropertiesTContext_Impl::MergeUnderline(), missing underline case!" );
			break;
		}
	}

	return GetXMLToken( eUnderline );
}

OUString XMLPropertiesTContext_Impl::MergeLineThrough(
			XMLTokenEnum eLineThrough, sal_Bool bBold, sal_Bool bDouble,
	   		sal_Unicode c )
{
	if( c )
		eLineThrough = c=='/' ? XML_SLASH : XML_uX;
	else if( bDouble )
		eLineThrough = XML_DOUBLE_LINE;
	else if( bBold )
		eLineThrough = XML_THICK_LINE;
	else if( XML_NONE != eLineThrough )
		eLineThrough = XML_SINGLE_LINE;

	return GetXMLToken( eLineThrough );
}

//------------------------------------------------------------------------------

TYPEINIT1( XMLStyleOASISTContext, XMLPersElemContentTContext );

XMLStyleOASISTContext::XMLStyleOASISTContext( XMLTransformerBase& rImp,
							  				  const OUString& rQName,
	   										  sal_Bool bPersistent ) :
	XMLPersElemContentTContext ( rImp, rQName ),
	m_bPersistent( bPersistent ),
    m_bControlStyle( false )
{
}

XMLStyleOASISTContext::XMLStyleOASISTContext(
		XMLTransformerBase& rImp,
	  	const OUString& rQName,
	    sal_uInt16 nPrefix,
		::xmloff::token::XMLTokenEnum eToken,
	   	sal_Bool bPersistent ) :
	XMLPersElemContentTContext( rImp, rQName, nPrefix, eToken ),
	m_bPersistent( bPersistent )
{
}

XMLStyleOASISTContext::~XMLStyleOASISTContext()
{
}

XMLTransformerContext *XMLStyleOASISTContext::CreateChildContext(
			sal_uInt16 nPrefix,
			const OUString& rLocalName,
			const OUString& rQName,
			const Reference< XAttributeList >& rAttrList )
{
	XMLTransformerContext *pContext = 0;

	if( XML_NAMESPACE_STYLE == nPrefix )
	{
		XMLPropType ePropType =
			XMLPropertiesTContext_Impl::GetPropType( rLocalName );
		if( XML_PROP_TYPE_END != ePropType )
		{
			// if no properties context exist start a new one.
			if( !m_xPropContext.is() )
				m_xPropContext = new XMLPropertiesTContext_Impl(
                    GetTransformer(), rQName, ePropType, m_aStyleFamily, m_bControlStyle );
			else
				m_xPropContext->SetQNameAndPropType( rQName, ePropType );
			pContext = m_xPropContext.get();
		}
	}
	if( !pContext )
	{
		// if a properties context exist close it
		if( m_xPropContext.is() && !m_bPersistent )
		{
			m_xPropContext->Export();
			m_xPropContext = 0;
		}

		pContext = m_bPersistent
						? XMLPersElemContentTContext::CreateChildContext(
								nPrefix, rLocalName, rQName, rAttrList )
						: XMLTransformerContext::CreateChildContext(
								nPrefix, rLocalName, rQName, rAttrList );
	}

	return pContext;
}

void XMLStyleOASISTContext::StartElement(
		const Reference< XAttributeList >& rAttrList )
{
	XMLTransformerActions *pActions =
		GetTransformer().GetUserDefinedActions( OASIS_STYLE_ACTIONS );
	OSL_ENSURE( pActions, "go no actions" );

	Reference< XAttributeList > xAttrList( rAttrList );
	XMLMutableAttributeList *pMutableAttrList = 0;
	sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
	sal_Int16 nFamilyAttr = -1;
	m_bControlStyle = sal_False;

	for( sal_Int16 i=0; i < nAttrCount; i++ )
	{
		const OUString& rAttrName = xAttrList->getNameByIndex( i );
		OUString aLocalName;
		sal_uInt16 nPrefix =
			GetTransformer().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( xAttrList );
				xAttrList = pMutableAttrList;
			}
			const OUString& rAttrValue = xAttrList->getValueByIndex( i );
			switch( (*aIter).second.m_nActionType )
			{
			case XML_ATACTION_STYLE_FAMILY:
				if( IsXMLToken( rAttrValue, XML_GRAPHIC ) )
				{
					m_aStyleFamily = GetXMLToken( XML_GRAPHICS ) ;
					pMutableAttrList->SetValueByIndex( i, m_aStyleFamily );
				}
				else
				{
					m_aStyleFamily = rAttrValue;

					if( IsXMLToken( rAttrValue, XML_PARAGRAPH ) )
						nFamilyAttr = i;
				}

				break;
			case XML_ATACTION_STYLE_DISPLAY_NAME:
			case XML_ATACTION_REMOVE:
				pMutableAttrList->RemoveAttributeByIndex( i );
				--i;
				--nAttrCount;
				break;
			case XML_ATACTION_DECODE_STYLE_NAME:
				m_bControlStyle = 0 == rAttrValue.compareToAscii( "ctrl", 4 );
			case XML_ATACTION_DECODE_STYLE_NAME_REF:
				{
					OUString aAttrValue( rAttrValue );
					if( GetTransformer().DecodeStyleName(aAttrValue) )
						pMutableAttrList->SetValueByIndex( i, aAttrValue );
				}
				break;
			case XML_ATACTION_IN2INCH:
				{
					OUString aAttrValue( rAttrValue );
					if( XMLTransformerBase::ReplaceSingleInWithInch(
								aAttrValue ) )
						pMutableAttrList->SetValueByIndex( i, aAttrValue );
				}
				break;
			case XML_ATACTION_NEG_PERCENT:
				{
					OUString aAttrValue( rAttrValue );
					if( GetTransformer().NegPercent(aAttrValue) )
						pMutableAttrList->SetValueByIndex( i, aAttrValue );
				}
				break;
			case XML_ATACTION_URI_OASIS:
				{
					OUString aAttrValue( rAttrValue );
					if( GetTransformer().ConvertURIToOOo( aAttrValue,
							static_cast< sal_Bool >((*aIter).second.m_nParam1)))
						pMutableAttrList->SetValueByIndex( i, aAttrValue );
				}
				break;
			default:
				OSL_ENSURE( sal_False, "unknown action" );
				break;
			}
		}
	}

	if( m_bControlStyle && nFamilyAttr != -1 )
		pMutableAttrList->SetValueByIndex( nFamilyAttr, GetXMLToken( XML_CONTROL ) );


	if( m_bPersistent )
		XMLPersElemContentTContext::StartElement( xAttrList );
	else
		GetTransformer().GetDocHandler()->startElement( GetExportQName(),
														xAttrList );
}

void XMLStyleOASISTContext::EndElement()
{
	if( m_bPersistent )
	{
		XMLPersElemContentTContext::EndElement();
	}
	else
	{
		// if a properties context exist close it
		if( m_xPropContext.is() )
		{
			m_xPropContext->Export();
			m_xPropContext = 0;
		}
		GetTransformer().GetDocHandler()->endElement( GetExportQName() );
	}
}

void XMLStyleOASISTContext::Characters( const OUString& )
{
	// element content only:
}

void XMLStyleOASISTContext::ExportContent()
{
	if( m_xPropContext.is() )
		m_xPropContext->Export();
	XMLPersElemContentTContext::ExportContent();
}

sal_Bool XMLStyleOASISTContext::IsPersistent() const
{
	return m_bPersistent;
}

XMLTransformerActions *XMLStyleOASISTContext::CreateTransformerActions(
		sal_uInt16 nType )
{
	XMLTransformerActionInit *pInit = 0;

	switch( nType )
	{
	case PROP_OASIS_GRAPHIC_ATTR_ACTIONS:
		pInit = aGraphicPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_DRAWING_PAGE_ATTR_ACTIONS:
		pInit = aDrawingPagePropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_PAGE_LAYOUT_ATTR_ACTIONS:
		pInit = aPageLayoutPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_HEADER_FOOTER_ATTR_ACTIONS:
		pInit = aHeaderFooterPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_TEXT_ATTR_ACTIONS:
		pInit = aTextPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_PARAGRAPH_ATTR_ACTIONS:
		pInit = aParagraphPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_SECTION_ATTR_ACTIONS:
		pInit = aSectionPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_TABLE_ATTR_ACTIONS:
		pInit = aTablePropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_TABLE_COLUMN_ATTR_ACTIONS:
		pInit = aTableColumnPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_TABLE_ROW_ATTR_ACTIONS:
		pInit = aTableRowPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_TABLE_CELL_ATTR_ACTIONS:
		pInit = aTableCellPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_LIST_LEVEL_ATTR_ACTIONS:
		pInit = aListLevelPropertyOASISAttrActionTable;
		break;
	case PROP_OASIS_CHART_ATTR_ACTIONS:
		pInit = aChartPropertyOASISAttrActionTable;
		break;
	}

	XMLTransformerActions *pActions = 0;
	if( pInit )
		pActions = new XMLTransformerActions( pInit );

	return pActions;
}