| /************************************************************** |
| * |
| * 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( !this, "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( !this, "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; |
| } |
